MTPPy2.0 0.1.5__py3-none-any.whl

mtppy/part4/automation_services/base_functions/service_operation_mode.py

@@ -0,0 +1,368 @@
+"""
+Implementation of ServiceOperationMode BaseFunction as specified in PNO MTP 2.0 Part 4, Sections 8.2.2.3
+
+The ServiceOperationMode BaseFunction is a concept that allows the service to select its operation mode
+based on the state of the service and the configuration parameters. It is used to determine whether
+the service should operate in offline, operator, or automatic mode.
+
+- Manual Operations:  Operator actions are conveyed via the `Op` variables,
+- Automatic Operation:  PEA-internal actions made visible via the `Aut` variables
+- Actual Operation:  The actual state of the service is reflected in the `Act` variables.
+
+"""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from collections.abc import Callable
+from typing import ClassVar
+
+import inspect
+
+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 ServiceOperationMode(DataItemCollection):
+    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_DATA_ITEMS: ClassVar = {
+        STATE_CHANNEL: DataItem(
+            STATE_CHANNEL,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            init_value=False,
+        ),
+        STATE_OFF_AUT: DataItem(
+            STATE_OFF_AUT,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            init_value=False,
+        ),
+        STATE_OP_AUT: DataItem(
+            STATE_OP_AUT,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            init_value=False,
+        ),
+        STATE_AUT_AUT: DataItem(
+            STATE_AUT_AUT,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            init_value=False,
+        ),
+        STATE_OFF_OP: DataItem(
+            STATE_OFF_OP,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadWriteAccess,
+            init_value=False,
+            # self.set_state_off_op,
+        ),
+        STATE_OP_OP: DataItem(
+            STATE_OP_OP,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadWriteAccess,
+            init_value=False,
+            # self.set_state_op_op,
+        ),
+        STATE_AUT_OP: DataItem(
+            STATE_AUT_OP,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadWriteAccess,
+            init_value=False,
+            # self.set_state_aut_op,
+        ),
+        STATE_OP_ACT: DataItem(
+            STATE_OP_ACT,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            init_value=False,
+        ),
+        STATE_AUT_ACT: DataItem(
+            STATE_AUT_ACT,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            init_value=False,
+        ),
+        STATE_OFF_ACT: DataItem(
+            STATE_OFF_ACT,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            init_value=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):
+        """
+        Represents the operation mode BaseFunction for service part.
+        """
+        super().__init__()
+
+        self.switch_to_offline_mode_allowed = False
+
+        self.enter_offline_callbacks = []
+        self.exit_offline_callbacks = []
+
+        self.enter_operator_callbacks = []
+        self.exit_operator_callbacks = []
+
+        self.enter_automatic_callbacks = []
+        self.exit_automatic_callbacks = []
+
+        self.get_item(ServiceOperationMode.STATE_OFF_OP).ext_wrt_cb = (
+            self.set_state_off_op
+        )
+        self.get_item(ServiceOperationMode.STATE_OP_OP).ext_wrt_cb = (
+            self.set_state_op_op
+        )
+        self.get_item(ServiceOperationMode.STATE_AUT_OP).ext_wrt_cb = (
+            self.set_state_aut_op
+        )
+        # check if this brings us back in call back hell!!
+        # self.get_item(ServiceOperationMode.STATE_AUT_OP).int_wrt_cb = (
+        #    self.set_state_aut_op
+        # )
+
+        self.get_item(ServiceOperationMode.STATE_OFF_AUT).int_wrt_cb = (
+            self.set_state_off_aut
+        )
+        self.get_item(ServiceOperationMode.STATE_OP_AUT).int_wrt_cb = (
+            self.set_state_op_aut
+        )
+        self.get_item(ServiceOperationMode.STATE_AUT_AUT).int_wrt_cb = (
+            self.set_state_aut_aut
+        )
+
+    def _get_callback_list_str(self, callbacks: list[Callable]) -> str:
+        return (
+            "["
+            + ", ".join(
+                f"{inspect.getmodule(cb).__name__}.{cb.__name__}" for cb in callbacks
+            )
+            + "]"
+        )
+
+    def allow_switch_to_offline_mode(self, allow_flag: bool):
+        self.switch_to_offline_mode_allowed = allow_flag
+
+    def add_enter_offline_callback(self, callback: Callable[[], None]):
+        self.enter_offline_callbacks.append(callback)
+
+    def add_exit_offline_callback(self, callback: Callable[[], None]):
+        self.exit_offline_callbacks.append(callback)
+
+    def add_enter_operator_callback(self, callback: Callable[[], None]):
+        self.enter_operator_callbacks.append(callback)
+
+    def add_exit_operator_callback(self, callback: Callable[[], None]):
+        self.exit_operator_callbacks.append(callback)
+
+    def add_enter_automatic_callback(self, callback: Callable[[], None]):
+        self.enter_automatic_callbacks.append(callback)
+
+    def add_exit_automatic_callback(self, callback: Callable[[], None]):
+        self.exit_automatic_callbacks.append(callback)
+
+    def _enter_off(self):
+        if len(self.enter_offline_callbacks):
+            logger.mtp("Applying enter offline mode callbacks")
+            [cb() for cb in self.enter_offline_callbacks]
+
+    def _exit_off(self):
+        if len(self.exit_offline_callbacks):
+            logger.mtp(
+                f"Applying exit offline mode callbacks {self._get_callback_list_str(self.exit_offline_callbacks)}"
+            )
+            [cb() for cb in self.exit_offline_callbacks]
+
+    def _enter_op(self):
+        if len(self.enter_operator_callbacks):
+            logger.mtp("Applying enter operator mode callbacks")
+            [cb() for cb in self.enter_operator_callbacks]
+
+    def _exit_op(self):
+        if len(self.exit_operator_callbacks):
+            logger.mtp("Applying exit operator mode callbacks")
+            [cb() for cb in self.exit_operator_callbacks]
+
+    def _enter_aut(self):
+        if len(self.enter_automatic_callbacks):
+            logger.mtp("Applying enter automatic mode callbacks")
+            [cb() for cb in self.enter_automatic_callbacks]
+
+    def _exit_aut(self):
+        if len(self.exit_automatic_callbacks):
+            logger.mtp("Applying exit automatic mode callbacks")
+            [cb() for cb in self.exit_automatic_callbacks]
+
+    def _opmode_to_off(self):
+        logger.debug(f"_opmode_to_off: args: -")
+
+        prev_mode_is_op = self[ServiceOperationMode.STATE_OP_ACT]
+        prev_mode_is_aut = self[ServiceOperationMode.STATE_AUT_ACT]
+
+        self[ServiceOperationMode.STATE_OP_ACT] = False
+        self[ServiceOperationMode.STATE_AUT_ACT] = False
+        self[ServiceOperationMode.STATE_OFF_ACT] = True
+
+        # Mode change callbacks
+        if prev_mode_is_op:
+            self._exit_op()
+        elif prev_mode_is_aut:
+            self._exit_aut()
+        self._enter_off()
+
+        logger.mtp("ServiceOperationMode is now off")
+
+    def _opmode_to_aut(self):
+        logger.debug(f"_opmode_to_aut: args: -")
+
+        prev_mode_is_off = self[ServiceOperationMode.STATE_OFF_ACT]
+        prev_mode_is_op = self[ServiceOperationMode.STATE_OP_ACT]
+
+        self[ServiceOperationMode.STATE_OP_ACT] = False
+        self[ServiceOperationMode.STATE_AUT_ACT] = True
+        self[ServiceOperationMode.STATE_OFF_ACT] = False
+
+        # Mode change callbacks
+        if prev_mode_is_off:
+            self._exit_off()
+        elif prev_mode_is_op:
+            self._exit_op()
+        self._enter_aut()
+
+        logger.mtp("ServiceOperationMode is now aut")
+
+    def _opmode_to_op(self):
+        logger.debug(f"_opmode_to_op: args: -")
+
+        prev_mode_is_off = self[ServiceOperationMode.STATE_OFF_ACT]
+        prev_mode_is_aut = self[ServiceOperationMode.STATE_AUT_ACT]
+
+        self[ServiceOperationMode.STATE_OP_ACT] = True
+        self[ServiceOperationMode.STATE_AUT_ACT] = False
+        self[ServiceOperationMode.STATE_OFF_ACT] = False
+
+        # Mode change callbacks
+        if prev_mode_is_off:
+            self._exit_off()
+        elif prev_mode_is_aut:
+            self._exit_aut()
+        self._enter_op()
+
+        logger.mtp(
+            f"ServiceOperationMode is now op, StateOpAct={self[ServiceOperationMode.STATE_OP_ACT]}"
+        )
+
+    def set_state_channel(self, value: bool):
+        logger.debug(f"set_state_channel: value={value}")
+
+        self[ServiceOperationMode.STATE_CHANNEL] = value
+
+        logger.info(
+            f"requested {value}, got {self[ServiceOperationMode.STATE_CHANNEL]}"
+        )
+
+    def set_state_aut_aut(self, value: bool):
+        logger.debug(f"value={value}")
+
+        if self[ServiceOperationMode.STATE_CHANNEL] and value:
+            if (
+                self[ServiceOperationMode.STATE_OFF_ACT]
+                or self[ServiceOperationMode.STATE_OP_ACT]
+            ):
+                self._opmode_to_aut()
+
+        logger.info(
+            f"requested {value}, got {self[ServiceOperationMode.STATE_AUT_AUT]}"
+        )
+
+    def set_state_aut_op(self, value: bool):
+        logger.debug(f"set_state_aut_op: value={value}")
+
+        if not self[ServiceOperationMode.STATE_CHANNEL] and value:
+            if (
+                self[ServiceOperationMode.STATE_OFF_ACT]
+                or self[ServiceOperationMode.STATE_OP_ACT]
+            ):
+                self._opmode_to_aut()
+        # handshake
+        self[ServiceOperationMode.STATE_AUT_OP] = False
+
+    def set_state_off_aut(self, value: bool):
+        logger.debug(f"set_state_off_aut: value={value}")
+
+        if (
+            self[ServiceOperationMode.STATE_CHANNEL]
+            and value
+            and self.switch_to_offline_mode_allowed
+        ):
+            if (
+                self[ServiceOperationMode.STATE_AUT_ACT]
+                or self[ServiceOperationMode.STATE_OP_ACT]
+            ):
+                self._opmode_to_off()
+
+        logger.info(
+            f"requested {value}, got {self[ServiceOperationMode.STATE_OFF_AUT]}"
+        )
+
+    def set_state_off_op(self, value: bool):
+        logger.debug(f"value={value}")
+
+        if (
+            value
+            and not self[ServiceOperationMode.STATE_CHANNEL]
+            and self.switch_to_offline_mode_allowed
+        ):
+            if (
+                self[ServiceOperationMode.STATE_AUT_ACT]
+                or self[ServiceOperationMode.STATE_OP_ACT]
+            ):
+                self._opmode_to_off()
+            self[ServiceOperationMode.STATE_OFF_OP] = False
+
+    def set_state_op_aut(self, value: bool):
+        logger.debug(f"set_state_op_aut: value={value}")
+
+        if self[ServiceOperationMode.STATE_CHANNEL] and value:
+            if (
+                self[ServiceOperationMode.STATE_OFF_ACT]
+                or self[ServiceOperationMode.STATE_AUT_ACT]
+            ):
+                self._opmode_to_op()
+
+        logger.info(f"requested {value}, got {self[ServiceOperationMode.STATE_OP_AUT]}")
+
+    def set_state_op_op(self, value: bool):
+        logger.debug(f"set_state_op_op: value={value}")
+
+        if not self[ServiceOperationMode.STATE_CHANNEL] and value:
+            if (
+                self[ServiceOperationMode.STATE_OFF_ACT]  # offline
+                or self[ServiceOperationMode.STATE_AUT_ACT]  # automatic
+            ):
+                self._opmode_to_op()
+        self[ServiceOperationMode.STATE_OP_OP] = False

mtppy/part4/automation_services/base_functions/service_operation_mode_test.py

@@ -0,0 +1,242 @@
+"""Test Suite for ServiceOperationMode."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+import pytest
+from mtppy.part4.automation_services.base_functions.service_operation_mode import ServiceOperationMode
+
+
+def init_service_op_mode(
+    init_mode="off", state_channel=False, allow_switch_to_offline=True
+):
+    service_op_mode = ServiceOperationMode()
+    service_op_mode.allow_switch_to_offline_mode(allow_switch_to_offline)
+    service_op_mode.set_state_channel(state_channel)
+
+    # MTP Part 4 Figure 2
+    if init_mode == "off":
+        service_op_mode[ServiceOperationMode.STATE_OFF_ACT] = True
+        service_op_mode[ServiceOperationMode.STATE_OP_ACT] = False
+        service_op_mode[ServiceOperationMode.STATE_AUT_ACT] = False
+    elif init_mode == "op":
+        service_op_mode[ServiceOperationMode.STATE_OFF_ACT] = False
+        service_op_mode[ServiceOperationMode.STATE_OP_ACT] = True
+        service_op_mode[ServiceOperationMode.STATE_AUT_ACT] = False
+    elif init_mode == "aut":
+        service_op_mode[ServiceOperationMode.STATE_OFF_ACT] = False
+        service_op_mode[ServiceOperationMode.STATE_OP_ACT] = False
+        service_op_mode[ServiceOperationMode.STATE_AUT_ACT] = True
+    else:
+        raise ValueError(f"ServiceOperationMode {init_mode} is unknown")
+
+    return service_op_mode
+
+
+def service_operation_mode_is_in_specific_mode(
+    service_op_mode: ServiceOperationMode,
+    state_channel_assertion: bool,
+    mode_assertion: str,
+):
+    mode = lambda m: (mode_assertion == m)
+    return all(
+        [
+            service_op_mode[ServiceOperationMode.STATE_CHANNEL]
+            == state_channel_assertion,
+            service_op_mode[ServiceOperationMode.STATE_OFF_AUT] == False,
+            service_op_mode[ServiceOperationMode.STATE_OP_AUT] == False,
+            service_op_mode[ServiceOperationMode.STATE_AUT_AUT] == False,
+            service_op_mode[ServiceOperationMode.STATE_OFF_OP] == False,
+            service_op_mode[ServiceOperationMode.STATE_OP_OP] == False,
+            service_op_mode[ServiceOperationMode.STATE_AUT_OP] == False,
+            service_op_mode[ServiceOperationMode.STATE_OP_ACT] == mode("op"),
+            service_op_mode[ServiceOperationMode.STATE_AUT_ACT] == mode("aut"),
+            service_op_mode[ServiceOperationMode.STATE_OFF_ACT] == mode("off"),
+        ]
+    )
+
+
+def assert_service_operation_mode_is_in_specific_mode(
+    service_op_mode: ServiceOperationMode,
+    state_channel_assertion: bool,
+    mode_assertion: str,
+) -> None:
+    mode = lambda m: (mode_assertion == m)
+    assert (
+        service_op_mode[ServiceOperationMode.STATE_CHANNEL] == state_channel_assertion
+    )
+    assert service_op_mode[ServiceOperationMode.STATE_OP_ACT] == mode("op")
+    assert service_op_mode[ServiceOperationMode.STATE_AUT_ACT] == mode("aut")
+    assert service_op_mode[ServiceOperationMode.STATE_OFF_ACT] == mode("off")
+
+
+def test_initial_state():
+    service_op_mode = init_service_op_mode(init_mode="off", state_channel=False)
+    assert service_operation_mode_is_in_specific_mode(service_op_mode, False, "off")
+
+
+def test_state_channel_change():
+    # Initial mode
+    service_op_mode = init_service_op_mode()
+    # Trigger source channel change
+    service_op_mode["StateChannel"] = True
+    assert service_operation_mode_is_in_specific_mode(service_op_mode, True, "off")
+    # Trigger source channel change back
+    service_op_mode["StateChannel"] = False
+    assert service_operation_mode_is_in_specific_mode(service_op_mode, False, "off")
+
+
+@pytest.mark.parametrize(
+    "init_mode, target_mode, param_extern, param_intern",
+    [
+        (
+            "off",
+            "op",
+            ServiceOperationMode.STATE_OP_OP,
+            ServiceOperationMode.STATE_OP_AUT,
+        ),
+        (
+            "op",
+            "off",
+            ServiceOperationMode.STATE_OFF_OP,
+            ServiceOperationMode.STATE_OFF_AUT,
+        ),
+        (
+            "off",
+            "aut",
+            ServiceOperationMode.STATE_AUT_OP,
+            ServiceOperationMode.STATE_AUT_AUT,
+        ),
+        (
+            "aut",
+            "off",
+            ServiceOperationMode.STATE_OFF_OP,
+            ServiceOperationMode.STATE_OFF_AUT,
+        ),
+        (
+            "aut",
+            "op",
+            ServiceOperationMode.STATE_OP_OP,
+            ServiceOperationMode.STATE_OP_AUT,
+        ),
+        (
+            "op",
+            "aut",
+            ServiceOperationMode.STATE_AUT_OP,
+            ServiceOperationMode.STATE_AUT_AUT,
+        ),
+    ],
+)
+def test_switch_state(
+    init_mode: str,
+    target_mode: str,
+    param_extern: str,
+    param_intern: str,
+):
+    # Step 1 - request by operator (= external write), state_channel = False
+    sc = False
+    op_mode = init_service_op_mode(init_mode=init_mode, state_channel=sc)
+    assert_service_operation_mode_is_in_specific_mode(op_mode, sc, init_mode)
+    op_mode.get_item(param_extern).ext_wrt_cb(True)
+    assert_service_operation_mode_is_in_specific_mode(op_mode, sc, target_mode)
+
+    # Step 2 - request by automation (= internal write), state_channel = True
+    sc = True
+    op_mode = init_service_op_mode(init_mode=init_mode, state_channel=sc)
+    assert_service_operation_mode_is_in_specific_mode(op_mode, sc, init_mode)
+    op_mode[param_intern] = True
+    assert_service_operation_mode_is_in_specific_mode(op_mode, sc, target_mode)
+
+
+def test_allowance_change_op_to_off_state_channel_false():
+    # Initial mode
+    service_op_mode = init_service_op_mode(
+        init_mode="op", state_channel=False, allow_switch_to_offline=False
+    )
+    assert service_operation_mode_is_in_specific_mode(service_op_mode, False, "op")
+    # Trigger mode transition
+    service_op_mode.get_item(ServiceOperationMode.STATE_OFF_OP).ext_wrt_cb(True)
+    assert service_operation_mode_is_in_specific_mode(service_op_mode, False, "op")
+
+
+def test_allowance_change_op_to_off_state_channel_true():
+    # Initial mode
+    service_op_mode = init_service_op_mode(
+        init_mode="op", state_channel=True, allow_switch_to_offline=False
+    )
+    assert service_operation_mode_is_in_specific_mode(service_op_mode, True, "op")
+    # Trigger mode transition
+    service_op_mode[ServiceOperationMode.STATE_OFF_AUT] = True
+    assert service_operation_mode_is_in_specific_mode(service_op_mode, True, "op")
+
+
+def test_allowance_change_aut_to_off_state_channel_false():
+    # Initial mode
+    service_op_mode = init_service_op_mode(
+        init_mode="aut", state_channel=False, allow_switch_to_offline=False
+    )
+    assert service_operation_mode_is_in_specific_mode(service_op_mode, False, "aut")
+    # Trigger mode transition
+    service_op_mode.get_item(ServiceOperationMode.STATE_OFF_OP).ext_wrt_cb(True)
+    assert service_operation_mode_is_in_specific_mode(service_op_mode, False, "aut")
+
+
+def test_allowance_change_aut_to_off_state_channel_true():
+    # Initial mode
+    service_op_mode = init_service_op_mode(
+        init_mode="aut", state_channel=True, allow_switch_to_offline=False
+    )
+    assert service_operation_mode_is_in_specific_mode(service_op_mode, True, "aut")
+    # Trigger mode transition
+    service_op_mode.set_state_off_aut(True)
+    assert service_operation_mode_is_in_specific_mode(service_op_mode, True, "aut")
+
+
+def test_exit_offline_callback_off_to_op():
+    test_value = {"value": 0}
+
+    def callback_function():
+        test_value["value"] = 10
+
+    # Initial mode
+    service_op_mode = init_service_op_mode(init_mode="off")
+    assert service_operation_mode_is_in_specific_mode(service_op_mode, False, "off")
+    # Emulate external write on StateOpOp w/o exit callback
+    service_op_mode.get_item(ServiceOperationMode.STATE_OP_OP).ext_wrt_cb(True)
+    assert service_operation_mode_is_in_specific_mode(service_op_mode, False, "op")
+    assert test_value["value"] == 0
+
+    # Initial mode
+    service_op_mode = init_service_op_mode(init_mode="off")
+    assert service_operation_mode_is_in_specific_mode(service_op_mode, False, "off")
+    service_op_mode.add_exit_offline_callback(callback_function)
+    # Trigger mode transition with exit callback
+    service_op_mode.get_item(ServiceOperationMode.STATE_OP_OP).ext_wrt_cb(True)
+    assert service_operation_mode_is_in_specific_mode(service_op_mode, False, "op")
+    assert test_value["value"] == 10
+
+
+def test_exit_offline_callback_off_to_aut():
+    test_value = {"value": 0}
+
+    def callback_function():
+        test_value["value"] = 10
+
+    # Initial mode
+    service_op_mode = init_service_op_mode(init_mode="off")
+    assert service_operation_mode_is_in_specific_mode(service_op_mode, False, "off")
+    # Trigger mode transition without callback
+    service_op_mode.get_item(ServiceOperationMode.STATE_AUT_OP).ext_wrt_cb(True)
+    assert service_operation_mode_is_in_specific_mode(service_op_mode, False, "aut")
+    assert test_value["value"] == 0
+
+    # Initial mode
+    service_op_mode = init_service_op_mode(init_mode="off")
+    assert service_operation_mode_is_in_specific_mode(service_op_mode, False, "off")
+    service_op_mode.add_exit_offline_callback(callback_function)
+    # Trigger mode transition with callback
+    service_op_mode.get_item(ServiceOperationMode.STATE_AUT_OP).ext_wrt_cb(True)
+    assert service_operation_mode_is_in_specific_mode(service_op_mode, False, "aut")
+    assert test_value["value"] == 10

mtppy/part4/automation_services/base_functions/service_operator_interaction.py

@@ -0,0 +1,62 @@
+"""Implementation of ServiceOperatorInteraction."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+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
+from typing import ClassVar
+
+
+class ServiceOperatorInteraction(DataItemCollection):
+    # DataItem constant definitions
+    INTERACT_QUESTION_ID = "InteractQuestionID"
+    INTERACT_ANSWER_ID = "InteractAnswerID"
+    POS_TEXT_ID = "PosTextID"
+    INTERACT_ADD_INFO = "InteractAddInfo"
+
+    # Class-level data items dictionary
+    CLASS_DATA_ITEMS: ClassVar = {
+        INTERACT_QUESTION_ID: DataItem(
+            INTERACT_QUESTION_ID,
+            W3cXmlDataTypes.UNSIGNED_SHORT,
+            MTPAccess.ReadAccess,
+            0,
+        ),
+        INTERACT_ANSWER_ID: DataItem(
+            INTERACT_ANSWER_ID,
+            W3cXmlDataTypes.UNSIGNED_SHORT,
+            MTPAccess.ReadWriteAccess,
+            0,
+        ),
+        POS_TEXT_ID: DataItem(
+            POS_TEXT_ID, W3cXmlDataTypes.UNSIGNED_SHORT, MTPAccess.ReadAccess, 0
+        ),
+        INTERACT_ADD_INFO: DataItem(
+            INTERACT_ADD_INFO, W3cXmlDataTypes.STRING, MTPAccess.ReadAccess, ""
+        ),
+    }
+
+    def __init__(self):
+        """
+        Represents the service interactions BaseFunction for service part.
+        """
+        super().__init__()
+        # Initialize data items with dynamic values (using class-defined data items)
+        self[ServiceOperatorInteraction.INTERACT_QUESTION_ID] = 0
+        self[ServiceOperatorInteraction.INTERACT_ANSWER_ID] = 0
+        self[ServiceOperatorInteraction.POS_TEXT_ID] = 0
+        self[ServiceOperatorInteraction.INTERACT_ADD_INFO] = ""
+
+        # Set callbacks for writable items (using the correct pattern for callbacks)
+        self.get_item(ServiceOperatorInteraction.INTERACT_ANSWER_ID).ext_wrt_cb = (
+            self.set_interact_answer_id
+        )
+
+    def set_interact_answer_id(self, value):
+        self[ServiceOperatorInteraction.INTERACT_ANSWER_ID] = value
+
+    # A list of interactions shall be added and method such as "raise_service_interaction" added