labnotes 0.0.12__tar.gz → 0.0.14__tar.gz

{labnotes-0.0.12 → labnotes-0.0.14}/.gitignore

@@ -21,3 +21,5 @@ build/
 docs/.vitepress/cache
 docs/.vitepress/dist
 docs/node_modules/
+
+notes

labnotes-0.0.14/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.5
+Name: labnotes
+Version: 0.0.14
+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>
+License-Expression: MIT
+Requires-Python: >=3.12
+Requires-Dist: click>=8.5.0
+Requires-Dist: dirsql>=0.4.110
+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: uvicorn>=0.54.0
+Description-Content-Type: text/markdown
+
+# labnotes
+
+Browse experiment designs, notes, and run data from a folder.
+
+```sh
+uvx labnotes server
+```
+
+A project's root is the folder holding its `.labnotes.toml`. `labnotes init`
+writes one with the default layout:
+
+```toml
+[experiments]
+path = "{experiment}"
+
+[files]
+path = "{experiment}/files/"
+
+[runs]
+path = "{experiment}/runs/{run}"
+```
+
+Each path is relative to the root. `{experiment}` and `{run}` stand for folder
+names: the experiments path must use `{experiment}`, and the runs path both.
+labnotes reads the file from the working folder, or from the path given with
+`-c`.
+
+`labnotes experiments` reads three tables from those paths:
+
+- `experiments`: `name`, and `config`, the experiment's `experiment.toml` as
+  JSON. An experiment is a folder matching the experiments path that holds an
+  `experiment.toml`, files or runs.
+- `files`: `experiment`, `filename`, `path`, `ctime`, `mtime`.
+- `runs`: `experiment`, `id`, `folder`, `created`, `ended`, `exit_code`,
+  `error`, `stdout`, `stderr`, and `params` as JSON, read from each run
+  folder's `run.json`.
+
+Keys come from folder names, so renaming a folder renames its rows on the next
+read. Paths are relative to the root, and times are UTC ISO 8601.
+
+```sh
+labnotes experiments            # name, last_run, created, files, runs
+labnotes experiments foo        # the same, plus config
+labnotes experiments foo runs   # foo's runs, oldest first
+```
+
+Each takes `--format table` (the default) or `--format json`.
+
+`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.
+
+`-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.
+
+## Agent skill
+
+```sh
+npx skills add thekevinscott/labnotes
+```
+
+The skill tells a coding agent to run `labnotes context`, which prints a usage
+guide for the installed version.

labnotes-0.0.14/README.md

@@ -0,0 +1,80 @@
+# labnotes
+
+Browse experiment designs, notes, and run data from a folder.
+
+```sh
+uvx labnotes server
+```
+
+A project's root is the folder holding its `.labnotes.toml`. `labnotes init`
+writes one with the default layout:
+
+```toml
+[experiments]
+path = "{experiment}"
+
+[files]
+path = "{experiment}/files/"
+
+[runs]
+path = "{experiment}/runs/{run}"
+```
+
+Each path is relative to the root. `{experiment}` and `{run}` stand for folder
+names: the experiments path must use `{experiment}`, and the runs path both.
+labnotes reads the file from the working folder, or from the path given with
+`-c`.
+
+`labnotes experiments` reads three tables from those paths:
+
+- `experiments`: `name`, and `config`, the experiment's `experiment.toml` as
+  JSON. An experiment is a folder matching the experiments path that holds an
+  `experiment.toml`, files or runs.
+- `files`: `experiment`, `filename`, `path`, `ctime`, `mtime`.
+- `runs`: `experiment`, `id`, `folder`, `created`, `ended`, `exit_code`,
+  `error`, `stdout`, `stderr`, and `params` as JSON, read from each run
+  folder's `run.json`.
+
+Keys come from folder names, so renaming a folder renames its rows on the next
+read. Paths are relative to the root, and times are UTC ISO 8601.
+
+```sh
+labnotes experiments            # name, last_run, created, files, runs
+labnotes experiments foo        # the same, plus config
+labnotes experiments foo runs   # foo's runs, oldest first
+```
+
+Each takes `--format table` (the default) or `--format json`.
+
+`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.
+
+`-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.
+
+## Agent skill
+
+```sh
+npx skills add thekevinscott/labnotes
+```
+
+The skill tells a coding agent to run `labnotes context`, which prints a usage
+guide for the installed version.

{labnotes-0.0.12 → labnotes-0.0.14}/pyproject.toml

@@ -18,6 +18,7 @@ dependencies = [
     "jupyter-client>=8.10.0",
     "markdown-it-py>=4.2.0",
     "pyyaml>=6.0.3",
+    "rich>=14",
     "starlette>=1.8.0",
     "uvicorn>=0.54.0",
 ]
@@ -51,7 +52,7 @@ exclude = ["*_test.py"]
 packages = ["src/labnotes"]
 
 [tool.pytest.ini_options]
-testpaths = ["src/labnotes"]
+testpaths = ["src/labnotes", "tests"]
 python_files = "*_test.py"
 
 [tool.ruff.lint]

labnotes-0.0.14/src/labnotes/cli.py

@@ -0,0 +1,42 @@
+from pathlib import Path
+
+import click
+
+from labnotes.context_guide import context_guide
+from labnotes.experiments import experiments
+from labnotes.init import init
+from labnotes.load_config import load_config
+from labnotes.read_config import CONFIG_FILE
+from labnotes.server import server
+
+
+@click.group(
+    invoke_without_command=True,
+    help="Manage experiments in a folder. `labnotes context` prints a guide for"
+    " coding agents.",
+)
+@click.version_option(package_name="labnotes")
+@click.option(
+    "-c",
+    "--config",
+    "config_path",
+    type=click.Path(path_type=Path, dir_okay=False, exists=True),
+    help=f"Project config. Default: {CONFIG_FILE} in the working folder, if there.",
+)
+@click.pass_context
+def main(ctx: click.Context, config_path: Path | None) -> None:
+    if ctx.invoked_subcommand is None:
+        click.echo(ctx.get_help())
+        ctx.exit()
+    ctx.obj = config_path or Path.cwd() / CONFIG_FILE
+
+
+@main.command(help="Print a guide for coding agents.")
+@click.pass_context
+def context(ctx: click.Context) -> None:
+    click.echo(context_guide(load_config(ctx), Path.cwd()), nl=False)
+
+
+main.add_command(experiments)
+main.add_command(init)
+main.add_command(server)

labnotes-0.0.14/src/labnotes/context.md

@@ -0,0 +1,47 @@
+## Usage
+
+A project that uses labnotes has a `.labnotes.toml` at its root; the folder holding it is the root. labnotes reads it from the working folder, so run labnotes from the project root, or pass `-c PATH`. The lines above this guide name the one found and its paths, or say there is none. `labnotes init` writes one with the default layout:
+
+```toml
+[experiments]
+path = "{experiment}"            # one folder per experiment
+
+[files]
+path = "{experiment}/files/"     # an experiment's notes and other files
+
+[runs]
+path = "{experiment}/runs/{run}" # one folder per run
+```
+
+Paths are relative to the root. `{experiment}` and `{run}` stand for folder names; the experiments and files paths use `{experiment}`, the runs path both. A project laid out differently keeps its folders and changes the paths: look at where its experiments, notes and runs live, then write the templates that match.
+
+`labnotes experiments` reads three tables from those paths:
+
+- `experiments`: `name`, and `config`, the experiment's `experiment.toml` as
+  JSON. An experiment is a folder matching the experiments path that holds an
+  `experiment.toml`, files or runs.
+- `files`: `experiment`, `filename`, `path`, `ctime`, `mtime`.
+- `runs`: `experiment`, `id`, `folder`, `created`, `ended`, `exit_code`,
+  `error`, `stdout`, `stderr`, and `params` as JSON, read from each run
+  folder's `run.json`.
+
+Keys come from folder names, so renaming a folder renames its rows on the next
+read. Paths are relative to the root, and times are UTC ISO 8601.
+
+```sh
+labnotes experiments            # name, last_run, created, files, runs
+labnotes experiments foo        # the same, plus config
+labnotes experiments foo runs   # foo's runs, oldest first
+```
+
+Each takes `--format table` (the default) or `--format json`; use `--format json` when you parse the output.
+
+`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.

{labnotes-0.0.12 → labnotes-0.0.14}/src/labnotes/context_guide.py

@@ -16,7 +16,9 @@ def context_guide(config: LabnotesConfig | None, cwd: Path) -> str:
     else:
         project = (
             f"Config: {config.path}\n"
-            f"Experiments folder: {config.experiments_folder}\n"
-            f"Data folder: {config.data_folder}"
+            f"Root: {config.root}\n"
+            f"Experiments: {config.experiments}\n"
+            f"Files: {config.files}\n"
+            f"Runs: {config.runs}"
         )
     return f"labnotes {version('labnotes')}\n\n{project}\n\n{guide}"

labnotes-0.0.14/src/labnotes/default_config_text.py

@@ -0,0 +1,7 @@
+from labnotes.read_path import DEFAULT_PATHS
+
+
+def default_config_text() -> str:
+    return "\n".join(
+        f'[{table}]\npath = "{template}"\n' for table, template in DEFAULT_PATHS.items()
+    )

labnotes-0.0.14/src/labnotes/experiments.py

@@ -0,0 +1,33 @@
+import asyncio
+
+import click
+
+from labnotes.load_config import load_config
+from labnotes.print_rows import print_rows
+from labnotes.read_config import CONFIG_FILE
+from labnotes.tables.experiment_rows import experiment_rows
+
+
+@click.command(help="List experiments, show one, or list its runs.")
+@click.argument("name", required=False)
+@click.argument("action", required=False, type=click.Choice(["runs"]))
+@click.option(
+    "--format",
+    "output_format",
+    type=click.Choice(["table", "json"]),
+    default="table",
+    show_default=True,
+)
+@click.pass_context
+def experiments(
+    ctx: click.Context, name: str | None, action: str | None, output_format: str
+) -> None:
+    config = load_config(ctx)
+    if config is None:
+        raise click.ClickException(
+            f"No {CONFIG_FILE} here. Run labnotes init, or pass -c PATH."
+        )
+    rows = asyncio.run(experiment_rows(config, name, action))
+    if rows is None:
+        raise click.ClickException(f"No experiment named {name}.")
+    print_rows(rows, output_format)

labnotes-0.0.14/src/labnotes/init.py

@@ -0,0 +1,17 @@
+from pathlib import Path
+
+import click
+
+from labnotes.default_config_text import default_config_text
+from labnotes.read_config import CONFIG_FILE
+
+
+@click.command(help=f"Write a {CONFIG_FILE} with the default layout here.")
+def init() -> None:
+    path = Path.cwd() / CONFIG_FILE
+    try:
+        with path.open("x", encoding="utf-8") as file:
+            file.write(default_config_text())
+    except FileExistsError as error:
+        raise click.ClickException(f"{path} already exists.") from error
+    click.echo(f"Wrote {path}")

labnotes-0.0.14/src/labnotes/load_config.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+
+import click
+
+from labnotes.models import LabnotesConfig
+from labnotes.read_config import read_config
+
+
+def load_config(ctx: click.Context) -> LabnotesConfig | None:
+    path: Path = ctx.find_root().obj
+    try:
+        return read_config(path) if path.is_file() else None
+    except ValueError as error:
+        raise click.ClickException(str(error)) from error

{labnotes-0.0.12 → labnotes-0.0.14}/src/labnotes/models.py

@@ -13,5 +13,7 @@ class RunView:
 @dataclass(frozen=True)
 class LabnotesConfig:
     path: Path
-    experiments_folder: Path
-    data_folder: Path
+    root: Path
+    experiments: str
+    files: str
+    runs: str

labnotes-0.0.14/src/labnotes/print_rows.py

@@ -0,0 +1,19 @@
+import json
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+
+def print_rows(rows: list[dict[str, object]], output_format: str) -> None:
+    match output_format:
+        case "json":
+            click.echo(json.dumps(rows, indent=2))
+            return
+    if not rows:
+        click.echo("No rows.")
+        return
+    table = Table(*rows[0].keys())
+    for row in rows:
+        table.add_row(*("" if value is None else str(value) for value in row.values()))
+    Console().print(table)

labnotes-0.0.14/src/labnotes/read_config.py

@@ -0,0 +1,27 @@
+import tomllib
+from pathlib import Path
+
+from labnotes.models import LabnotesConfig
+from labnotes.read_path import DEFAULT_PATHS, read_path
+
+CONFIG_FILE = ".labnotes.toml"
+
+
+def read_config(path: Path) -> LabnotesConfig:
+    try:
+        with path.open("rb") as file:
+            values = tomllib.load(file)
+    except tomllib.TOMLDecodeError as error:
+        raise ValueError(f"{path}: {error}") from error
+    unknown = sorted(values.keys() - DEFAULT_PATHS.keys())
+    if unknown:
+        raise ValueError(f"{path}: unknown tables {', '.join(unknown)}")
+    path = path.resolve()
+    return LabnotesConfig(
+        path,
+        path.parent,
+        **{
+            table: read_path(path, table, values.get(table, {}))
+            for table in DEFAULT_PATHS
+        },
+    )

labnotes-0.0.14/src/labnotes/read_path.py

@@ -0,0 +1,34 @@
+import re
+from pathlib import Path, PurePosixPath
+
+DEFAULT_PATHS = {
+    "experiments": "{experiment}",
+    "files": "{experiment}/files/",
+    "runs": "{experiment}/runs/{run}",
+}
+PLACEHOLDERS = {
+    "experiments": {"experiment"},
+    "files": {"experiment"},
+    "runs": {"experiment", "run"},
+}
+PLACEHOLDER = re.compile(r"\{([^}]*)\}")
+
+
+def read_path(config: Path, table: str, section: object) -> str:
+    if not isinstance(section, dict):
+        raise ValueError(f"{config}: {table} must be a table, like [{table}]")
+    unknown = sorted(section.keys() - {"path"})
+    if unknown:
+        raise ValueError(f"{config}: unknown keys in [{table}]: {', '.join(unknown)}")
+    template = section.get("path", DEFAULT_PATHS[table])
+    if not isinstance(template, str):
+        raise ValueError(f"{config}: [{table}] path must be a string")
+    if PurePosixPath(template).is_absolute() or template.startswith("~"):
+        raise ValueError(
+            f"{config}: [{table}] path must be relative to the config's folder"
+        )
+    required = PLACEHOLDERS[table]
+    if set(PLACEHOLDER.findall(template)) != required:
+        expected = " and ".join(f"{{{name}}}" for name in sorted(required))
+        raise ValueError(f"{config}: [{table}] path must use exactly {expected}")
+    return template

labnotes-0.0.14/src/labnotes/server.py

@@ -0,0 +1,64 @@
+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
+
+# 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.option(
+    "--kernel-idle-minutes",
+    type=click.IntRange(min=1),
+    default=30,
+    show_default=True,
+    envvar=KERNEL_IDLE_MINUTES,
+    help="Stop a note's Python kernel after this long without a run.",
+)
+@click.option(
+    "-h",
+    "--host",
+    default="127.0.0.1",
+    show_default=True,
+    help="Bind to this host. 0.0.0.0 or a Tailscale IP serves beyond localhost.",
+)
+@click.option("-p", "--port", type=int, default=8000, show_default=True)
+@click.pass_context
+def server(
+    ctx: click.Context,
+    experiments_folder: Path,
+    data_folder: Path,
+    kernel_idle_minutes: int,
+    **server_options: object,
+) -> None:
+    # 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[KERNEL_IDLE_MINUTES] = str(kernel_idle_minutes)
+    ctx.invoke(
+        uvicorn_main,
+        app="labnotes.serve_app:serve_app",
+        factory=True,
+        **server_options,
+    )
+
+
+server.params += [p for p in uvicorn_main.params if p.name not in OWN_OPTIONS]

labnotes-0.0.14/src/labnotes/tables/experiment_rows.py

@@ -0,0 +1,17 @@
+from labnotes.models import LabnotesConfig
+from labnotes.tables.list_experiment_runs import list_experiment_runs
+from labnotes.tables.open_tables import open_tables
+from labnotes.tables.summarize_experiments import summarize_experiments
+
+
+async def experiment_rows(
+    config: LabnotesConfig, name: str | None, action: str | None
+) -> list[dict[str, object]] | None:
+    tables = open_tables(config)
+    rows = await summarize_experiments(tables, name)
+    if name is not None and not rows:
+        return None
+    match name, action:
+        case str(), "runs":
+            return await list_experiment_runs(tables, name)
+    return rows

labnotes-0.0.14/src/labnotes/tables/file_prefix.py

@@ -0,0 +1,9 @@
+import re
+
+GLOB = re.compile(r"[*?\[]")
+
+
+def file_prefix(template: str) -> str:
+    glob = GLOB.search(template)
+    head = template[: glob.start()] if glob else template
+    return head if head.endswith("/") else head[: head.rfind("/") + 1]

labnotes-0.0.14/src/labnotes/tables/iso_time.py

@@ -0,0 +1,5 @@
+from datetime import UTC, datetime
+
+
+def iso_time(seconds: float) -> str:
+    return datetime.fromtimestamp(seconds, UTC).strftime("%Y-%m-%dT%H:%M:%SZ")

labnotes-0.0.14/src/labnotes/tables/list_experiment_runs.py

@@ -0,0 +1,10 @@
+from dirsql import DirSQL
+
+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"
+        f" WHERE experiment = {quote_string(name)} ORDER BY created, id"
+    )

labnotes-0.0.14/src/labnotes/tables/open_tables.py

@@ -0,0 +1,63 @@
+from functools import partial
+
+from dirsql import DirSQL, Table
+
+from labnotes.models import LabnotesConfig
+from labnotes.tables.path_glob import path_glob
+from labnotes.tables.read_experiment import read_experiment
+from labnotes.tables.read_file import read_file
+from labnotes.tables.read_run import read_run
+
+# experiments is a view, so files and runs can't declare a foreign key to it.
+EXPERIMENTS = """
+CREATE TABLE experiment_configs (experiment TEXT PRIMARY KEY, config TEXT);
+CREATE VIEW experiments AS
+  SELECT names.name, experiment_configs.config
+  FROM (
+    SELECT experiment AS name FROM experiment_configs
+    UNION SELECT experiment FROM files
+    UNION SELECT experiment FROM runs
+  ) AS names
+  LEFT JOIN experiment_configs ON experiment_configs.experiment = names.name;
+"""
+FILES = """
+CREATE TABLE files (
+  experiment TEXT, filename TEXT, path TEXT PRIMARY KEY, ctime TEXT, mtime TEXT
+)
+"""
+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,
+  PRIMARY KEY (experiment, id)
+)
+"""
+
+
+def open_tables(config: LabnotesConfig) -> DirSQL:
+    root = config.root
+    return DirSQL(
+        str(root),
+        tables=[
+            Table(
+                name="files",
+                ddl=FILES,
+                glob=path_glob(config.files),
+                on_file=partial(read_file, root, config.files),
+            ),
+            Table(
+                name="runs",
+                ddl=RUNS,
+                glob=path_glob(f"{config.runs}/run.json"),
+                on_file=partial(read_run, root, config.runs),
+            ),
+            Table(
+                name="experiment_configs",
+                ddl=EXPERIMENTS,
+                glob=path_glob(f"{config.experiments}/experiment.toml"),
+                on_file=partial(read_experiment, root, config.experiments),
+            ),
+        ],
+        # Run folders are often gitignored (DVC, large outputs); scan them anyway.
+        no_ignore=True,
+    )

labnotes-0.0.14/src/labnotes/tables/path_glob.py

@@ -0,0 +1,8 @@
+import re
+
+PLACEHOLDER = re.compile(r"\{[^}]*\}")
+
+
+def path_glob(template: str) -> str:
+    glob = PLACEHOLDER.sub("*", template)
+    return f"{glob}**" if glob.endswith("/") else glob