graphddb-runtime 1.0.7__tar.gz → 1.0.9__tar.gz

{graphddb_runtime-1.0.7 → graphddb_runtime-1.0.9}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: graphddb-runtime
-Version: 1.0.7
+Version: 1.0.9
 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.7.1
+Requires-Dist: behavior-contracts==0.7.3
 Provides-Extra: test
 Requires-Dist: pytest>=7.0; extra == "test"
 

{graphddb_runtime-1.0.7 → graphddb_runtime-1.0.9}/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
 
@@ -735,10 +755,14 @@ def collect_transaction_items(
 
         if component_name == "PutItem":
             plain = _group(ports, "item")
-            # A raw marker-row write (literalKey) carries its PK/SK verbatim; a
-            # modeled Put derives PK/SK/GSI from the manifest entity (C4 config).
-            if not ports.get("literalKey"):
-                expander._add_key_attributes(entity, plain)
+            # A modeled Put's PK/SK/GSI key attributes now ride as DECLARATIVE
+            # `key.*` ports (attribute → evaluated `concat`/`ref` template — the
+            # same symbolic derivation reads/updates use, issue #350), so fold
+            # them into the written item directly. NO runtime manifest key
+            # derivation. A raw marker-row write (literalKey) carries its PK/SK
+            # verbatim in `item` and emits no `key.*` group, so the fold is a
+            # no-op for it.
+            plain.update(_group(ports, "key"))
             serialized = {k: rt._serializer.serialize(v) for k, v in plain.items()}
             put: Dict[str, Any] = {"TableName": table, "Item": serialized}
             expander._apply_condition(cond_spec, put, cond_params, None)

{graphddb_runtime-1.0.7 → graphddb_runtime-1.0.9}/graphddb_runtime/runtime.py

@@ -1951,7 +1951,12 @@ class GraphDDBRuntime:
                     field: self._serializer.serialize(resolve_value_template(tmpl, params))
                     for field, tmpl in spec.get("item", {}).items()
                 }
-                self._add_key_attributes(spec["entity"], item, params)
+                # A put's PK/SK/GSI key attributes ride as DECLARATIVE key
+                # templates on `keyCondition` (the same symbolic derivation
+                # read/update/delete use, issue #350); resolve + fold — NO runtime
+                # manifest key derivation.
+                for attr, tmpl in spec.get("keyCondition", {}).items():
+                    item[attr] = self._serializer.serialize(resolve_template(tmpl, params))
                 requests.append({"PutRequest": {"Item": item}})
             else:  # DeleteItem
                 dynamo_key = {
@@ -2269,7 +2274,11 @@ class GraphDDBRuntime:
             field: self._serializer.serialize(resolve_value_template(tmpl, params))
             for field, tmpl in item_tmpl.items()
         }
-        self._add_key_attributes(spec["entity"], item, params)
+        # A put's PK/SK/GSI key attributes ride as DECLARATIVE key templates on
+        # `keyCondition` (the same symbolic derivation read/update/delete use,
+        # issue #350); resolve + fold — NO runtime manifest key derivation.
+        for attr, tmpl in spec.get("keyCondition", {}).items():
+            item[attr] = self._serializer.serialize(resolve_template(tmpl, params))
 
         request: Dict[str, Any] = {
             "TableName": self._physical_table(spec["tableName"]),
@@ -2549,35 +2558,6 @@ class GraphDDBRuntime:
                 values[alias] = self._serializer.serialize(resolved)
             request["ConditionExpression"] = condition["expression"]
 
-    def _add_key_attributes(
-        self, entity_name: str, item: Dict[str, Any], params: Mapping[str, Any]
-    ) -> None:
-        entity_meta = self._entities.get(entity_name, {})
-        plain = {
-            field: self._deserializer.deserialize(av) for field, av in item.items()
-        }
-        key = entity_meta.get("key")
-        if key:
-            # pkTemplate is self-contained (segment key model #51); no prefix.
-            pk = self._fill(key.get("pkTemplate") or "", plain)
-            item["PK"] = self._serializer.serialize(pk)
-            sk_tmpl = key.get("skTemplate")
-            if sk_tmpl is not None:
-                item["SK"] = self._serializer.serialize(self._fill(sk_tmpl, plain))
-
-        for gsi in entity_meta.get("gsis", []):
-            index = gsi["indexName"]
-            pk_tmpl = gsi.get("pkTemplate")
-            sk_tmpl = gsi.get("skTemplate")
-            if pk_tmpl is not None and self._fillable(pk_tmpl, plain):
-                item[f"{index}PK"] = self._serializer.serialize(
-                    self._fill(pk_tmpl, plain)
-                )
-            if sk_tmpl is not None and self._fillable(sk_tmpl, plain):
-                item[f"{index}SK"] = self._serializer.serialize(
-                    self._fill(sk_tmpl, plain)
-                )
-
     @staticmethod
     def _fillable(template: str, values: Mapping[str, Any]) -> bool:
         return all(

{graphddb_runtime-1.0.7 → graphddb_runtime-1.0.9}/graphddb_runtime/transactions.py

@@ -145,18 +145,6 @@ def _resolve_condition_tree(
     return out
 
 
-def _fill_key(template: str, item: Mapping[str, Any]) -> str:
-    def repl(match: "re.Match[str]") -> str:
-        name = match.group(0)[1:-1]
-        return str(item.get(name, ""))
-
-    return _PLACEHOLDER_RE.sub(repl, template)
-
-
-def _key_fillable(template: str, item: Mapping[str, Any]) -> bool:
-    return all(m.group(0)[1:-1] in item for m in _PLACEHOLDER_RE.finditer(template))
-
-
 # ── SCP guard evaluation seam (issue #266, Phase 3 S6) ────────────────────────
 #
 # The branch-for-branch port of the TS ``evaluateGuard`` seam
@@ -450,24 +438,6 @@ class TransactionExpander:
             raise KeyError(f"unknown entity '{name}' in manifest")
         return entity
 
-    def _add_key_attributes(self, entity_name: str, plain: Dict[str, Any]) -> None:
-        entity = self._entity(entity_name)
-        key = entity.get("key")
-        if key:
-            # pkTemplate is self-contained (segment key model #51); no prefix.
-            plain["PK"] = _fill_key(key.get("pkTemplate") or "", plain)
-            sk_tmpl = key.get("skTemplate")
-            if sk_tmpl is not None:
-                plain["SK"] = _fill_key(sk_tmpl, plain)
-        for gsi in entity.get("gsis", []):
-            index = gsi["indexName"]
-            pk_tmpl = gsi.get("pkTemplate")
-            sk_tmpl = gsi.get("skTemplate")
-            if pk_tmpl is not None and _key_fillable(pk_tmpl, plain):
-                plain[f"{index}PK"] = _fill_key(pk_tmpl, plain)
-            if sk_tmpl is not None and _key_fillable(sk_tmpl, plain):
-                plain[f"{index}SK"] = _fill_key(sk_tmpl, plain)
-
     def _apply_condition(
         self,
         condition: Optional[Mapping[str, Any]],

{graphddb_runtime-1.0.7 → graphddb_runtime-1.0.9}/graphddb_runtime.egg-info/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: graphddb-runtime
-Version: 1.0.7
+Version: 1.0.9
 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.7.1
+Requires-Dist: behavior-contracts==0.7.3
 Provides-Extra: test
 Requires-Dist: pytest>=7.0; extra == "test"
 

{graphddb_runtime-1.0.7 → graphddb_runtime-1.0.9}/graphddb_runtime.egg-info/requires.txt

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

{graphddb_runtime-1.0.7 → graphddb_runtime-1.0.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graphddb-runtime"
-version = "1.0.7"
+version = "1.0.9"
 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.7.1"]
+dependencies = ["boto3>=1.26", "behavior-contracts==0.7.3"]
 
 [project.optional-dependencies]
 test = ["pytest>=7.0"]