iris-pex-embedded-python 4.0.0b5__tar.gz → 4.0.0b6__tar.gz

{iris_pex_embedded_python-4.0.0b5/src/iris_pex_embedded_python.egg-info → iris_pex_embedded_python-4.0.0b6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris_pex_embedded_python
-Version: 4.0.0b5
+Version: 4.0.0b6
 Summary: Iris Interoperability based on Embedded Python
 Author-email: grongier <guillaume.rongier@intersystems.com>
 License: MIT License

{iris_pex_embedded_python-4.0.0b5 → iris_pex_embedded_python-4.0.0b6}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 
 [project]
 name = "iris_pex_embedded_python"
-version = "4.0.0b5"
+version = "4.0.0b6"
 description = "Iris Interoperability based on Embedded Python"
 readme = "README.md"
 requires-python = ">=3.10"

{iris_pex_embedded_python-4.0.0b5 → iris_pex_embedded_python-4.0.0b6}/src/iop/production/declarations.py

@@ -2,18 +2,23 @@ from __future__ import annotations
 
 from collections.abc import Iterable, Mapping
 from dataclasses import dataclass, field
-from typing import Any, ClassVar
+from typing import Any, ClassVar, Protocol
 
 from .common import SETTING_NAME_ALIASES
 from .types import TargetSetting
 
 
+class _NamedRouteTarget(Protocol):
+    @property
+    def name(self) -> str: ...
+
+
 @dataclass(frozen=True)
 class Route:
     """Declarative route from a production item port to one or more targets."""
 
     port: str | TargetSetting
-    targets: str | Iterable[str]
+    targets: str | _NamedRouteTarget | Iterable[str | _NamedRouteTarget]
     logical_name: str = ""
 
     @property
@@ -36,13 +41,19 @@ class Route:
 
     @property
     def target_names(self) -> tuple[str, ...]:
-        if isinstance(self.targets, str):
+        if _is_route_target(self.targets):
             targets = (self.targets,)
         else:
-            targets = tuple(str(target) for target in self.targets)
+            try:
+                targets = tuple(self.targets)
+            except TypeError as exc:
+                raise TypeError(
+                    f"Route {self.port_name!r} targets must be an item name, "
+                    "a production item declaration, or an iterable of either"
+                ) from exc
         if not targets:
             raise ValueError(f"Route {self.port_name!r} requires at least one target")
-        return targets
+        return tuple(_route_target_name(target, self.port_name) for target in targets)
 
 
 @dataclass(frozen=True)
@@ -143,6 +154,24 @@ def normalize_route_port_for_match(name: str | TargetSetting) -> str:
     return normalize_route_port(name)
 
 
+def _is_route_target(value: Any) -> bool:
+    return isinstance(value, str) or isinstance(value, _ProductionItemDeclaration)
+
+
+def _route_target_name(value: Any, port_name: str) -> str:
+    if isinstance(value, str):
+        if value:
+            return value
+    elif isinstance(value, _ProductionItemDeclaration):
+        if value.name:
+            return value.name
+
+    raise TypeError(
+        f"Route {port_name!r} targets must be item names or production item "
+        "declarations"
+    )
+
+
 def _mapping(
     values: Mapping[str, Any] | None,
     field_name: str,

iris_pex_embedded_python-4.0.0b6/src/iop/production/declarative.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Any, ClassVar
+
+from .component import ComponentRef
+from .declarations import (
+    _ProductionItemDeclaration,
+    normalize_route_port_for_match,
+)
+
+
+class _DeclarativeProductionMixin:
+    components: ClassVar[Iterable[_ProductionItemDeclaration] | None] = ()
+    services: ClassVar[Iterable[_ProductionItemDeclaration] | None] = ()
+    processes: ClassVar[Iterable[_ProductionItemDeclaration] | None] = ()
+    operations: ClassVar[Iterable[_ProductionItemDeclaration] | None] = ()
+
+    def _hydrate_declared_items(self) -> None:
+        declarations: list[_ProductionItemDeclaration] = []
+        for attr_name, expected_kind in (
+            ("components", "component"),
+            ("services", "service"),
+            ("processes", "process"),
+            ("operations", "operation"),
+        ):
+            for declaration in self._declared_items(attr_name):
+                if declaration.kind != expected_kind:
+                    raise TypeError(
+                        f"{attr_name} must contain {expected_kind.title()}Item "
+                        f"declarations"
+                    )
+                self._raise_declared_route_conflicts(declaration)
+                self._add_declared_item(declaration)
+                declarations.append(declaration)
+
+        for declaration in declarations:
+            self._connect_declared_routes(declaration)
+
+    def _declared_items(self, attr_name: str) -> tuple[_ProductionItemDeclaration, ...]:
+        values = getattr(type(self), attr_name, ())
+        if values is None:
+            return ()
+        if isinstance(values, _ProductionItemDeclaration):
+            return (values,)
+        try:
+            declarations = tuple(values)
+        except TypeError as exc:
+            raise TypeError(f"{attr_name} must be an iterable of item declarations") from exc
+        for declaration in declarations:
+            if not isinstance(declaration, _ProductionItemDeclaration):
+                raise TypeError(f"{attr_name} must contain production item declarations")
+        return declarations
+
+    def _raise_declared_route_conflicts(
+        self,
+        declaration: _ProductionItemDeclaration,
+    ) -> None:
+        host_ports = {
+            normalize_route_port_for_match(name)
+            for name in declaration.host_setting_values
+        }
+        route_ports = {route.port_name for route in declaration.route_values}
+        conflicts = sorted(host_ports & route_ports)
+        if not conflicts:
+            return
+        names = ", ".join(repr(name) for name in conflicts)
+        raise ValueError(
+            f"{declaration.kind.title()} item {declaration.name!r} declares route "
+            f"port(s) in Host settings: {names}. Declare route ports with Route only."
+        )
+
+    def _add_declared_item(self, declaration: _ProductionItemDeclaration) -> None:
+        kwargs: dict[str, Any] = {
+            "enabled": declaration.enabled,
+            "pool_size": declaration.pool_size,
+            "category": declaration.category,
+            "foreground": declaration.foreground,
+            "comment": declaration.comment,
+            "log_trace_events": declaration.log_trace_events,
+            "schedule": declaration.schedule,
+            "settings": declaration.host_setting_values,
+            "adapter_settings": declaration.adapter_setting_values,
+        }
+        if declaration.adapter_class is not None:
+            kwargs["adapter_class"] = declaration.adapter_class
+        if declaration.adapter_class_name is not None:
+            kwargs["adapter_class_name"] = declaration.adapter_class_name
+
+        method = {
+            "component": self.component,
+            "service": self.service,
+            "process": self.process,
+            "operation": self.operation,
+        }[declaration.kind]
+
+        component = declaration.component
+        if isinstance(component, type):
+            if declaration.class_name is not None:
+                kwargs["class_name"] = declaration.class_name
+            ref = method(declaration.name, component, **kwargs)
+            ref.other_settings = declaration.other_setting_values
+            return
+
+        class_name = declaration.class_name
+        if component is not None:
+            component_class_name = str(component)
+            if class_name is not None and class_name != component_class_name:
+                raise ValueError(
+                    f"{declaration.kind.title()} item {declaration.name!r} "
+                    "declares conflicting component and class_name values"
+                )
+            class_name = component_class_name
+
+        if class_name is None:
+            raise ValueError(
+                f"{declaration.kind.title()} item {declaration.name!r} requires "
+                "a component class or class_name"
+            )
+        kwargs["class_name"] = class_name
+        ref = method(declaration.name, **kwargs)
+        ref.other_settings = declaration.other_setting_values
+
+    def _connect_declared_routes(self, declaration: _ProductionItemDeclaration) -> None:
+        source = self.item(declaration.name)
+        for route in declaration.route_values:
+            self._raise_if_route_port_owner_mismatch(source, route)
+            port = source.port(
+                route.port_name,
+                logical_name=route.route_logical_name,
+            )
+            targets = route.target_names
+            self.connect(port, targets[0])
+            for target in targets[1:]:
+                self.connect_add(port, target)
+
+    def _raise_if_route_port_owner_mismatch(
+        self,
+        source: ComponentRef,
+        route: Any,
+    ) -> None:
+        owner = route.port_owner
+        if (
+            owner is None
+            or source.component_class is None
+            or issubclass(source.component_class, owner)
+        ):
+            return
+        raise ValueError(
+            f"Route port {route.port_name!r} belongs to "
+            f"{owner.__module__}.{owner.__qualname__}, not "
+            f"{source.component_class.__module__}."
+            f"{source.component_class.__qualname__}"
+        )

{iris_pex_embedded_python-4.0.0b5 → iris_pex_embedded_python-4.0.0b6}/src/iop/production/model.py

@@ -11,10 +11,7 @@ from .common import (
     _auto_proxy_class_name,
 )
 from .component import ComponentRef
-from .declarations import (
-    _ProductionItemDeclaration,
-    normalize_route_port_for_match,
-)
+from .declarative import _DeclarativeProductionMixin
 from .diff import _diff_productions
 from .inspection import component_runtime_info, inspect_component
 from .reconstruction import production_from_dict
@@ -38,7 +35,7 @@ from .types import (
 _MISSING = object()
 
 
-class Production:
+class Production(_DeclarativeProductionMixin):
     """Python authoring DSL for IRIS interoperability production topology.
 
     Python Production is the source of truth for Python-authored topology.
@@ -62,8 +59,80 @@ class Production:
         alert_action_window: int | str | object = _MISSING,
         namespace: str | None | object = _MISSING,
         director: _DirectorProtocol | None | object = _MISSING,
-        _hydrate_declarations: bool = True,
     ):
+        self._initialize(
+            name,
+            testing_enabled=testing_enabled,
+            log_general_trace_events=log_general_trace_events,
+            actor_pool_size=actor_pool_size,
+            description=description,
+            shutdown_timeout=shutdown_timeout,
+            update_timeout=update_timeout,
+            alert_notification_manager=alert_notification_manager,
+            alert_notification_operation=alert_notification_operation,
+            alert_notification_recipients=alert_notification_recipients,
+            alert_action_window=alert_action_window,
+            namespace=namespace,
+            director=director,
+            hydrate_declarations=True,
+        )
+
+    @classmethod
+    def _new_unhydrated(
+        cls,
+        name: str | object = _MISSING,
+        *,
+        testing_enabled: bool | str | object = _MISSING,
+        log_general_trace_events: bool | str | object = _MISSING,
+        actor_pool_size: int | str | object = _MISSING,
+        description: str | object = _MISSING,
+        shutdown_timeout: int | str | object = _MISSING,
+        update_timeout: int | str | object = _MISSING,
+        alert_notification_manager: str | object = _MISSING,
+        alert_notification_operation: str | object = _MISSING,
+        alert_notification_recipients: str | object = _MISSING,
+        alert_action_window: int | str | object = _MISSING,
+        namespace: str | None | object = _MISSING,
+        director: _DirectorProtocol | None | object = _MISSING,
+    ) -> Production:
+        production = object.__new__(cls)
+        Production._initialize(
+            production,
+            name,
+            testing_enabled=testing_enabled,
+            log_general_trace_events=log_general_trace_events,
+            actor_pool_size=actor_pool_size,
+            description=description,
+            shutdown_timeout=shutdown_timeout,
+            update_timeout=update_timeout,
+            alert_notification_manager=alert_notification_manager,
+            alert_notification_operation=alert_notification_operation,
+            alert_notification_recipients=alert_notification_recipients,
+            alert_action_window=alert_action_window,
+            namespace=namespace,
+            director=director,
+            hydrate_declarations=False,
+        )
+        return production
+
+    def _initialize(
+        self,
+        name: str | object = _MISSING,
+        *,
+        testing_enabled: bool | str | object = _MISSING,
+        log_general_trace_events: bool | str | object = _MISSING,
+        actor_pool_size: int | str | object = _MISSING,
+        description: str | object = _MISSING,
+        shutdown_timeout: int | str | object = _MISSING,
+        update_timeout: int | str | object = _MISSING,
+        alert_notification_manager: str | object = _MISSING,
+        alert_notification_operation: str | object = _MISSING,
+        alert_notification_recipients: str | object = _MISSING,
+        alert_action_window: int | str | object = _MISSING,
+        namespace: str | None | object = _MISSING,
+        director: _DirectorProtocol | None | object = _MISSING,
+        hydrate_declarations: bool,
+    ) -> None:
         self.name = self._resolve_production_name(name)
         self.testing_enabled = self._production_default(
             "testing_enabled", testing_enabled, False
@@ -114,7 +183,7 @@ class Production:
         self._graph_warnings: list[str] = []
         self._queue_info: dict[str, dict[str, Any]] = {}
         self._messages: list[PersistentMessageRegistration] = []
-        if _hydrate_declarations:
+        if hydrate_declarations:
             self._hydrate_declared_items()
 
     def _resolve_production_name(self, name: str | object) -> str:
@@ -138,143 +207,6 @@ class Production:
             return class_value
         return default
 
-    def _hydrate_declared_items(self) -> None:
-        declarations: list[_ProductionItemDeclaration] = []
-        for attr_name, expected_kind in (
-            ("components", "component"),
-            ("services", "service"),
-            ("processes", "process"),
-            ("operations", "operation"),
-        ):
-            for declaration in self._declared_items(attr_name):
-                if declaration.kind != expected_kind:
-                    raise TypeError(
-                        f"{attr_name} must contain {expected_kind.title()}Item "
-                        f"declarations"
-                    )
-                self._raise_declared_route_conflicts(declaration)
-                self._add_declared_item(declaration)
-                declarations.append(declaration)
-
-        for declaration in declarations:
-            self._connect_declared_routes(declaration)
-
-    def _declared_items(self, attr_name: str) -> tuple[_ProductionItemDeclaration, ...]:
-        values = getattr(type(self), attr_name, ())
-        if values is None:
-            return ()
-        if isinstance(values, _ProductionItemDeclaration):
-            return (values,)
-        try:
-            declarations = tuple(values)
-        except TypeError as exc:
-            raise TypeError(f"{attr_name} must be an iterable of item declarations") from exc
-        for declaration in declarations:
-            if not isinstance(declaration, _ProductionItemDeclaration):
-                raise TypeError(f"{attr_name} must contain production item declarations")
-        return declarations
-
-    def _raise_declared_route_conflicts(
-        self,
-        declaration: _ProductionItemDeclaration,
-    ) -> None:
-        host_ports = {
-            normalize_route_port_for_match(name)
-            for name in declaration.host_setting_values
-        }
-        route_ports = {route.port_name for route in declaration.route_values}
-        conflicts = sorted(host_ports & route_ports)
-        if not conflicts:
-            return
-        names = ", ".join(repr(name) for name in conflicts)
-        raise ValueError(
-            f"{declaration.kind.title()} item {declaration.name!r} declares route "
-            f"port(s) in Host settings: {names}. Declare route ports with Route only."
-        )
-
-    def _add_declared_item(self, declaration: _ProductionItemDeclaration) -> None:
-        kwargs: dict[str, Any] = {
-            "enabled": declaration.enabled,
-            "pool_size": declaration.pool_size,
-            "category": declaration.category,
-            "foreground": declaration.foreground,
-            "comment": declaration.comment,
-            "log_trace_events": declaration.log_trace_events,
-            "schedule": declaration.schedule,
-            "settings": declaration.host_setting_values,
-            "adapter_settings": declaration.adapter_setting_values,
-        }
-        if declaration.adapter_class is not None:
-            kwargs["adapter_class"] = declaration.adapter_class
-        if declaration.adapter_class_name is not None:
-            kwargs["adapter_class_name"] = declaration.adapter_class_name
-
-        method = {
-            "component": self.component,
-            "service": self.service,
-            "process": self.process,
-            "operation": self.operation,
-        }[declaration.kind]
-
-        component = declaration.component
-        if isinstance(component, type):
-            if declaration.class_name is not None:
-                kwargs["class_name"] = declaration.class_name
-            ref = method(declaration.name, component, **kwargs)
-            ref.other_settings = declaration.other_setting_values
-            return
-
-        class_name = declaration.class_name
-        if component is not None:
-            component_class_name = str(component)
-            if class_name is not None and class_name != component_class_name:
-                raise ValueError(
-                    f"{declaration.kind.title()} item {declaration.name!r} "
-                    "declares conflicting component and class_name values"
-                )
-            class_name = component_class_name
-
-        if class_name is None:
-            raise ValueError(
-                f"{declaration.kind.title()} item {declaration.name!r} requires "
-                "a component class or class_name"
-            )
-        kwargs["class_name"] = class_name
-        ref = method(declaration.name, **kwargs)
-        ref.other_settings = declaration.other_setting_values
-
-    def _connect_declared_routes(self, declaration: _ProductionItemDeclaration) -> None:
-        source = self.item(declaration.name)
-        for route in declaration.route_values:
-            self._raise_if_route_port_owner_mismatch(source, route)
-            port = source.port(
-                route.port_name,
-                logical_name=route.route_logical_name,
-            )
-            targets = route.target_names
-            self.connect(port, targets[0])
-            for target in targets[1:]:
-                self.connect_add(port, target)
-
-    def _raise_if_route_port_owner_mismatch(
-        self,
-        source: ComponentRef,
-        route: Any,
-    ) -> None:
-        owner = route.port_owner
-        if (
-            owner is None
-            or source.component_class is None
-            or issubclass(source.component_class, owner)
-        ):
-            return
-        raise ValueError(
-            f"Route port {route.port_name!r} belongs to "
-            f"{owner.__module__}.{owner.__qualname__}, not "
-            f"{source.component_class.__module__}."
-            f"{source.component_class.__qualname__}"
-        )
-
     def testing(self, enabled: bool | str = True) -> Production:
         self.testing_enabled = enabled
         return self
@@ -337,11 +269,10 @@ class Production:
         namespace: str | None = None,
         director: _DirectorProtocol | None = None,
     ) -> Production:
-        seed = cls(
+        seed = cls._new_unhydrated(
             name,
             namespace=namespace,
             director=director,
-            _hydrate_declarations=False,
         )
         runtime_director = _ProductionRuntime(seed).director
         exported = runtime_director.export_production(name)

{iris_pex_embedded_python-4.0.0b5 → iris_pex_embedded_python-4.0.0b6}/src/iop/production/reconstruction.py

@@ -28,7 +28,7 @@ def production_from_dict(
 ):
     production_name, production_data = _production_payload(data)
     production_settings = _split_production_settings(production_data.get("Setting"))
-    production = production_cls(
+    production = production_cls._new_unhydrated(
         production_name,
         testing_enabled=production_data.get("@TestingEnabled", False),
         log_general_trace_events=production_data.get("@LogGeneralTraceEvents", False),
@@ -48,7 +48,6 @@ def production_from_dict(
         alert_action_window=production_settings.get("alert_action_window", 60),
         namespace=namespace,
         director=director,
-        _hydrate_declarations=False,
     )
 
     _add_imported_items(production, production_data)

{iris_pex_embedded_python-4.0.0b5 → iris_pex_embedded_python-4.0.0b6}/src/iop/production/rendering.py

@@ -88,7 +88,10 @@ def production_to_python(production) -> str:
 
 def production_to_class(production) -> str:
     item_names = {item.name for item in production.items}
-    route_targets = _valid_route_targets(_route_targets(production, item_names), item_names)
+    route_targets = _valid_route_targets(
+        _route_targets(production, item_names),
+        item_names,
+    )
     item_groups = _class_item_groups(production.items)
     used_items = {
         _class_item_type(kind)
@@ -105,12 +108,23 @@ def production_to_class(production) -> str:
         "# Generated from IRIS production export.",
         "# Review before using as source of truth; some runtime/dynamic routing intent",
         "# cannot be fully reconstructed from deployed IRIS metadata.",
-        f"from iop import {', '.join(imports)}",
-        "",
-        "",
-        f"class {class_name}(Production):",
-        f"    name = {_literal(production.name)}",
     ]
+    if _has_string_python_proxy_items(production.items):
+        lines.extend(
+            [
+                "# TODO: replace Python.* string class names with imported Python",
+                "# classes before re-migration, or ensure the proxy classes already exist.",
+            ]
+        )
+    lines.extend(
+        [
+            f"from iop import {', '.join(imports)}",
+            "",
+            "",
+            f"class {class_name}(Production):",
+            f"    name = {_literal(production.name)}",
+        ]
+    )
     lines.extend(_class_production_setting_lines(production))
     lines.append("")
 
@@ -119,10 +133,10 @@ def production_to_class(production) -> str:
         if not items:
             continue
         attr_name = _class_item_attr(kind)
-        lines.append(f"    {attr_name} = [")
+        lines.append(f"    {attr_name} = (")
         for item in items:
             lines.extend(_class_item_lines(item, kind, route_targets))
-        lines.append("    ]")
+        lines.append("    )")
         lines.append("")
 
     unresolved = _unresolved_class_routes(production, item_names)
@@ -141,7 +155,15 @@ def production_to_class(production) -> str:
 
 
 def _class_production_setting_lines(production) -> list[str]:
-    settings = [
+    return [
+        f"    {name} = {_literal(value)}"
+        for name, value, default in _production_setting_literals(production)
+        if value != default
+    ]
+
+
+def _production_setting_literals(production) -> list[tuple[str, Any, Any]]:
+    return [
         ("testing_enabled", _bool_literal(production.testing_enabled), False),
         (
             "log_general_trace_events",
@@ -157,11 +179,6 @@ def _class_production_setting_lines(production) -> list[str]:
         ("alert_notification_recipients", production.alert_notification_recipients, ""),
         ("alert_action_window", _int_literal(production.alert_action_window), 60),
     ]
-    return [
-        f"    {name} = {_literal(value)}"
-        for name, value, default in settings
-        if value != default
-    ]
 
 
 def _class_item_groups(items) -> dict[str, list[Any]]:
@@ -179,13 +196,6 @@ def _class_item_groups(items) -> dict[str, list[Any]]:
 def _class_item_kind(item) -> str:
     if item.kind in {"service", "process", "operation"}:
         return item.kind
-    class_name = str(item.class_name or "").lower()
-    if "service" in class_name:
-        return "service"
-    if "process" in class_name:
-        return "process"
-    if "operation" in class_name:
-        return "operation"
     return "component"
 
 
@@ -239,11 +249,21 @@ def _class_item_lines(item, kind: str, route_targets) -> list[str]:
     if routes:
         kwargs.append(("routes", routes))
 
-    lines = [
-        f"        {_class_item_type(kind)}(",
-        f"            {_literal(item.name)},",
-        f"            {_literal(item.class_name or '')},",
-    ]
+    lines = []
+    if _is_string_python_proxy_item(item):
+        lines.extend(
+            [
+                "        # TODO: replace this proxy class name with the Python",
+                "        # class object if this item should be auto-registered.",
+            ]
+        )
+    lines.extend(
+        [
+            f"        {_class_item_type(kind)}(",
+            f"            {_literal(item.name)},",
+            f"            {_literal(item.class_name or '')},",
+        ]
+    )
     for name, value in kwargs:
         lines.extend(_class_keyword_lines(name, value))
     lines.append("        ),")
@@ -285,17 +305,29 @@ def _class_keyword_lines(name: str, value: Any) -> list[str]:
 def _class_route_keyword_lines(routes: list[tuple[str, list[str]]]) -> list[str]:
     if len(routes) == 1:
         port, targets = routes[0]
-        target_literal = _literal(targets[0]) if len(targets) == 1 else _literal(targets)
-        return [f"            routes=[Route({_literal(port)}, {target_literal})],"]
+        target_literal = _class_route_targets_literal(targets)
+        return [f"            routes=(Route({_literal(port)}, {target_literal}),),"]
 
-    lines = ["            routes=["]
+    lines = ["            routes=("]
     for port, targets in routes:
-        target_literal = _literal(targets[0]) if len(targets) == 1 else _literal(targets)
+        target_literal = _class_route_targets_literal(targets)
         lines.append(f"                Route({_literal(port)}, {target_literal}),")
-    lines.append("            ],")
+    lines.append("            ),")
     return lines
 
 
+def _class_route_targets_literal(targets: list[str]) -> str:
+    return _literal(targets[0]) if len(targets) == 1 else _literal(tuple(targets))
+
+
+def _has_string_python_proxy_items(items) -> bool:
+    return any(_is_string_python_proxy_item(item) for item in items)
+
+
+def _is_string_python_proxy_item(item) -> bool:
+    return str(item.class_name or "").startswith("Python.")
+
+
 def _indented_dict_keyword_lines(
     name: str,
     value: dict[str, Any],
@@ -361,37 +393,9 @@ def _production_class_name(production_name: str) -> str:
 
 
 def _production_constructor_lines(production) -> list[str]:
-    kwargs = [
-        ("testing_enabled", _bool_literal(production.testing_enabled), False),
-        (
-            "log_general_trace_events",
-            _bool_literal(production.log_general_trace_events),
-            False,
-        ),
-        ("actor_pool_size", _int_literal(production.actor_pool_size), 2),
-        ("description", production.description, ""),
-        ("shutdown_timeout", _int_literal(production.shutdown_timeout), 120),
-        ("update_timeout", _int_literal(production.update_timeout), 10),
-        (
-            "alert_notification_manager",
-            production.alert_notification_manager,
-            "",
-        ),
-        (
-            "alert_notification_operation",
-            production.alert_notification_operation,
-            "",
-        ),
-        (
-            "alert_notification_recipients",
-            production.alert_notification_recipients,
-            "",
-        ),
-        ("alert_action_window", _int_literal(production.alert_action_window), 60),
-    ]
     rendered = [
         (name, value)
-        for name, value, default in kwargs
+        for name, value, default in _production_setting_literals(production)
         if value != default
     ]
     if not rendered:

{iris_pex_embedded_python-4.0.0b5 → iris_pex_embedded_python-4.0.0b6/src/iris_pex_embedded_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris_pex_embedded_python
-Version: 4.0.0b5
+Version: 4.0.0b6
 Summary: Iris Interoperability based on Embedded Python
 Author-email: grongier <guillaume.rongier@intersystems.com>
 License: MIT License

{iris_pex_embedded_python-4.0.0b5 → iris_pex_embedded_python-4.0.0b6}/src/iris_pex_embedded_python.egg-info/SOURCES.txt

@@ -69,6 +69,7 @@ src/iop/production/actions.py
 src/iop/production/common.py
 src/iop/production/component.py
 src/iop/production/declarations.py
+src/iop/production/declarative.py
 src/iop/production/diff.py
 src/iop/production/import_.py
 src/iop/production/inspection.py