labnotes 0.0.25__tar.gz → 0.0.26__tar.gz

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

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

@@ -88,10 +88,12 @@ 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. `+` 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.26}/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.26}/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.26}/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.25 → labnotes-0.0.26}/src/labnotes/tui/run_app.py

@@ -19,6 +19,9 @@ class RunApp(App[None]):
     BINDINGS = [
         Binding("ctrl+c", "interrupt", "Stop runs"),
         Binding("n", "run_next", "Run next"),
+        Binding("d", "toggle_run", "Deselect"),
+        Binding("plus,equals_sign", "concurrency(1)", "More at once", key_display="+"),
+        Binding("minus", "concurrency(-1)", "Fewer at once", key_display="-"),
         Binding("q", "quit", "Quit"),
     ]
 
@@ -27,7 +30,10 @@ class RunApp(App[None]):
         self.start = start
         self.title = title
         self.results: list[dict[str, object]] = []
-        self.controls = Controls(lambda: None, lambda run: None)
+        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()
@@ -68,6 +74,7 @@ class RunApp(App[None]):
                     cells = (planned["run"], args, "pending", "")
                     table.add_row(*map(dim, cells), key=planned["run"])
                     self.pending.add(planned["run"])
+                self.show_concurrency(event)
                 self.show(describe_event(event))
             case "started":
                 self.pending.discard(run)
@@ -82,12 +89,22 @@ class RunApp(App[None]):
                 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)
+                self.reorder(event)
                 table.move_cursor(row=table.get_row_index(run))
                 self.show(describe_event(event))
+            case "deselected":
+                self.pending.discard(run)
+                table.update_cell(run, "status", dim("deselected"))
+                self.reorder(event)
+                self.show(describe_event(event))
+            case "reselected":
+                self.pending.add(run)
+                table.update_cell(run, "status", dim("pending"))
+                self.reorder(event)
+                self.show(describe_event(event))
+            case "concurrency":
+                self.show_concurrency(event)
+                self.show(describe_event(event))
             case "stopping":
                 for pending in self.pending:
                     table.update_cell(pending, "status", dim("skipped"))
@@ -95,6 +112,18 @@ class RunApp(App[None]):
             case _:
                 self.show(describe_event(event))
 
+    def reorder(self, event: dict[str, object]) -> None:
+        table = self.query_one(DataTable)
+        waiting: list[str] = [*event["pending"], *event["held"]]  # type: ignore[misc]
+        for run in waiting:
+            row = table.get_row(run)
+            table.remove_row(run)
+            table.add_row(*row, key=run)
+
+    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:
         table = self.query_one(DataTable)
         for run, began in self.started.items():
@@ -117,8 +146,20 @@ class RunApp(App[None]):
         else:
             self.show("Runs are still going. Ctrl-C stops them.")
 
-    def action_run_next(self) -> None:
+    def cursor_run(self) -> str | 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))
+        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)