query-cascade 0.3.1__tar.gz → 0.3.3__tar.gz

{query_cascade-0.3.1 → query_cascade-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: query-cascade
-Version: 0.3.1
+Version: 0.3.3
 Summary: Minimal demand-driven query framework for incremental computation.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{query_cascade-0.3.1 → query_cascade-0.3.3}/pyproject.toml

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

{query_cascade-0.3.1 → query_cascade-0.3.3}/src/cascade/_evaluator.py

@@ -7,7 +7,7 @@ from typing import Any, Callable, Mapping, Sequence
 from . import _canonical, _disk_cache
 from ._disk_cache import DiskCache
 from ._errors import CycleError, PersistentCacheError, QueryCancelled
-from ._runtime import RuntimeFrame, RuntimeState
+from ._runtime import UNSET, RuntimeFrame, RuntimeState
 from ._state import InputVersion, MemoEntry, QueryKey, Snapshot
 from ._store import GraphStore
 
@@ -146,10 +146,24 @@ class Evaluator:
             )
 
         key: QueryKey = ("query", query_id, args)
-        if any(frame.key == key for frame in runtime.stack):
-            cycle_start = [frame.key for frame in runtime.stack] + [key]
-            cycle = " -> ".join(self._store.key_to_str(k) for k in cycle_start)
-            raise CycleError(f"cycle detected: {cycle}")
+        for i, frame in enumerate(runtime.stack):
+            if frame.key == key:
+                if frame.cycle_guess is UNSET:
+                    has_fp, fp_val = self._store.lookup_query_fixed_point(query_id)
+                    if not has_fp:
+                        cycle_start = [f.key for f in runtime.stack[i:]] + [key]
+                        cycle = " -> ".join(self._store.key_to_str(k) for k in cycle_start)
+                        raise CycleError(f"cycle detected: {cycle}")
+                    frame.cycle_guess = fp_val
+                    
+                frame.is_cycle_root = True
+                for f in runtime.stack[i:]:
+                    frame.cycle_nodes.add(f.key)
+                
+                # Record the back-edge dependency so the calling node is properly invalidated later
+                if len(runtime.stack) > 0:
+                    runtime.stack[-1].deps[key] = runtime.snapshot.revision
+                return frame.cycle_guess
         self.check_cancelled(runtime.cancel_epoch)
         entry, replay_needed = self.compute_or_get_memo(key, fn, runtime)
         self.record_dependency(key, entry.changed_at)
@@ -235,6 +249,11 @@ class Evaluator:
             return memo.changed_at
 
         runtime = self._runtime_var.get()
+        if runtime is not None:
+            for frame in runtime.stack:
+                if frame.key == key:
+                    return snapshot.revision
+
         if runtime is None:
             self._run_in_runtime(
                 RuntimeState(
@@ -280,17 +299,50 @@ class Evaluator:
         runtime.stack.append(frame)
         start = self._store.monotonic_seconds()
         self._store.trace_event("recompute_start", key)
-        try:
-            self.check_cancelled(runtime.cancel_epoch)
-            result = fn(*key[2])
-            self.check_cancelled(runtime.cancel_epoch)
-        finally:
+        
+        with self._store.lock:
+            old_memo = self._store.memos.get(key)
+            if old_memo is not None and old_memo.cycle_nodes:
+                for k in old_memo.cycle_nodes:
+                    if k != key:
+                        self._store.drop_memo_locked(k)
+                        
+        while True:
+            try:
+                self.check_cancelled(runtime.cancel_epoch)
+                result = fn(*key[2])
+                self.check_cancelled(runtime.cancel_epoch)
+            except BaseException:
+                runtime.stack.pop()
+                raise
+                
+            if frame.is_cycle_root:
+                if self._store.stable_hash(result) != self._store.stable_hash(frame.cycle_guess):
+                    frame.cycle_guess = result
+                    frame.is_cycle_root = False
+                    with self._store.lock:
+                        self._store.revision += 1
+                        runtime.snapshot = Snapshot(revision=self._store.revision)
+                        for k in frame.cycle_nodes:
+                            if k != key:
+                                self._store.drop_memo_locked(k)
+                    frame.deps.clear()
+                    frame.effects.clear()
+                    continue
+                    
             runtime.stack.pop()
+            break
+            
         elapsed = self._store.monotonic_seconds() - start
         duration_ms = elapsed * 1000.0
 
         frozen_effects = {name: tuple(items) for name, items in frame.effects.items()}
         value_hash = self._store.stable_hash(result)
+        
+        if frame.cycle_nodes:
+            for k in frame.cycle_nodes:
+                frame.deps.pop(k, None)
+            
         with self._store.lock:
             previous = self._store.memos.get(key)
             if previous is not None and previous.value_hash == value_hash:
@@ -307,6 +359,7 @@ class Evaluator:
                 deps=frame.deps,
                 effects=frozen_effects,
                 last_access=self._store.next_access_id,
+                cycle_nodes=tuple(frame.cycle_nodes),
             )
             self._store.drop_memo_locked(key)
             self._store.memos[key] = memo

{query_cascade-0.3.1 → query_cascade-0.3.3}/src/cascade/_runtime.py

@@ -7,11 +7,16 @@ from typing import Any
 from ._state import QueryKey, Snapshot
 
 
+UNSET = object()
+
 @dataclass
 class RuntimeFrame:
     key: QueryKey
     deps: dict[QueryKey, int] = field(default_factory=dict)
     effects: dict[str, list[Any]] = field(default_factory=lambda: defaultdict(list))
+    cycle_guess: Any = UNSET
+    is_cycle_root: bool = False
+    cycle_nodes: set[QueryKey] = field(default_factory=set)
 
 
 @dataclass

{query_cascade-0.3.1 → query_cascade-0.3.3}/src/cascade/_state.py

@@ -31,6 +31,7 @@ class MemoEntry:
     deps: tuple[Dependency, ...]
     effects: dict[str, tuple[Any, ...]]
     last_access: int
+    cycle_nodes: tuple[QueryKey, ...] = ()
 
 
 @dataclass(frozen=True)

{query_cascade-0.3.1 → query_cascade-0.3.3}/src/cascade/_store.py

@@ -44,6 +44,7 @@ class GraphStore:
 
         self.inputs: dict[InputKey, list[InputVersion]] = {}
         self.queries: dict[str, Callable[..., Any]] = {}
+        self.query_fixed_points: dict[str, Any] = {}
         self.input_fns: dict[str, Callable[..., Any]] = {}
         self.memos: dict[QueryKey, MemoEntry] = {}
         self.dependents: dict[QueryKey, set[QueryKey]] = defaultdict(set)
@@ -101,14 +102,23 @@ class GraphStore:
             sk = self.key_to_str(key)
             self._stats_by_key[sk] = self._stats_by_key.get(sk, 0.0) + seconds
 
-    def register_query(self, query_id: str, fn: Callable[..., Any]) -> None:
+    def register_query(self, query_id: str, fn: Callable[..., Any], *, fixed_point: Any = None, has_fixed_point: bool = False) -> None:
         with self.lock:
             self.queries[query_id] = fn
+            if has_fixed_point:
+                self.query_fixed_points[query_id] = fixed_point
 
     def lookup_query(self, query_id: str) -> Callable[..., Any]:
         with self.lock:
             return self.queries[query_id]
 
+    def lookup_query_fixed_point(self, query_id: str) -> tuple[bool, Any]:
+        """Returns (has_fixed_point, fixed_point_value)."""
+        with self.lock:
+            if query_id in self.query_fixed_points:
+                return True, self.query_fixed_points[query_id]
+            return False, None
+
     def register_input(self, input_id: str, fn: Callable[..., Any]) -> None:
         with self.lock:
             self.input_fns[input_id] = fn
@@ -419,6 +429,7 @@ class GraphStore:
         deps: dict[QueryKey, int],
         effects: dict[str, tuple[Any, ...]],
         last_access: int,
+        cycle_nodes: tuple[QueryKey, ...] = (),
     ) -> MemoEntry:
         return MemoEntry(
             value=value,
@@ -428,4 +439,5 @@ class GraphStore:
             deps=tuple(Dependency(dep_key, observed) for dep_key, observed in deps.items()),
             effects=effects,
             last_access=last_access,
+            cycle_nodes=cycle_nodes,
         )

{query_cascade-0.3.1 → query_cascade-0.3.3}/src/cascade/engine.py

@@ -218,10 +218,15 @@ class Engine:
         self._store.register_input(handle.id, fn)
         return handle
 
-    def query(self, fn: Callable[..., Any]) -> _QueryHandle:
-        handle = _QueryHandle(self, fn)
-        self._store.register_query(handle.id, fn)
-        return handle
+    def query(self, fn: Callable[..., Any] | None = None, *, fixed_point: Any = _UNSET) -> Any:
+        def decorator(f: Callable[..., Any]) -> _QueryHandle:
+            handle = _QueryHandle(self, f)
+            has_fixed_point = fixed_point is not _UNSET
+            self._store.register_query(handle.id, f, fixed_point=fixed_point, has_fixed_point=has_fixed_point)
+            return handle
+        if fn is not None:
+            return decorator(fn)
+        return decorator
 
     def accumulator(self, name: str) -> Accumulator:
         return Accumulator(self, name=name)

{query_cascade-0.3.1 → query_cascade-0.3.3}/src/query_cascade.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: query-cascade
-Version: 0.3.1
+Version: 0.3.3
 Summary: Minimal demand-driven query framework for incremental computation.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{query_cascade-0.3.1 → query_cascade-0.3.3}/src/query_cascade.egg-info/SOURCES.txt

@@ -29,6 +29,7 @@ tests/test_engine_private.py
 tests/test_engine_private2.py
 tests/test_evaluator_and_synthetic_coverage.py
 tests/test_examples.py
+tests/test_fixed_point.py
 tests/test_internal_invariants.py
 tests/test_performance.py
 tests/test_repro_touch_memo_keyerror.py

{query_cascade-0.3.1 → query_cascade-0.3.3}/tests/test_disk_cache.py

@@ -674,3 +674,172 @@ def test_disk_cache_prune_vacuum_edge_cases(tmp_path: Path) -> None:
     engine.prune([("query", "missing:fid", ())], vacuum_disk=True)
     
     engine.shutdown()
+
+
+def test_dynamic_graph_topology_cross_session(tmp_path: Path) -> None:
+    data = tmp_path / "cond.txt"
+    data.write_text("A")
+    cache = tmp_path / "cache"
+    runs: dict[str, int] = {}
+
+    def build() -> tuple[Engine, Any]:
+        engine = Engine(cache_dir=cache)
+
+        @engine.input
+        def condition() -> str:
+            return data.read_text().strip()
+
+        @engine.query
+        def branch_a() -> str:
+            runs["branch_a"] = runs.get("branch_a", 0) + 1
+            return "A_out"
+
+        @engine.query
+        def branch_b() -> str:
+            runs["branch_b"] = runs.get("branch_b", 0) + 1
+            return "B_out"
+
+        @engine.query
+        def root() -> str:
+            runs["root"] = runs.get("root", 0) + 1
+            if condition() == "A":
+                return branch_a()
+            else:
+                return branch_b()
+
+        return engine, root
+
+    # Session 1: cond is A
+    engine_1, root_1 = build()
+    assert root_1() == "A_out"
+    assert runs == {"root": 1, "branch_a": 1}
+    engine_1.shutdown()
+
+    # Session 2: cond is still A, should hit
+    runs.clear()
+    engine_2, root_2 = build()
+    assert root_2() == "A_out"
+    assert runs == {}
+    engine_2.shutdown()
+
+    # Session 3: cond is B, must recompute root and branch_b
+    data.write_text("B")
+    runs.clear()
+    engine_3, root_3 = build()
+    assert root_3() == "B_out"
+    assert runs == {"root": 1, "branch_b": 1}
+    engine_3.shutdown()
+
+    # Session 4: cond is B, should hit
+    runs.clear()
+    engine_4, root_4 = build()
+    assert root_4() == "B_out"
+    assert runs == {}
+    engine_4.shutdown()
+
+    # Session 5: cond is A again. root's fingerprint was overwritten by Session 3 (which depended on B),
+    # so root must recompute. But branch_a will hit the cache from Session 1!
+    data.write_text("A")
+    runs.clear()
+    engine_5, root_5 = build()
+    assert root_5() == "A_out"
+    assert runs == {"root": 1}
+    engine_5.shutdown()
+
+
+def test_errors_are_not_cached_across_sessions(tmp_path: Path) -> None:
+    data = tmp_path / "state.txt"
+    data.write_text("fail")
+    cache = tmp_path / "cache"
+    runs: dict[str, int] = {}
+
+    def build() -> tuple[Engine, Any]:
+        engine = Engine(cache_dir=cache)
+
+        @engine.input
+        def state() -> str:
+            return data.read_text().strip()
+
+        @engine.query
+        def process() -> str:
+            runs["process"] = runs.get("process", 0) + 1
+            val = state()
+            if val == "fail":
+                raise ValueError("Oops")
+            return "Success"
+
+        return engine, process
+
+    # Session 1: fails
+    engine_1, process_1 = build()
+    with pytest.raises(ValueError, match="Oops"):
+        process_1()
+    assert runs == {"process": 1}
+    engine_1.shutdown()
+
+    # Session 2: still failing, must re-run because errors aren't cached
+    runs.clear()
+    engine_2, process_2 = build()
+    with pytest.raises(ValueError, match="Oops"):
+        process_2()
+    assert runs == {"process": 1}
+    engine_2.shutdown()
+
+    # Session 3: state fixed, runs and caches
+    data.write_text("ok")
+    runs.clear()
+    engine_3, process_3 = build()
+    assert process_3() == "Success"
+    assert runs == {"process": 1}
+    engine_3.shutdown()
+
+    # Session 4: state still ok, hits cache
+    runs.clear()
+    engine_4, process_4 = build()
+    assert process_4() == "Success"
+    assert runs == {}
+    engine_4.shutdown()
+
+
+def test_deep_dependency_chain_cross_session(tmp_path: Path) -> None:
+    data = tmp_path / "val.txt"
+    data.write_text("0")
+    cache = tmp_path / "cache"
+    runs: dict[str, int] = {}
+
+    def build() -> tuple[Engine, Any]:
+        engine = Engine(cache_dir=cache)
+
+        @engine.input
+        def base() -> int:
+            return int(data.read_text().strip())
+
+        @engine.query
+        def chain(idx: int) -> int:
+            runs[f"q_{idx}"] = runs.get(f"q_{idx}", 0) + 1
+            if idx == 0:
+                return base() + 1
+            return chain(idx - 1) + 1
+
+        return engine, chain
+
+    # Session 1: compute the chain
+    engine_1, chain_1 = build()
+    assert chain_1(49) == 50
+    assert len(runs) == 50
+    engine_1.shutdown()
+
+    # Session 2: hit the chain
+    runs.clear()
+    engine_2, chain_2 = build()
+    assert chain_2(49) == 50
+    assert len(runs) == 0
+    engine_2.shutdown()
+
+    # Session 3: update base, recomputes all
+    data.write_text("10")
+    runs.clear()
+    engine_3, chain_3 = build()
+    assert chain_3(49) == 60
+    assert len(runs) == 50
+    engine_3.shutdown()

query_cascade-0.3.3/tests/test_fixed_point.py

@@ -0,0 +1,38 @@
+import pytest
+from cascade.engine import Engine, CycleError
+
+def test_fixed_point_basic():
+    engine = Engine()
+
+    @engine.input
+    def input_val():
+        return 1
+
+    @engine.query(fixed_point=0)
+    def cell_a():
+        return cell_b() + input_val()
+        
+    @engine.query
+    def cell_b():
+        return cell_a() // 2
+        
+    assert cell_a() == 1
+    assert cell_b() == 0
+    
+    input_val.set(value=4)
+    assert cell_a() == 7
+    assert cell_b() == 3
+
+def test_fixed_point_no_default_raises():
+    engine = Engine()
+    
+    @engine.query
+    def cell_a():
+        return cell_b()
+        
+    @engine.query
+    def cell_b():
+        return cell_a()
+        
+    with pytest.raises(CycleError):
+        cell_a()