labnotes 0.0.54__tar.gz → 0.0.56__tar.gz

{labnotes-0.0.54 → labnotes-0.0.56}/PKG-INFO

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

@@ -6,7 +6,13 @@ from pathlib import Path
 from starlette.applications import Starlette
 from starlette.exceptions import HTTPException
 from starlette.requests import Request
-from starlette.responses import HTMLResponse, JSONResponse, Response
+from starlette.responses import (
+    HTMLResponse,
+    JSONResponse,
+    PlainTextResponse,
+    Response,
+    StreamingResponse,
+)
 from starlette.routing import Mount, Route
 from starlette.staticfiles import StaticFiles
 from starlette.templating import Jinja2Templates
@@ -14,6 +20,7 @@ from starlette.templating import Jinja2Templates
 from labnotes.asset_url import asset_url
 from labnotes.drain_watch import drain_watch
 from labnotes.experiment_notes import experiment_notes
+from labnotes.file_changes import file_changes
 from labnotes.format_duration import format_duration
 from labnotes.format_value import format_value
 from labnotes.list_experiments import list_experiments
@@ -74,9 +81,7 @@ def create_app(config: LabnotesConfig, kernel_idle_minutes: float) -> Starlette:
             request, "experiment.html", {"experiment": loaded}
         )
 
-    async def find_note(request: Request) -> dict[str, str]:
-        if request.headers.get("content-type") != "application/json":
-            raise HTTPException(415, "Send JSON")
+    async def read_note(request: Request) -> dict[str, str]:
         name = request.path_params["name"]
         note = request.path_params["note"]
         found = await experiment_notes(
@@ -87,6 +92,21 @@ def create_app(config: LabnotesConfig, kernel_idle_minutes: float) -> Starlette:
         [note] = found
         return note
 
+    async def find_note(request: Request) -> dict[str, str]:
+        if request.headers.get("content-type") != "application/json":
+            raise HTTPException(415, "Send JSON")
+        return await read_note(request)
+
+    async def get_note(request: Request) -> Response:
+        note = await read_note(request)
+        return PlainTextResponse(note["content"], media_type="text/markdown")
+
+    async def changes(request: Request) -> Response:
+        return StreamingResponse(
+            file_changes(request.app.state.tables, request.path_params["name"]),
+            media_type="text/event-stream",
+        )
+
     async def put_note(request: Request) -> Response:
         note = await find_note(request)
         body = await request.json()
@@ -119,6 +139,8 @@ def create_app(config: LabnotesConfig, kernel_idle_minutes: float) -> Starlette:
         routes=[
             Route("/", index),
             Route("/experiments/{name}", experiment),
+            Route("/experiments/{name}/changes", changes),
+            Route("/experiments/{name}/notes/{note:path}", get_note),
             Route("/experiments/{name}/notes/{note:path}", put_note, methods=["PUT"]),
             Route(
                 "/experiments/{name}/notes/{note:path}/run",

labnotes-0.0.56/src/labnotes/file_changes.py

@@ -0,0 +1,11 @@
+import json
+from collections.abc import AsyncIterator
+
+from dirsql import DirSQL
+
+
+async def file_changes(tables: DirSQL, experiment: str) -> AsyncIterator[str]:
+    async for event in tables.watch():
+        row = event.row or event.old_row
+        if event.table == "files" and row and row["experiment"] == experiment:
+            yield f"data: {json.dumps(row['filename'])}\n\n"

{labnotes-0.0.54 → labnotes-0.0.56}/src/labnotes/list_runs.py

@@ -16,6 +16,11 @@ async def list_runs(
         f" lower({quote_string(value)})) > 0"
         for column, value in view.filters.items()
     ]
+    where += [
+        f"params -> {quote_string(f'$.{quote_identifier(column)}')}"
+        f" IN ({', '.join(quote_string(value) for value in picked.values())})"
+        for column, picked in view.picked.items()
+    ]
     filtered = f" WHERE {' AND '.join(where)}" if where else ""
     direction = "DESC" if view.descending else "ASC"
     if view.sort == "status":

{labnotes-0.0.54 → labnotes-0.0.56}/src/labnotes/load_experiment.py

@@ -1,5 +1,5 @@
 import json
-from collections.abc import Callable, Mapping, Sequence
+from collections.abc import Callable, Sequence
 from pathlib import Path
 from typing import cast
 
@@ -9,7 +9,9 @@ from labnotes.check_counts import check_counts
 from labnotes.count_runs import count_runs
 from labnotes.experiment_notes import experiment_notes
 from labnotes.experiment_runs import experiment_runs
+from labnotes.format_value import format_value
 from labnotes.list_runs import list_runs
+from labnotes.models import QueryParams
 from labnotes.parse_run_view import parse_run_view
 from labnotes.python_blocks import python_blocks
 from labnotes.render_markdown import render_markdown
@@ -27,7 +29,7 @@ async def load_experiment(
     root: Path,
     mode: str,
     name: str,
-    params: Mapping[str, str],
+    params: QueryParams,
     outputs_for: Callable[[str, str], Sequence[str]] = _no_outputs,
 ) -> dict[str, object] | None:
     found = await tables.query(
@@ -43,7 +45,12 @@ async def load_experiment(
     source = experiment_runs(name, list(varies))
     summary = await check_counts(tables, source, summary)
     shown = ["id", *(key for key in varies if key != "id"), "started", "duration"]
-    view = parse_run_view(params, shown)
+    choices = {
+        key: {format_value(value): json.dumps(value) for value in values}
+        for key, values in varies.items()
+        if key != "id"
+    }
+    view = parse_run_view(params, shown, choices)
     [totals] = await count_runs(tables, source, str(summary["completed_run"]))
     notes = await experiment_notes(tables, root, name)
     return {
@@ -69,6 +76,7 @@ async def load_experiment(
         ),
         "run_columns": shown,
         "run_view": view,
+        "run_choices": choices,
         "sort_hrefs": {
             column: sort_href(view, column) for column in ["status", *shown]
         },

{labnotes-0.0.54 → labnotes-0.0.56}/src/labnotes/models.py

@@ -1,7 +1,7 @@
 from collections.abc import Callable, Coroutine
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any
+from typing import Any, Protocol
 
 from labnotes.default_counts import DEFAULT_COUNTS
 from labnotes.modes import DEFAULT_MODE
@@ -24,12 +24,17 @@ Listen = Callable[[Controls], None]
 Start = Callable[[Report, Listen], Coroutine[Any, Any, list[dict[str, object]]]]
 
 
+class QueryParams(Protocol):
+    def getlist(self, key: str) -> list[str]: ...
+
+
 @dataclass(frozen=True)
 class RunView:
     sort: str | None = None
     descending: bool = False
     status: str | None = None
     filters: dict[str, str] = field(default_factory=dict)
+    picked: dict[str, dict[str, str]] = field(default_factory=dict)
 
 
 @dataclass(frozen=True)

labnotes-0.0.56/src/labnotes/parse_run_view.py

@@ -0,0 +1,39 @@
+from collections.abc import Mapping
+
+from labnotes.models import QueryParams, RunView
+
+STATUSES = {"complete", "incomplete"}
+
+
+def parse_run_view(
+    params: QueryParams,
+    columns: list[str],
+    choices: Mapping[str, Mapping[str, str]],
+) -> RunView:
+    def last(key: str) -> str | None:
+        values = params.getlist(key)
+        return values[-1] if values else None
+
+    sort = last("sort")
+    status = last("status")
+    return RunView(
+        sort=sort if sort in columns or sort == "status" else None,
+        descending=last("order") == "desc",
+        status=status if status in STATUSES else None,
+        filters={
+            column: value
+            for column in columns
+            if column not in choices and (value := (last(f"f.{column}") or "").strip())
+        },
+        picked={
+            column: picked
+            for column, values in choices.items()
+            if (
+                picked := {
+                    label: values[label]
+                    for label in params.getlist(f"f.{column}")
+                    if label in values
+                }
+            )
+        },
+    )

labnotes-0.0.56/src/labnotes/sort_href.py

@@ -0,0 +1,16 @@
+from urllib.parse import urlencode
+
+from labnotes.models import RunView
+
+
+def sort_href(view: RunView, column: str) -> str:
+    params = [("sort", column)]
+    if view.sort == column and not view.descending:
+        params.append(("order", "desc"))
+    if view.status:
+        params.append(("status", view.status))
+    params += [(f"f.{name}", value) for name, value in view.filters.items()]
+    params += [
+        (f"f.{name}", label) for name, picked in view.picked.items() for label in picked
+    ]
+    return f"?{urlencode(params)}#runs"

{labnotes-0.0.54 → labnotes-0.0.56}/src/labnotes/static/experiment.js

@@ -46,6 +46,10 @@ if (filters) {
     for (const part of ["thead tr:first-child", "tbody"]) {
       runs.querySelector(part).replaceWith(fresh.querySelector(part));
     }
+    const summaries = fresh.querySelectorAll(".pick summary");
+    runs.querySelectorAll(".pick summary").forEach((summary, index) => {
+      summary.textContent = summaries[index].textContent;
+    });
     history.replaceState(null, "", url);
   };
 
@@ -58,4 +62,12 @@ if (filters) {
     clearTimeout(pending);
     pending = setTimeout(refresh, 250);
   });
+  document.addEventListener("change", (event) => {
+    if (event.target.form === filters && event.target.type === "checkbox") refresh();
+  });
+  document.addEventListener("click", (event) => {
+    for (const pick of runs.querySelectorAll(".pick[open]")) {
+      if (!pick.contains(event.target)) pick.open = false;
+    }
+  });
 }

{labnotes-0.0.54 → labnotes-0.0.56}/src/labnotes/static/labnotes.css

@@ -276,6 +276,39 @@ h3 {
   border-radius: 5px;
 }
 .runs-table .filters select { padding: 0.1rem 0; }
+.runs-table .pick { position: relative; }
+.runs-table .pick summary {
+  list-style: none;
+  cursor: pointer;
+  font-size: 0.82rem;
+  padding: 0.1rem 0.4rem;
+  color: var(--ink);
+  background: var(--surface);
+  border: 1px solid var(--rule);
+  border-radius: 5px;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.runs-table .pick summary::-webkit-details-marker { display: none; }
+.runs-table .pick[open] summary, .runs-table .pick summary:focus-visible { outline: none; border-color: var(--accent); }
+.runs-table .pick .options {
+  position: absolute;
+  z-index: 1;
+  top: calc(100% + 0.25rem);
+  left: 0;
+  min-width: 100%;
+  max-height: 16rem;
+  overflow: auto;
+  padding: 0.3rem 0;
+  background: var(--surface);
+  border: 1px solid var(--rule);
+  border-radius: 5px;
+  box-shadow: 0 4px 12px rgb(0 0 0 / 0.08);
+}
+.runs-table .pick label { display: flex; gap: 0.45rem; align-items: center; padding: 0.2rem 0.6rem; font-size: 0.82rem; white-space: nowrap; cursor: pointer; }
+.runs-table .pick label:hover { background: var(--paper); }
+.runs-table .filters .pick input { width: auto; }
 .runs-table .filters input:focus, .runs-table .filters select:focus { outline: none; border-color: var(--accent); }
 .runs-table tbody tr:last-child td { border-bottom: 0; }
 .run-row { cursor: pointer; }

{labnotes-0.0.54 → labnotes-0.0.56}/src/labnotes/static/note-edit.js

@@ -4,6 +4,8 @@ if (note) {
   const prose = note.querySelector(".prose");
   const status = note.querySelector(".edit-status");
   const editor = import(note.dataset.editor);
+  let editing = null;
+
   editor.then(
     () => prose.classList.add("editable"),
     () => {
@@ -15,9 +17,15 @@ if (note) {
   const open = async (event) => {
     if (event.target.closest("a, button, output") || getSelection().toString()) return;
     const { edit } = await editor;
-    if (!prose.isConnected) return;
+    if (editing) return;
     prose.removeEventListener("click", open);
-    edit(note, prose, status);
+    editing = edit(note, prose, status);
   };
   prose.addEventListener("click", open);
+
+  new EventSource(note.dataset.changesUrl).addEventListener("message", (event) => {
+    if (JSON.parse(event.data) !== note.dataset.note) return;
+    if (editing) editing.pull();
+    else location.reload();
+  });
 }

{labnotes-0.0.54 → labnotes-0.0.56}/src/labnotes/static/note-editor.js

@@ -12,6 +12,7 @@ import { EditorState, RangeSetBuilder } from "@codemirror/state";
 import { Decoration, EditorView, ViewPlugin, keymap } from "@codemirror/view";
 import { tags } from "@lezer/highlight";
 import { GFM, parseCode, parser } from "@lezer/markdown";
+import { DIFF_DELETE, DIFF_EQUAL, diff_match_patch } from "diff-match-patch";
 
 // Built from @lezer/markdown rather than @codemirror/lang-markdown, which
 // imports HTML, CSS and JavaScript support that notes never use.
@@ -102,9 +103,27 @@ function show(status, message) {
   status.hidden = false;
 }
 
+const dmp = new diff_match_patch();
+
+// Three-way: what changed on disk since base, applied onto the editor's text.
+const merge = (base, ours, theirs) => dmp.patch_apply(dmp.patch_make(base, theirs), ours)[0];
+
+// Minimal changes, so the cursor and undo history survive.
+function setText(view, text) {
+  const changes = [];
+  let at = 0;
+  for (const [op, chunk] of dmp.diff_main(view.state.doc.toString(), text)) {
+    if (op === DIFF_EQUAL) at += chunk.length;
+    else if (op === DIFF_DELETE) {
+      changes.push({ from: at, to: at + chunk.length });
+      at += chunk.length;
+    } else changes.push({ from: at, insert: chunk });
+  }
+  if (changes.length) view.dispatch({ changes });
+}
+
 export function edit(note, prose, status) {
   let base = JSON.parse(note.querySelector(".note-source").textContent);
-  let stale = false;
   let timer;
   let queue = Promise.resolve();
 
@@ -112,31 +131,46 @@ export function edit(note, prose, status) {
   host.className = "editor";
   prose.replaceWith(host);
 
-  const save = () =>
-    (queue = queue
-      .then(async () => {
-        clearTimeout(timer);
-        const content = view.state.doc.toString();
-        if (stale || content === base) return;
-        const response = await fetch(note.dataset.saveUrl, {
-          method: "PUT",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ base, content }),
-        });
-        if (response.status === 409) {
-          stale = true;
-          show(status, "This note changed on disk, so your edits are not saved. Copy them, then reload.");
-        } else if (response.ok) {
-          base = content;
-        } else {
-          show(status, `Not saved: ${response.status} ${response.statusText}`);
-        }
-      })
-      .catch((error) => show(status, `Not saved: ${error.message}`)));
+  const run = (task) =>
+    (queue = queue.then(task).catch((error) => show(status, `Not saved: ${error.message}`)));
+
+  const absorb = (theirs) => {
+    setText(view, merge(base, view.state.doc.toString(), theirs));
+    base = theirs;
+  };
+
+  const push = async () => {
+    clearTimeout(timer);
+    for (;;) {
+      const content = view.state.doc.toString();
+      if (content === base) return;
+      const response = await fetch(note.dataset.saveUrl, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ base, content }),
+      });
+      if (response.status !== 409) {
+        if (response.ok) base = content;
+        else show(status, `Not saved: ${response.status} ${response.statusText}`);
+        return;
+      }
+      absorb((await response.json()).content);
+    }
+  };
+
+  const pull = async () => {
+    const response = await fetch(note.dataset.saveUrl, { cache: "no-store" });
+    if (!response.ok) return show(status, `Not synced: ${response.status} ${response.statusText}`);
+    const theirs = await response.text();
+    if (theirs === base) return;
+    absorb(theirs);
+    await push();
+  };
+
+  const save = () => run(push);
 
   const close = async () => {
     await save();
-    if (stale) return;
     document.removeEventListener("mousedown", outside);
     location.reload();
   };
@@ -166,4 +200,5 @@ export function edit(note, prose, status) {
     }),
   });
   view.focus();
+  return { pull: () => run(pull) };
 }

{labnotes-0.0.54 → labnotes-0.0.56}/src/labnotes/templates/editor_imports.html

@@ -16,6 +16,7 @@
     "@lezer/python": "https://esm.sh/*@lezer/python@1.1.19",
     "@marijn/find-cluster-break": "https://esm.sh/*@marijn/find-cluster-break@1.0.4",
     "crelt": "https://esm.sh/*crelt@1.0.7",
+    "diff-match-patch": "https://esm.sh/*diff-match-patch@1.0.5",
     "style-mod": "https://esm.sh/*style-mod@4.1.4",
     "w3c-keyname": "https://esm.sh/*w3c-keyname@2.2.8"
   }

{labnotes-0.0.54 → labnotes-0.0.56}/src/labnotes/templates/experiment.html

@@ -37,7 +37,7 @@
 <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 %}
 </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') }}">
+<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 %}
   <p class="edit-status" role="status" hidden></p>
   <div class="prose">{{ note.html | safe }}</div>
@@ -52,7 +52,7 @@
 {% else %}
 <section id="runs">
   {% set view = e.run_view %}
-  {% set narrowed = view.status or view.filters %}
+  {% set narrowed = view.status or view.filters or view.picked %}
   {% if narrowed %}<p class="narrowed"><span class="num">{{ e.runs_list | length }}</span> of <span class="num">{{ e.runs }}</span> <a class="clear" href="{{ '?sort=' ~ (view.sort | urlencode) ~ ('&order=desc' if view.descending else '') if view.sort else '?' }}#runs">Clear filters</a></p>{% endif %}
   {% if e.runs %}
   <form id="run-filters" method="get" action="#runs">
@@ -75,7 +75,10 @@
           <option value="complete"{{ ' selected' if view.status == 'complete' }}>✓</option>
           <option value="incomplete"{{ ' selected' if view.status == 'incomplete' }}>✕</option>
         </select></td>
-        {% for column in e.run_columns %}<td><input form="run-filters" type="search" name="f.{{ column }}" value="{{ view.filters.get(column, '') }}" placeholder="filter" aria-label="Filter {{ column }}"></td>{% endfor %}
+        {% for column in e.run_columns %}<td>{% if column in e.run_choices %}{% set picked = view.picked.get(column, {}) %}<details class="pick">
+          <summary aria-label="Filter {{ column }}">{{ picked | join(', ') if picked else 'all' }}</summary>
+          <div class="options">{% for label in e.run_choices[column] %}<label><input form="run-filters" type="checkbox" name="f.{{ column }}" value="{{ label }}"{{ ' checked' if label in picked }}> {{ label }}</label>{% endfor %}</div>
+        </details>{% else %}<input form="run-filters" type="search" name="f.{{ column }}" value="{{ view.filters.get(column, '') }}" placeholder="filter" aria-label="Filter {{ column }}">{% endif %}</td>{% endfor %}
       </tr>
     </thead>
     <tbody>

labnotes-0.0.54/src/labnotes/parse_run_view.py

@@ -1,20 +0,0 @@
-from collections.abc import Mapping
-
-from labnotes.models import RunView
-
-STATUSES = {"complete", "incomplete"}
-
-
-def parse_run_view(params: Mapping[str, str], columns: list[str]) -> RunView:
-    sort = params.get("sort")
-    status = params.get("status")
-    return RunView(
-        sort=sort if sort in columns or sort == "status" else None,
-        descending=params.get("order") == "desc",
-        status=status if status in STATUSES else None,
-        filters={
-            column: value
-            for column in columns
-            if (value := params.get(f"f.{column}", "").strip())
-        },
-    )

labnotes-0.0.54/src/labnotes/sort_href.py

@@ -1,13 +0,0 @@
-from urllib.parse import urlencode
-
-from labnotes.models import RunView
-
-
-def sort_href(view: RunView, column: str) -> str:
-    params = {"sort": column}
-    if view.sort == column and not view.descending:
-        params["order"] = "desc"
-    if view.status:
-        params["status"] = view.status
-    params.update({f"f.{name}": value for name, value in view.filters.items()})
-    return f"?{urlencode(params)}#runs"