labnotes 0.0.23__tar.gz → 0.0.25__tar.gz

{labnotes-0.0.23 → labnotes-0.0.25}/PKG-INFO

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

@@ -86,7 +86,9 @@ 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. Move the cursor to a pending run and press `n` to run it
+next; `q` quits. Elsewhere, or with `--no-tui`, it prints a
 line per event instead.
 
 - `--concurrency N` runs N at a time (default 1).

{labnotes-0.0.23 → labnotes-0.0.25}/src/labnotes/models.py

@@ -6,7 +6,15 @@ from typing import Any
 from labnotes.default_counts import DEFAULT_COUNTS
 
 Report = Callable[[dict[str, object]], None]
-Listen = Callable[[Callable[[], None]], None]
+
+
+@dataclass(frozen=True)
+class Controls:
+    interrupt: Callable[[], None]
+    run_next: Callable[[str], None]
+
+
+Listen = Callable[[Controls], None]
 Start = Callable[[Report, Listen], Coroutine[Any, Any, list[dict[str, object]]]]
 
 

{labnotes-0.0.23 → labnotes-0.0.25}/src/labnotes/runner/describe_event.py

@@ -4,13 +4,16 @@ 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()
         case "ended":
             outcome = event["error"] or f"exited {event['exit_code']}"
             return f"{event['run']} {outcome}"
+        case "queued":
+            return f"{event['run']} runs next."
         case "stopping":
             return "Stopping runs. Ctrl-C again to kill them."
         case _:

{labnotes-0.0.23 → labnotes-0.0.25}/src/labnotes/runner/run_experiment.py

@@ -4,7 +4,13 @@ import json
 import os
 import signal
 
-from labnotes.models import ExperimentConfig, LabnotesConfig, Listen, Report
+from labnotes.models import (
+    Controls,
+    ExperimentConfig,
+    LabnotesConfig,
+    Listen,
+    Report,
+)
 from labnotes.runner.execute_run import execute_run
 from labnotes.runner.new_run_id import new_run_id
 from labnotes.runner.param_grid import param_grid
@@ -22,10 +28,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()
@@ -45,12 +65,17 @@ async def run_experiment(
             report({"event": "killing"})
             signal_runs(signal.SIGKILL)
 
+    def run_next(run: str) -> None:
+        entry = next((entry for entry in plan if entry[0] == run), None)
+        if entry is not None:
+            plan.remove(entry)
+            plan.insert(0, entry)
+            pending = [id_ for id_, _ in plan]
+            report({"event": "queued", "run": run, "pending": pending})
+
     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})
@@ -60,6 +85,6 @@ async def run_experiment(
             report({"event": "ended", "run": run, **result})
             results.append(result)
 
-    listen(interrupt)
+    listen(Controls(interrupt, run_next))
     await asyncio.gather(*(work() for _ in range(concurrency)))
     return results

{labnotes-0.0.23 → labnotes-0.0.25}/src/labnotes/runner/run_headless.py

@@ -1,17 +1,17 @@
 import asyncio
 import signal
-from collections.abc import Callable
 
 import click
 
-from labnotes.models import Start
+from labnotes.models import Controls, Start
 from labnotes.runner.describe_event import describe_event
 from labnotes.runner.stop_then_kill import stop_then_kill
 
 
 def run_headless(start: Start) -> list[dict[str, object]]:
-    def listen(interrupt: Callable[[], None]) -> None:
-        asyncio.get_running_loop().add_signal_handler(signal.SIGINT, interrupt)
-        stop_then_kill(interrupt, signal.SIGTERM, signal.SIGHUP)
+    def listen(controls: Controls) -> None:
+        loop = asyncio.get_running_loop()
+        loop.add_signal_handler(signal.SIGINT, controls.interrupt)
+        stop_then_kill(controls.interrupt, signal.SIGTERM, signal.SIGHUP)
 
     return asyncio.run(start(lambda event: click.echo(describe_event(event)), listen))

labnotes-0.0.25/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.23 → labnotes-0.0.25}/src/labnotes/tui/run_app.py

@@ -1,21 +1,24 @@
 import signal
 import time
-from collections.abc import Callable
 
 from textual.app import App, ComposeResult
 from textual.binding import Binding
 from textual.widgets import DataTable, Footer, Header, Static
 
-from labnotes.models import Start
+from labnotes.models import Controls, 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 = [
         Binding("ctrl+c", "interrupt", "Stop runs"),
+        Binding("n", "run_next", "Run next"),
         Binding("q", "quit", "Quit"),
     ]
 
@@ -24,19 +27,20 @@ class RunApp(App[None]):
         self.start = start
         self.title = title
         self.results: list[dict[str, object]] = []
-        self.interrupt: Callable[[], None] = lambda: None
+        self.controls = Controls(lambda: None, lambda run: None)
         self.done = False
         self.started: dict[str, float] = {}
+        self.pending: set[str] = set()
 
     def compose(self) -> ComposeResult:
         yield Header()
-        yield DataTable(id="runs", cursor_type="none")
+        yield DataTable(id="runs", cursor_type="row")
         yield Static(id="status")
         yield Footer()
 
     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:
@@ -50,23 +54,44 @@ class RunApp(App[None]):
         passed = len(self.results) - failed
         self.show(f"{passed} passed, {failed} failed. q to quit.")
 
-    def listen(self, interrupt: Callable[[], None]) -> None:
-        self.interrupt = interrupt
+    def listen(self, controls: Controls) -> None:
+        self.controls = controls
         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 "queued":
+                for pending in event["pending"]:  # type: ignore[attr-defined]
+                    row = table.get_row(pending)
+                    table.remove_row(pending)
+                    table.add_row(*row, key=pending)
+                table.move_cursor(row=table.get_row_index(run))
+                self.show(describe_event(event))
+            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))
 
@@ -84,10 +109,16 @@ class RunApp(App[None]):
         if self.done:
             self.exit()
         else:
-            self.interrupt()
+            self.controls.interrupt()
 
     async def action_quit(self) -> None:
         if self.done:
             self.exit()
         else:
             self.show("Runs are still going. Ctrl-C stops them.")
+
+    def action_run_next(self) -> None:
+        table = self.query_one(DataTable)
+        if table.row_count:
+            cell = table.coordinate_to_cell_key(table.cursor_coordinate)
+            self.controls.run_next(str(cell.row_key.value))