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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris_pex_embedded_python
-Version: 4.0.1b5
+Version: 4.0.1b7
 Summary: Iris Interoperability based on Embedded Python
 Author-email: grongier <guillaume.rongier@intersystems.com>
 License: MIT License
@@ -98,7 +98,7 @@ class HelloOperation(BusinessOperation):
 prod = Production("HelloWorld.Production", testing_enabled=True)
 service = prod.service("HelloService", HelloService)
 operation = prod.operation("HelloOperation", HelloOperation)
-prod.connect(service.Output, operation)
+service.connect(HelloService.Output, operation)
 
 PRODUCTIONS = [prod]
 ```

{iris_pex_embedded_python-4.0.1b5 → iris_pex_embedded_python-4.0.1b7}/README.md

@@ -44,7 +44,7 @@ class HelloOperation(BusinessOperation):
 prod = Production("HelloWorld.Production", testing_enabled=True)
 service = prod.service("HelloService", HelloService)
 operation = prod.operation("HelloOperation", HelloOperation)
-prod.connect(service.Output, operation)
+service.connect(HelloService.Output, operation)
 
 PRODUCTIONS = [prod]
 ```

{iris_pex_embedded_python-4.0.1b5 → iris_pex_embedded_python-4.0.1b7}/docs/cookbooks/add-business-operation.md

@@ -93,7 +93,8 @@ If another component sends to the operation, declare a `target()` setting on the
 sender and connect it:
 
 ```python
-prod.connect(process.Orders, operation)
+process = prod.process("OrderProcess", OrderProcess)
+process.connect(OrderProcess.Orders, operation)
 ```
 
 ## Migration Command

{iris_pex_embedded_python-4.0.1b5 → iris_pex_embedded_python-4.0.1b7}/docs/cookbooks/add-business-process.md

@@ -85,8 +85,8 @@ process = prod.process("OrderProcess", OrderProcess)
 accepted = prod.operation("AcceptedOperation", AcceptedOperation)
 rejected = prod.operation("RejectedOperation", RejectedOperation)
 
-prod.connect(process.Accepted, accepted)
-prod.connect(process.Rejected, rejected)
+process.connect(OrderProcess.Accepted, accepted)
+process.connect(OrderProcess.Rejected, rejected)
 ```
 
 ## Migration Command
@@ -113,4 +113,3 @@ iop --migrate settings.py
   intended precedence explicit.
 - Calling a downstream component directly instead of sending a production
   message through a target.
-

{iris_pex_embedded_python-4.0.1b5 → iris_pex_embedded_python-4.0.1b7}/docs/cookbooks/add-polling-service.md

@@ -55,7 +55,7 @@ In `settings.py`:
 ```python
 service = prod.service("FilePollService", FilePollService)
 operation = prod.operation("TargetOperation", TargetOperation)
-prod.connect(service.Output, operation)
+service.connect(FilePollService.Output, operation)
 ```
 
 ## Migration Command

{iris_pex_embedded_python-4.0.1b5 → iris_pex_embedded_python-4.0.1b7}/docs/cookbooks/hello-world-production.md

@@ -74,7 +74,7 @@ prod = Production("HelloWorld.Production", testing_enabled=True)
 
 service = prod.service("HelloService", HelloService)
 operation = prod.operation("HelloOperation", HelloOperation)
-prod.connect(service.Output, operation)
+service.connect(HelloService.Output, operation)
 
 PRODUCTIONS = [prod]
 ```

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

@@ -24,7 +24,7 @@ Implementation requirements:
 - Add services with prod.service(...), processes with prod.process(...), and
   operations with prod.operation(...).
 - Use target() attributes on component classes for outbound routing.
-- Use prod.connect(source.TargetName, destination) for graph edges.
+- Use component.connect(ComponentClass.TargetName, destination) for graph edges.
 - Keep PRODUCTIONS = [prod] as the migration entrypoint.
 - Do not add raw CLASSES entries for components already declared in the
   Production graph.
@@ -51,8 +51,8 @@ process = prod.process("RouteProcess", RouteProcess)
 accepted = prod.operation("AcceptedOperation", AcceptedOperation)
 rejected = prod.operation("RejectedOperation", RejectedOperation)
 
-prod.connect(process.Accepted, accepted)
-prod.connect(process.Rejected, rejected)
+process.connect(RouteProcess.Accepted, accepted)
+process.connect(RouteProcess.Rejected, rejected)
 ```
 
 When a route should have a conventional default, pass the target item name to

{iris_pex_embedded_python-4.0.1b5 → iris_pex_embedded_python-4.0.1b7}/docs/getting-started/first-steps.md

@@ -126,7 +126,7 @@ prod = Production("HelloWorld.Production", testing_enabled=True)
 
 service = prod.service("HelloService", HelloService)
 operation = prod.operation("HelloOperation", HelloOperation)
-prod.connect(service.Output, operation)
+service.connect(HelloService.Output, operation)
 
 PRODUCTIONS = [prod]
 ```
@@ -136,7 +136,7 @@ In this production:
 - `Production("HelloWorld.Production")` declares the IRIS production class.
 - `prod.service("HelloService", HelloService)` adds one service item.
 - `prod.operation("HelloOperation", HelloOperation)` adds one operation item.
-- `prod.connect(service.Output, operation)` sets the service `Output` target to `HelloOperation` and records the production graph edge.
+- `service.connect(HelloService.Output, operation)` sets the service `Output` target to `HelloOperation` and records the production graph edge.
 - `PRODUCTIONS = [prod]` tells IoP what to migrate.
 
 You do not need a separate `CLASSES` dictionary for these production components. IoP registers Python component classes from the `Production` graph during migration.

{iris_pex_embedded_python-4.0.1b5 → iris_pex_embedded_python-4.0.1b7}/docs/getting-started/register-component.md

@@ -40,7 +40,7 @@ class OrderOperation(BusinessOperation):
 prod = Production("Demo.Production", testing_enabled=True)
 file = prod.service("FileInput", FileService)
 orders = prod.operation("OrderOperation", OrderOperation)
-prod.connect(file.Output, orders)
+file.connect(FileService.Output, orders)
 
 PRODUCTIONS = [prod]
 ```
@@ -55,7 +55,7 @@ Migration registers the generated IRIS proxy classes for `FileService` and
 `OrderOperation`, then saves `Demo.Production`.
 
 `target()` declares a configurable outbound target setting on the component
-class. `prod.connect(file.Output, orders)` sets that setting to the destination
+class. `file.connect(FileService.Output, orders)` sets that setting to the destination
 component and records the production graph edge.
 
 When you need to test `FileService` at runtime, do not use `iop --test`.

iris_pex_embedded_python-4.0.1b7/docs/index.md

@@ -0,0 +1,68 @@
+# IoP (Interoperability On Python)
+
+[![PyPI - Status](https://img.shields.io/pypi/status/iris-pex-embedded-python)](https://pypi.org/project/iris-pex-embedded-python/)
+[![PyPI](https://img.shields.io/pypi/v/iris-pex-embedded-python)](https://pypi.org/project/iris-pex-embedded-python/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/iris-pex-embedded-python)](https://pypi.org/project/iris-pex-embedded-python/)
+[![PyPI - License](https://img.shields.io/pypi/l/iris-pex-embedded-python)](https://pypi.org/project/iris-pex-embedded-python/)
+![GitHub last commit](https://img.shields.io/github/last-commit/grongierisc/interoperability-embedded-python)
+
+Welcome to the **Interoperability On Python (IoP)** proof of concept! This project demonstrates how the **IRIS Interoperability Framework** can be utilized with a **Python-first approach**.
+
+Documentation can be found [here](https://grongierisc.github.io/interoperability-embedded-python/).
+For prompt-driven workflows, see [AI-assisted coding with IoP](https://grongierisc.github.io/interoperability-embedded-python/ai-coding/).
+For task-oriented examples, see the [IoP cookbooks](https://grongierisc.github.io/interoperability-embedded-python/cookbooks/).
+For application repositories, start from the [reusable AGENTS.md template](https://grongierisc.github.io/interoperability-embedded-python/agents-template/).
+
+## Example
+
+Here's a tiny Python-authored production:
+
+```python
+from dataclasses import dataclass
+
+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
+
+To start using this proof of concept, install it using pip:
+
+```bash
+pip install iris-pex-embedded-python
+```
+
+## Getting Started
+
+If you're new to this project, begin by reading the [installation guide](https://grongierisc.github.io/interoperability-embedded-python/getting-started/installation). Then, follow the [first steps](https://grongierisc.github.io/interoperability-embedded-python/getting-started/first-steps) to create your first Python-authored production.
+
+If you are using an AI coding assistant, start with [AI-assisted coding with IoP](https://grongierisc.github.io/interoperability-embedded-python/ai-coding/).
+For concrete workflows, use the [IoP cookbooks](https://grongierisc.github.io/interoperability-embedded-python/cookbooks/).
+For healthcare productions, also see [Healthcare AI-assisted coding](https://grongierisc.github.io/interoperability-embedded-python/healthcare-ai-coding/).
+
+Happy coding!

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

@@ -145,9 +145,25 @@ Python-authored components use Python classes:
 prod = Production("Demo.Production")
 file = prod.service("FileInput", FileService)
 orders = prod.operation(OrderOperation)
-prod.connect(file.Output, orders)
+file.connect(FileService.Output, orders)
 ```
 
+For static autocomplete, bind through the component ref and pass the descriptor
+from the component class:
+
+```python
+first = prod.service("FirstInput", FileService)
+second = prod.service("SecondInput", FileService)
+orders = prod.operation(OrderOperation)
+
+first.connect(FileService.Output, orders)
+second.connect(FileService.Output, orders)
+```
+
+The left-side `ComponentRef` selects the production item instance, so both
+connections bind the same class-declared target setting to different configured
+items.
+
 For a conventional route, the target can be defaulted on the component class:
 
 ```python

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

@@ -504,7 +504,7 @@ class OrderOperation(BusinessOperation):
 prod = Production("Demo.Production")
 file = prod.service("FileInput", FileService)
 orders = prod.operation(OrderOperation)
-prod.connect(file.Output, orders)
+file.connect(FileService.Output, orders)
 ```
 
 The same topology can be declared as a production subclass. Instantiating the
@@ -561,7 +561,7 @@ class FileProduction(Production):
 `target()` declares a configurable outbound target setting on `FileService`.
 `Route(FileService.Output, ORDER_OPERATION)` wires that setting to a production
 item. This separation mirrors the instance-style form:
-`prod.connect(file.Output, orders)`.
+`file.connect(FileService.Output, orders)`.
 
 For Python component classes, prefer passing the descriptor
 (`FileService.Output`) to `Route`. For built-in IRIS or ObjectScript classes,
@@ -615,6 +615,19 @@ file = (
 )
 ```
 
+For Python components, `ComponentRef.connect(...)` also accepts the `target()`
+descriptor from the component class. This keeps the left-side production item
+instance explicit while giving static tools autocomplete on the class:
+
+```python
+first = prod.service("FirstInput", FileService)
+second = prod.service("SecondInput", FileService)
+orders = prod.operation(OrderOperation)
+
+first.connect(FileService.Output, orders)
+second.connect(FileService.Output, orders)
+```
+
 For ObjectScript or built-in IRIS components, use manual target setting names:
 
 ```python
@@ -640,6 +653,12 @@ Progressive component methods include `pool()`, `enable()`, `disable()`,
 attributes on `ComponentRef`, so their fluent update methods use distinct names
 instead of shadowing those attributes.
 
+Declared target settings are available as dynamic `ComponentRef` attributes,
+such as `rest.my_target`, and are exposed through `dir(rest)` for runtime
+autocomplete. For Pylance, mypy, and other static tools, prefer
+`rest.connect(Rest.my_target, operation)` because completion happens on the
+component class.
+
 Python `Production` is the source of truth for Python-authored topology. IRIS
 remains the runtime source of truth. Imported graphs are operational
 reconstructions until metadata persistence makes round-trip fidelity possible.

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

@@ -41,7 +41,7 @@ class HelloOperation(BusinessOperation):
 prod = Production("Demo.Production", testing_enabled=True)
 service = prod.service("HelloService", HelloService)
 operation = prod.operation("HelloOperation", HelloOperation)
-prod.connect(service.Output, operation)
+service.connect(HelloService.Output, operation)
 
 PRODUCTIONS = [prod]
 ```
@@ -201,13 +201,13 @@ class OrderOperation(BusinessOperation):
 prod = Production("Demo.Production", testing_enabled=True)
 file = prod.service("FileInput", FileService)
 orders = prod.operation(OrderOperation)
-prod.connect(file.Output, orders)
+file.connect(FileService.Output, orders)
 
 PRODUCTIONS = [prod]
 ```
 
 `target()` declares an outbound target setting on the component class.
-`prod.connect()` sets that setting to the destination component and
+`component.connect(ComponentClass.Target, destination)` 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
@@ -310,7 +310,7 @@ PRODUCTIONS = [FileProduction()]
 
 `target()` declares the outbound target setting on the Python component class.
 `Route(FileService.Output, ORDER_OPERATION)` wires that setting to a production
-item. This is the class-style equivalent of `prod.connect(file.Output, orders)`.
+item. This is the class-style equivalent of `file.connect(FileService.Output, orders)`.
 
 For Python component classes, prefer the descriptor form
 `Route(FileService.Output, ...)`. For existing IRIS classes, use the IRIS
@@ -617,7 +617,7 @@ feed = (
     .host_setting("Limit", int(os.environ.get("REDDIT_LIMIT", "10")))
 )
 exporter = prod.operation("FileExporter", FileOperation)
-prod.connect(feed.Output, exporter)
+feed.connect(RedditService.Output, exporter)
 
 PRODUCTIONS = [prod]
 ```

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

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 
 [project]
 name = "iris_pex_embedded_python"
-version = "4.0.1b5"
+version = "4.0.1b7"
 description = "Iris Interoperability based on Embedded Python"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -53,6 +53,7 @@ exclude = ["tests*"]
 
 [tool.setuptools.package-data]
 "*" = ["*.cls", "cls/**/*.cls"]
+"iop" = ["py.typed"]
 
 [tool.pytest.ini_options]
 asyncio_default_fixture_loop_scope = "class"

{iris_pex_embedded_python-4.0.1b5 → iris_pex_embedded_python-4.0.1b7}/src/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)

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

@@ -219,10 +219,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(
@@ -570,7 +570,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
@@ -578,14 +583,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.
@@ -650,6 +665,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"
             )

{iris_pex_embedded_python-4.0.1b5 → iris_pex_embedded_python-4.0.1b7}/src/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:

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

@@ -12,7 +12,7 @@ from ..components.settings import Category, Setting, controls
 class TargetSetting(Setting):
     """Production target setting descriptor created by target()."""
 
-    def __init__(self, default: Any = "", **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())
@@ -34,7 +34,7 @@ class TargetSetting(Setting):
         return super().__get__(instance, owner)
 
 
-def target(default: Any = "", **kwargs: Any) -> TargetSetting:
+def target(default: str = "", **kwargs: Any) -> TargetSetting:
     """Purpose:
         Declare a configurable outbound target setting on a component class.
 

{iris_pex_embedded_python-4.0.1b5 → iris_pex_embedded_python-4.0.1b7}/src/iop/production/validation.py

@@ -10,6 +10,7 @@ from .common import (
     SETTING_NAME_ALIASES,
 )
 from .import_ import _as_list, _production_payload, _split_settings
+from .types import TargetSetting
 
 _PRODUCTION_PUBLIC_FIELDS = {
     "name",
@@ -151,6 +152,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))
 
 
@@ -334,9 +337,65 @@ 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 = dict(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 +453,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:

{iris_pex_embedded_python-4.0.1b5 → iris_pex_embedded_python-4.0.1b7/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.1b5
+Version: 4.0.1b7
 Summary: Iris Interoperability based on Embedded Python
 Author-email: grongier <guillaume.rongier@intersystems.com>
 License: MIT License
@@ -98,7 +98,7 @@ class HelloOperation(BusinessOperation):
 prod = Production("HelloWorld.Production", testing_enabled=True)
 service = prod.service("HelloService", HelloService)
 operation = prod.operation("HelloOperation", HelloOperation)
-prod.connect(service.Output, operation)
+service.connect(HelloService.Output, operation)
 
 PRODUCTIONS = [prod]
 ```

{iris_pex_embedded_python-4.0.1b5 → iris_pex_embedded_python-4.0.1b7}/src/iris_pex_embedded_python.egg-info/SOURCES.txt

@@ -44,6 +44,7 @@ docs/getting-started/installation.md
 docs/getting-started/register-component.md
 src/iop/__init__.py
 src/iop/__main__.py
+src/iop/py.typed
 src/iop/cli/__init__.py
 src/iop/cli/formatting.py
 src/iop/cli/main.py

iris_pex_embedded_python-4.0.1b7/src/iris_pex_embedded_python.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+