aas-standard-parser 0.1.6__tar.gz → 0.1.8__tar.gz

{aas_standard_parser-0.1.6 → aas_standard_parser-0.1.8}/PKG-INFO

@@ -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.6 → aas_standard_parser-0.1.8}/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-0.1.6 → aas_standard_parser-0.1.8}/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-0.1.8/aas_standard_parser/aimc_parser.py

@@ -0,0 +1,272 @@
+"""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 = 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")
+        return json.loads(dict_string)
+
+    def sink_as_dict(self) -> dict:
+        """Convert the sink reference to a dictionary.
+
+        :return: The sink reference as a dictionary.
+        """
+        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 = 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] = 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."})
+
+
+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.
+
+    :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
+
+    # 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.")
+
+    return mc_element
+
+
+def get_mapping_configuration_elements(aimc_submodel: model.Submodel) -> list[model.SubmodelElementCollection] | None:
+    """Get all mapping configurations 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
+
+    # get mapping configuration root element
+    root_element = get_mapping_configuration_root_element(aimc_submodel)
+    if root_element is None:
+        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")
+
+    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.
+
+    :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.")
+
+    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
+
+    # 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)
+
+    logger.debug(f"Parsed {len(mapping_configurations)} mapping configurations.")
+
+    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"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.
+
+    :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}'")
+
+    # get interface reference element
+    interface_reference = _get_interface_reference_element(mapping_configuration_element)
+    if interface_reference is None:
+        return None
+
+    source_sink_relations = _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}'.")
+        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
+
+    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_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}'.")
+
+        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 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
+        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]