iris-pex-embedded-python 4.0.1b3__tar.gz → 4.0.1b5__tar.gz

{iris_pex_embedded_python-4.0.1b3/src/iris_pex_embedded_python.egg-info → iris_pex_embedded_python-4.0.1b5}/PKG-INFO

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

{iris_pex_embedded_python-4.0.1b3 → iris_pex_embedded_python-4.0.1b5}/docs/cookbooks/production-settings-and-targets.md

@@ -55,6 +55,25 @@ prod.connect(process.Accepted, accepted)
 prod.connect(process.Rejected, rejected)
 ```
 
+When a route should have a conventional default, pass the target item name to
+`target()`:
+
+```python
+class RouteProcess(BusinessProcess):
+    Accepted = target("AcceptedOperation")
+    Rejected = target("RejectedOperation")
+
+
+process = prod.process("RouteProcess", RouteProcess)
+accepted = prod.operation("AcceptedOperation", AcceptedOperation)
+rejected = prod.operation("RejectedOperation", RejectedOperation)
+```
+
+The default target is written to the generated setting initial expression and
+to the production Host setting. IoP records the graph edge when the named target
+item exists. Use `prod.connect(...)` when the production should override the
+class default.
+
 ## Migration Command
 
 ```bash
@@ -73,4 +92,3 @@ iop --migrate settings.py --dry-run
   `target()` settings.
 - Adding a component to `settings.py` but forgetting its graph edge.
 - Using raw production dictionaries for new Python-authored topology.
-

{iris_pex_embedded_python-4.0.1b3 → iris_pex_embedded_python-4.0.1b5}/docs/production-graph.md

@@ -51,6 +51,11 @@ Implemented graph import and display:
 `str(target_setting_ref)` returns the stable authoring identity, such as
 `FileInput.Output`. Runtime dispatch uses explicit target setting resolution.
 
+`target("OperationName")` declares a default target. The default is used as the
+generated IRIS property initial expression, applied to the component Host
+setting, and registered as a graph edge once the target item exists. Explicit
+Host settings and `prod.connect(...)` override the class default.
+
 Implemented production lifecycle:
 
 - `prod.start()`
@@ -143,6 +148,18 @@ orders = prod.operation(OrderOperation)
 prod.connect(file.Output, orders)
 ```
 
+For a conventional route, the target can be defaulted on the component class:
+
+```python
+class FileService(PollingBusinessService):
+    Output = target("OrderOperation")
+
+
+prod = Production("Demo.Production")
+file = prod.service("FileInput", FileService)
+orders = prod.operation("OrderOperation", OrderOperation)
+```
+
 ObjectScript and built-in IRIS components use `class_name`:
 
 ```python

{iris_pex_embedded_python-4.0.1b3 → iris_pex_embedded_python-4.0.1b5}/docs/python-api.md

@@ -209,6 +209,18 @@ class FileService(BusinessService):
     )
 ```
 
+Pass a target item name to `target()` to declare a default route:
+
+```python
+class FileService(BusinessService):
+    Output = target("OrderOperation")
+```
+
+The default is used as the generated IRIS property initial expression and as the
+production Host setting. If the named item is present in the `Production`, IoP
+also records the graph edge. An explicit Host setting or `prod.connect(...)`
+overrides the default.
+
 You can also keep normal Python defaults and attach metadata with `typing.Annotated`:
 
 ```python

{iris_pex_embedded_python-4.0.1b3 → iris_pex_embedded_python-4.0.1b5}/docs/settings.md

@@ -210,6 +210,24 @@ PRODUCTIONS = [prod]
 `prod.connect()` sets that setting to the destination component and
 records graph edges available to Python.
 
+Pass a production item name as the first `target()` argument when a route should
+have a default target without an explicit `prod.connect(...)` call:
+
+```python
+class FileService(PollingBusinessService):
+    Output = target("OrderOperation")
+
+
+prod = Production("Demo.Production", testing_enabled=True)
+file = prod.service("FileInput", FileService)
+orders = prod.operation("OrderOperation", OrderOperation)
+```
+
+The default becomes the generated IRIS property initial expression, populates
+the component Host setting, and is recorded as a graph edge once the named
+target item exists. An explicit Host setting or `prod.connect(...)` overrides
+the class default.
+
 You can also write the same production as a class declaration. The class is a
 template; put an instance in `PRODUCTIONS`.
 

{iris_pex_embedded_python-4.0.1b3 → iris_pex_embedded_python-4.0.1b5}/pyproject.toml

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

{iris_pex_embedded_python-4.0.1b3 → iris_pex_embedded_python-4.0.1b5}/src/iop/messages/dispatch.py

@@ -1,3 +1,4 @@
+import ast
 import logging
 from collections.abc import Callable
 from dataclasses import dataclass
@@ -36,6 +37,8 @@ _PICKLE_MESSAGE_CLASSES = {
     "IOP.Generator.Message.StartPickle",
 }
 _HANDLER_ATTRIBUTE = "__iop_handler_message__"
+_IRIS_MODULE_PREFIX = "iris."
+_UNRESOLVED = object()
 
 
 @dataclass(frozen=True)
@@ -60,7 +63,7 @@ def handler(message_type: Any) -> Callable[[Callable], Callable]:
         message_type: The message class, fully qualified class name string, or
             IRIS object instance this method handles.
     """
-    message = _message_class_name(message_type)
+    message = _message_key_from_declared(message_type)
     if message is None:
         raise TypeError("handler() requires a message class or class name")
 
@@ -154,11 +157,10 @@ def dispatch_message(host: Any, request: Any) -> Any:
     """
     call = "on_message"
 
-    module = request.__class__.__module__
-    classname = request.__class__.__name__
+    message_names = _message_keys_from_request(request)
 
     for msg, method in host.DISPATCH:
-        if msg == module + "." + classname:
+        if msg in message_names:
             return getattr(host, method)(request)
 
     return getattr(host, call)(request)
@@ -202,15 +204,24 @@ def create_dispatch(host: Any) -> None:
 
 def _declared_dispatch(host: Any) -> list[tuple[str, str]]:
     if "DISPATCH" in getattr(host, "__dict__", {}):
-        return list(host.__dict__["DISPATCH"])
+        return _normalized_dispatch(host.__dict__["DISPATCH"])
 
     class_dispatch = host.__class__.__dict__.get("DISPATCH")
     if class_dispatch is not None:
-        return list(class_dispatch)
+        return _normalized_dispatch(class_dispatch)
 
     return []
 
 
+def _normalized_dispatch(dispatch: Any) -> list[tuple[str, str]]:
+    entries = []
+    for message, method in dispatch:
+        key = _message_key_from_declared(message)
+        if key is not None:
+            entries.append((key, method))
+    return entries
+
+
 def _decorated_dispatch(host: Any) -> list[tuple[str, str]]:
     dispatch = []
     for method_name in dir(host):
@@ -308,12 +319,7 @@ def get_handler_info(host: Any, method_name: str) -> tuple[str, str] | None:
 
         method = getattr(host, method_name)
         param: Parameter = next(iter(params.values()))
-        annotation = _resolve_annotation(host, method, param.annotation)
-
-        if annotation == Parameter.empty:
-            return None
-
-        message = _message_class_name(annotation)
+        message = _message_key_from_annotation(host, method, param.annotation)
         if message is None:
             return None
 
@@ -323,48 +329,63 @@ def get_handler_info(host: Any, method_name: str) -> tuple[str, str] | None:
         return None
 
 
-def _resolve_annotation(host: Any, method: Callable, annotation: Any) -> Any:
+def _message_key_from_annotation(
+    host: Any, method: Callable, annotation: Any
+) -> str | None:
+    if annotation == Parameter.empty:
+        return None
+
     if not isinstance(annotation, str):
-        return annotation
+        return _message_key_from_declared(annotation, allow_bare_string=False)
 
-    globalns = _annotation_globalns(method)
-    localns = _annotation_localns(host)
+    value: Any = annotation
+    for _ in range(3):
+        if not isinstance(value, str):
+            return _message_key_from_declared(value, allow_bare_string=False)
 
-    try:
-        resolved = eval(annotation, globalns, localns)  # noqa: B307
-    except Exception:
-        resolved = annotation
+        key = _message_key_from_string(value, allow_bare=False)
+        if key is not None:
+            return key
 
-    if isinstance(resolved, str):
-        # Quoted postponed annotations evaluate to a string first.
-        try:
-            resolved = eval(resolved, globalns, localns)  # noqa: B307
-        except Exception:
-            if "." in resolved:
-                return resolved
-            return Parameter.empty
+        unquoted = _unquote_string(value)
+        if unquoted is not None and unquoted != value:
+            value = unquoted
+            continue
 
-    return resolved
+        value = _lookup_annotation_name(host, method, value)
+        if value is _UNRESOLVED:
+            return None
 
+    return None
 
-def _annotation_globalns(method: Callable) -> dict[str, Any]:
-    function = getattr(method, "__func__", method)
-    return getattr(function, "__globals__", {})
 
+def _message_keys_from_request(request: Any) -> tuple[str, ...]:
+    module = request.__class__.__module__
+    classname = request.__class__.__name__
+    names = [f"{module}.{classname}"]
 
-def _annotation_localns(host: Any) -> dict[str, Any]:
-    namespace: dict[str, Any] = {}
-    for klass in reversed(type(host).__mro__):
-        namespace.update(vars(klass))
-    return namespace
+    if module.startswith("iris"):
+        native_name = _native_iris_message_key(request)
+        if native_name:
+            names.append(native_name)
+            names.append(f"{_IRIS_MODULE_PREFIX}{native_name}")
+
+    return tuple(dict.fromkeys(names))
 
 
-def _message_class_name(message_type: Any) -> str | None:
+def _message_key_from_declared(
+    message_type: Any, *, allow_bare_string: bool = True
+) -> str | None:
     if isinstance(message_type, str):
-        return message_type
+        return _message_key_from_string(
+            message_type,
+            allow_bare=allow_bare_string,
+        )
 
     if is_iris_object_instance(message_type):
-        return f"{type(message_type).__module__}.{type(message_type).__name__}"
+        return _native_iris_message_key(message_type) or _python_class_key(
+            type(message_type)
+        )
 
     if message_type is Any or message_type is object:
         return None
@@ -375,7 +396,70 @@ def _message_class_name(message_type: Any) -> str | None:
     if not _is_dispatch_message_class(message_type):
         return None
 
-    return f"{message_type.__module__}.{message_type.__name__}"
+    return _python_class_key(message_type)
+
+
+def _message_key_from_string(value: str, *, allow_bare: bool) -> str | None:
+    if not value or _unquote_string(value) is not None:
+        return None
+
+    normalized = _strip_iris_prefix(value)
+    if "." in normalized:
+        return normalized if _looks_like_message_key(normalized) else None
+
+    return normalized if allow_bare else None
+
+
+def _native_iris_message_key(message: Any) -> str | None:
+    iris_classname = get_iris_object_classname(message)
+    if not iris_classname:
+        return None
+    return _strip_iris_prefix(iris_classname)
+
+
+def _python_class_key(klass: type) -> str:
+    return f"{klass.__module__}.{klass.__name__}"
+
+
+def _strip_iris_prefix(value: str) -> str:
+    if value.startswith(_IRIS_MODULE_PREFIX):
+        return value[len(_IRIS_MODULE_PREFIX) :]
+    return value
+
+
+def _looks_like_message_key(value: str) -> bool:
+    return not any(character in value for character in "'\"[](){} ,:")
+
+
+def _unquote_string(value: str) -> str | None:
+    try:
+        literal = ast.literal_eval(value)
+    except (SyntaxError, ValueError):
+        return None
+    return literal if isinstance(literal, str) else None
+
+
+def _lookup_annotation_name(host: Any, method: Callable, name: str) -> Any:
+    if not name.isidentifier():
+        return _UNRESOLVED
+
+    localns = _annotation_localns(host)
+    if name in localns:
+        return localns[name]
+
+    return _annotation_globalns(method).get(name, _UNRESOLVED)
+
+
+def _annotation_globalns(method: Callable) -> dict[str, Any]:
+    function = getattr(method, "__func__", method)
+    return getattr(function, "__globals__", {})
+
+
+def _annotation_localns(host: Any) -> dict[str, Any]:
+    namespace: dict[str, Any] = {}
+    for klass in reversed(type(host).__mro__):
+        namespace.update(vars(klass))
+    return namespace
 
 
 def _is_dispatch_message_class(klass: type) -> bool:

{iris_pex_embedded_python-4.0.1b3 → iris_pex_embedded_python-4.0.1b5}/src/iop/production/model.py

@@ -34,6 +34,7 @@ from .types import (
     PersistentMessageRegistration,
     ProductionDiff,
     ProductionGraph,
+    TargetSetting,
     TargetSettingRef,
     _edge_identity,
 )
@@ -1055,6 +1056,35 @@ class Production(_DeclarativeProductionMixin):
                     )
         self._items.append(ref)
         self._items_by_name[ref.name] = ref
+        self._apply_target_defaults()
+
+    def _apply_target_defaults(self) -> None:
+        for ref in self._items:
+            for setting_name, target_name in self._target_default_routes(ref):
+                if setting_name not in ref.host_settings:
+                    if setting_name in ref.target_setting_names:
+                        continue
+                    ref.host_settings[setting_name] = target_name
+                ref.target_setting_names.add(setting_name)
+                if str(ref.host_settings[setting_name]) != target_name:
+                    continue
+                if target_name not in self._items_by_name:
+                    continue
+                self._register_connection(
+                    ref.name,
+                    setting_name,
+                    target_name,
+                )
+
+    def _target_default_routes(self, ref: ComponentRef) -> tuple[tuple[str, str], ...]:
+        if ref.component_class is None:
+            return ()
+        routes: list[tuple[str, str]] = []
+        for setting_name, descriptor in _target_settings(ref.component_class):
+            target_name = _target_default_name(descriptor.default)
+            if target_name:
+                routes.append((setting_name, target_name))
+        return tuple(routes)
 
     def _diff_current(
         self,
@@ -1141,3 +1171,21 @@ def _connection_mode(mode: str) -> str:
         "Unsupported connection mode: "
         f"{mode!r}. Expected 'replace', 'add', or 'remove'."
     )
+
+
+def _target_settings(
+    component_class: type,
+) -> tuple[tuple[str, TargetSetting], ...]:
+    descriptors: dict[str, TargetSetting] = {}
+    for base in reversed(component_class.__mro__):
+        for name, value in base.__dict__.items():
+            if isinstance(value, TargetSetting):
+                descriptors[name] = value
+    return tuple(descriptors.items())
+
+
+def _target_default_name(value: Any) -> str:
+    if value is None:
+        return ""
+    name = getattr(value, "name", value)
+    return str(name).strip()

{iris_pex_embedded_python-4.0.1b3 → iris_pex_embedded_python-4.0.1b5}/src/iop/production/types.py

@@ -12,11 +12,11 @@ from ..components.settings import Category, Setting, controls
 class TargetSetting(Setting):
     """Production target setting descriptor created by target()."""
 
-    def __init__(self, **kwargs: Any):
+    def __init__(self, default: Any = "", **kwargs: Any):
         kwargs.setdefault("iris_type", "Ens.DataType.ConfigName")
         kwargs.setdefault("category", Category.BASIC)
         kwargs.setdefault("control", controls.production_item())
-        super().__init__("", **kwargs)
+        super().__init__(default, **kwargs)
 
     @overload
     def __get__(self, instance: None, owner: type | None = None) -> TargetSetting: ...
@@ -34,13 +34,16 @@ class TargetSetting(Setting):
         return super().__get__(instance, owner)
 
 
-def target(**kwargs: Any) -> TargetSetting:
+def target(default: Any = "", **kwargs: Any) -> TargetSetting:
     """Purpose:
         Declare a configurable outbound target setting on a component class.
 
     Use when:
         A service or process sends messages to another production component.
 
+        Pass a target item name as the first argument when the route should have
+        a default target even without an explicit Production.connect(...) call.
+
     Lifecycle:
         The descriptor becomes an IRIS production setting. Production.connect(...)
         binds it to a concrete target component.
@@ -59,11 +62,14 @@ def target(**kwargs: Any) -> TargetSetting:
 
         prod.connect(router.Output, operation)
 
+        class DefaultRouter(BusinessProcess):
+            Output = target("DefaultOperation")
+
     Related:
         docs/cookbooks/production-settings-and-targets.md,
         docs/production-graph.md
     """
-    return TargetSetting(**kwargs)
+    return TargetSetting(default, **kwargs)
 
 
 @dataclass

{iris_pex_embedded_python-4.0.1b3 → iris_pex_embedded_python-4.0.1b5/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.1b3
+Version: 4.0.1b5
 Summary: Iris Interoperability based on Embedded Python
 Author-email: grongier <guillaume.rongier@intersystems.com>
 License: MIT License