runops 0.2.0__py3-none-any.whl

runops/cli/create.py

@@ -0,0 +1,263 @@
+"""CLI commands for run and survey creation."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated, Any, Optional
+
+import typer
+
+from runops.core.actions import ActionStatus, execute_action
+from runops.core.case import JobData, load_case, resolve_case
+from runops.core.exceptions import SimctlError
+from runops.core.project import find_project_root, load_project
+from runops.core.survey import expand_survey, generate_display_name, load_survey
+
+
+def _echo_warnings(warnings: list[str], *, context: str = "") -> None:
+    """Print non-fatal validation warnings emitted during run creation."""
+    prefix = f"{context}: " if context else ""
+    for warning in warnings:
+        typer.echo(f"  Warning: {prefix}{warning}", err=True)
+
+
+def create(
+    case_name: Annotated[
+        str,
+        typer.Argument(
+            help="Case name to create a run from.",
+        ),
+    ],
+    dest: Annotated[
+        Optional[Path],
+        typer.Option("--dest", "-d", help="Destination directory (defaults to cwd)."),
+    ] = None,
+) -> None:
+    """Create a run in the current directory.
+
+    Examples:
+      cd runs/experiment && runops runs create flat_surface
+    """
+    target_dir = (dest or Path.cwd()).resolve()
+
+    if case_name == "survey" and (target_dir / "survey.toml").is_file():
+        typer.echo(
+            "Error: 'runops runs create survey' has been removed. "
+            "Use 'runops runs sweep [DIR]' instead.",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+    _create_single(case_name, target_dir)
+
+
+def _create_single(case_name: str, target_dir: Path) -> None:
+    """Create a single run from a case template."""
+    try:
+        project_root = find_project_root(target_dir)
+        result = execute_action(
+            "create_run",
+            project_root=project_root,
+            case_name=case_name,
+            dest_dir=target_dir,
+        )
+    except SimctlError as exc:
+        typer.echo(f"Error creating run: {exc}", err=True)
+        raise typer.Exit(code=1) from exc
+
+    if result.status is not ActionStatus.SUCCESS:
+        typer.echo(f"Error creating run: {result.message}", err=True)
+        raise typer.Exit(code=1)
+
+    _echo_warnings(list(result.data.get("warnings", [])))
+    typer.echo(f"Created run: {result.data.get('run_id', '???')}")
+    typer.echo(f"  Path: {result.data.get('run_dir', target_dir)}")
+
+
+def _create_survey(survey_dir: Path) -> None:
+    """Expand survey.toml into multiple runs."""
+    try:
+        project_root = find_project_root(survey_dir)
+        result = execute_action(
+            "create_survey",
+            project_root=project_root,
+            survey_dir=survey_dir,
+        )
+    except SimctlError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        raise typer.Exit(code=1) from exc
+
+    if result.status is not ActionStatus.SUCCESS:
+        typer.echo(f"Error: {result.message}", err=True)
+        raise typer.Exit(code=1)
+
+    created_runs = list(result.data.get("runs", []))
+    if not created_runs:
+        typer.echo("No parameter combinations to expand.")
+        raise typer.Exit(code=0)
+
+    for created_run in created_runs:
+        _echo_warnings(
+            list(created_run.get("warnings", [])),
+            context=str(created_run.get("display_name", "")),
+        )
+
+    typer.echo(f"Created {len(created_runs)} runs in {survey_dir}")
+    for created_run in created_runs:
+        display_name = str(created_run.get("display_name", ""))
+        name_part = f" ({display_name})" if display_name else ""
+        typer.echo(f"  {created_run.get('run_id', '???')}{name_part}")
+
+
+def sweep(
+    survey_dir: Annotated[
+        Optional[Path],
+        typer.Argument(help="Directory containing survey.toml (defaults to cwd)."),
+    ] = None,
+    dry_run: Annotated[
+        bool,
+        typer.Option(
+            "--dry-run",
+            "-n",
+            help=(
+                "Print the runs that would be generated (count, parameter "
+                "combinations, estimated total resource cost) without "
+                "writing any files."
+            ),
+        ),
+    ] = False,
+) -> None:
+    """Generate all runs from a survey.toml parameter sweep.
+
+    With ``--dry-run`` the survey is parsed and expanded but no run
+    directories are created — useful to verify the parameter combinations
+    and total resource cost before committing files / queue time.
+    """
+    target = (survey_dir or Path.cwd()).resolve()
+    if dry_run:
+        _sweep_dry_run(target)
+    else:
+        _create_survey(target)
+
+
+def _sweep_dry_run(survey_dir: Path) -> None:
+    """Print the planned runs without writing files."""
+    try:
+        survey_data = load_survey(survey_dir)
+    except SimctlError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        raise typer.Exit(code=1) from exc
+
+    try:
+        project_root = find_project_root(survey_dir)
+    except SimctlError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        raise typer.Exit(code=1) from exc
+
+    # Look up the base case so we can show the resolved job (the survey's
+    # own [job] block, when present, overrides the case's).
+    try:
+        project = load_project(project_root)
+        case_dir = resolve_case(survey_data.base_case, project.root_dir)
+        case_data = load_case(case_dir)
+    except SimctlError as exc:
+        typer.echo(f"Error resolving base case: {exc}", err=True)
+        raise typer.Exit(code=1) from exc
+
+    effective_job = survey_data.job if survey_data.job.partition else case_data.job
+
+    combinations = expand_survey(survey_data.axes, survey_data.linked)
+    if not combinations:
+        typer.echo("No parameter combinations to expand.")
+        raise typer.Exit(code=0)
+
+    n = len(combinations)
+    typer.echo(f"[dry-run] {n} runs would be created in {survey_dir}")
+    typer.echo(f"  base case  : {survey_data.base_case}")
+    typer.echo(f"  simulator  : {survey_data.simulator}")
+    typer.echo(f"  launcher   : {survey_data.launcher}")
+    if survey_data.naming_template:
+        typer.echo(f"  display    : {survey_data.naming_template}")
+    typer.echo(_format_job_summary(effective_job))
+    typer.echo(_format_resource_estimate(effective_job, n))
+
+    # Print one line per combination so the user can scan parameters.
+    typer.echo("")
+    typer.echo("Planned runs:")
+    for combo in combinations:
+        display_name = generate_display_name(survey_data.naming_template, combo)
+        params_str = _format_combo(combo)
+        if display_name:
+            typer.echo(f"  {display_name:<24} {params_str}")
+        else:
+            typer.echo(f"  {params_str}")
+
+
+def _format_combo(combo: dict[str, Any]) -> str:
+    """Format a combo dict as ``key1=value1, key2=value2``."""
+    parts = []
+    for key in sorted(combo.keys()):
+        value = combo[key]
+        # Truncate long lists for readability.
+        if isinstance(value, list) and len(value) > 4:
+            shown = f"[{value[0]}, ..., {value[-1]} ({len(value)} items)]"
+        else:
+            shown = repr(value)
+        parts.append(f"{key}={shown}")
+    return ", ".join(parts)
+
+
+def _format_job_summary(job: JobData) -> str:
+    """Format a JobData line for the dry-run output."""
+    if job.processes > 1 or job.threads > 1 or job.cores > 1:
+        # rsc-style site
+        return (
+            f"  job        : partition={job.partition or '(default)'} "
+            f"p={job.processes} t={job.threads} c={job.cores} "
+            f"walltime={job.walltime}"
+        )
+    return (
+        f"  job        : partition={job.partition or '(default)'} "
+        f"nodes={job.nodes} ntasks={job.ntasks} walltime={job.walltime}"
+    )
+
+
+def _format_resource_estimate(job: JobData, n_runs: int) -> str:
+    """Best-effort estimate of total core-hours for the planned sweep."""
+    # Pick the larger of (rsc processes) or (standard ntasks) so the
+    # estimate works regardless of which site mode the job uses.
+    cores_per_run = max(job.processes, job.ntasks)
+    walltime_hours = _walltime_to_hours(job.walltime)
+    if cores_per_run <= 1 or walltime_hours <= 0:
+        return "  estimate   : (cannot estimate — incomplete job spec)"
+    total_core_hours = cores_per_run * walltime_hours * n_runs
+    return (
+        f"  estimate   : {n_runs} runs x {cores_per_run} cores x "
+        f"{walltime_hours:.1f} h walltime ~= {total_core_hours:,.0f} core-hours"
+    )
+
+
+def _walltime_to_hours(walltime: str) -> float:
+    """Parse a walltime string to hours.  Returns 0.0 on failure."""
+    if not walltime:
+        return 0.0
+    # Strip optional ``D-`` day prefix.
+    days = 0
+    rest = walltime
+    if "-" in walltime:
+        head, _, rest = walltime.partition("-")
+        try:
+            days = int(head)
+        except ValueError:
+            return 0.0
+    parts = rest.split(":")
+    try:
+        if len(parts) == 3:
+            h, m, s = (int(p) for p in parts)
+        elif len(parts) == 2:
+            h, m, s = 0, int(parts[0]), int(parts[1])
+        else:
+            return 0.0
+    except ValueError:
+        return 0.0
+    return days * 24 + h + m / 60 + s / 3600

runops/cli/dashboard.py

@@ -0,0 +1,179 @@
+"""CLI command for the multi-run dashboard view."""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+
+from runops.cli.run_lookup import resolve_run_targets
+from runops.core.exceptions import SimctlError
+from runops.core.manifest import read_manifest
+
+
+def dashboard(
+    targets: Annotated[
+        Optional[list[str]],
+        typer.Argument(
+            help=(
+                "Run identifiers, run directories, or directories containing "
+                "runs (recursive).  Defaults to cwd / project runs/."
+            ),
+        ),
+    ] = None,
+    watch: Annotated[
+        Optional[float],
+        typer.Option(
+            "--watch",
+            "-w",
+            help=(
+                "Refresh the dashboard every N seconds (clears screen between "
+                "refreshes).  Press Ctrl-C to stop."
+            ),
+        ),
+    ] = None,
+    all_states: Annotated[
+        bool,
+        typer.Option(
+            "--all",
+            "-a",
+            help="Show all runs, not just the ones in submitted/running state.",
+        ),
+    ] = False,
+) -> None:
+    """Multi-run progress dashboard.
+
+    Aggregates per-run progress (state, step, %, last diagnostic) into a
+    single table.  Useful while a survey of dozens of runs is in flight:
+    instead of opening ``runops runs log`` for each run individually,
+    one ``runops runs dashboard`` call shows the whole survey.
+
+    Examples:
+      runops runs dashboard runs/series_A          # one survey
+      runops runs dashboard -w 30 runs/series_A    # auto-refresh every 30 s
+      runops runs dashboard --all runs/            # whole project, including
+                                                    # completed/failed runs
+    """
+    cwd = Path.cwd().resolve()
+    run_dirs = resolve_run_targets(targets, search_dir=cwd)
+
+    if watch is not None and watch > 0:
+        _watch_loop(run_dirs, all_states=all_states, interval=watch)
+    else:
+        _print_dashboard(run_dirs, all_states=all_states)
+
+
+def _print_dashboard(run_dirs: list[Path], *, all_states: bool) -> None:
+    """Render the dashboard table once."""
+    if not run_dirs:
+        typer.echo("No runs found.")
+        return
+
+    active_states = {"submitted", "running"}
+    rows: list[tuple[str, str, str, str, str, str]] = []
+
+    for run_dir in run_dirs:
+        try:
+            manifest = read_manifest(run_dir)
+        except SimctlError:
+            continue
+
+        status = str(manifest.run.get("status", "unknown"))
+        if not all_states and status not in active_states:
+            continue
+
+        run_id = str(manifest.run.get("id", run_dir.name))
+        display_name = str(manifest.run.get("display_name", ""))
+
+        step_str, pct_str = _progress_for_run(run_dir, manifest.simulator)
+
+        # Show the latest known Slurm state if recorded.
+        last_slurm = str(manifest.run.get("last_slurm_state", "")) or "-"
+
+        rows.append((run_id, display_name, status, step_str, pct_str, last_slurm))
+
+    if not rows:
+        typer.echo("No active runs found.")
+        return
+
+    # Sort by run_id for stable output.
+    rows.sort(key=lambda r: r[0])
+
+    headers = ("RUN_ID", "NAME", "STATE", "STEP", "%", "SLURM")
+    widths = [len(h) for h in headers]
+    for row in rows:
+        for i, cell in enumerate(row):
+            widths[i] = max(widths[i], len(cell))
+
+    fmt = "  ".join(f"{{:<{w}}}" for w in widths)
+    typer.echo(fmt.format(*headers))
+    typer.echo(fmt.format(*("-" * w for w in widths)))
+    for row in rows:
+        typer.echo(fmt.format(*row))
+
+    n_active = sum(1 for r in rows if r[2] in active_states)
+    typer.echo(f"\n{n_active} active, {len(rows)} total")
+
+
+def _progress_for_run(
+    run_dir: Path,
+    simulator: dict[str, str],
+) -> tuple[str, str]:
+    """Best-effort progress lookup for a single run.
+
+    Returns ``(step_str, pct_str)`` where each part is a short string
+    suitable for table cells.  Returns ``("-", "-")`` when the adapter
+    has no progress to report.
+    """
+    adapter_name = simulator.get("adapter", "") or simulator.get("name", "")
+    if not adapter_name:
+        return "-", "-"
+
+    try:
+        import runops.adapters  # noqa: F401  (registers adapters)
+        from runops.adapters.registry import get as get_adapter
+
+        adapter_cls = get_adapter(adapter_name)
+        adapter = adapter_cls()
+        summary = adapter.summarize(run_dir)
+    except Exception:
+        return "-", "-"
+
+    last_step = summary.get("last_step")
+    nstep = summary.get("nstep")
+    if last_step is None or not nstep:
+        return "-", "-"
+
+    pct = float(last_step) / float(nstep) * 100
+    return f"{int(last_step):d}/{int(nstep):d}", f"{pct:5.1f}%"
+
+
+def _watch_loop(
+    run_dirs: list[Path],
+    *,
+    all_states: bool,
+    interval: float,
+) -> None:
+    """Refresh the dashboard every ``interval`` seconds.
+
+    Stops cleanly on Ctrl-C.  Each refresh re-reads the manifests and
+    re-runs the per-run progress lookup, so newly-submitted or newly-
+    completed runs are picked up automatically.
+    """
+    from datetime import datetime
+
+    try:
+        while True:
+            typer.echo("\x1b[2J\x1b[H", nl=False)
+            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            typer.echo(
+                f"runops runs dashboard (watch every {interval:g}s) — {timestamp}"
+            )
+            typer.echo("")
+            _print_dashboard(run_dirs, all_states=all_states)
+            time.sleep(interval)
+    except KeyboardInterrupt:
+        typer.echo("\nStopped.")
+        raise typer.Exit(code=0) from None

runops/cli/extend.py

@@ -0,0 +1,204 @@
+"""CLI command for extending/continuing a simulation from a snapshot."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+from typing import Annotated, Any, Optional
+
+import typer
+
+from runops.cli.run_lookup import resolve_run_or_cwd
+from runops.core.discovery import collect_existing_run_ids
+from runops.core.exceptions import SimctlError
+from runops.core.manifest import ManifestData, read_manifest, write_manifest
+from runops.core.project import find_project_root, load_project
+from runops.core.run import create_run
+
+
+def extend(
+    run: Annotated[
+        Optional[str],
+        typer.Argument(help="Source run to continue from (defaults to cwd)."),
+    ] = None,
+    dest: Annotated[
+        Optional[Path],
+        typer.Option(
+            "--dest", "-d", help="Destination directory (defaults to source's parent)."
+        ),
+    ] = None,
+    nstep: Annotated[
+        Optional[int],
+        typer.Option("--nstep", help="Override total step count for continuation."),
+    ] = None,
+    submit: Annotated[
+        bool,
+        typer.Option("--run", help="Automatically submit the continuation run."),
+    ] = False,
+) -> None:
+    """Create a continuation run from a completed simulation's snapshot.
+
+    Copies input files, links snapshots, and updates restart parameters.
+    The adapter handles simulator-specific continuation setup.
+
+    Examples:
+      runops runs extend                      # continue cwd run
+      runops runs extend R0001 --nstep 200000 # continue with more steps
+      runops runs extend --run                # continue and submit
+    """
+    source_dir = resolve_run_or_cwd(run, search_dir=Path.cwd())
+
+    # Read source manifest
+    try:
+        source_manifest = read_manifest(source_dir)
+    except SimctlError as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(code=1) from None
+
+    source_id = source_manifest.run.get("id", source_dir.name)
+    source_status = source_manifest.run.get("status", "")
+
+    if source_status not in ("completed", "running", "failed"):
+        typer.echo(
+            f"Warning: source run {source_id} is '{source_status}'. "
+            "Continuation is typically from completed runs."
+        )
+
+    # Determine destination
+    target_dir = dest or source_dir.parent
+    target_dir = target_dir.resolve()
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    # Load project for adapter/launcher
+    try:
+        project_root = find_project_root(target_dir)
+        project = load_project(project_root)
+    except SimctlError as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(code=1) from None
+
+    # Get adapter
+    adapter_name = source_manifest.simulator.get("adapter", "")
+    if not adapter_name:
+        adapter_name = source_manifest.simulator.get("name", "")
+
+    try:
+        from runops.adapters.registry import get as get_adapter
+        from runops.adapters.registry import load_from_config
+
+        load_from_config(project.simulators)
+        adapter_cls = get_adapter(adapter_name)
+        adapter = adapter_cls()
+    except (KeyError, Exception) as e:
+        typer.echo(f"Error loading adapter '{adapter_name}': {e}", err=True)
+        raise typer.Exit(code=1) from None
+
+    # Collect existing run IDs
+    runs_dir = project_root / "runs"
+    existing_ids = collect_existing_run_ids(runs_dir)
+
+    # Create new run directory
+    params = dict(source_manifest.params_snapshot)
+    try:
+        run_info = create_run(
+            target_dir,
+            existing_ids,
+            display_name=f"extend_{source_id}",
+            params=params,
+        )
+    except SimctlError as e:
+        typer.echo(f"Error creating run: {e}", err=True)
+        raise typer.Exit(code=1) from None
+
+    new_dir = run_info.run_dir
+    new_input = new_dir / "input"
+    new_input.mkdir(parents=True, exist_ok=True)
+
+    # Copy input files from source
+    source_input = source_dir / "input"
+    if source_input.is_dir():
+        for item in source_input.iterdir():
+            dest_item = new_input / item.name
+            if item.is_file():
+                shutil.copy2(item, dest_item)
+            elif item.is_dir():
+                shutil.copytree(item, dest_item, dirs_exist_ok=True)
+
+    # Let adapter set up continuation (snapshot links, parameter updates)
+    continuation_info: dict[str, Any] = {}
+    if hasattr(adapter, "setup_continuation"):
+        try:
+            continuation_info = adapter.setup_continuation(
+                source_dir=source_dir,
+                new_dir=new_dir,
+                nstep_override=nstep,
+            )
+        except Exception as e:
+            typer.echo(f"Error in adapter continuation setup: {e}", err=True)
+            raise typer.Exit(code=1) from None
+
+    # Copy job script from source if exists
+    source_submit = source_dir / "submit"
+    new_submit = new_dir / "submit"
+    new_submit.mkdir(parents=True, exist_ok=True)
+    source_job = source_submit / "job.sh"
+    if source_job.is_file():
+        shutil.copy2(source_job, new_submit / "job.sh")
+
+    # Create work directory
+    (new_dir / "work").mkdir(exist_ok=True)
+
+    # Write manifest
+    new_manifest = ManifestData(
+        run={
+            "id": run_info.run_id,
+            "display_name": run_info.display_name,
+            "status": "created",
+            "created_at": run_info.created_at,
+        },
+        path={"run_dir": str(new_dir)},
+        origin={
+            "case": source_manifest.origin.get("case", ""),
+            "survey": "",
+            "parent_run": source_id,
+        },
+        classification=dict(source_manifest.classification),
+        simulator=dict(source_manifest.simulator),
+        launcher=dict(source_manifest.launcher),
+        simulator_source=dict(source_manifest.simulator_source),
+        job={
+            "scheduler": "slurm",
+            "job_id": "",
+            "partition": source_manifest.job.get("partition", ""),
+            "nodes": source_manifest.job.get("nodes", 1),
+            "ntasks": source_manifest.job.get("ntasks", 1),
+            "walltime": source_manifest.job.get("walltime", "01:00:00"),
+            "submitted_at": "",
+        },
+        variation={"changed_keys": []},
+        params_snapshot=params,
+        files={
+            "input_dir": "input",
+            "submit_dir": "submit",
+            "work_dir": "work",
+            "analysis_dir": "analysis",
+            "status_dir": "status",
+        },
+    )
+    write_manifest(new_dir, new_manifest)
+
+    typer.echo(f"Created continuation run: {run_info.run_id}")
+    typer.echo(f"  Source: {source_id}")
+    typer.echo(f"  Path:   {new_dir}")
+    if continuation_info:
+        for key, val in continuation_info.items():
+            typer.echo(f"  {key}: {val}")
+
+    # Auto-submit if requested
+    if submit:
+        from runops.cli.submit import _submit_single_run
+
+        job_id = _submit_single_run(new_dir)
+        if job_id is None:
+            typer.echo("Warning: auto-submit failed")
+            raise typer.Exit(code=1)