labnotes 0.0.60__tar.gz → 0.0.62__tar.gz

{labnotes-0.0.60 → labnotes-0.0.62}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.0.60
+Version: 0.0.62
 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.60 → labnotes-0.0.62}/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
@@ -30,8 +31,8 @@ from labnotes.notebook_kernel import NotebookKernel
 from labnotes.python_blocks import python_blocks
 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")
@@ -40,20 +41,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()
 
@@ -97,6 +94,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 +149,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.62/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.60 → labnotes-0.0.62}/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.60 → labnotes-0.0.62}/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.60 → labnotes-0.0.62}/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.60 → labnotes-0.0.62}/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.62/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.60 → labnotes-0.0.62}/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.60 → labnotes-0.0.62}/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.62/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)

labnotes-0.0.60/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)