--

Author: valentin-gauthier-geosiris

energyml-utils/example/attic/arrays_test.py

@@ -17,7 +17,7 @@
 from energyml.utils.storage_interface import EnergymlStorageInterface
 from energyml.utils.epc import Epc
 from energyml.utils.epc_stream import EpcStreamReader, RelsUpdateMode
-from energyml.utils.introspection import get_obj_title
+from energyml.utils.introspection import get_obj_title, search_attribute_matching_name, get_object_attribute
 from energyml.resqml.v2_2.resqmlv2 import Point3DLatticeArray
 from energyml.eml.v2_3.commonv2 import TimeSeries
 from energyml.eml.v2_1.commonv2 import TimeSeries as TimeSeries21
@@ -299,6 +299,8 @@ def read_props_and_cbt(
                         _return_none_if_no_category_lookup=True,
                     )
                 print("=" * 40)
+                # print("TS: ", search_attribute_matching_name(prop_or_cbt, "\\w*.time_series"))
+                # print(f"\t {get_object_attribute(prop_or_cbt, 'time_or_interval_series.time_series')}")
                 print(f"{type(prop_or_cbt)} : {get_obj_title(prop_or_cbt)} - uuid: {uuid}")
                 print(array)
 

energyml-utils/src/energyml/utils/data/helper.py

@@ -759,19 +759,17 @@ def _array_name_mapping(array_type_name: str) -> str:
     :param array_type_name:
     :return:
     """
-    array_type_name = array_type_name.replace("3D", "3d").replace("2D", "2d").lower()
-    # logging.debug(f"=============> Mapping array type name '{array_type_name}' to reader function name...")
-    if array_type_name.endswith("constantarray"):
+    array_type_name = array_type_name.replace("3D", "3d").replace("2D", "2d")
+    if array_type_name.endswith("ConstantArray"):
         return "ConstantArray"
-    elif "external" in array_type_name or "hdf5" in array_type_name:
+    elif "External" in array_type_name or "Hdf5" in array_type_name:
         return "ExternalArray"
-    elif "xml" in array_type_name:
-        # logging.debug("=============> XML array detected, be careful with the performance !")
+    elif "Xml" in array_type_name:
         return "XmlArray"
-    elif "jagged" in array_type_name:
+    elif "Jagged" in array_type_name:
         return "JaggedArray"
-    elif "lattice" in array_type_name:
-        if "integer" in array_type_name or "double" in array_type_name or "floatingpoint" in array_type_name:
+    elif "Lattice" in array_type_name:
+        if "Integer" in array_type_name or "Double" in array_type_name or "Floating" in array_type_name:
             return "int_double_lattice_array"
     return array_type_name
 

energyml-utils/src/energyml/utils/data/mesh.py

@@ -1072,7 +1072,7 @@ def read_property_interpreted_with_cbt(
             elif isinstance(category_lookup_data, dict):
                 # Transpose so that each index corresponds to a category (column), not a row
                 category_lookup_matrice = np.array(list(category_lookup_data.values())).T
-                print(f"category_lookup_matrice : {category_lookup_matrice}")
+                # logging.debug(f"category_lookup_matrice : {category_lookup_matrice}")
                 # return a matrice with the same shape as prop_arrays but with the values from the category lookup array using the prop value as key in the category lookup array
                 result = (
                     np.array(
@@ -1251,7 +1251,7 @@ def read_column_based_table(
 def read_time_series(
     energyml_object: Any,
     workspace: EnergymlStorageInterface,
-) -> List[Dict[str, Tuple[str, int]]]:
+) -> List[Tuple[str, int]]:
     """
     Read a time series from an Energyml object.
 

energyml-utils/src/energyml/utils/introspection.py

@@ -387,24 +387,26 @@ def get_class_attribute_type(cls: Union[type, Any], attribute_name: str):
     return None
 
 
-def get_matching_class_attribute_name(
+def get_all_matching_class_attribute_name(
     cls: Union[type, Any],
     attribute_name: str,
     re_flags=re.IGNORECASE,
-) -> Optional[str]:
+) -> List[str]:
     """
-    From an object and an attribute name, returns the correct attribute name of the class.
-    Example : "ObjectVersion" --> object_version.
-    This method doesn't only transform to snake case but search into the obj class attributes (or dict keys)
+    From an object and an attribute name, returns all the correct attribute names of the class matching with the attribute_name.
+     Example : "\\w*.Version" --> ["object_version", "ObjectVersion", "obj_version", ...]
+     This method doesn't only transform to snake case but search into the obj class attributes (or dict keys)
     """
+    matching_names = []
     if isinstance(cls, dict):
         for name in cls.keys():
             if snake_case(name) == snake_case(attribute_name):
-                return name
+                matching_names.append(name)
         pattern = re.compile(attribute_name, flags=re_flags)
         for name in cls.keys():
             if pattern.match(name):
-                return name
+                matching_names.append(name)
+        return matching_names
     else:
         class_fields = get_class_fields(cls)
         try:
@@ -413,7 +415,7 @@ def get_matching_class_attribute_name(
                 if snake_case(name) == snake_case(attribute_name) or (
                     hasattr(cf, "metadata") and "name" in cf.metadata and cf.metadata["name"] == attribute_name
                 ):
-                    return name
+                    matching_names.append(name)
 
             # search regex after to avoid shadowing perfect match
             pattern = re.compile(attribute_name, flags=re_flags)
@@ -422,11 +424,27 @@ def get_matching_class_attribute_name(
                 if pattern.match(name) or (
                     hasattr(cf, "metadata") and "name" in cf.metadata and pattern.match(cf.metadata["name"])
                 ):
-                    return name
+                    matching_names.append(name)
         except Exception as e:
             logging.error(f"Failed to get attribute {attribute_name} from class {cls}")
             logging.error(e)
 
+    return matching_names
+
+
+def get_matching_class_attribute_name(
+    cls: Union[type, Any],
+    attribute_name: str,
+    re_flags=re.IGNORECASE,
+) -> Optional[str]:
+    """
+    From an object and an attribute name, returns the correct attribute name of the class.
+    Example : "ObjectVersion" --> object_version.
+    This method doesn't only transform to snake case but search into the obj class attributes (or dict keys)
+    """
+    matched = get_all_matching_class_attribute_name(cls, attribute_name, re_flags)
+    if len(matched) > 0:
+        return matched[0]
     return None
 
 
@@ -931,22 +949,24 @@ def search_attribute_matching_name_with_path(
             else:
                 not_match_path_and_obj.append((f"{current_path}{k}", s_o))
     elif not is_primitive(obj):
-        match_value = get_matching_class_attribute_name(obj, current_match.replace("\\.", "."))
-        if match_value is not None:
+        # logging.debug(f"searching {current_match} in {type(obj)} with path {current_path} and next match {next_match}")
+        match_values = get_all_matching_class_attribute_name(obj, current_match, re_flags)
+        for match_value in match_values:
             match_path_and_obj.append(
                 (
                     f"{current_path}{match_value}",
                     get_object_attribute_no_verif(obj, match_value),
                 )
             )
         for att_name in get_class_attributes(obj):
-            if att_name != match_value:
+            if att_name not in match_values:
                 not_match_path_and_obj.append(
                     (
                         f"{current_path}{att_name}",
                         get_object_attribute_no_verif(obj, att_name),
                     )
                 )
+        # logging.debug(f"\tmatch_path_and_obj: {match_path_and_obj}")
 
     for matched_path, matched in match_path_and_obj:
         if next_match is not None:  # next_match is different, match is not final