labnotes 0.0.87__tar.gz → 0.0.89__tar.gz

{labnotes-0.0.87 → labnotes-0.0.89}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.0.87
+Version: 0.0.89
 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.89/src/labnotes/file_changes.py

@@ -0,0 +1,11 @@
+import json
+from collections.abc import AsyncIterator
+
+from dirsql import DirSQL
+
+from labnotes.watch_rows import watch_rows
+
+
+async def file_changes(tables: DirSQL, experiment: str) -> AsyncIterator[str]:
+    async for row in watch_rows(tables, {"files"}, experiment):
+        yield f"data: {json.dumps(row['filename'])}\n\n"

{labnotes-0.0.87 → labnotes-0.0.89}/src/labnotes/tui/experiment_screen.py

@@ -10,9 +10,14 @@ from textual.worker import Worker, WorkerState
 
 from labnotes.load_experiment import load_experiment
 from labnotes.models import LabnotesConfig
+from labnotes.tui.fill_table import fill_table
 from labnotes.tui.invocation_columns import invocation_columns
 from labnotes.tui.invocation_rows import invocation_rows
+from labnotes.tui.reload_on_change import reload_on_change
 from labnotes.tui.runs_table import RunsTable
+from labnotes.watch_rows import watch_rows
+
+WATCHED = {"runs", "experiment_configs"}
 
 
 class ExperimentScreen(Screen[None]):
@@ -36,7 +41,12 @@ class ExperimentScreen(Screen[None]):
 
     def on_mount(self) -> None:
         self.sub_title = self.experiment_name
-        self.run_worker(self.load(), exit_on_error=False)
+        self.run_worker(
+            reload_on_change(
+                watch_rows(self.tables, WATCHED, self.experiment_name), self.load
+            ),
+            exit_on_error=False,
+        )
 
     def on_worker_state_changed(self, event: Worker.StateChanged) -> None:
         if event.state == WorkerState.ERROR:
@@ -50,20 +60,22 @@ class ExperimentScreen(Screen[None]):
             self.experiment_name,
             QueryParams(),
         )
-        if loaded is None:
+        if loaded is None and not self.experiment:
             raise ValueError(f"No experiment named {self.experiment_name}.")
+        if loaded is None:
+            self.sub_title = f"{self.experiment_name} was removed."
+            fill_table(self.query_one(DataTable), [], [])
+            return
         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)
+        fill_table(
+            self.query_one(DataTable),
+            invocation_columns(self.experiment),
+            invocation_rows(self.experiment, self.opened),
+        )
 
     def action_toggle_invocation(self) -> None:
         table = self.query_one(DataTable)

{labnotes-0.0.87 → labnotes-0.0.89}/src/labnotes/tui/experiments_screen.py

@@ -7,7 +7,12 @@ 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.fill_table import fill_table
+from labnotes.tui.reload_on_change import reload_on_change
 from labnotes.tui.runs_table import RunsTable
+from labnotes.watch_rows import watch_rows
+
+WATCHED = {"files", "runs", "experiment_configs"}
 
 
 class ExperimentsScreen(Screen[None]):
@@ -22,7 +27,10 @@ class ExperimentsScreen(Screen[None]):
         yield Footer()
 
     def on_mount(self) -> None:
-        self.run_worker(self.load(), exit_on_error=False)
+        self.run_worker(
+            reload_on_change(watch_rows(self.tables, WATCHED), self.load),
+            exit_on_error=False,
+        )
 
     def on_worker_state_changed(self, event: Worker.StateChanged) -> None:
         if event.state == WorkerState.ERROR:
@@ -30,16 +38,18 @@ class ExperimentsScreen(Screen[None]):
 
     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"]),
-            )
+        self.sub_title = "" if rows else "No experiments."
+        fill_table(
+            self.query_one(DataTable),
+            list(next(iter(rows), ())),
+            [
+                (
+                    str(row["name"]),
+                    ["" if value is None else str(value) for value in row.values()],
+                )
+                for row in rows
+            ],
+        )
 
     def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
         self.app.push_screen(

labnotes-0.0.89/src/labnotes/tui/fill_table.py

@@ -0,0 +1,26 @@
+from collections.abc import Sequence
+
+from textual.widgets import DataTable
+
+
+def fill_table(
+    table: DataTable[object],
+    columns: Sequence[str],
+    rows: Sequence[tuple[str, Sequence[object]]],
+) -> None:
+    # The cursor follows its row by key, so rows arriving above it don't move it.
+    row = table.cursor_row
+    key = (
+        table.coordinate_to_cell_key(table.cursor_coordinate).row_key.value
+        if table.row_count
+        else None
+    )
+    if [str(column.label) for column in table.columns.values()] == list(columns):
+        table.clear()
+    else:
+        table.clear(columns=True)
+        table.add_columns(*columns)
+    keys = [each for each, _ in rows]
+    for each, cells in rows:
+        table.add_row(*cells, key=each)
+    table.move_cursor(row=keys.index(key) if key in keys else row)

labnotes-0.0.89/src/labnotes/tui/reload_on_change.py

@@ -0,0 +1,22 @@
+import asyncio
+from collections.abc import AsyncIterable, Awaitable, Callable
+
+
+async def reload_on_change(
+    changes: AsyncIterable[object], reload: Callable[[], Awaitable[None]]
+) -> None:
+    # Changes that land during a reload collapse into one more reload.
+    stale = asyncio.Event()
+
+    async def mark() -> None:
+        async for _ in changes:
+            stale.set()
+
+    marker = asyncio.create_task(mark())
+    try:
+        while True:
+            await reload()
+            await stale.wait()
+            stale.clear()
+    finally:
+        marker.cancel()

{labnotes-0.0.87 → labnotes-0.0.89}/src/labnotes/tui/run_app.py

@@ -1,5 +1,4 @@
 import asyncio
-import codecs
 import signal
 import time
 from pathlib import Path
@@ -7,7 +6,7 @@ from pathlib import Path
 from rich.text import Text
 from textual.app import App, ComposeResult
 from textual.binding import Binding
-from textual.widgets import DataTable, Footer, Header, Input, Log, Static
+from textual.widgets import DataTable, Footer, Header, Input, Static
 
 from labnotes.models import Controls, Start
 from labnotes.runner.describe_event import describe_event
@@ -15,10 +14,10 @@ from labnotes.runner.stop_then_kill import stop_then_kill
 from labnotes.runner.param_args import param_args
 from labnotes.tui.dim import dim
 from labnotes.tui.format_elapsed import format_elapsed
+from labnotes.tui.run_output import RunOutput
 from labnotes.tui.runs_table import RunsTable
 
 COLUMNS = ("run", "params", "status", "time")
-STREAMS = ("stdout", "stderr")
 PENDING, PASSED, FAILED = "○", "✓", "✗"
 SPINNER = "|/-\\"
 SKIPPED, DESELECTED = "–", "⊘"
@@ -80,18 +79,11 @@ class RunApp(App[None]):
         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")
-            for stream in STREAMS
-        }
-        self.last_stream: str | None
-        self.mid_line: bool
 
     def compose(self) -> ComposeResult:
         yield Header()
         yield RunsTable(id="runs", cursor_type="row")
-        yield Log(id="output")
+        yield RunOutput(id="output")
         yield Input(id="filter", placeholder="Filter params")
         yield Static(id="status")
         yield Footer()
@@ -101,7 +93,7 @@ class RunApp(App[None]):
         for column in COLUMNS:
             table.add_column(column, key=column)
         self.query_one(Input).display = False
-        self.query_one(Log).display = False
+        self.query_one(RunOutput).display = False
         self.query_one(Header).mount(Static(id="concurrency"))
         table.set_interval(0.1, self.spin)
 
@@ -373,44 +365,22 @@ class RunApp(App[None]):
 
     def view(self, run: str) -> None:
         self.viewing = run
-        self.offsets = dict.fromkeys(STREAMS, 0)
-        for decoder in self.decoders.values():
-            decoder.reset()
-        self.last_stream = None
-        self.mid_line = False
-        self.query_one(Log).clear()
+        self.query_one(RunOutput).reset()
         self.query_one(DataTable).display = False
-        self.query_one(Log).display = True
+        self.query_one(RunOutput).display = True
         self.sub_title = run
         self.show("")
         self.refresh_bindings()
         self.follow()
 
     def follow(self) -> None:
-        if self.viewing not in self.folders:
-            return
-        for stream in STREAMS:
-            path = self.folders[self.viewing] / f"{stream}.log"
-            if not path.exists():
-                continue
-            with path.open("rb") as log:
-                log.seek(self.offsets[stream])
-                data = log.read()
-            self.offsets[stream] += len(data)
-            text = self.decoders[stream].decode(data)
-            if not text:
-                continue
-            # Don't glue one stream's unfinished line onto the other's output.
-            if self.mid_line and stream != self.last_stream:
-                text = "\n" + text
-            self.query_one(Log).write(text)
-            self.last_stream = stream
-            self.mid_line = not text.endswith("\n")
+        if self.viewing in self.folders:
+            self.query_one(RunOutput).follow(self.folders[self.viewing])
 
     def action_leave(self) -> None:
         if self.viewing is not None:
             self.viewing = None
-            self.query_one(Log).display = False
+            self.query_one(RunOutput).display = False
             self.query_one(DataTable).display = True
             self.sub_title = ""
             self.refresh_bindings()

labnotes-0.0.89/src/labnotes/tui/run_output.py

@@ -0,0 +1,41 @@
+import codecs
+from pathlib import Path
+
+from textual.widgets import Log
+
+STREAMS = ("stdout", "stderr")
+
+
+class RunOutput(Log):
+    def __init__(self, id: str | None = None) -> None:
+        super().__init__(id=id)
+        self.reset()
+
+    def reset(self) -> None:
+        self.offsets = dict.fromkeys(STREAMS, 0)
+        self.decoders = {
+            stream: codecs.getincrementaldecoder("utf-8")(errors="replace")
+            for stream in STREAMS
+        }
+        self.last_stream: str | None = None
+        self.mid_line = False
+        self.clear()
+
+    def follow(self, folder: Path) -> None:
+        for stream in STREAMS:
+            path = folder / f"{stream}.log"
+            if not path.exists():
+                continue
+            with path.open("rb") as log:
+                log.seek(self.offsets[stream])
+                data = log.read()
+            self.offsets[stream] += len(data)
+            text = self.decoders[stream].decode(data)
+            if not text:
+                continue
+            # Don't glue one stream's unfinished line onto the other's output.
+            if self.mid_line and stream != self.last_stream:
+                text = "\n" + text
+            self.write(text)
+            self.last_stream = stream
+            self.mid_line = not text.endswith("\n")

labnotes-0.0.89/src/labnotes/watch_rows.py

@@ -0,0 +1,13 @@
+from collections.abc import AsyncIterator, Collection
+from typing import Any
+
+from dirsql import DirSQL
+
+
+async def watch_rows(
+    tables: DirSQL, names: Collection[str], experiment: str | None = None
+) -> AsyncIterator[dict[str, Any]]:
+    async for event in tables.watch():
+        row = event.row or event.old_row
+        if event.table in names and row and experiment in (None, row["experiment"]):
+            yield row

{labnotes-0.0.87 → labnotes-0.0.89}/testing-conventions.toml

@@ -5,9 +5,9 @@ lines = [12]
 reason = "LOCK_EX and LOCK_NB are disjoint bits, so | equals + and ^"
 
 [[python.exempt]]
-path = "src/labnotes/tui/run_app.py"
+path = "src/labnotes/tui/run_output.py"
 rules = ["mutation"]
-lines = [311]
+lines = [37]
 reason = "last_stream is always the same str object taken from STREAMS, so is not equals !="
 
 [[python.exempt]]

labnotes-0.0.87/src/labnotes/file_changes.py

@@ -1,11 +0,0 @@
-import json
-from collections.abc import AsyncIterator
-
-from dirsql import DirSQL
-
-
-async def file_changes(tables: DirSQL, experiment: str) -> AsyncIterator[str]:
-    async for event in tables.watch():
-        row = event.row or event.old_row
-        if event.table == "files" and row and row["experiment"] == experiment:
-            yield f"data: {json.dumps(row['filename'])}\n\n"