MTPPy2.0 0.1.5__py3-none-any.whl

mtppy/part4/automation_services/service_test.py

@@ -0,0 +1,407 @@
+"""test suite for service."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+from unittest.mock import Mock
+
+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.procedure import Procedure
+from mtppy.part4.automation_services.service import Service, _has_zero_id
+from mtppy.part4.automation_services.service_elements.parameter_elements.parameter_element import (
+    ParameterElement,
+)
+from mtppy.part4.automation_services.service_elements.service_control import (
+    ServiceControl as SC,
+)
+
+
+class MockService(Service):
+    def idle(self):
+        pass
+
+    def starting(self):
+        pass
+
+    def execute(self):
+        pass
+
+    def completing(self):
+        pass
+
+    def completed(self):
+        pass
+
+    def pausing(self):
+        pass
+
+    def paused(self):
+        pass
+
+    def resuming(self):
+        pass
+
+    def holding(self):
+        pass
+
+    def held(self):
+        pass
+
+    def unholding(self):
+        pass
+
+    def stopping(self):
+        pass
+
+    def stopped(self):
+        pass
+
+    def aborting(self):
+        pass
+
+    def aborted(self):
+        pass
+
+    def resetting(self):
+        pass
+
+
+def init_service_with_procedures(service_op_mode="off", service_src_mode="int"):
+    service = MockService("mock", "my fancy mock service")
+
+    dummy_procedures = [
+        Procedure(1, "first"),
+        Procedure(2, "second"),
+        Procedure(3, "third"),
+        Procedure(4, "forth"),
+    ]
+
+    service.add_procedure(dummy_procedures)
+
+    if service_op_mode == "off":
+        service.service_control.service_op_mode[SOM.STATE_OFF_ACT] = True
+    elif service_op_mode == "op":
+        service.service_control.service_op_mode[SOM.STATE_OFF_ACT] = False
+        service.service_control.service_op_mode[SOM.STATE_OP_ACT] = True
+    elif service_op_mode == "aut":
+        service.service_control.service_op_mode[SOM.STATE_OFF_ACT] = False
+        service.service_control.service_op_mode[SOM.STATE_AUT_ACT] = True
+    else:
+        raise ValueError(f"ServiceOperationMode {service_op_mode} is unknown")
+
+    if service_src_mode == "int":
+        service.service_control.service_src_mode[SSM.SRC_INT_ACT] = True
+    elif service_src_mode == "ext":
+        service.service_control.service_src_mode[SSM.SRC_EXT_ACT] = True
+    else:
+        raise ValueError(f"ServiceSourceMode {service_src_mode} is unknown")
+
+    return service
+
+
+def test_service_initialization():
+    service = MockService("TestService", "Test Description")
+    assert service.name == "TestService"
+    assert service.service_control is not None
+    assert service.state_machine is not None
+
+
+def test_service_name_can_be_updated():
+    service = MockService("TestService")
+
+    service.name = "RenamedService"
+
+    assert service.name == "RenamedService"
+    assert service.tag_name == "RenamedService"
+
+
+def test_add_procedure_single():
+    service = MockService("TestService")
+    proc = Procedure(1, "Proc1")
+    service.add_procedure(proc)
+    assert 1 in service.procedures
+    assert service.procedures[1].name == "Proc1"
+
+
+def test_add_procedure_list():
+    service = MockService("TestService")
+    procs = [Procedure(1, "Proc1"), Procedure(2, "Proc2")]
+    service.add_procedure(procs)
+    assert 1 in service.procedures
+    assert 2 in service.procedures
+    assert len(service.procedures) == 2
+
+
+def test_add_procedure_dict_and_none_values():
+    service = MockService("TestService")
+    first = Procedure(1, "Proc1")
+    second = Procedure(2, "Proc2")
+
+    service.add_procedure({"first": first, "missing": None, "second": second})
+    service.add_procedure(None)
+
+    assert service.procedures == {1: first, 2: second}
+    assert service.service_control.procedure_keys == [1, 2]
+
+
+def test_create_procedure_invalid_id():
+    with pytest.raises(ValueError, match="ProcedureId must be bigger than 0"):
+        Procedure(0, "InvalidProc")
+
+
+def test_add_configuration_parameter():
+    service = MockService("TestService")
+    param = ParameterElement("Param1", "Desc1")
+    service.add_configuration_parameter(param)
+    assert "Param1" in service.configuration_parameters
+    assert service.configuration_parameters["Param1"] == param
+
+
+def test_apply_configuration_parameters(monkeypatch):
+    service = MockService("TestService")
+    param = ParameterElement("Param1", "Desc1")
+    update_calls = []
+    monkeypatch.setattr(param, "update_v_out", lambda: update_calls.append(param))
+    service.add_configuration_parameter(param)
+
+    service.apply_configuration_parameters()
+
+    assert update_calls == [param]
+
+
+def test_apply_procedure_parameters_for_current_procedure(monkeypatch):
+    service = MockService("TestService")
+    procedure = Procedure(1, "Proc1")
+    apply_calls = []
+    monkeypatch.setattr(
+        procedure,
+        "apply_procedure_parameters",
+        lambda: apply_calls.append(procedure),
+    )
+    service.add_procedure(procedure)
+    service.service_control[SC.PROCEDURE_CUR] = 1
+
+    service.apply_procedure_parameters()
+
+    assert apply_calls == [procedure]
+
+
+def test_current_procedure_lookup():
+    service = MockService("TestService")
+    procedure = Procedure(1, "Proc1")
+    service.add_procedure(procedure)
+    service.service_control[SC.PROCEDURE_CUR] = 1
+
+    assert service.get_current_procedure() is procedure
+    assert service._lookup_procedure_cur_name() == "Proc1"
+
+
+def test_lookup_procedure_name_without_current_procedure():
+    service = MockService("TestService")
+    service.service_control[SC.PROCEDURE_CUR] = 0
+
+    assert service._lookup_procedure_cur_name() == "undefined"
+
+
+def test_get_procedures_returns_service_procedures():
+    service = MockService("TestService")
+
+    assert service._get_procedures() is service.procedures
+
+
+def test_get_param_returns_current_procedure_parameter(monkeypatch):
+    service = MockService("TestService")
+    procedure = Mock()
+    parameter = Mock()
+    procedure.procedure_parameters = {"param1": parameter}
+    procedure.process_value_ins = {}
+    procedure.process_value_outs = {}
+    procedure.report_values = {}
+    procedure.required_equipment = {}
+    monkeypatch.setattr(service, "get_current_procedure", lambda: procedure)
+
+    assert service.get_param("param1") is parameter
+
+
+def test_get_param_returns_none_when_parameter_is_not_found(monkeypatch):
+    service = MockService("TestService")
+    procedure = Mock()
+    procedure.procedure_parameters = {}
+    procedure.process_value_ins = {}
+    procedure.process_value_outs = {}
+    procedure.report_values = {}
+    procedure.required_equipment = {}
+    monkeypatch.setattr(service, "get_current_procedure", lambda: procedure)
+
+    assert service.get_param("missing") is None
+
+
+def test_is_state_reallocates_when_state_does_not_match(monkeypatch):
+    service = MockService("TestService")
+    reallocate_calls = []
+    monkeypatch.setattr(
+        service.thread_ctrl,
+        "reallocate_running_thread",
+        lambda: reallocate_calls.append(True),
+    )
+
+    assert service.is_state("idle") is True
+    assert service.is_state("execute") is False
+    assert reallocate_calls == [True]
+
+
+def test_state_change_delegates_to_state_machine(monkeypatch):
+    service = MockService("TestService")
+    state_change_calls = []
+    monkeypatch.setattr(
+        service.state_machine,
+        "state_change",
+        lambda: state_change_calls.append(True),
+    )
+
+    service.state_change()
+
+    assert state_change_calls == [True]
+
+
+def test_get_current_procedure_none():
+    service = MockService("TestService")
+    service.service_control[SC.PROCEDURE_REQ] = 0
+    with pytest.raises(RuntimeError, match="No current procedure"):
+        service.get_current_procedure()
+
+
+def test_service_state_callback_returns_while_offline(monkeypatch):
+    service = MockService("TestService")
+    state_calls = []
+    monkeypatch.setattr(
+        service.state_machine,
+        "get_current_state_str",
+        lambda: state_calls.append(True) or "idle",
+    )
+    service.service_control.service_op_mode[SOM.STATE_OFF_ACT] = True
+
+    service._state_change_callback()
+
+    assert state_calls == []
+
+
+def test_service_state_callback_handles_undefined_state(monkeypatch):
+    service = MockService("TestService")
+    requested_states = []
+    monkeypatch.setattr(
+        service.state_machine,
+        "get_current_state_str",
+        lambda: "undefined",
+    )
+    monkeypatch.setattr(
+        service.service_control.service_op_mode,
+        "allow_switch_to_offline_mode",
+        lambda allow_flag: requested_states.append(allow_flag),
+    )
+    service.service_control.service_op_mode[SOM.STATE_OFF_ACT] = False
+
+    service._state_change_callback()
+
+    assert requested_states == [False]
+
+
+def test_service_state_callback_applies_starting_procedure_parameters(monkeypatch):
+    service = MockService("TestService")
+    procedure = Procedure(1, "Proc1")
+    service.add_procedure(procedure)
+    service.service_control[SC.PROCEDURE_CUR] = 1
+    apply_calls = []
+    thread_calls = []
+    monkeypatch.setattr(
+        service,
+        "apply_procedure_parameters",
+        lambda: apply_calls.append(True),
+    )
+    monkeypatch.setattr(
+        service.state_machine,
+        "get_current_state_str",
+        lambda: "starting",
+    )
+    monkeypatch.setattr(
+        service.thread_ctrl,
+        "request_state",
+        lambda state, callback: thread_calls.append((state, callback)),
+    )
+    monkeypatch.setattr(
+        service.thread_ctrl,
+        "reallocate_running_thread",
+        lambda: thread_calls.append("reallocate"),
+    )
+    monkeypatch.setattr(
+        service.service_control.service_op_mode,
+        "allow_switch_to_offline_mode",
+        lambda allow_flag: thread_calls.append(("offline", allow_flag)),
+    )
+    service.service_control.service_op_mode[SOM.STATE_OFF_ACT] = False
+
+    service._state_change_callback()
+
+    assert apply_calls == [True]
+    assert thread_calls[0][0] == "starting"
+    assert thread_calls[1] == "reallocate"
+    assert thread_calls[2] == ("offline", False)
+
+
+def test_service_state_callback_allows_offline_only_in_idle(monkeypatch):
+    service = MockService("TestService")
+    offline_requests = []
+    monkeypatch.setattr(
+        service.state_machine,
+        "get_current_state_str",
+        lambda: "idle",
+    )
+    monkeypatch.setattr(
+        service.thread_ctrl,
+        "request_state",
+        lambda state, callback: None,
+    )
+    monkeypatch.setattr(
+        service.thread_ctrl,
+        "reallocate_running_thread",
+        lambda: None,
+    )
+    monkeypatch.setattr(
+        service.service_control.service_op_mode,
+        "allow_switch_to_offline_mode",
+        lambda allow_flag: offline_requests.append(allow_flag),
+    )
+    service.service_control.service_op_mode[SOM.STATE_OFF_ACT] = False
+
+    service._state_change_callback()
+
+    assert offline_requests == [True]
+
+
+class ProcedureIdDouble:
+    def __init__(self, procedure_id):
+        self.procedure_id = procedure_id
+
+
+@pytest.mark.parametrize(
+    ("procedure", "expected"),
+    [
+        (None, False),
+        (ProcedureIdDouble(1), False),
+        (ProcedureIdDouble(0), True),
+        ([None, ProcedureIdDouble(1)], False),
+        ([None, ProcedureIdDouble(0)], True),
+        ({"missing": None, "valid": ProcedureIdDouble(1)}, False),
+        ({"missing": None, "zero": ProcedureIdDouble(0)}, True),
+    ],
+)
+def test_has_zero_id_supports_procedure_shapes(procedure, expected):
+    assert _has_zero_id(procedure) is expected

mtppy/part4/definitions/__init__.py

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

mtppy/part4/definitions/command_codes.py

@@ -0,0 +1,58 @@
+"""Definition of CommandCodes."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from enum import Enum
+
+
+class CommandCodes(Enum):
+    """
+    List of commands defined for MTP services
+    """
+
+    RESET = ("reset", 2)
+    START = ("start", 4)
+    STOP = ("stop", 8)
+    HOLD = ("hold", 16)
+    UNHOLD = ("unhold", 32)
+    PAUSE = ("pause", 64)
+    RESUME = ("resume", 128)
+    ABORT = ("abort", 256)
+    RESTART = ("restart", 512)
+    COMPLETE = ("complete", 1024)
+
+    def __init__(self, string: str, code: int):
+        self.string = string
+        self.code = code
+
+    @classmethod
+    def list_of_strings(cls) -> list[str]:
+        return [c.string for c in CommandCodes]
+
+    @classmethod
+    def list_of_codes(cls) -> list[int]:
+        return [c.code for c in CommandCodes]
+
+    @classmethod
+    def from_code(cls, code: int) -> str:
+        for member in cls:
+            if member.code == code:
+                return member.string
+        raise ValueError(f"Unknown command code: {code}")
+
+    @classmethod
+    def from_string(cls, string: str) -> int:
+        search_string = string.lower()
+        for member in cls:
+            if member.string == search_string:
+                return member.code
+        raise ValueError(f"Unknown command string: {string}")
+
+    def __str__(self):
+        return self.string
+
+    def __int__(self):
+        return self.code

mtppy/part4/definitions/command_codes_test.py

@@ -0,0 +1,44 @@
+"""Test suite for CommandCodes."""
+
+import pytest
+
+from mtppy.part4.definitions.command_codes import CommandCodes
+
+
+def test_command_metadata_and_conversions():
+    assert CommandCodes.START.string == "start"
+    assert CommandCodes.START.code == 4
+    assert str(CommandCodes.START) == "start"
+    assert int(CommandCodes.START) == 4
+
+
+def test_list_helpers_return_all_commands_in_enum_order():
+    assert CommandCodes.list_of_strings() == [member.string for member in CommandCodes]
+    assert CommandCodes.list_of_codes() == [member.code for member in CommandCodes]
+    assert len(CommandCodes.list_of_codes()) == len(CommandCodes)
+
+
+@pytest.mark.parametrize("code", [member.code for member in CommandCodes])
+def test_from_code_returns_command_string(code):
+    member = next(member for member in CommandCodes if member.code == code)
+
+    assert CommandCodes.from_code(code) == member.string
+
+
+@pytest.mark.parametrize("string", ["RESET", "Start", "complete"])
+def test_from_string_is_case_insensitive(string):
+    expected = next(
+        member.code for member in CommandCodes if member.string == string.lower()
+    )
+
+    assert CommandCodes.from_string(string) == expected
+
+
+def test_invalid_command_code_is_rejected():
+    with pytest.raises(ValueError, match="Unknown command code: 999"):
+        CommandCodes.from_code(999)
+
+
+def test_invalid_command_string_is_rejected():
+    with pytest.raises(ValueError, match="Unknown command string: launch"):
+        CommandCodes.from_string("launch")

mtppy/part4/definitions/state_codes.py

@@ -0,0 +1,65 @@
+"""Definition of StateCodes."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from enum import Enum
+
+
+class StateCodes(Enum):
+    """
+    List of states defined for MTP services
+    """
+
+    UNDEFINED = ("undefined", 0)
+    STOPPED = ("stopped", 4)
+    STARTING = ("starting", 8)
+    IDLE = ("idle", 16)
+    PAUSED = ("paused", 32)
+    EXECUTE = ("execute", 64)
+    STOPPING = ("stopping", 128)
+    ABORTING = ("aborting", 256)
+    ABORTED = ("aborted", 512)
+    HOLDING = ("holding", 1024)
+    HELD = ("held", 2048)
+    UNHOLDING = ("unholding", 4096)
+    PAUSING = ("pausing", 8192)
+    RESUMING = ("resuming", 16384)
+    RESETTING = ("resetting", 32678)
+    COMPLETING = ("completing", 65536)
+    COMPLETED = ("completed", 131072)
+
+    def __init__(self, string: str, code: int):
+        self.string = string
+        self.code = code
+
+    @classmethod
+    def list_of_strings(cls) -> list[str]:
+        return [c.string for c in StateCodes]
+
+    @classmethod
+    def list_of_codes(cls) -> list[int]:
+        return [c.code for c in StateCodes]
+
+    @classmethod
+    def from_code(cls, code: int) -> str:
+        for member in cls:
+            if member.code == code:
+                return member.string
+        raise ValueError(f"Unknown state: {code}")
+
+    @classmethod
+    def from_string(cls, string: str) -> int:
+        search_string = string.lower()
+        for member in cls:
+            if member.string == search_string:
+                return member.code
+        raise ValueError(f"Unknown state string: {string}")
+
+    def __str__(self):
+        return self.string
+
+    def __int__(self):
+        return self.code

mtppy/part4/definitions/state_codes_test.py

@@ -0,0 +1,44 @@
+"""Test suite for StateCodes."""
+
+import pytest
+
+from mtppy.part4.definitions.state_codes import StateCodes
+
+
+def test_state_metadata_and_conversions():
+    assert StateCodes.IDLE.string == "idle"
+    assert StateCodes.IDLE.code == 16
+    assert str(StateCodes.IDLE) == "idle"
+    assert int(StateCodes.IDLE) == 16
+
+
+def test_list_helpers_return_all_states_in_enum_order():
+    assert StateCodes.list_of_strings() == [member.string for member in StateCodes]
+    assert StateCodes.list_of_codes() == [member.code for member in StateCodes]
+    assert len(StateCodes.list_of_codes()) == len(StateCodes)
+
+
+@pytest.mark.parametrize("code", [member.code for member in StateCodes])
+def test_from_code_returns_state_string(code):
+    member = next(member for member in StateCodes if member.code == code)
+
+    assert StateCodes.from_code(code) == member.string
+
+
+@pytest.mark.parametrize("string", ["UNDEFINED", "Idle", "COMPLETED"])
+def test_from_string_is_case_insensitive(string):
+    expected = next(
+        member.code for member in StateCodes if member.string == string.lower()
+    )
+
+    assert StateCodes.from_string(string) == expected
+
+
+def test_invalid_state_code_is_rejected():
+    with pytest.raises(ValueError, match="Unknown state: 999"):
+        StateCodes.from_code(999)
+
+
+def test_invalid_state_string_is_rejected():
+    with pytest.raises(ValueError, match="Unknown state string: launch"):
+        StateCodes.from_string("launch")

mtppy/part4/process_values/__init__.py

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

mtppy/part4/process_values/base_functions/__init__.py

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

mtppy/part4/process_values/base_functions/vqc.py

@@ -0,0 +1,48 @@
+"""Implementation of the VQC Base Function."""
+
+__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.part3.definitions.mtp_access import MTPAccess
+from mtppy.part5.definitions.w3c_xml_data_types import W3cXmlDataTypes
+from mtppy.utils.data_item import DataItem, DataItemCollection
+
+
+class VQCBaseFunction(DataItemCollection):
+    """Provide the VQC process value base function.
+
+    This base function stores the VQC value and exposes it through a
+    read/write data item.
+    """
+
+    VQC_ = "VQC"
+
+    CLASS_DATA_ITEMS: ClassVar = {
+        VQC_: DataItem(
+            VQC_,
+            W3cXmlDataTypes.UNSIGNED_BYTE,
+            MTPAccess.ReadWriteAccess,
+            255,
+        ),
+    }
+
+    def __init__(self) -> None:
+        """Initialize the VQC BaseFunction.
+
+        Sets up the VQC data item with the appropriate write callback.
+        """
+        super().__init__()
+
+        self.get_item(VQCBaseFunction.VQC_).ext_wrt_cb = self._set_vqc
+
+    def _set_vqc(self, value: tc.ANY_TYPE) -> None:
+        self[VQCBaseFunction.VQC_] = value
+
+    def get_vqc(self) -> int:
+        """Return the current VQC value."""
+        return tc.cast_to_int(self[VQCBaseFunction.VQC_])

mtppy/part4/process_values/input_elements/__init__.py

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