labnotes 0.0.47__tar.gz → 0.0.48__tar.gz

{labnotes-0.0.47 → labnotes-0.0.48}/PKG-INFO

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

@@ -62,14 +62,16 @@ Each combination of `[params]` runs `repeats` times (1 if omitted), round-robin,
 so running again fills in what failed or never ran. `mode` under
 `[experiments]` in `.labnotes.toml` sets it for every experiment that doesn't
 set its own.
-Each run gets a new run folder, named for the UTC time it was planned (`20261020-000429-brave-fox`), so folder listings sort by start. `command` runs in a shell from the root, with
+Each run gets a new run folder. In `fill` mode it is named for the UTC time it was planned
+(`runs/20261020-000429-brave-fox`). In `adhoc` mode each `run` command gets one folder named
+that way, and its runs nest inside it (`runs/20261020-000429-brave-fox/quiet-river`); the run id
+is that path under `runs/`. Either way, folder listings sort by start. `command` runs in a shell from the root, with
 `{run_dir}` replaced by the run folder's absolute path. Pass it to the
 script so it writes its outputs there.
 Each param is appended as `--name value`, with the name as written (use
 `source-language` for a `--source-language` flag), booleans as 0 or 1, and lists
 and tables as JSON. labnotes writes `run.json` (params, created, ended, exit
-code, and `invocation_id`, shared by every run one `run` command started;
-query it as `run ->> 'invocation_id'`), `stdout.log` and `stderr.log` to the
+code), `stdout.log` and `stderr.log` to the
 run folder.
 A run counts when it exited 0 and its `run.json` doesn't hold
 `"excluded": true`, so excluding a run by hand means adding that key; the next

{labnotes-0.0.47 → labnotes-0.0.48}/src/labnotes/runner/execute_run.py

@@ -15,11 +15,9 @@ async def execute_run(
     params: dict[str, object],
     running: set[asyncio.subprocess.Process],
     stopping: asyncio.Event,
-    invocation: str,
 ) -> dict[str, object]:
     run: dict[str, object] = {
         "params": params,
-        "invocation_id": invocation,
         "created": iso_time(time.time()),
         "ended": None,
         "exit_code": None,

{labnotes-0.0.47 → labnotes-0.0.48}/src/labnotes/runner/run_experiment.py

@@ -12,7 +12,7 @@ from labnotes.models import (
     Report,
 )
 from labnotes.runner.execute_run import execute_run
-from labnotes.runner.new_invocation_id import new_invocation_id
+from labnotes.runner.new_run_id import new_run_id
 from labnotes.runner.new_stamped_run_id import new_stamped_run_id
 from labnotes.runner.param_grid import param_grid
 from labnotes.runner.plan_runs import plan_runs
@@ -44,12 +44,18 @@ async def run_experiment(
             run in planned or run_folder(config.root, config.runs, name, run).exists()
         )
 
-    invocation = new_invocation_id()
+    group = new_stamped_run_id(taken) if experiment.mode == "adhoc" else None
+
+    def new_id() -> str:
+        if group is None:
+            return new_stamped_run_id(taken)
+        return f"{group}/" + new_run_id(lambda run: taken(f"{group}/{run}"))
+
     plan: list[Entry] = []
     for params in plan_runs(
         param_grid(experiment.params), experiment.repeats, finished
     ):
-        run = new_stamped_run_id(taken)
+        run = new_id()
         planned.add(run)
         plan.append((run, params))
     runs = [{"run": run, "params": params} for run, params in plan]
@@ -131,7 +137,7 @@ async def run_experiment(
     def retry(run: str) -> None:
         if stopping.is_set() or run not in ended:
             return
-        again = new_stamped_run_id(taken)
+        again = new_id()
         planned.add(again)
         plan.append((again, ended[run]))
         report({"event": "retried", "run": run, "retry": again, "params": ended[run]})
@@ -182,7 +188,6 @@ async def run_experiment(
             params,
             running[run],
             stopping,
-            invocation,
         )
         del running[run]
         report({"event": "ended", "run": run, **result})

{labnotes-0.0.47 → labnotes-0.0.48}/src/labnotes/tables/path_glob.py

@@ -4,5 +4,5 @@ PLACEHOLDER = re.compile(r"\{[^}]*\}")
 
 
 def path_glob(template: str) -> str:
-    glob = PLACEHOLDER.sub("*", template)
+    glob = PLACEHOLDER.sub("*", template.replace("{run}", "**"))
     return f"{glob}**" if glob.endswith("/") else glob

{labnotes-0.0.47 → labnotes-0.0.48}/src/labnotes/tables/path_pattern.py

@@ -6,6 +6,9 @@ TOKEN = re.compile(r"\{([^}]*)\}|\*\*|\*|\?|[^{*?]+")
 def path_pattern(template: str) -> re.Pattern[str]:
     parts = []
     for found in TOKEN.finditer(template):
+        if found.group(1) == "run":
+            parts.append("(?P<run>[^/]+(?:/[^/]+)?)")
+            continue
         if found.group(1) is not None:
             parts.append(f"(?P<{found.group(1)}>[^/]+)")
             continue

{labnotes-0.0.47 → labnotes-0.0.48}/src/labnotes/tui/run_app.py

@@ -110,7 +110,7 @@ class RunApp(App[None]):
             case "planned":
                 for planned in event["runs"]:  # type: ignore[attr-defined]
                     args = " ".join(param_args(planned["params"]))
-                    cells = (planned["run"], args, PENDING, "")
+                    cells = (planned["run"].rpartition("/")[2], args, PENDING, "")
                     self.cells[planned["run"]] = [*map(dim, cells)]
                     self.pending.add(planned["run"])
                 self.redraw(table.cursor_row)
@@ -161,7 +161,9 @@ class RunApp(App[None]):
             case "retried":
                 again = str(event["retry"])
                 args = " ".join(param_args(event["params"]))  # type: ignore[arg-type]
-                self.cells[again] = [*map(dim, (again, args, PENDING, ""))]
+                self.cells[again] = [
+                    *map(dim, (again.rpartition("/")[2], args, PENDING, ""))
+                ]
                 self.pending.add(again)
                 self.redraw(table.cursor_row)
                 self.show(describe_event(event))

{labnotes-0.0.47 → labnotes-0.0.48}/testing-conventions.toml

@@ -7,5 +7,11 @@ reason = "LOCK_EX and LOCK_NB are disjoint bits, so | equals + and ^"
 [[python.exempt]]
 path = "src/labnotes/tui/run_app.py"
 rules = ["mutation"]
-lines = [309]
+lines = [311]
 reason = "last_stream is always the same str object taken from STREAMS, so is not equals !="
+
+[[python.exempt]]
+path = "src/labnotes/runner/run_experiment.py"
+rules = ["mutation"]
+lines = [47]
+reason = "mode is validated to fill or adhoc; \"fill\" <= \"adhoc\" is false like ==, and both are interned literals so is equals =="

labnotes-0.0.48/tests/integration/conftest.py

@@ -0,0 +1,83 @@
+import asyncio
+import json
+import socket
+import subprocess
+import sys
+import time
+from collections.abc import Awaitable, Callable, Iterator
+from pathlib import Path
+
+import pytest
+from playwright.async_api import Page, async_playwright
+
+CONFIG = (
+    'name = "Alpha study"\ncommand = "go"\nrepeats = 2\nmode = "fill"\n'
+    '[params]\nsource-language = ["en", "fr"]\n'
+)
+
+
+def write(path: Path, text: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(text, encoding="utf-8")
+
+
+def run(project: Path, name: str, params: dict[str, object], **fields: object) -> None:
+    record = {"params": params, "created": f"2026-10-17T00:00:0{name[-1]}Z", **fields}
+    write(project / f"alpha/runs/{name}/run.json", json.dumps(record))
+
+
+def project(root: Path) -> Path:
+    write(root / "beta/files/notes.md", "beta notes")
+    write(root / ".labnotes.toml", "")
+    write(root / "alpha/experiment.toml", CONFIG)
+    write(root / "alpha/files/plan.md", "# The plan\n\n```python\n1 + 1\n```\n")
+    write(root / "alpha/files/results.md", "# Results\n\nAll good.\n")
+    run(root, "run1", {"source-language": "en"}, exit_code=0)
+    run(root, "run2", {"source-language": "fr"}, exit_code=1, stdout="boom")
+    return root
+
+
+def free_port() -> int:
+    with socket.socket() as sock:
+        sock.bind(("127.0.0.1", 0))
+        return int(sock.getsockname()[1])
+
+
+def serve(root: Path) -> Iterator[str]:
+    port = free_port()
+    labnotes = Path(sys.executable).parent / "labnotes"
+    process = subprocess.Popen(
+        [labnotes, "-c", root / ".labnotes.toml", "server", "-p", str(port)],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+    try:
+        for _ in range(100):
+            try:
+                socket.create_connection(("127.0.0.1", port)).close()
+                break
+            except OSError:
+                time.sleep(0.1)
+        yield f"http://127.0.0.1:{port}"
+    finally:
+        process.terminate()
+        process.wait()
+
+
+def browse(
+    url: str, check: Callable[[Page], Awaitable[None]], width: int = 1280
+) -> 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})
+            await page.goto(url)
+            await check(page)
+            await browser.close()
+
+    asyncio.run(drive())
+
+
+@pytest.fixture
+def site(tmp_path: Path) -> Iterator[str]:
+    yield from serve(project(tmp_path))

labnotes-0.0.47/src/labnotes/runner/new_invocation_id.py

@@ -1,6 +0,0 @@
-import hashlib
-import time
-
-
-def new_invocation_id() -> str:
-    return hashlib.sha256(str(time.time_ns()).encode()).hexdigest()[:8]