labnotes 0.0.35__tar.gz → 0.0.37__tar.gz

{labnotes-0.0.35 → labnotes-0.0.37}/PKG-INFO

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

@@ -86,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.
 
@@ -98,7 +99,9 @@ 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. 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).

{labnotes-0.0.35 → labnotes-0.0.37}/src/labnotes/runner/run_experiment.py

@@ -53,7 +53,14 @@ async def run_experiment(
         planned.add(run)
         plan.append((run, params))
     runs = [{"run": run, "params": params} for run, params in plan]
-    report({"event": "planned", "runs": runs, "concurrency": concurrency})
+    report(
+        {
+            "event": "planned",
+            "runs": runs,
+            "concurrency": concurrency,
+            "mode": experiment.mode,
+        }
+    )
     running: dict[str, set[asyncio.subprocess.Process]] = {}
     stopped: set[str] = set()
     results: list[dict[str, object]] = []
@@ -166,7 +173,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.35 → labnotes-0.0.37}/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:
@@ -95,10 +107,14 @@ class RunApp(App[None]):
                 self.redraw(table.cursor_row)
                 self.show_concurrency(event)
                 self.show(describe_event(event))
+                match event["mode"], event["runs"]:
+                    case "adhoc", [only]:
+                        self.view(only["run"], "stdout")  # type: ignore[index]
             case "started":
                 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 +155,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 +166,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 +258,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