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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: query-cascade
-Version: 0.3.2
+Version: 0.3.4
 Summary: Minimal demand-driven query framework for incremental computation.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
@@ -92,6 +92,8 @@ print(get_result())
 *   **`engine.inspect_graph()`**: Returns a dictionary of all nodes and edges in the dependency graph.
 *   **`engine.subgraph(roots, direction="deps")`**: Filters the graph to the dependency chain of the specified root nodes.
 *   **`engine.prune(roots, vacuum_disk=False)`**: Removes cached query results from the in-memory LRU cache that are not reachable from the specified roots. Set `vacuum_disk=True` to also do a deep vacuum of the persistent LMDB disk cache, deleting all orphaned blobs and metadata.
+*   **`engine.access_id`**: Property returning a monotonically increasing sequence number for memo accesses.
+*   **`engine.sweep_unaccessed(since_access_id)`**: Evicts all memos that haven't been accessed since `since_access_id`. Useful for generational garbage collection (e.g. at the end of a compilation pass).
 
 ---
 
@@ -155,6 +157,18 @@ validate_data(effects=effects)
 print(effects["warnings"])
 ```
 
+### Error Caching
+By default, queries will intercept and cache exceptions (`Exception` subclasses, excluding control flow exceptions like `QueryCancelled`). This is critical for interactive systems like language servers where inputs are frequently invalid. 
+
+```python
+@engine.query(cache_exceptions=(ValueError, TypeError))
+def parse(source: str):
+    if not source:
+        raise ValueError("Empty source")
+    return {"ast": source}
+```
+If a query throws an exception, it gets cached just like a regular return value. Subsequent calls instantly re-raise the exception, preserving incremental evaluation speed during error states. Cached exceptions can also be hydrated from the persistent disk cache.
+
 ### Performance Metrics
 Set `stats=True` in the `Engine` constructor to track execution timing.
 *   **`engine.stats_summary()`**: Returns wall-clock time spent in function bodies and cache eviction counts.
@@ -197,6 +211,8 @@ pip install query-cascade
 | Script | What it shows |
 |--------|----------------|
 | `compiler_pipeline.py` | `source → parse → symbols → typecheck`, warnings accumulator, cache-hit narration |
+| `error_caching.py` | Basic exception caching to prevent repeated re-evaluation on failure |
+| `error_caching_persistence.py` | Disk cache hydration of exceptions across process runs |
 | `dynamic_macro_expansion.py` | Query that **changes downstream dependencies** at runtime |
 | `snapshot_isolation.py` | Snapshot reads while live inputs change |
 | `concurrent_background_work.py` | Dedup under concurrency + cancellation after input changes |

{query_cascade-0.3.2 → query_cascade-0.3.4}/README.md

@@ -74,6 +74,8 @@ print(get_result())
 *   **`engine.inspect_graph()`**: Returns a dictionary of all nodes and edges in the dependency graph.
 *   **`engine.subgraph(roots, direction="deps")`**: Filters the graph to the dependency chain of the specified root nodes.
 *   **`engine.prune(roots, vacuum_disk=False)`**: Removes cached query results from the in-memory LRU cache that are not reachable from the specified roots. Set `vacuum_disk=True` to also do a deep vacuum of the persistent LMDB disk cache, deleting all orphaned blobs and metadata.
+*   **`engine.access_id`**: Property returning a monotonically increasing sequence number for memo accesses.
+*   **`engine.sweep_unaccessed(since_access_id)`**: Evicts all memos that haven't been accessed since `since_access_id`. Useful for generational garbage collection (e.g. at the end of a compilation pass).
 
 ---
 
@@ -137,6 +139,18 @@ validate_data(effects=effects)
 print(effects["warnings"])
 ```
 
+### Error Caching
+By default, queries will intercept and cache exceptions (`Exception` subclasses, excluding control flow exceptions like `QueryCancelled`). This is critical for interactive systems like language servers where inputs are frequently invalid. 
+
+```python
+@engine.query(cache_exceptions=(ValueError, TypeError))
+def parse(source: str):
+    if not source:
+        raise ValueError("Empty source")
+    return {"ast": source}
+```
+If a query throws an exception, it gets cached just like a regular return value. Subsequent calls instantly re-raise the exception, preserving incremental evaluation speed during error states. Cached exceptions can also be hydrated from the persistent disk cache.
+
 ### Performance Metrics
 Set `stats=True` in the `Engine` constructor to track execution timing.
 *   **`engine.stats_summary()`**: Returns wall-clock time spent in function bodies and cache eviction counts.
@@ -179,6 +193,8 @@ pip install query-cascade
 | Script | What it shows |
 |--------|----------------|
 | `compiler_pipeline.py` | `source → parse → symbols → typecheck`, warnings accumulator, cache-hit narration |
+| `error_caching.py` | Basic exception caching to prevent repeated re-evaluation on failure |
+| `error_caching_persistence.py` | Disk cache hydration of exceptions across process runs |
 | `dynamic_macro_expansion.py` | Query that **changes downstream dependencies** at runtime |
 | `snapshot_isolation.py` | Snapshot reads while live inputs change |
 | `concurrent_background_work.py` | Dedup under concurrency + cancellation after input changes |

{query_cascade-0.3.2 → query_cascade-0.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "query-cascade"
-version = "0.3.2"
+version = "0.3.4"
 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.4}/src/cascade/_canonical.py

@@ -114,10 +114,16 @@ def _encode_node(obj: Any) -> Any:
     if isinstance(obj, dict):
         return _encode_dict(obj)
 
+    if isinstance(obj, BaseException):
+        return _ext(
+            8,  # _EXT_EXCEPTION
+            [type(obj).__module__, type(obj).__qualname__, [_encode_node(x) for x in obj.args]]
+        )
+
     raise TypeError(
         f"cascade persistent cache: cannot serialize {type(obj).__module__}.{type(obj).__qualname__!r}; "
         "supported types are primitives, bytes, list/tuple/set/frozenset/dict, "
-        "@dataclass instances, and typing.NamedTuple instances."
+        "@dataclass instances, typing.NamedTuple instances, and BaseException."
     )
 
 
@@ -182,4 +188,11 @@ def _decode_ext(ext: Any) -> Any:
         if not (isinstance(cls, type) and issubclass(cls, tuple) and hasattr(cls, "_make")):
             raise TypeError(f"{module_name}.{qualname!r} is not a NamedTuple")
         return cls(*vals)
+    if ext.code == 8:  # _EXT_EXCEPTION
+        module_name, qualname, values = payload
+        vals = [_decode_node(x) for x in values]
+        cls = _resolve_type(module_name, qualname)
+        if not (isinstance(cls, type) and issubclass(cls, BaseException)):
+            raise TypeError(f"{module_name}.{qualname!r} is not an Exception")
+        return cls(*vals)
     raise ValueError(f"cascade persistent cache: unknown extension code {ext.code}")

{query_cascade-0.3.2 → query_cascade-0.3.4}/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,15 +146,31 @@ 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)
         if replay_needed:
             self.replay_effects(entry.effects)
+        if entry.error is not None:
+            raise entry.error
         return entry.value
 
     def compute_or_get_memo(
@@ -235,6 +251,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 +301,68 @@ 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)
+                        
+        error: BaseException | None = None
+        while True:
+            try:
+                self.check_cancelled(runtime.cancel_epoch)
+                result = fn(*key[2])
+                self.check_cancelled(runtime.cancel_epoch)
+                error = None
+            except BaseException as exc:
+                cache_ex = self._store.lookup_query_cache_exceptions(key[1])
+                should_cache = False
+                if isinstance(exc, (QueryCancelled, CycleError, PersistentCacheError)):
+                    pass
+                elif cache_ex is True:
+                    should_cache = isinstance(exc, Exception)
+                elif isinstance(cache_ex, tuple):
+                    should_cache = isinstance(exc, cache_ex)
+                    
+                if should_cache:
+                    error = exc
+                    result = None
+                else:
+                    runtime.stack.pop()
+                    raise
+                
+            if frame.is_cycle_root:
+                if error is None and 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 error is not None:
+            value_hash = self._store.stable_hash(error)
+        else:
+            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 +379,8 @@ class Evaluator:
                 deps=frame.deps,
                 effects=frozen_effects,
                 last_access=self._store.next_access_id,
+                cycle_nodes=tuple(frame.cycle_nodes),
+                error=error,
             )
             self._store.drop_memo_locked(key)
             self._store.memos[key] = memo
@@ -358,9 +432,16 @@ class Evaluator:
             value = _canonical.decode(blob)
             effects_raw = record.get("effects", {})
             effects = {str(name): tuple(items) for name, items in effects_raw.items()}
+            is_error = record.get("is_error", False)
         except Exception:
             self._store.trace_event("disk_red", key, detail="record decode failed")
             return None
+            
+        error = None
+        if is_error:
+            error = value
+            value = None
+            
         with self._store.lock:
             self._store.next_access_id += 1
             memo = self._store.entry_from_runtime(
@@ -371,6 +452,7 @@ class Evaluator:
                 deps=observed,
                 effects=effects,
                 last_access=self._store.next_access_id,
+                error=error,
             )
             self._store.drop_memo_locked(key)
             self._store.memos[key] = memo
@@ -494,7 +576,10 @@ class Evaluator:
         if deps_records is None:
             return
         try:
-            value_blob = _canonical.encode(memo.value)
+            if memo.error is not None:
+                value_blob = _canonical.encode(memo.error)
+            else:
+                value_blob = _canonical.encode(memo.value)
         except TypeError as exc:
             raise PersistentCacheError(
                 f"query {self._store.key_to_str(key)!r} returned a value the persistent cache "
@@ -513,6 +598,7 @@ class Evaluator:
                 "value_hash": memo.value_hash,
                 "deps": deps_records,
                 "effects": effects_node,
+                "is_error": memo.error is not None,
             }
             disk.store_entry(_disk_cache.entry_key(kind, fid, args_blob), record, memo.value_hash, value_blob)
         except PersistentCacheError:

{query_cascade-0.3.2 → query_cascade-0.3.4}/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.4}/src/cascade/_serde.py

@@ -183,10 +183,19 @@ def _to_jsonable(obj: Any) -> Any:
             pairs.append([_to_jsonable(k), _to_jsonable(obj[k])])
         return {"__map__": pairs}
 
+    if isinstance(obj, BaseException):
+        return {
+            "__exception__": {
+                "m": type(obj).__module__,
+                "q": type(obj).__qualname__,
+                "a": [_to_jsonable(x) for x in obj.args],
+            }
+        }
+
     raise TypeError(
         f"cascade serde: unsupported type {type(obj).__module__}.{type(obj).__qualname__!r}; "
-        "use primitives, bytes, collections, @dataclass / typing.NamedTuple instances, or "
-        "cascade state types (MemoEntry, InputVersion, …)."
+        "use primitives, bytes, collections, @dataclass / typing.NamedTuple instances, "
+        "cascade state types (MemoEntry, InputVersion, …), or BaseException."
     )
 
 
@@ -281,4 +290,15 @@ def _from_jsonable(obj: Any) -> Any:
                 pass
             return tuple(vals)
 
+        if sole_key == "__exception__":
+            d = sole_val
+            vals = [_from_jsonable(x) for x in d["a"]]
+            try:
+                cls = _resolve_type(d["m"], d["q"])
+                if isinstance(cls, type) and issubclass(cls, BaseException):
+                    return cls(*vals)
+            except Exception:
+                pass
+            return Exception(f"Unresolved exception {d['m']}.{d['q']}: {vals}")
+
     raise TypeError(f"cascade serde: unrecognized object shape: {obj!r}")

{query_cascade-0.3.2 → query_cascade-0.3.4}/src/cascade/_state.py

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

{query_cascade-0.3.2 → query_cascade-0.3.4}/src/cascade/_store.py

@@ -44,6 +44,8 @@ class GraphStore:
 
         self.inputs: dict[InputKey, list[InputVersion]] = {}
         self.queries: dict[str, Callable[..., Any]] = {}
+        self.query_fixed_points: dict[str, Any] = {}
+        self.query_cache_exceptions: dict[str, bool | tuple[type[BaseException], ...]] = {}
         self.input_fns: dict[str, Callable[..., Any]] = {}
         self.memos: dict[QueryKey, MemoEntry] = {}
         self.dependents: dict[QueryKey, set[QueryKey]] = defaultdict(set)
@@ -101,14 +103,28 @@ 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, cache_exceptions: bool | tuple[type[BaseException], ...] = False) -> None:
         with self.lock:
             self.queries[query_id] = fn
+            self.query_cache_exceptions[query_id] = cache_exceptions
+            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_cache_exceptions(self, query_id: str) -> bool | tuple[type[BaseException], ...]:
+        with self.lock:
+            return self.query_cache_exceptions.get(query_id, False)
+
+    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
@@ -228,6 +244,13 @@ class GraphStore:
                     self._stats_evictions_recent.append(self.key_to_str(victim))
             self.drop_memo_locked(victim)
 
+    def sweep_unaccessed(self, since_access_id: int) -> None:
+        with self.lock:
+            remove = [k for k, memo in self.memos.items() if memo.last_access <= since_access_id]
+            for key in remove:
+                self.drop_memo_locked(key)
+            self._rebuild_lru_heap_locked()
+
     def latest_input_version(self, input_key: InputKey) -> InputVersion | None:
         versions = self.inputs.get(input_key)
         if not versions:
@@ -419,6 +442,8 @@ class GraphStore:
         deps: dict[QueryKey, int],
         effects: dict[str, tuple[Any, ...]],
         last_access: int,
+        cycle_nodes: tuple[QueryKey, ...] = (),
+        error: BaseException | None = None,
     ) -> MemoEntry:
         return MemoEntry(
             value=value,
@@ -428,4 +453,6 @@ 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,
+            error=error,
         )

{query_cascade-0.3.2 → query_cascade-0.3.4}/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, cache_exceptions: bool | tuple[type[BaseException], ...] = True) -> 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, cache_exceptions=cache_exceptions)
+            return handle
+        if fn is not None:
+            return decorator(fn)
+        return decorator
 
     def accumulator(self, name: str) -> Accumulator:
         return Accumulator(self, name=name)
@@ -418,6 +423,15 @@ class Engine:
     def reset_stats(self) -> None:
         self._store.reset_stats()
 
+    @property
+    def access_id(self) -> int:
+        """The monotonically increasing sequence number for memo accesses."""
+        return self._store.next_access_id
+
+    def sweep_unaccessed(self, since_access_id: int) -> None:
+        """Evict all memos that haven't been accessed since the given access ID."""
+        self._store.sweep_unaccessed(since_access_id)
+
     def prune(self, roots: Iterable[tuple[str, str, tuple[Any, ...]]], *, vacuum_disk: bool = False) -> None:
         root_list = list(roots)
         self._store.prune(root_list)

{query_cascade-0.3.2 → query_cascade-0.3.4}/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.4
 Summary: Minimal demand-driven query framework for incremental computation.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
@@ -92,6 +92,8 @@ print(get_result())
 *   **`engine.inspect_graph()`**: Returns a dictionary of all nodes and edges in the dependency graph.
 *   **`engine.subgraph(roots, direction="deps")`**: Filters the graph to the dependency chain of the specified root nodes.
 *   **`engine.prune(roots, vacuum_disk=False)`**: Removes cached query results from the in-memory LRU cache that are not reachable from the specified roots. Set `vacuum_disk=True` to also do a deep vacuum of the persistent LMDB disk cache, deleting all orphaned blobs and metadata.
+*   **`engine.access_id`**: Property returning a monotonically increasing sequence number for memo accesses.
+*   **`engine.sweep_unaccessed(since_access_id)`**: Evicts all memos that haven't been accessed since `since_access_id`. Useful for generational garbage collection (e.g. at the end of a compilation pass).
 
 ---
 
@@ -155,6 +157,18 @@ validate_data(effects=effects)
 print(effects["warnings"])
 ```
 
+### Error Caching
+By default, queries will intercept and cache exceptions (`Exception` subclasses, excluding control flow exceptions like `QueryCancelled`). This is critical for interactive systems like language servers where inputs are frequently invalid. 
+
+```python
+@engine.query(cache_exceptions=(ValueError, TypeError))
+def parse(source: str):
+    if not source:
+        raise ValueError("Empty source")
+    return {"ast": source}
+```
+If a query throws an exception, it gets cached just like a regular return value. Subsequent calls instantly re-raise the exception, preserving incremental evaluation speed during error states. Cached exceptions can also be hydrated from the persistent disk cache.
+
 ### Performance Metrics
 Set `stats=True` in the `Engine` constructor to track execution timing.
 *   **`engine.stats_summary()`**: Returns wall-clock time spent in function bodies and cache eviction counts.
@@ -197,6 +211,8 @@ pip install query-cascade
 | Script | What it shows |
 |--------|----------------|
 | `compiler_pipeline.py` | `source → parse → symbols → typecheck`, warnings accumulator, cache-hit narration |
+| `error_caching.py` | Basic exception caching to prevent repeated re-evaluation on failure |
+| `error_caching_persistence.py` | Disk cache hydration of exceptions across process runs |
 | `dynamic_macro_expansion.py` | Query that **changes downstream dependencies** at runtime |
 | `snapshot_isolation.py` | Snapshot reads while live inputs change |
 | `concurrent_background_work.py` | Dedup under concurrency + cancellation after input changes |

{query_cascade-0.3.2 → query_cascade-0.3.4}/src/query_cascade.egg-info/SOURCES.txt

@@ -27,12 +27,18 @@ tests/test_engine_concurrency.py
 tests/test_engine_persistence_and_tracing.py
 tests/test_engine_private.py
 tests/test_engine_private2.py
+tests/test_engine_sweep.py
+tests/test_error_caching.py
+tests/test_error_caching_persistence.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
 tests/test_scale_behavior.py
 tests/test_serde.py
 tests/test_stateful_engine_invariants.py
-tests/test_subgraph_stats_export.py
+tests/test_store_coverage.py
+tests/test_subgraph_stats_export.py
+tests/test_sweep_unaccessed.py

{query_cascade-0.3.2 → query_cascade-0.3.4}/tests/test_disk_cache.py

@@ -747,7 +747,7 @@ def test_dynamic_graph_topology_cross_session(tmp_path: Path) -> None:
     engine_5.shutdown()
 
 
-def test_errors_are_not_cached_across_sessions(tmp_path: Path) -> None:
+def test_errors_are_cached_across_sessions(tmp_path: Path) -> None:
     data = tmp_path / "state.txt"
     data.write_text("fail")
     cache = tmp_path / "cache"
@@ -777,12 +777,12 @@ def test_errors_are_not_cached_across_sessions(tmp_path: Path) -> None:
     assert runs == {"process": 1}
     engine_1.shutdown()
 
-    # Session 2: still failing, must re-run because errors aren't cached
+    # Session 2: still failing, hydrated from disk
     runs.clear()
     engine_2, process_2 = build()
     with pytest.raises(ValueError, match="Oops"):
         process_2()
-    assert runs == {"process": 1}
+    assert runs == {}
     engine_2.shutdown()
 
     # Session 3: state fixed, runs and caches

query_cascade-0.3.4/tests/test_engine_sweep.py

@@ -0,0 +1,78 @@
+from cascade.engine import Engine
+
+def test_sweep_unaccessed() -> None:
+    engine = Engine()
+
+    @engine.input
+    def file_content(path: str) -> str:
+        return "content"
+
+    @engine.query
+    def compile_file(path: str) -> str:
+        return file_content(path).upper()
+
+    @engine.query
+    def compile_project(paths: tuple[str, ...]) -> str:
+        return " + ".join(compile_file(p) for p in paths)
+
+    # 1. Populate cache with A, B, C
+    res = compile_project(("A", "B", "C"))
+    assert res == "CONTENT + CONTENT + CONTENT"
+    
+    # Store access ID after the first pass
+    start_id = engine.access_id
+    
+    # 2. Simulate second pass: file "C" is deleted, only "A" and "B" remain.
+    res2 = compile_project(("A", "B"))
+    assert res2 == "CONTENT + CONTENT"
+    
+    # Verify that file_content("C") and compile_file("C") are still in cache
+    graph_before = engine.inspect_graph()
+    nodes_before = set(graph_before["nodes"])
+    assert "query:tests.test_engine_sweep:test_sweep_unaccessed.<locals>.compile_file('C',)" in nodes_before
+    
+    # 3. Sweep
+    engine.sweep_unaccessed(start_id)
+    
+    # 4. Verify unaccessed nodes are dropped, accessed are kept
+    graph_after = engine.inspect_graph()
+    nodes_after = set(graph_after["nodes"])
+    
+    assert "query:tests.test_engine_sweep:test_sweep_unaccessed.<locals>.compile_file('C',)" not in nodes_after
+    assert "query:tests.test_engine_sweep:test_sweep_unaccessed.<locals>.compile_file('A',)" in nodes_after
+    assert "query:tests.test_engine_sweep:test_sweep_unaccessed.<locals>.compile_file('B',)" in nodes_after
+    
+    # Note: sweep_unaccessed operates on query memos (Memos), not input versions.
+    # The input nodes reported by inspect_graph might still show up since they 
+    # are tracked separately in inputs, but the memo table eviction is what frees up memory.
+
+def test_sweep_empty_cache() -> None:
+    engine = Engine()
+    start_id = engine.access_id
+    
+    # sweeping an empty cache should not crash
+    engine.sweep_unaccessed(start_id)
+    
+    graph_after = engine.inspect_graph()
+    assert len(graph_after["nodes"]) == 0
+
+def test_sweep_resets_lru() -> None:
+    engine = Engine(max_entries=2)
+    
+    @engine.query
+    def q(x: int) -> int:
+        return x
+        
+    q(1)
+    q(2)
+    start_id = engine.access_id
+    q(3)
+    
+    # 3 pushes out 1 because max_entries=2 (2 and 3 remain)
+    graph = engine.inspect_graph()
+    assert len(graph["nodes"]) == 2
+    
+    engine.sweep_unaccessed(start_id)
+    # Only 3 remains since it was accessed after start_id
+    graph_after = engine.inspect_graph()
+    assert len(graph_after["nodes"]) == 1

query_cascade-0.3.4/tests/test_error_caching.py

@@ -0,0 +1,125 @@
+import pytest
+
+from cascade.engine import Engine
+
+
+def test_error_is_cached():
+    engine = Engine()
+    calls = 0
+
+    @engine.query(cache_exceptions=True)
+    def throws_error():
+        nonlocal calls
+        calls += 1
+        raise ValueError("Something went wrong")
+
+    with pytest.raises(ValueError, match="Something went wrong"):
+        throws_error()
+    assert calls == 1
+
+    # Should hit cache and raise again without incrementing calls
+    with pytest.raises(ValueError, match="Something went wrong"):
+        throws_error()
+    assert calls == 1
+
+
+def test_error_cache_invalidation():
+    engine = Engine()
+
+    @engine.input
+    def get_input():
+        return "bad"
+
+    calls = 0
+
+    @engine.query(cache_exceptions=True)
+    def process():
+        nonlocal calls
+        calls += 1
+        val = get_input()
+        if val == "bad":
+            raise ValueError("bad input")
+        return val
+
+    with pytest.raises(ValueError, match="bad input"):
+        process()
+    assert calls == 1
+
+    with pytest.raises(ValueError, match="bad input"):
+        process()
+    assert calls == 1
+
+    # Invalidate by changing input
+    get_input.set(value="good")
+    assert process() == "good"
+    assert calls == 2
+
+
+def test_dependent_query_rethrows():
+    engine = Engine()
+    b_calls = 0
+
+    @engine.query(cache_exceptions=True)
+    def b():
+        nonlocal b_calls
+        b_calls += 1
+        raise RuntimeError("b failed")
+
+    a_calls = 0
+
+    @engine.query(cache_exceptions=True)
+    def a():
+        nonlocal a_calls
+        a_calls += 1
+        return b()
+
+    with pytest.raises(RuntimeError, match="b failed"):
+        a()
+    assert a_calls == 1
+    assert b_calls == 1
+
+    with pytest.raises(RuntimeError, match="b failed"):
+        a()
+    assert a_calls == 1
+    assert b_calls == 1
+
+
+class MyError(Exception):
+    pass
+
+
+def test_selective_exception_caching():
+    engine = Engine()
+    calls = 0
+
+    @engine.input
+    def error_type():
+        return "my"
+
+    @engine.query(cache_exceptions=(MyError,))
+    def throws_specific():
+        nonlocal calls
+        calls += 1
+        err = error_type()
+        if err == "my":
+            raise MyError("my error")
+        else:
+            raise ValueError("value error")
+
+    with pytest.raises(MyError):
+        throws_specific()
+    assert calls == 1
+
+    with pytest.raises(MyError):
+        throws_specific()
+    assert calls == 1  # cached
+
+    error_type.set(value="value")
+    with pytest.raises(ValueError):
+        throws_specific()
+    assert calls == 2
+
+    # Should NOT be cached
+    with pytest.raises(ValueError):
+        throws_specific()
+    assert calls == 3

query_cascade-0.3.4/tests/test_error_caching_persistence.py

@@ -0,0 +1,39 @@
+import pytest
+import tempfile
+from cascade.engine import Engine
+
+def test_persistent_error_caching():
+    with tempfile.TemporaryDirectory() as tmpdir:
+        engine1 = Engine(cache_dir=tmpdir)
+        
+        calls1 = 0
+        
+        @engine1.query
+        def throws():
+            nonlocal calls1
+            calls1 += 1
+            raise ValueError("Disk cached error")
+            
+        with pytest.raises(ValueError, match="Disk cached error"):
+            throws()
+        assert calls1 == 1
+        
+        engine1.shutdown()
+        
+        # Hydrate in new engine
+        engine2 = Engine(cache_dir=tmpdir)
+        calls2 = 0
+        
+        @engine2.query
+        def throws():
+            nonlocal calls2
+            calls2 += 1
+            raise ValueError("Disk cached error")
+            
+        with pytest.raises(ValueError, match="Disk cached error"):
+            throws()
+        
+        # Should be hydrated from disk, so calls2 remains 0
+        assert calls2 == 0
+        
+        engine2.shutdown()

query_cascade-0.3.4/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()

query_cascade-0.3.4/tests/test_store_coverage.py

@@ -0,0 +1,44 @@
+from cascade.engine import Engine
+
+def test_store_stats_eviction_recent_cap() -> None:
+    engine = Engine(stats=True, max_entries=2)
+    # populate cache
+    @engine.query
+    def q(x: int) -> int:
+        return x
+    
+    q(1)
+    q(2)
+    q(3) # evicts 1
+    
+    assert engine.stats_summary()["evictions_total"] == 1
+    assert len(engine.stats_summary()["evictions_recent"]) == 1
+    
+    # modify cap to 0
+    engine._store.set_stats_eviction_recent_cap(0)
+    assert len(engine.stats_summary()["evictions_recent"]) == 0
+    
+    # modify cap to 5
+    engine._store.set_stats_eviction_recent_cap(5)
+    
+    q(4) # evicts 2
+    assert engine.stats_summary()["evictions_total"] == 2
+    assert len(engine.stats_summary()["evictions_recent"]) == 1
+
+def test_engine_negative_clock() -> None:
+    clock_val = 100.0
+    def clock():
+        nonlocal clock_val
+        val = clock_val
+        clock_val -= 10.0 # goes backwards!
+        return val
+        
+    engine = Engine(stats=True, stats_clock=clock)
+    @engine.query
+    def q(x: int) -> int:
+        return x
+        
+    q(1)
+    stats = engine.stats_summary()
+    key = list(stats["by_key"].keys())[0]
+    assert stats["by_key"][key] == 0.0 # clamped from negative to 0.0

query_cascade-0.3.4/tests/test_sweep_unaccessed.py

@@ -0,0 +1,33 @@
+from cascade import Engine
+
+def test_sweep_unaccessed() -> None:
+    engine = Engine()
+    
+    @engine.input
+    def root() -> int:
+        return 1
+        
+    @engine.query
+    def query_a() -> int:
+        return root() + 1
+        
+    @engine.query
+    def query_b() -> int:
+        return query_a() + 1
+        
+    # Phase 1: Compute both. Both 'query_a' and 'query_b' are accessed.
+    assert query_b() == 3
+    stats = engine.stats_summary()
+    assert stats["memo_count"] == 2
+    
+    # Record access_id before the next "epoch"
+    epoch = engine.access_id
+    
+    # Phase 2: Compute only a (query_b is unaccessed this pass)
+    assert query_a() == 2
+    
+    engine.sweep_unaccessed(epoch)
+    
+    # query_b should be evicted, query_a should remain
+    stats_after = engine.stats_summary()
+    assert stats_after["memo_count"] == 1