labnotes 0.2.9__tar.gz → 0.2.11__tar.gz

{labnotes-0.2.9 → labnotes-0.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.2.9
+Version: 0.2.11
 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.9 → labnotes-0.2.11}/src/labnotes/experiments.py

@@ -168,7 +168,7 @@ def experiments(
             )
             try:
                 if sys.stdout.isatty() and sys.stderr.isatty():
-                    results = run_tui(start, name)
+                    results = run_tui(start, name, config, experiment_config)
                 else:
                     results = run_headless(start)
             except ValueError as error:

{labnotes-0.2.9 → labnotes-0.2.11}/src/labnotes/tui/experiment_screen.py

@@ -1,4 +1,3 @@
-from collections.abc import Mapping
 from types import MappingProxyType
 from typing import Any
 
@@ -17,15 +16,15 @@ from labnotes.tui.native_rows import native_rows
 from labnotes.tui.reload_on_change import reload_on_change
 from labnotes.tui.stopped_title import stopped_title
 from labnotes.tui.view_pane import ViewPane
+from labnotes.tui.view_switcher import ViewSwitcher
 from labnotes.view.experiment import Experiment
 from labnotes.watch_rows import watch_rows
 
 WATCHED = {"runs", "experiment_configs"}
 BUILT_IN = "labnotes.tui.runs_browser:RunsBrowser"
-MAX_VIEWS = 8
 
 
-class ExperimentScreen(Screen[None]):
+class ExperimentScreen(ViewSwitcher, Screen[None]):
     BINDINGS = [Binding("escape", "back", "Back")]
 
     def __init__(
@@ -82,7 +81,7 @@ class ExperimentScreen(Screen[None]):
             self.deliver(None)
             return
         if not self.found:
-            await self.add_views(loaded["views"])
+            await self.add_views(loaded["views"], self.config.root)
         self.found = True
         self.sub_title = str(loaded["display_name"])
         self.shown = Experiment(
@@ -93,49 +92,11 @@ class ExperimentScreen(Screen[None]):
         )
         self.deliver(self.shown)
 
-    async def add_views(self, specs: Mapping[str, str]) -> None:
-        names = list(specs)[:MAX_VIEWS]
-        if not names:
-            return
-        panes = [
-            ViewPane(name, specs[name], self.config.root, id=f"view-{number}")
-            for number, name in enumerate(names, 2)
-        ]
-        for pane in panes:
-            pane.display = False
-        await self.query_one(ContentSwitcher).mount_all(panes)
-        # Screen bindings are fixed per class; each screen's view names differ.
-        for number, name in enumerate(["runs", *names], 1):
-            self._bindings.bind(str(number), f"show_view({number})", name)
-        self._bindings.bind("0", "show_view(1)")
-        self.refresh_bindings()
-
-    def deliver(
-        self, experiment: Experiment | None, paths: frozenset[str] = frozenset()
-    ) -> None:
-        for pane in self.query(ViewPane):
-            pane.deliver(experiment, paths)
-
     async def watch_files(self) -> None:
         async for row in watch_rows(self.tables, {"run_files"}, self.experiment_name):
             if self.shown is not None:
                 self.deliver(self.shown, frozenset({str(row["path"])}))
 
-    def action_show_view(self, number: int) -> None:
-        switcher = self.query_one(ContentSwitcher)
-        if switcher.current is not None and self.focused is not None:
-            self.left[switcher.current] = self.focused
-        switcher.current = f"view-{number}"
-        self.call_after_refresh(self.refocus, switcher.current)
-
-    def refocus(self, current: str) -> None:
-        widget = self.left.get(current)
-        if widget is not None and widget.focusable:
-            widget.focus()
-            return
-        self.set_focus(None)
-        self.focus_next()
-
     def action_back(self) -> None:
         if self.query_one(ContentSwitcher).current == "view-1":
             self.app.pop_screen()

{labnotes-0.2.9 → labnotes-0.2.11}/src/labnotes/tui/run_app.py

@@ -1,38 +1,58 @@
 import signal
 import time
-from collections.abc import Sequence
+import tomllib
+from collections.abc import Mapping, Sequence
 from pathlib import Path
+from types import MappingProxyType
+from typing import Any, cast
 
 from rich.text import Text
+from starlette.datastructures import QueryParams
 from textual import work
 from textual.app import App, ComposeResult
 from textual.binding import Binding
-from textual.widgets import DataTable, Footer, Header, Input, Static
+from textual.css.query import NoMatches
+from textual.widget import Widget
+from textual.widgets import ContentSwitcher, DataTable, Footer, Header, Input, Static
 
-from labnotes.utils.format_bytes import format_bytes
-from labnotes.models import Controls, Start
+from labnotes.compose_experiment import compose_experiment
+from labnotes.load_experiment import load_experiment
+from labnotes.models import Controls, LabnotesConfig, Start
 from labnotes.retries import RETRY_EXIT_CODE
-from labnotes.utils.run_usage import run_usage
 from labnotes.runner.describe_event import describe_event
-from labnotes.runner.stop_then_kill import GRACE_SECONDS, stop_then_kill
 from labnotes.runner.param_args import param_args
+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.log_blocks import LogBlocks
+from labnotes.tui.native_rows import native_rows
+from labnotes.tui.reload_on_change import reload_on_change
 from labnotes.tui.run_output import RunOutput
 from labnotes.tui.runs_table import RunsTable
+from labnotes.tui.view_pane import ViewPane
+from labnotes.tui.view_switcher import ViewSwitcher
+from labnotes.utils.format_bytes import format_bytes
+from labnotes.utils.run_usage import run_usage
+from labnotes.view.experiment import Experiment
+from labnotes.view_specs import view_specs
+from labnotes.watch_rows import watch_rows
 
 PENDING, PASSED, FAILED = "○", "✓", "✗"
 SPINNER = "|/-\\"
 SKIPPED = "–"
 VIEWING_ACTIONS = {"leave", "quit", "interrupt", "command_palette"}
+BUILT_IN = "labnotes.tui.run_app:RunLiveView"
 
 
-class RunApp(App[None]):
-    CSS = "#concurrency { dock: right; width: auto; padding: 0 1; }"
+class RunLiveView(Widget):
+    DEFAULT_CSS = """
+    RunLiveView { height: 1fr; }
+    RunLiveView RunsTable { height: 1fr; }
+    """
     BINDINGS = [
-        Binding("ctrl+c", "interrupt", "Quit"),
         Binding("x", "kill_run", "Stop run"),
         Binding("slash", "filter", "Filter", key_display="/"),
         Binding("escape", "leave", "Back"),
@@ -40,13 +60,9 @@ class RunApp(App[None]):
         Binding("minus", "concurrency(-1)", "Fewer at once", key_display="-"),
     ]
 
-    def __init__(self, start: Start, title: str, columns: Sequence[str]) -> None:
+    def __init__(self, columns: Sequence[str] = ()) -> None:
         super().__init__()
-        self.columns = tuple(columns)
-        self.start = start
-        self.title = title
-        self.results: list[dict[str, object]] = []
-        self.error: Exception | None = None
+        self.columns = tuple(columns or RUN_COLUMNS)
         self.controls = Controls(
             lambda: None, lambda count: None, lambda run: None, lambda: None
         )
@@ -67,13 +83,11 @@ class RunApp(App[None]):
         self.unmeasured: dict[str, None] = {}
 
     def compose(self) -> ComposeResult:
-        yield Header()
         yield RunsTable(id="runs", cursor_type="row")
         yield LogBlocks(id="blocks")
         yield RunOutput(id="output")
         yield Input(id="filter", placeholder="Filter params")
         yield Static(id="status")
-        yield Footer()
 
     def on_mount(self) -> None:
         table = self.query_one(DataTable)
@@ -81,32 +95,16 @@ class RunApp(App[None]):
             table.add_column(column, key=column)
         self.query_one(Input).display = False
         self.query_one(RunOutput).display = False
-        self.query_one(Header).mount(Static(id="concurrency"))
         table.set_interval(0.1, self.spin)
-
-    def on_ready(self) -> None:
         self.set_interval(1, self.tick)
         self.set_interval(0.25, self.follow)
-        self.run_worker(self.drive())
-
-    async def drive(self) -> None:
-        try:
-            self.results = await self.start(self.show_event, self.listen)
-        except Exception as error:
-            self.error = error
-        self.exit()
-
-    def listen(self, controls: Controls) -> None:
-        self.controls = controls
-        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:
         table = self.query_one(DataTable)
         run = str(event.get("run"))
         match event["event"]:
             case "planned":
-                self.title = str(event["title"])
+                self.app.title = str(event["title"])
                 for planned in event["runs"]:  # type: ignore[attr-defined]
                     args = " ".join(param_args(planned["params"]))
                     self.cells[planned["run"]] = self.waiting_cells(
@@ -219,7 +217,7 @@ class RunApp(App[None]):
             table.update_cell(run, column, cell, update_width=True)
 
     def check_action(self, action: str, parameters: tuple[object, ...]) -> bool:
-        if isinstance(self.screen, LeavePrompt):
+        if isinstance(self.app.screen, LeavePrompt):
             return False
         if action == "leave" and self.viewing is None:
             return self.query_one(Input).display
@@ -227,7 +225,9 @@ class RunApp(App[None]):
 
     def show_concurrency(self, event: dict[str, object]) -> None:
         self.concurrency = int(event["concurrency"])  # type: ignore[call-overload]
-        self.query_one("#concurrency", Static).update(f"{self.concurrency} at a time")
+        self.app.query_one("#concurrency", Static).update(
+            f"{self.concurrency} at a time"
+        )
 
     def tick(self) -> None:
         now = time.monotonic()
@@ -271,28 +271,6 @@ class RunApp(App[None]):
     def show(self, text: str) -> None:
         self.query_one("#status", Static).update(text)
 
-    def stop_runs(self) -> None:
-        if self.idle:
-            self.controls.finish()
-        else:
-            self.controls.interrupt()
-
-    def action_interrupt(self) -> None:
-        if self.started:
-            self.push_screen(LeavePrompt(len(self.started)), self.answer)
-        elif self.idle:
-            self.controls.finish()
-        else:
-            self.exit()
-
-    async def action_quit(self) -> None:
-        self.action_interrupt()
-
-    def answer(self, choice: str | None) -> None:
-        if choice == "stop":
-            self.controls.interrupt()
-            self.set_timer(GRACE_SECONDS, self.controls.interrupt)
-
     def cursor_run(self) -> str | None:
         table = self.query_one(DataTable)
         if not table.row_count:
@@ -322,7 +300,7 @@ class RunApp(App[None]):
         self.query_one(RunOutput).reset()
         self.query_one(DataTable).display = False
         self.query_one(RunOutput).display = True
-        self.sub_title = run
+        self.app.sub_title = run
         self.show("")
         self.refresh_bindings()
         self.follow()
@@ -338,7 +316,7 @@ class RunApp(App[None]):
             self.query_one(LogBlocks).display = False
             self.query_one(RunOutput).display = False
             self.query_one(DataTable).display = True
-            self.sub_title = ""
+            self.app.sub_title = ""
             self.refresh_bindings()
             if self.idle:
                 self.show_summary()
@@ -359,3 +337,150 @@ class RunApp(App[None]):
         event.input.display = bool(event.value)
         self.query_one(DataTable).focus()
         self.refresh_bindings()
+
+
+class RunApp(ViewSwitcher, App[None]):
+    CSS = "#concurrency { dock: right; width: auto; padding: 0 1; }"
+    BINDINGS = [Binding("ctrl+c", "interrupt", "Quit")]
+
+    def __init__(
+        self,
+        start: Start,
+        title: str,
+        columns: Sequence[str],
+        config: LabnotesConfig | None = None,
+        experiment_config: Path | None = None,
+    ) -> None:
+        super().__init__()
+        self.start = start
+        self.title = title
+        self.config = config
+        self.experiment_config = experiment_config
+        self.experiment_name = title
+        self.view_specs = self.configured_views()
+        self.results: list[dict[str, object]] = []
+        self.error: Exception | None = None
+        self.columns = tuple(columns)
+        self.body = RunLiveView(columns)
+        self.body.id = "view-1"
+        self.body_ready = True
+        self.loaded_views = False
+        self.shown: Experiment | None = None
+        self.left: dict[str, Widget] = {}
+        self.controls = self.body.controls
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with ContentSwitcher(initial="view-1"):
+            if self.view_specs:
+                assert self.config is not None
+                yield ViewPane("runs", BUILT_IN, self.config.root, id="view-1")
+            else:
+                yield self.body
+        yield Footer()
+
+    async def on_mount(self) -> None:
+        await self.query_one(Header).mount(Static(id="concurrency"))
+        if self.view_specs:
+            assert self.config is not None
+            self._bindings.bind("escape", "leave", "Back")
+            try:
+                self.body = self.query_one(RunLiveView)
+            except NoMatches:
+                # ViewPane already displays the built-in view's loading error.
+                self.body_ready = False
+            tables = open_tables(self.config, run_files=True)
+            self.run_worker(
+                reload_on_change(
+                    watch_rows(
+                        tables, {"runs", "experiment_configs"}, self.experiment_name
+                    ),
+                    lambda: self.load_data(tables),
+                    lambda error: None,
+                ),
+                exit_on_error=False,
+            )
+            self.run_worker(self.watch_files(tables), exit_on_error=False)
+        self.run_worker(self.drive())
+
+    def configured_views(self) -> dict[str, str]:
+        if self.config is None:
+            return {}
+        folder = self.config.experiments.replace("{experiment}", self.experiment_name)
+        path = self.experiment_config or self.config.root / folder / "experiment.toml"
+        try:
+            source = path.read_text()
+            layer = tomllib.loads(source)
+        except (OSError, tomllib.TOMLDecodeError):
+            # The runner reports missing or invalid config through its normal path.
+            layer = {}
+        return view_specs(compose_experiment(self.config.defaults, layer))
+
+    async def load_data(self, tables: Any) -> None:
+        assert self.config is not None
+        loaded = await load_experiment(
+            tables, self.config.root, self.experiment_name, QueryParams()
+        )
+        if loaded is None:
+            return
+        if not self.loaded_views:
+            await self.add_views(
+                cast(Mapping[str, str], loaded["views"]), self.config.root
+            )
+            self.loaded_views = True
+        self.shown = Experiment(
+            self.config.root,
+            self.experiment_name,
+            native_rows(loaded),
+            MappingProxyType(cast(dict[str, Any], loaded["config"] or {})),
+        )
+        self.deliver(self.shown)
+
+    async def watch_files(self, tables: Any) -> None:
+        async for row in watch_rows(tables, {"run_files"}, self.experiment_name):
+            if self.shown is not None:
+                self.deliver(self.shown, frozenset({str(row["path"])}))
+
+    async def drive(self) -> None:
+        try:
+            self.results = await self.start(self.show_event, self.listen)
+        except Exception as error:
+            self.error = error
+        self.exit()
+
+    def listen(self, controls: Controls) -> 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)
+
+    def show_event(self, event: dict[str, object]) -> None:
+        if self.body_ready:
+            self.body.show_event(event)
+
+    def stop_runs(self) -> None:
+        if self.body_ready and self.body.idle:
+            self.controls.finish()
+        else:
+            self.controls.interrupt()
+
+    def action_interrupt(self) -> None:
+        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:
+            self.controls.finish()
+        else:
+            self.exit()
+
+    async def action_quit(self) -> None:
+        self.action_interrupt()
+
+    def answer(self, choice: str | None) -> None:
+        if choice == "stop":
+            self.controls.interrupt()
+            self.set_timer(GRACE_SECONDS, self.controls.interrupt)
+
+    def action_leave(self) -> None:
+        if self.query_one(ContentSwitcher).current != "view-1":
+            self.action_show_view(1)

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

@@ -0,0 +1,106 @@
+import codecs
+from collections.abc import Iterable
+from pathlib import Path
+from typing import Self
+
+from rich.style import Style
+from rich.text import Text
+from rich.cells import cell_len
+from textual.geometry import Size
+from textual.strip import Strip
+from textual.widgets import Log
+
+from labnotes.latest_log import latest_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.paths: dict[str, Path] = {}
+        self.decoders = {
+            stream: codecs.getincrementaldecoder("utf-8")(errors="replace")
+            for stream in STREAMS
+        }
+        self.last_stream: str | None = None
+        self.unfinished = ""
+        self.clear()
+
+    @property
+    def mid_line(self) -> bool:
+        return bool(self.unfinished)
+
+    def follow(self, folder: Path) -> None:
+        for stream in STREAMS:
+            path = latest_log(folder, stream)
+            if not path.exists():
+                continue
+            if self.paths.setdefault(stream, path) != path:
+                self.paths[stream] = path
+                self.offsets[stream] = 0
+            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
+            # A stream's unfinished line is redrawn as it grows, but the
+            # other stream's output starts below it.
+            if self.mid_line and stream == self.last_stream:
+                self.drop_unfinished()
+                text = self.unfinished + text
+            *complete, self.unfinished = text.split("\n")
+            if complete:
+                self.write_lines(complete)
+            if self.unfinished:
+                self.write_lines([self.unfinished])
+            self.last_stream = stream
+
+    def write_lines(self, lines: Iterable[str], scroll_end: bool | None = None) -> Self:
+        new_lines = list(lines)
+        if not new_lines:
+            return self
+        at_end = self.is_vertical_scroll_end
+        self._lines.extend(new_lines)
+        self._width = max(self._width, max(map(len, new_lines)))
+        self.virtual_size = Size(self._width, len(self._lines))
+        self.refresh()
+        if (
+            self.is_mounted
+            and (self.auto_scroll if scroll_end is None else scroll_end)
+            and at_end
+        ):
+            self.scroll_end(animate=False, immediate=True, x_axis=False)
+        return self
+
+    def drop_unfinished(self) -> None:
+        self._lines.pop()
+        self._render_line_cache.discard(len(self._lines))
+        self.virtual_size = Size(self._width, len(self._lines))
+        self.refresh()
+
+    def _render_line_strip(self, y: int, rich_style: Style) -> Strip:
+        selection = self.text_selection
+        if selection is None and y in self._render_line_cache:
+            return self._render_line_cache[y]
+        line_text = Text.from_ansi(self._lines[y], style=rich_style)
+        if selection is not None:
+            if (span := selection.get_span(y)) is not None:
+                start, end = span
+                if end == -1:
+                    end = len(line_text)
+                line_text.stylize(
+                    self.screen.get_component_rich_style("screen--selection"),
+                    start,
+                    end,
+                )
+        line = Strip(line_text.render(self.app.console), cell_len(line_text.plain))
+        if selection is None:
+            self._render_line_cache[y] = line
+        return line

labnotes-0.2.11/src/labnotes/tui/run_tui.py

@@ -0,0 +1,20 @@
+from pathlib import Path
+
+from labnotes.models import LabnotesConfig, Start
+from labnotes.tui.config import RUN_COLUMNS
+from labnotes.tui.run_app import RunApp
+
+
+def run_tui(
+    start: Start,
+    title: str,
+    config: LabnotesConfig | None = None,
+    experiment_config: Path | None = None,
+) -> list[dict[str, object]]:
+    app = RunApp(
+        start, title, RUN_COLUMNS, config=config, experiment_config=experiment_config
+    )
+    app.run()
+    if app.error is not None:
+        raise app.error
+    return app.results

{labnotes-0.2.9 → labnotes-0.2.11}/src/labnotes/tui/view_process.py

@@ -13,7 +13,7 @@ GRACE_SECONDS = 1.0
 
 
 class ViewProcess:
-    """Hold one view worker for the life of labnotes, one request at a time."""
+    """Hold one view worker for a screen's life, one request at a time."""
 
     def __init__(self, command: str, root: Path) -> None:
         self.command = command

labnotes-0.2.11/src/labnotes/tui/view_switcher.py

@@ -0,0 +1,53 @@
+from collections.abc import Mapping
+from pathlib import Path
+
+from textual.widget import Widget
+from textual.widgets import ContentSwitcher
+
+from labnotes.tui.view_pane import ViewPane
+from labnotes.view.experiment import Experiment
+
+MAX_VIEWS = 8
+
+
+class ViewSwitcher:
+    """Mount and switch the same view panes in browse and run screens."""
+
+    left: dict[str, Widget]
+
+    async def add_views(self, specs: Mapping[str, str], root: Path) -> None:
+        names = list(specs)[:MAX_VIEWS]
+        if not names:
+            return
+        panes = [
+            ViewPane(name, specs[name], root, id=f"view-{number}")
+            for number, name in enumerate(names, 2)
+        ]
+        for pane in panes:
+            pane.display = False
+        await self.query_one(ContentSwitcher).mount_all(panes)  # type: ignore[attr-defined]
+        for number, name in enumerate(["runs", *names], 1):
+            self._bindings.bind(str(number), f"show_view({number})", name)  # type: ignore[attr-defined]
+        self._bindings.bind("0", "show_view(1)")  # type: ignore[attr-defined]
+        self.refresh_bindings()  # type: ignore[attr-defined]
+
+    def deliver(
+        self, experiment: Experiment | None, paths: frozenset[str] = frozenset()
+    ) -> None:
+        for pane in self.query(ViewPane):  # type: ignore[attr-defined]
+            pane.deliver(experiment, paths)
+
+    def action_show_view(self, number: int) -> None:
+        switcher = self.query_one(ContentSwitcher)  # type: ignore[attr-defined]
+        if switcher.current is not None and self.focused is not None:  # type: ignore[attr-defined]
+            self.left[switcher.current] = self.focused  # type: ignore[attr-defined]
+        switcher.current = f"view-{number}"
+        self.call_after_refresh(self.refocus, switcher.current)  # type: ignore[attr-defined]
+
+    def refocus(self, current: str) -> None:
+        widget = self.left.get(current)
+        if widget is not None and widget.focusable:
+            widget.focus()
+            return
+        self.set_focus(None)  # type: ignore[attr-defined]
+        self.screen.focus_next()  # type: ignore[attr-defined]

{labnotes-0.2.9 → labnotes-0.2.11}/testing-conventions.toml

@@ -40,8 +40,20 @@ rules = ["mutation"]
 lines = [221]
 reason = "the leave action name is the string literal from the Binding, which CPython interns, so is equals =="
 
+[[python.exempt]]
+path = "src/labnotes/tui/run_app.py"
+rules = ["mutation"]
+lines = [485]
+reason = "the switcher contains only view-1 through view-9; every non-built-in view id sorts above view-1, so > equals !="
+
 [[python.exempt]]
 path = "src/labnotes/runner/hold_experiment.py"
 rules = ["mutation"]
 lines = [18]
 reason = "LOCK_EX and LOCK_NB are disjoint bits, so | equals + and ^"
+
+[[python.exempt]]
+path = "src/labnotes/tui/run_output.py"
+rules = ["mutation"]
+lines = [96]
+reason = "a selection span ends at -1 or a non-negative offset, so <= equals ==; -1 is a CPython cached small int, so is equals =="