labnotes 0.0.19__tar.gz → 0.0.21__tar.gz

{labnotes-0.0.19 → labnotes-0.0.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.0.19
+Version: 0.0.21
 Summary: Browse experiment designs, notes, and run data from a folder.
 Project-URL: Repository, https://github.com/thekevinscott/labnotes
 Author-email: Kevin Scott <me@thekevinscott.com>
@@ -14,7 +14,6 @@ Requires-Dist: ipykernel>=7.4.0
 Requires-Dist: jinja2>=3.1.6
 Requires-Dist: jupyter-client>=8.10.0
 Requires-Dist: markdown-it-py>=4.2.0
-Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: rich>=14
 Requires-Dist: starlette>=1.8.0
 Requires-Dist: textual>=8.2.8
@@ -114,29 +113,18 @@ line per event instead.
 - A second `run` of the same experiment fails while the first holds the lock.
 - It exits 1 if any run failed.
 
-`labnotes server` doesn't read `.labnotes.toml` yet. Give it the two folders
-it uses with `--experiments-folder` and `--data-folder`:
-
-- `--experiments-folder` holds one subfolder per experiment, each with a
-  `design.yaml` (with a `study` key) and any number of markdown notes.
-- `--data-folder` holds the run data and a `.dirsql.toml` that declares a
-  `runs` table with a `study` column. An experiment's runs are the rows whose
-  `study` matches its design's.
-
-That serves a local site at http://127.0.0.1:8000: a table of experiments,
-and a page per experiment with its parameters, its notes, progress per cell of
-the design grid, and every run so far. Both folders are watched, so a reload
-shows new runs and edited notes.
-
-`design.yaml` keys the site reads: `study`, `fixed`, `varies` (each key a list
-of values), `runs_per_cell`, and `completed_run`, a SQL condition over the
-`runs` table that marks a run as complete. Anything else shows up as-is.
+`labnotes server` serves a local site at http://127.0.0.1:8000 from the same
+`.labnotes.toml`: a table of experiments, and a page per experiment with its
+params, its markdown files, progress per cell of the params grid, and every
+run so far. A cell is full once it has `repeats` runs that exited 0 and aren't
+excluded, the same count `run` uses. The project is watched, so a reload shows
+new runs and edited notes. Python blocks in a note run with the root as the
+working folder.
 
 `-h`/`--host` and `-p`/`--port` change where it listens; `-h 0.0.0.0` (or a
 Tailscale IP) serves beyond localhost. Every other uvicorn option passes
 through: `--reload`, `--workers`, `--proxy-headers`, `--root-path`, the
-`--ssl-*` set, and the rest. `labnotes server --help` lists them. `LABNOTES_EXPERIMENTS_FOLDER` and
-`LABNOTES_DATA_FOLDER` can stand in for the folder flags.
+`--ssl-*` set, and the rest. `labnotes server --help` lists them.
 
 ## Agent skill
 

{labnotes-0.0.19 → labnotes-0.0.21}/README.md

@@ -91,29 +91,18 @@ line per event instead.
 - A second `run` of the same experiment fails while the first holds the lock.
 - It exits 1 if any run failed.
 
-`labnotes server` doesn't read `.labnotes.toml` yet. Give it the two folders
-it uses with `--experiments-folder` and `--data-folder`:
-
-- `--experiments-folder` holds one subfolder per experiment, each with a
-  `design.yaml` (with a `study` key) and any number of markdown notes.
-- `--data-folder` holds the run data and a `.dirsql.toml` that declares a
-  `runs` table with a `study` column. An experiment's runs are the rows whose
-  `study` matches its design's.
-
-That serves a local site at http://127.0.0.1:8000: a table of experiments,
-and a page per experiment with its parameters, its notes, progress per cell of
-the design grid, and every run so far. Both folders are watched, so a reload
-shows new runs and edited notes.
-
-`design.yaml` keys the site reads: `study`, `fixed`, `varies` (each key a list
-of values), `runs_per_cell`, and `completed_run`, a SQL condition over the
-`runs` table that marks a run as complete. Anything else shows up as-is.
+`labnotes server` serves a local site at http://127.0.0.1:8000 from the same
+`.labnotes.toml`: a table of experiments, and a page per experiment with its
+params, its markdown files, progress per cell of the params grid, and every
+run so far. A cell is full once it has `repeats` runs that exited 0 and aren't
+excluded, the same count `run` uses. The project is watched, so a reload shows
+new runs and edited notes. Python blocks in a note run with the root as the
+working folder.
 
 `-h`/`--host` and `-p`/`--port` change where it listens; `-h 0.0.0.0` (or a
 Tailscale IP) serves beyond localhost. Every other uvicorn option passes
 through: `--reload`, `--workers`, `--proxy-headers`, `--root-path`, the
-`--ssl-*` set, and the rest. `labnotes server --help` lists them. `LABNOTES_EXPERIMENTS_FOLDER` and
-`LABNOTES_DATA_FOLDER` can stand in for the folder flags.
+`--ssl-*` set, and the rest. `labnotes server --help` lists them.
 
 ## Agent skill
 

{labnotes-0.0.19 → labnotes-0.0.21}/pyproject.toml

@@ -19,7 +19,6 @@ dependencies = [
     "jinja2>=3.1.6",
     "jupyter-client>=8.10.0",
     "markdown-it-py>=4.2.0",
-    "pyyaml>=6.0.3",
     "rich>=14",
     "starlette>=1.8.0",
     "textual>=8.2.8",
@@ -38,7 +37,6 @@ dev = [
     "mypy>=2.4.0",
     "pytest>=8.0",
     "ruff==0.8.4",
-    "types-pyyaml>=6.0.12.20260906",
 ]
 
 [tool.hatch.version]

{labnotes-0.0.19 → labnotes-0.0.21}/src/labnotes/context.md

@@ -73,7 +73,8 @@ A script run by labnotes should:
 
 - take each param as a `--name value` flag, parsing lists and tables from JSON;
 - take its output folder as an argument, passed in `command` as `{run_dir}`, and write everything it produces there;
-- exit non-zero when it fails, so the run counts as failed and runs again next time.
+- exit non-zero when it fails, so the run counts as failed and runs again next time;
+- stop any background process it starts before it exits; the run ends when `command` exits.
 
 Runs can take a long time. Start `run` in the background, then check on it with `labnotes experiments foo runs`; a run with no `ended` is still going.
 
@@ -89,12 +90,4 @@ line per event instead.
 - A second `run` of the same experiment fails while the first holds the lock.
 - It exits 1 if any run failed.
 
-`labnotes server` doesn't read `.labnotes.toml` yet: pass `--experiments-folder` and `--data-folder`, or set `LABNOTES_EXPERIMENTS_FOLDER` and `LABNOTES_DATA_FOLDER`. The experiments folder has one subfolder per experiment, each with a `design.yaml` and markdown notes. The data folder holds run data and a `.dirsql.toml` declaring a `runs` table with a `study` column.
-
-The run data lives in the data folder. Query it with [dirsql](https://dirsql.dev) and the data folder's `.dirsql.toml`, which declares the `runs` table:
-
-```sh
-uvx dirsql -c data/.dirsql.toml "SELECT * FROM runs LIMIT 1" --format json
-```
-
-`uvx labnotes server` serves the experiments and their runs as a local site.
+`uvx labnotes server` serves the experiments, their markdown files and their runs as a local site, read from the same `.labnotes.toml`. A grid cell is full once it has `repeats` runs that exited 0 and aren't excluded.

{labnotes-0.0.19 → labnotes-0.0.21}/src/labnotes/create_app.py

@@ -14,17 +14,17 @@ from starlette.templating import Jinja2Templates
 
 from labnotes.asset_url import asset_url
 from labnotes.drain_watch import drain_watch
+from labnotes.experiment_notes import experiment_notes
 from labnotes.format_value import format_value
 from labnotes.list_experiments import list_experiments
 from labnotes.load_experiment import load_experiment
+from labnotes.models import LabnotesConfig
 from labnotes.notebook_kernel import NotebookKernel
-from labnotes.open_experiments import open_experiments
-from labnotes.open_runs import open_runs
 from labnotes.pivot_cells import pivot_cells
 from labnotes.python_blocks import python_blocks
 from labnotes.saved_outputs import saved_outputs
-from labnotes.sql_quote import quote_string
 from labnotes.stop_idle_kernels import stop_idle_kernels
+from labnotes.tables.open_tables import open_tables
 
 HERE = Path(__file__).parent
 templates = Jinja2Templates(directory=HERE / "templates")
@@ -32,20 +32,15 @@ templates.env.filters["value"] = format_value
 templates.env.globals["asset"] = asset_url
 
 
-def create_app(
-    experiments_folder: Path, data_folder: Path, kernel_idle_minutes: float
-) -> Starlette:
+def create_app(config: LabnotesConfig, kernel_idle_minutes: float) -> Starlette:
     kernels: dict[tuple[str, str], NotebookKernel] = {}
 
     @asynccontextmanager
     async def lifespan(app: Starlette) -> AsyncIterator[None]:
-        app.state.experiments = open_experiments(experiments_folder)
-        app.state.runs = open_runs(data_folder)
-        await app.state.experiments.ready()
-        await app.state.runs.ready()
+        app.state.tables = open_tables(config)
+        await app.state.tables.ready()
         watchers = [
-            asyncio.create_task(drain_watch(app.state.experiments)),
-            asyncio.create_task(drain_watch(app.state.runs)),
+            asyncio.create_task(drain_watch(app.state.tables)),
             asyncio.create_task(stop_idle_kernels(kernels, kernel_idle_minutes)),
         ]
         yield
@@ -55,20 +50,18 @@ def create_app(
             await kernel.stop()
 
     async def index(request: Request) -> Response:
-        state = request.app.state
-        experiments = await list_experiments(state.experiments, state.runs)
+        experiments = await list_experiments(request.app.state.tables)
         return templates.TemplateResponse(
             request,
             "index.html",
-            {"experiments": experiments, "folder": experiments_folder.resolve().name},
+            {"experiments": experiments, "folder": config.root.name},
         )
 
     async def experiment(request: Request) -> Response:
-        state = request.app.state
         name = request.path_params["name"]
         loaded = await load_experiment(
-            state.experiments,
-            state.runs,
+            request.app.state.tables,
+            config.root,
             name,
             request.query_params,
             lambda note, content: saved_outputs(kernels.get((name, note)), content),
@@ -88,14 +81,13 @@ def create_app(
             raise HTTPException(415, "Send JSON")
         name = request.path_params["name"]
         note = request.path_params["note"]
-        found = await request.app.state.experiments.query(
-            "SELECT content FROM notes"
-            f" WHERE experiment = {quote_string(name)} AND name = {quote_string(note)}"
+        found = await experiment_notes(
+            request.app.state.tables, config.root, name, note
         )
         if not found:
             raise HTTPException(404, "No such note")
-        [row] = found
-        return str(row["content"])
+        [note] = found
+        return note["content"]
 
     async def run_block(request: Request) -> Response:
         blocks = python_blocks(await note_content(request))
@@ -104,7 +96,7 @@ def create_app(
         if not isinstance(block, int) or not 0 <= block < len(blocks):
             raise HTTPException(400, "No such block")
         if key not in kernels:
-            kernels[key] = NotebookKernel(data_folder)
+            kernels[key] = NotebookKernel(config.root)
         return HTMLResponse(await kernels[key].run(blocks[block]))
 
     async def restart_kernel(request: Request) -> Response:
@@ -118,9 +110,13 @@ def create_app(
         routes=[
             Route("/", index),
             Route("/experiments/{name}", experiment),
-            Route("/experiments/{name}/notes/{note}/run", run_block, methods=["POST"]),
             Route(
-                "/experiments/{name}/notes/{note}/restart",
+                "/experiments/{name}/notes/{note:path}/run",
+                run_block,
+                methods=["POST"],
+            ),
+            Route(
+                "/experiments/{name}/notes/{note:path}/restart",
                 restart_kernel,
                 methods=["POST"],
             ),

labnotes-0.0.21/src/labnotes/experiment_notes.py

@@ -0,0 +1,23 @@
+from pathlib import Path
+
+from dirsql import DirSQL
+
+from labnotes.sql_quote import quote_string
+
+
+async def experiment_notes(
+    tables: DirSQL, root: Path, experiment: str, note: str | None = None
+) -> list[dict[str, str]]:
+    where = f"experiment = {quote_string(experiment)} AND filename LIKE '%.md'"
+    if note is not None:
+        where += f" AND filename = {quote_string(note)}"
+    rows = await tables.query(
+        f"SELECT filename, path FROM files WHERE {where} ORDER BY filename"
+    )
+    return [
+        {
+            "name": str(row["filename"]),
+            "content": (root / str(row["path"])).read_text(encoding="utf-8"),
+        }
+        for row in rows
+    ]

labnotes-0.0.21/src/labnotes/experiment_progress.py

@@ -0,0 +1,25 @@
+from typing import cast
+
+from dirsql import DirSQL
+
+from labnotes.cell_progress import cell_progress
+from labnotes.count_runs import count_runs
+
+
+async def experiment_progress(
+    tables: DirSQL, source: str, summary: dict[str, object]
+) -> dict[str, object]:
+    varies = cast(dict[str, list[object]], summary["varies"])
+    completed_run = str(summary["completed_run"])
+    runs_per_cell = summary["runs_per_cell"]
+    [totals] = await count_runs(tables, source, completed_run)
+    progress: dict[str, object] = {**totals, "filled": None, "cells": []}
+    if runs_per_cell is None:
+        return progress
+    grouped = await count_runs(tables, source, completed_run, group_by=list(varies))
+    cells = cell_progress(varies, grouped)
+    progress["cells"] = cells
+    progress["filled"] = sum(
+        min(cast(int, cell["completed"]), cast(int, runs_per_cell)) for cell in cells
+    )
+    return progress

labnotes-0.0.21/src/labnotes/experiment_runs.py

@@ -0,0 +1,13 @@
+from labnotes.sql_quote import quote_identifier, quote_string
+
+
+def experiment_runs(experiment: str, params: list[str]) -> str:
+    columns = "".join(
+        f", params ->> {quote_string(f'$.{quote_identifier(key)}')}"
+        f" AS {quote_identifier(key)}"
+        for key in params
+    )
+    return (
+        f"(SELECT *{columns} FROM runs"
+        f" WHERE experiment = {quote_string(experiment)})"
+    )

labnotes-0.0.21/src/labnotes/list_experiments.py

@@ -0,0 +1,26 @@
+import json
+from typing import cast
+
+from dirsql import DirSQL
+
+from labnotes.experiment_progress import experiment_progress
+from labnotes.experiment_runs import experiment_runs
+from labnotes.summarize_config import summarize_config
+
+
+async def list_experiments(tables: DirSQL) -> list[dict[str, object]]:
+    rows = await tables.query(
+        "SELECT name, display_name, config FROM experiments ORDER BY name"
+    )
+    listed = []
+    for row in rows:
+        name = str(row["name"])
+        config = None if row["config"] is None else json.loads(str(row["config"]))
+        summary = summarize_config(config)
+        varies = cast(dict[str, list[object]], summary["varies"])
+        source = experiment_runs(name, list(varies))
+        progress = await experiment_progress(tables, source, summary)
+        listed.append(
+            {"name": name, "display_name": row["display_name"], **summary, **progress}
+        )
+    return listed

{labnotes-0.0.19 → labnotes-0.0.21}/src/labnotes/list_runs.py

@@ -23,7 +23,7 @@ async def list_runs(
     elif view.sort:
         order = f"{quote_identifier(view.sort)} {direction}"
     else:
-        order = "2 DESC"
+        order = "created DESC, id DESC"
     return await runs.query(
         f"SELECT ({completed_run}) AS labnotes_completed, * FROM {source}"
         f"{filtered} ORDER BY {order}"

{labnotes-0.0.19 → labnotes-0.0.21}/src/labnotes/load_experiment.py

@@ -1,19 +1,20 @@
 import json
 from collections.abc import Callable, Mapping, Sequence
+from pathlib import Path
 from typing import cast
 
 from dirsql import DirSQL
 
+from labnotes.experiment_notes import experiment_notes
+from labnotes.experiment_progress import experiment_progress
+from labnotes.experiment_runs import experiment_runs
 from labnotes.list_runs import list_runs
 from labnotes.parse_run_view import parse_run_view
 from labnotes.python_blocks import python_blocks
 from labnotes.render_markdown import render_markdown
-from labnotes.run_columns import run_columns
 from labnotes.sort_href import sort_href
 from labnotes.sql_quote import quote_string
-from labnotes.study_progress import study_progress
-from labnotes.study_runs import study_runs
-from labnotes.summarize_design import summarize_design
+from labnotes.summarize_config import summarize_config
 
 
 def _no_outputs(note: str, content: str) -> Sequence[str]:
@@ -21,53 +22,45 @@ def _no_outputs(note: str, content: str) -> Sequence[str]:
 
 
 async def load_experiment(
-    experiments: DirSQL,
-    runs: DirSQL,
+    tables: DirSQL,
+    root: Path,
     name: str,
     params: Mapping[str, str],
     outputs_for: Callable[[str, str], Sequence[str]] = _no_outputs,
 ) -> dict[str, object] | None:
-    found = await experiments.query(
-        f"SELECT name, study, design FROM experiments WHERE name = {quote_string(name)}"
+    found = await tables.query(
+        "SELECT name, display_name, config FROM experiments"
+        f" WHERE name = {quote_string(name)}"
     )
     if not found:
         return None
     [row] = found
-    notes = await experiments.query(
-        "SELECT name, content FROM notes"
-        f" WHERE experiment = {quote_string(name)} ORDER BY name"
-    )
-    summary = summarize_design(json.loads(str(row["design"])))
+    config = None if row["config"] is None else json.loads(str(row["config"]))
+    summary = summarize_config(config)
     varies = cast(dict[str, list[object]], summary["varies"])
-    study = None if row["study"] is None else str(row["study"])
-    columns = await run_columns(runs)
-    progress = await study_progress(runs, study, summary, columns)
-    shown = columns[:1] + [key for key in varies if key in columns[1:]]
+    source = experiment_runs(name, list(varies))
+    progress = await experiment_progress(tables, source, summary)
+    shown = ["id", *(key for key in varies if key != "id")]
     view = parse_run_view(params, shown)
-    listed = (
-        []
-        if study is None
-        else await list_runs(
-            runs, study_runs(study), str(summary["completed_run"]), view
-        )
-    )
+    notes = await experiment_notes(tables, root, name)
     return {
         "name": row["name"],
-        "study": study,
+        "display_name": row["display_name"],
         **summary,
         **progress,
         "notes": [
             {
                 "name": note["name"],
                 "html": render_markdown(
-                    str(note["content"]),
-                    outputs_for(str(note["name"]), str(note["content"])),
+                    note["content"], outputs_for(note["name"], note["content"])
                 ),
-                "runnable": bool(python_blocks(str(note["content"]))),
+                "runnable": bool(python_blocks(note["content"])),
             }
             for note in notes
         ],
-        "runs_list": listed,
+        "runs_list": await list_runs(
+            tables, source, str(summary["completed_run"]), view
+        ),
         "run_columns": shown,
         "run_view": view,
         "sort_hrefs": {

{labnotes-0.0.19 → labnotes-0.0.21}/src/labnotes/runner/execute_run.py

@@ -3,6 +3,7 @@ import time
 from pathlib import Path
 
 from labnotes.runner.shell_command import shell_command
+from labnotes.runner.wait_for_group import wait_for_group
 from labnotes.runner.write_run_json import write_run_json
 from labnotes.tables.iso_time import iso_time
 
@@ -13,6 +14,7 @@ async def execute_run(
     command: str,
     params: dict[str, object],
     running: set[asyncio.subprocess.Process],
+    stopping: asyncio.Event,
 ) -> dict[str, object]:
     run: dict[str, object] = {
         "params": params,
@@ -42,6 +44,11 @@ async def execute_run(
             running.add(process)
             try:
                 run["exit_code"] = await process.wait()
+                # The shell can exit on SIGTERM before what it started. Once
+                # stopping, the run stays killable until its whole group is
+                # gone. A normal exit ends the run even if helpers linger.
+                if stopping.is_set():
+                    await wait_for_group(process.pid)
             finally:
                 running.discard(process)
     run["ended"] = iso_time(time.time())

{labnotes-0.0.19 → labnotes-0.0.21}/src/labnotes/runner/run_experiment.py

@@ -32,7 +32,7 @@ async def run_experiment(
     report({"event": "planned", "runs": len(plan), "concurrency": concurrency})
     running: set[asyncio.subprocess.Process] = set()
     results: list[dict[str, object]] = []
-    stopping = False
+    stopping = asyncio.Event()
 
     def signal_runs(signal_number: int) -> None:
         for process in running:
@@ -40,10 +40,9 @@ async def run_experiment(
                 os.killpg(process.pid, signal_number)
 
     def interrupt() -> None:
-        nonlocal stopping
         plan.clear()
-        if not stopping:
-            stopping = True
+        if not stopping.is_set():
+            stopping.set()
             report({"event": "stopping"})
             signal_runs(signal.SIGTERM)
         elif running:
@@ -60,7 +59,7 @@ async def run_experiment(
             folder.mkdir(parents=True)
             report({"event": "started", "run": run, "params": params})
             result = await execute_run(
-                config.root, folder, experiment.command, params, running
+                config.root, folder, experiment.command, params, running, stopping
             )
             report({"event": "ended", "run": run, **result})
             results.append(result)

labnotes-0.0.21/src/labnotes/runner/wait_for_group.py

@@ -0,0 +1,11 @@
+import asyncio
+import os
+
+
+async def wait_for_group(group: int) -> None:
+    while True:
+        try:
+            os.killpg(group, 0)
+        except ProcessLookupError:
+            return
+        await asyncio.sleep(0.1)

{labnotes-0.0.19 → labnotes-0.0.21}/src/labnotes/serve_app.py

@@ -4,15 +4,13 @@ from pathlib import Path
 from starlette.applications import Starlette
 
 from labnotes.create_app import create_app
+from labnotes.read_config import read_config
 
-EXPERIMENTS_FOLDER = "LABNOTES_EXPERIMENTS_FOLDER"
-DATA_FOLDER = "LABNOTES_DATA_FOLDER"
+CONFIG = "LABNOTES_CONFIG"
 KERNEL_IDLE_MINUTES = "LABNOTES_KERNEL_IDLE_MINUTES"
 
 
 def serve_app() -> Starlette:
     return create_app(
-        Path(os.environ[EXPERIMENTS_FOLDER]),
-        Path(os.environ[DATA_FOLDER]),
-        int(os.environ[KERNEL_IDLE_MINUTES]),
+        read_config(Path(os.environ[CONFIG])), int(os.environ[KERNEL_IDLE_MINUTES])
     )

{labnotes-0.0.19 → labnotes-0.0.21}/src/labnotes/server.py

@@ -1,29 +1,18 @@
 import os
-from pathlib import Path
 
 import click
 from uvicorn.main import main as uvicorn_main
 
-from labnotes.serve_app import DATA_FOLDER, EXPERIMENTS_FOLDER, KERNEL_IDLE_MINUTES
+from labnotes.load_config import load_config
+from labnotes.read_config import CONFIG_FILE
+from labnotes.serve_app import CONFIG, KERNEL_IDLE_MINUTES
 
 # labnotes owns these; the rest of uvicorn's options pass straight through.
 OWN_OPTIONS = {"app", "factory", "app_dir", "version", "host", "port"}
 
 
-@click.command(help="Serve the experiments and their run data as a local site.")
-@click.option(
-    "--experiments-folder",
-    type=click.Path(path_type=Path),
-    envvar=EXPERIMENTS_FOLDER,
-    required=True,
-    help="One subfolder per experiment, each with a design.yaml and markdown notes.",
-)
-@click.option(
-    "--data-folder",
-    type=click.Path(path_type=Path),
-    envvar=DATA_FOLDER,
-    required=True,
-    help="Run data, with a .dirsql.toml declaring a runs table that has a study column.",
+@click.command(
+    help="Serve the experiments, their notes and their runs as a local site."
 )
 @click.option(
     "--kernel-idle-minutes",
@@ -44,14 +33,16 @@ OWN_OPTIONS = {"app", "factory", "app_dir", "version", "host", "port"}
 @click.pass_context
 def server(
     ctx: click.Context,
-    experiments_folder: Path,
-    data_folder: Path,
     kernel_idle_minutes: int,
     **server_options: object,
 ) -> None:
+    config = load_config(ctx)
+    if config is None:
+        raise click.ClickException(
+            f"No {CONFIG_FILE} here. Run labnotes init, or pass -c PATH."
+        )
     # Through the environment so --reload and --workers child processes see them.
-    os.environ[EXPERIMENTS_FOLDER] = str(experiments_folder.resolve())
-    os.environ[DATA_FOLDER] = str(data_folder.resolve())
+    os.environ[CONFIG] = str(config.path.resolve())
     os.environ[KERNEL_IDLE_MINUTES] = str(kernel_idle_minutes)
     ctx.invoke(
         uvicorn_main,

labnotes-0.0.21/src/labnotes/summarize_config.py

@@ -0,0 +1,26 @@
+from math import prod
+
+# What the runner counts toward repeats.
+COMPLETED_RUN = "exit_code = 0 AND NOT coalesce(excluded, 0)"
+
+
+def summarize_config(config: dict[str, object] | None) -> dict[str, object]:
+    config = config or {}
+    params = config.get("params")
+    varies = {
+        key: values if isinstance(values, list) else [values]
+        for key, values in (params if isinstance(params, dict) else {}).items()
+    }
+    repeats = config.get("repeats", 1) if config else None
+    repeats = repeats if isinstance(repeats, int) else None
+    cells = prod(len(values) for values in varies.values())
+    command = config.get("command")
+    return {
+        "fixed": {},
+        "varies": varies,
+        "cell_count": cells,
+        "runs_per_cell": repeats,
+        "target": cells * repeats if repeats is not None else None,
+        "completed_run": COMPLETED_RUN,
+        "other": {} if command is None else {"command": command},
+    }