labnotes 0.0.73__tar.gz → 0.0.75__tar.gz

{labnotes-0.0.73 → labnotes-0.0.75}/.gitignore

@@ -24,3 +24,7 @@ docs/.vitepress/dist
 docs/node_modules/
 
 notes
+
+# Written by Claude Code when it loads the labnotes mod
+skills/labnotes/.claude-plugin/types/
+skills/labnotes/tsconfig.json

{labnotes-0.0.73 → labnotes-0.0.75}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.0.73
+Version: 0.0.75
 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>
@@ -14,6 +14,7 @@ Requires-Dist: ipykernel>=7.4.0
 Requires-Dist: jinja2>=3.1.6
 Requires-Dist: jupyter-client>=8.10.0
 Requires-Dist: markdown-it-py>=4.2.0
+Requires-Dist: markupsafe>=3.0.4
 Requires-Dist: psutil>=7.2.2
 Requires-Dist: rich>=14
 Requires-Dist: starlette>=1.8.0

{labnotes-0.0.73 → labnotes-0.0.75}/pyproject.toml

@@ -19,6 +19,7 @@ dependencies = [
     "jinja2>=3.1.6",
     "jupyter-client>=8.10.0",
     "markdown-it-py>=4.2.0",
+    "markupsafe>=3.0.4",
     "psutil>=7.2.2",
     "rich>=14",
     "starlette>=1.8.0",

{labnotes-0.0.73 → labnotes-0.0.75}/src/labnotes/context.md

@@ -122,6 +122,10 @@ going. Elsewhere, it prints a line per event instead.
   seconds later. Once the runs are done, either one closes the live view.
 - `labnotes run stop` stops every run the daemon has going: SIGTERM, then
   SIGKILL 5 seconds later.
+- `labnotes run status` prints what the daemon has going, a line per event so
+  far plus the latest line each running run logged. `-f` keeps following, and
+  waits for a daemon when none is up. `--json` prints one JSON object per line.
+  Following doesn't keep the daemon up.
 - A second `run` of the same experiment fails while the first is going.
 - It exits 0 even if runs fail; the summary line counts failures.
 

{labnotes-0.0.73 → labnotes-0.0.75}/src/labnotes/create_app.py

@@ -24,6 +24,7 @@ from labnotes.drain_watch import drain_watch
 from labnotes.experiment_notes import experiment_notes
 from labnotes.file_changes import file_changes
 from labnotes.format_duration import format_duration
+from labnotes.format_started import format_started
 from labnotes.format_value import format_value
 from labnotes.list_experiments import list_experiments
 from labnotes.load_experiment import load_experiment
@@ -42,6 +43,7 @@ HERE = Path(__file__).parent
 templates = Jinja2Templates(directory=HERE / "templates")
 templates.env.filters["value"] = format_value
 templates.env.filters["duration"] = format_duration
+templates.env.filters["started"] = format_started
 templates.env.globals["asset"] = asset_url
 
 

{labnotes-0.0.73 → labnotes-0.0.75}/src/labnotes/daemon/daemon_app.py

@@ -23,6 +23,8 @@ def daemon_app(config: LabnotesConfig) -> Starlette:
     sessions: dict[str, Controls | None] = {}
     owners: dict[str, int] = {}
     clients: dict[int, asyncio.Queue[Event]] = {}
+    watchers: set[int] = set()
+    history: dict[str, list[Event]] = {}
     ids = itertools.count(1)
     tasks: set[asyncio.Task[str | None]] = set()
 
@@ -40,11 +42,22 @@ def daemon_app(config: LabnotesConfig) -> Starlette:
                 del owners[name]
                 controls.finish()
 
+    def record(event: Event) -> None:
+        history.setdefault(str(event["experiment"]), []).append(event)
+        broadcast(event)
+
     async def events(request: Request) -> Response:
         client = next(ids)
+        watching = request.query_params.get("watch") == "1"
 
         async def stream() -> AsyncIterator[str]:
             clients[client] = asyncio.Queue()
+            if watching:
+                watchers.add(client)
+                for past in history.values():
+                    for old in past:
+                        clients[client].put_nowait(old)
+                clients[client].put_nowait({"event": "replayed"})
             try:
                 event: Event = {"event": "connected", "client": client}
                 while True:
@@ -52,6 +65,7 @@ def daemon_app(config: LabnotesConfig) -> Starlette:
                     event = await clients[client].get()
             finally:
                 del clients[client]
+                watchers.discard(client)
                 release(client)
 
         return StreamingResponse(stream(), media_type="text/event-stream")
@@ -86,7 +100,7 @@ def daemon_app(config: LabnotesConfig) -> Starlette:
                     name,
                     experiment,
                     concurrency,
-                    lambda event: broadcast({**event, "experiment": name}),
+                    lambda event: record({**event, "experiment": name}),
                     listen,
                 )
             # Clients hear why the session ended; the daemon keeps serving.
@@ -94,6 +108,7 @@ def daemon_app(config: LabnotesConfig) -> Starlette:
                 error = str(failure)
             del sessions[name]
             owners.pop(name, None)
+            history.pop(name, None)
             broadcast({"event": "done", "experiment": name, "error": error})
             return error
 
@@ -149,6 +164,8 @@ def daemon_app(config: LabnotesConfig) -> Starlette:
             Route("/experiments/{name}/{action}", control, methods=["POST"]),
         ]
     )
-    app.state.idle = lambda: not clients and not sessions
+    app.state.idle = (
+        lambda: all(client in watchers for client in clients) and not sessions
+    )
     app.state.stop = stop_all
     return app

labnotes-0.0.75/src/labnotes/daemon/describe_status.py

@@ -0,0 +1,14 @@
+from labnotes.runner.describe_event import describe_event
+
+
+def describe_status(event: dict[str, object]) -> str:
+    match event:
+        case {"event": "output"}:
+            said = f"{event['run']}: {event['line']}"
+        case {"event": "done", "error": None}:
+            said = "Done."
+        case {"event": "done"}:
+            said = f"Stopped: {event['error']}"
+        case _:
+            said = describe_event(event)
+    return f"{event['experiment']}: {said}"

labnotes-0.0.75/src/labnotes/daemon/run_logs.py

@@ -0,0 +1,54 @@
+from pathlib import Path
+
+STREAMS = ("stdout", "stderr")
+Key = tuple[str, str]
+
+
+class RunLogs:
+    """The latest line each running run wrote, read from its logs by byte offset."""
+
+    def __init__(self) -> None:
+        self.folders: dict[Key, Path] = {}
+        self.offsets: dict[tuple[Key, str], int] = {}
+        self.partial: dict[tuple[Key, str], bytes] = {}
+
+    def add(self, experiment: str, run: str, folder: Path) -> None:
+        self.folders[experiment, run] = folder
+
+    def drop(self, experiment: str, run: str) -> None:
+        self.folders.pop((experiment, run), None)
+
+    def latest(self) -> list[dict[str, object]]:
+        found: list[dict[str, object]] = []
+        for key, folder in self.folders.items():
+            for stream in STREAMS:
+                line = self.read(key, stream, folder / f"{stream}.log")
+                if line is not None:
+                    experiment, run = key
+                    found.append(
+                        {
+                            "event": "output",
+                            "experiment": experiment,
+                            "run": run,
+                            "stream": stream,
+                            "line": line,
+                        }
+                    )
+        return found
+
+    def read(self, key: Key, stream: str, path: Path) -> str | None:
+        try:
+            with path.open("rb") as log:
+                log.seek(self.offsets.get((key, stream), 0))
+                data = log.read()
+        except FileNotFoundError:
+            return None
+        self.offsets[key, stream] = self.offsets.get((key, stream), 0) + len(data)
+        *complete, rest = (self.partial.get((key, stream), b"") + data).split(b"\n")
+        self.partial[key, stream] = rest
+        shown = [
+            text
+            for line in complete
+            if (text := line.rsplit(b"\r")[-1].decode(errors="replace").strip())
+        ]
+        return shown[-1] if shown else None

labnotes-0.0.75/src/labnotes/daemon/watch_daemon.py

@@ -0,0 +1,52 @@
+import asyncio
+from collections.abc import Callable
+from pathlib import Path
+
+import httpx2
+
+from labnotes.daemon.daemon_client import daemon_client
+from labnotes.daemon.run_logs import RunLogs
+
+Event = dict[str, object]
+TAIL_SECONDS = 1.0
+
+
+async def watch_daemon(root: Path, follow: bool, emit: Callable[[Event], None]) -> None:
+    logs = RunLogs()
+
+    def tail() -> None:
+        for line in logs.latest():
+            emit(line)
+
+    async def keep_tailing() -> None:
+        while True:
+            await asyncio.sleep(TAIL_SECONDS)
+            tail()
+
+    tailing = asyncio.create_task(keep_tailing()) if follow else None
+    try:
+        async with (
+            daemon_client(root) as client,
+            client.stream("GET", "/events", params={"watch": "1"}) as response,
+        ):
+            events = aiter(httpx2.EventSource(response))
+            await anext(events)
+            async for message in events:
+                event: Event = message.json()  # type: ignore[assignment]
+                match event:
+                    case {"event": "replayed"}:
+                        tail()
+                        if not follow:
+                            return
+                        continue
+                    case {"event": "started", "experiment": str(name), "run": str(run)}:
+                        logs.add(name, run, Path(str(event["folder"])))
+                    case {"event": "ended", "experiment": str(name), "run": str(run)}:
+                        tail()
+                        logs.drop(name, run)
+                emit(event)
+    except httpx2.TransportError:
+        pass
+    finally:
+        if tailing is not None:
+            tailing.cancel()

labnotes-0.0.75/src/labnotes/daemon/watch_status.py

@@ -0,0 +1,19 @@
+import asyncio
+from collections.abc import Callable
+from pathlib import Path
+
+from labnotes.daemon.daemon_running import daemon_running
+from labnotes.daemon.watch_daemon import watch_daemon
+
+POLL_SECONDS = 1.0
+
+
+async def watch_status(
+    root: Path, follow: bool, emit: Callable[[dict[str, object]], None]
+) -> None:
+    while True:
+        if await daemon_running(root):
+            await watch_daemon(root, follow, emit)
+        if not follow:
+            return
+        await asyncio.sleep(POLL_SECONDS)

labnotes-0.0.75/src/labnotes/format_started.py

@@ -0,0 +1,8 @@
+from markupsafe import Markup, escape
+
+
+def format_started(utc: str | None) -> Markup:
+    if utc is None:
+        return Markup("—")
+    stamp = escape(utc)
+    return Markup(f'<time datetime="{stamp.replace(" ", "T")}Z">{stamp}</time>')

{labnotes-0.0.73 → labnotes-0.0.75}/src/labnotes/run_command.py

@@ -5,6 +5,7 @@ import click
 from labnotes.daemon.stop_runs import stop_runs
 from labnotes.load_config import load_config
 from labnotes.read_config import CONFIG_FILE
+from labnotes.run_status import run_status
 
 
 @click.group(name="run", help="Control the runs going in this project.")
@@ -24,3 +25,6 @@ def stop(ctx: click.Context) -> None:
         )
     stopping = asyncio.run(stop_runs(config.root))
     click.echo("Stopping runs." if stopping else "Nothing is running.")
+
+
+run_command.add_command(run_status)

labnotes-0.0.75/src/labnotes/run_status.py

@@ -0,0 +1,29 @@
+import asyncio
+import contextlib
+import json
+
+import click
+
+from labnotes.daemon.describe_status import describe_status
+from labnotes.daemon.watch_status import watch_status
+from labnotes.load_config import load_config
+from labnotes.read_config import CONFIG_FILE
+
+
+@click.command(name="status", help="Show what the runs in this project are doing.")
+@click.option("--follow", "-f", is_flag=True, help="Keep reporting until interrupted.")
+@click.option("--json", "as_json", is_flag=True, help="One JSON event per line.")
+@click.pass_context
+def run_status(ctx: click.Context, follow: bool, as_json: bool) -> None:
+    config = load_config(ctx)
+    if config is None:
+        raise click.ClickException(
+            f"No {CONFIG_FILE} here. Run labnotes init, or pass -c PATH."
+        )
+
+    def emit(event: dict[str, object]) -> None:
+        line = json.dumps(event, default=str) if as_json else describe_status(event)
+        click.echo(line)
+
+    with contextlib.suppress(KeyboardInterrupt):
+        asyncio.run(watch_status(config.root, follow, emit))

labnotes-0.0.75/src/labnotes/static/local-time.js

@@ -0,0 +1,18 @@
+const pad = (number) => String(number).padStart(2, "0");
+
+const localize = (root) => {
+  for (const time of root.querySelectorAll("time[datetime]")) {
+    const at = new Date(time.dateTime);
+    const day = `${at.getFullYear()}-${pad(at.getMonth() + 1)}-${pad(at.getDate())}`;
+    time.textContent = `${day} ${pad(at.getHours())}:${pad(at.getMinutes())}:${pad(at.getSeconds())}`;
+  }
+};
+
+localize(document);
+new MutationObserver((records) => {
+  for (const record of records) {
+    for (const node of record.addedNodes) {
+      if (node instanceof Element) localize(node);
+    }
+  }
+}).observe(document.body, { childList: true, subtree: true });

{labnotes-0.0.73 → labnotes-0.0.75}/src/labnotes/templates/experiment.html

@@ -83,7 +83,7 @@
     {% macro run_rows(run) %}
       <tr class="run-row">
         <td><span class="status {{ 'good' if run.labnotes_completed else 'bad' }}" title="{{ 'complete' if run.labnotes_completed else 'not complete' }}">{{ '✓' if run.labnotes_completed else '✕' }}</span></td>
-        {% for column in e.run_columns %}{% if column == 'id' and nested %}<td class="mono">{{ run.id.partition('/')[2] or run.id }}</td><td></td>{% else %}<td class="{{ 'mono' if loop.first }}{{ 'num' if column == 'duration' }}">{{ run[column] | duration if column == 'duration' else run[column] | value }}</td>{% endif %}{% endfor %}
+        {% for column in e.run_columns %}{% if column == 'id' and nested %}<td class="mono">{{ run.id.partition('/')[2] or run.id }}</td><td></td>{% else %}<td class="{{ 'mono' if loop.first }}{{ 'num' if column == 'duration' }}">{{ run[column] | duration if column == 'duration' else (run[column] | started if column == 'started' else run[column] | value) }}</td>{% endif %}{% endfor %}
       </tr>
     {% endmacro %}
     {% if nested %}
@@ -93,7 +93,7 @@
         <td class="num" title="{{ group.passed }} passed, {{ group.failed }} failed"><span class="good">{{ group.passed }}✓</span> <span class="bad">{{ group.failed }}✕</span></td>
         <td class="mono"><button type="button" class="group-toggle" aria-expanded="false">{{ group.name }}</button></td>
         <td class="num">{{ group.runs | length }}</td>
-        {% for column in e.run_columns[1:] %}<td>{{ group.started or '' if column == 'started' }}</td>{% endfor %}
+        {% for column in e.run_columns[1:] %}<td>{{ group.started | started if column == 'started' and group.started }}</td>{% endfor %}
       </tr>
       {% for run in group.runs %}{{ run_rows(run) }}{% endfor %}
     </tbody>
@@ -116,4 +116,5 @@
 </section>
 {% endif %}
 <script src="{{ asset('experiment.js') }}" defer></script>
+<script src="{{ asset('local-time.js') }}" defer></script>
 {% endblock %}

{labnotes-0.0.73 → labnotes-0.0.75}/testing-conventions.toml

@@ -31,7 +31,7 @@ reason = "quiet counts up by one from zero, so it reaches IDLE_EXIT_SECONDS befo
 [[python.exempt]]
 path = "src/labnotes/daemon/daemon_app.py"
 rules = ["mutation"]
-lines = [117]
+lines = [132]
 reason = "start answers 202, 400, 409 or 500, so every status but 202 is above it: != equals >"
 
 [[python.exempt]]

{labnotes-0.0.73 → labnotes-0.0.75}/tests/integration/conftest.py

@@ -65,12 +65,17 @@ def serve(root: Path) -> Iterator[str]:
 
 
 def browse(
-    url: str, check: Callable[[Page], Awaitable[None]], width: int = 1280
+    url: str,
+    check: Callable[[Page], Awaitable[None]],
+    width: int = 1280,
+    timezone_id: str = "UTC",
 ) -> None:
     async def drive() -> None:
         async with async_playwright() as playwright:
             browser = await playwright.chromium.launch()
-            page = await browser.new_page(viewport={"width": width, "height": 800})
+            page = await browser.new_page(
+                viewport={"width": width, "height": 800}, timezone_id=timezone_id
+            )
             await page.goto(url)
             await check(page)
             await browser.close()

{labnotes-0.0.73 → labnotes-0.0.75}/uv.lock

@@ -10,6 +10,17 @@ resolution-markers = [
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P3D"
 
+[options.exclude-newer-package]
+botbox = false
+cachetta = false
+coaxer = false
+curtaincall = false
+dirsql = false
+labnotes = false
+lamp-the-djinn = false
+pyskillet = false
+repo-name-checker = false
+
 [[package]]
 name = "anyio"
 version = "4.15.1"
@@ -550,6 +561,7 @@ dependencies = [
     { name = "jinja2" },
     { name = "jupyter-client" },
     { name = "markdown-it-py" },
+    { name = "markupsafe" },
     { name = "psutil" },
     { name = "rich" },
     { name = "starlette" },
@@ -577,6 +589,7 @@ requires-dist = [
     { name = "jinja2", specifier = ">=3.1.6" },
     { name = "jupyter-client", specifier = ">=8.10.0" },
     { name = "markdown-it-py", specifier = ">=4.2.0" },
+    { name = "markupsafe", specifier = ">=3.0.4" },
     { name = "psutil", specifier = ">=7.2.2" },
     { name = "rich", specifier = ">=14" },
     { name = "starlette", specifier = ">=1.8.0" },