labnotes 0.1.2__tar.gz → 0.2.1__tar.gz

{labnotes-0.1.2 → labnotes-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.1.2
+Version: 0.2.1
 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.1.2 → labnotes-0.2.1}/src/labnotes/context.md

@@ -102,19 +102,17 @@ the value from the start, even if the code changed while they waited.
 commands run once per `run` from the root: setup before the first run starts,
 teardown after the last one ends, even if runs failed, were stopped, or setup
 failed (so teardown must cope with a partial setup). A failing setup starts no
-run; a failing teardown fails the invocation. Both get `{invocation_dir}` only:
-the shared folder for a multi-run adhoc invocation, or the run folder when one
-run is planned. That folder exists before setup starts. In matrix mode with
-several runs there is no shared folder, so `{invocation_dir}` in a hook fails.
-`{run_dir}` is never filled in hooks; use `{invocation_dir}` instead. An
-unavailable placeholder fails before anything starts.
+run; a failing teardown fails the invocation. Hooks and `meta` get no folder
+placeholders: `{run_dir}` or `{invocation_dir}` in one fails before anything
+starts. Share values through state instead.
 Setup can call `labnotes.set_state({"container": "abc"})`; runs and teardown read the
 dict with `labnotes.get_state()`. Writes merge by top-level key, replacing an
 existing value without dropping other keys. Values must be JSON serializable;
 reading before any write returns `{}`. Runs can only read: `set_state` raises
 `RuntimeError` there. Both functions raise outside an invocation and in `meta`.
 Labnotes gives setup/teardown `LABNOTES_STATE` and runs `LABNOTES_RUN_STATE`,
-pointing to `{invocation_dir}/state.json` or, without a shared folder, a temp
+pointing to `state.json` in the multi-run adhoc group folder or the lone run's
+folder, or, without a shared folder, a temp
 file kept through all runs and teardown and then removed. Queued runs and retries
 read the same file after setup finishes. `meta` receives neither state variable;
 state is never copied into `run.json`.
@@ -125,8 +123,8 @@ children and set their own hook and run variables.
 provides shared values; experiment values replace them by name. Variables in
 the environment that starts `labnotes experiments NAME run` win over both,
 including inline assignments. Values can use raw `{run_dir}` and
-`{invocation_dir}` placeholders. In hooks and meta, only `{invocation_dir}` is
-available, and it requires one planned run in matrix mode.
+`{invocation_dir}` placeholders. Hooks and meta get neither, so values using
+one are left out of their environment; runs still get them.
 `LABNOTES_*` names are reserved for labnotes.
 A run counts when it exited 0 and its `run.json` doesn't hold
 `"excluded": true`, so excluding a run by hand means adding that key; the next

labnotes-0.2.1/src/labnotes/runner/check_args.py

@@ -0,0 +1,19 @@
+from collections import Counter
+
+from labnotes.runner.command_flags import command_flags
+from labnotes.runner.group_args import group_args
+
+
+def check_args(params: dict[str, list[object]], command: str, args: list[str]) -> None:
+    taken = Counter(flag.name for flag in command_flags(command))
+    given: set[str] = set()
+    for name in (arg.name for arg in group_args(args) if arg.name is not None):
+        if name in params:
+            raise ValueError(f"--{name} is a param. Pick it with --{name}=VALUE.")
+        if taken[name] > 1:
+            raise ValueError(
+                f"--{name} is in the command more than once, so -- can't override it."
+            )
+        if taken[name] and name in given:
+            raise ValueError(f"--{name} is in -- ARGS more than once.")
+        given.add(name)

labnotes-0.2.1/src/labnotes/runner/check_hook_placeholders.py

@@ -0,0 +1,12 @@
+from labnotes.runner.placeholders import PLACEHOLDERS
+
+
+def check_hook_placeholders(hooks: dict[str, str | None]) -> None:
+    for hook, command in hooks.items():
+        for name in PLACEHOLDERS:
+            if command is not None and f"{{{name}}}" in command:
+                raise ValueError(
+                    f"{hook} command {command} uses {{{name}}}; setup, teardown, "
+                    "and meta get no folder placeholders. "
+                    "Share values with set_state() and get_state()."
+                )

labnotes-0.2.1/src/labnotes/runner/command_flags.py

@@ -0,0 +1,35 @@
+import re
+from itertools import zip_longest
+from typing import NamedTuple
+
+from labnotes.runner.flag_name import flag_name
+
+OPERATOR = ";&|<>()"
+WORD = re.compile(
+    rf"""[{OPERATOR}]+|(?:[^\s{OPERATOR}'"\\]|\\.|'[^']*'|"(?:[^"\\]|\\.)*")+""",
+    re.DOTALL,
+)
+
+
+class CommandFlag(NamedTuple):
+    name: str
+    start: int
+    end: int
+    joined: bool
+
+
+def command_flags(command: str) -> list[CommandFlag]:
+    words = list(WORD.finditer(command))
+    flags: list[CommandFlag] = []
+    for word, after in zip_longest(words, words[1:]):
+        name = flag_name(word[0])
+        if name is None:
+            continue
+        joined = "=" in word[0]
+        end = word.end()
+        if not joined and after is not None:
+            value = after[0]
+            if value[0] not in OPERATOR and not value.startswith("-"):
+                end = after.end()
+        flags.append(CommandFlag(name, word.start(), end, joined))
+    return flags

labnotes-0.2.1/src/labnotes/runner/fill_experiment_env.py

@@ -0,0 +1,23 @@
+from collections.abc import Mapping
+
+from labnotes.runner.fill_dirs import fill_dirs
+from labnotes.runner.placeholders import PLACEHOLDERS
+
+
+def fill_experiment_env(
+    configured: Mapping[str, str],
+    inherited: Mapping[str, str],
+    dirs: Mapping[str, str],
+) -> dict[str, str]:
+    caller = {
+        key: value
+        for key, value in inherited.items()
+        if not key.startswith("LABNOTES_")
+    }
+    filled = {
+        key: fill_dirs(value, dirs, quote=False)
+        for key, value in configured.items()
+        if key not in caller
+        and all(name in dirs for name in PLACEHOLDERS if f"{{{name}}}" in value)
+    }
+    return {**filled, **caller}

labnotes-0.2.1/src/labnotes/runner/group_args.py

@@ -0,0 +1,33 @@
+from typing import NamedTuple
+
+from labnotes.runner.flag_name import flag_name
+
+
+class Arg(NamedTuple):
+    name: str | None
+    value: str | None
+    tokens: list[str]
+
+
+def group_args(args: list[str]) -> list[Arg]:
+    grouped: list[Arg] = []
+    values = {
+        index + 1
+        for index, token in enumerate(args[:-1])
+        if flag_name(token) is not None
+        and "=" not in token
+        and not args[index + 1].startswith("-")
+    }
+    for index, token in enumerate(args):
+        name = flag_name(token)
+        if index in values:
+            continue
+        if name is None:
+            grouped.append(Arg(None, None, [token]))
+        elif "=" in token:
+            grouped.append(Arg(name, token.partition("=")[2], [token]))
+        elif index + 1 in values:
+            grouped.append(Arg(name, args[index + 1], [token, args[index + 1]]))
+        else:
+            grouped.append(Arg(name, None, [token]))
+    return grouped

labnotes-0.2.1/src/labnotes/runner/override_flags.py

@@ -0,0 +1,21 @@
+import shlex
+
+from labnotes.runner.command_flags import command_flags
+from labnotes.runner.group_args import group_args
+
+
+def override_flags(command: str, args: list[str]) -> tuple[str, list[str]]:
+    flags = {flag.name: flag for flag in command_flags(command)}
+    replaced: list[tuple[int, int, str]] = []
+    rest: list[str] = []
+    for arg in group_args(args):
+        flag = flags.get(arg.name) if arg.name is not None else None
+        if flag is None:
+            rest += arg.tokens
+        elif arg.value is not None:
+            separator = "=" if flag.joined else " "
+            text = f"--{arg.name}{separator}{shlex.quote(arg.value)}"
+            replaced.append((flag.start, flag.end, text))
+    for start, end, text in sorted(replaced, reverse=True):
+        command = command[:start] + text + command[end:]
+    return command, rest

{labnotes-0.1.2 → labnotes-0.2.1}/src/labnotes/runner/placeholders.py

@@ -1,2 +1 @@
 PLACEHOLDERS = ("run_dir", "invocation_dir")
-HOOK_PLACEHOLDERS = ("invocation_dir",)

{labnotes-0.1.2 → labnotes-0.2.1}/src/labnotes/runner/run_experiment.py

@@ -16,10 +16,10 @@ from labnotes.models import (
     Report,
 )
 from labnotes.retries import RETRY_EXIT_CODE, RETRY_SECONDS
+from labnotes.runner.check_hook_placeholders import check_hook_placeholders
 from labnotes.runner.execute_run import execute_run
 from labnotes.runner.fill_experiment_env import fill_experiment_env
 from labnotes.runner.fill_dirs import fill_dirs
-from labnotes.runner.hook_dirs import hook_dirs
 from labnotes.runner.in_subset import in_subset
 from labnotes.runner.invocation_hook import invocation_hook
 from labnotes.runner.invocation_meta import invocation_meta
@@ -101,21 +101,21 @@ async def run_experiment(
         "teardown": experiment.teardown,
         "meta": experiment.meta,
     }
-    dirs = hook_dirs(hooks, group_dir, run_dirs)
+    check_hook_placeholders(hooks)
     hook_env = {
-        hook: fill_experiment_env(
-            experiment.env, inherited, dirs, hook=hook, runs=len(plan)
-        )
+        hook: fill_experiment_env(experiment.env, inherited, {})
         for hook, command in hooks.items()
         if command is not None
     }
     meta = None
     if experiment.meta is not None:
-        meta = await invocation_meta(
-            command_root, fill_dirs(experiment.meta, dirs), hook_env["meta"]
-        )
-    if dirs:
-        Path(dirs["invocation_dir"]).mkdir(parents=True, exist_ok=True)
+        meta = await invocation_meta(command_root, experiment.meta, hook_env["meta"])
+    invocation_dir = group_dir
+    match run_dirs:
+        case [run_dir]:
+            invocation_dir = run_dir
+    if invocation_dir is not None:
+        Path(invocation_dir).mkdir(parents=True, exist_ok=True)
     runs = [{"run": run, "params": params} for run, params in plan]
     report(
         {
@@ -248,7 +248,7 @@ async def run_experiment(
         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())
+        run_invocation_dir = invocation_dir or str(folder.resolve())
         report({"event": "started", "run": run, "params": params, "folder": folder})
         running[run] = set()
         trees[run] = set()
@@ -303,14 +303,14 @@ async def run_experiment(
             await invocation_hook(
                 command_root,
                 "teardown",
-                fill_dirs(experiment.teardown, dirs),
+                experiment.teardown,
                 hook_env["teardown"],
             )
 
     listen(Controls(interrupt, set_concurrency, kill, finish))
     with (
-        nullcontext(dirs["invocation_dir"])
-        if dirs
+        nullcontext(invocation_dir)
+        if invocation_dir is not None
         else TemporaryDirectory(prefix="labnotes-state-")
     ) as state_dir:
         state_file = Path(state_dir) / "state.json"
@@ -324,7 +324,7 @@ async def run_experiment(
                 await invocation_hook(
                     command_root,
                     "setup",
-                    fill_dirs(experiment.setup, dirs),
+                    experiment.setup,
                     hook_env["setup"],
                 )
             fill()

{labnotes-0.1.2 → labnotes-0.2.1}/src/labnotes/runner/shell_command.py

@@ -2,6 +2,7 @@ import shlex
 from collections.abc import Sequence
 from pathlib import Path
 
+from labnotes.runner.override_flags import override_flags
 from labnotes.runner.param_args import param_args
 
 
@@ -9,4 +10,5 @@ def shell_command(
     command: str, folder: Path, params: dict[str, object], args: Sequence[str] = ()
 ) -> str:
     filled = command.replace("{run_dir}", shlex.quote(str(folder)))
-    return f"{filled} {shlex.join([*param_args(params), *args])}".rstrip()
+    overridden, rest = override_flags(filled, list(args))
+    return f"{overridden} {shlex.join([*param_args(params), *rest])}".rstrip()

labnotes-0.1.2/src/labnotes/runner/check_args.py

@@ -1,15 +0,0 @@
-import shlex
-
-from labnotes.runner.flag_name import flag_name
-
-
-def check_args(params: dict[str, list[object]], command: str, args: list[str]) -> None:
-    taken = {flag_name(token) for token in shlex.split(command)}
-    for arg in args:
-        name = flag_name(arg)
-        if name is None:
-            continue
-        if name in params:
-            raise ValueError(f"--{name} is a param. Pick it with --{name}=VALUE.")
-        if name in taken:
-            raise ValueError(f"--{name} is already in the command.")

labnotes-0.1.2/src/labnotes/runner/fill_experiment_env.py

@@ -1,34 +0,0 @@
-from collections.abc import Mapping
-
-from labnotes.runner.fill_dirs import fill_dirs
-from labnotes.runner.placeholders import HOOK_PLACEHOLDERS, PLACEHOLDERS
-
-
-def fill_experiment_env(
-    configured: Mapping[str, str],
-    inherited: Mapping[str, str],
-    dirs: Mapping[str, str],
-    *,
-    hook: str | None = None,
-    runs: int = 1,
-) -> dict[str, str]:
-    caller = {
-        key: value
-        for key, value in inherited.items()
-        if not key.startswith("LABNOTES_")
-    }
-    filled: dict[str, str] = {}
-    for key, value in configured.items():
-        if key in caller:
-            continue
-        used = [name for name in PLACEHOLDERS if f"{{{name}}}" in value]
-        if hook is not None and any(name not in HOOK_PLACEHOLDERS for name in used):
-            continue
-        for name in used:
-            if name not in dirs:
-                raise ValueError(
-                    f"{hook} env.{key} uses {{{name}}}, but this invocation plans "
-                    f"{runs} runs. {{{name}}} needs exactly one run in this mode."
-                )
-        filled[key] = fill_dirs(value, dirs, quote=False)
-    return {**filled, **caller}

labnotes-0.1.2/src/labnotes/runner/hook_dirs.py

@@ -1,21 +0,0 @@
-def hook_dirs(
-    hooks: dict[str, str | None], invocation_dir: str | None, run_dirs: list[str]
-) -> dict[str, str]:
-    match run_dirs:
-        case [run_dir]:
-            invocation_dir = invocation_dir or run_dir
-    available = {"invocation_dir": invocation_dir} if invocation_dir is not None else {}
-    for hook, command in hooks.items():
-        if command is None:
-            continue
-        if "{run_dir}" in command:
-            raise ValueError(
-                f"{hook} command {command} uses {{run_dir}}; "
-                "use {invocation_dir} instead."
-            )
-        if "{invocation_dir}" in command and invocation_dir is None:
-            raise ValueError(
-                f"{hook} command {command} uses {{invocation_dir}}, but this "
-                f"invocation plans {len(run_dirs)} runs and has no shared folder."
-            )
-    return available