aas-standard-parser 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

aas_standard_parser/__init__.py

@@ -0,0 +1,18 @@
+from datetime import datetime
+import importlib.metadata
+
+__copyright__ = f"Copyright (C) {datetime.now().year} :em engineering methods AG. All rights reserved."
+__author__ = "Daniel Klein"
+
+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 import aid_parser, aimc_parser
+
+
+__all__ = ["aid_parser", "aimc_parser"]

aas_standard_parser/aid_parser.py

@@ -0,0 +1,305 @@
+"""This module provides functions to parse AID Submodels and extract MQTT interface descriptions."""
+
+from collections.abc import Iterator
+from typing import NamedTuple
+
+from basyx.aas.model import (
+    ExternalReference,
+    Key,
+    KeyTypes,
+    NamespaceSet,
+    Property,
+    Reference,
+    Submodel,
+    SubmodelElement,
+    SubmodelElementCollection,
+)
+from basyx.aas.util import traversal
+
+
+class MQTTInterfaceDescription(NamedTuple):
+    """Represents an MQTT interface configuration for a specific asset.
+
+    :param interface_smc: The SubmodelElementCollection representing the MQTT interface.
+    :param base_url: The base URL for the MQTT interface.
+    :param websocket_connection: Whether this interface is using a WebSocket connection or not (default).
+    """
+
+    interface_smc: SubmodelElementCollection
+    base_url: str
+    websocket_connection: bool = False
+
+class AIDParser:
+    """A class to handle parsing of AID Submodels and connecting to MQTT topics.
+
+    It extracts the MQTT topic information from the AID Submodel as well as the base url of the MQTT broker.
+    All MQTT interface configurations are stored in a list of MQTTInterfaceDescriptions.
+    """
+
+    _mqtt_interface_descriptions: list[MQTTInterfaceDescription]
+    _default_mqtt_interface: MQTTInterfaceDescription = None
+    _fallback_mqtt_interface: MQTTInterfaceDescription = None
+    _topic_map: dict[str, str] = {}
+
+    def __init__(self, aid_sm: Submodel):
+        """Initialize the AIDParser with a JSON representation of an AID Submodel.
+
+        Extract all MQTT interface collections and find the contained MQTT topics using the default interface.
+        """
+        mqtt_interfaces: list[SubmodelElementCollection] = self._find_all_mqtt_interfaces(aid_sm)
+        if mqtt_interfaces == []:
+            print("No MQTT interface description found in AID Submodel.")
+
+        self._mqtt_interface_descriptions = [
+            MQTTInterfaceDescription(
+                interface_smc=smc,
+                base_url=self._get_base_url_from_interface(smc),
+                websocket_connection=self._uses_websocket(smc)
+            )
+            for smc in mqtt_interfaces
+        ]
+        print(f"Found {len(self._mqtt_interface_descriptions)} MQTT interfaces in AID Submodel.")
+        self._default_mqtt_interface = self._get_default_mqtt_interface_description()
+        self._fallback_mqtt_interface = self._get_fallback_mqtt_interface_description()
+        self._create_topic_map(self._default_mqtt_interface.interface_smc)
+
+    def _find_all_mqtt_interfaces(self, aid_sm: Submodel) -> list[SubmodelElementCollection]:
+        """Find all MQTT interface collections in the AID Submodel by semantic_id and supplemental_semantic_id.
+
+        :return: A list of MQTT interface SubmodelElementCollections or an empty list if none are found.
+        """
+        interfaces: list[SubmodelElement] = find_all_by_semantic_id(
+            aid_sm.submodel_element, "https://admin-shell.io/idta/AssetInterfacesDescription/1/0/Interface"
+        )
+
+        return [interface for interface in interfaces if isinstance(interface, SubmodelElementCollection) and
+                contains_supplemental_semantic_id(interface, "http://www.w3.org/2011/mqtt")] if interfaces else []
+
+    def _get_base_url_from_interface(self, mqtt_interface: SubmodelElementCollection) -> str:
+        """Set the base URL for the MQTT interface from the EndpointMetadata SMC."""
+        endpoint_metadata: SubmodelElementCollection = find_by_semantic_id(
+            mqtt_interface.value, "https://admin-shell.io/idta/AssetInterfacesDescription/1/0/EndpointMetadata"
+        )
+        if endpoint_metadata is None:
+            raise ValueError("EndpointMetadata SMC not found in AID Submodel.")
+        base: Property = find_by_semantic_id(
+            endpoint_metadata.value, "https://www.w3.org/2019/wot/td#base"
+        )
+        if base is None:
+            raise ValueError("BaseUrl Property not found in EndpointMetadata SMC.")
+        return base.value
+
+    def _create_topic_map(self, mqtt_interface: SubmodelElementCollection):
+        """Find all MQTT topics by their property definitions in the MQTT interface SMC and create a new topic Map.
+
+        The topic Map is a dictionary of the Topic Name (IdShort of the Property Definition) and the MQTT topic link.
+
+        :param mqtt_interface: The MQTT interface SubmodelElementCollection to use.
+        """
+        print(f"Creating topic map for MQTT interface {mqtt_interface.id_short}.")
+        mqtt_property_collection: SubmodelElementCollection = self._get_mqtt_properties(mqtt_interface)
+        if not mqtt_property_collection:
+            print(f"No MQTT properties found in InteractionMetadata of MQTT Interface {mqtt_interface.id_short}.")
+            return
+
+        property_definitions: list[SubmodelElementCollection] = [
+            prop_def for prop_def in find_all_by_semantic_id(
+                traversal.walk_submodel(mqtt_property_collection),
+                "https://admin-shell.io/idta/AssetInterfaceDescription/1/0/PropertyDefinition"
+            )
+            if isinstance(prop_def, SubmodelElementCollection) and
+            find_by_semantic_id(prop_def.value, "https://www.w3.org/2019/wot/td#hasForm") is not None
+        ]
+        self._topic_map = self._get_topics_from_property_definitions(property_definitions)
+
+    def _get_topics_from_property_definitions(self, property_definitions: list[SubmodelElementCollection]) -> dict[str, str]:
+        """Create a mapping of MQTT topics from the property definitions.
+
+        :param property_definitions: The list of property definitions from the AID SM.
+        :return: A dictionary mapping IdShort of MQTT topic definitions to their MQTT topic links.
+        """
+        topic_map: dict[str, str] = {}
+        for prop_def in property_definitions:
+            forms = find_by_semantic_id(
+                prop_def.value, "https://www.w3.org/2019/wot/td#hasForm"
+            )
+            if forms is None:
+                print(f"Form SMC not found in PropertyDefinition {prop_def.id_short}.")
+                continue
+
+            target_href = find_by_semantic_id(
+                forms.value, "https://www.w3.org/2019/wot/hypermedia#hasTarget"
+            )
+            if target_href is None:
+                print(f"Target property not found in Form SMC of PropertyDefinition {prop_def.id_short}.")
+                continue
+
+            topic_map[prop_def.id_short] = target_href.value
+        return topic_map
+
+    def _get_default_mqtt_interface_description(self) -> MQTTInterfaceDescription:
+        """Get the default MQTT interface description from the list of MQTT interfaces.
+
+        Default MQTT interface does not use Websocket. If no such interface is found, simply return the first one.
+
+        :return: The default MQTT interface or None if no interface is found.
+        """
+        for interface in self._mqtt_interface_descriptions:
+            if not interface.websocket_connection:
+                print(f"Using default MQTT interface: {interface.interface_smc.id_short}")
+                return interface
+
+        if len(self._mqtt_interface_descriptions) > 0:
+            print(f"Using default MQTT interface: {self._mqtt_interface_descriptions[0].interface_smc.id_short}")
+            return self._mqtt_interface_descriptions[0]
+
+        return None
+
+    def _get_fallback_mqtt_interface_description(self) -> MQTTInterfaceDescription:
+        """Get the fallback MQTT interface description from the list of MQTT interfaces.
+
+        :return: The fallback MQTT interface or None if no second interface is provided in the AID SM.
+        """
+        if len(self._mqtt_interface_descriptions) > 1:
+            for interface in self._mqtt_interface_descriptions:
+                if interface.websocket_connection:
+                    print(f"Using fallback MQTT interface: {interface.interface_smc.id_short}")
+                    return interface
+        return None
+
+    def _get_mqtt_properties(self, default_mqtt_interface: SubmodelElementCollection) -> SubmodelElementCollection | None:
+        """Get the MQTT properties from the InteractionMetadata SMC.
+
+        :return: The SubmodelElementCollection containing MQTT properties on None if not found.
+        """
+        interaction_metadata: SubmodelElementCollection = find_by_semantic_id(
+            default_mqtt_interface.value, "https://admin-shell.io/idta/AssetInterfacesDescription/1/0/InteractionMetadata"
+        )
+        if interaction_metadata is None:
+            print("InteractionMetadata SMC not found in MQTT interface description.")
+            return None
+
+        mqtt_property_collection: SubmodelElementCollection = find_by_semantic_id(
+            interaction_metadata.value, "https://www.w3.org/2019/wot/td#PropertyAffordance"
+        )
+        if mqtt_property_collection is None:
+            print("PropertyAffordance SMC not found in InteractionMetadata SMC.")
+            return None
+
+        return mqtt_property_collection
+
+    def _uses_websocket(self, mqtt_interface: SubmodelElementCollection) -> bool:
+        """Check if the given MQTT interface uses a WebSocket connection by searching for the appropriate semantic ID.
+
+        :param mqtt_interface: The MQTT interface to check.
+        :return: True if the interface uses WebSocket, False otherwise.
+        """
+        return contains_supplemental_semantic_id(mqtt_interface, "https://www.rfc-editor.org/rfc/rfc6455")
+
+    def get_mqtt_topic_map(self, fallback: bool = False) -> dict[str, str]:
+        """Get the MQTT topic map.
+
+        If the fallback value needs to be used, regenerate the topic map from the fallback MQTT interface.
+
+        :param fallback: Whether to use the fallback MQTT interface, defaults to False
+        :return: The MQTT topic map.
+        """
+        if fallback:
+            self._create_topic_map(self._get_fallback().interface_smc)
+        return self._topic_map
+
+    def get_mqtt_base_url(self, fallback: bool = False) -> str:
+        """Get the base URL for the MQTT connection.
+
+        :param fallback: Whether to use the fallback MQTT interface, defaults to False
+        :return: The base URL of the MQTT interface.
+        """
+        if fallback:
+            return self._get_fallback().base_url
+
+        return self._default_mqtt_interface.base_url
+
+    def _get_fallback(self):
+        """Get the fallback MQTT interface description if it exists.
+
+        :raises ConnectionError: If no fallback MQTT interface is available.
+        :return: The fallback MQTT interface description.
+        """
+        if not self._fallback_mqtt_interface:
+            raise ConnectionError("No fallback MQTT interface available.")
+        return self._fallback_mqtt_interface
+
+    def uses_websocket_interface(self, fallback: bool = False) -> bool:
+        """Check if the MQTT connection will be initialized using Websocket.
+
+        :param fallback: Whether to use the fallback MQTT interface, defaults to False
+        :return: True if the MQTT interface uses WebSocket, False otherwise.
+        """
+        if fallback:
+            return self._get_fallback().websocket_connection
+
+        return self._default_mqtt_interface.websocket_connection
+
+
+def find_all_by_semantic_id(parent: Iterator[SubmodelElement], semantic_id_value: str) -> list[SubmodelElement]:
+    """Find all SubmodelElements having a specific Semantic ID.
+
+    :param parent: The NamespaceSet to search within.
+    :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)
+    ]
+    return found_elements
+
+def find_by_semantic_id(parent: NamespaceSet[SubmodelElement], semantic_id_value: str) -> SubmodelElement:
+    """Find a SubmodelElement by its semantic ID.
+
+    :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.
+    """
+    reference: Reference = ExternalReference(
+        [Key(
+            type_= KeyTypes.GLOBAL_REFERENCE,
+            value=semantic_id_value
+        )]
+    )
+    for element in parent:
+        if element.semantic_id.__eq__(reference):
+            return element
+    return None
+
+def find_by_supplemental_semantic_id(parent: NamespaceSet[SubmodelElement], semantic_id_value: str) -> SubmodelElement:
+    """Find a SubmodelElement by its supplemental semantic ID.
+
+    :param parent: The NamespaceSet to search within.
+    :param semantic_id_value: The supplemental semantic ID value to search for.
+    :return: The first found SubmodelElement, or None if not found.
+    """
+    for element in parent:
+        if contains_supplemental_semantic_id(element, semantic_id_value):
+            return element
+    return None
+
+def contains_supplemental_semantic_id(element: SubmodelElement, semantic_id_value: str) -> bool:
+    """Check if the element contains a specific supplemental semantic ID.
+
+    :param element: The SubmodelElement to check.
+    :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
+        )]
+    )
+    return element.supplemental_semantic_id.__contains__(reference)

aas_standard_parser/aimc_parser.py

@@ -0,0 +1,244 @@
+import json
+import logging
+
+import basyx.aas.adapter.json
+from basyx.aas import model
+
+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
+
+    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
+    aid_submodel_id: str
+    source_sink_relations: list[SourceSinkRelation]
+
+
+class MappingConfigurations:
+    """Class representing mapping configurations from AIMC submodel."""
+
+    configurations: list[MappingConfiguration]
+    aid_submodel_ids: list[str]
+
+
+class AimcParser:
+    """Parser for the AIMC submodel.
+
+    :return: The parsed AIMC submodel.
+    """
+
+    aimc_submodel: model.Submodel | None = None
+    mapping_configuration_element: model.SubmodelElementCollection | None = None
+
+    def __init__(self, aimc_submodel: model.Submodel):
+        """Initialize the AIMC parser.
+
+        :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_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
+        )
+
+        if self.mapping_configuration_element is None:
+            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:
+        """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()
+
+        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(self) -> MappingConfigurations:
+        """Parse all mapping configurations in the AIMC submodel.
+
+        :return: A list of parsed mapping configurations.
+        """
+        logger.info("Parse mapping configurations from AIMC submodel.")
+
+        mapping_configurations: list[MappingConfiguration] = []
+
+        mc_elements = self.get_mapping_configuration_elements()
+
+        if mc_elements is None:
+            logger.error("No mapping configuration elements found in AIMC submodel.")
+            return mapping_configurations
+
+        for mc_element in mc_elements:
+            mc = self.parse_mapping_configuration(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(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
+
+        logger.debug(f"Parse mapping configuration '{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)
+
+        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(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}'.")
+
+        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}'.")
+
+        relations_list: model.SubmodelElementList = next(
+            (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}'.")
+            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)
+
+        return source_sink_relations

{aas_standard_parser-0.1.1.dist-info → aas_standard_parser-0.1.2.dist-info}/METADATA

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

aas_standard_parser-0.1.2.dist-info/RECORD

@@ -0,0 +1,8 @@
+aas_standard_parser/__init__.py,sha256=JEyzB-q1WkxIMyO6JMBh4I4VqwpjZGPNFQqPshO5nUU,503
+aas_standard_parser/aid_parser.py,sha256=0U3J9WOkt5t_xh9SZZ_7h_uQ-bR6Q7NaZltbyq69Qsc,13758
+aas_standard_parser/aimc_parser.py,sha256=xw0uIn5e78Bmdi2v_zlS63EeeRAsKy_ssx9Y9GPxdK4,10571
+aas_standard_parser-0.1.2.dist-info/licenses/LICENSE,sha256=simqYMD2P9Ikm0Kh9n7VGNpaVcm2TMVVQmECYZ_xVZ8,1065
+aas_standard_parser-0.1.2.dist-info/METADATA,sha256=pXqo4t6hu0CyI0fZF2e5w8a7AUZR_Flyik5izAO-1wk,1718
+aas_standard_parser-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aas_standard_parser-0.1.2.dist-info/top_level.txt,sha256=OQaK6cwYttR1-eKTz5u4M0jbwSfp4HqJ56chaf0nHnw,20
+aas_standard_parser-0.1.2.dist-info/RECORD,,

aas_standard_parser-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+aas_standard_parser

aas_standard_parser-0.1.1.dist-info/RECORD

@@ -1,5 +0,0 @@
-aas_standard_parser-0.1.1.dist-info/licenses/LICENSE,sha256=simqYMD2P9Ikm0Kh9n7VGNpaVcm2TMVVQmECYZ_xVZ8,1065
-aas_standard_parser-0.1.1.dist-info/METADATA,sha256=RObxSGDYUd_Pqt3LMW5xhagvyvNojdzc83VyjIz2j4Y,1718
-aas_standard_parser-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aas_standard_parser-0.1.1.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-aas_standard_parser-0.1.1.dist-info/RECORD,,

aas_standard_parser-0.1.1.dist-info/top_level.txt

@@ -1 +0,0 @@
-