adagio-cli 0.1.0__py3-none-any.whl

adagio/__init__.py

@@ -0,0 +1,15 @@
+from importlib.metadata import PackageNotFoundError, version
+
+
+def _resolve_version() -> str:
+    for dist_name in ("adagio-cli", "adagio"):
+        try:
+            return version(dist_name)
+        except PackageNotFoundError:
+            continue
+    return "0.0.0"
+
+
+__version__ = _resolve_version()
+
+__all__ = ["__version__"]

adagio/app/parsers/pipeline.py

@@ -0,0 +1,89 @@
+"""Helpers for pulling promoted parameter specs from pipeline JSON."""
+
+from typing import Any, List, Optional
+from uuid import UUID
+
+from pydantic import BaseModel
+
+
+class Parameter(BaseModel):
+    id: UUID
+    name: str
+    required: bool
+    default: Optional[Any] = None
+    type: str
+    description: Optional[str] = None
+
+
+class Input(BaseModel):
+    id: UUID
+    name: str
+    required: bool
+    type: str
+    description: Optional[str] = None
+
+
+class Output(BaseModel):
+    id: UUID
+    name: str
+    type: str
+    description: Optional[str] = None
+
+
+def _extract_signature(data: Any) -> dict[str, Any]:
+    signature = (
+        data.get("spec", {}).get("signature")
+        if isinstance(data, dict)
+        else None
+    ) or (data.get("signature") if isinstance(data, dict) else None)
+
+    if not isinstance(signature, dict):
+        raise ValueError(
+            "Invalid pipeline: missing 'signature' section in pipeline JSON."
+        )
+
+    return signature
+
+
+def parse_parameters(data: Any) -> List[Parameter]:
+    """Parse promoted parameters from supported pipeline JSON layouts.
+
+    We currently accept either:
+    - {"spec": {"signature": {"parameters": [...]}}}
+    - {"signature": {"parameters": [...]} }
+    """
+    signature = _extract_signature(data)
+
+    raw_parameters = signature.get("parameters")
+    if not isinstance(raw_parameters, list):
+        raise ValueError(
+            "Invalid pipeline: missing 'signature.parameters' list in pipeline JSON."
+        )
+
+    return [Parameter(**param) for param in raw_parameters]
+
+
+def parse_inputs(data: Any) -> List[Input]:
+    """Parse promoted inputs from supported pipeline JSON layouts."""
+    signature = _extract_signature(data)
+
+    raw_inputs = signature.get("inputs")
+    if not isinstance(raw_inputs, list):
+        raise ValueError(
+            "Invalid pipeline: missing 'signature.inputs' list in pipeline JSON."
+        )
+
+    return [Input(**input_item) for input_item in raw_inputs]
+
+
+def parse_outputs(data: Any) -> List[Output]:
+    """Parse pipeline outputs from supported pipeline JSON layouts."""
+    signature = _extract_signature(data)
+
+    raw_outputs = signature.get("outputs")
+    if not isinstance(raw_outputs, list):
+        raise ValueError(
+            "Invalid pipeline: missing 'signature.outputs' list in pipeline JSON."
+        )
+
+    return [Output(**output_item) for output_item in raw_outputs]

adagio/check.py

@@ -0,0 +1,16 @@
+
+
+def check_dependencies(spec):
+    pass
+
+
+def check_version(spec):
+    pass
+
+
+def check_graph(spec):
+    pass
+
+
+def check_arguments(spec, arguments):
+    pass

adagio/cli/__init__.py

@@ -0,0 +1 @@
+__all__: list[str] = []

adagio/cli/args.py

@@ -0,0 +1,62 @@
+import re
+from enum import Enum
+
+try:
+    from enum import StrEnum
+except ImportError:  # pragma: no cover - Python < 3.11
+    class StrEnum(str, Enum):
+        pass
+
+
+class ParamType(StrEnum):
+    INPUT = "input"
+    PARAM = "param"
+    OUTPUT = "output"
+
+
+class ShowParamsMode(StrEnum):
+    ALL = "all"
+    MISSING = "missing"
+    REQUIRED = "required"
+
+
+def promote_positional_pipeline(argv: list[str]) -> tuple[list[str], str | None]:
+    """Allow `adagio run <pipeline>` by rewriting it to `--pipeline <pipeline>`."""
+    if len(argv) < 2 or argv[0] != "run":
+        return argv, None
+
+    candidate = argv[1]
+    if candidate.startswith("-"):
+        return argv, None
+
+    rewritten = ["run", "--pipeline", candidate, *argv[2:]]
+    return rewritten, candidate
+
+
+def extract_flag_value(argv: list[str], *flags: str) -> str | None:
+    """Supports: --flag value, -f value, --flag=value."""
+    flag_set = set(flags)
+    for i, tok in enumerate(argv):
+        if tok in flag_set:
+            return argv[i + 1] if i + 1 < len(argv) else None
+        for flag in flags:
+            if tok.startswith(flag + "="):
+                return tok.split("=", 1)[1]
+    return None
+
+
+def to_identifier(name: str, prefix: str | None = None) -> str:
+    """Turn arbitrary names into valid Python identifiers for kwargs keys."""
+    clean = (name or "").strip()
+    clean = re.sub(r"[^0-9a-zA-Z_]+", "_", clean)
+    if not clean:
+        raise ValueError("Empty parameter name in pipeline file.")
+    if clean[0].isdigit():
+        clean = "_" + clean
+    if prefix:
+        return f"{prefix}_{clean}"
+    return clean
+
+
+def dynamic_opt(name: str, param_type: ParamType) -> str:
+    return f"--{param_type}-{name.replace('_', '-')}"

adagio/cli/cache.py

@@ -0,0 +1,82 @@
+import re
+import shutil
+from pathlib import Path
+from typing import Annotated
+
+from cyclopts import App, Group, Parameter
+from rich.console import Console
+
+from ..executors.cache_support import CACHE_DIR_HELP, resolve_cache_dir_path
+
+QIIME_CACHE_CONTENTS = {"VERSION", "data", "keys", "pools", "processes"}
+QIIME_CACHE_LINE_RE = re.compile(r"cache: v?\d+\Z")
+
+
+def run_cache(argv: list[str], *, console: Console) -> None:
+    app = App(
+        name="adagio cache",
+        help="Manage Adagio's shared QIIME cache directory.",
+    )
+    command_group = Group("Command Options", sort_key=0)
+
+    @app.command
+    def clear(
+        *,
+        cache_dir: Annotated[
+            Path,
+            Parameter(
+                name=("--cache-dir",),
+                group=command_group,
+                help=CACHE_DIR_HELP,
+            ),
+        ],
+    ) -> None:
+        """Delete an existing QIIME cache directory."""
+        resolved_cache_dir = resolve_cache_dir_path(
+            cwd=Path.cwd().resolve(),
+            raw_value=str(cache_dir),
+        )
+        _clear_cache(cache_dir=resolved_cache_dir, console=console)
+
+    app(argv)
+
+
+def _clear_cache(*, cache_dir: Path, console: Console) -> None:
+    _require_qiime_cache(cache_dir)
+    shutil.rmtree(cache_dir)
+    console.print(f"Cleared cache directory: {cache_dir}")
+
+
+def _require_qiime_cache(cache_dir: Path) -> None:
+    if not cache_dir.exists():
+        raise SystemExit(f"Cache directory does not exist: {cache_dir}")
+    if not cache_dir.is_dir():
+        raise SystemExit(f"Cache path is not a directory: {cache_dir}")
+
+    contents = set(item.name for item in cache_dir.iterdir())
+    if not contents.issuperset(QIIME_CACHE_CONTENTS):
+        raise SystemExit(f"Path is not a QIIME cache: {cache_dir}")
+
+    version_file = cache_dir / "VERSION"
+    try:
+        version_text = version_file.read_text(encoding="utf-8").strip()
+    except OSError as exc:
+        raise SystemExit(f"Could not read cache version file: {version_file}") from exc
+
+    if not _looks_like_qiime_cache_version(version_text):
+        raise SystemExit(f"Path is not a QIIME cache: {cache_dir}")
+
+
+def _looks_like_qiime_cache_version(version_text: str) -> bool:
+    lines = version_text.splitlines()
+    if len(lines) != 3:
+        return False
+
+    if lines[0] != "QIIME 2":
+        return False
+
+    if not QIIME_CACHE_LINE_RE.fullmatch(lines[1]):
+        return False
+
+    framework_prefix = "framework: "
+    return lines[2].startswith(framework_prefix) and bool(lines[2][len(framework_prefix) :].strip())

adagio/cli/config.py

@@ -0,0 +1,183 @@
+import json
+import re
+from decimal import Decimal, InvalidOperation
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
+
+from ..executors.base import TaskEnvironmentOverride
+
+try:
+    import tomllib
+except ModuleNotFoundError:  # pragma: no cover
+    import tomli as tomllib
+
+
+class EnvironmentOverride(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    kind: str | None = None
+    image: str | None = None
+    prefix: str | None = None
+    platform: str | None = None
+    conda_executable: str | None = None
+    options: dict[str, Any] = Field(default_factory=dict)
+
+    @model_validator(mode="after")
+    def _validate_reference_fields(self) -> "EnvironmentOverride":
+        configured = [
+            name
+            for name, value in (
+                ("image", self.image),
+                ("prefix", self.prefix),
+            )
+            if value is not None
+        ]
+        if len(configured) > 1:
+            names = ", ".join(configured)
+            raise ValueError(f"Only one environment reference field may be set: {names}")
+        # Stripped BEFORE the absoluteness check and stored stripped, matching
+        # the UI's trimmed validation and the backend validator - otherwise
+        # " /opt/env" is rejected after the UI called it valid, and
+        # "/opt/env " names a different directory with a trailing space.
+        # Absoluteness is checked before ``.resolve()`` so a relative spelling
+        # fails loudly instead of silently binding to the CLI's working
+        # directory. ``~`` is fine - expanduser() yields an absolute path.
+        if self.prefix is not None:
+            self.prefix = self.prefix.strip()
+            if not Path(self.prefix).expanduser().is_absolute():
+                raise ValueError(
+                    f'Conda prefix must be an absolute path; got "{self.prefix}".'
+                )
+        return self
+
+    def to_task_environment_override(self) -> TaskEnvironmentOverride | None:
+        options = dict(self.options)
+        reference = self.image
+        if self.prefix is not None:
+            reference = str(Path(self.prefix).expanduser().resolve())
+        if self.conda_executable is not None:
+            options["conda_executable"] = self.conda_executable
+
+        if (
+            self.kind is None
+            and reference is None
+            and self.platform is None
+            and not options
+        ):
+            return None
+
+        return TaskEnvironmentOverride(
+            kind=self.kind,
+            reference=reference,
+            platform=self.platform,
+            options=options or None,
+        )
+
+
+_MEMORY_REQUEST_PATTERN = re.compile(
+    r"^(?P<amount>(?:\d+(?:\.\d+)?|\.\d+))\s*"
+    r"(?:B|KB|MB|GB|TB|PB|KiB|MiB|GiB|TiB|PiB)$",
+    re.IGNORECASE,
+)
+
+
+class TaskResourceRequirements(BaseModel):
+    """Requested shape for one task execution.
+
+    These values are parsed and retained for forward compatibility. The serial
+    executor intentionally does not apply them yet.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    cpus: int | None = Field(default=None, ge=1, strict=True)
+    memory: str | None = None
+
+    @field_validator("memory")
+    @classmethod
+    def _validate_memory(cls, value: str | None) -> str | None:
+        if value is None:
+            return None
+        normalized = value.strip()
+        match = _MEMORY_REQUEST_PATTERN.fullmatch(normalized)
+        if match is None:
+            raise ValueError(
+                'Memory must be a positive, unit-bearing quantity such as "8 GiB".'
+            )
+        try:
+            amount = Decimal(match.group("amount"))
+        except InvalidOperation as err:  # pragma: no cover - guarded by regex
+            raise ValueError("Memory amount is invalid.") from err
+        if amount <= 0:
+            raise ValueError("Memory must be greater than zero.")
+        return normalized
+
+
+class ResourceRequirementsConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    tasks: dict[str, TaskResourceRequirements] = Field(default_factory=dict)
+
+
+class AdagioRunConfig(BaseModel):
+    version: int = 1
+    defaults: EnvironmentOverride = Field(default_factory=EnvironmentOverride)
+    plugins: dict[str, EnvironmentOverride] = Field(default_factory=dict)
+    tasks: dict[str, EnvironmentOverride] = Field(default_factory=dict)
+    resources: ResourceRequirementsConfig = Field(
+        default_factory=ResourceRequirementsConfig
+    )
+
+
+def load_run_config(path: Path | None) -> AdagioRunConfig | None:
+    if path is None:
+        return None
+
+    data = _parse_config_text(path.read_text(encoding="utf-8"))
+    if not isinstance(data, dict):
+        raise SystemExit("Invalid config file: expected a TOML table or JSON object.")
+
+    return AdagioRunConfig.model_validate(data)
+
+
+def _parse_config_text(text: str) -> Any:
+    """Parse a runtime config as TOML *or* JSON (auto-detect).
+
+    The runtime launch contract lets an adapter hand the CLI a valid
+    ``AdagioRunConfig`` serialized as either TOML or JSON (design §5.7). A JSON
+    document (leading ``{``/``[``) parses cleanly as JSON but not as TOML, so we
+    sniff the first non-whitespace character and prefer JSON there; otherwise we
+    parse TOML. Existing TOML behavior is unchanged — a TOML config never starts
+    with ``{``/``[`` at document scope (``[table]`` headers do, so we fall back
+    to TOML on JSON-parse failure to stay safe).
+    """
+    stripped = text.lstrip()
+    if stripped[:1] in ("{", "["):
+        try:
+            return json.loads(text)
+        except json.JSONDecodeError:
+            # A TOML file legitimately begins with an ``[table]`` header; fall
+            # through to the TOML parser rather than failing outright.
+            pass
+    return tomllib.loads(text)
+
+
+def default_environment_override(
+    run_config: AdagioRunConfig | None,
+) -> TaskEnvironmentOverride | None:
+    if run_config is None:
+        return None
+    return run_config.defaults.to_task_environment_override()
+
+
+def named_environment_overrides(
+    raw_overrides: dict[str, EnvironmentOverride],
+) -> dict[str, TaskEnvironmentOverride] | None:
+    resolved = {
+        name: override
+        for name, raw_override in raw_overrides.items()
+        if (override := raw_override.to_task_environment_override()) is not None
+    }
+    return resolved or None