Added parsing.py

diff --git a/sfa/rspecs/pl_rspec_version.py b/sfa/rspecs/pl_rspec_version.py
new file mode 100644 (file)
index 0000000..eb4f9a6
--- /dev/null
+++ b/sfa/rspecs/pl_rspec_version.py
@@ -0,0 +1,16 @@
+from sfa.rspecs.sfa_rspec import sfa_rspec_version
+from sfa.rspecs.pg_rspec import pg_rspec_ad_version, pg_rspec_request_version 
+
+ad_rspec_versions = [
+    pg_rspec_ad_version,
+    sfa_rspec_version
+    ]
+
+request_rspec_versions = ad_rspec_versions
+
+default_rspec_version = { 'type': 'SFA', 'version': '1' }
+
+supported_rspecs = {'ad_rspec_versions': ad_rspec_versions,
+                    'request_rspec_versions': request_rspec_versions,
+                    'default_ad_rspec': default_rspec_version}
+

diff --git a/sfa/senslab/__init__.py b/sfa/senslab/__init__.py
new file mode 100644 (file)
index 0000000..e69de29

diff --git a/sfa/senslab/parsing.py b/sfa/senslab/parsing.py
new file mode 100644 (file)
index 0000000..248caad
--- /dev/null
+++ b/sfa/senslab/parsing.py
@@ -0,0 +1,95 @@
+
+# import modules used here -- sys is a very standard one
+import sys
+import httplib
+import json
+
+
+def strip_dictionnary (dict_to_strip):
+       stripped_filter = []
+       stripped_filterdict = {}
+       for f in dict_to_strip :
+               stripped_filter.append(str(f).strip('|'))
+               
+       stripped_filterdict = dict(zip(stripped_filter, dict_to_strip.values()))
+       
+       return stripped_filterdict
+       
+
+def filter_return_fields( dict_to_filter, return_fields):
+       filtered_dict = {}
+       #print>>sys.stderr, " \r\n \t \tfilter_return_fields return fields %s " %(return_fields)
+       for field in return_fields:
+               #print>>sys.stderr, " \r\n \t \tfield %s " %(field)     
+               if field in dict_to_filter:
+                       filtered_dict[field] = dict_to_filter[field]
+       #print>>sys.stderr, " \r\n \t\t filter_return_fields filtered_dict %s " %(filtered_dict)
+       return filtered_dict
+       
+       
+       
+def parse_filter(list_to_filter, param_filter, type_of_list, return_fields=None) :
+       list_type = { 'persons': {'str': 'email','int':'person_id'},\
+        'keys':{'int':'key_id'},\
+        'site':{'str':'login_base','int':'site_id'},\
+         'node':{'str':'hostname','int':'node_id'},\
+         'slice':{'str':'name','int':'slice_id'}}
+        
+       if type_of_list not in list_type:
+               print>>sys.stderr, " \r\n type_of_list Error  parse_filter %s " %(type_of_list)
+               return []
+       
+       print>>sys.stderr, " \r\n ____FIRST ENTRY parse_filter param_filter %s type %s  list %s " %(param_filter, type(param_filter), list_to_filter)
+       return_filtered_list= []
+       
+       for item in list_to_filter:
+               tmp_item = {}
+               
+               if type(param_filter) is list :
+                       print>>sys.stderr, " \r\n p_filter LIST %s " %(param_filter)
+                       
+                       for p_filter in param_filter:
+                               print>>sys.stderr, " \r\n p_filter %s \t item %s " %(p_filter,item)
+                               if type(p_filter) is int:
+                                       if item[list_type[type_of_list]['int']] == p_filter :
+                                               if return_fields:
+                                                       tmp_item = filter_return_fields(item,return_fields)
+                                               else:
+                                                       tmp_item = item
+                                               return_filtered_list.append(tmp_item)
+                                       #print>>sys.stderr, " \r\n 1tmp_item",tmp_item  
+                                       
+                               if type(p_filter) is str:
+                                       if item[list_type[type_of_list]['str']] == p_filter :
+                                               if return_fields:
+                                                       tmp_item = filter_return_fields(item,return_fields)
+                                               else:
+                                                       tmp_item = item
+                                               return_filtered_list.append(tmp_item)
+                                       #print>>sys.stderr, " \r\n 2tmp_item",tmp_item
+                                       
+       
+               elif type(param_filter) is dict:
+                       stripped_filterdict = strip_dictionnary(param_filter)
+                       
+                       tmp_copy = {}
+                       tmp_copy = item.copy()
+                       #print>>sys.stderr, " \r\n \t\t ________tmp_copy %s " %(tmp_copy)
+                       key_list = tmp_copy.keys()                      
+                       for key in key_list:
+                               print>>sys.stderr, " \r\n \t\t  key %s " %(key)
+                               if key not in stripped_filterdict.keys():
+                                       del tmp_copy[key] 
+                                       
+                       
+                       print>>sys.stderr, " \r\n tmp_copy %s param_filter %s cmp = %s " %(tmp_copy, param_filter,cmp(tmp_copy, stripped_filterdict))
+                       
+                       if cmp(tmp_copy, stripped_filterdict) == 0:     
+                               if return_fields:
+                                       tmp_item = filter_return_fields(item,return_fields)
+                               else:
+                                       
+                                       tmp_item = item 
+                               return_filtered_list.append(tmp_item)
+               
+       return  return_filtered_list
\ No newline at end of file