MTPPy2.0 0.1.5__py3-none-any.whl

mtppy/part3/data_assembly_set/base_functions/source_mode.py

@@ -0,0 +1,189 @@
+"""Implementation of the Source Mode Base Function.
+
+This module implements the Source Mode Base Function as specified in PNO MTP 2.0
+Part 3, Section 8.2.2.3. The SourceMode class manages the source mode states
+(SrcChannel, SrcIntOp, SrcIntAut, SrcIntAct, SrcManOp, SrcManAut, SrcManAct)
+and provides methods to control the source mode transitions.
+"""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+import typing
+from typing import ClassVar
+
+from mtppy.utils.logging import logger
+from mtppy.utils.data_item import DataItem, DataItemCollection
+from mtppy.part3.definitions.mtp_access import MTPAccess
+from mtppy.part5.definitions.w3c_xml_data_types import W3cXmlDataTypes
+
+
+class SourceMode(DataItemCollection):
+    """Implements the operation and source modes BaseFunction.
+
+    This class manages the source mode states and transitions according to
+    the MTP 2.0 specification. It handles the interaction between different
+    source mode components like channel, internal and manual modes.
+    """
+
+    SRC_CHANNEL = "SrcChannel"
+    SRC_INT_OP = "SrcIntOp"
+    SRC_INT_AUT = "SrcIntAut"
+    SRC_INT_ACT = "SrcIntAct"
+    SRC_MAN_OP = "SrcManOp"
+    SRC_MAN_AUT = "SrcManAut"
+    SRC_MAN_ACT = "SrcManAct"
+
+    CLASS_DATA_ITEMS: ClassVar = {
+        SRC_CHANNEL: DataItem(
+            SRC_CHANNEL,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            init_value=False,
+            description="SourceMode channel - 0: operator (*Op) shall be used, 1: automatic (*Aut) shall be used.",
+        ),
+        SRC_INT_OP: DataItem(
+            SRC_INT_OP,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadWriteAccess,
+            init_value=False,
+            description="Request SourceMode to Internal by operator (if SrcChannel is false) - 0: no operation, 1: request internal.",
+        ),
+        SRC_INT_AUT: DataItem(
+            SRC_INT_AUT,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            init_value=False,
+            description="Request SourceMode to Internal by automatic (if SrcChannel is true) - 0: no operation, 1: request internal",
+        ),
+        SRC_INT_ACT: DataItem(
+            SRC_INT_ACT,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            init_value=False,
+            description="Indicator for Internal Mode - 0: internal mode inactive, 1: internal mode active.",
+        ),
+        SRC_MAN_OP: DataItem(
+            SRC_MAN_OP,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadWriteAccess,
+            init_value=False,
+            description="Request SourceMode to Manual by operator (if SrcChannel is false) - 0: no operation, 1: request manual.",
+        ),
+        SRC_MAN_AUT: DataItem(
+            SRC_MAN_AUT,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            init_value=False,
+            description="Request SourceMode to Manual by automatic (if SrcChannel is true) - 0: no operation, 1: request manual.",
+        ),
+        SRC_MAN_ACT: DataItem(
+            SRC_MAN_ACT,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            init_value=False,
+        ),
+    }
+
+    def __init__(self) -> None:
+        """Initialize the SourceMode instance.
+
+        The data items defined CLASS_DATA_ITEMS are set up by the
+        DataItemCollection. This class registers the callback functions for
+        automatic and manual operation mode changes.
+
+        """
+        super().__init__()
+        # add callbacks to ReadWrit-e and WriteAccess variables
+        self.get_item(SourceMode.SRC_INT_OP).ext_wrt_cb = self.set_src_int_op
+        self.get_item(SourceMode.SRC_MAN_OP).ext_wrt_cb = self.set_src_man_op
+
+        self.get_item(SourceMode.SRC_MAN_AUT).int_wrt_cb = self.set_src_man_aut
+        self.get_item(SourceMode.SRC_INT_AUT).int_wrt_cb = self.set_src_int_aut
+
+        logger.debug("SourceMode initialized")
+
+    def _src_to_off(self) -> None:
+        self[SourceMode.SRC_INT_ACT] = False
+        self[SourceMode.SRC_MAN_ACT] = False
+        logger.mtp("SourceMode is now off")
+
+    def _src_to_int(self) -> None:
+        self[SourceMode.SRC_INT_ACT] = True
+        self[SourceMode.SRC_MAN_ACT] = False
+        logger.mtp("SourceMode is now int")
+
+    def _src_to_man(self) -> None:
+        self[SourceMode.SRC_INT_ACT] = False
+        self[SourceMode.SRC_MAN_ACT] = True
+        logger.mtp("SourceMode is now man")
+
+    @typing.override
+    def set_src_channel(self, value: bool) -> None:
+        """Set the source channel value.
+
+        Args:
+            value: The boolean value to set for the source channel.
+
+        """
+        self[SourceMode.SRC_CHANNEL] = value
+        logger.mtp(
+            f"SrcChannel is now {self[SourceMode.SRC_CHANNEL]}",
+        )
+
+    def set_src_man_aut(self, value: bool) -> None:
+        """Set the manual automatic mode.
+
+        If the source channel is active and the value is True, transitions to
+        manual mode.
+
+        Args:
+            value: The boolean value to set for the manual automatic mode.
+
+        """
+        if self[SourceMode.SRC_CHANNEL] and value:
+            self._src_to_man()
+
+    def set_src_man_op(self, value: bool) -> None:
+        """Set the manual operation mode.
+
+        If the source channel is not active and the value is True, transitions to
+        manual mode. Also resets the manual operation mode to False.
+
+        Args:
+            value: The boolean value to set for the manual operation mode.
+
+        """
+        if not self[SourceMode.SRC_CHANNEL] and value:
+            self._src_to_man()
+        self[SourceMode.SRC_MAN_OP] = False
+
+    def set_src_int_aut(self, value: bool) -> None:
+        """Set the internal automatic mode.
+
+        If the source channel is active and the value is True, transitions to
+        internal mode.
+
+        Args:
+            value: The boolean value to set for the internal automatic mode.
+
+        """
+        if self[SourceMode.SRC_CHANNEL] and value:
+            self._src_to_int()
+
+    def set_src_int_op(self, value: bool) -> None:
+        """Set the internal operation mode.
+
+        If the source channel is not active and the value is True, transitions to
+        internal mode. Also resets the internal operation mode to False to prevent
+        infinite loops.
+
+        Args:
+            value: The boolean value to set for the internal operation mode.
+
+        """
+        if not self[SourceMode.SRC_CHANNEL] and value:
+            self._src_to_int()  # already done, setting again results in infinite loop
+        self[SourceMode.SRC_INT_OP] = False

mtppy/part3/data_assembly_set/base_functions/source_mode_test.py

@@ -0,0 +1,112 @@
+"""Test Suite for SourceMode."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+import pytest
+
+from mtppy.part3.data_assembly_set.base_functions.source_mode import SourceMode
+
+
+def init_source_mode(init_mode="int", src_channel=False):
+    src_mode = SourceMode()
+    src_mode.set_src_channel(src_channel)
+
+    if init_mode == "man":
+        src_mode[SourceMode.SRC_MAN_ACT] = True
+    elif init_mode == "int":
+        src_mode[SourceMode.SRC_INT_ACT] = True
+    else:
+        raise ValueError(f"Source mode {init_mode} is unknown")
+
+    return src_mode
+
+
+def source_mode_is_in_specific_mode(
+    src_mode, source_channel_assertion: bool, mode_assertion: str
+):
+    return all(
+        [
+            src_mode[SourceMode.SRC_CHANNEL] == source_channel_assertion,
+            src_mode[SourceMode.SRC_MAN_AUT] == False,
+            src_mode[SourceMode.SRC_INT_OP] == False,
+            src_mode[SourceMode.SRC_INT_AUT] == False,
+            src_mode[SourceMode.SRC_MAN_OP] == False,
+            src_mode[SourceMode.SRC_INT_ACT] == (mode_assertion == "int"),
+            src_mode[SourceMode.SRC_MAN_ACT] == (mode_assertion == "man"),
+        ]
+    )
+
+
+def test_initial_state():
+    # Initial mode
+    src_mode = init_source_mode(init_mode="int", src_channel=False)
+    assert source_mode_is_in_specific_mode(src_mode, False, "int") == True
+
+
+def test_source_channel_change():
+    # Initial mode
+    src_mode = init_source_mode()
+    # Trigger channel change
+    src_mode[SourceMode.SRC_CHANNEL] = True
+    assert source_mode_is_in_specific_mode(src_mode, True, "int") == True
+    # Trigger channel change back
+    src_mode[SourceMode.SRC_CHANNEL] = False
+    assert source_mode_is_in_specific_mode(src_mode, False, "int") == True
+
+
+def test_int_to_ext_src_channel_false():
+    # Initial mode
+    src_mode = init_source_mode()
+    assert source_mode_is_in_specific_mode(src_mode, False, "int") == True
+    # Trigger mode transition
+    src_mode.get_item(SourceMode.SRC_MAN_OP).ext_wrt_cb(True)
+    assert source_mode_is_in_specific_mode(src_mode, False, "man") == True
+
+
+def test_int_to_ext_src_channel_true():
+    # Initial mode
+    src_mode = init_source_mode(src_channel=True)
+    assert source_mode_is_in_specific_mode(src_mode, True, "int") == True
+    # Trigger mode transition
+    src_mode.SrcManAut = True
+    assert source_mode_is_in_specific_mode(src_mode, True, "man") == True
+
+
+def test_ext_to_int_src_channel_false():
+    # Initial mode
+    src_mode = init_source_mode(init_mode="man", src_channel=False)
+    assert source_mode_is_in_specific_mode(src_mode, False, "man") == True
+    # Trigger mode transition
+    src_mode.get_item(SourceMode.SRC_INT_OP).ext_wrt_cb(True)
+    assert source_mode_is_in_specific_mode(src_mode, False, "int") == True
+
+
+def test_ext_to_int_src_channel_true():
+    # Initial mode
+    src_mode = init_source_mode(init_mode="man", src_channel=True)
+    assert source_mode_is_in_specific_mode(src_mode, True, "man") == True
+    # Trigger mode transition
+    src_mode.SrcIntAut = True
+    assert source_mode_is_in_specific_mode(src_mode, True, "int") == True
+
+
+@pytest.mark.parametrize(
+    "state_request",
+    [SourceMode.SRC_INT_OP, SourceMode.SRC_MAN_OP],
+)
+def test_external_state_request_handshake(state_request: str) -> None:
+    src_mode = init_source_mode()
+
+    callback = src_mode.get_item(state_request).ext_wrt_cb
+    assert callback is not None
+    callback(True)
+
+    assert src_mode[state_request] is False
+
+
+if __name__ == "__main__":
+    # This allows running the tests directly if needed
+    pytest.main([__file__, "-v"])

mtppy/part3/data_assembly_set/base_functions/wqc.py

@@ -0,0 +1,75 @@
+"""Implementation of the WQC Base Function (PNO MTP 2.0 Part 3, Section 8.3.2).
+
+The WQC (Worst Quality Control) base function provides a foundation for
+write quality control operations. The base function provides the setter
+`set_wqc` for internal writes that simply sets the value. This setter is
+meant to be overwritten by derived classes with something semantically meaningful.
+
+Note:
+    If no quality code is available 255 (=unspecified WQC) shall be used.
+
+Example:
+    ```python
+    wqc = WQCBaseFunction()
+    wqc.set_wqc(10)
+    ```
+
+Attributes:
+    WQC_: Class constant representing the WQC alias of the PNO MTP 2.0 spec.
+"""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from typing import ClassVar
+
+import utils.type_conversion as tc
+from mtppy.utils.data_item import DataItem, DataItemCollection
+from mtppy.part3.definitions.mtp_access import MTPAccess
+from mtppy.part5.definitions.w3c_xml_data_types import W3cXmlDataTypes
+
+
+class WQCBaseFunction(DataItemCollection):
+    """Base function for Write Quality Control operations.
+
+    This class implements the basic WQC functionality that can be extended
+    by derived classes to provide specific write quality control behaviors.
+
+    Defines:
+        WQC_: Class constant representing the WQC data item name.
+    """
+
+    WQC_ = "WQC"
+
+    CLASS_DATA_ITEMS: ClassVar = {
+        WQC_: DataItem(
+            WQC_,
+            W3cXmlDataTypes.UNSIGNED_BYTE,
+            MTPAccess.ReadAccess,
+            init_value=255,
+            description="provides information about the conditions under \
+                        which a value was determined.",
+        ),
+    }
+
+    def __init__(self) -> None:
+        """Initialize the WQC BaseFunction.
+
+        Sets up the WQC data item with the appropriate write callback.
+        """
+        super().__init__()
+
+        self.get_item(WQCBaseFunction.WQC_).int_wrt_cb = self.set_wqc
+
+    def set_wqc(self, value: tc.ANY_TYPE) -> None:
+        """Set the WQC value.
+
+        This method is intended to be overridden by derived classes to
+        provide specific write quality control behavior.
+
+        Args:
+            value: The value to set for the WQC data item.
+        """
+        self[WQCBaseFunction.WQC_] = value

mtppy/part3/data_assembly_set/base_functions/wqc_test.py

@@ -0,0 +1,86 @@
+"""Test suite for the WQC (Work Quality Control) module."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+import sys
+import os
+import pytest
+
+# Add the src directory to the Python path to import modules
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "src"))
+
+
+def test_wqc_module_import():
+    """Test that the WQC module can be imported successfully."""
+    try:
+        from mtppy.part3.data_assembly_set.base_functions.wqc import WQCBaseFunction
+
+        assert True
+    except ImportError as e:
+        assert False, f"Failed to import WQC module: {e}"
+
+
+def test_wqc_base_function_exists():
+    """Test that WQCBaseFunction class exists."""
+    try:
+        from mtppy.part3.data_assembly_set.base_functions.wqc import WQCBaseFunction
+
+        assert WQCBaseFunction is not None
+        assert callable(WQCBaseFunction)
+    except ImportError as e:
+        pytest.fail(f"Failed to import WQCBaseFunction: {e}")
+
+
+def test_wqc_base_function_inheritance():
+    """Test that WQCBaseFunction has correct inheritance."""
+    try:
+        from mtppy.part3.data_assembly_set.base_functions.wqc import WQCBaseFunction
+
+        # Check if it's a class
+        assert isinstance(WQCBaseFunction, type)
+
+        # Check that it has expected attributes
+        assert hasattr(WQCBaseFunction, "__doc__")
+
+    except ImportError as e:
+        pytest.fail(f"Failed to test WQCBaseFunction inheritance: {e}")
+
+
+def test_wqc_functionality():
+    """Test basic WQC functionality."""
+    try:
+        from mtppy.part3.data_assembly_set.base_functions.wqc import WQCBaseFunction
+
+        # Try to instantiate the class
+        wqc_instance = WQCBaseFunction()
+
+        # Basic assertions
+        assert wqc_instance is not None
+        assert hasattr(wqc_instance, "__class__")
+
+    except Exception as e:
+        pytest.fail(f"Failed to test WQC functionality: {e}")
+
+
+def test_wqc_snake_case_api():
+    """Test basic WQC functionality."""
+    try:
+        from mtppy.part3.data_assembly_set.base_functions.wqc import WQCBaseFunction
+
+        # Try to instantiate the class
+        wqc_instance = WQCBaseFunction()
+
+        for wqc in range(0, 100, 10):
+            wqc_instance.WQC = wqc
+            assert wqc_instance.WQC == wqc
+
+    except Exception as e:
+        pytest.fail(f"Failed to test WQC functionality: {e}")
+
+
+if __name__ == "__main__":
+    # This allows running the tests directly if needed
+    pytest.main([__file__, "-v"])

mtppy/part3/data_assembly_set/data_assembly.py

@@ -0,0 +1,65 @@
+"""Implementation of the DataAssembly (PNO MTP 2.0 Part 1, 5.3)."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from typing import ClassVar
+
+from mtppy.utils.data_item import DataItem, DataItemCollection
+from mtppy.part3.definitions.mtp_access import MTPAccess
+from mtppy.part5.definitions.w3c_xml_data_types import W3cXmlDataTypes
+
+
+class DataAssembly(DataItemCollection):
+    """DataAssembly is the base class for all the DataAssemblies that
+    serve as interface between POL and PEA and are specified in
+    PNO MTP 2.0 Part 3 (Library) and PNO MTP 2.0 Part 4 (Services).
+
+    It defines the aliases ``TagName`` and ``TagDescription``
+
+    DataAssembly itself is quite simple, the heavy lifting of providing
+    simple pythonic access paths (dict, attribute, setter/getter)
+    to the elements and managing the callback logic on change requests is
+    done by the baseclass [DataItemCollection][mtppy.utils.data_item.DataItemCollection].
+    """
+
+    TAG_NAME = "TagName"
+    TAG_DESCRIPTION = "TagDescription"
+
+    CLASS_DATA_ITEMS: ClassVar = {
+        TAG_NAME: DataItem(
+            TAG_NAME,
+            W3cXmlDataTypes.STRING,
+            MTPAccess.ReadAccess,
+            init_value="untagged",
+        ),
+        TAG_DESCRIPTION: DataItem(
+            TAG_DESCRIPTION,
+            W3cXmlDataTypes.STRING,
+            MTPAccess.ReadAccess,
+            init_value="undescribed",
+        ),
+    }
+
+    # class attributes
+    mtpObjectType: str
+    tag_name: str
+    tag_description: str
+
+    def __init__(self, tag_name: str, tag_description: str = "") -> None:
+        """Initialize the DataAssembly.
+
+        Arguments:
+            tag_name: value for ``TagName`` (internal variable tag_name)
+            tag_description:  value for ``TagDescription`` (internal variable
+                tag_description)
+        """
+        super().__init__()
+        self.mtpObjectType = "MTPDataObjectSUCLib/DataAssembly"
+        self[DataAssembly.TAG_NAME] = tag_name
+        self[DataAssembly.TAG_DESCRIPTION] = tag_description
+
+        self.tag_name = tag_name
+        self.tag_description = tag_description

mtppy/part3/data_assembly_set/diagnostic_elements/__init__.py

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

mtppy/part3/data_assembly_set/diagnostic_elements/diagnostic_element.py

@@ -0,0 +1,19 @@
+"""Base Class for Diagnostic Elements."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+from mtppy.part3.data_assembly_set.data_assembly import DataAssembly
+from mtppy.part3.data_assembly_set.base_functions.wqc import WQCBaseFunction
+
+
+class DiagnosticElement(DataAssembly):
+
+    wqc: WQCBaseFunction
+
+    def __init__(self, tag_name: str, tag_description: str):
+        super().__init__(tag_name, tag_description)
+        self.mtpObjectType = "MTPDataObjectSUCLib/DataAssembly/DiagnosticElement"
+
+        self.wqc = WQCBaseFunction()

mtppy/part3/data_assembly_set/indicator_elements/__init__.py

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

mtppy/part3/data_assembly_set/indicator_elements/indicator_element.py

@@ -0,0 +1,22 @@
+"""Base Class for Indicators."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+from mtppy.part3.data_assembly_set.data_assembly import DataAssembly
+from mtppy.part3.data_assembly_set.base_functions.oslevel import OSLevelBaseFunction
+from mtppy.part3.data_assembly_set.base_functions.wqc import WQCBaseFunction
+
+
+class IndicatorElement(DataAssembly):
+
+    os_level: OSLevelBaseFunction
+    wqc: WQCBaseFunction
+
+    def __init__(self, tag_name: str, tag_description: str):
+        super().__init__(tag_name, tag_description)
+        self.mtpObjectType = "MTPDataAssemblySUCLib/DataAssembly/IndicatorElement"
+
+        self.os_level = OSLevelBaseFunction()
+        self.wqc = WQCBaseFunction()

mtppy/part3/data_assembly_set/indicator_elements/views/__init__.py

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

mtppy/part3/data_assembly_set/indicator_elements/views/ana_view.py

@@ -0,0 +1,68 @@
+"""Implementation of AnaView"""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from typing import ClassVar
+
+from mtppy.utils.logging import logger
+from mtppy.utils.data_item import DataItem
+from mtppy.part3.definitions.mtp_access import MTPAccess
+from mtppy.part5.definitions.w3c_xml_data_types import W3cXmlDataTypes
+from mtppy.part3.data_assembly_set.indicator_elements.indicator_element import (
+    IndicatorElement,
+)
+
+
+class AnaView(IndicatorElement):
+    # DataItem constant definitions
+    V_ = "V"
+    V_UNIT = "VUnit"
+    VSCL_MIN = "VSclMin"
+    VSCL_MAX = "VSclMax"
+
+    # Class-level data items dictionary
+    CLASS_DATA_ITEMS: ClassVar = {
+        V_: DataItem(V_, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, 0),
+        V_UNIT: DataItem(V_UNIT, W3cXmlDataTypes.SHORT, MTPAccess.ReadAccess, None),
+        VSCL_MIN: DataItem(VSCL_MIN, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, None),
+        VSCL_MAX: DataItem(VSCL_MAX, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, None),
+    }
+
+    v_scl_min: float
+    v_scl_max: float
+    v_unit: int
+
+    def __init__(
+        self,
+        tag_name: str,
+        tag_description: str = "",
+        v_scl_min: float = 0,
+        v_scl_max: float = 100,
+        v_unit: int = 1998,
+    ):
+        """
+        Analog View (AnaView).
+        """
+        super().__init__(tag_name, tag_description)
+        self.mtpObjectType = (
+            "MTPDataAssemblySUCLib/DataAssembly/IndicatorElement/AnaView"
+        )
+
+        self.v_scl_min = v_scl_min
+        self.v_scl_max = v_scl_max
+        self.v_unit = v_unit
+
+        # Initialize data items with dynamic values (using class-defined data items)
+        self[AnaView.V_] = 0
+        self[AnaView.V_UNIT] = self.v_unit
+        self[AnaView.VSCL_MIN] = self.v_scl_min
+        self[AnaView.VSCL_MAX] = self.v_scl_max
+
+        # Add callbacks for ReadWrite Variables
+
+    def set_v(self, value):
+        self[AnaView.V_] = value
+        logger.mtp(f"V set to {value}")