feat: enhance source connection handling with target reference and host settings resolution

Author: bot

src/iop/production/source_inference.py

@@ -15,6 +15,7 @@ class SourceConnection:
     source: str
     detail: str = ""
     interaction: str = "request"
+    target_reference: str = ""
 
 
 _PYTHON_REQUEST_METHODS = {
@@ -93,7 +94,7 @@ def infer_source_connections(
 
 def _infer_python_connections(
     class_name: str,
-    _host_settings: dict[str, Any],
+    host_settings: dict[str, Any],
     roots: tuple[Path, ...],
 ) -> list[SourceConnection]:
     candidates = []
@@ -114,7 +115,12 @@ def _infer_python_connections(
 
     connections: list[SourceConnection] = []
     for _root_index, candidate in candidates[:1]:
-        connections.extend(candidate.connections)
+        connections.extend(
+            _python_connections_for_host_settings(
+                candidate.connections,
+                host_settings,
+            )
+        )
     return _unique_connections(connections)
 
 
@@ -281,7 +287,7 @@ def _python_class_connections(class_node: ast.ClassDef) -> list[SourceConnection
             continue
         call_name = _python_call_name(node.func)
         if call_name in _PYTHON_REQUEST_METHODS:
-            for target, detail, interaction in _python_request_targets(
+            for target, detail, interaction, target_reference in _python_request_targets(
                 node,
                 string_values,
                 call_name,
@@ -292,10 +298,11 @@ def _python_class_connections(class_node: ast.ClassDef) -> list[SourceConnection
                         source="Python source",
                         detail=detail,
                         interaction=interaction,
+                        target_reference=target_reference,
                     )
                 )
         elif call_name in _PYTHON_MULTI_REQUEST_METHODS:
-            for target, detail, interaction in _python_multi_request_targets(
+            for target, detail, interaction, target_reference in _python_multi_request_targets(
                 node,
                 string_values,
                 call_name,
@@ -306,6 +313,7 @@ def _python_class_connections(class_node: ast.ClassDef) -> list[SourceConnection
                         source="Python source",
                         detail=detail,
                         interaction=interaction,
+                        target_reference=target_reference,
                     )
                 )
     return _unique_connections(connections)
@@ -367,7 +375,7 @@ def _python_request_targets(
     call: ast.Call,
     string_values: dict[str, list[str]],
     call_name: str,
-) -> list[tuple[str, str, str]]:
+) -> list[tuple[str, str, str, str]]:
     target_node = _python_call_target_node(call)
     if target_node is None:
         return []
@@ -383,14 +391,14 @@ def _python_multi_request_targets(
     call: ast.Call,
     string_values: dict[str, list[str]],
     call_name: str,
-) -> list[tuple[str, str, str]]:
+) -> list[tuple[str, str, str, str]]:
     if not call.args:
         return []
     collection = call.args[0]
     if not isinstance(collection, (ast.List, ast.Tuple)):
         return []
 
-    targets: list[tuple[str, str, str]] = []
+    targets: list[tuple[str, str, str, str]] = []
     for item in collection.elts:
         if not isinstance(item, ast.Tuple) or not item.elts:
             continue
@@ -410,20 +418,59 @@ def _resolve_python_targets(
     string_values: dict[str, list[str]],
     call_name: str,
     interaction: str,
-) -> list[tuple[str, str, str]]:
+) -> list[tuple[str, str, str, str]]:
     literal = _python_literal_string(node)
     if literal is not None:
-        return [(literal, f"{call_name} literal", interaction)]
+        return [(literal, f"{call_name} literal", interaction, "")]
 
     name = _python_reference_name(node)
     if name is None:
         return []
+    detail = f"{call_name} {name}"
+    values = string_values.get(name, [])
+    if not values:
+        return [("", detail, interaction, name)]
     return [
-        (value, f"{call_name} {name}", interaction)
-        for value in string_values.get(name, [])
+        (value, detail, interaction, name)
+        for value in values
     ]
 
 
+def _python_connections_for_host_settings(
+    connections: tuple[SourceConnection, ...],
+    host_settings: dict[str, Any],
+) -> list[SourceConnection]:
+    resolved: list[SourceConnection] = []
+    for connection in connections:
+        setting_name = _python_reference_setting_name(connection.target_reference)
+        setting_targets = (
+            _split_targets(host_settings.get(setting_name, ""))
+            if setting_name
+            else []
+        )
+        if setting_targets:
+            for target in setting_targets:
+                resolved.append(
+                    SourceConnection(
+                        target=target,
+                        source=connection.source,
+                        detail=connection.detail,
+                        interaction=connection.interaction,
+                        target_reference=connection.target_reference,
+                    )
+                )
+            continue
+        if connection.target:
+            resolved.append(connection)
+    return resolved
+
+
+def _python_reference_setting_name(reference: str) -> str:
+    if not reference.startswith("self."):
+        return ""
+    return reference.removeprefix("self.")
+
+
 def _python_call_target_node(call: ast.Call) -> ast.AST | None:
     for keyword in call.keywords:
         if keyword.arg == "target":
@@ -664,15 +711,16 @@ def _root_key(root: Path) -> str:
 
 def _unique_connections(connections: list[SourceConnection]) -> list[SourceConnection]:
     unique: list[SourceConnection] = []
-    seen: set[tuple[str, str, str, str]] = set()
+    seen: set[tuple[str, str, str, str, str]] = set()
     for connection in connections:
-        if not connection.target:
+        if not connection.target and not connection.target_reference:
             continue
         key = (
             connection.target,
             connection.source,
             connection.detail,
             connection.interaction,
+            connection.target_reference,
         )
         if key in seen:
             continue

src/tests/unit/test_production.py

@@ -467,6 +467,110 @@ def on_message(self, request):
     ]["interaction"] == "sync"
 
 
+def test_production_from_dict_prefers_python_host_setting_over_source_default(
+    tmp_path,
+    monkeypatch,
+):
+    (tmp_path / "bench_bp.py").write_text(
+        """
+class BenchIoPProcess:
+    target = target()
+
+    def on_init(self):
+        if not hasattr(self, "target"):
+            self.target = "Python.BenchIoPOperation"
+
+    def on_message(self, request):
+        self.send_request_sync(self.target, request)
+""",
+        encoding="utf-8",
+    )
+    monkeypatch.chdir(tmp_path)
+    classpaths = str(tmp_path)
+
+    prod = Production.from_dict(
+        {
+            "Bench.Production": {
+                "Item": [
+                    {
+                        "@Name": "Python.BenchIoPProcess",
+                        "@ClassName": "Python.BenchIoPProcess",
+                        "Setting": [
+                            {
+                                "@Target": "Host",
+                                "@Name": "%classpaths",
+                                "#text": classpaths,
+                            },
+                            {
+                                "@Target": "Host",
+                                "@Name": "target",
+                                "#text": "Python.BenchIoPOperation",
+                            },
+                        ],
+                    },
+                    {
+                        "@Name": "Python.BenchIoPProcess.To.Cls",
+                        "@ClassName": "Python.BenchIoPProcess",
+                        "Setting": [
+                            {
+                                "@Target": "Host",
+                                "@Name": "%classpaths",
+                                "#text": classpaths,
+                            },
+                            {
+                                "@Target": "Host",
+                                "@Name": "target",
+                                "#text": "Bench.Operation",
+                            },
+                        ],
+                    },
+                    {
+                        "@Name": "Python.BenchIoPOperation",
+                        "@ClassName": "Python.BenchIoPOperation",
+                    },
+                    {"@Name": "Bench.Operation", "@ClassName": "Bench.Operation"},
+                ]
+            }
+        },
+        connections={
+            "items": [
+                {
+                    "item": "Python.BenchIoPProcess",
+                    "iop": True,
+                    "module": "bench_bp",
+                    "classname": "BenchIoPProcess",
+                    "classpaths": classpaths,
+                    "connections": [],
+                },
+                {
+                    "item": "Python.BenchIoPProcess.To.Cls",
+                    "iop": True,
+                    "module": "bench_bp",
+                    "classname": "BenchIoPProcess",
+                    "classpaths": classpaths,
+                    "connections": [],
+                },
+            ]
+        },
+    )
+
+    edges = {
+        (edge["source_item"], edge["target"]): edge
+        for edge in prod.graph().to_dict()["edges"]
+    }
+
+    assert (
+        "Python.BenchIoPProcess.To.Cls",
+        "Python.BenchIoPOperation",
+    ) not in edges
+    assert edges[
+        ("Python.BenchIoPProcess", "Python.BenchIoPOperation")
+    ]["interaction"] == "sync"
+    assert edges[
+        ("Python.BenchIoPProcess.To.Cls", "Bench.Operation")
+    ]["interaction"] == "sync"
+
+
 def test_production_from_dict_does_not_treat_python_prefix_as_python_source(
     tmp_path,
     monkeypatch,