Utils/scripts/download_data.py

#!/usr/bin/env python3
"""Download public PhysInOne evaluation data and released 3D assets."""

from __future__ import annotations

import argparse
import filecmp
import json
import os
import re
import shutil
import stat
import sys
import threading
import time
import urllib.error
import urllib.request
import zipfile
from collections import deque
from concurrent.futures import ThreadPoolExecutor, as_completed
from dataclasses import dataclass
from datetime import datetime, timezone
from pathlib import Path, PurePosixPath
from typing import Hashable, Iterable, Optional, Sequence, TextIO
from urllib.parse import quote, unquote


REPOSITORY = "vLAR/PhysInOne"
LIST_ROOT = Path(__file__).resolve().parent / "download_lists"
CHUNK_SIZE = 8 * 1024 * 1024
USER_AGENT = "PhysInOne-public-downloader/1.0"


def format_bytes(value: float) -> str:
    units = ("B", "KiB", "MiB", "GiB", "TiB")
    amount = float(max(0.0, value))
    for unit in units:
        if amount < 1024.0 or unit == units[-1]:
            if unit == "B":
                return f"{amount:.0f} {unit}"
            return f"{amount:.1f} {unit}"
        amount /= 1024.0
    return f"{amount:.1f} TiB"


def format_duration(seconds: Optional[float]) -> str:
    if seconds is None or seconds < 0 or seconds == float("inf"):
        return "--:--"
    value = int(seconds + 0.5)
    hours, remainder = divmod(value, 3600)
    minutes, secs = divmod(remainder, 60)
    if hours:
        return f"{hours:d}:{minutes:02d}:{secs:02d}"
    return f"{minutes:02d}:{secs:02d}"


class DownloadProgress:
    """Thread-safe aggregate progress bar with a clean non-TTY fallback."""

    def __init__(
        self,
        total_files: int,
        label: str = "Downloading",
        *,
        show_bytes: bool = True,
        stream: Optional[TextIO] = None,
        refresh_interval: float = 0.2,
        log_interval: float = 10.0,
    ) -> None:
        self.total_files = max(0, int(total_files))
        self.label = label
        self.show_bytes = show_bytes
        self.stream = stream or sys.stderr
        self.interactive = bool(
            getattr(self.stream, "isatty", lambda: False)()
            and not bool(getattr(self.stream, "closed", False))
        )
        self.refresh_interval = max(0.05, refresh_interval)
        self.log_interval = max(1.0, log_interval)
        self.started_at = time.monotonic()
        self._last_render = 0.0
        self._completed = 0
        self._failed = 0
        self._network_bytes = 0
        self._states: dict[Hashable, list[Optional[int]]] = {}
        self._samples: deque[tuple[float, int]] = deque()
        self._lock = threading.Lock()
        self._closed = False
        self._dirty = True

    def begin_file(
        self,
        key: Hashable,
        existing_bytes: int = 0,
        total_bytes: Optional[int] = None,
    ) -> None:
        with self._lock:
            self._states[key] = [
                max(0, int(existing_bytes)),
                None if total_bytes is None else max(0, int(total_bytes)),
            ]
            self._dirty = True
            self._render_locked()

    def advance(self, key: Hashable, amount: int) -> None:
        increment = max(0, int(amount))
        if not increment:
            return
        with self._lock:
            state = self._states.setdefault(key, [0, None])
            state[0] = int(state[0] or 0) + increment
            self._network_bytes += increment
            self._dirty = True
            current = time.monotonic()
            self._samples.append((current, self._network_bytes))
            cutoff = current - 12.0
            while len(self._samples) > 2 and self._samples[0][0] < cutoff:
                self._samples.popleft()
            self._render_locked(current)

    def complete(
        self,
        key: Hashable,
        status: str,
        local_path: str = "",
        failed: bool = False,
    ) -> None:
        with self._lock:
            state = self._states.setdefault(key, [0, None])
            if not failed and local_path:
                path = Path(local_path)
                try:
                    size = path.stat().st_size if path.is_file() else None
                except OSError:
                    size = None
                if size is not None:
                    state[0] = size
                    state[1] = size
            self._completed += 1
            if failed:
                self._failed += 1
            self._dirty = True
            self._render_locked(force=self._completed == self.total_files)

    def finish(self) -> None:
        with self._lock:
            if self._closed:
                return
            if self.total_files:
                if self._dirty:
                    self._render_locked(force=True)
                if self.interactive:
                    self.stream.write("\n")
                    self.stream.flush()
            self._closed = True

    def _speed_locked(self, current: float) -> tuple[float, float]:
        elapsed = max(current - self.started_at, 1e-6)
        average = self._network_bytes / elapsed
        if len(self._samples) >= 2:
            first_time, first_bytes = self._samples[0]
            window = max(current - first_time, 1e-6)
            recent = (self._network_bytes - first_bytes) / window
        else:
            recent = average
        return recent, average

    def _byte_totals_locked(self) -> tuple[int, Optional[int]]:
        current_bytes = sum(int(state[0] or 0) for state in self._states.values())
        known = [int(state[1]) for state in self._states.values() if state[1] is not None]
        if not known:
            return current_bytes, None
        average_size = sum(known) / len(known)
        estimated = int(sum(known) + average_size * (self.total_files - len(known)))
        return current_bytes, max(current_bytes, estimated)

    def _line_locked(self, current: float) -> str:
        ratio = self._completed / self.total_files if self.total_files else 1.0
        width = shutil.get_terminal_size(fallback=(120, 24)).columns
        bar_width = 10 if width < 120 else min(24, max(12, width // 10))
        filled = min(bar_width, int(ratio * bar_width))
        if filled < bar_width and self._completed < self.total_files:
            bar = "=" * filled + ">" + "." * (bar_width - filled - 1)
        else:
            bar = "=" * filled + "." * (bar_width - filled)
        elapsed = max(current - self.started_at, 1e-6)
        headline = f"{self.label} [{bar}] {self._completed}/{self.total_files}"
        if self._failed:
            headline += f" fail:{self._failed}"
        parts = [headline]
        if self.show_bytes:
            current_bytes, estimated_bytes = self._byte_totals_locked()
            recent, average = self._speed_locked(current)
            current_text = format_bytes(current_bytes).replace(" ", "")
            if estimated_bytes is None:
                byte_text = current_text
                eta = None
            else:
                total_text = format_bytes(estimated_bytes).replace(" ", "")
                byte_text = f"{current_text}/~{total_text}"
                eta = (
                    max(0, estimated_bytes - current_bytes) / recent
                    if recent > 0
                    else None
                )
            recent_text = format_bytes(recent).replace(" ", "")
            parts.extend([byte_text, f"{recent_text}/s", f"ETA {format_duration(eta)}"])
            if width >= 120:
                average_text = format_bytes(average).replace(" ", "")
                parts.append(f"avg {average_text}/s")
        else:
            rate = self._completed / elapsed
            remaining = max(0, self.total_files - self._completed)
            eta = remaining / rate if rate > 0 else None
            parts.extend([f"{rate:.1f} files/s", f"ETA {format_duration(eta)}"])
        return " | ".join(parts)

    def _render_locked(self, current: Optional[float] = None, force: bool = False) -> None:
        if self._closed:
            return
        timestamp = current if current is not None else time.monotonic()
        interval = self.refresh_interval if self.interactive else self.log_interval
        if not force and timestamp - self._last_render < interval:
            return
        line = self._line_locked(timestamp)
        if self.interactive:
            width = shutil.get_terminal_size(fallback=(120, 24)).columns
            clipped = line[: max(1, width - 1)]
            self.stream.write("\r\033[2K" + clipped)
        else:
            self.stream.write(line + "\n")
        self.stream.flush()
        self._last_render = timestamp
        self._dirty = False


@dataclass(frozen=True)
class TaskSpec:
    manifest: str
    remote_prefix: str
    local_root: str
    extract_by_default: bool = False


TASKS = {
    "video_generation": TaskSpec(
        "video_generation.txt",
        "Leaderboard/Video%20Generation/",
        "leaderboard/video_generation",
    ),
    "future_prediction": TaskSpec(
        "future_prediction.txt",
        "Leaderboard/Future%20Prediction/",
        "leaderboard/future_prediction",
    ),
    "physical_properties_estimation": TaskSpec(
        "physical_properties_estimation.txt",
        "Leaderboard/Physical%20Properties%20Estimation/",
        "leaderboard/physical_properties_estimation",
    ),
    "motion_transfer": TaskSpec(
        "motion_transfer.txt",
        "Leaderboard/Motion%20Transfer/",
        "leaderboard/motion_transfer",
    ),
    "3d_assets": TaskSpec(
        "3d_assets.txt",
        "Assets/PhysicBenchmark/",
        "assets/PhysicBenchmark",
        extract_by_default=True,
    ),
}

ALIASES = {
    "video": "video_generation",
    "vg": "video_generation",
    "future": "future_prediction",
    "fp": "future_prediction",
    "physical_properties": "physical_properties_estimation",
    "physical_property_estimation": "physical_properties_estimation",
    "ppe": "physical_properties_estimation",
    "motion": "motion_transfer",
    "mt": "motion_transfer",
    "assets": "3d_assets",
    "3d": "3d_assets",
}


def utc_now() -> str:
    return datetime.now(timezone.utc).isoformat(timespec="seconds")


def safe_message(exc: BaseException) -> str:
    message = " ".join(str(exc).replace("\t", " ").splitlines()).strip()
    return message or type(exc).__name__


def normalize_task(value: str) -> str:
    slug = value.strip().lower().replace("-", "_").replace(" ", "_")
    slug = ALIASES.get(slug, slug)
    if slug not in TASKS and slug != "all":
        choices = ", ".join([*TASKS, "all"])
        raise argparse.ArgumentTypeError(
            f"unknown task {value!r}; choose one of: {choices}"
        )
    return slug


def selected_tasks(values: Sequence[str]) -> list[str]:
    if not values or "all" in values:
        return list(TASKS)
    return list(dict.fromkeys(values))


def read_manifest(spec: TaskSpec) -> list[str]:
    path = LIST_ROOT / spec.manifest
    if not path.is_file():
        raise RuntimeError(f"missing download manifest: {path}")
    entries = [
        line.strip()
        for line in path.read_text(encoding="utf-8").splitlines()
        if line.strip() and not line.lstrip().startswith("#")
    ]
    if not entries:
        raise RuntimeError(f"empty download manifest: {path}")
    if len(entries) != len(set(entries)):
        raise RuntimeError(f"duplicate paths in download manifest: {path}")
    invalid = [entry for entry in entries if not entry.startswith(spec.remote_prefix)]
    if invalid:
        raise RuntimeError(f"invalid path in {path.name}: {invalid[0]}")
    for entry in entries:
        validate_remote_path(entry)
    return entries


def validate_remote_path(encoded_path: str) -> None:
    decoded = unquote(encoded_path)
    path = PurePosixPath(decoded)
    if path.is_absolute() or not path.parts:
        raise RuntimeError(f"unsafe remote path: {encoded_path}")
    if any(part in {"", ".", ".."} for part in path.parts):
        raise RuntimeError(f"unsafe remote path: {encoded_path}")
    if "\\" in decoded or re.match(r"^[A-Za-z]:", decoded):
        raise RuntimeError(f"unsafe remote path: {encoded_path}")


def local_path_for(output_dir: Path, spec: TaskSpec, remote_path: str) -> Path:
    relative = unquote(remote_path[len(spec.remote_prefix) :])
    parts = PurePosixPath(relative).parts
    if not parts or any(part in {"", ".", ".."} for part in parts):
        raise RuntimeError(f"unsafe relative path: {remote_path}")
    if any(any(character.isspace() for character in part) for part in parts):
        raise RuntimeError(f"local path would contain whitespace: {remote_path}")
    return output_dir.joinpath(*PurePosixPath(spec.local_root).parts, *parts)


def filter_entries(entries: Iterable[str], scene_filters: Sequence[str]) -> list[str]:
    filters = [item.casefold() for item in scene_filters if item.strip()]
    if not filters:
        return list(entries)
    return [
        entry
        for entry in entries
        if any(item in unquote(entry).casefold() for item in filters)
    ]


def build_url(repository: str, revision: str, remote_path: str) -> str:
    encoded_revision = quote(revision, safe="")
    encoded_path = quote(unquote(remote_path), safe="/._-~")
    return (
        f"https://huggingface.co/datasets/{repository}/resolve/"
        f"{encoded_revision}/{encoded_path}?download=true"
    )


@dataclass(frozen=True)
class DownloadResult:
    task: str
    remote_path: str
    local_path: str
    status: str
    bytes_written: int = 0
    error: str = ""


def download_once(
    url: str,
    destination: Path,
    timeout: float,
    resume: bool,
    progress: Optional[DownloadProgress] = None,
    progress_key: object = "",
) -> tuple[str, int]:
    destination.parent.mkdir(parents=True, exist_ok=True)
    partial = destination.with_name(f"{destination.name}.part")
    if not resume and partial.exists():
        partial.unlink()

    offset = partial.stat().st_size if partial.is_file() else 0
    headers = {"User-Agent": USER_AGENT}
    if offset:
        headers["Range"] = f"bytes={offset}-"

    request = urllib.request.Request(url, headers=headers)
    try:
        response = urllib.request.urlopen(request, timeout=timeout)
    except urllib.error.HTTPError as exc:
        if exc.code == 416 and offset:
            content_range = exc.headers.get("Content-Range", "")
            match = re.search(r"\*/(\d+)$", content_range)
            if match and int(match.group(1)) == offset:
                os.replace(partial, destination)
                return "resumed", 0
        raise

    with response:
        status_code = getattr(response, "status", response.getcode())
        append = bool(offset and status_code == 206)
        mode = "ab" if append else "wb"
        starting_size = offset if append else 0
        expected_raw = response.headers.get("Content-Length")
        expected = int(expected_raw) if expected_raw and expected_raw.isdigit() else None
        if progress is not None:
            total_bytes = starting_size + expected if expected is not None else None
            progress.begin_file(progress_key, starting_size, total_bytes)
        written = 0
        with partial.open(mode) as handle:
            while True:
                chunk = response.read(CHUNK_SIZE)
                if not chunk:
                    break
                handle.write(chunk)
                written += len(chunk)
                if progress is not None:
                    progress.advance(progress_key, len(chunk))
        if expected is not None and written != expected:
            raise IOError(
                f"incomplete response: expected {expected} bytes, received {written}"
            )
        if partial.stat().st_size != starting_size + written:
            raise IOError("downloaded file size changed unexpectedly")

    os.replace(partial, destination)
    return ("resumed" if append else "downloaded"), written


def download_file(
    task: str,
    remote_path: str,
    destination: Path,
    revision: str,
    timeout: float,
    retries: int,
    resume: bool,
    force: bool,
    skip_removed_archive: bool,
    repository: str = REPOSITORY,
    progress: Optional[DownloadProgress] = None,
    progress_key: object = "",
) -> DownloadResult:
    if skip_removed_archive and not destination.exists() and marker_matches(destination):
        return DownloadResult(
            task, remote_path, str(destination), "extracted_zip_removed"
        )
    if destination.is_file() and not force:
        return DownloadResult(task, remote_path, str(destination), "reused")
    if destination.exists() and not destination.is_file():
        return DownloadResult(
            task,
            remote_path,
            str(destination),
            "failed",
            error="download target exists and is not a file",
        )
    if force:
        partial = destination.with_name(f"{destination.name}.part")
        if partial.exists():
            partial.unlink()

    url = build_url(repository, revision, remote_path)
    error = ""
    for attempt in range(retries + 1):
        try:
            status, written = download_once(
                url, destination, timeout, resume, progress, progress_key
            )
            return DownloadResult(
                task, remote_path, str(destination), status, bytes_written=written
            )
        except Exception as exc:  # continue independent downloads and report every failure
            error = safe_message(exc)
            if attempt < retries:
                time.sleep(min(2**attempt, 8))
    return DownloadResult(
        task, remote_path, str(destination), "failed", error=error
    )


def is_safe_zip_member(info: zipfile.ZipInfo) -> bool:
    raw = info.filename
    normalized = raw.replace("\\", "/")
    path = PurePosixPath(normalized)
    if raw != normalized or path.is_absolute() or not path.parts:
        return False
    if any(part in {"", ".", ".."} for part in path.parts):
        return False
    if re.match(r"^[A-Za-z]:", normalized):
        return False
    mode = (info.external_attr >> 16) & 0o170000
    return mode != stat.S_IFLNK


def extraction_marker(archive: Path) -> Path:
    return archive.parent / ".physinone_extract_status" / f"{archive.name}.json"


def marker_matches(archive: Path, destination_required: Optional[Path] = None) -> bool:
    marker = extraction_marker(archive)
    if not marker.is_file():
        return False
    if destination_required is not None and not destination_required.is_dir():
        return False
    try:
        state = json.loads(marker.read_text(encoding="utf-8"))
    except (OSError, ValueError):
        return False
    if archive.is_file():
        return state.get("archive_size") == archive.stat().st_size
    return state.get("archive_removed") is True


def write_extraction_marker(archive: Path, file_count: int, removed: bool = False) -> None:
    marker = extraction_marker(archive)
    marker.parent.mkdir(parents=True, exist_ok=True)
    payload = {
        "archive": archive.name,
        "archive_size": archive.stat().st_size if archive.is_file() else None,
        "archive_removed": removed,
        "files": file_count,
        "status": "complete",
        "verified_at": utc_now(),
    }
    marker.write_text(json.dumps(payload, sort_keys=True) + "\n", encoding="utf-8")


def inspect_archive(archive: zipfile.ZipFile) -> list[zipfile.ZipInfo]:
    members = archive.infolist()
    unsafe = [info.filename for info in members if not is_safe_zip_member(info)]
    if unsafe:
        raise RuntimeError(f"unsafe ZIP member: {unsafe[0]}")
    bad = archive.testzip()
    if bad is not None:
        raise RuntimeError(f"ZIP CRC check failed at {bad}")
    return members


def extract_scene_archive(archive_path: Path) -> tuple[str, int, int]:
    destination = archive_path.with_suffix("")
    if marker_matches(archive_path, destination):
        return "already_extracted", 0, 0
    if destination.exists():
        raise RuntimeError(
            f"extraction target exists without a matching marker: {destination}"
        )
    temporary = archive_path.parent / (
        f".{archive_path.stem}.extracting-{os.getpid()}-{threading.get_ident()}"
    )
    if temporary.exists():
        shutil.rmtree(temporary)
    temporary.mkdir(parents=False)
    try:
        with zipfile.ZipFile(archive_path) as archive:
            members = inspect_archive(archive)
            roots = {PurePosixPath(info.filename).parts[0] for info in members}
            if roots != {archive_path.stem}:
                raise RuntimeError(
                    f"unexpected ZIP roots {sorted(roots)}; expected {archive_path.stem!r}"
                )
            archive.extractall(temporary)
            extracted = temporary / archive_path.stem
            if not extracted.is_dir():
                raise RuntimeError("archive did not create the expected scene directory")
            extracted.replace(destination)
        file_count = sum(1 for info in members if not info.is_dir())
        write_extraction_marker(archive_path, file_count)
        return "extracted", file_count, 0
    finally:
        if temporary.exists():
            shutil.rmtree(temporary)


def merge_tree(source_root: Path, destination_root: Path) -> tuple[int, int]:
    added = 0
    reused = 0
    for source in sorted(source_root.rglob("*")):
        relative = source.relative_to(source_root)
        destination = destination_root / relative
        if source.is_dir():
            destination.mkdir(parents=True, exist_ok=True)
            continue
        destination.parent.mkdir(parents=True, exist_ok=True)
        if destination.exists():
            if not destination.is_file():
                raise RuntimeError(f"extraction conflict: {destination}")
            if source.stat().st_size != destination.stat().st_size or not filecmp.cmp(
                source, destination, shallow=False
            ):
                raise RuntimeError(f"extraction would overwrite different data: {destination}")
            source.unlink()
            reused += 1
        else:
            source.replace(destination)
            added += 1
    return added, reused


def extract_asset_archive(archive_path: Path) -> tuple[str, int, int]:
    if marker_matches(archive_path):
        return "already_extracted", 0, 0
    temporary_root = archive_path.parent / ".physinone_extracting"
    temporary = temporary_root / (
        f"{archive_path.stem}-{os.getpid()}-{threading.get_ident()}"
    )
    if temporary.exists():
        shutil.rmtree(temporary)
    temporary.mkdir(parents=True)
    try:
        with zipfile.ZipFile(archive_path) as archive:
            members = inspect_archive(archive)
            archive.extractall(temporary)
        added, reused = merge_tree(temporary, archive_path.parent)
        file_count = sum(1 for info in members if not info.is_dir())
        write_extraction_marker(archive_path, file_count)
        return "extracted", added, reused
    finally:
        if temporary.exists():
            shutil.rmtree(temporary)
        if temporary_root.exists() and not any(temporary_root.iterdir()):
            temporary_root.rmdir()


@dataclass(frozen=True)
class ExtractionResult:
    task: str
    archive: str
    status: str
    added: int = 0
    reused: int = 0
    error: str = ""


class RunLogs:
    def __init__(self, root: Path) -> None:
        self.root = root
        self.root.mkdir(parents=True, exist_ok=True)
        self.downloads = root / "downloads.tsv"
        self.extractions = root / "extractions.tsv"
        self.failures = root / "failures.tsv"
        self._lock = threading.Lock()
        self.downloads.write_text(
            "task\tremote_path\tlocal_path\tstatus\tbytes_written\ttimestamp\n",
            encoding="utf-8",
        )
        self.extractions.write_text(
            "task\tarchive\tstatus\tadded\treused\ttimestamp\n",
            encoding="utf-8",
        )
        self.failures.write_text(
            "stage\ttask\tpath\terror\ttimestamp\n", encoding="utf-8"
        )

    def record_download(self, result: DownloadResult) -> None:
        now = utc_now()
        with self._lock:
            if result.error:
                with self.failures.open("a", encoding="utf-8") as handle:
                    handle.write(
                        f"download\t{result.task}\t{result.remote_path}\t"
                        f"{result.error}\t{now}\n"
                    )
            else:
                with self.downloads.open("a", encoding="utf-8") as handle:
                    handle.write(
                        f"{result.task}\t{result.remote_path}\t{result.local_path}\t"
                        f"{result.status}\t{result.bytes_written}\t{now}\n"
                    )

    def record_extraction(self, result: ExtractionResult) -> None:
        now = utc_now()
        with self._lock:
            if result.error:
                with self.failures.open("a", encoding="utf-8") as handle:
                    handle.write(
                        f"extract\t{result.task}\t{result.archive}\t"
                        f"{result.error}\t{now}\n"
                    )
            else:
                with self.extractions.open("a", encoding="utf-8") as handle:
                    handle.write(
                        f"{result.task}\t{result.archive}\t{result.status}\t"
                        f"{result.added}\t{result.reused}\t{now}\n"
                    )


def should_extract(task: str, requested: Optional[bool]) -> bool:
    if requested is not None:
        return requested
    return TASKS[task].extract_by_default


def extract_download(
    task: str,
    archive: Path,
    delete_after: bool,
) -> ExtractionResult:
    try:
        if task == "3d_assets":
            status, added, reused = extract_asset_archive(archive)
        else:
            status, added, reused = extract_scene_archive(archive)
        if delete_after and archive.is_file():
            file_count = added + reused
            archive.unlink()
            write_extraction_marker(archive, file_count, removed=True)
        return ExtractionResult(task, str(archive), status, added, reused)
    except Exception as exc:
        return ExtractionResult(
            task, str(archive), "failed", error=safe_message(exc)
        )


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(
        description=(
            "Download public PhysInOne Leaderboard data and released 3D assets "
            "with Python standard-library networking."
        )
    )
    parser.add_argument(
        "--task",
        nargs="+",
        type=normalize_task,
        default=["all"],
        help=(
            "Task(s): video_generation, future_prediction, "
            "physical_properties_estimation, motion_transfer, 3d_assets, or all."
        ),
    )
    parser.add_argument(
        "--output-dir",
        type=Path,
        default=Path("PhysInOne_data"),
        help="Local output root without spaces (default: ./PhysInOne_data).",
    )
    parser.add_argument(
        "--scene",
        action="append",
        default=[],
        help="Keep paths containing this scene name or six-character ID; repeatable.",
    )
    parser.add_argument(
        "--workers", type=int, default=4, help="Concurrent downloads (default: 4)."
    )
    parser.add_argument(
        "--revision", default="main", help="Dataset revision (default: main)."
    )
    parser.add_argument(
        "--retries", type=int, default=3, help="Retries after each failure (default: 3)."
    )
    parser.add_argument(
        "--timeout",
        type=float,
        default=60.0,
        help="Network timeout in seconds (default: 60).",
    )
    extraction = parser.add_mutually_exclusive_group()
    extraction.add_argument(
        "--extract", dest="extract", action="store_true", help="Safely extract ZIP files."
    )
    extraction.add_argument(
        "--no-extract",
        dest="extract",
        action="store_false",
        help="Keep all ZIP files compressed.",
    )
    parser.set_defaults(extract=None)
    parser.add_argument(
        "--delete-zip-after-extract",
        action="store_true",
        help="Delete a ZIP only after successful extraction.",
    )
    parser.add_argument(
        "--no-resume",
        action="store_true",
        help="Restart incomplete .part files instead of resuming them.",
    )
    parser.add_argument(
        "--force", action="store_true", help="Replace completed local downloads."
    )
    parser.add_argument(
        "--list-only", action="store_true", help="Print selected public URLs and exit."
    )
    parser.add_argument(
        "--dry-run", action="store_true", help="Show counts and output paths without downloading."
    )
    return parser


def main(argv: Optional[Sequence[str]] = None) -> int:
    args = build_parser().parse_args(argv)
    if args.workers < 1:
        raise SystemExit("--workers must be at least 1")
    if args.retries < 0:
        raise SystemExit("--retries cannot be negative")
    if args.timeout <= 0:
        raise SystemExit("--timeout must be positive")
    if args.delete_zip_after_extract and args.extract is False:
        raise SystemExit("--delete-zip-after-extract cannot be used with --no-extract")
    if any(character.isspace() for character in str(args.output_dir)):
        raise SystemExit("--output-dir must not contain whitespace")

    tasks = selected_tasks(args.task)
    output_dir = args.output_dir.expanduser().resolve()
    selections: list[tuple[str, str, Path]] = []
    counts: dict[str, int] = {}
    for task in tasks:
        spec = TASKS[task]
        entries = filter_entries(read_manifest(spec), args.scene)
        counts[task] = len(entries)
        selections.extend(
            (task, entry, local_path_for(output_dir, spec, entry))
            for entry in entries
        )

    for task in tasks:
        print(f"{task}: {counts[task]} file(s)")
    print(f"total: {len(selections)} file(s)")
    if args.scene and not selections:
        print("No files matched --scene.", file=sys.stderr)
        return 2
    if args.list_only:
        for _, remote_path, _ in selections:
            print(build_url(REPOSITORY, args.revision, remote_path))
        return 0
    if args.dry_run:
        for task in tasks:
            print(f"{task} -> {output_dir / TASKS[task].local_root}")
        return 0

    output_dir.mkdir(parents=True, exist_ok=True)
    run_id = datetime.now().strftime("%Y%m%d_%H%M%S")
    logs = RunLogs(output_dir / "_download_logs" / run_id)
    results: list[DownloadResult] = []
    progress = DownloadProgress(len(selections), "Downloading")
    try:
        with ThreadPoolExecutor(max_workers=args.workers) as pool:
            futures = {
                pool.submit(
                    download_file,
                    task,
                    remote_path,
                    destination,
                    args.revision,
                    args.timeout,
                    args.retries,
                    not args.no_resume,
                    args.force,
                    (
                        args.delete_zip_after_extract
                        and should_extract(task, args.extract)
                        and remote_path.lower().endswith(".zip")
                    ),
                    REPOSITORY,
                    progress,
                    index,
                ): index
                for index, (task, remote_path, destination) in enumerate(selections)
            }
            for future in as_completed(futures):
                key = futures[future]
                result = future.result()
                results.append(result)
                logs.record_download(result)
                progress.complete(
                    key, result.status, result.local_path, failed=bool(result.error)
                )
    finally:
        progress.finish()

    extraction_results: list[ExtractionResult] = []
    successful = {
        (result.task, result.remote_path): Path(result.local_path)
        for result in results
        if not result.error
    }
    extraction_plan = [
        item
        for item in selections
        if item[1].lower().endswith(".zip") and should_extract(item[0], args.extract)
    ]
    if extraction_plan:
        extraction_progress = DownloadProgress(
            len(extraction_plan), "Extracting", show_bytes=False
        )
        try:
            for index, (task, remote_path, destination) in enumerate(extraction_plan):
                archive = successful.get((task, remote_path), destination)
                marker = extraction_marker(archive)
                if not archive.is_file() and marker_matches(archive):
                    result = ExtractionResult(
                        task, str(archive), "already_extracted_zip_removed"
                    )
                elif not archive.is_file():
                    result = ExtractionResult(
                        task,
                        str(archive),
                        "failed",
                        error="archive is unavailable because its download failed",
                    )
                else:
                    result = extract_download(task, archive, args.delete_zip_after_extract)
                extraction_results.append(result)
                logs.record_extraction(result)
                extraction_progress.complete(
                    index, result.status, result.archive, failed=bool(result.error)
                )
        finally:
            extraction_progress.finish()

    download_failures = sum(1 for result in results if result.error)
    extraction_failures = sum(1 for result in extraction_results if result.error)
    summary = {
        "repository": REPOSITORY,
        "revision": args.revision,
        "tasks": tasks,
        "selected_files": len(selections),
        "successful_downloads": len(results) - download_failures,
        "download_failures": download_failures,
        "completed_extractions": len(extraction_results) - extraction_failures,
        "extraction_failures": extraction_failures,
        "output_dir": str(output_dir),
        "log_dir": str(logs.root),
        "finished_at": utc_now(),
    }
    (logs.root / "summary.json").write_text(
        json.dumps(summary, indent=2, sort_keys=True) + "\n", encoding="utf-8"
    )
    print(json.dumps(summary, indent=2, sort_keys=True))
    return 1 if download_failures or extraction_failures else 0


if __name__ == "__main__":
    raise SystemExit(main())