dovecli 0.1.0__py3-none-any.whl

dap_cli/cli.py

@@ -0,0 +1,678 @@
+"""
+`dap` command-line tool: authenticate against a DAP server and list,
+download, and upload files. Talks to the a_cli Django app (a_cli/views.py)
+over plain HTTP via dap_cli.client.DapClient.
+"""
+
+import csv
+import math
+import os
+import re
+import time
+from datetime import datetime
+
+import click
+import requests
+
+from dap_cli import config
+from dap_cli.client import DapClient, DapError
+
+MIN_PART_SIZE = 5 * 1024 * 1024
+DOWNLOAD_CHUNK_SIZE = 8 * 1024 * 1024
+
+# Cosmetic only -- the server/API always use the real Run.status value
+# ("PENDING"); this just relabels it for display in the CLI's output.
+STATUS_DISPLAY = {"PENDING": "IN-PROGRESS"}
+
+
+def _display_status(status):
+    return STATUS_DISPLAY.get(status, status)
+
+
+def _format_datetime(value):
+    """The server sends upload_date as an ISO 8601 string (Django's
+    DjangoJSONEncoder default) -- render it as something a human can
+    actually read at a glance instead of raw ISO text."""
+    if not value:
+        return ""
+    try:
+        return datetime.fromisoformat(value.replace("Z", "+00:00")).strftime("%Y-%m-%d %H:%M UTC")
+    except (TypeError, ValueError):
+        return value
+
+
+def _print_table(headers, rows):
+    """Plain column-aligned table -- no new dependency (e.g. tabulate/rich)
+    needed for output this simple."""
+    widths = [len(h) for h in headers]
+    for row in rows:
+        for i, cell in enumerate(row):
+            widths[i] = max(widths[i], len(str(cell)))
+
+    def _format_row(row):
+        return "  ".join(str(cell).ljust(widths[i]) for i, cell in enumerate(row))
+
+    click.echo(_format_row(headers))
+    click.echo("  ".join("-" * w for w in widths))
+    for row in rows:
+        click.echo(_format_row(row))
+
+
+def _print_tabs(headers, rows):
+    click.echo("\t".join(headers))
+    for row in rows:
+        click.echo("\t".join(str(cell) for cell in row))
+
+
+def _client():
+    return DapClient()
+
+
+BANNER = """\
+····································································
+:██████╗  ██████╗ ██╗   ██╗███████╗████████╗ █████╗ ██╗██╗         :
+:██╔══██╗██╔═══██╗██║   ██║██╔════╝╚══██╔══╝██╔══██╗██║██║         :
+:██║  ██║██║   ██║██║   ██║█████╗     ██║   ███████║██║██║         :
+:██║  ██║██║   ██║╚██╗ ██╔╝██╔══╝     ██║   ██╔══██║██║██║         :
+:██████╔╝╚██████╔╝ ╚████╔╝ ███████╗   ██║   ██║  ██║██║███████╗    :
+:╚═════╝  ╚═════╝   ╚═══╝  ╚══════╝   ╚═╝   ╚═╝  ╚═╝╚═╝╚══════╝    :
+:                                                                  :
+: ██████╗ ███████╗███╗   ██╗ ██████╗ ███╗   ███╗██╗ ██████╗███████╗:
+:██╔════╝ ██╔════╝████╗  ██║██╔═══██╗████╗ ████║██║██╔════╝██╔════╝:
+:██║  ███╗█████╗  ██╔██╗ ██║██║   ██║██╔████╔██║██║██║     ███████╗:
+:██║   ██║██╔══╝  ██║╚██╗██║██║   ██║██║╚██╔╝██║██║██║     ╚════██║:
+:╚██████╔╝███████╗██║ ╚████║╚██████╔╝██║ ╚═╝ ██║██║╚██████╗███████║:
+: ╚═════╝ ╚══════╝╚═╝  ╚═══╝ ╚═════╝ ╚═╝     ╚═╝╚═╝ ╚═════╝╚══════╝:
+····································································\
+"""
+
+
+class DapGroup(click.Group):
+    """Prepends the banner to `dap --help` (and `dap <bad-command>`'s usage
+    error) -- overriding format_help() instead of stuffing the banner into
+    the docstring, since click reflows docstring text to fit the terminal
+    width and would mangle the box-drawing art."""
+
+    def format_help(self, ctx, formatter):
+        formatter.write(BANNER + "\n")
+        super().format_help(ctx, formatter)
+
+
+@click.group(cls=DapGroup)
+def main():
+    """DAP command-line tool: authenticate, list, download, and upload files."""
+
+
+@main.command()
+@click.option("--api-url", default=None, help="DAP server base URL (default: https://portal.cantatabio.com)")
+def login(api_url):
+    """Log in with your DAP email and password and save a CLI token."""
+    email = click.prompt("Email")
+    password = click.prompt("Password", hide_input=True)
+    client = DapClient(api_url=api_url or config.get_api_url())
+    try:
+        token = client.login(email, password)
+    except DapError as e:
+        raise click.ClickException(str(e))
+    config.set_token(token, api_url=client.api_url)
+    click.echo("Logged in.")
+
+
+@main.command()
+def logout():
+    """Clear the locally saved CLI token."""
+    config.clear()
+    click.echo("Logged out.")
+
+
+@main.command()
+def whoami():
+    """Show the logged-in account's email and credit balance."""
+    try:
+        info = _client().whoami()
+    except DapError as e:
+        raise click.ClickException(str(e))
+    click.echo(f"{info['email']} -- {info['credits']} credits")
+
+
+@main.group()
+def files():
+    """List, download, and upload files."""
+
+
+@files.command("list")
+@click.option("--output", type=click.Choice(["tabs", "table"]), default="tabs", help="Output format (default: tabs)")
+def list_files(output):
+    """List your uploaded/registered files."""
+    try:
+        rows = _client().list_files()
+    except DapError as e:
+        raise click.ClickException(str(e))
+    if not rows:
+        click.echo("No files.")
+        return
+    headers = ["ID", "NAME", "SIZE", "UPLOAD_DATE", "TIME_REMAINING"]
+    table_rows = [
+        [f["id"], f["name"], f["size"], _format_datetime(f["upload_date"]), f"{f['time_remaining']} days"] for f in rows
+    ]
+    if output == "table":
+        _print_table(headers, table_rows)
+    else:
+        _print_tabs(headers, table_rows)
+
+
+@files.command("download")
+@click.argument("file")
+@click.option("-o", "--output", default=None, help="Output path (default: the file's original name)")
+def download(file, output):
+    """Download a file by its id or name (see `dap files list`)."""
+    client = _client()
+    try:
+        rows = client.list_files()
+    except DapError as e:
+        raise click.ClickException(str(e))
+
+    matches = [f for f in rows if f["id"] == file or f["name"] == file]
+    if not matches:
+        raise click.ClickException(f"No file found matching '{file}'")
+    if len(matches) > 1:
+        ids = ", ".join(m["id"] for m in matches)
+        raise click.ClickException(f"Multiple files named '{file}' -- specify by id instead: {ids}")
+    file_id = matches[0]["id"]
+
+    try:
+        info = client.get_download_link(file_id)
+    except DapError as e:
+        raise click.ClickException(str(e))
+
+    output = output or info["name"]
+    response = requests.get(info["download_url"], stream=True)
+    response.raise_for_status()
+    total = int(info.get("size") or 0)
+    written = 0
+    with open(output, "wb") as f:
+        for chunk in response.iter_content(chunk_size=DOWNLOAD_CHUNK_SIZE):
+            f.write(chunk)
+            written += len(chunk)
+            if total:
+                click.echo(f"\r{written}/{total} bytes ({written * 100 // total}%)", nl=False)
+    click.echo(f"\nSaved to {output}")
+
+
+def _upload_file(client, path, label=None):
+    """
+    Drives the same S3 multipart flow as `dap files upload` (create/sign
+    parts/PUT/complete, aborting the multipart upload on any failure) --
+    shared with `dap submit sv`'s auto-upload-local-FASTQ path so there's
+    one implementation, not two. `label`, when given, prints an
+    announcement line before the transfer starts, so a caller uploading
+    several files in sequence (like submit sv) can say which is which;
+    `dap files upload` itself omits it, keeping its own output unchanged.
+    """
+    if not os.path.isfile(path):
+        raise click.ClickException(f"No such file: {path}")
+
+    filename = os.path.basename(path)
+    size = os.path.getsize(path)
+
+    if label:
+        click.echo(f"Uploading {label}: {filename}")
+
+    try:
+        created = client.create_upload(filename, "application/octet-stream")
+    except DapError as e:
+        raise click.ClickException(str(e))
+
+    key, upload_id = created["key"], created["upload_id"]
+    chunk_size = max(MIN_PART_SIZE, math.ceil(size / 10000))
+
+    try:
+        parts = []
+        uploaded = 0
+        with open(path, "rb") as f:
+            part_number = 1
+            while True:
+                chunk = f.read(chunk_size)
+                if not chunk:
+                    break
+                url = client.sign_upload_part(upload_id, key, part_number)
+                response = requests.put(url, data=chunk)
+                response.raise_for_status()
+                parts.append({"part_number": part_number, "etag": response.headers["ETag"]})
+                uploaded += len(chunk)
+                click.echo(f"\r{uploaded}/{size} bytes ({uploaded * 100 // size}%)", nl=False)
+                part_number += 1
+
+        result = client.complete_upload(upload_id, key, parts)
+    except (DapError, requests.RequestException) as e:
+        # Best-effort cleanup so a failed upload doesn't leave an orphaned
+        # multipart upload sitting in the bucket forever.
+        try:
+            client.abort_upload(upload_id, key)
+        except DapError:
+            pass
+        raise click.ClickException(str(e))
+
+    click.echo(f"\nUploaded: {result['name']} ({result['id']})")
+    return result
+
+
+def _resolve_fastq_uri(client, value, label):
+    """
+    Accepts either an s3:// URI (used as-is, no upload) or a local file
+    path (uploaded automatically via _upload_file, returning the new
+    S3file's uri) -- auto-detected per value, no separate flag, so a
+    single --tumor/--normal pair can even mix one of each.
+    """
+    if value.startswith("s3://"):
+        return value
+    if os.path.isfile(value):
+        return _upload_file(client, value, label=label)["uri"]
+    raise click.ClickException(f"'{value}' is not a valid local file or an S3 URI (must start with s3://)")
+
+
+def _parse_design_file(path):
+    """
+    Parses a --design CSV (header: sample_type,r1,r2) into the same
+    tuple-of-(r1, r2)-tuples shape repeated --tumor/--normal flags already
+    produce, so it can feed straight into submit_sv's existing
+    _resolve_pairs. Rep number is implicit: rows are grouped by
+    sample_type, and within each group file order determines the rep.
+
+    Validates the file is actually well-formed before any upload/network
+    call happens: tolerates a UTF-8 BOM and stray whitespace around header
+    names (common artifacts of Excel/hand-edited CSVs), then rejects a
+    wrong header, rows with the wrong number of columns, an invalid
+    sample_type, or a missing r1/r2 -- each error names the offending row.
+    """
+    tumor_pairs, normal_pairs = [], []
+    with open(path, newline="", encoding="utf-8-sig") as f:
+        reader = csv.DictReader(f)
+        if reader.fieldnames:
+            reader.fieldnames = [name.strip() for name in reader.fieldnames]
+        if reader.fieldnames != ["sample_type", "r1", "r2"]:
+            raise click.ClickException(f"{path}: header must be exactly 'sample_type,r1,r2'")
+        for row_num, row in enumerate(reader, start=2):  # header is row 1
+            if row.get(None) is not None:
+                raise click.ClickException(f"{path}:{row_num}: too many columns (expected sample_type,r1,r2)")
+            if not any((row.get(k) or "").strip() for k in ("sample_type", "r1", "r2")):
+                continue
+            sample_type = (row["sample_type"] or "").strip().lower()
+            r1, r2 = (row["r1"] or "").strip(), (row["r2"] or "").strip()
+            if sample_type not in ("tumor", "normal"):
+                raise click.ClickException(
+                    f"{path}:{row_num}: sample_type must be 'tumor' or 'normal', got '{row['sample_type']}'"
+                )
+            if not r1 or not r2:
+                raise click.ClickException(f"{path}:{row_num}: r1 and r2 are both required")
+            (tumor_pairs if sample_type == "tumor" else normal_pairs).append((r1, r2))
+    return tumor_pairs, normal_pairs
+
+
+# Mirrors utils/fastq.py's categorize_fastq() marker convention (R1/R2/r1/r2/
+# bare _1/_2, boundary-guarded so R10/_11 don't false-match) -- ported here
+# since dap_cli is a standalone package that can't import Django app code.
+_FASTQ_EXT_RE = re.compile(r"\.(fastq|fq)\.gz$", re.IGNORECASE)
+_R1R2_MARKER_RE = re.compile(r"[._](r[12])(?=[._]|$)|[._]([12])(?=[._]|$)", re.IGNORECASE)
+_SAMPLE_TYPE_MARKER_RE = re.compile(r"(?:^|[._])(tumor|normal)(?:[._]|$)", re.IGNORECASE)
+
+
+def _build_pairs_from_values(source, values):
+    """
+    Classifies/pairs a flat list of local paths or s3:// URIs (found by
+    scanning a --design directory or S3 prefix) into tumor/normal (r1, r2)
+    tuples -- the same shape a hand-written --design CSV or repeated
+    --tumor/--normal flags already produce, so it plugs straight into
+    submit_sv's existing _resolve_pairs unchanged.
+    """
+    groups = {"tumor": {}, "normal": {}}
+    for value in values:
+        name = os.path.basename(value)
+        if not _FASTQ_EXT_RE.search(name):
+            continue  # ignore non-FASTQ files (.DS_Store, stray docs, etc.)
+
+        type_match = _SAMPLE_TYPE_MARKER_RE.search(name)
+        if not type_match:
+            raise click.ClickException(f"{source}: '{name}' has no 'tumor'/'normal' marker in its filename.")
+        sample_type = type_match.group(1).lower()
+
+        r_match = _R1R2_MARKER_RE.search(name)
+        if not r_match:
+            raise click.ClickException(f"{source}: '{name}' has no R1/R2 marker in its filename.")
+        which = f"r{(r_match.group(1) or r_match.group(2)).lower().lstrip('r')}"
+        group_key = name[: r_match.start()] + name[r_match.end() :]
+
+        group = groups[sample_type].setdefault(group_key, {})
+        if which in group:
+            raise click.ClickException(f"{source}: multiple {which.upper()} files match '{group_key}'.")
+        group[which] = value
+
+    def _ordered_pairs(sample_type):
+        result = []
+        for group_key in sorted(groups[sample_type]):
+            pair = groups[sample_type][group_key]
+            if "r1" not in pair or "r2" not in pair:
+                missing = "R2" if "r1" in pair else "R1"
+                raise click.ClickException(f"{source}: '{group_key}' is missing its {missing} mate.")
+            result.append((pair["r1"], pair["r2"]))
+        return result
+
+    return _ordered_pairs("tumor"), _ordered_pairs("normal")
+
+
+def _resolve_design(client, design):
+    """
+    Dispatches --design to the right source: an existing file is parsed as
+    a CSV (see _parse_design_file), a local directory or an s3:// prefix is
+    scanned and auto-paired via _build_pairs_from_values.
+    """
+    if design.startswith("s3://"):
+        try:
+            values = client.list_s3_prefix(design)
+        except DapError as e:
+            raise click.ClickException(str(e))
+        return _build_pairs_from_values(design, values)
+    if os.path.isdir(design):
+        values = sorted(
+            os.path.join(design, name) for name in os.listdir(design) if os.path.isfile(os.path.join(design, name))
+        )
+        return _build_pairs_from_values(design, values)
+    if os.path.isfile(design):
+        return _parse_design_file(design)
+    raise click.ClickException(f"'{design}' is not a valid CSV file, directory, or s3:// prefix.")
+
+
+@files.command("upload")
+@click.argument("path")
+def upload(path):
+    """Upload a local file."""
+    _upload_file(_client(), path)
+
+
+@main.group()
+def runs():
+    """List pipeline runs."""
+
+
+@runs.command("list")
+@click.option("--status", default=None, help="Filter by status (e.g. SUCCESS, FAILED, PENDING).")
+@click.option("--pipeline", default=None, help="Filter by pipeline (e.g. sv, epi, diff, qc).")
+@click.option("--limit", type=int, default=20, show_default=True, help="Maximum number of runs to show.")
+@click.option("--output", type=click.Choice(["tabs", "table"]), default="tabs", help="Output format (default: tabs)")
+def list_runs(status, pipeline, limit, output):
+    """List your pipeline runs."""
+    try:
+        rows = _client().list_runs(status=status, pipeline=pipeline, limit=limit)
+    except DapError as e:
+        raise click.ClickException(str(e))
+    if not rows:
+        click.echo("No runs.")
+        return
+    headers = ["ID", "NAME", "STATUS", "PIPELINE", "REF_GENOME", "CREATED", "CREDIT_USE"]
+    table_rows = [
+        [
+            r["id"],
+            r["name"],
+            _display_status(r["status"]),
+            r["run_pipeline"],
+            r["ref_genome"],
+            _format_datetime(r["created"]),
+            r["credit_use"],
+        ]
+        for r in rows
+    ]
+    if output == "table":
+        _print_table(headers, table_rows)
+    else:
+        _print_tabs(headers, table_rows)
+
+
+TERMINAL_STATUSES = {"SUCCESS", "FAILED", "CANCELLED"}
+PROGRESS_BAR_WIDTH = 30
+
+
+def _progress_bar(percent, width=PROGRESS_BAR_WIDTH):
+    filled = max(0, min(width, round(width * percent / 100)))
+    return "[" + "█" * filled + "░" * (width - filled) + "]"
+
+
+def _run_detail_lines(run):
+    lines = [
+        f"ID:          {run['id']}",
+        f"Name:        {run['name']}",
+        f"Status:      {_display_status(run['status'])}",
+        f"Pipeline:    {run['run_pipeline']}",
+        f"Ref genome:  {run['ref_genome']}",
+        f"Created:     {_format_datetime(run['created'])}",
+        f"Credit use:  {run['credit_use']}",
+        f"Retry count: {run['retry']}",
+    ]
+    if run.get("note"):
+        lines.append(f"Note:        {run['note']}")
+
+    progress = run.get("progress")
+    if progress:
+        bar = _progress_bar(progress["percent"])
+        lines.append(f"Progress:    {bar} {progress['percent']}% ({progress['completed']}/{progress['total']} stages)")
+        if progress["running"]:
+            lines.append(f"Running:     {', '.join(progress['running'])}")
+        if progress["retrying"]:
+            lines.append(f"Retrying:    {', '.join(progress['retrying'])}")
+
+    if run.get("nextflow_error"):
+        lines.append(f"Caused by:   {run['nextflow_error']}")
+
+    return lines
+
+
+def _print_run_detail(run):
+    for line in _run_detail_lines(run):
+        click.echo(line)
+
+
+def _watch_run(client, run_id, interval):
+    previous_line_count = 0
+    try:
+        while True:
+            try:
+                run = client.get_run(run_id)
+            except DapError as e:
+                raise click.ClickException(str(e))
+
+            lines = _run_detail_lines(run)
+            if previous_line_count:
+                # Move the cursor back to the start of the previous block
+                # and clear everything below it, so each poll redraws in
+                # place instead of scrolling the terminal.
+                click.echo(f"\x1b[{previous_line_count}A\x1b[J", nl=False)
+            click.echo("\n".join(lines))
+            previous_line_count = len(lines)
+
+            if run["status"] in TERMINAL_STATUSES:
+                return
+
+            time.sleep(interval)
+    except KeyboardInterrupt:
+        click.echo("Stopped watching.")
+
+
+@runs.command("status")
+@click.argument("run_id")
+@click.option("-w", "--watch", is_flag=True, help="Keep polling and show live progress until the run finishes.")
+@click.option("--interval", type=float, default=5.0, show_default=True, help="Seconds between polls in --watch mode.")
+def run_status(run_id, watch, interval):
+    """Show a run's status, and its live progress or failure reason."""
+    client = _client()
+
+    if watch:
+        _watch_run(client, run_id, interval)
+        return
+
+    try:
+        run = client.get_run(run_id)
+    except DapError as e:
+        raise click.ClickException(str(e))
+    _print_run_detail(run)
+
+
+@runs.command("cancer-types")
+@click.option("--output", type=click.Choice(["tabs", "table"]), default="tabs", help="Output format (default: tabs)")
+def cancer_types(output):
+    """List valid --cancer-type values for `dap submit sv`."""
+    try:
+        types = _client().list_cancer_types()
+    except DapError as e:
+        raise click.ClickException(str(e))
+    rows = [[t] for t in types]
+    if output == "table":
+        _print_table(["CANCER_TYPE"], rows)
+    else:
+        _print_tabs(["CANCER_TYPE"], rows)
+
+
+@main.group()
+def submit():
+    """Submit pipeline runs."""
+
+
+@submit.command("sv")
+@click.option("--name", required=True, help="Run name.")
+@click.option(
+    "--tumor",
+    "tumor_pairs",
+    nargs=2,
+    multiple=True,
+    metavar="R1 R2",
+    help="Tumor FASTQ pair -- each of R1/R2 can be an S3 URI (see `dap files list`) or a local file path, "
+    "which is uploaded automatically. Repeat for multiple lanes/reps of the same tumor sample -- each "
+    "occurrence adds one replicate to this run, it does not start a separate run. Cannot be combined "
+    "with --design.",
+)
+@click.option(
+    "--normal",
+    "normal_pairs",
+    nargs=2,
+    multiple=True,
+    metavar="R1 R2",
+    help="Matched-normal FASTQ pair (S3 URI or local file path, same as --tumor). Repeat for multiple "
+    "lanes/reps, same as --tumor. Cannot be combined with --design.",
+)
+@click.option(
+    "--design",
+    type=str,
+    default=None,
+    help="Build tumor/normal pairs from a CSV file (columns: sample_type,r1,r2), a local directory, or an "
+    "s3:// prefix, instead of repeating --tumor/--normal. For a directory/prefix, each FASTQ filename "
+    "must contain a 'tumor'/'normal' marker plus an R1/R2 marker (e.g. tumor_lane1_R1.fastq.gz); pairs "
+    "are built automatically. Cannot be combined with --tumor/--normal.",
+)
+@click.option("--ref-genome", type=click.Choice(["hg38", "mm10"]), default="hg38", show_default=True)
+@click.option(
+    "--kit",
+    type=click.Choice(["linkprep", "ffpe", "microc", "hichip", "capture"]),
+    default="linkprep",
+    show_default=True,
+)
+@click.option("--cancer-type", default="Not_Specified", show_default=True, help="See `dap runs cancer-types`.")
+@click.option("--ai-summary/--no-ai-summary", default=True, show_default=True)
+@click.option("--min-purity", type=float, default=0.1, show_default=True)
+@click.option("--max-purity", type=float, default=1.0, show_default=True)
+@click.option("--min-ploidy", type=float, default=0.0, show_default=True)
+@click.option("--max-ploidy", type=float, default=5.0, show_default=True)
+@click.option("--outdir", default="", help="Custom S3 output location (default: server-assigned).")
+@click.option("-y", "--yes", is_flag=True, help="Skip the confirmation prompt.")
+def submit_sv(
+    name,
+    tumor_pairs,
+    normal_pairs,
+    design,
+    ref_genome,
+    kit,
+    cancer_type,
+    ai_summary,
+    min_purity,
+    max_purity,
+    min_ploidy,
+    max_ploidy,
+    outdir,
+    yes,
+):
+    """Submit a structural-variant (SV) pipeline run.
+
+    Each R1/R2 value in --tumor/--normal can be either an S3 URI (already
+    registered, e.g. via `dap files upload`) or a local file path -- local
+    files are uploaded automatically before the run is submitted.
+    Alternatively, pass --design with a CSV file (columns: sample_type,r1,r2),
+    a local directory, or an s3:// prefix, instead of repeating
+    --tumor/--normal.
+    """
+    client = _client()
+
+    if design and (tumor_pairs or normal_pairs):
+        raise click.ClickException("--design cannot be combined with --tumor/--normal -- use one or the other.")
+    if design:
+        tumor_pairs, normal_pairs = _resolve_design(client, design)
+    if not tumor_pairs:
+        raise click.ClickException("At least one tumor replicate is required (via --tumor or --design).")
+
+    try:
+        valid_cancer_types = client.list_cancer_types()
+    except DapError as e:
+        raise click.ClickException(str(e))
+    if cancer_type not in valid_cancer_types:
+        raise click.ClickException(
+            f"'{cancer_type}' is not a valid --cancer-type. Run `dap runs cancer-types` to see valid values."
+        )
+
+    def _resolve_pairs(pairs, sample_type):
+        resolved = []
+        for i, (r1, r2) in enumerate(pairs, start=1):
+            r1_uri = _resolve_fastq_uri(client, r1, f"{sample_type} rep {i} R1")
+            r2_uri = _resolve_fastq_uri(client, r2, f"{sample_type} rep {i} R2")
+            resolved.append({"r1": r1_uri, "r2": r2_uri})
+        return resolved
+
+    tumor_fastq_pairs = _resolve_pairs(tumor_pairs, "tumor")
+    normal_fastq_pairs = _resolve_pairs(normal_pairs, "normal")
+
+    try:
+        estimate = client.estimate_credits(tumor_fastq_pairs + normal_fastq_pairs)
+        account = client.whoami()
+    except DapError as e:
+        raise click.ClickException(str(e))
+
+    click.echo(f"Name:             {name}")
+    click.echo(f"Reference genome: {ref_genome}")
+    click.echo(f"Kit:              {kit}")
+    click.echo(f"Cancer type:      {cancer_type}")
+    click.echo(f"Tumor reps:       {len(tumor_fastq_pairs)}")
+    click.echo(f"Normal reps:      {len(normal_fastq_pairs)}")
+    click.echo(f"Estimated cost:   {estimate['estimated_credit_use']} credits (you have {account['credits']})")
+
+    if not yes and not click.confirm("Submit this run?"):
+        click.echo("Aborted.")
+        return
+
+    try:
+        result = client.submit_sv_run(
+            name=name,
+            tumor_fastq_pairs=tumor_fastq_pairs,
+            normal_fastq_pairs=normal_fastq_pairs,
+            ref_genome=ref_genome,
+            kit=kit,
+            cancer_type=cancer_type,
+            ai_summary="yes" if ai_summary else "no",
+            min_purity=min_purity,
+            max_purity=max_purity,
+            min_ploidy=min_ploidy,
+            max_ploidy=max_ploidy,
+            outdir=outdir,
+        )
+    except DapError as e:
+        raise click.ClickException(str(e))
+
+    click.echo(f"Submitted: {result['name']} ({result['id']}) -- status={_display_status(result['status'])}")
+
+
+if __name__ == "__main__":
+    main()

dap_cli/client.py

@@ -0,0 +1,124 @@
+"""
+Thin HTTP client for the DAP CLI JSON API (a_cli/views.py, server-side).
+Every method sets Authorization: Bearer <token> and raises a clear error on
+a non-2xx response, rather than letting a requests.HTTPError/JSON-parsing
+error leak up unformatted.
+"""
+
+import requests
+
+from dap_cli import config
+
+
+class DapError(Exception):
+    """A DAP API call failed (non-2xx response, error message from the server)."""
+
+
+class NotLoggedInError(DapError):
+    """No token saved locally, or the server rejected it -- run `dap login`."""
+
+
+class DapClient:
+    def __init__(self, api_url=None, token=None):
+        self.api_url = (api_url or config.get_api_url()).rstrip("/")
+        self.token = token if token is not None else config.get_token()
+        self.session = requests.Session()
+
+    def _url(self, path):
+        return f"{self.api_url}{path}"
+
+    def _headers(self):
+        if not self.token:
+            raise NotLoggedInError("Not logged in -- run `dap login` first")
+        return {"Authorization": f"Bearer {self.token}"}
+
+    def _check(self, response):
+        if response.status_code == 401:
+            raise NotLoggedInError("Session expired or invalid -- run `dap login` again")
+        if not response.ok:
+            try:
+                message = response.json().get("error", response.text)
+            except ValueError:
+                message = response.text
+            raise DapError(f"{response.status_code}: {message}")
+        return response
+
+    def login(self, email, password):
+        response = self.session.post(self._url("/cli/auth/login"), json={"email": email, "password": password})
+        return self._check(response).json()["token"]
+
+    def whoami(self):
+        response = self.session.get(self._url("/cli/whoami"), headers=self._headers())
+        return self._check(response).json()
+
+    def list_files(self):
+        response = self.session.get(self._url("/cli/files"), headers=self._headers())
+        return self._check(response).json()["files"]
+
+    def get_download_link(self, file_id):
+        response = self.session.get(self._url(f"/cli/files/{file_id}/download"), headers=self._headers())
+        return self._check(response).json()
+
+    def create_upload(self, filename, content_type):
+        response = self.session.post(
+            self._url("/cli/uploads"),
+            headers=self._headers(),
+            json={"filename": filename, "content_type": content_type},
+        )
+        return self._check(response).json()
+
+    def sign_upload_part(self, upload_id, key, part_number):
+        response = self.session.get(
+            self._url(f"/cli/uploads/{upload_id}/parts"),
+            headers=self._headers(),
+            params={"key": key, "part_number": part_number},
+        )
+        return self._check(response).json()["url"]
+
+    def complete_upload(self, upload_id, key, parts):
+        response = self.session.post(
+            self._url(f"/cli/uploads/{upload_id}/complete"),
+            headers=self._headers(),
+            json={"key": key, "parts": parts},
+        )
+        return self._check(response).json()
+
+    def abort_upload(self, upload_id, key):
+        response = self.session.delete(
+            self._url(f"/cli/uploads/{upload_id}"), headers=self._headers(), params={"key": key}
+        )
+        self._check(response)
+
+    def list_runs(self, status=None, pipeline=None, limit=20):
+        params = {"limit": limit}
+        if status:
+            params["status"] = status
+        if pipeline:
+            params["pipeline"] = pipeline
+        response = self.session.get(self._url("/cli/runs"), headers=self._headers(), params=params)
+        return self._check(response).json()["runs"]
+
+    def get_run(self, run_id):
+        response = self.session.get(self._url(f"/cli/runs/{run_id}"), headers=self._headers())
+        return self._check(response).json()
+
+    def submit_sv_run(self, **kwargs):
+        response = self.session.post(self._url("/cli/runs/sv"), headers=self._headers(), json=kwargs)
+        return self._check(response).json()
+
+    def list_s3_prefix(self, prefix):
+        response = self.session.get(
+            self._url("/cli/design/s3-list"), headers=self._headers(), params={"prefix": prefix}
+        )
+        files = self._check(response).json()["files"]
+        return [f["uri"] for f in files]
+
+    def list_cancer_types(self):
+        response = self.session.get(self._url("/cli/cancer-types"), headers=self._headers())
+        return self._check(response).json()["cancer_types"]
+
+    def estimate_credits(self, fastq_pairs):
+        response = self.session.post(
+            self._url("/cli/estimate-credits"), headers=self._headers(), json={"fastq_pairs": fastq_pairs}
+        )
+        return self._check(response).json()

dap_cli/config.py

@@ -0,0 +1,49 @@
+"""
+Local config storage for the `dap` CLI: ~/.dap/config.json holding the
+bearer token issued by `dap login` and the API base URL to talk to. This
+runs entirely on the user's own machine -- separate from anything the
+Django server persists.
+"""
+
+import json
+import os
+from pathlib import Path
+
+DEFAULT_API_URL = "https://portal.cantatabio.com"
+CONFIG_DIR = Path(os.environ.get("DAP_CONFIG_DIR", Path.home() / ".dap"))
+CONFIG_PATH = CONFIG_DIR / "config.json"
+
+
+def load():
+    if not CONFIG_PATH.exists():
+        return {}
+    with open(CONFIG_PATH) as f:
+        return json.load(f)
+
+
+def save(data):
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    with open(CONFIG_PATH, "w") as f:
+        json.dump(data, f)
+    os.chmod(CONFIG_PATH, 0o600)
+
+
+def get_api_url():
+    return os.environ.get("DAP_API_URL") or load().get("api_url") or DEFAULT_API_URL
+
+
+def get_token():
+    return load().get("token")
+
+
+def set_token(token, api_url=None):
+    data = load()
+    data["token"] = token
+    if api_url:
+        data["api_url"] = api_url
+    save(data)
+
+
+def clear():
+    if CONFIG_PATH.exists():
+        CONFIG_PATH.unlink()

dovecli-0.1.0.dist-info/METADATA

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: dovecli
+Version: 0.1.0
+Summary: Command-line client for the Dovetail Analysis Portal (DAP): authenticate, list, and submit a run, download, and upload files.
+Author-email: Ekkachai Danwanichakul <edanwanichakul@dovetail-genomics.com>
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.1
+Requires-Dist: requests>=2.31
+
+# DAP CLI
+
+`dap` is the command-line client for the Dovetail Analysis Portal (DAP):
+log in, list and submit runs, and upload/download files without leaving a
+terminal. It talks to the DAP server over plain HTTP and is a standalone
+package, separate from the DAP web app itself.
+
+## Install
+
+```console
+$ pip install dapcli
+```
+
+This installs the `dap` command on your `PATH`, along with its only two
+runtime dependencies, [click](https://click.palletsprojects.com/) and
+[requests](https://requests.readthedocs.io/). Requires Python 3.9+.
+
+## Quickstart
+
+```console
+$ dap login
+Email: you@example.com
+Password:
+Logged in.
+
+$ dap whoami
+you@example.com -- 5 credits
+
+$ dap files list
+$ dap files upload /path/to/reads_R1.fastq.gz
+
+$ dap runs cancer-types
+$ dap submit sv --name my-first-run \
+    --tumor s3://bucket/user_1/tumor_R1.fastq.gz s3://bucket/user_1/tumor_R2.fastq.gz \
+    --cancer-type Breast
+
+$ dap runs list
+$ dap runs status <run-id> --watch
+```
+
+By default `dap` talks to `https://portal.cantatabio.com`. Point it at a
+different server with `dap login --api-url ...` or the `DAP_API_URL`
+environment variable. Your login token is stored locally at
+`~/.dap/config.json` (override with `DAP_CONFIG_DIR`); your password is
+never saved.

dovecli-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+dap_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dap_cli/cli.py,sha256=Hcg4Uliz-A75JtFiQKg2tJsCKzAqsUuINE6RzxJKN-c,26755
+dap_cli/client.py,sha256=tyENzNcy-aFCY_RfmTbIDGweh76QbvnPMZDzG2NsJgg,4750
+dap_cli/config.py,sha256=Lc-JxVyHL4M3TMooFy-DCldyUALrd4I2ogaL-Og41Yo,1128
+dovecli-0.1.0.dist-info/METADATA,sha256=0WkhCoenrSpBcx0q6JbIwLxfbbo8FDhy06nYh7GtyGQ,1630
+dovecli-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+dovecli-0.1.0.dist-info/entry_points.txt,sha256=Hqq81rzGpxHw35IvqmA0PzubcnyAP9KY13bJiyI-yxg,41
+dovecli-0.1.0.dist-info/top_level.txt,sha256=OyCJdddmXnFNaVpSblKod3JjwS6XBdtCbafypjAjPDk,8
+dovecli-0.1.0.dist-info/RECORD,,

dovecli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dovecli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dap = dap_cli.cli:main

dovecli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dap_cli