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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aas-standard-parser
-Version: 0.1.8
+Version: 0.2.0
 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 → aas_standard_parser-0.2.0}/aas_standard_parser/aimc_parser.py

@@ -2,7 +2,7 @@
 
 import json
 import logging
-from dataclasses import dataclass, field
+from dataclasses import field
 
 import basyx.aas.adapter.json
 from basyx.aas import model
@@ -12,14 +12,25 @@ import aas_standard_parser.collection_helpers as ch
 logger = logging.getLogger(__name__)
 
 
+class ReferenceProperties:
+    """Class representing properties of a reference in the mapping configuration."""
+
+    submodel_id: str = field(metadata={"description": "Identifier of the submodel used by the reference."})
+    property_name: str = field(metadata={"description": "Name of the mapped property."})
+    parent_path: list[str] = field(metadata={"description": "List of idShorts representing the parent path of the reference."})
+
+
 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_submodel_id: str = field(metadata={"description": "Identifier of the source (AID) submodel used by the source reference."})
+    sink_submodel_id: str = field(metadata={"description": "Identifier of the target submodel used by the sink 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."})
+    source_property_name: str = field(metadata={"description": "Name of the mapped property in source."})
+    sink_property_name: str = field(metadata={"description": "Name of the mapped property in sink."})
+    source_parent_path: list[str] = field(metadata={"description": "List of idShorts representing the parent path of the source reference."})
+    sink_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.
@@ -37,13 +48,6 @@ class SourceSinkRelation:
         """
         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."""
@@ -164,7 +168,7 @@ def parse_mapping_configuration_element(
         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.source_submodel_id for source_sink_relation in source_sink_relations})
 
     if len(aid_submodel_ids) != 1:
         logger.error(
@@ -233,35 +237,49 @@ def _generate_source_sink_relations(mapping_configuration_element: model.Submode
             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
+        source_ref_properties = _get_reference_properties(source_sink_relation.first)
+        sink_ref_properties = _get_reference_properties(source_sink_relation.second)
 
         relation = SourceSinkRelation()
+
         relation.source = source_sink_relation.first
+        relation.source_submodel_id = source_ref_properties.submodel_id
+        relation.source_property_name = source_ref_properties.property_name
+        relation.source_parent_path = source_ref_properties.parent_path
+
         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)
+        relation.sink_submodel_id = sink_ref_properties.submodel_id
+        relation.sink_property_name = sink_ref_properties.property_name
+        relation.sink_parent_path = sink_ref_properties.parent_path
 
         source_sink_relations.append(relation)
 
     return source_sink_relations
 
 
+def _get_reference_properties(reference: model.ExternalReference) -> ReferenceProperties | None:
+    global_ref = next((key for key in reference.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 '{reference}'")
+        return None
+
+    last_fragment_ref = next((key for key in reversed(reference.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 '{reference.id_short}'")
+        return None
+
+    parent_path = _get_reference_parent_path(reference)
+
+    ref_properties = ReferenceProperties()
+    ref_properties.submodel_id = global_ref.value
+    ref_properties.property_name = last_fragment_ref.value
+    ref_properties.parent_path = parent_path
+
+    return ref_properties
+
+
 def _get_reference_parent_path(reference: model.ExternalReference) -> list[str]:
     """Get the parent path of a reference as a list of idShorts.
 

{aas_standard_parser-0.1.8 → aas_standard_parser-0.2.0}/aas_standard_parser/submodel_parser.py

@@ -3,9 +3,9 @@
 import logging
 
 from basyx.aas import model
-from basyx.aas.model import ExternalReference, Key, KeyTypes, NamespaceSet, Reference, SubmodelElement
+from basyx.aas.model import NamespaceSet, SubmodelElement
 
-import collection_helpers
+from aas_standard_parser import collection_helpers
 
 logger = logging.getLogger(__name__)
 

{aas_standard_parser-0.1.8 → aas_standard_parser-0.2.0}/aas_standard_parser.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aas-standard-parser
-Version: 0.1.8
+Version: 0.2.0
 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 → aas_standard_parser-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aas-standard-parser"
-version = "0.1.8"
+version = "0.2.0"
 description = "Some auxiliary functions for parsing standard submodels"
 readme = "README.md"
 license = { file = "LICENSE" }

{aas_standard_parser-0.1.8 → aas_standard_parser-0.2.0}/tests/test_aimc_parser.py

@@ -1,7 +1,7 @@
 import pytest
 from basyx.aas import model
 
-from aas_standard_parser.aimc_parser import MappingConfiguration
+from aas_standard_parser.aimc_parser import MappingConfiguration, SourceSinkRelation
 import aas_standard_parser.aimc_parser as aimc_parser
 from aas_standard_parser.utils import create_submodel_from_file
 
@@ -40,7 +40,7 @@ def test_003_parse_mapping_configuration_element(aimc_submodel: model.submodel):
 
     assert configuration is not None
     _check_interface_ref(configuration)
-    _check_relations_aid(configuration)
+    _check_relations(configuration)
     _check_relations(configuration)
 
 def test_004_parse_mapping_configurations(aimc_submodel: model.submodel):
@@ -56,7 +56,7 @@ def test_004_parse_mapping_configurations(aimc_submodel: model.submodel):
     assert configuration.aid_submodel_id == "https://fluid40.de/ids/sm/4757_4856_8464_1441"
 
     _check_interface_ref(configuration)
-    _check_relations_aid(configuration)
+    _check_relations(configuration)
     _check_relations(configuration)
 
 def _check_interface_ref(configuration: MappingConfiguration):
@@ -74,24 +74,58 @@ def _check_interface_ref(configuration: MappingConfiguration):
     assert key is not None
     assert key.value == "https://fluid40.de/ids/sm/4757_4856_8464_1442/Interface_MQTT"
 
-def _check_relations_aid(configuration: MappingConfiguration):
+
+def _check_relations(configuration: MappingConfiguration):
     assert len(configuration.source_sink_relations) > 0
 
     relation = configuration.source_sink_relations[0]
     assert relation is not None
-    assert relation.aid_submodel_id == configuration.aid_submodel_id
 
-    assert relation.property_name is not None
-    assert relation.property_name == "HandlingC"
+    assert relation.source is not None
+    assert relation.source_submodel_id == configuration.aid_submodel_id
 
+    assert relation.sink is not None
 
-def _check_relations(configuration: MappingConfiguration):
-    assert len(configuration.source_sink_relations) > 0
+    _check_relations_source(relation)
+    _check_relations_sink(relation)
+    _check_relation_methods(relation)
 
-    relation = configuration.source_sink_relations[0]
+def _check_relations_source(relation: SourceSinkRelation):
     assert relation is not None
-    assert relation.source is not None
-    assert relation.sink is not None
 
     assert isinstance(relation.source, model.ExternalReference)
+
+    assert relation.source_property_name is not None
+    assert relation.source_property_name == "HandlingC"
+
+    assert relation.source_parent_path is not None
+    assert len(relation.source_parent_path) == 5
+    assert relation.source_parent_path[3] == "axes_position"
+
+    assert relation.source_submodel_id is not None
+    assert relation.source_submodel_id == relation.source.key[0].value
+
+def _check_relations_sink(relation: SourceSinkRelation):
+    assert relation is not None
+
     assert isinstance(relation.sink, model.ExternalReference)
+
+    assert relation.sink_property_name is not None
+    assert relation.sink_property_name == "HandlingC"
+
+    assert relation.sink_parent_path is not None
+    assert len(relation.sink_parent_path) == 2
+    assert relation.sink_parent_path[1] == "AxesPosition"
+
+    assert relation.sink_submodel_id is not None
+    assert relation.sink_submodel_id == relation.sink.key[0].value
+
+def _check_relation_methods(relation: SourceSinkRelation):
+    # test to_json methods
+    source_json = relation.source_as_dict()
+    assert source_json is not None
+    assert "type" in source_json
+
+    sink_json = relation.sink_as_dict()
+    assert sink_json is not None
+    assert "type" in sink_json