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

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

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

{aas_standard_parser-0.2.0 → aas_standard_parser-0.2.2}/aas_standard_parser/aimc_parser.py

@@ -1,69 +1,15 @@
 """Parser for Mapping Configurations in AIMC Submodel."""
 
-import json
 import logging
-from dataclasses import field
 
-import basyx.aas.adapter.json
 from basyx.aas import model
 
 import aas_standard_parser.collection_helpers as ch
+from aas_standard_parser.classes.aimc_parser_classes import MappingConfiguration, MappingConfigurations, ReferenceProperties, SourceSinkRelation
 
 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."""
-
-    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."})
-    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.
-
-        :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))
-
-
-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.
 
@@ -168,7 +114,7 @@ def parse_mapping_configuration_element(
         return None
 
     # check if all relations have the same AID submodel
-    aid_submodel_ids = list({source_sink_relation.source_submodel_id for source_sink_relation in source_sink_relations})
+    aid_submodel_ids = list({source_sink_relation.source_properties.submodel_id for source_sink_relation in source_sink_relations})
 
     if len(aid_submodel_ids) != 1:
         logger.error(
@@ -237,20 +183,9 @@ 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_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.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
+        relation.source_properties = _get_reference_properties(source_sink_relation.first)
+        relation.sink_properties = _get_reference_properties(source_sink_relation.second)
 
         source_sink_relations.append(relation)
 
@@ -276,6 +211,7 @@ def _get_reference_properties(reference: model.ExternalReference) -> ReferencePr
     ref_properties.submodel_id = global_ref.value
     ref_properties.property_name = last_fragment_ref.value
     ref_properties.parent_path = parent_path
+    ref_properties.reference = reference
 
     return ref_properties
 

aas_standard_parser-0.2.2/aas_standard_parser/classes/aimc_parser_classes.py

@@ -0,0 +1,52 @@
+import json
+from dataclasses import field
+
+import basyx.aas.adapter.json
+from basyx.aas import model
+
+
+class ReferenceProperties:
+    """Class representing properties of a reference in the mapping configuration."""
+
+    reference: model.ExternalReference = field(metadata={"description": "Reference to the property in the submodel."})
+    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."""
+
+    source_properties: ReferenceProperties = field(metadata={"description": "Properties of the source reference."})
+    sink_properties: ReferenceProperties = field(metadata={"description": "Properties of the sink reference."})
+
+    def source_reference_as_dict(self) -> dict:
+        """Convert the source reference to a dictionary.
+
+        :return: The source reference as a dictionary.
+        """
+        dict_string = json.dumps(self.source_properties.reference, cls=basyx.aas.adapter.json.AASToJsonEncoder)
+        dict_string = dict_string.replace("GlobalReference", "Submodel").replace("FragmentReference", "SubmodelElementCollection")
+        return json.loads(dict_string)
+
+    def sink_reference_as_dict(self) -> dict:
+        """Convert the sink reference to a dictionary.
+
+        :return: The sink reference as a dictionary.
+        """
+        return json.dumps(self.sink_properties.reference, cls=basyx.aas.adapter.json.AASToJsonEncoder)
+
+
+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."})

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

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

{aas_standard_parser-0.2.0 → aas_standard_parser-0.2.2}/aas_standard_parser.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ aas_standard_parser.egg-info/SOURCES.txt
 aas_standard_parser.egg-info/dependency_links.txt
 aas_standard_parser.egg-info/requires.txt
 aas_standard_parser.egg-info/top_level.txt
+aas_standard_parser/classes/aimc_parser_classes.py
 aas_standard_parser/demo/demo_process.py
 aas_standard_parser/demo/logging_handler.py
 tests/test_aimc_parser.py

{aas_standard_parser-0.2.0 → aas_standard_parser-0.2.2}/pyproject.toml

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

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

@@ -1,7 +1,7 @@
 import pytest
 from basyx.aas import model
 
-from aas_standard_parser.aimc_parser import MappingConfiguration, SourceSinkRelation
+from aas_standard_parser.classes.aimc_parser_classes import MappingConfiguration, SourceSinkRelation, ReferenceProperties
 import aas_standard_parser.aimc_parser as aimc_parser
 from aas_standard_parser.utils import create_submodel_from_file
 
@@ -41,7 +41,6 @@ def test_003_parse_mapping_configuration_element(aimc_submodel: model.submodel):
     assert configuration is not None
     _check_interface_ref(configuration)
     _check_relations(configuration)
-    _check_relations(configuration)
 
 def test_004_parse_mapping_configurations(aimc_submodel: model.submodel):
     mapping_configurations = aimc_parser.parse_mapping_configurations(aimc_submodel)
@@ -57,7 +56,6 @@ def test_004_parse_mapping_configurations(aimc_submodel: model.submodel):
 
     _check_interface_ref(configuration)
     _check_relations(configuration)
-    _check_relations(configuration)
 
 def _check_interface_ref(configuration: MappingConfiguration):
     assert configuration.interface_reference is not None
@@ -81,51 +79,51 @@ def _check_relations(configuration: MappingConfiguration):
     relation = configuration.source_sink_relations[0]
     assert relation is not None
 
-    assert relation.source is not None
-    assert relation.source_submodel_id == configuration.aid_submodel_id
+    assert relation.source_properties is not None
+    assert relation.source_properties.submodel_id == configuration.aid_submodel_id
 
-    assert relation.sink is not None
+    assert relation.sink_properties is not None
 
-    _check_relations_source(relation)
-    _check_relations_sink(relation)
+    _check_relations_source(relation.source_properties)
+    _check_relations_sink(relation.sink_properties)
     _check_relation_methods(relation)
 
-def _check_relations_source(relation: SourceSinkRelation):
-    assert relation is not None
+def _check_relations_source(reference_properties: ReferenceProperties):
+    assert reference_properties is not None
 
-    assert isinstance(relation.source, model.ExternalReference)
+    assert isinstance(reference_properties.reference, model.ExternalReference)
 
-    assert relation.source_property_name is not None
-    assert relation.source_property_name == "HandlingC"
+    assert reference_properties.property_name is not None
+    assert reference_properties.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 reference_properties.parent_path is not None
+    assert len(reference_properties.parent_path) == 5
+    assert reference_properties.parent_path[3] == "axes_position"
 
-    assert relation.source_submodel_id is not None
-    assert relation.source_submodel_id == relation.source.key[0].value
+    assert reference_properties.submodel_id is not None
+    assert reference_properties.submodel_id == reference_properties.reference.key[0].value
 
-def _check_relations_sink(relation: SourceSinkRelation):
-    assert relation is not None
+def _check_relations_sink(reference_properties: ReferenceProperties):
+    assert reference_properties is not None
 
-    assert isinstance(relation.sink, model.ExternalReference)
+    assert isinstance(reference_properties.reference, model.ExternalReference)
 
-    assert relation.sink_property_name is not None
-    assert relation.sink_property_name == "HandlingC"
+    assert reference_properties.property_name is not None
+    assert reference_properties.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 reference_properties.parent_path is not None
+    assert len(reference_properties.parent_path) == 2
+    assert reference_properties.parent_path[1] == "AxesPosition"
 
-    assert relation.sink_submodel_id is not None
-    assert relation.sink_submodel_id == relation.sink.key[0].value
+    assert reference_properties.submodel_id is not None
+    assert reference_properties.submodel_id == reference_properties.reference.key[0].value
 
 def _check_relation_methods(relation: SourceSinkRelation):
     # test to_json methods
-    source_json = relation.source_as_dict()
+    source_json = relation.source_reference_as_dict()
     assert source_json is not None
     assert "type" in source_json
 
-    sink_json = relation.sink_as_dict()
+    sink_json = relation.sink_reference_as_dict()
     assert sink_json is not None
     assert "type" in sink_json