labnotes 0.0.27__tar.gz → 0.0.29__tar.gz

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

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

@@ -90,7 +90,9 @@ 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. `/` filters rows by params text; Enter keeps the filter,
-Escape clears it. `+` and `-` change how many run at once; lowering it lets running runs
+Escape clears it. `D` deselects every pending run the filter shows. `k` stops the
+running run under the cursor; `k` again kills it. `+` 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.27 → labnotes-0.0.29}/src/labnotes/models.py

@@ -14,6 +14,7 @@ class Controls:
     run_next: Callable[[str], None]
     set_concurrency: Callable[[int], None]
     toggle: Callable[[str], None]
+    kill: Callable[[str], None]
 
 
 Listen = Callable[[Controls], None]

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

@@ -18,6 +18,10 @@ def describe_event(event: dict[str, object]) -> str:
             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":
+            return f"Killing {event['run']}."
         case "concurrency":
             return f"{event['concurrency']} at a time."
         case "stopping":

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

@@ -48,25 +48,41 @@ async def run_experiment(
         plan.append((run, params))
     runs = [{"run": run, "params": params} for run, params in plan]
     report({"event": "planned", "runs": runs, "concurrency": concurrency})
-    running: set[asyncio.subprocess.Process] = set()
+    running: dict[str, set[asyncio.subprocess.Process]] = {}
+    stopped: set[str] = set()
     results: list[dict[str, object]] = []
     stopping = asyncio.Event()
 
-    def signal_runs(signal_number: int) -> None:
-        for process in running:
+    def signal_run(run: str, signal_number: int) -> None:
+        for process in running[run]:
             with contextlib.suppress(ProcessLookupError):
                 os.killpg(process.pid, signal_number)
 
+    def signal_runs(signal_number: int) -> None:
+        for run in running:
+            signal_run(run, signal_number)
+
     def interrupt() -> None:
         plan.clear()
         if not stopping.is_set():
             stopping.set()
             report({"event": "stopping"})
             signal_runs(signal.SIGTERM)
-        elif running:
+        elif any(running.values()):
             report({"event": "killing"})
             signal_runs(signal.SIGKILL)
 
+    def kill(run: str) -> None:
+        if not running.get(run):
+            return
+        if run in stopped:
+            report({"event": "killing run", "run": run})
+            signal_run(run, signal.SIGKILL)
+        else:
+            stopped.add(run)
+            report({"event": "stopping run", "run": run})
+            signal_run(run, signal.SIGTERM)
+
     held: list[Entry] = []
 
     def find(entries: list[Entry], run: str) -> Entry | None:
@@ -125,13 +141,15 @@ async def run_experiment(
         folder = run_folder(config.root, config.runs, name, run)
         folder.mkdir(parents=True)
         report({"event": "started", "run": run, "params": params})
+        running[run] = set()
         result = await execute_run(
-            config.root, folder, experiment.command, params, running, stopping
+            config.root, folder, experiment.command, params, running[run], stopping
         )
+        del running[run]
         report({"event": "ended", "run": run, **result})
         results.append(result)
 
-    listen(Controls(interrupt, run_next, set_concurrency, toggle))
+    listen(Controls(interrupt, run_next, set_concurrency, toggle, kill))
     fill()
     await idle.wait()
     await asyncio.gather(*started)

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

@@ -20,6 +20,8 @@ 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("k", "kill_run", "Stop run"),
         Binding("slash", "filter", "Filter", key_display="/"),
         Binding("escape", "clear_filter", "Clear filter"),
         Binding("plus,equals_sign", "concurrency(1)", "More at once", key_display="+"),
@@ -33,7 +35,11 @@ class RunApp(App[None]):
         self.title = title
         self.results: list[dict[str, object]] = []
         self.controls = Controls(
-            lambda: None, lambda run: None, lambda count: None, lambda run: None
+            lambda: None,
+            lambda run: None,
+            lambda count: None,
+            lambda run: None,
+            lambda run: None,
         )
         self.concurrency = 1
         self.done = False
@@ -177,6 +183,16 @@ class RunApp(App[None]):
         if (run := self.cursor_run()) is not None:
             self.controls.toggle(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)