MTPPy2.0 0.1.5__py3-none-any.whl

mtppy/utils/data_item_test.py

@@ -0,0 +1,325 @@
+"""Test Suite for Data Item."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from itertools import product
+from typing import ClassVar
+from unittest.mock import Mock
+
+import pytest
+
+from mtppy.part3.definitions.mtp_access import MTPAccess
+from mtppy.part5.definitions.w3c_xml_data_types import W3cXmlDataTypes
+from mtppy.utils.data_item import DataItem, DataItemCollection
+
+types = [e for e in W3cXmlDataTypes if e.python_type]
+values = [-10, -5.6, 0, 1, 3.5, True, False]
+combinations = list(product(types, values))
+
+
+@pytest.mark.parametrize("data_type, value", combinations)
+def test_compatible_types(data_type, value):
+    attr = DataItem("", data_type, MTPAccess.ReadAccess, value)
+    assert isinstance(
+        attr._value,
+        data_type.python_type,
+    ), f"Value {attr._value} is not of type {data_type.python_type}"
+
+
+incompatible_types = [W3cXmlDataTypes.SHORT, W3cXmlDataTypes.FLOAT]
+incompatible_values = ["string"]
+incompatible_combinations = list(product(incompatible_types, incompatible_values))
+
+
+@pytest.mark.parametrize("data_type, value", incompatible_combinations)
+def test_incompatible_types(data_type, value):
+    attr = DataItem("", data_type, MTPAccess.ReadAccess, value)
+    assert not isinstance(
+        attr._value,
+        data_type.python_type,
+    ), f"Value {attr._value} is of type {data_type.python_type}"
+
+
+@pytest.mark.parametrize(
+    "unsupported",
+    [W3cXmlDataTypes.TOKEN, W3cXmlDataTypes.ANY_URI, W3cXmlDataTypes.DATE_TIME],
+)
+def test_unsupported_w3c_xml_data_type(unsupported):
+    """Test that a TypeError is raised when an invalid w3c_xml_data_type is passed."""
+    with pytest.raises(TypeError):
+        DataItem(
+            name="TestItem",
+            w3c_xml_data_type=unsupported,
+            access=MTPAccess.ReadAccess,
+            init_value=None,
+        )
+
+
+def test_invalid_w3c_xml_data_type():
+    """Test that a TypeError is raised when an invalid w3c_xml_data_type is passed."""
+    with pytest.raises(TypeError):
+        DataItem(
+            name="TestItem",
+            w3c_xml_data_type="invalid_type",
+            access=MTPAccess.ReadAccess,
+            init_value=None,
+        )
+
+
+def test_invalid_access():
+    """Test that a TypeError is raised when an invalid access type is passed."""
+    with pytest.raises(TypeError):
+        DataItem(
+            name="TestItem",
+            w3c_xml_data_type=W3cXmlDataTypes.FLOAT,
+            access="invalid_access",
+            init_value=1.0,
+        )
+
+
+def test_external_write_callback():
+    class OPCUANode:
+        def __init__(self, cb):
+            self.cb = cb
+            self.value = 0
+
+        def set_value(self, value):
+            self.value = value
+            self.cb(value)
+
+    test_value = {"value": 0}
+
+    def callback_function(new_value):
+        test_value["value"] = new_value
+
+    attr = DataItem(
+        "",
+        W3cXmlDataTypes.SHORT,
+        MTPAccess.ReadWriteAccess,
+        0,
+        external_write_cb=callback_function,
+    )
+
+    node = OPCUANode(attr.ext_wrt_cb)
+
+    node.set_value(10)
+    assert test_value["value"] == 10
+
+
+def test_communication_object_attachment(mocker):
+    class CommObj:
+        def __init__(self):
+            self.value = 0
+            self._node_id = "dummy"
+
+        def write_value_callback(self, value):
+            self.value = value
+
+    attr = DataItem(
+        "",
+        W3cXmlDataTypes.SHORT,
+        MTPAccess.ReadWriteAccess,
+        10,
+        external_write_cb=Mock(),
+    )
+    comm_object = CommObj()
+    attr.attach_communication_object(comm_object)
+
+    assert attr.comm_obj == comm_object
+    assert comm_object.value == 0
+    attr.set_value(13)
+    assert comm_object.value == 13
+
+
+def test_data_item_properties_and_default_initial_value():
+    attr = DataItem(
+        "Counter",
+        W3cXmlDataTypes.INT,
+        MTPAccess.ReadAccess,
+        description="A counter",
+        init_value=None,
+    )
+
+    assert attr.get_value() == 0
+    assert attr.init_value == 0
+    assert attr.description == "A counter"
+    assert attr.get_value_str() == "Counter=0"
+    assert attr.comm_obj is None
+    assert attr.ext_wrt_cb is None
+    assert attr.int_wrt_cb is None
+
+
+def test_set_value_calls_internal_callback_and_updates_from_callback():
+    callback_values = []
+
+    def internal_callback(value):
+        callback_values.append(value)
+
+    attr = DataItem(
+        "Counter",
+        W3cXmlDataTypes.INT,
+        MTPAccess.ReadWriteAccess,
+        0,
+        internal_write_cb=internal_callback,
+    )
+
+    attr.set_value(4)
+
+    assert callback_values == [4]
+    assert attr.get_value() == 0
+    assert attr._is_notifying is False
+
+
+def test_internal_callback_can_update_data_item_recursively():
+    attr = None
+
+    def internal_callback(value):
+        if value < 2:
+            attr.set_value(value + 1)
+
+    attr = DataItem(
+        "Counter",
+        W3cXmlDataTypes.INT,
+        MTPAccess.ReadWriteAccess,
+        0,
+        internal_write_cb=internal_callback,
+    )
+
+    attr.set_value(1)
+
+    assert attr.get_value() == 2
+    assert attr._is_notifying is False
+
+
+def test_set_value_notifies_external_object_when_value_is_unchanged():
+    communication_object = Mock()
+    attr = DataItem("Counter", W3cXmlDataTypes.INT, MTPAccess.ReadAccess, 4)
+    attr.attach_communication_object(communication_object)
+
+    attr.set_value(4)
+
+    communication_object.write_value_callback.assert_called_once_with(4)
+
+
+def test_set_value_uses_int_class_when_conversion_fails():
+    attr = DataItem("Counter", W3cXmlDataTypes.INT, MTPAccess.ReadAccess, 0)
+
+    attr.set_value("invalid")
+
+    assert attr.get_value() is int
+
+
+def test_data_item_collection_supports_mapping_operations_and_values():
+    collection = SampleCollection()
+
+    assert len(collection) == 2
+    assert list(collection) == ["First", "Second"]
+    assert collection.keys() == {"First", "Second"}
+    assert collection.values() == [1, "initial"]
+    assert collection.items() == [("First", 1), ("Second", "initial")]
+    assert collection["First"] == 1
+    assert collection.get_item("First").name == "First"
+
+    collection["First"] = 7
+    assert collection["First"] == 7
+
+
+def test_data_item_collection_supports_attribute_access_and_assignment():
+    collection = SampleCollection()
+
+    assert collection.First == 1
+
+    with pytest.raises(AttributeError, match="no attribute"):
+        collection.first
+
+    collection.First = 3
+    assert collection.First == 3
+
+    assert collection.extra == "I'm special"
+
+    collection.extra = "attribute!"
+    assert collection.extra == "attribute!"
+
+
+def test_data_item_assignment_to_unknown_key():
+    collection = SampleCollection()
+
+    with pytest.raises(KeyError):
+        collection.missing = 12
+
+
+def test_data_item_collection_rejects_unknown_keys_and_deletion():
+    collection = SampleCollection()
+
+    with pytest.raises(KeyError, match="key-immutable"):
+        collection["Unknown"] = 1
+
+    with pytest.raises(TypeError, match="key-immutable"):
+        del collection["First"]
+
+    with pytest.raises(KeyError):
+        collection["Unknown"]
+
+    with pytest.raises(KeyError):
+        collection.get_item("Unknown")
+
+
+def test_data_item_collection_rejects_unknown_attributes():
+    collection = SampleCollection()
+
+    assert hasattr(collection, "missing") is False
+
+    with pytest.raises(AttributeError, match="has no attribute 'missing'"):
+        collection.missing
+
+
+def test_data_item_collection_repr_contains_class_and_values():
+    collection = SampleCollection()
+
+    assert repr(collection) == (
+        "class=SampleCollection,data_items={'First': 1, 'Second': 'initial'})"
+    )
+
+
+def test_data_item_collection_deep_copies_class_data_items():
+    first_collection = SampleCollection()
+    second_collection = SampleCollection()
+
+    TEST_VALUE = 9
+    first_collection["First"] = TEST_VALUE
+
+    assert first_collection["First"] == TEST_VALUE
+    assert second_collection["First"] == 1
+
+
+class BaseCollection(DataItemCollection):
+    """A base collection of data items."""
+
+    FIRST = "First"
+    CLASS_DATA_ITEMS: ClassVar[dict[str, DataItem]] = {
+        FIRST: DataItem(FIRST, W3cXmlDataTypes.INT, MTPAccess.ReadAccess, 1),
+    }
+
+
+class SampleCollection(BaseCollection):
+    """A subclass of BaseCollection."""
+
+    SECOND = "Second"
+    CLASS_DATA_ITEMS: ClassVar[dict[str, DataItem]] = {
+        SECOND: DataItem(
+            SECOND,
+            W3cXmlDataTypes.STRING,
+            MTPAccess.ReadAccess,
+            "initial",
+        ),
+    }
+
+    extra: str
+
+    def __init__(self) -> None:
+        """Initialize the SampleCollection instance."""
+        super().__init__()
+        self.extra = "I'm special"

mtppy/utils/logging.py

@@ -0,0 +1,23 @@
+"""predefined logging levels for the MTPPy2.0 framework."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+import logging
+from typing import Final, cast
+
+from utils.logging import CUSTOM_LEVELS, CustomLogger
+
+logging.setLoggerClass(CustomLogger)
+logger: CustomLogger = cast("CustomLogger", logging.getLogger("MTPPy2.0Logger"))
+
+INFO_LEVELS: Final = CUSTOM_LEVELS
+CHOICES: Final = [level_name.upper() for level_name in INFO_LEVELS]
+
+logger.add_custom_levels(INFO_LEVELS)
+
+
+def setLogLevel(log_level: int | str) -> None:
+    """Set the root logger level from a numeric value or level name."""
+    logging.getLogger().setLevel(log_level)

mtppy/utils/logging_test.py

@@ -0,0 +1,26 @@
+"""Tests for the framework logging facade."""
+
+import logging
+
+from mtppy.utils.logging import CHOICES, INFO_LEVELS, CustomLogger, logger, setLogLevel
+from utils.logging import APP_LEVEL
+
+
+def test_framework_logger_is_pylance_visible_custom_logger() -> None:
+    assert isinstance(logger, CustomLogger)
+    logger.app("framework application message")
+
+
+def test_framework_logging_levels_match_choices() -> None:
+    assert [name.upper() for name in INFO_LEVELS] == CHOICES
+    assert INFO_LEVELS == {"opcua": 1, "mtp": 2, "app": 4, "pol": 6}
+
+
+def test_set_log_level_accepts_custom_level_name() -> None:
+    root_logger = logging.getLogger()
+    original_level = root_logger.level
+    try:
+        setLogLevel("APP")
+        assert root_logger.level == APP_LEVEL
+    finally:
+        root_logger.setLevel(original_level)

mtppy/utils/mtp_file_handling/__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/extract_manifest_from_mtp_file.py

@@ -0,0 +1,22 @@
+"""extract manifest from mtp file."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+import os
+import zipfile
+
+
+def extract_manifest_from_mtp_file(mtp_path, extract_dir):
+    try:
+        with zipfile.ZipFile(mtp_path, "r") as zip_ref:
+            aml_files = [
+                f for f in zip_ref.namelist() if f.lower().endswith("manifest.aml")
+            ]
+            if not aml_files:
+                raise FileNotFoundError("No Manifest.aml file found in MTP package.")
+            zip_ref.extractall(extract_dir)
+            return os.path.join(extract_dir, aml_files[0])
+    except zipfile.BadZipFile:
+        raise ValueError("Failed to unzip the MTP package. The file may be corrupted.")

mtppy/utils/mtp_file_handling/extract_mtp_file.py

@@ -0,0 +1,22 @@
+"""extract mtp file."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+import zipfile
+
+from utils.file_handling.get_work_dir import get_work_dir
+
+
+def extract_mtp_file(mtp_path):
+    """Extract files from an MTP file."""
+    extract_folder = get_work_dir()
+
+    with zipfile.ZipFile(mtp_path, "r") as zip_ref:
+        print(f"Contents of the zip file {mtp_path}:")
+        print(zip_ref.namelist())  # List all the files inside the zip archive
+        zip_ref.extractall(extract_folder)  # Extract to the folder we defined
+
+    print(f"Files extracted to: {extract_folder}")
+    return extract_folder

mtppy/utils/mtp_file_handling/is_valid_mtp.py

@@ -0,0 +1,22 @@
+"""determine if mtp is valid."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+import zipfile
+
+from mtppy.utils.mtp_file_handling.is_valid_path_to_mtp import is_valid_path_to_mtp
+
+
+def is_valid_mtp(path):
+    if not is_valid_path_to_mtp(path):
+        raise FileNotFoundError(f"File not found: {path}")
+    if not zipfile.is_zipfile(path):
+        raise ValueError(f"File is not a valid ZIP archive: {path}")
+    with zipfile.ZipFile(path, "r") as zip_ref:
+        if not any(
+            file.lower().endswith("manifest.aml") for file in zip_ref.namelist()
+        ):
+            raise FileNotFoundError("No .aml file found in the MTP package.")
+    return True

mtppy/utils/mtp_file_handling/is_valid_path_for_manifest.py

@@ -0,0 +1,15 @@
+"""determine if path for manifest is valid."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from pathlib import Path
+
+
+def is_valid_path_for_manifest(path):
+    path_object = Path(path)
+    return (path_object.suffix == ".aml") and (
+        path_object.name.lower() == "manifest.aml"
+    )

mtppy/utils/mtp_file_handling/is_valid_path_to_manifest.py

@@ -0,0 +1,17 @@
+"""determine if path to manifest is valid."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+from pathlib import Path
+
+
+def is_valid_path_to_manifest(path: str | Path) -> bool:
+    path_object = Path(path)
+    return (
+        path_object.exists()
+        and path_object.is_file()
+        and (path_object.suffix == ".aml")
+        and (path_object.name.lower() == "manifest.aml")
+    )

mtppy/utils/mtp_file_handling/is_valid_path_to_mtp.py

@@ -0,0 +1,17 @@
+"""determine if path to mtp is valid."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from pathlib import Path
+
+
+def is_valid_path_to_mtp(path):
+    path_object = Path(path)
+    return (
+        path_object.exists()
+        and path_object.is_file()
+        and (path_object.suffix == ".mtp")
+    )

mtppy/utils/mtp_file_handling/load_manifest_file.py

@@ -0,0 +1,24 @@
+"""load manifest method."""
+
+__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_to_manifest import (
+    is_valid_path_to_manifest,
+)
+
+
+def load_manifest_file(file_path) -> ET.ElementTree:
+    """Load and return manifest content from file as XML Element Tree."""
+    if not is_valid_path_to_manifest(file_path):
+        raise FileNotFoundError(f"Invalid path: {file_path}")
+    return ET.parse(file_path)
+
+    # with open(file_path, 'r') as f:
+    #    return json.load(f)
+    #
+    # root = ET.fromstring(xml_string).

mtppy/utils/mtp_file_handling/mtp_reader/__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_reader/mtp_reader.py

@@ -0,0 +1,103 @@
+"""Class MtpReader, the mockup for reading an MTP-File."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from pathlib import Path
+from xml.etree.ElementTree import ElementTree
+
+from mtppy.pea.data_assembly_factory import DataAssemblyConfig
+from mtppy.utils.logging import logger
+from mtppy.utils.mtp_file_handling.extract_manifest_from_mtp_file import (
+    extract_manifest_from_mtp_file,
+)
+from mtppy.utils.mtp_file_handling.is_valid_mtp import is_valid_mtp
+from mtppy.utils.mtp_file_handling.load_manifest_file import load_manifest_file
+from mtppy.utils.mtp_file_handling.mtp_reader.mtp_xml import (
+    get_data_assemblies,
+    get_opcua_node_ids,
+    get_services,
+)
+from utils.file_handling.cleanup_folder import cleanup_folder
+from utils.file_handling.get_work_dir import get_work_dir
+
+
+class MtpReader:
+    """A class to read and parse MTP files.
+
+    This class provides functionality to read MTP files, extract their manifest,
+    and create mappings between aliases and OPC UA node IDs.
+    """
+
+    def __init__(self, mtp_path: str | Path | None = None) -> None:
+        """Initialize the MtpReader with an optional MTP file path.
+
+        Args:
+            mtp_path: Path to the MTP file to read. If None, no file is read initially but all the public data structured are initialized
+        """
+        self._manifest: ElementTree = ElementTree()
+        self.alias_opcua_map = {}
+        self.data_assemblies: dict[str, DataAssemblyConfig] = {}
+        self.services = {}
+
+        if mtp_path:
+            self._manifest = self.read_mtp(mtp_path)
+            root = self._manifest.getroot()
+            node_ids = get_opcua_node_ids(root)
+            self.data_assemblies = get_data_assemblies(root)
+            self.alias_opcua_map = self.create_alias_opcua_node_map(
+                self.data_assemblies,
+                node_ids,
+            )
+            self.services = get_services(root)
+
+    def read_mtp(self, mtp_path: str | Path) -> ElementTree:
+        """Read and parse an MTP file.
+
+        Args:
+            mtp_path: Path to the MTP file to read.
+
+        Returns:
+            Parsed XML tree of the manifest
+
+        Raises:
+            FileNotFoundError: If file does not exist
+            ValueError: If file is not readable
+        """
+        logger.info(f"🔍 Checking MTP package: {mtp_path}")
+        is_valid_mtp(mtp_path)
+
+        logger.info("📦 Extracting AML file...")
+        workdir = get_work_dir(base="../workdir")
+        aml_file_path = extract_manifest_from_mtp_file(mtp_path, workdir)
+
+        result = load_manifest_file(aml_file_path)
+
+        logger.info(" ♲ Cleaning up...")
+        cleanup_folder(workdir)
+
+        logger.info("✅ MTP parsing complete.")
+        return result
+
+    def create_alias_opcua_node_map(
+        self,
+        data_assemblies: dict[str, DataAssemblyConfig],
+        node_ids: dict[str, str],
+    ) -> dict[str, str]:
+        """Create a mapping between MTP aliases and OPC UA node IDs.
+
+        Returns:
+            Dictionary mapping aliases to OPC UA node IDs.
+        """
+        alias_opcua_node_map: dict[str, str] = {}
+        for da_name, value in data_assemblies.items():
+            for alias, ref in value.items():
+                if (
+                    isinstance(ref, dict)
+                    and "value" in ref
+                    and ref["value"] in node_ids
+                ):
+                    alias_opcua_node_map[f"{da_name}.{alias}"] = node_ids[ref["value"]]
+        return alias_opcua_node_map