labnotes 0.0.18__tar.gz → 0.0.20__tar.gz

{labnotes-0.0.18 → labnotes-0.0.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.0.18
+Version: 0.0.20
 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
@@ -98,6 +97,9 @@ Each param is appended as `--name value`, with the name as written (use
 `source-language` for a `--source-language` flag), booleans as 0 or 1, and lists
 and tables as JSON. labnotes writes `run.json` (params, created, ended, exit
 code), `stdout.log` and `stderr.log` to the run folder.
+To exclude a run, add `"excluded": true` and an optional `"reason"` to its
+`run.json`. An excluded run doesn't count toward `repeats`, so the next `run`
+replaces it; both show as columns in `runs`.
 
 In a terminal, `run` shows a live table of runs (status and time) and stays
 open when they finish; `q` quits. Elsewhere, or with `--no-tui`, it prints a
@@ -111,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.18 → labnotes-0.0.20}/README.md

@@ -75,6 +75,9 @@ Each param is appended as `--name value`, with the name as written (use
 `source-language` for a `--source-language` flag), booleans as 0 or 1, and lists
 and tables as JSON. labnotes writes `run.json` (params, created, ended, exit
 code), `stdout.log` and `stderr.log` to the run folder.
+To exclude a run, add `"excluded": true` and an optional `"reason"` to its
+`run.json`. An excluded run doesn't count toward `repeats`, so the next `run`
+replaces it; both show as columns in `runs`.
 
 In a terminal, `run` shows a live table of runs (status and time) and stays
 open when they finish; `q` quits. Elsewhere, or with `--no-tui`, it prints a
@@ -88,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.18 → labnotes-0.0.20}/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.18 → labnotes-0.0.20}/src/labnotes/context.md

@@ -65,6 +65,9 @@ Each param is appended as `--name value`, with the name as written (use
 `source-language` for a `--source-language` flag), booleans as 0 or 1, and lists
 and tables as JSON. labnotes writes `run.json` (params, created, ended, exit
 code), `stdout.log` and `stderr.log` to the run folder.
+To exclude a run, add `"excluded": true` and an optional `"reason"` to its
+`run.json`. An excluded run doesn't count toward `repeats`, so the next `run`
+replaces it; both show as columns in `runs`.
 
 A script run by labnotes should:
 
@@ -86,12 +89,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.18 → labnotes-0.0.20}/src/labnotes/count_runs.py

@@ -1,10 +1,10 @@
 from dirsql import DirSQL
 
-from labnotes.sql_quote import quote_identifier, quote_string
+from labnotes.sql_quote import quote_identifier
 
 
 async def count_runs(
-    runs: DirSQL, study: str, completed_run: str, group_by: list[str] | None = None
+    runs: DirSQL, source: str, completed_run: str, group_by: list[str] | None = None
 ) -> list[dict[str, object]]:
     keys = [quote_identifier(key) for key in group_by or []]
     columns = "".join(f"{key}, " for key in keys)
@@ -12,5 +12,5 @@ async def count_runs(
     return await runs.query(
         f"SELECT {columns}COUNT(*) AS runs,"
         f" COALESCE(SUM(CASE WHEN ({completed_run}) THEN 1 ELSE 0 END), 0) AS completed"
-        f" FROM runs WHERE study = {quote_string(study)}{group}"
+        f" FROM {source}{group}"
     )

{labnotes-0.0.18 → labnotes-0.0.20}/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.20/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.20/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.20/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.20/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.18 → labnotes-0.0.20}/src/labnotes/list_runs.py

@@ -5,9 +5,9 @@ from labnotes.sql_quote import quote_identifier, quote_string
 
 
 async def list_runs(
-    runs: DirSQL, study: str, completed_run: str, view: RunView
+    runs: DirSQL, source: str, completed_run: str, view: RunView
 ) -> list[dict[str, object]]:
-    where = [f"study = {quote_string(study)}"]
+    where = []
     if view.status:
         negate = {"complete": "", "incomplete": "NOT "}[view.status]
         where.append(f"{negate}({completed_run})")
@@ -16,14 +16,15 @@ async def list_runs(
         f" lower({quote_string(value)})) > 0"
         for column, value in view.filters.items()
     ]
+    filtered = f" WHERE {' AND '.join(where)}" if where else ""
     direction = "DESC" if view.descending else "ASC"
     if view.sort == "status":
         order = f"labnotes_completed {direction}"
     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 runs"
-        f" WHERE {' AND '.join(where)} ORDER BY {order}"
+        f"SELECT ({completed_run}) AS labnotes_completed, * FROM {source}"
+        f"{filtered} ORDER BY {order}"
     )

{labnotes-0.0.18 → labnotes-0.0.20}/src/labnotes/load_experiment.py

@@ -1,18 +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.summarize_design import summarize_design
+from labnotes.summarize_config import summarize_config
 
 
 def _no_outputs(note: str, content: str) -> Sequence[str]:
@@ -20,51 +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, 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.18 → labnotes-0.0.20}/src/labnotes/runner/run_experiment.py

@@ -23,7 +23,11 @@ async def run_experiment(
     listen: Listen,
 ) -> list[dict[str, object]]:
     runs = await list_experiment_runs(open_tables(config), name)
-    finished = [json.loads(str(run["params"])) for run in runs if run["exit_code"] == 0]
+    finished = [
+        json.loads(str(run["params"]))
+        for run in runs
+        if run["exit_code"] == 0 and not run["excluded"]
+    ]
     plan = plan_runs(param_grid(experiment.params), experiment.repeats, finished)
     report({"event": "planned", "runs": len(plan), "concurrency": concurrency})
     running: set[asyncio.subprocess.Process] = set()

{labnotes-0.0.18 → labnotes-0.0.20}/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.18 → labnotes-0.0.20}/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.20/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},
+    }

{labnotes-0.0.18 → labnotes-0.0.20}/src/labnotes/tables/list_experiment_runs.py

@@ -5,6 +5,7 @@ from labnotes.sql_quote import quote_string
 
 async def list_experiment_runs(tables: DirSQL, name: str) -> list[dict[str, object]]:
     return await tables.query(
-        "SELECT id, created, ended, exit_code, error, params, folder FROM runs"
+        "SELECT id, created, ended, exit_code, error, excluded, reason, params, folder"
+        " FROM runs"
         f" WHERE experiment = {quote_string(name)} ORDER BY created, id"
     )

{labnotes-0.0.18 → labnotes-0.0.20}/src/labnotes/tables/open_tables.py

@@ -31,7 +31,8 @@ CREATE TABLE files (
 RUNS = """
 CREATE TABLE runs (
   experiment TEXT, id TEXT, folder TEXT, created TEXT, ended TEXT,
-  exit_code INTEGER, error TEXT, stdout TEXT, stderr TEXT, params TEXT,
+  exit_code INTEGER, error TEXT, excluded INTEGER, reason TEXT,
+  stdout TEXT, stderr TEXT, params TEXT,
   PRIMARY KEY (experiment, id)
 )
 """