query-cascade 0.2.1__tar.gz → 0.2.2__tar.gz

{query_cascade-0.2.1 → query_cascade-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: query-cascade
-Version: 0.2.1
+Version: 0.2.2
 Summary: Minimal demand-driven query framework for incremental computation.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
@@ -321,7 +321,7 @@ print(deps_only["memo_count"], deps_only["edges"])
 
 ### Query stats (timing and eviction)
 
-**`by_key`** totals **wall time** in seconds for **successful** recomputes only (cache hits are not timed). **`stats_clock`** is optional for deterministic tests. Counters are **in-memory only** (**`save`** / **`load`** do not persist them).
+**`by_key`** totals **wall time** in seconds for **successful** recomputes only (cache hits are not timed). Each value is **inclusive** for that callable: if the body calls other queries, their execution time is included in the parent’s row as well as their own (do not sum **`by_key`** across the graph to get “total work”). **`stats_clock`** is optional for deterministic tests. Counters are **in-memory only** (**`save`** / **`load`** do not persist them).
 
 ```python
 from cascade import Engine

{query_cascade-0.2.1 → query_cascade-0.2.2}/README.md

@@ -308,7 +308,7 @@ print(deps_only["memo_count"], deps_only["edges"])
 
 ### Query stats (timing and eviction)
 
-**`by_key`** totals **wall time** in seconds for **successful** recomputes only (cache hits are not timed). **`stats_clock`** is optional for deterministic tests. Counters are **in-memory only** (**`save`** / **`load`** do not persist them).
+**`by_key`** totals **wall time** in seconds for **successful** recomputes only (cache hits are not timed). Each value is **inclusive** for that callable: if the body calls other queries, their execution time is included in the parent’s row as well as their own (do not sum **`by_key`** across the graph to get “total work”). **`stats_clock`** is optional for deterministic tests. Counters are **in-memory only** (**`save`** / **`load`** do not persist them).
 
 ```python
 from cascade import Engine

{query_cascade-0.2.1 → query_cascade-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "query-cascade"
-version = "0.2.1"
+version = "0.2.2"
 description = "Minimal demand-driven query framework for incremental computation."
 requires-python = ">=3.12"
 readme = "README.md"

{query_cascade-0.2.1 → query_cascade-0.2.2}/src/cascade/_evaluator.py

@@ -162,7 +162,13 @@ class Evaluator:
                     self._store.trace_event("cache_hit", key)
                     return existing, True
 
-                if self.try_mark_green(key, existing, runtime.snapshot):
+                self._store.pin_memo_verification_locked(key)
+                try:
+                    green = self.try_mark_green(key, existing, runtime.snapshot)
+                finally:
+                    self._store.unpin_memo_verification_locked(key)
+
+                if green:
                     existing.verified_at = runtime.snapshot.revision
                     self._store.touch_memo_locked(key)
                     self._store.trace_event("cache_green", key)

{query_cascade-0.2.1 → query_cascade-0.2.2}/src/cascade/_store.py

@@ -48,6 +48,9 @@ class GraphStore:
         self.in_flight: dict[tuple[QueryKey, int], concurrent.futures.Future[MemoEntry]] = {}
         # Lazy min-heap (last_access, key); stale entries removed on pop (touches push new tuples).
         self._lru_heap: list[tuple[int, QueryKey]] = []
+        # Refcount: memo rows participating in an in-flight cache/verify sequence must not
+        # be LRU-evicted (nested recompute can otherwise drop the parent before verify ends).
+        self._memo_verify_pin_count: dict[QueryKey, int] = {}
 
     def monotonic_seconds(self) -> float:
         return self._monotonic_seconds()
@@ -142,6 +145,16 @@ class GraphStore:
         memo.last_access = self.next_access_id
         heapq.heappush(self._lru_heap, (memo.last_access, key))
 
+    def pin_memo_verification_locked(self, key: QueryKey) -> None:
+        self._memo_verify_pin_count[key] = self._memo_verify_pin_count.get(key, 0) + 1
+
+    def unpin_memo_verification_locked(self, key: QueryKey) -> None:
+        n = self._memo_verify_pin_count.get(key, 0)
+        if n <= 1:
+            self._memo_verify_pin_count.pop(key, None)
+        else:
+            self._memo_verify_pin_count[key] = n - 1
+
     def push_memo_lru_locked(self, key: QueryKey) -> None:
         memo = self.memos.get(key)
         if memo is None:
@@ -149,6 +162,7 @@ class GraphStore:
         heapq.heappush(self._lru_heap, (memo.last_access, key))
 
     def drop_memo_locked(self, key: QueryKey) -> None:
+        self._memo_verify_pin_count.pop(key, None)
         memo = self.memos.pop(key, None)
         if memo is None:
             return
@@ -170,9 +184,22 @@ class GraphStore:
             memo = self.memos.get(key)
             if memo is None or memo.last_access != last_acc:
                 continue
+            if self._memo_verify_pin_count.get(key, 0) > 0:
+                continue
             return key
         return None
 
+    def _unpinned_lru_fallback_key_locked(self) -> QueryKey | None:
+        best_k: QueryKey | None = None
+        best_acc: int | None = None
+        for k, memo in self.memos.items():
+            if self._memo_verify_pin_count.get(k, 0) > 0:
+                continue
+            if best_acc is None or memo.last_access < best_acc:
+                best_acc = memo.last_access
+                best_k = k
+        return best_k
+
     def evict_if_needed_locked(self) -> None:
         while len(self.memos) > self.max_entries:
             victim = self._pop_lru_victim_key_locked()
@@ -180,7 +207,9 @@ class GraphStore:
                 self._rebuild_lru_heap_locked()
                 victim = self._pop_lru_victim_key_locked()
             if victim is None:
-                victim = min(self.memos.items(), key=lambda it: it[1].last_access)[0]
+                victim = self._unpinned_lru_fallback_key_locked()
+            if victim is None:
+                break
             self.trace_event("evict", victim, "lru")
             if self._stats_enabled:
                 self._stats_evictions_total += 1
@@ -354,6 +383,7 @@ class GraphStore:
             # In-flight dedup futures are process-local/transient and should never
             # survive a load boundary.
             self.in_flight.clear()
+            self._memo_verify_pin_count.clear()
             self._rebuild_lru_heap_locked()
 
     def make_persistence_payload(self) -> dict[str, Any]:

{query_cascade-0.2.1 → query_cascade-0.2.2}/src/query_cascade.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: query-cascade
-Version: 0.2.1
+Version: 0.2.2
 Summary: Minimal demand-driven query framework for incremental computation.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
@@ -321,7 +321,7 @@ print(deps_only["memo_count"], deps_only["edges"])
 
 ### Query stats (timing and eviction)
 
-**`by_key`** totals **wall time** in seconds for **successful** recomputes only (cache hits are not timed). **`stats_clock`** is optional for deterministic tests. Counters are **in-memory only** (**`save`** / **`load`** do not persist them).
+**`by_key`** totals **wall time** in seconds for **successful** recomputes only (cache hits are not timed). Each value is **inclusive** for that callable: if the body calls other queries, their execution time is included in the parent’s row as well as their own (do not sum **`by_key`** across the graph to get “total work”). **`stats_clock`** is optional for deterministic tests. Counters are **in-memory only** (**`save`** / **`load`** do not persist them).
 
 ```python
 from cascade import Engine

{query_cascade-0.2.1 → query_cascade-0.2.2}/src/query_cascade.egg-info/SOURCES.txt

@@ -26,6 +26,7 @@ tests/test_evaluator_and_synthetic_coverage.py
 tests/test_examples.py
 tests/test_internal_invariants.py
 tests/test_performance.py
+tests/test_repro_touch_memo_keyerror.py
 tests/test_scale_behavior.py
 tests/test_serde.py
 tests/test_stateful_engine_invariants.py

query_cascade-0.2.2/tests/test_repro_touch_memo_keyerror.py

@@ -0,0 +1,70 @@
+"""Regression: nested ``try_mark_green`` must not LRU-evict memos mid-verify.
+
+Previously, ``compute_or_get_memo`` could touch a parent memo, call
+``try_mark_green`` (which recursively recomputed deps), and nested
+``evict_if_needed_locked`` could evict that parent before the post-verify
+``touch_memo_locked`` → ``KeyError``.  Query memos under verification are now
+refcount-pinned in :class:`~cascade._store.GraphStore` so LRU skips them until
+``unpin_memo_verification_locked``.
+"""
+
+from __future__ import annotations
+
+from cascade import Engine
+
+
+def _run_nested_verify_under_pressure(*, max_entries: int = 6) -> None:
+    engine = Engine(max_entries=max_entries, trace_limit=2_000)
+    inp = engine.input(lambda: 0)
+
+    @engine.query
+    def aux(i: int) -> int:
+        return i + 1
+
+    @engine.query
+    def leaf(i: int) -> int:
+        return aux(i)
+
+    @engine.query
+    def root() -> int:
+        return sum(leaf(j) for j in range(3))
+
+    assert root() == 6
+    inp.set(1)
+    assert root() == 6
+
+
+def test_nested_verify_with_small_memo_table_no_keyerror() -> None:
+    """Seven query keys, ``max_entries == 6``: first run evicts; second run verifies."""
+    _run_nested_verify_under_pressure(max_entries=6)
+
+
+def test_same_graph_succeeds_with_smaller_cache() -> None:
+    _run_nested_verify_under_pressure(max_entries=5)
+
+
+def test_many_fillers_after_revision_before_root_still_computes(max_entries: int = 12) -> None:
+    engine = Engine(max_entries=max_entries, trace_limit=10_000)
+    inp = engine.input(lambda: 0)
+
+    @engine.query
+    def filler(n: int) -> int:
+        return n
+
+    @engine.query
+    def aux(i: int) -> int:
+        return i + 1
+
+    @engine.query
+    def leaf(i: int) -> int:
+        return aux(i)
+
+    @engine.query
+    def root() -> int:
+        return sum(leaf(j) for j in range(3))
+
+    assert root() == 6
+    for n in range(400):
+        filler(n)
+    inp.set(1)
+    assert root() == 6