labnotes 0.0.83__tar.gz → 0.0.85__tar.gz

{labnotes-0.0.83 → labnotes-0.0.85}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.0.83
+Version: 0.0.85
 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>
@@ -68,7 +68,11 @@ labnotes experiments foo        # the same, plus config
 labnotes experiments foo runs   # foo's runs, oldest first
 ```
 
-Each takes `--format table` (the default) or `--format json`.
+Each takes `--format table` or `--format json`, which print rows and exit.
+Without `--format`, `labnotes experiments` and `labnotes experiments foo` open
+a browser in a terminal: the experiment list, Enter to open one, Escape to go
+back. An experiment shows its runs grouped by invocation; Space opens one.
+Piped, they print a table.
 
 `labnotes experiments new [NAME]` creates an experiment folder with a starter
 `experiment.toml`, picking a random name if you give none. `new` itself can't

{labnotes-0.0.83 → labnotes-0.0.85}/README.md

@@ -44,7 +44,11 @@ labnotes experiments foo        # the same, plus config
 labnotes experiments foo runs   # foo's runs, oldest first
 ```
 
-Each takes `--format table` (the default) or `--format json`.
+Each takes `--format table` or `--format json`, which print rows and exit.
+Without `--format`, `labnotes experiments` and `labnotes experiments foo` open
+a browser in a terminal: the experiment list, Enter to open one, Escape to go
+back. An experiment shows its runs grouped by invocation; Space opens one.
+Piped, they print a table.
 
 `labnotes experiments new [NAME]` creates an experiment folder with a starter
 `experiment.toml`, picking a random name if you give none. `new` itself can't

{labnotes-0.0.83 → labnotes-0.0.85}/src/labnotes/context.md

@@ -29,12 +29,14 @@ Keys come from folder names, so renaming a folder renames its rows on the next
 read. Paths are relative to the root, and times are UTC ISO 8601.
 
 ```sh
-labnotes experiments            # name, last_run, created, files, runs
-labnotes experiments foo        # the same, plus config
-labnotes experiments foo runs   # foo's runs, oldest first
+labnotes experiments --format json            # name, last_run, created, files, runs
+labnotes experiments foo --format json        # the same, plus config
+labnotes experiments foo runs --format json   # foo's runs, oldest first
 ```
 
-Each takes `--format table` (the default) or `--format json`; use `--format json` when you parse the output.
+Always pass `--format json` (to parse) or `--format table`. Without `--format`,
+`labnotes experiments` and `labnotes experiments foo` open an interactive
+browser when they find a terminal, and wait for keys that never come.
 
 `labnotes experiments new [NAME]` creates an experiment folder with a starter
 `experiment.toml`, picking a random name if you give none. `new` itself can't
@@ -91,14 +93,15 @@ A script run by labnotes should:
 - stop any background process it starts before it exits; the run ends when `command` exits.
 - flush its output as it goes (`print(..., flush=True)`, or `PYTHONUNBUFFERED=1`), so the live view shows it as it happens.
 
-Runs can take a long time. Start `run` in the background, then check on it with `labnotes experiments foo runs`; a run with no `ended` is still going.
+Runs can take a long time. Start `run` in the background, then check on it with `labnotes experiments foo runs --format json`; a run with no `ended` is still going.
 
 In a terminal, `run` shows a live table of runs (status and time) 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. `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. Space deselects a pending run so it won't run; Space again puts it back at
+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
 running run under the cursor; `x` again kills it. `+` and
@@ -127,7 +130,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,
+  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`.
 - 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. If it can't

{labnotes-0.0.83 → labnotes-0.0.85}/src/labnotes/experiments.py

@@ -11,6 +11,7 @@ from labnotes.print_rows import print_rows
 from labnotes.read_config import CONFIG_FILE
 from labnotes.runner.run_headless import run_headless
 from labnotes.tables.experiment_rows import experiment_rows
+from labnotes.tui.browse_tui import browse_tui
 from labnotes.tui.run_tui import run_tui
 
 
@@ -24,8 +25,8 @@ from labnotes.tui.run_tui import run_tui
     "--format",
     "output_format",
     type=click.Choice(["table", "json"]),
-    default="table",
-    show_default=True,
+    help="Print rows and exit. Unset, a terminal browses them instead;"
+    " anything else gets table.",
 )
 @click.option(
     "--concurrency",
@@ -44,7 +45,7 @@ def experiments(
     ctx: click.Context,
     name: str | None,
     action: str | None,
-    output_format: str,
+    output_format: str | None,
     concurrency: int | None,
     experiment_config: Path | None,
 ) -> None:
@@ -75,10 +76,21 @@ def experiments(
             return
     if action not in (None, "runs"):
         raise click.UsageError(f"Unknown action {action}. Use runs or run.")
+    if (
+        action is None
+        and output_format is None
+        and sys.stdout.isatty()
+        and sys.stderr.isatty()
+    ):
+        try:
+            browse_tui(config, name)
+        except ValueError as error:
+            raise click.ClickException(str(error)) from error
+        return
     try:
         rows = asyncio.run(experiment_rows(config, name, action))
     except ValueError as error:
         raise click.ClickException(str(error)) from error
     if rows is None:
         raise click.ClickException(f"No experiment named {name}.")
-    print_rows(rows, output_format)
+    print_rows(rows, output_format or "table")

{labnotes-0.0.83 → labnotes-0.0.85}/src/labnotes/models.py

@@ -18,6 +18,7 @@ class Controls:
     kill: Callable[[str], None]
     retry: Callable[[str], None]
     finish: Callable[[], None]
+    move: Callable[[str, int], None]
 
 
 Listen = Callable[[Controls], None]

{labnotes-0.0.83 → labnotes-0.0.85}/src/labnotes/run_control.py

@@ -18,7 +18,8 @@ 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; set_concurrency a number; "
+        "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."
     ),
 )

{labnotes-0.0.83 → labnotes-0.0.85}/src/labnotes/runner/describe_event.py

@@ -14,6 +14,10 @@ def describe_event(event: dict[str, object]) -> str:
             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":

{labnotes-0.0.83 → labnotes-0.0.85}/src/labnotes/runner/run_experiment.py

@@ -125,6 +125,13 @@ async def run_experiment(
             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
@@ -202,7 +209,11 @@ async def run_experiment(
         ended[run] = params
         results.append(result)
 
-    listen(Controls(interrupt, run_next, set_concurrency, toggle, kill, retry, finish))
+    listen(
+        Controls(
+            interrupt, run_next, set_concurrency, toggle, kill, retry, finish, move
+        )
+    )
     fill()
     await done.wait()
     await asyncio.gather(*started)

labnotes-0.0.85/src/labnotes/tui/browse_app.py

@@ -0,0 +1,25 @@
+from textual.app import App
+from textual.binding import Binding
+
+from labnotes.models import LabnotesConfig
+from labnotes.tables.open_tables import open_tables
+from labnotes.tui.experiment_screen import ExperimentScreen
+from labnotes.tui.experiments_screen import ExperimentsScreen
+
+
+class BrowseApp(App[BaseException | None]):
+    BINDINGS = [Binding("q", "quit", "Quit")]
+
+    def __init__(self, config: LabnotesConfig, name: str | None) -> None:
+        super().__init__()
+        self.config = config
+        self.experiment_name = name
+        self.title = config.root.name
+
+    def on_mount(self) -> None:
+        tables = open_tables(self.config)
+        self.push_screen(ExperimentsScreen(tables, self.config))
+        if self.experiment_name is not None:
+            self.push_screen(
+                ExperimentScreen(tables, self.config, self.experiment_name)
+            )

labnotes-0.0.85/src/labnotes/tui/browse_tui.py

@@ -0,0 +1,8 @@
+from labnotes.models import LabnotesConfig
+from labnotes.tui.browse_app import BrowseApp
+
+
+def browse_tui(config: LabnotesConfig, name: str | None) -> None:
+    error = BrowseApp(config, name).run()
+    if error is not None:
+        raise error

labnotes-0.0.85/src/labnotes/tui/experiment_screen.py

@@ -0,0 +1,80 @@
+from typing import Any
+
+from dirsql import DirSQL
+from starlette.datastructures import QueryParams
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.screen import Screen
+from textual.widgets import DataTable, Footer, Header
+from textual.worker import Worker, WorkerState
+
+from labnotes.load_experiment import load_experiment
+from labnotes.models import LabnotesConfig
+from labnotes.tui.invocation_columns import invocation_columns
+from labnotes.tui.invocation_rows import invocation_rows
+from labnotes.tui.runs_table import RunsTable
+
+
+class ExperimentScreen(Screen[None]):
+    BINDINGS = [
+        Binding("space", "open_invocation", "Open invocation"),
+        Binding("escape", "app.pop_screen", "Back"),
+    ]
+
+    def __init__(self, tables: DirSQL, config: LabnotesConfig, name: str) -> None:
+        super().__init__()
+        self.tables = tables
+        self.config = config
+        self.experiment_name = name
+        self.experiment: dict[str, Any] = {}
+        self.opened: set[str] = set()
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield RunsTable(id="runs", cursor_type="row")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.sub_title = self.experiment_name
+        self.run_worker(self.load(), exit_on_error=False)
+
+    def on_worker_state_changed(self, event: Worker.StateChanged) -> None:
+        if event.state == WorkerState.ERROR:
+            self.app.exit(event.worker.error)
+
+    async def load(self) -> None:
+        loaded = await load_experiment(
+            self.tables,
+            self.config.root,
+            self.config.mode,
+            self.experiment_name,
+            QueryParams(),
+        )
+        if loaded is None:
+            raise ValueError(f"No experiment named {self.experiment_name}.")
+        self.experiment = loaded
+        self.sub_title = str(loaded["display_name"])
+        self.query_one(DataTable).add_columns(*invocation_columns(loaded))
+        self.redraw()
+
+    def redraw(self) -> None:
+        table = self.query_one(DataTable)
+        row = table.cursor_row
+        table.clear()
+        for key, cells in invocation_rows(self.experiment, self.opened):
+            table.add_row(*cells, key=key)
+        table.move_cursor(row=row)
+
+    def action_open_invocation(self) -> None:
+        table = self.query_one(DataTable)
+        if not table.row_count:
+            return
+        key = str(table.coordinate_to_cell_key(table.cursor_coordinate).row_key.value)
+        groups = {
+            group["name"]
+            for group in self.experiment["run_groups"] or ()
+            if not group["flat"]
+        }
+        if key in groups:
+            self.opened ^= {key}
+            self.redraw()

labnotes-0.0.85/src/labnotes/tui/experiments_screen.py

@@ -0,0 +1,47 @@
+from dirsql import DirSQL
+from textual.app import ComposeResult
+from textual.screen import Screen
+from textual.widgets import DataTable, Footer, Header
+from textual.worker import Worker, WorkerState
+
+from labnotes.models import LabnotesConfig
+from labnotes.tables.summarize_experiments import summarize_experiments
+from labnotes.tui.experiment_screen import ExperimentScreen
+from labnotes.tui.runs_table import RunsTable
+
+
+class ExperimentsScreen(Screen[None]):
+    def __init__(self, tables: DirSQL, config: LabnotesConfig) -> None:
+        super().__init__()
+        self.tables = tables
+        self.config = config
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield RunsTable(id="experiments", cursor_type="row")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.run_worker(self.load(), exit_on_error=False)
+
+    def on_worker_state_changed(self, event: Worker.StateChanged) -> None:
+        if event.state == WorkerState.ERROR:
+            self.app.exit(event.worker.error)
+
+    async def load(self) -> None:
+        rows = await summarize_experiments(self.tables)
+        if not rows:
+            self.sub_title = "No experiments."
+            return
+        table = self.query_one(DataTable)
+        table.add_columns(*rows[0])
+        for row in rows:
+            table.add_row(
+                *("" if value is None else str(value) for value in row.values()),
+                key=str(row["name"]),
+            )
+
+    def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
+        self.app.push_screen(
+            ExperimentScreen(self.tables, self.config, str(event.row_key.value))
+        )

labnotes-0.0.85/src/labnotes/tui/group_cells.py

@@ -0,0 +1,26 @@
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+from rich.text import Text
+
+from labnotes.format_value import format_value
+
+
+def group_cells(
+    group: Mapping[str, Any], columns: Sequence[str], live: bool
+) -> list[object]:
+    status = Text.assemble(
+        (f"{group['passed']}✓", "green"), " ", (f"{group['failed']}✕", "red")
+    )
+    if group["unfinished"]:
+        mark, style = ("◐", "yellow") if live else ("–", "dim")
+        status.append(f" {group['unfinished']}{mark}", style=style)
+    cells: list[object] = [status, group["name"], str(len(group["runs"]))]
+    for column in columns[1:]:
+        if column == "started":
+            cells.append(group["started"] or "")
+        elif column in group["shared"]:
+            cells.append(format_value(group["shared"][column]))
+        else:
+            cells.append("")
+    return cells

labnotes-0.0.85/src/labnotes/tui/invocation_columns.py

@@ -0,0 +1,9 @@
+from collections.abc import Mapping
+from typing import Any
+
+
+def invocation_columns(experiment: Mapping[str, Any]) -> list[str]:
+    columns = ["", *experiment["run_columns"]]
+    if experiment["run_groups"] is not None:
+        columns.insert(2, "runs")
+    return columns

labnotes-0.0.85/src/labnotes/tui/invocation_rows.py

@@ -0,0 +1,31 @@
+from collections.abc import Collection, Mapping
+from typing import Any
+
+from labnotes.tui.group_cells import group_cells
+from labnotes.tui.run_cells import run_cells
+
+
+def invocation_rows(
+    experiment: Mapping[str, Any], opened: Collection[str]
+) -> list[tuple[str, list[object]]]:
+    columns = experiment["run_columns"]
+    live = experiment["runs_live"]
+    groups = experiment["run_groups"]
+    if groups is None:
+        return [
+            (str(run["id"]), run_cells(run, columns, False, live))
+            for run in experiment["runs_list"]
+        ]
+    rows = []
+    for group in groups:
+        if group["flat"]:
+            [run, *_] = group["runs"]
+            rows.append((str(run["id"]), run_cells(run, columns, True, live)))
+            continue
+        rows.append((group["name"], group_cells(group, columns, live)))
+        if group["name"] in opened:
+            rows += [
+                (str(run["id"]), run_cells(run, columns, True, live))
+                for run in group["runs"]
+            ]
+    return rows

{labnotes-0.0.83 → labnotes-0.0.85}/src/labnotes/tui/run_app.py

@@ -23,6 +23,8 @@ PENDING, PASSED, FAILED = "○", "✓", "✗"
 SPINNER = "|/-\\"
 SKIPPED, DESELECTED = "–", "⊘"
 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]):
@@ -30,6 +32,11 @@ class RunApp(App[None]):
     BINDINGS = [
         Binding("ctrl+c", "interrupt", "Stop runs"),
         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"),
@@ -56,6 +63,7 @@ class RunApp(App[None]):
             lambda run: None,
             lambda run: None,
             lambda: None,
+            lambda run, place: None,
         )
         self.concurrency = 1
         self.idle = False
@@ -70,6 +78,8 @@ class RunApp(App[None]):
         self.hiding = False
         self.folders: dict[str, Path] = {}
         self.viewing: str | None = None
+        self.grabbed: str | None = None
+        self.grabbed_from: list[str] = []
         self.offsets: dict[str, int]
         self.decoders = {
             stream: codecs.getincrementaldecoder("utf-8")(errors="replace")
@@ -129,6 +139,8 @@ 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()
@@ -158,10 +170,10 @@ class RunApp(App[None]):
                 del self.started[run]
                 self.redraw(table.cursor_row)
             case "queued":
-                self.reorder(event, table.cursor_row)
-                table.move_cursor(row=table.get_row_index(run))
-                self.show(describe_event(event))
+                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))
@@ -198,7 +210,14 @@ class RunApp(App[None]):
         passed = len(self.ended) - failed
         self.show(f"{passed} passed, {failed} failed. q 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)
@@ -220,6 +239,10 @@ class RunApp(App[None]):
             table.update_cell(run, column, cell, update_width=True)
 
     def check_action(self, action: str, parameters: tuple[object, ...]) -> bool:
+        if self.grabbed is not None:
+            return action in GRABBING_ACTIONS
+        if action in GRABBED_ACTIONS:
+            return False
         return self.viewing is None or action in VIEWING_ACTIONS
 
     def show_concurrency(self, event: dict[str, object]) -> None:
@@ -262,6 +285,57 @@ class RunApp(App[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)
@@ -294,7 +368,8 @@ class RunApp(App[None]):
         field.focus()
 
     def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
-        self.view(str(event.row_key.value))
+        if self.grabbed is None:
+            self.view(str(event.row_key.value))
 
     def view(self, run: str) -> None:
         self.viewing = run

labnotes-0.0.85/src/labnotes/tui/run_cells.py

@@ -0,0 +1,29 @@
+from collections.abc import Mapping, Sequence
+
+from rich.text import Text
+
+from labnotes.format_duration import format_duration
+from labnotes.format_value import format_value
+from labnotes.tui.dim import dim
+
+
+def run_cells(
+    run: Mapping[str, object], columns: Sequence[str], nested: bool, live: bool
+) -> list[object]:
+    if run["labnotes_unfinished"]:
+        status = Text("◐", style="yellow") if live else dim("–")
+    elif run["labnotes_completed"]:
+        status = Text("✓", style="green")
+    else:
+        status = Text("✕", style="red")
+    cells: list[object] = [status]
+    for column in columns:
+        value = run[column]
+        if column == "id" and nested:
+            child = str(value).partition("/")[2]
+            cells += [f"  {child}" if child else str(value), ""]
+        elif column == "duration":
+            cells.append(format_duration(value))  # type: ignore[arg-type]
+        else:
+            cells.append(format_value(value))
+    return cells

{labnotes-0.0.83 → labnotes-0.0.85}/testing-conventions.toml

@@ -45,3 +45,27 @@ path = "src/labnotes/run_control.py"
 rules = ["mutation"]
 lines = [38]
 reason = "argument counts are small ints, which CPython caches, so is not equals !="
+
+[[python.exempt]]
+path = "src/labnotes/tui/run_cells.py"
+rules = ["mutation"]
+lines = [22, 25]
+reason = "run columns come from string literals in load_experiment, which CPython interns, so is equals =="
+
+[[python.exempt]]
+path = "src/labnotes/tui/group_cells.py"
+rules = ["mutation"]
+lines = [20]
+reason = "run columns come from string literals in load_experiment, which CPython interns, so is equals =="
+
+[[python.exempt]]
+path = "src/labnotes/tui/experiment_screen.py"
+rules = ["mutation"]
+lines = [42]
+reason = "WorkerState members are singletons, so is equals =="
+
+[[python.exempt]]
+path = "src/labnotes/tui/experiments_screen.py"
+rules = ["mutation"]
+lines = [28, 37]
+reason = "WorkerState members are singletons, so is equals ==; every row of one query has the same keys, so any row names the columns"