src.energyml# Copyright (c) 2023-2024 Geosiris.
+# SPDX-License-Identifier: Apache-2.0src.energyml.utilsThe energyml.utils module. +It contains tools for energyml management …
src.energyml.utils.data.hdf# Copyright (c) 2023-2024 Geosiris.
+# SPDX-License-Identifier: Apache-2.0
+from dataclasses import dataclass
+from io import BytesIO
+from typing import Optional, List, Tuple, Any, Union
+
+import h5py
+
+from ..epc import Epc, get_obj_identifier, ObjectNotFoundNotException, \
+ EPCRelsRelationshipType
+from ..introspection import search_attribute_matching_name_with_path, search_attribute_matching_name, \
+ get_obj_uuid, get_object_attribute
+
+
+@dataclass
+class DatasetReader:
+ def read_array(self, source: str, path_in_external_file: str) -> Optional[List[Any]]:
+ return None
+
+ def get_array_dimension(self, source: str, path_in_external_file: str) -> Optional[List[Any]]:
+ return None
+
+
+@dataclass
+class ETPReader(DatasetReader):
+ def read_array(self, obj_uri: str, path_in_external_file: str) -> Optional[List[Any]]:
+ return None
+
+ def get_array_dimension(self, source: str, path_in_external_file: str) -> Optional[List[Any]]:
+ return None
+
+
+@dataclass
+class HDF5FileReader(DatasetReader):
+ def read_array(self, source: Union[BytesIO, str], path_in_external_file: str) -> Optional[List[Any]]:
+ with h5py.File(source, "r") as f:
+ d_group = f[path_in_external_file]
+ return d_group[()].tolist()
+
+ def get_array_dimension(self, source: Union[BytesIO, str], path_in_external_file: str) -> Optional[List[Any]]:
+ with h5py.File(source, "r") as f:
+ return list(f[path_in_external_file].shape)
+
+ def extract_h5_datasets(
+ self, input_h5: Union[BytesIO, str], output_h5: Union[BytesIO, str], h5_datasets_paths: List[str]
+ ) -> None:
+ """
+ Copy all dataset from :param input_h5 matching with paths in :param h5_datasets_paths into the :param output
+ :param input_h5:
+ :param output_h5:
+ :param h5_datasets_paths:
+ :return:
+ """
+ if len(h5_datasets_paths) > 0:
+ with h5py.File(output_h5, "w") as f_dest:
+ with h5py.File(input_h5, "r") as f_src:
+ for dataset in h5_datasets_paths:
+ f_dest.create_dataset(dataset, data=f_src[dataset])
+
+
+def get_hdf_reference(obj) -> List[Any]:
+ """
+ See :func:`get_hdf_reference_with_path`. Only the value is returned, not the dot path into the object
+ :param obj:
+ :return:
+ """
+ return [
+ val
+ for path, val in get_hdf_reference_with_path(obj=obj)
+ ]
+
+
+def get_hdf_reference_with_path(obj: any) -> List[Tuple[str, Any]]:
+ """
+ See :func:`search_attribute_matching_name_with_path`. Search an attribute with type matching regex
+ "(PathInHdfFile|PathInExternalFile)".
+
+ :param obj:
+ :return: [ (Dot_Path_In_Obj, value), ...]
+ """
+ return search_attribute_matching_name_with_path(
+ obj,
+ "(PathInHdfFile|PathInExternalFile)"
+ )
+
+
+def get_crs_obj(
+ context_obj: Any,
+ path_in_root: Optional[str] = None,
+ root_obj: Optional[Any] = None,
+ epc: Optional[Epc] = None
+) -> Optional[Any]:
+ """
+ Search for the CRS object related to :param:`context_obj` into the :param:`epc`
+ :param context_obj:
+ :param path_in_root:
+ :param root_obj:
+ :param epc:
+ :return:
+ """
+ crs_list = search_attribute_matching_name(context_obj, r"\.*Crs", search_in_sub_obj=True, deep_search=False)
+ if crs_list is not None and len(crs_list) > 0:
+ crs = epc.get_object_by_identifier(get_obj_identifier(crs_list[0]))
+ if crs is None:
+ crs = epc.get_object_by_uuid(get_obj_uuid(crs_list[0]))
+ if crs is None:
+ raise ObjectNotFoundNotException(get_obj_identifier(crs_list[0]))
+ if crs is not None:
+ return crs
+
+ if context_obj != root_obj:
+ upper_path = path_in_root[:path_in_root.rindex(".")]
+ if len(upper_path) > 0:
+ return get_crs_obj(
+ context_obj=get_object_attribute(root_obj, upper_path),
+ path_in_root=upper_path,
+ root_obj=root_obj,
+ epc=epc,
+ )
+
+ return None
+
+
+def get_hdf5_path_from_external_path(
+ external_path_obj: Any,
+ path_in_root: Optional[str] = None,
+ root_obj: Optional[Any] = None,
+ epc: Optional[Epc] = None
+) -> Optional[str]:
+ """
+ Return the hdf5 file path (Searches for "uri" attribute or in :param:`epc` rels files).
+ :param external_path_obj: can be an attribute of an ExternalDataArrayPart
+ :param path_in_root:
+ :param root_obj:
+ :param epc:
+ :return:
+ """
+ if isinstance(external_path_obj, str):
+ # external_path_obj is maybe an attribute of an ExternalDataArrayPart, now search upper in the object
+ upper_path = path_in_root[:path_in_root.rindex(".")]
+ return get_hdf5_path_from_external_path(
+ external_path_obj=get_object_attribute(root_obj, upper_path),
+ path_in_root=upper_path,
+ root_obj=root_obj,
+ epc=epc,
+ )
+ elif type(external_path_obj).__name__ == "ExternalDataArrayPart":
+ epc_folder = epc.get_epc_file_folder()
+ h5_uri = search_attribute_matching_name(external_path_obj, "uri")
+ if h5_uri is not None and len(h5_uri) > 0:
+ return f"{epc_folder}/{h5_uri[0]}"
+ else:
+ epc_folder = epc.get_epc_file_folder()
+ hdf_proxy = search_attribute_matching_name(external_path_obj, "HdfProxy")[0]
+ if hdf_proxy is not None:
+ hdf_proxy_obj = epc.get_object_by_identifier(get_obj_identifier(hdf_proxy))
+ if hdf_proxy_obj is not None:
+ for rel in epc.additional_rels.get(get_obj_identifier(hdf_proxy_obj), []):
+ # print(f"\trel : {rel}")
+ if rel.type_value == EPCRelsRelationshipType.EXTERNAL_RESOURCE.get_type():
+ return f"{epc_folder}/{rel.target}"
+ return None
+def get_crs_obj(context_obj: Any, path_in_root: Optional[str] = None, root_obj: Optional[Any] = None, epc: Optional[Epc] = None) ‑> Optional[Any]
+Search for the CRS object related to :param:context_obj into the :param:epc
+:param context_obj:
+:param path_in_root:
+:param root_obj:
+:param epc:
+:return:
def get_crs_obj(
+ context_obj: Any,
+ path_in_root: Optional[str] = None,
+ root_obj: Optional[Any] = None,
+ epc: Optional[Epc] = None
+) -> Optional[Any]:
+ """
+ Search for the CRS object related to :param:`context_obj` into the :param:`epc`
+ :param context_obj:
+ :param path_in_root:
+ :param root_obj:
+ :param epc:
+ :return:
+ """
+ crs_list = search_attribute_matching_name(context_obj, r"\.*Crs", search_in_sub_obj=True, deep_search=False)
+ if crs_list is not None and len(crs_list) > 0:
+ crs = epc.get_object_by_identifier(get_obj_identifier(crs_list[0]))
+ if crs is None:
+ crs = epc.get_object_by_uuid(get_obj_uuid(crs_list[0]))
+ if crs is None:
+ raise ObjectNotFoundNotException(get_obj_identifier(crs_list[0]))
+ if crs is not None:
+ return crs
+
+ if context_obj != root_obj:
+ upper_path = path_in_root[:path_in_root.rindex(".")]
+ if len(upper_path) > 0:
+ return get_crs_obj(
+ context_obj=get_object_attribute(root_obj, upper_path),
+ path_in_root=upper_path,
+ root_obj=root_obj,
+ epc=epc,
+ )
+
+ return None
+def get_hdf5_path_from_external_path(external_path_obj: Any, path_in_root: Optional[str] = None, root_obj: Optional[Any] = None, epc: Optional[Epc] = None) ‑> Optional[str]
+Return the hdf5 file path (Searches for "uri" attribute or in :param:epc rels files).
+:param external_path_obj: can be an attribute of an ExternalDataArrayPart
+:param path_in_root:
+:param root_obj:
+:param epc:
+:return:
def get_hdf5_path_from_external_path(
+ external_path_obj: Any,
+ path_in_root: Optional[str] = None,
+ root_obj: Optional[Any] = None,
+ epc: Optional[Epc] = None
+) -> Optional[str]:
+ """
+ Return the hdf5 file path (Searches for "uri" attribute or in :param:`epc` rels files).
+ :param external_path_obj: can be an attribute of an ExternalDataArrayPart
+ :param path_in_root:
+ :param root_obj:
+ :param epc:
+ :return:
+ """
+ if isinstance(external_path_obj, str):
+ # external_path_obj is maybe an attribute of an ExternalDataArrayPart, now search upper in the object
+ upper_path = path_in_root[:path_in_root.rindex(".")]
+ return get_hdf5_path_from_external_path(
+ external_path_obj=get_object_attribute(root_obj, upper_path),
+ path_in_root=upper_path,
+ root_obj=root_obj,
+ epc=epc,
+ )
+ elif type(external_path_obj).__name__ == "ExternalDataArrayPart":
+ epc_folder = epc.get_epc_file_folder()
+ h5_uri = search_attribute_matching_name(external_path_obj, "uri")
+ if h5_uri is not None and len(h5_uri) > 0:
+ return f"{epc_folder}/{h5_uri[0]}"
+ else:
+ epc_folder = epc.get_epc_file_folder()
+ hdf_proxy = search_attribute_matching_name(external_path_obj, "HdfProxy")[0]
+ if hdf_proxy is not None:
+ hdf_proxy_obj = epc.get_object_by_identifier(get_obj_identifier(hdf_proxy))
+ if hdf_proxy_obj is not None:
+ for rel in epc.additional_rels.get(get_obj_identifier(hdf_proxy_obj), []):
+ # print(f"\trel : {rel}")
+ if rel.type_value == EPCRelsRelationshipType.EXTERNAL_RESOURCE.get_type():
+ return f"{epc_folder}/{rel.target}"
+ return None
+def get_hdf_reference(obj) ‑> List[Any]
+See :func:get_hdf_reference_with_path(). Only the value is returned, not the dot path into the object
+:param obj:
+:return:
def get_hdf_reference(obj) -> List[Any]:
+ """
+ See :func:`get_hdf_reference_with_path`. Only the value is returned, not the dot path into the object
+ :param obj:
+ :return:
+ """
+ return [
+ val
+ for path, val in get_hdf_reference_with_path(obj=obj)
+ ]
+def get_hdf_reference_with_path(obj: ) ‑> List[Tuple[str, Any]]
+See :func:search_attribute_matching_name_with_path. Search an attribute with type matching regex
+"(PathInHdfFile|PathInExternalFile)".
:param obj: +:return: [ (Dot_Path_In_Obj, value), …]
def get_hdf_reference_with_path(obj: any) -> List[Tuple[str, Any]]:
+ """
+ See :func:`search_attribute_matching_name_with_path`. Search an attribute with type matching regex
+ "(PathInHdfFile|PathInExternalFile)".
+
+ :param obj:
+ :return: [ (Dot_Path_In_Obj, value), ...]
+ """
+ return search_attribute_matching_name_with_path(
+ obj,
+ "(PathInHdfFile|PathInExternalFile)"
+ )
+class DatasetReader
+DatasetReader()
@dataclass
+class DatasetReader:
+ def read_array(self, source: str, path_in_external_file: str) -> Optional[List[Any]]:
+ return None
+
+ def get_array_dimension(self, source: str, path_in_external_file: str) -> Optional[List[Any]]:
+ return None
+def get_array_dimension(self, source: str, path_in_external_file: str) ‑> Optional[List[Any]]
+def get_array_dimension(self, source: str, path_in_external_file: str) -> Optional[List[Any]]:
+ return None
+def read_array(self, source: str, path_in_external_file: str) ‑> Optional[List[Any]]
+def read_array(self, source: str, path_in_external_file: str) -> Optional[List[Any]]:
+ return None
+class ETPReader
+ETPReader()
@dataclass
+class ETPReader(DatasetReader):
+ def read_array(self, obj_uri: str, path_in_external_file: str) -> Optional[List[Any]]:
+ return None
+
+ def get_array_dimension(self, source: str, path_in_external_file: str) -> Optional[List[Any]]:
+ return None
+def get_array_dimension(self, source: str, path_in_external_file: str) ‑> Optional[List[Any]]
+def get_array_dimension(self, source: str, path_in_external_file: str) -> Optional[List[Any]]:
+ return None
+def read_array(self, obj_uri: str, path_in_external_file: str) ‑> Optional[List[Any]]
+def read_array(self, obj_uri: str, path_in_external_file: str) -> Optional[List[Any]]:
+ return None
+class HDF5FileReader
+HDF5FileReader()
@dataclass
+class HDF5FileReader(DatasetReader):
+ def read_array(self, source: Union[BytesIO, str], path_in_external_file: str) -> Optional[List[Any]]:
+ with h5py.File(source, "r") as f:
+ d_group = f[path_in_external_file]
+ return d_group[()].tolist()
+
+ def get_array_dimension(self, source: Union[BytesIO, str], path_in_external_file: str) -> Optional[List[Any]]:
+ with h5py.File(source, "r") as f:
+ return list(f[path_in_external_file].shape)
+
+ def extract_h5_datasets(
+ self, input_h5: Union[BytesIO, str], output_h5: Union[BytesIO, str], h5_datasets_paths: List[str]
+ ) -> None:
+ """
+ Copy all dataset from :param input_h5 matching with paths in :param h5_datasets_paths into the :param output
+ :param input_h5:
+ :param output_h5:
+ :param h5_datasets_paths:
+ :return:
+ """
+ if len(h5_datasets_paths) > 0:
+ with h5py.File(output_h5, "w") as f_dest:
+ with h5py.File(input_h5, "r") as f_src:
+ for dataset in h5_datasets_paths:
+ f_dest.create_dataset(dataset, data=f_src[dataset])
+def extract_h5_datasets(self, input_h5: Union[_io.BytesIO, str], output_h5: Union[_io.BytesIO, str], h5_datasets_paths: List[str]) ‑> None
+Copy all dataset from :param input_h5 matching with paths in :param h5_datasets_paths into the :param output +:param input_h5: +:param output_h5: +:param h5_datasets_paths: +:return:
def extract_h5_datasets(
+ self, input_h5: Union[BytesIO, str], output_h5: Union[BytesIO, str], h5_datasets_paths: List[str]
+) -> None:
+ """
+ Copy all dataset from :param input_h5 matching with paths in :param h5_datasets_paths into the :param output
+ :param input_h5:
+ :param output_h5:
+ :param h5_datasets_paths:
+ :return:
+ """
+ if len(h5_datasets_paths) > 0:
+ with h5py.File(output_h5, "w") as f_dest:
+ with h5py.File(input_h5, "r") as f_src:
+ for dataset in h5_datasets_paths:
+ f_dest.create_dataset(dataset, data=f_src[dataset])
+def get_array_dimension(self, source: Union[_io.BytesIO, str], path_in_external_file: str) ‑> Optional[List[Any]]
+def get_array_dimension(self, source: Union[BytesIO, str], path_in_external_file: str) -> Optional[List[Any]]:
+ with h5py.File(source, "r") as f:
+ return list(f[path_in_external_file].shape)
+def read_array(self, source: Union[_io.BytesIO, str], path_in_external_file: str) ‑> Optional[List[Any]]
+def read_array(self, source: Union[BytesIO, str], path_in_external_file: str) -> Optional[List[Any]]:
+ with h5py.File(source, "r") as f:
+ d_group = f[path_in_external_file]
+ return d_group[()].tolist()src.energyml.utils.data.helper# Copyright (c) 2023-2024 Geosiris.
+# SPDX-License-Identifier: Apache-2.0
+import inspect
+import sys
+from typing import Any, Optional, Callable, Literal, List, Union, Tuple
+
+from .hdf import get_hdf5_path_from_external_path, HDF5FileReader, get_hdf_reference, get_crs_obj
+from ..epc import Epc, get_obj_identifier
+from ..introspection import snake_case, get_object_attribute_no_verif, \
+ search_attribute_matching_name_with_path, search_attribute_matching_name, flatten_concatenation, \
+ search_attribute_in_upper_matching_name
+
+_ARRAY_NAMES_ = [
+ "BooleanArrayFromDiscretePropertyArray",
+ "BooleanArrayFromIndexArray",
+ "BooleanConstantArray",
+ "BooleanExternalArray",
+ "BooleanHdf5Array",
+ "BooleanXmlArray",
+ "CompoundExternalArray",
+ "DasTimeArray",
+ "DoubleConstantArray",
+ "DoubleHdf5Array",
+ "DoubleLatticeArray",
+ "ExternalDataArray",
+ "FloatingPointConstantArray",
+ "FloatingPointExternalArray",
+ "FloatingPointLatticeArray",
+ "FloatingPointXmlArray",
+ "IntegerArrayFromBooleanMaskArray",
+ "IntegerConstantArray",
+ "IntegerExternalArray",
+ "IntegerHdf5Array",
+ "IntegerLatticeArray",
+ "IntegerRangeArray",
+ "IntegerXmlArray",
+ "JaggedArray",
+ "ParametricLineArray",
+ "ParametricLineFromRepresentationLatticeArray",
+ "Point2DHdf5Array",
+ "Point3DFromRepresentationLatticeArray",
+ "Point3DHdf5Array",
+ "Point3DLatticeArray",
+ "Point3DParametricArray",
+ "Point3DZvalueArray",
+ "ResqmlJaggedArray",
+ "StringConstantArray",
+ "StringExternalArray",
+ "StringHdf5Array",
+ "StringXmlArray"
+]
+
+
+def get_array_reader_function(array_type_name: str) -> Optional[Callable]:
+ """
+ Returns the name of the potential appropriate function to read an object with type is named :param array_type_name
+ :param array_type_name: the initial type name
+ :return:
+ """
+ for name, obj in inspect.getmembers(sys.modules[__name__]):
+ if name == f"read_{snake_case(array_type_name)}":
+ return obj
+ return None
+
+
+def _array_name_mapping(array_type_name: str) -> str:
+ """
+ Transform the type name to match existing reader function
+ :param array_type_name:
+ :return:
+ """
+ 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:
+ return "ExternalArray"
+ elif array_type_name.endswith("XmlArray"):
+ return "XmlArray"
+ 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:
+ return "int_double_lattice_array"
+ return array_type_name
+
+
+def read_array(
+ energyml_array: Any,
+ root_obj: Optional[Any] = None,
+ path_in_root: Optional[str] = None,
+ epc: Optional[Epc] = None
+) -> List[Any]:
+ """
+ Read an array and return a list. The array is read depending on its type. see. :py:func:`energyml.utils.data.helper.get_supported_array`
+ :param energyml_array:
+ :param root_obj:
+ :param path_in_root:
+ :param epc:
+ :return:
+ """
+ if isinstance(energyml_array, list):
+ return energyml_array
+ array_type_name = _array_name_mapping(type(energyml_array).__name__)
+
+ reader_func = get_array_reader_function(array_type_name)
+ if reader_func is not None:
+ return reader_func(
+ energyml_array=energyml_array,
+ root_obj=root_obj,
+ path_in_root=path_in_root,
+ epc=epc,
+ )
+ else:
+ print(f"Type {array_type_name} is not supported: function read_{snake_case(array_type_name)} not found")
+ raise Exception(f"Type {array_type_name} is not supported\n\t{energyml_array}: \n\tfunction read_{snake_case(array_type_name)} not found")
+
+
+def get_supported_array() -> List[str]:
+ """
+ Return a list of the supported arrays for the use of :py:func:`energyml.utils.data.helper.read_array` function.
+ :return:
+ """
+ return [x for x in _ARRAY_NAMES_ if get_array_reader_function(_array_name_mapping(x)) is not None]
+
+
+def get_not_supported_array():
+ """
+ Return a list of the NOT supported arrays for the use of :py:func:`energyml.utils.data.helper.read_array` function.
+ :return:
+ """
+ return [x for x in _ARRAY_NAMES_ if get_array_reader_function(_array_name_mapping(x)) is None]
+
+
+def read_constant_array(
+ energyml_array: Any,
+ root_obj: Optional[Any] = None,
+ path_in_root: Optional[str] = None,
+ epc: Optional[Epc] = None
+) -> List[Any]:
+ """
+ Read a constant array ( BooleanConstantArray, DoubleConstantArray, FloatingPointConstantArray, IntegerConstantArray ...)
+ :param energyml_array:
+ :param root_obj:
+ :param path_in_root:
+ :param epc:
+ :return:
+ """
+ # print(f"Reading constant array\n\t{energyml_array}")
+
+ value = get_object_attribute_no_verif(energyml_array, "value")
+ count = get_object_attribute_no_verif(energyml_array, "count")
+
+ # print(f"\tValue : {[value for i in range(0, count)]}")
+
+ return [value for i in range(0, count)]
+
+
+def read_xml_array(
+ energyml_array: Any,
+ root_obj: Optional[Any] = None,
+ path_in_root: Optional[str] = None,
+ epc: Optional[Epc] = None
+) -> List[Any]:
+ """
+ Read a xml array ( BooleanXmlArray, FloatingPointXmlArray, IntegerXmlArray, StringXmlArray ...)
+ :param energyml_array:
+ :param root_obj:
+ :param path_in_root:
+ :param epc:
+ :return:
+ """
+ values = get_object_attribute_no_verif(energyml_array, "values")
+ # count = get_object_attribute_no_verif(energyml_array, "count_per_value")
+ return values
+
+
+def read_jagged_array(
+ energyml_array: Any,
+ root_obj: Optional[Any] = None,
+ path_in_root: Optional[str] = None,
+ epc: Optional[Epc] = None
+) -> List[Any]:
+ """
+ Read a jagged array
+ :param energyml_array:
+ :param root_obj:
+ :param path_in_root:
+ :param epc:
+ :return:
+ """
+ elements = read_array(
+ energyml_array=get_object_attribute_no_verif(energyml_array, "elements"),
+ root_obj=root_obj,
+ path_in_root=path_in_root + ".elements",
+ epc=epc,
+ )
+ cumulative_length = read_array(
+ energyml_array=read_array(get_object_attribute_no_verif(energyml_array, "cumulative_length")),
+ root_obj=root_obj,
+ path_in_root=path_in_root + ".cumulative_length",
+ epc=epc,
+ )
+
+ res = []
+ previous = 0
+ for cl in cumulative_length:
+ res.append(elements[previous: cl])
+ previous = cl
+ return res
+
+
+def read_external_array(
+ energyml_array: Any,
+ root_obj: Optional[Any] = None,
+ path_in_root: Optional[str] = None,
+ epc: Optional[Epc] = None
+) -> List[Any]:
+ """
+ Read an external array (BooleanExternalArray, BooleanHdf5Array, DoubleHdf5Array, IntegerHdf5Array, StringExternalArray ...)
+ :param energyml_array:
+ :param root_obj:
+ :param path_in_root:
+ :param epc:
+ :return:
+ """
+ hdf5_path = get_hdf5_path_from_external_path(
+ external_path_obj=energyml_array,
+ path_in_root=path_in_root,
+ root_obj=root_obj,
+ epc=epc,
+ )
+ h5_reader = HDF5FileReader()
+ path_in_external = get_hdf_reference(energyml_array)[0]
+
+ result_array = h5_reader.read_array(hdf5_path, path_in_external)
+
+ if path_in_root.lower().endswith("points") and len(result_array) > 0 and len(result_array[0]) == 3:
+ crs = get_crs_obj(
+ context_obj=energyml_array,
+ path_in_root=path_in_root,
+ root_obj=root_obj,
+ epc=epc,
+ )
+ zincreasing_downward = is_z_reversed(crs)
+
+ if zincreasing_downward:
+ result_array = list(map(lambda p: [p[0], p[1], -p[2]], result_array))
+
+ return result_array
+
+
+def read_int_double_lattice_array(
+ energyml_array: Any,
+ root_obj: Optional[Any] = None,
+ path_in_root: Optional[str] = None,
+ epc: Optional[Epc] = None
+):
+ """
+ Read DoubleLatticeArray or IntegerLatticeArray.
+ :param energyml_array:
+ :param root_obj:
+ :param path_in_root:
+ :param epc:
+ :return:
+ """
+ start_value = get_object_attribute_no_verif(energyml_array, "start_value")
+ offset = get_object_attribute_no_verif(energyml_array, "offset")
+
+ result = []
+
+ # if len(offset) == 1:
+ # pass
+ # elif len(offset) == 2:
+ # pass
+ # else:
+ raise Exception(f"{type(energyml_array)} read with an offset of length {len(offset)} is not supported")
+
+ # return result
+
+
+def _point_as_array(point: Any) -> List:
+ """
+ Transform a point that has "coordinate1", "coordinate2", "coordinate3" as attributes into a list.
+ :param point:
+ :return:
+ """
+ return [
+ get_object_attribute_no_verif(point, "coordinate1"),
+ get_object_attribute_no_verif(point, "coordinate2"),
+ get_object_attribute_no_verif(point, "coordinate3"),
+ ]
+
+
+def prod_n_tab(val: Union[float, int, str], tab: List[Union[float, int, str]]):
+ """
+ Multiply every value of the list 'tab' by the constant 'val'
+ :param val:
+ :param tab:
+ :return:
+ """
+ return list(map(lambda x: x*val, tab))
+
+
+def sum_lists(l1: List, l2: List):
+ """
+ Sums 2 lists values.
+
+ Example:
+ [1,1,1] and [2,2,3,6] gives : [3,3,4,6]
+
+ :param l1:
+ :param l2:
+ :return:
+ """
+ return [l1[i] + l2[i] for i in range(min(len(l1), len(l2)))]+max(l1, l2, key=len)[min(len(l1), len(l2)):]
+
+
+def read_point3d_zvalue_array(
+ energyml_array: Any,
+ root_obj: Optional[Any] = None,
+ path_in_root: Optional[str] = None,
+ epc: Optional[Epc] = None
+):
+ """
+ Read a Point3D2ValueArray
+ :param energyml_array:
+ :param root_obj:
+ :param path_in_root:
+ :param epc:
+ :return:
+ """
+ supporting_geometry = get_object_attribute_no_verif(energyml_array, "supporting_geometry")
+ sup_geom_array = read_array(
+ energyml_array=supporting_geometry,
+ root_obj=root_obj,
+ path_in_root=path_in_root + ".SupportingGeometry",
+ epc=epc,
+ )
+
+ zvalues = get_object_attribute_no_verif(energyml_array, "zvalues")
+ zvalues_array = flatten_concatenation(read_array(
+ energyml_array=zvalues,
+ root_obj=root_obj,
+ path_in_root=path_in_root + ".ZValues",
+ epc=epc,
+ ))
+
+ count = 0
+
+ for i in range(len(sup_geom_array)):
+ try:
+ sup_geom_array[i][2] = zvalues_array[i]
+ except Exception as e:
+ if count == 0:
+ print(e, f": {i} is out of bound of {len(zvalues_array)}")
+ count = count + 1
+
+ return sup_geom_array
+
+
+def read_point3d_from_representation_lattice_array(
+ energyml_array: Any,
+ root_obj: Optional[Any] = None,
+ path_in_root: Optional[str] = None,
+ epc: Optional[Epc] = None
+):
+ """
+ Read a Point3DFromRepresentationLatticeArray.
+
+ Note: Only works for Grid2DRepresentation.
+
+ :param energyml_array:
+ :param root_obj:
+ :param path_in_root:
+ :param epc:
+ :return:
+ """
+ supporting_rep_identifier = get_obj_identifier(get_object_attribute_no_verif(energyml_array, "supporting_representation"))
+ print(f"energyml_array : {energyml_array}\n\t{supporting_rep_identifier}")
+ supporting_rep = epc.get_object_by_identifier(supporting_rep_identifier)
+
+ # TODO chercher un pattern \.*patch\.*.[d]+ pour trouver le numero du patch dans le path_in_root puis lire le patch
+ # print(f"path_in_root {path_in_root}")
+
+ result = []
+ if "grid2d" in str(type(supporting_rep)).lower():
+ patch_path, patch = search_attribute_matching_name_with_path(supporting_rep, "Grid2dPatch")[0]
+ points = read_grid2d_patch(
+ patch=patch,
+ grid2d=supporting_rep,
+ path_in_root=patch_path,
+ epc=epc,
+ )
+ # TODO: take the points by there indices from the NodeIndicesOnSupportingRepresentation
+ result = points
+
+ else:
+ raise Exception(f"Not supported type {type(energyml_array)} for object {type(root_obj)}")
+ # pour trouver les infos qu'il faut
+ return result
+
+
+def read_grid2d_patch(
+ patch: Any,
+ grid2d: Optional[Any] = None,
+ path_in_root: Optional[str] = None,
+ epc: Optional[Epc] = None
+) -> List:
+ points_path, points_obj = search_attribute_matching_name_with_path(patch, "Geometry.Points")[0]
+
+ return read_array(
+ energyml_array=points_obj,
+ root_obj=grid2d,
+ path_in_root=path_in_root + points_path,
+ epc=epc,
+ )
+
+
+def read_point3d_lattice_array(
+ energyml_array: Any,
+ root_obj: Optional[Any] = None,
+ path_in_root: Optional[str] = None,
+ epc: Optional[Epc] = None
+) -> List:
+ """
+ Read a Point3DLatticeArray.
+
+ Note: If a CRS is found and its 'ZIncreasingDownward' is set to true or its
+
+ :param energyml_array:
+ :param root_obj:
+ :param path_in_root:
+ :param epc:
+ :return:
+ """
+ result = []
+ origin = _point_as_array(get_object_attribute_no_verif(energyml_array, "origin"))
+ offset = get_object_attribute_no_verif(energyml_array, "offset")
+
+ if len(offset) == 2:
+ slowest = offset[0]
+ fastest = offset[1]
+
+ crs_sa_count = search_attribute_in_upper_matching_name(
+ obj=energyml_array,
+ name_rgx="SlowestAxisCount",
+ root_obj=root_obj,
+ current_path=path_in_root,
+ )
+
+ crs_fa_count = search_attribute_in_upper_matching_name(
+ obj=energyml_array,
+ name_rgx="FastestAxisCount",
+ root_obj=root_obj,
+ current_path=path_in_root,
+ )
+
+ crs = get_crs_obj(
+ context_obj=energyml_array,
+ path_in_root=path_in_root,
+ root_obj=root_obj,
+ epc=epc,
+ )
+ zincreasing_downward = is_z_reversed(crs)
+
+ slowest_vec = _point_as_array(get_object_attribute_no_verif(slowest, "offset"))
+ slowest_spacing = read_array(get_object_attribute_no_verif(slowest, "spacing"))
+ slowest_table = list(map(lambda x: prod_n_tab(x, slowest_vec), slowest_spacing))
+
+ fastest_vec = _point_as_array(get_object_attribute_no_verif(fastest, "offset"))
+ fastest_spacing = read_array(get_object_attribute_no_verif(fastest, "spacing"))
+ fastest_table = list(map(lambda x: prod_n_tab(x, fastest_vec), fastest_spacing))
+
+ slowest_size = len(slowest_table)
+ fastest_size = len(fastest_table)
+
+ if len(crs_sa_count) > 0 and len(crs_fa_count) and crs_sa_count[0] == fastest_size:
+ print("reversing order")
+ # if offset were given in the wrong order
+ tmp_table = slowest_table
+ slowest_table = fastest_table
+ fastest_table = tmp_table
+
+ tmp_size = slowest_size
+ slowest_size = fastest_size
+ fastest_size = tmp_size
+
+ for i in range(slowest_size):
+ for j in range(fastest_size):
+ previous_value = origin
+ # to avoid a sum of the parts of the array at each iteration, I take the previous value in the same line
+ # number i and add the fastest_table[j] value
+
+ if j > 0:
+ if i > 0:
+ line_idx = i * fastest_size # numero de ligne
+ previous_value = result[line_idx + j - 1]
+ else:
+ previous_value = result[j - 1]
+ if zincreasing_downward:
+ result.append(sum_lists(previous_value, slowest_table[i - 1]))
+ else:
+ result.append(sum_lists(previous_value, fastest_table[j - 1]))
+ else:
+ if i > 0:
+ prev_line_idx = (i - 1) * fastest_size # numero de ligne precedent
+ previous_value = result[prev_line_idx]
+ if zincreasing_downward:
+ result.append(sum_lists(previous_value, fastest_table[j - 1]))
+ else:
+ result.append(sum_lists(previous_value, slowest_table[i - 1]))
+ else:
+ result.append(previous_value)
+ else:
+ raise Exception(f"{type(energyml_array)} read with an offset of length {len(offset)} is not supported")
+
+ return result
+
+
+def is_z_reversed(crs: Optional[Any]) -> bool:
+ """
+ Returns True if the Z axe is reverse (ZIncreasingDownward=='True' or VerticalAxis.Direction=='down')
+ :param crs:
+ :return: By default, False is returned (if 'crs' is None)
+ """
+ reverse_z_values = False
+ if crs is not None:
+ # resqml 201
+ zincreasing_downward = search_attribute_matching_name(crs, "ZIncreasingDownward")
+ if len(zincreasing_downward) > 0:
+ reverse_z_values = zincreasing_downward[0]
+
+ # resqml >= 22
+ vert_axis = search_attribute_matching_name(crs, "VerticalAxis.Direction")
+ if len(vert_axis) > 0:
+ reverse_z_values = vert_axis[0].lower() == "down"
+
+ return reverse_z_values
+
+
+# def read_boolean_constant_array(
+# energyml_array: Any,
+# root_obj: Optional[Any] = None,
+# path_in_root: Optional[str] = None,
+# epc: Optional[Epc] = None
+# ):
+# print(energyml_array)
+def get_array_reader_function(array_type_name: str) ‑> Optional[Callable]
+Returns the name of the potential appropriate function to read an object with type is named :param array_type_name +:param array_type_name: the initial type name +:return:
def get_array_reader_function(array_type_name: str) -> Optional[Callable]:
+ """
+ Returns the name of the potential appropriate function to read an object with type is named :param array_type_name
+ :param array_type_name: the initial type name
+ :return:
+ """
+ for name, obj in inspect.getmembers(sys.modules[__name__]):
+ if name == f"read_{snake_case(array_type_name)}":
+ return obj
+ return None
+def get_not_supported_array()
+Return a list of the NOT supported arrays for the use of :py:func:energyml.utils.data.helper.read_array function.
+:return:
def get_not_supported_array():
+ """
+ Return a list of the NOT supported arrays for the use of :py:func:`energyml.utils.data.helper.read_array` function.
+ :return:
+ """
+ return [x for x in _ARRAY_NAMES_ if get_array_reader_function(_array_name_mapping(x)) is None]
+def get_supported_array() ‑> List[str]
+Return a list of the supported arrays for the use of :py:func:energyml.utils.data.helper.read_array function.
+:return:
def get_supported_array() -> List[str]:
+ """
+ Return a list of the supported arrays for the use of :py:func:`energyml.utils.data.helper.read_array` function.
+ :return:
+ """
+ return [x for x in _ARRAY_NAMES_ if get_array_reader_function(_array_name_mapping(x)) is not None]
+def is_z_reversed(crs: Optional[Any]) ‑> bool
+Returns True if the Z axe is reverse (ZIncreasingDownward=='True' or VerticalAxis.Direction=='down') +:param crs: +:return: By default, False is returned (if 'crs' is None)
def is_z_reversed(crs: Optional[Any]) -> bool:
+ """
+ Returns True if the Z axe is reverse (ZIncreasingDownward=='True' or VerticalAxis.Direction=='down')
+ :param crs:
+ :return: By default, False is returned (if 'crs' is None)
+ """
+ reverse_z_values = False
+ if crs is not None:
+ # resqml 201
+ zincreasing_downward = search_attribute_matching_name(crs, "ZIncreasingDownward")
+ if len(zincreasing_downward) > 0:
+ reverse_z_values = zincreasing_downward[0]
+
+ # resqml >= 22
+ vert_axis = search_attribute_matching_name(crs, "VerticalAxis.Direction")
+ if len(vert_axis) > 0:
+ reverse_z_values = vert_axis[0].lower() == "down"
+
+ return reverse_z_values
+def prod_n_tab(val: Union[float, int, str], tab: List[Union[float, int, str]])
+Multiply every value of the list 'tab' by the constant 'val' +:param val: +:param tab: +:return:
def prod_n_tab(val: Union[float, int, str], tab: List[Union[float, int, str]]):
+ """
+ Multiply every value of the list 'tab' by the constant 'val'
+ :param val:
+ :param tab:
+ :return:
+ """
+ return list(map(lambda x: x*val, tab))
+def read_array(energyml_array: Any, root_obj: Optional[Any] = None, path_in_root: Optional[str] = None, epc: Optional[Epc] = None) ‑> List[Any]
+Read an array and return a list. The array is read depending on its type. see. :py:func:energyml.utils.data.helper.get_supported_array
+:param energyml_array:
+:param root_obj:
+:param path_in_root:
+:param epc:
+:return:
def read_array(
+ energyml_array: Any,
+ root_obj: Optional[Any] = None,
+ path_in_root: Optional[str] = None,
+ epc: Optional[Epc] = None
+) -> List[Any]:
+ """
+ Read an array and return a list. The array is read depending on its type. see. :py:func:`energyml.utils.data.helper.get_supported_array`
+ :param energyml_array:
+ :param root_obj:
+ :param path_in_root:
+ :param epc:
+ :return:
+ """
+ if isinstance(energyml_array, list):
+ return energyml_array
+ array_type_name = _array_name_mapping(type(energyml_array).__name__)
+
+ reader_func = get_array_reader_function(array_type_name)
+ if reader_func is not None:
+ return reader_func(
+ energyml_array=energyml_array,
+ root_obj=root_obj,
+ path_in_root=path_in_root,
+ epc=epc,
+ )
+ else:
+ print(f"Type {array_type_name} is not supported: function read_{snake_case(array_type_name)} not found")
+ raise Exception(f"Type {array_type_name} is not supported\n\t{energyml_array}: \n\tfunction read_{snake_case(array_type_name)} not found")
+def read_constant_array(energyml_array: Any, root_obj: Optional[Any] = None, path_in_root: Optional[str] = None, epc: Optional[Epc] = None) ‑> List[Any]
+Read a constant array ( BooleanConstantArray, DoubleConstantArray, FloatingPointConstantArray, IntegerConstantArray …) +:param energyml_array: +:param root_obj: +:param path_in_root: +:param epc: +:return:
def read_constant_array(
+ energyml_array: Any,
+ root_obj: Optional[Any] = None,
+ path_in_root: Optional[str] = None,
+ epc: Optional[Epc] = None
+) -> List[Any]:
+ """
+ Read a constant array ( BooleanConstantArray, DoubleConstantArray, FloatingPointConstantArray, IntegerConstantArray ...)
+ :param energyml_array:
+ :param root_obj:
+ :param path_in_root:
+ :param epc:
+ :return:
+ """
+ # print(f"Reading constant array\n\t{energyml_array}")
+
+ value = get_object_attribute_no_verif(energyml_array, "value")
+ count = get_object_attribute_no_verif(energyml_array, "count")
+
+ # print(f"\tValue : {[value for i in range(0, count)]}")
+
+ return [value for i in range(0, count)]
+def read_external_array(energyml_array: Any, root_obj: Optional[Any] = None, path_in_root: Optional[str] = None, epc: Optional[Epc] = None) ‑> List[Any]
+Read an external array (BooleanExternalArray, BooleanHdf5Array, DoubleHdf5Array, IntegerHdf5Array, StringExternalArray …) +:param energyml_array: +:param root_obj: +:param path_in_root: +:param epc: +:return:
def read_external_array(
+ energyml_array: Any,
+ root_obj: Optional[Any] = None,
+ path_in_root: Optional[str] = None,
+ epc: Optional[Epc] = None
+) -> List[Any]:
+ """
+ Read an external array (BooleanExternalArray, BooleanHdf5Array, DoubleHdf5Array, IntegerHdf5Array, StringExternalArray ...)
+ :param energyml_array:
+ :param root_obj:
+ :param path_in_root:
+ :param epc:
+ :return:
+ """
+ hdf5_path = get_hdf5_path_from_external_path(
+ external_path_obj=energyml_array,
+ path_in_root=path_in_root,
+ root_obj=root_obj,
+ epc=epc,
+ )
+ h5_reader = HDF5FileReader()
+ path_in_external = get_hdf_reference(energyml_array)[0]
+
+ result_array = h5_reader.read_array(hdf5_path, path_in_external)
+
+ if path_in_root.lower().endswith("points") and len(result_array) > 0 and len(result_array[0]) == 3:
+ crs = get_crs_obj(
+ context_obj=energyml_array,
+ path_in_root=path_in_root,
+ root_obj=root_obj,
+ epc=epc,
+ )
+ zincreasing_downward = is_z_reversed(crs)
+
+ if zincreasing_downward:
+ result_array = list(map(lambda p: [p[0], p[1], -p[2]], result_array))
+
+ return result_array
+def read_grid2d_patch(patch: Any, grid2d: Optional[Any] = None, path_in_root: Optional[str] = None, epc: Optional[Epc] = None) ‑> List
+def read_grid2d_patch(
+ patch: Any,
+ grid2d: Optional[Any] = None,
+ path_in_root: Optional[str] = None,
+ epc: Optional[Epc] = None
+) -> List:
+ points_path, points_obj = search_attribute_matching_name_with_path(patch, "Geometry.Points")[0]
+
+ return read_array(
+ energyml_array=points_obj,
+ root_obj=grid2d,
+ path_in_root=path_in_root + points_path,
+ epc=epc,
+ )
+def read_int_double_lattice_array(energyml_array: Any, root_obj: Optional[Any] = None, path_in_root: Optional[str] = None, epc: Optional[Epc] = None)
+Read DoubleLatticeArray or IntegerLatticeArray. +:param energyml_array: +:param root_obj: +:param path_in_root: +:param epc: +:return:
def read_int_double_lattice_array(
+ energyml_array: Any,
+ root_obj: Optional[Any] = None,
+ path_in_root: Optional[str] = None,
+ epc: Optional[Epc] = None
+):
+ """
+ Read DoubleLatticeArray or IntegerLatticeArray.
+ :param energyml_array:
+ :param root_obj:
+ :param path_in_root:
+ :param epc:
+ :return:
+ """
+ start_value = get_object_attribute_no_verif(energyml_array, "start_value")
+ offset = get_object_attribute_no_verif(energyml_array, "offset")
+
+ result = []
+
+ # if len(offset) == 1:
+ # pass
+ # elif len(offset) == 2:
+ # pass
+ # else:
+ raise Exception(f"{type(energyml_array)} read with an offset of length {len(offset)} is not supported")
+
+ # return result
+def read_jagged_array(energyml_array: Any, root_obj: Optional[Any] = None, path_in_root: Optional[str] = None, epc: Optional[Epc] = None) ‑> List[Any]
+Read a jagged array +:param energyml_array: +:param root_obj: +:param path_in_root: +:param epc: +:return:
def read_jagged_array(
+ energyml_array: Any,
+ root_obj: Optional[Any] = None,
+ path_in_root: Optional[str] = None,
+ epc: Optional[Epc] = None
+) -> List[Any]:
+ """
+ Read a jagged array
+ :param energyml_array:
+ :param root_obj:
+ :param path_in_root:
+ :param epc:
+ :return:
+ """
+ elements = read_array(
+ energyml_array=get_object_attribute_no_verif(energyml_array, "elements"),
+ root_obj=root_obj,
+ path_in_root=path_in_root + ".elements",
+ epc=epc,
+ )
+ cumulative_length = read_array(
+ energyml_array=read_array(get_object_attribute_no_verif(energyml_array, "cumulative_length")),
+ root_obj=root_obj,
+ path_in_root=path_in_root + ".cumulative_length",
+ epc=epc,
+ )
+
+ res = []
+ previous = 0
+ for cl in cumulative_length:
+ res.append(elements[previous: cl])
+ previous = cl
+ return res
+def read_point3d_from_representation_lattice_array(energyml_array: Any, root_obj: Optional[Any] = None, path_in_root: Optional[str] = None, epc: Optional[Epc] = None)
+Read a Point3DFromRepresentationLatticeArray.
+Note: Only works for Grid2DRepresentation.
+:param energyml_array: +:param root_obj: +:param path_in_root: +:param epc: +:return:
def read_point3d_from_representation_lattice_array(
+ energyml_array: Any,
+ root_obj: Optional[Any] = None,
+ path_in_root: Optional[str] = None,
+ epc: Optional[Epc] = None
+):
+ """
+ Read a Point3DFromRepresentationLatticeArray.
+
+ Note: Only works for Grid2DRepresentation.
+
+ :param energyml_array:
+ :param root_obj:
+ :param path_in_root:
+ :param epc:
+ :return:
+ """
+ supporting_rep_identifier = get_obj_identifier(get_object_attribute_no_verif(energyml_array, "supporting_representation"))
+ print(f"energyml_array : {energyml_array}\n\t{supporting_rep_identifier}")
+ supporting_rep = epc.get_object_by_identifier(supporting_rep_identifier)
+
+ # TODO chercher un pattern \.*patch\.*.[d]+ pour trouver le numero du patch dans le path_in_root puis lire le patch
+ # print(f"path_in_root {path_in_root}")
+
+ result = []
+ if "grid2d" in str(type(supporting_rep)).lower():
+ patch_path, patch = search_attribute_matching_name_with_path(supporting_rep, "Grid2dPatch")[0]
+ points = read_grid2d_patch(
+ patch=patch,
+ grid2d=supporting_rep,
+ path_in_root=patch_path,
+ epc=epc,
+ )
+ # TODO: take the points by there indices from the NodeIndicesOnSupportingRepresentation
+ result = points
+
+ else:
+ raise Exception(f"Not supported type {type(energyml_array)} for object {type(root_obj)}")
+ # pour trouver les infos qu'il faut
+ return result
+def read_point3d_lattice_array(energyml_array: Any, root_obj: Optional[Any] = None, path_in_root: Optional[str] = None, epc: Optional[Epc] = None) ‑> List
+Read a Point3DLatticeArray.
+Note: If a CRS is found and its 'ZIncreasingDownward' is set to true or its
+:param energyml_array: +:param root_obj: +:param path_in_root: +:param epc: +:return:
def read_point3d_lattice_array(
+ energyml_array: Any,
+ root_obj: Optional[Any] = None,
+ path_in_root: Optional[str] = None,
+ epc: Optional[Epc] = None
+) -> List:
+ """
+ Read a Point3DLatticeArray.
+
+ Note: If a CRS is found and its 'ZIncreasingDownward' is set to true or its
+
+ :param energyml_array:
+ :param root_obj:
+ :param path_in_root:
+ :param epc:
+ :return:
+ """
+ result = []
+ origin = _point_as_array(get_object_attribute_no_verif(energyml_array, "origin"))
+ offset = get_object_attribute_no_verif(energyml_array, "offset")
+
+ if len(offset) == 2:
+ slowest = offset[0]
+ fastest = offset[1]
+
+ crs_sa_count = search_attribute_in_upper_matching_name(
+ obj=energyml_array,
+ name_rgx="SlowestAxisCount",
+ root_obj=root_obj,
+ current_path=path_in_root,
+ )
+
+ crs_fa_count = search_attribute_in_upper_matching_name(
+ obj=energyml_array,
+ name_rgx="FastestAxisCount",
+ root_obj=root_obj,
+ current_path=path_in_root,
+ )
+
+ crs = get_crs_obj(
+ context_obj=energyml_array,
+ path_in_root=path_in_root,
+ root_obj=root_obj,
+ epc=epc,
+ )
+ zincreasing_downward = is_z_reversed(crs)
+
+ slowest_vec = _point_as_array(get_object_attribute_no_verif(slowest, "offset"))
+ slowest_spacing = read_array(get_object_attribute_no_verif(slowest, "spacing"))
+ slowest_table = list(map(lambda x: prod_n_tab(x, slowest_vec), slowest_spacing))
+
+ fastest_vec = _point_as_array(get_object_attribute_no_verif(fastest, "offset"))
+ fastest_spacing = read_array(get_object_attribute_no_verif(fastest, "spacing"))
+ fastest_table = list(map(lambda x: prod_n_tab(x, fastest_vec), fastest_spacing))
+
+ slowest_size = len(slowest_table)
+ fastest_size = len(fastest_table)
+
+ if len(crs_sa_count) > 0 and len(crs_fa_count) and crs_sa_count[0] == fastest_size:
+ print("reversing order")
+ # if offset were given in the wrong order
+ tmp_table = slowest_table
+ slowest_table = fastest_table
+ fastest_table = tmp_table
+
+ tmp_size = slowest_size
+ slowest_size = fastest_size
+ fastest_size = tmp_size
+
+ for i in range(slowest_size):
+ for j in range(fastest_size):
+ previous_value = origin
+ # to avoid a sum of the parts of the array at each iteration, I take the previous value in the same line
+ # number i and add the fastest_table[j] value
+
+ if j > 0:
+ if i > 0:
+ line_idx = i * fastest_size # numero de ligne
+ previous_value = result[line_idx + j - 1]
+ else:
+ previous_value = result[j - 1]
+ if zincreasing_downward:
+ result.append(sum_lists(previous_value, slowest_table[i - 1]))
+ else:
+ result.append(sum_lists(previous_value, fastest_table[j - 1]))
+ else:
+ if i > 0:
+ prev_line_idx = (i - 1) * fastest_size # numero de ligne precedent
+ previous_value = result[prev_line_idx]
+ if zincreasing_downward:
+ result.append(sum_lists(previous_value, fastest_table[j - 1]))
+ else:
+ result.append(sum_lists(previous_value, slowest_table[i - 1]))
+ else:
+ result.append(previous_value)
+ else:
+ raise Exception(f"{type(energyml_array)} read with an offset of length {len(offset)} is not supported")
+
+ return result
+def read_point3d_zvalue_array(energyml_array: Any, root_obj: Optional[Any] = None, path_in_root: Optional[str] = None, epc: Optional[Epc] = None)
+Read a Point3D2ValueArray +:param energyml_array: +:param root_obj: +:param path_in_root: +:param epc: +:return:
def read_point3d_zvalue_array(
+ energyml_array: Any,
+ root_obj: Optional[Any] = None,
+ path_in_root: Optional[str] = None,
+ epc: Optional[Epc] = None
+):
+ """
+ Read a Point3D2ValueArray
+ :param energyml_array:
+ :param root_obj:
+ :param path_in_root:
+ :param epc:
+ :return:
+ """
+ supporting_geometry = get_object_attribute_no_verif(energyml_array, "supporting_geometry")
+ sup_geom_array = read_array(
+ energyml_array=supporting_geometry,
+ root_obj=root_obj,
+ path_in_root=path_in_root + ".SupportingGeometry",
+ epc=epc,
+ )
+
+ zvalues = get_object_attribute_no_verif(energyml_array, "zvalues")
+ zvalues_array = flatten_concatenation(read_array(
+ energyml_array=zvalues,
+ root_obj=root_obj,
+ path_in_root=path_in_root + ".ZValues",
+ epc=epc,
+ ))
+
+ count = 0
+
+ for i in range(len(sup_geom_array)):
+ try:
+ sup_geom_array[i][2] = zvalues_array[i]
+ except Exception as e:
+ if count == 0:
+ print(e, f": {i} is out of bound of {len(zvalues_array)}")
+ count = count + 1
+
+ return sup_geom_array
+def read_xml_array(energyml_array: Any, root_obj: Optional[Any] = None, path_in_root: Optional[str] = None, epc: Optional[Epc] = None) ‑> List[Any]
+Read a xml array ( BooleanXmlArray, FloatingPointXmlArray, IntegerXmlArray, StringXmlArray …) +:param energyml_array: +:param root_obj: +:param path_in_root: +:param epc: +:return:
def read_xml_array(
+ energyml_array: Any,
+ root_obj: Optional[Any] = None,
+ path_in_root: Optional[str] = None,
+ epc: Optional[Epc] = None
+) -> List[Any]:
+ """
+ Read a xml array ( BooleanXmlArray, FloatingPointXmlArray, IntegerXmlArray, StringXmlArray ...)
+ :param energyml_array:
+ :param root_obj:
+ :param path_in_root:
+ :param epc:
+ :return:
+ """
+ values = get_object_attribute_no_verif(energyml_array, "values")
+ # count = get_object_attribute_no_verif(energyml_array, "count_per_value")
+ return values
+def sum_lists(l1: List, l2: List)
+Sums 2 lists values.
+[1,1,1] and [2,2,3,6] gives : [3,3,4,6]
+:param l1: +:param l2: +:return:
def sum_lists(l1: List, l2: List):
+ """
+ Sums 2 lists values.
+
+ Example:
+ [1,1,1] and [2,2,3,6] gives : [3,3,4,6]
+
+ :param l1:
+ :param l2:
+ :return:
+ """
+ return [l1[i] + l2[i] for i in range(min(len(l1), len(l2)))]+max(l1, l2, key=len)[min(len(l1), len(l2)):]src.energyml.utils.dataThe data module.
+Contains functions to help the read of specific entities like Grid2DRepresentation, TriangulatedSetRepresentation etc. +It also contains functions to export data into OFF/OBJ format.
+# Copyright (c) 2023-2024 Geosiris.
+# SPDX-License-Identifier: Apache-2.0
+"""
+The data module.
+
+Contains functions to help the read of specific entities like Grid2DRepresentation, TriangulatedSetRepresentation etc.
+It also contains functions to export data into OFF/OBJ format.
+"""src.energyml.utils.data.hdfsrc.energyml.utils.data.helpersrc.energyml.utils.data.meshsrc.energyml.utils.data.mesh# Copyright (c) 2023-2024 Geosiris.
+# SPDX-License-Identifier: Apache-2.0
+import inspect
+import re
+import sys
+from dataclasses import dataclass, field
+from io import BytesIO
+from typing import List, Optional, Any, Callable
+
+from .hdf import get_hdf_reference_with_path, \
+ get_hdf5_path_from_external_path, HDF5FileReader, get_crs_obj
+from .helper import read_array, read_grid2d_patch, is_z_reversed
+from ..epc import Epc, get_obj_identifier
+from ..introspection import search_attribute_matching_name, \
+ search_attribute_matching_type_with_path, \
+ search_attribute_matching_name_with_path, snake_case
+
+_FILE_HEADER: bytes = b"# file exported by energyml-utils python module (Geosiris)\n"
+
+Point = list[float]
+
+
+@dataclass
+class AbstractMesh:
+ energyml_object: Any = field(
+ default=None
+ )
+
+ crs_object: Any = field(
+ default=None
+ )
+
+ point_list: List[Point] = field(
+ default_factory=list,
+ )
+
+ identifier: str = field(
+ default=None,
+ )
+
+ def export_off(self, out: BytesIO) -> None:
+ pass
+
+ def get_nb_edges(self) -> int:
+ return 0
+
+ def get_nb_faces(self) -> int:
+ return 0
+
+ def get_indices(self) -> List[List[int]]:
+ return []
+
+
+@dataclass
+class PointSetMesh(AbstractMesh):
+ pass
+
+
+@dataclass
+class PolylineSetMesh(AbstractMesh):
+ line_indices: List[List[int]] = field(
+ default_factory=list,
+ )
+
+ def get_nb_edges(self) -> int:
+ return sum(list(map(lambda li: len(li) - 1, self.line_indices)))
+
+ def get_nb_faces(self) -> int:
+ return 0
+
+ def get_indices(self) -> List[List[int]]:
+ return self.line_indices
+
+
+@dataclass
+class SurfaceMesh(AbstractMesh):
+ faces_indices: List[List[int]] = field(
+ default_factory=list,
+ )
+
+ def get_nb_edges(self) -> int:
+ return sum(list(map(lambda li: len(li) - 1, self.faces_indices)))
+
+ def get_nb_faces(self) -> int:
+ return len(self.faces_indices)
+
+ def get_indices(self) -> List[List[int]]:
+ return self.faces_indices
+
+
+def get_mesh_reader_function(mesh_type_name: str) -> Optional[Callable]:
+ """
+ Returns the name of the potential appropriate function to read an object with type is named mesh_type_name
+ :param mesh_type_name: the initial type name
+ :return:
+ """
+ for name, obj in inspect.getmembers(sys.modules[__name__]):
+ if name == f"read_{snake_case(mesh_type_name)}":
+ return obj
+ return None
+
+
+def _mesh_name_mapping(array_type_name: str) -> str:
+ """
+ Transform the type name to match existing reader function
+ :param array_type_name:
+ :return:
+ """
+ array_type_name = array_type_name.replace("3D", "3d").replace("2D", "2d")
+ array_type_name = re.sub("^[Oo]bj([A-Z])", r"\1", array_type_name)
+ return array_type_name
+
+
+def read_mesh_object(
+ energyml_object: Any,
+ epc: Optional[Epc] = None
+) -> List[AbstractMesh]:
+ """
+ Read and "meshable" object. If :param:`energyml_object` is not supported, an exception will be raised.
+ :param energyml_object:
+ :param epc:
+ :return:
+ """
+ if isinstance(energyml_object, list):
+ return energyml_object
+ array_type_name = _mesh_name_mapping(type(energyml_object).__name__)
+
+ reader_func = get_mesh_reader_function(array_type_name)
+ if reader_func is not None:
+ return reader_func(
+ energyml_object=energyml_object,
+ epc=epc,
+ )
+ else:
+ print(f"Type {array_type_name} is not supported: function read_{snake_case(array_type_name)} not found")
+ raise Exception(f"Type {array_type_name} is not supported\n\t{energyml_object}: \n\tfunction read_{snake_case(array_type_name)} not found")
+
+
+def read_point_set_representation(energyml_object: Any, epc: Epc) -> List[PointSetMesh]:
+ # pt_geoms = search_attribute_matching_type(point_set, "AbstractGeometry")
+ h5_reader = HDF5FileReader()
+
+ meshes = []
+ for refer_path, refer_value in get_hdf_reference_with_path(energyml_object):
+ try:
+ hdf5_path = get_hdf5_path_from_external_path(
+ external_path_obj=refer_value,
+ path_in_root=refer_path,
+ root_obj=energyml_object,
+ epc=epc,
+ )
+ crs = get_crs_obj(
+ context_obj=refer_value,
+ path_in_root=refer_path,
+ root_obj=energyml_object,
+ epc=epc,
+ )
+ if hdf5_path is not None:
+ print(f"Reading h5 file : {hdf5_path}")
+ meshes.append(PointSetMesh(
+ identifier=refer_value,
+ energyml_object=energyml_object,
+ crs_object=crs,
+ point_list=h5_reader.read_array(hdf5_path, refer_value)
+ ))
+ except Exception as e:
+ print(f"Error with path {refer_path} -- {energyml_object}")
+ raise e
+ return meshes
+
+
+def read_polyline_set_representation(energyml_object: Any, epc: Epc) -> List[PointSetMesh]:
+ # pt_geoms = search_attribute_matching_type(point_set, "AbstractGeometry")
+ h5_reader = HDF5FileReader()
+
+ meshes = []
+
+ patch_idx = 0
+ for path_path_in_obj, patch in search_attribute_matching_name_with_path(energyml_object, "LinePatch"):
+ print(f"patch {patch}")
+ geometry_path_in_obj, geometry = search_attribute_matching_name_with_path(patch, "geometry")[0]
+ node_count_per_poly_path_in_obj, node_count_per_poly = \
+ search_attribute_matching_name_with_path(patch, "NodeCountPerPolyline")[0]
+ points_ext_array = search_attribute_matching_type_with_path(geometry, "ExternalDataArrayPart|Hdf5Dataset")
+ node_count_ext_array = search_attribute_matching_type_with_path(node_count_per_poly,
+ "ExternalDataArrayPart|Hdf5Dataset")
+
+ if len(points_ext_array) > 0:
+ point_per_elt = []
+ point_indices = []
+ crs = None
+
+ # Reading points
+ for patch_part_path, patchPart_value in points_ext_array:
+ patch_part_full_path_in_obj = path_path_in_obj + geometry_path_in_obj + patch_part_path
+ for refer_path, refer_value in get_hdf_reference_with_path(patchPart_value):
+ print(f"refer_path {patch_part_full_path_in_obj}{refer_path} refer_value{refer_value} ")
+ hdf5_path = get_hdf5_path_from_external_path(
+ external_path_obj=refer_value,
+ path_in_root=patch_part_full_path_in_obj + refer_path,
+ root_obj=energyml_object,
+ epc=epc,
+ )
+ crs = get_crs_obj(
+ context_obj=refer_value,
+ path_in_root=patch_part_full_path_in_obj + refer_path,
+ root_obj=energyml_object,
+ epc=epc,
+ )
+ if hdf5_path is not None:
+ print(f"Reading h5 file : {hdf5_path}")
+ point_per_elt = point_per_elt + h5_reader.read_array(hdf5_path, refer_value)
+
+ # Reading polyline indices
+ # for patch_part_path, patchPart_value in node_count_ext_array:
+ # patch_part_full_path_in_obj = path_path_in_obj + node_count_per_poly_path_in_obj + patch_part_path
+ # for refer_path, refer_value in get_hdf_reference_with_path(patchPart_value):
+ # print(f"refer_path: {patch_part_full_path_in_obj}{refer_path} refer_value: {refer_value} ")
+ # hdf5_path = get_hdf5_path_from_external_path(
+ # external_path_obj=refer_value,
+ # path_in_root=patch_part_full_path_in_obj + refer_path,
+ # root_obj=energyml_object,
+ # epc=epc,
+ # )
+ # if hdf5_path is not None:
+ # node_counts_list = h5_reader.read_array(hdf5_path, refer_value)
+ # idx = 0
+ # for nb_node in node_counts_list:
+ # point_indices.append([x for x in range(idx, idx + nb_node)])
+ # idx = idx + nb_node
+
+ node_counts_list = read_array(
+ energyml_array=node_count_per_poly,
+ root_obj=energyml_object,
+ path_in_root=path_path_in_obj + node_count_per_poly_path_in_obj,
+ epc=epc,
+ )
+ idx = 0
+ for nb_node in node_counts_list:
+ point_indices.append([x for x in range(idx, idx + nb_node)])
+ idx = idx + nb_node
+
+ if len(point_per_elt) > 0:
+ # poly_idx = 0
+ # for single_poly_indices in point_indices:
+ meshes.append(PolylineSetMesh(
+ # identifier=f"{get_obj_identifier(energyml_object)}_patch{patch_idx}_poly{poly_idx}",
+ identifier=f"{get_obj_identifier(energyml_object)}_patch{patch_idx}",
+ energyml_object=energyml_object,
+ crs_object=crs,
+ point_list=point_per_elt,
+ line_indices=point_indices
+ ))
+ # poly_idx = poly_idx + 1
+ patch_idx = patch_idx + 1
+
+ return meshes
+
+
+def read_grid2d_representation(energyml_object: Any, epc: Epc, keep_holes=False) -> List[SurfaceMesh]:
+ # h5_reader = HDF5FileReader()
+ meshes = []
+
+ patch_idx = 0
+ for patch_path, patch in search_attribute_matching_name_with_path(energyml_object, "Grid2dPatch"):
+ crs = get_crs_obj(
+ context_obj=patch,
+ path_in_root=patch_path,
+ root_obj=energyml_object,
+ epc=epc,
+ )
+
+ reverse_z_values = is_z_reversed(crs)
+
+ points = read_grid2d_patch(
+ patch=patch,
+ grid2d=energyml_object,
+ path_in_root=patch_path,
+ epc=epc,
+ )
+
+ fa_count = search_attribute_matching_name(patch, "FastestAxisCount")
+ if fa_count is None:
+ fa_count = search_attribute_matching_name(energyml_object, "FastestAxisCount")
+
+ sa_count = search_attribute_matching_name(patch, "SlowestAxisCount")
+ if sa_count is None:
+ sa_count = search_attribute_matching_name(energyml_object, "SlowestAxisCount")
+
+ fa_count = fa_count[0]
+ sa_count = sa_count[0]
+
+ print(f"sa_count {sa_count} fa_count {fa_count}")
+
+ points_no_nan = []
+
+ indice_to_final_indice = {}
+ if keep_holes:
+ for i in range(len(points)):
+ p = points[i]
+ if p[2] != p[2]: # a NaN
+ points[i][2] = 0
+ elif reverse_z_values:
+ points[i][2] = - points[i][2]
+ else:
+ for i in range(len(points)):
+ p = points[i]
+ if p[2] == p[2]: # not a NaN
+ if reverse_z_values:
+ points[i][2] = - points[i][2]
+ indice_to_final_indice[i] = len(points_no_nan)
+ points_no_nan.append(p)
+
+ indices = []
+
+ while sa_count*fa_count > len(points):
+ sa_count = sa_count - 1
+ fa_count = fa_count - 1
+
+ while sa_count*fa_count < len(points):
+ sa_count = sa_count + 1
+ fa_count = fa_count + 1
+
+ print(f"sa_count {sa_count} fa_count {fa_count} : {sa_count*fa_count} - {len(points)} ")
+
+ for sa in range(sa_count-1):
+ for fa in range(fa_count-1):
+ line = sa * fa_count
+ if sa+1 == int(sa_count / 2) and fa == int(fa_count / 2):
+ print(
+ "\n\t", (line + fa), " : ", (line + fa) in indice_to_final_indice,
+ "\n\t", (line + fa + 1), " : ", (line + fa + 1) in indice_to_final_indice,
+ "\n\t", (line + fa_count + fa + 1), " : ", (line + fa_count + fa + 1) in indice_to_final_indice,
+ "\n\t", (line + fa_count + fa), " : ", (line + fa_count + fa) in indice_to_final_indice,
+ )
+ if keep_holes:
+ indices.append(
+ [
+ line + fa,
+ line + fa + 1,
+ line + fa_count + fa + 1,
+ line + fa_count + fa,
+ ]
+ )
+ elif (
+ (line + fa) in indice_to_final_indice
+ and (line + fa + 1) in indice_to_final_indice
+ and (line + fa_count + fa + 1) in indice_to_final_indice
+ and (line + fa_count + fa) in indice_to_final_indice
+ ):
+ indices.append(
+ [
+ indice_to_final_indice[line + fa],
+ indice_to_final_indice[line + fa + 1],
+ indice_to_final_indice[line + fa_count + fa + 1],
+ indice_to_final_indice[line + fa_count + fa],
+ ]
+ )
+ # print(indices)
+ meshes.append(SurfaceMesh(
+ identifier=f"{get_obj_identifier(energyml_object)}_patch{patch_idx}",
+ energyml_object=energyml_object,
+ crs_object=None,
+ point_list=points if keep_holes else points_no_nan,
+ faces_indices=indices
+ ))
+ patch_idx = patch_idx + 1
+
+ return meshes
+
+
+def read_triangulated_set_representation(energyml_object: Any, epc: Epc) -> List[SurfaceMesh]:
+ meshes = []
+
+ point_offset = 0
+ patch_idx = 0
+ for patch_path, patch in search_attribute_matching_name_with_path(energyml_object, "\\.*Patch"):
+ crs = get_crs_obj(
+ context_obj=patch,
+ path_in_root=patch_path,
+ root_obj=energyml_object,
+ epc=epc,
+ )
+
+ point_list: List[Point] = []
+ for point_path, point_obj in search_attribute_matching_name_with_path(patch, "Geometry.Points"):
+ point_list = point_list + read_array(
+ energyml_array=point_obj,
+ root_obj=energyml_object,
+ path_in_root=patch_path + point_path,
+ epc=epc,
+ )
+
+ triangles_list: List[List[int]] = []
+ for triangles_path, triangles_obj in search_attribute_matching_name_with_path(patch, "Triangles"):
+ triangles_list = triangles_list + read_array(
+ energyml_array=triangles_obj,
+ root_obj=energyml_object,
+ path_in_root=patch_path + triangles_path,
+ epc=epc,
+ )
+ triangles_list = list(map(lambda tr: [ti - point_offset for ti in tr], triangles_list))
+ meshes.append(SurfaceMesh(
+ identifier=f"{get_obj_identifier(energyml_object)}_patch{patch_idx}",
+ energyml_object=energyml_object,
+ crs_object=crs,
+ point_list=point_list,
+ faces_indices=triangles_list
+ ))
+
+ point_offset = point_offset + len(point_list)
+
+ return meshes
+
+
+# MESH FILES
+
+
+def export_off(mesh_list: List[AbstractMesh], out: BytesIO):
+ """
+ Export an :class:`AbstractMesh` into off format.
+ :param mesh_list:
+ :param out:
+ :return:
+ """
+ nb_points = sum(list(map(lambda m: len(m.point_list), mesh_list)))
+ nb_edges = sum(list(map(lambda m: m.get_nb_edges(), mesh_list)))
+ nb_faces = sum(list(map(lambda m: m.get_nb_faces(), mesh_list)))
+
+ out.write(b"OFF\n")
+ out.write(_FILE_HEADER)
+ out.write(f"{nb_points} {nb_faces} {nb_edges}\n".encode('utf-8'))
+
+ points_io = BytesIO()
+ faces_io = BytesIO()
+
+ point_offset = 0
+ for m in mesh_list:
+ export_off_part(
+ off_point_part=points_io,
+ off_face_part=faces_io,
+ points=m.point_list,
+ indices=m.get_indices(),
+ point_offset=point_offset,
+ colors=[],
+ )
+ point_offset = point_offset + len(m.point_list)
+
+ out.write(points_io.getbuffer())
+ out.write(faces_io.getbuffer())
+
+
+def export_off_part(
+ off_point_part: BytesIO,
+ off_face_part: BytesIO,
+ points: List[List[float]],
+ indices: List[List[int]],
+ point_offset: Optional[int] = 0,
+ colors: Optional[List[List[int]]] = None
+) -> None:
+ for p in points:
+ for pi in p:
+ off_point_part.write(f"{pi} ".encode('utf-8'))
+ off_point_part.write(b"\n")
+
+ cpt = 0
+ for face in indices:
+ if len(face) > 1:
+ off_face_part.write(f"{len(face)} ".encode('utf-8'))
+ for pi in face:
+ off_face_part.write(f"{pi + point_offset} ".encode('utf-8'))
+
+ if colors is not None and len(colors) > cpt and colors[cpt] is not None and len(colors[cpt]) > 0:
+ for col in colors[cpt]:
+ off_face_part.write(f"{col} ".encode('utf-8'))
+
+ off_face_part.write(b"\n")
+
+
+def export_obj(mesh_list: List[AbstractMesh], out: BytesIO, obj_name: Optional[str] = None):
+ """
+ Export an :class:`AbstractMesh` into obj format.
+
+ Each AbstractMesh from the list :param:`mesh_list` will be placed into its own group.
+ :param mesh_list:
+ :param out:
+ :param obj_name:
+ :return:
+ """
+ out.write(f"# Generated by energyml-utils a Geosiris python module\n\n".encode('utf-8'))
+
+ if obj_name is not None:
+ out.write(f"o {obj_name}\n\n".encode('utf-8'))
+
+ point_offset = 0
+ for m in mesh_list:
+ out.write(f"g {m.identifier}\n\n".encode('utf-8'))
+ _export_obj_elt(
+ off_point_part=out,
+ off_face_part=out,
+ points=m.point_list,
+ indices=m.get_indices(),
+ point_offset=point_offset,
+ colors=[],
+ elt_letter="l" if isinstance(m, PolylineSetMesh) else "f"
+ )
+ point_offset = point_offset + len(m.point_list)
+ out.write("\n".encode('utf-8'))
+
+
+def _export_obj_elt(
+ off_point_part: BytesIO,
+ off_face_part: BytesIO,
+ points: List[List[float]],
+ indices: List[List[int]],
+ point_offset: Optional[int] = 0,
+ colors: Optional[List[List[int]]] = None,
+ elt_letter: str = "f",
+) -> None:
+ """
+
+ :param off_point_part:
+ :param off_face_part:
+ :param points:
+ :param indices:
+ :param point_offset:
+ :param colors: currently not supported
+ :param elt_letter: "l" for line and "f" for faces
+ :return:
+ """
+ offset_obj = 1 # OBJ point indices starts at 1 not 0
+ for p in points:
+ if len(p) > 0:
+ off_point_part.write(f"v {' '.join(list(map(lambda xyz: str(xyz), p)))}\n".encode('utf-8'))
+
+ # cpt = 0
+ for face in indices:
+ if len(face) > 1:
+ # off_face_part.write(f"{elt_letter} ".encode('utf-8'))
+ # for pi in face:
+ # off_face_part.write(f"{pi + point_offset} ".encode('utf-8'))
+ off_point_part.write(
+ f"{elt_letter} {' '.join(list(map(lambda x: str(x + point_offset + offset_obj), face)))}\n".encode(
+ 'utf-8'))
+
+ # if colors is not None and len(colors) > cpt and colors[cpt] is not None and len(colors[cpt]) > 0:
+ # for col in colors[cpt]:
+ # off_face_part.write(f"{col} ".encode('utf-8'))
+
+ # off_face_part.write(b"\n")
+def export_obj(mesh_list: List[AbstractMesh], out: _io.BytesIO, obj_name: Optional[str] = None)
+Export an :class:AbstractMesh into obj format.
Each AbstractMesh from the list :param:mesh_list will be placed into its own group.
+:param mesh_list:
+:param out:
+:param obj_name:
+:return:
def export_obj(mesh_list: List[AbstractMesh], out: BytesIO, obj_name: Optional[str] = None):
+ """
+ Export an :class:`AbstractMesh` into obj format.
+
+ Each AbstractMesh from the list :param:`mesh_list` will be placed into its own group.
+ :param mesh_list:
+ :param out:
+ :param obj_name:
+ :return:
+ """
+ out.write(f"# Generated by energyml-utils a Geosiris python module\n\n".encode('utf-8'))
+
+ if obj_name is not None:
+ out.write(f"o {obj_name}\n\n".encode('utf-8'))
+
+ point_offset = 0
+ for m in mesh_list:
+ out.write(f"g {m.identifier}\n\n".encode('utf-8'))
+ _export_obj_elt(
+ off_point_part=out,
+ off_face_part=out,
+ points=m.point_list,
+ indices=m.get_indices(),
+ point_offset=point_offset,
+ colors=[],
+ elt_letter="l" if isinstance(m, PolylineSetMesh) else "f"
+ )
+ point_offset = point_offset + len(m.point_list)
+ out.write("\n".encode('utf-8'))
+def export_off(mesh_list: List[AbstractMesh], out: _io.BytesIO)
+Export an :class:AbstractMesh into off format.
+:param mesh_list:
+:param out:
+:return:
def export_off(mesh_list: List[AbstractMesh], out: BytesIO):
+ """
+ Export an :class:`AbstractMesh` into off format.
+ :param mesh_list:
+ :param out:
+ :return:
+ """
+ nb_points = sum(list(map(lambda m: len(m.point_list), mesh_list)))
+ nb_edges = sum(list(map(lambda m: m.get_nb_edges(), mesh_list)))
+ nb_faces = sum(list(map(lambda m: m.get_nb_faces(), mesh_list)))
+
+ out.write(b"OFF\n")
+ out.write(_FILE_HEADER)
+ out.write(f"{nb_points} {nb_faces} {nb_edges}\n".encode('utf-8'))
+
+ points_io = BytesIO()
+ faces_io = BytesIO()
+
+ point_offset = 0
+ for m in mesh_list:
+ export_off_part(
+ off_point_part=points_io,
+ off_face_part=faces_io,
+ points=m.point_list,
+ indices=m.get_indices(),
+ point_offset=point_offset,
+ colors=[],
+ )
+ point_offset = point_offset + len(m.point_list)
+
+ out.write(points_io.getbuffer())
+ out.write(faces_io.getbuffer())
+def export_off_part(off_point_part: _io.BytesIO, off_face_part: _io.BytesIO, points: List[List[float]], indices: List[List[int]], point_offset: Optional[int] = 0, colors: Optional[List[List[int]]] = None) ‑> None
+def export_off_part(
+ off_point_part: BytesIO,
+ off_face_part: BytesIO,
+ points: List[List[float]],
+ indices: List[List[int]],
+ point_offset: Optional[int] = 0,
+ colors: Optional[List[List[int]]] = None
+) -> None:
+ for p in points:
+ for pi in p:
+ off_point_part.write(f"{pi} ".encode('utf-8'))
+ off_point_part.write(b"\n")
+
+ cpt = 0
+ for face in indices:
+ if len(face) > 1:
+ off_face_part.write(f"{len(face)} ".encode('utf-8'))
+ for pi in face:
+ off_face_part.write(f"{pi + point_offset} ".encode('utf-8'))
+
+ if colors is not None and len(colors) > cpt and colors[cpt] is not None and len(colors[cpt]) > 0:
+ for col in colors[cpt]:
+ off_face_part.write(f"{col} ".encode('utf-8'))
+
+ off_face_part.write(b"\n")
+def get_mesh_reader_function(mesh_type_name: str) ‑> Optional[Callable]
+Returns the name of the potential appropriate function to read an object with type is named mesh_type_name +:param mesh_type_name: the initial type name +:return:
def get_mesh_reader_function(mesh_type_name: str) -> Optional[Callable]:
+ """
+ Returns the name of the potential appropriate function to read an object with type is named mesh_type_name
+ :param mesh_type_name: the initial type name
+ :return:
+ """
+ for name, obj in inspect.getmembers(sys.modules[__name__]):
+ if name == f"read_{snake_case(mesh_type_name)}":
+ return obj
+ return None
+def read_grid2d_representation(energyml_object: Any, epc: Epc, keep_holes=False) ‑> List[SurfaceMesh]
+def read_grid2d_representation(energyml_object: Any, epc: Epc, keep_holes=False) -> List[SurfaceMesh]:
+ # h5_reader = HDF5FileReader()
+ meshes = []
+
+ patch_idx = 0
+ for patch_path, patch in search_attribute_matching_name_with_path(energyml_object, "Grid2dPatch"):
+ crs = get_crs_obj(
+ context_obj=patch,
+ path_in_root=patch_path,
+ root_obj=energyml_object,
+ epc=epc,
+ )
+
+ reverse_z_values = is_z_reversed(crs)
+
+ points = read_grid2d_patch(
+ patch=patch,
+ grid2d=energyml_object,
+ path_in_root=patch_path,
+ epc=epc,
+ )
+
+ fa_count = search_attribute_matching_name(patch, "FastestAxisCount")
+ if fa_count is None:
+ fa_count = search_attribute_matching_name(energyml_object, "FastestAxisCount")
+
+ sa_count = search_attribute_matching_name(patch, "SlowestAxisCount")
+ if sa_count is None:
+ sa_count = search_attribute_matching_name(energyml_object, "SlowestAxisCount")
+
+ fa_count = fa_count[0]
+ sa_count = sa_count[0]
+
+ print(f"sa_count {sa_count} fa_count {fa_count}")
+
+ points_no_nan = []
+
+ indice_to_final_indice = {}
+ if keep_holes:
+ for i in range(len(points)):
+ p = points[i]
+ if p[2] != p[2]: # a NaN
+ points[i][2] = 0
+ elif reverse_z_values:
+ points[i][2] = - points[i][2]
+ else:
+ for i in range(len(points)):
+ p = points[i]
+ if p[2] == p[2]: # not a NaN
+ if reverse_z_values:
+ points[i][2] = - points[i][2]
+ indice_to_final_indice[i] = len(points_no_nan)
+ points_no_nan.append(p)
+
+ indices = []
+
+ while sa_count*fa_count > len(points):
+ sa_count = sa_count - 1
+ fa_count = fa_count - 1
+
+ while sa_count*fa_count < len(points):
+ sa_count = sa_count + 1
+ fa_count = fa_count + 1
+
+ print(f"sa_count {sa_count} fa_count {fa_count} : {sa_count*fa_count} - {len(points)} ")
+
+ for sa in range(sa_count-1):
+ for fa in range(fa_count-1):
+ line = sa * fa_count
+ if sa+1 == int(sa_count / 2) and fa == int(fa_count / 2):
+ print(
+ "\n\t", (line + fa), " : ", (line + fa) in indice_to_final_indice,
+ "\n\t", (line + fa + 1), " : ", (line + fa + 1) in indice_to_final_indice,
+ "\n\t", (line + fa_count + fa + 1), " : ", (line + fa_count + fa + 1) in indice_to_final_indice,
+ "\n\t", (line + fa_count + fa), " : ", (line + fa_count + fa) in indice_to_final_indice,
+ )
+ if keep_holes:
+ indices.append(
+ [
+ line + fa,
+ line + fa + 1,
+ line + fa_count + fa + 1,
+ line + fa_count + fa,
+ ]
+ )
+ elif (
+ (line + fa) in indice_to_final_indice
+ and (line + fa + 1) in indice_to_final_indice
+ and (line + fa_count + fa + 1) in indice_to_final_indice
+ and (line + fa_count + fa) in indice_to_final_indice
+ ):
+ indices.append(
+ [
+ indice_to_final_indice[line + fa],
+ indice_to_final_indice[line + fa + 1],
+ indice_to_final_indice[line + fa_count + fa + 1],
+ indice_to_final_indice[line + fa_count + fa],
+ ]
+ )
+ # print(indices)
+ meshes.append(SurfaceMesh(
+ identifier=f"{get_obj_identifier(energyml_object)}_patch{patch_idx}",
+ energyml_object=energyml_object,
+ crs_object=None,
+ point_list=points if keep_holes else points_no_nan,
+ faces_indices=indices
+ ))
+ patch_idx = patch_idx + 1
+
+ return meshes
+def read_mesh_object(energyml_object: Any, epc: Optional[Epc] = None) ‑> List[AbstractMesh]
+Read and "meshable" object. If :param:energyml_object is not supported, an exception will be raised.
+:param energyml_object:
+:param epc:
+:return:
def read_mesh_object(
+ energyml_object: Any,
+ epc: Optional[Epc] = None
+) -> List[AbstractMesh]:
+ """
+ Read and "meshable" object. If :param:`energyml_object` is not supported, an exception will be raised.
+ :param energyml_object:
+ :param epc:
+ :return:
+ """
+ if isinstance(energyml_object, list):
+ return energyml_object
+ array_type_name = _mesh_name_mapping(type(energyml_object).__name__)
+
+ reader_func = get_mesh_reader_function(array_type_name)
+ if reader_func is not None:
+ return reader_func(
+ energyml_object=energyml_object,
+ epc=epc,
+ )
+ else:
+ print(f"Type {array_type_name} is not supported: function read_{snake_case(array_type_name)} not found")
+ raise Exception(f"Type {array_type_name} is not supported\n\t{energyml_object}: \n\tfunction read_{snake_case(array_type_name)} not found")
+def read_point_set_representation(energyml_object: Any, epc: Epc) ‑> List[PointSetMesh]
+def read_point_set_representation(energyml_object: Any, epc: Epc) -> List[PointSetMesh]:
+ # pt_geoms = search_attribute_matching_type(point_set, "AbstractGeometry")
+ h5_reader = HDF5FileReader()
+
+ meshes = []
+ for refer_path, refer_value in get_hdf_reference_with_path(energyml_object):
+ try:
+ hdf5_path = get_hdf5_path_from_external_path(
+ external_path_obj=refer_value,
+ path_in_root=refer_path,
+ root_obj=energyml_object,
+ epc=epc,
+ )
+ crs = get_crs_obj(
+ context_obj=refer_value,
+ path_in_root=refer_path,
+ root_obj=energyml_object,
+ epc=epc,
+ )
+ if hdf5_path is not None:
+ print(f"Reading h5 file : {hdf5_path}")
+ meshes.append(PointSetMesh(
+ identifier=refer_value,
+ energyml_object=energyml_object,
+ crs_object=crs,
+ point_list=h5_reader.read_array(hdf5_path, refer_value)
+ ))
+ except Exception as e:
+ print(f"Error with path {refer_path} -- {energyml_object}")
+ raise e
+ return meshes
+def read_polyline_set_representation(energyml_object: Any, epc: Epc) ‑> List[PointSetMesh]
+def read_polyline_set_representation(energyml_object: Any, epc: Epc) -> List[PointSetMesh]:
+ # pt_geoms = search_attribute_matching_type(point_set, "AbstractGeometry")
+ h5_reader = HDF5FileReader()
+
+ meshes = []
+
+ patch_idx = 0
+ for path_path_in_obj, patch in search_attribute_matching_name_with_path(energyml_object, "LinePatch"):
+ print(f"patch {patch}")
+ geometry_path_in_obj, geometry = search_attribute_matching_name_with_path(patch, "geometry")[0]
+ node_count_per_poly_path_in_obj, node_count_per_poly = \
+ search_attribute_matching_name_with_path(patch, "NodeCountPerPolyline")[0]
+ points_ext_array = search_attribute_matching_type_with_path(geometry, "ExternalDataArrayPart|Hdf5Dataset")
+ node_count_ext_array = search_attribute_matching_type_with_path(node_count_per_poly,
+ "ExternalDataArrayPart|Hdf5Dataset")
+
+ if len(points_ext_array) > 0:
+ point_per_elt = []
+ point_indices = []
+ crs = None
+
+ # Reading points
+ for patch_part_path, patchPart_value in points_ext_array:
+ patch_part_full_path_in_obj = path_path_in_obj + geometry_path_in_obj + patch_part_path
+ for refer_path, refer_value in get_hdf_reference_with_path(patchPart_value):
+ print(f"refer_path {patch_part_full_path_in_obj}{refer_path} refer_value{refer_value} ")
+ hdf5_path = get_hdf5_path_from_external_path(
+ external_path_obj=refer_value,
+ path_in_root=patch_part_full_path_in_obj + refer_path,
+ root_obj=energyml_object,
+ epc=epc,
+ )
+ crs = get_crs_obj(
+ context_obj=refer_value,
+ path_in_root=patch_part_full_path_in_obj + refer_path,
+ root_obj=energyml_object,
+ epc=epc,
+ )
+ if hdf5_path is not None:
+ print(f"Reading h5 file : {hdf5_path}")
+ point_per_elt = point_per_elt + h5_reader.read_array(hdf5_path, refer_value)
+
+ # Reading polyline indices
+ # for patch_part_path, patchPart_value in node_count_ext_array:
+ # patch_part_full_path_in_obj = path_path_in_obj + node_count_per_poly_path_in_obj + patch_part_path
+ # for refer_path, refer_value in get_hdf_reference_with_path(patchPart_value):
+ # print(f"refer_path: {patch_part_full_path_in_obj}{refer_path} refer_value: {refer_value} ")
+ # hdf5_path = get_hdf5_path_from_external_path(
+ # external_path_obj=refer_value,
+ # path_in_root=patch_part_full_path_in_obj + refer_path,
+ # root_obj=energyml_object,
+ # epc=epc,
+ # )
+ # if hdf5_path is not None:
+ # node_counts_list = h5_reader.read_array(hdf5_path, refer_value)
+ # idx = 0
+ # for nb_node in node_counts_list:
+ # point_indices.append([x for x in range(idx, idx + nb_node)])
+ # idx = idx + nb_node
+
+ node_counts_list = read_array(
+ energyml_array=node_count_per_poly,
+ root_obj=energyml_object,
+ path_in_root=path_path_in_obj + node_count_per_poly_path_in_obj,
+ epc=epc,
+ )
+ idx = 0
+ for nb_node in node_counts_list:
+ point_indices.append([x for x in range(idx, idx + nb_node)])
+ idx = idx + nb_node
+
+ if len(point_per_elt) > 0:
+ # poly_idx = 0
+ # for single_poly_indices in point_indices:
+ meshes.append(PolylineSetMesh(
+ # identifier=f"{get_obj_identifier(energyml_object)}_patch{patch_idx}_poly{poly_idx}",
+ identifier=f"{get_obj_identifier(energyml_object)}_patch{patch_idx}",
+ energyml_object=energyml_object,
+ crs_object=crs,
+ point_list=point_per_elt,
+ line_indices=point_indices
+ ))
+ # poly_idx = poly_idx + 1
+ patch_idx = patch_idx + 1
+
+ return meshes
+def read_triangulated_set_representation(energyml_object: Any, epc: Epc) ‑> List[SurfaceMesh]
+def read_triangulated_set_representation(energyml_object: Any, epc: Epc) -> List[SurfaceMesh]:
+ meshes = []
+
+ point_offset = 0
+ patch_idx = 0
+ for patch_path, patch in search_attribute_matching_name_with_path(energyml_object, "\\.*Patch"):
+ crs = get_crs_obj(
+ context_obj=patch,
+ path_in_root=patch_path,
+ root_obj=energyml_object,
+ epc=epc,
+ )
+
+ point_list: List[Point] = []
+ for point_path, point_obj in search_attribute_matching_name_with_path(patch, "Geometry.Points"):
+ point_list = point_list + read_array(
+ energyml_array=point_obj,
+ root_obj=energyml_object,
+ path_in_root=patch_path + point_path,
+ epc=epc,
+ )
+
+ triangles_list: List[List[int]] = []
+ for triangles_path, triangles_obj in search_attribute_matching_name_with_path(patch, "Triangles"):
+ triangles_list = triangles_list + read_array(
+ energyml_array=triangles_obj,
+ root_obj=energyml_object,
+ path_in_root=patch_path + triangles_path,
+ epc=epc,
+ )
+ triangles_list = list(map(lambda tr: [ti - point_offset for ti in tr], triangles_list))
+ meshes.append(SurfaceMesh(
+ identifier=f"{get_obj_identifier(energyml_object)}_patch{patch_idx}",
+ energyml_object=energyml_object,
+ crs_object=crs,
+ point_list=point_list,
+ faces_indices=triangles_list
+ ))
+
+ point_offset = point_offset + len(point_list)
+
+ return meshes
+class AbstractMesh
+(energyml_object: Any = None, crs_object: Any = None, point_list: List[list[float]] = <factory>, identifier: str = None)
+AbstractMesh(energyml_object: Any = None, crs_object: Any = None, point_list: List[list[float]] =
@dataclass
+class AbstractMesh:
+ energyml_object: Any = field(
+ default=None
+ )
+
+ crs_object: Any = field(
+ default=None
+ )
+
+ point_list: List[Point] = field(
+ default_factory=list,
+ )
+
+ identifier: str = field(
+ default=None,
+ )
+
+ def export_off(self, out: BytesIO) -> None:
+ pass
+
+ def get_nb_edges(self) -> int:
+ return 0
+
+ def get_nb_faces(self) -> int:
+ return 0
+
+ def get_indices(self) -> List[List[int]]:
+ return []var crs_object : Anyvar energyml_object : Anyvar identifier : strvar point_list : List[list[float]]
+def export_off(self, out: _io.BytesIO) ‑> None
+def export_off(self, out: BytesIO) -> None:
+ pass
+def get_indices(self) ‑> List[List[int]]
+def get_indices(self) -> List[List[int]]:
+ return []
+def get_nb_edges(self) ‑> int
+def get_nb_edges(self) -> int:
+ return 0
+def get_nb_faces(self) ‑> int
+def get_nb_faces(self) -> int:
+ return 0
+class PointSetMesh
+(energyml_object: Any = None, crs_object: Any = None, point_list: List[list[float]] = <factory>, identifier: str = None)
+PointSetMesh(energyml_object: Any = None, crs_object: Any = None, point_list: List[list[float]] =
@dataclass
+class PointSetMesh(AbstractMesh):
+ pass
+class PolylineSetMesh
+(energyml_object: Any = None, crs_object: Any = None, point_list: List[list[float]] = <factory>, identifier: str = None, line_indices: List[List[int]] = <factory>)
+PolylineSetMesh(energyml_object: Any = None, crs_object: Any = None, point_list: List[list[float]] =
@dataclass
+class PolylineSetMesh(AbstractMesh):
+ line_indices: List[List[int]] = field(
+ default_factory=list,
+ )
+
+ def get_nb_edges(self) -> int:
+ return sum(list(map(lambda li: len(li) - 1, self.line_indices)))
+
+ def get_nb_faces(self) -> int:
+ return 0
+
+ def get_indices(self) -> List[List[int]]:
+ return self.line_indicesvar line_indices : List[List[int]]
+def get_indices(self) ‑> List[List[int]]
+def get_indices(self) -> List[List[int]]:
+ return self.line_indices
+def get_nb_edges(self) ‑> int
+def get_nb_edges(self) -> int:
+ return sum(list(map(lambda li: len(li) - 1, self.line_indices)))
+def get_nb_faces(self) ‑> int
+def get_nb_faces(self) -> int:
+ return 0
+class SurfaceMesh
+(energyml_object: Any = None, crs_object: Any = None, point_list: List[list[float]] = <factory>, identifier: str = None, faces_indices: List[List[int]] = <factory>)
+SurfaceMesh(energyml_object: Any = None, crs_object: Any = None, point_list: List[list[float]] =
@dataclass
+class SurfaceMesh(AbstractMesh):
+ faces_indices: List[List[int]] = field(
+ default_factory=list,
+ )
+
+ def get_nb_edges(self) -> int:
+ return sum(list(map(lambda li: len(li) - 1, self.faces_indices)))
+
+ def get_nb_faces(self) -> int:
+ return len(self.faces_indices)
+
+ def get_indices(self) -> List[List[int]]:
+ return self.faces_indicesvar faces_indices : List[List[int]]
+def get_indices(self) ‑> List[List[int]]
+def get_indices(self) -> List[List[int]]:
+ return self.faces_indices
+def get_nb_edges(self) ‑> int
+def get_nb_edges(self) -> int:
+ return sum(list(map(lambda li: len(li) - 1, self.faces_indices)))
+def get_nb_faces(self) ‑> int
+def get_nb_faces(self) -> int:
+ return len(self.faces_indices)src.energyml.utils.epcThis example module shows various types of documentation available for use +with pydoc. +To generate HTML documentation for this module issue the +command:
+pydoc -w foo
+# Copyright (c) 2023-2024 Geosiris.
+# SPDX-License-Identifier: Apache-2.0
+"""
+This example module shows various types of documentation available for use
+with pydoc. To generate HTML documentation for this module issue the
+command:
+
+ pydoc -w foo
+
+"""
+
+import datetime
+import re
+import zipfile
+from dataclasses import dataclass, field
+from enum import Enum
+from io import BytesIO
+from typing import List, Any, Union, Dict, Callable, Optional, Tuple
+
+from energyml.opc.opc import CoreProperties, Relationships, Types, Default, Relationship, Override
+from xsdata.exceptions import ParserError
+from xsdata.formats.dataclass.models.generics import DerivedElement
+
+from .introspection import (
+ get_class_from_content_type,
+ get_obj_type, search_attribute_matching_type, get_obj_version, get_obj_uuid,
+ get_object_type_for_file_path_from_class, get_content_type_from_class, get_direct_dor_list
+)
+from .manager import get_class_pkg, get_class_pkg_version
+from .serialization import (
+ serialize_xml, read_energyml_xml_str, read_energyml_xml_bytes, read_energyml_xml_bytes_as_class
+)
+from .xml import is_energyml_content_type
+
+RELS_CONTENT_TYPE = "application/vnd.openxmlformats-package.core-properties+xml"
+RELS_FOLDER_NAME = "_rels"
+
+
+class NoCrsException(Exception):
+ pass
+
+
+@dataclass
+class ObjectNotFoundNotException(Exception):
+ obj_id: str = field(
+ default=None
+ )
+
+
+class EpcExportVersion(Enum):
+ """EPC export version."""
+ #: Classical export
+ CLASSIC = 1
+ #: Export with objet path sorted by package (eml/resqml/witsml/prodml)
+ EXPANDED = 2
+
+
+class EPCRelsRelationshipType(Enum):
+ #: The object in Target is the destination of the relationship.
+ DESTINATION_OBJECT = "destinationObject"
+ #: The current object is the source in the relationship with the target object.
+ SOURCE_OBJECT = "sourceObject"
+ #: The target object is a proxy object for an external data object (HDF5 file).
+ ML_TO_EXTERNAL_PART_PROXY = "mlToExternalPartProxy"
+ #: The current object is used as a proxy object by the target object.
+ EXTERNAL_PART_PROXY_TO_ML = "externalPartProxyToMl"
+ #: The target is a resource outside of the EPC package. Note that TargetMode should be "External"
+ #: for this relationship.
+ EXTERNAL_RESOURCE = "externalResource"
+ #: The object in Target is a media representation for the current object. As a guideline, media files
+ #: should be stored in a "media" folder in the ROOT of the package.
+ DestinationMedia = "destinationMedia"
+ #: The current object is a media representation for the object in Target.
+ SOURCE_MEDIA = "sourceMedia"
+ #: The target is part of a larger data object that has been chunked into several smaller files
+ CHUNKED_PART = "chunkedPart"
+ #: /!\ not in the norm
+ EXTENDED_CORE_PROPERTIES = "extended-core-properties"
+
+ def get_type(self) -> str:
+ match self:
+ case EPCRelsRelationshipType.EXTENDED_CORE_PROPERTIES:
+ return "http://schemas.f2i-consulting.com/package/2014/relationships/" + str(self.value)
+ case (
+ EPCRelsRelationshipType.CHUNKED_PART
+ | EPCRelsRelationshipType.DESTINATION_OBJECT
+ | EPCRelsRelationshipType.SOURCE_OBJECT
+ | EPCRelsRelationshipType.ML_TO_EXTERNAL_PART_PROXY
+ | EPCRelsRelationshipType.EXTERNAL_PART_PROXY_TO_ML
+ | EPCRelsRelationshipType.EXTERNAL_RESOURCE
+ | EPCRelsRelationshipType.DestinationMedia
+ | EPCRelsRelationshipType.SOURCE_MEDIA
+ | _
+ ):
+ return "http://schemas.energistics.org/package/2012/relationships/" + str(self.value)
+
+
+@dataclass
+class RawFile:
+ path: str = field(default="_")
+ content: BytesIO = field(default=None)
+
+
+@dataclass
+class Epc:
+ """
+ A class that represent an EPC file content
+ """
+ # content_type: List[str] = field(
+ # default_factory=list,
+ # )
+
+ export_version: EpcExportVersion = field(
+ default=EpcExportVersion.CLASSIC
+ )
+
+ core_props: CoreProperties = field(default=None)
+
+ """ xml files refered in the [Content_Types].xml """
+ energyml_objects: List = field(
+ default_factory=list,
+ )
+
+ """ Other files content like pdf etc """
+ raw_files: List[RawFile] = field(
+ default_factory=list,
+ )
+
+ """ A list of external files. It ca be used to link hdf5 files """
+ external_files_path: List[str] = field(
+ default_factory=list,
+ )
+
+ """
+ Additional rels for objects. Key is the object (same than in @energyml_objects) and value is a list of
+ RelationShip. This can be used to link an HDF5 to an ExternalPartReference in resqml 2.0.1
+ Key is a value returned by @get_obj_identifier
+ """
+ additional_rels: Dict[str, List[Relationship]] = field(
+ default_factory=lambda: {}
+ )
+
+ """
+ Epc file path. Used when loaded from a local file or for export
+ """
+ epc_file_path: Optional[str] = field(
+ default=None
+ )
+
+ def __str__(self):
+ return (
+ "EPC file (" + str(self.export_version) + ") "
+ + f"{len(self.energyml_objects)} energyml objects and {len(self.raw_files)} other files {[f.path for f in self.raw_files]}"
+ # + f"\n{[serialize_json(ar) for ar in self.additional_rels]}"
+ )
+
+ # EXPORT functions
+
+ def gen_opc_content_type(self) -> Types:
+ """
+ Generates a :class:`Types` instance and fill it with energyml objects :class:`Override` values
+ :return:
+ """
+ ct = Types()
+ rels_default = Default()
+ rels_default.content_type = RELS_CONTENT_TYPE
+ rels_default.extension = "rels"
+
+ ct.default = [rels_default]
+
+ ct.override = []
+ for e_obj in self.energyml_objects:
+ ct.override.append(Override(
+ content_type=get_content_type_from_class(type(e_obj)),
+ part_name=gen_energyml_object_path(e_obj, self.export_version),
+ ))
+
+ if self.core_props is not None:
+ ct.override.append(Override(
+ content_type=get_content_type_from_class(self.core_props),
+ part_name=gen_core_props_path(self.export_version),
+ ))
+
+ return ct
+
+ def export_file(self, path: Optional[str] = None) -> None:
+ """
+ Export the epc file. If :param:`path` is None, the epc 'self.epc_file_path' is used
+ :param path:
+ :return:
+ """
+ if path is None:
+ path = self.epc_file_path
+ epc_io = self.export_io()
+ with open(path, "wb") as f:
+ f.write(epc_io.getbuffer())
+
+ def export_io(self) -> BytesIO:
+ """
+ Export the epc file into a :class:`BytesIO` instance. The result is an 'in-memory' zip file.
+ :return:
+ """
+ zip_buffer = BytesIO()
+
+ with zipfile.ZipFile(zip_buffer, "a", zipfile.ZIP_DEFLATED, False) as zip_file:
+ # Energyml objects
+ for e_obj in self.energyml_objects:
+ e_path = gen_energyml_object_path(e_obj, self.export_version)
+ zip_info = zipfile.ZipInfo(filename=e_path, date_time=datetime.datetime.now().timetuple()[:6])
+ data = serialize_xml(e_obj)
+ zip_file.writestr(zip_info, data)
+
+ # Rels
+ for rels_path, rels in self.compute_rels().items():
+ zip_info = zipfile.ZipInfo(filename=rels_path, date_time=datetime.datetime.now().timetuple()[:6])
+ data = serialize_xml(rels)
+ zip_file.writestr(zip_info, data)
+
+ # CoreProps
+ if self.core_props is not None:
+ zip_info = zipfile.ZipInfo(filename=gen_core_props_path(self.export_version),
+ date_time=datetime.datetime.now().timetuple()[:6])
+ data = serialize_xml(self.core_props)
+ zip_file.writestr(zip_info, data)
+
+ # ContentType
+ zip_info = zipfile.ZipInfo(filename=get_epc_content_type_path(),
+ date_time=datetime.datetime.now().timetuple()[:6])
+ data = serialize_xml(self.gen_opc_content_type())
+ zip_file.writestr(zip_info, data)
+
+ return zip_buffer
+
+ def compute_rels(self) -> Dict[str, Relationships]:
+ """
+ Returns a dict containing for each objet, the rels xml file path as key and the RelationShips object as value
+ :return:
+ """
+ dor_relation = get_reverse_dor_list(self.energyml_objects)
+
+ # destObject
+ rels = {
+ obj_id: [
+ Relationship(
+ target=gen_energyml_object_path(target_obj, self.export_version),
+ type_value=EPCRelsRelationshipType.DESTINATION_OBJECT.get_type(),
+ id=f"_{obj_id}_{get_obj_type(target_obj)}_{get_obj_identifier(target_obj)}",
+ ) for target_obj in target_obj_list
+ ]
+ for obj_id, target_obj_list in dor_relation.items()
+ }
+ # sourceObject
+ for obj in self.energyml_objects:
+ obj_id = get_obj_identifier(obj)
+ if obj_id not in rels:
+ rels[obj_id] = []
+ for target_obj in get_direct_dor_list(obj):
+ rels[obj_id].append(Relationship(
+ target=gen_energyml_object_path(target_obj, self.export_version),
+ type_value=EPCRelsRelationshipType.SOURCE_OBJECT.get_type(),
+ id=f"_{obj_id}_{get_obj_type(target_obj)}_{get_obj_identifier(target_obj)}",
+ ))
+
+ map_obj_id_to_obj = {
+ get_obj_identifier(obj): obj
+ for obj in self.energyml_objects
+ }
+
+ obj_rels = {
+ gen_rels_path(energyml_object=map_obj_id_to_obj.get(obj_id), export_version=self.export_version): Relationships(
+ relationship=obj_rels + (self.additional_rels[obj_id] if obj_id in self.additional_rels else []),
+
+ )
+ for obj_id, obj_rels in rels.items()
+ }
+
+ # CoreProps
+ if self.core_props is not None:
+ obj_rels[gen_rels_path(self.core_props)] = Relationships(
+ relationship=[
+ Relationship(
+ target=gen_core_props_path(),
+ type_value=EPCRelsRelationshipType.EXTENDED_CORE_PROPERTIES.get_type(),
+ id="CoreProperties"
+ )
+ ]
+ )
+
+ return obj_rels
+
+ # -----------
+
+ def get_object_by_uuid(self, uuid: str) -> List[Any]:
+ """
+ Search all objects with the uuid :param:`uuid`.
+ :param uuid:
+ :return:
+ """
+ return list(filter(lambda o: get_obj_uuid(o) == uuid, self.energyml_objects))
+
+ def get_object_by_identifier(self, identifier: str) -> Optional[Any]:
+ """
+ Search an object by its identifier.
+ :param identifier: given by the function :func:`get_obj_identifier`
+ :return:
+ """
+ for o in self.energyml_objects:
+ if get_obj_identifier(o) == identifier:
+ return o
+ return None
+
+ def get_epc_file_folder(self) -> Optional[str]:
+ if self.epc_file_path is not None and len(self.epc_file_path) > 0:
+ folders_and_name = re.split(r"[\\/]", self.epc_file_path)
+ if len(folders_and_name) > 1:
+ return "/".join(folders_and_name[:-1])
+ else:
+ return ""
+ return None
+
+ # Class methods
+
+ @classmethod
+ def read_file(cls, epc_file_path: str):
+ with open(epc_file_path, "rb") as f:
+ epc = cls.read_stream(BytesIO(f.read()))
+ epc.epc_file_path = epc_file_path
+ return epc
+
+ @classmethod
+ def read_stream(cls, epc_file_io: BytesIO): # returns an Epc instance
+ """
+ :param epc_file_io:
+ :return: an :class:`EPC` instance
+ """
+ try:
+ _read_files = []
+ obj_list = []
+ raw_file_list = []
+ additional_rels = {}
+ core_props = None
+ with zipfile.ZipFile(epc_file_io, "r", zipfile.ZIP_DEFLATED) as epc_file:
+ content_type_file_name = get_epc_content_type_path()
+ content_type_info = None
+ try:
+ content_type_info = epc_file.getinfo(content_type_file_name)
+ except KeyError:
+ for info in epc_file.infolist():
+ if info.filename.lower() == content_type_file_name.lower():
+ content_type_info = info
+ break
+
+ _read_files.append(content_type_file_name)
+
+ if content_type_info is None:
+ print(f"No {content_type_file_name} file found")
+ else:
+ content_type_obj: Types = read_energyml_xml_bytes(epc_file.read(content_type_file_name))
+ path_to_obj = {}
+ for ov in content_type_obj.override:
+ ov_ct = ov.content_type
+ ov_path = ov.part_name
+ # print(ov_ct)
+ while ov_path.startswith("/") or ov_path.startswith("\\"):
+ ov_path = ov_path[1:]
+ if is_energyml_content_type(ov_ct):
+ _read_files.append(ov_path)
+ try:
+ ov_obj = read_energyml_xml_bytes_as_class(
+ epc_file.read(ov_path),
+ get_class_from_content_type(ov_ct)
+ )
+ if isinstance(ov_obj, DerivedElement):
+ ov_obj = ov_obj.value
+ path_to_obj[ov_path] = ov_obj
+ obj_list.append(ov_obj)
+ except ParserError as e:
+ print(f"Epc.@read_stream failed to parse file {ov_path} for content-type: {ov_ct} => {get_class_from_content_type(ov_ct)}")
+ raise e
+ elif get_class_from_content_type(ov_ct) == CoreProperties:
+ _read_files.append(ov_path)
+ core_props = read_energyml_xml_bytes_as_class(epc_file.read(ov_path), CoreProperties)
+
+ for f_info in epc_file.infolist():
+ if f_info.filename not in _read_files:
+ _read_files.append(f_info.filename)
+ if not f_info.filename.lower().endswith(".rels"):
+ try:
+ raw_file_list.append(
+ RawFile(
+ path=f_info.filename,
+ content=BytesIO(epc_file.read(f_info.filename)),
+ )
+ )
+ except IOError as e:
+ print(e)
+ else: # rels
+ # print(f"reading rels {f_info.filename}")
+ rels_folder, rels_file_name = get_file_folder_and_name_from_path(f_info.filename)
+ while rels_folder.endswith("/"):
+ rels_folder = rels_folder[:-1]
+ obj_folder = rels_folder[:rels_folder.rindex("/") + 1] if "/" in rels_folder else ""
+ obj_file_name = rels_file_name[:-5] # removing the ".rels"
+ rels_file: Relationships = read_energyml_xml_bytes_as_class(
+ epc_file.read(f_info.filename),
+ Relationships
+ )
+ obj_path = obj_folder + obj_file_name
+ if obj_path in path_to_obj:
+ try:
+ additional_rels_key = get_obj_identifier(path_to_obj[obj_path])
+ for rel in rels_file.relationship:
+ # print(f"\t\t{rel.type_value}")
+ if (rel.type_value != EPCRelsRelationshipType.DESTINATION_OBJECT.get_type()
+ and rel.type_value != EPCRelsRelationshipType.SOURCE_OBJECT.get_type()
+ and rel.type_value != EPCRelsRelationshipType.EXTENDED_CORE_PROPERTIES.get_type()
+ ): # not a computable relation
+ if additional_rels_key not in additional_rels:
+ additional_rels[additional_rels_key] = []
+ additional_rels[additional_rels_key].append(rel)
+ except Exception as e:
+ print(f"Error with obj path {obj_path} {path_to_obj[obj_path]}")
+ raise e
+ else:
+ print(f"xml file {obj_path} not found in EPC (rels is not associate to any object)")
+
+ return Epc(energyml_objects=obj_list,
+ raw_files=raw_file_list,
+ core_props=core_props,
+ additional_rels=additional_rels
+ )
+ except zipfile.BadZipFile as error:
+ print(error)
+
+ return None
+
+
+# ______ __ ____ __ _
+# / ____/___ ___ _________ ___ ______ ___ / / / __/_ ______ _____/ /_(_)___ ____ _____
+# / __/ / __ \/ _ \/ ___/ __ `/ / / / __ `__ \/ / / /_/ / / / __ \/ ___/ __/ / __ \/ __ \/ ___/
+# / /___/ / / / __/ / / /_/ / /_/ / / / / / / / / __/ /_/ / / / / /__/ /_/ / /_/ / / / (__ )
+# /_____/_/ /_/\___/_/ \__, /\__, /_/ /_/ /_/_/ /_/ \__,_/_/ /_/\___/\__/_/\____/_/ /_/____/
+# /____//____/
+
+
+def get_obj_identifier(obj: Any) -> str:
+ """
+ Generates an objet identifier as : 'OBJ_UUID.OBJ_VERSION'
+ If the object version is None, the result is 'OBJ_UUID.'
+ :param obj:
+ :return: str
+ """
+ obj_obj_version = get_obj_version(obj)
+ if obj_obj_version is None:
+ obj_obj_version = ""
+ obj_uuid = get_obj_uuid(obj)
+ return f"{obj_uuid}.{obj_obj_version}"
+
+
+def get_reverse_dor_list(obj_list: List[Any], key_func: Callable = get_obj_identifier) -> Dict[str, List[Any]]:
+ """
+ Compute a dict with 'OBJ_UUID.OBJ_VERSION' as Key, and list of DOR that reference it.
+ If the object version is None, key is 'OBJ_UUID.'
+ :param obj_list:
+ :param key_func: a callable to create the key of the dict from the object instance
+ :return: str
+ """
+ rels = {}
+ for obj in obj_list:
+ for dor in search_attribute_matching_type(obj, "DataObjectReference", return_self=False):
+ key = key_func(dor)
+ if key not in rels:
+ rels[key] = []
+ rels[key] = rels.get(key, []) + [obj]
+ return rels
+
+
+# PATHS
+
+
+def gen_core_props_path(export_version: EpcExportVersion = EpcExportVersion.CLASSIC):
+ return "docProps/core.xml"
+
+
+def gen_energyml_object_path(energyml_object: Union[str, Any],
+ export_version: EpcExportVersion = EpcExportVersion.CLASSIC):
+ """
+ Generate a path to store the :param:`energyml_object` into an epc file (depending on the :param:`export_version`)
+ :param energyml_object:
+ :param export_version:
+ :return:
+ """
+ if isinstance(energyml_object, str):
+ energyml_object = read_energyml_xml_str(energyml_object)
+
+ obj_type = get_object_type_for_file_path_from_class(energyml_object.__class__)
+
+ pkg = get_class_pkg(energyml_object)
+ pkg_version = get_class_pkg_version(energyml_object)
+ object_version = get_obj_version(energyml_object)
+ uuid = get_obj_uuid(energyml_object)
+
+ # if object_version is None:
+ # object_version = "0"
+
+ if export_version == EpcExportVersion.EXPANDED:
+ return f"namespace_{pkg}{pkg_version.replace('.', '')}/{uuid}{('/version_' + object_version) if object_version is not None else ''}/{obj_type}_{uuid}.xml"
+ else:
+ return obj_type + "_" + uuid + ".xml"
+
+
+def get_file_folder_and_name_from_path(path: str) -> Tuple[str, str]:
+ """
+ Returns a tuple (FOLDER_PATH, FILE_NAME)
+ :param path:
+ :return:
+ """
+ obj_folder = path[:path.rindex("/") + 1] if "/" in path else ""
+ obj_file_name = path[path.rindex("/") + 1:] if "/" in path else path
+ return obj_folder, obj_file_name
+
+
+def gen_rels_path(energyml_object: Any,
+ export_version: EpcExportVersion = EpcExportVersion.CLASSIC
+ ) -> str:
+ """
+ Generate a path to store the :param:`energyml_object` rels file into an epc file
+ (depending on the :param:`export_version`)
+ :param energyml_object:
+ :param export_version:
+ :return:
+ """
+ if isinstance(obj, CoreProperties):
+ return f"{RELS_FOLDER_NAME}/.rels"
+ else:
+ obj_path = gen_energyml_object_path(obj, export_version)
+ obj_folder, obj_file_name = get_file_folder_and_name_from_path(obj_path, )
+ return f"{obj_folder}{RELS_FOLDER_NAME}/{obj_file_name}.rels"
+
+
+def get_epc_content_type_path(export_version: EpcExportVersion = EpcExportVersion.CLASSIC) -> str:
+ """
+ Generate a path to store the "[Content_Types].xml" file into an epc file
+ (depending on the :param:`export_version`)
+ :return:
+ """
+ return "[Content_Types].xml"
+def gen_core_props_path(export_version: EpcExportVersion = EpcExportVersion.CLASSIC)
+def gen_core_props_path(export_version: EpcExportVersion = EpcExportVersion.CLASSIC):
+ return "docProps/core.xml"
+def gen_energyml_object_path(energyml_object: Union[str, Any], export_version: EpcExportVersion = EpcExportVersion.CLASSIC)
+Generate a path to store the :param:energyml_object into an epc file (depending on the :param:export_version)
+:param energyml_object:
+:param export_version:
+:return:
def gen_energyml_object_path(energyml_object: Union[str, Any],
+ export_version: EpcExportVersion = EpcExportVersion.CLASSIC):
+ """
+ Generate a path to store the :param:`energyml_object` into an epc file (depending on the :param:`export_version`)
+ :param energyml_object:
+ :param export_version:
+ :return:
+ """
+ if isinstance(energyml_object, str):
+ energyml_object = read_energyml_xml_str(energyml_object)
+
+ obj_type = get_object_type_for_file_path_from_class(energyml_object.__class__)
+
+ pkg = get_class_pkg(energyml_object)
+ pkg_version = get_class_pkg_version(energyml_object)
+ object_version = get_obj_version(energyml_object)
+ uuid = get_obj_uuid(energyml_object)
+
+ # if object_version is None:
+ # object_version = "0"
+
+ if export_version == EpcExportVersion.EXPANDED:
+ return f"namespace_{pkg}{pkg_version.replace('.', '')}/{uuid}{('/version_' + object_version) if object_version is not None else ''}/{obj_type}_{uuid}.xml"
+ else:
+ return obj_type + "_" + uuid + ".xml"
+def gen_rels_path(energyml_object: Any, export_version: EpcExportVersion = EpcExportVersion.CLASSIC) ‑> str
+Generate a path to store the :param:energyml_object rels file into an epc file
+(depending on the :param:export_version)
+:param energyml_object:
+:param export_version:
+:return:
def gen_rels_path(energyml_object: Any,
+ export_version: EpcExportVersion = EpcExportVersion.CLASSIC
+ ) -> str:
+ """
+ Generate a path to store the :param:`energyml_object` rels file into an epc file
+ (depending on the :param:`export_version`)
+ :param energyml_object:
+ :param export_version:
+ :return:
+ """
+ if isinstance(obj, CoreProperties):
+ return f"{RELS_FOLDER_NAME}/.rels"
+ else:
+ obj_path = gen_energyml_object_path(obj, export_version)
+ obj_folder, obj_file_name = get_file_folder_and_name_from_path(obj_path, )
+ return f"{obj_folder}{RELS_FOLDER_NAME}/{obj_file_name}.rels"
+def get_epc_content_type_path(export_version: EpcExportVersion = EpcExportVersion.CLASSIC) ‑> str
+Generate a path to store the "[Content_Types].xml" file into an epc file
+(depending on the :param:export_version)
+:return:
def get_epc_content_type_path(export_version: EpcExportVersion = EpcExportVersion.CLASSIC) -> str:
+ """
+ Generate a path to store the "[Content_Types].xml" file into an epc file
+ (depending on the :param:`export_version`)
+ :return:
+ """
+ return "[Content_Types].xml"
+def get_file_folder_and_name_from_path(path: str) ‑> Tuple[str, str]
+Returns a tuple (FOLDER_PATH, FILE_NAME) +:param path: +:return:
def get_file_folder_and_name_from_path(path: str) -> Tuple[str, str]:
+ """
+ Returns a tuple (FOLDER_PATH, FILE_NAME)
+ :param path:
+ :return:
+ """
+ obj_folder = path[:path.rindex("/") + 1] if "/" in path else ""
+ obj_file_name = path[path.rindex("/") + 1:] if "/" in path else path
+ return obj_folder, obj_file_name
+def get_obj_identifier(obj: Any) ‑> str
+Generates an objet identifier as : 'OBJ_UUID.OBJ_VERSION' +If the object version is None, the result is 'OBJ_UUID.' +:param obj: +:return: str
def get_obj_identifier(obj: Any) -> str:
+ """
+ Generates an objet identifier as : 'OBJ_UUID.OBJ_VERSION'
+ If the object version is None, the result is 'OBJ_UUID.'
+ :param obj:
+ :return: str
+ """
+ obj_obj_version = get_obj_version(obj)
+ if obj_obj_version is None:
+ obj_obj_version = ""
+ obj_uuid = get_obj_uuid(obj)
+ return f"{obj_uuid}.{obj_obj_version}"
+def get_reverse_dor_list(obj_list: List[Any], key_func: Callable = <function get_obj_identifier>) ‑> Dict[str, List[Any]]
+Compute a dict with 'OBJ_UUID.OBJ_VERSION' as Key, and list of DOR that reference it. +If the object version is None, key is 'OBJ_UUID.' +:param obj_list: +:param key_func: a callable to create the key of the dict from the object instance +:return: str
def get_reverse_dor_list(obj_list: List[Any], key_func: Callable = get_obj_identifier) -> Dict[str, List[Any]]:
+ """
+ Compute a dict with 'OBJ_UUID.OBJ_VERSION' as Key, and list of DOR that reference it.
+ If the object version is None, key is 'OBJ_UUID.'
+ :param obj_list:
+ :param key_func: a callable to create the key of the dict from the object instance
+ :return: str
+ """
+ rels = {}
+ for obj in obj_list:
+ for dor in search_attribute_matching_type(obj, "DataObjectReference", return_self=False):
+ key = key_func(dor)
+ if key not in rels:
+ rels[key] = []
+ rels[key] = rels.get(key, []) + [obj]
+ return rels
+class EPCRelsRelationshipType
+(*args, **kwds)
+Create a collection of name/value pairs.
+Example enumeration:
+>>> class Color(Enum):
+... RED = 1
+... BLUE = 2
+... GREEN = 3
+Access them by:
+>>> Color.RED
+<Color.RED: 1>
+>>> Color(1)
+<Color.RED: 1>
+>>> Color['RED']
+<Color.RED: 1>
+Enumerations can be iterated over, and know how many members they have:
+>>> len(Color)
+3
+>>> list(Color)
+[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]
+Methods can be added to enumerations, and members can have their own +attributes – see the documentation for details.
class EPCRelsRelationshipType(Enum):
+ #: The object in Target is the destination of the relationship.
+ DESTINATION_OBJECT = "destinationObject"
+ #: The current object is the source in the relationship with the target object.
+ SOURCE_OBJECT = "sourceObject"
+ #: The target object is a proxy object for an external data object (HDF5 file).
+ ML_TO_EXTERNAL_PART_PROXY = "mlToExternalPartProxy"
+ #: The current object is used as a proxy object by the target object.
+ EXTERNAL_PART_PROXY_TO_ML = "externalPartProxyToMl"
+ #: The target is a resource outside of the EPC package. Note that TargetMode should be "External"
+ #: for this relationship.
+ EXTERNAL_RESOURCE = "externalResource"
+ #: The object in Target is a media representation for the current object. As a guideline, media files
+ #: should be stored in a "media" folder in the ROOT of the package.
+ DestinationMedia = "destinationMedia"
+ #: The current object is a media representation for the object in Target.
+ SOURCE_MEDIA = "sourceMedia"
+ #: The target is part of a larger data object that has been chunked into several smaller files
+ CHUNKED_PART = "chunkedPart"
+ #: /!\ not in the norm
+ EXTENDED_CORE_PROPERTIES = "extended-core-properties"
+
+ def get_type(self) -> str:
+ match self:
+ case EPCRelsRelationshipType.EXTENDED_CORE_PROPERTIES:
+ return "http://schemas.f2i-consulting.com/package/2014/relationships/" + str(self.value)
+ case (
+ EPCRelsRelationshipType.CHUNKED_PART
+ | EPCRelsRelationshipType.DESTINATION_OBJECT
+ | EPCRelsRelationshipType.SOURCE_OBJECT
+ | EPCRelsRelationshipType.ML_TO_EXTERNAL_PART_PROXY
+ | EPCRelsRelationshipType.EXTERNAL_PART_PROXY_TO_ML
+ | EPCRelsRelationshipType.EXTERNAL_RESOURCE
+ | EPCRelsRelationshipType.DestinationMedia
+ | EPCRelsRelationshipType.SOURCE_MEDIA
+ | _
+ ):
+ return "http://schemas.energistics.org/package/2012/relationships/" + str(self.value)var CHUNKED_PARTThe target is part of a larger data object that has been chunked into several smaller files
var DESTINATION_OBJECTThe object in Target is the destination of the relationship.
var DestinationMediaThe object in Target is a media representation for the current object. As a guideline, media files +should be stored in a "media" folder in the ROOT of the package.
var EXTENDED_CORE_PROPERTIES/!\ not in the norm
var EXTERNAL_PART_PROXY_TO_MLThe current object is used as a proxy object by the target object.
var EXTERNAL_RESOURCEThe target is a resource outside of the EPC package. Note that TargetMode should be "External" +for this relationship.
var ML_TO_EXTERNAL_PART_PROXYThe target object is a proxy object for an external data object (HDF5 file).
var SOURCE_MEDIAThe current object is a media representation for the object in Target.
var SOURCE_OBJECTThe current object is the source in the relationship with the target object.
+def get_type(self) ‑> str
+def get_type(self) -> str:
+ match self:
+ case EPCRelsRelationshipType.EXTENDED_CORE_PROPERTIES:
+ return "http://schemas.f2i-consulting.com/package/2014/relationships/" + str(self.value)
+ case (
+ EPCRelsRelationshipType.CHUNKED_PART
+ | EPCRelsRelationshipType.DESTINATION_OBJECT
+ | EPCRelsRelationshipType.SOURCE_OBJECT
+ | EPCRelsRelationshipType.ML_TO_EXTERNAL_PART_PROXY
+ | EPCRelsRelationshipType.EXTERNAL_PART_PROXY_TO_ML
+ | EPCRelsRelationshipType.EXTERNAL_RESOURCE
+ | EPCRelsRelationshipType.DestinationMedia
+ | EPCRelsRelationshipType.SOURCE_MEDIA
+ | _
+ ):
+ return "http://schemas.energistics.org/package/2012/relationships/" + str(self.value)
+class Epc
+(export_version: EpcExportVersion = EpcExportVersion.CLASSIC, core_props: energyml.opc.opc.CoreProperties = None, energyml_objects: List = <factory>, raw_files: List[RawFile] = <factory>, external_files_path: List[str] = <factory>, additional_rels: Dict[str, List[energyml.opc.opc.Relationship]] = <factory>, epc_file_path: Optional[str] = None)
+A class that represent an EPC file content
@dataclass
+class Epc:
+ """
+ A class that represent an EPC file content
+ """
+ # content_type: List[str] = field(
+ # default_factory=list,
+ # )
+
+ export_version: EpcExportVersion = field(
+ default=EpcExportVersion.CLASSIC
+ )
+
+ core_props: CoreProperties = field(default=None)
+
+ """ xml files refered in the [Content_Types].xml """
+ energyml_objects: List = field(
+ default_factory=list,
+ )
+
+ """ Other files content like pdf etc """
+ raw_files: List[RawFile] = field(
+ default_factory=list,
+ )
+
+ """ A list of external files. It ca be used to link hdf5 files """
+ external_files_path: List[str] = field(
+ default_factory=list,
+ )
+
+ """
+ Additional rels for objects. Key is the object (same than in @energyml_objects) and value is a list of
+ RelationShip. This can be used to link an HDF5 to an ExternalPartReference in resqml 2.0.1
+ Key is a value returned by @get_obj_identifier
+ """
+ additional_rels: Dict[str, List[Relationship]] = field(
+ default_factory=lambda: {}
+ )
+
+ """
+ Epc file path. Used when loaded from a local file or for export
+ """
+ epc_file_path: Optional[str] = field(
+ default=None
+ )
+
+ def __str__(self):
+ return (
+ "EPC file (" + str(self.export_version) + ") "
+ + f"{len(self.energyml_objects)} energyml objects and {len(self.raw_files)} other files {[f.path for f in self.raw_files]}"
+ # + f"\n{[serialize_json(ar) for ar in self.additional_rels]}"
+ )
+
+ # EXPORT functions
+
+ def gen_opc_content_type(self) -> Types:
+ """
+ Generates a :class:`Types` instance and fill it with energyml objects :class:`Override` values
+ :return:
+ """
+ ct = Types()
+ rels_default = Default()
+ rels_default.content_type = RELS_CONTENT_TYPE
+ rels_default.extension = "rels"
+
+ ct.default = [rels_default]
+
+ ct.override = []
+ for e_obj in self.energyml_objects:
+ ct.override.append(Override(
+ content_type=get_content_type_from_class(type(e_obj)),
+ part_name=gen_energyml_object_path(e_obj, self.export_version),
+ ))
+
+ if self.core_props is not None:
+ ct.override.append(Override(
+ content_type=get_content_type_from_class(self.core_props),
+ part_name=gen_core_props_path(self.export_version),
+ ))
+
+ return ct
+
+ def export_file(self, path: Optional[str] = None) -> None:
+ """
+ Export the epc file. If :param:`path` is None, the epc 'self.epc_file_path' is used
+ :param path:
+ :return:
+ """
+ if path is None:
+ path = self.epc_file_path
+ epc_io = self.export_io()
+ with open(path, "wb") as f:
+ f.write(epc_io.getbuffer())
+
+ def export_io(self) -> BytesIO:
+ """
+ Export the epc file into a :class:`BytesIO` instance. The result is an 'in-memory' zip file.
+ :return:
+ """
+ zip_buffer = BytesIO()
+
+ with zipfile.ZipFile(zip_buffer, "a", zipfile.ZIP_DEFLATED, False) as zip_file:
+ # Energyml objects
+ for e_obj in self.energyml_objects:
+ e_path = gen_energyml_object_path(e_obj, self.export_version)
+ zip_info = zipfile.ZipInfo(filename=e_path, date_time=datetime.datetime.now().timetuple()[:6])
+ data = serialize_xml(e_obj)
+ zip_file.writestr(zip_info, data)
+
+ # Rels
+ for rels_path, rels in self.compute_rels().items():
+ zip_info = zipfile.ZipInfo(filename=rels_path, date_time=datetime.datetime.now().timetuple()[:6])
+ data = serialize_xml(rels)
+ zip_file.writestr(zip_info, data)
+
+ # CoreProps
+ if self.core_props is not None:
+ zip_info = zipfile.ZipInfo(filename=gen_core_props_path(self.export_version),
+ date_time=datetime.datetime.now().timetuple()[:6])
+ data = serialize_xml(self.core_props)
+ zip_file.writestr(zip_info, data)
+
+ # ContentType
+ zip_info = zipfile.ZipInfo(filename=get_epc_content_type_path(),
+ date_time=datetime.datetime.now().timetuple()[:6])
+ data = serialize_xml(self.gen_opc_content_type())
+ zip_file.writestr(zip_info, data)
+
+ return zip_buffer
+
+ def compute_rels(self) -> Dict[str, Relationships]:
+ """
+ Returns a dict containing for each objet, the rels xml file path as key and the RelationShips object as value
+ :return:
+ """
+ dor_relation = get_reverse_dor_list(self.energyml_objects)
+
+ # destObject
+ rels = {
+ obj_id: [
+ Relationship(
+ target=gen_energyml_object_path(target_obj, self.export_version),
+ type_value=EPCRelsRelationshipType.DESTINATION_OBJECT.get_type(),
+ id=f"_{obj_id}_{get_obj_type(target_obj)}_{get_obj_identifier(target_obj)}",
+ ) for target_obj in target_obj_list
+ ]
+ for obj_id, target_obj_list in dor_relation.items()
+ }
+ # sourceObject
+ for obj in self.energyml_objects:
+ obj_id = get_obj_identifier(obj)
+ if obj_id not in rels:
+ rels[obj_id] = []
+ for target_obj in get_direct_dor_list(obj):
+ rels[obj_id].append(Relationship(
+ target=gen_energyml_object_path(target_obj, self.export_version),
+ type_value=EPCRelsRelationshipType.SOURCE_OBJECT.get_type(),
+ id=f"_{obj_id}_{get_obj_type(target_obj)}_{get_obj_identifier(target_obj)}",
+ ))
+
+ map_obj_id_to_obj = {
+ get_obj_identifier(obj): obj
+ for obj in self.energyml_objects
+ }
+
+ obj_rels = {
+ gen_rels_path(energyml_object=map_obj_id_to_obj.get(obj_id), export_version=self.export_version): Relationships(
+ relationship=obj_rels + (self.additional_rels[obj_id] if obj_id in self.additional_rels else []),
+
+ )
+ for obj_id, obj_rels in rels.items()
+ }
+
+ # CoreProps
+ if self.core_props is not None:
+ obj_rels[gen_rels_path(self.core_props)] = Relationships(
+ relationship=[
+ Relationship(
+ target=gen_core_props_path(),
+ type_value=EPCRelsRelationshipType.EXTENDED_CORE_PROPERTIES.get_type(),
+ id="CoreProperties"
+ )
+ ]
+ )
+
+ return obj_rels
+
+ # -----------
+
+ def get_object_by_uuid(self, uuid: str) -> List[Any]:
+ """
+ Search all objects with the uuid :param:`uuid`.
+ :param uuid:
+ :return:
+ """
+ return list(filter(lambda o: get_obj_uuid(o) == uuid, self.energyml_objects))
+
+ def get_object_by_identifier(self, identifier: str) -> Optional[Any]:
+ """
+ Search an object by its identifier.
+ :param identifier: given by the function :func:`get_obj_identifier`
+ :return:
+ """
+ for o in self.energyml_objects:
+ if get_obj_identifier(o) == identifier:
+ return o
+ return None
+
+ def get_epc_file_folder(self) -> Optional[str]:
+ if self.epc_file_path is not None and len(self.epc_file_path) > 0:
+ folders_and_name = re.split(r"[\\/]", self.epc_file_path)
+ if len(folders_and_name) > 1:
+ return "/".join(folders_and_name[:-1])
+ else:
+ return ""
+ return None
+
+ # Class methods
+
+ @classmethod
+ def read_file(cls, epc_file_path: str):
+ with open(epc_file_path, "rb") as f:
+ epc = cls.read_stream(BytesIO(f.read()))
+ epc.epc_file_path = epc_file_path
+ return epc
+
+ @classmethod
+ def read_stream(cls, epc_file_io: BytesIO): # returns an Epc instance
+ """
+ :param epc_file_io:
+ :return: an :class:`EPC` instance
+ """
+ try:
+ _read_files = []
+ obj_list = []
+ raw_file_list = []
+ additional_rels = {}
+ core_props = None
+ with zipfile.ZipFile(epc_file_io, "r", zipfile.ZIP_DEFLATED) as epc_file:
+ content_type_file_name = get_epc_content_type_path()
+ content_type_info = None
+ try:
+ content_type_info = epc_file.getinfo(content_type_file_name)
+ except KeyError:
+ for info in epc_file.infolist():
+ if info.filename.lower() == content_type_file_name.lower():
+ content_type_info = info
+ break
+
+ _read_files.append(content_type_file_name)
+
+ if content_type_info is None:
+ print(f"No {content_type_file_name} file found")
+ else:
+ content_type_obj: Types = read_energyml_xml_bytes(epc_file.read(content_type_file_name))
+ path_to_obj = {}
+ for ov in content_type_obj.override:
+ ov_ct = ov.content_type
+ ov_path = ov.part_name
+ # print(ov_ct)
+ while ov_path.startswith("/") or ov_path.startswith("\\"):
+ ov_path = ov_path[1:]
+ if is_energyml_content_type(ov_ct):
+ _read_files.append(ov_path)
+ try:
+ ov_obj = read_energyml_xml_bytes_as_class(
+ epc_file.read(ov_path),
+ get_class_from_content_type(ov_ct)
+ )
+ if isinstance(ov_obj, DerivedElement):
+ ov_obj = ov_obj.value
+ path_to_obj[ov_path] = ov_obj
+ obj_list.append(ov_obj)
+ except ParserError as e:
+ print(f"Epc.@read_stream failed to parse file {ov_path} for content-type: {ov_ct} => {get_class_from_content_type(ov_ct)}")
+ raise e
+ elif get_class_from_content_type(ov_ct) == CoreProperties:
+ _read_files.append(ov_path)
+ core_props = read_energyml_xml_bytes_as_class(epc_file.read(ov_path), CoreProperties)
+
+ for f_info in epc_file.infolist():
+ if f_info.filename not in _read_files:
+ _read_files.append(f_info.filename)
+ if not f_info.filename.lower().endswith(".rels"):
+ try:
+ raw_file_list.append(
+ RawFile(
+ path=f_info.filename,
+ content=BytesIO(epc_file.read(f_info.filename)),
+ )
+ )
+ except IOError as e:
+ print(e)
+ else: # rels
+ # print(f"reading rels {f_info.filename}")
+ rels_folder, rels_file_name = get_file_folder_and_name_from_path(f_info.filename)
+ while rels_folder.endswith("/"):
+ rels_folder = rels_folder[:-1]
+ obj_folder = rels_folder[:rels_folder.rindex("/") + 1] if "/" in rels_folder else ""
+ obj_file_name = rels_file_name[:-5] # removing the ".rels"
+ rels_file: Relationships = read_energyml_xml_bytes_as_class(
+ epc_file.read(f_info.filename),
+ Relationships
+ )
+ obj_path = obj_folder + obj_file_name
+ if obj_path in path_to_obj:
+ try:
+ additional_rels_key = get_obj_identifier(path_to_obj[obj_path])
+ for rel in rels_file.relationship:
+ # print(f"\t\t{rel.type_value}")
+ if (rel.type_value != EPCRelsRelationshipType.DESTINATION_OBJECT.get_type()
+ and rel.type_value != EPCRelsRelationshipType.SOURCE_OBJECT.get_type()
+ and rel.type_value != EPCRelsRelationshipType.EXTENDED_CORE_PROPERTIES.get_type()
+ ): # not a computable relation
+ if additional_rels_key not in additional_rels:
+ additional_rels[additional_rels_key] = []
+ additional_rels[additional_rels_key].append(rel)
+ except Exception as e:
+ print(f"Error with obj path {obj_path} {path_to_obj[obj_path]}")
+ raise e
+ else:
+ print(f"xml file {obj_path} not found in EPC (rels is not associate to any object)")
+
+ return Epc(energyml_objects=obj_list,
+ raw_files=raw_file_list,
+ core_props=core_props,
+ additional_rels=additional_rels
+ )
+ except zipfile.BadZipFile as error:
+ print(error)
+
+ return Nonevar additional_rels : Dict[str, List[energyml.opc.opc.Relationship]]Epc file path. Used when loaded from a local file or for export
var core_props : energyml.opc.opc.CorePropertiesxml files refered in the [Content_Types].xml
var energyml_objects : ListOther files content like pdf etc
var epc_file_path : Optional[str]var export_version : EpcExportVersionvar external_files_path : List[str]Additional rels for objects. Key is the object (same than in @energyml_objects) and value is a list of +RelationShip. This can be used to link an HDF5 to an ExternalPartReference in resqml 2.0.1 +Key is a value returned by @get_obj_identifier
var raw_files : List[RawFile]A list of external files. It ca be used to link hdf5 files
+def read_file(epc_file_path: str)
+@classmethod
+def read_file(cls, epc_file_path: str):
+ with open(epc_file_path, "rb") as f:
+ epc = cls.read_stream(BytesIO(f.read()))
+ epc.epc_file_path = epc_file_path
+ return epc
+def read_stream(epc_file_io: _io.BytesIO)
+:param epc_file_io:
+:return: an :class:EPC instance
@classmethod
+def read_stream(cls, epc_file_io: BytesIO): # returns an Epc instance
+ """
+ :param epc_file_io:
+ :return: an :class:`EPC` instance
+ """
+ try:
+ _read_files = []
+ obj_list = []
+ raw_file_list = []
+ additional_rels = {}
+ core_props = None
+ with zipfile.ZipFile(epc_file_io, "r", zipfile.ZIP_DEFLATED) as epc_file:
+ content_type_file_name = get_epc_content_type_path()
+ content_type_info = None
+ try:
+ content_type_info = epc_file.getinfo(content_type_file_name)
+ except KeyError:
+ for info in epc_file.infolist():
+ if info.filename.lower() == content_type_file_name.lower():
+ content_type_info = info
+ break
+
+ _read_files.append(content_type_file_name)
+
+ if content_type_info is None:
+ print(f"No {content_type_file_name} file found")
+ else:
+ content_type_obj: Types = read_energyml_xml_bytes(epc_file.read(content_type_file_name))
+ path_to_obj = {}
+ for ov in content_type_obj.override:
+ ov_ct = ov.content_type
+ ov_path = ov.part_name
+ # print(ov_ct)
+ while ov_path.startswith("/") or ov_path.startswith("\\"):
+ ov_path = ov_path[1:]
+ if is_energyml_content_type(ov_ct):
+ _read_files.append(ov_path)
+ try:
+ ov_obj = read_energyml_xml_bytes_as_class(
+ epc_file.read(ov_path),
+ get_class_from_content_type(ov_ct)
+ )
+ if isinstance(ov_obj, DerivedElement):
+ ov_obj = ov_obj.value
+ path_to_obj[ov_path] = ov_obj
+ obj_list.append(ov_obj)
+ except ParserError as e:
+ print(f"Epc.@read_stream failed to parse file {ov_path} for content-type: {ov_ct} => {get_class_from_content_type(ov_ct)}")
+ raise e
+ elif get_class_from_content_type(ov_ct) == CoreProperties:
+ _read_files.append(ov_path)
+ core_props = read_energyml_xml_bytes_as_class(epc_file.read(ov_path), CoreProperties)
+
+ for f_info in epc_file.infolist():
+ if f_info.filename not in _read_files:
+ _read_files.append(f_info.filename)
+ if not f_info.filename.lower().endswith(".rels"):
+ try:
+ raw_file_list.append(
+ RawFile(
+ path=f_info.filename,
+ content=BytesIO(epc_file.read(f_info.filename)),
+ )
+ )
+ except IOError as e:
+ print(e)
+ else: # rels
+ # print(f"reading rels {f_info.filename}")
+ rels_folder, rels_file_name = get_file_folder_and_name_from_path(f_info.filename)
+ while rels_folder.endswith("/"):
+ rels_folder = rels_folder[:-1]
+ obj_folder = rels_folder[:rels_folder.rindex("/") + 1] if "/" in rels_folder else ""
+ obj_file_name = rels_file_name[:-5] # removing the ".rels"
+ rels_file: Relationships = read_energyml_xml_bytes_as_class(
+ epc_file.read(f_info.filename),
+ Relationships
+ )
+ obj_path = obj_folder + obj_file_name
+ if obj_path in path_to_obj:
+ try:
+ additional_rels_key = get_obj_identifier(path_to_obj[obj_path])
+ for rel in rels_file.relationship:
+ # print(f"\t\t{rel.type_value}")
+ if (rel.type_value != EPCRelsRelationshipType.DESTINATION_OBJECT.get_type()
+ and rel.type_value != EPCRelsRelationshipType.SOURCE_OBJECT.get_type()
+ and rel.type_value != EPCRelsRelationshipType.EXTENDED_CORE_PROPERTIES.get_type()
+ ): # not a computable relation
+ if additional_rels_key not in additional_rels:
+ additional_rels[additional_rels_key] = []
+ additional_rels[additional_rels_key].append(rel)
+ except Exception as e:
+ print(f"Error with obj path {obj_path} {path_to_obj[obj_path]}")
+ raise e
+ else:
+ print(f"xml file {obj_path} not found in EPC (rels is not associate to any object)")
+
+ return Epc(energyml_objects=obj_list,
+ raw_files=raw_file_list,
+ core_props=core_props,
+ additional_rels=additional_rels
+ )
+ except zipfile.BadZipFile as error:
+ print(error)
+
+ return None
+def compute_rels(self) ‑> Dict[str, energyml.opc.opc.Relationships]
+Returns a dict containing for each objet, the rels xml file path as key and the RelationShips object as value +:return:
def compute_rels(self) -> Dict[str, Relationships]:
+ """
+ Returns a dict containing for each objet, the rels xml file path as key and the RelationShips object as value
+ :return:
+ """
+ dor_relation = get_reverse_dor_list(self.energyml_objects)
+
+ # destObject
+ rels = {
+ obj_id: [
+ Relationship(
+ target=gen_energyml_object_path(target_obj, self.export_version),
+ type_value=EPCRelsRelationshipType.DESTINATION_OBJECT.get_type(),
+ id=f"_{obj_id}_{get_obj_type(target_obj)}_{get_obj_identifier(target_obj)}",
+ ) for target_obj in target_obj_list
+ ]
+ for obj_id, target_obj_list in dor_relation.items()
+ }
+ # sourceObject
+ for obj in self.energyml_objects:
+ obj_id = get_obj_identifier(obj)
+ if obj_id not in rels:
+ rels[obj_id] = []
+ for target_obj in get_direct_dor_list(obj):
+ rels[obj_id].append(Relationship(
+ target=gen_energyml_object_path(target_obj, self.export_version),
+ type_value=EPCRelsRelationshipType.SOURCE_OBJECT.get_type(),
+ id=f"_{obj_id}_{get_obj_type(target_obj)}_{get_obj_identifier(target_obj)}",
+ ))
+
+ map_obj_id_to_obj = {
+ get_obj_identifier(obj): obj
+ for obj in self.energyml_objects
+ }
+
+ obj_rels = {
+ gen_rels_path(energyml_object=map_obj_id_to_obj.get(obj_id), export_version=self.export_version): Relationships(
+ relationship=obj_rels + (self.additional_rels[obj_id] if obj_id in self.additional_rels else []),
+
+ )
+ for obj_id, obj_rels in rels.items()
+ }
+
+ # CoreProps
+ if self.core_props is not None:
+ obj_rels[gen_rels_path(self.core_props)] = Relationships(
+ relationship=[
+ Relationship(
+ target=gen_core_props_path(),
+ type_value=EPCRelsRelationshipType.EXTENDED_CORE_PROPERTIES.get_type(),
+ id="CoreProperties"
+ )
+ ]
+ )
+
+ return obj_rels
+def export_file(self, path: Optional[str] = None) ‑> None
+Export the epc file. If :param:path is None, the epc 'self.epc_file_path' is used
+:param path:
+:return:
def export_file(self, path: Optional[str] = None) -> None:
+ """
+ Export the epc file. If :param:`path` is None, the epc 'self.epc_file_path' is used
+ :param path:
+ :return:
+ """
+ if path is None:
+ path = self.epc_file_path
+ epc_io = self.export_io()
+ with open(path, "wb") as f:
+ f.write(epc_io.getbuffer())
+def export_io(self) ‑> _io.BytesIO
+Export the epc file into a :class:BytesIO instance. The result is an 'in-memory' zip file.
+:return:
def export_io(self) -> BytesIO:
+ """
+ Export the epc file into a :class:`BytesIO` instance. The result is an 'in-memory' zip file.
+ :return:
+ """
+ zip_buffer = BytesIO()
+
+ with zipfile.ZipFile(zip_buffer, "a", zipfile.ZIP_DEFLATED, False) as zip_file:
+ # Energyml objects
+ for e_obj in self.energyml_objects:
+ e_path = gen_energyml_object_path(e_obj, self.export_version)
+ zip_info = zipfile.ZipInfo(filename=e_path, date_time=datetime.datetime.now().timetuple()[:6])
+ data = serialize_xml(e_obj)
+ zip_file.writestr(zip_info, data)
+
+ # Rels
+ for rels_path, rels in self.compute_rels().items():
+ zip_info = zipfile.ZipInfo(filename=rels_path, date_time=datetime.datetime.now().timetuple()[:6])
+ data = serialize_xml(rels)
+ zip_file.writestr(zip_info, data)
+
+ # CoreProps
+ if self.core_props is not None:
+ zip_info = zipfile.ZipInfo(filename=gen_core_props_path(self.export_version),
+ date_time=datetime.datetime.now().timetuple()[:6])
+ data = serialize_xml(self.core_props)
+ zip_file.writestr(zip_info, data)
+
+ # ContentType
+ zip_info = zipfile.ZipInfo(filename=get_epc_content_type_path(),
+ date_time=datetime.datetime.now().timetuple()[:6])
+ data = serialize_xml(self.gen_opc_content_type())
+ zip_file.writestr(zip_info, data)
+
+ return zip_buffer
+def gen_opc_content_type(self) ‑> energyml.opc.opc.Types
+Generates a :class:Types instance and fill it with energyml objects :class:Override values
+:return:
def gen_opc_content_type(self) -> Types:
+ """
+ Generates a :class:`Types` instance and fill it with energyml objects :class:`Override` values
+ :return:
+ """
+ ct = Types()
+ rels_default = Default()
+ rels_default.content_type = RELS_CONTENT_TYPE
+ rels_default.extension = "rels"
+
+ ct.default = [rels_default]
+
+ ct.override = []
+ for e_obj in self.energyml_objects:
+ ct.override.append(Override(
+ content_type=get_content_type_from_class(type(e_obj)),
+ part_name=gen_energyml_object_path(e_obj, self.export_version),
+ ))
+
+ if self.core_props is not None:
+ ct.override.append(Override(
+ content_type=get_content_type_from_class(self.core_props),
+ part_name=gen_core_props_path(self.export_version),
+ ))
+
+ return ct
+def get_epc_file_folder(self) ‑> Optional[str]
+def get_epc_file_folder(self) -> Optional[str]:
+ if self.epc_file_path is not None and len(self.epc_file_path) > 0:
+ folders_and_name = re.split(r"[\\/]", self.epc_file_path)
+ if len(folders_and_name) > 1:
+ return "/".join(folders_and_name[:-1])
+ else:
+ return ""
+ return None
+def get_object_by_identifier(self, identifier: str) ‑> Optional[Any]
+Search an object by its identifier.
+:param identifier: given by the function :func:get_obj_identifier()
+:return:
def get_object_by_identifier(self, identifier: str) -> Optional[Any]:
+ """
+ Search an object by its identifier.
+ :param identifier: given by the function :func:`get_obj_identifier`
+ :return:
+ """
+ for o in self.energyml_objects:
+ if get_obj_identifier(o) == identifier:
+ return o
+ return None
+def get_object_by_uuid(self, uuid: str) ‑> List[Any]
+Search all objects with the uuid :param:uuid.
+:param uuid:
+:return:
def get_object_by_uuid(self, uuid: str) -> List[Any]:
+ """
+ Search all objects with the uuid :param:`uuid`.
+ :param uuid:
+ :return:
+ """
+ return list(filter(lambda o: get_obj_uuid(o) == uuid, self.energyml_objects))
+class EpcExportVersion
+(*args, **kwds)
+EPC export version.
class EpcExportVersion(Enum):
+ """EPC export version."""
+ #: Classical export
+ CLASSIC = 1
+ #: Export with objet path sorted by package (eml/resqml/witsml/prodml)
+ EXPANDED = 2var CLASSICClassical export
var EXPANDEDExport with objet path sorted by package (eml/resqml/witsml/prodml)
+class NoCrsException
+(*args, **kwargs)
+Common base class for all non-exit exceptions.
class NoCrsException(Exception):
+ pass
+class ObjectNotFoundNotException
+(obj_id: str = None)
+ObjectNotFoundNotException(obj_id: str = None)
@dataclass
+class ObjectNotFoundNotException(Exception):
+ obj_id: str = field(
+ default=None
+ )var obj_id : str
+class RawFile
+(path: str = '_', content: _io.BytesIO = None)
+RawFile(path: str = '_', content: _io.BytesIO = None)
@dataclass
+class RawFile:
+ path: str = field(default="_")
+ content: BytesIO = field(default=None)var content : _io.BytesIOvar path : strsrc.energyml.utilsThe energyml.utils module. +It contains tools for energyml management.
+Please check the following module (depending on your need): +- energyml-opc +- energyml-common2-0 +- energyml-common2-1 +- energyml-common2-2 +- energyml-common2-3 +- energyml-resqml2-0-1 +- energyml-resqml2-2-dev3 +- energyml-resqml2-2 +- energyml-witsml2-0 +- energyml-witsml2-1 +- energyml-prodml2-0 +- energyml-prodml2-2
+# Copyright (c) 2023-2024 Geosiris.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+The energyml.utils module.
+It contains tools for energyml management.
+
+Please check the following module (depending on your need):
+ - energyml-opc
+ - energyml-common2-0
+ - energyml-common2-1
+ - energyml-common2-2
+ - energyml-common2-3
+ - energyml-resqml2-0-1
+ - energyml-resqml2-2-dev3
+ - energyml-resqml2-2
+ - energyml-witsml2-0
+ - energyml-witsml2-1
+ - energyml-prodml2-0
+ - energyml-prodml2-2
+"""src.energyml.utils.dataThe data module …
src.energyml.utils.epcThis example module shows various types of documentation available for use +with pydoc. +To generate HTML documentation for this module issue the +…
src.energyml.utils.introspectionsrc.energyml.utils.managersrc.energyml.utils.serializationsrc.energyml.utils.validationsrc.energyml.utils.xmlsrc.energyml.utils.introspection# Copyright (c) 2023-2024 Geosiris.
+# SPDX-License-Identifier: Apache-2.0
+import datetime
+import random
+import re
+import sys
+import typing
+import uuid as uuid_mod
+from dataclasses import Field
+from enum import Enum
+from importlib import import_module
+from typing import Any, List, Optional, Union, Dict, Tuple
+
+from .manager import get_class_pkg, get_class_pkg_version, RELATED_MODULES, \
+ get_related_energyml_modules_name, get_sub_classes, get_classes_matching_name
+from .xml import parse_content_type, ENERGYML_NAMESPACES
+
+
+primitives = (bool, str, int, float, type(None))
+
+
+def is_enum(cls: Union[type, Any]):
+ """
+ Returns True if :param:`cls` is an Enum
+ :param cls:
+ :return:
+ """
+ if isinstance(cls, type):
+ return Enum in cls.__bases__
+ return is_enum(type(cls))
+
+
+def is_primitive(cls: Union[type, Any]) -> bool:
+ """
+ Returns True if :param:`cls` is a primitiv type or extends Enum
+ :param cls:
+ :return: bool
+ """
+ if isinstance(cls, type):
+ return cls in primitives or Enum in cls.__bases__
+ return is_primitive(type(cls))
+
+
+def is_abstract(cls: Union[type, Any]) -> bool:
+ """
+ Returns True if :param:`cls` is an abstract class
+ :param cls:
+ :return: bool
+ """
+ if isinstance(cls, type):
+ return not is_primitive(cls) and (cls.__name__.startswith("Abstract") or (hasattr(cls, "__dataclass_fields__") and len(cls.__dataclass_fields__)) == 0) and len(get_class_methods(cls)) == 0
+ return is_abstract(type(cls))
+
+
+def get_class_methods(cls: Union[type, Any]) -> List[str]:
+ """
+ Returns the list of the methods names for a specific class.
+ :param cls:
+ :return:
+ """
+ return [func for func in dir(cls) if callable(getattr(cls, func)) and not func.startswith("__") and not isinstance(getattr(cls, func), type)]
+
+
+def get_class_from_name(class_name_and_module: str) -> Optional[type]:
+ """
+ Return a :class:`type` object matching with the name :param:`class_name_and_module`.
+ :param class_name_and_module:
+ :return:
+ """
+ module_name = class_name_and_module[: class_name_and_module.rindex(".")]
+ last_ns_part = class_name_and_module[
+ class_name_and_module.rindex(".") + 1:
+ ]
+ try:
+ # Required to read "CustomData" on eml objects that may contain resqml values
+ # ==> we need to import all modules related to the same version of the common
+ import_related_module(module_name)
+ return getattr(sys.modules[module_name], last_ns_part)
+ except AttributeError as e:
+ if "2d" in last_ns_part:
+ return get_class_from_name(
+ class_name_and_module.replace("2d", "2D")
+ )
+ elif "3d" in last_ns_part:
+ return get_class_from_name(
+ class_name_and_module.replace("3d", "3D")
+ )
+ elif last_ns_part[0].islower():
+ return get_class_from_name(
+ module_name + "." + last_ns_part[0].upper() + last_ns_part[1:]
+ )
+ else:
+ print(e)
+ return None
+
+
+def get_class_from_content_type(content_type: str) -> Optional[type]:
+ """
+ Return a :class:`type` object matching with the content-type :param:`content_type`.
+ :param content_type:
+ :return:
+ """
+ ct = parse_content_type(content_type)
+ domain = ct.group("domain")
+ if domain is None:
+ domain = "opc"
+ if domain == "opc":
+ xml_domain = ct.group("xmlDomain")
+ if "." in xml_domain:
+ xml_domain = xml_domain[xml_domain.rindex(".") + 1:]
+ if "extended" in xml_domain:
+ xml_domain = xml_domain.replace("extended", "")
+ opc_type = pascal_case(xml_domain)
+ # print("energyml.opc.opc." + opc_type)
+ return get_class_from_name("energyml.opc.opc." + opc_type)
+ else:
+ ns = ENERGYML_NAMESPACES[domain]
+ domain = ct.group("domain")
+ obj_type = ct.group("type")
+ if obj_type.lower().startswith("obj_"): # for resqml201
+ obj_type = "Obj" + obj_type[4:]
+ version_num = str(ct.group("domainVersion")).replace(".", "_")
+ if domain.lower() == "resqml" and version_num.startswith("2_0"):
+ version_num = "2_0_1"
+ return get_class_from_name(
+ "energyml."
+ + domain
+ + ".v"
+ + version_num
+ + "."
+ + ns[ns.rindex("/") + 1:]
+ + "."
+ + obj_type
+ )
+
+
+def snake_case(s: str) -> str:
+ """ Transform a str into snake case. """
+ s = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', s)
+ s = re.sub('__([A-Z])', r'_\1', s)
+ s = re.sub('([a-z0-9])([A-Z])', r'\1_\2', s)
+ return s.lower()
+
+
+def pascal_case(s: str) -> str:
+ """ Transform a str into pascal case. """
+ return snake_case(s).replace("_", " ").title().replace(" ", "")
+
+
+def flatten_concatenation(matrix) -> List:
+ """
+ Flatten a matrix.
+
+ Example :
+ [ [a,b,c], [d,e,f], [ [x,y,z], [0] ] ]
+ will be translated in: [a, b, c, d, e, f, [x,y,z], [0]]
+ :param matrix:
+ :return:
+ """
+ flat_list = []
+ for row in matrix:
+ flat_list += row
+ return flat_list
+
+
+def import_related_module(energyml_module_name: str) -> None:
+ """
+ Import related modules for a specific energyml module. (See. :const:`RELATED_MODULES`)
+ :param energyml_module_name:
+ :return:
+ """
+ for related in RELATED_MODULES:
+ if energyml_module_name in related:
+ for m in related:
+ try:
+ import_module(m)
+ except Exception as e:
+ pass
+ # print(e)
+
+
+def get_class_fields(cls: Union[type, Any]) -> Dict[str, Field]:
+ """
+ Return all class fields names, mapped to their :class:`Field` value.
+ :param cls:
+ :return:
+ """
+ if not isinstance(cls, type): # if cls is an instance
+ cls = type(cls)
+ try:
+ return cls.__dataclass_fields__
+ except AttributeError:
+ return {}
+
+
+def get_class_attributes(cls: Union[type, Any]) -> List[str]:
+ """
+ returns a list of attributes (not private ones)
+ """
+ # if not isinstance(cls, type): # if cls is an instance
+ # cls = type(cls)
+ # return list(filter(lambda a: not a.startswith("__"), dir(cls)))
+ return list(get_class_fields(cls).keys())
+
+
+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
+ """
+ class_fields = get_class_fields(cls)
+
+ # a search with the exact value
+ for name, cf in class_fields.items():
+ if (
+ snake_case(name) == snake_case(attribute_name)
+ or ('name' in cf.metadata and cf.metadata['name'] == attribute_name)
+ ):
+ return name
+
+ # search regex after to avoid shadowing perfect match
+ pattern = re.compile(attribute_name, flags=re_flags)
+ for name, cf in class_fields.items():
+ # print(f"\t->{name} : {attribute_name} {pattern.match(name)} {('name' in cf.metadata and pattern.match(cf.metadata['name']))}")
+ if pattern.match(name) or ('name' in cf.metadata and pattern.match(cf.metadata['name'])):
+ return name
+
+ return None
+
+
+def get_object_attribute(
+ obj: Any, attr_dot_path: str, force_snake_case=True
+) -> Any:
+ """
+ returns the value of an attribute given by a dot representation of its path in the object
+ example "Citation.Title"
+ """
+ while attr_dot_path.startswith("."): # avoid '.Citation.Title' to take an empty attribute name before the first '.'
+ attr_dot_path = attr_dot_path[1:]
+
+ current_attrib_name = attr_dot_path
+
+ if "." in attr_dot_path:
+ current_attrib_name = attr_dot_path.split(".")[0]
+
+ if force_snake_case:
+ current_attrib_name = snake_case(current_attrib_name)
+
+ value = None
+ if isinstance(obj, list):
+ value = obj[int(current_attrib_name)]
+ elif isinstance(obj, dict):
+ value = obj[current_attrib_name]
+ else:
+ value = getattr(obj, current_attrib_name)
+
+ if "." in attr_dot_path:
+ return get_object_attribute(
+ value, attr_dot_path[len(current_attrib_name) + 1:]
+ )
+ else:
+ return value
+
+
+def get_object_attribute_advanced(obj: Any, attr_dot_path: str) -> Any:
+ """
+ see @get_matching_class_attribute_name and @get_object_attribute
+ """
+ current_attrib_name = attr_dot_path
+
+ if "." in attr_dot_path:
+ current_attrib_name = attr_dot_path.split(".")[0]
+
+ current_attrib_name = get_matching_class_attribute_name(
+ obj, current_attrib_name
+ )
+
+ value = None
+ if isinstance(obj, list):
+ value = obj[int(current_attrib_name)]
+ elif isinstance(obj, dict):
+ value = obj[current_attrib_name]
+ else:
+ value = getattr(obj, current_attrib_name)
+
+ if "." in attr_dot_path:
+ return get_object_attribute_advanced(
+ value, attr_dot_path[len(current_attrib_name) + 1:]
+ )
+ else:
+ return value
+
+
+def get_object_attribute_no_verif(obj: Any, attr_name: str) -> Any:
+ """
+ Return the value of the attribute named after param :param:`attr_name` without verification (may raise an exception
+ if it doesn't exists).
+
+ Note: attr_name="0" will work if :param:`obj` is of type :class:`List`
+ :param obj:
+ :param attr_name:
+ :return:
+ """
+ if isinstance(obj, list):
+ return obj[int(attr_name)]
+ elif isinstance(obj, dict):
+ return obj[attr_name]
+ else:
+ return getattr(obj, attr_name)
+
+
+def get_object_attribute_rgx(obj: Any, attr_dot_path_rgx: str) -> Any:
+ """
+ see @get_object_attribute. Search the attribute name using regex for values between dots.
+ Example : [Cc]itation.[Tt]it\\.*
+ """
+ current_attrib_name = attr_dot_path_rgx
+
+ attrib_list = re.split(r"(?<!\\)\.+", attr_dot_path_rgx)
+
+ if len(attrib_list) > 0:
+ current_attrib_name = attrib_list[0]
+
+ # unescape Dot
+ current_attrib_name = current_attrib_name.replace("\\.", ".")
+
+ real_attrib_name = get_matching_class_attribute_name(
+ obj, current_attrib_name
+ )
+ if real_attrib_name is not None:
+ value = get_object_attribute_no_verif(obj, real_attrib_name)
+
+ if len(attrib_list) > 1:
+ return get_object_attribute_rgx(
+ value, attr_dot_path_rgx[len(current_attrib_name) + 1:]
+ )
+ else:
+ return value
+ return None
+
+
+def get_obj_type(obj: Any) -> str:
+ """ Return the type name of an object. If obj is already a :class:`type`, return its __name__"""
+ if isinstance(obj, type):
+ return str(obj.__name__)
+ return get_obj_type(type(obj))
+
+
+def class_match_rgx(
+ cls: Union[type, Any],
+ rgx: str,
+ super_class_search: bool = True,
+ re_flags=re.IGNORECASE,
+):
+ if not isinstance(cls, type):
+ cls = type(cls)
+
+ if re.match(rgx, cls.__name__, re_flags):
+ return True
+
+ if not is_primitive(cls) and super_class_search:
+ for base in cls.__bases__:
+ if class_match_rgx(base, rgx, super_class_search, re_flags):
+ return True
+ return False
+
+
+def search_attribute_matching_type_with_path(
+ obj: Any,
+ type_rgx: str,
+ re_flags=re.IGNORECASE,
+ return_self: bool = True, # test directly on input object and not only in its attributes
+ deep_search: bool = True, # Search inside a matching object
+ super_class_search: bool = True, # Search inside in super classes of the object
+ current_path: str = "",
+) -> List[Tuple[str, Any]]:
+ """
+ Returns a list of tuple (path, value) for each sub attribute with type matching param "type_rgx".
+ The path is a dot-version like ".Citation.Title"
+ :param obj:
+ :param type_rgx:
+ :param re_flags:
+ :param return_self:
+ :param deep_search:
+ :param super_class_search:
+ :param current_path:
+ :return:
+ """
+ res = []
+ if obj is not None:
+ if return_self and class_match_rgx(
+ obj, type_rgx, super_class_search, re_flags
+ ):
+ res.append((current_path, obj))
+ if not deep_search:
+ return res
+
+ if isinstance(obj, list):
+ cpt = 0
+ for s_o in obj:
+ res = res + search_attribute_matching_type_with_path(
+ obj=s_o,
+ type_rgx=type_rgx,
+ re_flags=re_flags,
+ return_self=True,
+ deep_search=deep_search,
+ current_path=f"{current_path}.{cpt}",
+ super_class_search=super_class_search,
+ )
+ cpt = cpt + 1
+ elif isinstance(obj, dict):
+ for k, s_o in obj.items():
+ res = res + search_attribute_matching_type_with_path(
+ obj=s_o,
+ type_rgx=type_rgx,
+ re_flags=re_flags,
+ return_self=True,
+ deep_search=deep_search,
+ current_path=f"{current_path}.{k}",
+ super_class_search=super_class_search,
+ )
+ elif not is_primitive(obj):
+ for att_name in get_class_attributes(obj):
+ res = res + search_attribute_matching_type_with_path(
+ obj=get_object_attribute_rgx(obj, att_name),
+ type_rgx=type_rgx,
+ re_flags=re_flags,
+ return_self=True,
+ deep_search=deep_search,
+ current_path=f"{current_path}.{att_name}",
+ super_class_search=super_class_search,
+ )
+
+ return res
+
+
+def search_attribute_in_upper_matching_name(
+ obj: Any,
+ name_rgx: str,
+ root_obj: Optional[Any] = None,
+ re_flags=re.IGNORECASE,
+ current_path: str = "",
+) -> Optional[Any]:
+ """
+ See :func:`search_attribute_matching_type_with_path`. It only returns the value not the path
+ :param obj:
+ :param name_rgx:
+ :param root_obj:
+ :param re_flags:
+ :param current_path:
+ :return:
+ """
+ elt_list = search_attribute_matching_name(obj, name_rgx, search_in_sub_obj=False, deep_search=False)
+ if elt_list is not None and len(elt_list) > 0:
+ return elt_list
+
+ if obj != root_obj:
+ upper_path = current_path[:current_path.rindex(".")]
+ if len(upper_path) > 0:
+ return search_attribute_in_upper_matching_name(
+ obj=get_object_attribute(root_obj, upper_path),
+ name_rgx=name_rgx,
+ root_obj=root_obj,
+ re_flags=re_flags,
+ current_path=upper_path,
+ )
+
+ return None
+
+
+def search_attribute_matching_type(
+ obj: Any,
+ type_rgx: str,
+ re_flags=re.IGNORECASE,
+ return_self: bool = True, # test directly on input object and not only in its attributes
+ deep_search: bool = True, # Search inside a matching object
+ super_class_search: bool = True, # Search inside in super classes of the object
+) -> List[Any]:
+ """
+ See :func:`search_attribute_matching_type_with_path`. It only returns the value not the path
+ :param obj:
+ :param type_rgx:
+ :param re_flags:
+ :param return_self:
+ :param deep_search:
+ :param super_class_search:
+ :return:
+ """
+ return [
+ val
+ for path, val in search_attribute_matching_type_with_path(
+ obj=obj,
+ type_rgx=type_rgx,
+ re_flags=re_flags,
+ return_self=return_self,
+ deep_search=deep_search,
+ super_class_search=super_class_search,
+ )
+ ]
+
+
+def search_attribute_matching_name_with_path(
+ obj: Any,
+ name_rgx: str,
+ re_flags=re.IGNORECASE,
+ current_path: str = "",
+ deep_search: bool = True, # Search inside a matching object
+ search_in_sub_obj: bool = True, # Search in obj attributes
+) -> List[Tuple[str, Any]]:
+ """
+ Returns a list of tuple (path, value) for each sub attribute with type matching param "name_rgx".
+ The path is a dot-version like ".Citation.Title"
+ :param obj:
+ :param name_rgx:
+ :param re_flags:
+ :param current_path:
+ :param deep_search:
+ :param search_in_sub_obj:
+ :return:
+ """
+ while name_rgx.startswith("."):
+ name_rgx = name_rgx[1:]
+ current_match = name_rgx
+ next_match = current_match
+ if '.' in current_match:
+ attrib_list = re.split(r"(?<!\\)\.+", name_rgx)
+ current_match = attrib_list[0]
+ next_match = '.'.join(attrib_list[1:])
+
+ res = []
+
+ match_value = None
+ match_path_and_obj = []
+ not_match_path_and_obj = []
+ if isinstance(obj, list):
+ cpt = 0
+ for s_o in obj:
+ match = re.match(current_match.replace("\\.", "."), str(cpt), flags=re_flags)
+ if match is not None:
+ match_value = match.group(0)
+ match_path_and_obj.append( (f"{current_path}.{cpt}", s_o) )
+ else:
+ not_match_path_and_obj.append( (f"{current_path}.{cpt}", s_o) )
+ cpt = cpt + 1
+ elif isinstance(obj, dict):
+ for k, s_o in obj.items():
+ match = re.match(current_match.replace("\\.", "."), k, flags=re_flags)
+ if match is not None:
+ match_value = match.group(0)
+ match_path_and_obj.append( (f"{current_path}.{k}", s_o) )
+ 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:
+ 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:
+ not_match_path_and_obj.append( (f"{current_path}.{att_name}", get_object_attribute_no_verif(obj, att_name)) )
+
+ for matched_path, matched in match_path_and_obj:
+ if next_match != current_match and len(next_match) > 0: # next_match is different, match is not final
+ res = res + search_attribute_matching_name_with_path(
+ obj=matched,
+ name_rgx=next_match,
+ re_flags=re_flags,
+ current_path=matched_path,
+ deep_search=False, # no deep with partial
+ search_in_sub_obj=False, # no partial search in sub obj with no match
+ )
+ else: # a complete match
+ res.append( (matched_path, matched) )
+ if deep_search:
+ res = res + search_attribute_matching_name_with_path(
+ obj=matched,
+ name_rgx=name_rgx,
+ re_flags=re_flags,
+ current_path=matched_path,
+ deep_search=deep_search, # no deep with partial
+ search_in_sub_obj=True,
+ )
+ if search_in_sub_obj:
+ for not_matched_path, not_matched in not_match_path_and_obj:
+ res = res + search_attribute_matching_name_with_path(
+ obj=not_matched,
+ name_rgx=name_rgx,
+ re_flags=re_flags,
+ current_path=not_matched_path,
+ deep_search=deep_search,
+ search_in_sub_obj=True,
+ )
+
+ return res
+
+
+def search_attribute_matching_name(
+ obj: Any,
+ name_rgx: str,
+ re_flags=re.IGNORECASE,
+ deep_search: bool = True, # Search inside a matching object
+ search_in_sub_obj: bool = True, # Search in obj attributes
+) -> List[Any]:
+ """
+ See :func:`search_attribute_matching_name_with_path`. It only returns the value not the path
+
+ :param obj:
+ :param name_rgx:
+ :param re_flags:
+ :param deep_search:
+ :param search_in_sub_obj:
+ :return:
+ """
+ return [
+ val
+ for path, val in search_attribute_matching_name_with_path(
+ obj=obj,
+ name_rgx=name_rgx,
+ re_flags=re_flags,
+ deep_search=deep_search,
+ search_in_sub_obj=search_in_sub_obj
+ )
+ ]
+
+
+# Utility functions
+
+
+def gen_uuid() -> str:
+ """
+ Generate a new uuid.
+ :return:
+ """
+ return str(uuid_mod.uuid4())
+
+
+def get_obj_uuid(obj: Any) -> str:
+ """
+ Return the object uuid (attribute must match the following regex : "[Uu]u?id|UUID").
+ :param obj:
+ :return:
+ """
+ return get_object_attribute_rgx(obj, "[Uu]u?id|UUID")
+
+
+def get_obj_version(obj: Any) -> str:
+ """
+ Return the object version (check for "object_version" or "version_string" attribute).
+ :param obj:
+ :return:
+ """
+ try:
+ return get_object_attribute_no_verif(obj, "object_version")
+ except AttributeError as e:
+ try:
+ return get_object_attribute_no_verif(obj, "version_string")
+ except Exception:
+ print(f"Error with {type(obj)}")
+ raise e
+
+
+def get_direct_dor_list(obj: Any) -> List[Any]:
+ """
+ Search all sub attribute of type "DataObjectreference".
+ :param obj:
+ :return:
+ """
+ return search_attribute_matching_type(obj, "DataObjectreference")
+
+
+def get_data_object_type(cls: Union[type, Any], print_dev_version=True, nb_max_version_digits=2):
+ return get_class_pkg(cls) + "." + get_class_pkg_version(cls, print_dev_version, nb_max_version_digits)
+
+
+def get_qualified_type_from_class(cls: Union[type, Any], print_dev_version=True):
+ return (
+ get_data_object_type(cls, print_dev_version, 2)
+ .replace(".", "") + "." + get_object_type_for_file_path_from_class(cls)
+ )
+
+
+def get_content_type_from_class(cls: Union[type, Any], print_dev_version=True, nb_max_version_digits=2):
+ if not isinstance(cls, type):
+ cls = type(cls)
+
+ if ".opc." in cls.__module__:
+ if cls.__name__.lower() == "coreproperties":
+ return "application/vnd.openxmlformats-package.core-properties+xml"
+ else:
+ return ("application/x-" + get_class_pkg(cls)
+ + "+xml;version=" + get_class_pkg_version(cls, print_dev_version, nb_max_version_digits) + ";type="
+ + get_object_type_for_file_path_from_class(cls))
+
+ print(f"@get_content_type_from_class not supported type : {cls}")
+ return None
+
+
+def get_object_type_for_file_path_from_class(cls) -> str:
+ # obj_type = get_obj_type(cls)
+ # pkg = get_class_pkg(cls)
+ # if re.match(r"Obj[A-Z].*", obj_type) is not None and pkg == "resqml":
+ # return "obj_" + obj_type[3:]
+ # return obj_type
+
+ try:
+ return cls.Meta.name # to work with 3d transformed in 3D and Obj[A-Z] in obj_[A-Z]
+ except AttributeError:
+ pkg = get_class_pkg(cls)
+ return get_obj_type(cls)
+
+
+def now(time_zone=datetime.timezone(datetime.timedelta(hours=1), "UTC")) -> int:
+ """ Return an epoch value """
+ return int(datetime.datetime.timestamp(datetime.datetime.now(time_zone)))
+
+
+def epoch(time_zone=datetime.timezone(datetime.timedelta(hours=1), "UTC")) -> int:
+ return int(now(time_zone))
+
+
+def date_to_epoch(date: str) -> int:
+ """
+ Transform a energyml date into an epoch datetime
+ :return: int
+ """
+ return int(datetime.datetime.fromisoformat(date).timestamp())
+
+
+def epoch_to_date(epoch_value: int, time_zone=datetime.timezone(datetime.timedelta(hours=1), "UTC")) -> str:
+ date = datetime.datetime.fromtimestamp(epoch_value / 1e3, time_zone)
+ return date.strftime("%Y-%m-%dT%H:%M:%S%z")
+
+
+# RANDOM
+
+
+def get_class_from_simple_name(simple_name: str, energyml_module_context=None) -> type:
+ """
+ Search for a :class:`type` depending on the simple class name :param:`simple_name`.
+ :param simple_name:
+ :param energyml_module_context:
+ :return:
+ """
+ if energyml_module_context is None:
+ energyml_module_context = []
+ try:
+ return eval(simple_name)
+ except NameError as e:
+ for mod in energyml_module_context:
+ try:
+ exec(f"from {mod} import *")
+ # required to be able to access to type in
+ # typing values like "List[ObjectAlias]"
+ except ModuleNotFoundError:
+ pass
+ return eval(simple_name)
+
+
+def _gen_str_from_attribute_name(attribute_name: Optional[str], _parent_class: Optional[type]=None) -> str:
+ """
+ Generate a str from the attribute name. The result is not the same for an attribute named "Uuid" than for an
+ attribute named "mime_type" for example.
+ :param attribute_name:
+ :param _parent_class:
+ :return:
+ """
+ attribute_name_lw = attribute_name.lower()
+ if attribute_name is not None:
+ if attribute_name_lw == "uuid" or attribute_name_lw == "uid":
+ return gen_uuid()
+ elif attribute_name_lw == "title":
+ return f"{_parent_class.__name__} title (" + str(random_value_from_class(int)) + ")"
+ elif attribute_name_lw == "schema_version" and get_class_pkg_version(_parent_class) is not None:
+ return get_class_pkg_version(_parent_class)
+ elif re.match(r"\w*version$", attribute_name_lw):
+ return str(random_value_from_class(int))
+ elif re.match(r"\w*date_.*", attribute_name_lw):
+ return epoch_to_date(epoch())
+ elif re.match(r"path_in_.*", attribute_name_lw):
+ return f"/FOLDER/{gen_uuid()}/a_patch{random.randint(0, 30)}"
+ elif "mime_type" in attribute_name_lw and ("external" in _parent_class.__name__.lower() and "part" in _parent_class.__name__.lower()):
+ return f"application/x-hdf5"
+ elif "type" in attribute_name_lw:
+ if attribute_name_lw.startswith("qualified"):
+ return get_qualified_type_from_class(get_classes_matching_name(_parent_class, "Abstract")[0])
+ if attribute_name_lw.startswith("content"):
+ return get_content_type_from_class(get_classes_matching_name(_parent_class, "Abstract")[0])
+ return "A random str " + (f"[{attribute_name}] " if attribute_name is not None else "") + "(" + str(
+ random_value_from_class(int)) + ")"
+
+
+def random_value_from_class(cls: type):
+ """
+ Generate a random value for a :class:`type`. All attributes should be filled with random values.
+ :param cls:
+ :return:
+ """
+ energyml_module_context = []
+ if not is_primitive(cls):
+ # import_related_module(cls.__module__)
+ energyml_module_context = get_related_energyml_modules_name(cls)
+ return _random_value_from_class(cls=cls, energyml_module_context=energyml_module_context, attribute_name=None)
+
+
+def _random_value_from_class(cls: Any, energyml_module_context: List[str], attribute_name: Optional[str] = None, _parent_class: Optional[type]=None):
+ """
+ Generate a random value for a :class:`type`. All attributes should be filled with random values.
+ :param cls:
+ :param energyml_module_context:
+ :param attribute_name:
+ :param _parent_class: the :class:`type`of the parent object
+ :return:
+ """
+
+ try:
+ if isinstance(cls, str) or cls == str:
+ return _gen_str_from_attribute_name(attribute_name, _parent_class)
+ elif isinstance(cls, int) or cls == int:
+ return random.randint(0, 10000)
+ elif isinstance(cls, float) or cls == float:
+ return random.randint(0, 1000000) / 100.
+ elif isinstance(cls, bool) or cls == bool:
+ return random.randint(0, 1) == 1
+ elif is_enum(cls):
+ return cls[cls._member_names_[random.randint(0, len(cls._member_names_) - 1)]]
+ elif isinstance(cls, typing.Union.__class__):
+ type_list = list(cls.__args__)
+ if type(None) in type_list:
+ type_list.remove(type(None)) # we don't want to generate none value
+ chosen_type = type_list[random.randint(0, len(type_list))]
+ return _random_value_from_class(chosen_type, energyml_module_context, attribute_name, cls)
+ elif cls.__module__ == 'typing':
+ nb_value_for_list = random.randint(2, 3)
+ type_list = list(cls.__args__)
+ if type(None) in type_list:
+ type_list.remove(type(None)) # we don't want to generate none value
+
+ if cls._name == "List":
+ lst = []
+ for i in range(nb_value_for_list):
+ chosen_type = type_list[random.randint(0, len(type_list) - 1)]
+ lst.append(_random_value_from_class(chosen_type, energyml_module_context, attribute_name, list))
+ return lst
+ else:
+ chosen_type = type_list[random.randint(0, len(type_list) - 1)]
+ return _random_value_from_class(chosen_type, energyml_module_context, attribute_name, _parent_class)
+ else:
+ potential_classes = list(filter(lambda _c: not is_abstract(_c), [cls] + get_sub_classes(cls)))
+ if len(potential_classes) > 0:
+ chosen_type = potential_classes[random.randint(0, len(potential_classes) - 1)]
+ args = {}
+ for k, v in get_class_fields(chosen_type).items():
+ # print(f"get_class_fields {k} : {v}")
+ args[k] = _random_value_from_class(
+ cls=get_class_from_simple_name(simple_name=v.type, energyml_module_context=energyml_module_context),
+ energyml_module_context=energyml_module_context,
+ attribute_name=k,
+ _parent_class=chosen_type)
+
+ if not isinstance(chosen_type, type):
+ chosen_type = type(chosen_type)
+ return chosen_type(**args)
+
+ except Exception as e:
+ print(f"exception on attribute '{attribute_name}' for class {cls} :")
+ raise e
+
+ print(f"@_random_value_from_class Not supported object type generation {cls}")
+ return None
+def class_match_rgx(cls: Union[type, Any], rgx: str, super_class_search: bool = True, re_flags=re.IGNORECASE)
+def class_match_rgx(
+ cls: Union[type, Any],
+ rgx: str,
+ super_class_search: bool = True,
+ re_flags=re.IGNORECASE,
+):
+ if not isinstance(cls, type):
+ cls = type(cls)
+
+ if re.match(rgx, cls.__name__, re_flags):
+ return True
+
+ if not is_primitive(cls) and super_class_search:
+ for base in cls.__bases__:
+ if class_match_rgx(base, rgx, super_class_search, re_flags):
+ return True
+ return False
+def date_to_epoch(date: str) ‑> int
+Transform a energyml date into an epoch datetime +:return: int
def date_to_epoch(date: str) -> int:
+ """
+ Transform a energyml date into an epoch datetime
+ :return: int
+ """
+ return int(datetime.datetime.fromisoformat(date).timestamp())
+def epoch(time_zone=datetime.timezone(datetime.timedelta(seconds=3600), 'UTC')) ‑> int
+def epoch(time_zone=datetime.timezone(datetime.timedelta(hours=1), "UTC")) -> int:
+ return int(now(time_zone))
+def epoch_to_date(epoch_value: int, time_zone=datetime.timezone(datetime.timedelta(seconds=3600), 'UTC')) ‑> str
+def epoch_to_date(epoch_value: int, time_zone=datetime.timezone(datetime.timedelta(hours=1), "UTC")) -> str:
+ date = datetime.datetime.fromtimestamp(epoch_value / 1e3, time_zone)
+ return date.strftime("%Y-%m-%dT%H:%M:%S%z")
+def flatten_concatenation(matrix) ‑> List
+Flatten a matrix.
+Example : +[ [a,b,c], [d,e,f], [ [x,y,z], [0] ] ] +will be translated in: [a, b, c, d, e, f, [x,y,z], [0]] +:param matrix: +:return:
def flatten_concatenation(matrix) -> List:
+ """
+ Flatten a matrix.
+
+ Example :
+ [ [a,b,c], [d,e,f], [ [x,y,z], [0] ] ]
+ will be translated in: [a, b, c, d, e, f, [x,y,z], [0]]
+ :param matrix:
+ :return:
+ """
+ flat_list = []
+ for row in matrix:
+ flat_list += row
+ return flat_list
+def gen_uuid() ‑> str
+Generate a new uuid. +:return:
def gen_uuid() -> str:
+ """
+ Generate a new uuid.
+ :return:
+ """
+ return str(uuid_mod.uuid4())
+def get_class_attributes(cls: Union[type, Any]) ‑> List[str]
+returns a list of attributes (not private ones)
def get_class_attributes(cls: Union[type, Any]) -> List[str]:
+ """
+ returns a list of attributes (not private ones)
+ """
+ # if not isinstance(cls, type): # if cls is an instance
+ # cls = type(cls)
+ # return list(filter(lambda a: not a.startswith("__"), dir(cls)))
+ return list(get_class_fields(cls).keys())
+def get_class_fields(cls: Union[type, Any]) ‑> Dict[str, dataclasses.Field]
+Return all class fields names, mapped to their :class:Field value.
+:param cls:
+:return:
def get_class_fields(cls: Union[type, Any]) -> Dict[str, Field]:
+ """
+ Return all class fields names, mapped to their :class:`Field` value.
+ :param cls:
+ :return:
+ """
+ if not isinstance(cls, type): # if cls is an instance
+ cls = type(cls)
+ try:
+ return cls.__dataclass_fields__
+ except AttributeError:
+ return {}
+def get_class_from_content_type(content_type: str) ‑> Optional[type]
+Return a :class:type object matching with the content-type :param:content_type.
+:param content_type:
+:return:
def get_class_from_content_type(content_type: str) -> Optional[type]:
+ """
+ Return a :class:`type` object matching with the content-type :param:`content_type`.
+ :param content_type:
+ :return:
+ """
+ ct = parse_content_type(content_type)
+ domain = ct.group("domain")
+ if domain is None:
+ domain = "opc"
+ if domain == "opc":
+ xml_domain = ct.group("xmlDomain")
+ if "." in xml_domain:
+ xml_domain = xml_domain[xml_domain.rindex(".") + 1:]
+ if "extended" in xml_domain:
+ xml_domain = xml_domain.replace("extended", "")
+ opc_type = pascal_case(xml_domain)
+ # print("energyml.opc.opc." + opc_type)
+ return get_class_from_name("energyml.opc.opc." + opc_type)
+ else:
+ ns = ENERGYML_NAMESPACES[domain]
+ domain = ct.group("domain")
+ obj_type = ct.group("type")
+ if obj_type.lower().startswith("obj_"): # for resqml201
+ obj_type = "Obj" + obj_type[4:]
+ version_num = str(ct.group("domainVersion")).replace(".", "_")
+ if domain.lower() == "resqml" and version_num.startswith("2_0"):
+ version_num = "2_0_1"
+ return get_class_from_name(
+ "energyml."
+ + domain
+ + ".v"
+ + version_num
+ + "."
+ + ns[ns.rindex("/") + 1:]
+ + "."
+ + obj_type
+ )
+def get_class_from_name(class_name_and_module: str) ‑> Optional[type]
+Return a :class:type object matching with the name :param:class_name_and_module.
+:param class_name_and_module:
+:return:
def get_class_from_name(class_name_and_module: str) -> Optional[type]:
+ """
+ Return a :class:`type` object matching with the name :param:`class_name_and_module`.
+ :param class_name_and_module:
+ :return:
+ """
+ module_name = class_name_and_module[: class_name_and_module.rindex(".")]
+ last_ns_part = class_name_and_module[
+ class_name_and_module.rindex(".") + 1:
+ ]
+ try:
+ # Required to read "CustomData" on eml objects that may contain resqml values
+ # ==> we need to import all modules related to the same version of the common
+ import_related_module(module_name)
+ return getattr(sys.modules[module_name], last_ns_part)
+ except AttributeError as e:
+ if "2d" in last_ns_part:
+ return get_class_from_name(
+ class_name_and_module.replace("2d", "2D")
+ )
+ elif "3d" in last_ns_part:
+ return get_class_from_name(
+ class_name_and_module.replace("3d", "3D")
+ )
+ elif last_ns_part[0].islower():
+ return get_class_from_name(
+ module_name + "." + last_ns_part[0].upper() + last_ns_part[1:]
+ )
+ else:
+ print(e)
+ return None
+def get_class_from_simple_name(simple_name: str, energyml_module_context=None) ‑> type
+Search for a :class:type depending on the simple class name :param:simple_name.
+:param simple_name:
+:param energyml_module_context:
+:return:
def get_class_from_simple_name(simple_name: str, energyml_module_context=None) -> type:
+ """
+ Search for a :class:`type` depending on the simple class name :param:`simple_name`.
+ :param simple_name:
+ :param energyml_module_context:
+ :return:
+ """
+ if energyml_module_context is None:
+ energyml_module_context = []
+ try:
+ return eval(simple_name)
+ except NameError as e:
+ for mod in energyml_module_context:
+ try:
+ exec(f"from {mod} import *")
+ # required to be able to access to type in
+ # typing values like "List[ObjectAlias]"
+ except ModuleNotFoundError:
+ pass
+ return eval(simple_name)
+def get_class_methods(cls: Union[type, Any]) ‑> List[str]
+Returns the list of the methods names for a specific class. +:param cls: +:return:
def get_class_methods(cls: Union[type, Any]) -> List[str]:
+ """
+ Returns the list of the methods names for a specific class.
+ :param cls:
+ :return:
+ """
+ return [func for func in dir(cls) if callable(getattr(cls, func)) and not func.startswith("__") and not isinstance(getattr(cls, func), type)]
+def get_content_type_from_class(cls: Union[type, Any], print_dev_version=True, nb_max_version_digits=2)
+def get_content_type_from_class(cls: Union[type, Any], print_dev_version=True, nb_max_version_digits=2):
+ if not isinstance(cls, type):
+ cls = type(cls)
+
+ if ".opc." in cls.__module__:
+ if cls.__name__.lower() == "coreproperties":
+ return "application/vnd.openxmlformats-package.core-properties+xml"
+ else:
+ return ("application/x-" + get_class_pkg(cls)
+ + "+xml;version=" + get_class_pkg_version(cls, print_dev_version, nb_max_version_digits) + ";type="
+ + get_object_type_for_file_path_from_class(cls))
+
+ print(f"@get_content_type_from_class not supported type : {cls}")
+ return None
+def get_data_object_type(cls: Union[type, Any], print_dev_version=True, nb_max_version_digits=2)
+def get_data_object_type(cls: Union[type, Any], print_dev_version=True, nb_max_version_digits=2):
+ return get_class_pkg(cls) + "." + get_class_pkg_version(cls, print_dev_version, nb_max_version_digits)
+def get_direct_dor_list(obj: Any) ‑> List[Any]
+Search all sub attribute of type "DataObjectreference". +:param obj: +:return:
def get_direct_dor_list(obj: Any) -> List[Any]:
+ """
+ Search all sub attribute of type "DataObjectreference".
+ :param obj:
+ :return:
+ """
+ return search_attribute_matching_type(obj, "DataObjectreference")
+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
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
+ """
+ class_fields = get_class_fields(cls)
+
+ # a search with the exact value
+ for name, cf in class_fields.items():
+ if (
+ snake_case(name) == snake_case(attribute_name)
+ or ('name' in cf.metadata and cf.metadata['name'] == attribute_name)
+ ):
+ return name
+
+ # search regex after to avoid shadowing perfect match
+ pattern = re.compile(attribute_name, flags=re_flags)
+ for name, cf in class_fields.items():
+ # print(f"\t->{name} : {attribute_name} {pattern.match(name)} {('name' in cf.metadata and pattern.match(cf.metadata['name']))}")
+ if pattern.match(name) or ('name' in cf.metadata and pattern.match(cf.metadata['name'])):
+ return name
+
+ return None
+def get_obj_type(obj: Any) ‑> str
+Return the type name of an object. If obj is already a :class:type, return its name
def get_obj_type(obj: Any) -> str:
+ """ Return the type name of an object. If obj is already a :class:`type`, return its __name__"""
+ if isinstance(obj, type):
+ return str(obj.__name__)
+ return get_obj_type(type(obj))
+def get_obj_uuid(obj: Any) ‑> str
+Return the object uuid (attribute must match the following regex : "[Uu]u?id|UUID"). +:param obj: +:return:
def get_obj_uuid(obj: Any) -> str:
+ """
+ Return the object uuid (attribute must match the following regex : "[Uu]u?id|UUID").
+ :param obj:
+ :return:
+ """
+ return get_object_attribute_rgx(obj, "[Uu]u?id|UUID")
+def get_obj_version(obj: Any) ‑> str
+Return the object version (check for "object_version" or "version_string" attribute). +:param obj: +:return:
def get_obj_version(obj: Any) -> str:
+ """
+ Return the object version (check for "object_version" or "version_string" attribute).
+ :param obj:
+ :return:
+ """
+ try:
+ return get_object_attribute_no_verif(obj, "object_version")
+ except AttributeError as e:
+ try:
+ return get_object_attribute_no_verif(obj, "version_string")
+ except Exception:
+ print(f"Error with {type(obj)}")
+ raise e
+def get_object_attribute(obj: Any, attr_dot_path: str, force_snake_case=True) ‑> Any
+returns the value of an attribute given by a dot representation of its path in the object +example "Citation.Title"
def get_object_attribute(
+ obj: Any, attr_dot_path: str, force_snake_case=True
+) -> Any:
+ """
+ returns the value of an attribute given by a dot representation of its path in the object
+ example "Citation.Title"
+ """
+ while attr_dot_path.startswith("."): # avoid '.Citation.Title' to take an empty attribute name before the first '.'
+ attr_dot_path = attr_dot_path[1:]
+
+ current_attrib_name = attr_dot_path
+
+ if "." in attr_dot_path:
+ current_attrib_name = attr_dot_path.split(".")[0]
+
+ if force_snake_case:
+ current_attrib_name = snake_case(current_attrib_name)
+
+ value = None
+ if isinstance(obj, list):
+ value = obj[int(current_attrib_name)]
+ elif isinstance(obj, dict):
+ value = obj[current_attrib_name]
+ else:
+ value = getattr(obj, current_attrib_name)
+
+ if "." in attr_dot_path:
+ return get_object_attribute(
+ value, attr_dot_path[len(current_attrib_name) + 1:]
+ )
+ else:
+ return value
+def get_object_attribute_advanced(obj: Any, attr_dot_path: str) ‑> Any
+see @get_matching_class_attribute_name and @get_object_attribute
def get_object_attribute_advanced(obj: Any, attr_dot_path: str) -> Any:
+ """
+ see @get_matching_class_attribute_name and @get_object_attribute
+ """
+ current_attrib_name = attr_dot_path
+
+ if "." in attr_dot_path:
+ current_attrib_name = attr_dot_path.split(".")[0]
+
+ current_attrib_name = get_matching_class_attribute_name(
+ obj, current_attrib_name
+ )
+
+ value = None
+ if isinstance(obj, list):
+ value = obj[int(current_attrib_name)]
+ elif isinstance(obj, dict):
+ value = obj[current_attrib_name]
+ else:
+ value = getattr(obj, current_attrib_name)
+
+ if "." in attr_dot_path:
+ return get_object_attribute_advanced(
+ value, attr_dot_path[len(current_attrib_name) + 1:]
+ )
+ else:
+ return value
+def get_object_attribute_no_verif(obj: Any, attr_name: str) ‑> Any
+Return the value of the attribute named after param :param:attr_name without verification (may raise an exception
+if it doesn't exists).
Note: attr_name="0" will work if :param:obj is of type :class:List
+:param obj:
+:param attr_name:
+:return:
def get_object_attribute_no_verif(obj: Any, attr_name: str) -> Any:
+ """
+ Return the value of the attribute named after param :param:`attr_name` without verification (may raise an exception
+ if it doesn't exists).
+
+ Note: attr_name="0" will work if :param:`obj` is of type :class:`List`
+ :param obj:
+ :param attr_name:
+ :return:
+ """
+ if isinstance(obj, list):
+ return obj[int(attr_name)]
+ elif isinstance(obj, dict):
+ return obj[attr_name]
+ else:
+ return getattr(obj, attr_name)
+def get_object_attribute_rgx(obj: Any, attr_dot_path_rgx: str) ‑> Any
+see @get_object_attribute. Search the attribute name using regex for values between dots. +Example : [Cc]itation.[Tt]it.*
def get_object_attribute_rgx(obj: Any, attr_dot_path_rgx: str) -> Any:
+ """
+ see @get_object_attribute. Search the attribute name using regex for values between dots.
+ Example : [Cc]itation.[Tt]it\\.*
+ """
+ current_attrib_name = attr_dot_path_rgx
+
+ attrib_list = re.split(r"(?<!\\)\.+", attr_dot_path_rgx)
+
+ if len(attrib_list) > 0:
+ current_attrib_name = attrib_list[0]
+
+ # unescape Dot
+ current_attrib_name = current_attrib_name.replace("\\.", ".")
+
+ real_attrib_name = get_matching_class_attribute_name(
+ obj, current_attrib_name
+ )
+ if real_attrib_name is not None:
+ value = get_object_attribute_no_verif(obj, real_attrib_name)
+
+ if len(attrib_list) > 1:
+ return get_object_attribute_rgx(
+ value, attr_dot_path_rgx[len(current_attrib_name) + 1:]
+ )
+ else:
+ return value
+ return None
+def get_object_type_for_file_path_from_class(cls) ‑> str
+def get_object_type_for_file_path_from_class(cls) -> str:
+ # obj_type = get_obj_type(cls)
+ # pkg = get_class_pkg(cls)
+ # if re.match(r"Obj[A-Z].*", obj_type) is not None and pkg == "resqml":
+ # return "obj_" + obj_type[3:]
+ # return obj_type
+
+ try:
+ return cls.Meta.name # to work with 3d transformed in 3D and Obj[A-Z] in obj_[A-Z]
+ except AttributeError:
+ pkg = get_class_pkg(cls)
+ return get_obj_type(cls)
+def get_qualified_type_from_class(cls: Union[type, Any], print_dev_version=True)
+def get_qualified_type_from_class(cls: Union[type, Any], print_dev_version=True):
+ return (
+ get_data_object_type(cls, print_dev_version, 2)
+ .replace(".", "") + "." + get_object_type_for_file_path_from_class(cls)
+ )Import related modules for a specific energyml module. (See. :const:RELATED_MODULES)
+:param energyml_module_name:
+:return:
def import_related_module(energyml_module_name: str) -> None:
+ """
+ Import related modules for a specific energyml module. (See. :const:`RELATED_MODULES`)
+ :param energyml_module_name:
+ :return:
+ """
+ for related in RELATED_MODULES:
+ if energyml_module_name in related:
+ for m in related:
+ try:
+ import_module(m)
+ except Exception as e:
+ pass
+ # print(e)
+def is_abstract(cls: Union[type, Any]) ‑> bool
+Returns True if :param:cls is an abstract class
+:param cls:
+:return: bool
def is_abstract(cls: Union[type, Any]) -> bool:
+ """
+ Returns True if :param:`cls` is an abstract class
+ :param cls:
+ :return: bool
+ """
+ if isinstance(cls, type):
+ return not is_primitive(cls) and (cls.__name__.startswith("Abstract") or (hasattr(cls, "__dataclass_fields__") and len(cls.__dataclass_fields__)) == 0) and len(get_class_methods(cls)) == 0
+ return is_abstract(type(cls))
+def is_enum(cls: Union[type, Any])
+Returns True if :param:cls is an Enum
+:param cls:
+:return:
def is_enum(cls: Union[type, Any]):
+ """
+ Returns True if :param:`cls` is an Enum
+ :param cls:
+ :return:
+ """
+ if isinstance(cls, type):
+ return Enum in cls.__bases__
+ return is_enum(type(cls))
+def is_primitive(cls: Union[type, Any]) ‑> bool
+Returns True if :param:cls is a primitiv type or extends Enum
+:param cls:
+:return: bool
def is_primitive(cls: Union[type, Any]) -> bool:
+ """
+ Returns True if :param:`cls` is a primitiv type or extends Enum
+ :param cls:
+ :return: bool
+ """
+ if isinstance(cls, type):
+ return cls in primitives or Enum in cls.__bases__
+ return is_primitive(type(cls))
+def now(time_zone=datetime.timezone(datetime.timedelta(seconds=3600), 'UTC')) ‑> int
+Return an epoch value
def now(time_zone=datetime.timezone(datetime.timedelta(hours=1), "UTC")) -> int:
+ """ Return an epoch value """
+ return int(datetime.datetime.timestamp(datetime.datetime.now(time_zone)))
+def pascal_case(s: str) ‑> str
+Transform a str into pascal case.
def pascal_case(s: str) -> str:
+ """ Transform a str into pascal case. """
+ return snake_case(s).replace("_", " ").title().replace(" ", "")
+def random_value_from_class(cls: type)
+Generate a random value for a :class:type. All attributes should be filled with random values.
+:param cls:
+:return:
def random_value_from_class(cls: type):
+ """
+ Generate a random value for a :class:`type`. All attributes should be filled with random values.
+ :param cls:
+ :return:
+ """
+ energyml_module_context = []
+ if not is_primitive(cls):
+ # import_related_module(cls.__module__)
+ energyml_module_context = get_related_energyml_modules_name(cls)
+ return _random_value_from_class(cls=cls, energyml_module_context=energyml_module_context, attribute_name=None)
+def search_attribute_in_upper_matching_name(obj: Any, name_rgx: str, root_obj: Optional[Any] = None, re_flags=re.IGNORECASE, current_path: str = '') ‑> Optional[Any]
+See :func:search_attribute_matching_type_with_path(). It only returns the value not the path
+:param obj:
+:param name_rgx:
+:param root_obj:
+:param re_flags:
+:param current_path:
+:return:
def search_attribute_in_upper_matching_name(
+ obj: Any,
+ name_rgx: str,
+ root_obj: Optional[Any] = None,
+ re_flags=re.IGNORECASE,
+ current_path: str = "",
+) -> Optional[Any]:
+ """
+ See :func:`search_attribute_matching_type_with_path`. It only returns the value not the path
+ :param obj:
+ :param name_rgx:
+ :param root_obj:
+ :param re_flags:
+ :param current_path:
+ :return:
+ """
+ elt_list = search_attribute_matching_name(obj, name_rgx, search_in_sub_obj=False, deep_search=False)
+ if elt_list is not None and len(elt_list) > 0:
+ return elt_list
+
+ if obj != root_obj:
+ upper_path = current_path[:current_path.rindex(".")]
+ if len(upper_path) > 0:
+ return search_attribute_in_upper_matching_name(
+ obj=get_object_attribute(root_obj, upper_path),
+ name_rgx=name_rgx,
+ root_obj=root_obj,
+ re_flags=re_flags,
+ current_path=upper_path,
+ )
+
+ return None
+def search_attribute_matching_name(obj: Any, name_rgx: str, re_flags=re.IGNORECASE, deep_search: bool = True, search_in_sub_obj: bool = True) ‑> List[Any]
+See :func:search_attribute_matching_name_with_path(). It only returns the value not the path
:param obj: +:param name_rgx: +:param re_flags: +:param deep_search: +:param search_in_sub_obj: +:return:
def search_attribute_matching_name(
+ obj: Any,
+ name_rgx: str,
+ re_flags=re.IGNORECASE,
+ deep_search: bool = True, # Search inside a matching object
+ search_in_sub_obj: bool = True, # Search in obj attributes
+) -> List[Any]:
+ """
+ See :func:`search_attribute_matching_name_with_path`. It only returns the value not the path
+
+ :param obj:
+ :param name_rgx:
+ :param re_flags:
+ :param deep_search:
+ :param search_in_sub_obj:
+ :return:
+ """
+ return [
+ val
+ for path, val in search_attribute_matching_name_with_path(
+ obj=obj,
+ name_rgx=name_rgx,
+ re_flags=re_flags,
+ deep_search=deep_search,
+ search_in_sub_obj=search_in_sub_obj
+ )
+ ]
+def search_attribute_matching_name_with_path(obj: Any, name_rgx: str, re_flags=re.IGNORECASE, current_path: str = '', deep_search: bool = True, search_in_sub_obj: bool = True) ‑> List[Tuple[str, Any]]
+Returns a list of tuple (path, value) for each sub attribute with type matching param "name_rgx". +The path is a dot-version like ".Citation.Title" +:param obj: +:param name_rgx: +:param re_flags: +:param current_path: +:param deep_search: +:param search_in_sub_obj: +:return:
def search_attribute_matching_name_with_path(
+ obj: Any,
+ name_rgx: str,
+ re_flags=re.IGNORECASE,
+ current_path: str = "",
+ deep_search: bool = True, # Search inside a matching object
+ search_in_sub_obj: bool = True, # Search in obj attributes
+) -> List[Tuple[str, Any]]:
+ """
+ Returns a list of tuple (path, value) for each sub attribute with type matching param "name_rgx".
+ The path is a dot-version like ".Citation.Title"
+ :param obj:
+ :param name_rgx:
+ :param re_flags:
+ :param current_path:
+ :param deep_search:
+ :param search_in_sub_obj:
+ :return:
+ """
+ while name_rgx.startswith("."):
+ name_rgx = name_rgx[1:]
+ current_match = name_rgx
+ next_match = current_match
+ if '.' in current_match:
+ attrib_list = re.split(r"(?<!\\)\.+", name_rgx)
+ current_match = attrib_list[0]
+ next_match = '.'.join(attrib_list[1:])
+
+ res = []
+
+ match_value = None
+ match_path_and_obj = []
+ not_match_path_and_obj = []
+ if isinstance(obj, list):
+ cpt = 0
+ for s_o in obj:
+ match = re.match(current_match.replace("\\.", "."), str(cpt), flags=re_flags)
+ if match is not None:
+ match_value = match.group(0)
+ match_path_and_obj.append( (f"{current_path}.{cpt}", s_o) )
+ else:
+ not_match_path_and_obj.append( (f"{current_path}.{cpt}", s_o) )
+ cpt = cpt + 1
+ elif isinstance(obj, dict):
+ for k, s_o in obj.items():
+ match = re.match(current_match.replace("\\.", "."), k, flags=re_flags)
+ if match is not None:
+ match_value = match.group(0)
+ match_path_and_obj.append( (f"{current_path}.{k}", s_o) )
+ 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:
+ 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:
+ not_match_path_and_obj.append( (f"{current_path}.{att_name}", get_object_attribute_no_verif(obj, att_name)) )
+
+ for matched_path, matched in match_path_and_obj:
+ if next_match != current_match and len(next_match) > 0: # next_match is different, match is not final
+ res = res + search_attribute_matching_name_with_path(
+ obj=matched,
+ name_rgx=next_match,
+ re_flags=re_flags,
+ current_path=matched_path,
+ deep_search=False, # no deep with partial
+ search_in_sub_obj=False, # no partial search in sub obj with no match
+ )
+ else: # a complete match
+ res.append( (matched_path, matched) )
+ if deep_search:
+ res = res + search_attribute_matching_name_with_path(
+ obj=matched,
+ name_rgx=name_rgx,
+ re_flags=re_flags,
+ current_path=matched_path,
+ deep_search=deep_search, # no deep with partial
+ search_in_sub_obj=True,
+ )
+ if search_in_sub_obj:
+ for not_matched_path, not_matched in not_match_path_and_obj:
+ res = res + search_attribute_matching_name_with_path(
+ obj=not_matched,
+ name_rgx=name_rgx,
+ re_flags=re_flags,
+ current_path=not_matched_path,
+ deep_search=deep_search,
+ search_in_sub_obj=True,
+ )
+
+ return res
+def search_attribute_matching_type(obj: Any, type_rgx: str, re_flags=re.IGNORECASE, return_self: bool = True, deep_search: bool = True, super_class_search: bool = True) ‑> List[Any]
+See :func:search_attribute_matching_type_with_path(). It only returns the value not the path
+:param obj:
+:param type_rgx:
+:param re_flags:
+:param return_self:
+:param deep_search:
+:param super_class_search:
+:return:
def search_attribute_matching_type(
+ obj: Any,
+ type_rgx: str,
+ re_flags=re.IGNORECASE,
+ return_self: bool = True, # test directly on input object and not only in its attributes
+ deep_search: bool = True, # Search inside a matching object
+ super_class_search: bool = True, # Search inside in super classes of the object
+) -> List[Any]:
+ """
+ See :func:`search_attribute_matching_type_with_path`. It only returns the value not the path
+ :param obj:
+ :param type_rgx:
+ :param re_flags:
+ :param return_self:
+ :param deep_search:
+ :param super_class_search:
+ :return:
+ """
+ return [
+ val
+ for path, val in search_attribute_matching_type_with_path(
+ obj=obj,
+ type_rgx=type_rgx,
+ re_flags=re_flags,
+ return_self=return_self,
+ deep_search=deep_search,
+ super_class_search=super_class_search,
+ )
+ ]
+def search_attribute_matching_type_with_path(obj: Any, type_rgx: str, re_flags=re.IGNORECASE, return_self: bool = True, deep_search: bool = True, super_class_search: bool = True, current_path: str = '') ‑> List[Tuple[str, Any]]
+Returns a list of tuple (path, value) for each sub attribute with type matching param "type_rgx". +The path is a dot-version like ".Citation.Title" +:param obj: +:param type_rgx: +:param re_flags: +:param return_self: +:param deep_search: +:param super_class_search: +:param current_path: +:return:
def search_attribute_matching_type_with_path(
+ obj: Any,
+ type_rgx: str,
+ re_flags=re.IGNORECASE,
+ return_self: bool = True, # test directly on input object and not only in its attributes
+ deep_search: bool = True, # Search inside a matching object
+ super_class_search: bool = True, # Search inside in super classes of the object
+ current_path: str = "",
+) -> List[Tuple[str, Any]]:
+ """
+ Returns a list of tuple (path, value) for each sub attribute with type matching param "type_rgx".
+ The path is a dot-version like ".Citation.Title"
+ :param obj:
+ :param type_rgx:
+ :param re_flags:
+ :param return_self:
+ :param deep_search:
+ :param super_class_search:
+ :param current_path:
+ :return:
+ """
+ res = []
+ if obj is not None:
+ if return_self and class_match_rgx(
+ obj, type_rgx, super_class_search, re_flags
+ ):
+ res.append((current_path, obj))
+ if not deep_search:
+ return res
+
+ if isinstance(obj, list):
+ cpt = 0
+ for s_o in obj:
+ res = res + search_attribute_matching_type_with_path(
+ obj=s_o,
+ type_rgx=type_rgx,
+ re_flags=re_flags,
+ return_self=True,
+ deep_search=deep_search,
+ current_path=f"{current_path}.{cpt}",
+ super_class_search=super_class_search,
+ )
+ cpt = cpt + 1
+ elif isinstance(obj, dict):
+ for k, s_o in obj.items():
+ res = res + search_attribute_matching_type_with_path(
+ obj=s_o,
+ type_rgx=type_rgx,
+ re_flags=re_flags,
+ return_self=True,
+ deep_search=deep_search,
+ current_path=f"{current_path}.{k}",
+ super_class_search=super_class_search,
+ )
+ elif not is_primitive(obj):
+ for att_name in get_class_attributes(obj):
+ res = res + search_attribute_matching_type_with_path(
+ obj=get_object_attribute_rgx(obj, att_name),
+ type_rgx=type_rgx,
+ re_flags=re_flags,
+ return_self=True,
+ deep_search=deep_search,
+ current_path=f"{current_path}.{att_name}",
+ super_class_search=super_class_search,
+ )
+
+ return res
+def snake_case(s: str) ‑> str
+Transform a str into snake case.
def snake_case(s: str) -> str:
+ """ Transform a str into snake case. """
+ s = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', s)
+ s = re.sub('__([A-Z])', r'_\1', s)
+ s = re.sub('([a-z0-9])([A-Z])', r'\1_\2', s)
+ return s.lower()src.energyml.utils.manager# Copyright (c) 2023-2024 Geosiris.
+# SPDX-License-Identifier: Apache-2.0
+import importlib
+import inspect
+import pkgutil
+import re
+from typing import List, Union, Any
+
+REGEX_ENERGYML_MODULE_NAME = r"energyml\.(?P<pkg>.*)\.v(?P<version>(?P<versionNumber>\d+(_\d+)*)(_dev(?P<versionDev>.*))?)\..*"
+REGEX_PROJECT_VERSION = r"(?P<n0>[\d]+)(.(?P<n1>[\d]+)(.(?P<n2>[\d]+))?)?"
+
+ENERGYML_MODULES_NAMES = ["eml", "prodml", "witsml", "resqml"]
+
+RELATED_MODULES = [
+ ["energyml.eml.v2_0.commonv2", "energyml.resqml.v2_0_1.resqmlv2"],
+ [
+ "energyml.eml.v2_1.commonv2",
+ "energyml.prodml.v2_0.prodmlv2",
+ "energyml.witsml.v2_0.witsmlv2",
+ ],
+ ["energyml.eml.v2_2.commonv2", "energyml.resqml.v2_2_dev3.resqmlv2"],
+ [
+ "energyml.eml.v2_3.commonv2",
+ "energyml.resqml.v2_2.resqmlv2",
+ "energyml.prodml.v2_2.prodmlv2",
+ "energyml.witsml.v2_1.witsmlv2",
+ ],
+]
+
+
+def get_related_energyml_modules_name(cls: Union[type, Any]) -> List[str]:
+ """
+ Return the list of all energyml modules related to another one.
+ For example resqml 2.0.1 is related to common 2.0
+ :param cls:
+ :return:
+ """
+ if isinstance(cls, type):
+ for related in RELATED_MODULES:
+ if cls.__module__ in related:
+ return related
+ else:
+ return get_related_energyml_modules_name(type(cls))
+ return []
+
+
+def dict_energyml_modules() -> List:
+ """
+ List all accessible energyml python modules
+ :return:
+ """
+ modules = {}
+
+ energyml_module = importlib.import_module("energyml")
+ # print("> energyml")
+
+ for mod in pkgutil.iter_modules(energyml_module.__path__):
+ # print(f"{mod.name}")
+ if mod.name in ENERGYML_MODULES_NAMES:
+ energyml_sub_module = importlib.import_module(
+ f"energyml.{mod.name}"
+ )
+ if mod.name not in modules:
+ modules[mod.name] = []
+ for sub_mod in pkgutil.iter_modules(energyml_sub_module.__path__):
+ modules[mod.name].append(sub_mod.name)
+ # modules[mod.name].append(re.sub(r"^\D*(?P<number>\d+(.\d+)*$)",
+ # r"\g<number>", sub_mod.name).replace("_", "."))
+ return modules
+
+
+def list_energyml_modules():
+ try:
+ energyml_module = importlib.import_module("energyml")
+ modules = []
+ for obj in pkgutil.iter_modules(energyml_module.__path__):
+ # print(f"{obj.name}")
+ if obj.name in ENERGYML_MODULES_NAMES:
+ modules.append(obj.name)
+ return modules
+ except ModuleNotFoundError:
+ return []
+
+
+def list_classes(module_path: str) -> List:
+ """
+ List all accessible classes from a specific module
+ :param module_path:
+ :return:
+ """
+ try:
+ module = importlib.import_module(module_path)
+ class_list = []
+ for _, obj in inspect.getmembers(module):
+ if inspect.isclass(obj):
+ class_list.append(obj)
+ return class_list
+ except ModuleNotFoundError:
+ print(f"Err : module {module_path} not found")
+ return []
+
+
+def get_sub_classes(cls: type) -> List[type]:
+ """
+ Return all classes that extends the class :param:`cls`.
+ :param cls:
+ :return:
+ """
+ sub_classes = []
+ for related in get_related_energyml_modules_name(cls):
+ try:
+ module = importlib.import_module(related)
+ for _, obj in inspect.getmembers(module):
+ if inspect.isclass(obj) and cls in obj.__bases__:
+ sub_classes.append(obj)
+ sub_classes = sub_classes + get_sub_classes(obj)
+ except ModuleNotFoundError:
+ pass
+ return list(dict.fromkeys(sub_classes))
+
+
+def get_classes_matching_name(cls: type, name_rgx: str, re_flags=re.IGNORECASE,) -> List[type]:
+ """
+ Search a class matching the regex @re_flags. The search is the energyml packages related to the objet type @cls.
+ :param cls:
+ :param name_rgx:
+ :param re_flags:
+ :return:
+ """
+ match_classes = []
+ for related in get_related_energyml_modules_name(cls):
+ try:
+ module = importlib.import_module(related)
+ for _, obj in inspect.getmembers(module):
+ if inspect.isclass(obj) and re.match(name_rgx, obj.__name__, re_flags):
+ match_classes.append(obj)
+ except ModuleNotFoundError:
+ pass
+ return list(dict.fromkeys(match_classes))
+
+
+def get_all_energyml_classes() -> dict:
+ result = {}
+ for mod_name, versions in dict_energyml_modules().items():
+ for version in versions:
+ result = result | get_all_classes(mod_name, version)
+ return result
+
+
+def get_all_classes(module_name: str, version: str) -> dict:
+ result = {}
+ pkg_path = f"energyml.{module_name}.{version}"
+ package = importlib.import_module(pkg_path)
+ for _, modname, _ in pkgutil.walk_packages(
+ path=getattr(package, "__path__"),
+ prefix=package.__name__ + ".",
+ onerror=lambda x: None,
+ ):
+ result[pkg_path] = []
+ for classFound in list_classes(modname):
+ try:
+ result[pkg_path].append(classFound)
+ except Exception:
+ pass
+
+ return result
+
+
+def get_class_pkg(cls):
+ try:
+ p = re.compile(REGEX_ENERGYML_MODULE_NAME)
+ m = p.search(cls.__module__)
+ return m.group("pkg")
+ except AttributeError as e:
+ print(f"Exception to get class package for '{cls}'")
+ raise e
+
+
+def reshape_version(version: str, nb_digit: int) -> str:
+ """
+ Reshape a project version to have only specific number of digits. If 0 < nbDigit < 4 then the reshape is done,
+ else, the original version is returned.
+ Example : reshapeVersion("v2.0.1", 2) ==> "2.0" and reshapeVersion("version2.0.1.3.2.5", 4) ==> "version2.0.1.3.2.5"
+ """
+ p = re.compile(REGEX_PROJECT_VERSION)
+ m = p.search(version)
+ if m is not None:
+ n0 = m.group("n0")
+ n1 = m.group("n1")
+ n2 = m.group("n2")
+ if nb_digit == 1:
+ return n0
+ elif nb_digit == 2:
+ return n0 + ("." + n1 if n1 is not None else "")
+ elif nb_digit == 3:
+ return n0 + (
+ "." + n1 + ("." + n2 if n2 is not None else "")
+ if n1 is not None
+ else ""
+ )
+
+ return version
+
+
+def get_class_pkg_version(
+ cls, print_dev_version: bool = True, nb_max_version_digits: int = 2
+):
+ p = re.compile(REGEX_ENERGYML_MODULE_NAME)
+ m = p.search(
+ cls.__module__ if isinstance(cls, type) else type(cls).__module__
+ )
+ return reshape_version(m.group("versionNumber"), nb_max_version_digits) + (
+ m.group("versionDev")
+ if m.group("versionDev") is not None and print_dev_version
+ else ""
+ )
+
+
+# ProtocolDict = DefaultDict[str, MessageDict]
+# def get_all__classes() -> ProtocolDict:
+# protocolDict: ProtocolDict = defaultdict(
+# lambda: defaultdict(type(ETPModel))
+# )
+# package = energyml
+# for _, modname, _ in pkgutil.walk_packages(
+# path=getattr(package, "__path__"),
+# prefix=package.__name__ + ".",
+# onerror=lambda x: None,
+# ):
+# for classFound in list_classes(modname):
+# try:
+# schem = json.loads(avro_schema(classFound))
+# protocolId = schem["protocol"]
+# messageType = schem["messageType"]
+# protocolDict[protocolId][messageType] = classFound
+# except Exception:
+# pass
+# return protocolDict
+def dict_energyml_modules() ‑> List
+List all accessible energyml python modules +:return:
def dict_energyml_modules() -> List:
+ """
+ List all accessible energyml python modules
+ :return:
+ """
+ modules = {}
+
+ energyml_module = importlib.import_module("energyml")
+ # print("> energyml")
+
+ for mod in pkgutil.iter_modules(energyml_module.__path__):
+ # print(f"{mod.name}")
+ if mod.name in ENERGYML_MODULES_NAMES:
+ energyml_sub_module = importlib.import_module(
+ f"energyml.{mod.name}"
+ )
+ if mod.name not in modules:
+ modules[mod.name] = []
+ for sub_mod in pkgutil.iter_modules(energyml_sub_module.__path__):
+ modules[mod.name].append(sub_mod.name)
+ # modules[mod.name].append(re.sub(r"^\D*(?P<number>\d+(.\d+)*$)",
+ # r"\g<number>", sub_mod.name).replace("_", "."))
+ return modules
+def get_all_classes(module_name: str, version: str) ‑> dict
+def get_all_classes(module_name: str, version: str) -> dict:
+ result = {}
+ pkg_path = f"energyml.{module_name}.{version}"
+ package = importlib.import_module(pkg_path)
+ for _, modname, _ in pkgutil.walk_packages(
+ path=getattr(package, "__path__"),
+ prefix=package.__name__ + ".",
+ onerror=lambda x: None,
+ ):
+ result[pkg_path] = []
+ for classFound in list_classes(modname):
+ try:
+ result[pkg_path].append(classFound)
+ except Exception:
+ pass
+
+ return result
+def get_all_energyml_classes() ‑> dict
+def get_all_energyml_classes() -> dict:
+ result = {}
+ for mod_name, versions in dict_energyml_modules().items():
+ for version in versions:
+ result = result | get_all_classes(mod_name, version)
+ return result
+def get_class_pkg(cls)
+def get_class_pkg(cls):
+ try:
+ p = re.compile(REGEX_ENERGYML_MODULE_NAME)
+ m = p.search(cls.__module__)
+ return m.group("pkg")
+ except AttributeError as e:
+ print(f"Exception to get class package for '{cls}'")
+ raise e
+def get_class_pkg_version(cls, print_dev_version: bool = True, nb_max_version_digits: int = 2)
+def get_class_pkg_version(
+ cls, print_dev_version: bool = True, nb_max_version_digits: int = 2
+):
+ p = re.compile(REGEX_ENERGYML_MODULE_NAME)
+ m = p.search(
+ cls.__module__ if isinstance(cls, type) else type(cls).__module__
+ )
+ return reshape_version(m.group("versionNumber"), nb_max_version_digits) + (
+ m.group("versionDev")
+ if m.group("versionDev") is not None and print_dev_version
+ else ""
+ )
+def get_classes_matching_name(cls: type, name_rgx: str, re_flags=re.IGNORECASE) ‑> List[type]
+Search a class matching the regex @re_flags. The search is the energyml packages related to the objet type @cls. +:param cls: +:param name_rgx: +:param re_flags: +:return:
def get_classes_matching_name(cls: type, name_rgx: str, re_flags=re.IGNORECASE,) -> List[type]:
+ """
+ Search a class matching the regex @re_flags. The search is the energyml packages related to the objet type @cls.
+ :param cls:
+ :param name_rgx:
+ :param re_flags:
+ :return:
+ """
+ match_classes = []
+ for related in get_related_energyml_modules_name(cls):
+ try:
+ module = importlib.import_module(related)
+ for _, obj in inspect.getmembers(module):
+ if inspect.isclass(obj) and re.match(name_rgx, obj.__name__, re_flags):
+ match_classes.append(obj)
+ except ModuleNotFoundError:
+ pass
+ return list(dict.fromkeys(match_classes))Return the list of all energyml modules related to another one. +For example resqml 2.0.1 is related to common 2.0 +:param cls: +:return:
def get_related_energyml_modules_name(cls: Union[type, Any]) -> List[str]:
+ """
+ Return the list of all energyml modules related to another one.
+ For example resqml 2.0.1 is related to common 2.0
+ :param cls:
+ :return:
+ """
+ if isinstance(cls, type):
+ for related in RELATED_MODULES:
+ if cls.__module__ in related:
+ return related
+ else:
+ return get_related_energyml_modules_name(type(cls))
+ return []
+def get_sub_classes(cls: type) ‑> List[type]
+Return all classes that extends the class :param:cls.
+:param cls:
+:return:
def get_sub_classes(cls: type) -> List[type]:
+ """
+ Return all classes that extends the class :param:`cls`.
+ :param cls:
+ :return:
+ """
+ sub_classes = []
+ for related in get_related_energyml_modules_name(cls):
+ try:
+ module = importlib.import_module(related)
+ for _, obj in inspect.getmembers(module):
+ if inspect.isclass(obj) and cls in obj.__bases__:
+ sub_classes.append(obj)
+ sub_classes = sub_classes + get_sub_classes(obj)
+ except ModuleNotFoundError:
+ pass
+ return list(dict.fromkeys(sub_classes))
+def list_classes(module_path: str) ‑> List
+List all accessible classes from a specific module +:param module_path: +:return:
def list_classes(module_path: str) -> List:
+ """
+ List all accessible classes from a specific module
+ :param module_path:
+ :return:
+ """
+ try:
+ module = importlib.import_module(module_path)
+ class_list = []
+ for _, obj in inspect.getmembers(module):
+ if inspect.isclass(obj):
+ class_list.append(obj)
+ return class_list
+ except ModuleNotFoundError:
+ print(f"Err : module {module_path} not found")
+ return []
+def list_energyml_modules()
+def list_energyml_modules():
+ try:
+ energyml_module = importlib.import_module("energyml")
+ modules = []
+ for obj in pkgutil.iter_modules(energyml_module.__path__):
+ # print(f"{obj.name}")
+ if obj.name in ENERGYML_MODULES_NAMES:
+ modules.append(obj.name)
+ return modules
+ except ModuleNotFoundError:
+ return []
+def reshape_version(version: str, nb_digit: int) ‑> str
+Reshape a project version to have only specific number of digits. If 0 < nbDigit < 4 then the reshape is done, +else, the original version is returned. +Example : reshapeVersion("v2.0.1", 2) ==> "2.0" and reshapeVersion("version2.0.1.3.2.5", 4) ==> "version2.0.1.3.2.5"
def reshape_version(version: str, nb_digit: int) -> str:
+ """
+ Reshape a project version to have only specific number of digits. If 0 < nbDigit < 4 then the reshape is done,
+ else, the original version is returned.
+ Example : reshapeVersion("v2.0.1", 2) ==> "2.0" and reshapeVersion("version2.0.1.3.2.5", 4) ==> "version2.0.1.3.2.5"
+ """
+ p = re.compile(REGEX_PROJECT_VERSION)
+ m = p.search(version)
+ if m is not None:
+ n0 = m.group("n0")
+ n1 = m.group("n1")
+ n2 = m.group("n2")
+ if nb_digit == 1:
+ return n0
+ elif nb_digit == 2:
+ return n0 + ("." + n1 if n1 is not None else "")
+ elif nb_digit == 3:
+ return n0 + (
+ "." + n1 + ("." + n2 if n2 is not None else "")
+ if n1 is not None
+ else ""
+ )
+
+ return versionsrc.energyml.utils.serialization# Copyright (c) 2023-2024 Geosiris.
+# SPDX-License-Identifier: Apache-2.0
+from io import BytesIO
+from typing import Optional, Any
+
+import energyml
+from xsdata.exceptions import ParserError
+from xsdata.formats.dataclass.context import XmlContext
+from xsdata.formats.dataclass.parsers import XmlParser
+from xsdata.formats.dataclass.serializers import JsonSerializer
+from xsdata.formats.dataclass.serializers import XmlSerializer
+from xsdata.formats.dataclass.serializers.config import SerializerConfig
+
+from .introspection import get_class_from_name
+from .xml import get_class_name_from_xml, get_tree
+
+
+def read_energyml_xml_bytes_as_class(file: bytes, obj_class: type) -> Any:
+ """
+ Read an xml file into the instance of type :param:`obj_class`.
+ :param file:
+ :param obj_class:
+ :return:
+ """
+ parser = XmlParser()
+ try:
+ return parser.from_bytes(file, obj_class)
+ except ParserError as e:
+ print(f"Failed to parse file {file} as class {obj_class}")
+ raise e
+
+
+def read_energyml_xml_bytes(file: bytes) -> Any:
+ """
+ Read an xml file. The type of object is searched from the xml root name.
+ :param file:
+ :return:
+ """
+ return read_energyml_xml_bytes_as_class(
+ file, get_class_from_name(get_class_name_from_xml(get_tree(file)))
+ )
+
+
+def read_energyml_xml_io(file: BytesIO, obj_class: Optional[type] = None) -> Any:
+ if obj_class is not None:
+ return read_energyml_xml_bytes_as_class(file.getbuffer(), obj_class)
+ else:
+ return read_energyml_xml_bytes(file.getbuffer())
+
+
+def read_energyml_xml_str(file_content: str) -> Any:
+ parser = XmlParser()
+ # from energyml.resqml.v2_2.resqmlv2 import TriangulatedSetRepresentation
+ return parser.from_string(
+ file_content,
+ get_class_from_name(get_class_name_from_xml(get_tree(file_content))),
+ ) # , TriangulatedSetRepresentation)
+
+
+def read_energyml_xml_file(file_path: str) -> Any:
+ xml_content = ""
+ with open(file_path, "r") as f:
+ xml_content = f.read()
+ parser = XmlParser()
+ # from energyml.resqml.v2_2.resqmlv2 import TriangulatedSetRepresentation
+ # return parser.parse(file_path) # , TriangulatedSetRepresentation)
+ return parser.parse(
+ file_path,
+ get_class_from_name(get_class_name_from_xml(get_tree(xml_content))),
+ )
+
+
+def serialize_xml(obj) -> str:
+ context = XmlContext(
+ # element_name_generator=text.camel_case,
+ # attribute_name_generator=text.kebab_case
+ )
+ serializer_config = SerializerConfig(indent=" ")
+ serializer = XmlSerializer(context=context, config=serializer_config)
+ return serializer.render(obj)
+
+
+def serialize_json(obj) -> str:
+ context = XmlContext(
+ # element_name_generator=text.camel_case,
+ # attribute_name_generator=text.kebab_case
+ )
+ serializer_config = SerializerConfig(indent=" ")
+ serializer = JsonSerializer(context=context, config=serializer_config)
+ return serializer.render(obj)
+def read_energyml_xml_bytes(file: bytes) ‑> Any
+Read an xml file. The type of object is searched from the xml root name. +:param file: +:return:
def read_energyml_xml_bytes(file: bytes) -> Any:
+ """
+ Read an xml file. The type of object is searched from the xml root name.
+ :param file:
+ :return:
+ """
+ return read_energyml_xml_bytes_as_class(
+ file, get_class_from_name(get_class_name_from_xml(get_tree(file)))
+ )
+def read_energyml_xml_bytes_as_class(file: bytes, obj_class: type) ‑> Any
+Read an xml file into the instance of type :param:obj_class.
+:param file:
+:param obj_class:
+:return:
def read_energyml_xml_bytes_as_class(file: bytes, obj_class: type) -> Any:
+ """
+ Read an xml file into the instance of type :param:`obj_class`.
+ :param file:
+ :param obj_class:
+ :return:
+ """
+ parser = XmlParser()
+ try:
+ return parser.from_bytes(file, obj_class)
+ except ParserError as e:
+ print(f"Failed to parse file {file} as class {obj_class}")
+ raise e
+def read_energyml_xml_file(file_path: str) ‑> Any
+def read_energyml_xml_file(file_path: str) -> Any:
+ xml_content = ""
+ with open(file_path, "r") as f:
+ xml_content = f.read()
+ parser = XmlParser()
+ # from energyml.resqml.v2_2.resqmlv2 import TriangulatedSetRepresentation
+ # return parser.parse(file_path) # , TriangulatedSetRepresentation)
+ return parser.parse(
+ file_path,
+ get_class_from_name(get_class_name_from_xml(get_tree(xml_content))),
+ )
+def read_energyml_xml_io(file: _io.BytesIO, obj_class: Optional[type] = None) ‑> Any
+def read_energyml_xml_io(file: BytesIO, obj_class: Optional[type] = None) -> Any:
+ if obj_class is not None:
+ return read_energyml_xml_bytes_as_class(file.getbuffer(), obj_class)
+ else:
+ return read_energyml_xml_bytes(file.getbuffer())
+def read_energyml_xml_str(file_content: str) ‑> Any
+def read_energyml_xml_str(file_content: str) -> Any:
+ parser = XmlParser()
+ # from energyml.resqml.v2_2.resqmlv2 import TriangulatedSetRepresentation
+ return parser.from_string(
+ file_content,
+ get_class_from_name(get_class_name_from_xml(get_tree(file_content))),
+ ) # , TriangulatedSetRepresentation)
+def serialize_json(obj) ‑> str
+def serialize_json(obj) -> str:
+ context = XmlContext(
+ # element_name_generator=text.camel_case,
+ # attribute_name_generator=text.kebab_case
+ )
+ serializer_config = SerializerConfig(indent=" ")
+ serializer = JsonSerializer(context=context, config=serializer_config)
+ return serializer.render(obj)
+def serialize_xml(obj) ‑> str
+def serialize_xml(obj) -> str:
+ context = XmlContext(
+ # element_name_generator=text.camel_case,
+ # attribute_name_generator=text.kebab_case
+ )
+ serializer_config = SerializerConfig(indent=" ")
+ serializer = XmlSerializer(context=context, config=serializer_config)
+ return serializer.render(obj)src.energyml.utils.validation# Copyright (c) 2023-2024 Geosiris.
+# SPDX-License-Identifier: Apache-2.0
+import re
+from dataclasses import dataclass, field, Field
+from enum import Enum
+from typing import Any, List
+
+from .epc import (
+ get_obj_identifier, Epc,
+)
+from .introspection import (
+ get_class_fields,
+ get_object_attribute,
+ search_attribute_matching_type_with_path,
+ get_object_attribute_no_verif,
+ get_object_attribute_rgx,
+ get_matching_class_attribute_name, get_obj_uuid, get_obj_version, get_content_type_from_class,
+ get_qualified_type_from_class,
+)
+
+
+class ErrorType(Enum):
+ CRITICAL = "critical"
+ DEBUG = "debug"
+ INFO = "info"
+ WARNING = "warning"
+
+
+@dataclass
+class ValidationError:
+
+ msg: str = field(default="Validation error")
+
+ error_type: ErrorType = field(default=ErrorType.INFO)
+
+ def __str__(self):
+ return f"[{str(self.error_type).upper()}] : {self.msg}"
+
+
+@dataclass
+class ValidationObjectError(ValidationError):
+
+ target_obj: Any = field(default=None)
+
+ attribute_dot_path: str = field(default=None)
+
+ def __str__(self):
+ return f"{ValidationError.__str__(self)}\n\t{get_obj_identifier(self.target_obj)} : '{self.attribute_dot_path}'"
+
+
+@dataclass
+class MandatoryError(ValidationObjectError):
+ def __str__(self):
+ return f"{ValidationError.__str__(self)}\n\tMandatory value is None for {get_obj_identifier(self.target_obj)} : '{self.attribute_dot_path}'"
+
+
+def validate_epc(epc: Epc) -> List[ValidationError]:
+ """
+ Verify if all :param:`epc`'s objects are valid.
+ :param epc:
+ :return:
+ """
+ errs = []
+ for obj in epc.energyml_objects:
+ errs = errs + patterns_verification(obj)
+
+ errs = errs + dor_verification(epc.energyml_objects)
+
+ return errs
+
+
+def dor_verification(energyml_objects: List[Any]) -> List[ValidationError]:
+ """
+ Verification for DOR. An error is raised if DORs contains wrong information, or if a referenced object is unknown
+ in the :param:`epc`.
+ :param energyml_objects:
+ :return:
+ """
+ errs = []
+
+ dict_obj_identifier = {
+ get_obj_identifier(obj): obj for obj in energyml_objects
+ }
+ dict_obj_uuid = {}
+ for obj in energyml_objects:
+ uuid = get_obj_uuid(obj)
+ if uuid not in dict_obj_uuid:
+ dict_obj_uuid[uuid] = []
+ dict_obj_uuid[uuid].append(obj)
+
+ # TODO: chercher dans les objets les AbstractObject (en Witsml des sous objet peuvent etre aussi references)
+
+ for obj in energyml_objects:
+ dor_list = search_attribute_matching_type_with_path(
+ obj, "DataObjectReference"
+ )
+ for dor_path, dor in dor_list:
+ dor_target_id = get_obj_identifier(dor)
+ if dor_target_id not in dict_obj_identifier:
+ dor_uuid = get_obj_uuid(dor)
+ dor_version = get_obj_version(dor)
+ if dor_uuid not in dict_obj_uuid:
+ errs.append(
+ ValidationObjectError(
+ error_type=ErrorType.CRITICAL,
+ target_obj=obj,
+ attribute_dot_path=dor_path,
+ msg=f"[DOR ERR] has wrong information. Unkown object with uuid '{dor_uuid}'",
+ )
+ )
+ else:
+ accessible_version = [
+ get_obj_version(ref_obj)
+ for ref_obj in dict_obj_uuid[dor_uuid]
+ ]
+ errs.append(
+ ValidationObjectError(
+ error_type=ErrorType.CRITICAL,
+ target_obj=obj,
+ attribute_dot_path=dor_path,
+ msg=f"[DOR ERR] has wrong information. Unkown object version '{dor_version}'. "
+ f"Version must be one of {accessible_version}",
+ )
+ )
+ else:
+ target = dict_obj_identifier[dor_target_id]
+ target_title = get_object_attribute_rgx(
+ target, "citation.title"
+ )
+ target_content_type = get_content_type_from_class(target)
+ target_qualified_type = get_qualified_type_from_class(target)
+
+ dor_title = get_object_attribute_rgx(dor, "title")
+
+ if dor_title != target_title:
+ errs.append(
+ ValidationObjectError(
+ error_type=ErrorType.CRITICAL,
+ target_obj=obj,
+ attribute_dot_path=dor_path,
+ msg=f"[DOR ERR] has wrong information. Title should be '{target_title}' and not '{dor_title}'",
+ )
+ )
+
+ if (
+ get_matching_class_attribute_name(dor, "content_type")
+ is not None
+ ):
+ dor_content_type = get_object_attribute_no_verif(
+ dor, "content_type"
+ )
+ if dor_content_type != target_content_type:
+ errs.append(
+ ValidationObjectError(
+ error_type=ErrorType.CRITICAL,
+ target_obj=obj,
+ attribute_dot_path=dor_path,
+ msg=f"[DOR ERR] has wrong information. ContentType should be '{target_content_type}' and not '{dor_content_type}'",
+ )
+ )
+
+ if (
+ get_matching_class_attribute_name(dor, "qualified_type")
+ is not None
+ ):
+ dor_qualified_type = get_object_attribute_no_verif(
+ dor, "qualified_type"
+ )
+ if dor_qualified_type != target_qualified_type:
+ errs.append(
+ ValidationObjectError(
+ error_type=ErrorType.CRITICAL,
+ target_obj=obj,
+ attribute_dot_path=dor_path,
+ msg=f"[DOR ERR] has wrong information. QualifiedType should be '{target_qualified_type}' and not '{dor_qualified_type}'",
+ )
+ )
+
+ return errs
+
+
+def patterns_verification(obj: Any) -> List[ValidationError]:
+ """
+ Verification on object values, using the patterns defined in the original energyml xsd files.
+ :param obj:
+ :return:
+ """
+ return _patterns_verification(obj, obj, "")
+
+
+def _patterns_verification(
+ obj: Any, root_obj: Any, current_attribute_dot_path: str = ""
+) -> List[ValidationError]:
+ """
+ Verification on object values, using the patterns defined in the original energyml xsd files.
+ :param obj:
+ :param root_obj:
+ :param current_attribute_dot_path:
+ :return:
+ """
+ error_list = []
+
+ if isinstance(obj, list):
+ cpt = 0
+ for val in obj:
+ error_list = error_list + _patterns_verification(
+ val, root_obj, f"{current_attribute_dot_path}.{cpt}"
+ )
+ cpt = cpt + 1
+ elif isinstance(obj, dict):
+ for k, val in obj.items():
+ error_list = error_list + _patterns_verification(
+ val, root_obj, f"{current_attribute_dot_path}.{k}"
+ )
+ else:
+ # print(get_class_fields(obj))
+ for att_name, att_field in get_class_fields(obj).items():
+ # print(f"att_name : {att_field.metadata}")
+ error_list = error_list + validate_attribute(
+ get_object_attribute(obj, att_name, False),
+ root_obj,
+ att_field,
+ f"{current_attribute_dot_path}.{att_name}",
+ )
+
+ return error_list
+
+
+def validate_attribute(
+ value: Any, root_obj: Any, att_field: Field, path: str
+) -> List[ValidationError]:
+ errs = []
+
+ if value is None:
+ if att_field.metadata.get("required", False):
+ errs.append(
+ MandatoryError(
+ error_type=ErrorType.CRITICAL,
+ target_obj=root_obj,
+ attribute_dot_path=path,
+ )
+ )
+ else:
+ min_length = att_field.metadata.get("min_length", None)
+ max_length = att_field.metadata.get("max_length", None)
+ pattern = att_field.metadata.get("pattern", None)
+ min_occurs = att_field.metadata.get("pattern", None)
+ min_inclusive = att_field.metadata.get("pattern", None)
+ # white_space
+
+ if max_length is not None:
+ length = len(value)
+ if length > max_length:
+ errs.append(
+ ValidationObjectError(
+ error_type=ErrorType.CRITICAL,
+ target_obj=root_obj,
+ attribute_dot_path=path,
+ msg=f"Max length was {max_length} but found {length}",
+ )
+ )
+
+ if min_length is not None:
+ length = len(value)
+ if length < min_length:
+ errs.append(
+ ValidationObjectError(
+ error_type=ErrorType.CRITICAL,
+ target_obj=root_obj,
+ attribute_dot_path=path,
+ msg=f"Max length was {min_length} but found {length}",
+ )
+ )
+
+ if min_occurs is not None:
+ if isinstance(value, list) and min_occurs > len(value):
+ errs.append(
+ ValidationObjectError(
+ error_type=ErrorType.CRITICAL,
+ target_obj=root_obj,
+ attribute_dot_path=path,
+ msg=f"Min occurs was {min_occurs} but found {len(value)}",
+ )
+ )
+
+ if min_inclusive is not None:
+ potential_err = ValidationObjectError(
+ error_type=ErrorType.CRITICAL,
+ target_obj=root_obj,
+ attribute_dot_path=path,
+ msg=f"Min occurs was {min_inclusive} but found {len(value)}",
+ )
+ if isinstance(value, list):
+ for val in value:
+ if (
+ (isinstance(val, str) and len(val) > min_inclusive)
+ or ((isinstance(val, int) or isinstance(val, float)) and val > min_inclusive)
+ ):
+ errs.append(potential_err)
+
+ if pattern is not None:
+ if re.match(pattern, value) is None:
+ errs.append(
+ ValidationObjectError(
+ error_type=ErrorType.CRITICAL,
+ target_obj=root_obj,
+ attribute_dot_path=path,
+ msg=f"Pattern error. Value '{value}' was supposed to respect pattern '{pattern}'",
+ )
+ )
+
+ return errs + _patterns_verification(
+ obj=value,
+ root_obj=root_obj,
+ current_attribute_dot_path=path,
+ )
+
+
+def correct_dor(energyml_objects: List[Any]) -> None:
+ """
+ Fix DOR errors (missing object_version, wrong title, wrong content-type/qualified-type ...)
+ :param energyml_objects:
+ :return:
+ """
+ dict_obj_identifier = {
+ get_obj_identifier(obj): obj for obj in energyml_objects
+ }
+ dict_obj_uuid = {}
+ for obj in energyml_objects:
+ uuid = get_obj_uuid(obj)
+ if uuid not in dict_obj_uuid:
+ dict_obj_uuid[uuid] = []
+ dict_obj_uuid[uuid].append(obj)
+
+ # TODO: chercher dans les objets les AbstractObject (en Witsml des sous objet peuvent etre aussi references)
+
+ for obj in energyml_objects:
+ dor_list = search_attribute_matching_type_with_path(
+ obj, "DataObjectReference"
+ )
+ for dor_path, dor in dor_list:
+ dor_target_id = get_obj_identifier(dor)
+ if dor_target_id in dict_obj_identifier:
+ target = dict_obj_identifier[dor_target_id]
+ target_title = get_object_attribute_rgx(
+ target, "citation.title"
+ )
+ target_content_type = get_content_type_from_class(target)
+ target_qualified_type = get_qualified_type_from_class(target)
+
+ dor_title = get_object_attribute_rgx(dor, "title")
+
+ if dor_title != target_title:
+ dor.title = target_title
+
+ if (
+ get_matching_class_attribute_name(dor, "content_type")
+ is not None
+ ):
+ dor_content_type = get_object_attribute_no_verif(
+ dor, "content_type"
+ )
+ if dor_content_type != target_content_type:
+ dor.content_type = target_content_type
+
+ if (
+ get_matching_class_attribute_name(dor, "qualified_type")
+ is not None
+ ):
+ dor_qualified_type = get_object_attribute_no_verif(
+ dor, "qualified_type"
+ )
+ if dor_qualified_type != target_qualified_type:
+ dor.qualified_type = target_qualified_type
+def correct_dor(energyml_objects: List[Any]) ‑> None
+Fix DOR errors (missing object_version, wrong title, wrong content-type/qualified-type …) +:param energyml_objects: +:return:
def correct_dor(energyml_objects: List[Any]) -> None:
+ """
+ Fix DOR errors (missing object_version, wrong title, wrong content-type/qualified-type ...)
+ :param energyml_objects:
+ :return:
+ """
+ dict_obj_identifier = {
+ get_obj_identifier(obj): obj for obj in energyml_objects
+ }
+ dict_obj_uuid = {}
+ for obj in energyml_objects:
+ uuid = get_obj_uuid(obj)
+ if uuid not in dict_obj_uuid:
+ dict_obj_uuid[uuid] = []
+ dict_obj_uuid[uuid].append(obj)
+
+ # TODO: chercher dans les objets les AbstractObject (en Witsml des sous objet peuvent etre aussi references)
+
+ for obj in energyml_objects:
+ dor_list = search_attribute_matching_type_with_path(
+ obj, "DataObjectReference"
+ )
+ for dor_path, dor in dor_list:
+ dor_target_id = get_obj_identifier(dor)
+ if dor_target_id in dict_obj_identifier:
+ target = dict_obj_identifier[dor_target_id]
+ target_title = get_object_attribute_rgx(
+ target, "citation.title"
+ )
+ target_content_type = get_content_type_from_class(target)
+ target_qualified_type = get_qualified_type_from_class(target)
+
+ dor_title = get_object_attribute_rgx(dor, "title")
+
+ if dor_title != target_title:
+ dor.title = target_title
+
+ if (
+ get_matching_class_attribute_name(dor, "content_type")
+ is not None
+ ):
+ dor_content_type = get_object_attribute_no_verif(
+ dor, "content_type"
+ )
+ if dor_content_type != target_content_type:
+ dor.content_type = target_content_type
+
+ if (
+ get_matching_class_attribute_name(dor, "qualified_type")
+ is not None
+ ):
+ dor_qualified_type = get_object_attribute_no_verif(
+ dor, "qualified_type"
+ )
+ if dor_qualified_type != target_qualified_type:
+ dor.qualified_type = target_qualified_type
+def dor_verification(energyml_objects: List[Any]) ‑> List[ValidationError]
+Verification for DOR. An error is raised if DORs contains wrong information, or if a referenced object is unknown
+in the :param:epc.
+:param energyml_objects:
+:return:
def dor_verification(energyml_objects: List[Any]) -> List[ValidationError]:
+ """
+ Verification for DOR. An error is raised if DORs contains wrong information, or if a referenced object is unknown
+ in the :param:`epc`.
+ :param energyml_objects:
+ :return:
+ """
+ errs = []
+
+ dict_obj_identifier = {
+ get_obj_identifier(obj): obj for obj in energyml_objects
+ }
+ dict_obj_uuid = {}
+ for obj in energyml_objects:
+ uuid = get_obj_uuid(obj)
+ if uuid not in dict_obj_uuid:
+ dict_obj_uuid[uuid] = []
+ dict_obj_uuid[uuid].append(obj)
+
+ # TODO: chercher dans les objets les AbstractObject (en Witsml des sous objet peuvent etre aussi references)
+
+ for obj in energyml_objects:
+ dor_list = search_attribute_matching_type_with_path(
+ obj, "DataObjectReference"
+ )
+ for dor_path, dor in dor_list:
+ dor_target_id = get_obj_identifier(dor)
+ if dor_target_id not in dict_obj_identifier:
+ dor_uuid = get_obj_uuid(dor)
+ dor_version = get_obj_version(dor)
+ if dor_uuid not in dict_obj_uuid:
+ errs.append(
+ ValidationObjectError(
+ error_type=ErrorType.CRITICAL,
+ target_obj=obj,
+ attribute_dot_path=dor_path,
+ msg=f"[DOR ERR] has wrong information. Unkown object with uuid '{dor_uuid}'",
+ )
+ )
+ else:
+ accessible_version = [
+ get_obj_version(ref_obj)
+ for ref_obj in dict_obj_uuid[dor_uuid]
+ ]
+ errs.append(
+ ValidationObjectError(
+ error_type=ErrorType.CRITICAL,
+ target_obj=obj,
+ attribute_dot_path=dor_path,
+ msg=f"[DOR ERR] has wrong information. Unkown object version '{dor_version}'. "
+ f"Version must be one of {accessible_version}",
+ )
+ )
+ else:
+ target = dict_obj_identifier[dor_target_id]
+ target_title = get_object_attribute_rgx(
+ target, "citation.title"
+ )
+ target_content_type = get_content_type_from_class(target)
+ target_qualified_type = get_qualified_type_from_class(target)
+
+ dor_title = get_object_attribute_rgx(dor, "title")
+
+ if dor_title != target_title:
+ errs.append(
+ ValidationObjectError(
+ error_type=ErrorType.CRITICAL,
+ target_obj=obj,
+ attribute_dot_path=dor_path,
+ msg=f"[DOR ERR] has wrong information. Title should be '{target_title}' and not '{dor_title}'",
+ )
+ )
+
+ if (
+ get_matching_class_attribute_name(dor, "content_type")
+ is not None
+ ):
+ dor_content_type = get_object_attribute_no_verif(
+ dor, "content_type"
+ )
+ if dor_content_type != target_content_type:
+ errs.append(
+ ValidationObjectError(
+ error_type=ErrorType.CRITICAL,
+ target_obj=obj,
+ attribute_dot_path=dor_path,
+ msg=f"[DOR ERR] has wrong information. ContentType should be '{target_content_type}' and not '{dor_content_type}'",
+ )
+ )
+
+ if (
+ get_matching_class_attribute_name(dor, "qualified_type")
+ is not None
+ ):
+ dor_qualified_type = get_object_attribute_no_verif(
+ dor, "qualified_type"
+ )
+ if dor_qualified_type != target_qualified_type:
+ errs.append(
+ ValidationObjectError(
+ error_type=ErrorType.CRITICAL,
+ target_obj=obj,
+ attribute_dot_path=dor_path,
+ msg=f"[DOR ERR] has wrong information. QualifiedType should be '{target_qualified_type}' and not '{dor_qualified_type}'",
+ )
+ )
+
+ return errs
+def patterns_verification(obj: Any) ‑> List[ValidationError]
+Verification on object values, using the patterns defined in the original energyml xsd files. +:param obj: +:return:
def patterns_verification(obj: Any) -> List[ValidationError]:
+ """
+ Verification on object values, using the patterns defined in the original energyml xsd files.
+ :param obj:
+ :return:
+ """
+ return _patterns_verification(obj, obj, "")
+def validate_attribute(value: Any, root_obj: Any, att_field: dataclasses.Field, path: str) ‑> List[ValidationError]
+def validate_attribute(
+ value: Any, root_obj: Any, att_field: Field, path: str
+) -> List[ValidationError]:
+ errs = []
+
+ if value is None:
+ if att_field.metadata.get("required", False):
+ errs.append(
+ MandatoryError(
+ error_type=ErrorType.CRITICAL,
+ target_obj=root_obj,
+ attribute_dot_path=path,
+ )
+ )
+ else:
+ min_length = att_field.metadata.get("min_length", None)
+ max_length = att_field.metadata.get("max_length", None)
+ pattern = att_field.metadata.get("pattern", None)
+ min_occurs = att_field.metadata.get("pattern", None)
+ min_inclusive = att_field.metadata.get("pattern", None)
+ # white_space
+
+ if max_length is not None:
+ length = len(value)
+ if length > max_length:
+ errs.append(
+ ValidationObjectError(
+ error_type=ErrorType.CRITICAL,
+ target_obj=root_obj,
+ attribute_dot_path=path,
+ msg=f"Max length was {max_length} but found {length}",
+ )
+ )
+
+ if min_length is not None:
+ length = len(value)
+ if length < min_length:
+ errs.append(
+ ValidationObjectError(
+ error_type=ErrorType.CRITICAL,
+ target_obj=root_obj,
+ attribute_dot_path=path,
+ msg=f"Max length was {min_length} but found {length}",
+ )
+ )
+
+ if min_occurs is not None:
+ if isinstance(value, list) and min_occurs > len(value):
+ errs.append(
+ ValidationObjectError(
+ error_type=ErrorType.CRITICAL,
+ target_obj=root_obj,
+ attribute_dot_path=path,
+ msg=f"Min occurs was {min_occurs} but found {len(value)}",
+ )
+ )
+
+ if min_inclusive is not None:
+ potential_err = ValidationObjectError(
+ error_type=ErrorType.CRITICAL,
+ target_obj=root_obj,
+ attribute_dot_path=path,
+ msg=f"Min occurs was {min_inclusive} but found {len(value)}",
+ )
+ if isinstance(value, list):
+ for val in value:
+ if (
+ (isinstance(val, str) and len(val) > min_inclusive)
+ or ((isinstance(val, int) or isinstance(val, float)) and val > min_inclusive)
+ ):
+ errs.append(potential_err)
+
+ if pattern is not None:
+ if re.match(pattern, value) is None:
+ errs.append(
+ ValidationObjectError(
+ error_type=ErrorType.CRITICAL,
+ target_obj=root_obj,
+ attribute_dot_path=path,
+ msg=f"Pattern error. Value '{value}' was supposed to respect pattern '{pattern}'",
+ )
+ )
+
+ return errs + _patterns_verification(
+ obj=value,
+ root_obj=root_obj,
+ current_attribute_dot_path=path,
+ )
+def validate_epc(epc: Epc) ‑> List[ValidationError]
+Verify if all :param:epc's objects are valid.
+:param epc:
+:return:
def validate_epc(epc: Epc) -> List[ValidationError]:
+ """
+ Verify if all :param:`epc`'s objects are valid.
+ :param epc:
+ :return:
+ """
+ errs = []
+ for obj in epc.energyml_objects:
+ errs = errs + patterns_verification(obj)
+
+ errs = errs + dor_verification(epc.energyml_objects)
+
+ return errs
+class ErrorType
+(*args, **kwds)
+Create a collection of name/value pairs.
+Example enumeration:
+>>> class Color(Enum):
+... RED = 1
+... BLUE = 2
+... GREEN = 3
+Access them by:
+>>> Color.RED
+<Color.RED: 1>
+>>> Color(1)
+<Color.RED: 1>
+>>> Color['RED']
+<Color.RED: 1>
+Enumerations can be iterated over, and know how many members they have:
+>>> len(Color)
+3
+>>> list(Color)
+[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]
+Methods can be added to enumerations, and members can have their own +attributes – see the documentation for details.
class ErrorType(Enum):
+ CRITICAL = "critical"
+ DEBUG = "debug"
+ INFO = "info"
+ WARNING = "warning"var CRITICALvar DEBUGvar INFOvar WARNING
+class MandatoryError
+(msg: str = 'Validation error', error_type: ErrorType = ErrorType.INFO, target_obj: Any = None, attribute_dot_path: str = None)
+MandatoryError(msg: str = 'Validation error', error_type: src.energyml.utils.validation.ErrorType =
@dataclass
+class MandatoryError(ValidationObjectError):
+ def __str__(self):
+ return f"{ValidationError.__str__(self)}\n\tMandatory value is None for {get_obj_identifier(self.target_obj)} : '{self.attribute_dot_path}'"
+class ValidationError
+(msg: str = 'Validation error', error_type: ErrorType = ErrorType.INFO)
+ValidationError(msg: str = 'Validation error', error_type: src.energyml.utils.validation.ErrorType =
@dataclass
+class ValidationError:
+
+ msg: str = field(default="Validation error")
+
+ error_type: ErrorType = field(default=ErrorType.INFO)
+
+ def __str__(self):
+ return f"[{str(self.error_type).upper()}] : {self.msg}"var error_type : ErrorTypevar msg : str
+class ValidationObjectError
+(msg: str = 'Validation error', error_type: ErrorType = ErrorType.INFO, target_obj: Any = None, attribute_dot_path: str = None)
+ValidationObjectError(msg: str = 'Validation error', error_type: src.energyml.utils.validation.ErrorType =
@dataclass
+class ValidationObjectError(ValidationError):
+
+ target_obj: Any = field(default=None)
+
+ attribute_dot_path: str = field(default=None)
+
+ def __str__(self):
+ return f"{ValidationError.__str__(self)}\n\t{get_obj_identifier(self.target_obj)} : '{self.attribute_dot_path}'"var attribute_dot_path : strvar target_obj : Anysrc.energyml.utils.xml# Copyright (c) 2023-2024 Geosiris.
+# SPDX-License-Identifier: Apache-2.0
+import re
+from io import BytesIO
+from typing import Optional, Any, Union
+
+from lxml import etree as ETREE # type: Any
+
+ENERGYML_NAMESPACES = {
+ "eml": "http://www.energistics.org/energyml/data/commonv2",
+ "prodml": "http://www.energistics.org/energyml/data/prodmlv2",
+ "witsml": "http://www.energistics.org/energyml/data/witsmlv2",
+ "resqml": "http://www.energistics.org/energyml/data/resqmlv2",
+}
+"""
+dict of all energyml namespaces
+""" # pylint: disable=W0105
+
+ENERGYML_NAMESPACES_PACKAGE = {
+ "eml": ["http://www.energistics.org/energyml/data/commonv2"],
+ "prodml": ["http://www.energistics.org/energyml/data/prodmlv2"],
+ "witsml": ["http://www.energistics.org/energyml/data/witsmlv2"],
+ "resqml": ["http://www.energistics.org/energyml/data/resqmlv2"],
+ "opc": [
+ "http://schemas.openxmlformats.org/package/2006/content-types",
+ "http://schemas.openxmlformats.org/package/2006/metadata/core-properties"
+ ],
+}
+"""
+dict of all energyml namespace packages
+""" # pylint: disable=W0105
+
+REGEX_UUID_NO_GRP = (
+ r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}"
+)
+REGEX_UUID = r"(?P<uuid>" + REGEX_UUID_NO_GRP + ")"
+REGEX_DOMAIN_VERSION = r"(?P<domainVersion>(?P<versionNum>([\d]+[\._])*\d)\s*(?P<dev>dev\s*(?P<devNum>[\d]+))?)"
+REGEX_DOMAIN_VERSION_FLAT = r"(?P<domainVersion>(?P<versionNumFlat>([\d]+)*\d)\s*(?P<dev>dev\s*(?P<devNum>[\d]+))?)"
+
+
+# ContentType
+REGEX_MIME_TYPE_MEDIA = r"(?P<media>application|audio|font|example|image|message|model|multipart|text|video)"
+REGEX_CT_ENERGYML_DOMAIN = r"(?P<energymlDomain>x-(?P<domain>[\w]+)\+xml)"
+REGEX_CT_XML_DOMAIN = r"(?P<xmlRawDomain>(x\-)?(?P<xmlDomain>.+)\+xml)"
+REGEX_CT_TOKEN_VERSION = r"version=" + REGEX_DOMAIN_VERSION
+REGEX_CT_TOKEN_TYPE = r"type=(?P<type>[\w\_]+)"
+
+REGEX_CONTENT_TYPE = (
+ REGEX_MIME_TYPE_MEDIA + "/"
+ + "(?P<rawDomain>(" + REGEX_CT_ENERGYML_DOMAIN + ")|(" + REGEX_CT_XML_DOMAIN + r")|([\w-]+\.?)+)"
+ + "(;((" + REGEX_CT_TOKEN_VERSION + ")|(" + REGEX_CT_TOKEN_TYPE + ")))*"
+)
+REGEX_QUALIFIED_TYPE = (
+ r"(?P<domain>[a-zA-Z]+)" + REGEX_DOMAIN_VERSION_FLAT + r"\.(?P<type>[\w_]+)"
+)
+# =========
+
+REGEX_SCHEMA_VERSION = (
+ r"(?P<name>[eE]ml|[cC]ommon|[rR]esqml|[wW]itsml|[pP]rodml)?\s*v?"
+ + REGEX_DOMAIN_VERSION
+ + r"\s*$"
+)
+
+REGEX_ENERGYML_FILE_NAME_OLD = r"(?P<type>[\w]+)_" + REGEX_UUID_NO_GRP + r"\.xml$"
+REGEX_ENERGYML_FILE_NAME_NEW = (
+ REGEX_UUID_NO_GRP + r"\.(?P<objectVersion>\d+(\.\d+)*)\.xml$"
+)
+REGEX_ENERGYML_FILE_NAME = (
+ rf"^(.*/)?({REGEX_ENERGYML_FILE_NAME_OLD})|({REGEX_ENERGYML_FILE_NAME_NEW})"
+)
+
+REGEX_XML_HEADER = r"^\s*\<\?xml\s+((encoding\s*=\s*\"(?P<encoding>[^\"]+)\"|version\s*=\s*\"(?P<version>[^\"]+)\"|standalone\s*=\s*\"(?P<standalone>[^\"]+)\")\s+)+"
+
+
+def get_pkg_from_namespace(namespace: str) -> Optional[str]:
+ for (k, v) in ENERGYML_NAMESPACES_PACKAGE.items():
+ if namespace in v:
+ return k
+ return None
+
+
+def is_energyml_content_type(content_type: str) -> bool:
+ ct = parse_content_type(content_type)
+ return ct.group("domain") is not None
+
+
+def get_root_namespace(tree: ETREE.Element) -> str:
+ return tree.nsmap[tree.prefix]
+
+
+def get_class_name_from_xml(tree: ETREE.Element) -> str:
+ root_namespace = get_root_namespace(tree)
+ pkg = get_pkg_from_namespace(root_namespace)
+ if pkg is None:
+ print(f"No pkg found for elt {tree}")
+ else:
+ if pkg == "opc":
+ return "energyml.opc.opc." + get_root_type(tree)
+ else:
+ schema_version = find_schema_version_in_element(tree).replace(".", "_").replace("-", "_")
+ if pkg == "resqml" and schema_version == "2_0":
+ schema_version = "2_0_1"
+ return ("energyml." + pkg
+ + ".v" + schema_version
+ + "."
+ + root_namespace[root_namespace.rindex("/") + 1:]
+ + "." + get_root_type(tree)
+ )
+
+
+def get_xml_encoding(xml_content: str) -> Optional[str]:
+ try:
+ m = re.search(REGEX_XML_HEADER, xml_content)
+ return m.group("encoding")
+ except AttributeError:
+ return "utf-8"
+
+
+def get_tree(xml_content: Union[bytes, str]) -> ETREE.Element:
+ xml_bytes = xml_content
+ if isinstance(xml_bytes, str):
+ xml_bytes = xml_content.encode(encoding=get_xml_encoding(xml_content).strip().lower())
+
+ return ETREE.parse(BytesIO(xml_bytes)).getroot()
+
+
+def energyml_xpath(tree: ETREE.Element, xpath: str) -> Optional[list]:
+ """A xpath research that knows energyml namespaces"""
+ try:
+ return ETREE.XPath(xpath, namespaces=ENERGYML_NAMESPACES)(tree)
+ except TypeError:
+ return None
+
+
+def search_element_has_child_xpath(tree: ETREE.Element, child_name: str) -> list:
+ """
+ Search elements that has a child named (xml tag) as 'child_name'.
+ Warning : child_name must contain the namespace (see. ENERGYML_NAMESPACES)
+ """
+ return list(x for x in energyml_xpath(tree, f"//{child_name}/.."))
+
+
+def get_uuid(tree: ETREE.Element) -> str:
+ _uuids = tree.xpath("@uuid")
+ if len(_uuids) <= 0:
+ _uuids = tree.xpath("@UUID")
+ if len(_uuids) <= 0:
+ _uuids = tree.xpath("@uid")
+ if len(_uuids) <= 0:
+ _uuids = tree.xpath("@UID")
+ return _uuids[0]
+
+
+def get_root_type(tree: ETREE.Element) -> str:
+ """ Returns the type (xml tag) of the element without the namespace """
+ return tree.xpath("local-name()")
+
+
+def find_schema_version_in_element(tree: ETREE.ElementTree) -> str:
+ """Find the "SchemaVersion" inside an xml content of a energyml file
+
+ :param tree: An energyml xml file content.
+ :type tree: bytes
+
+ :returns: The SchemaVersion that contains only the version number. For example, if the xml
+ file contains : SchemaVersion="Resqml 2.0.1"
+ the result will be : "2.0.1"
+ :rtype: str
+ """
+ _schema_version = tree.xpath("@schemaVersion")
+ if _schema_version is None:
+ _schema_version = tree.xpath("@SchemaVersion")
+
+ if _schema_version is not None:
+ match_version = re.search(r"\d+(\.\d+)*", _schema_version[0])
+ if match_version is not None:
+ return match_version.group(0)
+ return ""
+
+
+def parse_content_type(ct: str):
+ return re.search(REGEX_CONTENT_TYPE, ct)var ENERGYML_NAMESPACESdict of all energyml namespaces
var ENERGYML_NAMESPACES_PACKAGEdict of all energyml namespace packages
+def energyml_xpath(tree: , xpath: str) ‑> Optional[list]
+A xpath research that knows energyml namespaces
def energyml_xpath(tree: ETREE.Element, xpath: str) -> Optional[list]:
+ """A xpath research that knows energyml namespaces"""
+ try:
+ return ETREE.XPath(xpath, namespaces=ENERGYML_NAMESPACES)(tree)
+ except TypeError:
+ return None
+def find_schema_version_in_element(tree: ) ‑> str
+Find the "SchemaVersion" inside an xml content of a energyml file
+:param tree: An energyml xml file content. +:type tree: bytes
+:returns: The SchemaVersion that contains only the version number. For example, if the xml +file contains : SchemaVersion="Resqml 2.0.1" +the result will be : "2.0.1" +:rtype: str
def find_schema_version_in_element(tree: ETREE.ElementTree) -> str:
+ """Find the "SchemaVersion" inside an xml content of a energyml file
+
+ :param tree: An energyml xml file content.
+ :type tree: bytes
+
+ :returns: The SchemaVersion that contains only the version number. For example, if the xml
+ file contains : SchemaVersion="Resqml 2.0.1"
+ the result will be : "2.0.1"
+ :rtype: str
+ """
+ _schema_version = tree.xpath("@schemaVersion")
+ if _schema_version is None:
+ _schema_version = tree.xpath("@SchemaVersion")
+
+ if _schema_version is not None:
+ match_version = re.search(r"\d+(\.\d+)*", _schema_version[0])
+ if match_version is not None:
+ return match_version.group(0)
+ return ""
+def get_class_name_from_xml(tree: ) ‑> str
+def get_class_name_from_xml(tree: ETREE.Element) -> str:
+ root_namespace = get_root_namespace(tree)
+ pkg = get_pkg_from_namespace(root_namespace)
+ if pkg is None:
+ print(f"No pkg found for elt {tree}")
+ else:
+ if pkg == "opc":
+ return "energyml.opc.opc." + get_root_type(tree)
+ else:
+ schema_version = find_schema_version_in_element(tree).replace(".", "_").replace("-", "_")
+ if pkg == "resqml" and schema_version == "2_0":
+ schema_version = "2_0_1"
+ return ("energyml." + pkg
+ + ".v" + schema_version
+ + "."
+ + root_namespace[root_namespace.rindex("/") + 1:]
+ + "." + get_root_type(tree)
+ )
+def get_pkg_from_namespace(namespace: str) ‑> Optional[str]
+def get_pkg_from_namespace(namespace: str) -> Optional[str]:
+ for (k, v) in ENERGYML_NAMESPACES_PACKAGE.items():
+ if namespace in v:
+ return k
+ return None
+def get_root_namespace(tree: ) ‑> str
+def get_root_namespace(tree: ETREE.Element) -> str:
+ return tree.nsmap[tree.prefix]
+def get_root_type(tree: ) ‑> str
+Returns the type (xml tag) of the element without the namespace
def get_root_type(tree: ETREE.Element) -> str:
+ """ Returns the type (xml tag) of the element without the namespace """
+ return tree.xpath("local-name()")
+def get_tree(xml_content: Union[bytes, str]) ‑> def get_tree(xml_content: Union[bytes, str]) -> ETREE.Element:
+ xml_bytes = xml_content
+ if isinstance(xml_bytes, str):
+ xml_bytes = xml_content.encode(encoding=get_xml_encoding(xml_content).strip().lower())
+
+ return ETREE.parse(BytesIO(xml_bytes)).getroot()
+def get_uuid(tree: ) ‑> str
+def get_uuid(tree: ETREE.Element) -> str:
+ _uuids = tree.xpath("@uuid")
+ if len(_uuids) <= 0:
+ _uuids = tree.xpath("@UUID")
+ if len(_uuids) <= 0:
+ _uuids = tree.xpath("@uid")
+ if len(_uuids) <= 0:
+ _uuids = tree.xpath("@UID")
+ return _uuids[0]
+def get_xml_encoding(xml_content: str) ‑> Optional[str]
+def get_xml_encoding(xml_content: str) -> Optional[str]:
+ try:
+ m = re.search(REGEX_XML_HEADER, xml_content)
+ return m.group("encoding")
+ except AttributeError:
+ return "utf-8"
+def is_energyml_content_type(content_type: str) ‑> bool
+def is_energyml_content_type(content_type: str) -> bool:
+ ct = parse_content_type(content_type)
+ return ct.group("domain") is not None
+def parse_content_type(ct: str)
+def parse_content_type(ct: str):
+ return re.search(REGEX_CONTENT_TYPE, ct)
+def search_element_has_child_xpath(tree: , child_name: str) ‑> list
+Search elements that has a child named (xml tag) as 'child_name'. +Warning : child_name must contain the namespace (see. ENERGYML_NAMESPACES)
def search_element_has_child_xpath(tree: ETREE.Element, child_name: str) -> list:
+ """
+ Search elements that has a child named (xml tag) as 'child_name'.
+ Warning : child_name must contain the namespace (see. ENERGYML_NAMESPACES)
+ """
+ return list(x for x in energyml_xpath(tree, f"//{child_name}/.."))srcsrc.energyml