MTPPy2.0 0.1.5__py3-none-any.whl

mtppy/part4/automation_services/service_elements/service_control.py

@@ -0,0 +1,473 @@
+"""Implementation of Service Control as specified in PNO MTP 2.0, Section x."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from collections.abc import Callable
+from typing import ClassVar
+
+from mtppy.utils.data_item import DataItem
+from mtppy.part3.definitions.mtp_access import MTPAccess
+from mtppy.part3.data_assembly_set.base_functions.oslevel import OSLevelBaseFunction
+from mtppy.part4.automation_services.base_functions.service_operation_mode import (
+    ServiceOperationMode,
+)
+from mtppy.part4.automation_services.base_functions.service_operator_interaction import (
+    ServiceOperatorInteraction,
+)
+from mtppy.part4.automation_services.base_functions.service_source_mode import (
+    ServiceSourceMode,
+)
+from mtppy.part4.automation_services.service_elements.service_element import (
+    ServiceElement,
+)
+from mtppy.part5.definitions.w3c_xml_data_types import W3cXmlDataTypes
+from mtppy.utils.logging import logger
+
+
+class ServiceControl(ServiceElement):
+    # DataItem constant definitions
+    COMMAND_EN = "CommandEn"
+    COMMAND_OP = "CommandOp"
+    COMMAND_INT = "CommandInt"
+    COMMAND_EXT = "CommandExt"
+    STATE_CUR = "StateCur"
+    PROCEDURE_OP = "ProcedureOp"
+    PROCEDURE_INT = "ProcedureInt"
+    PROCEDURE_EXT = "ProcedureExt"
+    PROCEDURE_CUR = "ProcedureCur"
+    PROCEDURE_REQ = "ProcedureReq"
+    PROC_PARAM_APPLY_EN = "ProcParamApplyEn"
+    PROC_PARAM_APPLY_EXT = "ProcParamApplyExt"
+    PROC_PARAM_APPLY_OP = "ProcParamApplyOp"
+    PROC_PARAM_APPLY_INT = "ProcParamApplyInt"
+    CONFIG_PARAM_APPLY_EN = "ConfigParamApplyEn"
+    CONFIG_PARAM_APPLY_EXT = "ConfigParamApplyExt"
+    CONFIG_PARAM_APPLY_OP = "ConfigParamApplyOp"
+    CONFIG_PARAM_APPLY_INT = "ConfigParamApplyInt"
+    REPORT_VALUE_FREEZE = "ReportValueFreeze"
+
+    # Class-level data items dictionary
+    CLASS_DATA_ITEMS: ClassVar = {
+        COMMAND_EN: DataItem(
+            COMMAND_EN,
+            W3cXmlDataTypes.UNSIGNED_SHORT,
+            MTPAccess.ReadAccess,
+            0,
+        ),
+        COMMAND_OP: DataItem(
+            COMMAND_OP,
+            W3cXmlDataTypes.UNSIGNED_SHORT,
+            MTPAccess.ReadWriteAccess,
+            0,
+        ),
+        COMMAND_INT: DataItem(
+            COMMAND_INT,
+            W3cXmlDataTypes.UNSIGNED_SHORT,
+            MTPAccess.ReadAccess,
+            0,
+        ),
+        COMMAND_EXT: DataItem(
+            COMMAND_EXT,
+            W3cXmlDataTypes.UNSIGNED_SHORT,
+            MTPAccess.ReadWriteAccess,
+            0,
+        ),
+        STATE_CUR: DataItem(
+            STATE_CUR,
+            W3cXmlDataTypes.UNSIGNED_SHORT,
+            MTPAccess.ReadAccess,
+            0,
+        ),
+        PROCEDURE_OP: DataItem(
+            PROCEDURE_OP,
+            W3cXmlDataTypes.UNSIGNED_SHORT,
+            MTPAccess.ReadWriteAccess,
+            0,
+        ),
+        PROCEDURE_INT: DataItem(
+            PROCEDURE_INT,
+            W3cXmlDataTypes.UNSIGNED_SHORT,
+            MTPAccess.ReadAccess,
+            0,
+        ),
+        PROCEDURE_EXT: DataItem(
+            PROCEDURE_EXT,
+            W3cXmlDataTypes.UNSIGNED_SHORT,
+            MTPAccess.ReadWriteAccess,
+            0,
+        ),
+        PROCEDURE_CUR: DataItem(
+            PROCEDURE_CUR,
+            W3cXmlDataTypes.UNSIGNED_SHORT,
+            MTPAccess.ReadAccess,
+            0,
+        ),
+        PROCEDURE_REQ: DataItem(
+            PROCEDURE_REQ,
+            W3cXmlDataTypes.UNSIGNED_SHORT,
+            MTPAccess.ReadAccess,
+            0,
+        ),
+        PROC_PARAM_APPLY_EN: DataItem(
+            PROC_PARAM_APPLY_EN,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            0,
+        ),
+        PROC_PARAM_APPLY_EXT: DataItem(
+            PROC_PARAM_APPLY_EXT,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadWriteAccess,
+            0,
+        ),
+        PROC_PARAM_APPLY_OP: DataItem(
+            PROC_PARAM_APPLY_OP,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadWriteAccess,
+            0,
+        ),
+        PROC_PARAM_APPLY_INT: DataItem(
+            PROC_PARAM_APPLY_INT,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            0,
+        ),
+        CONFIG_PARAM_APPLY_EN: DataItem(
+            CONFIG_PARAM_APPLY_EN,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            0,
+        ),
+        CONFIG_PARAM_APPLY_EXT: DataItem(
+            CONFIG_PARAM_APPLY_EXT,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadWriteAccess,
+            0,
+        ),
+        CONFIG_PARAM_APPLY_OP: DataItem(
+            CONFIG_PARAM_APPLY_OP,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadWriteAccess,
+            0,
+        ),
+        CONFIG_PARAM_APPLY_INT: DataItem(
+            CONFIG_PARAM_APPLY_INT,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            0,
+        ),
+        REPORT_VALUE_FREEZE: DataItem(
+            REPORT_VALUE_FREEZE,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadWriteAccess,
+            0,
+        ),
+    }
+
+    os_level: OSLevelBaseFunction
+    service_op_mode: ServiceOperationMode
+    service_src_mode: ServiceSourceMode
+    service_operator_interaction: ServiceOperatorInteraction
+    procedure_keys: list[int]
+    execution_procedure: Callable
+
+    def __init__(
+        self,
+        tag_name: str,
+        tag_description: str = "",
+        procedure_keys: list[int] | None = None,
+        execution_procedure: Callable | None = None,
+    ):
+        super().__init__(tag_name, tag_description)
+        self.mtpObjectType = (
+            "MTPDataAssemblySUCLib/DataAssembly/ServiceElement/ServiceControl"
+        )
+
+        self.os_level = OSLevelBaseFunction()
+        self.service_op_mode = ServiceOperationMode()
+        self.service_src_mode = ServiceSourceMode()
+        self.service_operator_interaction = ServiceOperatorInteraction()
+
+        self.procedure_keys: list[int] = (
+            procedure_keys if procedure_keys is not None else []
+        )
+
+        # Initialize data items with dynamic values (using class-defined data items)
+        self.get_item(ServiceControl.COMMAND_OP).init_value = 0
+        self.get_item(ServiceControl.COMMAND_EXT).init_value = 0
+        self.get_item(ServiceControl.PROCEDURE_OP).init_value = 0
+        self.get_item(ServiceControl.PROCEDURE_EXT).init_value = 0
+        self.get_item(ServiceControl.PROC_PARAM_APPLY_EXT).init_value = 0
+        self.get_item(ServiceControl.PROC_PARAM_APPLY_OP).init_value = 0
+        self.get_item(ServiceControl.CONFIG_PARAM_APPLY_EXT).init_value = 0
+        self.get_item(ServiceControl.CONFIG_PARAM_APPLY_OP).init_value = 0
+        self.get_item(ServiceControl.REPORT_VALUE_FREEZE).init_value = 0
+
+        self.get_item(ServiceControl.COMMAND_OP).ext_wrt_cb = self.set_command_op
+        self.get_item(ServiceControl.COMMAND_EXT).ext_wrt_cb = self.set_command_ext
+        self.get_item(ServiceControl.PROCEDURE_OP).ext_wrt_cb = self.set_procedure_op
+        self.get_item(ServiceControl.PROCEDURE_EXT).ext_wrt_cb = self.set_procedure_ext
+        self.get_item(ServiceControl.PROC_PARAM_APPLY_EXT).ext_wrt_cb = (
+            self.set_proc_param_apply_ext
+        )
+        self.get_item(ServiceControl.PROC_PARAM_APPLY_OP).ext_wrt_cb = (
+            self.set_proc_param_apply_op
+        )
+        self.get_item(ServiceControl.CONFIG_PARAM_APPLY_EXT).ext_wrt_cb = (
+            self.set_config_param_apply_ext
+        )
+        self.get_item(ServiceControl.CONFIG_PARAM_APPLY_OP).ext_wrt_cb = (
+            self.set_config_param_apply_op
+        )
+        self.get_item(ServiceControl.REPORT_VALUE_FREEZE).ext_wrt_cb = (
+            self.set_report_value_freeze
+        )
+
+        self.execution_procedure = execution_procedure or self.dummy_procedure
+
+    def dummy_procedure(self, value: int) -> None:
+        """A dummy procedure for testing purposes.
+
+        Args:
+            value: Value to log during the dummy procedure call.
+        """
+        logger.debug(f"calling self.dummy_procedure with value {value}")
+
+    def add_procedure_key(self, value: int) -> None:
+        """Add a procedure key to the list of valid keys.
+
+        Args:
+            value: The procedure key to add.
+
+        """
+        if value != 0 and value not in self.procedure_keys:
+            self.procedure_keys.append(value)
+
+    def remove_procedure_key(self, value: int) -> None:
+        """Remove a procedure key from the list of valid keys.
+
+        Args:
+            value: The procedure key to remove.
+
+        """
+        if value != 0 and value in self.procedure_keys:
+            self.procedure_keys.remove(value)
+
+    def set_command_op(self, value: int) -> None:
+        """Set the operator command.
+
+        Args:
+            value: The value to set for the operator command.
+
+        """
+        logger.debug(f"call {self.execution_procedure} with value {value}")
+        self.execution_procedure(value)
+        # Handshake
+        self[ServiceControl.COMMAND_OP] = 0
+        # self.get_item(ServiceControl.COMMAND_OP)._value = 0
+        # self.get_item(ServiceControl.COMMAND_OP)._notify_external_subscribers()
+
+    def set_command_ext(self, value: int) -> None:
+        """Set the external command.
+
+        Args:
+            value: The value to set for the external command.
+
+        """
+        # self[ServiceControl.COMMAND_EXT] = value
+        self.execution_procedure(value)
+        self[ServiceControl.COMMAND_EXT] = 0
+
+    def set_command_int(self, value: int) -> None:
+        """Set the internal command.
+
+        Args:
+            value: The value to set for the internal command.
+
+        """
+        self[ServiceControl.COMMAND_INT] = value
+
+    def set_proc_param_apply_en(self, value: bool) -> None:
+        """Set the procedure parameter apply enable.
+
+        Args:
+            value: The boolean value to set for the procedure parameter apply enable.
+
+        """
+        self[ServiceControl.PROC_PARAM_APPLY_EN] = value
+
+    def set_proc_param_apply_ext(self, value: bool) -> None:
+        """Set the external procedure parameter apply signal.
+
+        Args:
+            value: The boolean value to set for the external procedure parameter apply.
+
+        """
+        self[ServiceControl.PROC_PARAM_APPLY_EXT] = value
+
+    def set_proc_param_apply_op(self, value: bool) -> None:
+        """Set the operator procedure parameter apply signal.
+
+        Args:
+            value: The boolean value to set for the operator procedure parameter apply.
+
+        """
+        self[ServiceControl.PROC_PARAM_APPLY_OP] = value
+
+    def set_proc_param_apply_int(self, value: bool) -> None:
+        """Set the internal procedure parameter apply signal.
+
+        Args:
+            value: The boolean value to set for the internal procedure parameter apply.
+
+        """
+        self[ServiceControl.PROC_PARAM_APPLY_INT] = value
+
+    def apply_proc_param(self) -> None:
+        """Apply procedure parameters if enabled."""
+        if self[ServiceControl.PROC_PARAM_APPLY_EN]:
+            # Get ProcCur, Resolve Procedure and fire callback to update Procedures
+            self[ServiceControl.CONFIG_PARAM_APPLY_EXT] = False
+            self[ServiceControl.CONFIG_PARAM_APPLY_INT] = False
+            self[ServiceControl.CONFIG_PARAM_APPLY_OP] = False
+
+    def set_config_param_apply_en(self, value: bool) -> None:
+        """Set the configuration parameter apply enable.
+
+        Args:
+            value: The boolean value to set for the configuration parameter apply enable.
+
+        """
+        self[ServiceControl.CONFIG_PARAM_APPLY_EN] = value
+
+    def set_config_param_apply_ext(self, value: bool) -> None:
+        """Set the external configuration parameter apply signal.
+
+        Args:
+            value: The boolean value to set for the external configuration parameter apply.
+
+        """
+        self[ServiceControl.CONFIG_PARAM_APPLY_EXT] = value
+
+    def set_config_param_apply_op(self, value: bool) -> None:
+        """Set the operator configuration parameter apply signal.
+
+        Args:
+            value: The boolean value to set for the operator configuration parameter apply.
+
+        """
+        self[ServiceControl.CONFIG_PARAM_APPLY_OP] = value
+
+    def set_config_param_apply_int(self, value: bool) -> None:
+        """Set the internal configuration parameter apply signal.
+
+        Args:
+            value: The boolean value to set for the internal configuration parameter apply.
+
+        """
+        self[ServiceControl.CONFIG_PARAM_APPLY_INT] = value
+
+    def apply_config_param(self) -> None:
+        """Apply configuration parameters if enabled."""
+        if self[ServiceControl.CONFIG_PARAM_APPLY_EN]:
+            # Get ProcCur, Resolve Procedure and fire callback to update Procedures
+            self[ServiceControl.CONFIG_PARAM_APPLY_EXT] = False
+            self[ServiceControl.CONFIG_PARAM_APPLY_INT] = False
+            self[ServiceControl.CONFIG_PARAM_APPLY_OP] = False
+
+    def set_report_value_freeze(self, value: bool) -> None:
+        """Set the report value freeze control.
+
+        Args:
+            value: The boolean value to set for the report value freeze.
+
+        """
+        self[ServiceControl.REPORT_VALUE_FREEZE] = value
+
+    def set_procedure_op(self, value: int) -> None:
+        """Set the operator procedure.
+
+        Args:
+            value: The value to set for the operator procedure.
+
+        """
+        if self.service_op_mode[ServiceOperationMode.STATE_OP_ACT]:
+            self.set_procedure_req(value)
+        logger.info(
+            f"ProcedureOp arg={value}, actual={self[ServiceControl.PROCEDURE_OP]}",
+        )
+
+    def set_procedure_int(self, value: int) -> None:
+        """Set the internal procedure.
+
+        Args:
+            value: The value to set for the internal procedure.
+        """
+        logger.info(f"ProcedureInt set to {value}")
+        if (
+            self.service_op_mode[ServiceOperationMode.STATE_AUT_ACT]
+            and self.service_src_mode[ServiceSourceMode.SRC_INT_ACT]
+        ):
+            self.set_procedure_req(value)
+
+    def set_procedure_ext(self, value: int) -> None:
+        """Set the external procedure.
+
+        Args:
+            value: The value to set for the external procedure.
+        """
+        logger.info(f"ProcedureExt set to {value}")
+        if (
+            self.service_op_mode[ServiceOperationMode.STATE_AUT_ACT]
+            and self.service_src_mode[ServiceSourceMode.SRC_EXT_ACT]
+        ):
+            self.set_procedure_req(value)
+
+    def valid_value(self, value: int) -> bool:
+        """Check if a value is a valid procedure id
+
+        Args:
+            value: The value to check.
+
+        Returns:
+            True if value is in list of procedure keys, else False
+
+        """
+        return not (value not in self.procedure_keys and value != 0)
+
+    def set_procedure_req(self, value: int) -> None:
+        """Set the requested procedure if it is a valid procedure id,
+        else set the requested procedure parameter to 0 to indicate to
+        the POL that the request was invalid.
+
+        Args:
+            value: The value to set for the requested procedure.
+
+        """
+        if self.valid_value(value):
+            self[ServiceControl.PROCEDURE_REQ] = value
+        else:
+            self[ServiceControl.PROCEDURE_REQ] = 0
+        logger.info(f"args={value}, result={self[ServiceControl.PROCEDURE_REQ]}")
+
+    def set_procedure_cur(self) -> None:
+        """Set the current procedure based on the requested procedure."""
+        procedure_req = self[ServiceControl.PROCEDURE_REQ]
+        if self.valid_value(procedure_req):
+            self[ServiceControl.PROCEDURE_CUR] = procedure_req
+            # PNO MTP2.0 Part 4 requires resetting ProcedureOP and ProcedureExt (Section 8.2.4.4)
+            self[ServiceControl.PROCEDURE_OP] = 0
+            self[ServiceControl.PROCEDURE_EXT] = 0
+        logger.info(f"args={procedure_req}, result=self[ServiceControl.PROCEDURE_CUR]")
+
+    def get_procedure_cur(self) -> int:
+        """Get the current procedure value.
+
+        Returns:
+            The current procedure value.
+
+        """
+        return self[ServiceControl.PROCEDURE_CUR]

mtppy/part4/automation_services/service_elements/service_control_test.py

@@ -0,0 +1,150 @@
+"""test suite for service control."""
+
+__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 as SOM,
+)
+from mtppy.part4.automation_services.base_functions.service_source_mode import (
+    ServiceSourceMode as ssm,
+)
+from mtppy.part4.automation_services.service_elements.service_control import (
+    ServiceControl as sc,
+)
+
+
+def init_service_control(service_op_mode: str = "off", service_src_mode: str = "int"):
+
+    service_control = sc("Dummy", procedure_keys=[1, 2, 3, 4])
+
+    if service_op_mode == "off":
+        service_control.service_op_mode[SOM.STATE_OFF_ACT] = True
+        service_control.service_op_mode[SOM.STATE_OFF_AUT] = True
+        service_control.service_op_mode[SOM.STATE_OFF_OP] = True
+    elif service_op_mode == "op":
+        service_control.service_op_mode[SOM.STATE_AUT_ACT] = False
+        service_control.service_op_mode[SOM.STATE_OFF_ACT] = False
+        service_control.service_op_mode[SOM.STATE_OP_ACT] = True
+    elif service_op_mode == "aut":
+        service_control.service_op_mode[SOM.STATE_AUT_ACT] = True
+        service_control.service_op_mode[SOM.STATE_OFF_ACT] = False
+        service_control.service_op_mode[SOM.STATE_OP_ACT] = False
+    else:
+        raise ValueError(f"ServiceOperationMode {service_op_mode} is unknown")
+
+    if service_src_mode == "int":
+        service_control.service_src_mode[ssm.SRC_INT_ACT] = True
+    elif service_src_mode == "ext":
+        service_control.service_src_mode[ssm.SRC_EXT_ACT] = True
+    else:
+        raise ValueError(f"ServiceSourceMode {service_src_mode} is unknown")
+
+    return service_control
+
+
+def check_valid_states(service_control, set_function, change_allowed=False):
+    for proc_id in range(4):
+        set_function(proc_id)
+        if change_allowed:
+            assert service_control[sc.PROCEDURE_REQ] == proc_id
+        else:
+            assert service_control[sc.PROCEDURE_REQ] == 0
+
+
+def check_invalid_states(service_control, set_function):
+    set_function(0)
+    set_function(10)
+    assert service_control[sc.PROCEDURE_REQ] == 0
+
+
+@pytest.mark.parametrize(
+    "service_control_mode,change_allowed",
+    [
+        ("off", False),
+        ("op", True),
+        ("aut", False),
+    ],
+)
+def test_set_procedure_op(service_control_mode, change_allowed):
+    service_control = init_service_control(service_control_mode)
+    check_valid_states(
+        service_control, service_control.set_procedure_op, change_allowed=change_allowed
+    )
+    check_invalid_states(service_control, service_control.set_procedure_op)
+
+
+@pytest.mark.parametrize(
+    "service_op_mode,service_src_mode,change_allowed",
+    [
+        ("off", "ext", False),
+        ("off", "int", False),
+        ("op", "ext", False),
+        ("op", "int", False),
+        ("aut", "ext", False),
+        ("aut", "int", True),
+    ],
+)
+def test_set_procedure_int(service_op_mode, service_src_mode, change_allowed):
+    service_control = init_service_control(service_op_mode, service_src_mode)
+    check_valid_states(
+        service_control,
+        service_control.set_procedure_int,
+        change_allowed=change_allowed,
+    )
+    check_invalid_states(service_control, service_control.set_procedure_int)
+
+
+@pytest.mark.parametrize(
+    "service_op_mode,service_src_mode,change_allowed",
+    [
+        ("off", "ext", False),
+        ("off", "int", False),
+        ("op", "ext", False),
+        ("op", "int", False),
+        ("aut", "ext", True),
+        ("aut", "int", False),
+    ],
+)
+def test_set_procedure_ext(service_op_mode, service_src_mode, change_allowed):
+    service_control = init_service_control(service_op_mode, service_src_mode)
+    check_valid_states(
+        service_control,
+        service_control.set_procedure_ext,
+        change_allowed=change_allowed,
+    )
+    check_invalid_states(service_control, service_control.set_procedure_ext)
+
+
+def test_set_procedure_cur():
+    service_control = init_service_control("op")
+    for proc_id in range(4):
+        service_control.set_procedure_op(proc_id)
+        service_control.set_procedure_cur()
+        assert service_control[sc.PROCEDURE_CUR] == proc_id
+
+    service_control.set_procedure_op(0)
+    service_control.set_procedure_cur()
+    service_control.set_procedure_op(10)
+    service_control.set_procedure_cur()
+    assert service_control[sc.PROCEDURE_CUR] == 0
+
+
+@pytest.mark.parametrize("command", [sc.COMMAND_OP, sc.COMMAND_EXT])
+def test_command_handshake(command: str) -> None:
+    received_values: list[int] = []
+    service_control = sc(
+        "Dummy",
+        execution_procedure=received_values.append,
+    )
+
+    callback = service_control.get_item(command).ext_wrt_cb
+    assert callback is not None
+    callback(42)
+
+    assert received_values == [42]
+    assert service_control[command] == 0

mtppy/part4/automation_services/service_elements/service_element.py

@@ -0,0 +1,20 @@
+"""Base Class for Service 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 ServiceElement(DataAssembly):
+
+    wqc: WQCBaseFunction
+
+    def __init__(self, tag_name: str, tag_description: str):
+        super().__init__(tag_name, tag_description)
+        self.mtpObjectType = "MTPDataAssemblySUCLib/DataAssembly/ServiceElement"
+
+        self.wqc = WQCBaseFunction()