labnotes 0.0.61__tar.gz → 0.0.63__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.0.61
+Version: 0.0.63
 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>
@@ -101,7 +101,7 @@ To exclude a run, add `"excluded": true` and an optional `"reason"` to its
 replaces it; both show as columns in `runs`.
 
 In a terminal, `run` shows a live table of runs (status and time) and stays
-open when they finish; `q` quits. Elsewhere, or with `--no-tui`, it prints a
+open when they finish; `q` quits. Elsewhere, it prints a
 line per event instead.
 
 - `--concurrency N` runs N at a time (default 1).

{labnotes-0.0.61 → labnotes-0.0.63}/README.md

@@ -80,7 +80,7 @@ To exclude a run, add `"excluded": true` and an optional `"reason"` to its
 replaces it; both show as columns in `runs`.
 
 In a terminal, `run` shows a live table of runs (status and time) and stays
-open when they finish; `q` quits. Elsewhere, or with `--no-tui`, it prints a
+open when they finish; `q` quits. Elsewhere, it prints a
 line per event instead.
 
 - `--concurrency N` runs N at a time (default 1).

{labnotes-0.0.61 → labnotes-0.0.63}/src/labnotes/context.md

@@ -105,7 +105,7 @@ 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, or with `--no-tui`, it prints a
+plans a single run opens straight on its output. `q` quits. Elsewhere, it prints a
 line per event instead.
 
 - `--concurrency N` runs N at a time to start with. Without it, `concurrency`

{labnotes-0.0.61 → labnotes-0.0.63}/src/labnotes/create_app.py

@@ -1,6 +1,7 @@
 import asyncio
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
+from datetime import datetime
 from pathlib import Path
 
 from starlette.applications import Starlette
@@ -29,9 +30,9 @@ from labnotes.load_experiment import load_experiment
 from labnotes.models import LabnotesConfig
 from labnotes.notebook_kernel import NotebookKernel
 from labnotes.python_blocks import python_blocks
+from labnotes.save_conflict_copy import save_conflict_copy
 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
 
@@ -42,20 +43,16 @@ templates.env.filters["duration"] = format_duration
 templates.env.globals["asset"] = asset_url
 
 
-def create_app(config: LabnotesConfig, kernel_idle_minutes: float) -> Starlette:
+def create_app(config: LabnotesConfig) -> Starlette:
     kernels: dict[tuple[str, str], NotebookKernel] = {}
 
     @asynccontextmanager
     async def lifespan(app: Starlette) -> AsyncIterator[None]:
         app.state.tables = open_tables(config)
         await app.state.tables.ready()
-        watchers = [
-            asyncio.create_task(drain_watch(app.state.tables)),
-            asyncio.create_task(stop_idle_kernels(kernels, kernel_idle_minutes)),
-        ]
+        watcher = asyncio.create_task(drain_watch(app.state.tables))
         yield
-        for watcher in watchers:
-            watcher.cancel()
+        watcher.cancel()
         for kernel in kernels.values():
             await kernel.stop()
 
@@ -132,6 +129,14 @@ def create_app(config: LabnotesConfig, kernel_idle_minutes: float) -> Starlette:
             return JSONResponse({"content": current}, status_code=409)
         return Response(status_code=204)
 
+    async def post_conflict(request: Request) -> Response:
+        note = await find_note(request)
+        content = (await request.json()).get("content")
+        if not isinstance(content, str):
+            raise HTTPException(400, "Send content as a string")
+        copy = save_conflict_copy(Path(note["path"]), content, datetime.now())
+        return JSONResponse({"name": copy.name}, status_code=201)
+
     async def run_block(request: Request) -> Response:
         blocks = python_blocks((await find_note(request))["content"])
         key = (request.path_params["name"], request.path_params["note"])
@@ -157,6 +162,11 @@ def create_app(config: LabnotesConfig, kernel_idle_minutes: float) -> Starlette:
             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(
+                "/experiments/{name}/notes/{note:path}/conflict",
+                post_conflict,
+                methods=["POST"],
+            ),
             Route(
                 "/experiments/{name}/notes/{note:path}/run",
                 run_block,

{labnotes-0.0.61 → labnotes-0.0.63}/src/labnotes/experiments.py

@@ -39,11 +39,6 @@ from labnotes.tui.run_tui import run_tui
     type=click.Path(exists=True, dir_okay=False, path_type=Path),
     help="With run: read this file instead of the experiment's experiment.toml.",
 )
-@click.option(
-    "--no-tui",
-    is_flag=True,
-    help="With run: print a line per event instead of the live view.",
-)
 @click.pass_context
 def experiments(
     ctx: click.Context,
@@ -52,7 +47,6 @@ def experiments(
     output_format: str,
     concurrency: int | None,
     experiment_config: Path | None,
-    no_tui: bool,
 ) -> None:
     config = load_config(ctx)
     if config is None:
@@ -68,7 +62,7 @@ def experiments(
             click.echo(f"Created {path / 'experiment.toml'}")
             return
         case str(), "run":
-            live = sys.stdout.isatty() and sys.stderr.isatty() and not no_tui
+            live = sys.stdout.isatty() and sys.stderr.isatty()
             drive = run_tui if live else lambda start, title: run_headless(start)
             try:
                 results = start_experiment(

{labnotes-0.0.61 → labnotes-0.0.63}/src/labnotes/notebook_kernel.py

@@ -1,7 +1,6 @@
 import asyncio
 import hashlib
 from pathlib import Path
-from time import monotonic
 
 from jupyter_client.asynchronous.client import AsyncKernelClient
 from jupyter_client.manager import AsyncKernelManager
@@ -24,7 +23,6 @@ class NotebookKernel:
         self._lock = asyncio.Lock()
         self._manager: AsyncKernelManager | None = None
         self._client: AsyncKernelClient | None = None
-        self.last_used = monotonic()
 
     async def _start(self) -> None:
         self._manager = AsyncKernelManager(kernel_name="python3")
@@ -35,27 +33,24 @@ class NotebookKernel:
 
     async def run(self, code: str) -> str:
         async with self._lock:
-            try:
-                if self._client is None:
-                    await self._start()
-                assert self._client is not None
-                messages: list[dict[str, object]] = []
-                await self._client.execute_interactive(
-                    code,
-                    output_hook=lambda message: messages.append(message),
-                    allow_stdin=False,
-                )
-                html = output_html(
-                    [
-                        {"msg_type": message["msg_type"], "content": message["content"]}
-                        for message in messages
-                        if message["msg_type"] not in QUIET
-                    ]
-                )
-                self.outputs[block_key(code)] = html
-                return html
-            finally:
-                self.last_used = monotonic()
+            if self._client is None:
+                await self._start()
+            assert self._client is not None
+            messages: list[dict[str, object]] = []
+            await self._client.execute_interactive(
+                code,
+                output_hook=lambda message: messages.append(message),
+                allow_stdin=False,
+            )
+            html = output_html(
+                [
+                    {"msg_type": message["msg_type"], "content": message["content"]}
+                    for message in messages
+                    if message["msg_type"] not in QUIET
+                ]
+            )
+            self.outputs[block_key(code)] = html
+            return html
 
     async def stop(self) -> None:
         client, manager = self._client, self._manager
@@ -68,7 +63,3 @@ class NotebookKernel:
     async def restart(self) -> None:
         async with self._lock:
             await self.stop()
-
-    async def stop_if_idle(self, idle_seconds: float) -> None:
-        if not self._lock.locked() and monotonic() - self.last_used > idle_seconds:
-            await self.stop()

labnotes-0.0.63/src/labnotes/save_conflict_copy.py

@@ -0,0 +1,16 @@
+from datetime import datetime
+from itertools import chain, count
+from pathlib import Path
+
+
+def save_conflict_copy(path: Path, content: str, now: datetime) -> Path:
+    stamp = f"Conflicted copy {now:%Y%m%d%H%M}"
+    tags = chain([stamp], (f"{stamp} {n}" for n in count(2)))
+    while True:
+        copy = path.with_name(f"{path.stem} ({next(tags)}){path.suffix}")
+        try:
+            with copy.open("x", encoding="utf-8") as file:
+                file.write(content)
+            return copy
+        except FileExistsError:
+            pass

{labnotes-0.0.61 → labnotes-0.0.63}/src/labnotes/serve_app.py

@@ -7,10 +7,7 @@ from labnotes.create_app import create_app
 from labnotes.read_config import read_config
 
 CONFIG = "LABNOTES_CONFIG"
-KERNEL_IDLE_MINUTES = "LABNOTES_KERNEL_IDLE_MINUTES"
 
 
 def serve_app() -> Starlette:
-    return create_app(
-        read_config(Path(os.environ[CONFIG])), int(os.environ[KERNEL_IDLE_MINUTES])
-    )
+    return create_app(read_config(Path(os.environ[CONFIG])))

{labnotes-0.0.61 → labnotes-0.0.63}/src/labnotes/server.py

@@ -5,7 +5,7 @@ from uvicorn.main import main as uvicorn_main
 
 from labnotes.load_config import load_config
 from labnotes.read_config import CONFIG_FILE
-from labnotes.serve_app import CONFIG, KERNEL_IDLE_MINUTES
+from labnotes.serve_app import CONFIG
 
 # labnotes owns these; the rest of uvicorn's options pass straight through.
 OWN_OPTIONS = {"app", "factory", "app_dir", "version", "host", "port"}
@@ -14,14 +14,6 @@ OWN_OPTIONS = {"app", "factory", "app_dir", "version", "host", "port"}
 @click.command(
     help="Serve the experiments, their notes and their runs as a local site."
 )
-@click.option(
-    "--kernel-idle-minutes",
-    type=click.IntRange(min=1),
-    default=30,
-    show_default=True,
-    envvar=KERNEL_IDLE_MINUTES,
-    help="Stop a note's Python kernel after this long without a run.",
-)
 @click.option(
     "-h",
     "--host",
@@ -31,19 +23,14 @@ OWN_OPTIONS = {"app", "factory", "app_dir", "version", "host", "port"}
 )
 @click.option("-p", "--port", type=int, default=8000, show_default=True)
 @click.pass_context
-def server(
-    ctx: click.Context,
-    kernel_idle_minutes: int,
-    **server_options: object,
-) -> None:
+def server(ctx: click.Context, **server_options: object) -> None:
     config = load_config(ctx)
     if config is None:
         raise click.ClickException(
             f"No {CONFIG_FILE} here. Run labnotes init, or pass -c PATH."
         )
-    # Through the environment so --reload and --workers child processes see them.
+    # Through the environment so --reload and --workers child processes see it.
     os.environ[CONFIG] = str(config.path.resolve())
-    os.environ[KERNEL_IDLE_MINUTES] = str(kernel_idle_minutes)
     ctx.invoke(
         uvicorn_main,
         app="labnotes.serve_app:serve_app",

{labnotes-0.0.61 → labnotes-0.0.63}/src/labnotes/static/note-editor.js

@@ -105,9 +105,6 @@ function show(status, message) {
 
 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 = [];
@@ -125,22 +122,52 @@ function setText(view, text) {
 export function edit(note, prose, status) {
   let base = JSON.parse(note.querySelector(".note-source").textContent);
   let timer;
+  let deadline;
   let queue = Promise.resolve();
 
   const host = document.createElement("div");
   host.className = "editor";
   prose.replaceWith(host);
 
+  const notice = (message) => {
+    show(status, message);
+    setTimeout(() => {
+      if (status.textContent === message) status.hidden = true;
+    }, 4000);
+  };
+
   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));
+  // Three-way: what changed on disk since base, applied onto the editor's text.
+  // A patch that will not apply leaves the editor alone and keeps the disk
+  // version in a sibling file, as Obsidian Sync does.
+  const absorb = async (theirs) => {
+    const ours = view.state.doc.toString();
+    const [merged, applied] = dmp.patch_apply(dmp.patch_make(base, theirs), ours);
+    const name = note.dataset.note;
+    if (applied.every(Boolean)) {
+      setText(view, merged);
+      if (ours !== base) notice(`${name} was modified externally, merging changes automatically`);
+    } else {
+      const response = await fetch(note.dataset.conflictUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ content: theirs }),
+      });
+      if (!response.ok) throw new Error(`${response.status} ${response.statusText}`);
+      const copy = (await response.json()).name;
+      show(
+        status,
+        `${name} was modified externally and could not be merged. The outside version is saved as ${copy}.`,
+      );
+    }
     base = theirs;
   };
 
   const push = async () => {
     clearTimeout(timer);
+    deadline = undefined;
     for (;;) {
       const content = view.state.doc.toString();
       if (content === base) return;
@@ -154,7 +181,7 @@ export function edit(note, prose, status) {
         else show(status, `Not saved: ${response.status} ${response.statusText}`);
         return;
       }
-      absorb((await response.json()).content);
+      await absorb((await response.json()).content);
     }
   };
 
@@ -163,7 +190,7 @@ export function edit(note, prose, status) {
     if (!response.ok) return show(status, `Not synced: ${response.status} ${response.statusText}`);
     const theirs = await response.text();
     if (theirs === base) return;
-    absorb(theirs);
+    await absorb(theirs);
     await push();
   };
 
@@ -194,7 +221,8 @@ export function edit(note, prose, status) {
         EditorView.updateListener.of((update) => {
           if (!update.docChanged) return;
           clearTimeout(timer);
-          timer = setTimeout(save, 500);
+          deadline ??= Date.now() + 2000;
+          timer = setTimeout(save, Math.min(500, deadline - Date.now()));
         }),
       ],
     }),

{labnotes-0.0.61 → labnotes-0.0.63}/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 %}<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 }}">
+<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-conflict-url="{{ url_for('post_conflict', 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>

labnotes-0.0.61/src/labnotes/stop_idle_kernels.py

@@ -1,13 +0,0 @@
-import asyncio
-from collections.abc import Mapping
-
-from labnotes.notebook_kernel import NotebookKernel
-
-
-async def stop_idle_kernels(
-    kernels: Mapping[tuple[str, str], NotebookKernel], idle_minutes: float
-) -> None:
-    while True:
-        await asyncio.sleep(60)
-        for kernel in list(kernels.values()):
-            await kernel.stop_if_idle(idle_minutes * 60)