labnotes 0.0.100__tar.gz → 0.0.101__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.0.100
+Version: 0.0.101
 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,10 @@ 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}`.
+
 `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.101}/README.md

@@ -25,6 +25,10 @@ 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}`.
+
 `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.101}/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.
+
 `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.101}/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.101}/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.101}/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.101/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.101}/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.101}/src/labnotes/models.py

@@ -47,6 +47,8 @@ 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
 
 
 @dataclass(frozen=True)

{labnotes-0.0.100 → labnotes-0.0.101}/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.100 → labnotes-0.0.101}/src/labnotes/read_config.py

@@ -18,8 +18,11 @@ def read_config(path: Path) -> LabnotesConfig:
     unknown = sorted(values.keys() - DEFAULT_PATHS.keys())
     if unknown:
         raise ValueError(f"{path}: unknown tables {', '.join(unknown)}")
+    root = path.resolve().parent
+    single = (root / "experiment.toml").is_file()
     paths = {
-        table: read_path(path, table, values.get(table, {})) for table in DEFAULT_PATHS
+        table: read_path(path, table, values.get(table, {}), single=single)
+        for table in DEFAULT_PATHS
     }
     experiments = values.get("experiments", {})
     mode = experiments.get("mode", DEFAULT_MODE)
@@ -30,7 +33,11 @@ def read_config(path: Path) -> LabnotesConfig:
         raise ValueError(
             f"{path}: [experiments] concurrency must be a positive integer"
         )
-    path = path.resolve()
     return LabnotesConfig(
-        path, path.parent, **paths, mode=mode, concurrency=concurrency
+        path.resolve(),
+        root,
+        **paths,
+        mode=mode,
+        concurrency=concurrency,
+        experiment=root.name if single else None,
     )

{labnotes-0.0.100 → labnotes-0.0.101}/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.101}/src/labnotes/runner/prepare_experiment.py

@@ -11,6 +11,10 @@ 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"

labnotes-0.0.101/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.100 → labnotes-0.0.101}/src/labnotes/tables/open_tables.py

@@ -3,6 +3,7 @@ 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.path_glob import path_glob
 from labnotes.tables.read_blocks import read_blocks
 from labnotes.tables.read_experiment import read_experiment
@@ -66,31 +67,44 @@ 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),
+                glob=path_glob(experiment_toml(config.experiments)),
+                on_file=partial(
+                    read_experiment,
+                    root,
+                    config.experiments,
+                    experiment=config.experiment,
+                ),
             ),
         ],
         # Run folders are often gitignored (DVC, large outputs); scan them anyway.

{labnotes-0.0.100 → labnotes-0.0.101}/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.100 → labnotes-0.0.101}/src/labnotes/tables/read_experiment.py

@@ -2,19 +2,22 @@ import json
 import tomllib
 from pathlib import Path
 
+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) -> list[dict[str, object]]:
+def read_experiment(
+    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}/experiment.toml").fullmatch(relative)
+    found = path_pattern(experiment_toml(template)).fullmatch(relative)
     if found is None:
         return []
     source = Path(path).read_text(encoding="utf-8")
     config = tomllib.loads(source)
     return [
         {
-            "experiment": found["experiment"],
+            "experiment": experiment or found["experiment"],
             "config": json.dumps(config),
             "source": source,
         }

{labnotes-0.0.100 → labnotes-0.0.101}/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.101}/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.101}/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()
-    )