graphddb-runtime 0.7.4__tar.gz → 0.7.6__tar.gz

{graphddb_runtime-0.7.4 → graphddb_runtime-0.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphddb-runtime
-Version: 0.7.4
+Version: 0.7.6
 Summary: Thin DynamoDB executor for GraphDDB-generated Python repositories (single-operation core, issue #44).
 License: MIT
 Requires-Python: >=3.9

{graphddb_runtime-0.7.4 → graphddb_runtime-0.7.6}/graphddb_runtime/runtime.py

@@ -2137,6 +2137,19 @@ class GraphDDBRuntime:
             "TableName": self._physical_table(op["tableName"]),
             "Key": key,
         }
+        # Server-side projection (issue #237): push the `select` down as a
+        # ``ProjectionExpression`` so DynamoDB returns only the requested
+        # attributes (+ key attrs) instead of the full item — mirroring the TS
+        # runtime (``src/executor/dynamo-executor.ts`` ``executeGetItem``) and the
+        # BatchGet leg's ``_projection_request``. Hydration then runs over the
+        # projected subset (still byte-identical, since every attr hydration /
+        # relations need is in ``op["projection"]`` + ``keyCondition``).
+        projection = self._projection_request(op, select)
+        if projection:
+            request["ProjectionExpression"] = projection["ProjectionExpression"]
+            request["ExpressionAttributeNames"] = projection[
+                "ExpressionAttributeNames"
+            ]
         # Strongly-consistent point read on the base table (issue #65). The TS
         # runtime sets ``ConsistentRead`` on a base-table GetItem when the contract
         # method's ``consistentRead`` retrieval option is truthy
@@ -2211,6 +2224,18 @@ class GraphDDBRuntime:
         if op.get("indexName"):
             request["IndexName"] = op["indexName"]
 
+        # Server-side projection (issue #237): push the `select` down as a
+        # ``ProjectionExpression`` (mirroring TS ``executeQuery`` and the BatchGet
+        # ``_projection_request``). Projection name aliases (``#p*``) are merged
+        # into the shared ``ExpressionAttributeNames`` — they never collide with
+        # the key-condition (``#k*`` / ``#kr``) or filter aliases. DynamoDB still
+        # returns the full ``LastEvaluatedKey`` regardless of projection, so
+        # cursor continuation is unaffected.
+        projection = self._projection_request(op, select)
+        if projection:
+            request["ProjectionExpression"] = projection["ProjectionExpression"]
+            names.update(projection["ExpressionAttributeNames"])
+
         # Strongly-consistent read on a base-table Query (issue #65). The TS
         # planner (``src/planner/planner.ts``) sets ``ConsistentRead`` only for a
         # primary-key (base-table) query, so we mirror that for the valid case:

{graphddb_runtime-0.7.4 → graphddb_runtime-0.7.6}/graphddb_runtime.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphddb-runtime
-Version: 0.7.4
+Version: 0.7.6
 Summary: Thin DynamoDB executor for GraphDDB-generated Python repositories (single-operation core, issue #44).
 License: MIT
 Requires-Python: >=3.9

{graphddb_runtime-0.7.4 → graphddb_runtime-0.7.6}/graphddb_runtime.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ graphddb_runtime.egg-info/requires.txt
 graphddb_runtime.egg-info/top_level.txt
 tests/test_concurrency.py
 tests/test_contract_runtime.py
+tests/test_crosslang_python_cells.py
 tests/test_description.py
 tests/test_description_followups.py
 tests/test_description_jsdoc.py

{graphddb_runtime-0.7.4 → graphddb_runtime-0.7.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graphddb-runtime"
-version = "0.7.4"
+version = "0.7.6"
 description = "Thin DynamoDB executor for GraphDDB-generated Python repositories (single-operation core, issue #44)."
 readme = "README.md"
 requires-python = ">=3.9"

graphddb_runtime-0.7.6/tests/test_crosslang_python_cells.py

@@ -0,0 +1,408 @@
+"""Unit tests for the Python cross-language benchmark cells (issue #232).
+
+These are NON-integration (no DynamoDB Local): they drive the two cells
+(boto3 sdk baseline + graphddb_runtime) against a botocore ``Stubber`` (canned
+responses, request-shape asserted) or the micro mock transport, so they run in
+``npm run test:py``. They prove:
+
+  1. the boto3 SDK baseline issues the right requests and hydrates correctly, and
+     reports the expected requests/op + items/op (the fairness-gate cost);
+  2. the graphddb_runtime cell (over the generated IR) returns correct data and
+     reports the SAME req/op + items/op as the baseline (cross-language fairness);
+  3. the micro mock genuinely EXCLUDES I/O — the full boto3 client stack runs
+     (marshal + parse + hydrate) with NO socket opened.
+
+The cells live under ``benchmark/crosslang/adapters/python`` (outside the pytest
+rootdir), so their directory is added to ``sys.path`` here.
+"""
+
+from __future__ import annotations
+
+import os
+import socket
+import sys
+
+import boto3
+import pytest
+from botocore.config import Config
+from botocore.stub import Stubber
+
+# Make the benchmark Python cell modules importable.
+_THIS = os.path.dirname(os.path.abspath(__file__))
+_REPO = os.path.dirname(os.path.dirname(_THIS))  # repo root
+_CELL_DIR = os.path.join(_REPO, "benchmark", "crosslang", "adapters", "python")
+if _CELL_DIR not in sys.path:
+    sys.path.insert(0, _CELL_DIR)
+
+from graphddb_runtime import GraphDDBRuntime  # noqa: E402
+from graphddb_cell import GraphddbCell  # noqa: E402
+from sdk_baseline import SdkBaseline, TABLE  # noqa: E402
+from micro_transport import MicroMockTransport, USER_ITEM, LIST_ROWS  # noqa: E402
+
+GENERATED = os.path.join(_CELL_DIR, "generated")
+MANIFEST = os.path.join(GENERATED, "manifest.json")
+OPERATIONS = os.path.join(GENERATED, "operations.json")
+
+INPUTS = {
+    "readUserId": "u0",
+    "readEmail": "u0@example.com",
+    "readGroupId": "g0",
+    "putGroupId": "g99",
+    "updateUserId": "u1",
+    "joinGroupId": "g99",
+}
+
+
+def _client() -> boto3.client:
+    return boto3.client(
+        "dynamodb",
+        endpoint_url="http://localhost:8000",
+        region_name="local",
+        aws_access_key_id="fake",
+        aws_secret_access_key="fake",
+        config=Config(retries={"max_attempts": 1}),
+    )
+
+
+def _profile_item(uid: str) -> dict:
+    return {
+        "PK": {"S": f"USER#{uid}"},
+        "SK": {"S": "PROFILE"},
+        "userId": {"S": uid},
+        "name": {"S": f"User {uid}"},
+        "email": {"S": f"{uid}@example.com"},
+        "status": {"S": "active"},
+    }
+
+
+def _membership_rows(n: int) -> list:
+    return [
+        {
+            "PK": {"S": f"GROUP#g{i}"},
+            "SK": {"S": "USER#u0"},
+            "GSI1PK": {"S": "USER#u0"},
+            "GSI1SK": {"S": f"GROUP#g{i}"},
+            "userId": {"S": "u0"},
+            "groupId": {"S": f"g{i}"},
+            "role": {"S": "member"},
+        }
+        for i in range(n)
+    ]
+
+
+# ── 1. SDK baseline correctness + cost (requests/op · items/op) ─────────────────
+
+
+def test_sdk_pk_query_correct_and_projected():
+    c = _client()
+    stub = Stubber(c)
+    stub.add_response(
+        "get_item",
+        {"Item": _profile_item("u0")},
+        {
+            "TableName": TABLE,
+            "Key": {"PK": {"S": "USER#u0"}, "SK": {"S": "PROFILE"}},
+            "ProjectionExpression": "userId, #n, email",
+            "ExpressionAttributeNames": {"#n": "name"},
+        },
+    )
+    with stub:
+        cell = SdkBaseline(c)
+        result, requests, items = cell.pk_query("u0")
+    assert result["userId"] == "u0"
+    assert requests == 1 and items == 1
+
+
+def test_sdk_list_query_limit_and_cost():
+    c = _client()
+    stub = Stubber(c)
+    stub.add_response(
+        "query",
+        {"Items": _membership_rows(20), "Count": 20, "ScannedCount": 20},
+        {
+            "TableName": TABLE,
+            "KeyConditionExpression": "PK = :pk AND begins_with(SK, :p)",
+            "ExpressionAttributeValues": {":pk": {"S": "GROUP#g0"}, ":p": {"S": "USER#"}},
+            "ProjectionExpression": "userId, #r",
+            "ExpressionAttributeNames": {"#r": "role"},
+            "Limit": 20,
+        },
+    )
+    with stub:
+        cell = SdkBaseline(c)
+        rows, requests, items = cell.list_query("g0")
+    assert len(rows) == 20 and requests == 1 and items == 20
+
+
+def test_sdk_nested_batch_get_avoids_n_plus_1():
+    """user Get + memberships GSI Query + ONE BatchGetItem (never GetItem×N)."""
+    c = _client()
+    stub = Stubber(c)
+    stub.add_response("get_item", {"Item": {"userId": {"S": "u0"}}}, None)
+    stub.add_response(
+        "query",
+        {"Items": _membership_rows(3), "Count": 3, "ScannedCount": 3},
+        None,
+    )
+    stub.add_response(
+        "batch_get_item",
+        {
+            "Responses": {
+                TABLE: [
+                    {"PK": {"S": f"GROUP#g{i}"}, "SK": {"S": "META"}, "groupId": {"S": f"g{i}"}, "name": {"S": f"Group {i}"}}
+                    for i in range(3)
+                ]
+            }
+        },
+        None,
+    )
+    with stub:
+        cell = SdkBaseline(c)
+        result, requests, items = cell.nested_batch_get("u0")
+    # 3 physical requests (get + query + one batch), not 1 + N GetItems.
+    assert requests == 3
+    assert len(result["groups"]) == 3
+
+
+def test_sdk_relation_multi_write_is_atomic_transaction():
+    c = _client()
+    stub = Stubber(c)
+
+    captured = {}
+
+    def _capture(params):
+        captured["items"] = params["TransactItems"]
+        return True
+
+    stub.add_response("transact_write_items", {}, None)
+    with stub:
+        cell = SdkBaseline(c, write_salt="python-sdk")
+        _r, requests, items = cell.relation_multi_write("g99", "member")
+    # ONE atomic TransactWriteItems (req/op 1), writes read 0 items.
+    assert requests == 1 and items == 0
+
+
+# ── 2. graphddb cell correctness + same cost as the baseline (fairness) ─────────
+
+
+def _runtime(client) -> GraphDDBRuntime:
+    return GraphDDBRuntime(
+        dynamodb_client=client, manifest_path=MANIFEST, operations_path=OPERATIONS
+    )
+
+
+def test_graphddb_pk_query_hydrates_correctly():
+    c = _client()
+    stub = Stubber(c)
+    # #237: the graphddb runtime now pushes the `select` down as a server-side
+    # ProjectionExpression on the point GetItem (like the SDK baseline and the TS
+    # runtime), instead of reading the full item and projecting client-side. The
+    # request MUST carry a ProjectionExpression covering the selected fields
+    # (email/name/userId) plus the base-table key attrs (PK/SK). The stub's
+    # expected-params below asserts this fires — a plain GetItem (no projection)
+    # would now fail the stub.
+    stub.add_response(
+        "get_item",
+        {"Item": _profile_item("u0")},
+        {
+            "TableName": TABLE,
+            "Key": {"PK": {"S": "USER#u0"}, "SK": {"S": "PROFILE"}},
+            "ProjectionExpression": "#p0, #p1, #p2, #p3, #p4",
+            "ExpressionAttributeNames": {
+                "#p0": "email",
+                "#p1": "name",
+                "#p2": "userId",
+                "#p3": "PK",
+                "#p4": "SK",
+            },
+        },
+    )
+    with stub:
+        cell = GraphddbCell(_runtime(c))
+        result = cell.pk_query("u0")
+    assert result is not None and result["userId"] == "u0"
+    # projection applied server-side: only userId/name/email, not status.
+    assert "status" not in result
+    assert GraphddbCell.items_read(result) == 1
+
+
+def test_graphddb_list_query_applies_limit():
+    """The graphddb range-contract path issues a Query with Limit=20 (no over-read)."""
+    c = _client()
+    stub = Stubber(c)
+    stub.add_response(
+        "query",
+        {"Items": _membership_rows(20), "Count": 20, "ScannedCount": 20},
+        None,  # request-shape flexibility: assert Limit via a captured check below
+    )
+    with stub:
+        cell = GraphddbCell(_runtime(c))
+        result = cell.list_query("g0")
+    items = result["items"] if isinstance(result, dict) else result
+    assert len(items) == 20
+    assert GraphddbCell.items_read(result) == 20
+
+
+def test_graphddb_list_query_sends_limit_20():
+    """Assert the physical Query carries Limit=20 (fairness with the SDK baseline)."""
+    c = _client()
+    seen = {}
+    orig = c.query
+
+    def _spy(**kwargs):
+        seen.update(kwargs)
+        return orig(**kwargs)
+
+    c.query = _spy  # type: ignore[assignment]
+    stub = Stubber(c)
+    stub.add_response(
+        "query", {"Items": _membership_rows(20), "Count": 20, "ScannedCount": 20}, None
+    )
+    with stub:
+        GraphddbCell(_runtime(c)).list_query("g0")
+    assert seen.get("Limit") == 20
+
+
+def test_graphddb_query_sends_projection_expression():
+    """#237: the physical Query pushes the `select` down as a server-side
+    ProjectionExpression (not client-side projection). Assert the wire request
+    carries a ProjectionExpression whose aliased names cover the selected fields
+    (role/userId) plus the partition key attr (PK)."""
+    c = _client()
+    seen = {}
+    orig = c.query
+
+    def _spy(**kwargs):
+        seen.update(kwargs)
+        return orig(**kwargs)
+
+    c.query = _spy  # type: ignore[assignment]
+    stub = Stubber(c)
+    stub.add_response(
+        "query", {"Items": _membership_rows(20), "Count": 20, "ScannedCount": 20}, None
+    )
+    with stub:
+        GraphddbCell(_runtime(c)).list_query("g0")
+    proj = seen.get("ProjectionExpression")
+    assert proj, "Query must send a ProjectionExpression (#237)"
+    names = seen.get("ExpressionAttributeNames", {})
+    # Every projection token is an alias resolving to a real attribute name.
+    projected_attrs = {names[tok.strip()] for tok in proj.split(",")}
+    # The selected fields (+ partition key) must be projected server-side.
+    assert {"role", "userId", "PK"} <= projected_attrs
+
+
+def test_graphddb_getitem_sends_projection_expression():
+    """#237: the physical point GetItem pushes the `select` down as a server-side
+    ProjectionExpression covering the selected fields + base-table key attrs."""
+    c = _client()
+    seen = {}
+    orig = c.get_item
+
+    def _spy(**kwargs):
+        seen.update(kwargs)
+        return orig(**kwargs)
+
+    c.get_item = _spy  # type: ignore[assignment]
+    stub = Stubber(c)
+    stub.add_response("get_item", {"Item": _profile_item("u0")}, None)
+    with stub:
+        GraphddbCell(_runtime(c)).pk_query("u0")
+    proj = seen.get("ProjectionExpression")
+    assert proj, "GetItem must send a ProjectionExpression (#237)"
+    names = seen.get("ExpressionAttributeNames", {})
+    projected_attrs = {names[tok.strip()] for tok in proj.split(",")}
+    assert {"email", "name", "userId", "PK", "SK"} <= projected_attrs
+
+
+def test_graphddb_relation_single_matches_baseline_cost():
+    """user + memberships (2 requests, items = 1 + rows) — same logical work as SDK."""
+    c = _client()
+    stub = Stubber(c)
+    stub.add_response("get_item", {"Item": {"userId": {"S": "u0"}}}, None)
+    stub.add_response(
+        "query", {"Items": _membership_rows(5), "Count": 5, "ScannedCount": 5}, None
+    )
+    with stub:
+        cell = GraphddbCell(_runtime(c))
+        result = cell.relation_single("u0")
+    # parent user (1) + 5 membership rows.
+    assert GraphddbCell.items_read(result) == 6
+
+
+# ── 3. the micro mock genuinely EXCLUDES I/O (no socket) ────────────────────────
+
+
+def test_micro_mock_excludes_io_no_socket(monkeypatch):
+    """With the mock installed, a full get_item runs but NO socket is ever opened."""
+    c = boto3.client(
+        "dynamodb",
+        endpoint_url="http://localhost:1",  # nothing listens here
+        region_name="local",
+        aws_access_key_id="x",
+        aws_secret_access_key="y",
+        config=Config(retries={"max_attempts": 1}, connect_timeout=1, read_timeout=1),
+    )
+    mock = MicroMockTransport()
+    mock.install(c)
+
+    # Trip a hard failure if ANY real socket connect is attempted.
+    real_connect = socket.socket.connect
+
+    def _boom(self, *args, **kwargs):  # noqa: ANN001
+        raise AssertionError("micro-bench opened a real socket — I/O NOT excluded")
+
+    monkeypatch.setattr(socket.socket, "connect", _boom)
+
+    resp = c.get_item(
+        TableName=TABLE,
+        Key={"PK": {"S": "USER#u0"}, "SK": {"S": "PROFILE"}},
+        ProjectionExpression="userId, #n, email",
+        ExpressionAttributeNames={"#n": "name"},
+    )
+    # The FULL client stack parsed the fixture (proves the stack ran, not a bypass).
+    assert resp["Item"]["userId"]["S"] == "u0"
+    assert mock.served == 1
+    # Restore for tidiness (monkeypatch would anyway).
+    monkeypatch.setattr(socket.socket, "connect", real_connect)
+
+
+def test_micro_mock_full_client_stack_runs_query_and_batch():
+    """The mock serves Query (20 rows) and BatchGetItem, parsed by the real stack."""
+    c = _client()
+    mock = MicroMockTransport()
+    mock.install(c)
+    q = c.query(
+        TableName=TABLE,
+        KeyConditionExpression="PK = :pk AND begins_with(SK, :p)",
+        ExpressionAttributeValues={":pk": {"S": "GROUP#g0"}, ":p": {"S": "USER#"}},
+        Limit=20,
+    )
+    assert q["Count"] == LIST_ROWS and len(q["Items"]) == LIST_ROWS
+    b = c.batch_get_item(
+        RequestItems={TABLE: {"Keys": [{"PK": {"S": "GROUP#g0"}, "SK": {"S": "META"}}]}}
+    )
+    assert len(b["Responses"][TABLE]) == LIST_ROWS
+    assert mock.served == 2
+
+
+def test_micro_mock_graphddb_cell_runs_without_io():
+    """The graphddb cell's client-side path runs end-to-end over the mock transport."""
+    c = _client()
+    mock = MicroMockTransport()
+    mock.install(c)
+    cell = GraphddbCell(_runtime(c))
+    # pkQuery hydrates the fixed USER_ITEM through the runtime; relationSingle builds
+    # the plan + hydrates the parent + 20 membership rows — all with no network.
+    user = cell.pk_query("u0")
+    assert user is not None and user["userId"] == USER_ITEM["userId"]["S"]
+    relation = cell.relation_single("u0")
+    assert GraphddbCell.items_read(relation) == 1 + LIST_ROWS
+    assert mock.served >= 3  # get + (get ∥ query for the relation)
+
+
+def test_micro_fixtures_match_ts_shapes():
+    """The Python micro fixtures mirror the TS MICRO_FIXTURES (attr/row counts)."""
+    assert LIST_ROWS == 20
+    # USER_ITEM carries the 6 attributes the TS fixture does.
+    assert set(USER_ITEM.keys()) == {"PK", "SK", "userId", "name", "email", "status"}