iris-pex-embedded-python 4.0.0b10__tar.gz → 4.0.0b11__tar.gz

{iris_pex_embedded_python-4.0.0b10 → iris_pex_embedded_python-4.0.0b11}/PKG-INFO

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

{iris_pex_embedded_python-4.0.0b10 → iris_pex_embedded_python-4.0.0b11}/pyproject.toml

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

{iris_pex_embedded_python-4.0.0b10 → iris_pex_embedded_python-4.0.0b11}/src/iop/production/reconstruction.py

@@ -218,17 +218,24 @@ def _infer_connections_from_host_settings(
     runtime_sources_with_targets: set[str],
 ) -> None:
     for ref in production._items:
-        if ref.name in runtime_sources_with_targets:
-            continue
         for setting_name, value in ref.host_settings.items():
             if str(setting_name).startswith("%"):
                 continue
+            has_runtime_targets = ref.name in runtime_sources_with_targets
+            if has_runtime_targets and not _is_target_config_setting(setting_name):
+                continue
             for target_name in _setting_targets(value):
                 if target_name not in production._items_by_name:
                     continue
+                if _has_connection(production, ref.name, setting_name, target_name):
+                    continue
                 ref.target_setting_names.add(setting_name)
                 metadata = {"source": "Host setting fallback"}
-                if ref.name in runtime_sources:
+                if has_runtime_targets:
+                    metadata["reason"] = (
+                        "runtime discovery did not report this target setting"
+                    )
+                elif ref.name in runtime_sources:
                     metadata["reason"] = "runtime discovery returned no targets"
                 production._register_connection(
                     ref.name,
@@ -240,6 +247,27 @@ def _infer_connections_from_host_settings(
                 )
 
 
+def _is_target_config_setting(setting_name: Any) -> bool:
+    normalized = str(setting_name or "").strip().lower()
+    return normalized.endswith("targetconfigname") or normalized.endswith(
+        "targetconfignames"
+    )
+
+
+def _has_connection(
+    production,
+    source_item: str,
+    source_target_setting: str,
+    target_name: str,
+) -> bool:
+    return any(
+        edge.source_item == source_item
+        and edge.source_target_setting == source_target_setting
+        and edge.target == target_name
+        for edge in production._edges
+    )
+
+
 def _infer_connections_from_source(production) -> None:
     existing = {
         (edge.source_item, edge.target): edge

{iris_pex_embedded_python-4.0.0b10 → iris_pex_embedded_python-4.0.0b11}/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

{iris_pex_embedded_python-4.0.0b10 → iris_pex_embedded_python-4.0.0b11}/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.0b10
+Version: 4.0.0b11
 Summary: Iris Interoperability based on Embedded Python
 Author-email: grongier <guillaume.rongier@intersystems.com>
 License: MIT License