aas-standard-parser 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

aas_standard_parser/__init__.py

@@ -13,7 +13,7 @@ except importlib.metadata.PackageNotFoundError:
 __project__ = "aas-standard-parser"
 __package__ = "aas-standard-parser"
 
+from aas_standard_parser import aimc_parser
 from aas_standard_parser.aid_parser import AIDParser
-from aas_standard_parser.aimc_parser import AIMCParser
 
-__all__ = ["AIMCParser", "AIDParser"]
+__all__ = ["AIDParser", "aimc_parser"]

aas_standard_parser/aid_parser.py

@@ -1,32 +1,44 @@
 """This module provides functions to parse AID Submodels and extract MQTT interface descriptions."""
+
 import base64
 from typing import Dict, List
 
 from basyx.aas.model import (
     Property,
     SubmodelElement,
-    SubmodelElementCollection, SubmodelElementList, Submodel,
+    SubmodelElementCollection,
+    SubmodelElementList,
 )
 
-from aas_standard_parser.collection_helpers import find_by_semantic_id, find_all_by_semantic_id, find_by_id_short
+from aas_standard_parser.collection_helpers import find_all_by_semantic_id, find_by_id_short, find_by_semantic_id
 
 
-class PropertyDetails:
+class IProtocolBinding:
+    def __init__(self):
+        pass
+
+
+class HttpProtocolBinding(IProtocolBinding):
+    def __init__(self, method_name: str, headers: Dict[str, str]):
+        super().__init__()
+        self.method_name = method_name
+        self.headers = headers
+
 
-    def __init__(self, href: str, keys: List[str]):
+class PropertyDetails:
+    def __init__(self, href: str, keys: List[str], protocol_binding: IProtocolBinding = None):
         self.href = href
         self.keys = keys
+        self.protocol_binding = protocol_binding
 
 
 class IAuthenticationDetails:
-
     def __init__(self):
         # TODO: different implementations for different AID versions
         pass
 
 
 class BasicAuthenticationDetails(IAuthenticationDetails):
-
     def __init__(self, user: str, password: str):
         self.user = user
         self.password = password
@@ -34,17 +46,15 @@ class BasicAuthenticationDetails(IAuthenticationDetails):
 
 
 class NoAuthenticationDetails(IAuthenticationDetails):
-
     def __init__(self):
         super().__init__()
 
 
-class AIDParser():
-
+class AIDParser:
     def __init__(self):
         pass
 
-    def get_base_url_from_interface(self, aid_interface: SubmodelElementCollection) -> str:
+    def parse_base(self, aid_interface: SubmodelElementCollection) -> str:
         """Get the base address (EndpointMetadata.base) from a SMC describing an interface in the AID."""
 
         endpoint_metadata: SubmodelElementCollection | None = find_by_semantic_id(
@@ -53,16 +63,13 @@ class AIDParser():
         if endpoint_metadata is None:
             raise ValueError(f"'EndpointMetadata' SMC not found in the provided '{aid_interface.id_short}' SMC.")
 
-        base: Property | None = find_by_semantic_id(
-            endpoint_metadata.value, "https://www.w3.org/2019/wot/td#baseURI"
-        )
+        base: Property | None = find_by_semantic_id(endpoint_metadata.value, "https://www.w3.org/2019/wot/td#baseURI")
         if base is None:
             raise ValueError("'base' Property not found in 'EndpointMetadata' SMC.")
 
         return base.value
 
-
-    def create_property_to_href_map(self, aid_interface: SubmodelElementCollection) -> Dict[str, PropertyDetails]:
+    def parse_properties(self, aid_interface: SubmodelElementCollection) -> Dict[str, PropertyDetails]:
         """Find all first-level and nested properties in a provided SMC describing one interface in the AID.
         Map each property (either top-level or nested) to the according 'href' attribute.
         Nested properties are further mapped to the hierarchical list of keys
@@ -88,38 +95,58 @@ class AIDParser():
         fl_properties: List[SubmodelElement] = find_all_by_semantic_id(
             properties.value, "https://admin-shell.io/idta/AssetInterfacesDescription/1/0/PropertyDefinition"
         )
-        # TODO: some AIDs have typos in that semanticId but we only support the official ones
-        #fl_properties_alternative: List[SubmodelElement] = find_all_by_semantic_id(
-        #    properties.value, "https://admin-shell.io/idta/AssetInterfaceDescription/1/0/PropertyDefinition"
-        #)
-        #fl_properties.extend(fl_properties_alternative)
         if fl_properties is None:
-            #raise ValueError(f"No first-level 'property' SMC not found in 'properties' SMC.")
+            print(f"WARN: No first-level 'property' SMC not found in 'properties' SMC.")
             return {}
 
-        def traverse_property(smc: SubmodelElementCollection, parent_path: str, href: str, key_path: List[str | int],
-                              is_items=False, idx=None, is_top_level=False):
+        def traverse_property(
+            smc: SubmodelElementCollection,
+            parent_path: str,
+            href: str,
+            key_path: List[str | int],
+            is_items=False,
+            idx=None,
+            is_top_level=False,
+            protocol_binding: IProtocolBinding = None,
+        ):
             # determine local key only if not top-level
             if not is_top_level:
                 if is_items and idx is not None:
-                    local_key = idx  # integer index
+                    # is a nested "items" property -> add index to the list of keys
+                    local_key = idx
                 else:
-                    key_prop = find_by_semantic_id(
-                        smc.value, "https://admin-shell.io/idta/AssetInterfacesDescription/1/0/key"
-                    )
-                    local_key = key_prop.value if key_prop else smc.id_short  # string
+                    # is a nested "properties" property -> add value of "key" attribute or idShort to list of keys
+                    key_prop = find_by_semantic_id(smc.value, "https://admin-shell.io/idta/AssetInterfacesDescription/1/0/key")
+                    local_key = key_prop.value if key_prop else smc.id_short
                 new_key_path = key_path + [local_key]
             else:
-                new_key_path = key_path  # top-level: no key added
-
-            # register this property
+                # TODO: use the key of the first-level property (or its idShort otherwise)
+                # is a top-level property
+                # key_prop: Property | None = find_by_semantic_id(
+                #    smc.value, "https://admin-shell.io/idta/AssetInterfacesDescription/1/0/key"
+                # )
+                # local_key = key_prop.value if key_prop else smc.id_short
+                # new_key_path = [local_key]
+
+                new_key_path = key_path
+                # NOTE (Tom Gneuß, 2025-10-20)
+                # See GitHub Issue: https://github.com/admin-shell-io/submodel-templates/issues/197
+                # First-level properties are allowed to have a "key" attribute - otherwise the idShort path is used.
+                # However, complex first-level properties would represent, e.g., the JSON payload (object) itself.
+                # This JSON payload does only have keys for nested elements.
+                # So, using the key (or idShort) of the first-level property to get the JSON object from the payload
+                # is not possible.
+                # On the other hand: the first-level property could intentionally be something within the JSON object.
+                # In that case, having a "key" (or using the idSort) is entirely valid.
+                # How to distinguish both cases?
+
+            # create the idShort path of this property
             full_path = f"{parent_path}.{smc.id_short}"
-            mapping[full_path] = PropertyDetails(href, new_key_path)
+            # add this property with all its details to the mapping -> href (from top-level parent if this is nested),
+            # protocol bindings (from top-level parent if this is nested), list of keys
+            mapping[full_path] = PropertyDetails(href, new_key_path, protocol_binding)
 
             # traverse nested "properties" or "items"
-            # (nested properties = object members, nested items = array elements)
-            # TODO: some apparently use the wrong semanticId:
-            # "https://www.w3.org/2019/wot/td#PropertyAffordance"
             for nested_sem_id in [
                 "https://www.w3.org/2019/wot/json-schema#properties",
                 "https://www.w3.org/2019/wot/json-schema#items",
@@ -133,52 +160,66 @@ class AIDParser():
                     nested_properties: List[SubmodelElement] = find_all_by_semantic_id(
                         nested_group.value, "https://www.w3.org/2019/wot/json-schema#propertyName"
                     )
-                    # TODO: some AIDs have typos or use wrong semanticIds but we only support the official ones
-                    #nested_properties_alternative1: List[SubmodelElement] = find_all_by_semantic_id(
-                    #    nested_group.value, "https://admin-shell.io/idta/AssetInterfaceDescription/1/0/PropertyDefinition"
-                    #)
-                    # nested_properties_alternative2: List[SubmodelElement] = find_all_by_semantic_id(
-                    #    nested_group.value, "https://admin-shell.io/idta/AssetInterfacesDescription/1/0/PropertyDefinition"
-                    # )
-                    #nested_properties.extend(nested_properties_alternative1)
-                    #nested_properties.extend(nested_properties_alternative2)
 
                     # traverse all nested properties/items recursively
                     for idx, nested in enumerate(nested_properties):
                         if nested_sem_id.endswith("#items"):
-                            # for arrays: append index instead of property key
+                            # for arrays: append index instead of "key" attribute
                             traverse_property(nested, full_path, href, new_key_path, is_items=True, idx=idx)
                         else:
                             traverse_property(nested, full_path, href, new_key_path)
 
         # process all first-level properties
-        for fl_property in fl_properties:
-            forms: SubmodelElementCollection | None = find_by_semantic_id(
-                fl_property.value, "https://www.w3.org/2019/wot/td#hasForm"
-            )
+        for fl_property in fl_properties:  # type: SubmodelElementCollection
+            forms: SubmodelElementCollection | None = find_by_semantic_id(fl_property.value, "https://www.w3.org/2019/wot/td#hasForm")
             if forms is None:
                 raise ValueError(f"'forms' SMC not found in '{fl_property.id_short}' SMC.")
 
-            href: Property | None = find_by_semantic_id(
-                forms.value, "https://www.w3.org/2019/wot/hypermedia#hasTarget"
-            )
+            href: Property | None = find_by_semantic_id(forms.value, "https://www.w3.org/2019/wot/hypermedia#hasTarget")
             if href is None:
                 raise ValueError("'href' Property not found in 'forms' SMC.")
 
+            # get the href value of the first-level property
             href_value = href.value
+
+            # construct the idShort path up to "Interface_.InteractionMetadata.properties"
+            # will be used as prefix for the idShort paths of the first-level and nested properties
             idshort_path_prefix = f"{aid_interface.id_short}.{interaction_metadata.id_short}.{properties.id_short}"
 
+            # check which protocol-specific subtype of forms is used
+            # there is no clean solution for determining the subtype (e.g., a supplSemId)
+            # -> can only be figured out if the specific fields are present
+            protocol_binding: IProtocolBinding = None
+
+            # ... try HTTP ("htv_methodName" must be present)
+            htv_method_name: Property | None = find_by_semantic_id(forms.value, "https://www.w3.org/2011/http#methodName")
+            if htv_method_name is not None:
+                protocol_binding: HttpProtocolBinding = HttpProtocolBinding(htv_method_name.value, {})
+                htv_headers: SubmodelElementCollection | None = find_by_semantic_id(forms.value, "https://www.w3.org/2011/http#headers")
+                if htv_headers is not None:
+                    for header in htv_headers.value:  # type: SubmodelElementCollection
+                        htv_field_name: Property | None = find_by_semantic_id(header.value, "https://www.w3.org/2011/http#fieldName")
+                        htv_field_value: Property | None = find_by_semantic_id(header.value, "https://www.w3.org/2011/http#fieldValue")
+                        protocol_binding.headers[htv_field_name.value] = htv_field_value.value
+
+            # TODO: the other protocols
+            # ... try Modbus
+            # ... try MQTT
+
+            # recursively parse the first-level property and its nested properties (if any)
             traverse_property(
-                fl_property,
-                idshort_path_prefix,
-                href_value,
-                [],
-                is_top_level=True
+                smc=fl_property,
+                parent_path=idshort_path_prefix,
+                href=href_value,
+                key_path=[],
+                is_items=False,
+                idx=None,
+                is_top_level=True,
+                protocol_binding=protocol_binding,
             )
 
         return mapping
 
-
     def parse_security(self, aid_interface: SubmodelElementCollection) -> IAuthenticationDetails:
         """Extract the authentication details (EndpointMetadata.security) from the provided interface in the AID.
 
@@ -191,9 +232,7 @@ class AIDParser():
         if endpoint_metadata is None:
             raise ValueError(f"'EndpointMetadata' SMC not found in the provided '{aid_interface.id_short}' SMC.")
 
-        security: SubmodelElementList | None = find_by_semantic_id(
-            endpoint_metadata.value, "https://www.w3.org/2019/wot/td#hasSecurityConfiguration"
-        )
+        security: SubmodelElementList | None = find_by_semantic_id(endpoint_metadata.value, "https://www.w3.org/2019/wot/td#hasSecurityConfiguration")
         if security is None:
             raise ValueError("'security' SML not found in 'EndpointMetadata' SMC.")
 
@@ -212,16 +251,12 @@ class AIDParser():
             raise ValueError("'securityDefinitions' SMC not found in 'EndpointMetadata' SMC.")
 
         # find the security scheme SMC with the same idShort as mentioned in the reference "sc"
-        referenced_security: SubmodelElementCollection | None = find_by_id_short(
-            security_definitions.value, sc_idshort
-        )
+        referenced_security: SubmodelElementCollection | None = find_by_id_short(security_definitions.value, sc_idshort)
         if referenced_security is None:
             raise ValueError(f"Referenced security scheme '{sc_idshort}' SMC not found in 'securityDefinitions' SMC")
 
         # get the name of the security scheme
-        scheme: Property | None = find_by_semantic_id(
-            referenced_security.value, "https://www.w3.org/2019/wot/security#SecurityScheme"
-        )
+        scheme: Property | None = find_by_semantic_id(referenced_security.value, "https://www.w3.org/2019/wot/security#SecurityScheme")
         if scheme is None:
             raise ValueError(f"'scheme' Property not found in referenced security scheme '{sc_idshort}' SMC.")
 
@@ -232,9 +267,7 @@ class AIDParser():
                 auth_details = NoAuthenticationDetails()
 
             case "basic":
-                basic_sc_name: Property | None = find_by_semantic_id(
-                    referenced_security.value, "https://www.w3.org/2019/wot/security#name"
-                )
+                basic_sc_name: Property | None = find_by_semantic_id(referenced_security.value, "https://www.w3.org/2019/wot/security#name")
                 if basic_sc_name is None:
                     raise ValueError("'name' Property not found in 'basic_sc' SMC")
 

aas_standard_parser/aimc_parser.py

@@ -1,31 +1,33 @@
+"""Parser for Mapping Configurations in AIMC Submodel."""
+
 import json
 import logging
+from dataclasses import dataclass, field
 
 import basyx.aas.adapter.json
 from basyx.aas import model
 
+import aas_standard_parser.collection_helpers as ch
+
 logger = logging.getLogger(__name__)
 
 
 class SourceSinkRelation:
     """Class representing a source-sink relation in the mapping configuration."""
 
-    aid_submodel_id: str
-    source: model.ExternalReference
-    sink: model.ExternalReference
-    property_name: str
+    aid_submodel_id: str = field(metadata={"description": "Identifier of the AID submodel used by the source reference."})
+    source: model.ExternalReference = field(metadata={"description": "Reference to the source property in the AID submodel."})
+    sink: model.ExternalReference = field(metadata={"description": "Reference to the sink property in the target submodel."})
+    property_name: str = field(metadata={"description": "Name of the mapped property."})
+    source_parent_path: list[str] = field(metadata={"description": "List of idShorts representing the parent path of the reference."})
 
     def source_as_dict(self) -> dict:
         """Convert the source reference to a dictionary.
 
         :return: The source reference as a dictionary.
         """
-        dict_string = json.dumps(
-            self.source, cls=basyx.aas.adapter.json.AASToJsonEncoder
-        )
-        dict_string = dict_string.replace("GlobalReference", "Submodel").replace(
-            "FragmentReference", "SubmodelElementCollection"
-        )
+        dict_string = json.dumps(self.source, cls=basyx.aas.adapter.json.AASToJsonEncoder)
+        dict_string = dict_string.replace("GlobalReference", "Submodel").replace("FragmentReference", "SubmodelElementCollection")
         return json.loads(dict_string)
 
     def sink_as_dict(self) -> dict:
@@ -33,312 +35,238 @@ class SourceSinkRelation:
 
         :return: The sink reference as a dictionary.
         """
-        return json.loads(
-            json.dumps(self.sink, cls=basyx.aas.adapter.json.AASToJsonEncoder)
-        )
+        return json.loads(json.dumps(self.sink, cls=basyx.aas.adapter.json.AASToJsonEncoder))
+
+    def get_source_parent_property_group_name(self) -> str:
+        """Get the name of the parent property group from the source. Ignore 'properties' entries from the path."""
+        if len(self.source_parent_path) == 0:
+            return ""
+
+        return next((n for n in reversed(self.source_parent_path) if n != "properties"), "")
 
 
 class MappingConfiguration:
     """Class representing a mapping configuration."""
 
-    interface_reference: model.ReferenceElement
-    aid_submodel_id: str
-    source_sink_relations: list[SourceSinkRelation]
+    interface_reference: model.ReferenceElement = field(metadata={"description": "Reference to the interface in the AID submodel."})
+    aid_submodel_id: str = field(metadata={"description": "Identifier of the AID submodel used by the interface reference."})
+    source_sink_relations: list[SourceSinkRelation] = field(metadata={"description": "List of source-sink relations in the mapping configuration."})
 
 
 class MappingConfigurations:
     """Class representing mapping configurations from AIMC submodel."""
 
-    configurations: list[MappingConfiguration]
-    aid_submodel_ids: list[str]
+    configurations: list[MappingConfiguration] = field(metadata={"description": "List of mapping configurations."})
+    aid_submodel_ids: list[str] = field(metadata={"description": "List of AID submodel IDs used in the mapping configurations."})
 
 
-class AIMCParser:
-    """Parser for the AIMC submodel.
+def get_mapping_configuration_root_element(aimc_submodel: model.Submodel) -> model.SubmodelElementCollection | None:
+    """Get the mapping configuration root submodel element collection from the AIMC submodel.
 
-    :return: The parsed AIMC submodel.
+    :param aimc_submodel: The AIMC submodel to extract the mapping configuration root from.
+    :return: The mapping configuration root submodel element collection or None if not found.
     """
+    # check if AIMC submodel is None
+    if aimc_submodel is None:
+        logger.error("AIMC submodel is None.")
+        return None
 
-    aimc_submodel: model.Submodel | None = None
-    mapping_configuration_element: model.SubmodelElementCollection | None = None
+    # get 'MappingConfigurations' element list by its semantic ID
+    mc_element = ch.find_by_in_semantic_id(aimc_submodel.submodel_element, "idta/AssetInterfacesMappingConfiguration/1/0/MappingConfigurations")
+    if mc_element is None:
+        logger.error("'MappingConfigurations' element list not found in AIMC submodel.")
 
-    def __init__(self, aimc_submodel: model.Submodel):
-        """Initialize the AIMC parser.
+    return mc_element
 
-        :param aimc_submodel: The AIMC submodel to parse.
-        """
-        if aimc_submodel is None:
-            raise ValueError("AIMC submodel cannot be None.")
 
-        self.aimc_submodel = aimc_submodel
+def get_mapping_configuration_elements(aimc_submodel: model.Submodel) -> list[model.SubmodelElementCollection] | None:
+    """Get all mapping configurations from the AIMC submodel.
 
-    def get_mapping_configuration_root_element(
-        self,
-    ) -> model.SubmodelElementCollection | None:
-        """Get the mapping configuration root submodel element collection from the AIMC submodel.
+    :param aimc_submodel: The AIMC submodel to extract mapping configurations from.
+    :return: A dictionary containing all mapping configurations.
+    """
+    # check if AIMC submodel is None
+    if aimc_submodel is None:
+        logger.error("AIMC submodel is None.")
+        return None
 
-        :return: The mapping configuration root submodel element collection or None if not found.
-        """
-        self.mapping_configuration_element = next(
-            (
-                elem
-                for elem in self.aimc_submodel.submodel_element
-                if elem.id_short == "MappingConfigurations"
-            ),
-            None,
-        )
+    # get mapping configuration root element
+    root_element = get_mapping_configuration_root_element(aimc_submodel)
+    if root_element is None:
+        return None
 
-        if self.mapping_configuration_element is None:
-            logger.error(
-                "'MappingConfigurations' element list not found in AIMC submodel."
-            )
-            return None
+    # find all 'MappingConfiguration' elements by their semantic ID
+    mapping_configurations = ch.find_all_by_in_semantic_id(root_element.value, "idta/AssetInterfacesMappingConfiguration/1/0/MappingConfiguration")
 
-        return self.mapping_configuration_element
+    logger.debug(f"Found {len(mapping_configurations)} mapping configuration elements in AIMC submodel.")
 
-    def get_mapping_configuration_elements(
-        self,
-    ) -> list[model.SubmodelElementCollection] | None:
-        """Get all mapping configurations elements from the AIMC submodel.
+    return mapping_configurations
 
-        :return: A dictionary containing all mapping configurations elements.
-        """
-        if self.mapping_configuration_element is None:
-            self.mapping_configuration_element = (
-                self.get_mapping_configuration_root_element()
-            )
-
-        if self.mapping_configuration_element is None:
-            return None
-
-        mapping_configurations: list[model.SubmodelElementCollection] = [
-            element
-            for element in self.mapping_configuration_element.value
-            if isinstance(element, model.SubmodelElementCollection)
-        ]
-
-        logger.debug(
-            f"Found {len(mapping_configurations)} mapping configuration elements in AIMC submodel."
-        )
 
-        return mapping_configurations
+def parse_mapping_configurations(aimc_submodel: model.Submodel) -> MappingConfigurations:
+    """Parse all mapping configurations in the AIMC submodel.
 
-    def parse_mapping_configurations(self) -> MappingConfigurations:
-        """Parse all mapping configurations in the AIMC submodel.
+    :param aimc_submodel: The AIMC submodel to parse mapping configurations from.
+    :return: A list of parsed mapping configurations.
+    """
+    logger.info("Parse mapping configurations from AIMC submodel.")
 
-        :return: A list of parsed mapping configurations.
-        """
-        logger.info("Parse mapping configurations from AIMC submodel.")
+    mapping_configurations: list[MappingConfiguration] = []
 
-        mapping_configurations: list[MappingConfiguration] = []
+    # get all mapping configuration elements
+    mapping_configurations_elements = get_mapping_configuration_elements(aimc_submodel)
+    if mapping_configurations_elements is None:
+        logger.error("No mapping configuration elements found in AIMC submodel.")
+        return mapping_configurations_elements
 
-        mc_elements = self.get_mapping_configuration_elements()
+    # parse each mapping configuration element
+    for mc_element in mapping_configurations_elements:
+        mc = parse_mapping_configuration_element(mc_element)
+        if mc is not None:
+            mapping_configurations.append(mc)
 
-        if mc_elements is None:
-            logger.error("No mapping configuration elements found in AIMC submodel.")
-            return mapping_configurations
+    logger.debug(f"Parsed {len(mapping_configurations)} mapping configurations.")
 
-        for mc_element in mc_elements:
-            mc = self.parse_mapping_configuration(mc_element)
-            if mc is not None:
-                mapping_configurations.append(mc)
+    mcs = MappingConfigurations()
+    mcs.configurations = mapping_configurations
+    # add all unique AID submodel IDs from all mapping configurations
+    mcs.aid_submodel_ids = list({mc.aid_submodel_id for mc in mapping_configurations})
 
-        logger.debug(f"Parsed {len(mapping_configurations)} mapping configurations.")
+    logger.debug(f"Found {len(mcs.aid_submodel_ids)} unique AID submodel IDs in mapping configurations.")
+    logger.debug(f"Found {len(mcs.configurations)} mapping configurations in AIMC submodel.")
 
-        mcs = MappingConfigurations()
-        mcs.configurations = mapping_configurations
-        # add all unique AID submodel IDs from all mapping configurations
-        mcs.aid_submodel_ids = list(
-            {mc.aid_submodel_id for mc in mapping_configurations}
-        )
+    return mcs
 
-        logger.debug(
-            f"Found {len(mcs.aid_submodel_ids)} unique AID submodel IDs in mapping configurations."
-        )
-        logger.debug(
-            f"Found {len(mcs.configurations)} mapping configurations in AIMC submodel."
-        )
 
-        return mcs
+def parse_mapping_configuration_element(
+    mapping_configuration_element: model.SubmodelElementCollection,
+) -> MappingConfiguration | None:
+    """Parse a mapping configuration element.
 
-    def parse_mapping_configuration(
-        self, mapping_configuration_element: model.SubmodelElementCollection
-    ) -> MappingConfiguration | None:
-        """Parse a mapping configuration element.
+    :param mapping_configuration_element: The mapping configuration element to parse.
+    :return: The parsed mapping configuration or None if parsing failed.
+    """
+    if mapping_configuration_element is None:
+        logger.error("Mapping configuration element is None.")
+        return None
 
-        :param mapping_configuration_element: The mapping configuration element to parse.
-        :return: The parsed mapping configuration or None if parsing failed.
-        """
-        if mapping_configuration_element is None:
-            logger.error("Mapping configuration element is None.")
-            return None
+    logger.debug(f"Parse mapping configuration '{mapping_configuration_element}'")
 
-        logger.debug(f"Parse mapping configuration '{mapping_configuration_element}'")
+    # get interface reference element
+    interface_reference = _get_interface_reference_element(mapping_configuration_element)
+    if interface_reference is None:
+        return None
 
-        interface_reference = self._get_interface_reference(
-            mapping_configuration_element
-        )
+    source_sink_relations = _generate_source_sink_relations(mapping_configuration_element)
 
-        if interface_reference is None:
-            return None
+    if len(source_sink_relations) == 0:
+        logger.error(f"No source-sink relations found in mapping configuration '{mapping_configuration_element.id_short}'.")
+        return None
 
-        source_sink_relations = self._generate_source_sink_relations(
-            mapping_configuration_element
-        )
+    # check if all relations have the same AID submodel
+    aid_submodel_ids = list({source_sink_relation.aid_submodel_id for source_sink_relation in source_sink_relations})
 
-        if len(source_sink_relations) == 0:
-            logger.error(
-                f"No source-sink relations found in mapping configuration '{mapping_configuration_element.id_short}'."
-            )
-            return None
-
-        # check if all relations have the same AID submodel
-        aid_submodel_ids = list(
-            {
-                source_sink_relation.aid_submodel_id
-                for source_sink_relation in source_sink_relations
-            }
+    if len(aid_submodel_ids) != 1:
+        logger.error(
+            f"Multiple AID submodel IDs found in mapping configuration '{mapping_configuration_element.id_short}': {aid_submodel_ids}. Expected exactly one AID submodel ID."
         )
+        return None
 
-        if len(aid_submodel_ids) != 1:
-            logger.error(
-                f"Multiple AID submodel IDs found in mapping configuration '{mapping_configuration_element.id_short}': {aid_submodel_ids}. Expected exactly one AID submodel ID."
-            )
-            return None
-
-        mc = MappingConfiguration()
-        mc.interface_reference = interface_reference
-        mc.source_sink_relations = source_sink_relations
-        # add all unique AID submodel IDs from source-sink relations
-        mc.aid_submodel_id = aid_submodel_ids[0]
-        return mc
-
-    def _get_interface_reference(
-        self, mapping_configuration_element: model.SubmodelElementCollection
-    ) -> model.ReferenceElement | None:
-        """Get the interface reference ID from the mapping configuration element.
-
-        :param mapping_configuration_element: The mapping configuration element to extract the interface reference ID from.
-        :return: The interface reference ID or None if not found.
-        """
-        logger.debug(
-            f"Get 'InterfaceReference' from mapping configuration '{mapping_configuration_element}'."
-        )
+    mc = MappingConfiguration()
+    mc.interface_reference = interface_reference
+    mc.source_sink_relations = source_sink_relations
+    # add all unique AID submodel IDs from source-sink relations
+    mc.aid_submodel_id = aid_submodel_ids[0]
+    return mc
 
-        interface_ref: model.ReferenceElement = next(
-            (
-                elem
-                for elem in mapping_configuration_element.value
-                if elem.id_short == "InterfaceReference"
-            ),
-            None,
-        )
 
-        if interface_ref is None or not isinstance(
-            interface_ref, model.ReferenceElement
-        ):
-            logger.error(
-                f"'InterfaceReference' not found in mapping configuration '{mapping_configuration_element.id_short}'."
-            )
-            return None
-
-        if interface_ref.value is None or len(interface_ref.value.key) == 0:
-            logger.error(
-                f"'InterfaceReference' has no value in mapping configuration '{mapping_configuration_element.id_short}'."
-            )
-            return None
-
-        return interface_ref
-
-    def _generate_source_sink_relations(
-        self, mapping_configuration_element: model.SubmodelElementCollection
-    ) -> list[SourceSinkRelation]:
-        source_sink_relations: list[SourceSinkRelation] = []
-
-        logger.debug(
-            f"Get 'MappingSourceSinkRelations' from mapping configuration '{mapping_configuration_element}'."
-        )
+def _get_interface_reference_element(
+    mapping_configuration_element: model.SubmodelElementCollection,
+) -> model.ReferenceElement | None:
+    """Get the interface reference ID from the mapping configuration element.
+
+    :param mapping_configuration_element: The mapping configuration element to extract the interface reference ID from.
+    :return: The interface reference ID or None if not found.
+    """
+    logger.debug(f"Get 'InterfaceReference' from mapping configuration '{mapping_configuration_element}'.")
+
+    interface_ref: model.ReferenceElement = ch.find_by_in_semantic_id(
+        mapping_configuration_element, "idta/AssetInterfacesMappingConfiguration/1/0/InterfaceReference"
+    )
+
+    if interface_ref is None or not isinstance(interface_ref, model.ReferenceElement):
+        logger.error(f"'InterfaceReference' not found in mapping configuration '{mapping_configuration_element.id_short}'.")
+        return None
+
+    if interface_ref.value is None or len(interface_ref.value.key) == 0:
+        logger.error(f"'InterfaceReference' has no value in mapping configuration '{mapping_configuration_element.id_short}'.")
+        return None
+
+    return interface_ref
+
+
+def _generate_source_sink_relations(mapping_configuration_element: model.SubmodelElementCollection) -> list[SourceSinkRelation]:
+    source_sink_relations: list[SourceSinkRelation] = []
+
+    logger.debug(f"Get 'MappingSourceSinkRelations' from mapping configuration '{mapping_configuration_element}'.")
+
+    relations_list: model.SubmodelElementList = ch.find_by_in_semantic_id(
+        mapping_configuration_element, "/idta/AssetInterfacesMappingConfiguration/1/0/MappingSourceSinkRelations"
+    )
+
+    if relations_list is None or not isinstance(relations_list, model.SubmodelElementList):
+        logger.error(f"'MappingSourceSinkRelations' not found in mapping configuration '{mapping_configuration_element.id_short}'.")
+        return source_sink_relations
+
+    for source_sink_relation in relations_list.value:
+        logger.debug(f"Parse source-sink relation '{source_sink_relation}'.")
 
-        relations_list: model.SubmodelElementList = next(
-            (
-                elem
-                for elem in mapping_configuration_element.value
-                if elem.id_short == "MappingSourceSinkRelations"
-            ),
+        if not isinstance(source_sink_relation, model.RelationshipElement):
+            logger.warning(f"'{source_sink_relation}' is not a RelationshipElement")
+            continue
+
+        if source_sink_relation.first is None or len(source_sink_relation.first.key) == 0:
+            logger.warning(f"'first' reference is missing in RelationshipElement '{source_sink_relation.id_short}'")
+            continue
+
+        if source_sink_relation.second is None or len(source_sink_relation.second.key) == 0:
+            logger.warning(f"'second' reference is missing in RelationshipElement '{source_sink_relation.id_short}'")
+            continue
+
+        source_ref = source_sink_relation.first
+
+        global_ref = next((key for key in source_ref.key if key.type == model.KeyTypes.GLOBAL_REFERENCE), None)
+
+        if global_ref is None:
+            logger.warning(f"No GLOBAL_REFERENCE key found in 'first' reference of RelationshipElement '{source_sink_relation.id_short}'")
+            continue
+
+        last_fragment_ref = next(
+            (key for key in reversed(source_ref.key) if key.type == model.KeyTypes.FRAGMENT_REFERENCE),
             None,
         )
 
-        if relations_list is None or not isinstance(
-            relations_list, model.SubmodelElementList
-        ):
-            logger.error(
-                f"'MappingSourceSinkRelations' not found in mapping configuration '{mapping_configuration_element.id_short}'."
-            )
-            return source_sink_relations
-
-        for source_sink_relation in relations_list.value:
-            logger.debug(f"Parse source-sink relation '{source_sink_relation}'.")
-
-            if not isinstance(source_sink_relation, model.RelationshipElement):
-                logger.warning(
-                    f"'{source_sink_relation.id_short}' is not a RelationshipElement"
-                )
-                continue
-
-            if (
-                source_sink_relation.first is None
-                or len(source_sink_relation.first.key) == 0
-            ):
-                logger.warning(
-                    f"'first' reference is missing in RelationshipElement '{source_sink_relation.id_short}'"
-                )
-                continue
-
-            if (
-                source_sink_relation.second is None
-                or len(source_sink_relation.second.key) == 0
-            ):
-                logger.warning(
-                    f"'second' reference is missing in RelationshipElement '{source_sink_relation.id_short}'"
-                )
-                continue
-
-            global_ref = next(
-                (
-                    key
-                    for key in source_sink_relation.first.key
-                    if key.type == model.KeyTypes.GLOBAL_REFERENCE
-                ),
-                None,
-            )
-
-            if global_ref is None:
-                logger.warning(
-                    f"No GLOBAL_REFERENCE key found in 'first' reference of RelationshipElement '{source_sink_relation.id_short}'"
-                )
-                continue
-
-            last_fragment_ref = next(
-                (
-                    key
-                    for key in reversed(source_sink_relation.first.key)
-                    if key.type == model.KeyTypes.FRAGMENT_REFERENCE
-                ),
-                None,
-            )
-
-            if last_fragment_ref is None:
-                logger.warning(
-                    f"No FRAGMENT_REFERENCE key found in 'first' reference of RelationshipElement '{source_sink_relation.id_short}'"
-                )
-                continue
-
-            relation = SourceSinkRelation()
-            relation.source = source_sink_relation.first
-            relation.sink = source_sink_relation.second
-            relation.aid_submodel_id = global_ref.value
-            relation.property_name = last_fragment_ref.value
-
-            source_sink_relations.append(relation)
+        if last_fragment_ref is None:
+            logger.warning(f"No FRAGMENT_REFERENCE key found in 'first' reference of RelationshipElement '{source_sink_relation.id_short}'")
+            continue
 
-        return source_sink_relations
+        relation = SourceSinkRelation()
+        relation.source = source_sink_relation.first
+        relation.sink = source_sink_relation.second
+        relation.aid_submodel_id = global_ref.value
+        relation.property_name = last_fragment_ref.value
+        relation.source_parent_path = _get_reference_parent_path(source_ref)
+
+        source_sink_relations.append(relation)
+
+    return source_sink_relations
+
+
+def _get_reference_parent_path(reference: model.ExternalReference) -> list[str]:
+    """Get the parent path of a reference as a list of idShorts.
+
+    :param reference: The reference to extract the parent path from.
+    :return: A list of idShorts representing the parent path.
+    """
+    # Exclude the last key which is the actual element
+    return [key.value for key in reference.key[:-1] if key.type == model.KeyTypes.FRAGMENT_REFERENCE]

aas_standard_parser/collection_helpers.py

@@ -1,6 +1,7 @@
-from basyx.aas.model import NamespaceSet, SubmodelElement, ExternalReference, Reference, Key, KeyTypes
 from typing import List
 
+from basyx.aas.model import ExternalReference, Key, KeyTypes, NamespaceSet, Reference, SubmodelElement
+
 
 def find_all_by_semantic_id(parent: NamespaceSet[SubmodelElement], semantic_id_value: str) -> List[SubmodelElement]:
     """Find all SubmodelElements having a specific Semantic ID.
@@ -9,15 +10,8 @@ def find_all_by_semantic_id(parent: NamespaceSet[SubmodelElement], semantic_id_v
     :param semantic_id_value: The semantic ID value to search for.
     :return: The found SubmodelElement(s) or an empty list if not found.
     """
-    reference: Reference = ExternalReference(
-        (Key(
-            type_=KeyTypes.GLOBAL_REFERENCE,
-            value=semantic_id_value
-        ),)
-    )
-    found_elements: list[SubmodelElement] = [
-        element for element in parent if element.semantic_id.__eq__(reference)
-    ]
+    reference: Reference = ExternalReference((Key(type_=KeyTypes.GLOBAL_REFERENCE, value=semantic_id_value),))
+    found_elements: list[SubmodelElement] = [element for element in parent if element.semantic_id.__eq__(reference)]
     return found_elements
 
 
@@ -29,14 +23,8 @@ def find_by_semantic_id(parent: NamespaceSet[SubmodelElement], semantic_id_value
     :return: The first found SubmodelElement, or None if not found.
     @rtype: object
     """
-
     # create a Reference that acts like the to-be-matched semanticId
-    reference: Reference = ExternalReference(
-        (Key(
-            type_=KeyTypes.GLOBAL_REFERENCE,
-            value=semantic_id_value
-        ),)
-    )
+    reference: Reference = ExternalReference((Key(type_=KeyTypes.GLOBAL_REFERENCE, value=semantic_id_value),))
 
     # check if the constructed Reference appears as semanticId of the child elements
     for element in parent:
@@ -45,6 +33,26 @@ def find_by_semantic_id(parent: NamespaceSet[SubmodelElement], semantic_id_value
     return None
 
 
+def find_by_in_semantic_id(parent: NamespaceSet[SubmodelElement], semantic_id_part: str) -> SubmodelElement | None:
+    """Find a SubmodelElement by checking if its semantic ID contains the given value.
+
+    :param parent: The NamespaceSet to search within.
+    :param semantic_id_value: The semantic ID value to search for.
+    :return: The first found SubmodelElement, or None if not found.
+    """
+    return next((el for el in parent if any(semantic_id_part in key.value for key in el.semantic_id.key)), None)
+
+
+def find_all_by_in_semantic_id(parent: NamespaceSet[SubmodelElement], semantic_id_part: str) -> SubmodelElement | None:
+    """Find a SubmodelElement by checking if its semantic ID contains the given value.
+
+    :param parent: The NamespaceSet to search within.
+    :param semantic_id_value: The semantic ID value to search for.
+    :return: The first found SubmodelElement, or None if not found.
+    """
+    return [el for el in parent if any(semantic_id_part in key.value for key in el.semantic_id.key)]
+
+
 def find_by_id_short(parent: NamespaceSet[SubmodelElement], id_short_value: str) -> SubmodelElement | None:
     """Find a SubmodelElement by its idShort.
 
@@ -79,10 +87,5 @@ def contains_supplemental_semantic_id(element: SubmodelElement, semantic_id_valu
     :param semantic_id_value: The supplemental semantic ID value to search for.
     :return: True if the element contains the supplemental semantic ID, False otherwise.
     """
-    reference: Reference = ExternalReference(
-        (Key(
-            type_=KeyTypes.GLOBAL_REFERENCE,
-            value=semantic_id_value
-        ),)
-    )
+    reference: Reference = ExternalReference((Key(type_=KeyTypes.GLOBAL_REFERENCE, value=semantic_id_value),))
     return element.supplemental_semantic_id.__contains__(reference)

aas_standard_parser/demo/demo_process.py

@@ -0,0 +1,18 @@
+import logging
+
+import aas_standard_parser.aimc_parser as aimc_parser
+from aas_standard_parser.utils import create_submodel_from_file
+
+logger = logging.getLogger(__name__)
+
+
+def start() -> None:
+    logger.info("Demo process started.")
+
+    aimc_submodel = create_submodel_from_file("tests/test_data/aimc_submodel.json")
+
+    tmp = aimc_parser.parse_mapping_configurations(aimc_submodel)
+
+    tmp2 = tmp.configurations[0].source_sink_relations[0].get_source_parent_property_group_name()
+
+    logger.info("Demo process finished.")

aas_standard_parser/demo/logging_handler.py

@@ -0,0 +1,197 @@
+"""
+Logging handler.
+
+This module contains all methods and functions to handle the logging.
+"""
+
+import json
+import logging
+import queue
+import sys
+import uuid
+from datetime import UTC, datetime
+from logging.handlers import QueueHandler
+from pathlib import Path
+from typing import ClassVar
+
+from pythonjsonlogger import jsonlogger
+
+LOG_FOLDER: str = "./_log"
+LOG_FILE_SUFFIX: str = "_log.json"
+
+
+class ColorCodes:
+    """Define the color codes for the console output."""
+
+    grey = "\x1b[38;21m"
+    green = "\x1b[1;32m"
+    yellow = "\x1b[33;21m"
+    red = "\x1b[31;21m"
+    bold_red = "\x1b[31;1m"
+    blue = "\x1b[1;34m"
+    light_blue = "\x1b[1;36m"
+    purple = "\x1b[1;35m"
+    reset = "\x1b[0m"
+
+
+class CustomConsoleFormatter(logging.Formatter):
+    """Custom console formatter for logging with colored level.
+
+    :param logging: formatter
+    """
+
+    FORMATS: ClassVar[dict] = {
+        logging.DEBUG: ColorCodes.blue
+        + "%(levelname)s"
+        + ColorCodes.reset
+        + ":   %(message)s (%(filename)s:%(lineno)d)",
+        logging.INFO: ColorCodes.green
+        + "%(levelname)s"
+        + ColorCodes.reset
+        + ":   %(message)s",
+        logging.WARNING: ColorCodes.yellow
+        + "%(levelname)s"
+        + ColorCodes.reset
+        + ":   %(message)s",
+        logging.ERROR: ColorCodes.red
+        + "%(levelname)s"
+        + ColorCodes.reset
+        + ":    %(message)s (%(filename)s:%(lineno)d)",
+        logging.CRITICAL: ColorCodes.bold_red
+        + "%(levelname)s:  %(message)s (%(filename)s:%(lineno)d)"
+        + ColorCodes.reset,
+    }
+
+    def format(self, record) -> str:
+        """Format the log record.
+
+        :param record: record to format
+        :return: formatted record
+        """
+        log_fmt = self.FORMATS.get(record.levelno)
+        formatter = logging.Formatter(log_fmt)
+        return formatter.format(record)
+
+
+def _handle_file_rotation(log_file_path: Path, max_file_count: int = 5) -> None:
+    log_folder: Path = log_file_path.resolve()
+
+    if max_file_count < 1:
+        return
+
+    if not log_folder.exists():
+        return
+
+    existing_log_files: list[Path] = [
+        file for file in log_folder.iterdir() if file.name.endswith(LOG_FILE_SUFFIX)
+    ]
+
+    if len(existing_log_files) < max_file_count:
+        return
+
+    existing_log_files.sort(key=lambda x: x.stat().st_ctime)
+
+    files_to_delete: int = len(existing_log_files) - (max_file_count - 1)
+
+    for file in existing_log_files[:files_to_delete]:
+        file.unlink()
+
+    return
+
+
+def initialize_logging(console_level=logging.INFO) -> Path:
+    """Initialize the standard logging.
+
+    :param debug_mode_status: Status of the debug mode
+    :param log_file_name: Name of the (path and extension)
+    """
+    log_path = Path(LOG_FOLDER).resolve()
+    log_path.mkdir(parents=True, exist_ok=True)
+
+    log_file_path = log_path / "api.log"
+
+    log_file_format = (
+        "%(asctime)s %(levelname)s: %(message)s   (%(filename)s:%(lineno)d)"
+    )
+    logging.basicConfig(
+        filename=log_file_path,
+        level=logging.DEBUG,
+        format=log_file_format,
+        filemode="w",
+    )
+
+    # set console logging
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(console_level)
+    console_handler.setFormatter(CustomConsoleFormatter())
+    logging.getLogger("").addHandler(console_handler)
+
+    # set queue logging
+    log_queue: queue.Queue = queue.Queue(-1)  # Use default max size
+    queue_handler = QueueHandler(log_queue)
+    logging.getLogger("").addHandler(queue_handler)
+
+    logger = logging.getLogger(__name__)
+    script_path = Path(sys.argv[0])
+    python_version = sys.version.replace("\n", "")
+
+    print("")
+    logger.info(f"Run script '{script_path.name.replace('.py', '')}'")
+    logger.info(f"Script executed by Python v{python_version}")
+    logger.info("Logging initialized")
+
+    return log_file_path.resolve()
+
+
+def read_log_file_as_list(log_file_path: Path) -> list[dict]:
+    """Read the log file as a list of dictionaries (Json conform).
+
+    :param log_file_path: Path to the log file
+    :return: list of dictionaries (Json conform)
+    """
+    with Path.open(log_file_path, "r", encoding="utf-8") as f:
+        return [json.loads(line) for line in f if line.strip()]
+
+
+def set_log_file(
+    max_log_files: int = 10,
+) -> Path:
+    """Set the log file.
+
+    :param max_log_files: max number of log files in folder, defaults to 5
+    :return: log file path
+    """
+    logger = logging.getLogger()  # Get the root logger
+
+    # Remove all existing file handlers
+    for handler in logger.handlers[:]:
+        if isinstance(handler, logging.FileHandler):
+            logger.removeHandler(handler)
+            handler.close()
+
+    now = datetime.now(tz=UTC)
+    time_string = now.strftime("%Y-%m-%d_%H-%M-%S")
+
+    # handle log file and folder
+    log_path: Path = Path(LOG_FOLDER).resolve()
+    log_path = Path(LOG_FOLDER, "runtime").resolve()
+
+    log_path.mkdir(parents=True, exist_ok=True)
+    log_file_name = f"{uuid.uuid4().hex}{LOG_FILE_SUFFIX}"
+    log_file_path = log_path / f"{time_string}_{log_file_name}"
+
+    _handle_file_rotation(log_path, max_log_files)
+
+    # Add a new file handler with the new log file path
+    json_formatter = jsonlogger.JsonFormatter(
+        "%(asctime)s %(levelname)s %(name)s %(message)s %(filename)s %(lineno)d"
+    )
+    json_file_handler = logging.FileHandler(log_file_path, mode="w")
+    json_file_handler.setFormatter(json_formatter)
+    json_file_handler.setLevel(logging.DEBUG)
+    logger.addHandler(json_file_handler)
+
+    logging.info(f"Maximum log file number is: {max_log_files}")  # noqa: LOG015
+    logging.info(f"Write log file to: '{log_file_path}'")  # noqa: LOG015
+
+    return log_file_path.resolve()

aas_standard_parser/submodel_parser.py

@@ -1,13 +1,26 @@
+"""Module for parsing submodels."""
+
 import logging
 
 from basyx.aas import model
+from basyx.aas.model import ExternalReference, Key, KeyTypes, NamespaceSet, Reference, SubmodelElement
+
+import collection_helpers
 
 logger = logging.getLogger(__name__)
 
 
-def get_submodel_element_by_path(
-    submodel: model.Submodel, path: str
-) -> model.SubmodelElement:
+def get_element_by_semantic_id(collection: NamespaceSet[SubmodelElement], semantic_id: str) -> SubmodelElement | None:
+    """Get an element from parent collection by its semantic ID (not recursive).
+
+    :param parent: parent collection to search within
+    :param semantic_id: semantic ID to search for
+    :return: the found submodel element or None if not found
+    """
+    return collection_helpers.find_by_semantic_id(collection, semantic_id)
+
+
+def get_submodel_element_by_path(submodel: model.Submodel, path: str) -> model.SubmodelElement:
     """Returns a specific submodel element from the submodel at a specific path.
 
     :param submodel: The submodel to search within.
@@ -26,24 +39,15 @@ def get_submodel_element_by_path(
             base, idx = part[:-1].split("[")
             idx = int(idx)
             # Find the SubmodelElementList in the current elements
-            submodel_element = next(
-                (el for el in current_elements if el.id_short == base), None
-            )
-
-            if not submodel_element or not (
-                isinstance(submodel_element, model.SubmodelElementList)
-                or isinstance(submodel_element, model.SubmodelElementCollection)
-            ):
-                logger.debug(
-                    f"Submodel element '{base}' not found or is not a collection/list in current {current_elements}."
-                )
+            submodel_element = next((el for el in current_elements if el.id_short == base), None)
+
+            if not submodel_element or not (isinstance(submodel_element, (model.SubmodelElementList, model.SubmodelElementCollection))):
+                logger.debug(f"Submodel element '{base}' not found or is not a collection/list in current {current_elements}.")
                 return None
 
             # Check if index is within range
             if idx >= len(submodel_element.value):
-                logger.debug(
-                    f"Index '{idx}' out of range for element '{base}' with length {len(submodel_element.value)}."
-                )
+                logger.debug(f"Index '{idx}' out of range for element '{base}' with length {len(submodel_element.value)}.")
                 return None
 
             # get the element by its index from SubmodelElementList
@@ -51,14 +55,10 @@ def get_submodel_element_by_path(
 
         else:
             # Find the SubmodelElement in the current SubmodelElementCollection
-            submodel_element = next(
-                (el for el in current_elements if el.id_short == part), None
-            )
+            submodel_element = next((el for el in current_elements if el.id_short == part), None)
 
         if not submodel_element:
-            logger.debug(
-                f"Submodel element '{part}' not found in current {current_elements}."
-            )
+            logger.debug(f"Submodel element '{part}' not found in current {current_elements}.")
             return None
 
         # If we've reached the last part, return the found element
@@ -66,9 +66,7 @@ def get_submodel_element_by_path(
             return submodel_element
 
         # If the found element is a collection or list, continue traversing
-        if isinstance(submodel_element, model.SubmodelElementCollection) or isinstance(
-            submodel_element, model.SubmodelElementList
-        ):
+        if isinstance(submodel_element, (model.SubmodelElementCollection, model.SubmodelElementList)):
             current_elements = submodel_element.value
         else:
             return submodel_element

aas_standard_parser/utils.py

@@ -0,0 +1,25 @@
+import json
+from pathlib import Path
+
+from aas_http_client import sdk_tools
+from basyx.aas import model
+
+
+def create_submodel_from_file(file_path: str) -> model.Submodel:
+    """Creates a Submodel from a given file path.
+
+    :param file_path: Path to the file containing the submodel data.
+    :return: The created Submodel object.
+    """
+    file = Path(file_path)
+    if not file.exists():
+        raise FileNotFoundError(f"Submodel template file not found: {file}")
+
+    template_data = {}
+
+    # Load the template JSON file
+    with open(file, "r", encoding="utf-8") as f:
+        template_data = json.load(f)
+
+    # Load the template JSON into a Submodel object
+    return sdk_tools.convert_to_object(template_data)

{aas_standard_parser-0.1.6.dist-info → aas_standard_parser-0.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aas-standard-parser
-Version: 0.1.6
+Version: 0.1.8
 Summary: Some auxiliary functions for parsing standard submodels
 Author-email: Daniel Klein <daniel.klein@em.ag>
 License: MIT License

aas_standard_parser-0.1.8.dist-info/RECORD

@@ -0,0 +1,14 @@
+aas_standard_parser/__init__.py,sha256=3iBTUUlJ97ImkAHdss_GP970BANEU1uNeg0HlRzzois,599
+aas_standard_parser/aid_parser.py,sha256=9vp8_kJRfExTmw8tjmO32n1eHFAE5ItmfPlZ2ORLZMs,14314
+aas_standard_parser/aimc_parser.py,sha256=yl94hOtqoOHYFP_8cladJho8u8QZ3MNUXR0OpXl5bLU,12298
+aas_standard_parser/collection_helpers.py,sha256=fTQGQiC-bGD41Qx0FDDBtWhvkeZtEe6Sh-aT93ePwro,4153
+aas_standard_parser/reference_helpers.py,sha256=UbqXaub5PTvt_W3VPntSSFcTS59PUwlTpoujny8rIRI,377
+aas_standard_parser/submodel_parser.py,sha256=4cPziJbFh3GjZ0ClSlCqIFJcYn-1tCg2Bmp7NrnMs_I,3189
+aas_standard_parser/utils.py,sha256=5iIPpM_ob2V9MwFL_vTbXd23doYKot30xenRmTPAquo,723
+aas_standard_parser/demo/demo_process.py,sha256=Xn9uD0xLoNx0ZvB3Lk0oYkGBRHaEfUbfqv5_SpPWYck,530
+aas_standard_parser/demo/logging_handler.py,sha256=x-eX4XDU3sZTJE22rzJSiaWQ8wRMbtaFpFBAeAcbIzI,5752
+aas_standard_parser-0.1.8.dist-info/licenses/LICENSE,sha256=simqYMD2P9Ikm0Kh9n7VGNpaVcm2TMVVQmECYZ_xVZ8,1065
+aas_standard_parser-0.1.8.dist-info/METADATA,sha256=5Sn4uRjsyj1k1yEIdfKXPCuLdHWkTlfglAi--InR3O0,1718
+aas_standard_parser-0.1.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aas_standard_parser-0.1.8.dist-info/top_level.txt,sha256=OQaK6cwYttR1-eKTz5u4M0jbwSfp4HqJ56chaf0nHnw,20
+aas_standard_parser-0.1.8.dist-info/RECORD,,

aas_standard_parser-0.1.6.dist-info/RECORD

@@ -1,11 +0,0 @@
-aas_standard_parser/__init__.py,sha256=vOFawIqavj7AIeabmIOq8iBr69lKFkzZVNKcAeIlayk,609
-aas_standard_parser/aid_parser.py,sha256=c8fERs7fxA1n5KwSdL8fGEq_w7f7NJdWNd6_QDByFwg,11876
-aas_standard_parser/aimc_parser.py,sha256=QVTAGCdIvf9K-L97aaBbQzHA9QG3JOrgETCHEHLBw0c,11964
-aas_standard_parser/collection_helpers.py,sha256=OYuy5lDEdy5rXw5L5-I2-KHF33efHsZUulo2rA58_zs,3287
-aas_standard_parser/reference_helpers.py,sha256=UbqXaub5PTvt_W3VPntSSFcTS59PUwlTpoujny8rIRI,377
-aas_standard_parser/submodel_parser.py,sha256=91YMIQEaXohNIwI3_b-sGnCvflQhXZrhyyDCpBD2hks,2871
-aas_standard_parser-0.1.6.dist-info/licenses/LICENSE,sha256=simqYMD2P9Ikm0Kh9n7VGNpaVcm2TMVVQmECYZ_xVZ8,1065
-aas_standard_parser-0.1.6.dist-info/METADATA,sha256=kWoMVNQ9HOySA_JIwpGrZzfMMilAPdqoTNmZ-AxLQwo,1718
-aas_standard_parser-0.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aas_standard_parser-0.1.6.dist-info/top_level.txt,sha256=OQaK6cwYttR1-eKTz5u4M0jbwSfp4HqJ56chaf0nHnw,20
-aas_standard_parser-0.1.6.dist-info/RECORD,,