labnotes 0.2.8__tar.gz → 0.2.10__tar.gz

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

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

@@ -0,0 +1,104 @@
+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.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"
+
+
+class ExperimentScreen(ViewSwitcher, 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.config.root)
+        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 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_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.10}/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.10}/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.10/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.10/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.10}/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"])