labnotes 0.2.8__tar.gz → 0.2.9__tar.gz

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

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

@@ -19,9 +19,11 @@ from labnotes.parse_run_view import parse_run_view
 from labnotes.pivot_runs import pivot_runs
 from labnotes.python_blocks import python_blocks
 from labnotes.render_markdown import render_markdown
+from labnotes.run_columns import run_columns
 from labnotes.runs_view_command import runs_view_command
 from labnotes.sort_href import sort_href
 from labnotes.sql_quote import quote_string
+from labnotes.view_specs import view_specs
 from labnotes.summarize_config import summarize_config
 from labnotes.utils.process_alive import process_alive
 
@@ -49,7 +51,7 @@ async def load_experiment(
     varies = cast(dict[str, list[object]], summary["varies"])
     source = experiment_runs(name, list(varies))
     summary = await check_counts(tables, source, summary)
-    shown = ["id", *(key for key in varies if key != "id"), "started", "duration"]
+    shown = run_columns(config)
     choices = {
         key: {format_value(value): json.dumps(value) for value in values}
         for key, values in varies.items()
@@ -70,7 +72,9 @@ async def load_experiment(
             pid, created if isinstance(created, int | float) else None
         )
 
-    runs_live = any(is_running(run) for run in runs)
+    for run in runs:
+        run["labnotes_running"] = is_running(run)
+    runs_live = any(run["labnotes_running"] for run in runs)
     nested = await nests_runs(tables, source)
     groups = (
         group_runs(runs, list(choices), await count_groups(tables, source))
@@ -92,6 +96,7 @@ async def load_experiment(
     return {
         "name": row["name"],
         "display_name": row["display_name"],
+        "config": config,
         "config_source": row["source"],
         "counts_set": "counts" in (config or {}),
         **summary,
@@ -115,6 +120,7 @@ async def load_experiment(
         "run_view": view,
         "run_choices": choices,
         "runs_view": runs_view_command(config),
+        "views": view_specs(config),
         "sort_hrefs": {
             column: sort_href(view, column) for column in ["status", *shown]
         },

labnotes-0.2.9/src/labnotes/param_names.py

@@ -0,0 +1,9 @@
+from collections.abc import Mapping
+from typing import cast
+
+from labnotes.summarize_config import summarize_config
+
+
+def param_names(config: Mapping[str, object] | None) -> list[str]:
+    summary = summarize_config(None if config is None else dict(config))
+    return [key for key in cast(dict[str, object], summary["varies"]) if key != "id"]

labnotes-0.2.9/src/labnotes/run_columns.py

@@ -0,0 +1,7 @@
+from collections.abc import Mapping
+
+from labnotes.param_names import param_names
+
+
+def run_columns(config: Mapping[str, object] | None) -> list[str]:
+    return ["id", *param_names(config), "started", "duration"]

{labnotes-0.2.8 → labnotes-0.2.9}/src/labnotes/runner/read_experiment_config.py

@@ -30,7 +30,7 @@ SETTINGS = {
     "from",
 }
 HOOKS = ("setup", "teardown")
-VIEWS = {"runs"}
+MAX_VIEWS = 8
 
 
 def read_experiment_config(
@@ -107,12 +107,18 @@ def read_experiment_config(
     views = values.get("views", {})
     if not isinstance(views, dict):
         raise ValueError(f"{path}: views must be a table, like [views]")
-    unknown = sorted(views.keys() - VIEWS)
-    if unknown:
-        raise ValueError(f"{path}: unknown keys in views: {', '.join(unknown)}")
     runs = views.get("runs")
     if runs is not None and (not isinstance(runs, str) or not runs.strip()):
         raise ValueError(f"{path}: views.runs must be a command")
+    shown = {name: spec for name, spec in views.items() if name != "runs"}
+    if len(shown) > MAX_VIEWS:
+        raise ValueError(f"{path}: views holds at most {MAX_VIEWS} views besides runs")
+    for name, spec in shown.items():
+        source, _, cls = spec.rpartition(":") if isinstance(spec, str) else ("", "", "")
+        if not source.strip() or not cls.strip():
+            raise ValueError(
+                f'{path}: views.{name} must be "path/to/file.py:ClassName"'
+            )
     return ExperimentConfig(
         command,
         repeats,

{labnotes-0.2.8 → labnotes-0.2.9}/src/labnotes/tui/browse_app.py

@@ -5,8 +5,6 @@ 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
-from labnotes.tui.runs_view import Request
-from labnotes.tui.view_process import ViewProcess
 
 
 class BrowseApp(App[BaseException | None]):
@@ -17,23 +15,11 @@ class BrowseApp(App[BaseException | None]):
         self.config = config
         self.experiment_name = name
         self.title = config.root.name
-        self.views: dict[str, ViewProcess] = {}
 
     def on_mount(self) -> None:
         tables = open_tables(self.config, run_files=True)
-        self.push_screen(ExperimentsScreen(tables, self.config, self.view_request))
+        self.push_screen(ExperimentsScreen(tables, self.config))
         if self.experiment_name is not None:
             self.push_screen(
-                ExperimentScreen(
-                    tables, self.config, self.experiment_name, self.view_request
-                )
+                ExperimentScreen(tables, self.config, self.experiment_name)
             )
-
-    def view_request(self, command: str) -> Request:
-        if command not in self.views:
-            self.views[command] = ViewProcess(command, self.config.root)
-        return self.views[command].request
-
-    async def on_unmount(self) -> None:
-        for process in self.views.values():
-            await process.close()

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

@@ -0,0 +1,143 @@
+from collections.abc import Mapping
+from types import MappingProxyType
+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.widget import Widget
+from textual.widgets import ContentSwitcher, Footer, Header
+from textual.worker import Worker, WorkerState
+
+from labnotes.load_experiment import load_experiment
+from labnotes.models import LabnotesConfig
+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.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]):
+    BINDINGS = [Binding("escape", "back", "Back")]
+
+    def __init__(
+        self,
+        tables: DirSQL,
+        config: LabnotesConfig,
+        name: str,
+    ) -> None:
+        super().__init__()
+        self.tables = tables
+        self.config = config
+        self.experiment_name = name
+        self.found = False
+        self.shown: Experiment | None = None
+        self.left: dict[str, Widget] = {}
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with ContentSwitcher(initial="view-1"):
+            yield ViewPane("runs", BUILT_IN, self.config.root, id="view-1")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.sub_title = self.experiment_name
+        self.run_worker(
+            reload_on_change(
+                watch_rows(self.tables, WATCHED, self.experiment_name),
+                self.load,
+                self.stopped,
+            ),
+            exit_on_error=False,
+        )
+        self.run_worker(self.watch_files(), 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)
+
+    def stopped(self, error: BaseException | None) -> None:
+        self.sub_title = stopped_title(self.sub_title, error)
+
+    async def load(self) -> None:
+        loaded: dict[str, Any] | None = await load_experiment(
+            self.tables,
+            self.config.root,
+            self.experiment_name,
+            QueryParams(),
+        )
+        if loaded is None and not self.found:
+            raise ValueError(f"No experiment named {self.experiment_name}.")
+        if loaded is None:
+            self.sub_title = f"{self.experiment_name} was removed."
+            self.shown = None
+            self.deliver(None)
+            return
+        if not self.found:
+            await self.add_views(loaded["views"])
+        self.found = True
+        self.sub_title = str(loaded["display_name"])
+        self.shown = Experiment(
+            self.config.root,
+            self.experiment_name,
+            native_rows(loaded),
+            MappingProxyType(loaded["config"] or {}),
+        )
+        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()
+        else:
+            self.action_show_view(1)

{labnotes-0.2.8 → labnotes-0.2.9}/src/labnotes/tui/experiments_screen.py

@@ -1,5 +1,3 @@
-from collections.abc import Callable
-
 from dirsql import DirSQL
 from textual.app import ComposeResult
 from textual.screen import Screen
@@ -12,7 +10,6 @@ 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.tui.runs_view import Request
 from labnotes.tui.stopped_title import stopped_title
 from labnotes.watch_rows import watch_rows
 
@@ -20,13 +17,10 @@ WATCHED = {"files", "runs", "experiment_configs"}
 
 
 class ExperimentsScreen(Screen[None]):
-    def __init__(
-        self, tables: DirSQL, config: LabnotesConfig, views: Callable[[str], Request]
-    ) -> None:
+    def __init__(self, tables: DirSQL, config: LabnotesConfig) -> None:
         super().__init__()
         self.tables = tables
         self.config = config
-        self.views = views
 
     def compose(self) -> ComposeResult:
         yield Header()
@@ -63,7 +57,5 @@ class ExperimentsScreen(Screen[None]):
 
     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), self.views
-            )
+            ExperimentScreen(self.tables, self.config, str(event.row_key.value))
         )

{labnotes-0.2.8 → labnotes-0.2.9}/src/labnotes/tui/format_cell.py

@@ -7,13 +7,15 @@ from labnotes.tui.dim import dim
 from labnotes.tui.format_elapsed import format_elapsed
 
 
-def format_cell(key: str, value: object, live: bool) -> object:
+def format_cell(key: str, value: object) -> object:
     if key == "status" and value == "passed":
         return Text("✓", style="green")
     if key == "status" and value == "failed":
         return Text("✕", style="red")
+    if key == "status" and value == "running":
+        return Text("◐", style="yellow")
     if key == "status" and value == "unfinished":
-        return Text("◐", style="yellow") if live else dim("–")
+        return dim("–")
     if key == "duration" and isinstance(value, int) and not isinstance(value, bool):
         return format_elapsed(value)
     if key == "started" and isinstance(value, str):

labnotes-0.2.9/src/labnotes/tui/guard_view.py

@@ -0,0 +1,35 @@
+from collections.abc import Callable, Iterable
+from typing import cast
+
+from textual.message import Message
+from textual.widget import Widget
+
+
+def guard_view(view: type[Widget], failed: Callable[[Exception], None]) -> type[Widget]:
+    """Subclass a view so errors in its compose and handlers reach `failed`.
+
+    Textual ends the app on any error a widget raises. A view is someone else's
+    code, so its errors stay in its pane instead.
+    """
+
+    def compose(self: Widget) -> Iterable[Widget]:
+        try:
+            yield from view.compose(self)
+        except Exception as error:
+            failed(error)
+
+    # _dispatch_message is private to Textual, but every handler runs under it.
+    async def _dispatch_message(self: Widget, message: Message) -> None:
+        try:
+            await view._dispatch_message(self, message)
+        except Exception as error:
+            failed(error)
+
+    namespace = {
+        "__module__": view.__module__,
+        "__qualname__": view.__qualname__,
+        "compose": compose,
+        "_dispatch_message": _dispatch_message,
+    }
+    # type() builds a subclass of view, so it is a Widget subclass.
+    return cast(type[Widget], type(view.__name__, (view,), namespace))

labnotes-0.2.9/src/labnotes/tui/load_view.py

@@ -0,0 +1,27 @@
+import importlib
+import sys
+from importlib.machinery import SourceFileLoader
+from pathlib import Path
+from types import ModuleType
+
+from textual.widget import Widget
+
+
+def load_view(spec: str, root: Path) -> type[Widget]:
+    """Import the widget class `spec` names: `file.py:Class` from `root`, or `module:Class`."""
+    source, _, name = spec.rpartition(":")
+    if source.endswith(".py"):
+        path = root / source
+        module = ModuleType(f"labnotes_view_{path.stem}")
+        module.__file__ = str(path)
+        # Dataclasses and pickling look a class's module up by name.
+        sys.modules[module.__name__] = module
+        SourceFileLoader(module.__name__, str(path)).exec_module(module)
+    else:
+        module = importlib.import_module(source)
+    view = getattr(module, name, None)
+    if view is None:
+        raise ImportError(f"{source} has no {name}")
+    if not isinstance(view, type) or not issubclass(view, Widget):
+        raise TypeError(f"{spec} is not a Textual widget")
+    return view

{labnotes-0.2.8 → labnotes-0.2.9}/src/labnotes/tui/native_rows.py

@@ -11,7 +11,7 @@ def native_row(run: Mapping[str, Any]) -> dict[str, Any]:
         if isinstance(row.get(key), str):
             row[key] = json.loads(row[key])
     if run["labnotes_unfinished"]:
-        row["status"] = "unfinished"
+        row["status"] = "running" if run["labnotes_running"] else "unfinished"
     elif run["labnotes_completed"]:
         row["status"] = "passed"
     else:
@@ -20,5 +20,5 @@ def native_row(run: Mapping[str, Any]) -> dict[str, Any]:
     return row
 
 
-def native_rows(experiment: Mapping[str, Any]) -> dict[str, dict[str, Any]]:
-    return {str(run["folder"]): native_row(run) for run in experiment["runs_list"]}
+def native_rows(experiment: Mapping[str, Any]) -> tuple[dict[str, Any], ...]:
+    return tuple(native_row(run) for run in experiment["runs_list"])

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

@@ -0,0 +1,12 @@
+from collections.abc import Mapping, Sequence
+
+from labnotes.tui.format_cell import format_cell
+
+
+def run_cells(
+    row: Mapping[str, object], columns: Sequence[Mapping[str, str]]
+) -> list[object]:
+    return [
+        format_cell(column["key"], row[column["key"]]) if column["key"] in row else ""
+        for column in columns
+    ]

labnotes-0.2.8/src/labnotes/tui/run_screen.py → labnotes-0.2.9/src/labnotes/tui/run_panel.py

@@ -1,16 +1,15 @@
 from pathlib import Path
 
 from textual.app import ComposeResult
-from textual.binding import Binding
-from textual.screen import Screen
-from textual.widgets import Footer, Header
+from textual.containers import Vertical
+from textual.widgets import Static
 
 from labnotes.tui.log_blocks import LogBlocks
 from labnotes.tui.run_output import RunOutput
 
 
-class RunScreen(Screen[None]):
-    BINDINGS = [Binding("escape", "app.pop_screen", "Back")]
+class RunPanel(Vertical):
+    DEFAULT_CSS = "RunPanel #run-id { padding: 0 1; text-style: bold; }"
 
     def __init__(self, run_id: str, folder: Path) -> None:
         super().__init__()
@@ -18,13 +17,11 @@ class RunScreen(Screen[None]):
         self.folder = folder
 
     def compose(self) -> ComposeResult:
-        yield Header()
+        yield Static(self.run_id, id="run-id", markup=False)
         yield LogBlocks(id="blocks")
         yield RunOutput(id="output")
-        yield Footer()
 
     def on_mount(self) -> None:
-        self.sub_title = self.run_id
         self.follow()
         self.set_interval(0.25, self.follow)
 

labnotes-0.2.9/src/labnotes/tui/runs_browser.py

@@ -0,0 +1,132 @@
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.widget import Widget
+from textual.widgets import DataTable, Static
+
+from labnotes.runs_view_command import runs_view_command
+from labnotes.tui.fill_table import fill_table
+from labnotes.tui.run_output import RunOutput
+from labnotes.tui.run_panel import RunPanel
+from labnotes.tui.runs_table import RunsTable
+from labnotes.tui.runs_view import RunsView
+from labnotes.tui.table_columns import table_columns
+from labnotes.tui.table_rows import table_rows
+from labnotes.tui.view_process import ViewProcess
+from labnotes.view.changed import Changed
+from labnotes.view.experiment import Experiment
+
+
+class RunsBrowser(Widget):
+    """Show an experiment's runs, then a run's output: the built-in view."""
+
+    DEFAULT_CSS = """
+    RunsBrowser RunsTable { height: 1fr; }
+    RunsBrowser #view-status { color: $text-warning; }
+    """
+    BINDINGS = [
+        Binding("enter", "open_row", "Open", priority=True),
+        Binding("escape", "close_run", "Back"),
+    ]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.process: ViewProcess | None = None
+        self.view: RunsView | None = None
+        self.experiment = Experiment(Path(), "", ())
+        self.viewing: str | None = None
+
+    def compose(self) -> ComposeResult:
+        yield RunsTable(id="runs", cursor_type="row")
+        yield Static(id="view-status")
+
+    def check_action(self, action: str, parameters: tuple[object, ...]) -> bool:
+        if action == "open_row":
+            return self.viewing is None
+        if action == "close_run":
+            return self.viewing is not None
+        return True
+
+    def on_labnotes_changed(self, message: Changed) -> None:
+        if message.paths:
+            if self.view is not None:
+                for path in sorted(message.paths):
+                    self.view.touch(path)
+                self.ask(self.view)
+            return
+        experiment = message.experiment
+        if experiment is None:
+            fill_table(self.query_one(DataTable), [], [])
+            return
+        self.experiment = experiment
+        command = runs_view_command(dict(experiment.config))
+        if command is not None and self.view is None:
+            self.process = ViewProcess(command, experiment.root)
+            self.view = RunsView(self.process.request)
+        if self.view is not None:
+            rows = {str(row["folder"]): dict(row) for row in experiment.runs}
+            self.view.update(table_columns(experiment.config), rows)
+            self.ask(self.view)
+        self.redraw()
+
+    async def on_unmount(self) -> None:
+        if self.process is not None:
+            await self.process.close()
+
+    def ask(self, view: RunsView) -> None:
+        request = view.next_request()
+        if request is not None:
+            self.run_worker(self.answer(view, request), exit_on_error=False)
+
+    async def answer(self, view: RunsView, request: dict[str, Any]) -> None:
+        if await view.exchange(request):
+            self.redraw()
+        else:
+            self.show_status()
+        self.ask(view)
+
+    def redraw(self) -> None:
+        rows: Mapping[str, Mapping[str, Any]]
+        if self.view is None:
+            columns = table_columns(self.experiment.config)
+            rows = {str(row["folder"]): row for row in self.experiment.runs}
+        else:
+            columns, rows = self.view.table()
+        fill_table(
+            self.query_one(DataTable),
+            [column["label"] for column in columns],
+            table_rows(self.experiment.runs, columns, rows),
+        )
+        self.show_status()
+
+    def show_status(self) -> None:
+        text = "" if self.view is None else self.view.status()
+        status = self.query_one("#view-status", Static)
+        status.update(text)
+        status.display = bool(text) and self.viewing is None
+
+    async def action_open_row(self) -> None:
+        table = self.query_one(DataTable)
+        if not table.row_count:
+            return
+        folder = str(
+            table.coordinate_to_cell_key(table.cursor_coordinate).row_key.value
+        )
+        ids = {str(row["folder"]): str(row["id"]) for row in self.experiment.runs}
+        panel = RunPanel(ids[folder], self.experiment.root / folder)
+        self.viewing = folder
+        table.display = False
+        self.show_status()
+        await self.mount(panel)
+        panel.query_one(RunOutput).focus()
+
+    def action_close_run(self) -> None:
+        self.viewing = None
+        self.query_one(RunPanel).remove()
+        table = self.query_one(DataTable)
+        table.display = True
+        table.focus()
+        self.show_status()

labnotes-0.2.9/src/labnotes/tui/table_columns.py

@@ -0,0 +1,8 @@
+from collections.abc import Mapping
+
+from labnotes.run_columns import run_columns
+
+
+def table_columns(config: Mapping[str, object]) -> list[dict[str, str]]:
+    keys = run_columns(config)
+    return [{"key": "status", "label": ""}, *({"key": k, "label": k} for k in keys)]

labnotes-0.2.9/src/labnotes/tui/table_rows.py

@@ -0,0 +1,12 @@
+from collections.abc import Mapping, Sequence
+
+from labnotes.tui.run_cells import run_cells
+
+
+def table_rows(
+    runs: Sequence[Mapping[str, object]],
+    columns: Sequence[Mapping[str, str]],
+    rows: Mapping[str, Mapping[str, object]],
+) -> list[tuple[str, list[object]]]:
+    folders = [str(run["folder"]) for run in runs]
+    return [(folder, run_cells(rows[folder], columns)) for folder in folders]