mirror_worker.py

# /// script
# requires-python = ">=3.10"
# dependencies = ["huggingface_hub>=1.0.0", "httpx[http2]>=0.27"]
# ///
"""Resumable, bounded-storage ModelScope -> HF Dataset mirror worker."""

from __future__ import annotations

import os
import shutil
import time
import json
import hashlib
import math
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
from urllib.parse import urlencode

import httpx
from huggingface_hub import CommitOperationAdd, HfApi, hf_hub_download

SOURCE_REPO = "daimonrobotics/Daimon-Infinity"
DEST_REPO = "mrfakename/Daimon-Infinity"
WORKER_INDEX = int(os.environ["WORKER_INDEX"])
WORKER_COUNT = int(os.environ["WORKER_COUNT"])
MODELSCOPE_TOKEN = os.environ["MODELSCOPE_TOKEN"]
HF_TOKEN = os.environ["HF_TOKEN"]
WORKDIR = Path("/tmp/daimon-infinity")


def retry(action, label: str, attempts: int = 6):
    for attempt in range(attempts):
        try:
            return action()
        except Exception:
            if attempt == attempts - 1:
                raise
            time.sleep(min(180, 2 ** attempt * 5))


def commit_batch(target: HfApi, batch: list[tuple[str, Path]]) -> None:
    """Upload many staged files in one Hub commit, respecting 429 cooldowns."""
    operations = [
        CommitOperationAdd(path_in_repo=path, path_or_fileobj=str(local))
        for path, local in batch
    ]
    for attempt in range(8):
        try:
            target.create_commit(
                repo_id=DEST_REPO,
                repo_type="dataset",
                operations=operations,
                commit_message=f"Mirror batch: {len(batch)} files",
            )
            return
        except Exception as exc:
            if "429" in str(exc):
                # HF reports an hour-long repository commit cooldown.
                time.sleep(3700)
            elif attempt == 7:
                raise
            else:
                time.sleep(min(300, 2 ** attempt * 10))


def direct_download(path: str, target: Path, size: int, expected_sha256: str | None) -> None:
    """Download a ModelScope object via direct concurrent HTTP range requests.

    This intentionally bypasses ModelScope's snapshot/cache/downloader stack.
    Ranges write directly into a preallocated temporary file, avoiding the
    SDK's part-file merge and associated extra disk I/O.
    """
    query = urlencode({"Revision": "master", "FilePath": path})
    url = f"https://modelscope.cn/api/v1/datasets/{SOURCE_REPO}/repo?{query}"
    tmp = target.with_suffix(target.suffix + ".partial")
    target.parent.mkdir(parents=True, exist_ok=True)
    fd = os.open(tmp, os.O_RDWR | os.O_CREAT, 0o644)
    try:
        os.ftruncate(fd, size)
        range_size = max(64 * 1024 * 1024, math.ceil(size / 16))
        ranges = [
            (start, min(size - 1, start + range_size - 1))
            for start in range(0, size, range_size)
        ]
        timeout = httpx.Timeout(connect=30.0, read=120.0, write=120.0, pool=30.0)
        limits = httpx.Limits(max_connections=20, max_keepalive_connections=16)
        with httpx.Client(
            # ModelScope's redirect endpoint intermittently resets HTTP/2
            # multiplexed streams.  A pool of independent HTTP/1.1 ranges is
            # faster in practice because failed streams do not take siblings
            # down with the same connection.
            http2=False,
            follow_redirects=True,
            timeout=timeout,
            limits=limits,
            cookies={"m_session_id": MODELSCOPE_TOKEN},
        ) as client:
            def fetch(byte_range: tuple[int, int]) -> None:
                start, end = byte_range
                full_file_response = start == 0 and end == size - 1
                for attempt in range(8):
                    try:
                        # A few tiny ModelScope objects return an empty 200 to
                        # a Range request. Retry their single full-file range
                        # without that header before treating it as a failure.
                        headers = (
                            {} if full_file_response and attempt > 0
                            else {"Range": f"bytes={start}-{end}"}
                        )
                        with client.stream("GET", url, headers=headers) as response:
                            if response.status_code != 206 and not (
                                response.status_code == 200 and full_file_response
                            ):
                                raise RuntimeError(f"range {start}-{end}: HTTP {response.status_code}")
                            offset = start
                            for chunk in response.iter_bytes(4 * 1024 * 1024):
                                os.pwrite(fd, chunk, offset)
                                offset += len(chunk)
                            if offset != end + 1:
                                raise RuntimeError(f"short range {start}-{end}: got {offset - start}")
                        return
                    except Exception:
                        if attempt == 7:
                            raise
                        time.sleep(min(60, 2 ** attempt))

            with ThreadPoolExecutor(max_workers=min(16, len(ranges))) as pool:
                list(pool.map(fetch, ranges))
    finally:
        os.close(fd)

    if expected_sha256:
        digest = hashlib.sha256()
        with open(tmp, "rb") as handle:
            for chunk in iter(lambda: handle.read(16 * 1024 * 1024), b""):
                digest.update(chunk)
        if digest.hexdigest() != expected_sha256:
            tmp.unlink(missing_ok=True)
            raise RuntimeError(f"SHA-256 mismatch for {path}")
    tmp.replace(target)


def main() -> None:
    WORKDIR.mkdir(parents=True, exist_ok=True)
    target = HfApi(token=HF_TOKEN)
    uploaded = set(target.list_repo_files(DEST_REPO, repo_type="dataset"))
    # A dedicated indexing job writes the full paginated source tree once.
    # Reusing it avoids thousands of duplicate ModelScope listing requests.
    manifest = hf_hub_download(
        DEST_REPO, ".mirror/manifest.jsonl", repo_type="dataset", token=HF_TOKEN
    )
    with open(manifest, encoding="utf-8") as handle:
        files = [json.loads(line) for line in handle]
    selected = [
        item for number, item in enumerate(files)
        if number % WORKER_COUNT == WORKER_INDEX
        and (item.get("Type") or item.get("type")) != "tree"
    ]
    # Each shard is processed in deterministic manifest order.  Resume at its
    # first absent path instead of walking tens of thousands of committed files
    # after every hourly job restart.
    shard_total = len(selected)
    resume_at = next(
        (
            index
            for index, item in enumerate(selected)
            if (item.get("Path") or item.get("path") or item.get("Name")) not in uploaded
        ),
        len(selected),
    )
    print(
        f"worker {WORKER_INDEX}/{WORKER_COUNT}: "
        f"{resume_at}/{shard_total} complete; {shard_total - resume_at} remaining",
        flush=True,
    )
    selected = selected[resume_at:]
    pending: list[tuple[str, Path]] = []
    pending_bytes = 0

    def flush() -> None:
        nonlocal pending, pending_bytes
        if not pending:
            return
        commit_batch(target, pending)
        for _, local_file in pending:
            local_file.unlink(missing_ok=True)
        pending = []
        pending_bytes = 0

    for number, item in enumerate(selected, start=resume_at + 1):
        path = item.get("Path") or item.get("path") or item.get("Name")
        if not path:
            continue
        if path in uploaded:
            print(f"skip {number}/{shard_total} {path}", flush=True)
            continue
        local = WORKDIR / path
        local.parent.mkdir(parents=True, exist_ok=True)
        try:
            direct_download(
                path,
                local,
                int(item.get("Size") or item.get("size") or 0),
                item.get("Sha256") or item.get("sha256"),
            )
            local_size = local.stat().st_size
            # Keep Xet commit payloads small; large multi-file commits have
            # timed out on the Hub. A file over 5 GB is committed by itself.
            if pending and (len(pending) >= 200 or pending_bytes + local_size > 5_000_000_000):
                flush()
            pending.append((path, local))
            pending_bytes += local_size
            uploaded.add(path)
            if len(pending) >= 200 or pending_bytes >= 5_000_000_000:
                flush()
            print(f"done {number}/{shard_total} {path}", flush=True)
        finally:
            # Staged files remain until their batch commit succeeds.
            if path not in uploaded:
                local.unlink(missing_ok=True)
            # Remove any empty nested directories left by this file.
            parent = local.parent
            while parent != WORKDIR:
                try:
                    parent.rmdir()
                except OSError:
                    break
                parent = parent.parent

    flush()
    shutil.rmtree(WORKDIR, ignore_errors=True)


if __name__ == "__main__":
    main()