MTPPy2.0 0.1.5__py3-none-any.whl

mtppy/part3/data_assembly_set/base_functions/operation_mode.py

@@ -0,0 +1,252 @@
+"""Implementation of the Operation Mode Base Function."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from typing import ClassVar, Callable
+
+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 OperationMode(DataItemCollection):
+    # DataItem constant definitions
+    STATE_CHANNEL = "StateChannel"
+    STATE_OFF_AUT = "StateOffAut"
+    STATE_OP_AUT = "StateOpAut"
+    STATE_AUT_AUT = "StateAutAut"
+    STATE_OFF_OP = "StateOffOp"
+    STATE_OP_OP = "StateOpOp"
+    STATE_AUT_OP = "StateAutOp"
+    STATE_OP_ACT = "StateOpAct"
+    STATE_AUT_ACT = "StateAutAct"
+    STATE_OFF_ACT = "StateOffAct"
+
+    # Class-level data items dictionary
+    CLASS_DATA_ITEMS: ClassVar = {
+        STATE_CHANNEL: DataItem(
+            STATE_CHANNEL, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, False
+        ),
+        STATE_OFF_AUT: DataItem(
+            STATE_OFF_AUT, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, False
+        ),
+        STATE_OP_AUT: DataItem(
+            STATE_OP_AUT, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, False
+        ),
+        STATE_AUT_AUT: DataItem(
+            STATE_AUT_AUT, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, False
+        ),
+        STATE_OFF_OP: DataItem(
+            STATE_OFF_OP, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadWriteAccess, False
+        ),
+        STATE_OP_OP: DataItem(
+            STATE_OP_OP, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadWriteAccess, False
+        ),
+        STATE_AUT_OP: DataItem(
+            STATE_AUT_OP, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadWriteAccess, False
+        ),
+        STATE_OP_ACT: DataItem(
+            STATE_OP_ACT, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, False
+        ),
+        STATE_AUT_ACT: DataItem(
+            STATE_AUT_ACT, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, False
+        ),
+        STATE_OFF_ACT: DataItem(
+            STATE_OFF_ACT, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, True
+        ),
+    }
+
+    switch_to_offline_mode_allowed: bool
+
+    enter_offline_callbacks: list[Callable[[], None]]
+    exit_offline_callbacks: list[Callable[[], None]]
+    enter_operator_callbacks: list[Callable[[], None]]
+    exit_operator_callbacks: list[Callable[[], None]]
+    enter_automatic_callbacks: list[Callable[[], None]]
+    exit_automatic_callbacks: list[Callable[[], None]]
+
+    def __init__(self) -> None:
+        """
+        Represents the operation mode BaseFunction.
+        """
+        super().__init__()
+        # Initialize data items with dynamic values (using class-defined data items)
+        self.get_item(OperationMode.STATE_CHANNEL).init_value = False
+        self.get_item(OperationMode.STATE_OFF_AUT).init_value = False
+        self.get_item(OperationMode.STATE_OP_AUT).init_value = False
+        self.get_item(OperationMode.STATE_AUT_AUT).init_value = False
+        self.get_item(OperationMode.STATE_OFF_OP).init_value = False
+        self.get_item(OperationMode.STATE_OP_OP).init_value = False
+        self.get_item(OperationMode.STATE_AUT_OP).init_value = False
+        self.get_item(OperationMode.STATE_OP_ACT).init_value = False
+        self.get_item(OperationMode.STATE_AUT_ACT).init_value = False
+        self.get_item(OperationMode.STATE_OFF_ACT).init_value = True
+
+        self.switch_to_offline_mode_allowed = True
+
+        self.enter_offline_callbacks = []
+        self.exit_offline_callbacks = []
+
+        self.enter_operator_callbacks = []
+        self.exit_operator_callbacks = []
+
+        self.enter_automatic_callbacks = []
+        self.exit_automatic_callbacks = []
+
+        # Set callbacks for writable items (using the correct pattern for callbacks)
+        self.get_item(OperationMode.STATE_OFF_OP).ext_wrt_cb = self.set_state_off_op
+        self.get_item(OperationMode.STATE_OP_OP).ext_wrt_cb = self.set_state_op_op
+        self.get_item(OperationMode.STATE_AUT_OP).ext_wrt_cb = self.set_state_aut_op
+
+        self.get_item(OperationMode.STATE_OP_AUT).int_wrt_cb = self.set_state_op_aut
+        self.get_item(OperationMode.STATE_OFF_AUT).int_wrt_cb = self.set_state_off_aut
+        self.get_item(OperationMode.STATE_AUT_AUT).int_wrt_cb = self.set_state_aut_aut
+
+    def allow_switch_to_offline_mode(self, allow_flag: bool) -> None:
+        self.switch_to_offline_mode_allowed = allow_flag
+
+    def add_enter_offline_callback(self, callback: Callable[[], None]) -> None:
+        self.enter_offline_callbacks.append(callback)
+
+    def add_exit_offline_callback(self, callback: Callable[[], None]) -> None:
+        self.exit_offline_callbacks.append(callback)
+
+    def add_enter_operator_callback(self, callback: Callable[[], None]) -> None:
+        self.enter_operator_callbacks.append(callback)
+
+    def add_exit_operator_callback(self, callback: Callable[[], None]) -> None:
+        self.exit_operator_callbacks.append(callback)
+
+    def add_enter_automatic_callback(self, callback: Callable[[], None]) -> None:
+        self.enter_automatic_callbacks.append(callback)
+
+    def add_exit_automatic_callback(self, callback: Callable[[], None]) -> None:
+        self.exit_automatic_callbacks.append(callback)
+
+    def _enter_off(self) -> None:
+        if len(self.enter_offline_callbacks):
+            logger.debug("Applying enter offline mode callbacks")
+            [cb() for cb in self.enter_offline_callbacks]
+
+    def _exit_off(self) -> None:
+        if len(self.exit_offline_callbacks):
+            logger.debug("Applying exit offline mode callbacks")
+            [cb() for cb in self.exit_offline_callbacks]
+
+    def _enter_op(self) -> None:
+        if len(self.enter_operator_callbacks):
+            logger.debug("Applying enter operator mode callbacks")
+            [cb() for cb in self.enter_operator_callbacks]
+
+    def _exit_op(self) -> None:
+        if len(self.exit_operator_callbacks):
+            logger.debug("Applying exit operator mode callbacks")
+            [cb() for cb in self.exit_operator_callbacks]
+
+    def _enter_aut(self) -> None:
+        if len(self.enter_automatic_callbacks):
+            logger.debug("Applying enter automatic mode callbacks")
+            [cb() for cb in self.enter_automatic_callbacks]
+
+    def _exit_aut(self) -> None:
+        if len(self.exit_automatic_callbacks):
+            logger.debug("Applying exit automatic mode callbacks")
+            [cb() for cb in self.exit_automatic_callbacks]
+
+    def _opmode_to_off(self) -> None:
+        current_mode_is_op = self[OperationMode.STATE_OP_ACT]
+
+        # Mode change callbacks
+        if current_mode_is_op:
+            self[OperationMode.STATE_OFF_ACT] = True
+            self[OperationMode.STATE_OP_ACT] = False
+            self[OperationMode.STATE_AUT_ACT] = False
+            self._exit_op()
+            self._enter_off()
+            logger.debug("Operation mode is now off")
+
+    def _opmode_to_aut(self) -> None:
+        current_mode_is_op = self[OperationMode.STATE_OP_ACT]
+
+        # Mode change callbacks
+        if current_mode_is_op:
+            self[OperationMode.STATE_OFF_ACT] = False
+            self[OperationMode.STATE_OP_ACT] = False
+            self[OperationMode.STATE_AUT_ACT] = True
+            self._exit_op()
+            self._enter_aut()
+            logger.debug("Operation mode is now aut")
+
+    def _opmode_to_op(self) -> None:
+        current_mode_is_off = self[OperationMode.STATE_OFF_ACT]
+        current_mode_is_aut = self[OperationMode.STATE_AUT_ACT]
+
+        # Mode change callbacks
+        if current_mode_is_off or current_mode_is_aut:
+            if current_mode_is_off:
+                self._exit_off()
+            elif current_mode_is_aut:
+                self._exit_aut()
+            self[OperationMode.STATE_OFF_ACT] = False
+            self[OperationMode.STATE_OP_ACT] = True
+            self[OperationMode.STATE_AUT_ACT] = False
+            self._enter_op()
+            logger.debug("Operation mode is now op")
+
+    def set_state_channel(self, value: bool) -> None:
+        logger.debug(f"OperationMode StateChannel is now {value}")
+        self[OperationMode.STATE_CHANNEL] = value
+
+    def set_state_aut_aut(self, value: bool) -> None:
+        logger.debug(f"StateAutAut set to {value}")
+        if self[OperationMode.STATE_CHANNEL] and value:
+            if self[OperationMode.STATE_OP_ACT]:
+                self._opmode_to_aut()
+
+    def set_state_aut_op(self, value: bool) -> None:
+        logger.debug(f"StateAutOp set to {value}")
+        if not self[OperationMode.STATE_CHANNEL] and value:
+            if self[OperationMode.STATE_OP_ACT]:
+                self._opmode_to_aut()
+        # handshake
+        self[OperationMode.STATE_AUT_OP] = False
+
+    def set_state_off_aut(self, value: bool) -> None:
+        logger.debug(f"StateOffAut set to {value}")
+        if (
+            self[OperationMode.STATE_CHANNEL]
+            and value
+            and self.switch_to_offline_mode_allowed
+        ):
+            if self[OperationMode.STATE_OP_ACT]:
+                self._opmode_to_off()
+
+    def set_state_off_op(self, value: bool) -> None:
+        logger.debug(f"StateOffOp set to {value}")
+        if (
+            not self[OperationMode.STATE_CHANNEL]
+            and value
+            and self.switch_to_offline_mode_allowed
+        ):
+            if self[OperationMode.STATE_OP_ACT]:
+                self._opmode_to_off()
+        # handshake
+        self[OperationMode.STATE_OFF_OP] = False
+
+    def set_state_op_aut(self, value: bool) -> None:
+        logger.debug(f"StateOpAut set to {value}")
+        if self[OperationMode.STATE_CHANNEL] and value:
+            if self[OperationMode.STATE_OFF_ACT] or self[OperationMode.STATE_AUT_ACT]:
+                self._opmode_to_op()
+
+    def set_state_op_op(self, value: bool) -> None:
+        logger.debug(f"StateOpOp set to {value}")
+        if not self[OperationMode.STATE_CHANNEL] and value:
+            if self[OperationMode.STATE_OFF_ACT] or self[OperationMode.STATE_AUT_ACT]:
+                self._opmode_to_op()
+        # handshake
+        self[OperationMode.STATE_OP_OP] = False

mtppy/part3/data_assembly_set/base_functions/operation_mode_test.py

@@ -0,0 +1,260 @@
+"""Test Suite for OperationMode."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+import pytest
+
+from mtppy.part3.data_assembly_set.base_functions.operation_mode import OperationMode
+
+
+def init_op_mode(
+    init_mode: str = "off",
+    state_channel: bool = False,
+    allow_switch_to_offline: bool = True,
+):
+
+    op_mode = OperationMode()
+    op_mode.allow_switch_to_offline_mode(allow_switch_to_offline)
+    op_mode.set_state_channel(state_channel)
+
+    if init_mode == "off":
+        op_mode[OperationMode.STATE_AUT_ACT] = False
+        op_mode[OperationMode.STATE_OFF_ACT] = True
+        op_mode[OperationMode.STATE_OP_ACT] = False
+    elif init_mode == "op":
+        op_mode[OperationMode.STATE_AUT_ACT] = False
+        op_mode[OperationMode.STATE_OFF_ACT] = False
+        op_mode[OperationMode.STATE_OP_ACT] = True
+    elif init_mode == "aut":
+        op_mode[OperationMode.STATE_AUT_ACT] = True
+        op_mode[OperationMode.STATE_OFF_ACT] = False
+        op_mode[OperationMode.STATE_OP_ACT] = False
+    else:
+        raise ValueError(f"Operation mode {init_mode} is unknown")
+
+    return op_mode
+
+
+def operation_mode_is_in_specific_mode(
+    op_mode: OperationMode, state_channel_assertion: bool, mode_assertion: str
+):
+    return all(
+        [
+            op_mode[OperationMode.STATE_CHANNEL] == state_channel_assertion,
+            op_mode[OperationMode.STATE_OFF_AUT] == False,
+            op_mode[OperationMode.STATE_OP_AUT] == False,
+            op_mode[OperationMode.STATE_AUT_AUT] == False,
+            op_mode[OperationMode.STATE_OFF_OP] == False,
+            op_mode[OperationMode.STATE_OP_OP] == False,
+            op_mode[OperationMode.STATE_AUT_OP] == False,
+            op_mode[OperationMode.STATE_OP_ACT] == (mode_assertion == "op"),
+            op_mode[OperationMode.STATE_AUT_ACT] == (mode_assertion == "aut"),
+            op_mode[OperationMode.STATE_OFF_ACT] == (mode_assertion == "off"),
+        ]
+    )
+
+
+def test_initial_state():
+    op_mode = init_op_mode(init_mode="off", state_channel=False)
+    assert operation_mode_is_in_specific_mode(op_mode, False, "off") == True
+
+
+def test_state_channel_change():
+    op_mode = init_op_mode()
+    op_mode.StateChannel = True
+    assert op_mode["StateChannel"] == True
+    op_mode.StateChannel = False
+    assert op_mode["StateChannel"] == False
+    assert operation_mode_is_in_specific_mode(op_mode, False, "off") == True
+
+
+def test_off_to_op_state_channel_false():
+    # Initial mode
+    op_mode = init_op_mode(init_mode="off", state_channel=False)
+    assert operation_mode_is_in_specific_mode(op_mode, False, "off") == True
+    # Emulate mode transition by external writer
+    op_mode.get_item(OperationMode.STATE_OP_OP).ext_wrt_cb(True)
+    assert operation_mode_is_in_specific_mode(op_mode, False, "op") == True
+
+
+def test_off_to_op_state_channel_true():
+    # Initial mode
+    op_mode = init_op_mode(init_mode="off", state_channel=True)
+    assert operation_mode_is_in_specific_mode(op_mode, True, "off") == True
+    # Trigger mode transition
+    op_mode.StateOpAut = True
+    assert operation_mode_is_in_specific_mode(op_mode, True, "op") == True
+
+
+def test_op_to_off_state_channel_false():
+    # Initial mode
+    op_mode = init_op_mode(init_mode="op", state_channel=False)
+    assert operation_mode_is_in_specific_mode(op_mode, False, "op") == True
+    # Trigger mode transition
+    op_mode.get_item(OperationMode.STATE_OFF_OP).ext_wrt_cb(True)
+    assert operation_mode_is_in_specific_mode(op_mode, False, "off") == True
+
+
+def test_op_to_off_state_channel_true():
+    # Initial mode
+    op_mode = init_op_mode(init_mode="op", state_channel=True)
+    assert operation_mode_is_in_specific_mode(op_mode, True, "op") == True
+    # Trigger mode transition
+    op_mode.StateOffAut = True
+    assert operation_mode_is_in_specific_mode(op_mode, True, "off") == True
+
+
+def test_off_to_aut_state_channel_false():
+    # Initial mode
+    op_mode = init_op_mode(init_mode="off", state_channel=False)
+    assert operation_mode_is_in_specific_mode(op_mode, False, "off") == True
+    # Trigger invalid mode transition --> no change expected
+    op_mode.get_item(OperationMode.STATE_AUT_OP).ext_wrt_cb(True)
+    assert operation_mode_is_in_specific_mode(op_mode, False, "off") == True
+
+
+def test_off_to_aut_state_channel_true():
+    # Initial mode
+    op_mode = init_op_mode(init_mode="off", state_channel=True)
+    assert operation_mode_is_in_specific_mode(op_mode, True, "off") == True
+    # Trigger invalid mode transition --> no change expected
+    op_mode.StateAutAut = True
+    assert operation_mode_is_in_specific_mode(op_mode, True, "off") == True
+
+
+def test_aut_to_off_state_channel_false():
+    # Initial mode
+    op_mode = init_op_mode(init_mode="aut", state_channel=False)
+    assert operation_mode_is_in_specific_mode(op_mode, False, "aut") == True
+    # Trigger invalid mode transition --> no change expected
+    op_mode.get_item(OperationMode.STATE_OFF_OP).ext_wrt_cb(True)
+    assert operation_mode_is_in_specific_mode(op_mode, False, "aut") == True
+
+
+def test_aut_to_off_state_channel_true():
+    # Initial mode
+    op_mode = init_op_mode(init_mode="aut", state_channel=True)
+    assert operation_mode_is_in_specific_mode(op_mode, True, "aut") == True
+    # Trigger invalid mode transition --> no change expected
+    op_mode.StateOffAut = True
+    assert operation_mode_is_in_specific_mode(op_mode, True, "aut") == True
+
+
+def test_aut_to_op_state_channel_false():
+    # Initial mode
+    op_mode = init_op_mode(init_mode="aut", state_channel=False)
+    assert operation_mode_is_in_specific_mode(op_mode, False, "aut") == True
+    # Trigger mode transition
+    op_mode.get_item(OperationMode.STATE_OP_OP).ext_wrt_cb(True)
+    assert operation_mode_is_in_specific_mode(op_mode, False, "op") == True
+
+
+def test_aut_to_op_state_channel_true():
+    # Initial mode
+    op_mode = init_op_mode(init_mode="aut", state_channel=True)
+    assert operation_mode_is_in_specific_mode(op_mode, True, "aut") == True
+    # Trigger mode transition
+    op_mode.StateOpAut = True
+    assert operation_mode_is_in_specific_mode(op_mode, True, "op") == True
+
+
+def test_op_to_aut_state_channel_false():
+    # Initial mode
+    op_mode = init_op_mode(init_mode="op", state_channel=False)
+    assert operation_mode_is_in_specific_mode(op_mode, False, "op") == True
+    # Trigger mode transition
+    op_mode.get_item(OperationMode.STATE_AUT_OP).ext_wrt_cb(True)
+    assert operation_mode_is_in_specific_mode(op_mode, False, "aut") == True
+
+
+def test_op_to_aut_state_channel_true():
+    # Initial mode
+    op_mode = init_op_mode(init_mode="op", state_channel=True)
+    assert operation_mode_is_in_specific_mode(op_mode, True, "op") == True
+    # Trigger mode transition
+    op_mode.StateAutAut = True
+    assert operation_mode_is_in_specific_mode(op_mode, True, "aut") == True
+
+
+def test_allowance_change_op_to_off_state_channel_false():
+    # Initial mode
+    op_mode = init_op_mode(
+        init_mode="op", state_channel=False, allow_switch_to_offline=False
+    )
+    assert operation_mode_is_in_specific_mode(op_mode, False, "op") == True
+    # Trigger mode transition
+    op_mode.get_item(OperationMode.STATE_OFF_OP).ext_wrt_cb(True)
+    assert operation_mode_is_in_specific_mode(op_mode, False, "op") == True
+
+
+def test_blocked_change_op_to_off_state_channel_true():
+    # Initial mode with offline switch blocked
+    op_mode = init_op_mode(
+        init_mode="op", state_channel=True, allow_switch_to_offline=False
+    )
+    assert operation_mode_is_in_specific_mode(op_mode, True, "op") == True
+    # Trigger valid mode transition
+    op_mode.get_item(OperationMode.STATE_OFF_AUT).int_wrt_cb(True)
+    assert operation_mode_is_in_specific_mode(op_mode, True, "op") == True
+
+
+def test_forbidden_change_aut_to_off_state_channel_true():
+    # Initial mode
+    op_mode = init_op_mode(
+        init_mode="aut", state_channel=True, allow_switch_to_offline=True
+    )
+    assert operation_mode_is_in_specific_mode(op_mode, True, "aut") == True
+    # Trigger invalid mode transition
+    op_mode.get_item(OperationMode.STATE_OFF_AUT).int_wrt_cb(True)
+    assert operation_mode_is_in_specific_mode(op_mode, True, "aut") == True
+
+
+def test_exit_offline_callback_off_to_op():
+    test_value = {"value": 0}
+
+    def callback_function():
+        test_value["value"] = 10
+
+    # Initial mode
+    op_mode = init_op_mode()
+    assert operation_mode_is_in_specific_mode(op_mode, False, "off") == True
+
+    # Simulate external write on StateOpOp
+    op_mode.get_item(OperationMode.STATE_OP_OP).ext_wrt_cb(True)
+    assert operation_mode_is_in_specific_mode(op_mode, False, "op") == True
+    assert test_value["value"] == 0
+
+    # Initial mode
+    op_mode = init_op_mode()
+    op_mode.add_exit_offline_callback(callback_function)
+    assert operation_mode_is_in_specific_mode(op_mode, False, "off") == True
+    # Trigger mode transition with registered callback
+    op_mode.get_item(OperationMode.STATE_OP_OP).ext_wrt_cb(True)
+    assert operation_mode_is_in_specific_mode(op_mode, False, "op") == True
+    assert test_value["value"] == 10
+
+
+@pytest.mark.parametrize(
+    "state_request",
+    [
+        OperationMode.STATE_OFF_OP,
+        OperationMode.STATE_OP_OP,
+        OperationMode.STATE_AUT_OP,
+    ],
+)
+def test_external_state_request_handshake(state_request: str) -> None:
+    op_mode = init_op_mode()
+
+    callback = op_mode.get_item(state_request).ext_wrt_cb
+    assert callback is not None
+    callback(True)
+
+    assert op_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/oslevel.py

@@ -0,0 +1,35 @@
+"""Implementation of the OS Level Base Function."""
+
+__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 OSLevelBaseFunction(DataItemCollection):
+    OS_LEVEL = "OSLevel"
+
+    CLASS_DATA_ITEMS: ClassVar = {
+        OS_LEVEL: DataItem(
+            OS_LEVEL,
+            W3cXmlDataTypes.UNSIGNED_SHORT,
+            MTPAccess.ReadWriteAccess,
+            init_value=0,
+        ),
+    }
+
+    def __init__(self) -> None:
+        """
+        Initialize the OSLevel BaseFunction.
+        """
+        super().__init__()
+        self.get_item(self.OS_LEVEL).ext_wrt_cb = self.set_os_level
+
+    def set_os_level(self, value) -> None:
+        self[OSLevelBaseFunction.OS_LEVEL] = value