labnotes 0.2.15__tar.gz → 0.2.16__tar.gz

{labnotes-0.2.15 → labnotes-0.2.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.2.15
+Version: 0.2.16
 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.16/conftest.py

@@ -0,0 +1,9 @@
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def state_home(
+    tmp_path_factory: pytest.TempPathFactory, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    # Run journals live under XDG_STATE_HOME; keep tests out of the real one.
+    monkeypatch.setenv("XDG_STATE_HOME", str(tmp_path_factory.mktemp("state")))

{labnotes-0.2.15 → labnotes-0.2.16}/src/labnotes/runner/run_experiment.py

@@ -30,6 +30,7 @@ from labnotes.runner.plan_runs import plan_runs
 from labnotes.runner.project_snapshot import ProjectSnapshot
 from labnotes.runner.run_folder import run_folder
 from labnotes.runner.run_locked import run_locked
+from labnotes.runner.run_state import RunState
 from labnotes.runner.signal_tree import signal_tree
 from labnotes.state_path import STATE_ENV
 from labnotes.tables.experiment_run_ids import experiment_run_ids
@@ -55,7 +56,15 @@ async def run_experiment(
     snapshot: ProjectSnapshot | None = None,
     command_line: str | None = None,
     run_id: str | None = None,
+    run_state: RunState | None = None,
 ) -> list[dict[str, object]]:
+    state = run_state or RunState.create(config, name)
+    forward = report
+
+    def emit(event: dict[str, object]) -> None:
+        state.record(event)
+        forward(event)
+
     command_root = snapshot.root if snapshot is not None else config.root
     inherited = dict(os.environ) if environment is None else environment
     tables = open_tables(config)
@@ -161,7 +170,7 @@ async def run_experiment(
     if experiment.meta is not None:
         meta = await invocation_meta(command_root, experiment.meta, hook_env["meta"])
     runs = [{"run": run, "params": params} for run, params in plan]
-    report(
+    emit(
         {
             "event": "planned",
             "title": experiment.name or name,
@@ -170,7 +179,7 @@ async def run_experiment(
         }
     )
     for row in held:
-        report({"event": "held", "run": str(row["id"])})
+        emit({"event": "held", "run": str(row["id"])})
     running: dict[str, set[asyncio.subprocess.Process]] = {}
     trees: dict[str, set[psutil.Process]] = {}
     stopped: set[str] = set()
@@ -189,14 +198,14 @@ async def run_experiment(
         plan.clear()
         if not stopping.is_set():
             stopping.set()
-            report({"event": "stopping"})
+            emit({"event": "stopping"})
             signal_runs(signal.SIGTERM)
             if waiting:
                 for run in list(waiting):
                     cancel_retry(run)
                 fill()
         elif any(running.values()):
-            report({"event": "killing"})
+            emit({"event": "killing"})
             signal_runs(signal.SIGKILL)
 
     def kill(run: str) -> None:
@@ -207,11 +216,11 @@ async def run_experiment(
         if not running.get(run):
             return
         if run in stopped:
-            report({"event": "killing run", "run": run})
+            emit({"event": "killing run", "run": run})
             signal_run(run, signal.SIGKILL)
         else:
             stopped.add(run)
-            report({"event": "stopping run", "run": run})
+            emit({"event": "stopping run", "run": run})
             signal_run(run, signal.SIGTERM)
 
     ended: dict[str, dict[str, object]] = {}
@@ -227,13 +236,13 @@ async def run_experiment(
             parents[again] = run
         attempts[again] = attempt
         plan.append((again, ended[run]))
-        report({"event": "retried", "run": run, "retry": again, "params": ended[run]})
+        emit({"event": "retried", "run": run, "retry": again, "params": ended[run]})
         fill()
 
     def retry_later(run: str) -> None:
         tried = attempts.get(run, 0)
         if tried >= experiment.retries:
-            report({"event": "gave up", "run": run, "retries": tried})
+            emit({"event": "gave up", "run": run, "retries": tried})
             return
         seconds = retry_seconds * 2**tried
 
@@ -242,7 +251,7 @@ async def run_experiment(
             requeue(run, tried + 1)
 
         waiting[run] = asyncio.get_running_loop().call_later(seconds, due)
-        report(
+        emit(
             {
                 "event": "retrying",
                 "run": run,
@@ -255,7 +264,7 @@ async def run_experiment(
     def cancel_retry(run: str) -> None:
         waiting.pop(run).cancel()
         release(run)
-        report({"event": "retry cancelled", "run": run})
+        emit({"event": "retry cancelled", "run": run})
 
     limit = concurrency
     live: set[asyncio.Task[None]] = set()
@@ -270,7 +279,7 @@ async def run_experiment(
             live.add(task)
             started.append(task)
         if not (live or waiting):
-            report({"event": "idle"})
+            emit({"event": "idle"})
             if finishing:
                 done.set()
 
@@ -287,19 +296,19 @@ async def run_experiment(
     def set_concurrency(count: int) -> None:
         nonlocal limit
         limit = max(1, count)
-        report({"event": "concurrency", "concurrency": limit})
+        emit({"event": "concurrency", "concurrency": limit})
         fill()
 
     async def start(run: str, params: dict[str, object]) -> None:
         folder = target_folder or run_folder(config.root, config.runs, name, run)
         folder.mkdir(parents=True, exist_ok=True)
         if not claim(run):
-            report({"event": "held", "run": run})
+            emit({"event": "held", "run": run})
             return
         if snapshot is not None and snapshot.sha is not None:
             (folder / "git-sha.txt").write_text(snapshot.sha + "\n")
             (folder / "git-diff.patch").write_bytes(snapshot.diff or b"")
-        report({"event": "started", "run": run, "params": params, "folder": folder})
+        emit({"event": "started", "run": run, "params": params, "folder": folder})
         # {invocation_dir} stays for configs written before runs were flat.
         dirs = dict.fromkeys(PLACEHOLDERS, str(folder.resolve()))
         running[run] = set()
@@ -337,7 +346,7 @@ async def run_experiment(
             command_line=command_line,
         )
         del running[run], trees[run]
-        report({"event": "ended", "run": run, **result})
+        emit({"event": "ended", "run": run, **result})
         ended[run] = params
         results[run] = {"run": run, **result}
         if result["exit_code"] == RETRY_EXIT_CODE and not (
@@ -349,7 +358,7 @@ async def run_experiment(
 
     async def teardown() -> None:
         if experiment.teardown is not None:
-            report({"event": "tearing down"})
+            emit({"event": "tearing down"})
             await invocation_hook(
                 command_root,
                 "teardown",
@@ -366,7 +375,7 @@ async def run_experiment(
         # Like vitest's globalSetup: a failed setup still gets its teardown.
         try:
             if experiment.setup is not None:
-                report({"event": "setting up"})
+                emit({"event": "setting up"})
                 await invocation_hook(
                     command_root,
                     "setup",
@@ -380,7 +389,7 @@ async def run_experiment(
             try:
                 await teardown()
             except Exception as failure:  # noqa: BLE001
-                report({"event": "teardown failed", "error": str(failure)})
+                emit({"event": "teardown failed", "error": str(failure)})
             raise
         finally:
             for run in list(locks):

labnotes-0.2.16/src/labnotes/runner/run_state.py

@@ -0,0 +1,62 @@
+"""Persist one invocation's run TUI events in the user's state folder."""
+
+import hashlib
+import json
+import os
+import time
+from pathlib import Path
+from uuid import uuid4
+
+from labnotes.models import LabnotesConfig
+from labnotes.runner.run_folder import run_folder
+
+
+def journal_folder(runs: Path) -> Path:
+    """Keep journals out of the runs folder, where scripts expect only runs."""
+    home = os.environ.get("XDG_STATE_HOME") or Path.home() / ".local" / "state"
+    key = hashlib.sha256(str(runs.resolve()).encode()).hexdigest()[:16]
+    return Path(home) / "labnotes" / "run-state" / key
+
+
+class RunState:
+    """Append complete events and replay them from a disk cursor."""
+
+    def __init__(self, path: Path) -> None:
+        self.path = path
+        self.offset = 0
+
+    @classmethod
+    def create(cls, config: LabnotesConfig, experiment: str) -> "RunState":
+        """Choose a journal unique to this invocation without touching disk yet."""
+        runs = run_folder(config.root, config.runs, experiment, "_").parent
+        stamp = time.strftime("%Y%m%d-%H%M%S", time.gmtime())
+        return cls(
+            journal_folder(runs) / f"{stamp}-{os.getpid()}-{uuid4().hex[:8]}.jsonl"
+        )
+
+    def record(self, event: dict[str, object]) -> None:
+        """Write one event before callers display it."""
+        at = time.time()
+        stored = {**event, "at": at}
+        if event["event"] == "retrying":
+            stored["retry_at"] = at + float(str(event["seconds"]))
+        data = (json.dumps(stored, default=str) + "\n").encode()
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self.path.touch(mode=0o600, exist_ok=True)
+        with self.path.open("ab") as file:
+            file.write(data)
+
+    def read(self) -> list[dict[str, object]]:
+        """Return only complete new events."""
+        try:
+            with self.path.open("rb") as file:
+                file.seek(self.offset)
+                data = file.read()
+        except FileNotFoundError:
+            return []
+        try:
+            end = data.rindex(b"\n") + 1
+        except ValueError:
+            return []
+        self.offset += end
+        return [json.loads(line) for line in data[:end].splitlines()]

{labnotes-0.2.15 → labnotes-0.2.16}/src/labnotes/runner/start_experiment.py

@@ -1,3 +1,4 @@
+from dataclasses import dataclass
 from pathlib import Path
 
 from labnotes.models import LabnotesConfig, Listen, Report, Start
@@ -5,6 +6,18 @@ from labnotes.runner.finalize_lost_runs import finalize_lost_runs
 from labnotes.runner.prepare_experiment import prepare_experiment
 from labnotes.runner.project_snapshot import project_snapshot
 from labnotes.runner.run_experiment import run_experiment
+from labnotes.runner.run_state import RunState
+
+
+@dataclass(frozen=True)
+class ExperimentStart:
+    """Keep a run invocation's journal path with its scheduler callback."""
+
+    run_state: RunState
+    start: Start
+
+    async def __call__(self, report: Report, listen: Listen) -> list[dict[str, object]]:
+        return await self.start(report, listen)
 
 
 def start_experiment(
@@ -19,7 +32,9 @@ def start_experiment(
     teardown: str | None,
     command_line: str | None = None,
     run_id: str | None = None,
-) -> Start:
+) -> ExperimentStart:
+    state = RunState.create(config, name)
+
     async def start(report: Report, listen: Listen) -> list[dict[str, object]]:
         experiment, limit = await prepare_experiment(
             config, name, experiment_config, concurrency, only, args, setup, teardown
@@ -39,6 +54,7 @@ def start_experiment(
                 snapshot=snapshot,
                 command_line=command_line,
                 run_id=run_id,
+                run_state=state,
             )
 
-    return start
+    return ExperimentStart(state, start)

{labnotes-0.2.15 → labnotes-0.2.16}/src/labnotes/tui/run_app.py

@@ -21,6 +21,7 @@ from labnotes.models import Controls, LabnotesConfig, Start
 from labnotes.retries import RETRY_EXIT_CODE
 from labnotes.runner.describe_event import describe_event
 from labnotes.runner.param_args import param_args
+from labnotes.runner.start_experiment import ExperimentStart
 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
@@ -119,7 +120,11 @@ class RunLiveView(Widget):
             case "started":
                 self.idle = False
                 self.pending.discard(run)
-                self.started[run] = time.monotonic()
+                self.started[run] = (
+                    time.monotonic() - max(0.0, time.time() - float(str(event["at"])))
+                    if "at" in event
+                    else time.monotonic()
+                )
                 self.folders[run] = Path(str(event["folder"]))
                 args = " ".join(param_args(event["params"]))  # type: ignore[arg-type]
                 shown = {
@@ -146,7 +151,11 @@ class RunLiveView(Widget):
                 self.unmeasured[run] = None
                 self.measure()
             case "retrying":
-                self.waiting[run] = time.monotonic() + float(event["seconds"])  # type: ignore[arg-type]
+                self.waiting[run] = time.monotonic() + (
+                    max(0.0, float(str(event["retry_at"])) - time.time())
+                    if "retry_at" in event
+                    else float(str(event["seconds"]))
+                )
                 self.tick()
                 self.show(describe_event(event))
             case "gave up":
@@ -368,6 +377,8 @@ class RunApp(ViewSwitcher, App[None]):
         self.shown: Experiment | None = None
         self.left: dict[str, Widget] = {}
         self.controls = self.body.controls
+        self.run_state = start.run_state if isinstance(start, ExperimentStart) else None
+        self.watching_state = False
 
     def compose(self) -> ComposeResult:
         yield Header()
@@ -456,8 +467,19 @@ class RunApp(ViewSwitcher, App[None]):
         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)
+        if self.run_state is None:
+            if self.body_ready:
+                self.body.show_event(event)
+            return
+        if not self.watching_state:
+            self.watching_state = True
+            self.set_interval(0.25, self.refresh_state)
+        self.refresh_state()
+
+    def refresh_state(self) -> None:
+        if self.run_state is not None and self.body_ready:
+            for event in self.run_state.read():
+                self.body.show_event(event)
 
     def stop_runs(self) -> None:
         if self.body_ready and self.body.idle: