labnotes 0.0.136__tar.gz → 0.0.138__tar.gz

{labnotes-0.0.136 → labnotes-0.0.138}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.0.136
+Version: 0.0.138
 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>
@@ -122,13 +122,12 @@ line per event instead.
 - `-e PATH` reads another file instead of `experiment.toml`.
 - `--PARAM=VALUE` runs only the cells where that param has that value, like
   `--model=small`.
-- With runs going, Ctrl-C asks first. Enter (or a second Ctrl-C) leaves them
-  running. `s` stops the running scripts and records their end, then kills any
-  still going 5 seconds later. Escape goes back. SIGTERM stops them like `s`.
-- A second `run` of the same experiment fails with "already running" while the
-  daemon still has the first going.
-- It exits 0 even if runs fail; the summary line counts failures. If it can't
-  start or reach the daemon, it prints the cause on one line and exits 1.
+- With runs going, Ctrl-C asks first. Enter (or a second Ctrl-C) stops the running scripts and records their end,
+  then kills any still going 5 seconds later. Escape goes back. SIGTERM and
+  SIGHUP stop them the same way.
+- The foreground process schedules the next run when a slot frees. Closing
+  its terminal stops the runs. Agents should use a dedicated tmux window.
+- It exits 0 even if runs fail; the summary line counts failures.
 
 `labnotes server` serves a local site at http://127.0.0.1:8000 from the same
 `.labnotes.toml`: a table of experiments, and a page per experiment with its

{labnotes-0.0.136 → labnotes-0.0.138}/README.md

@@ -97,13 +97,12 @@ line per event instead.
 - `-e PATH` reads another file instead of `experiment.toml`.
 - `--PARAM=VALUE` runs only the cells where that param has that value, like
   `--model=small`.
-- With runs going, Ctrl-C asks first. Enter (or a second Ctrl-C) leaves them
-  running. `s` stops the running scripts and records their end, then kills any
-  still going 5 seconds later. Escape goes back. SIGTERM stops them like `s`.
-- A second `run` of the same experiment fails with "already running" while the
-  daemon still has the first going.
-- It exits 0 even if runs fail; the summary line counts failures. If it can't
-  start or reach the daemon, it prints the cause on one line and exits 1.
+- With runs going, Ctrl-C asks first. Enter (or a second Ctrl-C) stops the running scripts and records their end,
+  then kills any still going 5 seconds later. Escape goes back. SIGTERM and
+  SIGHUP stop them the same way.
+- The foreground process schedules the next run when a slot frees. Closing
+  its terminal stops the runs. Agents should use a dedicated tmux window.
+- It exits 0 even if runs fail; the summary line counts failures.
 
 `labnotes server` serves a local site at http://127.0.0.1:8000 from the same
 `.labnotes.toml`: a table of experiments, and a page per experiment with its

{labnotes-0.0.136 → labnotes-0.0.138}/src/labnotes/cli.py

@@ -3,12 +3,10 @@ from pathlib import Path
 import click
 
 from labnotes.context_guide import context_guide
-from labnotes.daemon_command import daemon_command
 from labnotes.experiments import experiments
 from labnotes.init import init
 from labnotes.load_config import load_config
 from labnotes.read_config import CONFIG_FILE
-from labnotes.run_command import run_command
 from labnotes.server import server
 
 
@@ -39,8 +37,6 @@ def context(ctx: click.Context) -> None:
     click.echo(context_guide(load_config(ctx), Path.cwd()), nl=False)
 
 
-main.add_command(daemon_command)
 main.add_command(experiments)
 main.add_command(init)
-main.add_command(run_command)
 main.add_command(server)

{labnotes-0.0.136 → labnotes-0.0.138}/src/labnotes/context.md

@@ -85,7 +85,7 @@ run folder. `command` is the shell command the run executed, with the placeholde
 and the params filled in, written before the run starts, so a killed run has it
 and a later edit to `experiment.toml` doesn't hide what a run did. `ended_by` is `"timeout"`, `"stop"` (labnotes stopped it),
 `"signal"` (a signal labnotes didn't send, like the out-of-memory killer),
-`"lost"` (its process died unseen; the daemon marks these when it starts, with
+`"lost"` (its process died unseen; the next run marks these when it starts, with
 `ended` set and `exit_code` null) or null (the script exited itself). `signal` is the signal number read from the
 exit code (negative, or 128 + N from the shell), else null.
 `git` is `{"commit": "<full HEAD SHA>", "dirty": false}`, read from the command's
@@ -157,10 +157,10 @@ adding a repeat. When the retries run out, the last run keeps exit 75: it never
 got to test its params, so treat it as blocked, not as a result. Stopping the
 runs, or `x` on a run waiting to retry, cancels the retry. A run that was stopped never retries. The live view
 shows a waiting retry as `retry in 30s` and the end as `gave up (exit 75)`;
-`run status --json` reports `retrying`, `retried`, `gave up` and
+The live view reports `retrying`, `retried`, `gave up` and
 `retry cancelled` events.
 
-Runs can take a long time. Start `run` in the background, then check on it with `labnotes experiments foo runs --format json`; a run with no `ended` is still going. Each run lists `size`, the bytes in its run folder, and a running run lists `memory`, the resident bytes of its command and everything it started.
+Runs can take a long time. Start `run` in a dedicated tmux window, then check on it with `labnotes experiments foo runs --format json`; a run with no `ended` is still going. Each run lists `size`, the bytes in its run folder, and a running run lists `memory`, the resident bytes of its command and everything it started.
 
 While a run goes, labnotes appends a memory sample to `memory.jsonl` in its run
 folder every 5 seconds: one JSON line, `{"time": <unix seconds>, "rss": <bytes>,
@@ -202,27 +202,17 @@ going. Elsewhere, it prints a line per event instead.
   `run.json` gets `"error": "timed out after ..."` and `"ended_by": "timeout"`
   next to its exit code.
   Unset, runs have no time limit.
-- `run` hands its runs to the project's labnotes daemon, starting it if
-  needed, and shows or waits for them. The daemon listens on a socket in
-  `/tmp/labnotes-<uid>/` 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. 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.
-- `labnotes run status` prints what the daemon has going, a line per event so
-  far plus the latest line each running run logged and what each running run
-  uses (`usage` events with `--json`). `-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.
-- `labnotes run control NAME ACTION [ARG]` sends one live-view control to a
-  running experiment: `kill` a run, `set_concurrency` to a number,
-  `interrupt` or `finish`.
-- A second `run` of the same experiment fails while the first is going.
+- `run` owns its runs in the foreground. In a terminal it shows a live table;
+  outside a terminal it prints events until every run ends. A free concurrency
+  slot starts the next planned run. Agents should start it in a dedicated tmux
+  window so it can keep running between turns.
+- Ctrl-C, SIGTERM, SIGHUP, or quitting the live view stops running scripts:
+  SIGTERM first, then SIGKILL after 5 seconds if needed. Runs are recorded
+  as stopped before labnotes exits. The next start marks unfinished records
+  whose processes are gone as lost.
+- A second invocation starts its own run session and reads the current config.
 - It exits 0 even if runs fail; the summary line counts failures. A run that
   was retried counts as retried, not failed. If it can't
-  start or reach the daemon, it prints the cause on one line and exits 1.
+  start a run, it prints the cause on one line and exits 1.
 
 `uvx labnotes server` serves the experiments, their markdown files and their runs as a local site, read from the same `.labnotes.toml`. An experiment's page shows its `experiment.toml` on one line, then a Runs tab with a table of its runs and a Notebooks tab with one tab per markdown file. For a matrix experiment, the Runs tab also has a grid (`?view=grid`): one cell per combination of the params that vary, with how many runs count toward `repeats`. Clicking a run opens its `stdout.log` and `stderr.log` together, followed as they're written until the run ends.

{labnotes-0.0.136 → labnotes-0.0.138}/src/labnotes/experiments.py

@@ -5,7 +5,7 @@ from pathlib import Path
 import click
 
 from labnotes.create_experiment import create_experiment
-from labnotes.daemon.remote_start import remote_start
+from labnotes.runner.start_experiment import start_experiment
 from labnotes.utils.format_bytes import format_bytes
 from labnotes.load_config import load_config
 from labnotes.parse_subset import parse_subset
@@ -109,7 +109,7 @@ def experiments(
                 only = parse_subset(ctx.args)
             except ValueError as error:
                 raise click.UsageError(str(error)) from error
-            start = remote_start(
+            start = start_experiment(
                 config,
                 name,
                 experiment_config,

{labnotes-0.0.136 → labnotes-0.0.138}/src/labnotes/load_experiment.py

@@ -8,7 +8,6 @@ from dirsql import DirSQL
 from labnotes.check_counts import check_counts
 from labnotes.count_groups import count_groups
 from labnotes.count_runs import count_runs
-from labnotes.daemon.daemon_running import daemon_running
 from labnotes.experiment_notes import experiment_notes
 from labnotes.experiment_runs import experiment_runs
 from labnotes.format_value import format_value
@@ -24,6 +23,7 @@ from labnotes.runs_view_command import runs_view_command
 from labnotes.sort_href import sort_href
 from labnotes.sql_quote import quote_string
 from labnotes.summarize_config import summarize_config
+from labnotes.utils.process_alive import process_alive
 
 
 def _no_outputs(note: str, content: str) -> Sequence[str]:
@@ -60,6 +60,18 @@ async def load_experiment(
     [totals] = await count_runs(tables, source, str(summary["completed_run"]))
     notes = await experiment_notes(tables, root, name)
     runs = await list_runs(tables, source, str(summary["completed_run"]), view)
+
+    def is_running(row: dict[str, object]) -> bool:
+        record = row.get("run")
+        if not row.get("labnotes_unfinished") or not isinstance(record, str):
+            return False
+        fields = json.loads(record)
+        pid, created = fields.get("pid"), fields.get("pid_created")
+        return isinstance(pid, int) and process_alive(
+            pid, created if isinstance(created, int | float) else None
+        )
+
+    runs_live = any(is_running(run) for run in runs)
     nested = summary["mode"] == "adhoc" and await nests_runs(tables, source)
     groups = (
         group_runs(runs, list(choices), await count_groups(tables, source))
@@ -98,7 +110,7 @@ async def load_experiment(
             for note in notes
         ],
         "runs_list": runs,
-        "runs_live": await daemon_running(root),
+        "runs_live": runs_live,
         "run_groups": groups,
         "run_grid": grid,
         "run_columns": shown,

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

@@ -0,0 +1,37 @@
+from pathlib import Path
+
+from labnotes.models import LabnotesConfig, Listen, Report, Start
+from labnotes.runner.finalize_lost_runs import finalize_lost_runs
+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,
+    timeout: int | None,
+    only: dict[str, str] | None,
+    args: list[str] | None,
+    setup: str | None,
+    teardown: str | None,
+) -> Start:
+    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
+        )
+        await finalize_lost_runs(config)
+        return await run_experiment(
+            config,
+            name,
+            experiment,
+            limit,
+            report,
+            listen,
+            timeout=timeout,
+            only=only,
+            args=args,
+        )
+
+    return start

{labnotes-0.0.136 → labnotes-0.0.138}/src/labnotes/tui/leave_prompt.py

@@ -10,8 +10,7 @@ class LeavePrompt(ModalScreen[str | None]):
     #prompt { width: auto; padding: 1 2; border: round $accent; }
     """
     BINDINGS = [
-        Binding("enter,ctrl+c", "dismiss('leave')", "Leave running"),
-        Binding("s", "dismiss('stop')", "Stop them"),
+        Binding("enter,ctrl+c,s", "dismiss('stop')", "Stop runs"),
         Binding("escape", "dismiss", "Cancel"),
     ]
 
@@ -23,6 +22,6 @@ class LeavePrompt(ModalScreen[str | None]):
         runs = "run" if self.count == 1 else "runs"
         yield Static(
             f"{self.count} {runs} still going. "
-            "Leave them running (enter) / stop them (s) / cancel (esc).",
+            "Stop them (enter or s) / cancel (esc).",
             id="prompt",
         )

{labnotes-0.0.136 → labnotes-0.0.138}/src/labnotes/tui/run_app.py

@@ -1,4 +1,3 @@
-import asyncio
 import signal
 import time
 from collections.abc import Sequence
@@ -100,7 +99,7 @@ class RunApp(App[None]):
     def listen(self, controls: Controls) -> None:
         self.controls = controls
         stop_then_kill(self.stop_runs, signal.SIGTERM)
-        asyncio.get_running_loop().add_signal_handler(signal.SIGHUP, self.exit)
+        stop_then_kill(self.stop_runs, signal.SIGHUP)
 
     def show_event(self, event: dict[str, object]) -> None:
         table = self.query_one(DataTable)
@@ -286,9 +285,7 @@ class RunApp(App[None]):
         self.action_interrupt()
 
     def answer(self, choice: str | None) -> None:
-        if choice == "leave":
-            self.exit()
-        elif choice == "stop":
+        if choice == "stop":
             self.controls.interrupt()
             self.set_timer(GRACE_SECONDS, self.controls.interrupt)
 

{labnotes-0.0.136 → labnotes-0.0.138}/testing-conventions.toml

@@ -1,9 +1,3 @@
-[[python.exempt]]
-path = "src/labnotes/runner/hold_folder.py"
-rules = ["mutation"]
-lines = [12]
-reason = "LOCK_EX and LOCK_NB are disjoint bits, so | equals + and ^"
-
 [[python.exempt]]
 path = "src/labnotes/tui/run_output.py"
 rules = ["mutation"]
@@ -16,30 +10,6 @@ rules = ["mutation"]
 lines = [61, 69]
 reason = "summarize_config returns mode matrix or adhoc; \"matrix\" <= \"adhoc\" is false like ==, and both are interned literals so is equals =="
 
-[[python.exempt]]
-path = "src/labnotes/daemon/exit_when_idle.py"
-rules = ["mutation"]
-lines = [12]
-reason = "quiet counts up by one from zero, so it reaches IDLE_EXIT_SECONDS before passing it: < equals != and, for small ints, is not"
-
-[[python.exempt]]
-path = "src/labnotes/daemon/daemon_app.py"
-rules = ["mutation"]
-lines = [134]
-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 = [51]
-reason = "the daemon answers a run with 202, 400, 409 or 500, so every status but 202 is above it: != equals >"
-
-[[python.exempt]]
-path = "src/labnotes/run_control.py"
-rules = ["mutation"]
-lines = [39]
-reason = "argument counts are small ints, which CPython caches, so is not equals !="
-
 [[python.exempt]]
 path = "src/labnotes/tui/run_cells.py"
 rules = ["mutation"]

{labnotes-0.0.136 → labnotes-0.0.138}/tests/integration/conftest.py

@@ -10,7 +10,6 @@ from pathlib import Path
 import pytest
 from playwright.async_api import Page, async_playwright
 
-from labnotes.daemon.socket_path import socket_path
 
 CONFIG = (
     'name = "Alpha study"\ncommand = "go"\nrepeats = 2\nmode = "matrix"\n'
@@ -45,24 +44,6 @@ def free_port() -> int:
         return int(sock.getsockname()[1])
 
 
-def daemon(root: Path) -> Iterator[None]:
-    labnotes = Path(sys.executable).parent / "labnotes"
-    process = subprocess.Popen(
-        [labnotes, "-c", root / ".labnotes.toml", "daemon"],
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-    )
-    try:
-        for _ in range(100):
-            if socket_path(root).exists():
-                break
-            time.sleep(0.1)
-        yield
-    finally:
-        process.terminate()
-        process.wait()
-
-
 def serve(root: Path) -> Iterator[str]:
     port = free_port()
     labnotes = Path(sys.executable).parent / "labnotes"

{labnotes-0.0.136 → labnotes-0.0.138}/uv.lock

@@ -385,20 +385,20 @@ wheels = [
 
 [[package]]
 name = "httpcore2"
-version = "2.13.1"
+version = "2.16.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "h11" },
     { name = "truststore" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/cb/f3/1db7aa2bc2524062192bb0e0323969492d1883152a232fe36eea65f4e35c/httpcore2-2.13.1.tar.gz", hash = "sha256:e0aa977abe17e69a3b820a24542a6fa88702676d83880b8d194dcd18408e5103", size = 68071, upload-time = "2026-09-23T07:47:22.372Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c0/61/afa9d6b7452f9eca73f73d45324eb0bb52f098fd5e6049bf6b8263be9b4e/httpcore2-2.16.0.tar.gz", hash = "sha256:c72cd0413563b17e1cd8354677dff887466f8ec2551679759e93126534428643", size = 69886, upload-time = "2026-10-21T07:09:45.31Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/09/ba/a4568248771ce81957bfb7cc600264a40fbcda092391ee1c415c50be4bea/httpcore2-2.13.1-py3-none-any.whl", hash = "sha256:e1e05d4f25f7d7d496bfb96748f6f4b67657b03da069b3a68c36069f3db73d0a", size = 83423, upload-time = "2026-09-23T07:47:19.365Z" },
+    { url = "https://files.pythonhosted.org/packages/af/c2/ce417c397afa5181f0e3c6ff01a4d01639414e1adef08730d97571297151/httpcore2-2.16.0-py3-none-any.whl", hash = "sha256:5c4358319f2602d984ad93182c9fee5160f22e9da7babdda870a5e7c4e2dc34f", size = 85070, upload-time = "2026-10-21T07:09:42.802Z" },
 ]
 
 [[package]]
 name = "httpx2"
-version = "2.13.1"
+version = "2.16.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio", marker = "sys_platform != 'emscripten'" },
@@ -408,9 +408,9 @@ dependencies = [
     { name = "truststore", marker = "sys_platform != 'emscripten'" },
     { name = "typing-extensions", marker = "python_full_version < '3.13'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d5/44/474bef2a0e9d90f1715d32cb98b0738695ca17ba324095fb2497ed7fbd59/httpx2-2.13.1.tar.gz", hash = "sha256:e48744a19e3af5ee48313d0ce5fe941d5422fae5705ea922a4aabf94d7800dfa", size = 100405, upload-time = "2026-09-23T07:47:23.052Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/73/5ca2cedf5e4e50423d1c258877865a6b62793633b561c58499f8aeb33b7e/httpx2-2.16.0.tar.gz", hash = "sha256:0d54c98128e8f2ff7fbbde0fca8c359e5f032edeaaaac443cdb7f31f685bcd7f", size = 103116, upload-time = "2026-10-21T07:09:46.348Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/9c/6fe8931fd9f381042a9e4c7d5a7b4cbf7016b252bec0c99a49fce42c3326/httpx2-2.13.1-py3-none-any.whl", hash = "sha256:6dff50fabc270ee5fd25d845d0b078ed20564579744d6d962850975996d2f9a4", size = 95597, upload-time = "2026-09-23T07:47:20.995Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/3d/2e4bc4fd1ef9770871669adb348d612a6e4786b303a23f9935b81c48dd60/httpx2-2.16.0-py3-none-any.whl", hash = "sha256:fd2c5d7909e8d86fe92d53020c310ca0e4e431b838c207c5754b9bbf0308d49a", size = 97880, upload-time = "2026-10-21T07:09:44.01Z" },
 ]
 
 [[package]]

labnotes-0.0.136/src/labnotes/daemon/control_run.py

@@ -1,16 +0,0 @@
-from pathlib import Path
-
-from labnotes.daemon.daemon_client import daemon_client
-from labnotes.daemon.daemon_running import daemon_running
-
-
-async def control_run(
-    root: Path, name: str, action: str, args: list[object]
-) -> str | None:
-    if not await daemon_running(root):
-        return "Nothing is running."
-    async with daemon_client(root) as client:
-        reply = await client.post(f"/experiments/{name}/{action}", json={"args": args})
-    if reply.is_success:
-        return None
-    return str(reply.json()["error"])

labnotes-0.0.136/src/labnotes/daemon/daemon_app.py

@@ -1,179 +0,0 @@
-import asyncio
-import dataclasses
-import itertools
-import json
-from collections.abc import AsyncIterator
-from pathlib import Path
-
-from starlette.applications import Starlette
-from starlette.requests import Request
-from starlette.responses import JSONResponse, Response, StreamingResponse
-from starlette.routing import Route
-
-from labnotes.models import Controls, LabnotesConfig
-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
-
-Event = dict[str, object]
-ACTIONS = frozenset(field.name for field in dataclasses.fields(Controls))
-
-
-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()
-
-    def broadcast(event: Event) -> None:
-        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()
-
-    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:
-                    yield f"data: {json.dumps(event, default=str)}\n\n"
-                    event = await clients[client].get()
-            finally:
-                del clients[client]
-                watchers.discard(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 = await prepare_experiment(
-                config,
-                name,
-                None if path is None else Path(str(path)),
-                body.get("concurrency"),  # type: ignore[arg-type]
-                body.get("only"),  # type: ignore[arg-type]
-                body.get("args"),  # type: ignore[arg-type]
-                body.get("setup"),  # type: ignore[arg-type]
-                body.get("teardown"),  # type: ignore[arg-type]
-            )
-        except ValueError as error:
-            return refuse(400, str(error))
-        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
-            try:
-                await run_experiment(
-                    config,
-                    name,
-                    experiment,
-                    concurrency,
-                    lambda event: record({**event, "experiment": name}),
-                    listen,
-                    body.get("timeout"),  # type: ignore[arg-type]
-                    only=body.get("only"),  # type: ignore[arg-type]
-                    args=body.get("args"),  # type: ignore[arg-type]
-                    environment=body.get("environment"),  # type: ignore[arg-type]
-                )
-            # 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)
-            history.pop(name, None)
-            broadcast({"event": "done", "experiment": name, "error": error})
-            return error
-
-        task = asyncio.create_task(session())
-        tasks.add(task)
-        task.add_done_callback(tasks.discard)
-        waiting = asyncio.create_task(ready.wait())
-        await asyncio.wait({task, waiting}, return_when=asyncio.FIRST_COMPLETED)
-        waiting.cancel()
-        if not ready.is_set():
-            return refuse(500, str(task.result()))
-        return JSONResponse({}, status_code=202)
-
-    async def run(request: Request) -> Response:
-        name = request.path_params["name"]
-        body = await request.json()
-        if name in sessions:
-            return refuse(409, f"{name} is already running.")
-        sessions[name] = None
-        response = await start(name, body)
-        if response.status_code != 202:
-            sessions.pop(name, None)
-        return response
-
-    async def control(request: Request) -> Response:
-        name, action = request.path_params["name"], request.path_params["action"]
-        body = await request.json()
-        controls = sessions.get(name)
-        if action not in ACTIONS or controls is None:
-            return refuse(404, f"No {action} for {name}.")
-        getattr(controls, action)(*body["args"])
-        return JSONResponse({})
-
-    def stop_all() -> None:
-        stopping = [controls for controls in sessions.values() if controls]
-
-        def interrupt() -> None:
-            for controls in stopping:
-                controls.interrupt()
-
-        interrupt()
-        asyncio.get_running_loop().call_later(GRACE_SECONDS, interrupt)
-
-    async def stop(request: Request) -> Response:
-        stop_all()
-        return JSONResponse({})
-
-    app = Starlette(
-        routes=[
-            Route("/events", events),
-            Route("/stop", stop, methods=["POST"]),
-            Route("/experiments/{name}/run", run, methods=["POST"]),
-            Route("/experiments/{name}/{action}", control, methods=["POST"]),
-        ]
-    )
-    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.136/src/labnotes/daemon/daemon_client.py

@@ -1,12 +0,0 @@
-from pathlib import Path
-
-import httpx2
-
-from labnotes.daemon.socket_path import socket_path
-
-
-def daemon_client(root: Path) -> httpx2.AsyncClient:
-    transport = httpx2.AsyncHTTPTransport(uds=str(socket_path(root)))
-    return httpx2.AsyncClient(
-        transport=transport, base_url="http://labnotes", timeout=None
-    )

labnotes-0.0.136/src/labnotes/daemon/daemon_running.py

@@ -1,14 +0,0 @@
-import asyncio
-from pathlib import Path
-
-from labnotes.daemon.socket_path import socket_path
-
-
-async def daemon_running(root: Path) -> bool:
-    try:
-        _, writer = await asyncio.open_unix_connection(socket_path(root))
-    except (FileNotFoundError, ConnectionRefusedError):
-        return False
-    writer.close()
-    await writer.wait_closed()
-    return True

labnotes-0.0.136/src/labnotes/daemon/daemon_server.py

@@ -1,12 +0,0 @@
-from collections.abc import Iterator
-from contextlib import contextmanager
-
-import uvicorn
-
-
-class DaemonServer(uvicorn.Server):
-    # A signal stops the runs through the daemon's own handlers; uvicorn's
-    # would shut the server down under them.
-    @contextmanager
-    def capture_signals(self) -> Iterator[None]:
-        yield