labnotes 0.0.25__tar.gz → 0.0.27__tar.gz

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

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

@@ -88,10 +88,13 @@ Runs can take a long time. Start `run` in the background, then check on it with
 In a terminal, `run` shows a live table of runs (status and time) and stays
 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
+next. `d` deselects a pending run so it won't run; `d` again puts it back at
+the end of the queue. `/` filters rows by params text; Enter keeps the filter,
+Escape clears it. `+` and `-` change how many run at once; lowering it lets running runs
+finish; `q` quits. Elsewhere, or with `--no-tui`, it prints a
 line per event instead.
 
-- `--concurrency N` runs N at a time (default 1).
+- `--concurrency N` runs N at a time to start with (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,

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

@@ -12,6 +12,8 @@ Report = Callable[[dict[str, object]], None]
 class Controls:
     interrupt: Callable[[], None]
     run_next: Callable[[str], None]
+    set_concurrency: Callable[[int], None]
+    toggle: Callable[[str], None]
 
 
 Listen = Callable[[Controls], None]

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

@@ -14,6 +14,12 @@ def describe_event(event: dict[str, object]) -> str:
             return f"{event['run']} {outcome}"
         case "queued":
             return f"{event['run']} runs next."
+        case "deselected":
+            return f"{event['run']} deselected."
+        case "reselected":
+            return f"{event['run']} back in the queue."
+        case "concurrency":
+            return f"{event['concurrency']} at a time."
         case "stopping":
             return "Stopping runs. Ctrl-C again to kill them."
         case _:

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

@@ -19,6 +19,8 @@ from labnotes.runner.run_folder import run_folder
 from labnotes.tables.list_experiment_runs import list_experiment_runs
 from labnotes.tables.open_tables import open_tables
 
+Entry = tuple[str, dict[str, object]]
+
 
 async def run_experiment(
     config: LabnotesConfig,
@@ -37,7 +39,7 @@ async def run_experiment(
             run in planned or run_folder(config.root, config.runs, name, run).exists()
         )
 
-    plan: list[tuple[str, dict[str, object]]] = []
+    plan: list[Entry] = []
     for params in plan_runs(
         param_grid(experiment.params), experiment.repeats, finished
     ):
@@ -65,26 +67,72 @@ async def run_experiment(
             report({"event": "killing"})
             signal_runs(signal.SIGKILL)
 
+    held: list[Entry] = []
+
+    def find(entries: list[Entry], run: str) -> Entry | None:
+        return next((entry for entry in entries if entry[0] == run), None)
+
+    def arrange(event: str, run: str) -> None:
+        pending = [id_ for id_, _ in plan]
+        deselected = [id_ for id_, _ in held]
+        report({"event": event, "run": run, "pending": pending, "held": deselected})
+
     def run_next(run: str) -> None:
-        entry = next((entry for entry in plan if entry[0] == run), None)
+        entry = find(plan, run)
         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:
-            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})
-            result = await execute_run(
-                config.root, folder, experiment.command, params, running, stopping
-            )
-            report({"event": "ended", "run": run, **result})
-            results.append(result)
-
-    listen(Controls(interrupt, run_next))
-    await asyncio.gather(*(work() for _ in range(concurrency)))
+            arrange("queued", run)
+
+    def toggle(run: str) -> None:
+        if stopping.is_set():
+            return
+        if (entry := find(plan, run)) is not None:
+            plan.remove(entry)
+            held.append(entry)
+            arrange("deselected", run)
+        elif (entry := find(held, run)) is not None:
+            held.remove(entry)
+            plan.append(entry)
+            arrange("reselected", run)
+            fill()
+
+    limit = concurrency
+    live: set[asyncio.Task[None]] = set()
+    started: list[asyncio.Task[None]] = []
+    idle = asyncio.Event()
+
+    def fill() -> None:
+        while plan and len(live) < limit:
+            task = asyncio.create_task(start(*plan.pop(0)))
+            task.add_done_callback(end)
+            live.add(task)
+            started.append(task)
+        if not live:
+            idle.set()
+
+    def end(task: asyncio.Task[None]) -> None:
+        live.remove(task)
+        fill()
+
+    def set_concurrency(count: int) -> None:
+        nonlocal limit
+        limit = max(1, count)
+        report({"event": "concurrency", "concurrency": limit})
+        fill()
+
+    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})
+        result = await execute_run(
+            config.root, folder, experiment.command, params, running, stopping
+        )
+        report({"event": "ended", "run": run, **result})
+        results.append(result)
+
+    listen(Controls(interrupt, run_next, set_concurrency, toggle))
+    fill()
+    await idle.wait()
+    await asyncio.gather(*started)
     return results

labnotes-0.0.27/src/labnotes/tui/run_app.py

@@ -0,0 +1,200 @@
+import signal
+import time
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.widgets import DataTable, Footer, Header, Input, Static
+
+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("d", "toggle_run", "Deselect"),
+        Binding("slash", "filter", "Filter", key_display="/"),
+        Binding("escape", "clear_filter", "Clear filter"),
+        Binding("plus,equals_sign", "concurrency(1)", "More at once", key_display="+"),
+        Binding("minus", "concurrency(-1)", "Fewer at once", key_display="-"),
+        Binding("q", "quit", "Quit"),
+    ]
+
+    def __init__(self, start: Start, title: str) -> None:
+        super().__init__()
+        self.start = start
+        self.title = title
+        self.results: list[dict[str, object]] = []
+        self.controls = Controls(
+            lambda: None, lambda run: None, lambda count: None, lambda run: None
+        )
+        self.concurrency = 1
+        self.done = False
+        self.started: dict[str, float] = {}
+        self.pending: set[str] = set()
+        self.cells: dict[str, list[object]] = {}
+        self.filter = ""
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield DataTable(id="runs", cursor_type="row")
+        yield Input(id="filter", placeholder="Filter params")
+        yield Static(id="status")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        table = self.query_one(DataTable)
+        for column in COLUMNS:
+            table.add_column(column, key=column)
+        self.query_one(Input).display = False
+
+    def on_ready(self) -> None:
+        self.set_interval(1, self.tick)
+        self.run_worker(self.drive())
+
+    async def drive(self) -> None:
+        self.results = await self.start(self.show_event, self.listen)
+        self.done = True
+        failed = sum(result["exit_code"] != 0 for result in self.results)
+        passed = len(self.results) - failed
+        self.show(f"{passed} passed, {failed} failed. q to quit.")
+
+    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", "")
+                    self.cells[planned["run"]] = [*map(dim, cells)]
+                    self.pending.add(planned["run"])
+                self.redraw(table.cursor_row)
+                self.show_concurrency(event)
+                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]
+                cells = (run, args, "running", format_elapsed(0))
+                for column, cell in zip(COLUMNS, cells):
+                    self.set_cell(run, column, cell)
+            case "ended":
+                outcome = event["error"] or f"exited {event['exit_code']}"
+                self.set_cell(run, "status", outcome)
+                self.tick()
+                del self.started[run]
+            case "queued":
+                self.reorder(event, table.cursor_row)
+                table.move_cursor(row=table.get_row_index(run))
+                self.show(describe_event(event))
+            case "deselected":
+                self.pending.discard(run)
+                self.set_cell(run, "status", dim("deselected"))
+                self.reorder(event, table.cursor_row)
+                self.show(describe_event(event))
+            case "reselected":
+                self.pending.add(run)
+                self.set_cell(run, "status", dim("pending"))
+                self.reorder(event, table.cursor_row)
+                self.show(describe_event(event))
+            case "concurrency":
+                self.show_concurrency(event)
+                self.show(describe_event(event))
+            case "stopping":
+                for pending in self.pending:
+                    self.set_cell(pending, "status", dim("skipped"))
+                self.show(describe_event(event))
+            case _:
+                self.show(describe_event(event))
+
+    def reorder(self, event: dict[str, object], row: int) -> None:
+        waiting: list[str] = [*event["pending"], *event["held"]]  # type: ignore[misc]
+        for run in waiting:
+            self.cells[run] = self.cells.pop(run)
+        self.redraw(row)
+
+    def redraw(self, row: int) -> None:
+        table = self.query_one(DataTable)
+        table.clear()
+        for run, cells in self.cells.items():
+            if self.filter in str(cells[1]):
+                table.add_row(*cells, key=run)
+        table.move_cursor(row=row)
+
+    def set_cell(self, run: str, column: str, cell: object) -> None:
+        self.cells[run][COLUMNS.index(column)] = cell
+        table = self.query_one(DataTable)
+        if run in table.rows:
+            table.update_cell(run, column, cell, update_width=True)
+
+    def show_concurrency(self, event: dict[str, object]) -> None:
+        self.concurrency = int(event["concurrency"])  # type: ignore[call-overload]
+        self.sub_title = f"{self.concurrency} at a time"
+
+    def tick(self) -> None:
+        for run, began in self.started.items():
+            self.set_cell(run, "time", format_elapsed(time.monotonic() - began))
+
+    def show(self, text: str) -> None:
+        self.query_one("#status", Static).update(text)
+
+    def action_interrupt(self) -> None:
+        if self.done:
+            self.exit()
+        else:
+            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 cursor_run(self) -> str | None:
+        table = self.query_one(DataTable)
+        if not table.row_count:
+            return None
+        cell = table.coordinate_to_cell_key(table.cursor_coordinate)
+        return str(cell.row_key.value)
+
+    def action_run_next(self) -> None:
+        if (run := self.cursor_run()) is not None:
+            self.controls.run_next(run)
+
+    def action_toggle_run(self) -> None:
+        if (run := self.cursor_run()) is not None:
+            self.controls.toggle(run)
+
+    def action_concurrency(self, change: int) -> None:
+        self.controls.set_concurrency(self.concurrency + change)
+
+    def action_filter(self) -> None:
+        field = self.query_one(Input)
+        field.display = True
+        field.focus()
+
+    def action_clear_filter(self) -> None:
+        field = self.query_one(Input)
+        field.value = ""
+        field.display = False
+        self.query_one(DataTable).focus()
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        self.filter = event.value
+        self.redraw(self.query_one(DataTable).cursor_row)
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        event.input.display = bool(event.value)
+        self.query_one(DataTable).focus()

labnotes-0.0.25/src/labnotes/tui/run_app.py

@@ -1,124 +0,0 @@
-import signal
-import time
-
-from textual.app import App, ComposeResult
-from textual.binding import Binding
-from textual.widgets import DataTable, Footer, Header, Static
-
-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"),
-    ]
-
-    def __init__(self, start: Start, title: str) -> None:
-        super().__init__()
-        self.start = start
-        self.title = title
-        self.results: list[dict[str, object]] = []
-        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="row")
-        yield Static(id="status")
-        yield Footer()
-
-    def on_mount(self) -> None:
-        table = self.query_one(DataTable)
-        for column in COLUMNS:
-            table.add_column(column, key=column)
-
-    def on_ready(self) -> None:
-        self.set_interval(1, self.tick)
-        self.run_worker(self.drive())
-
-    async def drive(self) -> None:
-        self.results = await self.start(self.show_event, self.listen)
-        self.done = True
-        failed = sum(result["exit_code"] != 0 for result in self.results)
-        passed = len(self.results) - failed
-        self.show(f"{passed} passed, {failed} failed. q to quit.")
-
-    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]
-                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))
-
-    def tick(self) -> None:
-        table = self.query_one(DataTable)
-        for run, began in self.started.items():
-            table.update_cell(
-                run, "time", format_elapsed(time.monotonic() - began), update_width=True
-            )
-
-    def show(self, text: str) -> None:
-        self.query_one("#status", Static).update(text)
-
-    def action_interrupt(self) -> None:
-        if self.done:
-            self.exit()
-        else:
-            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))