MTPPy2.0 0.1.5__py3-none-any.whl

mtppy/part4/automation_services/helpers/state_machine_test.py

@@ -0,0 +1,294 @@
+"""Test Suite for StateMachine."""
+
+__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_test import (
+    service_operation_mode_is_in_specific_mode,
+)
+from mtppy.part4.automation_services.base_functions.service_source_mode_test import (
+    service_source_mode_is_in_specific_mode,
+)
+from mtppy.part4.automation_services.helpers.state_machine import StateMachine
+from mtppy.part4.definitions.state_codes import StateCodes
+from mtppy.part4.definitions.command_codes import CommandCodes
+from mtppy.part4.automation_services.service_elements.service_control import (
+    ServiceControl,
+)
+
+valid_commands = {
+    "stopped": {"reset": "resetting", "abort": "aborting"},
+    "starting": {
+        "complete": "completing",
+        "hold": "holding",
+        "stop": "stopping",
+        "abort": "aborting",
+    },
+    "idle": {"start": "starting", "stop": "stopping", "abort": "aborting"},
+    "paused": {
+        "resume": "resuming",
+        "complete": "completing",
+        "hold": "holding",
+        "stop": "stopping",
+        "abort": "aborting",
+    },
+    "execute": {
+        "complete": "completing",
+        "restart": "starting",
+        "pause": "pausing",
+        "hold": "holding",
+        "stop": "stopping",
+        "abort": "aborting",
+    },
+    "stopping": {"abort": "aborting"},
+    "aborting": {},
+    "aborted": {"reset": "resetting"},
+    "holding": {"stop": "stopping", "abort": "aborting"},
+    "held": {"unhold": "unholding", "stop": "stopping", "abort": "aborting"},
+    "unholding": {
+        "complete": "completing",
+        "hold": "holding",
+        "stop": "stopping",
+        "abort": "aborting",
+    },
+    "pausing": {
+        "complete": "completing",
+        "hold": "holding",
+        "stop": "stopping",
+        "abort": "aborting",
+    },
+    "resuming": {
+        "complete": "completing",
+        "hold": "holding",
+        "stop": "stopping",
+        "abort": "aborting",
+    },
+    "resetting": {"stop": "stopping", "abort": "aborting"},
+    "completing": {"hold": "holding", "stop": "stopping", "abort": "aborting"},
+    "completed": {"reset": "resetting", "stop": "stopping", "abort": "aborting"},
+}
+
+
+def init_service_control(
+    service_op_mode="off", service_src_mode="int"
+) -> ServiceControl:
+    service_control = ServiceControl("Test")
+
+    if service_op_mode == "off":
+        service_control.service_op_mode["StateOffAct"] = True
+    elif service_op_mode == "op":
+        service_control.service_op_mode["StateOffAct"] = False
+        service_control.service_op_mode["StateOpAct"] = True
+    elif service_op_mode == "aut":
+        service_control.service_op_mode["StateOffAct"] = False
+        service_control.service_op_mode["StateAutAct"] = True
+    else:
+        raise ValueError(f"ServiceOperationMode {service_op_mode} is unknown")
+
+    if service_src_mode == "int":
+        service_control.service_src_mode["SrcIntAct"] = True
+    elif service_src_mode == "ext":
+        service_control.service_src_mode["SrcExtAct"] = True
+    else:
+        raise ValueError(f"ServiceSourceMode {service_src_mode} is unknown")
+
+    return service_control
+
+
+class CallbackObject:
+    def __init__(self):
+        self.value = 0
+
+    def value_callback(self):
+        self.value = 10
+
+
+def init_state_machine(
+    state: str = "idle", service_op_mode: str = "off", service_src_mode: str = "int"
+):
+    callback_object = CallbackObject()
+    service_control = init_service_control(
+        service_op_mode=service_op_mode, service_src_mode=service_src_mode
+    )
+    state_machine = StateMachine(
+        service_control=service_control,
+        execution_routine=callback_object.value_callback,
+    )
+    if service_op_mode != "off":
+        state_machine.activate()
+        state_machine.act_state = StateCodes.from_string(state)
+        state_machine.command_en_ctrl.execute(state)
+
+    if not (
+        state_machine.get_current_state_str() == state
+        and service_operation_mode_is_in_specific_mode(
+            service_control.service_op_mode, False, service_op_mode
+        )
+        and service_source_mode_is_in_specific_mode(
+            service_control.service_src_mode, False, service_src_mode
+        )
+    ):
+        print(f"Initialization failed")
+    return state_machine, callback_object
+
+
+test_scenario_inactive = [
+    ("off", "int", "set_command_op", False),
+    ("off", "ext", "set_command_op", False),
+    ("off", "int", "set_command_int", False),
+    ("off", "ext", "set_command_int", False),
+    ("off", "int", "set_command_ext", False),
+    ("off", "ext", "set_command_ext", False),
+]
+
+test_scenario = [
+    ("op", "int", "set_command_op", True),
+    ("op", "ext", "set_command_op", True),
+    ("aut", "int", "set_command_op", False),
+    ("aut", "ext", "set_command_op", False),
+    ("op", "int", "set_command_int", False),
+    ("op", "ext", "set_command_int", False),
+    ("aut", "int", "set_command_int", True),
+    ("aut", "ext", "set_command_int", False),
+    ("op", "int", "set_command_ext", False),
+    ("op", "ext", "set_command_ext", False),
+    ("aut", "int", "set_command_ext", False),
+    ("aut", "ext", "set_command_ext", True),
+]
+
+
+@pytest.mark.parametrize(
+    "op_mode, src_mode, set_command, change_allowed", test_scenario
+)
+def test_set_command(op_mode, src_mode, set_command, change_allowed):
+    for state in StateCodes.list_of_strings():
+        if state == "undefined":
+            continue
+        for command in CommandCodes.list_of_codes():
+            state_machine, callback_object = init_state_machine(
+                state=state, service_op_mode=op_mode, service_src_mode=src_mode
+            )
+            # print(f'Initial State: {state_machine.get_current_state_str()} now running: state_machine.{set_command}({command})')
+            eval(f"state_machine.{set_command}({command})")
+            command_str = CommandCodes.from_code(command)
+            # eval(f'state_machine.{command_str}()')
+            if command_str in valid_commands[state].keys() and change_allowed:
+                expected_state = valid_commands[state][command_str]
+            else:
+                expected_state = state
+            final_state = state_machine.get_current_state_str()
+            print(
+                f"Scenario: op_mode {op_mode} src_mode {src_mode}, {set_command}, valid change: {change_allowed},",
+                end=" ",
+            )
+            print(
+                f"expect transition {state}->command({command_str})->{expected_state} (actual: {final_state})"
+            )
+            assert final_state == expected_state
+
+
+def test_activate_and_deactivate():
+    state_machine, callback_object = init_state_machine(service_op_mode="off")
+
+    assert state_machine.is_active is False
+    state_machine.activate()
+
+    assert state_machine.is_active is True
+    assert state_machine.get_current_state_str() == "idle"
+    assert callback_object.value == 10
+
+    state_machine.deactivate()
+
+    assert state_machine.is_active is False
+    assert state_machine.get_current_state_str() == "undefined"
+
+
+def test_activate_does_not_reinitialize_active_machine():
+    state_machine, callback_object = init_state_machine(service_op_mode="off")
+    state_machine.activate()
+    callback_object.value = 0
+
+    state_machine.activate()
+
+    assert state_machine.get_current_state_str() == "idle"
+    assert callback_object.value == 0
+
+
+def test_deactivate_only_works_from_idle():
+    state_machine, _ = init_state_machine(state="execute", service_op_mode="op")
+
+    state_machine.deactivate()
+
+    assert state_machine.is_active is True
+    assert state_machine.get_current_state_str() == "execute"
+
+
+def test_command_execution_ignores_inactive_and_unknown_commands():
+    state_machine, _ = init_state_machine(service_op_mode="off")
+
+    state_machine.command_execution(CommandCodes.START.code)
+    state_machine.command_execution(-1)
+
+    assert state_machine.is_active is False
+    assert state_machine.get_current_state_str() == "undefined"
+
+
+def test_active_command_execution_ignores_unknown_command():
+    state_machine, _ = init_state_machine(state="idle", service_op_mode="op")
+
+    state_machine.command_execution(-1)
+
+    assert state_machine.get_current_state_str() == "idle"
+
+
+def test_command_execution_ignores_disabled_command():
+    state_machine, _ = init_state_machine(state="idle", service_op_mode="op")
+    state_machine.command_en_ctrl.disable_all()
+
+    state_machine.command_execution(CommandCodes.START.code)
+
+    assert state_machine.get_current_state_str() == "idle"
+
+
+@pytest.mark.parametrize(
+    ("state", "expected_state"),
+    [
+        ("starting", "execute"),
+        ("completing", "completed"),
+        ("pausing", "paused"),
+        ("resuming", "execute"),
+        ("resetting", "idle"),
+        ("holding", "held"),
+        ("unholding", "execute"),
+        ("stopping", "stopped"),
+    ],
+)
+def test_state_change_transitions(state, expected_state):
+    state_machine, _ = init_state_machine(state=state, service_op_mode="op")
+
+    state_machine.state_change()
+
+    assert state_machine.get_current_state_str() == expected_state
+
+
+def test_state_change_does_nothing_without_transition():
+    state_machine, _ = init_state_machine(state="idle", service_op_mode="op")
+
+    state_machine.state_change()
+
+    assert state_machine.get_current_state_str() == "idle"
+
+
+def test_set_command_requires_matching_operation_and_source_modes():
+    state_machine, _ = init_state_machine(
+        state="idle", service_op_mode="aut", service_src_mode="int"
+    )
+
+    state_machine.set_command_op(CommandCodes.START.code)
+    state_machine.set_command_ext(CommandCodes.START.code)
+
+    assert state_machine.get_current_state_str() == "idle"

mtppy/part4/automation_services/helpers/thread_control.py

@@ -0,0 +1,39 @@
+"""Class for Thread Control."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+import logging
+from threading import Thread, Event
+
+
+class ThreadControl:
+    def __init__(self):
+        """
+        Represents a thread control to be able to run with multithreading.
+        """
+        self.thread = None
+        self.running_state = ""
+        self.requested_state = ""
+        self.callback_function = None
+        self._stop_event = Event()
+
+    def request_state(self, state: str, cb_function: callable):
+        logging.debug(f"State {state} requested")
+        self.requested_state = state
+        self.callback_function = cb_function
+
+    def reallocate_running_thread(self):
+        logging.debug(f"Reallocate thread to state {self.requested_state}")
+        if self.requested_state is not self.running_state:
+            self.thread = Thread(target=self.callback_function, daemon=True)
+            self.thread.start()
+            self.running_state = self.requested_state
+
+    def stop(self):
+        self._stop_event.set()
+
+    def is_stopped(self):
+        return self._stop_event.is_set()

mtppy/part4/automation_services/helpers/thread_control_test.py

@@ -0,0 +1,80 @@
+"""Test suite for ThreadControl."""
+
+from threading import Event
+
+from mtppy.part4.automation_services.helpers.thread_control import ThreadControl
+
+
+def test_initial_state():
+    thread_control = ThreadControl()
+
+    assert thread_control.thread is None
+    assert thread_control.running_state == ""
+    assert thread_control.requested_state == ""
+    assert thread_control.callback_function is None
+    assert thread_control.is_stopped() is False
+
+
+def test_request_state_stores_state_and_callback():
+    thread_control = ThreadControl()
+    callback = lambda: None
+
+    thread_control.request_state("idle", callback)
+
+    assert thread_control.requested_state == "idle"
+    assert thread_control.callback_function is callback
+
+
+def test_reallocate_running_thread_starts_requested_callback():
+    thread_control = ThreadControl()
+    callback_finished = Event()
+
+    thread_control.request_state("idle", callback_finished.set)
+    thread_control.reallocate_running_thread()
+
+    thread_control.thread.join(timeout=1)
+    assert callback_finished.is_set() is True
+    assert thread_control.running_state == "idle"
+    assert thread_control.thread.is_alive() is False
+
+
+def test_reallocate_running_thread_switches_to_new_state():
+    thread_control = ThreadControl()
+    first_callback_finished = Event()
+    second_callback_finished = Event()
+
+    thread_control.request_state("starting", first_callback_finished.set)
+    thread_control.reallocate_running_thread()
+    thread_control.thread.join(timeout=1)
+
+    thread_control.request_state("execute", second_callback_finished.set)
+    thread_control.reallocate_running_thread()
+    thread_control.thread.join(timeout=1)
+
+    assert first_callback_finished.is_set() is True
+    assert second_callback_finished.is_set() is True
+    assert thread_control.running_state == "execute"
+
+
+def test_reallocate_running_thread_does_not_start_when_state_is_unchanged():
+    thread_control = ThreadControl()
+    callback_finished = Event()
+
+    thread_control.request_state("idle", callback_finished.set)
+    thread_control.reallocate_running_thread()
+    first_thread = thread_control.thread
+    first_thread.join(timeout=1)
+    callback_finished.clear()
+
+    thread_control.reallocate_running_thread()
+
+    assert thread_control.thread is first_thread
+    assert callback_finished.is_set() is False
+
+
+def test_stop_sets_stop_event():
+    thread_control = ThreadControl()
+
+    thread_control.stop()
+
+    assert thread_control.is_stopped() is True

mtppy/part4/automation_services/procedure.py

@@ -0,0 +1,111 @@
+"""Implementation of the Procedure Object (PNO MTP 2.0 Part 4, Section 8.2.4)."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from mtppy.utils.logging import logger
+from mtppy.part3.data_assembly_set.data_assembly import DataAssembly
+from mtppy.part3.data_assembly_set.indicator_elements.indicator_element import (
+    IndicatorElement,
+)
+from mtppy.part4.process_values.input_elements.input_element import InputElement
+from mtppy.part4.automation_services.service_elements.procedure_health_view import (
+    ProcedureHealthView,
+)
+from mtppy.part4.automation_services.service_elements.parameter_elements.parameter_element import (
+    ParameterElement,
+)
+from mtppy.utils.data_assembly_dict import DataAssemblyDict
+
+
+class Procedure:
+    def __init__(
+        self,
+        procedure_id: int,
+        tag_name: str,
+        tag_description: str = "",
+        is_self_completing=False,
+        required_equipment: DataAssembly | list[DataAssembly] | None = None,
+    ) -> None:
+
+        self.name = tag_name
+        if procedure_id == 0:
+            raise ValueError("ProcedureId must be bigger than 0")
+        self.procedure_id = procedure_id
+        self.is_self_completing = is_self_completing
+
+        self.procedure_health_view = ProcedureHealthView(tag_name, tag_description)
+
+        self.procedure_parameters = DataAssemblyDict(ParameterElement)
+        self.process_value_ins = DataAssemblyDict(InputElement)
+        self.process_value_outs = DataAssemblyDict(IndicatorElement)
+        self.report_values = DataAssemblyDict(IndicatorElement)
+
+        self.required_equipment = DataAssemblyDict(DataAssembly)
+        self.add_required_equipment(required_equipment)
+
+    def add_procedure_parameter(
+        self, procedure_parameter: ParameterElement | list[ParameterElement]
+    ) -> None:
+        """Add one or more procedure parameter to the procedure.
+
+        Arguments:
+            procedure_parameter: ParemeterElement or list of type ParameterElement.
+        """
+
+        self.procedure_parameters.add(procedure_parameter)
+
+    def add_process_value_in(
+        self, process_value_in: InputElement | list[InputElement]
+    ) -> None:
+        """Add one or more InputElements to the procedure.
+
+        Arguments:
+            process_value_in: InputElement or list of InputElements.
+        """
+        self.process_value_ins.add(process_value_in)
+
+    def add_process_value_out(
+        self, process_value_out: IndicatorElement | list[IndicatorElement]
+    ) -> None:
+        """Add one or more IndicatorElements to the procedure.
+
+        Arguments:
+            process_value_out: IndicatorElement or list of IndicatorElement.
+        """
+        self.process_value_outs.add(process_value_out)
+
+    def add_report_value(
+        self,
+        report_value: IndicatorElement | list[IndicatorElement],
+    ) -> None:
+        """Add one or more IndicatorElements to the procedure as ReportValue.
+
+        Arguments:
+            report_value: IndicatorElement or list of IndicatorElement.
+        """
+        self.report_values.add(report_value)
+
+    def apply_procedure_parameters(self) -> None:
+        """Apply ProcedureParameters."""
+        for procedure_parameter in self.procedure_parameters.values():
+            logger.mtp(f"self={self.name},VReq={procedure_parameter["VReq"]}")
+            procedure_parameter.update_v_out()
+
+    def add_required_equipment(
+        self,
+        equipment: (
+            DataAssembly
+            | list[DataAssembly | None]
+            | dict[str, DataAssembly | None]
+            | None
+        ),
+    ) -> None:
+        """Add one or more DataAssemblies to the procedure as Required Equipment.
+
+        Arguments:
+            equipment: DataAssembly or list of DataAssemblies.
+        """
+        self.required_equipment.add(equipment)