labnotes 0.0.24__tar.gz → 0.0.25__tar.gz

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

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

@@ -87,7 +87,8 @@ 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; `q` quits. Elsewhere, or with `--no-tui`, it prints a
+`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.24 → 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.24 → labnotes-0.0.25}/src/labnotes/runner/describe_event.py

@@ -12,6 +12,8 @@ def describe_event(event: dict[str, object]) -> str:
         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.24 → 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
@@ -59,6 +65,14 @@ 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:
             run, params = plan.pop(0)
@@ -71,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.24 → 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.24 → labnotes-0.0.25}/src/labnotes/tui/run_app.py

@@ -1,12 +1,11 @@
 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
@@ -19,6 +18,7 @@ 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"),
     ]
 
@@ -27,14 +27,14 @@ 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()
 
@@ -54,8 +54,8 @@ 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:
@@ -81,6 +81,13 @@ class RunApp(App[None]):
                 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"))
@@ -102,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))