MTPPy2.0 0.1.5__py3-none-any.whl

mtppy/pea/rmtp_pea.py

@@ -0,0 +1,155 @@
+"""PEA implementation that loads an MTP package and user logic module."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+import argparse
+import asyncio
+import importlib
+from types import ModuleType
+from typing import cast
+
+from mtppy.pea.data_assembly_factory import DataAssemblyFactory
+from mtppy.pea.pea import PEA
+from mtppy.pea.service_factory import ServiceConfig, ServiceFactory
+from mtppy.part4.automation_services.service import Service
+from mtppy.pea.user_logic.user_logic_registry import global_registry
+from mtppy.pea.user_logic.user_logic_service import UserLogicService
+from mtppy.utils.logging import CHOICES, logger, setLogLevel
+from mtppy.utils.mtp_file_handling.mtp_reader.mtp_reader import MtpReader
+
+
+class RMTPPea(PEA):
+    """PEA assembled from an MTP package and a user logic module."""
+
+    def __init__(
+        self,
+        endpoint: str = "opc.tcp://localhost:4840/",
+        mtp: str = "",
+        ssd: str = "",
+        code: str = "",
+        cycle_time: float = 1.0,
+    ) -> None:
+        super().__init__(endpoint)
+        self._cycle_time = cycle_time
+        if mtp:
+            self.load_requirements(mtp, ssd, code)
+
+    @staticmethod
+    def _import_user_code(module_name: str) -> ModuleType:
+        """Import the user logic module by its Python module name."""
+        if not module_name:
+            raise ValueError("user logic module name must not be empty")
+        return importlib.import_module(module_name)
+
+    def load_requirements(self, mtp: str, ssd: str = "", code: str = "") -> None:
+        """Load user logic, data assemblies, and services from an MTP package."""
+        del ssd
+        module = self._import_user_code(code)
+        logger.app(f"successfully loaded module {module.__name__}")
+
+        reader = MtpReader(mtp)
+        data_assemblies = DataAssemblyFactory.create_data_assemblies(
+            reader.data_assemblies
+        )
+        self.add_data_assembly(data_assemblies)
+
+        services = ServiceFactory.create_services(
+            cast(dict[str, ServiceConfig], reader.services), data_assemblies
+        )
+        for service_group in services.values():
+            service = service_group.get(ServiceFactory.RBSUB_SERVICE)
+            if isinstance(service, UserLogicService):
+                service.set_registry(global_registry)
+                service.set_cycle_time(self._cycle_time)
+            if isinstance(service, Service):
+                self.add_service(service)
+
+
+def parse_args(args: list[str] | None = None) -> argparse.Namespace:
+    """Parse command-line options for starting an RMTP-backed PEA."""
+    parser = argparse.ArgumentParser("rmtp_pea")
+    parser.add_argument(
+        "-r",
+        "--rmtp",
+        required=True,
+        help="basename of the requirements MTP files (without .mtp or .json)",
+    )
+    parser.add_argument(
+        "-u",
+        "--user-logic",
+        dest="user_logic",
+        required=True,
+        help="Python module containing the user logic",
+    )
+    parser.add_argument(
+        "-l",
+        "--log-level",
+        default="MTP",
+        choices=["DEBUG", "INFO", *CHOICES, "WARNING", "ERROR", "CRITICAL"],
+        help="logging level (default: MTP)",
+    )
+    parser.add_argument(
+        "-d",
+        "--duration",
+        type=float,
+        default=10.0,
+        help="seconds to keep the PEA running when not using --daemon",
+    )
+    parser.add_argument(
+        "-c",
+        "--cycle-time",
+        type=float,
+        default=1.0,
+        help="cycle time in seconds for the procedures execution, default=1.0",
+    )
+    parser.add_argument(
+        "-e",
+        "--endpoint",
+        default="opc.tcp://localhost:4840",
+        help="OPC UA endpoint",
+    )
+    parser.add_argument(
+        "--daemon",
+        action="store_true",
+        help="keep the PEA running until interrupted",
+    )
+    return parser.parse_args(args)
+
+
+async def run(parsed_args: argparse.Namespace) -> None:
+    setLogLevel(parsed_args.log_level)
+    logger.app(f"--- Create PEA at {parsed_args.endpoint} ---")
+
+    pea = RMTPPea(
+        endpoint=parsed_args.endpoint,
+        mtp=f"{parsed_args.rmtp}.mtp",
+        ssd=f"{parsed_args.rmtp}.json",
+        code=parsed_args.user_logic,
+        cycle_time=parsed_args.cycle_time,
+    )
+    pea.start()
+    logger.app("--- PEA OPC UA server started ---")
+
+    try:
+        if parsed_args.daemon:
+            await asyncio.Event().wait()
+        else:
+            await asyncio.sleep(parsed_args.duration)
+    except (KeyboardInterrupt, asyncio.exceptions.CancelledError):
+        logger.app("--- PEA interrupted ---")
+    finally:
+        logger.app("--- Stop PEA ---")
+        pea.stop()
+
+
+def main(args: list[str] | None = None) -> None:
+    """Start an RMTP PEA from command-line arguments."""
+    parsed_args = parse_args(args)
+    asyncio.run(run(parsed_args))
+
+
+if __name__ == "__main__":
+    main()

mtppy/pea/rmtp_pea_test.py

@@ -0,0 +1,27 @@
+"""Tests for the MTP-backed PEA facade."""
+
+import importlib
+from pathlib import Path
+
+from mtppy.pea import RMTPPea
+from mtppy.pea.rmtp_pea import RMTPPea as DirectRMTPPea
+
+
+def test_rmtp_pea_is_exported_from_pea_package() -> None:
+    assert RMTPPea is DirectRMTPPea
+
+
+def test_rmtp_pea_can_import_user_logic_module(monkeypatch) -> None:
+    project_root = Path(__file__).parents[3]
+    monkeypatch.syspath_prepend(str(project_root))
+
+    module = RMTPPea._import_user_code("examples.minimal")
+
+    assert module is importlib.import_module("examples.minimal")
+
+
+def test_rmtp_pea_without_mtp_starts_empty() -> None:
+    pea = RMTPPea()
+
+    assert pea.data_assemblies == {}
+    assert pea.service_set == {}

mtppy/pea/service_factory.py

@@ -0,0 +1,178 @@
+"""Factory for creating services from a ServiceConfig dictionary.
+
+This module provides a factory class for creating service instances
+based on the configuration dictionaries of type DataAssemblyConfig and ServiceConfig.
+
+"""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from collections.abc import Callable
+from typing import ClassVar
+from itertools import chain
+
+from mtppy.utils.logging import logger
+import utils.type_conversion as tc
+
+from mtppy.part3.data_assembly_set.data_assembly import DataAssembly
+from mtppy.part4.automation_services.service import Service
+from mtppy.part4.automation_services.procedure import Procedure
+from mtppy.pea.user_logic.user_logic_service import UserLogicService
+
+ServiceConfig = dict[str, str | dict[str, str | None | dict[str, str | None]]]
+
+
+class ServiceFactory:
+    """Factory class for creating DataAssembly instances."""
+
+    # TODO: move string constants to mtppy.part4.definitions.automation_ml.AML
+    RBSUB_ROOT: str = "MTPServiceSUCLib"
+    RBSUB_SERVICE: str = f"{RBSUB_ROOT}/Service"
+    RBSUB_PROCEDURE: str = f"{RBSUB_ROOT}/Service/Procedure"
+    RBSUB_REQUIRED_EQUIPMENT: str = f"{RBSUB_ROOT}/RequiredEquipment"
+    RBSUB_REPORT_VALUE: str = f"{RBSUB_ROOT}/ReportValue"
+    RBSUB_PROCEDURE_PARAMETER: str = f"{RBSUB_ROOT}/ServiceParameter/ProcedureParameter"
+
+    _FACTORY: ClassVar[
+        dict[
+            str,
+            Callable[
+                [dict[str, ServiceConfig], dict[str, DataAssembly]],
+                dict[str, dict[str, Service | Procedure | DataAssembly]],
+            ],
+        ]
+    ] = {}
+
+    @classmethod
+    def initialize_factory(cls):
+        cls._FACTORY = {
+            cls.RBSUB_SERVICE: ServiceFactory.create_service,
+            cls.RBSUB_PROCEDURE: ServiceFactory.create_procedure,
+            cls.RBSUB_PROCEDURE_PARAMETER: ServiceFactory.get_data_assembly,
+            cls.RBSUB_REPORT_VALUE: ServiceFactory.get_data_assembly,
+            cls.RBSUB_REQUIRED_EQUIPMENT: ServiceFactory.get_data_assembly,
+        }
+
+    @classmethod
+    def create_services(
+        cls,
+        service_dict: dict[str, ServiceConfig],
+        data_assemblies: dict[str, DataAssembly] = {},
+    ) -> dict[str, dict[str, Service | Procedure | DataAssembly]]:
+        return cls.create_instances(service_dict, data_assemblies)
+
+    @classmethod
+    def create_instances(
+        cls,
+        service_dict: dict[str, ServiceConfig],
+        data_assemblies: dict[str, DataAssembly] = {},
+    ) -> dict[str, dict[str, Service | Procedure | DataAssembly]]:
+        """recursively create instances from a configration dictionary.
+
+        Args:
+            service_dict: Dictionary mapping names to ServiceConfig dictionaries.
+
+        Returns:
+            Dictionary mapping names to created instances.
+        """
+        result: dict[str, dict[str, Service | Procedure | DataAssembly]] = {}
+        if isinstance(service_dict, dict):
+            for name, config in service_dict.items():
+                if "RefBaseSystemUnitPath" in config:
+                    if name not in result:
+                        result[name] = {}
+                    kind = config["RefBaseSystemUnitPath"]
+                    if isinstance(kind, str):
+                        result[name][kind] = cls._FACTORY[kind](config, data_assemblies)
+                    elif isinstance(kind, list):
+                        for k in kind:
+                            result[name][k] = cls._FACTORY[k](config, data_assemblies)
+                    else:
+                        raise ValueError("unknown type RefBaseSystemUnitPath")
+        return result
+
+    @staticmethod
+    def create_service(
+        config: ServiceConfig,
+        data_assemblies: dict[str, DataAssembly] = {},
+    ) -> Service:
+        """Create a single Service instance from a configuration entry.
+
+        Args:
+            config: Configuration dictionary for the service.
+
+        Returns:
+            Created service instance.
+        """
+
+        tag_name: str = config["Name"]
+        tag_description: str = ""
+
+        service = UserLogicService(tag_name, tag_description)
+        procedures = ServiceFactory.create_instances(config, data_assemblies)
+        service.add_procedure(
+            list(chain.from_iterable(sub.values() for sub in procedures.values()))
+        )
+        return service
+
+    @classmethod
+    def create_procedure(
+        cls,
+        config: ServiceConfig,
+        data_assemblies: dict[str, DataAssembly] = {},
+    ) -> Procedure:
+        """Create a single Procedure instance from a configuration entry.
+
+        Args:
+            config: Configuration dictionary for the service.
+
+        Returns:
+            Created service instance.
+        """
+
+        tag_name: str = config["Name"]
+        is_self_completing: bool = tc.cast_to_bool(config["IsSelfCompleting"]["value"])
+        procedure_id: int = int(config["ProcedureID"]["value"])
+
+        procedure = Procedure(
+            procedure_id=procedure_id,
+            tag_name=tag_name,
+            is_self_completing=is_self_completing,
+        )
+        equipment = ServiceFactory.create_instances(config, data_assemblies)
+
+        dispatcher: dict[
+            str,
+            Callable[
+                [
+                    list[DataAssembly | None],
+                ],
+                None,
+            ],
+        ] = {
+            cls.RBSUB_REQUIRED_EQUIPMENT: procedure.add_required_equipment,
+            cls.RBSUB_PROCEDURE_PARAMETER: procedure.add_procedure_parameter,
+            cls.RBSUB_REPORT_VALUE: procedure.add_report_value,
+        }
+        for key in dispatcher:
+            dispatcher[key]([d[key] for d in equipment.values() if key in d])
+
+        return procedure
+
+    @staticmethod
+    def get_data_assembly(
+        config: ServiceConfig,
+        data_assemblies: dict[str, DataAssembly] = {},
+    ) -> DataAssembly | None:
+        name: str = config["Name"]
+        if name in data_assemblies:
+            return data_assemblies[name]
+        else:
+            logger.warning(f"No data assembly defined for {name}")
+            return None
+
+
+ServiceFactory.initialize_factory()

mtppy/pea/service_factory_test.py

@@ -0,0 +1,156 @@
+"""
+Unit tests for the ServiceFactory class.
+"""
+
+import pytest
+
+from mtppy.pea.service_factory import ServiceFactory
+from mtppy.part3.data_assembly_set.data_assembly import DataAssembly
+from mtppy.part3.data_assembly_set.indicator_elements.views.ana_view import AnaView
+from mtppy.part4.automation_services.service import Service
+from mtppy.part4.automation_services.procedure import Procedure
+from mtppy.part4.automation_services.service_elements.parameter_elements.dint_serv_param import DIntServParam
+
+MINIMAL_SERVICE_CONFIG = {
+    "rand_num_gen": {
+        "Classification": {"default": "", "value": ""},
+        "ID": "d65bb96a-f5af-457e-8fa6-63cdbb5a8a80",
+        "Name": "rand_num_gen",
+        "RefBaseSystemUnitPath": "MTPServiceSUCLib/Service",
+        "RefID": {"default": "", "value": "542a4ea1-baa2-4e34-af95-9b3c2a605ae3"},
+        "cont": {
+            "Classification": {"default": "", "value": ""},
+            "ID": "202d0321-7bbe-42f3-84c8-e871527b4656",
+            "IsSelfCompleting": {"default": "", "value": "true"},
+            "Name": "cont",
+            "ProcedureID": {"default": "", "value": "1"},
+            "RefBaseSystemUnitPath": "MTPServiceSUCLib/Service/Procedure",
+            "RefID": {"default": "", "value": "c0048311-3a6f-4339-9f29-7a87dc020e17"},
+            "generated_value": {
+                "ID": "cbc5c1e8-96da-4311-8763-6caadf85e0b9",
+                "Name": "generated_value",
+                "RefBaseSystemUnitPath": [
+                    "MTPServiceSUCLib/ReportValue",
+                    "MTPServiceSUCLib/RequiredEquipment",
+                ],
+                "RefID": {
+                    "default": "",
+                    "value": "43bcd4e3-f9e5-40e5-b573-e67470ad134c",
+                },
+            },
+            "lower_bound": {
+                "ID": [
+                    "fe89d547-851d-4be8-9c94-ee085a6dd867",
+                ],
+                "Name": "lower_bound",
+                "RefBaseSystemUnitPath": [
+                    "MTPServiceSUCLib/ServiceParameter/ProcedureParameter",
+                    "MTPServiceSUCLib/RequiredEquipment",
+                ],
+                "RefID": {
+                    "default": "",
+                    "value": "b3e75452-613e-4fca-be18-b11a62bcb1f7",
+                },
+            },
+            "upper_bound": {
+                "ID": "455570ca-7835-4eb8-b09b-29ec59737573",
+                "Name": "upper_bound",
+                "RefBaseSystemUnitPath": [
+                    "MTPServiceSUCLib/ServiceParameter/ProcedureParameter",
+                    "MTPServiceSUCLib/RequiredEquipment",
+                ],
+                "RefID": {
+                    "default": "",
+                    "value": "8df4853a-1b1a-4b86-9079-b5d4203cbe46",
+                },
+            },
+        },
+    }
+}
+
+MINIMAL_DATA_ASSEMBLIES = {
+    "upper_bound": DIntServParam(tag_name="upper_bound"),
+    "lower_bound": DIntServParam(tag_name="lower_bound"),
+    "generated_value": AnaView(tag_name="generated_value"),
+}
+
+
+def test_factory() -> None:
+    """Test that all methods referred to in the _FACTORY exists."""
+    assert len(ServiceFactory._FACTORY) == 5
+    for elem in ServiceFactory._FACTORY.values():
+        assert hasattr(ServiceFactory, elem.__name__) == True
+
+
+def test_get_data_assembly() -> None:
+    """test retrieval of equipment"""
+    config = MINIMAL_SERVICE_CONFIG["rand_num_gen"]["cont"]["upper_bound"]
+    equipment = ServiceFactory.get_data_assembly(config, MINIMAL_DATA_ASSEMBLIES)
+    assert isinstance(equipment, DataAssembly)
+    assert equipment.TagName == "upper_bound"
+    assert equipment.tag_name == "upper_bound"
+
+
+def test_get_data_assembly_missing() -> None:
+    config = MINIMAL_SERVICE_CONFIG["rand_num_gen"]["cont"]["generated_value"]
+    equipment = ServiceFactory.get_data_assembly(config)
+    assert equipment is None
+
+
+def test_create_procedure() -> None:
+    procedure = ServiceFactory.create_procedure(
+        MINIMAL_SERVICE_CONFIG["rand_num_gen"]["cont"],
+        MINIMAL_DATA_ASSEMBLIES,
+    )
+    assert isinstance(procedure, Procedure) == True
+
+
+@pytest.mark.parametrize(
+    ("value", "expected"),
+    [("true", True), ("false", False), (True, True), (False, False)],
+)
+def test_create_procedure_parses_is_self_completing(
+    value: object, expected: bool
+) -> None:
+    config = {
+        "Name": "procedure",
+        "IsSelfCompleting": {"value": value},
+        "ProcedureID": {"value": "1"},
+    }
+
+    procedure = ServiceFactory.create_procedure(config)  # type: ignore[arg-type]
+
+    assert procedure.is_self_completing is expected
+
+
+def test_create_procedure_rejects_invalid_boolean() -> None:
+    config = {
+        "Name": "procedure",
+        "IsSelfCompleting": {"value": "yes"},
+        "ProcedureID": {"value": "1"},
+    }
+
+    with pytest.raises(ValueError, match="Invalid boolean value"):
+        ServiceFactory.create_procedure(config)  # type: ignore[arg-type]
+
+
+def test_create_service() -> None:
+    service = ServiceFactory.create_service(
+        MINIMAL_SERVICE_CONFIG["rand_num_gen"],
+        MINIMAL_DATA_ASSEMBLIES,
+    )
+    assert isinstance(service, Service) == True
+
+
+def test_create_services() -> None:
+    services = ServiceFactory.create_services(
+        MINIMAL_SERVICE_CONFIG,
+        MINIMAL_DATA_ASSEMBLIES,
+    )
+    assert len(services) == 1
+    assert "rand_num_gen" in services
+    assert ServiceFactory.RBSUB_SERVICE in services["rand_num_gen"]
+    assert (
+        isinstance(services["rand_num_gen"][ServiceFactory.RBSUB_SERVICE], Service)
+        == True
+    )

mtppy/pea/user_logic/__init__.py

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

mtppy/pea/user_logic/user_logic_pea.py

@@ -0,0 +1,72 @@
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+import importlib
+
+from mtppy.pea.data_assembly_factory import DataAssemblyFactory
+from mtppy.pea.pea import PEA
+from mtppy.pea.service_factory import ServiceFactory
+from mtppy.pea.user_logic.user_logic_registry import global_registry
+from mtppy.pea.user_logic.user_logic_service import UserLogicService
+from mtppy.utils.logging import logger
+from mtppy.utils.mtp_file_handling.mtp_reader.mtp_reader import MtpReader
+
+
+class UserLogicPEA(PEA):
+    def __init__(
+        self,
+        endpoint: str = "opc.tcp://localhost:4840/",
+        mtp: str = "",
+        ssd: str = "",
+        code: str = "",
+    ) -> None:
+        """Initialize UserLogicPEA"""
+        super().__init__(endpoint)
+        if mtp is not None and len(mtp):
+            self.load_requirements(mtp, ssd, code)
+
+    def _import_user_code(self, module_name: str):
+        """Dynamically import the user module by name and inject the registry decorator
+
+        Args:
+            module_name: The name of the module to import.
+
+        Returns:
+            module: The imported module.
+        """
+        # Import the module dynamically
+        module = importlib.import_module(module_name)
+
+        return module
+
+    def load_requirements(self, mtp: str, ssd: str, code: str):
+        """Loads requirements mtp and user logic. ignores namespace for the moment."""
+        # load the user logic
+        module = self._import_user_code(code)
+        logger.app(f"successfully loaded module {module.__name__}")
+
+        # Log all function names from the module
+        # function_names = [name for name, obj in vars(module).items() if callable(obj)]
+        # logger.app(f"Functions in module: {', '.join(function_names)}")
+
+        logger.app(
+            f"registered {",".join(f"{v.__name__} as {k}" for k,v in global_registry._registry.items())}",
+        )
+
+        reader = MtpReader(mtp)
+
+        # create and attach the data_assemblies
+        data_assemblies = DataAssemblyFactory.create_data_assemblies(
+            reader.data_assemblies,
+        )
+        self.add_data_assembly(data_assemblies)
+
+        # create and attach the services
+        services = ServiceFactory.create_services(reader.services, data_assemblies)
+        for k in services:
+            service = services[k][ServiceFactory.RBSUB_SERVICE]
+            if isinstance(service, UserLogicService):
+                service.set_registry(global_registry)
+            self.add_service(service)