labnotes 0.0.59__tar.gz → 0.0.61__tar.gz

{labnotes-0.0.59 → labnotes-0.0.61}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.0.59
+Version: 0.0.61
 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.59 → labnotes-0.0.61}/src/labnotes/create_app.py

@@ -18,6 +18,7 @@ from starlette.staticfiles import StaticFiles
 from starlette.templating import Jinja2Templates
 
 from labnotes.asset_url import asset_url
+from labnotes.create_note import create_note
 from labnotes.drain_watch import drain_watch
 from labnotes.experiment_notes import experiment_notes
 from labnotes.file_changes import file_changes
@@ -32,6 +33,7 @@ from labnotes.save_note import save_note
 from labnotes.saved_outputs import saved_outputs
 from labnotes.stop_idle_kernels import stop_idle_kernels
 from labnotes.tables.open_tables import open_tables
+from labnotes.wait_for_note import wait_for_note
 
 HERE = Path(__file__).parent
 templates = Jinja2Templates(directory=HERE / "templates")
@@ -97,6 +99,18 @@ def create_app(config: LabnotesConfig, kernel_idle_minutes: float) -> Starlette:
             raise HTTPException(415, "Send JSON")
         return await read_note(request)
 
+    async def post_note(request: Request) -> Response:
+        if request.headers.get("content-type") != "application/json":
+            raise HTTPException(415, "Send JSON")
+        name = request.path_params["name"]
+        filename = create_note(config, name)
+        if filename is None:
+            raise HTTPException(404, "No such experiment")
+        await wait_for_note(request.app.state.tables, config.root, name, filename)
+        page = request.url_for("experiment", name=name)
+        url = page.include_query_params(tab="notebooks", note=filename)
+        return JSONResponse({"url": f"{url.path}?{url.query}#edit"}, status_code=201)
+
     async def get_note(request: Request) -> Response:
         note = await read_note(request)
         return PlainTextResponse(note["content"], media_type="text/markdown")
@@ -140,6 +154,7 @@ def create_app(config: LabnotesConfig, kernel_idle_minutes: float) -> Starlette:
             Route("/", index),
             Route("/experiments/{name}", experiment),
             Route("/experiments/{name}/changes", changes),
+            Route("/experiments/{name}/notes", post_note, methods=["POST"]),
             Route("/experiments/{name}/notes/{note:path}", get_note),
             Route("/experiments/{name}/notes/{note:path}", put_note, methods=["PUT"]),
             Route(

labnotes-0.0.61/src/labnotes/create_note.py

@@ -0,0 +1,23 @@
+from pathlib import Path
+
+from labnotes.models import LabnotesConfig
+from labnotes.tables.file_prefix import file_prefix
+
+
+def create_note(config: LabnotesConfig, experiment: str) -> str | None:
+    def folder(template: str) -> Path:
+        return config.root / template.replace("{experiment}", experiment)
+
+    if experiment.startswith(".") or not folder(config.experiments).is_dir():
+        return None
+    notes = folder(file_prefix(config.files))
+    notes.mkdir(parents=True, exist_ok=True)
+    filename, n = "Untitled.md", 1
+    while True:
+        try:
+            with (notes / filename).open("x", encoding="utf-8") as note:
+                note.write("# Untitled\n")
+            return filename
+        except FileExistsError:
+            n += 1
+            filename = f"Untitled {n}.md"

labnotes-0.0.61/src/labnotes/runner/new_param_run_id.py

@@ -0,0 +1,18 @@
+import secrets
+from collections.abc import Callable
+
+from labnotes.runner.new_run_id import new_run_id
+from labnotes.runner.param_run_name import param_run_name
+
+
+def new_param_run_id(
+    params: dict[str, object],
+    choices: dict[str, list[object]],
+    taken: Callable[[str], bool],
+) -> str:
+    name = param_run_name(params, choices)
+    if not name:
+        return new_run_id(taken)
+    while taken(candidate := f"{name}-{secrets.token_hex(2)}"):
+        pass
+    return candidate

labnotes-0.0.61/src/labnotes/runner/param_run_name.py

@@ -0,0 +1,17 @@
+import os
+import re
+
+UNSAFE = re.compile(r"[^A-Za-z0-9]+")
+LIMIT = 60
+
+
+def param_run_name(params: dict[str, object], choices: dict[str, list[object]]) -> str:
+    parts = []
+    for name, values in choices.items():
+        if len(values) < 2:
+            continue
+        shared = os.path.commonprefix([str(value) for value in values])
+        cut = re.match(r".*[^A-Za-z0-9]", shared)
+        value = str(params[name])[cut.end() if cut else 0 :]
+        parts.append(UNSAFE.sub("-", value).strip("-"))
+    return "-".join(part for part in parts if part)[:LIMIT].strip("-")

{labnotes-0.0.59 → labnotes-0.0.61}/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_run_id import new_run_id
+from labnotes.runner.new_param_run_id import new_param_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
@@ -46,16 +46,18 @@ async def run_experiment(
 
     group = new_stamped_run_id(taken) if experiment.mode == "adhoc" else None
 
-    def new_id() -> str:
+    def new_id(params: dict[str, object]) -> str:
         if group is None:
             return new_stamped_run_id(taken)
-        return f"{group}/" + new_run_id(lambda run: taken(f"{group}/{run}"))
+        return f"{group}/" + new_param_run_id(
+            params, experiment.params, lambda run: taken(f"{group}/{run}")
+        )
 
     plan: list[Entry] = []
     for params in plan_runs(
         param_grid(experiment.params), experiment.repeats, finished
     ):
-        run = new_id()
+        run = new_id(params)
         planned.add(run)
         plan.append((run, params))
     runs = [{"run": run, "params": params} for run, params in plan]
@@ -137,7 +139,7 @@ async def run_experiment(
     def retry(run: str) -> None:
         if stopping.is_set() or run not in ended:
             return
-        again = new_id()
+        again = new_id(ended[run])
         planned.add(again)
         plan.append((again, ended[run]))
         report({"event": "retried", "run": run, "retry": again, "params": ended[run]})

{labnotes-0.0.59 → labnotes-0.0.61}/src/labnotes/static/labnotes.css

@@ -243,6 +243,8 @@ h3 {
 .tabs a[aria-current="page"] { color: var(--ink); border-bottom-color: var(--accent); }
 .tabs .count { font-size: 0.8rem; color: var(--ink-3); margin-left: 0.3rem; }
 .tabs.sub { gap: 1.2rem; margin-top: -0.4rem; font-family: var(--mono); font-size: 0.8rem; }
+.new-note { font: inherit; color: var(--ink-2); background: none; border: 0; padding: 0 0.2rem; cursor: pointer; }
+.new-note:hover { color: var(--ink); }
 
 /* Runs table */
 .narrowed { color: var(--ink-2); font-size: 0.88rem; margin: 0 0 0.75rem; }

labnotes-0.0.61/src/labnotes/static/new-note.js

@@ -0,0 +1,12 @@
+for (const button of document.querySelectorAll(".new-note")) {
+  button.addEventListener("click", async () => {
+    button.disabled = true;
+    const response = await fetch(button.dataset.url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: "{}",
+    });
+    if (response.ok) location.assign((await response.json()).url);
+    else button.disabled = false;
+  });
+}

{labnotes-0.0.59 → labnotes-0.0.61}/src/labnotes/static/note-edit.js

@@ -23,6 +23,10 @@ if (note) {
     editing = edit(note, prose, status);
   };
   prose.addEventListener("click", open);
+  if (location.hash === "#edit") {
+    history.replaceState(null, "", location.pathname + location.search);
+    open({ target: prose });
+  }
 
   new EventSource(note.dataset.changesUrl).addEventListener("message", (event) => {
     if (JSON.parse(event.data) !== note.dataset.note) return;

{labnotes-0.0.59 → labnotes-0.0.61}/src/labnotes/templates/experiment.html

@@ -35,7 +35,7 @@
 {% set note = (e.notes | selectattr('name', 'equalto', chosen) | first) or (e.notes | first) %}
 {% if note %}
 <nav class="tabs sub">
-  {% for each in e.notes %}<a href="?tab=notebooks&amp;note={{ each.name | urlencode }}"{% if each.name == note.name %} aria-current="page"{% endif %}>{{ each.name }}</a>{% endfor %}
+  {% for each in e.notes %}<a href="?tab=notebooks&amp;note={{ each.name | urlencode }}"{% if each.name == note.name %} aria-current="page"{% endif %}>{{ each.name }}</a>{% endfor %}<button type="button" class="new-note" data-url="{{ url_for('post_note', name=e.name) }}" aria-label="New note" title="New note">+</button>
 </nav>
 <article class="note" data-run-url="{{ url_for('run_block', name=e.name, note=note.name) }}" data-restart-url="{{ url_for('restart_kernel', name=e.name, note=note.name) }}" data-save-url="{{ url_for('put_note', name=e.name, note=note.name) }}" data-editor="{{ asset('note-editor.js') }}" data-changes-url="{{ url_for('changes', name=e.name) }}" data-note="{{ note.name }}">
   {% if note.runnable %}<header class="note-name"><button type="button" class="restart" title="Stop this note's Python kernel. The next Run starts a fresh one.">Restart</button></header>{% endif %}
@@ -47,8 +47,9 @@
 <script src="{{ asset('run-cell.js') }}" defer></script>
 <script type="module" src="{{ asset('note-edit.js') }}"></script>
 {% else %}
-<p class="empty">No notebooks yet.</p>
+<p class="empty">No notebooks yet. <button type="button" class="new-note" data-url="{{ url_for('post_note', name=e.name) }}" aria-label="New note" title="New note">+</button></p>
 {% endif %}
+<script src="{{ asset('new-note.js') }}" defer></script>
 {% else %}
 <section id="runs">
   {% set view = e.run_view %}

labnotes-0.0.61/src/labnotes/wait_for_note.py

@@ -0,0 +1,13 @@
+import asyncio
+from pathlib import Path
+
+from dirsql import DirSQL
+
+from labnotes.experiment_notes import experiment_notes
+
+
+async def wait_for_note(tables: DirSQL, root: Path, experiment: str, note: str) -> None:
+    for _ in range(40):
+        if await experiment_notes(tables, root, experiment, note):
+            return
+        await asyncio.sleep(0.05)