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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: query-cascade
-Version: 0.3.2
+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.2 → query_cascade-0.3.3}/pyproject.toml

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

{query_cascade-0.3.2 → 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.2 → 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.2 → 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.2 → 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.2 → 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.2 → 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.2
+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.2 → 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.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()