pyhdf5_handler.src.object_handler

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