labnotes 0.0.67__tar.gz → 0.0.69__tar.gz

{labnotes-0.0.67 → labnotes-0.0.69}/PKG-INFO

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

@@ -36,6 +36,7 @@ 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.tables.open_tables import open_tables
+from labnotes.wait_for_note import wait_for_note
 
 HERE = Path(__file__).parent
 templates = Jinja2Templates(directory=HERE / "templates")
@@ -149,6 +150,13 @@ def create_app(config: LabnotesConfig) -> Starlette:
         current = save_note(path, base, content)
         if current is not None:
             return JSONResponse({"content": current}, status_code=409)
+        await wait_for_note(
+            request.app.state.tables,
+            config.root,
+            request.path_params["name"],
+            request.path_params["note"],
+            content,
+        )
         return Response(status_code=204)
 
     async def post_conflict(request: Request) -> Response:

{labnotes-0.0.67 → labnotes-0.0.69}/src/labnotes/experiment_notes.py

@@ -12,13 +12,13 @@ async def experiment_notes(
     if note is not None:
         where += f" AND filename = {quote_string(note)}"
     rows = await tables.query(
-        f"SELECT filename, path FROM files WHERE {where} ORDER BY filename"
+        f"SELECT filename, path, content FROM files WHERE {where} ORDER BY filename"
     )
     return [
         {
             "name": str(row["filename"]),
             "path": str(root / str(row["path"])),
-            "content": (root / str(row["path"])).read_text(encoding="utf-8"),
+            "content": str(row["content"] or ""),
         }
         for row in rows
     ]

{labnotes-0.0.67 → labnotes-0.0.69}/src/labnotes/runner/read_experiment_config.py

@@ -10,10 +10,11 @@ from labnotes.modes import MODES
 SETTINGS = {"name", "command", "repeats", "params", "counts", "mode", "concurrency"}
 
 
-def read_experiment_config(path: Path, mode: str, concurrency: int) -> ExperimentConfig:
+def read_experiment_config(
+    path: Path, source: str, mode: str, concurrency: int
+) -> ExperimentConfig:
     try:
-        with path.open("rb") as file:
-            values = tomllib.load(file)
+        values = tomllib.loads(source)
     except tomllib.TOMLDecodeError as error:
         raise ValueError(f"{path}: {error}") from error
     unknown = sorted(values.keys() - SETTINGS)

{labnotes-0.0.67 → labnotes-0.0.69}/src/labnotes/runner/run_experiment.py

@@ -17,6 +17,7 @@ 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
 from labnotes.runner.run_folder import run_folder
+from labnotes.tables.experiment_run_ids import experiment_run_ids
 from labnotes.tables.list_experiment_runs import list_experiment_runs
 from labnotes.tables.open_tables import open_tables
 
@@ -31,18 +32,17 @@ async def run_experiment(
     report: Report,
     listen: Listen,
 ) -> list[dict[str, object]]:
+    tables = open_tables(config)
+    existing = await experiment_run_ids(tables, name)
     finished: list[dict[str, object]] = []
     match experiment.mode:
         case "fill":
-            tables = open_tables(config)
-            existing = await list_experiment_runs(tables, name, experiment.counts)
-            finished = [json.loads(str(r["params"])) for r in existing if r["counted"]]
+            counted = await list_experiment_runs(tables, name, experiment.counts)
+            finished = [json.loads(str(r["params"])) for r in counted if r["counted"]]
     planned: set[str] = set()
 
     def taken(run: str) -> bool:
-        return (
-            run in planned or run_folder(config.root, config.runs, name, run).exists()
-        )
+        return run in planned or run in existing
 
     group = new_stamped_run_id(taken) if experiment.mode == "adhoc" else None
 

{labnotes-0.0.67 → labnotes-0.0.69}/src/labnotes/runner/start_experiment.py

@@ -1,3 +1,4 @@
+import asyncio
 from collections.abc import Callable
 from functools import partial
 from pathlib import Path
@@ -7,6 +8,7 @@ from labnotes.runner.hold_folder import hold_folder
 from labnotes.runner.read_experiment_config import read_experiment_config
 from labnotes.runner.run_experiment import run_experiment
 from labnotes.runner.runs_parent import runs_parent
+from labnotes.tables.file_text import file_text
 
 
 def start_experiment(
@@ -19,10 +21,11 @@ def start_experiment(
     if experiment_config is None:
         folder = config.experiments.replace("{experiment}", name)
         experiment_config = config.root / folder / "experiment.toml"
-    if not experiment_config.is_file():
+    source = asyncio.run(file_text(config.root, experiment_config))
+    if source is None:
         raise ValueError(f"No experiment.toml for {name} at {experiment_config}.")
     experiment = read_experiment_config(
-        experiment_config, config.mode, config.concurrency
+        experiment_config, source, config.mode, config.concurrency
     )
     if concurrency is None:
         concurrency = experiment.concurrency

{labnotes-0.0.67 → labnotes-0.0.69}/src/labnotes/static/note-edit.js

@@ -11,10 +11,7 @@ export function attach(note, openNow) {
 
   editor.then(
     () => prose.classList.add("editable"),
-    () => {
-      status.textContent = "Editing needs the network: the editor loads from esm.sh.";
-      status.hidden = false;
-    },
+    () => {},
   );
 
   const open = async (event) => {

labnotes-0.0.69/src/labnotes/tables/experiment_run_ids.py

@@ -0,0 +1,11 @@
+from dirsql import DirSQL
+
+from labnotes.sql_quote import quote_string
+
+
+async def experiment_run_ids(tables: DirSQL, name: str) -> set[str]:
+    rows = await tables.query(
+        f"SELECT id FROM runs WHERE experiment = {quote_string(name)}"
+    )
+    ids = {str(row["id"]) for row in rows}
+    return ids | {run.split("/")[0] for run in ids}

labnotes-0.0.69/src/labnotes/tables/file_text.py

@@ -0,0 +1,12 @@
+from pathlib import Path
+
+from dirsql import DirSQL
+
+from labnotes.sql_quote import quote_string
+
+
+async def file_text(root: Path, path: Path) -> str | None:
+    rows = await DirSQL(str(root), tables=[], no_ignore=True).query(
+        f"SELECT content FROM {quote_string(str(path))}"
+    )
+    return next((str(row["content"] or "") for row in rows), None)

labnotes-0.0.69/src/labnotes/tables/note_text.py

@@ -0,0 +1,10 @@
+from pathlib import Path
+
+
+def note_text(path: Path) -> str | None:
+    if path.suffix != ".md":
+        return None
+    try:
+        return path.read_text(encoding="utf-8")
+    except UnicodeDecodeError:
+        return None

{labnotes-0.0.67 → labnotes-0.0.69}/src/labnotes/tables/open_tables.py

@@ -29,7 +29,7 @@ CREATE VIEW experiments AS
 FILES = """
 CREATE TABLE files (
   experiment TEXT, filename TEXT, path TEXT PRIMARY KEY, ctime TEXT, mtime TEXT,
-  mtime_ns INTEGER
+  mtime_ns INTEGER, content TEXT
 )
 """
 RUNS = """

{labnotes-0.0.67 → labnotes-0.0.69}/src/labnotes/tables/read_file.py

@@ -2,6 +2,7 @@ from pathlib import Path
 
 from labnotes.tables.file_prefix import file_prefix
 from labnotes.tables.iso_time import iso_time
+from labnotes.tables.note_text import note_text
 from labnotes.tables.path_pattern import path_pattern
 
 
@@ -20,5 +21,6 @@ def read_file(root: Path, template: str, path: str) -> list[dict[str, object]]:
             "ctime": iso_time(stat.st_ctime),
             "mtime": iso_time(stat.st_mtime),
             "mtime_ns": stat.st_mtime_ns,
+            "content": note_text(Path(path)),
         }
     ]

labnotes-0.0.69/src/labnotes/wait_for_note.py

@@ -0,0 +1,20 @@
+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,
+    content: str | None = None,
+) -> None:
+    for _ in range(40):
+        found = await experiment_notes(tables, root, experiment, note)
+        if found and (content is None or found[0]["content"] == content):
+            return
+        await asyncio.sleep(0.05)