labnotes 0.0.122__tar.gz → 0.0.124__tar.gz

{labnotes-0.0.122 → labnotes-0.0.124}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.0.122
+Version: 0.0.124
 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.122 → labnotes-0.0.124}/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.122 → labnotes-0.0.124}/src/labnotes/daemon/daemon_app.py

@@ -79,6 +79,7 @@ def daemon_app(config: LabnotesConfig) -> Starlette:
                 None if path is None else Path(str(path)),
                 body.get("concurrency"),  # type: ignore[arg-type]
                 body.get("only"),  # type: ignore[arg-type]
+                body.get("args"),  # type: ignore[arg-type]
             )
         except ValueError as error:
             return refuse(400, str(error))
@@ -105,6 +106,7 @@ def daemon_app(config: LabnotesConfig) -> Starlette:
                     listen,
                     body.get("timeout"),  # type: ignore[arg-type]
                     only=body.get("only"),  # type: ignore[arg-type]
+                    args=body.get("args"),  # type: ignore[arg-type]
                 )
             # Clients hear why the session ended; the daemon keeps serving.
             except Exception as failure:  # noqa: BLE001

{labnotes-0.0.122 → labnotes-0.0.124}/src/labnotes/daemon/remote_start.py

@@ -17,6 +17,7 @@ def remote_start(
     concurrency: int | None,
     timeout: float | None = None,
     only: dict[str, str] | None = None,
+    args: list[str] | None = None,
 ) -> Start:
     async def start(report: Report, listen: Listen) -> list[dict[str, object]]:
         try:
@@ -48,6 +49,7 @@ def remote_start(
                     "concurrency": concurrency,
                     "timeout": timeout,
                     "only": only,
+                    "args": args,
                 },
             )
             if reply.status_code != 202:

{labnotes-0.0.122 → labnotes-0.0.124}/src/labnotes/experiments.py

@@ -17,12 +17,25 @@ from labnotes.tui.browse_tui import browse_tui
 from labnotes.tui.run_tui import run_tui
 
 BYTES = ("memory", "size")
+PASSTHROUGH = "labnotes.passthrough"
+
+
+class PassthroughCommand(click.Command):
+    def parse_args(self, ctx: click.Context, args: list[str]) -> list[str]:
+        if "--" in args:
+            at = args.index("--")
+            ctx.meta[PASSTHROUGH] = args[at + 1 :]
+            args = args[:at]
+        return super().parse_args(ctx, args)
 
 
 @click.command(
+    cls=PassthroughCommand,
     help="List experiments, show one, list its runs, or run it."
     " `new [NAME]` creates one. With run, --PARAM=VALUE runs only the"
-    " matrix cells where that param has that value.",
+    " matrix cells where that param has that value, and anything after --"
+    " is appended to every run's command and recorded in run.json, so never"
+    " pass secrets there.",
     context_settings={"ignore_unknown_options": True, "allow_extra_args": True},
 )
 @click.argument("name", required=False)
@@ -63,6 +76,7 @@ def experiments(
     experiment_config: Path | None,
     timeout: int | None,
 ) -> None:
+    passthrough: list[str] | None = ctx.meta.get(PASSTHROUGH)
     config = load_config(ctx)
     if config is None:
         raise click.ClickException(
@@ -82,7 +96,13 @@ def experiments(
             except ValueError as error:
                 raise click.UsageError(str(error)) from error
             start = remote_start(
-                config, name, experiment_config, concurrency, timeout, only
+                config,
+                name,
+                experiment_config,
+                concurrency,
+                timeout,
+                only,
+                passthrough or None,
             )
             try:
                 if sys.stdout.isatty() and sys.stderr.isatty():
@@ -101,6 +121,8 @@ def experiments(
             passed = len(results) - failed - retried
             click.echo(f"{passed} passed, {failed} failed.{again}")
             return
+    if passthrough is not None:
+        raise click.UsageError("-- ARGS needs run.")
     if ctx.args:
         raise click.UsageError(f"Unexpected {ctx.args[0]}. --PARAM=VALUE needs run.")
     if action not in (None, "runs"):

{labnotes-0.0.122 → labnotes-0.0.124}/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.122 → labnotes-0.0.124}/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.124/src/labnotes/runner/check_args.py

@@ -0,0 +1,15 @@
+import shlex
+
+from labnotes.runner.flag_name import flag_name
+
+
+def check_args(params: dict[str, list[object]], command: str, args: list[str]) -> None:
+    taken = {flag_name(token) for token in shlex.split(command)}
+    for arg in args:
+        name = flag_name(arg)
+        if name is None:
+            continue
+        if name in params:
+            raise ValueError(f"--{name} is a param. Pick it with --{name}=VALUE.")
+        if name in taken:
+            raise ValueError(f"--{name} is already in the command.")

{labnotes-0.0.122 → labnotes-0.0.124}/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.122 → labnotes-0.0.124}/src/labnotes/runner/execute_run.py

@@ -2,7 +2,7 @@ import asyncio
 import contextlib
 import os
 import time
-from collections.abc import Callable
+from collections.abc import Callable, Sequence
 from pathlib import Path
 
 import psutil
@@ -31,10 +31,11 @@ async def execute_run(
     stop: Callable[[], None] = lambda: None,
     stopped: Callable[[], bool] = lambda: False,
     meta: dict[str, object] | None = None,
+    args: Sequence[str] = (),
     *,
     memory_interval: float,
 ) -> dict[str, object]:
-    resolved = shell_command(command, folder, params)
+    resolved = shell_command(command, folder, params, args)
     run: dict[str, object] = {
         "params": params,
         "command": resolved,
@@ -45,6 +46,8 @@ async def execute_run(
         "ended_by": None,
         "signal": None,
     }
+    if args:
+        run["args"] = list(args)
     if retry_of is not None:
         run["retry_of"] = retry_of
     if meta is not None:

labnotes-0.0.124/src/labnotes/runner/flag_name.py

@@ -0,0 +1,4 @@
+def flag_name(token: str) -> str | None:
+    if not token.startswith("--"):
+        return None
+    return token.removeprefix("--").partition("=")[0] or None

{labnotes-0.0.122 → labnotes-0.0.124}/src/labnotes/runner/prepare_experiment.py

@@ -1,6 +1,7 @@
 from pathlib import Path
 
 from labnotes.models import ExperimentConfig, LabnotesConfig
+from labnotes.runner.check_args import check_args
 from labnotes.runner.check_subset import check_subset
 from labnotes.runner.read_experiment_config import read_experiment_config
 from labnotes.tables.file_text import file_text
@@ -12,6 +13,7 @@ async def prepare_experiment(
     experiment_config: Path | None,
     concurrency: int | None,
     only: dict[str, str] | None = None,
+    args: list[str] | None = None,
 ) -> tuple[ExperimentConfig, int]:
     if config.experiment not in (None, name):
         raise ValueError(
@@ -33,4 +35,6 @@ async def prepare_experiment(
     )
     if only:
         check_subset(experiment.params, only)
+    if args:
+        check_args(experiment.params, experiment.command, args)
     return experiment, experiment.concurrency if concurrency is None else concurrency

{labnotes-0.0.122 → labnotes-0.0.124}/src/labnotes/runner/run_experiment.py

@@ -38,6 +38,7 @@ async def run_experiment(
     timeout: float | None = None,
     retry_seconds: float = RETRY_SECONDS,
     only: dict[str, str] | None = None,
+    args: list[str] | None = None,
 ) -> list[dict[str, object]]:
     meta = None
     if experiment.meta is not None:
@@ -128,43 +129,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 +143,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:
@@ -266,6 +221,7 @@ async def run_experiment(
             stop=lambda: kill(run),
             stopped=lambda: run in stopped,
             meta=meta,
+            args=args or (),
             memory_interval=experiment.memory_interval,
         )
         del running[run], trees[run]
@@ -277,11 +233,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.124/src/labnotes/runner/shell_command.py

@@ -0,0 +1,12 @@
+import shlex
+from collections.abc import Sequence
+from pathlib import Path
+
+from labnotes.runner.param_args import param_args
+
+
+def shell_command(
+    command: str, folder: Path, params: dict[str, object], args: Sequence[str] = ()
+) -> str:
+    filled = command.replace("{run_dir}", shlex.quote(str(folder)))
+    return f"{filled} {shlex.join([*param_args(params), *args])}".rstrip()

{labnotes-0.0.122 → labnotes-0.0.124}/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.122 → labnotes-0.0.124}/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.122/src/labnotes/runner/shell_command.py

@@ -1,9 +0,0 @@
-import shlex
-from pathlib import Path
-
-from labnotes.runner.param_args import param_args
-
-
-def shell_command(command: str, folder: Path, params: dict[str, object]) -> str:
-    filled = command.replace("{run_dir}", shlex.quote(str(folder)))
-    return f"{filled} {shlex.join(param_args(params))}".rstrip()