graphddb-runtime 1.0.6__tar.gz → 1.0.8__tar.gz

{graphddb_runtime-1.0.6 → graphddb_runtime-1.0.8}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: graphddb-runtime
-Version: 1.0.6
+Version: 1.0.8
 Summary: Thin DynamoDB executor for GraphDDB-generated Python repositories (single-operation core, issue #44).
 License: MIT
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: boto3>=1.26
-Requires-Dist: behavior-contracts==0.6.0
+Requires-Dist: behavior-contracts==0.7.3
 Provides-Extra: test
 Requires-Dist: pytest>=7.0; extra == "test"
 

{graphddb_runtime-1.0.6 → graphddb_runtime-1.0.8}/graphddb_runtime/behavior_exec.py

@@ -122,16 +122,22 @@ _READ_META_PORTS = frozenset(
         "filter",
         "projection",
         "cardinality",
-        "implicitSourceField",
     )
 )
 
 
 def _node_parts(node: Mapping[str, Any]) -> Tuple[str, Optional[Mapping[str, Any]], Mapping[str, Any]]:
-    """``(id, map|None, ports)`` of a body node (componentRef or map)."""
+    """``(id, map|None, ports)`` of a body node (componentRef / map / fanout)."""
     m = node.get("map")
     if m is not None:
         return node["id"], m, m["ports"]
+    fo = node.get("fanout")
+    if fo is not None:
+        # A `refs` fan-out (bc 0.7.3 v3): its per-element BatchGet ports drive the
+        # SAME batched handler a batched map did. bc's `run_behavior` owns the
+        # dedupe/drop/wrap (fanout_dedup_drop) — graphddb only supplies the aligned
+        # bodies. Return its ports for the structural/config consumers.
+        return node["id"], None, fo["ports"]
     return node["id"], None, node["ports"]
 
 
@@ -240,11 +246,6 @@ def execute_read_component(
             "is_root": node_id == "root",
         }
 
-    # Batched fan-out bookkeeping for the refs fold: node id → the per-element
-    # dedupe markers, ALIGNED to the map's driver elements (first-seen dedupe /
-    # missing-drop needs the element→key identity the handler computed).
-    refs_markers: Dict[str, List[str]] = {}
-
     def _key_of(ports: Mapping[str, Any], key_attrs: List[str]) -> Dict[str, Any]:
         return {attr: ports[attr] for attr in key_attrs}
 
@@ -381,8 +382,12 @@ def execute_read_component(
             ports["items"] if batched else [ports]  # type: ignore[assignment]
         )
 
-        # Dedupe INSIDE the handler (CONSUMER) — first-seen order, exactly the
-        # old `_run_relation_batch_get` / `_apply_refs` marker dedupe.
+        # PHYSICAL dedupe INSIDE the handler (CONSUMER) — the ONE deduped/chunked
+        # BatchGet the request needs to avoid over-fetch. The RESULT-level dedupe /
+        # dangling-drop / connection-wrap is NO LONGER graphddb's: bc's `fanout`
+        # node (v3, run_behavior → fanout_dedup_drop) owns it, keyed off the result
+        # body's `dedupeKey` field. The handler returns the list ALIGNED to the
+        # input element order (null for a missing body) — the fanout's contract.
         plain_keys: List[Dict[str, Any]] = []
         markers: List[str] = []
         seen: set = set()
@@ -394,8 +399,6 @@ def execute_read_component(
                 continue
             seen.add(marker)
             plain_keys.append(plain_key)
-        if batched:
-            refs_markers[ctx["nodeId"]] = markers
 
         if len(plain_keys) > rt._limits.max_items:
             raise LimitExceededError(
@@ -491,25 +494,30 @@ def execute_read_component(
         if exc.code == "OP_FAILED" and ddb_error:
             raise ddb_error[-1]
         raise
-    return _fold_read_output(component, out, refs_markers)
+    return _fold_read_output(component, out)
 
 
 def _fold_read_output(
     component: Mapping[str, Any],
     out: Any,
-    refs_markers: Mapping[str, List[str]],
 ) -> Any:
-    """The documented mechanical, id-driven fold from the v2 ``run_behavior``
+    """The documented mechanical, id-driven fold from the v3 ``run_behavior``
     output to the old assembled result shape (components.ts module doc; proven
     golden-equal by ``__tests__/spec/components.test.ts``):
 
     - a chained connection's flat per-element ``into`` keys re-nest along the
       node-id path (``groups.items.group.permissions.items`` → move each
       element's ``permissions`` under its ``group``);
-    - a batched refs fan-out's ALIGNED list dedupes by first-seen element key,
-      drops missing bodies, and wraps as a ``{items, cursor: None}`` connection;
-    - every ``implicitSourceField`` marker strips the driver attribute from the
-      assembled root (the old ``_strip_implicit_sources``).
+    - a ``refs`` fan-out node's connection ``{items, cursor: None}`` is produced
+      ENTIRELY by bc's ``fanout`` node (v3, ``fanout_dedup_drop``): first-seen
+      dedupe (by the result body's ``dedupeKey`` field), dangling drop, and the
+      connection wrap all happen inside ``run_behavior`` now — graphddb folds it
+      through unchanged (the dedup/drop is no longer here);
+    - the implicitly-projected ``refs`` SOURCE id-list (``tagRefs``) is stripped
+      from the assembled root: it is a bare-return field the fanout ``over`` read,
+      absent from the caller-visible ``outputType`` (the annotation omits it), so
+      any root field NOT in ``outputType.root`` is dropped (the old
+      ``_strip_implicit_sources``, now derived from the type-notation).
     """
     output = component["output"]
     body: List[Mapping[str, Any]] = list(component["body"])
@@ -535,23 +543,10 @@ def _fold_read_output(
             )
         val = out_obj[prop]
         if "ref" in spec_node:
-            node_id = spec_node["ref"][0]
-            node = node_by_id[node_id]
-            m = node.get("map")
-            if m is not None and "into" not in m:
-                # Batched refs fan-out: aligned list → dedupe/drop → connection.
-                markers = refs_markers.get(node_id, [])
-                seen: set = set()
-                items: List[Any] = []
-                for i, item_body in enumerate(val or []):
-                    marker = markers[i]
-                    if item_body is None or marker in seen:
-                        continue
-                    seen.add(marker)
-                    items.append(item_body)
-                result[prop] = {"items": items, "cursor": None}
-            else:
-                result[prop] = val
+            # A `refs` fan-out node result is ALREADY the deduped/dropped
+            # `{items, cursor: None}` connection (bc's fanout node owns it); a
+            # plain relation ref is its value verbatim. Either way: pass through.
+            result[prop] = val
         elif "obj" in spec_node:
             # Chained connection: {cursor, items:<augmented tail>} — re-nest the
             # per-element flat `into` keys along each chain map's id.
@@ -565,13 +560,38 @@ def _fold_read_output(
                 f"components[]: unsupported output node for '{prop}' (fail-closed)"
             )
 
-    # Implicit-strip markers (gap 5): drop driver attributes projected solely to
-    # feed a fan-out — from the root, the only parent the emitted refs vocabulary
-    # allows (nested sourceList is emitter-rejected).
-    for node in body:
-        m = node.get("map")
-        if m is not None and "implicitSourceField" in m["ports"]:
-            result.pop(m["ports"]["implicitSourceField"], None)
+    # Implicit refs-source strip (gap 5): a `refs` fan-out's SOURCE id-list
+    # (`tagRefs`) is physically projected onto the root ONLY to feed the fanout
+    # `over`; it is a bare-return field the caller never sees. The type-notation
+    # annotation encodes exactly this: the root NODE's `outType` carries the
+    # source, while the component `outputType.root` OMITS it. So strip precisely
+    # the field(s) a root-level `fanout.over` reads that are ABSENT from
+    # `outputType.root` (a field the query SELECTS stays in `outputType.root` and
+    # is kept). Untyped IR (legacy/hand-built, no annotation) strips nothing —
+    # the pre-#347 behavior; nested/non-root fanout over is emitter-rejected.
+    output_type = component.get("outputType")
+    root_out = (
+        output_type.get("obj", {}).get("root")
+        if isinstance(output_type, Mapping)
+        else None
+    )
+    kept = (
+        set(root_out["obj"].keys())
+        if isinstance(root_out, Mapping) and isinstance(root_out.get("obj"), Mapping)
+        else None
+    )
+    if kept is not None:
+        for node in body:
+            fo = node.get("fanout")
+            if fo is None:
+                continue
+            over = fo.get("over")
+            ref = over.get("ref") if isinstance(over, Mapping) else None
+            # `over: {ref: ["root", "<source>"]}` — the implicit driver field.
+            if isinstance(ref, list) and len(ref) == 2 and ref[0] == "root":
+                source = ref[1]
+                if source not in kept:
+                    result.pop(source, None)
 
     return result
 

{graphddb_runtime-1.0.6 → graphddb_runtime-1.0.8}/graphddb_runtime.egg-info/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: graphddb-runtime
-Version: 1.0.6
+Version: 1.0.8
 Summary: Thin DynamoDB executor for GraphDDB-generated Python repositories (single-operation core, issue #44).
 License: MIT
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: boto3>=1.26
-Requires-Dist: behavior-contracts==0.6.0
+Requires-Dist: behavior-contracts==0.7.3
 Provides-Extra: test
 Requires-Dist: pytest>=7.0; extra == "test"
 

{graphddb_runtime-1.0.6 → graphddb_runtime-1.0.8}/graphddb_runtime.egg-info/requires.txt

@@ -1,5 +1,5 @@
 boto3>=1.26
-behavior-contracts==0.6.0
+behavior-contracts==0.7.3
 
 [test]
 pytest>=7.0

{graphddb_runtime-1.0.6 → graphddb_runtime-1.0.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graphddb-runtime"
-version = "1.0.6"
+version = "1.0.8"
 description = "Thin DynamoDB executor for GraphDDB-generated Python repositories (single-operation core, issue #44)."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -14,7 +14,7 @@ license = { text = "MIT" }
 # canonicalisation) are delegated to the extracted shared package
 # ``behavior-contracts`` (import name ``behavior_contracts``). The runtime
 # imports it unconditionally, so it is a HARD dependency.
-dependencies = ["boto3>=1.26", "behavior-contracts==0.6.0"]
+dependencies = ["boto3>=1.26", "behavior-contracts==0.7.3"]
 
 [project.optional-dependencies]
 test = ["pytest>=7.0"]