labnotes 0.0.22__tar.gz → 0.0.24__tar.gz

{labnotes-0.0.22 → labnotes-0.0.24}/PKG-INFO

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

@@ -86,14 +86,16 @@ 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; `q` quits. Elsewhere, or with `--no-tui`, it prints a
+open when they finish. Runs not started yet show grayed as `pending`, and as
+`skipped` once stopped; `q` quits. Elsewhere, or with `--no-tui`, it prints a
 line per event instead.
 
 - `--concurrency N` runs N at a time (default 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,
-  then kills any still going 5 seconds later.
+  then kills any still going 5 seconds later. Once the runs are done, either
+  one closes the live view.
 - A second `run` of the same experiment fails while the first holds the lock.
 - It exits 1 if any run failed.
 

{labnotes-0.0.22 → labnotes-0.0.24}/src/labnotes/runner/describe_event.py

@@ -4,7 +4,8 @@ from labnotes.runner.param_args import param_args
 def describe_event(event: dict[str, object]) -> str:
     match event["event"]:
         case "planned":
-            return f"{event['runs']} runs to go, {event['concurrency']} at a time."
+            runs = len(event["runs"])  # type: ignore[arg-type]
+            return f"{runs} runs to go, {event['concurrency']} at a time."
         case "started":
             args = " ".join(param_args(event["params"]))  # type: ignore[arg-type]
             return f"{event['run']} started {args}".rstrip()

{labnotes-0.0.22 → labnotes-0.0.24}/src/labnotes/runner/run_experiment.py

@@ -22,10 +22,24 @@ async def run_experiment(
     report: Report,
     listen: Listen,
 ) -> list[dict[str, object]]:
-    runs = await list_experiment_runs(open_tables(config), name, experiment.counts)
-    finished = [json.loads(str(run["params"])) for run in runs if run["counted"]]
-    plan = plan_runs(param_grid(experiment.params), experiment.repeats, finished)
-    report({"event": "planned", "runs": len(plan), "concurrency": concurrency})
+    existing = await list_experiment_runs(open_tables(config), name, experiment.counts)
+    finished = [json.loads(str(run["params"])) for run in existing if run["counted"]]
+    planned: set[str] = set()
+
+    def taken(run: str) -> bool:
+        return (
+            run in planned or run_folder(config.root, config.runs, name, run).exists()
+        )
+
+    plan: list[tuple[str, dict[str, object]]] = []
+    for params in plan_runs(
+        param_grid(experiment.params), experiment.repeats, finished
+    ):
+        run = new_run_id(taken)
+        planned.add(run)
+        plan.append((run, params))
+    runs = [{"run": run, "params": params} for run, params in plan]
+    report({"event": "planned", "runs": runs, "concurrency": concurrency})
     running: set[asyncio.subprocess.Process] = set()
     results: list[dict[str, object]] = []
     stopping = asyncio.Event()
@@ -47,10 +61,7 @@ async def run_experiment(
 
     async def work() -> None:
         while plan:
-            params = plan.pop(0)
-            run = new_run_id(
-                lambda id_: run_folder(config.root, config.runs, name, id_).exists()
-            )
+            run, params = plan.pop(0)
             folder = run_folder(config.root, config.runs, name, run)
             folder.mkdir(parents=True)
             report({"event": "started", "run": run, "params": params})

labnotes-0.0.24/src/labnotes/tui/dim.py

@@ -0,0 +1,5 @@
+from rich.text import Text
+
+
+def dim(cell: str) -> Text:
+    return Text(cell, style="dim")

{labnotes-0.0.22 → labnotes-0.0.24}/src/labnotes/tui/run_app.py

@@ -10,8 +10,11 @@ from labnotes.models import Start
 from labnotes.runner.describe_event import describe_event
 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
 
+COLUMNS = ("run", "params", "status", "time")
+
 
 class RunApp(App[None]):
     BINDINGS = [
@@ -27,6 +30,7 @@ class RunApp(App[None]):
         self.interrupt: Callable[[], None] = lambda: None
         self.done = False
         self.started: dict[str, float] = {}
+        self.pending: set[str] = set()
 
     def compose(self) -> ComposeResult:
         yield Header()
@@ -36,7 +40,7 @@ class RunApp(App[None]):
 
     def on_mount(self) -> None:
         table = self.query_one(DataTable)
-        for column in ("run", "params", "status", "time"):
+        for column in COLUMNS:
             table.add_column(column, key=column)
 
     def on_ready(self) -> None:
@@ -52,21 +56,35 @@ class RunApp(App[None]):
 
     def listen(self, interrupt: Callable[[], None]) -> None:
         self.interrupt = interrupt
-        stop_then_kill(interrupt, signal.SIGTERM, signal.SIGHUP)
+        stop_then_kill(self.action_interrupt, signal.SIGTERM, signal.SIGHUP)
 
     def show_event(self, event: dict[str, object]) -> None:
         table = self.query_one(DataTable)
         run = str(event.get("run"))
         match event["event"]:
+            case "planned":
+                for planned in event["runs"]:  # type: ignore[attr-defined]
+                    args = " ".join(param_args(planned["params"]))
+                    cells = (planned["run"], args, "pending", "")
+                    table.add_row(*map(dim, cells), key=planned["run"])
+                    self.pending.add(planned["run"])
+                self.show(describe_event(event))
             case "started":
+                self.pending.discard(run)
                 self.started[run] = time.monotonic()
                 args = " ".join(param_args(event["params"]))  # type: ignore[arg-type]
-                table.add_row(run, args, "running", "0s", key=run)
+                cells = (run, args, "running", format_elapsed(0))
+                for column, cell in zip(COLUMNS, cells):
+                    table.update_cell(run, column, cell, update_width=True)
             case "ended":
                 outcome = event["error"] or f"exited {event['exit_code']}"
                 table.update_cell(run, "status", outcome, update_width=True)
                 self.tick()
                 del self.started[run]
+            case "stopping":
+                for pending in self.pending:
+                    table.update_cell(pending, "status", dim("skipped"))
+                self.show(describe_event(event))
             case _:
                 self.show(describe_event(event))