sfa/senslab/parsing.py

   1
   2 # import modules used here -- sys is a very standard one
   3 import sys
   4 import httplib
   5 import json
   6 from collections import defaultdict
   7
   8 def strip_dictionnary (dict_to_strip):
   9         stripped_filter = []
  10         stripped_filterdict = {}
  11         for f in dict_to_strip :
  12                 stripped_filter.append(str(f).strip('|'))
  13
  14         stripped_filterdict = dict(zip(stripped_filter, dict_to_strip.values()))
  15
  16         return stripped_filterdict
  17
  18
  19 def filter_return_fields( dict_to_filter, return_fields):
  20         filtered_dict = {}
  21         for field in return_fields:
  22                 if field in dict_to_filter:
  23                         filtered_dict[field] = dict_to_filter[field]
  24         return filtered_dict
  25
  26
  27
  28 def parse_filter(list_to_filter, param_filter, type_of_list, return_fields=None) :
  29         list_type = { 'persons': {'str': 'hrn','int':'record_id'},\
  30          'keys':{'int':'key_id'},\
  31          'site':{'str':'login_base','int':'site_id'},\
  32           'node':{'str':'hostname','int':'node_id'},\
  33           'slice':{'str':'slice_hrn','int':'record_id_slice'},\
  34           'peers':{'str':'hrn'}}
  35
  36         if  param_filter is None and return_fields is None:
  37             return list_to_filter
  38
  39         if type_of_list not in list_type:
  40                 return []
  41
  42         return_filtered_list= []
  43
  44         for item in list_to_filter:
  45                 tmp_item = {}
  46
  47                 if type(param_filter) is list :
  48
  49                         for p_filter in param_filter:
  50                                 if type(p_filter) is int:
  51                                         if item[list_type[type_of_list]['int']] == p_filter :
  52                                                 if return_fields:
  53                                                         tmp_item = filter_return_fields(item,return_fields)
  54                                                 else:
  55                                                         tmp_item = item
  56                                                 return_filtered_list.append(tmp_item)
  57
  58                                 if type(p_filter) is str:
  59                                         if item[list_type[type_of_list]['str']] == str(p_filter) :
  60                                                 if return_fields:
  61                                                         tmp_item = filter_return_fields(item,return_fields)
  62                                                 else:
  63                                                         tmp_item = item
  64                                                 return_filtered_list.append(tmp_item)
  65
  66
  67                 elif type(param_filter) is dict:
  68                         #stripped_filterdict = strip_dictionnary(param_filter)
  69                         #tmp_copy = {}
  70                         #tmp_copy = item.copy()
  71                         #key_list = tmp_copy.keys()
  72                         #for key in key_list:
  73                                 #if key not in stripped_filterdict:
  74                                         #del tmp_copy[key]
  75
  76                         #rif the item matches the filter, returns it
  77                         founditem = []
  78                         check =  [ True for  k in param_filter.keys() if 'id' in k ]
  79                         dflt= defaultdict(str,param_filter)
  80
  81
  82
  83                         #founditem =  [ item for k in dflt if item[k] in dflt[k]]
  84                         for k in dflt:
  85                             if item[k] in dflt[k]:
  86                                founditem = [item]
  87
  88                         if founditem:
  89                             if return_fields:
  90                                 tmp_item = filter_return_fields(founditem[0],return_fields)
  91                             else:
  92                                 tmp_item = founditem[0]
  93                             return_filtered_list.append(tmp_item)
  94
  95
  96                         #if cmp(tmp_copy, stripped_filterdict) == 0:
  97                                 #if return_fields:
  98                                         #tmp_item = filter_return_fields(item,return_fields)
  99                                 #else:
 100
 101                                         #tmp_item = item
 102                                 #return_filtered_list.append(tmp_item)
 103         if return_filtered_list :
 104            return return_filtered_list
 105