stet 0.0.1__tar.gz

stet-0.0.1/.github/workflows/ci.yml

@@ -0,0 +1,52 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - run: uv sync --extra parquet
+      - run: uv run ruff format --check .
+      - run: uv run ruff check .
+      - run: uv run ty check
+
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python: ["3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+        with:
+          python-version: ${{ matrix.python }}
+      - run: uv sync --extra parquet
+      - run: uv run pytest
+
+  docs:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - run: uv sync
+      - run: uv run mkdocs build --strict
+
+  docs-deploy:
+    runs-on: ubuntu-latest
+    needs: [lint, test, docs]
+    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - run: uv sync
+      - run: uv run mkdocs gh-deploy --force

stet-0.0.1/.gitignore

@@ -0,0 +1,23 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# Test and coverage
+.coverage
+.pytest_cache/
+
+# MkDocs build output
+site/
+
+# Runtime filelock files
+*.lock
+
+# Default once store files (generated at runtime)
+_once_store.*

stet-0.0.1/.python-version

@@ -0,0 +1 @@
+3.14

stet-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vince Knight
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

stet-0.0.1/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: stet
+Version: 0.0.1
+Summary: Persistent memoization by parameter identity for experiment scripts
+Author-email: Vince Knight <vince@vknight.org>
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: filelock>=3.25.1
+Requires-Dist: pandas>=3.0.1
+Provides-Extra: parquet
+Requires-Dist: pyarrow>=23.0.1; extra == 'parquet'
+Description-Content-Type: text/markdown
+
+# stet
+
+A Python library for making parameter sweeps safely resumable.
+
+When a long-running experiment script is re-run — whether after a crash, a time limit, or deliberately to extend a sweep — `stet` automatically skips any parameter combinations that have already been completed.
+
+```python
+import stet
+
+@stet.once(store='markov_runs.csv', key=['alpha', 'n_states', 'seed'])
+def solve_markov(alpha, n_states, seed, n_iter=10_000):
+    # expensive computation
+    ...
+
+for alpha in alphas:
+    for n_states in [10, 50, 100]:
+        for seed in range(20):
+            solve_markov(alpha=alpha, n_states=n_states, seed=seed)
+```
+
+On restart, any already-completed `(alpha, n_states, seed)` combinations are skipped:
+
+```
+[once] Skipping solve_markov(alpha=0.01, n_states=10, seed=0)
+[once] Skipping solve_markov(alpha=0.01, n_states=10, seed=1)
+...
+```
+
+## Installation
+
+```bash
+uv add stet
+# or: python -m pip install stet
+```
+
+With Parquet support:
+
+```bash
+uv add stet[parquet]
+# or: python -m pip install stet[parquet]
+```
+
+## Usage
+
+**Zero config** — uses `_stet_store.csv` in the current directory, all parameters as the key:
+
+```python
+@stet.once
+def run_experiment(alpha, seed):
+    ...
+```
+
+**Named store** — backend selected from file extension (`.csv`, `.json`, `.sqlite`, `.parquet`):
+
+```python
+@stet.once(store='runs.sqlite')
+def run_experiment(alpha, seed):
+    ...
+```
+
+**Key subset** — only `alpha` and `seed` determine whether a run is skipped; `n_iter` is ignored:
+
+```python
+@stet.once(store='runs.csv', key=['alpha', 'seed'])
+def run_experiment(alpha, seed, n_iter=1000):
+    ...
+```
+
+## Utilities
+
+```python
+stet.status()            # print a summary of completed runs
+stet.reset()             # clear the store
+stet.reset(key_dict={'alpha': '0.1', 'seed': '42'})  # remove one entry
+```
+
+## Storage backends
+
+| Extension | Backend | Notes |
+|-----------|---------|-------|
+| `.csv` | pandas CSV | Default. Human-readable. |
+| `.json` | stdlib json | No extra dependencies. |
+| `.sqlite` | stdlib sqlite3 | Best for large stores and parallel workers. |
+| `.parquet` | pandas + pyarrow | Requires `stet[parquet]`. |
+
+## Documentation
+
+Full documentation including how-to guides, API reference, and explanation of design decisions:
+
+```bash
+uv run mkdocs serve
+```

stet-0.0.1/PYPITOKEN

@@ -0,0 +1 @@
+pypi-AgEIcHlwaS5vcmcCJGJlYjRmNWE4LTUxMGYtNGYzZC05ZmNmLTlmMzNjYjQ0YzBlMgACKlszLCJjZjcxYTNlZS0zOWZiLTRiNzgtOTk3MC1jMDFhNDY1ZjQ2Y2IiXQAABiAwdw95RJ2c_tU31jur4vq-JK_FFUme19FScapJbCKjCQ

stet-0.0.1/README.md

@@ -0,0 +1,92 @@
+# stet
+
+A Python library for making parameter sweeps safely resumable.
+
+When a long-running experiment script is re-run — whether after a crash, a time limit, or deliberately to extend a sweep — `stet` automatically skips any parameter combinations that have already been completed.
+
+```python
+import stet
+
+@stet.once(store='markov_runs.csv', key=['alpha', 'n_states', 'seed'])
+def solve_markov(alpha, n_states, seed, n_iter=10_000):
+    # expensive computation
+    ...
+
+for alpha in alphas:
+    for n_states in [10, 50, 100]:
+        for seed in range(20):
+            solve_markov(alpha=alpha, n_states=n_states, seed=seed)
+```
+
+On restart, any already-completed `(alpha, n_states, seed)` combinations are skipped:
+
+```
+[once] Skipping solve_markov(alpha=0.01, n_states=10, seed=0)
+[once] Skipping solve_markov(alpha=0.01, n_states=10, seed=1)
+...
+```
+
+## Installation
+
+```bash
+uv add stet
+# or: python -m pip install stet
+```
+
+With Parquet support:
+
+```bash
+uv add stet[parquet]
+# or: python -m pip install stet[parquet]
+```
+
+## Usage
+
+**Zero config** — uses `_stet_store.csv` in the current directory, all parameters as the key:
+
+```python
+@stet.once
+def run_experiment(alpha, seed):
+    ...
+```
+
+**Named store** — backend selected from file extension (`.csv`, `.json`, `.sqlite`, `.parquet`):
+
+```python
+@stet.once(store='runs.sqlite')
+def run_experiment(alpha, seed):
+    ...
+```
+
+**Key subset** — only `alpha` and `seed` determine whether a run is skipped; `n_iter` is ignored:
+
+```python
+@stet.once(store='runs.csv', key=['alpha', 'seed'])
+def run_experiment(alpha, seed, n_iter=1000):
+    ...
+```
+
+## Utilities
+
+```python
+stet.status()            # print a summary of completed runs
+stet.reset()             # clear the store
+stet.reset(key_dict={'alpha': '0.1', 'seed': '42'})  # remove one entry
+```
+
+## Storage backends
+
+| Extension | Backend | Notes |
+|-----------|---------|-------|
+| `.csv` | pandas CSV | Default. Human-readable. |
+| `.json` | stdlib json | No extra dependencies. |
+| `.sqlite` | stdlib sqlite3 | Best for large stores and parallel workers. |
+| `.parquet` | pandas + pyarrow | Requires `stet[parquet]`. |
+
+## Documentation
+
+Full documentation including how-to guides, API reference, and explanation of design decisions:
+
+```bash
+uv run mkdocs serve
+```

stet-0.0.1/benchmarks/run_benchmarks.py

@@ -0,0 +1,175 @@
+"""Benchmark the overhead of stet across backends and store sizes."""
+
+from __future__ import annotations
+
+import statistics
+import tempfile
+import time
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import matplotlib.ticker as ticker
+
+from stet.backends._csv import CsvBackend
+from stet.backends._json import JsonBackend
+from stet.backends._sqlite import SqliteBackend
+
+try:
+    from stet.backends._parquet import ParquetBackend
+
+    HAS_PARQUET = True
+except ImportError:
+    HAS_PARQUET = False
+
+BACKENDS = {
+    "CSV": CsvBackend,
+    "JSON": JsonBackend,
+    "SQLite": SqliteBackend,
+}
+if HAS_PARQUET:
+    BACKENDS["Parquet"] = ParquetBackend  # type: ignore[assignment]
+
+EXTENSIONS = {
+    "CSV": "csv",
+    "JSON": "json",
+    "SQLite": "sqlite",
+    "Parquet": "parquet",
+}
+
+N_REPEATS = 20  # repetitions per measurement
+STORE_SIZES = [0, 10, 100, 500, 1000, 2000, 5000, 10000]
+
+
+def measure(fn, n: int = N_REPEATS) -> tuple[float, float]:
+    """Return (mean_ms, stdev_ms) over n repetitions."""
+    times = []
+    for _ in range(n):
+        t0 = time.perf_counter()
+        fn()
+        times.append((time.perf_counter() - t0) * 1000)
+    return statistics.mean(times), statistics.stdev(times)
+
+
+def bench_record(backend_cls, ext: str, n_existing: int) -> tuple[float, float]:
+    """Time a single record() call with n_existing records already present."""
+    with tempfile.TemporaryDirectory() as d:
+        path = Path(d) / f"store.{ext}"
+        b = backend_cls(path)
+        for i in range(n_existing):
+            b.record({"x": i, "y": i * 2})
+
+        counter = [n_existing]
+
+        def fn() -> None:
+            b.record({"x": counter[0], "y": counter[0] * 2})
+            counter[0] += 1
+
+        return measure(fn)
+
+
+def bench_has_hit(backend_cls, ext: str, n_existing: int) -> tuple[float, float]:
+    """Time a has() call that returns True (skip path) with n_existing records."""
+    with tempfile.TemporaryDirectory() as d:
+        path = Path(d) / f"store.{ext}"
+        b = backend_cls(path)
+        for i in range(n_existing):
+            b.record({"x": i, "y": i * 2})
+        # target: last record inserted
+        target = {"x": n_existing - 1, "y": (n_existing - 1) * 2}
+        return measure(lambda: b.has(target))
+
+
+def bench_has_miss(backend_cls, ext: str, n_existing: int) -> tuple[float, float]:
+    """Time a has() call that returns False (run path) with n_existing records."""
+    with tempfile.TemporaryDirectory() as d:
+        path = Path(d) / f"store.{ext}"
+        b = backend_cls(path)
+        for i in range(n_existing):
+            b.record({"x": i, "y": i * 2})
+        absent = {"x": 999_999, "y": 999_999}
+        return measure(lambda: b.has(absent))
+
+
+def run_scaling_benchmark() -> dict[str, dict[str, list]]:
+    """
+    For each backend, measure has() (hit and miss) and record() time
+    as store size grows.
+    """
+    results: dict[str, dict[str, list]] = {
+        name: {"sizes": [], "has_hit": [], "has_miss": [], "record": []}
+        for name in BACKENDS
+    }
+
+    for name, cls in BACKENDS.items():
+        ext = EXTENSIONS[name]
+        print(f"\n{name}")
+        for n in STORE_SIZES:
+            if n == 0 and name != "SQLite":
+                # has() on empty store is trivial; use 1 as minimum for has_hit
+                hit_mean, _ = bench_has_hit(cls, ext, max(n, 1))
+            else:
+                hit_mean, _ = bench_has_hit(cls, ext, max(n, 1))
+            miss_mean, _ = bench_has_miss(cls, ext, n)
+            rec_mean, _ = bench_record(cls, ext, n)
+            results[name]["sizes"].append(n)
+            results[name]["has_hit"].append(hit_mean)
+            results[name]["has_miss"].append(miss_mean)
+            results[name]["record"].append(rec_mean)
+            print(
+                f"  n={n:5d}  has_hit={hit_mean:.2f}ms"
+                f"  has_miss={miss_mean:.2f}ms  record={rec_mean:.2f}ms"
+            )
+
+    return results
+
+
+def plot_results(results: dict, out_dir: Path) -> None:
+    out_dir.mkdir(parents=True, exist_ok=True)
+    colors = {
+        "CSV": "#1f77b4",
+        "JSON": "#ff7f0e",
+        "SQLite": "#2ca02c",
+        "Parquet": "#d62728",
+    }
+
+    # --- Plot 1: has() scaling (skip path) ---
+    fig, ax = plt.subplots(figsize=(7, 4))
+    for name, data in results.items():
+        ax.plot(
+            data["sizes"], data["has_hit"], marker="o", label=name, color=colors[name]
+        )
+    ax.set_xlabel("Records in store")
+    ax.set_ylabel("Time (ms)")
+    ax.set_title("Skip check overhead by store size")
+    ax.legend()
+    ax.yaxis.set_minor_locator(ticker.AutoMinorLocator())
+    ax.grid(True, which="both", alpha=0.3)
+    fig.tight_layout()
+    fig.savefig(out_dir / "skip_overhead.png", dpi=150)
+    plt.close(fig)
+    print(f"\nSaved: {out_dir / 'skip_overhead.png'}")
+
+    # --- Plot 2: record() scaling ---
+    fig, ax = plt.subplots(figsize=(7, 4))
+    for name, data in results.items():
+        ax.plot(
+            data["sizes"], data["record"], marker="o", label=name, color=colors[name]
+        )
+    ax.set_xlabel("Records in store")
+    ax.set_ylabel("Time (ms)")
+    ax.set_title("Record overhead by store size")
+    ax.legend()
+    ax.yaxis.set_minor_locator(ticker.AutoMinorLocator())
+    ax.grid(True, which="both", alpha=0.3)
+    fig.tight_layout()
+    fig.savefig(out_dir / "record_overhead.png", dpi=150)
+    plt.close(fig)
+    print(f"Saved: {out_dir / 'record_overhead.png'}")
+
+
+if __name__ == "__main__":
+    print("Running benchmarks...")
+    results = run_scaling_benchmark()
+    out_dir = Path(__file__).parent.parent / "docs" / "img"
+    plot_results(results, out_dir)
+    print("\nDone.")

stet-0.0.1/docs/explanation/how-once-works.md

@@ -0,0 +1,66 @@
+# How stet Works
+
+## Parameter-keyed tracking, not memoization
+
+Traditional memoization (e.g. `functools.lru_cache`) stores the *return value* of a function so that repeated calls with the same inputs return the cached result. `stet` does something different: it tracks *which parameter combinations have been executed* and skips them on future calls — without storing return values at all.
+
+This distinction matters for experiment scripts. Researchers typically write their own outputs (CSV rows, model files, database records). What they need is not cached results, but a durable record of which experiments have already run.
+
+## How the decorator works
+
+When you write:
+
+```python
+@stet.once(store='_stet_store.csv', key=['alpha', 'beta'])
+def run_experiment(alpha, beta, n_steps):
+    ...
+```
+
+`stet` wraps `run_experiment` so that each call:
+
+1. Binds all arguments to their parameter names using `inspect.signature`.
+2. Extracts only the `key` parameters (`alpha`, `beta`).
+3. Checks the store: has this `(alpha, beta)` combination been recorded?
+4. If yes: prints a skip message and returns `None`.
+5. If no: calls the real function, then records the key parameters plus a timestamp.
+
+## Why the store is separate from your data
+
+A natural question is: why not write results directly into the store file, so there is only one file to manage?
+
+The short answer is that experiment outputs are too varied for `stet` to own them. A single experiment might produce a row in a CSV, a trained model checkpoint, a plot, entries in a database, or all of the above. There is no single file format or schema that fits every case, and any attempt to impose one would either be too restrictive or too complex to be useful.
+
+Keeping the store separate means `stet` only needs to solve the narrow problem it was designed for — *did this parameter combination run?* — and leaves the richer question of *what did it produce?* entirely to you. This also means your output files stay in whatever format your analysis tools already expect, with no `stet`-specific structure mixed in.
+
+The practical consequence is two files: a `_stet_store.csv` (or `.sqlite`, `.json`, etc.) that `stet` manages, and your own output file that your script manages. If you want to check whether a particular run completed, use `stet.status()`; if you want to inspect the results, open your output file directly.
+
+There is one failure mode worth being aware of: if your function crashes *after* writing output but *before* returning (so `stet` never records the run), the store and your output file will be out of sync. On restart `stet` will re-run that experiment. Whether that is a problem depends on your output — appending a duplicate row to a CSV is usually harmless; re-training an expensive model is not. If atomicity matters, the safest pattern is to return results from the function and write output *after* the call returns:
+
+```python
+@stet.once(store='_stet_store.csv', key=['alpha', 'seed'])
+def run_experiment(alpha, seed):
+    return expensive_computation(alpha, seed)
+
+for alpha in alphas:
+    for seed in seeds:
+        result = run_experiment(alpha=alpha, seed=seed)
+        if result is not None:   # None means the run was skipped
+            write_output(result)
+```
+
+This way `stet` records the run only after the function has completed successfully, and you write output only after `stet` has recorded it.
+
+## Backend selection
+
+The backend is selected automatically from the file extension:
+
+- `.csv` → `CsvBackend` (pandas)
+- `.parquet` → `ParquetBackend` (pandas + pyarrow)
+- `.sqlite` / `.db` → `SqliteBackend` (stdlib sqlite3)
+- `.json` → `JsonBackend` (stdlib json)
+
+All backends implement the same interface (`BaseBackend`), so they're interchangeable.
+
+## File locking
+
+`stet` uses `filelock` to acquire a file-level lock before every read or write. This ensures that concurrent processes (e.g. `multiprocessing`, `joblib`) cannot corrupt the store. The lock is released immediately after the operation.

stet-0.0.1/docs/explanation/performance.md

@@ -0,0 +1,63 @@
+# Performance
+
+The dominant cost in `stet` is store I/O — reading the store to check whether a key exists, and writing to it when recording a new run.
+
+## What was measured
+
+The benchmark calls `backend.has()` and `backend.record()` directly — it does not go through the decorator. It isolates the store I/O cost specifically, and does not include the decorator's own work (argument binding, key extraction, file lock acquisition).
+
+For each backend and a range of store sizes, we measured:
+
+- **Skip check** (`has()`) — the time to look up a key that is present in the store.
+- **Record** (`record()`) — the time to write a new entry to the store.
+
+Each measurement is the mean of 20 repetitions. Store entries each had two key columns (`x`, `y`).
+
+### Environment
+
+| | |
+|---|---|
+| Machine | Apple M2, 16 GB RAM |
+| OS | macOS (darwin arm64) |
+| Python | 3.14.0 |
+| pandas | 3.0.1 |
+| pyarrow | 23.0.1 |
+| filelock | 3.25.1 |
+| Store sizes tested | 0, 10, 100, 500, 1000, 2000, 5000, 10000 records |
+
+Results on different hardware will vary, but the relative shape — SQLite staying flat, file-based backends growing linearly — holds regardless of machine.
+
+## Results
+
+### Skip check overhead
+
+![Skip check overhead by store size](../img/skip_overhead.png)
+
+### Record overhead
+
+![Record overhead by store size](../img/record_overhead.png)
+
+## What the numbers mean
+
+**SQLite is the only backend that stays flat.** Its skip check and record time are essentially constant (~0.3–0.6 ms) regardless of how many records are in the store. This is because SQLite uses a B-tree index for lookups and writes are transactional.
+
+**CSV, JSON, and Parquet all read the entire file on every operation.** Their overhead grows with store size because checking whether a key exists requires loading all existing records first. At 10,000 records, CSV and JSON skip checks take ~6 ms each; JSON record writes reach ~23 ms because the whole file is rewritten on every call.
+
+**Parquet has a higher fixed cost than CSV or JSON at small sizes** (~1 ms at 10 records vs ~0.6 ms) due to the cost of parsing the binary format, but it scales more gently than JSON at larger sizes (~3.8 ms record writes at 10,000 records vs ~23 ms for JSON).
+
+## Practical guidance
+
+For most experiment sweeps the overhead is negligible — a skip check under 1 ms is undetectable against any function that does real work. But it becomes relevant in two situations:
+
+- **Very fast functions** (sub-millisecond): the overhead can dominate. Consider batching or restructuring so that `stet` wraps a coarser unit of work.
+- **Very large stores with file-based backends**: at 5,000+ records, CSV and JSON become noticeably slow. Switch to SQLite if your store will grow large, especially in combination with parallel workers (see [Use with Multiprocessing](../how-to/use-with-multiprocessing.md)).
+
+## Reproducing these results
+
+The benchmarking script lives at `benchmarks/run_benchmarks.py`:
+
+```
+$ uv run python benchmarks/run_benchmarks.py
+```
+
+It re-generates the plots in `docs/img/`.

stet-0.0.1/docs/explanation/related-libraries.md

@@ -0,0 +1,33 @@
+# How `stet` relates to similar libraries
+
+Several Python libraries solve adjacent problems to `stet`. Understanding how they differ clarifies what `stet` is for and why it makes the design choices it does.
+
+## `joblib.Memory`
+
+`joblib.Memory` is the most widely used tool in this space. It wraps a function so that the return value is persisted to disk on the first call and returned from the cache on subsequent identical calls — standard memoization, made durable across processes and restarts.
+
+Because `joblib.Memory` stores return values, its storage is opaque: results live as pickle files in a nested directory structure not meant to be read by anything other than `joblib` itself. There is no way to open the cache in a spreadsheet, query it with SQL, or inspect it with standard tools. It also stores everything the function returns, which can mean large files for functions that return arrays or models.
+
+It also has no concept of a key subset. The cache key is the full set of arguments; there is no way to say "these parameters define the experiment identity, but this one is just a computational setting". For research workflows where you want to vary convergence tolerances or iteration counts without invalidating cached results, this is a significant constraint.
+
+`stet` is not trying to replace `joblib.Memory` — it is solving a different problem.
+
+## `checkpointing`
+
+The `checkpointing` package (PyPI) is a decorator that caches return values as pickle files and skips re-execution for identical arguments, with configurable behaviour on errors. Its intent and API are close to `joblib.Memory`: persist outputs, skip re-computation.
+
+The same differences apply. Storage is not human-readable or queryable, return values are always persisted, and there is no user-defined key subset. It adds some useful error-handling flexibility that `joblib.Memory` lacks, but the underlying model — cache the output, look it up on re-call — is the same.
+
+## `checkpointer`
+
+`checkpointer` (PyPI) is a more sophisticated decorator focused on *cache correctness*. It can detect when the decorated function's source code or dependencies have changed and invalidate the cache accordingly. It also supports async functions and robust hashing of complex objects such as NumPy arrays and PyTorch tensors.
+
+This solves a different problem. The question `checkpointer` answers is: *is this cached result still valid given that the code may have changed?* The question `stet` answers is: *has this parameter combination been run before?* For a researcher running a fixed parameter sweep across sessions, code-aware invalidation is not needed — and the overhead of hashing complex objects would add cost to every call.
+
+## `memento` (wickerlab)
+
+`memento` is the closest in intent to `stet`. It is explicitly designed for researchers running expensive experiments over a parameter grid, with built-in parallelisation and result caching.
+
+The key difference is that `memento` is workflow-prescriptive. You define your parameter grid upfront as a configuration object and pass it to `Memento.run()`, which handles iteration and parallelisation. This requires structuring your experiment around `memento`'s API.
+
+`stet` takes the opposite position: it is workflow-neutral. You decorate your function and loop over parameters however you already do — a `for` loop, a list comprehension, a call from a notebook cell, a parallel map. The decorator fits into existing code without restructuring it, and composes with whatever parallelisation approach you already use.