MTPPy2.0 0.1.5__py3-none-any.whl

mtppy/part6/alarm_set/alarm_test.py

@@ -0,0 +1,265 @@
+"""Tests for static AlarmSet.Base alarm descriptions."""
+
+# ruff: noqa: S101
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from typing import ClassVar
+
+import pytest
+from mtppy.utils.data_item import DataItem
+from mtppy.part3.data_assembly_set.data_assembly import DataAssembly
+from mtppy.part3.definitions.mtp_access import MTPAccess
+from mtppy.part5.definitions.w3c_xml_data_types import W3cXmlDataTypes
+from mtppy.part6.alarm_set.alarm import Alarm
+
+DEFAULT_SEVERITY = 500
+INTEGER_RANGES = [
+    (W3cXmlDataTypes.BYTE, -(2**7), (2**7) - 1),
+    (W3cXmlDataTypes.UNSIGNED_BYTE, 0, (2**8) - 1),
+    (W3cXmlDataTypes.SHORT, -(2**15), (2**15) - 1),
+    (W3cXmlDataTypes.UNSIGNED_SHORT, 0, (2**16) - 1),
+    (W3cXmlDataTypes.INT, -(2**31), (2**31) - 1),
+    (W3cXmlDataTypes.UNSIGNED_INT, 0, (2**32) - 1),
+    (W3cXmlDataTypes.LONG, -(2**63), (2**63) - 1),
+    (W3cXmlDataTypes.UNSIGNED_LONG, 0, (2**64) - 1),
+]
+
+
+class TriggerAssembly(DataAssembly):
+    """DataAssembly exposing all trigger types relevant to the tests."""
+
+    BOOL_TRIGGER = "BoolTrigger"
+    INT_TRIGGER = "IntTrigger"
+    TEXT_TRIGGER = "TextTrigger"
+    FLOAT_TRIGGER = "FloatTrigger"
+
+    CLASS_DATA_ITEMS: ClassVar = {
+        BOOL_TRIGGER: DataItem(
+            BOOL_TRIGGER,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            init_value=False,
+        ),
+        INT_TRIGGER: DataItem(
+            INT_TRIGGER,
+            W3cXmlDataTypes.INT,
+            MTPAccess.ReadAccess,
+            0,
+        ),
+        TEXT_TRIGGER: DataItem(
+            TEXT_TRIGGER,
+            W3cXmlDataTypes.STRING,
+            MTPAccess.ReadAccess,
+            "",
+        ),
+        FLOAT_TRIGGER: DataItem(
+            FLOAT_TRIGGER,
+            W3cXmlDataTypes.FLOAT,
+            MTPAccess.ReadAccess,
+            0.0,
+        ),
+    }
+
+
+def build_alarm(
+    *,
+    assembly: TriggerAssembly | None = None,
+    trigger_name: str = TriggerAssembly.BOOL_TRIGGER,
+    trigger_value: object = True,
+    severity: int = DEFAULT_SEVERITY,
+    ack_required: bool = True,
+    tag_name: str = "HighLevel.Alarm",
+    message: str = "Level is too high.",
+) -> Alarm:
+    """Build a valid alarm while allowing one property to be varied."""
+    target = assembly or TriggerAssembly("Triggers")
+    return Alarm(
+        tag_name=tag_name,
+        data_assembly=target,
+        trigger=target.get_item(trigger_name),
+        trigger_value=trigger_value,
+        severity=severity,
+        ack_required=ack_required,
+        message=message,
+    )
+
+
+def build_integer_alarm(
+    data_type: W3cXmlDataTypes,
+    trigger_value: int,
+) -> Alarm:
+    """Build an alarm with one concrete W3C integer trigger type."""
+
+    class IntegerTriggerAssembly(DataAssembly):
+        """DataAssembly containing the parameterized integer trigger."""
+
+        TRIGGER = "Trigger"
+        CLASS_DATA_ITEMS: ClassVar = {
+            TRIGGER: DataItem(
+                TRIGGER,
+                data_type,
+                MTPAccess.ReadAccess,
+                init_value=0,
+            ),
+        }
+
+    assembly = IntegerTriggerAssembly("IntegerTrigger")
+    return Alarm(
+        tag_name="Integer.Alarm",
+        data_assembly=assembly,
+        trigger=assembly.get_item(IntegerTriggerAssembly.TRIGGER),
+        trigger_value=trigger_value,
+        severity=DEFAULT_SEVERITY,
+        ack_required=False,
+        message="Integer alarm.",
+    )
+
+
+def test_alarm_preserves_static_base_metadata() -> None:
+    """A valid AlarmSet.Base description retains its public metadata."""
+    assembly = TriggerAssembly("Triggers")
+    trigger = assembly.get_item(TriggerAssembly.BOOL_TRIGGER)
+
+    alarm = build_alarm(assembly=assembly)
+
+    assert alarm.tag_name == "HighLevel.Alarm"
+    assert alarm.data_assembly is assembly
+    assert alarm.trigger is trigger
+    assert alarm.trigger_value is True
+    assert alarm.severity == DEFAULT_SEVERITY
+    assert alarm.ack_required is True
+    assert alarm.message == "Level is too high."
+
+
+@pytest.mark.parametrize("severity", [1, 500, 1000])
+def test_alarm_accepts_valid_severity_boundaries(severity: int) -> None:
+    """Severity accepts the complete specified inclusive range."""
+    assert build_alarm(severity=severity).severity == severity
+
+
+@pytest.mark.parametrize("severity", [0, 1001, -1, True, 1.0, "500", None])
+def test_alarm_rejects_invalid_severity(severity: object) -> None:
+    """Severity rejects out-of-range values and non-integer types."""
+    with pytest.raises((TypeError, ValueError)):
+        build_alarm(severity=severity)  # type: ignore[arg-type]
+
+
+@pytest.mark.parametrize("ack_required", [0, 1, "true", None])
+def test_alarm_rejects_non_boolean_ack_required(ack_required: object) -> None:
+    """AckRequired must be an actual bool rather than a truthy value."""
+    with pytest.raises(TypeError):
+        build_alarm(ack_required=ack_required)  # type: ignore[arg-type]
+
+
+@pytest.mark.parametrize(
+    ("tag_name", "message"),
+    [("", "message"), ("   ", "message"), ("alarm", ""), ("alarm", "   ")],
+)
+def test_alarm_rejects_empty_names_and_messages(tag_name: str, message: str) -> None:
+    """Alarm identity and operator message must contain visible text."""
+    with pytest.raises(ValueError, match="must not be empty"):
+        build_alarm(tag_name=tag_name, message=message)
+
+
+@pytest.mark.parametrize(
+    ("trigger_name", "trigger_value"),
+    [
+        (TriggerAssembly.BOOL_TRIGGER, True),
+        (TriggerAssembly.INT_TRIGGER, 12),
+        (TriggerAssembly.TEXT_TRIGGER, "ALARM"),
+    ],
+)
+def test_alarm_accepts_supported_trigger_types(
+    trigger_name: str,
+    trigger_value: object,
+) -> None:
+    """Boolean, integer and string equality triggers are supported."""
+    alarm = build_alarm(trigger_name=trigger_name, trigger_value=trigger_value)
+
+    assert alarm.trigger_value == trigger_value
+
+
+@pytest.mark.parametrize(("data_type", "lower", "upper"), INTEGER_RANGES)
+def test_alarm_accepts_integer_type_boundaries(
+    data_type: W3cXmlDataTypes,
+    lower: int,
+    upper: int,
+) -> None:
+    """Every supported W3C integer type accepts both inclusive boundaries."""
+    assert build_integer_alarm(data_type, lower).trigger_value == lower
+    assert build_integer_alarm(data_type, upper).trigger_value == upper
+
+
+@pytest.mark.parametrize(("data_type", "lower", "upper"), INTEGER_RANGES)
+def test_alarm_rejects_values_outside_integer_type_range(
+    data_type: W3cXmlDataTypes,
+    lower: int,
+    upper: int,
+) -> None:
+    """W3C integer triggers reject values that cannot be represented."""
+    for invalid_value in (lower - 1, upper + 1):
+        with pytest.raises(ValueError, match="range"):
+            build_integer_alarm(data_type, invalid_value)
+
+
+@pytest.mark.parametrize(
+    ("trigger_name", "trigger_value"),
+    [
+        (TriggerAssembly.BOOL_TRIGGER, 1),
+        (TriggerAssembly.INT_TRIGGER, True),
+        (TriggerAssembly.INT_TRIGGER, 1.0),
+        (TriggerAssembly.TEXT_TRIGGER, b"ALARM"),
+    ],
+)
+def test_alarm_requires_exact_trigger_value_type(
+    trigger_name: str,
+    trigger_value: object,
+) -> None:
+    """TriggerValue must use the exact Python type declared by the DataItem."""
+    with pytest.raises(TypeError, match="TriggerValue"):
+        build_alarm(trigger_name=trigger_name, trigger_value=trigger_value)
+
+
+def test_alarm_rejects_float_trigger() -> None:
+    """AlarmSet.Base does not support floating-point equality triggers."""
+    with pytest.raises(TypeError, match="trigger type"):
+        build_alarm(
+            trigger_name=TriggerAssembly.FLOAT_TRIGGER,
+            trigger_value=1.5,
+        )
+
+
+def test_alarm_trigger_must_belong_to_data_assembly() -> None:
+    """A trigger cannot be linked through an unrelated DataAssembly."""
+    assembly = TriggerAssembly("Triggers")
+    foreign = TriggerAssembly("Foreign")
+
+    with pytest.raises(ValueError, match="DataAssembly"):
+        Alarm(
+            tag_name="Foreign.Alarm",
+            data_assembly=assembly,
+            trigger=foreign.get_item(TriggerAssembly.BOOL_TRIGGER),
+            trigger_value=True,
+            severity=500,
+            ack_required=True,
+            message="Foreign trigger.",
+        )
+
+
+def test_base_alarm_does_not_install_runtime_callbacks() -> None:
+    """Describing a base alarm must not alter DataItem runtime behavior."""
+    assembly = TriggerAssembly("Triggers")
+    trigger = assembly.get_item(TriggerAssembly.BOOL_TRIGGER)
+    internal_callback = trigger.int_wrt_cb
+    external_callback = trigger.ext_wrt_cb
+
+    alarm = build_alarm(assembly=assembly)
+
+    assert trigger.int_wrt_cb is internal_callback
+    assert trigger.ext_wrt_cb is external_callback
+    assert not hasattr(alarm, "acknowledge")
+    assert not hasattr(alarm, "shelve")

mtppy/pea/__init__.py

@@ -0,0 +1,19 @@
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from mtppy.pea.rmtp_pea import RMTPPea
+
+__all__ = ["RMTPPea"]
+
+
+def __getattr__(name: str):
+    if name == "RMTPPea":
+        from mtppy.pea.rmtp_pea import RMTPPea
+
+        return RMTPPea
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

mtppy/pea/data_assembly_factory.py

@@ -0,0 +1,124 @@
+"""Factory for creating data assemblies from a DataAssemblyConfig dictionary.
+
+This module provides a factory class for creating DataAssembly instances
+based on a configuration dictionaries of type DataAssemblyConfig.
+
+"""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from typing import ClassVar
+
+from mtppy.part3.data_assembly_set.data_assembly import DataAssembly
+from mtppy.part3.data_assembly_set.pea_elements.pea_information_label.pea_information_label import (
+    PeaInformationLabel,
+)
+from mtppy.part3.data_assembly_set.active_elements.pid.pid_ctrl import PIDCtrl
+from mtppy.part3.data_assembly_set.indicator_elements.views.ana_view import AnaView
+from mtppy.part3.data_assembly_set.indicator_elements.views.bin_view import BinView
+from mtppy.part3.data_assembly_set.indicator_elements.views.dint_view import DIntView
+from mtppy.part3.data_assembly_set.indicator_elements.views.string_view import (
+    StringView,
+)
+from mtppy.part4.automation_services.service_elements.parameter_elements.ana_serv_param import (
+    AnaServParam,
+)
+from mtppy.part4.automation_services.service_elements.parameter_elements.bin_serv_param import (
+    BinServParam,
+)
+from mtppy.part4.automation_services.service_elements.parameter_elements.dint_serv_param import (
+    DIntServParam,
+)
+from mtppy.part4.automation_services.service_elements.parameter_elements.string_serv_param import (
+    StringServParam,
+)
+from mtppy.part4.automation_services.service_elements.procedure_health_view import (
+    ProcedureHealthView,
+)
+from mtppy.part4.automation_services.service_elements.service_control import (
+    ServiceControl,
+)
+
+DataAssemblyConfig = dict[str, str | dict[str, str | None]]
+
+
+class DataAssemblyFactory:
+    """Factory class for creating DataAssembly instances."""
+
+    _ROOT: str = "MTPDataAssemblySUCLib/DataAssembly"
+
+    _FACTORY: ClassVar[dict[str, type[DataAssembly]]] = {
+        f"{_ROOT}/ActiveElement/PIDCtrl": PIDCtrl,
+        f"{_ROOT}/IndicatorElement/AnaView": AnaView,
+        f"{_ROOT}/IndicatorElement/BinView": BinView,
+        f"{_ROOT}/IndicatorElement/DIntView": DIntView,
+        f"{_ROOT}/IndicatorElement/StringView": StringView,
+        f"{_ROOT}/ServiceElement/ParameterElement/DIntServParam": DIntServParam,
+        f"{_ROOT}/ServiceElement/ParameterElement/AnaServParam": AnaServParam,
+        f"{_ROOT}/ServiceElement/ParameterElement/BinServParam": BinServParam,
+        f"{_ROOT}/ServiceElement/ParameterElement/StringServParam": StringServParam,
+        f"{_ROOT}/PeaElement/PeaInformationLabel": PeaInformationLabel,
+        f"{_ROOT}/ServiceElement/ProcedureHealthView": ProcedureHealthView,
+        # TODO: reintroduce after fixing namespace handling
+        # f"{_ROOT}/ServiceElement/ServiceControl": ServiceControl,
+    }
+
+    @staticmethod
+    def create_data_assemblies(
+        da_dict: dict[str, DataAssemblyConfig],
+    ) -> dict[str, DataAssembly]:
+        """Create multiple DataAssembly instances from a dictionary of configurations.
+
+        Args:
+            da_dict: Dictionary mapping names to DataAssemblyConfig dictionaries.
+
+        Returns:
+            Dictionary mapping names to created DataAssembly instances.
+        """
+        data_assemblies: dict[str, DataAssembly] = {}
+        for key, value in da_dict.items():
+            data_assembly = DataAssemblyFactory.create_data_assembly(value)
+            if data_assembly is not None:
+                data_assemblies[key] = data_assembly
+        return data_assemblies
+
+    @staticmethod
+    def create_data_assembly(config: DataAssemblyConfig) -> DataAssembly | None:
+        """Create a single DataAssembly instance from a configuration entry.
+        If a default value is given in the config this value is set as init_value of
+        the underlying DataItem and the actual value of the DataAssembly is
+        initialized accordingly.
+
+        Args:
+            config: Configuration dictionary for the data assembly.
+
+        Returns:
+            Created DataAssembly instance.
+        """
+
+        da_type: str = config["RefBaseSystemUnitPath"]
+        tag_name: str = config["TagName"]["value"]
+        tag_description: str = (
+            config["TagDescription"]["value"] if "TagDescription" in config else ""
+        )
+
+        if da_type in DataAssemblyFactory._FACTORY:
+            instance = DataAssemblyFactory._FACTORY[da_type](
+                tag_name=tag_name,
+                tag_description=tag_description,
+            )
+            for alias, v in config.items():
+                if (
+                    "default" in v
+                    and v["default"] is not None
+                    and len(v["default"]) > 0
+                ):
+                    if alias in instance.keys():
+                        da = instance.get_item(alias)
+                        da.init_value = da.w3c_xml_data_type.converse(v["default"])
+                        instance[alias] = da.w3c_xml_data_type.converse(v["default"])
+            return instance
+        return None

mtppy/pea/data_assembly_factory_test.py

@@ -0,0 +1,229 @@
+"""
+Unit tests for the DataAssemblyFactory class.
+
+This module contains tests for the DataAssemblyFactory which creates
+DataAssembly instances from configuration dictionaries.
+"""
+
+import pytest
+
+from mtppy.pea.data_assembly_factory import DataAssemblyFactory, DataAssemblyConfig
+from mtppy.part3.data_assembly_set.data_assembly import DataAssembly
+from mtppy.part3.data_assembly_set.active_elements.pid.pid_ctrl import PIDCtrl
+from mtppy.part3.data_assembly_set.indicator_elements.views.ana_view import AnaView
+from mtppy.part3.data_assembly_set.pea_elements.pea_information_label.pea_information_label import (
+    PeaInformationLabel,
+)
+from mtppy.part4.automation_services.service_elements.procedure_health_view import (
+    ProcedureHealthView,
+)
+from mtppy.part4.automation_services.service_elements.service_control import (
+    ServiceControl,
+)
+
+
+@pytest.fixture
+def basic_config() -> DataAssemblyConfig:
+    """Create a basic configuration for testing."""
+    return {
+        "RefBaseSystemUnitPath": "MTPDataAssemblySUCLib/DataAssembly/IndicatorElement/AnaView",
+        "TagName": {"value": "TestAnaView"},
+        "TagDescription": {"value": "Test Description"},
+        "VSclMin": {"default": "10"},
+        "VSclMax": {"default": "100"},
+    }
+
+
+@pytest.fixture
+def pid_config() -> DataAssemblyConfig:
+    """Create a PID controller configuration for testing."""
+    return {
+        "RefBaseSystemUnitPath": "MTPDataAssemblySUCLib/DataAssembly/ActiveElement/PIDCtrl",
+        "TagName": {"value": "TestPID"},
+        "TagDescription": {"value": "Test PID Controller"},
+        "PVSclMin": {"default": "-100.0"},
+        "PVSclMax": {"default": "100.0"},
+    }
+
+
+@pytest.fixture
+def ana_serv_config() -> DataAssemblyConfig:
+    """Create an ana serv parameter configuration for testing."""
+    return {
+        "RefBaseSystemUnitPath": "MTPDataAssemblySUCLib/DataAssembly/ServiceElement/ParameterElement/AnaServParam",
+        "TagName": {"value": "Input Setpoint"},
+        "VMin": {"default": "10.0"},
+        "VMax": {"default": "90.0"},
+        "VSclMin": {"default": "0.0"},
+        "VSclMax": {"default": "100.0"},
+    }
+
+
+def test_create_data_assembly_success(basic_config: DataAssemblyConfig):
+    """Test successful creation of a DataAssembly instance."""
+    # Test with basic configuration
+    data_assembly = DataAssemblyFactory.create_data_assembly(basic_config)
+
+    assert data_assembly is not None
+    assert isinstance(data_assembly, AnaView)
+    assert hasattr(data_assembly, "tag_name")
+    assert hasattr(data_assembly, "tag_description")
+    assert data_assembly.tag_name == "TestAnaView"
+    assert data_assembly.tag_description == "Test Description"
+    assert data_assembly.VSclMin == 10.0
+    assert data_assembly.VSclMax == 100.0
+
+
+def test_create_data_assembly_with_default_value(basic_config: DataAssemblyConfig):
+    """Test DataAssembly creation with default value."""
+    # Modify config to include another default value
+    basic_config["VSclMin"] = {"default": "20.0"}
+
+    data_assembly = DataAssemblyFactory.create_data_assembly(basic_config)
+
+    # Check that default value was set correctly
+
+    assert data_assembly is not None
+    assert data_assembly["VSclMin"] == 20.0
+
+
+def test_created_data_assembly_inner_logic(ana_serv_config: DataAssemblyConfig):
+    data_assembly = DataAssemblyFactory.create_data_assembly(ana_serv_config)
+
+    # setup channels for internal access
+    assert data_assembly is not None
+    data_assembly.service_op_mode.StateChannel = True
+    data_assembly.service_src_mode.SrcChannel = True
+    # put in automatic state (from off most obviously)
+    data_assembly.service_op_mode.StateAutAut = True
+    assert data_assembly.service_op_mode.StateAutAct == True
+    # put in internal state
+    data_assembly.service_src_mode.SrcIntAut = True
+    assert data_assembly.service_src_mode.SrcIntAct == True
+
+    # set a value within the bounds
+    data_assembly.VInt = 30
+    data_assembly.ApplyInt = True
+    assert data_assembly.VOut == 30
+
+    # set a value outside the bounds
+    data_assembly.VInt = -10
+    data_assembly.ApplyInt = True
+    assert data_assembly.VOut == 30
+
+
+def test_create_data_assembly_pid_controller(pid_config: DataAssemblyConfig):
+    """Test creation of PID controller DataAssembly."""
+    data_assembly = DataAssemblyFactory.create_data_assembly(pid_config)
+
+    assert data_assembly is not None
+    assert isinstance(data_assembly, PIDCtrl)
+    assert data_assembly.tag_name == "TestPID"
+    assert data_assembly.tag_description == "Test PID Controller"
+    assert data_assembly.PVSclMin == -100.0
+    assert data_assembly.PVSclMax == 100.0
+
+
+@pytest.mark.parametrize(
+    ("assembly_type", "path"),
+    [
+        (
+            PeaInformationLabel,
+            "MTPDataAssemblySUCLib/DataAssembly/PeaElement/PeaInformationLabel",
+        ),
+        (
+            ProcedureHealthView,
+            "MTPDataAssemblySUCLib/DataAssembly/ServiceElement/ProcedureHealthView",
+        ),
+        # TODO: reintroduce after fixing namespace handling
+        #        (
+        #            ServiceControl,
+        #            "MTPDataAssemblySUCLib/DataAssembly/ServiceElement/ServiceControl",
+        #        ),
+    ],
+)
+def test_create_newly_supported_data_assemblies(
+    assembly_type: type[DataAssembly], path: str
+):
+    """Create each data assembly type registered by the factory."""
+    config: DataAssemblyConfig = {
+        "RefBaseSystemUnitPath": path,
+        "TagName": {"value": "TestAssembly"},
+        "TagDescription": {"value": "Test description"},
+    }
+
+    data_assembly = DataAssemblyFactory.create_data_assembly(config)
+
+    assert data_assembly is not None
+    assert isinstance(data_assembly, assembly_type)
+    assert data_assembly.tag_name == "TestAssembly"
+    assert data_assembly.tag_description == "Test description"
+
+
+def test_create_data_assembly_returns_none_for_unknown_type():
+    """Unsupported AML paths are ignored by the factory."""
+    config: DataAssemblyConfig = {
+        "RefBaseSystemUnitPath": "Unknown/DataAssembly",
+        "TagName": {"value": "Unsupported"},
+    }
+
+    assert DataAssemblyFactory.create_data_assembly(config) is None
+
+
+def test_create_data_assembly_ignores_empty_default(basic_config: DataAssemblyConfig):
+    """Empty defaults do not overwrite a class default value."""
+    basic_config["VSclMin"] = {"default": ""}
+
+    data_assembly = DataAssemblyFactory.create_data_assembly(basic_config)
+
+    assert data_assembly is not None
+    assert data_assembly.VSclMin == 0.0
+
+
+def test_create_data_assemblies_multiple():
+    """Test creating multiple DataAssembly instances."""
+    config_dict: dict[str, DataAssemblyConfig] = {
+        "assembly1": {
+            "RefBaseSystemUnitPath": "MTPDataAssemblySUCLib/DataAssembly/IndicatorElement/AnaView",
+            "TagName": {"value": "TestAnaView1"},
+            "TagDescription": {"value": "Test Description 1"},
+        },
+        "assembly2": {
+            "RefBaseSystemUnitPath": "MTPDataAssemblySUCLib/DataAssembly/IndicatorElement/BinView",
+            "TagName": {"value": "TestBinView"},
+            "TagDescription": {"value": "Test Description 2"},
+        },
+    }
+
+    assemblies = DataAssemblyFactory.create_data_assemblies(config_dict)
+
+    assert len(assemblies) == 2
+    assert "assembly1" in assemblies
+    assert "assembly2" in assemblies
+    assert assemblies["assembly1"].tag_name == "TestAnaView1"
+    assert assemblies["assembly2"].tag_name == "TestBinView"
+
+
+def test_factory_contains_expected_types():
+    """Test that the factory contains expected types."""
+    expected_types = [
+        "MTPDataAssemblySUCLib/DataAssembly/ActiveElement/PIDCtrl",
+        "MTPDataAssemblySUCLib/DataAssembly/IndicatorElement/AnaView",
+        "MTPDataAssemblySUCLib/DataAssembly/IndicatorElement/BinView",
+        "MTPDataAssemblySUCLib/DataAssembly/IndicatorElement/DIntView",
+        "MTPDataAssemblySUCLib/DataAssembly/ServiceElement/ParameterElement/DIntServParam",
+        "MTPDataAssemblySUCLib/DataAssembly/ServiceElement/ParameterElement/AnaServParam",
+        "MTPDataAssemblySUCLib/DataAssembly/ServiceElement/ParameterElement/BinServParam",
+        "MTPDataAssemblySUCLib/DataAssembly/ServiceElement/ParameterElement/StringServParam",
+        "MTPDataAssemblySUCLib/DataAssembly/PeaElement/PeaInformationLabel",
+        "MTPDataAssemblySUCLib/DataAssembly/ServiceElement/ProcedureHealthView",
+        # TODO: reintroduce after fixing namespace handling
+        # "MTPDataAssemblySUCLib/DataAssembly/ServiceElement/ServiceControl",
+    ]
+
+    for expected_type in expected_types:
+        assert expected_type in DataAssemblyFactory._FACTORY
+
+
+if __name__ == "__main__":
+    pytest.main([__file__])

mtppy/pea/mtp_generator/__init__.py

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