litedbmodel-runtime 2.0.2__tar.gz → 2.1.0__tar.gz

{litedbmodel_runtime-2.0.2 → litedbmodel_runtime-2.1.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: litedbmodel-runtime
-Version: 2.0.2
+Version: 2.1.0
 Summary: Thin multi-language runtime for litedbmodel v2 SCP makeSQL bundles (Python port). Executes the published static-makeSQL artifacts (a read ReadGraph = a bc surrogate ComponentGraphIR + per-node static statement templates, or a gate-first TransactionPlan) against a SQL driver — semantics-identical to the TS reference. Delegates the Expression-IR evaluation + map/Φ/wiring orchestration to behavior-contracts.
 Author: foo-ogawa
 License: MIT
 Keywords: orm,sql,ir,runtime,conformance,litedbmodel
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: behavior-contracts==0.5.0
+Requires-Dist: behavior-contracts==0.8.0
 Provides-Extra: test
 Requires-Dist: pytest>=7.0; extra == "test"
 Provides-Extra: livedb

{litedbmodel_runtime-2.0.2 → litedbmodel_runtime-2.1.0}/litedbmodel_runtime/__init__.py

@@ -16,8 +16,6 @@ from .dialect import SQLITE, POSTGRES, MYSQL, Dialect, dialect_for, to_dollar_pl
 from .driver import Driver, MysqlDriver, PostgresDriver, PreparedStatement, RunInfo, SqliteDriver
 from .errors import SqlFailure, map_sqlite_error
 from .static_bundle import (
-    NODE_COMPONENT,
-    SCOPE_PORT,
     assemble_make_sql,
     compose_make_sql,
     execute_read_graph,
@@ -38,7 +36,7 @@ from .relation import (
     run_relation_op,
 )
 
-__version__ = "2.0.2"
+__version__ = "2.1.0"
 
 __all__ = [
     "__version__",
@@ -60,8 +58,6 @@ __all__ = [
     "SqlFailure",
     "map_sqlite_error",
     # static makeSQL bundle runtime (the sole read/render path)
-    "NODE_COMPONENT",
-    "SCOPE_PORT",
     "assemble_make_sql",
     "compose_make_sql",
     "execute_read_graph",

{litedbmodel_runtime-2.0.2 → litedbmodel_runtime-2.1.0}/litedbmodel_runtime/livedb_runner.py

@@ -42,7 +42,7 @@ from litedbmodel_runtime import (  # noqa: E402
     read_bundle,
 )
 
-SUPPORTED_CORPUS_VERSION = 2
+SUPPORTED_CORPUS_VERSION = 3
 # A distinct namespace per language so 4 languages share ONE docker stack without cross-talk.
 PG_SCHEMA = os.environ.get("LIVEDB_PG_SCHEMA", "scp_py")
 MYSQL_DB = os.environ.get("LIVEDB_MYSQL_DB", "scp_py")

{litedbmodel_runtime-2.0.2 → litedbmodel_runtime-2.1.0}/litedbmodel_runtime/runtime.py

@@ -6,10 +6,10 @@ static-makeSQL artifacts the corpus ships (pure JSON: a read ``ReadGraph`` = a b
 gate-first makeSQL statements) and executes them against a SQL driver — SEMANTICS-IDENTICAL to the
 TS reference (``src/scp/runtime.ts`` + ``src/scp/makesql/*``).
 
-It re-implements NO generic execution/expression evaluation: bc's ``run_behavior`` owns the
-plan/map/wire/output orchestration and its ``evaluate_expression`` owns the CLOSED Expression-IR
-(ref/refOpt/coalesce/eq/…, the SKIP guards + deferred value-specs). This module adds ONLY the
-SQL-backend concerns (spec §11): assemble the static makeSQL statements per dialect → bind params →
+It re-implements NO generic expression evaluation: the NATIVE read-graph walker (#12) owns the
+plan/map/wire/output orchestration and bc's ``evaluate_expression`` owns the CLOSED Expression-IR
+(ref/refOpt/coalesce/eq/…, the SKIP guards + deferred value-specs) — NO bc ``run_behavior``. This
+module adds ONLY the SQL-backend concerns (spec §11): assemble the static makeSQL statements per dialect → bind params →
 execute REAL SQL → row→result assembly; and, for a Command bundle, the gate-first write transaction
 (``execute_transaction_bundle``). This mirrors the TS runtime's division of labor exactly (bc-core
 + a makeSQL handler). The reduced fragment-tree render path (``render.py``) is RETIRED for the SQL
@@ -25,7 +25,6 @@ from .dialect import dialect_for
 from .driver import Driver
 from .errors import SqlFailure, map_sqlite_error
 from .static_bundle import (
-    SCOPE_PORT,
     assemble_make_sql,
     execute_read_graph,
     render_placeholders,
@@ -40,7 +39,6 @@ _RETURNING_RE = re.compile(r"\breturning\b", re.IGNORECASE)
 _SELECT_RE = re.compile(r"\bselect\b", re.IGNORECASE)
 
 __all__ = [
-    "SCOPE_PORT",
     "ENTITY_ROOT",
     "execute_bundle",
     "execute_transaction_bundle",
@@ -73,7 +71,7 @@ def _to_driver_param_tx(v: Any) -> Any:
 
 
 def execute_bundle(bundle: Mapping[str, Any], input_scope: Mapping[str, Any], driver: Driver) -> Any:
-    """Execute a read/exec SqlBundle end-to-end (bc run_behavior + makeSQL handler).
+    """Execute a read/exec SqlBundle end-to-end (native read-graph walker; no bc run_behavior).
 
     The SAME code path a consumer runtime follows: it consumes ONLY the serialized bundle + bc
     runtime-core, never re-running litedbmodel's Backend-Compile. A read bundle carries a

{litedbmodel_runtime-2.0.2 → litedbmodel_runtime-2.1.0}/litedbmodel_runtime/static_bundle.py

@@ -2,10 +2,11 @@
 
 Byte-for-byte port of the TS ``src/scp/makesql/static-bundle.ts`` + ``makesql.ts`` + ``handler.ts``
 runtime halves — the SOLE makeSQL read/render path. It consumes the PRE-COMPILED, portable
-artifacts the corpus ships (a read ``ReadGraph`` = a bc ``ComponentGraphIR`` of ``__makeSqlNode``
-surrogate nodes + per-node STATIC statement templates), and EXECUTES them via the shared
-``behavior-contracts`` core (``run_behavior`` drives map / Φ-merge / wiring; ``evaluate_expression``
-resolves the deferred value-specs + skip). This module re-implements NO generic evaluator and does
+artifacts the corpus ships (a read ``ReadGraph`` = ``compileBehaviors``' REAL ``Select``/``Count``/map
+``ComponentGraphIR`` + per-node STATIC statement templates keyed by the real node id; #12 — no
+``__makeSqlNode``/``__scope`` surrogate), and EXECUTES them via the NATIVE read-graph walker (owns map /
+Φ-merge / wiring; NO bc ``run_behavior``) + bc ``evaluate_expression`` for the deferred value-specs +
+skip. This module re-implements NO generic evaluator and does
 NO SQL re-derivation — every statement's ``sql`` is fixed text already; the runtime only evaluates
 its deferred params + skip, resolves the WHERE connector from the present set, assembles + renders
 placeholders, and binds.
@@ -26,19 +27,15 @@ from __future__ import annotations
 
 import json
 import re
+from concurrent.futures import ThreadPoolExecutor
 from typing import Any, Dict, List, Mapping, Sequence
 
-from behavior_contracts import evaluate_expression, run_behavior
+from behavior_contracts import evaluate_expression
 
 from .dialect import Dialect, dialect_for
 from .driver import Driver
 from .errors import SqlFailure, map_sqlite_error
 
-# The synthetic port that carries a SQL node's render scope (mirrors TS SCOPE_PORT).
-SCOPE_PORT = "__scope"
-# The makeSQL catalog leaf name every rewritten SQL node references (mirrors TS NODE_COMPONENT).
-NODE_COMPONENT = "__makeSqlNode"
-
 _RETURNING_RE = re.compile(r"\breturning\b", re.IGNORECASE)
 
 
@@ -262,7 +259,7 @@ def render_read_primary(graph: Mapping[str, Any], input_scope: Mapping[str, Any]
     """Render the PRIMARY read node's statements of a ReadGraph → dialect SQL text + params.
 
     Byte-for-byte port of the TS ``renderReadPrimary``: the primary node is the first body node in
-    the surrogate IR order (map nodes reference it). Optional heads are normalized to present-as-null
+    the real-node IR order (map nodes reference it). Optional heads are normalized to present-as-null
     first (absent-key SKIP), so an omitted optional head renders the SAME text a runtime would.
     """
     statements_by_id: Mapping[str, Any] = graph["statementsById"]
@@ -279,37 +276,99 @@ def render_read_primary(graph: Mapping[str, Any], input_scope: Mapping[str, Any]
 # ── ReadGraph execution (port of static-bundle.ts executeReadGraph) ────────────
 
 
+def _plan_stages(component: Mapping[str, Any]) -> List[List[int]]:
+    """The plan stages (``groups``) as body-index lists, or one-node-per-stage in body order."""
+    plan = component.get("plan")
+    if isinstance(plan, Mapping):
+        groups = plan.get("groups")
+        if isinstance(groups, list):
+            return [[i for i in st if isinstance(i, int)] for st in groups if isinstance(st, list)]
+    return [[i] for i in range(len(component.get("body", [])))]
+
+
+def _plan_concurrency(component: Mapping[str, Any]) -> int:
+    """The plan's ``concurrency`` bound (default 1 — serial when absent/<=1), for the fan-out."""
+    plan = component.get("plan")
+    if isinstance(plan, Mapping):
+        c = plan.get("concurrency")
+        if isinstance(c, int) and c >= 1:
+            return c
+    return 1
+
+
+def _render_execute_node(
+    graph: Mapping[str, Any], node_id: str, scope: Mapping[str, Any], driver: Driver
+) -> List[Any]:
+    """Render node ``node_id``'s ``statementsById`` fragments against ``scope`` and run them."""
+    statements_by_id: Mapping[str, Any] = graph["statementsById"]
+    stmts = statements_by_id.get(node_id)
+    if stmts is None:
+        raise ValueError(f"static-bundle: no statements for node '{node_id}'")
+    rendered = render_statements(stmts, graph["dialect"], scope)
+    try:
+        return driver.prepare(rendered["sql"]).all(rendered["params"])
+    except Exception as e:  # driver error → mapped SqlFailure
+        raise map_sqlite_error(e)
+
+
+def _compute_read_node(
+    graph: Mapping[str, Any], node: Mapping[str, Any], base: Mapping[str, Any], driver: Driver
+) -> Any:
+    """Compute ONE read-graph body node's value: a ``cond`` join, a ``map`` (per-element
+    render+execute under the ``as`` binding), or a componentRef (render+execute)."""
+    if "cond" in node:
+        return evaluate_expression(node["cond"], base)
+    node_id = node.get("id", "")
+    if "map" in node:
+        m = node["map"]
+        over = evaluate_expression(m.get("over"), base)
+        if not isinstance(over, list):
+            raise ValueError(f"static-bundle: map '{node_id}': 'over' is not an array")
+        as_name = m.get("as") or "$"
+        out: List[Any] = []
+        for el in over:
+            elem_scope = dict(base)
+            elem_scope[as_name] = el
+            out.append(_render_execute_node(graph, node_id, elem_scope, driver))
+        return out
+    return _render_execute_node(graph, node_id, base, driver)
+
+
 def execute_read_graph(graph: Mapping[str, Any], input_scope: Mapping[str, Any], driver: Driver) -> Any:
-    """Execute a compiled ReadGraph via bc ``run_behavior`` + a makeSQL handler.
+    """Execute a compiled ReadGraph via the NATIVE walker (#12): no bc ``run_behavior``.
 
-    Byte-for-byte port of the TS ``executeReadGraph``: bc drives map iteration / wire binding /
-    Φ output; the handler renders each node's static statements against the evaluated ``__scope``
-    and runs REAL SQL. Returns the component's Φ output. This is the design's "bc composes,
-    makeSQL executes" — the SAME path the TS runtime follows.
+    Walks ``compileBehaviors``' REAL ``Select``/``Count``/map node IR in ``plan.groups`` stage order —
+    computing each node's rows from its ``statementsById`` fragments (rendered against the walk scope)
+    and committing ``nodeId -> value`` — then evaluates the component ``output`` Φ expression.
+    litedbmodel owns map iteration / wire binding / Φ output; NO ``__makeSqlNode``/``__scope``
+    surrogate. The SAME native model the TS/rust/go/php runtimes follow — interpreter-free.
     """
-    statements_by_id: Mapping[str, Any] = graph["statementsById"]
-    dialect_name: str = graph["dialect"]
-
-    def handle(ports: Mapping[str, Any], ctx: Mapping[str, Any]) -> Mapping[str, Any]:
-        node_id = ctx["nodeId"]
-        stmts = statements_by_id.get(node_id)
-        if stmts is None:
-            return {"error": f"static-bundle: no statements for node '{node_id}'"}
-        scope = ports.get(SCOPE_PORT)
-        if not isinstance(scope, dict):
-            return {"error": f"static-bundle: node '{node_id}' surrogate scope did not evaluate to an object"}
-        rendered = render_statements(stmts, dialect_name, scope)
-        try:
-            rows = driver.prepare(rendered["sql"]).all(rendered["params"])
-            return {"ok": rows}
-        except Exception as e:  # driver error → mapped {error}
-            return {"error": str(map_sqlite_error(e))}
-
-    handlers = {NODE_COMPONENT: handle}
-    ir = graph["ir"]
+    component = graph["ir"]["components"][0]
+    body = component.get("body", [])
+    output = component.get("output")
+    concurrency = _plan_concurrency(component)
     normalized = _normalize_optional_heads(list(graph.get("optionalHeads", [])), input_scope)
     try:
-        return run_behavior(ir, handlers, normalized, graph["name"])
+        results: List[tuple] = []
+        for stage in _plan_stages(component):
+            base = dict(normalized)
+            for nid, val in results:
+                base[nid] = val
+            ordered = sorted(stage)  # ascending body index — deterministic commit order
+            # Independent siblings of a stage run in bounded parallel (capped at the plan concurrency;
+            # concurrency <= 1 or a single member ⇒ serial); each dispatched on its own pooled
+            # connection against the driver. Results commit in ascending body index (deterministic).
+            if concurrency > 1 and len(ordered) > 1:
+                with ThreadPoolExecutor(max_workers=min(concurrency, len(ordered))) as pool:
+                    vals = list(pool.map(lambda idx: _compute_read_node(graph, body[idx], base, driver), ordered))
+            else:
+                vals = [_compute_read_node(graph, body[idx], base, driver) for idx in ordered]
+            for idx, val in zip(ordered, vals):
+                results.append((body[idx]["id"], val))
+        scope = dict(normalized)
+        for nid, val in results:
+            scope[nid] = val
+        return evaluate_expression(output, scope)
     except Exception as e:
         raise _re_error_to_sql_failure(e)
 

{litedbmodel_runtime-2.0.2 → litedbmodel_runtime-2.1.0}/litedbmodel_runtime/vectors_runner.py

@@ -47,7 +47,7 @@ from litedbmodel_runtime import (  # noqa: E402
 from litedbmodel_runtime.driver import SqliteDriver  # noqa: E402
 
 # The corpus schema version this runner supports (pin — bumped on additive refreeze).
-SUPPORTED_CORPUS_VERSION = 2
+SUPPORTED_CORPUS_VERSION = 3
 
 
 def _vectors_dir() -> Path:

{litedbmodel_runtime-2.0.2 → litedbmodel_runtime-2.1.0}/litedbmodel_runtime.egg-info/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: litedbmodel-runtime
-Version: 2.0.2
+Version: 2.1.0
 Summary: Thin multi-language runtime for litedbmodel v2 SCP makeSQL bundles (Python port). Executes the published static-makeSQL artifacts (a read ReadGraph = a bc surrogate ComponentGraphIR + per-node static statement templates, or a gate-first TransactionPlan) against a SQL driver — semantics-identical to the TS reference. Delegates the Expression-IR evaluation + map/Φ/wiring orchestration to behavior-contracts.
 Author: foo-ogawa
 License: MIT
 Keywords: orm,sql,ir,runtime,conformance,litedbmodel
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: behavior-contracts==0.5.0
+Requires-Dist: behavior-contracts==0.8.0
 Provides-Extra: test
 Requires-Dist: pytest>=7.0; extra == "test"
 Provides-Extra: livedb

{litedbmodel_runtime-2.0.2 → litedbmodel_runtime-2.1.0}/litedbmodel_runtime.egg-info/requires.txt

@@ -1,4 +1,4 @@
-behavior-contracts==0.5.0
+behavior-contracts==0.8.0
 
 [livedb]
 psycopg[binary]>=3.1

{litedbmodel_runtime-2.0.2 → litedbmodel_runtime-2.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "litedbmodel-runtime"
-version = "2.0.2"
+version = "2.1.0"
 description = "Thin multi-language runtime for litedbmodel v2 SCP makeSQL bundles (Python port). Executes the published static-makeSQL artifacts (a read ReadGraph = a bc surrogate ComponentGraphIR + per-node static statement templates, or a gate-first TransactionPlan) against a SQL driver — semantics-identical to the TS reference. Delegates the Expression-IR evaluation + map/Φ/wiring orchestration to behavior-contracts."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -16,7 +16,7 @@ keywords = ["orm", "sql", "ir", "runtime", "conformance", "litedbmodel"]
 # evaluation (ref/refOpt/coalesce/eq/… — the SKIP guards + param slots) to the shared common
 # core, exactly as the TS reference imports `behavior-contracts` from npm. HARD dependency,
 # consumed from the published PyPI registry (NO local path — the no-local-deps gate forbids it).
-dependencies = ["behavior-contracts==0.5.0"]
+dependencies = ["behavior-contracts==0.8.0"]
 
 [project.optional-dependencies]
 test = ["pytest>=7.0"]

{litedbmodel_runtime-2.0.2 → litedbmodel_runtime-2.1.0}/tests/test_consumes_bc_core.py

@@ -1,10 +1,11 @@
 """Guardrail test (WS7b, #31): bc runtime-core is CONSUMED, not reimplemented.
 
-The hard rule: the Python runtime delegates the CLOSED Expression-IR evaluation + the
-plan/map/wire/output orchestration to behavior-contracts (the published PyPI package), exactly
-like the TS reference imports `behavior-contracts` from npm. This asserts the runtime modules
-actually import bc's `run_behavior` / `evaluate_expression` (no local generic evaluator), and
-that the declared dependency is the PyPI package spec with NO local `../` path.
+The hard rule: the Python runtime delegates the CLOSED Expression-IR evaluation to
+behavior-contracts (the published PyPI package), exactly like the TS reference imports
+`behavior-contracts` from npm — no local generic expression evaluator. (#12: the read-graph
+plan/map/wire/output orchestration is now the crate's OWN NATIVE walker, not bc `run_behavior` —
+mirroring the rust/go native walkers.) This asserts the runtime consumes bc's `evaluate_expression`,
+does NOT call `run_behavior` on the exec path, and pins the PyPI dep with NO local `../` path.
 """
 
 from __future__ import annotations
@@ -29,7 +30,14 @@ def _imports_from(module: str) -> set[str]:
 def test_static_bundle_consumes_bc_evaluate_expression():
     names = _imports_from("static_bundle.py")
     assert "evaluate_expression" in names
-    assert "run_behavior" in names
+
+
+def test_static_bundle_does_not_call_run_behavior_on_exec_path():
+    # #12: the native read-graph walker replaced bc `run_behavior` on EVERY exec path — the runtime
+    # neither imports nor calls it (the CLOSED expression eval still rides bc `evaluate_expression`).
+    src = (PKG / "static_bundle.py").read_text(encoding="utf-8") + (PKG / "runtime.py").read_text(encoding="utf-8")
+    assert "run_behavior(" not in src, "runtime must not call bc run_behavior on the exec path (#12)"
+    assert "run_behavior" not in _imports_from("static_bundle.py")
 
 
 def test_no_local_generic_evaluator_reimplemented():

{litedbmodel_runtime-2.0.2 → litedbmodel_runtime-2.1.0}/tests/test_parallel_read.py

@@ -19,9 +19,6 @@ import time
 
 from litedbmodel_runtime.static_bundle import execute_read_graph
 
-SCOPE_PORT = "__scope"
-NODE_COMPONENT = "__makeSqlNode"
-
 
 class _LatencyPrepared:
     def __init__(self, driver: "_LatencyDriver", sql: str) -> None:
@@ -58,13 +55,17 @@ class _LatencyDriver:
 
 
 def _sibling_graph(n: int, concurrency: int = 16) -> dict:
-    """A read graph of n independent sibling nodes in ONE plan stage, each a trivial SELECT."""
+    """A read graph of n independent sibling nodes in ONE plan stage, each a trivial SELECT.
+
+    Each body node is a REAL ``compileBehaviors`` Select node — just an ``id`` the native walker
+    renders + executes from ``statementsById`` (#12: no ``__makeSqlNode``/``__scope`` surrogate).
+    """
     body = []
     output_obj = {}
     statements_by_id = {}
     for i in range(n):
         node_id = f"rel{i}"
-        body.append({"id": node_id, "component": NODE_COMPONENT, "ports": {SCOPE_PORT: {"obj": {}}}})
+        body.append({"id": node_id})
         output_obj[node_id] = {"ref": [node_id]}
         statements_by_id[node_id] = [{"sql": f"SELECT {i}", "params": []}]
     return {

{litedbmodel_runtime-2.0.2 → litedbmodel_runtime-2.1.0}/tests/test_runtime.py

@@ -2,15 +2,16 @@
 
 These exercise the static-makeSQL SQL-backend runtime against a REAL in-proc sqlite3 driver,
 independent of the frozen corpus, to prove:
-  - read bundle → bc run_behavior (plan/map/wire/output) + a makeSQL handler → assembled Φ output;
+  - read bundle → the NATIVE read-graph walker (plan/map/wire/output owned by litedbmodel; #12 —
+    no bc run_behavior, no surrogate) → assembled Φ output;
   - write bundle → gate-first transaction (commit; requires short-circuit ROLLBACK; idempotent
     duplicate short-circuit) with `$.entity` RETURNING exposure + emit-payload JSON serialization;
-  - bc-core is CONSUMED (the surrogate `__scope` port is evaluated by bc, the map orchestration is
-    bc's) — not reimplemented.
+  - bc-core is CONSUMED only for the deferred value-specs + skip (`evaluate_expression`) — the map
+    orchestration is the walker's, not reimplemented per node.
 
-The bundle is the LOCKED static-makeSQL shape: a read carries a `readGraph` (a bc surrogate
-`ComponentGraphIR` of `__makeSqlNode` nodes + per-node STATIC `{sql, params, skip?, whereFragment?}`
-statement templates); a write carries a `transaction` plan of `{sql, params}` makeSQL ops.
+The bundle is the LOCKED static-makeSQL shape: a read carries a `readGraph` (`compileBehaviors`'
+REAL `Select`/map `ComponentGraphIR` + per-node STATIC `{sql, params, skip?, whereFragment?}`
+statement templates keyed by node id); a write carries a `transaction` plan of `{sql, params}` ops.
 """
 
 from __future__ import annotations
@@ -63,20 +64,10 @@ def _read_bundle():
                         "name": "Feed",
                         "inputPorts": {"author_id": {"required": True}, "status": {"required": True}},
                         "body": [
-                            {
-                                "id": "n0",
-                                "component": "__makeSqlNode",
-                                "ports": {"__scope": {"obj": {"author_id": {"ref": ["author_id"]}, "status": {"ref": ["status"]}}}},
-                            },
+                            {"id": "n0"},
                             {
                                 "id": "n1",
-                                "map": {
-                                    "over": {"ref": ["n0"]},
-                                    "as": "$e0",
-                                    "component": "__makeSqlNode",
-                                    "parent": "n0",
-                                    "ports": {"__scope": {"obj": {"$e0": {"ref": ["$e0"]}}}},
-                                },
+                                "map": {"over": {"ref": ["n0"]}, "as": "$e0", "parent": "n0"},
                             },
                         ],
                         "output": {"obj": {"posts": {"ref": ["n0"]}, "authors": {"ref": ["n1"]}}},