aas-standard-parser 0.1.5__tar.gz → 0.1.7__tar.gz

{aas_standard_parser-0.1.5 → aas_standard_parser-0.1.7}/PKG-INFO

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

{aas_standard_parser-0.1.5 → aas_standard_parser-0.1.7}/aas_standard_parser/__init__.py

@@ -1,5 +1,5 @@
-from datetime import datetime
 import importlib.metadata
+from datetime import datetime
 
 # TODO: introduce MIT license
 __copyright__ = f"Copyright (C) {datetime.now().year} :em engineering methods AG. All rights reserved."
@@ -9,12 +9,11 @@ try:
     __version__ = importlib.metadata.version(__name__)
 except importlib.metadata.PackageNotFoundError:
     __version__ = "0.0.0-dev"
-    
+
 __project__ = "aas-standard-parser"
 __package__ = "aas-standard-parser"
 
-from aas_standard_parser.aimc_parser import AIMCParser
 from aas_standard_parser.aid_parser import AIDParser
-
+from aas_standard_parser.aimc_parser import AIMCParser
 
 __all__ = ["AIMCParser", "AIDParser"]

{aas_standard_parser-0.1.5 → aas_standard_parser-0.1.7}/aas_standard_parser/aid_parser.py

@@ -5,17 +5,32 @@ 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
 
 
+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
+
+
 class PropertyDetails:
 
-    def __init__(self, href: str, keys: List[str]):
+    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:
@@ -44,7 +59,7 @@ 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(
@@ -62,7 +77,7 @@ class AIDParser():
         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 +103,53 @@ 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:
+                    # 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  # string
+                    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,26 +163,17 @@ 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:
+        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"
             )
@@ -165,15 +186,51 @@ class AIDParser():
             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

{aas_standard_parser-0.1.5 → aas_standard_parser-0.1.7}/aas_standard_parser/aimc_parser.py

@@ -20,8 +20,12 @@ class SourceSinkRelation:
 
         :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:
@@ -29,7 +33,9 @@ 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)
+        )
 
 
 class MappingConfiguration:
@@ -66,37 +72,54 @@ class AIMCParser:
 
         self.aimc_submodel = aimc_submodel
 
-    def get_mapping_configuration_root_element(self) -> model.SubmodelElementCollection | None:
+    def get_mapping_configuration_root_element(
+        self,
+    ) -> model.SubmodelElementCollection | None:
         """Get the mapping configuration root submodel element collection from the AIMC submodel.
 
         :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
+            (
+                elem
+                for elem in self.aimc_submodel.submodel_element
+                if elem.id_short == "MappingConfigurations"
+            ),
+            None,
         )
 
         if self.mapping_configuration_element is None:
-            logger.error("'MappingConfigurations' element list not found in AIMC submodel.")
+            logger.error(
+                "'MappingConfigurations' element list not found in AIMC submodel."
+            )
             return None
 
         return self.mapping_configuration_element
 
-    def get_mapping_configuration_elements(self) -> list[model.SubmodelElementCollection] | None:
+    def get_mapping_configuration_elements(
+        self,
+    ) -> list[model.SubmodelElementCollection] | None:
         """Get all mapping configurations elements from the AIMC submodel.
 
         :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()
+            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)
+            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.")
+        logger.debug(
+            f"Found {len(mapping_configurations)} mapping configuration elements in AIMC submodel."
+        )
 
         return mapping_configurations
 
@@ -125,14 +148,22 @@ class AIMCParser:
         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})
+        mcs.aid_submodel_ids = list(
+            {mc.aid_submodel_id for mc in 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.")
+        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(self, mapping_configuration_element: model.SubmodelElementCollection) -> MappingConfiguration | None:
+    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.
@@ -144,19 +175,30 @@ class AIMCParser:
 
         logger.debug(f"Parse mapping configuration '{mapping_configuration_element}'")
 
-        interface_reference = self._get_interface_reference(mapping_configuration_element)
+        interface_reference = self._get_interface_reference(
+            mapping_configuration_element
+        )
 
         if interface_reference is None:
             return None
 
-        source_sink_relations = self._generate_source_sink_relations(mapping_configuration_element)
+        source_sink_relations = self._generate_source_sink_relations(
+            mapping_configuration_element
+        )
 
         if len(source_sink_relations) == 0:
-            logger.error(f"No source-sink relations found in mapping configuration '{mapping_configuration_element.id_short}'.")
+            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})
+        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(
@@ -171,66 +213,124 @@ class AIMCParser:
         mc.aid_submodel_id = aid_submodel_ids[0]
         return mc
 
-    def _get_interface_reference(self, mapping_configuration_element: model.SubmodelElementCollection) -> model.ReferenceElement | None:
+    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}'.")
+        logger.debug(
+            f"Get 'InterfaceReference' from mapping configuration '{mapping_configuration_element}'."
+        )
 
         interface_ref: model.ReferenceElement = next(
-            (elem for elem in mapping_configuration_element.value if elem.id_short == "InterfaceReference"), None
+            (
+                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}'.")
+        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}'.")
+            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]:
+    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}'.")
+        logger.debug(
+            f"Get 'MappingSourceSinkRelations' from mapping configuration '{mapping_configuration_element}'."
+        )
 
         relations_list: model.SubmodelElementList = next(
-            (elem for elem in mapping_configuration_element.value if elem.id_short == "MappingSourceSinkRelations"), None
+            (
+                elem
+                for elem in mapping_configuration_element.value
+                if elem.id_short == "MappingSourceSinkRelations"
+            ),
+            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}'.")
+        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")
+                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}'")
+            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}'")
+            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)
+            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}'")
+                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)
+            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}'")
+                logger.warning(
+                    f"No FRAGMENT_REFERENCE key found in 'first' reference of RelationshipElement '{source_sink_relation.id_short}'"
+                )
                 continue
 
             relation = SourceSinkRelation()

aas_standard_parser-0.1.7/aas_standard_parser/submodel_parser.py

@@ -0,0 +1,76 @@
+import logging
+
+from basyx.aas import model
+
+logger = logging.getLogger(__name__)
+
+
+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.
+    :param path: IdShort path to the submodel element (dot-separated), e.g., "Element1.Element2[0].Element3".
+    :return: The found submodel element or None if not found.
+    """
+    # Split the path by '.' and traverse the structure
+    parts = path.split(".")
+    current_elements = submodel.submodel_element
+    part_index = 0
+    for part in parts:
+        part_index += 1
+        # Handle indexed access like "Element[0]" for SubmodelElementLists
+        if "[" in part and "]" in part:
+            # Split SubmodelElementList name and index
+            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}."
+                )
+                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)}."
+                )
+                return None
+
+            # get the element by its index from SubmodelElementList
+            submodel_element = submodel_element.value[idx]
+
+        else:
+            # Find the SubmodelElement in the current SubmodelElementCollection
+            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}."
+            )
+            return None
+
+        # If we've reached the last part, return the found element
+        if part_index == len(parts):
+            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
+        ):
+            current_elements = submodel_element.value
+        else:
+            return submodel_element
+
+    return submodel_element

{aas_standard_parser-0.1.5 → aas_standard_parser-0.1.7}/aas_standard_parser.egg-info/PKG-INFO

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

{aas_standard_parser-0.1.5 → aas_standard_parser-0.1.7}/aas_standard_parser.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ aas_standard_parser/aid_parser.py
 aas_standard_parser/aimc_parser.py
 aas_standard_parser/collection_helpers.py
 aas_standard_parser/reference_helpers.py
+aas_standard_parser/submodel_parser.py
 aas_standard_parser.egg-info/PKG-INFO
 aas_standard_parser.egg-info/SOURCES.txt
 aas_standard_parser.egg-info/dependency_links.txt

{aas_standard_parser-0.1.5 → aas_standard_parser-0.1.7}/pyproject.toml

@@ -4,15 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aas-standard-parser"
-version = "0.1.5"
+version = "0.1.7"
 description = "Some auxiliary functions for parsing standard submodels"
 readme = "README.md"
 license = { file = "LICENSE" }
 authors = [{ name = "Daniel Klein", email = "daniel.klein@em.ag" }]
-dependencies = [
-    "typing>=3.7.4.3",
-    "basyx-python-sdk>=1.2.1",
-]
+dependencies = ["typing>=3.7.4.3", "basyx-python-sdk>=1.2.1"]
 [project.urls]
 Homepage = "https://github.com/fluid40/aas-http-client"