Add small-scene-first upload script

tools/pack_and_upload_scenes.py

@@ -0,0 +1,964 @@
+#!/usr/bin/env python3
+import argparse
+import ast
+import json
+import os
+import re
+import shutil
+import ssl
+import struct
+import subprocess
+import sys
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime
+from pathlib import Path
+
+
+EXCLUDED_DIRS = {
+    ".agents",
+    ".cache",
+    ".codex",
+    ".git",
+    ".vscode",
+    "__pycache__",
+    "_hf_scene_archives",
+    "alignment_test_outputs",
+    "outputs",
+}
+
+IMAGE_EXTENSIONS = {
+    ".bmp",
+    ".gif",
+    ".jpeg",
+    ".jpg",
+    ".png",
+    ".tif",
+    ".tiff",
+    ".webp",
+}
+
+PNG_MODALITY_FILTERS = {
+    "image": "Lanczos",
+    "depth": "Triangle",
+    "flow": "Triangle",
+    "flow_scaled": "Triangle",
+}
+
+DEFAULT_NUMPY_PYTHON = Path("/home/wangxy/miniconda3/envs/promptdepth/bin/python")
+
+
+def log(message: str) -> None:
+    now = datetime.now().isoformat(timespec="seconds")
+    print(f"[{now}] {message}", flush=True)
+
+
+def human_bytes(size: float) -> str:
+    units = ("B", "KiB", "MiB", "GiB", "TiB")
+    value = float(size)
+    for unit in units:
+        if abs(value) < 1024.0 or unit == units[-1]:
+            if unit == "B":
+                return f"{value:.0f} {unit}"
+            return f"{value:.1f} {unit}"
+        value /= 1024.0
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Pack each scene as a tar.zst archive and upload archives to Hugging Face."
+    )
+    parser.add_argument("repo_id", help="Dataset repo id, for example Yukki1011/PromptDepth")
+    parser.add_argument("--private", action="store_true", help="Create repo as private if needed")
+    parser.add_argument(
+        "--archive-dir",
+        default="_hf_scene_archives",
+        help="Temporary directory for scene archives",
+    )
+    parser.add_argument(
+        "--delete-after-upload",
+        action="store_true",
+        help="Delete each scene archive after it is uploaded successfully",
+    )
+    parser.add_argument(
+        "--zstd-level",
+        type=int,
+        default=1,
+        help="zstd compression level. 1 is fastest and usually best for PNG-heavy data",
+    )
+    parser.add_argument(
+        "--rate-limit-sleep",
+        type=int,
+        default=5,
+        help="Seconds to sleep before retrying after a rate limit",
+    )
+    parser.add_argument(
+        "--only",
+        nargs="*",
+        default=None,
+        help="Optional scene names to process. Default: all scenes",
+    )
+    parser.add_argument(
+        "--workers",
+        type=int,
+        default=1,
+        help="Number of scenes to pack/upload in parallel. Use 1 for sequential processing",
+    )
+    parser.add_argument(
+        "--max-image-width",
+        type=int,
+        default=1280,
+        help="Resize uploaded image files to fit within this width. Default keeps 720p width",
+    )
+    parser.add_argument(
+        "--max-image-height",
+        type=int,
+        default=720,
+        help="Resize uploaded image files to fit within this height. Default keeps 720p height",
+    )
+    parser.add_argument(
+        "--staging-progress-every",
+        type=int,
+        default=10,
+        help="Seconds between staging progress log updates",
+    )
+    parser.add_argument(
+        "--progress-every",
+        type=int,
+        default=30,
+        help="Deprecated. Hugging Face/Xet progress output is used when available.",
+    )
+    return parser.parse_args()
+
+
+def retry_delay_seconds(message: str, default_hourly_sleep: int) -> int | None:
+    lower = message.lower()
+    if "repository commits" in lower and "rate limit" in lower:
+        return default_hourly_sleep
+    if "too many requests" in lower or "429" in lower:
+        return default_hourly_sleep
+    retry_after = re.search(r"retry after\s+(\d+)\s+seconds", lower)
+    if retry_after:
+        return default_hourly_sleep
+    transient_network_markers = (
+        "broken pipe",
+        "connection error",
+        "unexpected_eof_while_reading",
+        "unexpected eof",
+        "connection reset",
+        "connection aborted",
+        "connecterror",
+        "connectionerror",
+        "connection timed out",
+        "connection timeout",
+        "connect timeout",
+        "http error",
+        "httperror",
+        "incomplete read",
+        "incompleteread",
+        "max retries exceeded",
+        "network is unreachable",
+        "no route to host",
+        "operation timed out",
+        "protocolerror",
+        "readtimeout",
+        "read timed out",
+        "request timeout",
+        "request timed out",
+        "temporarily unavailable",
+        "remote disconnected",
+        "remote end closed connection",
+        "protocol violation",
+        "tlsv1 alert",
+        "client has been closed",
+        "connection refused",
+        "name resolution",
+        "temporary failure in name resolution",
+    )
+    if any(marker in lower for marker in transient_network_markers):
+        return max(10, default_hourly_sleep)
+    return None
+
+
+def describe_proxy_environment() -> None:
+    proxy_vars = ("HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "http_proxy", "https_proxy", "all_proxy")
+    configured = [f"{name}={os.environ[name]}" for name in proxy_vars if os.environ.get(name)]
+    if configured:
+        log("Proxy environment detected: " + ", ".join(configured))
+        if any("127.0.0.1:" in value or "localhost:" in value for value in configured):
+            log("Localhost proxy detected; make sure the proxy is running on this server, not only on your laptop.")
+
+
+def scene_dirs(root: Path, only: list[str] | None) -> list[Path]:
+    selected = set(only or [])
+    scenes = []
+    for child in sorted(root.iterdir()):
+        if not child.is_dir() or child.name in EXCLUDED_DIRS:
+            continue
+        if selected and child.name not in selected:
+            continue
+        scenes.append(child)
+    scenes.sort(key=lambda scene: (directory_size_bytes(scene), scene.name))
+    return scenes
+
+
+def directory_size_bytes(path: Path) -> int:
+    total = 0
+    stack = [path]
+    while stack:
+        current = stack.pop()
+        try:
+            with os.scandir(current) as entries:
+                for entry in entries:
+                    try:
+                        if entry.is_dir(follow_symlinks=False):
+                            stack.append(Path(entry.path))
+                        elif entry.is_file(follow_symlinks=False):
+                            total += entry.stat(follow_symlinks=False).st_size
+                    except OSError:
+                        log(f"WARNING: cannot stat while sizing scene, skipping: {entry.path}")
+        except OSError:
+            log(f"WARNING: cannot scan while sizing scene, skipping: {current}")
+    return total
+
+
+def run_checked(cmd: list[str], cwd: Path) -> None:
+    log("+ " + " ".join(cmd))
+    subprocess.run(cmd, cwd=cwd, check=True)
+
+
+def archive_marker_payload(max_image_width: int, max_image_height: int) -> dict[str, object]:
+    return {
+        "created_at": datetime.now().isoformat(timespec="seconds"),
+        "image_downsample": {
+            "enabled": True,
+            "version": "modality-aware-v2",
+            "max_width": max_image_width,
+            "max_height": max_image_height,
+        },
+    }
+
+
+def archive_marker_matches(marker: Path, max_image_width: int, max_image_height: int) -> bool:
+    if not marker.exists():
+        return False
+    try:
+        payload = json.loads(marker.read_text())
+    except (json.JSONDecodeError, OSError):
+        return False
+    image_downsample = payload.get("image_downsample")
+    if not isinstance(image_downsample, dict):
+        return False
+    return (
+        image_downsample.get("enabled") is True
+        and image_downsample.get("version") == "modality-aware-v2"
+        and image_downsample.get("max_width") == max_image_width
+        and image_downsample.get("max_height") == max_image_height
+    )
+
+
+def image_dimensions(path: Path) -> tuple[int, int] | None:
+    result = subprocess.run(
+        ["identify", "-ping", "-format", "%w %h", str(path)],
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        check=False,
+    )
+    if result.returncode != 0:
+        log(f"WARNING: cannot identify image, keeping original: {path} ({result.stderr.strip()})")
+        return None
+    try:
+        width_text, height_text = result.stdout.strip().split()
+        return int(width_text), int(height_text)
+    except ValueError:
+        log(f"WARNING: unexpected identify output for {path}: {result.stdout.strip()!r}")
+        return None
+
+
+def npy_shape(path: Path) -> tuple[int, ...] | None:
+    try:
+        with path.open("rb") as handle:
+            if handle.read(6) != b"\x93NUMPY":
+                return None
+            major, _minor = handle.read(2)
+            if major == 1:
+                header_len = struct.unpack("<H", handle.read(2))[0]
+            elif major in (2, 3):
+                header_len = struct.unpack("<I", handle.read(4))[0]
+            else:
+                return None
+            header = handle.read(header_len).decode("latin1")
+        payload = ast.literal_eval(header)
+        shape = payload.get("shape")
+        if isinstance(shape, tuple) and all(isinstance(value, int) for value in shape):
+            return shape
+    except (OSError, SyntaxError, ValueError, struct.error):
+        return None
+    return None
+
+
+def numpy_python() -> str:
+    configured = os.environ.get("NPY_RESIZE_PYTHON")
+    if configured:
+        return configured
+    if DEFAULT_NUMPY_PYTHON.exists():
+        return str(DEFAULT_NUMPY_PYTHON)
+    return sys.executable
+
+
+def check_numpy_python() -> bool:
+    result = subprocess.run(
+        [numpy_python(), "-c", "import numpy"],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.PIPE,
+        text=True,
+        check=False,
+    )
+    if result.returncode == 0:
+        return True
+    log(
+        "ERROR: instance .npy resizing needs numpy. "
+        f"Tried {numpy_python()}: {result.stderr.strip()}"
+    )
+    return False
+
+
+def hardlink_or_copy(source: Path, dest: Path) -> None:
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        os.link(source, dest)
+    except OSError:
+        shutil.copy2(source, dest)
+
+
+def resize_image(source: Path, dest: Path, resize_geometry: str, filter_name: str) -> None:
+    subprocess.run(
+        [
+            "convert",
+            str(source),
+            "-filter",
+            filter_name,
+            "-resize",
+            resize_geometry,
+            str(dest),
+        ],
+        check=True,
+    )
+
+
+def path_modality(path: Path) -> str:
+    parts = path.parts
+    if len(parts) >= 2:
+        return parts[-2]
+    return ""
+
+
+def image_filter_for(source: Path) -> str:
+    return PNG_MODALITY_FILTERS.get(path_modality(source), "Lanczos")
+
+
+def npy_resize_helper_script() -> str:
+    return r"""
+import sys
+from pathlib import Path
+
+import numpy as np
+
+
+def nearest_indices(old_size: int, new_size: int) -> np.ndarray:
+    if old_size == new_size:
+        return np.arange(old_size)
+    scale = old_size / new_size
+    return np.minimum((np.arange(new_size) * scale).astype(np.int64), old_size - 1)
+
+
+source = Path(sys.argv[1])
+dest = Path(sys.argv[2])
+new_width = int(sys.argv[3])
+new_height = int(sys.argv[4])
+array = np.load(source)
+if array.ndim < 2:
+    raise ValueError(f"Expected at least 2D array, got shape {array.shape} for {source}")
+old_height, old_width = array.shape[:2]
+y_idx = nearest_indices(old_height, new_height)
+x_idx = nearest_indices(old_width, new_width)
+resized = array[y_idx][:, x_idx]
+dest.parent.mkdir(parents=True, exist_ok=True)
+np.save(dest, resized)
+"""
+
+
+def resize_npy_nearest(source: Path, dest: Path, new_width: int, new_height: int) -> None:
+    subprocess.run(
+        [
+            numpy_python(),
+            "-c",
+            npy_resize_helper_script(),
+            str(source),
+            str(dest),
+            str(new_width),
+            str(new_height),
+        ],
+        check=True,
+    )
+
+
+def scaled_size(width: int, height: int, max_width: int, max_height: int) -> tuple[int, int]:
+    scale = min(max_width / width, max_height / height, 1.0)
+    new_width = max(1, int(round(width * scale)))
+    new_height = max(1, int(round(height * scale)))
+    return new_width, new_height
+
+
+def progress_bar(done: int, total: int, width: int = 24) -> str:
+    if total <= 0:
+        return "[" + "-" * width + "]"
+    filled = min(width, int(width * done / total))
+    return "[" + "#" * filled + "-" * (width - filled) + "]"
+
+
+def log_staging_progress(
+    scene_name: str,
+    processed_entries: int,
+    total_entries: int,
+    processed_images: int,
+    total_images: int,
+    resized_count: int,
+) -> None:
+    percent = 100.0 if total_entries <= 0 else processed_entries * 100.0 / total_entries
+    log(
+        f"Staging {scene_name}: {progress_bar(processed_entries, total_entries)} "
+        f"{percent:5.1f}% ({processed_entries}/{total_entries} entries), "
+        f"images {processed_images}/{total_images}, resized {resized_count}"
+    )
+
+
+def stage_scene_for_archive(
+    scene: Path,
+    staging_root: Path,
+    max_image_width: int,
+    max_image_height: int,
+    progress_interval: int,
+) -> tuple[Path, int, int]:
+    staged_scene = staging_root / scene.name
+    if staged_scene.exists():
+        shutil.rmtree(staged_scene)
+    staged_scene.mkdir(parents=True, exist_ok=True)
+
+    entries = list(scene.rglob("*"))
+    total_entries = len(entries)
+    total_images = sum(
+        1
+        for path in entries
+        if path.is_file() and path.suffix.lower() in IMAGE_EXTENSIONS
+    )
+    image_count = 0
+    resized_count = 0
+    npy_count = 0
+    resized_npy_count = 0
+    resize_records: dict[str, dict[str, object]] = {}
+    resize_geometry = f"{max_image_width}x{max_image_height}>"
+    next_progress_at = time.monotonic()
+    log_staging_progress(scene.name, 0, total_entries, 0, total_images, 0)
+
+    for processed_entries, source in enumerate(entries, start=1):
+        relative = source.relative_to(scene)
+        dest = staged_scene / relative
+
+        if source.is_dir():
+            dest.mkdir(parents=True, exist_ok=True)
+        elif source.is_symlink():
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            os.symlink(os.readlink(source), dest)
+        elif not source.is_file():
+            pass
+        elif source.suffix.lower() == ".npy" and path_modality(source) == "instance":
+            npy_count += 1
+            array_shape = npy_shape(source)
+            if not array_shape or len(array_shape) < 2:
+                hardlink_or_copy(source, dest)
+            else:
+                height, width = array_shape[:2]
+                new_width, new_height = scaled_size(width, height, max_image_width, max_image_height)
+                if width <= max_image_width and height <= max_image_height:
+                    hardlink_or_copy(source, dest)
+                else:
+                    resize_npy_nearest(source, dest, new_width, new_height)
+                    resized_npy_count += 1
+                    resize_records[str(relative)] = {
+                        "modality": "instance",
+                        "original_size": [width, height],
+                        "resized_size": [new_width, new_height],
+                        "interpolation": "nearest",
+                    }
+        elif source.suffix.lower() not in IMAGE_EXTENSIONS:
+            hardlink_or_copy(source, dest)
+        else:
+            image_count += 1
+            dimensions = image_dimensions(source)
+            if dimensions is None:
+                hardlink_or_copy(source, dest)
+            else:
+                width, height = dimensions
+                new_width, new_height = scaled_size(width, height, max_image_width, max_image_height)
+                if width <= max_image_width and height <= max_image_height:
+                    hardlink_or_copy(source, dest)
+                else:
+                    dest.parent.mkdir(parents=True, exist_ok=True)
+                    filter_name = image_filter_for(source)
+                    resize_image(source, dest, resize_geometry, filter_name)
+                    resized_count += 1
+                    resize_records[str(relative)] = {
+                        "modality": path_modality(source) or "image",
+                        "original_size": [width, height],
+                        "resized_size": [new_width, new_height],
+                        "interpolation": filter_name,
+                    }
+
+        now = time.monotonic()
+        if processed_entries == total_entries or now >= next_progress_at:
+            log_staging_progress(
+                scene.name,
+                processed_entries,
+                total_entries,
+                image_count,
+                total_images,
+                resized_count,
+            )
+            next_progress_at = now + max(1, progress_interval)
+
+    metadata = {
+        "created_at": datetime.now().isoformat(timespec="seconds"),
+        "max_size": [max_image_width, max_image_height],
+        "notes": [
+            "RGB/image PNG files use Lanczos interpolation.",
+            "Depth and optical-flow PNG encodings use linear Triangle interpolation.",
+            "Instance .npy label maps use nearest-neighbor resizing to preserve IDs.",
+            "Flow PNG values in this dataset are normalized encodings; pixel scaling is applied at decode time using the resized width and height.",
+            "Camera JSON files in this dataset contain pose only. If downstream code uses intrinsics, scale fx/cx by resized_width/original_width and fy/cy by resized_height/original_height.",
+        ],
+        "counts": {
+            "images": image_count,
+            "resized_images": resized_count,
+            "instance_arrays": npy_count,
+            "resized_instance_arrays": resized_npy_count,
+        },
+        "files": resize_records,
+    }
+    (staged_scene / "_resize_metadata.json").write_text(json.dumps(metadata, indent=2) + "\n")
+    return staged_scene, image_count, resized_count
+
+
+def configure_huggingface_cache(root: Path) -> None:
+    cache_root = root / ".cache" / "huggingface"
+    tmp_root = root / ".cache" / "tmp"
+    xet_cache = cache_root / "xet"
+    for path in (cache_root, tmp_root, xet_cache):
+        path.mkdir(parents=True, exist_ok=True)
+
+    os.environ.setdefault("HF_HOME", str(cache_root))
+    os.environ.setdefault("HF_XET_CACHE", str(xet_cache))
+    os.environ.setdefault("TMPDIR", str(tmp_root))
+    os.environ.setdefault("TEMP", str(tmp_root))
+    os.environ.setdefault("TMP", str(tmp_root))
+    os.environ.setdefault("HF_XET_HIGH_PERFORMANCE", "1")
+
+
+def log_disk_space(path: Path) -> None:
+    usage = shutil.disk_usage(path)
+    log(
+        f"Disk space for {path}: {human_bytes(usage.free)} free "
+        f"of {human_bytes(usage.total)} total"
+    )
+
+
+def build_archive(
+    root: Path,
+    scene: Path,
+    archive_dir: Path,
+    zstd_level: int,
+    max_image_width: int,
+    max_image_height: int,
+    staging_progress_every: int,
+) -> Path:
+    archive_dir.mkdir(parents=True, exist_ok=True)
+    archive = archive_dir / f"{scene.name}.tar.zst"
+    complete_marker = archive_dir / f"{scene.name}.tar.zst.done"
+    tmp_archive = archive_dir / f"{scene.name}.tar.zst.tmp"
+
+    if archive.exists() and archive_marker_matches(complete_marker, max_image_width, max_image_height):
+        log(f"Archive already exists, skipping pack: {archive}")
+        return archive
+
+    tmp_archive.unlink(missing_ok=True)
+    complete_marker.unlink(missing_ok=True)
+
+    staging_root = archive_dir / ".staging" / scene.name
+    try:
+        log(
+            f"Staging scene with image resize limit {max_image_width}x{max_image_height}: "
+            f"{scene.name}"
+        )
+        staged_scene, image_count, resized_count = stage_scene_for_archive(
+            scene,
+            staging_root,
+            max_image_width,
+            max_image_height,
+            staging_progress_every,
+        )
+        log(
+            f"Image staging complete for {scene.name}: "
+            f"{resized_count}/{image_count} images resized"
+        )
+        log(f"Packing scene: {scene.name}")
+        run_checked(
+            [
+                "tar",
+                "-I",
+                f"zstd -T0 -{zstd_level}",
+                "-cf",
+                str(tmp_archive),
+                scene.name,
+            ],
+            cwd=staged_scene.parent,
+        )
+        tmp_archive.rename(archive)
+    finally:
+        shutil.rmtree(staging_root, ignore_errors=True)
+
+    complete_marker.write_text(
+        json.dumps(archive_marker_payload(max_image_width, max_image_height), indent=2) + "\n"
+    )
+    log(f"Packed archive: {archive}")
+    return archive
+
+
+def upload_with_retry(
+    api,
+    description: str,
+    rate_limit_sleep: int,
+    func,
+    *args,
+    **kwargs,
+) -> object:
+    attempt = 1
+    while True:
+        try:
+            log(f"{description} (attempt {attempt})")
+            return func(*args, **kwargs)
+        except (Exception, ssl.SSLError) as exc:
+            delay = retry_delay_seconds(str(exc), rate_limit_sleep)
+            if delay is None:
+                log(f"ERROR: {description} failed: {exc}")
+                raise
+            log(f"Retryable error during: {description}: {exc}. Sleeping {delay} seconds.")
+            time.sleep(delay)
+            attempt += 1
+
+
+def upload_archive_with_retry(
+    token: str,
+    archive: Path,
+    repo_id: str,
+    rate_limit_sleep: int,
+    overall_prefix: str,
+) -> None:
+    from huggingface_hub import HfApi
+
+    path_in_repo = f"archives/{archive.name}"
+    description = f"Uploading {archive.name} to {repo_id}/{path_in_repo}"
+    total_bytes = archive.stat().st_size
+    attempt = 1
+    while True:
+        try:
+            api = HfApi(token=token)
+            log(f"{description} (attempt {attempt})")
+            log(
+                f"Starting Hugging Face upload progress for {overall_prefix}{archive.name} "
+                f"({human_bytes(total_bytes)})"
+            )
+            api.upload_file(
+                path_or_fileobj=archive,
+                path_in_repo=path_in_repo,
+                repo_id=repo_id,
+                repo_type="dataset",
+                commit_message=f"Add {archive.name}",
+            )
+            break
+        except (Exception, ssl.SSLError) as exc:
+            delay = retry_delay_seconds(str(exc), rate_limit_sleep)
+            if delay is None:
+                log(f"ERROR: {description} failed: {exc}")
+                raise
+            log(f"Retryable error during: {description}: {exc}. Sleeping {delay} seconds.")
+            time.sleep(delay)
+            attempt += 1
+    log(f"Uploaded: {archive.name}")
+
+
+def remote_file_exists_with_retry(
+    api,
+    repo_id: str,
+    path_in_repo: str,
+    rate_limit_sleep: int,
+) -> bool:
+    return bool(
+        upload_with_retry(
+            api,
+            f"Checking remote file: {path_in_repo}",
+            rate_limit_sleep,
+            api.file_exists,
+            repo_id=repo_id,
+            filename=path_in_repo,
+            repo_type="dataset",
+        )
+    )
+
+
+def already_uploaded(
+    api,
+    repo_id: str,
+    path_in_repo: str,
+    marker: Path,
+    rate_limit_sleep: int,
+) -> bool:
+    exists = remote_file_exists_with_retry(api, repo_id, path_in_repo, rate_limit_sleep)
+    if exists:
+        if not marker.exists():
+            marker.write_text(datetime.now().isoformat(timespec="seconds") + "\n")
+        return True
+    if marker.exists():
+        log(f"Local uploaded marker is stale, removing: {marker}")
+        marker.unlink()
+    return False
+
+
+def write_manifest(root: Path, scenes: list[Path], archive_dir: Path) -> Path:
+    manifest = {
+        "created_at": datetime.now().isoformat(timespec="seconds"),
+        "format": "One tar.zst archive per scene under archives/",
+        "scenes": [scene.name for scene in scenes],
+    }
+    path = archive_dir / "archive_manifest.json"
+    archive_dir.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(manifest, indent=2) + "\n")
+    return path
+
+
+def process_scene(
+    token: str,
+    root: Path,
+    scene: Path,
+    scene_index: int,
+    total_scenes: int,
+    archive_dir: Path,
+    repo_id: str,
+    rate_limit_sleep: int,
+    zstd_level: int,
+    max_image_width: int,
+    max_image_height: int,
+    staging_progress_every: int,
+    delete_after_upload: bool,
+    uploaded_dir: Path,
+) -> str:
+    from huggingface_hub import HfApi
+
+    api = HfApi(token=token)
+    overall_prefix = f"scene {scene_index}/{total_scenes} "
+    uploaded_marker = uploaded_dir / f"{scene.name}.uploaded"
+    path_in_repo = f"archives/{scene.name}.tar.zst"
+    if already_uploaded(
+        api,
+        repo_id,
+        path_in_repo,
+        uploaded_marker,
+        rate_limit_sleep,
+    ):
+        log(f"Scene {scene_index}/{total_scenes} already exists on remote, skipping: {scene.name}")
+        return scene.name
+
+    archive = build_archive(
+        root,
+        scene,
+        archive_dir,
+        zstd_level,
+        max_image_width,
+        max_image_height,
+        staging_progress_every,
+    )
+    upload_archive_with_retry(
+        token,
+        archive,
+        repo_id,
+        rate_limit_sleep,
+        overall_prefix,
+    )
+    uploaded_marker.write_text(
+        json.dumps(archive_marker_payload(max_image_width, max_image_height), indent=2) + "\n"
+    )
+    if delete_after_upload:
+        log(f"Deleting uploaded archive to save disk: {archive}")
+        archive.unlink(missing_ok=True)
+        archive.with_suffix(archive.suffix + ".done").unlink(missing_ok=True)
+    return scene.name
+
+
+def main() -> int:
+    args = parse_args()
+    token = os.environ.get("HF_TOKEN")
+    if not token:
+        log("ERROR: HF_TOKEN is not set.")
+        log("Run: export HF_TOKEN=hf_xxx")
+        return 1
+
+    if not shutil.which("tar") or not shutil.which("zstd"):
+        log("ERROR: both tar and zstd must be installed.")
+        return 1
+    if not shutil.which("identify") or not shutil.which("convert"):
+        log("ERROR: ImageMagick identify and convert must be installed for image downsampling.")
+        return 1
+    if args.workers < 1:
+        log("ERROR: --workers must be at least 1.")
+        return 1
+    if args.max_image_width < 1 or args.max_image_height < 1:
+        log("ERROR: --max-image-width and --max-image-height must be at least 1.")
+        return 1
+    if args.staging_progress_every < 1:
+        log("ERROR: --staging-progress-every must be at least 1.")
+        return 1
+    if not check_numpy_python():
+        return 1
+
+    root = Path(__file__).resolve().parent
+    configure_huggingface_cache(root)
+
+    from huggingface_hub import HfApi
+
+    archive_dir = root / args.archive_dir
+    scenes = scene_dirs(root, args.only)
+    if not scenes:
+        log("ERROR: no scene directories found.")
+        return 1
+
+    log(f"Dataset root: {root}")
+    log(f"Target repo: {args.repo_id}")
+    log(f"Scenes to process: {len(scenes)}")
+    log(f"Archive directory: {archive_dir}")
+    log(f"Delete archive after upload: {args.delete_after_upload}")
+    log(f"Scene workers: {args.workers}")
+    log(f"Upload image resize limit: {args.max_image_width}x{args.max_image_height}")
+    log(f"Staging progress interval: {args.staging_progress_every} seconds")
+    log(f"NumPy resize Python: {numpy_python()}")
+    log(f"HF_HOME: {os.environ['HF_HOME']}")
+    log(f"HF_XET_CACHE: {os.environ['HF_XET_CACHE']}")
+    log(f"TMPDIR: {os.environ['TMPDIR']}")
+    log_disk_space(Path(os.environ["HF_XET_CACHE"]))
+    log_disk_space(archive_dir)
+    describe_proxy_environment()
+
+    uploaded_dir = archive_dir / ".uploaded"
+    uploaded_dir.mkdir(parents=True, exist_ok=True)
+
+    api = HfApi(token=token)
+    upload_with_retry(
+        api,
+        f"Ensuring repo exists: {args.repo_id}",
+        args.rate_limit_sleep,
+        api.create_repo,
+        repo_id=args.repo_id,
+        repo_type="dataset",
+        private=args.private,
+        exist_ok=True,
+    )
+
+    manifest = write_manifest(root, scenes, archive_dir)
+    manifest_marker = uploaded_dir / "archive_manifest.uploaded"
+    if already_uploaded(api, args.repo_id, "archive_manifest.json", manifest_marker, args.rate_limit_sleep):
+        log("Archive manifest already exists on remote, skipping.")
+    else:
+        upload_with_retry(
+            api,
+            "Uploading archive manifest",
+            args.rate_limit_sleep,
+            api.upload_file,
+            path_or_fileobj=manifest,
+            path_in_repo="archive_manifest.json",
+            repo_id=args.repo_id,
+            repo_type="dataset",
+            commit_message="Add archive manifest",
+        )
+        manifest_marker.write_text(datetime.now().isoformat(timespec="seconds") + "\n")
+
+    readme = root / "README.md"
+    readme_marker = uploaded_dir / "README.uploaded"
+    if readme.exists() and already_uploaded(api, args.repo_id, "README.md", readme_marker, args.rate_limit_sleep):
+        log("README already exists on remote, skipping.")
+    elif readme.exists():
+        upload_with_retry(
+            api,
+            "Uploading README",
+            args.rate_limit_sleep,
+            api.upload_file,
+            path_or_fileobj=readme,
+            path_in_repo="README.md",
+            repo_id=args.repo_id,
+            repo_type="dataset",
+            commit_message="Add dataset card",
+        )
+        readme_marker.write_text(datetime.now().isoformat(timespec="seconds") + "\n")
+
+    if args.workers == 1:
+        for scene_index, scene in enumerate(scenes, start=1):
+            process_scene(
+                token,
+                root,
+                scene,
+                scene_index,
+                len(scenes),
+                archive_dir,
+                args.repo_id,
+                args.rate_limit_sleep,
+                args.zstd_level,
+                args.max_image_width,
+                args.max_image_height,
+                args.staging_progress_every,
+                args.delete_after_upload,
+                uploaded_dir,
+            )
+    else:
+        log(
+            "Parallel mode enabled. Disk usage can grow by roughly "
+            f"{args.workers} archives while uploads are in flight."
+        )
+        with ThreadPoolExecutor(max_workers=args.workers) as executor:
+            futures = [
+                executor.submit(
+                    process_scene,
+                    token,
+                    root,
+                    scene,
+                    scene_index,
+                    len(scenes),
+                    archive_dir,
+                    args.repo_id,
+                    args.rate_limit_sleep,
+                    args.zstd_level,
+                    args.max_image_width,
+                    args.max_image_height,
+                    args.staging_progress_every,
+                    args.delete_after_upload,
+                    uploaded_dir,
+                )
+                for scene_index, scene in enumerate(scenes, start=1)
+            ]
+            for future in as_completed(futures):
+                scene_name = future.result()
+                log(f"Scene finished: {scene_name}")
+
+    log("All selected scenes were packed and uploaded.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())