labnotes 0.0.29__tar.gz → 0.0.31__tar.gz

{labnotes-0.0.29 → labnotes-0.0.31}/PKG-INFO

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

@@ -86,7 +86,8 @@ 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. Runs not started yet show grayed as `pending`, and as
+open when they finish. Failed runs show their status in red; `h` hides or shows them, and `r` on one
+runs it again under a new id. 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. `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,

{labnotes-0.0.29 → labnotes-0.0.31}/src/labnotes/models.py

@@ -15,6 +15,8 @@ class Controls:
     set_concurrency: Callable[[int], None]
     toggle: Callable[[str], None]
     kill: Callable[[str], None]
+    retry: Callable[[str], None]
+    finish: Callable[[], None]
 
 
 Listen = Callable[[Controls], None]

{labnotes-0.0.29 → labnotes-0.0.31}/src/labnotes/runner/describe_event.py

@@ -22,6 +22,10 @@ def describe_event(event: dict[str, object]) -> str:
             return f"Stopping {event['run']}."
         case "killing run":
             return f"Killing {event['run']}."
+        case "retried":
+            return f"{event['run']} retried as {event['retry']}."
+        case "idle":
+            return "No runs left."
         case "concurrency":
             return f"{event['concurrency']} at a time."
         case "stopping":

{labnotes-0.0.29 → labnotes-0.0.31}/src/labnotes/runner/run_experiment.py

@@ -113,10 +113,22 @@ async def run_experiment(
             arrange("reselected", run)
             fill()
 
+    ended: dict[str, dict[str, object]] = {}
+
+    def retry(run: str) -> None:
+        if stopping.is_set() or run not in ended:
+            return
+        again = new_run_id(taken)
+        planned.add(again)
+        plan.append((again, ended[run]))
+        report({"event": "retried", "run": run, "retry": again, "params": ended[run]})
+        fill()
+
     limit = concurrency
     live: set[asyncio.Task[None]] = set()
     started: list[asyncio.Task[None]] = []
-    idle = asyncio.Event()
+    finishing = False
+    done = asyncio.Event()
 
     def fill() -> None:
         while plan and len(live) < limit:
@@ -125,7 +137,15 @@ async def run_experiment(
             live.add(task)
             started.append(task)
         if not live:
-            idle.set()
+            report({"event": "idle"})
+            if finishing:
+                done.set()
+
+    def finish() -> None:
+        nonlocal finishing
+        finishing = True
+        if not (live or plan):
+            done.set()
 
     def end(task: asyncio.Task[None]) -> None:
         live.remove(task)
@@ -147,10 +167,11 @@ async def run_experiment(
         )
         del running[run]
         report({"event": "ended", "run": run, **result})
+        ended[run] = params
         results.append(result)
 
-    listen(Controls(interrupt, run_next, set_concurrency, toggle, kill))
+    listen(Controls(interrupt, run_next, set_concurrency, toggle, kill, retry, finish))
     fill()
-    await idle.wait()
+    await done.wait()
     await asyncio.gather(*started)
     return results

{labnotes-0.0.29 → labnotes-0.0.31}/src/labnotes/runner/run_headless.py

@@ -13,5 +13,6 @@ def run_headless(start: Start) -> list[dict[str, object]]:
         loop = asyncio.get_running_loop()
         loop.add_signal_handler(signal.SIGINT, controls.interrupt)
         stop_then_kill(controls.interrupt, signal.SIGTERM, signal.SIGHUP)
+        controls.finish()
 
     return asyncio.run(start(lambda event: click.echo(describe_event(event)), listen))

{labnotes-0.0.29 → labnotes-0.0.31}/src/labnotes/tui/run_app.py

@@ -1,6 +1,7 @@
 import signal
 import time
 
+from rich.text import Text
 from textual.app import App, ComposeResult
 from textual.binding import Binding
 from textual.widgets import DataTable, Footer, Header, Input, Static
@@ -22,6 +23,8 @@ class RunApp(App[None]):
         Binding("d", "toggle_run", "Deselect"),
         Binding("D", "deselect_shown", "Deselect shown"),
         Binding("k", "kill_run", "Stop run"),
+        Binding("h", "hide_failed", "Hide failed"),
+        Binding("r", "retry", "Retry"),
         Binding("slash", "filter", "Filter", key_display="/"),
         Binding("escape", "clear_filter", "Clear filter"),
         Binding("plus,equals_sign", "concurrency(1)", "More at once", key_display="+"),
@@ -40,13 +43,18 @@ class RunApp(App[None]):
             lambda count: None,
             lambda run: None,
             lambda run: None,
+            lambda run: None,
+            lambda: None,
         )
         self.concurrency = 1
-        self.done = False
+        self.idle = False
+        self.ended: set[str] = set()
         self.started: dict[str, float] = {}
         self.pending: set[str] = set()
         self.cells: dict[str, list[object]] = {}
         self.filter = ""
+        self.failed: set[str] = set()
+        self.hiding = False
 
     def compose(self) -> ComposeResult:
         yield Header()
@@ -67,10 +75,7 @@ class RunApp(App[None]):
 
     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.")
+        self.exit()
 
     def listen(self, controls: Controls) -> None:
         self.controls = controls
@@ -90,6 +95,7 @@ class RunApp(App[None]):
                 self.show_concurrency(event)
                 self.show(describe_event(event))
             case "started":
+                self.idle = False
                 self.pending.discard(run)
                 self.started[run] = time.monotonic()
                 args = " ".join(param_args(event["params"]))  # type: ignore[arg-type]
@@ -98,9 +104,14 @@ class RunApp(App[None]):
                     self.set_cell(run, column, cell)
             case "ended":
                 outcome = event["error"] or f"exited {event['exit_code']}"
-                self.set_cell(run, "status", outcome)
+                style = "red" if event["error"] or event["exit_code"] else ""
+                if style:
+                    self.failed.add(run)
+                self.ended.add(run)
+                self.set_cell(run, "status", Text(str(outcome), style=style))
                 self.tick()
                 del self.started[run]
+                self.redraw(table.cursor_row)
             case "queued":
                 self.reorder(event, table.cursor_row)
                 table.move_cursor(row=table.get_row_index(run))
@@ -115,6 +126,18 @@ class RunApp(App[None]):
                 self.set_cell(run, "status", dim("pending"))
                 self.reorder(event, table.cursor_row)
                 self.show(describe_event(event))
+            case "retried":
+                again = str(event["retry"])
+                args = " ".join(param_args(event["params"]))  # type: ignore[arg-type]
+                self.cells[again] = [*map(dim, (again, args, "pending", ""))]
+                self.pending.add(again)
+                self.redraw(table.cursor_row)
+                self.show(describe_event(event))
+            case "idle":
+                self.idle = True
+                failed = len(self.failed)
+                passed = len(self.ended) - failed
+                self.show(f"{passed} passed, {failed} failed. q to quit.")
             case "concurrency":
                 self.show_concurrency(event)
                 self.show(describe_event(event))
@@ -135,7 +158,8 @@ class RunApp(App[None]):
         table = self.query_one(DataTable)
         table.clear()
         for run, cells in self.cells.items():
-            if self.filter in str(cells[1]):
+            hidden = self.hiding and run in self.failed
+            if self.filter in str(cells[1]) and not hidden:
                 table.add_row(*cells, key=run)
         table.move_cursor(row=row)
 
@@ -157,14 +181,14 @@ class RunApp(App[None]):
         self.query_one("#status", Static).update(text)
 
     def action_interrupt(self) -> None:
-        if self.done:
-            self.exit()
+        if self.idle:
+            self.controls.finish()
         else:
             self.controls.interrupt()
 
     async def action_quit(self) -> None:
-        if self.done:
-            self.exit()
+        if self.idle:
+            self.controls.finish()
         else:
             self.show("Runs are still going. Ctrl-C stops them.")
 
@@ -183,6 +207,15 @@ class RunApp(App[None]):
         if (run := self.cursor_run()) is not None:
             self.controls.toggle(run)
 
+    def action_hide_failed(self) -> None:
+        self.hiding = not self.hiding
+        self.redraw(self.query_one(DataTable).cursor_row)
+        self.show("Failed runs hidden." if self.hiding else "Failed runs shown.")
+
+    def action_retry(self) -> None:
+        if (run := self.cursor_run()) is not None and run in self.failed:
+            self.controls.retry(run)
+
     def action_kill_run(self) -> None:
         if (run := self.cursor_run()) is not None:
             self.controls.kill(run)