labnotes 0.0.73__tar.gz → 0.0.74__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.0.73
+Version: 0.0.74
 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.0.73 → labnotes-0.0.74}/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.74}/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.74/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.74/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.74/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.74/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.73 → labnotes-0.0.74}/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.74/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.73 → labnotes-0.0.74}/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]]