labnotes 0.0.99__tar.gz → 0.0.101__tar.gz

{labnotes-0.0.99 → labnotes-0.0.101}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.0.99
+Version: 0.0.101
 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>
@@ -49,6 +49,10 @@ names: the experiments path must use `{experiment}`, and the runs path both.
 labnotes reads the file from the working folder, or from the path given with
 `-c`.
 
+When `experiment.toml` sits next to `.labnotes.toml`, the root is the one
+experiment, named after its folder. Paths then drop `{experiment}`: files
+default to `files/` and runs to `runs/{run}`.
+
 `labnotes experiments` reads three tables from those paths:
 
 - `experiments`: `name`, and `config`, the experiment's `experiment.toml` as

{labnotes-0.0.99 → labnotes-0.0.101}/README.md

@@ -25,6 +25,10 @@ names: the experiments path must use `{experiment}`, and the runs path both.
 labnotes reads the file from the working folder, or from the path given with
 `-c`.
 
+When `experiment.toml` sits next to `.labnotes.toml`, the root is the one
+experiment, named after its folder. Paths then drop `{experiment}`: files
+default to `files/` and runs to `runs/{run}`.
+
 `labnotes experiments` reads three tables from those paths:
 
 - `experiments`: `name`, and `config`, the experiment's `experiment.toml` as

{labnotes-0.0.99 → labnotes-0.0.101}/src/labnotes/context.md

@@ -15,6 +15,8 @@ path = "{experiment}/runs/{run}" # one folder per run
 
 Paths are relative to the root. `{experiment}` and `{run}` stand for folder names; the experiments and files paths use `{experiment}`, the runs path both. A project laid out differently keeps its folders and changes the paths: look at where its experiments, notes and runs live, then write the templates that match.
 
+When `experiment.toml` sits next to `.labnotes.toml`, the root is the one experiment, named after its folder. Paths then drop `{experiment}`: files default to `files/`, runs to `runs/{run}`, and `[experiments] path` is rejected.
+
 `labnotes experiments` reads three tables from those paths:
 
 - `experiments`: `name`, and `config`, the experiment's `experiment.toml` as

{labnotes-0.0.99 → labnotes-0.0.101}/src/labnotes/context_guide.py

@@ -17,8 +17,12 @@ def context_guide(config: LabnotesConfig | None, cwd: Path) -> str:
         project = (
             f"Config: {config.path}\n"
             f"Root: {config.root}\n"
-            f"Experiments: {config.experiments}\n"
-            f"Files: {config.files}\n"
+            + (
+                f"Experiment: {config.experiment} (the root is the one experiment)\n"
+                if config.experiment
+                else f"Experiments: {config.experiments}\n"
+            )
+            + f"Files: {config.files}\n"
             f"Runs: {config.runs}"
         )
     return f"labnotes {version('labnotes')}\n\n{project}\n\n{guide}"

{labnotes-0.0.99 → labnotes-0.0.101}/src/labnotes/create_experiment.py

@@ -18,6 +18,10 @@ def create_experiment(config: LabnotesConfig, name: str | None) -> Path:
     def folder(candidate: str) -> Path:
         return config.root / config.experiments.replace("{experiment}", candidate)
 
+    if config.experiment is not None:
+        raise ValueError(
+            f"{config.root} is the experiment {config.experiment}; it can't hold others."
+        )
     if name is None:
         name = new_run_id(lambda candidate: folder(candidate).exists())
     if name == "new":

{labnotes-0.0.99 → labnotes-0.0.101}/src/labnotes/create_note.py

@@ -8,6 +8,8 @@ def create_note(config: LabnotesConfig, experiment: str) -> Path | None:
     def folder(template: str) -> Path:
         return config.root / template.replace("{experiment}", experiment)
 
+    if config.experiment not in (None, experiment):
+        return None
     if experiment.startswith(".") or not folder(config.experiments).is_dir():
         return None
     notes = folder(file_prefix(config.files))

labnotes-0.0.101/src/labnotes/default_config_text.py

@@ -0,0 +1,10 @@
+from labnotes.read_path import DEFAULT_PATHS, SINGLE_PATHS
+
+
+def default_config_text(*, single: bool = False) -> str:
+    paths = SINGLE_PATHS if single else DEFAULT_PATHS
+    return "\n".join(
+        f'[{table}]\npath = "{template}"\n'
+        for table, template in paths.items()
+        if template
+    )

{labnotes-0.0.99 → labnotes-0.0.101}/src/labnotes/init.py

@@ -11,7 +11,8 @@ def init() -> None:
     path = Path.cwd() / CONFIG_FILE
     try:
         with path.open("x", encoding="utf-8") as file:
-            file.write(default_config_text())
+            single = (path.parent / "experiment.toml").is_file()
+            file.write(default_config_text(single=single))
     except FileExistsError as error:
         raise click.ClickException(f"{path} already exists.") from error
     click.echo(f"Wrote {path}")

{labnotes-0.0.99 → labnotes-0.0.101}/src/labnotes/models.py

@@ -47,6 +47,8 @@ class LabnotesConfig:
     runs: str
     mode: str = DEFAULT_MODE
     concurrency: int = 1
+    # Set when the config's folder is itself the one experiment.
+    experiment: str | None = None
 
 
 @dataclass(frozen=True)

{labnotes-0.0.99 → labnotes-0.0.101}/src/labnotes/note_path.py

@@ -10,7 +10,7 @@ def note_path(config: LabnotesConfig, experiment: str, note: str) -> Path | None
     if ".." in PurePosixPath(relative).parts or not note.endswith(".md"):
         return None
     found = path_pattern(config.files).fullmatch(relative)
-    if found is None or found["experiment"] != experiment:
+    if found is None or (config.experiment or found["experiment"]) != experiment:
         return None
     path = config.root / relative
     return path if path.is_relative_to(config.root) and path.is_file() else None

{labnotes-0.0.99 → labnotes-0.0.101}/src/labnotes/read_config.py

@@ -18,8 +18,11 @@ def read_config(path: Path) -> LabnotesConfig:
     unknown = sorted(values.keys() - DEFAULT_PATHS.keys())
     if unknown:
         raise ValueError(f"{path}: unknown tables {', '.join(unknown)}")
+    root = path.resolve().parent
+    single = (root / "experiment.toml").is_file()
     paths = {
-        table: read_path(path, table, values.get(table, {})) for table in DEFAULT_PATHS
+        table: read_path(path, table, values.get(table, {}), single=single)
+        for table in DEFAULT_PATHS
     }
     experiments = values.get("experiments", {})
     mode = experiments.get("mode", DEFAULT_MODE)
@@ -30,7 +33,11 @@ def read_config(path: Path) -> LabnotesConfig:
         raise ValueError(
             f"{path}: [experiments] concurrency must be a positive integer"
         )
-    path = path.resolve()
     return LabnotesConfig(
-        path, path.parent, **paths, mode=mode, concurrency=concurrency
+        path.resolve(),
+        root,
+        **paths,
+        mode=mode,
+        concurrency=concurrency,
+        experiment=root.name if single else None,
     )

{labnotes-0.0.99 → labnotes-0.0.101}/src/labnotes/read_path.py

@@ -6,31 +6,46 @@ DEFAULT_PATHS = {
     "files": "{experiment}/files/",
     "runs": "{experiment}/runs/{run}",
 }
+# One experiment at the config's folder, so no {experiment} to fill.
+SINGLE_PATHS = {"experiments": "", "files": "files/", "runs": "runs/{run}"}
 PLACEHOLDERS = {
     "experiments": {"experiment"},
     "files": {"experiment"},
     "runs": {"experiment", "run"},
 }
+# experiments is missing: one experiment has no folder to point at.
+SINGLE_PLACEHOLDERS: dict[str, set[str]] = {"files": set(), "runs": {"run"}}
 # Keys other readers own, so the path check lets them through.
 OTHER_KEYS = {"experiments": {"mode", "concurrency"}}
 PLACEHOLDER = re.compile(r"\{([^}]*)\}")
+SINGLE = "experiment.toml sits next to .labnotes.toml, so this folder is the experiment"
 
 
-def read_path(config: Path, table: str, section: object) -> str:
+def read_path(config: Path, table: str, section: object, single: bool = False) -> str:
     if not isinstance(section, dict):
         raise ValueError(f"{config}: {table} must be a table, like [{table}]")
     unknown = sorted(section.keys() - {"path", *OTHER_KEYS.get(table, ())})
     if unknown:
         raise ValueError(f"{config}: unknown keys in [{table}]: {', '.join(unknown)}")
-    template = section.get("path", DEFAULT_PATHS[table])
+    defaults = SINGLE_PATHS if single else DEFAULT_PATHS
+    if single and table not in SINGLE_PLACEHOLDERS:
+        if "path" in section:
+            raise ValueError(f"{config}: [experiments] path doesn't apply; {SINGLE}")
+        return SINGLE_PATHS[table]
+    template = section.get("path", defaults[table])
     if not isinstance(template, str):
         raise ValueError(f"{config}: [{table}] path must be a string")
     if PurePosixPath(template).is_absolute() or template.startswith("~"):
         raise ValueError(
             f"{config}: [{table}] path must be relative to the config's folder"
         )
-    required = PLACEHOLDERS[table]
-    if set(PLACEHOLDER.findall(template)) != required:
+    used = set(PLACEHOLDER.findall(template))
+    if single and "experiment" in used:
+        raise ValueError(f"{config}: [{table}] path can't use {{experiment}}; {SINGLE}")
+    required = SINGLE_PLACEHOLDERS[table] if single else PLACEHOLDERS[table]
+    if used != required:
         expected = " and ".join(f"{{{name}}}" for name in sorted(required))
+        if not expected:
+            raise ValueError(f"{config}: [{table}] path can't use placeholders")
         raise ValueError(f"{config}: [{table}] path must use exactly {expected}")
     return template

{labnotes-0.0.99 → labnotes-0.0.101}/src/labnotes/run_output.py

@@ -43,8 +43,30 @@ async def run_output(
             last, mid_line = stream, not text.endswith("\n")
             yield f"data: {json.dumps({'stream': stream, 'text': text})}\n\n"
 
+    blocks_read = 0
+
+    def read_blocks() -> Iterator[str]:
+        nonlocal blocks_read
+        path = folder / "log.jsonl"
+        if not path.exists():
+            return
+        with path.open("rb") as log:
+            log.seek(blocks_read)
+            data = log.read()
+        whole = data[: data.rfind(b"\n") + 1]
+        blocks_read += len(whole)
+        for line in whole.splitlines():
+            try:
+                record = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if isinstance(record, dict):
+                yield f"event: block\ndata: {json.dumps(record)}\n\n"
+
     for message in read(STREAMS):
         yield message
+    for message in read_blocks():
+        yield message
     exit_code = run["exit_code"]
     if run["ended"] is None:
         async for event in events:
@@ -54,6 +76,9 @@ async def run_output(
             if event.table == "logs" and row["run"] == run_id:
                 for message in read([row["stream"]]):
                     yield message
+            elif event.table == "blocks" and row["run"] == run_id:
+                for message in read_blocks():
+                    yield message
             elif (
                 event.table == "runs"
                 and row["id"] == run_id
@@ -63,4 +88,6 @@ async def run_output(
                 break
         for message in read(STREAMS):
             yield message
+        for message in read_blocks():
+            yield message
     yield f"event: end\ndata: {json.dumps(exit_code)}\n\n"

{labnotes-0.0.99 → labnotes-0.0.101}/src/labnotes/runner/prepare_experiment.py

@@ -11,6 +11,10 @@ async def prepare_experiment(
     experiment_config: Path | None,
     concurrency: int | None,
 ) -> tuple[ExperimentConfig, int]:
+    if config.experiment not in (None, name):
+        raise ValueError(
+            f"No experiment {name}; this project is the experiment {config.experiment}."
+        )
     if experiment_config is None:
         folder = config.experiments.replace("{experiment}", name)
         experiment_config = config.root / folder / "experiment.toml"

{labnotes-0.0.99 → labnotes-0.0.101}/src/labnotes/static/labnotes.css

@@ -302,6 +302,13 @@ h3 {
 /* Run output */
 .run-state.good { color: var(--good); }
 .run-state.bad { color: var(--bad); }
+.run-blocks { background: var(--surface); border: 1px solid var(--rule); border-radius: 6px; margin-bottom: 1rem; padding: 0.5rem 0; max-height: 50vh; overflow: auto; }
+.run-blocks[hidden] { display: none; }
+.log-block { display: block; width: 100%; padding: 0.2rem 1.25rem; border: 0; background: none; color: inherit; font: inherit; font-family: var(--mono); font-size: 0.82rem; text-align: left; cursor: pointer; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+.log-block::before { content: "▸ "; color: var(--ink-3); }
+.log-block[aria-expanded="true"] { white-space: pre-wrap; overflow-wrap: anywhere; }
+.log-block[aria-expanded="true"]::before { content: "▾ "; }
+.log-block:hover { background: color-mix(in srgb, var(--accent) 4%, transparent); }
 .run-log { background: var(--surface); border: 1px solid var(--rule); border-radius: 6px; }
 .run-log header { display: flex; gap: 1rem; padding: 0.4rem 1.25rem; border-bottom: 1px solid var(--rule); font-family: var(--mono); font-size: 0.75rem; color: var(--ink-3); }
 .run-log header span::before { content: "■ "; }

{labnotes-0.0.99 → labnotes-0.0.101}/src/labnotes/static/run-output.js

@@ -4,12 +4,41 @@ const output = document.querySelector(".run-output");
 const state = document.querySelector(".run-state");
 const source = new EventSource(output.dataset.url);
 
+const blocks = document.querySelector(".run-blocks");
+
 let parsers = {};
+let streaming = new Map();
 
 // The server resends the whole log on each connection, so a reconnect starts clean.
 source.addEventListener("open", () => {
   output.replaceChildren();
   parsers = {};
+  blocks.replaceChildren();
+  blocks.hidden = true;
+  streaming = new Map();
+});
+
+source.addEventListener("block", (event) => {
+  const { id, phase, content = "" } = JSON.parse(event.data);
+  const open = streaming.get(id);
+  if (open && (phase === "delta" || phase === "stop")) {
+    open.textContent += content;
+    if (phase === "stop") streaming.delete(id);
+    return;
+  }
+  if (phase === "stop") return;
+  const line = document.createElement("button");
+  line.type = "button";
+  line.className = "log-block";
+  line.setAttribute("aria-expanded", "false");
+  line.textContent = content;
+  line.addEventListener("click", () => {
+    const expanded = line.getAttribute("aria-expanded") === "true";
+    line.setAttribute("aria-expanded", String(!expanded));
+  });
+  if (phase === "start" || phase === "delta") streaming.set(id, line);
+  blocks.append(line);
+  blocks.hidden = false;
 });
 
 source.addEventListener("message", (event) => {

labnotes-0.0.101/src/labnotes/tables/experiment_toml.py

@@ -0,0 +1,5 @@
+import posixpath
+
+
+def experiment_toml(template: str) -> str:
+    return posixpath.join(template, "experiment.toml")

{labnotes-0.0.99 → labnotes-0.0.101}/src/labnotes/tables/open_tables.py

@@ -3,7 +3,9 @@ from functools import partial
 from dirsql import DirSQL, Table
 
 from labnotes.models import LabnotesConfig
+from labnotes.tables.experiment_toml import experiment_toml
 from labnotes.tables.path_glob import path_glob
+from labnotes.tables.read_blocks import read_blocks
 from labnotes.tables.read_experiment import read_experiment
 from labnotes.tables.read_file import read_file
 from labnotes.tables.read_log import read_log
@@ -48,6 +50,12 @@ CREATE TABLE logs (
   PRIMARY KEY (experiment, run, stream)
 )
 """
+BLOCKS = """
+CREATE TABLE blocks (
+  experiment TEXT, run TEXT, size INTEGER,
+  PRIMARY KEY (experiment, run)
+)
+"""
 
 
 def open_tables(config: LabnotesConfig) -> DirSQL:
@@ -59,25 +67,44 @@ def open_tables(config: LabnotesConfig) -> DirSQL:
                 name="files",
                 ddl=FILES,
                 glob=path_glob(config.files),
-                on_file=partial(read_file, root, config.files),
+                on_file=partial(
+                    read_file, root, config.files, experiment=config.experiment
+                ),
             ),
             Table(
                 name="runs",
                 ddl=RUNS,
                 glob=path_glob(f"{config.runs}/run.json"),
-                on_file=partial(read_run, root, config.runs),
+                on_file=partial(
+                    read_run, root, config.runs, experiment=config.experiment
+                ),
             ),
             Table(
                 name="logs",
                 ddl=LOGS,
                 glob=path_glob(f"{config.runs}/std*.log"),
-                on_file=partial(read_log, root, config.runs),
+                on_file=partial(
+                    read_log, root, config.runs, experiment=config.experiment
+                ),
+            ),
+            Table(
+                name="blocks",
+                ddl=BLOCKS,
+                glob=path_glob(f"{config.runs}/log.jsonl"),
+                on_file=partial(
+                    read_blocks, root, config.runs, experiment=config.experiment
+                ),
             ),
             Table(
                 name="experiment_configs",
                 ddl=EXPERIMENTS,
-                glob=path_glob(f"{config.experiments}/experiment.toml"),
-                on_file=partial(read_experiment, root, config.experiments),
+                glob=path_glob(experiment_toml(config.experiments)),
+                on_file=partial(
+                    read_experiment,
+                    root,
+                    config.experiments,
+                    experiment=config.experiment,
+                ),
             ),
         ],
         # Run folders are often gitignored (DVC, large outputs); scan them anyway.

labnotes-0.0.101/src/labnotes/tables/read_blocks.py

@@ -0,0 +1,19 @@
+from pathlib import Path
+
+from labnotes.tables.path_pattern import path_pattern
+
+
+def read_blocks(
+    root: Path, template: str, path: str, experiment: str | None = None
+) -> list[dict[str, object]]:
+    relative = Path(path).relative_to(root).as_posix()
+    found = path_pattern(f"{template}/log.jsonl").fullmatch(relative)
+    if found is None:
+        return []
+    return [
+        {
+            "experiment": experiment or found["experiment"],
+            "run": found["run"],
+            "size": Path(path).stat().st_size,
+        }
+    ]

{labnotes-0.0.99 → labnotes-0.0.101}/src/labnotes/tables/read_experiment.py

@@ -2,19 +2,22 @@ import json
 import tomllib
 from pathlib import Path
 
+from labnotes.tables.experiment_toml import experiment_toml
 from labnotes.tables.path_pattern import path_pattern
 
 
-def read_experiment(root: Path, template: str, path: str) -> list[dict[str, object]]:
+def read_experiment(
+    root: Path, template: str, path: str, experiment: str | None = None
+) -> list[dict[str, object]]:
     relative = Path(path).relative_to(root).as_posix()
-    found = path_pattern(f"{template}/experiment.toml").fullmatch(relative)
+    found = path_pattern(experiment_toml(template)).fullmatch(relative)
     if found is None:
         return []
     source = Path(path).read_text(encoding="utf-8")
     config = tomllib.loads(source)
     return [
         {
-            "experiment": found["experiment"],
+            "experiment": experiment or found["experiment"],
             "config": json.dumps(config),
             "source": source,
         }

{labnotes-0.0.99 → labnotes-0.0.101}/src/labnotes/tables/read_file.py

@@ -6,7 +6,9 @@ from labnotes.tables.note_text import note_text
 from labnotes.tables.path_pattern import path_pattern
 
 
-def read_file(root: Path, template: str, path: str) -> list[dict[str, object]]:
+def read_file(
+    root: Path, template: str, path: str, experiment: str | None = None
+) -> list[dict[str, object]]:
     relative = Path(path).relative_to(root).as_posix()
     found = path_pattern(template).fullmatch(relative)
     prefix = path_pattern(file_prefix(template).rstrip("/")).match(relative)
@@ -15,7 +17,7 @@ def read_file(root: Path, template: str, path: str) -> list[dict[str, object]]:
     stat = Path(path).stat()
     return [
         {
-            "experiment": found["experiment"],
+            "experiment": experiment or found["experiment"],
             "filename": relative[prefix.end() :].lstrip("/"),
             "path": relative,
             "ctime": iso_time(stat.st_ctime),

{labnotes-0.0.99 → labnotes-0.0.101}/src/labnotes/tables/read_log.py

@@ -5,14 +5,16 @@ from labnotes.tables.path_pattern import path_pattern
 STREAMS = ("stdout", "stderr")
 
 
-def read_log(root: Path, template: str, path: str) -> list[dict[str, object]]:
+def read_log(
+    root: Path, template: str, path: str, experiment: str | None = None
+) -> list[dict[str, object]]:
     relative = Path(path).relative_to(root).as_posix()
     found = path_pattern(f"{template}/{{stream}}.log").fullmatch(relative)
     if found is None or found["stream"] not in STREAMS:
         return []
     return [
         {
-            "experiment": found["experiment"],
+            "experiment": experiment or found["experiment"],
             "run": found["run"],
             "stream": found["stream"],
             "size": Path(path).stat().st_size,

{labnotes-0.0.99 → labnotes-0.0.101}/src/labnotes/tables/read_run.py

@@ -4,7 +4,9 @@ from pathlib import Path
 from labnotes.tables.path_pattern import path_pattern
 
 
-def read_run(root: Path, template: str, path: str) -> list[dict[str, object]]:
+def read_run(
+    root: Path, template: str, path: str, experiment: str | None = None
+) -> list[dict[str, object]]:
     relative = Path(path).relative_to(root).as_posix()
     found = path_pattern(f"{template}/run.json").fullmatch(relative)
     if found is None:
@@ -13,7 +15,7 @@ def read_run(root: Path, template: str, path: str) -> list[dict[str, object]]:
     folder = relative.removesuffix("/run.json")
     return [
         {
-            "experiment": found["experiment"],
+            "experiment": experiment or found["experiment"],
             "id": found["run"],
             "folder": folder,
             "created": run.get("created"),

{labnotes-0.0.99 → labnotes-0.0.101}/src/labnotes/templates/run.html

@@ -11,6 +11,8 @@
   </p>
 </section>
 
+<section class="run-blocks" hidden></section>
+
 <section class="run-log">
   <header><span class="stdout">stdout</span><span class="stderr">stderr</span></header>
   <pre class="run-output" data-url="{{ url_for('output', name=run.experiment, run=run.id) }}"></pre>

labnotes-0.0.101/src/labnotes/tui/log_block.py

@@ -0,0 +1,31 @@
+from rich.text import Text
+from textual.events import Click
+from textual.widgets import Static
+
+
+class LogBlock(Static):
+    DEFAULT_CSS = """
+    LogBlock { height: auto; }
+    LogBlock.-collapsed { height: 1; text-wrap: nowrap; text-overflow: ellipsis; }
+    """
+
+    def __init__(self, body: str) -> None:
+        super().__init__(classes="-collapsed")
+        self.body = body
+        self.expanded = False
+        self.show()
+
+    def extend(self, text: str) -> None:
+        self.body += text
+        self.show()
+
+    def on_click(self, _: Click) -> None:
+        self.expanded = not self.expanded
+        self.set_class(not self.expanded, "-collapsed")
+        self.show()
+
+    def show(self) -> None:
+        if self.expanded:
+            self.update(Text(f"▾ {self.body}"))
+        else:
+            self.update(Text(f"▸ {self.body}".replace("\n", " ")))

labnotes-0.0.101/src/labnotes/tui/log_blocks.py

@@ -0,0 +1,55 @@
+import json
+from pathlib import Path
+
+from textual.containers import VerticalScroll
+
+from labnotes.tui.log_block import LogBlock
+
+STREAMING = ("start", "delta")
+
+
+class LogBlocks(VerticalScroll):
+    DEFAULT_CSS = "LogBlocks { height: auto; max-height: 50%; }"
+
+    def __init__(self, id: str | None = None) -> None:
+        super().__init__(id=id)
+        self.reset()
+
+    def reset(self) -> None:
+        self.read_to = 0
+        self.streaming: dict[object, LogBlock] = {}
+        self.remove_children()
+        self.display = False
+
+    def follow(self, folder: Path) -> None:
+        path = folder / "log.jsonl"
+        if not path.exists():
+            return
+        with path.open("rb") as log:
+            log.seek(self.read_to)
+            data = log.read()
+        complete = data[: data.rfind(b"\n") + 1]
+        self.read_to += len(complete)
+        for line in complete.splitlines():
+            try:
+                record = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if isinstance(record, dict):
+                self.add(record)
+
+    def add(self, record: dict[str, object]) -> None:
+        phase, key = record.get("phase"), record.get("id")
+        body = str(record.get("content", ""))
+        if phase == "delta" and key in self.streaming:
+            self.streaming[key].extend(body)
+            return
+        if phase == "stop":
+            if key in self.streaming:
+                self.streaming.pop(key).extend(body)
+            return
+        block = LogBlock(body)
+        if phase in STREAMING:
+            self.streaming[key] = block
+        self.mount(block)
+        self.display = True

{labnotes-0.0.99 → labnotes-0.0.101}/src/labnotes/tui/run_app.py

@@ -15,6 +15,7 @@ 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.leave_prompt import LeavePrompt
+from labnotes.tui.log_blocks import LogBlocks
 from labnotes.tui.run_output import RunOutput
 from labnotes.tui.runs_table import RunsTable
 
@@ -83,6 +84,7 @@ class RunApp(App[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")
@@ -379,6 +381,7 @@ class RunApp(App[None]):
 
     def view(self, run: str) -> None:
         self.viewing = run
+        self.query_one(LogBlocks).reset()
         self.query_one(RunOutput).reset()
         self.query_one(DataTable).display = False
         self.query_one(RunOutput).display = True
@@ -389,11 +392,13 @@ class RunApp(App[None]):
 
     def follow(self) -> None:
         if self.viewing in self.folders:
+            self.query_one(LogBlocks).follow(self.folders[self.viewing])
             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(LogBlocks).display = False
             self.query_one(RunOutput).display = False
             self.query_one(DataTable).display = True
             self.sub_title = ""