labnotes 0.2.17__tar.gz → 0.2.19__tar.gz

{labnotes-0.2.17 → labnotes-0.2.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.2.17
+Version: 0.2.19
 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.2.17 → labnotes-0.2.19}/src/labnotes/daemon/server.py

@@ -61,6 +61,8 @@ class ExperimentDaemon:
             cast(str | None, options.get("teardown")),
             cast(str | None, options.get("command_line")),
             cast(str | None, options.get("run_id")),
+            cast(int | None, options.get("retries")),
+            bool(options.get("replace_capped")),
         )
         path = str(selected.run_state.path)
         invocation = Invocation()

{labnotes-0.2.17 → labnotes-0.2.19}/src/labnotes/experiments.py

@@ -7,7 +7,9 @@ import click
 from labnotes.command_line_group import COMMAND_LINE
 from labnotes.create_experiment import create_experiment
 from labnotes.daemon.command import command as daemon_command
+from labnotes.daemon.ensure import ensure_daemon
 from labnotes.runner.start_experiment import start_experiment
+from labnotes.runner.run_state import RunState
 from labnotes.utils.format_bytes import format_bytes
 from labnotes.load_config import load_config
 from labnotes.parse_params import parse_params
@@ -58,7 +60,23 @@ class PassthroughCommand(click.Command):
     help="With run: how many runs at once. Overrides experiment.toml and"
     " .labnotes.toml; 1 if none sets it.",
 )
-@click.option("--run-id", help="With run: restart only this failed run by id.")
+@click.option(
+    "--run-id",
+    help="With run: restart only this failed run by id, even if out of retries.",
+)
+@click.option(
+    "--retries",
+    type=click.IntRange(min=0),
+    help="With run: how many times a failed run is tried again, on exit 75 or,"
+    " with continues, by a later run. Overrides experiment.toml and"
+    " .labnotes.toml; 3 if none sets it.",
+)
+@click.option(
+    "--replace-capped",
+    is_flag=True,
+    help="With run: start a fresh run for a cell whose run is out of retries."
+    " Unset, that cell stays short.",
+)
 @click.option(
     "--headless",
     is_flag=True,
@@ -122,6 +140,8 @@ def experiments(
     output_format: str | None,
     concurrency: int | None,
     run_id: str | None,
+    retries: int | None,
+    replace_capped: bool,
     headless: bool,
     experiment_config: Path | None,
     timeout: int | None,
@@ -169,24 +189,61 @@ def experiments(
                 only = parse_subset(ctx.args)
             except ValueError as error:
                 raise click.UsageError(str(error)) from error
-            start = start_experiment(
-                config,
-                name,
-                experiment_config,
-                concurrency,
-                timeout,
-                only,
-                passthrough or None,
-                setup,
-                teardown,
-                ctx.meta.get(COMMAND_LINE),
-                run_id,
-            )
             try:
                 if not headless and sys.stdout.isatty() and sys.stderr.isatty():
-                    results = run_tui(start, name, config, experiment_config)
+                    asyncio.run(ensure_daemon(config, name))
+                    reply = daemon_command(
+                        config,
+                        name,
+                        {
+                            "command": "restart" if run_id else "start",
+                            "options": {
+                                "experiment_config": str(experiment_config)
+                                if experiment_config
+                                else None,
+                                "concurrency": concurrency,
+                                "timeout": timeout,
+                                "only": only,
+                                "args": passthrough or None,
+                                "setup": setup,
+                                "teardown": teardown,
+                                "command_line": ctx.meta.get(COMMAND_LINE),
+                                "run_id": run_id,
+                                "retries": retries,
+                                "replace_capped": replace_capped,
+                            },
+                        },
+                    )
+                    if not reply.get("ok"):
+                        raise ValueError(
+                            str(reply.get("error", "Daemon rejected start"))
+                        )
+                    run_tui(
+                        None,
+                        name,
+                        config,
+                        experiment_config,
+                        daemon_journal=RunState(Path(str(reply["journal"]))),
+                    )
+                    return
                 else:
-                    results = run_headless(start)
+                    results = run_headless(
+                        start_experiment(
+                            config,
+                            name,
+                            experiment_config,
+                            concurrency,
+                            timeout,
+                            only,
+                            passthrough or None,
+                            setup,
+                            teardown,
+                            ctx.meta.get(COMMAND_LINE),
+                            run_id,
+                            retries,
+                            replace_capped,
+                        )
+                    )
             except ValueError as error:
                 raise click.ClickException(str(error)) from error
             superseded = {r["retry_of"] for r in results if "retry_of" in r}
@@ -204,6 +261,8 @@ def experiments(
                 output_format is not None
                 or concurrency is not None
                 or run_id is not None
+                or retries is not None
+                or replace_capped
                 or experiment_config is not None
                 or timeout is not None
                 or setup is not None
@@ -226,6 +285,10 @@ def experiments(
         raise click.UsageError("-- ARGS needs run.")
     if run_id is not None:
         raise click.UsageError("--run-id needs run.")
+    if retries is not None:
+        raise click.UsageError("--retries needs run.")
+    if replace_capped:
+        raise click.UsageError("--replace-capped 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.2.17 → labnotes-0.2.19}/src/labnotes/models.py

@@ -65,3 +65,5 @@ class ExperimentConfig:
     teardown: str | None = None
     env: dict[str, str] = field(default_factory=dict)
     continues: bool = False
+    # A run option, not a config key: lets a run that used up `retries` free its slot.
+    replace_capped: bool = False

{labnotes-0.2.17 → labnotes-0.2.19}/src/labnotes/retries.py

@@ -1,4 +1,4 @@
 # EX_TEMPFAIL from sysexits.h: the only exit labnotes retries on its own.
 RETRY_EXIT_CODE = 75
-DEFAULT_RETRIES = 2
+DEFAULT_RETRIES = 3
 RETRY_SECONDS = 30.0

{labnotes-0.2.17 → labnotes-0.2.19}/src/labnotes/runner/describe_event.py

@@ -33,6 +33,10 @@ def describe_event(event: dict[str, object]) -> str:
         case "gave up":
             tried = f"after {event['retries']} retries"
             return f"{event['run']} gave up (exit {RETRY_EXIT_CODE}) {tried}."
+        case "capped":
+            cells = len(event["runs"])  # type: ignore[arg-type]
+            noun = "cell" if cells == 1 else "cells"
+            return f"{cells} {noun} gave up after {event['retries']} retries."
         case "retry cancelled":
             return f"{event['run']} won't retry."
         case "idle":

{labnotes-0.2.17 → labnotes-0.2.19}/src/labnotes/runner/prepare_experiment.py

@@ -17,6 +17,8 @@ async def prepare_experiment(
     args: list[str] | None = None,
     setup: str | None = None,
     teardown: str | None = None,
+    retries: int | None = None,
+    replace_capped: bool = False,
 ) -> tuple[ExperimentConfig, int]:
     if config.experiment not in (None, name):
         raise ValueError(
@@ -39,6 +41,10 @@ async def prepare_experiment(
         experiment = dataclasses.replace(experiment, setup=setup)
     if teardown is not None:
         experiment = dataclasses.replace(experiment, teardown=teardown)
+    if retries is not None:
+        experiment = dataclasses.replace(experiment, retries=retries)
+    if replace_capped:
+        experiment = dataclasses.replace(experiment, replace_capped=True)
     if only:
         check_subset(experiment.params, only)
     if args:

{labnotes-0.2.17 → labnotes-0.2.19}/src/labnotes/runner/run_experiment.py

@@ -84,6 +84,17 @@ async def run_experiment(
         for r in counted
         if r["counted"] or str(r.get("id")) in held_ids
     ]
+    resumable: list[Entry] = []
+    capped: list[Entry] = []
+    tries: dict[str, int] = {}
+    if experiment.continues:
+        for row in await list_resumable_runs(tables, name, experiment.counts):
+            entry = (str(row["id"]), json.loads(str(row["params"])))
+            tries[entry[0]] = int(str(row["invocations"]))
+            over = tries[entry[0]] > experiment.retries
+            (capped if over else resumable).append(entry)
+    if not experiment.replace_capped:
+        finished += [params for _, params in capped]
     planned: set[str] = set()
 
     def taken(run: str) -> bool:
@@ -112,12 +123,6 @@ async def run_experiment(
     def release(run: str) -> None:
         os.close(locks.pop(run))
 
-    resumable: list[Entry] = []
-    if experiment.continues:
-        resumable = [
-            (str(row["id"]), json.loads(str(row["params"])))
-            for row in await list_resumable_runs(tables, name, experiment.counts)
-        ]
     plan: list[Entry] = []
     target_folder: Path | None = None
     if run_id is not None:
@@ -155,6 +160,8 @@ async def run_experiment(
         run = new_stamped_run_id(taken) if resumed is None else resumed[0]
         planned.add(run)
         plan.append((run, params))
+    # A resumed run's earlier invocations spend the same retries as exit 75 does.
+    earlier = {run: tries[run] for run, _ in plan if run in tries and run != run_id}
     hooks = {
         "setup": experiment.setup,
         "teardown": experiment.teardown,
@@ -180,6 +187,9 @@ async def run_experiment(
     )
     for row in held:
         emit({"event": "held", "run": str(row["id"])})
+    gave_up = [run for run, params in capped if in_subset(params, only or {})]
+    if gave_up and run_id is None and not experiment.replace_capped:
+        emit({"event": "capped", "runs": gave_up, "retries": experiment.retries})
     running: dict[str, set[asyncio.subprocess.Process]] = {}
     trees: dict[str, set[psutil.Process]] = {}
     stopped: set[str] = set()
@@ -240,11 +250,11 @@ async def run_experiment(
         fill()
 
     def retry_later(run: str) -> None:
-        tried = attempts.get(run, 0)
+        tried = attempts.get(run, earlier.get(run, 0))
         if tried >= experiment.retries:
             emit({"event": "gave up", "run": run, "retries": tried})
             return
-        seconds = retry_seconds * 2**tried
+        seconds = retry_seconds * 2 ** (tried - earlier.get(run, 0))
 
         def due() -> None:
             del waiting[run]

{labnotes-0.2.17 → labnotes-0.2.19}/src/labnotes/runner/start_experiment.py

@@ -32,12 +32,23 @@ def start_experiment(
     teardown: str | None,
     command_line: str | None = None,
     run_id: str | None = None,
+    retries: int | None = None,
+    replace_capped: bool = False,
 ) -> ExperimentStart:
     state = RunState.create(config, name)
 
     async def start(report: Report, listen: Listen) -> list[dict[str, object]]:
         experiment, limit = await prepare_experiment(
-            config, name, experiment_config, concurrency, only, args, setup, teardown
+            config,
+            name,
+            experiment_config,
+            concurrency,
+            only,
+            args,
+            setup,
+            teardown,
+            retries,
+            replace_capped,
         )
         await finalize_lost_runs(config)
         with project_snapshot(config.root) as snapshot:

{labnotes-0.2.17 → labnotes-0.2.19}/src/labnotes/tables/list_resumable_runs.py

@@ -8,8 +8,13 @@ async def list_resumable_runs(
     tables: DirSQL, name: str, counts: str
 ) -> list[dict[str, object]]:
     # Ended badly: a nonzero or missing exit code, not merely uncounted.
+    # Invocations stopped by hand don't spend retries.
     return await tables.query(
-        f"SELECT id, params FROM runs WHERE experiment = {quote_string(name)}"
+        "SELECT id, params, CASE WHEN json_type(run, '$.invocations') = 'array'"
+        " THEN (SELECT count(*) FROM json_each(run, '$.invocations')"
+        " WHERE json_extract(value, '$.ended_by') IS NOT 'stop')"
+        " ELSE json_extract(run, '$.ended_by') IS NOT 'stop' END AS invocations"
+        f" FROM runs WHERE experiment = {quote_string(name)}"
         f" AND NOT coalesce(({counts}), false) AND NOT {UNFINISHED}"
         " AND (exit_code IS NULL OR exit_code <> 0)"
         " AND NOT coalesce(run ->> 'excluded', false) ORDER BY created, id"

{labnotes-0.2.17 → labnotes-0.2.19}/src/labnotes/tui/leave_prompt.py

@@ -25,3 +25,21 @@ class LeavePrompt(ModalScreen[str | None]):
             "Stop them (enter or s) / cancel (esc).",
             id="prompt",
         )
+
+
+class DetachedLeavePrompt(LeavePrompt):
+    """Choose explicitly whether a detached daemon should keep its cells."""
+
+    BINDINGS = [
+        Binding("s", "dismiss('stop')", "Stop runs"),
+        Binding("enter,l", "dismiss('leave')", "Leave running"),
+        Binding("escape", "dismiss", "Cancel"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        runs = "run" if self.count == 1 else "runs"
+        yield Static(
+            f"{self.count} {runs} still going. "
+            "Stop them (s) / leave running (enter or l) / cancel (esc).",
+            id="prompt",
+        )

{labnotes-0.2.17 → labnotes-0.2.19}/src/labnotes/tui/run_app.py

@@ -1,4 +1,7 @@
+import asyncio
+import json
 import signal
+import socket
 import time
 import tomllib
 from collections.abc import Mapping, Sequence
@@ -16,18 +19,21 @@ from textual.widget import Widget
 from textual.widgets import ContentSwitcher, DataTable, Footer, Header, Input, Static
 
 from labnotes.compose_experiment import compose_experiment
+from labnotes.daemon.command import command as daemon_command
+from labnotes.daemon.client import daemon_socket
 from labnotes.load_experiment import load_experiment
 from labnotes.models import Controls, LabnotesConfig, Start
 from labnotes.retries import RETRY_EXIT_CODE
 from labnotes.runner.describe_event import describe_event
 from labnotes.runner.param_args import param_args
 from labnotes.runner.start_experiment import ExperimentStart
+from labnotes.runner.run_state import RunState
 from labnotes.runner.stop_then_kill import GRACE_SECONDS, stop_then_kill
 from labnotes.tables.open_tables import open_tables
 from labnotes.tui.config import RUN_COLUMNS
 from labnotes.tui.dim import dim
 from labnotes.tui.format_elapsed import format_elapsed
-from labnotes.tui.leave_prompt import LeavePrompt
+from labnotes.tui.leave_prompt import DetachedLeavePrompt, LeavePrompt
 from labnotes.tui.log_blocks import LogBlocks
 from labnotes.tui.native_rows import native_rows
 from labnotes.tui.reload_on_change import reload_on_change
@@ -55,6 +61,7 @@ class RunLiveView(Widget):
     """
     BINDINGS = [
         Binding("x", "kill_run", "Stop run"),
+        Binding("r", "restart_run", "Restart"),
         Binding("slash", "filter", "Filter", key_display="/"),
         Binding("escape", "leave", "Back"),
         Binding("plus,equals_sign", "concurrency(1)", "More at once", key_display="+"),
@@ -294,6 +301,10 @@ class RunLiveView(Widget):
     def action_concurrency(self, change: int) -> None:
         self.controls.set_concurrency(self.concurrency + change)
 
+    def action_restart_run(self) -> None:
+        if (run := self.cursor_run()) is not None and isinstance(self.app, RunApp):
+            self.app.restart_run(run)
+
     def action_filter(self) -> None:
         field = self.query_one(Input)
         field.display = True
@@ -354,11 +365,12 @@ class RunApp(ViewSwitcher, App[None]):
 
     def __init__(
         self,
-        start: Start,
+        start: Start | None,
         title: str,
         columns: Sequence[str],
         config: LabnotesConfig | None = None,
         experiment_config: Path | None = None,
+        daemon_journal: RunState | None = None,
     ) -> None:
         super().__init__()
         self.start = start
@@ -377,8 +389,12 @@ class RunApp(ViewSwitcher, App[None]):
         self.shown: Experiment | None = None
         self.left: dict[str, Widget] = {}
         self.controls = self.body.controls
-        self.run_state = start.run_state if isinstance(start, ExperimentStart) else None
+        self.daemon_journal = daemon_journal
+        self.run_state = daemon_journal or (
+            start.run_state if isinstance(start, ExperimentStart) else None
+        )
         self.watching_state = False
+        self.attached: socket.socket | None = None
 
     def compose(self) -> ComposeResult:
         yield Header()
@@ -412,7 +428,93 @@ class RunApp(ViewSwitcher, App[None]):
                 exit_on_error=False,
             )
             self.run_worker(self.watch_files(tables), exit_on_error=False)
-        self.run_worker(self.drive())
+        if self.daemon_journal is not None:
+            journal = self.daemon_journal
+            try:
+                self.attach_daemon()
+            except (OSError, ValueError) as error:
+                self.error = error
+                self.exit()
+                return
+            self.listen(
+                Controls(
+                    lambda: self.queue_command({"command": "stop_all"}),
+                    lambda count: self.queue_command(
+                        {
+                            "command": "set_concurrency",
+                            "count": count,
+                            "journal": str(journal.path),
+                        }
+                    ),
+                    lambda run: self.queue_command({"command": "stop_one", "run": run}),
+                    lambda: None,
+                )
+            )
+            self.set_interval(0.25, self.refresh_state)
+            self.refresh_state()
+        else:
+            self.run_worker(self.drive())
+
+    def attach_daemon(self) -> None:
+        assert self.config is not None
+        path = daemon_socket(self.config, self.experiment_name)
+        if path is None:
+            raise ValueError(f"No daemon is running for {self.experiment_name}.")
+        client = socket.socket(socket.AF_UNIX)
+        try:
+            client.settimeout(10)
+            client.connect(str(path))
+            client.sendall(b'{"command":"attach"}\n')
+            with client.makefile("r") as replies:
+                reply = json.loads(replies.readline())
+            if not reply.get("ok"):
+                raise ValueError(str(reply.get("error", "Daemon rejected attach")))
+        except Exception:
+            client.close()
+            raise
+        self.attached = client
+
+    def on_unmount(self) -> None:
+        if self.attached is not None:
+            self.attached.close()
+
+    def queue_command(self, message: dict[str, object]) -> None:
+        self.run_worker(self.send_command(message), exit_on_error=False)
+
+    async def send_command(self, message: dict[str, object]) -> None:
+        assert self.config is not None
+        try:
+            reply = await asyncio.to_thread(
+                daemon_command, self.config, self.experiment_name, message
+            )
+            if not reply.get("ok"):
+                raise ValueError(str(reply.get("error", "Daemon rejected command")))
+        except ValueError as error:
+            if self.body_ready:
+                self.body.show(str(error))
+
+    def restart_run(self, run: str) -> None:
+        if self.daemon_journal is None:
+            return
+        if run not in self.body.failed:
+            self.body.show(f"{run} has not failed.")
+            return
+        self.run_worker(self.restart_daemon_run(run), exit_on_error=False)
+
+    async def restart_daemon_run(self, run: str) -> None:
+        assert self.config is not None
+        try:
+            reply = await asyncio.to_thread(
+                daemon_command,
+                self.config,
+                self.experiment_name,
+                {"command": "restart", "options": {"run_id": run}},
+            )
+            if not reply.get("ok"):
+                raise ValueError(str(reply.get("error", "Daemon rejected restart")))
+            self.body.show(f"Restarted {run}.")
+        except ValueError as error:
+            self.body.show(f"Could not restart {run}: {error}")
 
     def configured_views(self) -> dict[str, str]:
         if self.config is None:
@@ -453,6 +555,7 @@ class RunApp(ViewSwitcher, App[None]):
                 self.deliver(self.shown, frozenset({str(row["path"])}))
 
     async def drive(self) -> None:
+        assert self.start is not None
         try:
             self.results = await self.start(self.show_event, self.listen)
         except Exception as error:
@@ -463,8 +566,9 @@ class RunApp(ViewSwitcher, App[None]):
         self.controls = controls
         if self.body_ready:
             self.body.controls = controls
-        stop_then_kill(self.stop_runs, signal.SIGTERM)
-        stop_then_kill(self.stop_runs, signal.SIGHUP)
+        if self.daemon_journal is None:
+            stop_then_kill(self.stop_runs, signal.SIGTERM)
+            stop_then_kill(self.stop_runs, signal.SIGHUP)
 
     def show_event(self, event: dict[str, object]) -> None:
         if self.run_state is None:
@@ -488,6 +592,14 @@ class RunApp(ViewSwitcher, App[None]):
             self.controls.interrupt()
 
     def action_interrupt(self) -> None:
+        if self.daemon_journal is not None:
+            if self.body_ready and self.body.started:
+                self.push_screen(
+                    DetachedLeavePrompt(len(self.body.started)), self.answer
+                )
+            else:
+                self.exit()
+            return
         if self.body_ready and self.body.started:
             self.push_screen(LeavePrompt(len(self.body.started)), self.answer)
         elif self.body_ready and self.body.idle:
@@ -500,8 +612,17 @@ class RunApp(ViewSwitcher, App[None]):
 
     def answer(self, choice: str | None) -> None:
         if choice == "stop":
-            self.controls.interrupt()
-            self.set_timer(GRACE_SECONDS, self.controls.interrupt)
+            if self.daemon_journal is None:
+                self.controls.interrupt()
+                self.set_timer(GRACE_SECONDS, self.controls.interrupt)
+            else:
+                self.run_worker(self.stop_daemon_and_exit(), exit_on_error=False)
+        elif choice == "leave" and self.daemon_journal is not None:
+            self.exit()
+
+    async def stop_daemon_and_exit(self) -> None:
+        await self.send_command({"command": "stop_all"})
+        self.exit()
 
     def action_leave(self) -> None:
         if self.query_one(ContentSwitcher).current != "view-1":

{labnotes-0.2.17 → labnotes-0.2.19}/src/labnotes/tui/run_tui.py

@@ -1,18 +1,25 @@
 from pathlib import Path
 
 from labnotes.models import LabnotesConfig, Start
+from labnotes.runner.run_state import RunState
 from labnotes.tui.config import RUN_COLUMNS
 from labnotes.tui.run_app import RunApp
 
 
 def run_tui(
-    start: Start,
+    start: Start | None,
     title: str,
     config: LabnotesConfig | None = None,
     experiment_config: Path | None = None,
+    daemon_journal: RunState | None = None,
 ) -> list[dict[str, object]]:
     app = RunApp(
-        start, title, RUN_COLUMNS, config=config, experiment_config=experiment_config
+        start,
+        title,
+        RUN_COLUMNS,
+        config=config,
+        experiment_config=experiment_config,
+        daemon_journal=daemon_journal,
     )
     app.run()
     if app.error is not None:

{labnotes-0.2.17 → labnotes-0.2.19}/src/labnotes/tui/runs_browser.py

@@ -1,6 +1,5 @@
 import asyncio
 import os
-import sys
 from collections.abc import Mapping
 from pathlib import Path
 from typing import Any, cast
@@ -11,6 +10,8 @@ from textual.widget import Widget
 from textual.widgets import DataTable, Static
 
 from labnotes.runs_view_command import runs_view_command
+from labnotes.daemon.command import command as daemon_command
+from labnotes.daemon.ensure import ensure_daemon
 from labnotes.models import LabnotesConfig
 from labnotes.runner.claim_run import claim_run
 from labnotes.tui.fill_table import fill_table
@@ -144,28 +145,21 @@ class RunsBrowser(Widget):
 
     async def restart(self, run_id: str) -> None:
         config = cast(LabnotesConfig, getattr(self.app, "config"))
-        process = await asyncio.create_subprocess_exec(
-            sys.executable,
-            "-m",
-            "labnotes",
-            "-c",
-            str(config.path),
-            "experiments",
-            self.experiment.name,
-            "run",
-            "--run-id",
-            run_id,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-        )
-        stdout, stderr = await process.communicate()
-        if process.returncode == 0:
+        try:
+            await ensure_daemon(config, self.experiment.name)
+            reply = await asyncio.to_thread(
+                daemon_command,
+                config,
+                self.experiment.name,
+                {"command": "restart", "options": {"run_id": run_id}},
+            )
+            if not reply.get("ok"):
+                raise ValueError(str(reply.get("error", "Daemon rejected restart")))
             self.restart_status = (
                 f"Restarted {run_id}. Select the run to view its output."
             )
-        else:
-            detail = stderr.decode().strip() or stdout.decode().strip()
-            self.restart_status = f"Could not restart {run_id}: {detail}"
+        except ValueError as error:
+            self.restart_status = f"Could not restart {run_id}: {error}"
         self.show_status()
 
     async def action_open_row(self) -> None: