labnotes 0.0.43__tar.gz → 0.0.45__tar.gz

{labnotes-0.0.43 → labnotes-0.0.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.0.43
+Version: 0.0.45
 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>

{labnotes-0.0.43 → labnotes-0.0.45}/src/labnotes/context.md

@@ -59,7 +59,9 @@ renaming the experiment means editing `name`.
 Each combination of `[params]` runs `repeats` times (1 if omitted), round-robin, on every
 `run`, whatever is already on disk. That is `mode = "adhoc"`, the default.
 `mode = "fill"` counts what is there: only runs that count fill a combination,
-so running again fills in what failed or never ran.
+so running again fills in what failed or never ran. `mode` under
+`[experiments]` in `.labnotes.toml` sets it for every experiment that doesn't
+set its own.
 Each run gets a new run folder, named for the UTC time it was planned (`20261020-000429-brave-fox`), so folder listings sort by start. `command` runs in a shell from the root, with
 `{run_dir}` replaced by the run folder's absolute path. Pass it to the
 script so it writes its outputs there.
@@ -90,20 +92,23 @@ A script run by labnotes should:
 Runs can take a long time. Start `run` in the background, then check on it with `labnotes experiments foo runs`; a run with no `ended` is still going.
 
 In a terminal, `run` shows a live table of runs (status and time) and stays
-open when they finish. Failed runs show their status in red; `h` hides or shows them, and `r` on one
-runs it again under a new id. Runs not started yet show grayed as `pending`, and as
+open when they finish. Failed runs show their status in red; `f` hides or shows them, and `r` on one
+runs it again under a new id. `j` and `k` move the cursor, `g` and `G` jump to the
+first and last row. Runs not started yet show grayed as `pending`, and as
 `skipped` once stopped. Move the cursor to a pending run and press `n` to run it
-next. `d` deselects a pending run so it won't run; `d` again puts it back at
+next. Space deselects a pending run so it won't run; Space again puts it back at
 the end of the queue. `/` filters rows by params text; Enter keeps the filter,
-Escape clears it. `D` deselects every pending run the filter shows. `k` stops the
-running run under the cursor; `k` again kills it. `+` and
+Escape clears it. `D` deselects every pending run the filter shows. `x` stops the
+running run under the cursor; `x` again kills it. `+` and
 `-` change how many run at once; lowering it lets running runs
 finish. Enter on a run follows its `stdout.log`; `e` switches to
 `stderr.log` and back, and Escape returns to the table. An `adhoc` experiment that
 plans a single run opens straight on its output. `q` quits. Elsewhere, or with `--no-tui`, it prints a
 line per event instead.
 
-- `--concurrency N` runs N at a time to start with (default 1).
+- `--concurrency N` runs N at a time to start with. Without it, `concurrency`
+  in `experiment.toml` sets it, then `concurrency` under `[experiments]` in
+  `.labnotes.toml`, then 1.
 - `-e PATH` reads another file instead of `experiment.toml`.
 - Ctrl-C stops the running scripts and records their end. A second Ctrl-C
   kills them. Closing the terminal or sending SIGTERM stops them the same way,

{labnotes-0.0.43 → labnotes-0.0.45}/src/labnotes/create_app.py

@@ -50,7 +50,7 @@ def create_app(config: LabnotesConfig, kernel_idle_minutes: float) -> Starlette:
             await kernel.stop()
 
     async def index(request: Request) -> Response:
-        experiments = await list_experiments(request.app.state.tables)
+        experiments = await list_experiments(request.app.state.tables, config.mode)
         return templates.TemplateResponse(
             request,
             "index.html",
@@ -62,6 +62,7 @@ def create_app(config: LabnotesConfig, kernel_idle_minutes: float) -> Starlette:
         loaded = await load_experiment(
             request.app.state.tables,
             config.root,
+            config.mode,
             name,
             request.query_params,
             lambda note, content: saved_outputs(kernels.get((name, note)), content),

{labnotes-0.0.43 → labnotes-0.0.45}/src/labnotes/experiments.py

@@ -30,9 +30,8 @@ from labnotes.tui.run_tui import run_tui
 @click.option(
     "--concurrency",
     type=click.IntRange(min=1),
-    default=1,
-    show_default=True,
-    help="With run: how many runs at once.",
+    help="With run: how many runs at once. Overrides experiment.toml and"
+    " .labnotes.toml; 1 if none sets it.",
 )
 @click.option(
     "-e",
@@ -51,7 +50,7 @@ def experiments(
     name: str | None,
     action: str | None,
     output_format: str,
-    concurrency: int,
+    concurrency: int | None,
     experiment_config: Path | None,
     no_tui: bool,
 ) -> None:

labnotes-0.0.45/src/labnotes/is_positive_int.py

@@ -0,0 +1,2 @@
+def is_positive_int(value: object) -> bool:
+    return isinstance(value, int) and not isinstance(value, bool) and value > 0

{labnotes-0.0.43 → labnotes-0.0.45}/src/labnotes/list_experiments.py

@@ -9,7 +9,7 @@ from labnotes.experiment_runs import experiment_runs
 from labnotes.summarize_config import summarize_config
 
 
-async def list_experiments(tables: DirSQL) -> list[dict[str, object]]:
+async def list_experiments(tables: DirSQL, mode: str) -> list[dict[str, object]]:
     rows = await tables.query(
         "SELECT name, display_name, config FROM experiments ORDER BY name"
     )
@@ -17,7 +17,7 @@ async def list_experiments(tables: DirSQL) -> list[dict[str, object]]:
     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)
+        summary = summarize_config(config, mode)
         varies = cast(dict[str, list[object]], summary["varies"])
         source = experiment_runs(name, list(varies))
         summary = await check_counts(tables, source, summary)

{labnotes-0.0.43 → labnotes-0.0.45}/src/labnotes/load_experiment.py

@@ -25,6 +25,7 @@ def _no_outputs(note: str, content: str) -> Sequence[str]:
 async def load_experiment(
     tables: DirSQL,
     root: Path,
+    mode: str,
     name: str,
     params: Mapping[str, str],
     outputs_for: Callable[[str, str], Sequence[str]] = _no_outputs,
@@ -37,7 +38,7 @@ async def load_experiment(
         return None
     [row] = found
     config = None if row["config"] is None else json.loads(str(row["config"]))
-    summary = summarize_config(config)
+    summary = summarize_config(config, mode)
     varies = cast(dict[str, list[object]], summary["varies"])
     source = experiment_runs(name, list(varies))
     summary = await check_counts(tables, source, summary)

{labnotes-0.0.43 → labnotes-0.0.45}/src/labnotes/models.py

@@ -4,6 +4,7 @@ from pathlib import Path
 from typing import Any
 
 from labnotes.default_counts import DEFAULT_COUNTS
+from labnotes.modes import DEFAULT_MODE
 
 Report = Callable[[dict[str, object]], None]
 
@@ -38,6 +39,8 @@ class LabnotesConfig:
     experiments: str
     files: str
     runs: str
+    mode: str = DEFAULT_MODE
+    concurrency: int = 1
 
 
 @dataclass(frozen=True)
@@ -47,4 +50,5 @@ class ExperimentConfig:
     params: dict[str, list[object]]
     name: str | None = None
     counts: str = DEFAULT_COUNTS
-    mode: str = "adhoc"
+    mode: str = DEFAULT_MODE
+    concurrency: int = 1

labnotes-0.0.45/src/labnotes/modes.py

@@ -0,0 +1,2 @@
+MODES = ("fill", "adhoc")
+DEFAULT_MODE = "adhoc"

labnotes-0.0.45/src/labnotes/read_config.py

@@ -0,0 +1,36 @@
+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 fill 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.43 → labnotes-0.0.45}/src/labnotes/read_path.py

@@ -11,13 +11,15 @@ PLACEHOLDERS = {
     "files": {"experiment"},
     "runs": {"experiment", "run"},
 }
+# Keys other readers own, so the path check lets them through.
+OTHER_KEYS = {"experiments": {"mode", "concurrency"}}
 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"})
+    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])

{labnotes-0.0.43 → labnotes-0.0.45}/src/labnotes/runner/read_experiment_config.py

@@ -4,12 +4,13 @@ from pathlib import Path
 
 from labnotes.default_counts import DEFAULT_COUNTS
 from labnotes.models import ExperimentConfig
+from labnotes.is_positive_int import is_positive_int
+from labnotes.modes import MODES
 
-SETTINGS = {"name", "command", "repeats", "params", "counts", "mode"}
-MODES = ("fill", "adhoc")
+SETTINGS = {"name", "command", "repeats", "params", "counts", "mode", "concurrency"}
 
 
-def read_experiment_config(path: Path) -> ExperimentConfig:
+def read_experiment_config(path: Path, mode: str, concurrency: int) -> ExperimentConfig:
     try:
         with path.open("rb") as file:
             values = tomllib.load(file)
@@ -25,7 +26,7 @@ def read_experiment_config(path: Path) -> ExperimentConfig:
     if not isinstance(command, str) or not command.strip():
         raise ValueError(f"{path}: command must be a string")
     repeats = values.get("repeats", 1)
-    if isinstance(repeats, bool) or not isinstance(repeats, int) or repeats < 1:
+    if not is_positive_int(repeats):
         raise ValueError(f"{path}: repeats must be a positive integer")
     params = values.get("params", {})
     if not isinstance(params, dict):
@@ -40,7 +41,10 @@ def read_experiment_config(path: Path) -> ExperimentConfig:
     counts = values.get("counts", DEFAULT_COUNTS)
     if not isinstance(counts, str) or not counts.strip():
         raise ValueError(f"{path}: counts must be a SQL condition")
-    mode = values.get("mode", "adhoc")
+    mode = values.get("mode", mode)
     if mode not in MODES:
         raise ValueError(f"{path}: mode must be fill or adhoc")
-    return ExperimentConfig(command, repeats, params, name, counts, mode)
+    concurrency = values.get("concurrency", concurrency)
+    if not is_positive_int(concurrency):
+        raise ValueError(f"{path}: concurrency must be a positive integer")
+    return ExperimentConfig(command, repeats, params, name, counts, mode, concurrency)

{labnotes-0.0.43 → labnotes-0.0.45}/src/labnotes/runner/start_experiment.py

@@ -13,7 +13,7 @@ def start_experiment(
     config: LabnotesConfig,
     name: str,
     experiment_config: Path | None,
-    concurrency: int,
+    concurrency: int | None,
     drive: Callable[[Start, str], list[dict[str, object]]],
 ) -> list[dict[str, object]]:
     if experiment_config is None:
@@ -21,7 +21,11 @@ def start_experiment(
         experiment_config = config.root / folder / "experiment.toml"
     if not experiment_config.is_file():
         raise ValueError(f"No experiment.toml for {name} at {experiment_config}.")
-    experiment = read_experiment_config(experiment_config)
+    experiment = read_experiment_config(
+        experiment_config, config.mode, config.concurrency
+    )
+    if concurrency is None:
+        concurrency = experiment.concurrency
     runs = runs_parent(config.root, config.runs, name)
     runs.mkdir(parents=True, exist_ok=True)
     try:

{labnotes-0.0.43 → labnotes-0.0.45}/src/labnotes/summarize_config.py

@@ -3,7 +3,7 @@ from math import prod
 from labnotes.default_counts import DEFAULT_COUNTS
 
 
-def summarize_config(config: dict[str, object] | None) -> dict[str, object]:
+def summarize_config(config: dict[str, object] | None, mode: str) -> dict[str, object]:
     config = config or {}
     params = config.get("params")
     varies = {
@@ -15,7 +15,7 @@ def summarize_config(config: dict[str, object] | None) -> dict[str, object]:
     cells = prod(len(values) for values in varies.values())
     command = config.get("command")
     counts = config.get("counts")
-    fill = config.get("mode") == "fill"
+    fill = config.get("mode", mode) == "fill"
     return {
         "fixed": {},
         "varies": varies,

{labnotes-0.0.43 → labnotes-0.0.45}/src/labnotes/tables/experiment_rows.py

@@ -18,7 +18,9 @@ async def experiment_rows(
         case str(), "runs":
             [row] = rows
             stored = row["config"]
-            summary = summarize_config(json.loads(str(stored)) if stored else None)
+            summary = summarize_config(
+                json.loads(str(stored)) if stored else None, config.mode
+            )
             return await list_experiment_runs(
                 tables, name, str(summary["completed_run"])
             )

{labnotes-0.0.43 → labnotes-0.0.45}/src/labnotes/tui/run_app.py

@@ -14,6 +14,7 @@ from labnotes.runner.stop_then_kill import stop_then_kill
 from labnotes.runner.param_args import param_args
 from labnotes.tui.dim import dim
 from labnotes.tui.format_elapsed import format_elapsed
+from labnotes.tui.runs_table import RunsTable
 
 COLUMNS = ("run", "params", "status", "time")
 OTHER_STREAM = {"stdout": "stderr", "stderr": "stdout"}
@@ -26,10 +27,10 @@ class RunApp(App[None]):
     BINDINGS = [
         Binding("ctrl+c", "interrupt", "Stop runs"),
         Binding("n", "run_next", "Run next"),
-        Binding("d", "toggle_run", "Deselect"),
+        Binding("space", "toggle_run", "Deselect"),
         Binding("D", "deselect_shown", "Deselect shown"),
-        Binding("k", "kill_run", "Stop run"),
-        Binding("h", "hide_failed", "Hide failed"),
+        Binding("x", "kill_run", "Stop run"),
+        Binding("f", "hide_failed", "Hide failed"),
         Binding("r", "retry", "Retry"),
         Binding("slash", "filter", "Filter", key_display="/"),
         Binding("e", "switch_output", "stdout/stderr"),
@@ -72,7 +73,7 @@ class RunApp(App[None]):
 
     def compose(self) -> ComposeResult:
         yield Header()
-        yield DataTable(id="runs", cursor_type="row")
+        yield RunsTable(id="runs", cursor_type="row")
         yield Log(id="output")
         yield Input(id="filter", placeholder="Filter params")
         yield Static(id="status")

labnotes-0.0.45/src/labnotes/tui/runs_table.py

@@ -0,0 +1,11 @@
+from textual.binding import Binding
+from textual.widgets import DataTable
+
+
+class RunsTable(DataTable[object]):
+    BINDINGS = [
+        Binding("j", "cursor_down", show=False),
+        Binding("k", "cursor_up", show=False),
+        Binding("g", "scroll_top", show=False),
+        Binding("G", "scroll_bottom", show=False),
+    ]

labnotes-0.0.43/src/labnotes/read_config.py

@@ -1,27 +0,0 @@
-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
-        },
-    )