iris-pex-embedded-python 4.0.0b4__py3-none-any.whl → 4.0.0b6__py3-none-any.whl

iop/__init__.py

@@ -25,8 +25,11 @@ from iop.migration.utils import list_bindings as list_bindings
 from iop.migration.utils import register_component as register_component
 from iop.migration.utils import unbind_component as unbind_component
 from iop.migration.utils import unregister_component as unregister_component
+from iop.production import ComponentItem as ComponentItem
 from iop.production import ComponentRef as ComponentRef
+from iop.production import OperationItem as OperationItem
 from iop.production import Port as Port
+from iop.production import ProcessItem as ProcessItem
 from iop.production import Production as Production
 from iop.production import ProductionDiff as ProductionDiff
 from iop.production import ProductionDiffEntry as ProductionDiffEntry
@@ -35,6 +38,9 @@ from iop.production import ProductionValidationError as ProductionValidationErro
 from iop.production import ProductionValidationIssue as ProductionValidationIssue
 from iop.production import ProductionValidationReport as ProductionValidationReport
 from iop.production import ProductionValidationWarning as ProductionValidationWarning
+from iop.production import Route as Route
+from iop.production import ServiceItem as ServiceItem
+from iop.production import TargetSetting as TargetSetting
 from iop.production import target as target
 from iop.runtime.director import _Director
 from iop.runtime.protocol import DirectorProtocol as DirectorProtocol
@@ -44,6 +50,7 @@ __all__ = [
     "BusinessProcess",
     "BusinessService",
     "Category",
+    "ComponentItem",
     "ComponentRef",
     "Director",
     "DirectorProtocol",
@@ -54,11 +61,13 @@ __all__ = [
     "InboundAdapter",
     "Message",
     "Model",
+    "OperationItem",
     "OutboundAdapter",
     "PersistentMessage",
     "PickleMessage",
     "PollingBusinessService",
     "Port",
+    "ProcessItem",
     "Production",
     "ProductionDiff",
     "ProductionDiffEntry",
@@ -69,7 +78,10 @@ __all__ = [
     "ProductionValidationWarning",
     "PydanticMessage",
     "PydanticPickleMessage",
+    "Route",
+    "ServiceItem",
     "Setting",
+    "TargetSetting",
     "Utils",
     "bind_component",
     "controls",

iop/cli/main.py

@@ -230,6 +230,9 @@ class Command:
         if export_format == "python":
             print(production.to_python(), end="")
             return
+        if export_format == "class":
+            print(production.to_class(), end="")
+            return
         if export_format == "graph":
             print(production.graph())
             return

iop/cli/parser.py

@@ -105,7 +105,7 @@ def create_parser() -> argparse.ArgumentParser:
     export.add_argument(
         "--format",
         dest="export_format",
-        choices=("json", "python", "graph"),
+        choices=("json", "python", "class", "graph"),
         default="json",
         help="export format for -e/--export",
     )

iop/cls/IOP/Utils.cls

@@ -595,6 +595,7 @@ ClassMethod CreateProductionFromJSON(
 	#dim tPayload As %DynamicObject
 	#dim tProductionData As %DynamicObject
 	#dim tProduction As Ens.Config.Production
+	#dim tProductionClass As %Dictionary.ClassDefinition
 	#dim tItems,tDeclaredName
 	Try {
 		Return:(""=pProductionName) $$$ERROR($$$EnsErrGeneral,"Production name is required.")
@@ -614,6 +615,15 @@ ClassMethod CreateProductionFromJSON(
 			}
 		}
 
+		If ('##class(%Dictionary.ClassDefinition).%ExistsId(pProductionName)) {
+			Set tProductionClass = ##class(%Dictionary.ClassDefinition).%New()
+			Set tProductionClass.Name = pProductionName
+			Set tProductionClass.Super = "Ens.Production"
+			Set tProductionClass.ClassVersion = 25
+			Set tSC = tProductionClass.%Save()
+			Quit:$$$ISERR(tSC)
+		}
+
 		Set tProduction = ##class(Ens.Config.Production).%New()
 		Set tProduction.Name = pProductionName
 		Set tProduction.Description = ..DynamicGet(tProductionData,"Description","")

iop/components/settings.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 from enum import Enum
-from typing import Any
+from typing import Any, overload
 
 _MISSING = object()
 
@@ -45,9 +47,17 @@ class Setting:
         self.control = control or ""
         self.exclude = exclude
         self.name = ""
+        self.owner = None
 
     def __set_name__(self, owner, name):
         self.name = name
+        self.owner = owner
+
+    @overload
+    def __get__(self, instance: None, owner: type | None = None) -> Setting: ...
+
+    @overload
+    def __get__(self, instance: object, owner: type | None = None) -> Any: ...
 
     def __get__(self, instance, owner=None):
         if instance is None:

iop/migration/utils.py

@@ -1036,11 +1036,21 @@ def register_production_definition(production_name: str, production: dict):
     :param production_name: full IRIS production class name
     :param production: normalized {"Production": {...}} dictionary
     """
-    raise_on_error(
-        _iris.get_iris()
-        .cls("IOP.Utils")
-        .CreateProductionFromJSON(production_name, json.dumps(production))
-    )
+    try:
+        raise_on_error(
+            _iris.get_iris()
+            .cls("IOP.Utils")
+            .CreateProductionFromJSON(production_name, json.dumps(production))
+        )
+    except RuntimeError as exc:
+        if not _is_missing_production_class_error(exc, production_name):
+            raise
+        register_production(production_name, dict_to_xml(production))
+
+
+def _is_missing_production_class_error(exc: RuntimeError, production_name: str) -> bool:
+    message = str(exc)
+    return "CLASS DOES NOT EXIST" in message and production_name in message
 
 
 def export_production(production_name):

iop/production/__init__.py

@@ -1,6 +1,11 @@
 from __future__ import annotations
 
 from .component import ComponentRef as ComponentRef
+from .declarations import ComponentItem as ComponentItem
+from .declarations import OperationItem as OperationItem
+from .declarations import ProcessItem as ProcessItem
+from .declarations import Route as Route
+from .declarations import ServiceItem as ServiceItem
 from .model import Production as Production
 from .runtime import resolve_target as resolve_target
 from .types import GraphEdge as GraphEdge
@@ -19,10 +24,13 @@ from .validation import ProductionValidationWarning as ProductionValidationWarni
 
 __all__ = [
     "ComponentRef",
+    "ComponentItem",
     "GraphEdge",
     "GraphNode",
+    "OperationItem",
     "PersistentMessageRegistration",
     "Port",
+    "ProcessItem",
     "Production",
     "ProductionDiff",
     "ProductionDiffEntry",
@@ -31,6 +39,8 @@ __all__ = [
     "ProductionValidationIssue",
     "ProductionValidationReport",
     "ProductionValidationWarning",
+    "Route",
+    "ServiceItem",
     "TargetSetting",
     "resolve_target",
     "target",

iop/production/common.py

@@ -22,6 +22,11 @@ PRODUCTION_SETTING_FIELDS_BY_IRIS: dict[str, str] = {
     for field_name, (iris_name, _default) in PRODUCTION_SETTING_FIELDS.items()
 }
 
+SETTING_NAME_ALIASES = {
+    "target_config_name": "TargetConfigName",
+    "target_config_names": "TargetConfigNames",
+}
+
 
 def _bool_text(value: bool | str) -> str:
     if isinstance(value, bool):

iop/production/declarations.py

@@ -0,0 +1,194 @@
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass, field
+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 | _NamedRouteTarget | Iterable[str | _NamedRouteTarget]
+    logical_name: str = ""
+
+    @property
+    def port_name(self) -> str:
+        return normalize_route_port(self.port)
+
+    @property
+    def port_owner(self) -> type | None:
+        if isinstance(self.port, TargetSetting):
+            return self.port.owner
+        return None
+
+    @property
+    def route_logical_name(self) -> str:
+        if self.logical_name:
+            return self.logical_name
+        if isinstance(self.port, TargetSetting):
+            return self.port.logical_name
+        return ""
+
+    @property
+    def target_names(self) -> tuple[str, ...]:
+        if _is_route_target(self.targets):
+            targets = (self.targets,)
+        else:
+            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 tuple(_route_target_name(target, self.port_name) for target in targets)
+
+
+@dataclass(frozen=True)
+class _ProductionItemDeclaration:
+    name: str
+    component: type | str | None = None
+    class_name: str | None = None
+    adapter_class: type | str | None = None
+    adapter_class_name: str | None = None
+    enabled: bool | str = True
+    pool_size: int | str = 1
+    category: str = ""
+    foreground: bool | str = False
+    comment: str = ""
+    log_trace_events: bool | str = False
+    schedule: str = ""
+    settings: Mapping[str, Any] | None = None
+    host_settings: Mapping[str, Any] | None = None
+    adapter_settings: Mapping[str, Any] | None = None
+    other_settings: Iterable[Mapping[str, Any]] | None = None
+    routes: Route | Iterable[Route] | None = field(default_factory=tuple)
+
+    kind: ClassVar[str] = "component"
+
+    @property
+    def host_setting_values(self) -> dict[str, Any]:
+        settings = _mapping(self.settings, "settings", self.name)
+        host_settings = _mapping(self.host_settings, "host_settings", self.name)
+        duplicates = sorted(settings.keys() & host_settings.keys())
+        if duplicates:
+            names = ", ".join(repr(name) for name in duplicates)
+            raise ValueError(
+                f"{self.kind.title()} item {self.name!r} declares duplicate "
+                f"Host setting keys: {names}"
+            )
+        merged = dict(settings)
+        merged.update(host_settings)
+        return merged
+
+    @property
+    def adapter_setting_values(self) -> dict[str, Any]:
+        return _mapping(self.adapter_settings, "adapter_settings", self.name)
+
+    @property
+    def other_setting_values(self) -> list[dict[str, Any]]:
+        return [dict(setting) for setting in self.other_settings or ()]
+
+    @property
+    def route_values(self) -> tuple[Route, ...]:
+        if self.routes is None:
+            return ()
+        if isinstance(self.routes, Route):
+            return (self.routes,)
+        routes = tuple(self.routes)
+        for route in routes:
+            if not isinstance(route, Route):
+                raise TypeError(
+                    f"{self.kind.title()} item {self.name!r} routes must be Route "
+                    f"instances"
+                )
+        return routes
+
+
+@dataclass(frozen=True)
+class ServiceItem(_ProductionItemDeclaration):
+    kind: ClassVar[str] = "service"
+
+
+@dataclass(frozen=True)
+class ComponentItem(_ProductionItemDeclaration):
+    kind: ClassVar[str] = "component"
+
+
+@dataclass(frozen=True)
+class ProcessItem(_ProductionItemDeclaration):
+    kind: ClassVar[str] = "process"
+
+
+@dataclass(frozen=True)
+class OperationItem(_ProductionItemDeclaration):
+    kind: ClassVar[str] = "operation"
+
+
+def normalize_route_port(name: str | TargetSetting) -> str:
+    """Normalize known Pythonic route aliases without changing other settings."""
+
+    if isinstance(name, TargetSetting):
+        if not name.name:
+            raise ValueError(
+                "Route target setting must be declared on a component class"
+            )
+        return name.name
+    port_name = str(name)
+    return SETTING_NAME_ALIASES.get(port_name, port_name)
+
+
+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,
+    item_name: str,
+) -> dict[str, Any]:
+    try:
+        return dict(values or {})
+    except (TypeError, ValueError) as exc:
+        raise TypeError(
+            f"Production item {item_name!r} {field_name} must be a mapping"
+        ) from exc
+
+
+__all__ = [
+    "ComponentItem",
+    "OperationItem",
+    "ProcessItem",
+    "Route",
+    "ServiceItem",
+]

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__}"
+        )

iop/production/model.py

@@ -11,11 +11,13 @@ from .common import (
     _auto_proxy_class_name,
 )
 from .component import ComponentRef
+from .declarative import _DeclarativeProductionMixin
 from .diff import _diff_productions
 from .inspection import component_runtime_info, inspect_component
 from .reconstruction import production_from_dict
 from .rendering import (
     production_graph,
+    production_to_class,
     production_to_dict,
     production_to_python,
     production_to_xml,
@@ -30,8 +32,10 @@ from .types import (
     _edge_identity,
 )
 
+_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.
@@ -41,42 +45,137 @@ class Production:
 
     def __init__(
         self,
-        name: str,
+        name: str | object = _MISSING,
         *,
-        testing_enabled: bool | str = False,
-        log_general_trace_events: bool | str = False,
-        actor_pool_size: int | str = 2,
-        description: str = "",
-        shutdown_timeout: int | str = PRODUCTION_SETTING_FIELDS["shutdown_timeout"][1],
-        update_timeout: int | str = PRODUCTION_SETTING_FIELDS["update_timeout"][1],
-        alert_notification_manager: str = PRODUCTION_SETTING_FIELDS[
-            "alert_notification_manager"
-        ][1],
-        alert_notification_operation: str = PRODUCTION_SETTING_FIELDS[
-            "alert_notification_operation"
-        ][1],
-        alert_notification_recipients: str = PRODUCTION_SETTING_FIELDS[
-            "alert_notification_recipients"
-        ][1],
-        alert_action_window: int | str = PRODUCTION_SETTING_FIELDS[
-            "alert_action_window"
-        ][1],
-        namespace: str | None = None,
-        director: _DirectorProtocol | None = None,
+        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,
     ):
-        self.name = name
-        self.testing_enabled = testing_enabled
-        self.log_general_trace_events = log_general_trace_events
-        self.actor_pool_size = actor_pool_size
-        self.description = description
-        self.shutdown_timeout = shutdown_timeout
-        self.update_timeout = update_timeout
-        self.alert_notification_manager = alert_notification_manager
-        self.alert_notification_operation = alert_notification_operation
-        self.alert_notification_recipients = alert_notification_recipients
-        self.alert_action_window = alert_action_window
-        self.namespace = namespace
-        self._director = director
+        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
+        )
+        self.log_general_trace_events = self._production_default(
+            "log_general_trace_events", log_general_trace_events, False
+        )
+        self.actor_pool_size = self._production_default(
+            "actor_pool_size", actor_pool_size, 2
+        )
+        self.description = self._production_default("description", description, "")
+        self.shutdown_timeout = self._production_default(
+            "shutdown_timeout",
+            shutdown_timeout,
+            PRODUCTION_SETTING_FIELDS["shutdown_timeout"][1],
+        )
+        self.update_timeout = self._production_default(
+            "update_timeout",
+            update_timeout,
+            PRODUCTION_SETTING_FIELDS["update_timeout"][1],
+        )
+        self.alert_notification_manager = self._production_default(
+            "alert_notification_manager",
+            alert_notification_manager,
+            PRODUCTION_SETTING_FIELDS["alert_notification_manager"][1],
+        )
+        self.alert_notification_operation = self._production_default(
+            "alert_notification_operation",
+            alert_notification_operation,
+            PRODUCTION_SETTING_FIELDS["alert_notification_operation"][1],
+        )
+        self.alert_notification_recipients = self._production_default(
+            "alert_notification_recipients",
+            alert_notification_recipients,
+            PRODUCTION_SETTING_FIELDS["alert_notification_recipients"][1],
+        )
+        self.alert_action_window = self._production_default(
+            "alert_action_window",
+            alert_action_window,
+            PRODUCTION_SETTING_FIELDS["alert_action_window"][1],
+        )
+        self.namespace = self._production_default("namespace", namespace, None)
+        self._director = self._production_default("director", director, None)
         self._items: list[ComponentRef] = []
         self._items_by_name: dict[str, ComponentRef] = {}
         self._connections: dict[tuple[str, str], list[str]] = {}
@@ -84,6 +183,29 @@ class Production:
         self._graph_warnings: list[str] = []
         self._queue_info: dict[str, dict[str, Any]] = {}
         self._messages: list[PersistentMessageRegistration] = []
+        if hydrate_declarations:
+            self._hydrate_declared_items()
+
+    def _resolve_production_name(self, name: str | object) -> str:
+        if name is not _MISSING:
+            return name  # type: ignore[return-value]
+        class_name = getattr(type(self), "name", _MISSING)
+        if class_name is not _MISSING:
+            return class_name
+        return f"{type(self).__module__}.{type(self).__name__}"
+
+    def _production_default(
+        self,
+        field_name: str,
+        explicit: Any,
+        default: Any,
+    ) -> Any:
+        if explicit is not _MISSING:
+            return explicit
+        class_value = getattr(type(self), field_name, _MISSING)
+        if class_value is not _MISSING:
+            return class_value
+        return default
 
     def testing(self, enabled: bool | str = True) -> Production:
         self.testing_enabled = enabled
@@ -147,7 +269,11 @@ class Production:
         namespace: str | None = None,
         director: _DirectorProtocol | None = None,
     ) -> Production:
-        seed = cls(name, namespace=namespace, director=director)
+        seed = cls._new_unhydrated(
+            name,
+            namespace=namespace,
+            director=director,
+        )
         runtime_director = _ProductionRuntime(seed).director
         exported = runtime_director.export_production(name)
         connections = None
@@ -553,6 +679,9 @@ class Production:
     def to_python(self) -> str:
         return production_to_python(self)
 
+    def to_class(self) -> str:
+        return production_to_class(self)
+
     def graph(self) -> ProductionGraph:
         return production_graph(self)
 

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),
@@ -117,9 +117,7 @@ def _apply_runtime_item_metadata(production, connections: Any) -> None:
 def _apply_runtime_connections(production, connections: Any) -> tuple[set[str], set[str]]:
     connection_map, runtime_sources, warnings = _normalize_connections(connections)
     production._graph_warnings.extend(warnings)
-    runtime_sources_with_targets = {
-        source_item for source_item, targets in connection_map.items() if targets
-    }
+    runtime_sources_with_targets: set[str] = set()
 
     for source_item, targets in connection_map.items():
         if source_item not in production._items_by_name:
@@ -144,6 +142,7 @@ def _apply_runtime_connections(production, connections: Any) -> tuple[set[str],
                     f"Runtime connection target does not exist: "
                     f"{source_item} -> {target_name}"
                 )
+            runtime_sources_with_targets.add(source_item)
             production._register_connection(
                 source_item,
                 source_port,

iop/production/rendering.py

@@ -86,8 +86,84 @@ def production_to_python(production) -> str:
     return "\n".join(lines) + "\n"
 
 
-def _production_constructor_lines(production) -> list[str]:
-    kwargs = [
+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,
+    )
+    item_groups = _class_item_groups(production.items)
+    used_items = {
+        _class_item_type(kind)
+        for kind, items in item_groups.items()
+        if items
+    }
+    has_routes = bool(route_targets)
+    imports = ["Production", *sorted(used_items)]
+    if has_routes:
+        imports.append("Route")
+
+    class_name = _production_class_name(production.name)
+    lines = [
+        "# 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.",
+    ]
+    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("")
+
+    for kind in ("component", "service", "process", "operation"):
+        items = item_groups.get(kind, [])
+        if not items:
+            continue
+        attr_name = _class_item_attr(kind)
+        lines.append(f"    {attr_name} = (")
+        for item in items:
+            lines.extend(_class_item_lines(item, kind, route_targets))
+        lines.append("    )")
+        lines.append("")
+
+    unresolved = _unresolved_class_routes(production, item_names)
+    if unresolved:
+        lines.append("    # TODO: review unresolved or runtime-only routes:")
+        lines.extend(f"    # - {value}" for value in unresolved)
+        lines.append("")
+    if production.graph().warnings:
+        lines.append("    # Import warnings:")
+        lines.extend(f"    # - {warning}" for warning in production.graph().warnings)
+        lines.append("")
+
+    lines.append("")
+    lines.append(f"PRODUCTIONS = [{class_name}()]")
+    return "\n".join(lines) + "\n"
+
+
+def _class_production_setting_lines(production) -> list[str]:
+    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",
@@ -98,26 +174,228 @@ def _production_constructor_lines(production) -> list[str]:
         ("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_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),
     ]
+
+
+def _class_item_groups(items) -> dict[str, list[Any]]:
+    groups: dict[str, list[Any]] = {
+        "component": [],
+        "service": [],
+        "process": [],
+        "operation": [],
+    }
+    for item in items:
+        groups[_class_item_kind(item)].append(item)
+    return groups
+
+
+def _class_item_kind(item) -> str:
+    if item.kind in {"service", "process", "operation"}:
+        return item.kind
+    return "component"
+
+
+def _class_item_type(kind: str) -> str:
+    return {
+        "component": "ComponentItem",
+        "service": "ServiceItem",
+        "process": "ProcessItem",
+        "operation": "OperationItem",
+    }[kind]
+
+
+def _class_item_attr(kind: str) -> str:
+    return {
+        "component": "components",
+        "service": "services",
+        "process": "processes",
+        "operation": "operations",
+    }[kind]
+
+
+def _class_item_lines(item, kind: str, route_targets) -> list[str]:
+    kwargs: list[tuple[str, Any]] = []
+    optional_fields = [
+        ("category", item.category, ""),
+        ("pool_size", _int_literal(item.pool_size), 1),
+        ("enabled", _bool_literal(item.enabled), True),
+        ("foreground", _bool_literal(item.foreground), False),
+        ("comment", item.comment, ""),
+        ("log_trace_events", _bool_literal(item.log_trace_events), False),
+        ("schedule", item.schedule, ""),
+    ]
+    kwargs.extend(
+        (name, value)
+        for name, value, default in optional_fields
+        if value != default
+    )
+    settings = {
+        name: value
+        for name, value in item.host_settings.items()
+        if (item.name, name) not in route_targets
+    }
+    if settings:
+        kwargs.append(("settings", settings))
+    if item.adapter_settings:
+        kwargs.append(("adapter_settings", dict(item.adapter_settings)))
+    if item.other_settings:
+        kwargs.append(("other_settings", [dict(value) for value in item.other_settings]))
+
+    routes = _class_item_route_values(item, route_targets)
+    if routes:
+        kwargs.append(("routes", routes))
+
+    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("        ),")
+    return lines
+
+
+def _class_item_route_values(item, route_targets) -> list[tuple[str, list[str]]]:
+    values: list[tuple[str, list[str]]] = []
+    for source_item, source_port in sorted(route_targets):
+        if source_item != item.name:
+            continue
+        targets = route_targets[(source_item, source_port)]
+        values.append((source_port, list(targets)))
+    return values
+
+
+def _valid_route_targets(
+    route_targets: dict[tuple[str, str], list[str]],
+    item_names: set[str],
+) -> dict[tuple[str, str], list[str]]:
+    valid_routes: dict[tuple[str, str], list[str]] = {}
+    for source, targets in route_targets.items():
+        valid_targets = [target for target in targets if target in item_names]
+        if valid_targets:
+            valid_routes[source] = valid_targets
+    return valid_routes
+
+
+def _class_keyword_lines(name: str, value: Any) -> list[str]:
+    if isinstance(value, dict):
+        return _indented_dict_keyword_lines(name, value, indent=12)
+    if isinstance(value, list) and name == "routes":
+        return _class_route_keyword_lines(value)
+    if isinstance(value, list):
+        return _indented_list_keyword_lines(name, value, indent=12)
+    return [f"            {name}={_literal(value)},"]
+
+
+def _class_route_keyword_lines(routes: list[tuple[str, list[str]]]) -> list[str]:
+    if len(routes) == 1:
+        port, targets = routes[0]
+        target_literal = _class_route_targets_literal(targets)
+        return [f"            routes=(Route({_literal(port)}, {target_literal}),),"]
+
+    lines = ["            routes=("]
+    for port, targets in routes:
+        target_literal = _class_route_targets_literal(targets)
+        lines.append(f"                Route({_literal(port)}, {target_literal}),")
+    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],
+    *,
+    indent: int,
+) -> list[str]:
+    prefix = " " * indent
+    item_prefix = " " * (indent + 4)
+    lines = [f"{prefix}{name}={{"]
+    for key, item in value.items():
+        lines.append(f"{item_prefix}{_literal(key)}: {_literal(item)},")
+    lines.append(f"{prefix}}},")
+    return lines
+
+
+def _indented_list_keyword_lines(
+    name: str,
+    value: list[Any],
+    *,
+    indent: int,
+) -> list[str]:
+    prefix = " " * indent
+    item_prefix = " " * (indent + 4)
+    lines = [f"{prefix}{name}=["]
+    for item in value:
+        lines.append(f"{item_prefix}{_literal(item)},")
+    lines.append(f"{prefix}],")
+    return lines
+
+
+def _unresolved_class_routes(production, item_names: set[str]) -> list[str]:
+    unresolved: list[str] = []
+    for edge in production.edges:
+        if not edge.source_port:
+            unresolved.append(f"{edge.source_item} -> {edge.target}")
+        elif edge.target not in item_names:
+            unresolved.append(f"{edge.source_item}.{edge.source_port} -> {edge.target}")
+    return sorted(set(unresolved))
+
+
+def _production_class_name(production_name: str) -> str:
+    parts = [
+        part
+        for part in re.split(r"\W+", production_name)
+        if part
+    ]
+    if not parts:
+        return "GeneratedProduction"
+    candidate = parts[-1]
+    if candidate == "Production" and len(parts) > 1:
+        candidate = "".join(parts[-2:])
+    else:
+        candidate = "".join(
+            part[:1].upper() + part[1:]
+            for part in re.split(r"[_\s]+", candidate)
+            if part
+        )
+    if not candidate or not candidate[0].isalpha():
+        candidate = f"Generated{candidate}"
+    if keyword.iskeyword(candidate) or candidate == "Production":
+        candidate = f"{candidate}Definition"
+    return candidate
+
+
+def _production_constructor_lines(production) -> list[str]:
     rendered = [
         (name, value)
-        for name, value, default in kwargs
+        for name, value, default in _production_setting_literals(production)
         if value != default
     ]
     if not rendered:

iop/production/types.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import json
 from dataclasses import dataclass, field
-from typing import Any
+from typing import Any, overload
 
 from ..components.settings import Category, Setting, controls
 
@@ -17,6 +17,15 @@ class TargetSetting(Setting):
         super().__init__("", **kwargs)
         self.logical_name = logical_name
 
+    @overload
+    def __get__(self, instance: None, owner: type | None = None) -> TargetSetting: ...
+
+    @overload
+    def __get__(self, instance: object, owner: type | None = None) -> str: ...
+
+    def __get__(self, instance, owner=None):
+        return super().__get__(instance, owner)
+
 
 def target(logical_name: str = "", **kwargs: Any) -> TargetSetting:
     """Declare an outbound target port on a component class."""

iop/production/validation.py

@@ -4,7 +4,11 @@ import warnings
 from dataclasses import dataclass
 from typing import Any
 
-from .common import PRODUCTION_SETTING_FIELDS_BY_IRIS, PRODUCTION_SETTING_NAMES
+from .common import (
+    PRODUCTION_SETTING_FIELDS_BY_IRIS,
+    PRODUCTION_SETTING_NAMES,
+    SETTING_NAME_ALIASES,
+)
 from .import_ import _as_list, _production_payload, _split_settings
 
 _PRODUCTION_PUBLIC_FIELDS = {
@@ -32,11 +36,6 @@ _PRODUCTION_DICT_KEYS = {
     "Item",
 }
 
-_SETTING_NAME_ALIASES = {
-    "target_config_name": "TargetConfigName",
-    "target_config_names": "TargetConfigNames",
-}
-
 _PRODUCTION_SETTING_NAME_ALIASES = {
     **PRODUCTION_SETTING_NAMES,
     **{iris_name: iris_name for iris_name in PRODUCTION_SETTING_FIELDS_BY_IRIS},
@@ -350,7 +349,7 @@ def _validate_names_with_known_set(
     for setting_name in sorted(settings):
         if setting_name.startswith("%") or setting_name in known_names:
             continue
-        alias = _SETTING_NAME_ALIASES.get(setting_name)
+        alias = SETTING_NAME_ALIASES.get(setting_name)
         if alias in known_names:
             issues.append(_setting_alias_issue(path_prefix, setting_name, alias))
             continue
@@ -372,7 +371,7 @@ def _validate_names_with_iris_dictionary(
     for setting_name in sorted(settings):
         if _iris_property_exists(iris, iris_class_name, setting_name):
             continue
-        alias = _SETTING_NAME_ALIASES.get(setting_name)
+        alias = SETTING_NAME_ALIASES.get(setting_name)
         if alias and _iris_property_exists(iris, iris_class_name, alias):
             issues.append(_setting_alias_issue(path_prefix, setting_name, alias))
             continue

{iris_pex_embedded_python-4.0.0b4.dist-info → iris_pex_embedded_python-4.0.0b6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris_pex_embedded_python
-Version: 4.0.0b4
+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.0b4.dist-info → iris_pex_embedded_python-4.0.0b6.dist-info}/RECORD

@@ -1,9 +1,9 @@
-iop/__init__.py,sha256=JCkmGv50W1i4oi7CKrvLXyQ88-lv-2y-8SJ_05BOsPA,4001
+iop/__init__.py,sha256=XgOE11EBCWbk_lBPUv7oTnrTfg2XcW_9Eygr6lMltTU,4439
 iop/__main__.py,sha256=2rUNM7vaYK0W57Jj72rm7GORyIFLMXKwPq3QNLwYBmY,100
 iop/cli/__init__.py,sha256=Y78pBdA-ULzq1c_9xQZsFBlzm3x5xgxSzkvrH5DoM7I,31
 iop/cli/formatting.py,sha256=OLgHA1d8_paAuINQyKkYgihWMLoBhPn7kSXW5whRlIs,1606
-iop/cli/main.py,sha256=FzE86PbdIrJ8zVIIcsTRD7-v5_zdFUisnQ5Rs5hbQH8,13197
-iop/cli/parser.py,sha256=HWn3mxndR8Fw9HrnjtSP-ZMTps9X1cbQWCcye7NPIug,4878
+iop/cli/main.py,sha256=sKiZWZVqxQKdSTK7lHRMDN89A8wrTFSLgN2woXnQCHM,13302
+iop/cli/parser.py,sha256=4Es5xJPR3HVcEgFKn6sONEJQ7bSwZ8yluV1WuofoLf8,4887
 iop/cli/types.py,sha256=7GxUy2KHw_LNOWAQ2-EalKOikIDQFiKjMmEEmlWeOB8,1343
 iop/cls/IOP/BusinessOperation.cls,sha256=NlvbNtm1ZFZmHaMX_9FMKoptY-hQMq5jYN1nLQwvYJw,936
 iop/cls/IOP/BusinessProcess.cls,sha256=XJxzbiV0xokzRm-iI2Be5UIJLE3MlXr7W3WS_LkOCYs,3363
@@ -16,7 +16,7 @@ iop/cls/IOP/OutboundAdapter.cls,sha256=OQoGFHUy2qV_kcsShTlWGOngDrdH5dhwux4eopZyI
 iop/cls/IOP/PickleMessage.cls,sha256=S3y7AClQ8mAILjxPuHdCjGosBZYzGbUQ5WTv4mYPNMQ,1673
 iop/cls/IOP/Projection.cls,sha256=AZgbfpbEk02llhyIwrSw0M3QMcQNcjhjY3_vU_yx8FU,1315
 iop/cls/IOP/Test.cls,sha256=zvlCZJfOCmSFdmi-ZQHWDGYmqZAgRspaJj1j0r_IxJQ,2017
-iop/cls/IOP/Utils.cls,sha256=SZOKKVaJEUp3Y4xkt1OIWw2ExsjNZoWCBsySP7CjqoY,31095
+iop/cls/IOP/Utils.cls,sha256=fhKWWouv4ND1-3JHojBQbOH9ufjaiS8M-4n6oM4jCxk,31496
 iop/cls/IOP/Wrapper.cls,sha256=ydlNpqAekoH_XdGk0ZpspX1pxgv__E00Xf57F8oxsqs,1624
 iop/cls/IOP/Duplex/Operation.cls,sha256=K_fmgeLjPZQbHgNrc0kd6DUQoW0fDn1VHQjJxHo95Zk,525
 iop/cls/IOP/Duplex/Process.cls,sha256=xbefZ4z84a_IUhavWN6P_gZBzqkdJ5XRTXxro6iDvAg,6986
@@ -49,7 +49,7 @@ iop/components/outbound_adapter.py,sha256=Bm6KeaLR0fO3z5o9cmJxcMdIiOvdExik-Oc272
 iop/components/polling_business_service.py,sha256=5rVr6DVgfK3xwEfjFHa4dsWb6wI3JXJOQQYtHLAIjSY,901
 iop/components/private_session_duplex.py,sha256=IZ50ThI074qwFF1wFyhFCsSJK0huyuoIeVxwlGyweeQ,5157
 iop/components/private_session_process.py,sha256=edugk8iLTjaHMsz_fBuj9VE8aL66IgOz-mMlqPyk3Zc,1731
-iop/components/settings.py,sha256=VfUQ4H0GrJ7N-IG-KYUxtTQbRJmsTI5crU7V90mPczY,5509
+iop/components/settings.py,sha256=Y-MkpGaMOS-AcvuxVp46hLosQQIn4vMhyugoSKD4ikI,5798
 iop/messages/__init__.py,sha256=k1AKplpjdqSxM5Gl7bpWAfw93xUgigovlI4SKhwKHRI,355
 iop/messages/base.py,sha256=2DBU8CzKLXVYUT3Vp6QeL6QHJbbfOGfoE4Kmkrq8Hpg,1183
 iop/messages/decorators.py,sha256=jOjMllMHaDzS3Apo1h68LIn87boGfDnsQ1OhyyuReA0,2363
@@ -60,20 +60,22 @@ iop/messages/validation.py,sha256=cbq2VaaWTcqesmV-DDwReHh8peynvEMw9h0JNf4q9kQ,15
 iop/migration/__init__.py,sha256=wp-RvjLKYW_Pi2AJLfiWe1bACxENzEgjXtP9UMNiSVY,36
 iop/migration/io.py,sha256=hAehtApFZFgGzjzgwBmDMxdA1xoRhE-okOcEzvgFdQ4,1822
 iop/migration/plans.py,sha256=oj0sNLMBtWZBCoVEoP82RagIFumfTPqmGylDUxGLJNE,6738
-iop/migration/utils.py,sha256=s2CoqWj4HeW8KrKTaQZGBKH4ZMku3Zg8eolNZvGKMq0,40817
-iop/production/__init__.py,sha256=bVFLRI4lvhbUlKApRvvSqM6pVkOsBuofRrzuEIBT6nY,1360
+iop/migration/utils.py,sha256=tSnfQLsmPkuW4HC-fN5CYkYVjrurSAgSeGjiIQohqZQ,41229
+iop/production/__init__.py,sha256=9-Eot8R2ioCSKbZlQDPCXJ8Xdp73KtLygGBtTljNLaM,1714
 iop/production/actions.py,sha256=h95K9O6N8S2thV0dYEKOWxo5uPhfvgALZfB6G2jrUt8,7992
-iop/production/common.py,sha256=RopwhFJT7jP15a4iBvMWipwYwIAV6A0d0UsoxWLo-is,2969
+iop/production/common.py,sha256=IoUg9jkFzSQwDsHcXvkVAC4qxpWKs3kTfXFm_EP07EU,3091
 iop/production/component.py,sha256=uRCQZwlPNFbAEaWgDtbDHUdf4VD8A0R1sJhLTj8kHcA,7988
+iop/production/declarations.py,sha256=6v7015-VjU7F0KD4qhciUv616PmYfN20ZNhTuzfV7xk,5842
+iop/production/declarative.py,sha256=rUqeQiunZFGPSe2uz-jlpNke1Cy_teyRWxkmc7I_6OU,6196
 iop/production/diff.py,sha256=iVJeixEZzy-TaK7b7wdR5wzO5dyIGr2KPVsN0pf2dp4,9968
 iop/production/import_.py,sha256=hK5d6CKtd-_FOmuU39wiZ2cmn-SCUoZ-r3hRz8HgwgA,9865
 iop/production/inspection.py,sha256=LsAI4vhF27v8OMXtRAOHQn8XeaT4CIhjBu-CA-aorO0,3343
-iop/production/model.py,sha256=7YDAgQ-fo87VnE5A-CxmNtNsRHMVFB2NKkpBykH-ohQ,31106
-iop/production/reconstruction.py,sha256=YJMOBtpTzT-IxgQ4lx1kivA8zbWz3UZfwt-5q7d_kMk,7135
-iop/production/rendering.py,sha256=d9Et3hE8aPTCfnk0RKc6vu5HYOrI-JXFCfU6vZLKsKg,10649
+iop/production/model.py,sha256=-TuT0cLNUB0EQaJEp0afWw373WLLiNe87SeQaTflL7s,36421
+iop/production/reconstruction.py,sha256=aIQOs5W1B71OSE-38QoRxIOWo67fDDofCo0L3-HA3HA,7135
+iop/production/rendering.py,sha256=6TY9B7Bzo8k6Xok-GbEjr8awHRch27QXEj4VTSSIVrg,19904
 iop/production/runtime.py,sha256=JngIVVkigt1PNLUXBvQu3t8cBos-zLKlgguf0_WWh-M,2302
-iop/production/types.py,sha256=SsTYPspc8VGrSH8hy49tDBVLWu55D5yODNT7lfFbjmc,9131
-iop/production/validation.py,sha256=yeWEQmWANQ8md2H8QN4DhHyR5nIDLMJWZN7e0d2y2Rk,13839
+iop/production/types.py,sha256=z2e4VG50KK8oDP3zNeT0_6FzPEhrAykjdd6uK_HvBZM,9431
+iop/production/validation.py,sha256=14BfjrLXW1AOuP8AdBrs-CY6zynaDc8_AUD9frsYAIU,13753
 iop/runtime/__init__.py,sha256=wcyWMRuPCYE_CLd1NmgmI1M-IbFs2Gz2yIj2-EW_2AA,70
 iop/runtime/director.py,sha256=KW8BvkATK8XuIUPNBD9rMww9r3Zg4K3H54868eOgvl0,12867
 iop/runtime/environment.py,sha256=0KZ4EoW6NUEbF7FW471emxQ-9FbaiX6ngUHVGihgZXU,1564
@@ -86,9 +88,9 @@ iop/runtime/remote/director.py,sha256=jNnBIocWS76vog6noJtVky5Tv7ZDnPwiWl-hCu958D
 iop/runtime/remote/migration.py,sha256=Iboz-Ye7i9xif9bn433GazCF-gtD-HJW3wiUwWS5P6w,1831
 iop/runtime/remote/settings.py,sha256=P1Hsgld5o57HpSZgPVZzobyjlUmxJj6bstiWvR0JXnc,2144
 iop/runtime/remote/setup.py,sha256=Tr80F3JJTy7oSUso2jyx0iA_KZayd4MYt9vL0BvPpMA,2600
-iris_pex_embedded_python-4.0.0b4.dist-info/licenses/LICENSE,sha256=rZSiBFId_sfbJ6RL0GjjPX-InNLkNS9ou7eQsikciI8,1089
-iris_pex_embedded_python-4.0.0b4.dist-info/METADATA,sha256=wksvI6gY4uyZ7OftWfoAvCB4AspPjHl5xNqMsiA0sIY,4412
-iris_pex_embedded_python-4.0.0b4.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-iris_pex_embedded_python-4.0.0b4.dist-info/entry_points.txt,sha256=fzS8ZFsPe8cnpEx208X60DNugCPQmuSloPeg4pyyJDY,42
-iris_pex_embedded_python-4.0.0b4.dist-info/top_level.txt,sha256=BM54-OXQ6l2BDtmesWNXckh033s9gcjoO7bfjbwZbxU,4
-iris_pex_embedded_python-4.0.0b4.dist-info/RECORD,,
+iris_pex_embedded_python-4.0.0b6.dist-info/licenses/LICENSE,sha256=rZSiBFId_sfbJ6RL0GjjPX-InNLkNS9ou7eQsikciI8,1089
+iris_pex_embedded_python-4.0.0b6.dist-info/METADATA,sha256=_dCp-bIOqrvYR3wAYMbuqkrOYvvpxal9pnVehfdbH-M,4412
+iris_pex_embedded_python-4.0.0b6.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+iris_pex_embedded_python-4.0.0b6.dist-info/entry_points.txt,sha256=fzS8ZFsPe8cnpEx208X60DNugCPQmuSloPeg4pyyJDY,42
+iris_pex_embedded_python-4.0.0b6.dist-info/top_level.txt,sha256=BM54-OXQ6l2BDtmesWNXckh033s9gcjoO7bfjbwZbxU,4
+iris_pex_embedded_python-4.0.0b6.dist-info/RECORD,,