MTPPy2.0 0.1.5__py3-none-any.whl

mtppy/utils/mtp_file_handling/mtp_reader/mtp_reader_test.py

@@ -0,0 +1,96 @@
+"""Tests for MtpReader orchestration and alias mapping."""
+
+from pathlib import Path
+from xml.etree.ElementTree import ElementTree, fromstring
+
+from mtppy.utils.mtp_file_handling.mtp_reader.mtp_reader import MtpReader
+
+
+def test_empty_reader_has_empty_collections() -> None:
+    reader = MtpReader()
+
+    assert reader.data_assemblies == {}
+    assert reader.services == {}
+    assert reader.alias_opcua_map == {}
+
+
+def test_create_alias_opcua_node_map_only_maps_referenced_attributes() -> None:
+    reader = MtpReader()
+    data_assemblies = {
+        "assembly": {
+            "Mapped": {"value": "reference"},
+            "Missing": {"value": "unknown"},
+            "Plain": "value",
+        }
+    }
+
+    assert reader.create_alias_opcua_node_map(
+        data_assemblies, {"reference": "ns=2;s=assembly.Mapped"}
+    ) == {"assembly.Mapped": "ns=2;s=assembly.Mapped"}
+
+
+def test_read_mtp_runs_validation_extraction_loading_and_cleanup(monkeypatch) -> None:
+    reader = MtpReader()
+    manifest = ElementTree(fromstring("<Manifest />"))
+    calls: list[tuple[str, object]] = []
+
+    monkeypatch.setattr(
+        "mtppy.utils.mtp_file_handling.mtp_reader.mtp_reader.is_valid_mtp",
+        lambda path: calls.append(("validate", path)),
+    )
+    monkeypatch.setattr(
+        "mtppy.utils.mtp_file_handling.mtp_reader.mtp_reader.get_work_dir",
+        lambda base: calls.append(("workdir", base)) or Path("workdir"),
+    )
+    monkeypatch.setattr(
+        "mtppy.utils.mtp_file_handling.mtp_reader.mtp_reader.extract_manifest_from_mtp_file",
+        lambda path, workdir: calls.append(("extract", (path, workdir)))
+        or Path("manifest.xml"),
+    )
+    monkeypatch.setattr(
+        "mtppy.utils.mtp_file_handling.mtp_reader.mtp_reader.load_manifest_file",
+        lambda path: calls.append(("load", path)) or manifest,
+    )
+    monkeypatch.setattr(
+        "mtppy.utils.mtp_file_handling.mtp_reader.mtp_reader.cleanup_folder",
+        lambda workdir: calls.append(("cleanup", workdir)),
+    )
+
+    result = reader.read_mtp("example.mtp")
+
+    assert result is manifest
+    assert calls == [
+        ("validate", "example.mtp"),
+        ("workdir", "../workdir"),
+        ("extract", ("example.mtp", Path("workdir"))),
+        ("load", Path("manifest.xml")),
+        ("cleanup", Path("workdir")),
+    ]
+
+
+def test_reader_initializes_parsed_collections(monkeypatch) -> None:
+    reader = MtpReader()
+    manifest = ElementTree(fromstring("<Manifest />"))
+    monkeypatch.setattr(
+        MtpReader,
+        "read_mtp",
+        lambda self, path: manifest,
+    )
+    monkeypatch.setattr(
+        "mtppy.utils.mtp_file_handling.mtp_reader.mtp_reader.get_opcua_node_ids",
+        lambda root: {"ref": "ns=2;s=assembly.Value"},
+    )
+    monkeypatch.setattr(
+        "mtppy.utils.mtp_file_handling.mtp_reader.mtp_reader.get_data_assemblies",
+        lambda root: {"assembly": {"Value": {"value": "ref"}}},
+    )
+    monkeypatch.setattr(
+        "mtppy.utils.mtp_file_handling.mtp_reader.mtp_reader.get_services",
+        lambda root: {"service": {}},
+    )
+
+    result = MtpReader("example.mtp")
+
+    assert result.data_assemblies == {"assembly": {"Value": {"value": "ref"}}}
+    assert result.services == {"service": {}}
+    assert result.alias_opcua_map == {"assembly.Value": "ns=2;s=assembly.Value"}

mtppy/utils/mtp_file_handling/mtp_reader/mtp_xml.py

@@ -0,0 +1,226 @@
+"""Utilities for XML file handling."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+import uuid
+from typing import Any
+from xml.etree.ElementTree import Element
+
+from mtppy.pea.data_assembly_factory import DataAssemblyConfig
+
+
+def is_valid_guid(guid_string: str) -> bool:
+    """Check if the given string is a valid GUID/UUID.
+
+    Args:
+        guid_string: The string to validate.
+
+    Returns:
+        bool: True if the string is a valid GUID, False otherwise.
+    """
+    try:
+        uuid.UUID(guid_string)
+        return True
+    except (ValueError, TypeError):
+        return False
+
+
+NMSPC = {"ns0": "http://www.dke.de/CAEX"}
+_OPCUA_ITEM = "MTPServerAssemblyICLib/DataItem/OPCUAItem"
+_EXT_IF = "ns0:ExternalInterface"
+_INT_EL = "ns0:InternalElement"
+_ATTR = "ns0:Attribute"
+_RBCP = "RefBaseClassPath"
+_VAL = "ns0:Value"
+_DEF_VAL = "ns0:DefaultValue"
+_INST_HRCHY = "ns0:InstanceHierarchy"
+_DA_SET = "DataAssemblies"
+_SRV_SET = "Services"
+
+
+def get_child_value_text(elem: Element) -> str:
+    """Get the first <Value>content</Value> child of an element.
+
+    Args:
+        elem: The XML element to search.
+
+    Returns:
+        str: The value text if found, empty string otherwise.
+    """
+    element = elem.find(f"./{_VAL}", namespaces=NMSPC)
+    if element is not None and element.text is not None:
+        return element.text
+    return ""
+
+
+def get_child_default_value_text(elem: Element) -> str:
+    """Get the first <DefaultValue>content</DefaultValue> of an element.
+
+    Args:
+        elem: The XML element to search.
+
+    Returns:
+        str: The default value text if found, empty string otherwise.
+    """
+    element = elem.find(f"./{_DEF_VAL}", namespaces=NMSPC)
+    if element is not None and element.text is not None:
+        return element.text
+    return ""
+
+
+def get_all_child_attribute_text(
+    elem: Element,
+    node_ids: dict[str, str] | None = None,
+) -> dict[str, dict[str, str]]:
+    """Get all child attribute texts from an element.
+
+    Args:
+        elem: The XML element to process.
+        node_ids: Optional mapping of node IDs to their replacement values.
+
+    Returns:
+        dict: Dictionary containing attribute names and values.
+    """
+    result: dict[str, dict[str, str]] = {}
+    attributes = elem.findall(f"./{_ATTR}[@Name]", namespaces=NMSPC)
+    for attr in attributes:
+        value = get_child_value_text(attr)
+        default = get_child_default_value_text(attr)
+        if node_ids and value in node_ids:
+            result[attr.attrib["Name"]] = {"value": node_ids[value], "default": default}
+        else:
+            result[attr.attrib["Name"]] = {"value": value, "default": default}
+    return result
+
+
+def get_opcua_node_id(root: Element, identifier: str) -> str:
+    """Get OPC UA node ID from an ExternalInterface element.
+
+    Args:
+        root: The root ElementTree to search.
+        identifier: The ID of the ExternalInterface element.
+
+    Returns:
+        str: The OPC UA node ID in the format "ns=<namespace>;s=<identifier>",
+             or an empty string if not found.
+    """
+    result: dict[str, str] = {}
+    xpath = f".//{_EXT_IF}[@ID='{identifier}'][@{_RBCP}='{_OPCUA_ITEM}']/{_ATTR}"
+    elements = root.findall(xpath, namespaces=NMSPC)
+    if len(elements):
+        for e in elements:
+            if "Name" in e.attrib and e.attrib["Name"] and e.text:
+                result[e.attrib["Name"]] = e.text
+        return f"ns={result['namespace']};s={result['Identifier']}"
+    return ""
+
+
+def get_data_assemblies(root: Element | None) -> dict[str, DataAssemblyConfig]:
+    """Extract data assemblies from the XML root element.
+
+    Args:
+        root: The root ElementTree to search.
+
+    Returns:
+        dict: A dictionary mapping data assembly names to their configurations.
+    """
+    result: dict[str, DataAssemblyConfig] = {}
+    if root is not None:
+        xpath = f".//{_INST_HRCHY}[@Name='{_DA_SET}']"
+        dass = root.findall(xpath, namespaces=NMSPC)
+        if len(dass):
+            xpath = f"./{_INT_EL}"
+            for das in dass:
+                for data_assembly in das.findall(xpath, namespaces=NMSPC):
+                    name = data_assembly.attrib["Name"]
+                    value = get_all_child_attribute_text(data_assembly)
+                    # add attributes to values (ID, Name, RefBaseSystemUnitPath, RefID)
+                    for attr, attr_value in data_assembly.attrib.items():
+                        value[attr] = attr_value
+                    if name in result:
+                        for k, v in value.items():
+                            if k in result[name]:
+                                result[name][k] = [result[name][k], v]
+                            else:
+                                result[name][k] = v
+                    else:
+                        result[name] = value
+    return result
+
+
+def get_named_childs_recursive(parent: Element, xpath: str) -> dict[str, Any]:
+    """Recursively get named children from an XML element.
+
+    Args:
+        parent: The parent XML element.
+        xpath: The XPath expression to find child elements.
+
+    Returns:
+        dict: A dictionary of named children and their attributes.
+    """
+    result = {}
+    for child in parent.findall(xpath, namespaces=NMSPC):
+        name = child.attrib["Name"]
+        value = get_all_child_attribute_text(child)
+        for attr, attr_value in child.attrib.items():
+            value[attr] = attr_value
+        for grandchild, gc_value in get_named_childs_recursive(child, xpath).items():
+            value[grandchild] = gc_value
+        if name in result:
+            for k, v in value.items():
+                if k in result[name]:
+                    if result[name][k] != v:
+                        result[name][k] = [result[name][k], v]
+                else:
+                    result[name][k] = v
+        else:
+            result[name] = value
+    return result
+
+
+def get_services(root: Element | None) -> dict[str, dict[str, str | dict[str, str]]]:
+    """Extract services from the XML root element.
+
+    Args:
+        root: The root ElementTree to search.
+
+    Returns:
+        dict: A dictionary mapping service names to their configurations.
+    """
+    result: dict[str, dict[str, str]] = {}
+    if root is not None:
+        xpath = f".//{_INST_HRCHY}[@Name='{_SRV_SET}']"
+        sss = root.findall(xpath, namespaces=NMSPC)
+        if len(sss):
+            xpath = f"./{_INT_EL}"
+            for services in sss:
+                result = dict(get_named_childs_recursive(services, xpath).items())
+    return result
+
+
+def get_opcua_node_ids(root: Element | None) -> dict[str, str]:
+    """Get all OPC UA node IDs from ExternalInterface elements.
+
+    Args:
+        root: The root ElementTree to search.
+
+    Returns:
+        dict: A dictionary mapping ExternalInterface IDs to their node information.
+    """
+    result: dict[str, str] = {}
+    if root is not None:
+        elements = root.findall(
+            f".//{_EXT_IF}[@{_RBCP}='{_OPCUA_ITEM}']",
+            namespaces=NMSPC,
+        )
+        if len(elements):
+            for elem in elements:
+                value = get_all_child_attribute_text(elem)
+                ref = elem.attrib["ID"]
+                ns = value["Namespace"]["value"]
+                identifier = value["Identifier"]["value"]
+                result[ref] = f"ns={ns};s={identifier}"
+    return result

mtppy/utils/mtp_file_handling/mtp_reader/mtp_xml_test.py

@@ -0,0 +1,108 @@
+"""Tests for MTP manifest XML extraction helpers."""
+
+from xml.etree.ElementTree import Element, fromstring
+
+from mtppy.utils.mtp_file_handling.mtp_reader import mtp_xml
+
+NS = "http://www.dke.de/CAEX"
+
+
+def element(xml: str) -> Element:
+    return fromstring(f'<root xmlns="{NS}">{xml}</root>')
+
+
+def test_is_valid_guid() -> None:
+    assert mtp_xml.is_valid_guid("12345678-1234-5678-1234-567812345678")
+    assert not mtp_xml.is_valid_guid("invalid")
+
+
+def test_child_value_and_default_text() -> None:
+    attribute = element("<Value>actual</Value><DefaultValue>default</DefaultValue>")
+
+    assert mtp_xml.get_child_value_text(attribute) == "actual"
+    assert mtp_xml.get_child_default_value_text(attribute) == "default"
+    assert mtp_xml.get_child_value_text(element("<Other />")) == ""
+
+
+def test_get_all_child_attribute_text_replaces_node_reference() -> None:
+    assembly = element(
+        '<Attribute Name="TagName"><Value>assembly</Value></Attribute>'
+        '<Attribute Name="Node"><Value>node-ref</Value><DefaultValue>0</DefaultValue></Attribute>'
+    )
+
+    assert mtp_xml.get_all_child_attribute_text(assembly) == {
+        "TagName": {"value": "assembly", "default": ""},
+        "Node": {"value": "node-ref", "default": "0"},
+    }
+    assert (
+        mtp_xml.get_all_child_attribute_text(
+            assembly, {"node-ref": "ns=2;s=assembly.Node"}
+        )["Node"]["value"]
+        == "ns=2;s=assembly.Node"
+    )
+
+
+def test_get_opcua_node_id() -> None:
+    interface = element(
+        '<ExternalInterface ID="ref" RefBaseClassPath="MTPServerAssemblyICLib/DataItem/OPCUAItem">'
+        '<Attribute Name="namespace">2</Attribute>'
+        '<Attribute Name="Identifier">assembly.Value</Attribute>'
+        "</ExternalInterface>"
+    )
+
+    assert mtp_xml.get_opcua_node_id(interface, "ref") == "ns=2;s=assembly.Value"
+    assert mtp_xml.get_opcua_node_id(interface, "missing") == ""
+
+
+def test_get_data_assemblies_extracts_attributes_and_merges_duplicates() -> None:
+    root = fromstring(
+        f'<root xmlns="{NS}">'
+        '<InstanceHierarchy Name="DataAssemblies">'
+        '<InternalElement Name="upper_bound" ID="id-1" RefBaseSystemUnitPath="type-1">'
+        '<Attribute Name="TagName"><Value>upper_bound</Value></Attribute>'
+        "</InternalElement>"
+        '<InternalElement Name="upper_bound" ID="id-2" RefBaseSystemUnitPath="type-2">'
+        '<Attribute Name="TagName"><Value>upper_bound</Value></Attribute>'
+        "</InternalElement>"
+        "</InstanceHierarchy></root>"
+    )
+
+    assemblies = mtp_xml.get_data_assemblies(root)
+
+    assert assemblies["upper_bound"]["ID"] == ["id-1", "id-2"]
+    assert assemblies["upper_bound"]["TagName"] == [
+        {"value": "upper_bound", "default": ""},
+        {"value": "upper_bound", "default": ""},
+    ]
+    assert mtp_xml.get_data_assemblies(None) == {}
+
+
+def test_get_services_recurses_through_nested_elements() -> None:
+    root = fromstring(
+        f'<root xmlns="{NS}">'
+        '<InstanceHierarchy Name="Services">'
+        '<InternalElement Name="rand_num_gen" RefBaseSystemUnitPath="service">'
+        '<Attribute Name="Name"><Value>rand_num_gen</Value></Attribute>'
+        '<InternalElement Name="cont" RefBaseSystemUnitPath="procedure">'
+        '<Attribute Name="Name"><Value>cont</Value></Attribute>'
+        "</InternalElement></InternalElement>"
+        "</InstanceHierarchy></root>"
+    )
+
+    services = mtp_xml.get_services(root)
+
+    assert services["rand_num_gen"]["cont"]["RefBaseSystemUnitPath"] == "procedure"
+    assert mtp_xml.get_services(None) == {}
+
+
+def test_get_opcua_node_ids_extracts_external_interface_mapping() -> None:
+    root = fromstring(
+        f'<root xmlns="{NS}">'
+        '<ExternalInterface ID="ref" RefBaseClassPath="MTPServerAssemblyICLib/DataItem/OPCUAItem">'
+        '<Attribute Name="Namespace"><Value>2</Value></Attribute>'
+        '<Attribute Name="Identifier"><Value>upper_bound.VOp</Value></Attribute>'
+        "</ExternalInterface></root>"
+    )
+
+    assert mtp_xml.get_opcua_node_ids(root) == {"ref": "ns=2;s=upper_bound.VOp"}
+    assert mtp_xml.get_opcua_node_ids(None) == {}

mtppy/utils/mtp_file_handling/mtp_writer/__init__.py

@@ -0,0 +1,4 @@
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"

mtppy/utils/mtp_file_handling/mtp_writer/mtp_writer.py

@@ -0,0 +1,77 @@
+"""Class MtpWriter writes an MTP file."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+import logging
+from pathlib import Path
+
+from mtppy.utils.mtp_file_handling.is_valid_path_to_mtp import is_valid_path_to_mtp
+from mtppy.utils.mtp_file_handling.mtp_writer.ressources.get_content_types import (
+    get_content_types,
+)
+from mtppy.utils.mtp_file_handling.mtp_writer.ressources.get_rels import get_rels
+from mtppy.utils.mtp_file_handling.write_manifest_file import write_manifest_file
+from mtppy.utils.mtp_file_handling.write_mtp_file import write_mtp_file
+from utils.file_handling.cleanup_folder import cleanup_folder
+from utils.file_handling.get_utc_foldername_with_ms import get_utc_foldername_with_ms
+from utils.file_handling.get_work_dir import get_work_dir
+
+
+class MtpWriter:
+    def __init__(self):
+        """Writer for MTP files.
+        """
+
+    def write_mtp(
+        self,
+        manifest_content: str,
+        out_path: str | None = None,
+        mtp_name: str | None = None,
+    ):
+        try:
+            logging.info("🔍 Checking Manifest content....")
+            # conditional check?
+            logging.info("✅ Checking Manifest content --> PASSED")
+
+            workdir = get_work_dir(base="../workdir")
+            logging.info("📦 Write Manifest AML file...")
+            manifest_file_path = Path(workdir).joinpath("manifest.aml")
+            write_manifest_file(manifest_content, manifest_file_path)
+
+            logging.info("✅ Write Manifest AML file complete.")
+
+            if out_path is None:
+                out_dir_path = get_work_dir(base="../output")
+            else:
+                out_dir_path = out_path
+
+            if mtp_name is None:
+                mtp_file_name = f"MTPPy2.0-MTP-{get_utc_foldername_with_ms()}.mtp"
+            else:
+                mtp_file_name = f"{mtp_name}.mtp"
+            mtp_path = Path(out_dir_path).joinpath(mtp_file_name)
+            is_valid_path_to_mtp(mtp_path)
+
+            logging.info(f"💾 Saving data to MTP: {out_dir_path}")
+            base_dir = Path(__file__).parent
+            resource_path = base_dir.joinpath("ressources/CAEX_ClassModel_V.3.0.xsd")
+            write_mtp_file(
+                mtp_path,
+                {
+                    "manifest.aml": manifest_file_path,
+                    "_rels/.rels": get_rels(),
+                    "[Content_Types].xml": get_content_types(),
+                    "CAEX_ClassModel_V.3.0.xsd": resource_path,
+                },
+                [],
+            )
+
+            logging.info(" ♲ Cleaning up...")
+            cleanup_folder(workdir)
+
+            logging.info("✅ MTP creation complete.")
+        except Exception as e:
+            print(f"❌ Error: {e}")

mtppy/utils/mtp_file_handling/mtp_writer/ressources/get_content_types.py

@@ -0,0 +1,10 @@
+"""get content types as XML helper."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+
+def get_content_types() -> str:
+    return '<?xml version="1.0" encoding="utf-8"?><Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="aml" ContentType="model/vnd.automationml+xml" /><Default Extension="xsd" ContentType="text/xml" /><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml" /></Types>'

mtppy/utils/mtp_file_handling/mtp_writer/ressources/get_rels.py

@@ -0,0 +1,11 @@
+"""get relations as XML method."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+
+def get_rels() -> str:
+
+    return '<?xml version="1.0" encoding="utf-8"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Type="http://schemas.automationml.org/container/relationship/RootDocument" Target="/manifest.aml" Id="R37fdc16552e64602" /><Relationship Type="http://schemas.automationml.org/container/relationship/CAEXSchema" Target="/CAEX_ClassModel_V.3.0.xsd" Id="Rbd8467381b1c4394" /></Relationships>'

mtppy/utils/mtp_file_handling/mtp_writer/test_mtp_writer.py

@@ -0,0 +1,25 @@
+"""test suite for the mtp writer."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+import xml.etree.ElementTree as ET
+
+from mtppy.utils.mtp_file_handling.mtp_writer.mtp_writer import MtpWriter
+from utils.file_handling.get_work_dir import get_work_dir
+
+
+def test_mtp_writer():
+    mtp_writer = MtpWriter()
+
+    extract_folder = get_work_dir("../output")
+    root = ET.Element("root")
+    child = ET.SubElement(root, "item", attrib={"id": "1"})
+    child.text = "Hello World"
+    xml_str = ET.tostring(root, encoding="utf-8", xml_declaration=True).decode("utf-8")
+
+    mtp_writer.write_mtp(xml_str, extract_folder, "My-First-MTPPy-MTP")
+
+    # cleanup_folder(extract_folder)

mtppy/utils/mtp_file_handling/write_manifest_file.py

@@ -0,0 +1,29 @@
+"""Write the manifest part of an MTP file."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+import xml.etree.ElementTree as ET
+
+from mtppy.utils.mtp_file_handling.is_valid_path_for_manifest import (
+    is_valid_path_for_manifest,
+)
+
+
+def write_manifest_file(xml_content: str, output_file_path):
+    """Write and return manifest content from file as XML Element Tree.
+
+    Args:
+        xml_content: XML content to write
+        output_file_path: Path where the manifest file should be written
+
+    Raises:
+        NotADirectoryError: If the output file path is invalid
+    """
+    if not is_valid_path_for_manifest(output_file_path):
+        raise NotADirectoryError(f"Invalid path: {output_file_path}")
+    tree = ET.ElementTree(ET.fromstring(xml_content))
+    ET.indent(tree, space="  ")
+    tree.write(output_file_path, encoding="utf-8", xml_declaration=True)

mtppy/utils/mtp_file_handling/write_manifest_file_test.py

@@ -0,0 +1,22 @@
+"""test suite for the writing the manifest part of an MTP file."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+import xml.etree.ElementTree as ET
+
+from mtppy.utils.mtp_file_handling.write_manifest_file import write_manifest_file
+from utils.file_handling.cleanup_folder import cleanup_folder
+from utils.file_handling.get_work_dir import get_work_dir
+
+
+def test_write_manifest_file():
+    extract_folder = get_work_dir()
+    root = ET.Element("root")
+    child = ET.SubElement(root, "item", attrib={"id": "1"})
+    child.text = "value"
+    xml_str = ET.tostring(root, encoding="utf-8", xml_declaration=True).decode("utf-8")
+    write_manifest_file(xml_str, f"{extract_folder}/manifest.aml")
+    cleanup_folder(extract_folder)

mtppy/utils/mtp_file_handling/write_mtp_file.py

@@ -0,0 +1,43 @@
+"""write an MTP File."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+import logging
+import os
+import zipfile
+from pathlib import WindowsPath
+
+
+def write_mtp_file(output_path, files, folders):
+    """Combine files and folders to an MTP file.
+    files: dict mapping {file_name: source_path} or {file_name: bytes/str content} to zip
+            With content "data.txt": "some text content",
+            With file reference "config.json": "/path/to/config.json",
+    folders: list of folder paths to zip recursively, preserving relative structure (optional)
+    """
+    with zipfile.ZipFile(output_path, "w", zipfile.ZIP_DEFLATED) as zf:
+        if files:
+            for file_name, source in files.items():
+                if isinstance(source, WindowsPath) or not isinstance(source, (bytes, str)):
+                    zf.write(source, arcname=file_name)
+                else:
+                    zf.writestr(file_name, source)
+
+        if folders:
+            for folder in folders:
+                folder = os.path.normpath(folder)
+                base_name = os.path.basename(folder)
+                for root, _, filenames in os.walk(folder):
+                    for filename in filenames:
+                        filepath = os.path.join(root, filename)
+                        rel_path = os.path.relpath(filepath, folder)
+                        arcname = os.path.join(base_name, rel_path)
+                        zf.write(filepath, arcname=arcname)
+
+    logging.debug(f"MTP File written to: {output_path}")
+    return output_path
+
+    # with zipfile.ZipFile(output_path, "w", zipfile.ZIP_DEFLATED) as zf: