labnotes 0.0.70__tar.gz → 0.0.71__tar.gz

{labnotes-0.0.70 → labnotes-0.0.71}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.0.70
+Version: 0.0.71
 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.70 → labnotes-0.0.71}/src/labnotes/context.md

@@ -105,23 +105,21 @@ running run under the cursor; `x` again kills it. `+` and
 `-` change how many run at once; lowering it lets running runs
 finish. Enter on a run follows its `stdout.log` and `stderr.log` together, as
 they're written, and Escape returns to the table. An `adhoc` experiment that
-plans a single run opens straight on its output. `q` quits. Elsewhere, it prints a
-line per event instead.
+plans a single run opens straight on its output. `q` quits and leaves the runs
+going. Elsewhere, it prints a line per event instead.
 
 - `--concurrency N` runs N at a time to start with. Without it, `concurrency`
   in `experiment.toml` sets it, then `concurrency` under `[experiments]` in
   `.labnotes.toml`, then 1.
 - `-e PATH` reads another file instead of `experiment.toml`.
+- `run` hands its runs to the project's labnotes daemon, starting it if
+  needed, and shows or waits for them. The daemon listens on `.labnotes.sock`
+  in the project folder and exits once nothing is running and no client has
+  been connected for 15 seconds. Runs belong to the daemon, so quitting the
+  live view, closing its terminal, or killing `run` outright leaves them going.
 - Ctrl-C stops the running scripts and records their end. A second Ctrl-C
-  kills them. Closing the terminal or sending SIGTERM stops them the same way,
-  then kills any still going 5 seconds later. Once the runs are done, either
-  one closes the live view.
-- Outside a terminal, `run` hands its runs to the project's labnotes daemon,
-  starting it if needed, and waits for them. The daemon listens on
-  `.labnotes.sock` in the project folder and exits once nothing is running and
-  no client has been connected for 15 seconds. Runs belong to the daemon, so
-  killing the waiting `run` outright leaves them going. Ctrl-C or SIGTERM to it
-  still stops them.
+  kills them. SIGTERM stops them the same way, then kills any still going 5
+  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.
 - A second `run` of the same experiment fails while the first is going.

{labnotes-0.0.70 → labnotes-0.0.71}/src/labnotes/daemon/daemon_app.py

@@ -1,6 +1,6 @@
 import asyncio
-import contextlib
 import dataclasses
+import itertools
 import json
 from collections.abc import AsyncIterator
 from pathlib import Path
@@ -11,7 +11,6 @@ from starlette.responses import JSONResponse, Response, StreamingResponse
 from starlette.routing import Route
 
 from labnotes.models import Controls, LabnotesConfig
-from labnotes.runner.hold_folder import hold_folder
 from labnotes.runner.prepare_experiment import prepare_experiment
 from labnotes.runner.run_experiment import run_experiment
 from labnotes.runner.stop_then_kill import GRACE_SECONDS
@@ -22,35 +21,45 @@ ACTIONS = frozenset(field.name for field in dataclasses.fields(Controls))
 
 def daemon_app(config: LabnotesConfig) -> Starlette:
     sessions: dict[str, Controls | None] = {}
-    clients: set[asyncio.Queue[Event]] = set()
+    owners: dict[str, int] = {}
+    clients: dict[int, asyncio.Queue[Event]] = {}
+    ids = itertools.count(1)
     tasks: set[asyncio.Task[str | None]] = set()
 
     def broadcast(event: Event) -> None:
-        for queue in clients:
+        for queue in clients.values():
             queue.put_nowait(event)
 
     def refuse(status: int, error: str) -> Response:
         return JSONResponse({"error": error}, status_code=status)
 
+    def release(client: int) -> None:
+        for name, owner in list(owners.items()):
+            controls = sessions.get(name)
+            if owner == client and controls is not None:
+                del owners[name]
+                controls.finish()
+
     async def events(request: Request) -> Response:
-        queue: asyncio.Queue[Event] = asyncio.Queue()
+        client = next(ids)
 
         async def stream() -> AsyncIterator[str]:
-            clients.add(queue)
+            clients[client] = asyncio.Queue()
             try:
-                event: Event = {"event": "connected"}
+                event: Event = {"event": "connected", "client": client}
                 while True:
                     yield f"data: {json.dumps(event, default=str)}\n\n"
-                    event = await queue.get()
+                    event = await clients[client].get()
             finally:
-                clients.discard(queue)
+                del clients[client]
+                release(client)
 
         return StreamingResponse(stream(), media_type="text/event-stream")
 
     async def start(name: str, body: dict[str, object]) -> Response:
         path = body.get("experiment_config")
         try:
-            experiment, concurrency, runs = await prepare_experiment(
+            experiment, concurrency = await prepare_experiment(
                 config,
                 name,
                 None if path is None else Path(str(path)),
@@ -58,33 +67,33 @@ def daemon_app(config: LabnotesConfig) -> Starlette:
             )
         except ValueError as error:
             return refuse(400, str(error))
-        lock = contextlib.ExitStack()
-        try:
-            lock.enter_context(hold_folder(runs))
-        except BlockingIOError:
-            return refuse(409, f"{name} is already running ({runs} is held).")
         ready = asyncio.Event()
+        owner = body.get("client")
+        if isinstance(owner, int):
+            owners[name] = owner
 
         def listen(controls: Controls) -> None:
             sessions[name] = controls
             ready.set()
+            if name in owners and owners[name] not in clients:
+                release(owners[name])
 
         async def session() -> str | None:
             error = None
-            with lock:
-                try:
-                    await run_experiment(
-                        config,
-                        name,
-                        experiment,
-                        concurrency,
-                        lambda event: broadcast({**event, "experiment": name}),
-                        listen,
-                    )
-                # Clients hear why the session ended; the daemon keeps serving.
-                except Exception as failure:  # noqa: BLE001
-                    error = str(failure)
+            try:
+                await run_experiment(
+                    config,
+                    name,
+                    experiment,
+                    concurrency,
+                    lambda event: broadcast({**event, "experiment": name}),
+                    listen,
+                )
+            # Clients hear why the session ended; the daemon keeps serving.
+            except Exception as failure:  # noqa: BLE001
+                error = str(failure)
             del sessions[name]
+            owners.pop(name, None)
             broadcast({"event": "done", "experiment": name, "error": error})
             return error
 

{labnotes-0.0.70 → labnotes-0.0.71}/src/labnotes/daemon/remote_start.py

@@ -25,10 +25,11 @@ def remote_start(
             client.stream("GET", "/events") as response,
         ):
             events = aiter(httpx2.EventSource(response))
-            await anext(events)
+            connected: dict[str, object] = (await anext(events)).json()  # type: ignore[assignment]
             reply = await client.post(
                 f"/experiments/{name}/run",
                 json={
+                    "client": connected["client"],
                     "experiment_config": None
                     if experiment_config is None
                     else str(experiment_config.resolve()),

{labnotes-0.0.70 → labnotes-0.0.71}/src/labnotes/experiments.py

@@ -10,7 +10,6 @@ from labnotes.load_config import load_config
 from labnotes.print_rows import print_rows
 from labnotes.read_config import CONFIG_FILE
 from labnotes.runner.run_headless import run_headless
-from labnotes.runner.start_experiment import start_experiment
 from labnotes.tables.experiment_rows import experiment_rows
 from labnotes.tui.run_tui import run_tui
 
@@ -63,15 +62,12 @@ def experiments(
             click.echo(f"Created {path / 'experiment.toml'}")
             return
         case str(), "run":
+            start = remote_start(config, name, experiment_config, concurrency)
             try:
                 if sys.stdout.isatty() and sys.stderr.isatty():
-                    results = start_experiment(
-                        config, name, experiment_config, concurrency, run_tui
-                    )
+                    results = run_tui(start, name)
                 else:
-                    results = run_headless(
-                        remote_start(config, name, experiment_config, concurrency)
-                    )
+                    results = run_headless(start)
             except ValueError as error:
                 raise click.ClickException(str(error)) from error
             failed = sum(result["exit_code"] != 0 for result in results)

{labnotes-0.0.70 → labnotes-0.0.71}/src/labnotes/runner/prepare_experiment.py

@@ -2,7 +2,6 @@ from pathlib import Path
 
 from labnotes.models import ExperimentConfig, LabnotesConfig
 from labnotes.runner.read_experiment_config import read_experiment_config
-from labnotes.runner.runs_parent import runs_parent
 from labnotes.tables.file_text import file_text
 
 
@@ -11,7 +10,7 @@ async def prepare_experiment(
     name: str,
     experiment_config: Path | None,
     concurrency: int | None,
-) -> tuple[ExperimentConfig, int, Path]:
+) -> tuple[ExperimentConfig, int]:
     if experiment_config is None:
         folder = config.experiments.replace("{experiment}", name)
         experiment_config = config.root / folder / "experiment.toml"
@@ -21,10 +20,4 @@ async def prepare_experiment(
     experiment = read_experiment_config(
         experiment_config, source, config.mode, config.concurrency
     )
-    runs = runs_parent(config.root, config.runs, name)
-    runs.mkdir(parents=True, exist_ok=True)
-    return (
-        experiment,
-        experiment.concurrency if concurrency is None else concurrency,
-        runs,
-    )
+    return experiment, experiment.concurrency if concurrency is None else concurrency

{labnotes-0.0.70 → labnotes-0.0.71}/src/labnotes/runner/run_experiment.py

@@ -65,6 +65,7 @@ async def run_experiment(
     report(
         {
             "event": "planned",
+            "title": experiment.name or name,
             "runs": runs,
             "concurrency": concurrency,
             "mode": experiment.mode,

{labnotes-0.0.70 → labnotes-0.0.71}/src/labnotes/tui/run_app.py

@@ -1,3 +1,4 @@
+import asyncio
 import codecs
 import signal
 import time
@@ -104,13 +105,15 @@ class RunApp(App[None]):
 
     def listen(self, controls: Controls) -> None:
         self.controls = controls
-        stop_then_kill(self.action_interrupt, signal.SIGTERM, signal.SIGHUP)
+        stop_then_kill(self.action_interrupt, signal.SIGTERM)
+        asyncio.get_running_loop().add_signal_handler(signal.SIGHUP, self.exit)
 
     def show_event(self, event: dict[str, object]) -> None:
         table = self.query_one(DataTable)
         run = str(event.get("run"))
         match event["event"]:
             case "planned":
+                self.title = str(event["title"])
                 for planned in event["runs"]:  # type: ignore[attr-defined]
                     args = " ".join(param_args(planned["params"]))
                     cells = (planned["run"].rpartition("/")[2], args, PENDING, "")
@@ -242,7 +245,7 @@ class RunApp(App[None]):
         if self.idle:
             self.controls.finish()
         else:
-            self.show("Runs are still going. Ctrl-C stops them.")
+            self.exit()
 
     def cursor_run(self) -> str | None:
         table = self.query_one(DataTable)

{labnotes-0.0.70 → labnotes-0.0.71}/testing-conventions.toml

@@ -31,11 +31,11 @@ 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 = [108]
+lines = [117]
 reason = "start answers 202, 400, 409 or 500, so every status but 202 is above it: != equals >"
 
 [[python.exempt]]
 path = "src/labnotes/daemon/remote_start.py"
 rules = ["mutation"]
-lines = [38]
+lines = [39]
 reason = "the daemon answers a run with 202, 400, 409 or 500, so every status but 202 is above it: != equals >"

labnotes-0.0.70/src/labnotes/runner/start_experiment.py

@@ -1,27 +0,0 @@
-import asyncio
-from collections.abc import Callable
-from functools import partial
-from pathlib import Path
-
-from labnotes.models import LabnotesConfig, Start
-from labnotes.runner.hold_folder import hold_folder
-from labnotes.runner.prepare_experiment import prepare_experiment
-from labnotes.runner.run_experiment import run_experiment
-
-
-def start_experiment(
-    config: LabnotesConfig,
-    name: str,
-    experiment_config: Path | None,
-    concurrency: int | None,
-    drive: Callable[[Start, str], list[dict[str, object]]],
-) -> list[dict[str, object]]:
-    experiment, concurrency, runs = asyncio.run(
-        prepare_experiment(config, name, experiment_config, concurrency)
-    )
-    try:
-        with hold_folder(runs):
-            start = partial(run_experiment, config, name, experiment, concurrency)
-            return drive(start, experiment.name or name)
-    except BlockingIOError as error:
-        raise ValueError(f"{name} is already running ({runs} is held).") from error