labnotes 0.0.34__tar.gz → 0.0.36__tar.gz

{labnotes-0.0.34 → labnotes-0.0.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.0.34
+Version: 0.0.36
 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.34 → labnotes-0.0.36}/src/labnotes/context.md

@@ -59,6 +59,8 @@ renaming the experiment means editing `name`.
 Each combination of `[params]` runs `repeats` times, round-robin. Only runs
 that count fill a combination, so running again fills in what failed or never
 ran.
+`mode = "adhoc"` skips that: every `run` runs each combination `repeats` times
+again, whatever is already on disk. The default is `mode = "fill"`.
 Each run gets a new run folder. `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.
@@ -84,6 +86,7 @@ A script run by labnotes should:
 - take its output folder as an argument, passed in `command` as `{run_dir}`, and write everything it produces there;
 - exit non-zero when it fails, so the run counts as failed and runs again next time;
 - stop any background process it starts before it exits; the run ends when `command` exits.
+- flush its output as it goes (`print(..., flush=True)`, or `PYTHONUNBUFFERED=1`), so the live view shows it as it happens.
 
 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.
 
@@ -96,7 +99,8 @@ 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
 `-` change how many run at once; lowering it lets running runs
-finish; `q` quits. Elsewhere, or with `--no-tui`, it prints a
+finish. Enter on a run follows its `stdout.log`; `e` switches to
+`stderr.log` and back, and Escape returns to the table. `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).

{labnotes-0.0.34 → labnotes-0.0.36}/src/labnotes/models.py

@@ -47,3 +47,4 @@ class ExperimentConfig:
     params: dict[str, list[object]]
     name: str | None = None
     counts: str = DEFAULT_COUNTS
+    mode: str = "fill"

{labnotes-0.0.34 → labnotes-0.0.36}/src/labnotes/runner/read_experiment_config.py

@@ -5,7 +5,8 @@ from pathlib import Path
 from labnotes.default_counts import DEFAULT_COUNTS
 from labnotes.models import ExperimentConfig
 
-SETTINGS = {"name", "command", "repeats", "params", "counts"}
+SETTINGS = {"name", "command", "repeats", "params", "counts", "mode"}
+MODES = ("fill", "adhoc")
 
 
 def read_experiment_config(path: Path) -> ExperimentConfig:
@@ -39,4 +40,7 @@ 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")
-    return ExperimentConfig(command, repeats, params, name, counts)
+    mode = values.get("mode", "fill")
+    if mode not in MODES:
+        raise ValueError(f"{path}: mode must be fill or adhoc")
+    return ExperimentConfig(command, repeats, params, name, counts, mode)

{labnotes-0.0.34 → labnotes-0.0.36}/src/labnotes/runner/run_experiment.py

@@ -31,8 +31,12 @@ async def run_experiment(
     report: Report,
     listen: Listen,
 ) -> list[dict[str, object]]:
-    existing = await list_experiment_runs(open_tables(config), name, experiment.counts)
-    finished = [json.loads(str(run["params"])) for run in existing if run["counted"]]
+    finished: list[dict[str, object]] = []
+    match experiment.mode:
+        case "fill":
+            tables = open_tables(config)
+            existing = await list_experiment_runs(tables, name, experiment.counts)
+            finished = [json.loads(str(r["params"])) for r in existing if r["counted"]]
     planned: set[str] = set()
 
     def taken(run: str) -> bool:
@@ -162,7 +166,7 @@ async def run_experiment(
     async def start(run: str, params: dict[str, object]) -> None:
         folder = run_folder(config.root, config.runs, name, run)
         folder.mkdir(parents=True)
-        report({"event": "started", "run": run, "params": params})
+        report({"event": "started", "run": run, "params": params, "folder": folder})
         running[run] = set()
         result = await execute_run(
             config.root,

{labnotes-0.0.34 → labnotes-0.0.36}/src/labnotes/tui/run_app.py

@@ -1,10 +1,12 @@
+import codecs
 import signal
 import time
+from pathlib import Path
 
 from rich.text import Text
 from textual.app import App, ComposeResult
 from textual.binding import Binding
-from textual.widgets import DataTable, Footer, Header, Input, Static
+from textual.widgets import DataTable, Footer, Header, Input, Log, Static
 
 from labnotes.models import Controls, Start
 from labnotes.runner.describe_event import describe_event
@@ -14,6 +16,7 @@ from labnotes.tui.dim import dim
 from labnotes.tui.format_elapsed import format_elapsed
 
 COLUMNS = ("run", "params", "status", "time")
+OTHER_STREAM = {"stdout": "stderr", "stderr": "stdout"}
 
 
 class RunApp(App[None]):
@@ -26,7 +29,8 @@ class RunApp(App[None]):
         Binding("h", "hide_failed", "Hide failed"),
         Binding("r", "retry", "Retry"),
         Binding("slash", "filter", "Filter", key_display="/"),
-        Binding("escape", "clear_filter", "Clear filter"),
+        Binding("e", "switch_output", "stdout/stderr"),
+        Binding("escape", "leave", "Back"),
         Binding("plus,equals_sign", "concurrency(1)", "More at once", key_display="+"),
         Binding("minus", "concurrency(-1)", "Fewer at once", key_display="-"),
         Binding("q", "quit", "Quit"),
@@ -56,10 +60,16 @@ class RunApp(App[None]):
         self.filter = ""
         self.failed: set[str] = set()
         self.hiding = False
+        self.folders: dict[str, Path] = {}
+        self.viewing: str | None = None
+        self.stream = "stdout"
+        self.offset: int
+        self.decoder = codecs.getincrementaldecoder("utf-8")(errors="replace")
 
     def compose(self) -> ComposeResult:
         yield Header()
         yield DataTable(id="runs", cursor_type="row")
+        yield Log(id="output")
         yield Input(id="filter", placeholder="Filter params")
         yield Static(id="status")
         yield Footer()
@@ -69,9 +79,11 @@ class RunApp(App[None]):
         for column in COLUMNS:
             table.add_column(column, key=column)
         self.query_one(Input).display = False
+        self.query_one(Log).display = False
 
     def on_ready(self) -> None:
         self.set_interval(1, self.tick)
+        self.set_interval(0.25, self.follow)
         self.run_worker(self.drive())
 
     async def drive(self) -> None:
@@ -99,6 +111,7 @@ class RunApp(App[None]):
                 self.idle = False
                 self.pending.discard(run)
                 self.started[run] = time.monotonic()
+                self.folders[run] = Path(str(event["folder"]))
                 if run == self.next_run:
                     self.show("")
                 args = " ".join(param_args(event["params"]))  # type: ignore[arg-type]
@@ -139,9 +152,7 @@ class RunApp(App[None]):
                 self.show(describe_event(event))
             case "idle":
                 self.idle = True
-                failed = len(self.failed)
-                passed = len(self.ended) - failed
-                self.show(f"{passed} passed, {failed} failed. q to quit.")
+                self.show_summary()
             case "concurrency":
                 self.show_concurrency(event)
                 self.show(describe_event(event))
@@ -152,6 +163,11 @@ class RunApp(App[None]):
             case _:
                 self.show(describe_event(event))
 
+    def show_summary(self) -> None:
+        failed = len(self.failed)
+        passed = len(self.ended) - failed
+        self.show(f"{passed} passed, {failed} failed. q to quit.")
+
     def reorder(self, event: dict[str, object], row: int) -> None:
         waiting: list[str] = [*event["pending"], *event["held"]]  # type: ignore[misc]
         for run in waiting:
@@ -239,7 +255,46 @@ class RunApp(App[None]):
         field.display = True
         field.focus()
 
-    def action_clear_filter(self) -> None:
+    def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
+        self.view(str(event.row_key.value), "stdout")
+
+    def view(self, run: str, stream: str) -> None:
+        self.viewing = run
+        self.stream = stream
+        self.offset = 0
+        self.decoder.reset()
+        self.query_one(Log).clear()
+        self.query_one(DataTable).display = False
+        self.query_one(Log).display = True
+        self.show(f"{run} {stream}. e switches, Escape goes back.")
+        self.follow()
+
+    def follow(self) -> None:
+        if self.viewing not in self.folders:
+            return
+        path = self.folders[self.viewing] / f"{self.stream}.log"
+        if not path.exists():
+            return
+        with path.open("rb") as log:
+            log.seek(self.offset)
+            data = log.read()
+        self.offset += len(data)
+        self.query_one(Log).write(self.decoder.decode(data))
+
+    def action_switch_output(self) -> None:
+        if self.viewing is not None:
+            self.view(self.viewing, OTHER_STREAM[self.stream])
+
+    def action_leave(self) -> None:
+        if self.viewing is not None:
+            self.viewing = None
+            self.query_one(Log).display = False
+            self.query_one(DataTable).display = True
+            if self.idle:
+                self.show_summary()
+            else:
+                self.show("")
+            return
         field = self.query_one(Input)
         field.value = ""
         field.display = False