labnotes 0.0.100__tar.gz → 0.0.102__tar.gz

{labnotes-0.0.100 → labnotes-0.0.102}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.0.100
+Version: 0.0.102
 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>
@@ -49,6 +49,12 @@ 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`.
 
+When `experiment.toml` sits next to `.labnotes.toml`, the root is the one
+experiment, named after its folder. Paths then drop `{experiment}`: files
+default to `files/` and runs to `runs/{run}`. An `[experiment]` table in
+`.labnotes.toml` takes the same keys as `experiment.toml` and is the base
+that `experiment.toml` layers over.
+
 `labnotes experiments` reads three tables from those paths:
 
 - `experiments`: `name`, and `config`, the experiment's `experiment.toml` as

{labnotes-0.0.100 → labnotes-0.0.102}/README.md

@@ -25,6 +25,12 @@ 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`.
 
+When `experiment.toml` sits next to `.labnotes.toml`, the root is the one
+experiment, named after its folder. Paths then drop `{experiment}`: files
+default to `files/` and runs to `runs/{run}`. An `[experiment]` table in
+`.labnotes.toml` takes the same keys as `experiment.toml` and is the base
+that `experiment.toml` layers over.
+
 `labnotes experiments` reads three tables from those paths:
 
 - `experiments`: `name`, and `config`, the experiment's `experiment.toml` as

labnotes-0.0.102/src/labnotes/compose_experiment.py

@@ -0,0 +1,8 @@
+def compose_experiment(
+    base: dict[str, object], layer: dict[str, object]
+) -> dict[str, object]:
+    composed = {**base, **layer}
+    base_params, layer_params = base.get("params"), layer.get("params")
+    if isinstance(base_params, dict) and isinstance(layer_params, dict):
+        composed["params"] = {**base_params, **layer_params}
+    return composed

{labnotes-0.0.100 → labnotes-0.0.102}/src/labnotes/context.md

@@ -15,6 +15,8 @@ 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.
 
+When `experiment.toml` sits next to `.labnotes.toml`, the root is the one experiment, named after its folder. Paths then drop `{experiment}`: files default to `files/`, runs to `runs/{run}`, and `[experiments] path` is rejected. An `[experiment]` table in `.labnotes.toml` holds the same keys as `experiment.toml` and is the base each `experiment.toml` layers over (top-level keys replace, `params` merge by name). With no `[experiments] path`, it also makes the root the one experiment.
+
 `labnotes experiments` reads three tables from those paths:
 
 - `experiments`: `name`, and `config`, the experiment's `experiment.toml` as

{labnotes-0.0.100 → labnotes-0.0.102}/src/labnotes/context_guide.py

@@ -17,8 +17,12 @@ def context_guide(config: LabnotesConfig | None, cwd: Path) -> str:
         project = (
             f"Config: {config.path}\n"
             f"Root: {config.root}\n"
-            f"Experiments: {config.experiments}\n"
-            f"Files: {config.files}\n"
+            + (
+                f"Experiment: {config.experiment} (the root is the one experiment)\n"
+                if config.experiment
+                else 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.100 → labnotes-0.0.102}/src/labnotes/create_experiment.py

@@ -18,6 +18,10 @@ def create_experiment(config: LabnotesConfig, name: str | None) -> Path:
     def folder(candidate: str) -> Path:
         return config.root / config.experiments.replace("{experiment}", candidate)
 
+    if config.experiment is not None:
+        raise ValueError(
+            f"{config.root} is the experiment {config.experiment}; it can't hold others."
+        )
     if name is None:
         name = new_run_id(lambda candidate: folder(candidate).exists())
     if name == "new":

{labnotes-0.0.100 → labnotes-0.0.102}/src/labnotes/create_note.py

@@ -8,6 +8,8 @@ def create_note(config: LabnotesConfig, experiment: str) -> Path | None:
     def folder(template: str) -> Path:
         return config.root / template.replace("{experiment}", experiment)
 
+    if config.experiment not in (None, experiment):
+        return None
     if experiment.startswith(".") or not folder(config.experiments).is_dir():
         return None
     notes = folder(file_prefix(config.files))

labnotes-0.0.102/src/labnotes/default_config_text.py

@@ -0,0 +1,10 @@
+from labnotes.read_path import DEFAULT_PATHS, SINGLE_PATHS
+
+
+def default_config_text(*, single: bool = False) -> str:
+    paths = SINGLE_PATHS if single else DEFAULT_PATHS
+    return "\n".join(
+        f'[{table}]\npath = "{template}"\n'
+        for table, template in paths.items()
+        if template
+    )

{labnotes-0.0.100 → labnotes-0.0.102}/src/labnotes/init.py

@@ -11,7 +11,8 @@ def init() -> None:
     path = Path.cwd() / CONFIG_FILE
     try:
         with path.open("x", encoding="utf-8") as file:
-            file.write(default_config_text())
+            single = (path.parent / "experiment.toml").is_file()
+            file.write(default_config_text(single=single))
     except FileExistsError as error:
         raise click.ClickException(f"{path} already exists.") from error
     click.echo(f"Wrote {path}")

{labnotes-0.0.100 → labnotes-0.0.102}/src/labnotes/models.py

@@ -47,6 +47,10 @@ class LabnotesConfig:
     runs: str
     mode: str = DEFAULT_MODE
     concurrency: int = 1
+    # Set when the config's folder is itself the one experiment.
+    experiment: str | None = None
+    # [experiment] in .labnotes.toml, under each experiment.toml.
+    defaults: dict[str, object] = field(default_factory=dict)
 
 
 @dataclass(frozen=True)

{labnotes-0.0.100 → labnotes-0.0.102}/src/labnotes/note_path.py

@@ -10,7 +10,7 @@ def note_path(config: LabnotesConfig, experiment: str, note: str) -> Path | None
     if ".." in PurePosixPath(relative).parts or not note.endswith(".md"):
         return None
     found = path_pattern(config.files).fullmatch(relative)
-    if found is None or found["experiment"] != experiment:
+    if found is None or (config.experiment or found["experiment"]) != experiment:
         return None
     path = config.root / relative
     return path if path.is_relative_to(config.root) and path.is_file() else None

labnotes-0.0.102/src/labnotes/read_config.py

@@ -0,0 +1,56 @@
+import tomllib
+from pathlib import Path
+
+from labnotes.models import LabnotesConfig
+from labnotes.is_positive_int import is_positive_int
+from labnotes.modes import DEFAULT_MODE, MODES
+from labnotes.runner.read_experiment_config import SETTINGS
+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, "experiment"})
+    if unknown:
+        raise ValueError(f"{path}: unknown tables {', '.join(unknown)}")
+    experiments = values.get("experiments", {})
+    defaults = values.get("experiment", {})
+    if not isinstance(defaults, dict):
+        raise ValueError(f"{path}: experiment must be a table, like [experiment]")
+    unknown = sorted(defaults.keys() - SETTINGS)
+    if unknown:
+        raise ValueError(f"{path}: unknown keys in [experiment]: {', '.join(unknown)}")
+    root = path.resolve().parent
+    # An [experiments] path means many experiments, each taking [experiment] as
+    # its defaults; without one, [experiment] makes the root the experiment.
+    single = (root / "experiment.toml").is_file() or (
+        "experiment" in values
+        and not (isinstance(experiments, dict) and "path" in experiments)
+    )
+    paths = {
+        table: read_path(path, table, values.get(table, {}), single=single)
+        for table in DEFAULT_PATHS
+    }
+    mode = experiments.get("mode", DEFAULT_MODE)
+    if mode not in MODES:
+        raise ValueError(f"{path}: [experiments] mode must be matrix or adhoc")
+    concurrency = experiments.get("concurrency", 1)
+    if not is_positive_int(concurrency):
+        raise ValueError(
+            f"{path}: [experiments] concurrency must be a positive integer"
+        )
+    return LabnotesConfig(
+        path.resolve(),
+        root,
+        **paths,
+        mode=mode,
+        concurrency=concurrency,
+        experiment=root.name if single else None,
+        defaults=defaults,
+    )

{labnotes-0.0.100 → labnotes-0.0.102}/src/labnotes/read_path.py

@@ -6,31 +6,46 @@ DEFAULT_PATHS = {
     "files": "{experiment}/files/",
     "runs": "{experiment}/runs/{run}",
 }
+# One experiment at the config's folder, so no {experiment} to fill.
+SINGLE_PATHS = {"experiments": "", "files": "files/", "runs": "runs/{run}"}
 PLACEHOLDERS = {
     "experiments": {"experiment"},
     "files": {"experiment"},
     "runs": {"experiment", "run"},
 }
+# experiments is missing: one experiment has no folder to point at.
+SINGLE_PLACEHOLDERS: dict[str, set[str]] = {"files": set(), "runs": {"run"}}
 # Keys other readers own, so the path check lets them through.
 OTHER_KEYS = {"experiments": {"mode", "concurrency"}}
 PLACEHOLDER = re.compile(r"\{([^}]*)\}")
+SINGLE = "experiment.toml sits next to .labnotes.toml, so this folder is the experiment"
 
 
-def read_path(config: Path, table: str, section: object) -> str:
+def read_path(config: Path, table: str, section: object, single: bool = False) -> str:
     if not isinstance(section, dict):
         raise ValueError(f"{config}: {table} must be a table, like [{table}]")
     unknown = sorted(section.keys() - {"path", *OTHER_KEYS.get(table, ())})
     if unknown:
         raise ValueError(f"{config}: unknown keys in [{table}]: {', '.join(unknown)}")
-    template = section.get("path", DEFAULT_PATHS[table])
+    defaults = SINGLE_PATHS if single else DEFAULT_PATHS
+    if single and table not in SINGLE_PLACEHOLDERS:
+        if "path" in section:
+            raise ValueError(f"{config}: [experiments] path doesn't apply; {SINGLE}")
+        return SINGLE_PATHS[table]
+    template = section.get("path", defaults[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:
+    used = set(PLACEHOLDER.findall(template))
+    if single and "experiment" in used:
+        raise ValueError(f"{config}: [{table}] path can't use {{experiment}}; {SINGLE}")
+    required = SINGLE_PLACEHOLDERS[table] if single else PLACEHOLDERS[table]
+    if used != required:
         expected = " and ".join(f"{{{name}}}" for name in sorted(required))
+        if not expected:
+            raise ValueError(f"{config}: [{table}] path can't use placeholders")
         raise ValueError(f"{config}: [{table}] path must use exactly {expected}")
     return template

{labnotes-0.0.100 → labnotes-0.0.102}/src/labnotes/runner/prepare_experiment.py

@@ -11,13 +11,21 @@ async def prepare_experiment(
     experiment_config: Path | None,
     concurrency: int | None,
 ) -> tuple[ExperimentConfig, int]:
+    if config.experiment not in (None, name):
+        raise ValueError(
+            f"No experiment {name}; this project is the experiment {config.experiment}."
+        )
     if experiment_config is None:
         folder = config.experiments.replace("{experiment}", name)
         experiment_config = config.root / folder / "experiment.toml"
     source = await file_text(config.root, experiment_config)
-    if source is None:
+    if source is None and not config.defaults:
         raise ValueError(f"No experiment.toml for {name} at {experiment_config}.")
     experiment = read_experiment_config(
-        experiment_config, source, config.mode, config.concurrency
+        config.path if source is None else experiment_config,
+        source or "",
+        config.mode,
+        config.concurrency,
+        config.defaults,
     )
     return experiment, experiment.concurrency if concurrency is None else concurrency

{labnotes-0.0.100 → labnotes-0.0.102}/src/labnotes/runner/read_experiment_config.py

@@ -1,7 +1,9 @@
 import json
 import tomllib
 from pathlib import Path
+from typing import Any
 
+from labnotes.compose_experiment import compose_experiment
 from labnotes.default_counts import DEFAULT_COUNTS
 from labnotes.models import ExperimentConfig
 from labnotes.is_positive_int import is_positive_int
@@ -11,12 +13,17 @@ SETTINGS = {"name", "command", "repeats", "params", "counts", "mode", "concurren
 
 
 def read_experiment_config(
-    path: Path, source: str, mode: str, concurrency: int
+    path: Path,
+    source: str,
+    mode: str,
+    concurrency: int,
+    defaults: dict[str, object] | None = None,
 ) -> ExperimentConfig:
     try:
-        values = tomllib.loads(source)
+        layer = tomllib.loads(source)
     except tomllib.TOMLDecodeError as error:
         raise ValueError(f"{path}: {error}") from error
+    values: dict[str, Any] = compose_experiment(defaults or {}, layer)
     unknown = sorted(values.keys() - SETTINGS)
     if unknown:
         raise ValueError(f"{path}: unknown keys {', '.join(unknown)}")

labnotes-0.0.102/src/labnotes/tables/experiment_toml.py

@@ -0,0 +1,5 @@
+import posixpath
+
+
+def experiment_toml(template: str) -> str:
+    return posixpath.join(template, "experiment.toml")

labnotes-0.0.102/src/labnotes/tables/experiments_ddl.py

@@ -0,0 +1,34 @@
+import json
+
+from labnotes.models import LabnotesConfig
+from labnotes.sql_quote import quote_string
+
+# 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, source TEXT
+);
+CREATE VIEW experiments AS
+  SELECT name, coalesce(config ->> 'name', name) AS display_name, config, source
+  FROM (
+    SELECT
+      names.name,
+      coalesce(experiment_configs.config, {defaults}) AS config,
+      experiment_configs.source
+    FROM (
+      SELECT experiment AS name FROM experiment_configs
+      UNION SELECT experiment FROM files
+      UNION SELECT experiment FROM runs{one}
+    ) AS names
+    LEFT JOIN experiment_configs ON experiment_configs.experiment = names.name
+  );
+"""
+
+
+def experiments_ddl(config: LabnotesConfig) -> str:
+    defaults = json.dumps(config.defaults, default=str) if config.defaults else None
+    one = config.experiment
+    return EXPERIMENTS.format(
+        defaults="NULL" if defaults is None else quote_string(defaults),
+        one="" if one is None else f"\n      UNION SELECT {quote_string(one)}",
+    )

{labnotes-0.0.100 → labnotes-0.0.102}/src/labnotes/tables/open_tables.py

@@ -3,6 +3,8 @@ from functools import partial
 from dirsql import DirSQL, Table
 
 from labnotes.models import LabnotesConfig
+from labnotes.tables.experiment_toml import experiment_toml
+from labnotes.tables.experiments_ddl import experiments_ddl
 from labnotes.tables.path_glob import path_glob
 from labnotes.tables.read_blocks import read_blocks
 from labnotes.tables.read_experiment import read_experiment
@@ -10,24 +12,6 @@ from labnotes.tables.read_file import read_file
 from labnotes.tables.read_log import read_log
 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, source TEXT
-);
-CREATE VIEW experiments AS
-  SELECT
-    names.name,
-    coalesce(experiment_configs.config ->> 'name', names.name) AS display_name,
-    experiment_configs.config,
-    experiment_configs.source
-  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,
@@ -66,31 +50,45 @@ def open_tables(config: LabnotesConfig) -> DirSQL:
                 name="files",
                 ddl=FILES,
                 glob=path_glob(config.files),
-                on_file=partial(read_file, root, config.files),
+                on_file=partial(
+                    read_file, root, config.files, experiment=config.experiment
+                ),
             ),
             Table(
                 name="runs",
                 ddl=RUNS,
                 glob=path_glob(f"{config.runs}/run.json"),
-                on_file=partial(read_run, root, config.runs),
+                on_file=partial(
+                    read_run, root, config.runs, experiment=config.experiment
+                ),
             ),
             Table(
                 name="logs",
                 ddl=LOGS,
                 glob=path_glob(f"{config.runs}/std*.log"),
-                on_file=partial(read_log, root, config.runs),
+                on_file=partial(
+                    read_log, root, config.runs, experiment=config.experiment
+                ),
             ),
             Table(
                 name="blocks",
                 ddl=BLOCKS,
                 glob=path_glob(f"{config.runs}/log.jsonl"),
-                on_file=partial(read_blocks, root, config.runs),
+                on_file=partial(
+                    read_blocks, root, config.runs, experiment=config.experiment
+                ),
             ),
             Table(
                 name="experiment_configs",
-                ddl=EXPERIMENTS,
-                glob=path_glob(f"{config.experiments}/experiment.toml"),
-                on_file=partial(read_experiment, root, config.experiments),
+                ddl=experiments_ddl(config),
+                glob=path_glob(experiment_toml(config.experiments)),
+                on_file=partial(
+                    read_experiment,
+                    root,
+                    config.experiments,
+                    experiment=config.experiment,
+                    defaults=config.defaults,
+                ),
             ),
         ],
         # Run folders are often gitignored (DVC, large outputs); scan them anyway.

{labnotes-0.0.100 → labnotes-0.0.102}/src/labnotes/tables/read_blocks.py

@@ -3,14 +3,16 @@ from pathlib import Path
 from labnotes.tables.path_pattern import path_pattern
 
 
-def read_blocks(root: Path, template: str, path: str) -> list[dict[str, object]]:
+def read_blocks(
+    root: Path, template: str, path: str, experiment: str | None = None
+) -> list[dict[str, object]]:
     relative = Path(path).relative_to(root).as_posix()
     found = path_pattern(f"{template}/log.jsonl").fullmatch(relative)
     if found is None:
         return []
     return [
         {
-            "experiment": found["experiment"],
+            "experiment": experiment or found["experiment"],
             "run": found["run"],
             "size": Path(path).stat().st_size,
         }

labnotes-0.0.102/src/labnotes/tables/read_experiment.py

@@ -0,0 +1,29 @@
+import json
+import tomllib
+from pathlib import Path
+
+from labnotes.compose_experiment import compose_experiment
+from labnotes.tables.experiment_toml import experiment_toml
+from labnotes.tables.path_pattern import path_pattern
+
+
+def read_experiment(
+    root: Path,
+    template: str,
+    path: str,
+    experiment: str | None = None,
+    defaults: dict[str, object] | None = None,
+) -> list[dict[str, object]]:
+    relative = Path(path).relative_to(root).as_posix()
+    found = path_pattern(experiment_toml(template)).fullmatch(relative)
+    if found is None:
+        return []
+    source = Path(path).read_text(encoding="utf-8")
+    config = compose_experiment(defaults or {}, tomllib.loads(source))
+    return [
+        {
+            "experiment": experiment or found["experiment"],
+            "config": json.dumps(config),
+            "source": source,
+        }
+    ]

{labnotes-0.0.100 → labnotes-0.0.102}/src/labnotes/tables/read_file.py

@@ -6,7 +6,9 @@ from labnotes.tables.note_text import note_text
 from labnotes.tables.path_pattern import path_pattern
 
 
-def read_file(root: Path, template: str, path: str) -> list[dict[str, object]]:
+def read_file(
+    root: Path, template: str, path: str, experiment: str | None = None
+) -> list[dict[str, object]]:
     relative = Path(path).relative_to(root).as_posix()
     found = path_pattern(template).fullmatch(relative)
     prefix = path_pattern(file_prefix(template).rstrip("/")).match(relative)
@@ -15,7 +17,7 @@ def read_file(root: Path, template: str, path: str) -> list[dict[str, object]]:
     stat = Path(path).stat()
     return [
         {
-            "experiment": found["experiment"],
+            "experiment": experiment or found["experiment"],
             "filename": relative[prefix.end() :].lstrip("/"),
             "path": relative,
             "ctime": iso_time(stat.st_ctime),

{labnotes-0.0.100 → labnotes-0.0.102}/src/labnotes/tables/read_log.py

@@ -5,14 +5,16 @@ from labnotes.tables.path_pattern import path_pattern
 STREAMS = ("stdout", "stderr")
 
 
-def read_log(root: Path, template: str, path: str) -> list[dict[str, object]]:
+def read_log(
+    root: Path, template: str, path: str, experiment: str | None = None
+) -> list[dict[str, object]]:
     relative = Path(path).relative_to(root).as_posix()
     found = path_pattern(f"{template}/{{stream}}.log").fullmatch(relative)
     if found is None or found["stream"] not in STREAMS:
         return []
     return [
         {
-            "experiment": found["experiment"],
+            "experiment": experiment or found["experiment"],
             "run": found["run"],
             "stream": found["stream"],
             "size": Path(path).stat().st_size,

{labnotes-0.0.100 → labnotes-0.0.102}/src/labnotes/tables/read_run.py

@@ -4,7 +4,9 @@ from pathlib import Path
 from labnotes.tables.path_pattern import path_pattern
 
 
-def read_run(root: Path, template: str, path: str) -> list[dict[str, object]]:
+def read_run(
+    root: Path, template: str, path: str, experiment: str | None = None
+) -> list[dict[str, object]]:
     relative = Path(path).relative_to(root).as_posix()
     found = path_pattern(f"{template}/run.json").fullmatch(relative)
     if found is None:
@@ -13,7 +15,7 @@ def read_run(root: Path, template: str, path: str) -> list[dict[str, object]]:
     folder = relative.removesuffix("/run.json")
     return [
         {
-            "experiment": found["experiment"],
+            "experiment": experiment or found["experiment"],
             "id": found["run"],
             "folder": folder,
             "created": run.get("created"),

labnotes-0.0.100/src/labnotes/default_config_text.py

@@ -1,7 +0,0 @@
-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.100/src/labnotes/read_config.py

@@ -1,36 +0,0 @@
-import tomllib
-from pathlib import Path
-
-from labnotes.models import LabnotesConfig
-from labnotes.is_positive_int import is_positive_int
-from labnotes.modes import DEFAULT_MODE, MODES
-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)}")
-    paths = {
-        table: read_path(path, table, values.get(table, {})) for table in DEFAULT_PATHS
-    }
-    experiments = values.get("experiments", {})
-    mode = experiments.get("mode", DEFAULT_MODE)
-    if mode not in MODES:
-        raise ValueError(f"{path}: [experiments] mode must be matrix or adhoc")
-    concurrency = experiments.get("concurrency", 1)
-    if not is_positive_int(concurrency):
-        raise ValueError(
-            f"{path}: [experiments] concurrency must be a positive integer"
-        )
-    path = path.resolve()
-    return LabnotesConfig(
-        path, path.parent, **paths, mode=mode, concurrency=concurrency
-    )

labnotes-0.0.100/src/labnotes/tables/read_experiment.py

@@ -1,21 +0,0 @@
-import json
-import tomllib
-from pathlib import Path
-
-from labnotes.tables.path_pattern import path_pattern
-
-
-def read_experiment(root: Path, template: str, path: str) -> list[dict[str, object]]:
-    relative = Path(path).relative_to(root).as_posix()
-    found = path_pattern(f"{template}/experiment.toml").fullmatch(relative)
-    if found is None:
-        return []
-    source = Path(path).read_text(encoding="utf-8")
-    config = tomllib.loads(source)
-    return [
-        {
-            "experiment": found["experiment"],
-            "config": json.dumps(config),
-            "source": source,
-        }
-    ]