labnotes 0.0.138__tar.gz → 0.1.0__tar.gz

{labnotes-0.0.138 → labnotes-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.0.138
+Version: 0.1.0
 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.138 → labnotes-0.1.0}/src/labnotes/runner/execute_run.py

@@ -38,6 +38,7 @@ async def execute_run(
     state_file: Path,
     memory_interval: float,
     environment: dict[str, str] | None = None,
+    git_info: dict[str, str | bool] | None = None,
 ) -> dict[str, object]:
     resolved = shell_command(command, folder, params, args)
     run: dict[str, object] = {
@@ -49,7 +50,9 @@ async def execute_run(
         "error": None,
         "ended_by": None,
         "signal": None,
-        "git": await asyncio.to_thread(run_git, root),
+        "git": git_info
+        if git_info is not None
+        else await asyncio.to_thread(run_git, root),
     }
     if args:
         run["args"] = list(args)

labnotes-0.1.0/src/labnotes/runner/project_snapshot.py

@@ -0,0 +1,118 @@
+import logging
+import os
+import signal
+import shutil
+import subprocess
+from contextlib import contextmanager
+from collections.abc import Callable
+from dataclasses import dataclass
+from collections.abc import Iterator
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from types import FrameType
+
+
+@dataclass
+class ProjectSnapshot:
+    root: Path
+    sha: str | None = None
+    diff: bytes | None = None
+
+
+def git(root: Path, *args: str) -> bytes:
+    return subprocess.check_output(["git", *args], cwd=root, stderr=subprocess.DEVNULL)
+
+
+@contextmanager
+def project_snapshot(root: Path) -> Iterator[ProjectSnapshot]:
+    """Capture the working tree once for all commands in an invocation."""
+    try:
+        git(root, "rev-parse", "--is-inside-work-tree")
+    except (OSError, subprocess.SubprocessError):
+        logging.warning("Project is not a git repository; running from the live tree")
+        yield ProjectSnapshot(root)
+        return
+
+    try:
+        sha = git(root, "rev-parse", "HEAD").decode("ascii").strip()
+        diff = git(root, "diff", "HEAD")
+    except (OSError, subprocess.SubprocessError):
+        logging.warning("Project has no readable Git HEAD; running from the live tree")
+        yield ProjectSnapshot(root)
+        return
+    files = filter(
+        None, git(root, "ls-files", "-co", "--exclude-standard", "-z").split(b"\0")
+    )
+    ignored = filter(
+        None,
+        git(root, "ls-files", "-oi", "--exclude-standard", "--directory", "-z").split(
+            b"\0"
+        ),
+    )
+    with TemporaryDirectory(prefix="labnotes-") as directory:
+        snapshot = Path(directory)
+        previous: dict[
+            signal.Signals,
+            Callable[[int, FrameType | None], object] | int | signal.Handlers | None,
+        ] = {}
+
+        def stop(_number: int, _frame: object) -> None:
+            raise KeyboardInterrupt
+
+        try:
+            for number in (signal.SIGTERM, signal.SIGHUP):
+                try:
+                    old_handler = signal.signal(number, stop)
+                except ValueError:
+                    break  # Signals can only be installed from the main thread.
+                previous[number] = old_handler
+            subprocess.run(
+                [
+                    "git",
+                    "clone",
+                    "--quiet",
+                    "--shared",
+                    "--no-checkout",
+                    str(root),
+                    str(snapshot),
+                ],
+                check=True,
+            )
+            for raw in files:
+                relative = Path(raw.decode())
+                source = root / relative
+                if not source.exists() and not source.is_symlink():
+                    continue
+                target = snapshot / relative
+                target.parent.mkdir(parents=True, exist_ok=True)
+                if source.is_symlink():
+                    target.symlink_to(
+                        os.readlink(source), target_is_directory=source.is_dir()
+                    )
+                elif source.is_dir():
+                    shutil.copytree(source, target, symlinks=True)
+                else:
+                    shutil.copy2(source, target)
+            skipped: set[Path] = set()
+            for raw in ignored:
+                relative = Path(raw.decode().rstrip("/"))
+                if any(parent in relative.parents for parent in skipped):
+                    continue
+                if any((snapshot / parent).is_symlink() for parent in relative.parents):
+                    continue
+                source = root / relative
+                if source.is_dir() and (source / "pyvenv.cfg").exists():
+                    skipped.add(relative)
+                    continue
+                target = snapshot / relative
+                if target.is_symlink() or target.exists():
+                    continue
+                target.parent.mkdir(parents=True, exist_ok=True)
+                target.symlink_to(source, target_is_directory=source.is_dir())
+            subprocess.run(
+                ["git", "-C", str(snapshot), "reset", "--quiet", sha], check=True
+            )
+        finally:
+            for number, handler in previous.items():
+                signal.signal(number, handler)
+        yield ProjectSnapshot(snapshot, sha, diff)

{labnotes-0.0.138 → labnotes-0.1.0}/src/labnotes/runner/run_experiment.py

@@ -27,6 +27,7 @@ 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
+from labnotes.runner.project_snapshot import ProjectSnapshot
 from labnotes.runner.run_folder import run_folder
 from labnotes.runner.signal_tree import signal_tree
 from labnotes.state_path import STATE_ENV
@@ -49,7 +50,9 @@ async def run_experiment(
     only: dict[str, str] | None = None,
     args: list[str] | None = None,
     environment: dict[str, str] | None = None,
+    snapshot: ProjectSnapshot | None = None,
 ) -> list[dict[str, object]]:
+    command_root = snapshot.root if snapshot is not None else config.root
     inherited = dict(os.environ) if environment is None else environment
     tables = open_tables(config)
     existing = await experiment_run_ids(tables, name)
@@ -109,7 +112,7 @@ async def run_experiment(
     meta = None
     if experiment.meta is not None:
         meta = await invocation_meta(
-            config.root, fill_dirs(experiment.meta, dirs), hook_env["meta"]
+            command_root, fill_dirs(experiment.meta, dirs), hook_env["meta"]
         )
     if dirs:
         Path(dirs["invocation_dir"]).mkdir(parents=True, exist_ok=True)
@@ -242,12 +245,15 @@ async def run_experiment(
     async def start(run: str, params: dict[str, object]) -> None:
         folder = run_folder(config.root, config.runs, name, run)
         folder.mkdir(parents=True, exist_ok=True)
+        if snapshot is not None and snapshot.sha is not None:
+            (folder / "git-sha.txt").write_text(snapshot.sha + "\n")
+            (folder / "git-diff.patch").write_bytes(snapshot.diff or b"")
         run_invocation_dir = dirs.get("invocation_dir") or str(folder.resolve())
         report({"event": "started", "run": run, "params": params, "folder": folder})
         running[run] = set()
         trees[run] = set()
         result = await execute_run(
-            config.root,
+            command_root,
             folder,
             fill_dirs(
                 experiment.command,
@@ -276,6 +282,11 @@ async def run_experiment(
                     "invocation_dir": run_invocation_dir,
                 },
             ),
+            git_info=(
+                {"commit": snapshot.sha, "dirty": bool(snapshot.diff)}
+                if snapshot is not None and snapshot.sha is not None
+                else None
+            ),
         )
         del running[run], trees[run]
         report({"event": "ended", "run": run, **result})
@@ -290,7 +301,7 @@ async def run_experiment(
         if experiment.teardown is not None:
             report({"event": "tearing down"})
             await invocation_hook(
-                config.root,
+                command_root,
                 "teardown",
                 fill_dirs(experiment.teardown, dirs),
                 hook_env["teardown"],
@@ -311,7 +322,7 @@ async def run_experiment(
             if experiment.setup is not None:
                 report({"event": "setting up"})
                 await invocation_hook(
-                    config.root,
+                    command_root,
                     "setup",
                     fill_dirs(experiment.setup, dirs),
                     hook_env["setup"],

{labnotes-0.0.138 → labnotes-0.1.0}/src/labnotes/runner/start_experiment.py

@@ -3,6 +3,7 @@ from pathlib import Path
 from labnotes.models import LabnotesConfig, Listen, Report, Start
 from labnotes.runner.finalize_lost_runs import finalize_lost_runs
 from labnotes.runner.prepare_experiment import prepare_experiment
+from labnotes.runner.project_snapshot import project_snapshot
 from labnotes.runner.run_experiment import run_experiment
 
 
@@ -22,16 +23,18 @@ def start_experiment(
             config, name, experiment_config, concurrency, only, args, setup, teardown
         )
         await finalize_lost_runs(config)
-        return await run_experiment(
-            config,
-            name,
-            experiment,
-            limit,
-            report,
-            listen,
-            timeout=timeout,
-            only=only,
-            args=args,
-        )
+        with project_snapshot(config.root) as snapshot:
+            return await run_experiment(
+                config,
+                name,
+                experiment,
+                limit,
+                report,
+                listen,
+                timeout=timeout,
+                only=only,
+                args=args,
+                snapshot=snapshot,
+            )
 
     return start