adagio-cli 0.1.0a1__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,39 @@
+from pathlib import Path
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+try:
+    import tomllib
+except ModuleNotFoundError:  # pragma: no cover
+    import tomli as tomllib
+
+
+class ImageOverride(BaseModel):
+    kind: Literal["docker", "apptainer"] | None = None
+    image: str | None = None
+    platform: str | None = None
+
+
+class DefaultOverride(BaseModel):
+    kind: Literal["docker", "apptainer"] | None = None
+    image: str | None = None
+    platform: str | None = None
+
+
+class AdagioRunConfig(BaseModel):
+    version: int = 1
+    defaults: DefaultOverride = Field(default_factory=DefaultOverride)
+    plugins: dict[str, ImageOverride] = Field(default_factory=dict)
+    tasks: dict[str, ImageOverride] = Field(default_factory=dict)
+
+
+def load_run_config(path: Path | None) -> AdagioRunConfig | None:
+    if path is None:
+        return None
+
+    data = tomllib.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(data, dict):
+        raise SystemExit("Invalid config file: expected a TOML table.")
+
+    return AdagioRunConfig.model_validate(data)