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

{iris_pex_embedded_python-4.0.0b4/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.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 → 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.0b4"
+version = "4.0.0b6"
 description = "Iris Interoperability based on Embedded Python"
 readme = "README.md"
 requires-python = ">=3.10"

{iris_pex_embedded_python-4.0.0b4 → iris_pex_embedded_python-4.0.0b6}/src/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",

{iris_pex_embedded_python-4.0.0b4 → iris_pex_embedded_python-4.0.0b6}/src/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

{iris_pex_embedded_python-4.0.0b4 → iris_pex_embedded_python-4.0.0b6}/src/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",
     )

{iris_pex_embedded_python-4.0.0b4 → iris_pex_embedded_python-4.0.0b6}/src/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","")

{iris_pex_embedded_python-4.0.0b4 → iris_pex_embedded_python-4.0.0b6}/src/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:

{iris_pex_embedded_python-4.0.0b4 → iris_pex_embedded_python-4.0.0b6}/src/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):

{iris_pex_embedded_python-4.0.0b4 → iris_pex_embedded_python-4.0.0b6}/src/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",

{iris_pex_embedded_python-4.0.0b4 → iris_pex_embedded_python-4.0.0b6}/src/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):

iris_pex_embedded_python-4.0.0b6/src/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",
+]

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