MTPPy2.0 0.1.5__py3-none-any.whl

mtppy/pea/mtp_generator/mtp_generator.py

@@ -0,0 +1,1183 @@
+"""Generate an MTP file from internal data structures."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from pathlib import Path
+
+from opcua.ua import StringNodeId
+
+from mtppy.utils.mtp_file_handling.mtp_writer.mtp_writer import MtpWriter
+from mtppy.pea.pea import PEA
+from mtppy.pea.pea_opcua_server.pea_opcua_server import PeaOPCUAServer
+import xml.etree.ElementTree as ET
+
+from mtppy.part3.data_assembly_set.data_assembly import DataAssembly
+from mtppy.part4.automation_services.procedure import Procedure
+from mtppy.part4.automation_services.service import Service
+from mtppy.part6.alarm_set.alarm import Alarm
+from mtppy.utils.data_item import DataItem
+from utils.get_uuid import get_uuid
+
+
+class MTPGenerator:
+    def __init__(self):
+        """
+        Represents an MTP generator.
+        """
+        self._template_path = None
+        self._tree = None
+        self._root = None
+
+        self._mtp_writer = MtpWriter()
+
+        # first layer: instance hierarchy MTP and instance hierarchy service
+        self._instance_hierarchy_module_type_package = None
+        self._instance_hierarchy_data_assemblies = None
+        self._instance_hierarchy_server_assemblies = None
+        self._instance_hierarchy_pictures = None
+        self._instance_hierarchy_process_values = None
+        self._instance_hierarchy_services = None
+        self._instance_hierarchy_texts = None
+        self._instance_hierarchy_alarms = None
+
+        self._server_assembly_reference = None
+        self._namespace_of_data_items = None
+        self._data_assembly_ref_ids: dict[int, str] = {}
+        self._alarm_trigger_ids: dict[int, str] = {}
+        self._serialized_data_items: set[int] = set()
+        self._alarm_group_elements: dict[int, ET.Element] = {}
+
+    def init(self):
+
+        # path of a manifest template containing general infos
+        base_dir = Path(__file__).parent
+        manifest_template_path = base_dir.joinpath("ressources/manifest_template.xml")
+        self._template_path = manifest_template_path
+
+        # empty prefix = Standard-Namespace
+        ET.register_namespace("", "http://www.dke.de/CAEX")
+        self._tree = ET.parse(self._template_path)
+        self._root = self._tree.getroot()
+
+        # first layer: instance hierarchy MTP and instance hierarchy service
+        self._instance_hierarchy_module_type_package = None
+        self._instance_hierarchy_data_assemblies = None
+        self._instance_hierarchy_server_assemblies = None
+        self._instance_hierarchy_pictures = None
+        self._instance_hierarchy_process_values = None
+        self._instance_hierarchy_services = None
+        self._instance_hierarchy_texts = None
+        self._instance_hierarchy_alarms = None
+
+        self._server_assembly_reference = None
+        self._namespace_of_data_items = None
+        self._data_assembly_ref_ids = {}
+        self._alarm_trigger_ids = {}
+        self._serialized_data_items = set()
+        self._alarm_group_elements = {}
+
+        self.__init_instance_hierarchies()
+
+        return True
+
+    def generate(
+        self,
+        pea: PEA,
+        source_document_information: None | dict = None,
+        out_path: str | None = None,
+    ):
+        self.init()
+
+        if source_document_information is not None:
+            self.__change_source_document_information(source_document_information)
+
+        self.__build_module_type_package_instance_hierarchy(
+            "0.0.1", "MTPPy2.0-PEA", pea.pea_information_label
+        )
+        opcua_server = pea.pea_opcua_server
+        self.__init_server_assemblies_instance_hierarchy(opcua_server)
+
+        for alarm in pea.alarms.values():
+            alarm.validate()
+            self._alarm_trigger_ids.setdefault(id(alarm.trigger), get_uuid())
+
+        for data_assembly in pea.data_assemblies.values():
+            self.__add_data_assembly_to_instance_hierarchy_data_assemblies(
+                data_assembly
+            )
+
+        for service in pea.service_set.values():
+            self.__add_service_to_instance_hierarchy_services(service)
+
+        for process_value_in in pea.process_value_ins.values():
+            process_value_in_ref = (
+                self.__add_data_assembly_to_instance_hierarchy_data_assemblies(
+                    process_value_in
+                )
+            )
+            self.__add_process_value_in_to_instance_hierarchy_process_values(
+                process_value_in.tag_name, process_value_in_ref
+            )
+
+        for process_value_out in pea.process_value_outs.values():
+            process_value_out_ref = (
+                self.__add_data_assembly_to_instance_hierarchy_data_assemblies(
+                    process_value_out
+                )
+            )
+            self.__add_process_value_out_to_instance_hierarchy_process_values(
+                process_value_out.tag_name, process_value_out_ref
+            )
+
+        for alarm in pea.alarms.values():
+            self.__add_alarm_to_instance_hierarchy_alarms(alarm)
+
+        # Export result
+        mtp_content_str = ET.tostring(self._root, encoding="utf-8")
+        self._mtp_writer.write_mtp(
+            mtp_content_str, out_path=out_path, mtp_name=f"MyPrettyMTP-{get_uuid()}"
+        )
+
+    def __init_instance_hierarchies(self):
+        self._instance_hierarchy_module_type_package = self.__init_instance_hierarchy(
+            "ModuleTypePackage"
+        )
+        self._instance_hierarchy_data_assemblies = self.__init_instance_hierarchy(
+            "DataAssemblies"
+        )
+        self._instance_hierarchy_server_assemblies = self.__init_instance_hierarchy(
+            "ServerAssemblies"
+        )
+        self._instance_hierarchy_pictures = self.__init_instance_hierarchy("Pictures")
+        self._instance_hierarchy_process_values = self.__init_instance_hierarchy(
+            "ProcessValues"
+        )
+        self._instance_hierarchy_services = self.__init_instance_hierarchy("Services")
+        self._instance_hierarchy_texts = self.__init_instance_hierarchy("Texts")
+        self._instance_hierarchy_alarms = self.__init_instance_hierarchy("Alarms")
+
+    def __init_instance_hierarchy(self, name: str):
+        instance_hierarchy = ET.SubElement(self._root, "InstanceHierarchy")
+        instance_hierarchy.set("Name", name)
+        instance_hierarchy.set("ID", get_uuid())
+        return instance_hierarchy
+
+    def __change_source_document_information(self, source_document_information: dict):
+        source_document_information_root = self._root.find("SourceDocumentInformation")
+        if source_document_information_root is not None:
+            for (
+                source_document_information_element
+            ) in source_document_information_root.findall("./"):
+                if source_document_information_element.tag in list(
+                    source_document_information.keys()
+                ):
+                    source_document_information_element.text = (
+                        source_document_information[
+                            source_document_information_element.tag
+                        ]
+                    )
+                else:
+                    raise KeyError(
+                        "Key of SourceDocumentInformation dict is not correct"
+                    )
+
+    def __build_module_type_package_instance_hierarchy(
+        self, version: str, pea_name: str, pea_information_label: DataAssembly
+    ):
+        """Add internal element module type package to instance hierarchy mtp.
+
+        Args:
+            version: Version of mtp
+            pea_name: Name of pea
+            pea_information_label: PEA information label
+        """
+
+        # create InternalElement
+        module_type_package = ET.Element(
+            "InternalElement",
+            {
+                "Name": pea_name,
+                "ID": get_uuid(),
+                "RefBaseSystemUnitPath": "MTPSUCLib/ModuleTypePackage",
+            },
+        )
+        # add direct attributes to mtp internal element
+        mtp_version = ET.SubElement(module_type_package, "Attribute")
+        mtp_version.set("Name", "Version")
+        mtp_version.set("AttributeDataType", "xs:string")
+        mtp_version.set(
+            "RefAttributeType",
+            "MTPATLib/SemanticVersionAttributeType/ModuleTypePackageRevisionTyp",
+        )
+        mtp_version_value = ET.SubElement(mtp_version, "Value")
+        mtp_version_value.text = str(version)
+
+        mtp_device_revision = ET.SubElement(module_type_package, "Attribute")
+        mtp_device_revision.set("Name", "DeviceRevision")
+        mtp_device_revision.set("AttributeDataType", "xs:string")
+        mtp_device_revision.set(
+            "RefAttributeType",
+            "MTPATLib/SemanticVersionAttributeType/DeviceRevisionType",
+        )
+        mtp_device_revision_value = ET.SubElement(mtp_device_revision, "Value")
+        mtp_device_revision_value.text = str(version)
+
+        mtp_manufacturer_uri = ET.SubElement(module_type_package, "Attribute")
+        mtp_manufacturer_uri.set("Name", "ManufacturerUri")
+        mtp_manufacturer_uri.set("AttributeDataType", "xs:string")
+        mtp_manufacturer_uri_value = ET.SubElement(mtp_manufacturer_uri, "Value")
+        mtp_manufacturer_uri_value.text = "http://www.tu-dresden.de/P2O"
+
+        mtp_product_code = ET.SubElement(module_type_package, "Attribute")
+        mtp_product_code.set("Name", "ProductCode")
+        mtp_product_code.set("AttributeDataType", "xs:string")
+
+        mtp_pea_information = ET.SubElement(module_type_package, "Attribute")
+        mtp_pea_information.set("Name", "PeaInformation")
+        mtp_pea_information.set("AttributeDataType", "xs:string")
+        if pea_information_label is not None:
+            mtp_pea_information.set(
+                "RefAttributeType", "MTPATLib/IDReferenceType/IDLinkAttributeType"
+            )
+            ref_id = self.__add_data_assembly_to_instance_hierarchy_data_assemblies(
+                pea_information_label
+            )
+            mtp_pea_information_value = ET.SubElement(mtp_pea_information, "Value")
+            mtp_pea_information_value.text = ref_id
+
+        mtp_web_server_url = ET.SubElement(module_type_package, "Attribute")
+        mtp_web_server_url.set("Name", "WebServerUrl")
+        mtp_web_server_url.set("AttributeDataType", "xs:string")
+
+        # Add external references to AspectSet
+        internal_element = ET.SubElement(module_type_package, "InternalElement")
+        internal_element.set("Name", "DataAssemblies")
+        internal_element.set("ID", get_uuid())
+        internal_element.set(
+            "RefBaseSystemUnitPath", "MTPDataAssemblySUCLib/DataAssemblySet"
+        )
+        external_interface = ET.SubElement(internal_element, "ExternalInterface")
+        external_interface.set("Name", "DataAssemblies")
+        external_interface.set("ID", get_uuid())
+        external_interface.set("RefBaseClassPath", "MTPICLib/AspectSetReference")
+        attribute = ET.SubElement(external_interface, "Attribute")
+        attribute.set("Name", "AspectRef")
+        attribute.set("AttributeDataType", "xs:string")
+        attribute.set(
+            "RefAttributeType", "MTPATLib/IDReferenceType/AspectIDAttributeType"
+        )
+        attribute_value = ET.SubElement(attribute, "Value")
+        attribute_value.text = self._instance_hierarchy_data_assemblies.attrib["ID"]
+        role_requirements = ET.SubElement(internal_element, "RoleRequirements")
+        role_requirements.set(
+            "RefBaseRoleClassPath", "AutomationMLBaseRoleClassLib/AutomationMLBaseRole"
+        )
+
+        internal_element = ET.SubElement(module_type_package, "InternalElement")
+        internal_element.set("Name", "ServerAssemblies")
+        internal_element.set("ID", get_uuid())
+        internal_element.set(
+            "RefBaseSystemUnitPath", "MTPServerAssemblySUCLib/ServerAssemblySet"
+        )
+        external_interface = ET.SubElement(internal_element, "ExternalInterface")
+        external_interface.set("Name", "ServerAssemblies")
+        external_interface.set("ID", get_uuid())
+        external_interface.set("RefBaseClassPath", "MTPICLib/AspectSetReference")
+        attribute = ET.SubElement(external_interface, "Attribute")
+        attribute.set("Name", "AspectRef")
+        attribute.set("AttributeDataType", "xs:string")
+        attribute.set(
+            "RefAttributeType", "MTPATLib/IDReferenceType/AspectIDAttributeType"
+        )
+        attribute_value = ET.SubElement(attribute, "Value")
+        attribute_value.text = self._instance_hierarchy_server_assemblies.attrib["ID"]
+        role_requirements = ET.SubElement(internal_element, "RoleRequirements")
+        role_requirements.set(
+            "RefBaseRoleClassPath", "AutomationMLBaseRoleClassLib/AutomationMLBaseRole"
+        )
+
+        internal_element = ET.SubElement(module_type_package, "InternalElement")
+        internal_element.set("Name", "HMI")
+        internal_element.set("ID", get_uuid())
+        internal_element.set("RefBaseSystemUnitPath", "MTPHMISUCLib/HMISet")
+        external_interface = ET.SubElement(internal_element, "ExternalInterface")
+        external_interface.set("Name", "HMI")
+        external_interface.set("ID", get_uuid())
+        external_interface.set("RefBaseClassPath", "MTPICLib/AspectSetReference")
+        attribute = ET.SubElement(external_interface, "Attribute")
+        attribute.set("Name", "AspectRef")
+        attribute.set("AttributeDataType", "xs:string")
+        attribute.set(
+            "RefAttributeType", "MTPATLib/IDReferenceType/AspectIDAttributeType"
+        )
+        attribute_value = ET.SubElement(attribute, "Value")
+        attribute_value.text = self._instance_hierarchy_pictures.attrib["ID"]
+        role_requirements = ET.SubElement(internal_element, "RoleRequirements")
+        role_requirements.set(
+            "RefBaseRoleClassPath", "AutomationMLBaseRoleClassLib/AutomationMLBaseRole"
+        )
+
+        internal_element = ET.SubElement(module_type_package, "InternalElement")
+        internal_element.set("Name", "ProcessValues")
+        internal_element.set("ID", get_uuid())
+        internal_element.set(
+            "RefBaseSystemUnitPath", "MTPProcessValueSUCLib/ProcessValueSet"
+        )
+        external_interface = ET.SubElement(internal_element, "ExternalInterface")
+        external_interface.set("Name", "ProcessValues")
+        external_interface.set("ID", get_uuid())
+        external_interface.set("RefBaseClassPath", "MTPICLib/AspectSetReference")
+        attribute = ET.SubElement(external_interface, "Attribute")
+        attribute.set("Name", "AspectRef")
+        attribute.set("AttributeDataType", "xs:string")
+        attribute.set(
+            "RefAttributeType", "MTPATLib/IDReferenceType/AspectIDAttributeType"
+        )
+        attribute_value = ET.SubElement(attribute, "Value")
+        attribute_value.text = self._instance_hierarchy_process_values.attrib["ID"]
+        role_requirements = ET.SubElement(internal_element, "RoleRequirements")
+        role_requirements.set(
+            "RefBaseRoleClassPath", "AutomationMLBaseRoleClassLib/AutomationMLBaseRole"
+        )
+
+        internal_element = ET.SubElement(module_type_package, "InternalElement")
+        internal_element.set("Name", "Services")
+        internal_element.set("ID", get_uuid())
+        internal_element.set("RefBaseSystemUnitPath", "MTPServiceSUCLib/ServiceSet")
+        external_interface = ET.SubElement(internal_element, "ExternalInterface")
+        external_interface.set("Name", "Services")
+        external_interface.set("ID", get_uuid())
+        external_interface.set("RefBaseClassPath", "MTPICLib/AspectSetReference")
+        attribute = ET.SubElement(external_interface, "Attribute")
+        attribute.set("Name", "AspectRef")
+        attribute.set("AttributeDataType", "xs:string")
+        attribute.set(
+            "RefAttributeType", "MTPATLib/IDReferenceType/AspectIDAttributeType"
+        )
+        attribute_value = ET.SubElement(attribute, "Value")
+        attribute_value.text = self._instance_hierarchy_services.attrib["ID"]
+        role_requirements = ET.SubElement(internal_element, "RoleRequirements")
+        role_requirements.set(
+            "RefBaseRoleClassPath", "AutomationMLBaseRoleClassLib/AutomationMLBaseRole"
+        )
+
+        internal_element = ET.SubElement(module_type_package, "InternalElement")
+        internal_element.set("Name", "Texts")
+        internal_element.set("ID", get_uuid())
+        internal_element.set("RefBaseSystemUnitPath", "MTPTextSUCLib/TextSet")
+        external_interface = ET.SubElement(internal_element, "ExternalInterface")
+        external_interface.set("Name", "Texts")
+        external_interface.set("ID", get_uuid())
+        external_interface.set("RefBaseClassPath", "MTPICLib/AspectSetReference")
+        attribute = ET.SubElement(external_interface, "Attribute")
+        attribute.set("Name", "AspectRef")
+        attribute.set("AttributeDataType", "xs:string")
+        attribute.set(
+            "RefAttributeType", "MTPATLib/IDReferenceType/AspectIDAttributeType"
+        )
+        attribute_value = ET.SubElement(attribute, "Value")
+        attribute_value.text = self._instance_hierarchy_texts.attrib["ID"]
+        role_requirements = ET.SubElement(internal_element, "RoleRequirements")
+        role_requirements.set(
+            "RefBaseRoleClassPath", "AutomationMLBaseRoleClassLib/AutomationMLBaseRole"
+        )
+
+        internal_element = ET.SubElement(module_type_package, "InternalElement")
+        internal_element.set("Name", "Alarms")
+        internal_element.set("ID", get_uuid())
+        internal_element.set("RefBaseSystemUnitPath", "MTPAlarmSUCLib/AlarmSet")
+        external_interface = ET.SubElement(internal_element, "ExternalInterface")
+        external_interface.set("Name", "Alarms")
+        external_interface.set("ID", get_uuid())
+        external_interface.set("RefBaseClassPath", "MTPICLib/AspectSetReference")
+        attribute = ET.SubElement(external_interface, "Attribute")
+        attribute.set("Name", "AspectRef")
+        attribute.set("AttributeDataType", "xs:string")
+        attribute.set(
+            "RefAttributeType", "MTPATLib/IDReferenceType/AspectIDAttributeType"
+        )
+        attribute_value = ET.SubElement(attribute, "Value")
+        attribute_value.text = self._instance_hierarchy_alarms.attrib["ID"]
+        role_requirements = ET.SubElement(internal_element, "RoleRequirements")
+        role_requirements.set(
+            "RefBaseRoleClassPath", "AutomationMLBaseRoleClassLib/AutomationMLBaseRole"
+        )
+
+        role_requirements = ET.SubElement(module_type_package, "RoleRequirements")
+        role_requirements.set(
+            "RefBaseRoleClassPath", "AutomationMLBaseRoleClassLib/AutomationMLBaseRole"
+        )
+        # Add to root MTP instance hierarchy
+        self._instance_hierarchy_module_type_package.append(module_type_package)
+
+    def __init_server_assemblies_instance_hierarchy(
+        self, pea_opcua_server: PeaOPCUAServer
+    ):
+
+        server_assembly_internal_element = ET.Element(
+            "InternalElement",
+            {
+                "Name": "MTPPy2.0-OPCUA-Server",
+                "ID": get_uuid(),
+                "RefBaseSystemUnitPath": "MTPServerAssemblySUCLib/ServerAssembly/OPCUAServer",
+            },
+        )
+
+        attribute = ET.SubElement(server_assembly_internal_element, "Attribute")
+        attribute.set("Name", "Endpoint")
+        attribute.set("AttributeDataType", "xs:string")
+        attribute_value = ET.SubElement(attribute, "Value")
+        attribute_value.text = pea_opcua_server.endpoint
+
+        self._namespace_of_data_items = (
+            pea_opcua_server.opcua_options_provider.get_default_namespace_uri()
+        )
+
+        attribute = ET.SubElement(server_assembly_internal_element, "Attribute")
+        attribute.set("Name", "MaxSessions")
+        attribute.set("AttributeDataType", "xs:unsignedInt")
+        # attribute_value = ET.SubElement(attribute, 'Value')
+        # attribute_value.text = str(pea_opcua_server.opcua_options_provider.get_max_sessions())
+
+        self._server_assembly_reference = server_assembly_internal_element
+        # Add to root Server Instance Hierarchy
+        self._instance_hierarchy_server_assemblies.append(
+            server_assembly_internal_element
+        )
+
+    def __add_data_assembly_to_instance_hierarchy_data_assemblies(
+        self, data_assembly: DataAssembly
+    ) -> str:
+
+        # create internal element
+        data_assembly_element = ET.Element(
+            "InternalElement",
+            {
+                "Name": data_assembly.tag_name,
+                "ID": get_uuid(),
+                "RefBaseSystemUnitPath": data_assembly.mtpObjectType,
+            },
+        )
+
+        if hasattr(data_assembly, "_data_items"):
+            for data_item in data_assembly._data_items.values():
+                # Add DataItem to DataAssembly
+                self.__add_data_item_to_data_assembly(data_assembly_element, data_item)
+
+        # AlarmSet.Base Trigger links require a CAEX ID on their DataItem Attribute.
+        for key in data_assembly:
+            data_item = data_assembly.get_item(key)
+            data_item_id = id(data_item)
+            if (
+                data_item_id in self._alarm_trigger_ids
+                and data_item_id not in self._serialized_data_items
+            ):
+                self.__add_data_item_to_data_assembly(data_assembly_element, data_item)
+
+        # Evaluate BaseFunctions
+        base_functions = [
+            "op_mode",
+            "src_mode",
+            "os_level",
+            "wqc",
+            "vqc",
+            "service_op_mode",
+            "service_src_mode",
+            "service_operator_interaction",
+        ]
+
+        for base_function_name in base_functions:
+            if not hasattr(data_assembly, base_function_name):
+                continue
+            base_function = eval(f"data_assembly.{base_function_name}")
+            for data_item in base_function._data_items.values():
+                # Add DataItem to DataAssembly
+                self.__add_data_item_to_data_assembly(data_assembly_element, data_item)
+
+        ref_id = get_uuid()
+        attribute = ET.SubElement(data_assembly_element, "Attribute")
+        attribute.set("Name", "RefID")
+        attribute.set("AttributeDataType", "xs:string")
+        attribute.set("RefAttributeType", "MTPATLib/IDReferenceType/RefIDAttributeType")
+        attribute_value = ET.SubElement(attribute, "Value")
+        attribute_value.text = ref_id
+
+        self._data_assembly_ref_ids.setdefault(id(data_assembly), ref_id)
+
+        self._instance_hierarchy_data_assemblies.append(data_assembly_element)
+
+        return ref_id
+
+    def __add_data_item_to_data_assembly(
+        self, parent_elem: ET.Element, data_item: DataItem
+    ):
+        """Add DataItems to the corresponding DataAssembly.
+
+        Args:
+            parent_elem: Parent to which the DataItems should be added
+            data_item: DataItem to be added
+        """
+        attr = ET.SubElement(parent_elem, "Attribute")
+        attr.set("Name", data_item.name)
+        attr.set("AttributeDataType", "xs:string")
+        trigger_id = self._alarm_trigger_ids.get(id(data_item))
+        if trigger_id is not None:
+            attr.set("ID", trigger_id)
+        self._serialized_data_items.add(id(data_item))
+
+        # value type data_item.w3c_xml_data_type
+
+        # DefaultValue is always present
+        attr_default_value = ET.SubElement(attr, "DefaultValue")
+        attr_default_value.text = str(data_item.get_value())
+
+        if data_item.comm_obj is None:
+            attr.set("RefAttributeType", "MTPATLib/StaticValueAttributeType")
+            attr_value = ET.SubElement(attr, "Value")
+            attr_value.text = str(data_item.get_value())
+        else:
+            attr.set("RefAttributeType", "MTPATLib/IDReferenceType/IDLinkAttributeType")
+            attr_value = ET.SubElement(attr, "Value")
+            attr_value.text = self.__add_item_to_opc_ua_server(data_item)
+
+    def __add_item_to_opc_ua_server(self, data_item: DataItem):
+        """Create an ExternalInterface at OPC UA server in ServerAssembly InstanceHierarchy.
+
+        Args:
+            data_item: Element for that an OPC UA node is to create for.
+
+        Returns:
+            The reference ID of the created item.
+        """
+        if data_item.comm_obj is None:
+            raise AttributeError(
+                "Adding Object as item to OPCUA server not possible - CommObj missing in DataItem"
+            )
+
+        data_item_node_identifier: StringNodeId = (
+            data_item.comm_obj._node_id.nodeid.Identifier
+        )
+        data_item_access = data_item.access
+        ref_id = get_uuid()
+
+        item = ET.Element("ExternalInterface")
+        item.set("Name", data_item_node_identifier)
+        item.set("ID", ref_id)
+        item.set("RefBaseClassPath", "MTPServerAssemblyICLib/DataItem/OPCUAItem")
+
+        # attribute: Identifier
+        attr_identifier = ET.SubElement(item, "Attribute")
+        attr_identifier.set("Name", "Identifier")
+        attr_identifier.set("AttributeDataType", "xs:string")
+        attr_identifier.set(
+            "RefAttributeType",
+            "MTPServerAssemblyATLib/OPCUABaseNodeIDType/OPCUAStringNodeIDType",
+        )
+        attr_identifier_value = ET.SubElement(attr_identifier, "Value")
+        attr_identifier_value.text = data_item_node_identifier
+
+        # attribute: Namespace
+        attr_ns = ET.SubElement(item, "Attribute")
+        attr_ns.set("Name", "Namespace")
+        attr_ns.set("AttributeDataType", "xs:string")
+        attr_ns_value = ET.SubElement(attr_ns, "Value")
+        attr_ns_value.text = self._namespace_of_data_items
+
+        # attribute: Access
+        # attr_ns = ET.SubElement(item, 'Attribute')
+        # attr_ns.set('Name', 'Access')
+        # attr_ns.set('AttributeDataType', 'xs:uint')
+        # attr_ns_value = ET.SubElement(attr_ns, 'Value')
+        # attr_ns_value.text = str(data_item_access.value)
+
+        self._server_assembly_reference.append(item)
+
+        return ref_id
+
+    def __add_service_to_instance_hierarchy_services(self, service: Service):
+        """Create a Service at Services InstanceHierarchy.
+
+        Args:
+            service: Service object
+
+        Returns:
+            str: The reference ID of the created service
+        """
+        ref_id = get_uuid()
+
+        service_element = ET.Element("InternalElement")
+        service_element.set("Name", service.name)
+        service_element.set("ID", ref_id)
+        service_element.set("RefBaseSystemUnitPath", "MTPServiceSUCLib/Service")
+
+        service_control_reference = (
+            self.__add_data_assembly_to_instance_hierarchy_data_assemblies(
+                service.service_control
+            )
+        )
+
+        # attribute: Reference to ServiceControl DataAssembly
+        service_control_ref_attr = ET.SubElement(service_element, "Attribute")
+        service_control_ref_attr.set("Name", "RefID")
+        service_control_ref_attr.set("AttributeDataType", "xs:string")
+        service_control_ref_attr.set(
+            "RefAttributeType", "MTPATLib/IDReferenceType/RefIDAttributeType"
+        )
+        service_control_ref_attr_value = ET.SubElement(
+            service_control_ref_attr, "Value"
+        )
+        service_control_ref_attr_value.text = service_control_reference
+
+        classification_attr = ET.SubElement(service_element, "Attribute")
+        classification_attr.set("Name", "Classification")
+        classification_attr.set(
+            "RefAttributeType", "AutomationMLBaseAttributeTypeLib/OrderedListType"
+        )
+        classification_attr_description = ET.SubElement(
+            classification_attr, "Description"
+        )
+        classification_attr_description.text = "Function Classification"
+
+        for configuration_parameter in service.configuration_parameters.values():
+            parameter_element = ET.Element("InternalElement")
+            parameter_element.set("Name", configuration_parameter.tag_name)
+            parameter_element.set("ID", get_uuid())
+            parameter_element.set(
+                "RefBaseSystemUnitPath",
+                "MTPServiceSUCLib/ServiceParameter/ConfigurationParameter",
+            )
+
+            classification_attr = ET.SubElement(parameter_element, "Attribute")
+            classification_attr.set("Name", "Classification")
+            classification_attr.set(
+                "RefAttributeType", "AutomationMLBaseAttributeTypeLib/OrderedListType"
+            )
+            classification_attr_description = ET.SubElement(
+                service_control_ref_attr, "Description"
+            )
+            classification_attr_description.text = "Function Classification"
+
+            parameter_reference = (
+                self.__add_data_assembly_to_instance_hierarchy_data_assemblies(
+                    configuration_parameter
+                )
+            )
+
+            # attribute: Reference to Data Assembly
+            parameter_ref_attr = ET.SubElement(parameter_element, "Attribute")
+            parameter_ref_attr.set("Name", "RefID")
+            parameter_ref_attr.set("AttributeDataType", "xs:string")
+            parameter_ref_attr.set(
+                "RefAttributeType", "MTPATLib/IDReferenceType/RefIDAttributeType"
+            )
+            parameter_ref_attr_value = ET.SubElement(parameter_ref_attr, "Value")
+            parameter_ref_attr_value.text = parameter_reference
+
+            # attribute: RoleRequirements
+            parameter_role_req = ET.SubElement(parameter_element, "RoleRequirements")
+            parameter_role_req.set(
+                "RefBaseRoleClassPath",
+                "AutomationMLBaseRoleClassLib/AutomationMLBaseRole",
+            )
+
+        for procedure in service.procedures.values():
+            procedure_element = self.__create_procedure_element(procedure)
+            service_element.append(procedure_element)
+
+        # attribute: RoleRequirements
+        service_element_role_req = ET.SubElement(service_element, "RoleRequirements")
+        service_element_role_req.set(
+            "RefBaseRoleClassPath", "AutomationMLBaseRoleClassLib/AutomationMLBaseRole"
+        )
+        self._instance_hierarchy_services.append(service_element_role_req)
+
+        return ref_id
+
+    def __create_procedure_element(self, procedure: Procedure) -> ET.Element:
+        """Create a Procedure InternalElement as XML Tree Element.
+
+        Args:
+            procedure: Procedure object
+
+        Returns:
+            the created Procedure InternalElement
+        """
+
+        procedure_element = ET.Element("InternalElement")
+        procedure_element.set("Name", procedure.name)
+        procedure_element.set("ID", get_uuid())
+        procedure_element.set(
+            "RefBaseSystemUnitPath", "MTPServiceSUCLib/Service/Procedure"
+        )
+
+        is_self_completing_attr = ET.SubElement(procedure_element, "Attribute")
+        is_self_completing_attr.set("Name", "IsSelfCompleting")
+        is_self_completing_attr.set("AttributeDataType", "xs:boolean")
+        is_self_completing_attr_value = ET.SubElement(is_self_completing_attr, "Value")
+        is_self_completing_attr_value.text = str(procedure.is_self_completing).lower()
+
+        id_attr = ET.SubElement(procedure_element, "Attribute")
+        id_attr.set("Name", "ProcedureID")
+        is_self_completing_attr.set("AttributeDataType", "xs:unsignedInt")
+        id_attr_value = ET.SubElement(id_attr, "Value")
+        id_attr_value.text = str(procedure.procedure_id)
+
+        procedure_da_reference = (
+            self.__add_data_assembly_to_instance_hierarchy_data_assemblies(
+                procedure.procedure_health_view
+            )
+        )
+
+        # attribute: Reference to DataAssembly
+        procedure_da_ref_attr = ET.SubElement(procedure_element, "Attribute")
+        procedure_da_ref_attr.set("Name", "RefID")
+        procedure_da_ref_attr.set("AttributeDataType", "xs:string")
+        procedure_da_ref_attr.set(
+            "RefAttributeType", "MTPATLib/IDReferenceType/RefIDAttributeType"
+        )
+        procedure_da_ref_attr_value = ET.SubElement(procedure_da_ref_attr, "Value")
+        procedure_da_ref_attr_value.text = procedure_da_reference
+
+        classification_attr = ET.SubElement(procedure_element, "Attribute")
+        classification_attr.set("Name", "Classification")
+        classification_attr.set(
+            "RefAttributeType", "AutomationMLBaseAttributeTypeLib/OrderedListType"
+        )
+        classification_attr_description = ET.SubElement(
+            classification_attr, "Description"
+        )
+        classification_attr_description.text = "Function Classification"
+
+        for process_value_out in procedure.process_value_outs.values():
+
+            data_assembly_ref = (
+                self.__add_data_assembly_to_instance_hierarchy_data_assemblies(
+                    process_value_out
+                )
+            )
+            self.__add_process_value_out_to_instance_hierarchy_process_values(
+                process_value_out.tag_name, data_assembly_ref
+            )
+
+            pv_out = ET.Element("InternalElement")
+            pv_out.set("Name", process_value_out.tag_name)
+            pv_out.set("ID", get_uuid())
+            pv_out.set(
+                "RefBaseSystemUnitPath",
+                "MTPProcessValueSUCLib/ProcessValue/ProcessValueOut",
+            )
+
+            # attribute: Reference to Data Assembly
+            pv_out_ref_attr = ET.SubElement(pv_out, "Attribute")
+            pv_out_ref_attr.set("Name", "RefID")
+            pv_out_ref_attr.set("AttributeDataType", "xs:string")
+            pv_out_ref_attr.set(
+                "RefAttributeType", "MTPATLib/IDReferenceType/RefIDAttributeType"
+            )
+            pv_out_ref_attr_value = ET.SubElement(pv_out_ref_attr, "Value")
+            pv_out_ref_attr_value.text = data_assembly_ref
+
+            # attribute: RoleRequirements
+            pv_out_role_req = ET.SubElement(pv_out, "RoleRequirements")
+            pv_out_role_req.set(
+                "RefBaseRoleClassPath",
+                "AutomationMLBaseRoleClassLib/AutomationMLBaseRole",
+            )
+
+            procedure_element.append(pv_out)
+
+        for process_value_in in procedure.process_value_ins.values():
+
+            data_assembly_ref = (
+                self.__add_data_assembly_to_instance_hierarchy_data_assemblies(
+                    process_value_in
+                )
+            )
+            self.__add_process_value_in_to_instance_hierarchy_process_values(
+                process_value_in.tag_name, data_assembly_ref
+            )
+
+            pv_in = ET.Element("InternalElement")
+            pv_in.set("Name", process_value_in.tag_name)
+            pv_in.set("ID", get_uuid())
+            pv_in.set(
+                "RefBaseSystemUnitPath",
+                "MTPProcessValueSUCLib/ProcessValue/ProcessValueIn",
+            )
+
+            # attribute: Reference to Data Assembly
+            pv_in_ref_attr = ET.SubElement(pv_in, "Attribute")
+            pv_in_ref_attr.set("Name", "RefID")
+            pv_in_ref_attr.set("AttributeDataType", "xs:string")
+            pv_in_ref_attr.set(
+                "RefAttributeType", "MTPATLib/IDReferenceType/RefIDAttributeType"
+            )
+            pv_in_ref_attr_value = ET.SubElement(pv_in_ref_attr, "Value")
+            pv_in_ref_attr_value.text = data_assembly_ref
+
+            # attribute: RoleRequirements
+            pv_in_role_req = ET.SubElement(pv_in, "RoleRequirements")
+            pv_in_role_req.set(
+                "RefBaseRoleClassPath",
+                "AutomationMLBaseRoleClassLib/AutomationMLBaseRole",
+            )
+
+            procedure_element.append(pv_in)
+
+        for procedure_parameter in procedure.procedure_parameters.values():
+
+            data_assembly_ref = (
+                self.__add_data_assembly_to_instance_hierarchy_data_assemblies(
+                    procedure_parameter
+                )
+            )
+
+            procedure_parameter_element = ET.Element("InternalElement")
+            procedure_parameter_element.set("Name", procedure_parameter.tag_name)
+            procedure_parameter_element.set("ID", get_uuid())
+            procedure_parameter_element.set(
+                "RefBaseSystemUnitPath",
+                "MTPServiceSUCLib/ServiceParameter/ProcedureParameter",
+            )
+
+            # attribute: Reference to Data Assembly
+            procedure_parameter_element_ref_attr = ET.SubElement(
+                procedure_parameter_element, "Attribute"
+            )
+            procedure_parameter_element_ref_attr.set("Name", "RefID")
+            procedure_parameter_element_ref_attr.set("AttributeDataType", "xs:string")
+            procedure_parameter_element_ref_attr.set(
+                "RefAttributeType", "MTPATLib/IDReferenceType/RefIDAttributeType"
+            )
+            procedure_parameter_element_ref_attr_value = ET.SubElement(
+                procedure_parameter_element_ref_attr, "Value"
+            )
+            procedure_parameter_element_ref_attr_value.text = data_assembly_ref
+
+            # attribute: RoleRequirements
+            procedure_parameter_element_role_req = ET.SubElement(
+                procedure_parameter_element, "RoleRequirements"
+            )
+            procedure_parameter_element_role_req.set(
+                "RefBaseRoleClassPath",
+                "AutomationMLBaseRoleClassLib/AutomationMLBaseRole",
+            )
+
+            procedure_element.append(procedure_parameter_element)
+
+        for report_value in procedure.report_values.values():
+
+            data_assembly_ref = (
+                self.__add_data_assembly_to_instance_hierarchy_data_assemblies(
+                    report_value
+                )
+            )
+
+            report_value_element = ET.Element("InternalElement")
+            report_value_element.set("Name", report_value.tag_name)
+            report_value_element.set("ID", get_uuid())
+            report_value_element.set(
+                "RefBaseSystemUnitPath", "MTPSUCLib/LinkedObject/ReportValue"
+            )
+
+            # attribute: Reference to Data Assembly
+            report_value_element_ref_attr = ET.SubElement(
+                report_value_element, "Attribute"
+            )
+            report_value_element_ref_attr.set("Name", "RefID")
+            report_value_element_ref_attr.set("AttributeDataType", "xs:string")
+            report_value_element_ref_attr.set(
+                "RefAttributeType", "MTPATLib/IDReferenceType/RefIDAttributeType"
+            )
+            report_value_element_ref_attr_value = ET.SubElement(
+                report_value_element_ref_attr, "Value"
+            )
+            report_value_element_ref_attr_value.text = data_assembly_ref
+
+            # attribute: RoleRequirements
+            report_value_element_role_req = ET.SubElement(
+                report_value_element, "RoleRequirements"
+            )
+            report_value_element_role_req.set(
+                "RefBaseRoleClassPath",
+                "AutomationMLBaseRoleClassLib/AutomationMLBaseRole",
+            )
+
+            procedure_element.append(report_value_element)
+
+        for required_equipment in procedure.required_equipment.values():
+
+            data_assembly_ref = (
+                self.__add_data_assembly_to_instance_hierarchy_data_assemblies(
+                    required_equipment
+                )
+            )
+
+            required_equipment_element = ET.Element("InternalElement")
+            required_equipment_element.set("Name", required_equipment.tag_name)
+            required_equipment_element.set("ID", get_uuid())
+            required_equipment_element.set(
+                "RefBaseSystemUnitPath", "MTPSUCLib/LinkedObject/RequiredEquipment"
+            )
+
+            # attribute: Reference to Data Assembly
+            required_equipment_element_ref_attr = ET.SubElement(
+                required_equipment_element, "Attribute"
+            )
+            required_equipment_element_ref_attr.set("Name", "RefID")
+            required_equipment_element_ref_attr.set("AttributeDataType", "xs:string")
+            required_equipment_element_ref_attr.set(
+                "RefAttributeType", "MTPATLib/IDReferenceType/RefIDAttributeType"
+            )
+            required_equipment_element_ref_attr_value = ET.SubElement(
+                required_equipment_element_ref_attr, "Value"
+            )
+            required_equipment_element_ref_attr_value.text = data_assembly_ref
+
+            # attribute: RoleRequirements
+            required_equipment_element_role_req = ET.SubElement(
+                required_equipment_element, "RoleRequirements"
+            )
+            required_equipment_element_role_req.set(
+                "RefBaseRoleClassPath",
+                "AutomationMLBaseRoleClassLib/AutomationMLBaseRole",
+            )
+
+            procedure_element.append(required_equipment_element)
+
+        # attribute: RoleRequirements
+        procedure_role_req = ET.SubElement(procedure_element, "RoleRequirements")
+        procedure_role_req.set(
+            "RefBaseRoleClassPath", "AutomationMLBaseRoleClassLib/AutomationMLBaseRole"
+        )
+
+        return procedure_element
+
+    def __add_process_value_in_to_instance_hierarchy_process_values(
+        self, name, data_assembly_reference
+    ):
+        """
+        Create an ProcessValueIn at ProcessValues InstanceHierarchy.
+
+        Args:
+            data_assembly_reference: ID Reference to DataAssembly object
+        """
+        pv_in = ET.Element("InternalElement")
+        pv_in.set("Name", name)
+        pv_in.set("ID", get_uuid())
+        pv_in.set(
+            "RefBaseSystemUnitPath", "MTPProcessValueSUCLib/ProcessValue/ProcessValueIn"
+        )
+
+        # attribute: Reference to Data Assembly
+        pv_in_ref_attr = ET.SubElement(pv_in, "Attribute")
+        pv_in_ref_attr.set("Name", "RefID")
+        pv_in_ref_attr.set("AttributeDataType", "xs:string")
+        pv_in_ref_attr.set(
+            "RefAttributeType", "MTPATLib/IDReferenceType/RefIDAttributeType"
+        )
+        pv_in_ref_attr_value = ET.SubElement(pv_in_ref_attr, "Value")
+        pv_in_ref_attr_value.text = data_assembly_reference
+
+        # attribute: RoleRequirements
+        pv_in_role_req = ET.SubElement(pv_in, "RoleRequirements")
+        pv_in_role_req.set(
+            "RefBaseRoleClassPath", "AutomationMLBaseRoleClassLib/AutomationMLBaseRole"
+        )
+
+        self._instance_hierarchy_process_values.append(pv_in)
+
+    def __add_process_value_out_to_instance_hierarchy_process_values(
+        self, name, data_assembly_reference
+    ):
+        """Create an ProcessValueOut at ProcessValues InstanceHierarchy.
+
+        Args:
+            name: Name of the DataAssembly object
+            data_assembly_reference: ID Reference to DataAssembly object
+        """
+
+        pv_out = ET.Element("InternalElement")
+        pv_out.set("Name", name)
+        pv_out.set("ID", get_uuid())
+        pv_out.set(
+            "RefBaseSystemUnitPath",
+            "MTPProcessValueSUCLib/ProcessValue/ProcessValueOut",
+        )
+
+        # attribute: Reference to DataAssembly
+        pv_in_ref_attr = ET.SubElement(pv_out, "Attribute")
+        pv_in_ref_attr.set("Name", "RefID")
+        pv_in_ref_attr.set("AttributeDataType", "xs:string")
+        pv_in_ref_attr.set(
+            "RefAttributeType", "MTPATLib/IDReferenceType/RefIDAttributeType"
+        )
+        pv_in_ref_attr_value = ET.SubElement(pv_in_ref_attr, "Value")
+        pv_in_ref_attr_value.text = data_assembly_reference
+
+        # attribute: RoleRequirements
+        pv_in_role_req = ET.SubElement(pv_out, "RoleRequirements")
+        pv_in_role_req.set(
+            "RefBaseRoleClassPath", "AutomationMLBaseRoleClassLib/AutomationMLBaseRole"
+        )
+
+        self._instance_hierarchy_process_values.append(pv_out)
+
+    @staticmethod
+    def __serialize_alarm_value(value: object) -> str:
+        """Serialize scalar alarm values using XML-compatible spelling."""
+        if type(value) is bool:
+            return "true" if value else "false"
+        return str(value)
+
+    @staticmethod
+    def __add_role_requirements(parent: ET.Element) -> None:
+        """Append the generic AutomationML role requirement."""
+        role_requirements = ET.SubElement(parent, "RoleRequirements")
+        role_requirements.set(
+            "RefBaseRoleClassPath",
+            "AutomationMLBaseRoleClassLib/AutomationMLBaseRole",
+        )
+
+    @staticmethod
+    def __add_alarm_attribute(
+        parent: ET.Element,
+        name: str,
+        value: object,
+        data_type: str | None = None,
+        reference_type: str | None = None,
+    ) -> ET.Element:
+        """Append an alarm attribute and its scalar value."""
+        attribute = ET.SubElement(parent, "Attribute")
+        attribute.set("Name", name)
+        if data_type is not None:
+            attribute.set("AttributeDataType", data_type)
+        if reference_type is not None:
+            attribute.set("RefAttributeType", reference_type)
+        attribute_value = ET.SubElement(attribute, "Value")
+        attribute_value.text = MTPGenerator.__serialize_alarm_value(value)
+        return attribute
+
+    def __add_alarm_to_instance_hierarchy_alarms(self, alarm: Alarm) -> None:
+        """Add one AlarmSet.Base alarm and its references to the manifest."""
+        assembly_key = id(alarm.data_assembly)
+        data_assembly_ref_id = self._data_assembly_ref_ids.get(assembly_key)
+        if data_assembly_ref_id is None:
+            msg = f"Alarm {alarm.tag_name!r} must reference a registered DataAssembly"
+            raise ValueError(msg)
+        trigger_key = id(alarm.trigger)
+        if trigger_key not in self._serialized_data_items:
+            msg = f"Alarm {alarm.tag_name!r} trigger DataItem was not serialized"
+            raise ValueError(msg)
+        trigger_id = self._alarm_trigger_ids[trigger_key]
+
+        alarm_group = self._alarm_group_elements.get(assembly_key)
+        if alarm_group is None:
+            alarm_group = ET.Element(
+                "InternalElement",
+                {
+                    "Name": f"{alarm.data_assembly.tag_name}_AlarmGroup",
+                    "ID": get_uuid(),
+                    "RefBaseSystemUnitPath": "MTPAlarmSUCLib/AlarmGroup",
+                },
+            )
+            self.__add_alarm_attribute(
+                alarm_group,
+                "RefID",
+                data_assembly_ref_id,
+                "xs:string",
+                "MTPATLib/IDReferenceType/RefIDAttributeType",
+            )
+            self.__add_role_requirements(alarm_group)
+            self._instance_hierarchy_alarms.append(alarm_group)
+            self._alarm_group_elements[assembly_key] = alarm_group
+
+        message_id = self.__add_text_to_instance_hierarchy_texts(alarm)
+        alarm_element = ET.Element(
+            "InternalElement",
+            {
+                "Name": alarm.tag_name,
+                "ID": get_uuid(),
+                "RefBaseSystemUnitPath": "MTPAlarmSUCLib/Alarm",
+            },
+        )
+        self.__add_alarm_attribute(
+            alarm_element,
+            "AckRequired",
+            alarm.ack_required,
+            "xs:boolean",
+        )
+        self.__add_alarm_attribute(
+            alarm_element,
+            "Severity",
+            alarm.severity,
+            "xs:short",
+        )
+        self.__add_alarm_attribute(
+            alarm_element,
+            "Trigger",
+            trigger_id,
+            "xs:string",
+            "MTPATLib/IDReferenceType/IDLinkAttributeType",
+        )
+        self.__add_alarm_attribute(
+            alarm_element,
+            "TriggerValue",
+            alarm.trigger_value,
+            f"xs:{alarm.trigger.w3c_xml_data_type.string_value}",
+        )
+        classification = ET.SubElement(alarm_element, "Attribute")
+        classification.set("Name", "Classification")
+        classification.set(
+            "RefAttributeType",
+            "AutomationMLBaseAttributeTypeLib/OrderedListType",
+        )
+        ET.SubElement(classification, "Description").text = "Alarm Classification"
+        self.__add_alarm_attribute(
+            alarm_element,
+            "MessageRef",
+            message_id,
+            "xs:string",
+            "MTPTextATLib/TextRefAttributeType",
+        )
+        self.__add_role_requirements(alarm_element)
+
+        role_requirements_index = len(alarm_group) - 1
+        alarm_group.insert(role_requirements_index, alarm_element)
+
+    def __add_text_to_instance_hierarchy_texts(self, alarm: Alarm) -> str:
+        """Add an AlarmMessage and return its object ID."""
+        message_id = get_uuid()
+        message = ET.Element(
+            "InternalElement",
+            {
+                "Name": f"{alarm.tag_name} message",
+                "ID": message_id,
+                "RefBaseSystemUnitPath": ("MTPTextSUCLib/TextDefinition/AlarmMessage"),
+            },
+        )
+        alarm_text = ET.SubElement(
+            message,
+            "InternalElement",
+            {
+                "Name": f"{alarm.tag_name}.Text",
+                "ID": get_uuid(),
+                "RefBaseSystemUnitPath": (
+                    "MTPTextSUCLib/TextDefinition/AlarmMessage/AlarmText"
+                ),
+            },
+        )
+        self.__add_alarm_attribute(
+            alarm_text,
+            "Text",
+            alarm.message,
+            "xs:string",
+            "MTPATLib/StaticValueAttributeType",
+        )
+        self.__add_role_requirements(alarm_text)
+        self.__add_role_requirements(message)
+        self._instance_hierarchy_texts.append(message)
+        return message_id