labnotes 0.0.26__tar.gz → 0.0.28__tar.gz

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

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

@@ -89,7 +89,9 @@ 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. `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
+the end of the queue. `/` filters rows by params text; Enter keeps the filter,
+Escape clears it. `D` deselects every pending run the filter shows. `+` 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.
 

{labnotes-0.0.26 → labnotes-0.0.28}/src/labnotes/tui/run_app.py

@@ -3,7 +3,7 @@ import time
 
 from textual.app import App, ComposeResult
 from textual.binding import Binding
-from textual.widgets import DataTable, Footer, Header, Static
+from textual.widgets import DataTable, Footer, Header, Input, Static
 
 from labnotes.models import Controls, Start
 from labnotes.runner.describe_event import describe_event
@@ -20,6 +20,9 @@ class RunApp(App[None]):
         Binding("ctrl+c", "interrupt", "Stop runs"),
         Binding("n", "run_next", "Run next"),
         Binding("d", "toggle_run", "Deselect"),
+        Binding("D", "deselect_shown", "Deselect shown"),
+        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"),
@@ -37,10 +40,13 @@ class RunApp(App[None]):
         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()
 
@@ -48,6 +54,7 @@ class RunApp(App[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)
@@ -72,8 +79,9 @@ class RunApp(App[None]):
                 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.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":
@@ -82,54 +90,63 @@ class RunApp(App[None]):
                 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)
+                    self.set_cell(run, column, cell)
             case "ended":
                 outcome = event["error"] or f"exited {event['exit_code']}"
-                table.update_cell(run, "status", outcome, update_width=True)
+                self.set_cell(run, "status", outcome)
                 self.tick()
                 del self.started[run]
             case "queued":
-                self.reorder(event)
+                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)
-                table.update_cell(run, "status", dim("deselected"))
-                self.reorder(event)
+                self.set_cell(run, "status", dim("deselected"))
+                self.reorder(event, table.cursor_row)
                 self.show(describe_event(event))
             case "reselected":
                 self.pending.add(run)
-                table.update_cell(run, "status", dim("pending"))
-                self.reorder(event)
+                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:
-                    table.update_cell(pending, "status", dim("skipped"))
+                    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]) -> None:
-        table = self.query_one(DataTable)
+    def reorder(self, event: dict[str, object], row: int) -> None:
         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)
+            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:
-        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
-            )
+            self.set_cell(run, "time", format_elapsed(time.monotonic() - began))
 
     def show(self, text: str) -> None:
         self.query_one("#status", Static).update(text)
@@ -161,5 +178,30 @@ class RunApp(App[None]):
         if (run := self.cursor_run()) is not None:
             self.controls.toggle(run)
 
+    def action_deselect_shown(self) -> None:
+        shown = [str(key.value) for key in self.query_one(DataTable).rows]
+        for run in shown:
+            if run in self.pending:
+                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()