labnotes 0.0.121__tar.gz → 0.0.123__tar.gz

{labnotes-0.0.121 → labnotes-0.0.123}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.0.121
+Version: 0.0.123
 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.121 → labnotes-0.0.123}/pyproject.toml

@@ -36,7 +36,7 @@ labnotes = "labnotes.cli:main"
 
 [dependency-groups]
 dev = [
-    "curtaincall>=0.3.0",
+    "curtaincall>=0.4.0",
     "mypy>=2.4.0",
     "playwright>=1.64.0",
     "pytest>=8.0",

{labnotes-0.0.121 → labnotes-0.0.123}/src/labnotes/context.md

@@ -132,14 +132,10 @@ sets the seconds between samples; 0 turns it off.
 
 In a terminal, `run` shows a live table of runs (status, time, memory and
 folder size) and stays
-open when they finish. Failed runs show their status in red; `f` hides or shows them, and `r` on one
-runs it again under a new id, with `retry_of` set. `j` and `k` move the cursor, `g` and `G` jump to the
+open when they finish. Failed runs show their status in red. `j` and `k` move the cursor, `g` and `G` jump to the
 first and last row. 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. `m` grabs a pending run; `j` and `k` move it through the queue, Enter or `m`
-drops it, Escape puts it back. Space deselects a pending run so it won't run; Space again puts it back at
-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. `x` stops the
+`skipped` once stopped. `/` filters rows by params text; Enter keeps the filter,
+Escape clears it. `x` stops the
 running run under the cursor; `x` again kills it. `+` and
 `-` change how many run at once; lowering it lets running runs
 finish. Enter on a run follows its `stdout.log` and `stderr.log` together, as
@@ -180,9 +176,8 @@ going. Elsewhere, it prints a line per event instead.
   waits for a daemon when none is up. `--json` prints one JSON object per line.
   Following doesn't keep the daemon up.
 - `labnotes run control NAME ACTION [ARG]` sends one live-view control to a
-  running experiment: `kill`, `retry`, `run_next` or `toggle` a run, `move` a
-  run to a place in the queue counted from 0,
-  `set_concurrency` to a number, `interrupt` or `finish`.
+  running experiment: `kill` a run, `set_concurrency` to a number,
+  `interrupt` or `finish`.
 - A second `run` of the same experiment fails while the first is going.
 - It exits 0 even if runs fail; the summary line counts failures. A run that
   was retried counts as retried, not failed. If it can't

{labnotes-0.0.121 → labnotes-0.0.123}/src/labnotes/models.py

@@ -14,13 +14,9 @@ Report = Callable[[dict[str, object]], None]
 @dataclass(frozen=True)
 class Controls:
     interrupt: Callable[[], None]
-    run_next: Callable[[str], None]
     set_concurrency: Callable[[int], None]
-    toggle: Callable[[str], None]
     kill: Callable[[str], None]
-    retry: Callable[[str], None]
     finish: Callable[[], None]
-    move: Callable[[str, int], None]
 
 
 Listen = Callable[[Controls], None]

{labnotes-0.0.121 → labnotes-0.0.123}/src/labnotes/run_control.py

@@ -18,9 +18,7 @@ PARAMS = {
     name="control",
     help=(
         "Send one control to an experiment's runs, as the live view's keys do. "
-        "kill, retry, run_next and toggle take a run; move a run and its new place "
-        "in the queue, from 0; set_concurrency a number; "
-        "interrupt and finish nothing."
+        "kill takes a run; set_concurrency a number; interrupt and finish nothing."
     ),
 )
 @click.argument("name")

{labnotes-0.0.121 → labnotes-0.0.123}/src/labnotes/runner/describe_event.py

@@ -14,16 +14,6 @@ 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 "moved":
-            pending: list[str] = event["pending"]  # type: ignore[assignment]
-            place = pending.index(str(event["run"])) + 1
-            return f"{event['run']} moved to {place} of {len(pending)} in the queue."
-        case "deselected":
-            return f"{event['run']} deselected."
-        case "reselected":
-            return f"{event['run']} back in the queue."
         case "stopping run":
             return f"Stopping {event['run']}."
         case "killing run":

{labnotes-0.0.121 → labnotes-0.0.123}/src/labnotes/runner/run_experiment.py

@@ -128,43 +128,6 @@ async def run_experiment(
             report({"event": "stopping run", "run": run})
             signal_run(run, signal.SIGTERM)
 
-    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 = find(plan, run)
-        if entry is not None:
-            plan.remove(entry)
-            plan.insert(0, entry)
-            arrange("queued", run)
-
-    def move(run: str, place: int) -> None:
-        entry = find(plan, run)
-        if entry is not None:
-            plan.remove(entry)
-            plan.insert(max(0, place), entry)
-            arrange("moved", 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()
-
     ended: dict[str, dict[str, object]] = {}
     parents: dict[str, str] = {}
     attempts: dict[str, int] = {}
@@ -179,15 +142,6 @@ async def run_experiment(
         report({"event": "retried", "run": run, "retry": again, "params": ended[run]})
         fill()
 
-    def retry(run: str) -> None:
-        if stopping.is_set() or run not in ended:
-            return
-        if run in waiting:
-            waiting.pop(run).cancel()
-            requeue(run, attempts.get(run, 0) + 1)
-        else:
-            requeue(run, 0)
-
     def retry_later(run: str) -> None:
         tried = attempts.get(run, 0)
         if tried >= experiment.retries:
@@ -277,11 +231,7 @@ async def run_experiment(
         ):
             retry_later(run)
 
-    listen(
-        Controls(
-            interrupt, run_next, set_concurrency, toggle, kill, retry, finish, move
-        )
-    )
+    listen(Controls(interrupt, set_concurrency, kill, finish))
     fill()
     await done.wait()
     await asyncio.gather(*started)

{labnotes-0.0.121 → labnotes-0.0.123}/src/labnotes/tui/run_app.py

@@ -26,27 +26,15 @@ from labnotes.tui.runs_table import RunsTable
 
 PENDING, PASSED, FAILED = "○", "✓", "✗"
 SPINNER = "|/-\\"
-SKIPPED, DESELECTED = "–", "⊘"
+SKIPPED = "–"
 VIEWING_ACTIONS = {"leave", "quit", "interrupt", "command_palette"}
-GRABBED_ACTIONS = {"shift", "drop", "put_back"}
-GRABBING_ACTIONS = {*GRABBED_ACTIONS, "grab", "quit", "interrupt", "command_palette"}
 
 
 class RunApp(App[None]):
     CSS = "#concurrency { dock: right; width: auto; padding: 0 1; }"
     BINDINGS = [
         Binding("ctrl+c", "interrupt", "Quit"),
-        Binding("n", "run_next", "Run next"),
-        Binding("m", "grab", "Move"),
-        Binding("j,down", "shift(1)", priority=True),
-        Binding("k,up", "shift(-1)", priority=True),
-        Binding("enter", "drop", "Drop", priority=True),
-        Binding("escape", "put_back", "Put back"),
-        Binding("space", "toggle_run", "Deselect"),
-        Binding("D", "deselect_shown", "Deselect shown"),
         Binding("x", "kill_run", "Stop run"),
-        Binding("f", "hide_failed", "Hide failed"),
-        Binding("r", "retry", "Retry"),
         Binding("slash", "filter", "Filter", key_display="/"),
         Binding("escape", "leave", "Back"),
         Binding("plus,equals_sign", "concurrency(1)", "More at once", key_display="+"),
@@ -61,18 +49,10 @@ class RunApp(App[None]):
         self.results: list[dict[str, object]] = []
         self.error: Exception | None = None
         self.controls = Controls(
-            lambda: None,
-            lambda run: None,
-            lambda count: None,
-            lambda run: None,
-            lambda run: None,
-            lambda run: None,
-            lambda: None,
-            lambda run, place: None,
+            lambda: None, lambda count: None, lambda run: None, lambda: None
         )
         self.concurrency = 1
         self.idle = False
-        self.next_run: str | None = None
         self.ended: set[str] = set()
         self.frame = 0
         self.started: dict[str, float] = {}
@@ -82,11 +62,8 @@ class RunApp(App[None]):
         self.failed: set[str] = set()
         self.retried: set[str] = set()
         self.waiting: dict[str, float] = {}
-        self.hiding = False
         self.folders: dict[str, Path] = {}
         self.viewing: str | None = None
-        self.grabbed: str | None = None
-        self.grabbed_from: list[str] = []
         self.sampling = False
         self.unmeasured: dict[str, None] = {}
 
@@ -143,14 +120,10 @@ class RunApp(App[None]):
                     case "adhoc", [only]:
                         self.view(only["run"])  # type: ignore[index]
             case "started":
-                if run == self.grabbed:
-                    self.action_put_back()
                 self.idle = False
                 self.pending.discard(run)
                 self.started[run] = time.monotonic()
                 self.folders[run] = Path(str(event["folder"]))
-                if run == self.next_run:
-                    self.show("")
                 args = " ".join(param_args(event["params"]))  # type: ignore[arg-type]
                 shown = {
                     "run": run.rpartition("/")[2],
@@ -175,21 +148,6 @@ class RunApp(App[None]):
                 self.redraw(table.cursor_row)
                 self.unmeasured[run] = None
                 self.measure()
-            case "queued":
-                self.reposition(event, run)
-                self.next_run = run
-            case "moved":
-                self.reposition(event, run)
-            case "deselected":
-                self.pending.discard(run)
-                self.set_cell(run, "status", dim(DESELECTED))
-                self.reorder(event, table.cursor_row)
-                self.show(describe_event(event))
-            case "reselected":
-                self.pending.add(run)
-                self.set_cell(run, "status", dim(PENDING))
-                self.reorder(event, table.cursor_row)
-                self.show(describe_event(event))
             case "retrying":
                 self.waiting[run] = time.monotonic() + float(event["seconds"])  # type: ignore[arg-type]
                 self.tick()
@@ -233,25 +191,11 @@ class RunApp(App[None]):
         again = f" {retried} retried." if retried else ""
         self.show(f"{passed} passed, {failed} failed.{again} Ctrl-C to quit.")
 
-    def reposition(self, event: dict[str, object], run: str) -> None:
-        table = self.query_one(DataTable)
-        self.reorder(event, table.cursor_row)
-        table.move_cursor(row=table.get_row_index(run))
-        self.show(describe_event(event))
-
-    def reorder(self, event: dict[str, object], row: int) -> None:
-        self.release()
-        waiting: list[str] = [*event["pending"], *event["held"]]  # type: ignore[misc]
-        for run in waiting:
-            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():
-            hidden = self.hiding and run in self.failed
-            if self.filter in str(cells.get("params", "")) and not hidden:
+            if self.filter in str(cells.get("params", "")):
                 table.add_row(
                     *(cells.get(c, "") for c in self.columns),
                     key=run,
@@ -274,10 +218,8 @@ class RunApp(App[None]):
     def check_action(self, action: str, parameters: tuple[object, ...]) -> bool:
         if isinstance(self.screen, LeavePrompt):
             return False
-        if self.grabbed is not None:
-            return action in GRABBING_ACTIONS
-        if action in GRABBED_ACTIONS:
-            return False
+        if action == "leave" and self.viewing is None:
+            return self.query_one(Input).display
         return self.viewing is None or action in VIEWING_ACTIONS
 
     def show_concurrency(self, event: dict[str, object]) -> None:
@@ -324,7 +266,6 @@ class RunApp(App[None]):
             self.set_cell(run, "status", SPINNER[self.frame])
 
     def show(self, text: str) -> None:
-        self.next_run = None
         self.query_one("#status", Static).update(text)
 
     def stop_runs(self) -> None:
@@ -358,84 +299,10 @@ class RunApp(App[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 queue(self) -> list[str]:
-        return [run for run in self.cells if run in self.pending]
-
-    def action_grab(self) -> None:
-        if self.grabbed is not None:
-            self.action_drop()
-            return
-        run = self.cursor_run()
-        if run not in self.pending:
-            return
-        self.grabbed = run
-        self.grabbed_from = list(self.cells)
-        self.refresh_bindings()
-        self.show(f"Moving {run}. j/k moves it, Enter drops it, Escape puts it back.")
-
-    def action_shift(self, step: int) -> None:
-        run = str(self.grabbed)
-        queue = self.queue()
-        place = queue.index(run) + step
-        if place not in range(len(queue)):
-            return
-        order = list(self.cells)
-        here, there = order.index(run), order.index(queue[place])
-        order[here], order[there] = order[there], order[here]
-        self.cells = {key: self.cells[key] for key in order}
-        self.redraw_on(run)
-
-    def action_drop(self) -> None:
-        run = str(self.grabbed)
-        self.release()
-        self.show("")
-        self.controls.move(run, self.queue().index(run))
-
-    def action_put_back(self) -> None:
-        run = str(self.grabbed)
-        self.release()
-        places = {key: place for place, key in enumerate(self.grabbed_from)}
-        ordered = sorted(self.cells, key=lambda key: places.get(key, len(places)))
-        self.cells = {key: self.cells[key] for key in ordered}
-        self.redraw_on(run)
-        self.show("")
-
-    def release(self) -> None:
-        self.grabbed = None
-        self.refresh_bindings()
-
-    def redraw_on(self, run: str) -> None:
-        table = self.query_one(DataTable)
-        self.redraw(table.cursor_row)
-        table.move_cursor(row=table.get_row_index(run))
-
-    def action_toggle_run(self) -> 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)
 
-    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)
 
@@ -443,10 +310,10 @@ class RunApp(App[None]):
         field = self.query_one(Input)
         field.display = True
         field.focus()
+        self.refresh_bindings()
 
     def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
-        if self.grabbed is None:
-            self.view(str(event.row_key.value))
+        self.view(str(event.row_key.value))
 
     def view(self, run: str) -> None:
         self.viewing = run
@@ -481,6 +348,7 @@ class RunApp(App[None]):
         field.value = ""
         field.display = False
         self.query_one(DataTable).focus()
+        self.refresh_bindings()
 
     def on_input_changed(self, event: Input.Changed) -> None:
         self.filter = event.value
@@ -489,3 +357,4 @@ class RunApp(App[None]):
     def on_input_submitted(self, event: Input.Submitted) -> None:
         event.input.display = bool(event.value)
         self.query_one(DataTable).focus()
+        self.refresh_bindings()

{labnotes-0.0.121 → labnotes-0.0.123}/testing-conventions.toml

@@ -81,3 +81,9 @@ path = "src/labnotes/experiments.py"
 rules = ["mutation"]
 lines = [120]
 reason = "click hands back the \"json\" choice literal itself, so is not equals !="
+
+[[python.exempt]]
+path = "src/labnotes/tui/run_app.py"
+rules = ["mutation"]
+lines = [221]
+reason = "the leave action name is the string literal from the Binding, which CPython interns, so is equals =="

{labnotes-0.0.121 → labnotes-0.0.123}/uv.lock

@@ -237,15 +237,15 @@ wheels = [
 
 [[package]]
 name = "curtaincall"
-version = "0.3.0"
+version = "0.4.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pexpect" },
     { name = "pyte" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ca/12/056a3c89fcbc135b15a7cef872472a73bdad3594ddfccbe11b9a028b2f5f/curtaincall-0.3.0.tar.gz", hash = "sha256:afc9e9ce00a256982d69a737976527d38217082ca79fcafcf381fa2cd2bba041", size = 68784, upload-time = "2026-02-16T01:44:39.874Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4c/c3/14a2abeb4d38d1c381c33fb3fbd4d55675a0f98be8c39b15d688c546b3f3/curtaincall-0.4.0.tar.gz", hash = "sha256:b68c9652cb33eb0955e5b9307573302e8b6f260930a67ab69152c48db79b75cc", size = 33924, upload-time = "2026-10-26T14:16:25.535Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f8/52/1092ca83246b88a880f2fe35e38919b9e069c0ce97708880c4234ab72c32/curtaincall-0.3.0-py3-none-any.whl", hash = "sha256:4a754fa4a8ad726a00ec24ebb545f8f5a34a0f8d159936845d125bfeb2dfb652", size = 21504, upload-time = "2026-02-16T01:44:38.567Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/43/6c5749737b1fbb9a2757adf6df70ded2a38e832b63d4b4f9e75b6adf1080/curtaincall-0.4.0-py3-none-any.whl", hash = "sha256:2294a8b8e2d8cd10f47f5004ae7bc9b68ce9f7f1182c364dba294b3d190aa726", size = 29057, upload-time = "2026-10-26T14:16:24.342Z" },
 ]
 
 [[package]]
@@ -602,7 +602,7 @@ requires-dist = [
 
 [package.metadata.requires-dev]
 dev = [
-    { name = "curtaincall", specifier = ">=0.3.0" },
+    { name = "curtaincall", specifier = ">=0.4.0" },
     { name = "mypy", specifier = ">=2.4.0" },
     { name = "playwright", specifier = ">=1.64.0" },
     { name = "pytest", specifier = ">=8.0" },