labnotes 0.0.30__tar.gz → 0.0.32__tar.gz

{labnotes-0.0.30 → labnotes-0.0.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.0.30
+Version: 0.0.32
 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.32/src/labnotes/check_counts.py

@@ -0,0 +1,17 @@
+from dirsql import DirSQL
+
+
+async def check_counts(
+    tables: DirSQL, source: str, summary: dict[str, object]
+) -> dict[str, object]:
+    rule = str(summary["completed_run"])
+    try:
+        await tables.query(f"SELECT ({rule}) FROM {source} LIMIT 0")
+    except RuntimeError as error:
+        # A broken rule counts nothing, so the pages still render and say why.
+        return {
+            **summary,
+            "completed_run": "0",
+            "counts_error": f"{rule} doesn't work: {error}",
+        }
+    return summary

{labnotes-0.0.30 → labnotes-0.0.32}/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. Failed runs show their status in red. 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.30 → labnotes-0.0.32}/src/labnotes/list_experiments.py

@@ -3,6 +3,7 @@ from typing import cast
 
 from dirsql import DirSQL
 
+from labnotes.check_counts import check_counts
 from labnotes.experiment_progress import experiment_progress
 from labnotes.experiment_runs import experiment_runs
 from labnotes.summarize_config import summarize_config
@@ -19,6 +20,7 @@ async def list_experiments(tables: DirSQL) -> list[dict[str, object]]:
         summary = summarize_config(config)
         varies = cast(dict[str, list[object]], summary["varies"])
         source = experiment_runs(name, list(varies))
+        summary = await check_counts(tables, source, summary)
         progress = await experiment_progress(tables, source, summary)
         listed.append(
             {"name": name, "display_name": row["display_name"], **summary, **progress}

{labnotes-0.0.30 → labnotes-0.0.32}/src/labnotes/load_experiment.py

@@ -6,6 +6,7 @@ from typing import cast
 from dirsql import DirSQL
 
 from labnotes.experiment_notes import experiment_notes
+from labnotes.check_counts import check_counts
 from labnotes.experiment_progress import experiment_progress
 from labnotes.experiment_runs import experiment_runs
 from labnotes.list_runs import list_runs
@@ -39,6 +40,7 @@ async def load_experiment(
     summary = summarize_config(config)
     varies = cast(dict[str, list[object]], summary["varies"])
     source = experiment_runs(name, list(varies))
+    summary = await check_counts(tables, source, summary)
     progress = await experiment_progress(tables, source, summary)
     shown = ["id", *(key for key in varies if key != "id")]
     view = parse_run_view(params, shown)

{labnotes-0.0.30 → labnotes-0.0.32}/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.30 → labnotes-0.0.32}/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.30 → labnotes-0.0.32}/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.30 → labnotes-0.0.32}/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.30 → labnotes-0.0.32}/src/labnotes/static/labnotes.css

@@ -341,6 +341,7 @@ h2 .clear { font-family: var(--sans); font-size: 0.82rem; margin-left: 0.8rem; c
 .status { font-size: 0.8rem; font-weight: 700; }
 .status.good { color: var(--good); }
 .status.bad { color: var(--bad); }
+.counts-error { color: var(--bad); }
 
 .record {
   display: grid;

{labnotes-0.0.30 → labnotes-0.0.32}/src/labnotes/templates/experiment.html

@@ -66,7 +66,7 @@
     {% for key, value in e.other.items() %}
     <dt>{{ key }}</dt><dd><code>{{ value | value }}</code></dd>
     {% endfor %}
-    <dt>complete when</dt><dd><code>{{ e.completed_run }}</code></dd>
+    <dt>complete when</dt>{% if e.counts_error %}<dd class="counts-error">{{ e.counts_error }}</dd>{% else %}<dd><code>{{ e.completed_run }}</code></dd>{% endif %}
   </dl>
 </section>
 

{labnotes-0.0.30 → labnotes-0.0.32}/src/labnotes/templates/index.html

@@ -37,7 +37,9 @@
       </td>
       <td class="num" data-label="Runs">{{ experiment.runs }}</td>
       <td class="progress-col">
-        {% if experiment.filled is not none and experiment.target %}
+        {% if experiment.counts_error %}
+        <span class="counts-error" title="{{ experiment.counts_error }}">counts rule doesn't work</span>
+        {% elif experiment.filled is not none and experiment.target %}
         <div class="progress-line">
           {{ meter(experiment.filled, experiment.target) }}
           <span class="num">{{ experiment.filled }}<span class="of">/{{ experiment.target }}</span></span>

{labnotes-0.0.30 → labnotes-0.0.32}/src/labnotes/tui/run_app.py

@@ -23,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="+"),
@@ -41,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()
@@ -68,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
@@ -91,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]
@@ -100,9 +105,13 @@ class RunApp(App[None]):
             case "ended":
                 outcome = event["error"] or f"exited {event['exit_code']}"
                 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))
@@ -117,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))
@@ -137,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)
 
@@ -159,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.")
 
@@ -185,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)