pyhdf5_handler.src.object_handler

  1from __future__ import annotations
  2
  3import numpy as np
  4import numbers
  5import pandas as pd
  6import datetime
  7from ..src import constant
  8
  9
 10def _isinstance_pandas(value):
 11    pandas_classes = [getattr(pd, item) for item in dir(pd) if isinstance(getattr(pd, item), type)]
 12    for cls in pandas_classes:
 13        if isinstance(value, cls):
 14            return True
 15    return False
 16
 17def _isinstance_numpy(value):
 18    numpy_classes = [getattr(np, item) for item in dir(np) if isinstance(getattr(np, item), type)]
 19    for cls in numpy_classes:
 20        if isinstance(value, cls):
 21            return True
 22    return False
 23
 24def _isinstance_datetime(value):
 25    datetime_classes = [getattr(datetime, item) for item in dir(datetime) if isinstance(getattr(datetime, item), type)]
 26    for cls in datetime_classes:
 27        if isinstance(value, cls):
 28            return True
 29    return False
 30
 31def _isinstance_exclude_obj(value):
 32    
 33    type_str = str(type(value))
 34    module_name = type_str.split("'")[1].split('.')[0]
 35    
 36    if module_name in constant.EXCLUDE_PYTHON_OBJ:
 37        return True
 38    else:
 39        return False
 40
 41def generate_dict_structure(dictionary,recursion_counter=0,recursion_limit=100,include_method=True):
 42    """
 43    
 44    this function create a full dictionnary containing all the structure of an dictionnary in order to save it to an hdf5
 45
 46    Parameters
 47    ----------
 48    
 49    instance : python dictionary
 50        a custom dictionary.
 51    recursion_limit : int
 52        max recursion limit to dig inside `instance`
 53    recursion_counter: int
 54        current recursion value
 55    include_method: bool
 56        Include methods/functions in the object structure, if False, only data will be included.
 57
 58    Returns
 59    -------
 60    
 61    list or dict :
 62        A list or dictionary matching the structure of the python object.
 63    
 64    """
 65    key_data={}
 66    key_list = list()
 67    recursion_counter=0
 68    for attr,value in dictionary.items():
 69        
 70        try:
 71            if _isinstance_exclude_obj(value):
 72                next(attrs)
 73            elif isinstance(value,dict):
 74                subkey_data=generate_dict_structure(value)
 75                if len(subkey_data)>0:
 76                    key_data.update({attr:subkey_data})
 77            
 78            elif isinstance(value, (list, tuple, numbers.Number, str)):
 79                key_list.append(attr)
 80            
 81            elif _isinstance_pandas(value):
 82                key_list.append(attr)
 83                
 84            elif _isinstance_datetime(value):
 85                key_list.append(attr)
 86                
 87            elif _isinstance_numpy(value):
 88                key_list.append(attr)
 89            
 90            elif type(value) == "method":
 91                if include_method:
 92                    key_list.append(attr)
 93                else:
 94                    next(attr)
 95            else:
 96                
 97                recursion_counter = recursion_counter+1
 98                
 99                if recursion_counter > recursion_limit:
100                    print(f"recursion counter exceed the limit of {recursion_limit}... return")
101                    return
102                
103                subkey_data = generate_object_structure(value,recursion_counter=recursion_counter,recursion_limit=recursion_limit,include_method=include_method)
104                if len(subkey_data) > 0:
105                    key_data.update({attr: subkey_data})
106
107        except:
108            pass
109    
110    for attr, value in key_data.items():
111        key_list.append({attr: value})
112    
113    return key_list
114
115
116def generate_object_structure(instance,recursion_counter=0,recursion_limit=100,include_method=True):
117    """
118    
119    this function create a full dictionnary containing all the structure of an object in order to save it to an hdf5
120
121    Parameters
122    ----------
123    
124    instance : object
125        a custom python object.
126    recursion_limit : int
127        max recursion limit to dig inside `instance`
128    recursion_counter: int
129        current recursion value
130    include_method: bool
131        Include methods/functions in the object structure, if False, only data will be included.
132
133    Returns
134    -------
135    
136    list or dict :
137        A list or dictionary matching the structure of the python object.
138    
139    """
140    key_data = {}
141    key_list = list()
142    return_list = False
143    #recursion_counter += 1 
144    for attr in dir(instance):
145        
146        if not attr.startswith("_") and not attr in ["from_handle", "copy"]:
147            
148            try:
149                value = getattr(instance, attr)
150                
151                if _isinstance_exclude_obj(value):
152                    next(attr)
153                    
154                elif isinstance(value, (list, tuple)):
155                    key_list.append(attr)
156                    return_list = True
157                
158                elif _isinstance_numpy(value):
159                    key_list.append(attr)
160                    return_list = True
161                
162                elif isinstance(value, dict):
163                    
164                    depp_key_data=generate_dict_structure(value)
165                    if len(depp_key_data) > 0:
166                        key_data.update({attr: depp_key_data})
167
168                elif isinstance(value, numbers.Number):
169                    key_list.append(attr)
170                    return_list = True
171
172                elif isinstance(value, str):
173                    key_list.append(attr)
174                    return_list = True
175
176                elif "<class 'method" in str(type(value)):
177                    if include_method:
178                        key_list.append(attr)
179                        return_list = True
180                    else:
181                        next(attr)
182                
183                elif _isinstance_pandas(value):
184                    key_list.append(attr)
185                    return_list = True
186                
187                elif _isinstance_datetime(value):
188                    key_list.append(attr)
189                    return_list = True
190                
191                else:
192                    
193                    recursion_counter = recursion_counter+1
194                    
195                    if recursion_counter > recursion_limit:
196                        print(f"recursion counter exceed the limit of {recursion_limit}... return")
197                        return
198                    
199                    depp_key_data = generate_object_structure(value, recursion_counter=recursion_counter,recursion_limit=recursion_limit,include_method=include_method)
200
201                    if len(depp_key_data) > 0:
202                        key_data.update({attr: depp_key_data})
203
204            except:
205                # raise ValueError("unable to parse attr", attr)
206                # ~ print("unable to parse attr", attr, "skip it...")
207                pass
208
209    if return_list:
210        for attr, value in key_data.items():
211            key_list.append({attr: value})
212
213        return key_list
214
215    else:
216        return key_data
217
218
219def read_object_as_dict(instance, recursion_counter=0,recursion_limit=100):
220    """
221    
222    create a dictionary from a custom python object
223
224    Parameters
225    ----------
226    
227    instance : object
228        an custom python object
229    recursion_limit : int
230        max recursion limit to dig inside `instance`
231    recursion_counter: int
232        current recursion value
233
234    Return
235    ------
236    
237    key_data: dict
238        an dictionary containing all keys and atributes of the object
239    
240    """
241    key_data = {}
242    #recursion_counter = 0
243    for attr in dir(instance):
244        #print(attr)
245        if not attr.startswith("_") and not attr in ["from_handle", "copy"]:
246            try:
247                value = getattr(instance, attr)
248                
249                if _isinstance_exclude_obj(value):
250                    next(attr)
251                
252                elif isinstance(value, (list, tuple)):
253                    
254                    if isinstance(value, list):
255                        value = np.array(value).astype('U')
256
257                    if value.dtype == "object" or value.dtype.char == "U":
258                        value = value.astype("U")
259                    
260                    key_data.update({attr: value})
261                
262                elif isinstance(value, dict):
263                    key_data.update({attr: value})
264                
265                elif isinstance(value, numbers.Number):
266                    key_data.update({attr: value})
267
268                elif isinstance(value, str):
269                    key_data.update({attr: value})
270
271                elif type(value) == "method":
272                    next(attr)
273                
274                elif _isinstance_pandas(value):
275                    if value.dtype == "object" or value.dtype.char == "U":
276                        value = value.astype("U")
277                    key_data.update({attr: value})
278                
279                elif _isinstance_datetime(value):
280                    if value.dtype == "object" or value.dtype.char == "U":
281                        value = value.astype("U")
282                    key_data.update({attr: value})
283                
284                elif _isinstance_numpy(value):
285                    if value.dtype == "object" or value.dtype.char == "U":
286                        value = value.astype("U")
287                    key_data.update({attr: value})
288
289                else:
290                    
291                    recursion_counter = recursion_counter+1
292                    
293                    if recursion_counter > recursion_limit:
294                        print(f"recursion counter exceed the limit of {recursion_limit}... return")
295                        return
296                    
297                    depp_key_data = read_object_as_dict(
298                        value, recursion_counter=recursion_counter,recursion_limit=recursion_limit)
299                    
300                    if len(depp_key_data) > 0:
301                        key_data.update({attr: depp_key_data})
302
303            except:
304                pass
305
306    return key_data