labnotes 0.2.7__tar.gz → 0.2.9__tar.gz

{labnotes-0.2.7 → labnotes-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.2.7
+Version: 0.2.9
 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>
@@ -79,7 +79,8 @@ labnotes experiments foo runs   # foo's runs, oldest first
 Each takes `--format table` or `--format json`, which print rows and exit.
 Without `--format`, they open a browser in a terminal: the experiment list,
 Enter to open one, Escape to go back. `foo` and `foo runs` open straight on
-`foo`, which shows its runs grouped by invocation; Enter expands or collapses
+`foo`, which shows its runs, with runs that older versions nested in one invocation
+folder grouped under it; Enter expands or collapses
 one. Piped, they print a table.
 
 `labnotes experiments new [NAME]` creates an experiment folder with a starter
@@ -96,6 +97,7 @@ experiments folder:
 name = "Model and effort"
 command = "uv run scripts/study.py --output {run_dir}"
 repeats = 5
+continues = false
 
 [params]
 model = ["opus", "sonnet"]
@@ -107,6 +109,8 @@ and as `display_name` in `experiments`. The folder name stays the key, so
 renaming the experiment means editing `name`.
 Each combination of `[params]` runs `repeats` times, round-robin. Only runs
 that exit 0 count, so running again fills in what failed or never ran.
+`continues` is required: `true` invokes a failed run again in its own folder,
+`false` gives its combination a new one.
 Each run gets a new run folder. `command` runs in a shell from the root, with
 `{run_dir}` replaced by the run folder's absolute path. Pass it to the
 script so it writes its outputs there.

{labnotes-0.2.7 → labnotes-0.2.9}/README.md

@@ -53,7 +53,8 @@ labnotes experiments foo runs   # foo's runs, oldest first
 Each takes `--format table` or `--format json`, which print rows and exit.
 Without `--format`, they open a browser in a terminal: the experiment list,
 Enter to open one, Escape to go back. `foo` and `foo runs` open straight on
-`foo`, which shows its runs grouped by invocation; Enter expands or collapses
+`foo`, which shows its runs, with runs that older versions nested in one invocation
+folder grouped under it; Enter expands or collapses
 one. Piped, they print a table.
 
 `labnotes experiments new [NAME]` creates an experiment folder with a starter
@@ -70,6 +71,7 @@ experiments folder:
 name = "Model and effort"
 command = "uv run scripts/study.py --output {run_dir}"
 repeats = 5
+continues = false
 
 [params]
 model = ["opus", "sonnet"]
@@ -81,6 +83,8 @@ and as `display_name` in `experiments`. The folder name stays the key, so
 renaming the experiment means editing `name`.
 Each combination of `[params]` runs `repeats` times, round-robin. Only runs
 that exit 0 count, so running again fills in what failed or never ran.
+`continues` is required: `true` invokes a failed run again in its own folder,
+`false` gives its combination a new one.
 Each run gets a new run folder. `command` runs in a shell from the root, with
 `{run_dir}` replaced by the run folder's absolute path. Pass it to the
 script so it writes its outputs there.

labnotes-0.2.9/src/labnotes/config_migration.py

@@ -0,0 +1,12 @@
+MIGRATION = (
+    "https://github.com/thekevinscott/labnotes/blob/main/"
+    "docs/migrations.d/2026-11-02-python-remove-modes.md"
+)
+REMOVED_MODE = (
+    "mode was removed: every experiment plans what it is missing. "
+    f"Delete mode. See {MIGRATION}"
+)
+MISSING_CONTINUES = (
+    "continues is required: set continues = true or continues = false. "
+    f"See {MIGRATION}"
+)

{labnotes-0.2.7 → labnotes-0.2.9}/src/labnotes/context.md

@@ -55,6 +55,7 @@ experiments folder:
 name = "Model and effort"
 command = "uv run scripts/study.py --output {run_dir}"
 repeats = 5
+continues = false
 
 [params]
 model = ["opus", "sonnet"]
@@ -64,22 +65,26 @@ effort = ["low", "high"]
 `name` is optional: a display name for the experiment, shown in the live view
 and as `display_name` in `experiments`. The folder name stays the key, so
 renaming the experiment means editing `name`.
-Each combination of `[params]` runs `repeats` times (1 if omitted), round-robin, on every
-`run`, whatever is already on disk. That is `mode = "adhoc"`, the default.
-`mode = "matrix"` counts what is there: only runs that count fill a combination,
-so running again fills in what failed or never ran. `mode` under
-`[experiments]` in `.labnotes.toml` sets it for every experiment that doesn't
-set its own.
-Each run gets a new run folder. In `matrix` mode it is named for the UTC time it was planned
-(`runs/20261020-000429-brave-fox`). In `adhoc` mode a `run` command that plans one run names
-its folder the same way. One that plans more gets one folder named that way, and its runs nest
-inside it (`runs/20261020-000429-brave-fox/quiet-river`); the run id is that path under `runs/`. Either way, folder listings sort by start. `command` runs in a shell from the root, with
+Each combination of `[params]` needs `repeats` runs that count (1 if omitted).
+`run` plans only the combinations short of that, round-robin, so running again
+fills in what failed or never ran, and a finished experiment plans nothing
+(`Nothing to run: every combination has its repeats.`). To start over, copy it
+with `experiments new NAME --from OLD`, which drops `mode` and fills in
+`continues`. `mode` is gone; setting it is a config error.
+`continues` is required, in `experiment.toml` or `[experiment]` in
+`.labnotes.toml`. `continues = true` invokes a failed, stopped or lost run again
+in its own folder, with the same params and `{run_dir}`; `run.json` then lists
+each attempt under `"invocations"`. `continues = false` gives the combination a
+new folder. Never delete `run.json`, `stdout-*`, `stderr-*` or `run.lock` from a
+run folder.
+Each new run gets a run folder named for the UTC time it was planned
+(`runs/20261020-000429-brave-fox`), so folder listings sort by start. Older
+versions nested several runs in one invocation folder
+(`runs/20261020-000429-brave-fox/quiet-river`, run id is that path); those still
+list and count. Only one `run` of an experiment goes at a time; a second refuses. `command` runs in a shell from the root, with
 `{run_dir}` replaced by the run folder's absolute path. Pass it to the
-script so it writes its outputs there. `{invocation_dir}` is the shared adhoc
-group folder's absolute path when several runs are planned. With one planned
-run it stays at the first attempt's folder across retries, while `{run_dir}`
-changes per attempt. With several matrix runs, it equals each run's `{run_dir}`.
-Both placeholders are shell-quoted.
+script so it writes its outputs there. `{invocation_dir}` is the same
+folder as `{run_dir}`. Both placeholders are shell-quoted.
 Each param is appended as `--name value`, with the name as written (use
 `source-language` for a `--source-language` flag), booleans as 0 or 1, and lists
 and tables as JSON. labnotes writes `run.json` (params, `command`, created,
@@ -114,9 +119,7 @@ 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 `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
+pointing to 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`.
 Nested labnotes invocations clear inherited `LABNOTES_*` context for their
@@ -182,7 +185,7 @@ Escape clears it. `x` stops the
 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
+they're written, and Escape returns to the table. A `run` that
 plans a single run opens straight on its output. `q` quits and leaves the runs
 going. Elsewhere, it prints a line per event instead.
 
@@ -218,4 +221,4 @@ going. Elsewhere, it prints a line per event instead.
   was retried counts as retried, not failed. If it can't
   start a run, it prints the cause on one line and exits 1.
 
-`uvx labnotes server` serves the experiments, their markdown files and their runs as a local site, read from the same `.labnotes.toml`. An experiment's page shows its `experiment.toml` on one line, then a Runs tab with a table of its runs and a Notebooks tab with one tab per markdown file. For a matrix experiment, the Runs tab also has a grid (`?view=grid`): one cell per combination of the params that vary, with how many runs count toward `repeats`. Clicking a run opens its `stdout.log` and `stderr.log` together, followed as they're written until the run ends.
+`uvx labnotes server` serves the experiments, their markdown files and their runs as a local site, read from the same `.labnotes.toml`. An experiment's page shows its `experiment.toml` on one line, then a Runs tab with a table of its runs and a Notebooks tab with one tab per markdown file. The Runs tab also has a grid (`?view=grid`): one cell per combination of the params that vary, with how many runs count toward `repeats`. Clicking a run opens its `stdout.log` and `stderr.log` together, followed as they're written until the run ends.

{labnotes-0.2.7 → labnotes-0.2.9}/src/labnotes/create_app.py

@@ -63,7 +63,7 @@ def create_app(config: LabnotesConfig) -> Starlette:
             await kernel.stop()
 
     async def index(request: Request) -> Response:
-        experiments = await list_experiments(request.app.state.tables, config.mode)
+        experiments = await list_experiments(request.app.state.tables)
         return templates.TemplateResponse(
             request,
             "index.html",
@@ -75,7 +75,6 @@ def create_app(config: LabnotesConfig) -> Starlette:
         loaded = await load_experiment(
             request.app.state.tables,
             config.root,
-            config.mode,
             name,
             request.query_params,
             lambda note, content: saved_outputs(kernels.get((name, note)), content),

{labnotes-0.2.7 → labnotes-0.2.9}/src/labnotes/create_experiment.py

@@ -10,6 +10,8 @@ STARTER = """\
 # Runs from the project root. {run_dir} becomes the run's folder.
 command = "uv run script.py --output {run_dir}"
 repeats = 1
+# true: a failed run starts again in its own folder instead of a new one.
+continues = false
 
 # Each combination runs `repeats` times, passed as --name value.
 [params]
@@ -41,7 +43,8 @@ def create_experiment(
     path = folder(name)
     if path.exists():
         raise ValueError(f"{name} already exists at {path}.")
-    text = STARTER
+    inherited = config.defaults.get("continues") is True
+    text = STARTER.replace("continues = false", f"continues = {str(inherited).lower()}")
     if source is not None:
         origin = folder(source) / "experiment.toml"
         if not origin.is_file():
@@ -53,7 +56,7 @@ def create_experiment(
     else:
         path.mkdir(parents=True)
     (path / "experiment.toml").write_text(
-        experiment_definition(text, source, command, repeats, params or {}),
+        experiment_definition(text, source, command, repeats, params or {}, inherited),
         encoding="utf-8",
     )
     return path

{labnotes-0.2.7 → labnotes-0.2.9}/src/labnotes/experiment_definition.py

@@ -7,13 +7,17 @@ def experiment_definition(
     command: str | None,
     repeats: int | None,
     params: dict[str, list[object]],
+    continues: bool = False,
 ) -> str:
     document = tomlkit.parse(text)
     document.pop("from", None)
+    document.pop("mode", None)
     if command is not None:
         document["command"] = command
     if repeats is not None:
         document["repeats"] = repeats
+    if "continues" not in document:
+        document["continues"] = continues
     if params:
         table = document.setdefault("params", tomlkit.table())
         for name, values in params.items():

{labnotes-0.2.7 → labnotes-0.2.9}/src/labnotes/list_experiments.py

@@ -9,7 +9,7 @@ from labnotes.experiment_runs import experiment_runs
 from labnotes.summarize_config import summarize_config
 
 
-async def list_experiments(tables: DirSQL, mode: str) -> list[dict[str, object]]:
+async def list_experiments(tables: DirSQL) -> list[dict[str, object]]:
     rows = await tables.query(
         "SELECT name, display_name, config FROM experiments ORDER BY name"
     )
@@ -17,7 +17,7 @@ async def list_experiments(tables: DirSQL, mode: str) -> list[dict[str, object]]
     for row in rows:
         name = str(row["name"])
         config = None if row["config"] is None else json.loads(str(row["config"]))
-        summary = summarize_config(config, mode)
+        summary = summarize_config(config)
         varies = cast(dict[str, list[object]], summary["varies"])
         source = experiment_runs(name, list(varies))
         summary = await check_counts(tables, source, summary)

{labnotes-0.2.7 → labnotes-0.2.9}/src/labnotes/load_experiment.py

@@ -19,9 +19,11 @@ from labnotes.parse_run_view import parse_run_view
 from labnotes.pivot_runs import pivot_runs
 from labnotes.python_blocks import python_blocks
 from labnotes.render_markdown import render_markdown
+from labnotes.run_columns import run_columns
 from labnotes.runs_view_command import runs_view_command
 from labnotes.sort_href import sort_href
 from labnotes.sql_quote import quote_string
+from labnotes.view_specs import view_specs
 from labnotes.summarize_config import summarize_config
 from labnotes.utils.process_alive import process_alive
 
@@ -33,7 +35,6 @@ def _no_outputs(note: str, content: str) -> Sequence[str]:
 async def load_experiment(
     tables: DirSQL,
     root: Path,
-    mode: str,
     name: str,
     params: QueryParams,
     outputs_for: Callable[[str, str], Sequence[str]] = _no_outputs,
@@ -46,11 +47,11 @@ async def load_experiment(
         return None
     [row] = found
     config = None if row["config"] is None else json.loads(str(row["config"]))
-    summary = summarize_config(config, mode)
+    summary = summarize_config(config)
     varies = cast(dict[str, list[object]], summary["varies"])
     source = experiment_runs(name, list(varies))
     summary = await check_counts(tables, source, summary)
-    shown = ["id", *(key for key in varies if key != "id"), "started", "duration"]
+    shown = run_columns(config)
     choices = {
         key: {format_value(value): json.dumps(value) for value in values}
         for key, values in varies.items()
@@ -71,15 +72,16 @@ async def load_experiment(
             pid, created if isinstance(created, int | float) else None
         )
 
-    runs_live = any(is_running(run) for run in runs)
-    nested = summary["mode"] == "adhoc" and await nests_runs(tables, source)
+    for run in runs:
+        run["labnotes_running"] = is_running(run)
+    runs_live = any(run["labnotes_running"] for run in runs)
+    nested = await nests_runs(tables, source)
     groups = (
         group_runs(runs, list(choices), await count_groups(tables, source))
         if nested
         else None
     )
-    matrix = summary["mode"] == "matrix"
-    gridded = matrix and params.getlist("view")[-1:] == ["grid"]
+    gridded = params.getlist("view")[-1:] == ["grid"]
     axes = {key: varies[key] for key in choices if len(varies[key]) > 1}
     grid = (
         pivot_runs(
@@ -94,6 +96,7 @@ async def load_experiment(
     return {
         "name": row["name"],
         "display_name": row["display_name"],
+        "config": config,
         "config_source": row["source"],
         "counts_set": "counts" in (config or {}),
         **summary,
@@ -117,6 +120,7 @@ async def load_experiment(
         "run_view": view,
         "run_choices": choices,
         "runs_view": runs_view_command(config),
+        "views": view_specs(config),
         "sort_hrefs": {
             column: sort_href(view, column) for column in ["status", *shown]
         },

{labnotes-0.2.7 → labnotes-0.2.9}/src/labnotes/models.py

@@ -5,7 +5,6 @@ from typing import Any, Protocol
 
 from labnotes.default_counts import DEFAULT_COUNTS
 from labnotes.memory_interval import DEFAULT_MEMORY_INTERVAL
-from labnotes.modes import DEFAULT_MODE
 from labnotes.retries import DEFAULT_RETRIES
 
 Report = Callable[[dict[str, object]], None]
@@ -43,7 +42,6 @@ class LabnotesConfig:
     experiments: str
     files: str
     runs: str
-    mode: str = DEFAULT_MODE
     concurrency: int = 1
     retries: int = DEFAULT_RETRIES
     # Set when the config's folder is itself the one experiment.
@@ -59,7 +57,6 @@ class ExperimentConfig:
     params: dict[str, list[object]]
     name: str | None = None
     counts: str = DEFAULT_COUNTS
-    mode: str = DEFAULT_MODE
     concurrency: int = 1
     retries: int = DEFAULT_RETRIES
     meta: str | None = None

labnotes-0.2.9/src/labnotes/param_names.py

@@ -0,0 +1,9 @@
+from collections.abc import Mapping
+from typing import cast
+
+from labnotes.summarize_config import summarize_config
+
+
+def param_names(config: Mapping[str, object] | None) -> list[str]:
+    summary = summarize_config(None if config is None else dict(config))
+    return [key for key in cast(dict[str, object], summary["varies"]) if key != "id"]

{labnotes-0.2.7 → labnotes-0.2.9}/src/labnotes/read_config.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from labnotes.models import LabnotesConfig
 from labnotes.is_non_negative_int import is_non_negative_int
 from labnotes.is_positive_int import is_positive_int
-from labnotes.modes import DEFAULT_MODE, MODES
+from labnotes.config_migration import REMOVED_MODE
 from labnotes.runner.read_experiment_config import SETTINGS
 from labnotes.read_path import DEFAULT_PATHS, read_path
 from labnotes.retries import DEFAULT_RETRIES
@@ -25,6 +25,8 @@ def read_config(path: Path) -> LabnotesConfig:
     defaults = values.get("experiment", {})
     if not isinstance(defaults, dict):
         raise ValueError(f"{path}: experiment must be a table, like [experiment]")
+    if "mode" in defaults:
+        raise ValueError(f"{path}: [experiment] {REMOVED_MODE}")
     unknown = sorted(defaults.keys() - SETTINGS)
     if unknown:
         raise ValueError(f"{path}: unknown keys in [experiment]: {', '.join(unknown)}")
@@ -39,9 +41,8 @@ def read_config(path: Path) -> LabnotesConfig:
         table: read_path(path, table, values.get(table, {}), single=single)
         for table in DEFAULT_PATHS
     }
-    mode = experiments.get("mode", DEFAULT_MODE)
-    if mode not in MODES:
-        raise ValueError(f"{path}: [experiments] mode must be matrix or adhoc")
+    if "mode" in experiments:
+        raise ValueError(f"{path}: [experiments] {REMOVED_MODE}")
     concurrency = experiments.get("concurrency", 1)
     if not is_positive_int(concurrency):
         raise ValueError(
@@ -54,7 +55,6 @@ def read_config(path: Path) -> LabnotesConfig:
         path.resolve(),
         root,
         **paths,
-        mode=mode,
         concurrency=concurrency,
         retries=retries,
         experiment=root.name if single else None,

labnotes-0.2.9/src/labnotes/run_columns.py

@@ -0,0 +1,7 @@
+from collections.abc import Mapping
+
+from labnotes.param_names import param_names
+
+
+def run_columns(config: Mapping[str, object] | None) -> list[str]:
+    return ["id", *param_names(config), "started", "duration"]

{labnotes-0.2.7 → labnotes-0.2.9}/src/labnotes/runner/describe_event.py

@@ -7,6 +7,8 @@ def describe_event(event: dict[str, object]) -> str:
     match event["event"]:
         case "planned":
             runs = len(event["runs"])  # type: ignore[arg-type]
+            if not runs:
+                return "Nothing to run: every combination has its repeats."
             return f"{runs} runs to go, {event['concurrency']} at a time."
         case "started":
             args = " ".join(param_args(event["params"]))  # type: ignore[arg-type]

labnotes-0.2.9/src/labnotes/runner/hold_experiment.py

@@ -0,0 +1,29 @@
+import fcntl
+import os
+from collections.abc import Iterator
+from contextlib import contextmanager, suppress
+
+from labnotes.models import LabnotesConfig
+from labnotes.runner.runs_parent import runs_parent
+
+
+@contextmanager
+def hold_experiment(config: LabnotesConfig, name: str) -> Iterator[None]:
+    folder = runs_parent(config.root, config.runs, name)
+    made = not folder.exists()
+    folder.mkdir(parents=True, exist_ok=True)
+    descriptor = os.open(folder, os.O_RDONLY)
+    try:
+        try:
+            fcntl.flock(descriptor, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except BlockingIOError:
+            raise ValueError(
+                f"{name} is already running in another labnotes run."
+                " Wait for it to finish, or stop it, then run again."
+            ) from None
+        yield
+    finally:
+        if made:
+            with suppress(OSError):
+                folder.rmdir()
+        os.close(descriptor)

{labnotes-0.2.7 → labnotes-0.2.9}/src/labnotes/runner/prepare_experiment.py

@@ -31,7 +31,6 @@ async def prepare_experiment(
     experiment = read_experiment_config(
         config.path if source is None else experiment_config,
         source or "",
-        config.mode,
         config.concurrency,
         config.retries,
         config.defaults,

{labnotes-0.2.7 → labnotes-0.2.9}/src/labnotes/runner/read_experiment_config.py

@@ -10,7 +10,7 @@ from labnotes.is_non_negative_int import is_non_negative_int
 from labnotes.is_non_negative_number import is_non_negative_number
 from labnotes.memory_interval import DEFAULT_MEMORY_INTERVAL
 from labnotes.is_positive_int import is_positive_int
-from labnotes.modes import MODES
+from labnotes.config_migration import MISSING_CONTINUES, REMOVED_MODE
 
 SETTINGS = {
     "name",
@@ -18,7 +18,6 @@ SETTINGS = {
     "repeats",
     "params",
     "counts",
-    "mode",
     "concurrency",
     "retries",
     "meta",
@@ -31,13 +30,12 @@ SETTINGS = {
     "from",
 }
 HOOKS = ("setup", "teardown")
-VIEWS = {"runs"}
+MAX_VIEWS = 8
 
 
 def read_experiment_config(
     path: Path,
     source: str,
-    mode: str,
     concurrency: int,
     retries: int,
     defaults: dict[str, object] | None = None,
@@ -47,6 +45,8 @@ def read_experiment_config(
     except tomllib.TOMLDecodeError as error:
         raise ValueError(f"{path}: {error}") from error
     values: dict[str, Any] = compose_experiment(defaults or {}, layer)
+    if "mode" in values:
+        raise ValueError(f"{path}: {REMOVED_MODE}")
     unknown = sorted(values.keys() - SETTINGS)
     if unknown:
         raise ValueError(f"{path}: unknown keys {', '.join(unknown)}")
@@ -72,9 +72,6 @@ def read_experiment_config(
     counts = values.get("counts", DEFAULT_COUNTS)
     if not isinstance(counts, str) or not counts.strip():
         raise ValueError(f"{path}: counts must be a SQL condition")
-    mode = values.get("mode", mode)
-    if mode not in MODES:
-        raise ValueError(f"{path}: mode must be matrix or adhoc")
     concurrency = values.get("concurrency", concurrency)
     if not is_positive_int(concurrency):
         raise ValueError(f"{path}: concurrency must be a positive integer")
@@ -102,27 +99,32 @@ def read_experiment_config(
             raise ValueError(f"{path}: env.{key} is reserved for labnotes")
         if not isinstance(value, str):
             raise ValueError(f"{path}: env.{key} must be a string")
-    continues = values.get("continues", False)
+    if "continues" not in values:
+        raise ValueError(f"{path}: {MISSING_CONTINUES}")
+    continues = values["continues"]
     if not isinstance(continues, bool):
         raise ValueError(f"{path}: continues must be true or false")
-    if continues and mode != "matrix":
-        raise ValueError(f'{path}: continues needs mode = "matrix"')
     views = values.get("views", {})
     if not isinstance(views, dict):
         raise ValueError(f"{path}: views must be a table, like [views]")
-    unknown = sorted(views.keys() - VIEWS)
-    if unknown:
-        raise ValueError(f"{path}: unknown keys in views: {', '.join(unknown)}")
     runs = views.get("runs")
     if runs is not None and (not isinstance(runs, str) or not runs.strip()):
         raise ValueError(f"{path}: views.runs must be a command")
+    shown = {name: spec for name, spec in views.items() if name != "runs"}
+    if len(shown) > MAX_VIEWS:
+        raise ValueError(f"{path}: views holds at most {MAX_VIEWS} views besides runs")
+    for name, spec in shown.items():
+        source, _, cls = spec.rpartition(":") if isinstance(spec, str) else ("", "", "")
+        if not source.strip() or not cls.strip():
+            raise ValueError(
+                f'{path}: views.{name} must be "path/to/file.py:ClassName"'
+            )
     return ExperimentConfig(
         command,
         repeats,
         params,
         name,
         counts,
-        mode,
         concurrency,
         retries,
         meta,