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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris_pex_embedded_python
-Version: 4.0.0b4
+Version: 4.0.0b5
 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.0b5}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 
 [project]
 name = "iris_pex_embedded_python"
-version = "4.0.0b4"
+version = "4.0.0b5"
 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.0b5}/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.0b5}/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.0b5}/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.0b5}/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.0b5}/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.0b5}/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.0b5}/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.0b5}/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.0b5/src/iop/production/declarations.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass, field
+from typing import Any, ClassVar
+
+from .common import SETTING_NAME_ALIASES
+from .types import TargetSetting
+
+
+@dataclass(frozen=True)
+class Route:
+    """Declarative route from a production item port to one or more targets."""
+
+    port: str | TargetSetting
+    targets: str | Iterable[str]
+    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 isinstance(self.targets, str):
+            targets = (self.targets,)
+        else:
+            targets = tuple(str(target) for target in self.targets)
+        if not targets:
+            raise ValueError(f"Route {self.port_name!r} requires at least one target")
+        return 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 _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",
+]