| |
| """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: |
| 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()) |
|
|
