MTPPy2.0 0.1.5__py3-none-any.whl

mtppy/part5/definitions/iec61131_data_types_test.py

@@ -0,0 +1,82 @@
+"""Tests for IEC-61131 data types."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+import pytest
+
+from enum import Enum
+
+from mtppy.part5.definitions.iec61131_data_types import IEC61131DataTypes
+
+
+def test_iec61131_data_types_is_enum() -> None:
+    assert issubclass(IEC61131DataTypes, Enum)
+
+
+def test_iec61131_data_types_contains_all_supported_types() -> None:
+    expected_names = [
+        "BOOL",
+        "BYTE",
+        "WORD",
+        "DWORD",
+        "LWORD",
+        "SINT",
+        "INT",
+        "DINT",
+        "LINT",
+        "USINT",
+        "UINT",
+        "UDINT",
+        "ULINT",
+        "REAL",
+        "LREAL",
+        "STRING",
+        "WSTRING",
+        "DATE",
+        "TIME_OF_DAY",
+        "DATE_AND_TIME",
+    ]
+
+    assert [member.name for member in IEC61131DataTypes] == expected_names
+
+
+@pytest.mark.parametrize(
+    ("member", "expected_value"),
+    [
+        (member_name, (member_name,))
+        for member_name in (
+            "BOOL",
+            "BYTE",
+            "WORD",
+            "DWORD",
+            "LWORD",
+            "SINT",
+            "INT",
+            "DINT",
+            "LINT",
+            "USINT",
+            "UINT",
+            "UDINT",
+            "ULINT",
+            "REAL",
+            "LREAL",
+            "STRING",
+            "WSTRING",
+            "DATE",
+            "TIME_OF_DAY",
+        )
+    ]
+    + [("DATE_AND_TIME", "DATE_AND_TIME")],
+)
+def test_iec61131_data_type_values(
+    member: str, expected_value: tuple[str] | str
+) -> None:
+    assert IEC61131DataTypes[member].value == expected_value
+
+
+def test_iec61131_data_types_can_be_looked_up_by_value() -> None:
+    assert IEC61131DataTypes(("BOOL",)) is IEC61131DataTypes.BOOL
+    assert IEC61131DataTypes("DATE_AND_TIME") is IEC61131DataTypes.DATE_AND_TIME

mtppy/part5/definitions/opcua_data_types.py

@@ -0,0 +1,36 @@
+"""Definition of String Constants for OPCUA Data Types."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from enum import Enum
+
+
+class OpcUaDataTypes(Enum):
+    Boolean = ("Boolean",)
+    SByte = ("SByte",)
+    Byte = ("Byte",)
+    Int16 = ("Int16",)
+    UInt16 = ("UInt16",)
+    Int32 = ("Int32",)
+    UInt32 = ("UInt32",)
+    Int64 = ("Int64",)
+    UInt64 = ("UInt64",)
+    Float = ("Float",)
+    Double = ("Double",)
+    String = ("String",)
+    DateTime = ("DateTime",)
+    Guid = ("Guid",)
+    ByteString = ("ByteString",)
+    XmlElement = ("XmlElement",)
+    NodeId = ("NodeId",)
+    ExpandedNodeId = ("ExpandedNodeId",)
+    StatusCode = ("StatusCode",)
+    QualifiedName = ("QualifiedName",)
+    LocalizedText = ("LocalizedText",)
+    ExtensionObject = ("ExtensionObject",)
+    DataValue = ("DataValue",)
+    Variant = ("Variant",)
+    DiagnosticInfo = "DiagnosticInfo"

mtppy/part5/definitions/opcua_data_types_test.py

@@ -0,0 +1,90 @@
+"""Tests for OPC UA data types."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+import pytest
+
+from enum import Enum
+
+from mtppy.part5.definitions.opcua_data_types import OpcUaDataTypes
+
+
+def test_opcua_data_types_is_enum() -> None:
+    assert issubclass(OpcUaDataTypes, Enum)
+
+
+def test_opcua_data_types_contains_all_supported_types() -> None:
+    expected_names = [
+        "Boolean",
+        "SByte",
+        "Byte",
+        "Int16",
+        "UInt16",
+        "Int32",
+        "UInt32",
+        "Int64",
+        "UInt64",
+        "Float",
+        "Double",
+        "String",
+        "DateTime",
+        "Guid",
+        "ByteString",
+        "XmlElement",
+        "NodeId",
+        "ExpandedNodeId",
+        "StatusCode",
+        "QualifiedName",
+        "LocalizedText",
+        "ExtensionObject",
+        "DataValue",
+        "Variant",
+        "DiagnosticInfo",
+    ]
+
+    assert [member.name for member in OpcUaDataTypes] == expected_names
+
+
+@pytest.mark.parametrize(
+    ("member", "expected_value"),
+    [
+        (member_name, (member_name,))
+        for member_name in (
+            "Boolean",
+            "SByte",
+            "Byte",
+            "Int16",
+            "UInt16",
+            "Int32",
+            "UInt32",
+            "Int64",
+            "UInt64",
+            "Float",
+            "Double",
+            "String",
+            "DateTime",
+            "Guid",
+            "ByteString",
+            "XmlElement",
+            "NodeId",
+            "ExpandedNodeId",
+            "StatusCode",
+            "QualifiedName",
+            "LocalizedText",
+            "ExtensionObject",
+            "DataValue",
+            "Variant",
+        )
+    ]
+    + [("DiagnosticInfo", "DiagnosticInfo")],
+)
+def test_opcua_data_type_values(member: str, expected_value: tuple[str] | str) -> None:
+    assert OpcUaDataTypes[member].value == expected_value
+
+
+def test_opcua_data_types_can_be_looked_up_by_value() -> None:
+    assert OpcUaDataTypes(("Boolean",)) is OpcUaDataTypes.Boolean
+    assert OpcUaDataTypes("DiagnosticInfo") is OpcUaDataTypes.DiagnosticInfo

mtppy/part5/definitions/w3c_xml_data_types.py

@@ -0,0 +1,177 @@
+"""Conversion of MTP supported automation datatypes."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from collections.abc import Callable
+from enum import Enum
+
+from opcua.ua import VariantType
+
+import utils.type_conversion as tc
+
+
+class W3cXmlDataTypes(Enum):
+    """Enumeration of W3C XML schema data types supported by MTP 2.0.
+
+    Each member of this enumeration maps a W3C XML schema data type to the
+    corresponding Python type, the matching ``opcua.ua.VariantType``
+    and an optional conversion function used to cast Python values to the
+    target representation when reading or writing MTP data items.
+
+    Fully Supported Attributes:
+        BOOLEAN,
+        BYTE, UNSIGNED_BYTE
+        SHORT, UNSIGNED_SHORT
+        INT, UNSIGNED_INT
+        LONG, UNSIGNED_LONG
+        FLOAT, DOUBLE
+        STRING
+
+    Partially Supported Attributes:
+        DATE, TIME, DATE_TIME
+        ANY_URI, TOKEN
+    """
+
+    BOOLEAN = (
+        "boolean",
+        bool,
+        VariantType.Boolean,
+        tc.cast_to_bool,
+    )
+    UNSIGNED_BYTE = (
+        "unsignedByte",
+        int,
+        VariantType.Byte,
+        tc.cast_to_ubyte,
+    )
+    UNSIGNED_SHORT = (
+        "unsignedShort",
+        int,
+        VariantType.UInt16,
+        tc.cast_to_ushort,
+    )
+    UNSIGNED_INT = (
+        "unsignedInt",
+        int,
+        VariantType.UInt32,
+        tc.cast_to_uint,
+    )
+    UNSIGNED_LONG = (
+        "unsignedLong",
+        int,
+        VariantType.Int64,
+        tc.cast_to_ulong,
+    )
+    BYTE = (
+        "byte",
+        int,
+        VariantType.SByte,
+        tc.cast_to_byte,
+    )
+    SHORT = (
+        "short",
+        int,
+        VariantType.Int16,
+        tc.cast_to_short,
+    )
+    INT = (
+        "int",
+        int,
+        VariantType.Int32,
+        tc.cast_to_int,
+    )
+    LONG = (
+        "long",
+        int,
+        VariantType.Int64,
+        tc.cast_to_long,
+    )
+    FLOAT = (
+        "float",
+        float,
+        VariantType.Float,
+        float,
+    )
+    DOUBLE = (
+        "double",
+        float,
+        VariantType.Double,
+        float,
+    )
+    STRING = (
+        "string",
+        str,
+        VariantType.String,
+        tc.cast_to_string,
+    )
+    DATE = (
+        "date",
+        None,
+        VariantType.DateTime,
+        None,
+    )
+    TIME = (
+        "time",
+        None,
+        VariantType.DateTime,
+        None,
+    )
+    DATE_TIME = (
+        "dateTime",
+        None,
+        VariantType.DateTime,
+        None,
+    )
+    ANY_URI = (
+        "anyURI",
+        None,
+        None,
+        None,
+    )
+    TOKEN = (
+        "token",
+        None,
+        None,
+        None,
+    )
+
+    def __init__(
+        self,
+        string_value: str,
+        python_type: type | None,
+        opcua_variant: VariantType | None,
+        converse_function: Callable[[tc.ANY_TYPE], tc.ANY_TYPE] | None,
+    ) -> None:
+        """Initialize a W3cXmlDataTypes enum member.
+
+        Args:
+            string_value: The W3C XML schema name of the data type
+                (e.g. "boolean", "unsignedInt", a.s.o).
+            python_type: The corresponding Python type (e.g. `bool`,
+                `int`, `float`, and `str`). May be `None`
+                for XML types without a direct Python equivalent
+                (e.g. `anyURI`, `token`).
+            opcua_variant: The corresponding
+                `opcua.ua.VariantType` value. May be ``None`` for XML
+                types without a direct OPC UA mapping.
+            converse_function: A callable used to cast or convert a Python
+                value to the data type's expected Python representation.
+                May be ``None`` for types that do not require an explicit
+                conversion step.
+        """
+        self.string_value = string_value
+        self.python_type = python_type
+        self.opcua_variant = opcua_variant
+        self.converse = converse_function
+
+    def __str__(self) -> str:
+        """Return the W3C XML schema name of the data type as string.
+
+        Returns:
+            The XML schema name of the data type as stored in
+            ``string_value`` (e.g. ``"boolean"``, ``"unsignedInt"``).
+        """
+        return self.string_value

mtppy/part5/definitions/w3c_xml_data_types_test.py

@@ -0,0 +1,143 @@
+"""Tests for W3C XML data types."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from enum import Enum
+
+import pytest
+from opcua.ua import VariantType
+
+from mtppy.part5.definitions.w3c_xml_data_types import W3cXmlDataTypes
+import utils.type_conversion as tc
+
+
+def test_w3c_xml_data_types_is_enum() -> None:
+    assert issubclass(W3cXmlDataTypes, Enum)
+
+
+def test_w3c_xml_data_types_contains_all_supported_types() -> None:
+    expected_names = [
+        "BOOLEAN",
+        "UNSIGNED_BYTE",
+        "UNSIGNED_SHORT",
+        "UNSIGNED_INT",
+        "UNSIGNED_LONG",
+        "BYTE",
+        "SHORT",
+        "INT",
+        "LONG",
+        "FLOAT",
+        "DOUBLE",
+        "STRING",
+        "DATE",
+        "TIME",
+        "DATE_TIME",
+        "ANY_URI",
+        "TOKEN",
+    ]
+
+    assert [member.name for member in W3cXmlDataTypes] == expected_names
+
+
+@pytest.mark.parametrize(
+    ("member", "string_value", "python_type", "opcua_variant"),
+    [
+        (W3cXmlDataTypes.BOOLEAN, "boolean", bool, VariantType.Boolean),
+        (
+            W3cXmlDataTypes.UNSIGNED_BYTE,
+            "unsignedByte",
+            int,
+            VariantType.Byte,
+        ),
+        (
+            W3cXmlDataTypes.UNSIGNED_SHORT,
+            "unsignedShort",
+            int,
+            VariantType.UInt16,
+        ),
+        (
+            W3cXmlDataTypes.UNSIGNED_INT,
+            "unsignedInt",
+            int,
+            VariantType.UInt32,
+        ),
+        (
+            W3cXmlDataTypes.UNSIGNED_LONG,
+            "unsignedLong",
+            int,
+            VariantType.Int64,
+        ),
+        (W3cXmlDataTypes.BYTE, "byte", int, VariantType.SByte),
+        (W3cXmlDataTypes.SHORT, "short", int, VariantType.Int16),
+        (W3cXmlDataTypes.INT, "int", int, VariantType.Int32),
+        (W3cXmlDataTypes.LONG, "long", int, VariantType.Int64),
+        (W3cXmlDataTypes.FLOAT, "float", float, VariantType.Float),
+        (W3cXmlDataTypes.DOUBLE, "double", float, VariantType.Double),
+        (W3cXmlDataTypes.STRING, "string", str, VariantType.String),
+        (W3cXmlDataTypes.DATE, "date", None, VariantType.DateTime),
+        (W3cXmlDataTypes.TIME, "time", None, VariantType.DateTime),
+        (W3cXmlDataTypes.DATE_TIME, "dateTime", None, VariantType.DateTime),
+        (W3cXmlDataTypes.ANY_URI, "anyURI", None, None),
+        (W3cXmlDataTypes.TOKEN, "token", None, None),
+    ],
+)
+def test_w3c_xml_data_type_metadata(
+    member: W3cXmlDataTypes,
+    string_value: str,
+    python_type: type | None,
+    opcua_variant: VariantType | None,
+) -> None:
+    assert member.string_value == string_value
+    assert member.python_type is python_type
+    assert member.opcua_variant is opcua_variant
+
+
+def test_w3c_xml_data_types_string_representation() -> None:
+    assert str(W3cXmlDataTypes.BOOLEAN) == "boolean"
+    assert str(W3cXmlDataTypes.DATE_TIME) == "dateTime"
+    assert str(W3cXmlDataTypes.ANY_URI) == "anyURI"
+
+
+@pytest.mark.parametrize(
+    ("member", "value", "expected_value"),
+    [
+        (W3cXmlDataTypes.BOOLEAN, 1, True),
+        (W3cXmlDataTypes.UNSIGNED_BYTE, 256, 255),
+        (W3cXmlDataTypes.UNSIGNED_SHORT, 65536, 65535),
+        (W3cXmlDataTypes.UNSIGNED_INT, 2**32, 2**32 - 1),
+        (W3cXmlDataTypes.UNSIGNED_LONG, 2**64, 2**64 - 1),
+        (W3cXmlDataTypes.BYTE, 128, 127),
+        (W3cXmlDataTypes.SHORT, 2**15, 2**15 - 1),
+        (W3cXmlDataTypes.INT, 2**31, 2**31 - 1),
+        (W3cXmlDataTypes.LONG, 2**63, 2**63 - 1),
+        (W3cXmlDataTypes.FLOAT, "1.5", 1.5),
+        (W3cXmlDataTypes.DOUBLE, "2.5", 2.5),
+        (W3cXmlDataTypes.STRING, 123, "123"),
+    ],
+)
+def test_w3c_xml_data_type_conversions(
+    member: W3cXmlDataTypes, value: object, expected_value: object
+) -> None:
+    assert member.converse is not None
+    assert member.converse(value) == expected_value
+
+
+def test_w3c_xml_data_types_without_conversion_are_unmapped() -> None:
+    for member in (
+        W3cXmlDataTypes.DATE,
+        W3cXmlDataTypes.TIME,
+        W3cXmlDataTypes.DATE_TIME,
+        W3cXmlDataTypes.ANY_URI,
+        W3cXmlDataTypes.TOKEN,
+    ):
+        assert member.converse is None
+
+
+def test_w3c_xml_data_types_can_be_looked_up_by_value() -> None:
+    assert (
+        W3cXmlDataTypes(("boolean", bool, VariantType.Boolean, tc.cast_to_bool))
+        is W3cXmlDataTypes.BOOLEAN
+    )

mtppy/part5/server_assembly_set/__init__.py

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

mtppy/part6/__init__.py

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

mtppy/part6/alarm_set/__init__.py

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

mtppy/part6/alarm_set/alarm.py

@@ -0,0 +1,132 @@
+"""Static AlarmSet.Base alarm descriptions."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from dataclasses import dataclass
+
+from mtppy.part3.data_assembly_set.data_assembly import DataAssembly
+from mtppy.part5.definitions.w3c_xml_data_types import W3cXmlDataTypes
+from mtppy.utils.data_item import DataItem
+
+MIN_SEVERITY = 1
+MAX_SEVERITY = 1000
+_INTEGER_RANGES = {
+    W3cXmlDataTypes.BYTE: (-(2**7), (2**7) - 1),
+    W3cXmlDataTypes.UNSIGNED_BYTE: (0, (2**8) - 1),
+    W3cXmlDataTypes.SHORT: (-(2**15), (2**15) - 1),
+    W3cXmlDataTypes.UNSIGNED_SHORT: (0, (2**16) - 1),
+    W3cXmlDataTypes.INT: (-(2**31), (2**31) - 1),
+    W3cXmlDataTypes.UNSIGNED_INT: (0, (2**32) - 1),
+    W3cXmlDataTypes.LONG: (-(2**63), (2**63) - 1),
+    W3cXmlDataTypes.UNSIGNED_LONG: (0, (2**64) - 1),
+}
+
+
+@dataclass(frozen=True, slots=True)
+class Alarm:
+    """Describe a POL-evaluated AlarmSet.Base alarm.
+
+    The alarm links a value of an existing DataItem to static alarm metadata in
+    the generated MTP. It does not observe the DataItem or maintain alarm state
+    inside the PEA.
+
+    Args:
+        tag_name: Unique alarm name within the PEA.
+        data_assembly: DataAssembly containing the trigger DataItem.
+        trigger: Existing DataItem used as the alarm trigger.
+        trigger_value: Value for which the POL considers the alarm active.
+        message: Operator-facing alarm message.
+        ack_required: Whether the POL should require acknowledgement.
+        severity: Alarm severity in the inclusive range from 1 to 1000.
+
+    Raises:
+        TypeError: If an argument has an unsupported type.
+        ValueError: If text is empty, severity is out of range, or the trigger
+            does not belong to the DataAssembly.
+    """
+
+    tag_name: str
+    data_assembly: DataAssembly
+    trigger: DataItem
+    trigger_value: object
+    message: str
+    ack_required: bool
+    severity: int
+
+    def __post_init__(self) -> None:
+        """Validate the static alarm description."""
+        self.validate()
+
+    def validate(self) -> None:
+        """Revalidate this alarm and its mutable DataItem reference.
+
+        Raises:
+            TypeError: If a field or trigger type is unsupported.
+            ValueError: If a value is outside its permitted range or the trigger
+                no longer belongs to the configured DataAssembly.
+        """
+        self._validate_text(self.tag_name, "tag_name")
+        self._validate_text(self.message, "message")
+
+        if not isinstance(self.data_assembly, DataAssembly):
+            msg = "data_assembly must be a DataAssembly"
+            raise TypeError(msg)
+        if not isinstance(self.trigger, DataItem):
+            msg = "trigger must be a DataItem"
+            raise TypeError(msg)
+        if not any(
+            self.data_assembly.get_item(key) is self.trigger
+            for key in self.data_assembly
+        ):
+            msg = "trigger must belong to the configured DataAssembly"
+            raise ValueError(msg)
+
+        trigger_type = self.trigger.w3c_xml_data_type.python_type
+        if trigger_type not in (bool, int, str):
+            type_name = self.trigger.w3c_xml_data_type.string_value
+            msg = f"Alarm trigger type {type_name} is not supported"
+            raise TypeError(msg)
+        if type(self.trigger_value) is not trigger_type:
+            msg = "TriggerValue must have the exact type of the trigger DataItem"
+            raise TypeError(msg)
+        integer_range = _INTEGER_RANGES.get(self.trigger.w3c_xml_data_type)
+        if integer_range is not None and not (
+            integer_range[0] <= self.trigger_value <= integer_range[1]
+        ):
+            msg = (
+                f"TriggerValue is outside the range of "
+                f"xs:{self.trigger.w3c_xml_data_type.string_value}"
+            )
+            raise ValueError(msg)
+
+        if type(self.ack_required) is not bool:
+            msg = "ack_required must be a boolean"
+            raise TypeError(msg)
+        if type(self.severity) is not int:
+            msg = "severity must be an integer and bool is not accepted"
+            raise TypeError(msg)
+        if not MIN_SEVERITY <= self.severity <= MAX_SEVERITY:
+            msg = f"severity must be between {MIN_SEVERITY} and {MAX_SEVERITY}"
+            raise ValueError(msg)
+
+    @staticmethod
+    def _validate_text(value: str, field_name: str) -> None:
+        """Validate a required text field.
+
+        Args:
+            value: Field value to validate.
+            field_name: Field name used in the error message.
+
+        Raises:
+            TypeError: If the value is not a string.
+            ValueError: If the value contains no visible characters.
+        """
+        if not isinstance(value, str):
+            msg = f"{field_name} must be a string"
+            raise TypeError(msg)
+        if not value.strip():
+            msg = f"{field_name} must not be empty"
+            raise ValueError(msg)