iris-pex-embedded-python 4.0.0b15__py3-none-any.whl → 4.0.1__py3-none-any.whl

iop/__init__.py

@@ -125,8 +125,8 @@ class BusinessService(_BusinessService):
         production graph.
 
     Lifecycle:
-        IRIS calls on_process_input(); the default implementation delegates to
-        on_process_input(request).
+        IRIS calls on_process_input(); the default implementation delegates the
+        incoming request to on_message(request).
 
     Best practices:
         Declare outbound routes with target() and wire them in a Production

iop/components/business_service.py

@@ -20,16 +20,13 @@ def _call_process_input(method, request):
 
 
 class _BusinessService(_BusinessHost):
-    """This class is responsible for receiving the data from external system and sending it to business processes or business operations in the production.
-    The business service can use an adapter to access the external system, which is specified in the InboundAdapter property.
-    There are three ways of implementing a business service:
-    1) Polling business service with an adapter - The production framework at regular intervals calls the adapter's task method,
-        which sends incoming data to the business service process input method.
-    2) Polling business service that uses the default adapter - In this case, the framework calls the default adapter's OnTask method with no data.
-        The on_process_input() method then performs the role of the adapter and is responsible for accessing the external system and receiving the data.
-    3) Nonpolling business service - The production framework does not initiate the business service. Instead custom code in either a long-running process
-        or one that is started at regular intervals initiates the business service through the Director API.
-    """
+    """Runtime base for inbound production entry points.
+
+    IRIS invokes on_process_input(...). By default, that hook delegates to
+    on_message(...). Application code should normally subclass iop.BusinessService
+    or iop.PollingBusinessService and wire outbound routes with target() in a
+    Production graph.
+    """
 
     Adapter = adapter = None
     _wait_for_next_call_interval = False
@@ -79,13 +76,12 @@ class _BusinessService(_BusinessHost):
         return None
 
     def on_process_input(self, message_input=None):
-        """Receives the message from the inbond adapter via the PRocessInput method and is responsible for forwarding it to target business processes or operations.
-        If the business service does not specify an adapter, then the default adapter calls this method with no message
-        and the business service is responsible for receiving the data from the external system and validating it.
+        """Handle IRIS ProcessInput and delegate to on_message(message_input).
 
-        Parameters:
-        message_input: an instance of IRISObject or subclass of Message containing the data that the inbound adapter passes in.
-            The message can have any structure agreed upon by the inbound adapter and the business service.
+        Override this low-level hook only when an inbound adapter or Director
+        call needs custom ProcessInput handling. For simple services, override
+        on_message(...); for scheduled polling, use PollingBusinessService and
+        override on_poll().
         """
         return self.on_message(message_input)
 

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):
@@ -306,13 +317,9 @@ def get_handler_info(host: Any, method_name: str) -> tuple[str, str] | None:
         if len(params) != 1:
             return None
 
+        method = getattr(host, method_name)
         param: Parameter = next(iter(params.values()))
-        annotation = 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
 
@@ -322,12 +329,63 @@ def get_handler_info(host: Any, method_name: str) -> tuple[str, str] | None:
         return None
 
 
-def _message_class_name(message_type: Any) -> str | None:
+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 _message_key_from_declared(annotation, allow_bare_string=False)
+
+    value: Any = annotation
+    for _ in range(3):
+        if not isinstance(value, str):
+            return _message_key_from_declared(value, allow_bare_string=False)
+
+        key = _message_key_from_string(value, allow_bare=False)
+        if key is not None:
+            return key
+
+        unquoted = _unquote_string(value)
+        if unquoted is not None and unquoted != value:
+            value = unquoted
+            continue
+
+        value = _lookup_annotation_name(host, method, value)
+        if value is _UNRESOLVED:
+            return None
+
+    return None
+
+
+def _message_keys_from_request(request: Any) -> tuple[str, ...]:
+    module = request.__class__.__module__
+    classname = request.__class__.__name__
+    names = [f"{module}.{classname}"]
+
+    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_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
@@ -338,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:

iop/migration/utils.py

@@ -193,8 +193,11 @@ def register_component(
     overwrite: int = 1,
     iris_classname: str = "Python",
 ):
-    """
-    It registers a component in the Iris database.
+    """Register a Python component as an IRIS proxy class.
+
+    Prefer a Python Production graph in PRODUCTIONS for new application
+    components. Use register_component() directly for standalone bindings,
+    legacy migration helpers, or manual proxy registration only.
 
     :param module: The name of the module that contains the class
     :type module: str
@@ -239,8 +242,11 @@ def bind_component(
     overwrite: int = 1,
     iris_classname: str = "Python",
 ):
-    """
-    Public alias for registering a Python component as an IRIS proxy class.
+    """Public alias for register_component().
+
+    Prefer a Python Production graph in PRODUCTIONS for new application
+    components. Use bind_component() directly only for standalone bindings,
+    legacy migration helpers, or manual proxy registration.
     """
     return register_component(module, classname, path, overwrite, iris_classname)
 
@@ -436,18 +442,12 @@ def migrate(
     namespace: str | None = None,
     strict_production_validation: bool = False,
 ):
-    """
-    Read the settings.py file and register all the components
-    settings.py file has two dictionaries:
-        * CLASSES
-            * key: the name of the class
-            * value: an instance of the class
-        * PRODUCTIONS
-            list of dictionaries:
-            * key: the name of the production
-            * value: a dictionary containing the settings for the production
-        * SCHEMAS
-            List of classes
+    """Read a migration file and apply its registrations to IRIS.
+
+    New Python-authored applications should normally export Production objects
+    through PRODUCTIONS. CLASSES remains available for standalone bindings,
+    native PersistentMessage classes, and legacy migration files. SCHEMAS
+    registers Message or PydanticMessage schemas for DTL support.
     """
     settings, path = _load_settings(filename)
 
@@ -546,7 +546,19 @@ def _build_migration_manifest(
 
 
 def _load_settings(filename):
-    """Load settings module from file or default location.
+    """Load a migration settings module.
+
+    Purpose:
+        Resolve settings.py as a file-based module and keep imports local to the
+        settings file directory for this process.
+
+    Best practices:
+        Keep modules imported by settings.py in the same project/package rooted
+        near the settings file. Let IoP manage temporary import path setup.
+
+    Common mistakes:
+        Do not require users to set PYTHONPATH. Do not mutate environment
+        variables to force imports when module/package layout should be fixed.
 
     Returns:
         tuple: (settings_module, path_added_to_sys)
@@ -723,6 +735,20 @@ def _cleanup_sys_path(path):
 
 
 def import_module_from_path(module_name, file_path):
+    """Import one module from an absolute file path.
+
+    Purpose:
+        Execute a specific settings or component module by file location
+        without relying on global PYTHONPATH configuration.
+
+    Best practices:
+        Use absolute paths and stable module/package layout so imports resolve
+        from the project directory containing settings.py.
+
+    Common mistakes:
+        Do not patch PYTHONPATH or sys.path globally to make imports pass.
+        Keep import fixes in project structure and import statements.
+    """
     if not os.path.isabs(file_path):
         raise ValueError("The file path must be absolute")
 

iop/production/common.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 import importlib
 from typing import Any
 
+from ..components.settings import Setting
+
 PRODUCTION_SETTING_FIELDS: dict[str, tuple[str, Any]] = {
     "shutdown_timeout": ("ShutdownTimeout", 120),
     "update_timeout": ("UpdateTimeout", 10),
@@ -83,11 +85,21 @@ def _adapter_type_from_class_name(class_name: str | None) -> str:
     return _adapter_type_from_component_class(component_class)
 
 
+def _setting_name(name: Any) -> str:
+    if isinstance(name, Setting) and name.name:
+        return name.name
+    return str(name)
+
+
+def _normalize_settings_mapping(values: Any) -> dict[str, Any]:
+    return {_setting_name(key): value for key, value in dict(values or {}).items()}
+
+
 def _settings_to_iris(target_name: str, values: dict[str, Any]) -> list[dict[str, str]]:
     return [
         {
             "@Target": target_name,
-            "@Name": name,
+            "@Name": _setting_name(name),
             "#text": _text_value(value),
         }
         for name, value in values.items()
@@ -97,6 +109,7 @@ def _settings_to_iris(target_name: str, values: dict[str, Any]) -> list[dict[str
 def _apply_settings_update(target: dict[str, Any], updates: Any) -> None:
     """Merge *updates* into *target*, treating ``None`` values as removals."""
     for key, value in (updates or {}).items():
+        key = _setting_name(key)
         if value is None:
             target.pop(key, None)
         else:

iop/production/component.py

@@ -66,6 +66,13 @@ class ComponentRef:
             return self.target_setting(name)
         raise AttributeError(name)
 
+    def __dir__(self) -> list[str]:
+        names = set(super().__dir__())
+        if self.component_class is not None:
+            names.update(_target_setting_names(self.component_class))
+        names.update(self.target_setting_names)
+        return sorted(names)
+
     def target_setting(self, name: str) -> TargetSettingRef:
         self.target_setting_names.add(name)
         return TargetSettingRef(
@@ -161,7 +168,7 @@ class ComponentRef:
 
     def connect(
         self,
-        target_setting: str | TargetSettingRef,
+        target_setting: str | TargetSetting | TargetSettingRef,
         target_component: ComponentRef | str | None = None,
         **kwargs: Any,
     ) -> ComponentRef:
@@ -171,7 +178,7 @@ class ComponentRef:
 
     def _coerce_target_setting_ref(
         self,
-        target_setting: str | TargetSettingRef,
+        target_setting: str | TargetSetting | TargetSettingRef,
     ) -> TargetSettingRef:
         if isinstance(target_setting, TargetSettingRef):
             if target_setting.production is not self.production:
@@ -183,6 +190,28 @@ class ComponentRef:
                     "source target setting belongs to a different component"
                 )
             return target_setting
+        if isinstance(target_setting, TargetSetting):
+            owner = target_setting.owner
+            if owner is None or not target_setting.name:
+                raise ValueError(
+                    "target setting must be declared on a component class"
+                )
+            if self.component_class is None or not issubclass(
+                self.component_class,
+                owner,
+            ):
+                owner_name = f"{owner.__module__}.{owner.__qualname__}"
+                component_name = (
+                    f"{self.component_class.__module__}."
+                    f"{self.component_class.__qualname__}"
+                    if self.component_class is not None
+                    else self.class_name
+                )
+                raise ValueError(
+                    f"target setting {target_setting.name!r} belongs to "
+                    f"{owner_name}, not {component_name}"
+                )
+            return self.target_setting(target_setting.name)
         return self.target_setting(str(target_setting))
 
     def inspect(self, *, refresh: bool = True) -> dict[str, Any]:
@@ -232,3 +261,12 @@ class ComponentRef:
             item["Setting"] = settings
 
         return item
+
+
+def _target_setting_names(component_class: type) -> tuple[str, ...]:
+    names: dict[str, None] = {}
+    for base in reversed(component_class.__mro__):
+        for name, value in base.__dict__.items():
+            if isinstance(value, TargetSetting):
+                names[name] = None
+    return tuple(names)

iop/production/declarations.py

@@ -2,9 +2,9 @@ from __future__ import annotations
 
 from collections.abc import Iterable, Mapping
 from dataclasses import dataclass, field
-from typing import Any, ClassVar, Protocol
+from typing import Any, ClassVar, Protocol, cast
 
-from .common import SETTING_NAME_ALIASES
+from .common import SETTING_NAME_ALIASES, _normalize_settings_mapping
 from .types import TargetSetting
 
 
@@ -36,7 +36,9 @@ class Route:
             targets = (self.targets,)
         else:
             try:
-                targets = tuple(self.targets)
+                targets = tuple(
+                    cast(Iterable[str | _NamedRouteTarget], self.targets)
+                )
             except TypeError as exc:
                 raise TypeError(
                     f"Route {self.target_setting_name!r} targets must be an item name, "
@@ -174,7 +176,7 @@ def _mapping(
     item_name: str,
 ) -> dict[str, Any]:
     try:
-        return dict(values or {})
+        return _normalize_settings_mapping(values)
     except (TypeError, ValueError) as exc:
         raise TypeError(
             f"Production item {item_name!r} {field_name} must be a mapping"

iop/production/model.py

@@ -9,6 +9,7 @@ from .common import (
     _adapter_type_from_component_class,
     _apply_settings_update,
     _auto_proxy_class_name,
+    _normalize_settings_mapping,
 )
 from .component import ComponentRef
 from .declarative import _DeclarativeProductionMixin
@@ -34,6 +35,7 @@ from .types import (
     PersistentMessageRegistration,
     ProductionDiff,
     ProductionGraph,
+    TargetSetting,
     TargetSettingRef,
     _edge_identity,
 )
@@ -218,10 +220,10 @@ class Production(_DeclarativeProductionMixin):
 
     def _resolve_production_name(self, name: str | object) -> str:
         if name is not _MISSING:
-            return name  # type: ignore[return-value]
+            return str(name)
         class_name = getattr(type(self), "name", _MISSING)
         if class_name is not _MISSING:
-            return class_name
+            return str(class_name)
         return f"{type(self).__module__}.{type(self).__name__}"
 
     def _production_default(
@@ -431,8 +433,8 @@ class Production(_DeclarativeProductionMixin):
             comment=comment,
             log_trace_events=log_trace_events,
             schedule=schedule,
-            host_settings=dict(settings or {}),
-            adapter_settings=dict(adapter_settings or {}),
+            host_settings=_normalize_settings_mapping(settings),
+            adapter_settings=_normalize_settings_mapping(adapter_settings),
         )
         self._add_item(ref)
         return ref
@@ -569,7 +571,12 @@ class Production(_DeclarativeProductionMixin):
             )
         ]
 
-    def service(self, name_or_cls: str | type, cls: type | None = None, **kwargs):
+    def service(
+        self,
+        name_or_cls: str | type,
+        cls: type | None = None,
+        **kwargs: Any,
+    ) -> ComponentRef:
         """Add a BusinessService item to the production graph.
 
         See docs/cookbooks/hello-world-production.md and
@@ -577,14 +584,24 @@ class Production(_DeclarativeProductionMixin):
         """
         return self.component(name_or_cls, cls, kind="service", **kwargs)
 
-    def process(self, name_or_cls: str | type, cls: type | None = None, **kwargs):
+    def process(
+        self,
+        name_or_cls: str | type,
+        cls: type | None = None,
+        **kwargs: Any,
+    ) -> ComponentRef:
         """Add a BusinessProcess item to the production graph.
 
         See docs/cookbooks/add-business-process.md.
         """
         return self.component(name_or_cls, cls, kind="process", **kwargs)
 
-    def operation(self, name_or_cls: str | type, cls: type | None = None, **kwargs):
+    def operation(
+        self,
+        name_or_cls: str | type,
+        cls: type | None = None,
+        **kwargs: Any,
+    ) -> ComponentRef:
         """Add a BusinessOperation item to the production graph.
 
         See docs/cookbooks/add-business-operation.md.
@@ -649,6 +666,12 @@ class Production(_DeclarativeProductionMixin):
         mode: str = "replace",
     ) -> None:
         if not isinstance(source, TargetSettingRef):
+            if isinstance(source, TargetSetting):
+                raise TypeError(
+                    "source must be bound to a production item. Use "
+                    "component.connect(ComponentClass.Target, target_component) "
+                    "or prod.connect(component.Target, target_component)."
+                )
             raise TypeError(
                 "source must be a TargetSettingRef returned from a ComponentRef"
             )
@@ -1055,6 +1078,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 +1193,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()

iop/production/rendering.py

@@ -465,9 +465,7 @@ def _connection_lines(production, variables: dict[str, str], item_names: set[str
     for source_item, source_target_setting in sorted(grouped):
         targets = grouped[(source_item, source_target_setting)]
         source_var = variables[source_item]
-        source_expr = (
-            f"{source_var}.target_setting({_literal(source_target_setting)})"
-        )
+        source_expr = _literal(source_target_setting)
         valid_targets = [target for target in targets if target in variables]
         invalid_targets = [target for target in targets if target not in variables]
         for target in invalid_targets:
@@ -476,15 +474,16 @@ def _connection_lines(production, variables: dict[str, str], item_names: set[str
             continue
         if len(valid_targets) == 1:
             lines.append(
-                f"prod.connect({source_expr}, {variables[valid_targets[0]]})"
+                f"{source_var}.connect({source_expr}, {variables[valid_targets[0]]})"
             )
         else:
             lines.append(
-                f"prod.connect({source_expr}, {variables[valid_targets[0]]})"
+                f"{source_var}.connect({source_expr}, {variables[valid_targets[0]]})"
             )
             for target in valid_targets[1:]:
                 lines.append(
-                    f"prod.connect({source_expr}, {variables[target]}, mode='add')"
+                    f"{source_var}.connect({source_expr}, {variables[target]}, "
+                    "mode='add')"
                 )
 
     for edge in production.edges:

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: str = "", **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: str = "", **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

iop/production/validation.py

@@ -8,8 +8,10 @@ from .common import (
     PRODUCTION_SETTING_FIELDS_BY_IRIS,
     PRODUCTION_SETTING_NAMES,
     SETTING_NAME_ALIASES,
+    _normalize_settings_mapping,
 )
 from .import_ import _as_list, _production_payload, _split_settings
+from .types import TargetSetting
 
 _PRODUCTION_PUBLIC_FIELDS = {
     "name",
@@ -151,6 +153,8 @@ def _build_production_object_report(production: Any) -> ProductionValidationRepo
     for item in getattr(production, "items", ()):
         issues.extend(_validate_component_ref(item))
 
+    issues.extend(_validate_target_setting_values(production))
+
     return ProductionValidationReport(production_name, tuple(issues))
 
 
@@ -180,14 +184,18 @@ def _validate_component_ref(item: Any) -> list[ProductionValidationIssue]:
 
     issues.extend(
         _validate_settings(
-            settings=dict(getattr(item, "host_settings", {}) or {}),
+            settings=_normalize_settings_mapping(
+                getattr(item, "host_settings", {}) or {}
+            ),
             path_prefix=f"items.{item_name}.settings.Host",
             local_class=component_class,
             iris_class_name=class_name,
         )
     )
 
-    adapter_settings = dict(getattr(item, "adapter_settings", {}) or {})
+    adapter_settings = _normalize_settings_mapping(
+        getattr(item, "adapter_settings", {}) or {}
+    )
     if str(getattr(item, "kind", "")) == "process" and adapter_settings:
         issues.append(
             ProductionValidationIssue(
@@ -334,9 +342,67 @@ def _local_setting_names(cls: type) -> set[str] | None:
     if not callable(getter):
         return None
     try:
-        return {str(prop[0]) for prop in getter() if prop}
+        properties = getter()
     except Exception:
         return None
+    if not isinstance(properties, (list, tuple)):
+        return None
+    names: set[str] = set()
+    for prop in properties:
+        if isinstance(prop, (list, tuple)) and prop:
+            names.add(str(prop[0]))
+    return names
+
+
+def _validate_target_setting_values(production: Any) -> list[ProductionValidationIssue]:
+    items = tuple(getattr(production, "items", ()) or ())
+    item_names = {str(getattr(item, "name", "")) for item in items}
+    issues: list[ProductionValidationIssue] = []
+    for item in items:
+        item_name = str(getattr(item, "name", ""))
+        host_settings = _normalize_settings_mapping(
+            getattr(item, "host_settings", {}) or {}
+        )
+        for setting_name in _target_setting_names(item):
+            if setting_name not in host_settings:
+                continue
+            for target_name in _target_names(host_settings[setting_name]):
+                if target_name in item_names:
+                    continue
+                issues.append(
+                    ProductionValidationIssue(
+                        kind="route",
+                        path=f"items.{item_name}.settings.Host.{setting_name}",
+                        message=(
+                            f"Target setting references missing production item "
+                            f"{target_name!r}."
+                        ),
+                        suggestion=(
+                            f"Add a production item named {target_name!r}, "
+                            "or update/remove this target setting."
+                        ),
+                    )
+                )
+    return issues
+
+
+def _target_setting_names(item: Any) -> set[str]:
+    names = {str(name) for name in getattr(item, "target_setting_names", set())}
+    component_class = getattr(item, "component_class", None)
+    if isinstance(component_class, type):
+        for base in reversed(component_class.__mro__):
+            for name, value in base.__dict__.items():
+                if isinstance(value, TargetSetting):
+                    names.add(str(name))
+    return names
+
+
+def _target_names(value: Any) -> tuple[str, ...]:
+    return tuple(
+        target
+        for target in (part.strip() for part in str(value or "").split(","))
+        if target
+    )
 
 
 def _validate_names_with_known_set(
@@ -394,7 +460,7 @@ def _adapter_class_name_from_host(host_class_name: str) -> str:
         return ""
 
 
-def _iris_module():
+def _iris_module() -> Any:
     try:
         import iris  # type: ignore
     except Exception:

iop/py.typed

@@ -0,0 +1 @@
+

{iris_pex_embedded_python-4.0.0b15.dist-info → iris_pex_embedded_python-4.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris_pex_embedded_python
-Version: 4.0.0b15
+Version: 4.0.1
 Summary: Iris Interoperability based on Embedded Python
 Author-email: grongier <guillaume.rongier@intersystems.com>
 License: MIT License
@@ -69,14 +69,38 @@ For application repositories, start from the [reusable AGENTS.md template](https
 
 ## Example
 
-Here's a simple example of how a Business Operation can be implemented in Python:
+Here's a tiny Python-authored production:
 
 ```python
-from iop import BusinessOperation
+from dataclasses import dataclass
 
-class MyBo(BusinessOperation):
-    def on_message(self, request):
-        self.log_info("Hello World")
+from iop import BusinessOperation, Message, PollingBusinessService, Production, target
+
+
+@dataclass
+class HelloRequest(Message):
+    text: str = "Hello World"
+
+
+class HelloService(PollingBusinessService):
+    Output = target()
+
+    def on_poll(self):
+        self.send_request_async(self.Output, HelloRequest())
+
+
+class HelloOperation(BusinessOperation):
+    def on_message(self, request: HelloRequest):
+        self.log_info(request.text)
+        return request
+
+
+prod = Production("HelloWorld.Production", testing_enabled=True)
+service = prod.service("HelloService", HelloService)
+operation = prod.operation("HelloOperation", HelloOperation)
+service.connect(HelloService.Output, operation)
+
+PRODUCTIONS = [prod]
 ```
 
 ## Installation

{iris_pex_embedded_python-4.0.0b15.dist-info → iris_pex_embedded_python-4.0.1.dist-info}/RECORD

@@ -1,5 +1,6 @@
-iop/__init__.py,sha256=4QGYNWs4t-Zt4-WfjHXmKRosWS5jZ5A27vl2hiObCVc,10621
+iop/__init__.py,sha256=bnhSiC7XcOIiS7e51uY8fr9Li7RYjhCnlCyVDzZI6-I,10636
 iop/__main__.py,sha256=2rUNM7vaYK0W57Jj72rm7GORyIFLMXKwPq3QNLwYBmY,100
+iop/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 iop/cli/__init__.py,sha256=Y78pBdA-ULzq1c_9xQZsFBlzm3x5xgxSzkvrH5DoM7I,31
 iop/cli/formatting.py,sha256=OLgHA1d8_paAuINQyKkYgihWMLoBhPn7kSXW5whRlIs,1606
 iop/cli/main.py,sha256=r3sLZniM4LCXP6u1kuQmUgMLLD0H04NC5gVXKMNY31M,18418
@@ -39,7 +40,7 @@ iop/components/async_request.py,sha256=AU36pf6NIQMM9ZYR5h6LeQry0EfXXqDaKAjsP16_h
 iop/components/business_host.py,sha256=5EXwzZzfEVYLFlzi519GXKclTz2m5FMcqtl10lLzUyw,12089
 iop/components/business_operation.py,sha256=KycRNz-zuyJs2VneTBVcppyd3rKLekrISjbubCbzHxY,2905
 iop/components/business_process.py,sha256=1xTYwqhvJaXC-BvQ5WoGOud5QwxT9EPpvDPDX4zThXg,9839
-iop/components/business_service.py,sha256=fwSdHGFuC55_qSjFBpW-cLZmrK3Cm8Yxgk1KvxuQv2Y,4718
+iop/components/business_service.py,sha256=Bp47bJzTWHp66kp0Zo_D-blOKHzj4i6kXu-lCRMMzfg,3597
 iop/components/common.py,sha256=tsP2APRBnks1hVazS9dX0Q8KCoANbUsnaFTlzqOIkVY,19063
 iop/components/debugpy.py,sha256=sNFKaF9MtWBNAqxH4ubSIVqjsIpsHGjRK2jzBU-O59Y,6011
 iop/components/generator_request.py,sha256=NOllwJnY06kk_eC7cQXDQ8NBFKfQakyz3A_AgYJ5f5Y,1351
@@ -53,7 +54,7 @@ iop/components/settings.py,sha256=USAKAisdersKlAEIk8HDu_TuYtkO-Sc3an3PXjPcDRA,62
 iop/messages/__init__.py,sha256=k1AKplpjdqSxM5Gl7bpWAfw93xUgigovlI4SKhwKHRI,355
 iop/messages/base.py,sha256=ZrVXEz7JrYHnt5b3M7avxcJCB0_OZxm1uWm9gQ4_eAw,1906
 iop/messages/decorators.py,sha256=CWk08k8U2aTJv7Dx1n2jp8sjZZSCD8NJPoifKLB3W2g,2488
-iop/messages/dispatch.py,sha256=Mgz0OHTQDU02Z8qPxl_lks-nlAvW6ADcJkTS4faYE-Q,10459
+iop/messages/dispatch.py,sha256=l7FX-TAx5cLgjxoxNpL8ul3Lj4w4-taxTtyeZU3W85I,14001
 iop/messages/persistent.py,sha256=ibRhRTqzwGcAqem744KZzHiouUlc8-J3ftB4zyzQYx4,16906
 iop/messages/serialization.py,sha256=BW0o-7GaceMW7RMOzOJ8g9rKEv28NYnYFwtTLmAf7Yg,9255
 iop/messages/validation.py,sha256=X6MSWsjLZDuyX1Tfx0TP3T6OI4nj1HZccwR2Z9PSubY,1606
@@ -61,24 +62,24 @@ iop/migration/__init__.py,sha256=wp-RvjLKYW_Pi2AJLfiWe1bACxENzEgjXtP9UMNiSVY,36
 iop/migration/io.py,sha256=hAehtApFZFgGzjzgwBmDMxdA1xoRhE-okOcEzvgFdQ4,1822
 iop/migration/manifest.py,sha256=Bs4eC1_i-ZnovlgSW9FKu5WBwy_6Zwy5ZAcsi5A1szU,19351
 iop/migration/plans.py,sha256=5kx3aqQiPDJ3F8hU9pp9_mOO1_N6GA0Ps7--G1Iv6z8,2549
-iop/migration/utils.py,sha256=A3BlFpBGsDpF5DyA2DE1Oy52Ja7qC8QbFCxLFe_Xzg0,36867
+iop/migration/utils.py,sha256=pOojLPMZes05KXrGN2ap45ffppP5Z4tS4bjJ0gSD5Oc,38183
 iop/production/__init__.py,sha256=95VmJgC3lWtHpUJijLqyKKxFZa65OcRni8803kb4aHE,2148
 iop/production/actions.py,sha256=TLVAjPTPq21oLj9c-IG10qMNJ2hvPzueviMy_c1a0ZU,17199
-iop/production/common.py,sha256=IoUg9jkFzSQwDsHcXvkVAC4qxpWKs3kTfXFm_EP07EU,3091
-iop/production/component.py,sha256=tyPqo_AvmaXowUwFj6ycqS1n22IYB1NfC3aaF4T0ves,7862
-iop/production/declarations.py,sha256=Tb79Q6rwmFMi6xKpzajJa4Aa2_Tk3sD-e8qiuRJX77s,5821
+iop/production/common.py,sha256=L2QyvE2nC1J333sbebYx_6dyoaFL-89ouMO3Kfe4-D8,3465
+iop/production/component.py,sha256=XalzNEWhCC1RVSZlQZRBpZM3BdRC2TDU-ko3Zn8-Kzo,9475
+iop/production/declarations.py,sha256=u1hzgbDchr55R3dEXEIi9-P5JkfMG7C3aiSWhfhifG8,5952
 iop/production/declarative.py,sha256=IpHYO46mu7k9wnq3DpFreoALPoX1Vi8DrJb-85O_-bQ,7853
 iop/production/diff.py,sha256=NYpcSVklaGpaZOyl933W8eLsDWcwjlf6Upbp4pVGSMU,9975
 iop/production/import_.py,sha256=twBra6j2peolFadv8WyDwZZOd9NznzAkPsk2RbOfZQM,10833
 iop/production/inspection.py,sha256=PPv9DiDS4OrnKROqV7JPbuY8Y0JR-m8syPhap3GgE4g,3363
-iop/production/model.py,sha256=CpI5OBEBBw9z40Lws1rKVL9Mx_P4fhKmwYPoqEUntKU,41705
+iop/production/model.py,sha256=bEtDo-IwECuCrkKDXJXm1hB5Bmme4srB6l9isc8n3KI,44088
 iop/production/planning.py,sha256=nCYrXLKlHBlUaQZPzPfqtIERIv62F2sg4gJ0b8mtcKk,23375
 iop/production/reconstruction.py,sha256=5vVteTEM6IOiQUfpe4AUQg6Nt4oaaIDR61-1l6Vu8hk,12532
-iop/production/rendering.py,sha256=UVHLICY4zWEP3W7-99TpB2WeLBNREC2N8rYSnBa_iZM,20240
+iop/production/rendering.py,sha256=gyJyUcWwvgwRWvlvddZbCIhkjJ1DcMZfbL2brIa_k8U,20229
 iop/production/runtime.py,sha256=6grX1u20OhHnvhzC3yPDTFEoDs_TN4mfs5MxzFzZMls,2637
 iop/production/source_inference.py,sha256=Wl3E9-1hWb4qxD1jwrrZTLSgqN-0vGhOrJtmzDWPCao,21613
-iop/production/types.py,sha256=L_wyXO8deOnqRFin74SX_K8UWILFu-VzIO5pKNa6VXY,16580
-iop/production/validation.py,sha256=14BfjrLXW1AOuP8AdBrs-CY6zynaDc8_AUD9frsYAIU,13753
+iop/production/types.py,sha256=hzO8rj73z16WqFQBI7YBAznY-1fD8ENyJqzTY-ydFXI,16889
+iop/production/validation.py,sha256=gzRFLCTPGiNMIot1yG1FXG5ab9inpq4rqYYQpefhBYs,16217
 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
@@ -91,9 +92,9 @@ iop/runtime/remote/director.py,sha256=bkie751GrYLgGs7ApRCowHpSnJA8KupxCOrFDQmjyO
 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.0b15.dist-info/licenses/LICENSE,sha256=rZSiBFId_sfbJ6RL0GjjPX-InNLkNS9ou7eQsikciI8,1089
-iris_pex_embedded_python-4.0.0b15.dist-info/METADATA,sha256=FAs1I9jhJCMQabHY14tAR02X2fnv_DS7Yu-yrAZLVso,5284
-iris_pex_embedded_python-4.0.0b15.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-iris_pex_embedded_python-4.0.0b15.dist-info/entry_points.txt,sha256=fzS8ZFsPe8cnpEx208X60DNugCPQmuSloPeg4pyyJDY,42
-iris_pex_embedded_python-4.0.0b15.dist-info/top_level.txt,sha256=BM54-OXQ6l2BDtmesWNXckh033s9gcjoO7bfjbwZbxU,4
-iris_pex_embedded_python-4.0.0b15.dist-info/RECORD,,
+iris_pex_embedded_python-4.0.1.dist-info/licenses/LICENSE,sha256=rZSiBFId_sfbJ6RL0GjjPX-InNLkNS9ou7eQsikciI8,1089
+iris_pex_embedded_python-4.0.1.dist-info/METADATA,sha256=hf-w2SSbyHHLLX_SIr41V2hKx3CQ2mVjnbZmJ2Oczic,5852
+iris_pex_embedded_python-4.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+iris_pex_embedded_python-4.0.1.dist-info/entry_points.txt,sha256=fzS8ZFsPe8cnpEx208X60DNugCPQmuSloPeg4pyyJDY,42
+iris_pex_embedded_python-4.0.1.dist-info/top_level.txt,sha256=BM54-OXQ6l2BDtmesWNXckh033s9gcjoO7bfjbwZbxU,4
+iris_pex_embedded_python-4.0.1.dist-info/RECORD,,