feat: buckets transfer without region

.gitignore

@@ -0,0 +1 @@
+.cursor

README.md

@@ -1,14 +1,59 @@
 ---
 title: Duplicate Repo V2
-emoji: 🦀
+emoji: 🤗
 colorFrom: gray
 colorTo: pink
 sdk: gradio
-sdk_version: 6.13.0
+sdk_version: 6.0.0
 app_file: app.py
 pinned: false
 license: mit
-short_description: Duplicate hugging face repo across region
+short_description: Duplicate a Hugging Face Bucket via an HF Job
+hf_oauth: true
+hf_oauth_scopes:
+  - read-repos
+  - write-repos
+  - manage-repos
+  - jobs
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Duplicate your bucket
+
+UI for duplicating a [Hugging Face Bucket](https://huggingface.co/docs/hub/storage-buckets).
+The actual file transfer runs as a [Hugging Face Job](https://huggingface.co/docs/huggingface_hub/guides/jobs)
+in the logged-in user's namespace, so users need a plan that supports Jobs
+(Pro / Team / Enterprise).
+
+## Architecture
+
+```
+Gradio SDK Space                 HF Job (per request)
+┌──────────────────────┐         ┌───────────────────────────┐
+│ Gradio UI            │ submit  │ uv run worker.py          │
+│ Sign in with HF      │ ──────► │   --src /data/src         │
+│ Submit / Cancel      │         │   --dst /data/dst         │
+│ Live log viewer      │ ◄────── │ (volumes mounted by HF)   │
+└──────────────────────┘  poll   └───────────────────────────┘
+```
+
+- The Space is a stock Gradio SDK Space — no Dockerfile, no system packages,
+  no `hf-mount`. OAuth and the runtime are managed by HF.
+- On submit, `huggingface_hub.run_uv_job` uploads `worker.py` to the Job and
+  attaches both buckets as `Volume(type="bucket", …)`. The Hub mounts them at
+  `/data/src` (read-only) and `/data/dst` (writable) inside the Job container.
+- `worker.py` is stdlib-only; the Space tails its stdout via `fetch_job_logs`.
+
+## Files
+
+- `app.py` — Gradio Space (UI + Job orchestration).
+- `worker.py` — runs inside the Job; copies files between mounted volumes.
+- `requirements.txt` — `huggingface_hub`, `gradio[oauth]`.
+
+## Configuration
+
+| Env var       | Default       | Purpose                                 |
+| ------------- | ------------- | --------------------------------------- |
+| `JOB_FLAVOR`  | `cpu-upgrade` | Hardware flavor passed to `run_uv_job`. |
+| `JOB_TIMEOUT` | `2h`          | Max Job runtime.                        |
+
+Configuration reference: <https://huggingface.co/docs/hub/spaces-config-reference>.

app.py

@@ -0,0 +1,244 @@
+"""Gradio Space UI that delegates the actual bucket copy to an HF Job.
+
+The Job is launched via `huggingface_hub.run_uv_job` in the logged-in user's
+namespace. `worker.py` is uploaded with the Job (via `LOCAL_FILES_ENCODED`) and
+runs against buckets mounted as `Volume(type="bucket", ...)`. The Space submits,
+polls logs, and offers a cancel button — no `hf-mount`, no Dockerfile.
+"""
+
+from __future__ import annotations
+
+import os
+
+import gradio as gr
+import requests
+from huggingface_hub import (
+    Volume,
+    cancel_job,
+    fetch_job_logs,
+    inspect_job,
+    run_uv_job,
+)
+
+JOB_FLAVOR = os.environ.get("JOB_FLAVOR", "cpu-upgrade")
+JOB_TIMEOUT = os.environ.get("JOB_TIMEOUT", "2h")
+
+HF_ENDPOINT = os.environ.get("HF_ENDPOINT", "https://huggingface.co")
+BUCKET_REGIONS = ("us", "eu")
+
+WORKER_SCRIPT = "worker.py"
+SRC_MOUNT = "/data/src"
+DST_MOUNT = "/data/dst"
+
+
+def _ensure_destination_bucket(
+    bucket_id: str,
+    *,
+    private: bool,
+    region: str,
+    token: str,
+) -> None:
+    """Create the destination bucket if it doesn't exist (no-op if it does).
+
+    Calls the HF buckets REST API directly so we can pass the (currently
+    undocumented) `region` parameter that `huggingface_hub.create_bucket` does
+    not yet expose. Both `private` and `region` only take effect on initial
+    creation; pre-existing buckets keep their settings.
+    """
+    if "/" not in bucket_id:
+        namespace, name = "me", bucket_id
+    else:
+        namespace, name = bucket_id.split("/", 1)
+
+    url = f"{HF_ENDPOINT}/api/buckets/{namespace}/{name}"
+    payload = {"private": private, "region": region}
+    headers = {"Authorization": f"Bearer {token}"}
+
+    resp = requests.post(url, headers=headers, json=payload, timeout=30)
+
+    # 409 = bucket already exists; treat as success (exist_ok behavior).
+    if resp.status_code == 409:
+        return
+    if not resp.ok:
+        # Surface the server's error message verbatim — most useful for users.
+        raise RuntimeError(f"HTTP {resp.status_code}: {resp.text.strip() or resp.reason}")
+
+
+def submit_transfer(
+    source: str,
+    destination: str,
+    private: bool,
+    region: str,
+    oauth_token: gr.OAuthToken | None,
+):
+    if oauth_token is None:
+        raise gr.Error("Please log in using the button at the top to start a transfer.")
+
+    source = (source or "").strip()
+    destination = (destination or "").strip()
+    if not source or not destination:
+        raise gr.Error("Source and destination buckets are required (e.g. `username/my-bucket`).")
+    if source == destination:
+        raise gr.Error("Source and destination must be different.")
+    if region not in BUCKET_REGIONS:
+        raise gr.Error(f"Region must be one of {BUCKET_REGIONS}.")
+
+    try:
+        _ensure_destination_bucket(
+            destination,
+            private=private,
+            region=region,
+            token=oauth_token.token,
+        )
+    except Exception as e:
+        raise gr.Error(f"Failed to ensure destination bucket `{destination}` exists: {e}")
+
+    try:
+        job = run_uv_job(
+            script=WORKER_SCRIPT,
+            script_args=["--src", SRC_MOUNT, "--dst", DST_MOUNT],
+            volumes=[
+                Volume(type="bucket", source=source, mount_path=SRC_MOUNT, read_only=True),
+                Volume(type="bucket", source=destination, mount_path=DST_MOUNT, read_only=False),
+            ],
+            secrets={"HF_TOKEN": oauth_token.token},
+            flavor=JOB_FLAVOR,
+            timeout=JOB_TIMEOUT,
+            token=oauth_token.token,
+        )
+    except Exception as e:
+        raise gr.Error(f"Failed to submit job: {e}")
+
+    status_md = (
+        f"**Status**: submitted\n\n"
+        f"Job: [`{job.id}`]({job.url}) on `{JOB_FLAVOR}` (timeout `{JOB_TIMEOUT}`)"
+    )
+    return job.id, status_md, ""
+
+
+def poll_job(job_id: str, oauth_token: gr.OAuthToken | None):
+    if not job_id or oauth_token is None:
+        return gr.update(), gr.update()
+
+    try:
+        info = inspect_job(job_id=job_id, token=oauth_token.token)
+        log_lines = list(fetch_job_logs(job_id=job_id, follow=False, token=oauth_token.token))
+    except Exception as e:
+        return gr.update(), f"**Status**: poll error — {e}"
+
+    stage = info.status.stage
+    badge = {
+        "RUNNING": "🟢 RUNNING",
+        "COMPLETED": "✅ COMPLETED",
+        "CANCELED": "🟠 CANCELED",
+        "ERROR": "🔴 ERROR",
+        "DELETED": "⚫ DELETED",
+    }.get(stage, stage)
+
+    status_md = f"**Status**: {badge} — [`{info.id}`]({info.url})"
+    if info.status.message:
+        status_md += f"\n\n> {info.status.message}"
+
+    logs = "\n".join(log_lines)
+    return logs, status_md
+
+
+def cancel_transfer(job_id: str, oauth_token: gr.OAuthToken | None):
+    if not job_id:
+        return job_id, "**Status**: nothing to cancel"
+    if oauth_token is None:
+        raise gr.Error("Please log in.")
+    try:
+        cancel_job(job_id=job_id, token=oauth_token.token)
+    except Exception as e:
+        raise gr.Error(f"Failed to cancel job: {e}")
+    return "", f"**Status**: cancel requested for `{job_id}`"
+
+
+def update_login_state(profile: gr.OAuthProfile | None):
+    """Refresh the login banner and toggle the form's visibility.
+
+    Triggered on demo.load (page open, including the post-OAuth redirect).
+    Returns updates for: (login_md, form_group).
+    """
+    if profile is not None:
+        return (
+            f"Signed in as **@{profile.username}**.",
+            gr.update(visible=True),
+        )
+    return (
+        "Please sign in with Hugging Face to start a transfer.",
+        gr.update(visible=False),
+    )
+
+
+with gr.Blocks(title="Duplicate your bucket") as demo:
+    gr.Markdown(
+        "# Duplicate your bucket\n"
+        "Copy a Hugging Face Bucket to another Bucket. The transfer runs as an "
+        "[HF Job](https://huggingface.co/docs/huggingface_hub/guides/jobs) in your "
+        "namespace — your account needs to support Jobs (Pro / Team / Enterprise)."
+    )
+    gr.LoginButton()
+    login_md = gr.Markdown("Please sign in with Hugging Face to start a transfer.")
+
+    with gr.Group(visible=False) as form_group:
+        with gr.Row():
+            src_input = gr.Textbox(
+                label="Source bucket",
+                placeholder="name/source-bucket",
+                scale=1,
+            )
+            dst_input = gr.Textbox(
+                label="Destination bucket",
+                placeholder="name/destination-bucket",
+                scale=1,
+            )
+
+        with gr.Accordion(
+            "Destination creation options — only applied if the destination bucket doesn't exist yet",
+            open=True,
+        ):
+            with gr.Row():
+                private_input = gr.Checkbox(label="Private", value=False, scale=1)
+                region_input = gr.Dropdown(
+                    label="Region",
+                    choices=list(BUCKET_REGIONS),
+                    value="us",
+                    scale=1,
+                )
+
+        with gr.Row():
+            submit_btn = gr.Button("Start transfer", variant="primary", scale=1)
+            cancel_btn = gr.Button("Cancel", variant="stop", scale=0)
+
+        status_md = gr.Markdown(value="**Status**: idle")
+        log_box = gr.Textbox(
+            label="Job logs",
+            interactive=False,
+            lines=20,
+            max_lines=200,
+            elem_id="log-box",
+        )
+
+        job_id_state = gr.State("")
+
+    submit_btn.click(
+        fn=submit_transfer,
+        inputs=[src_input, dst_input, private_input, region_input],
+        outputs=[job_id_state, status_md, log_box],
+    )
+    cancel_btn.click(
+        fn=cancel_transfer,
+        inputs=[job_id_state],
+        outputs=[job_id_state, status_md],
+    )
+
+    log_timer = gr.Timer(value=2)
+    log_timer.tick(fn=poll_job, inputs=[job_id_state], outputs=[log_box, status_md])
+
+    demo.load(fn=update_login_state, outputs=[login_md, form_group])
+
+
+demo.queue()
+demo.launch()

requirements.txt

@@ -0,0 +1,2 @@
+huggingface_hub==1.11.0
+gradio[oauth]>=6.0,<7

worker.py

@@ -0,0 +1,93 @@
+"""HF Job worker: copy every file from --src to --dst.
+
+Both directories are mounted by the HF Jobs platform via `Volume(type="bucket", ...)`,
+so this script only needs the Python stdlib and progress logging to stdout (the
+Space tails the Job logs to render the live progress).
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+import time
+from pathlib import Path
+
+CHUNK_SIZE = 64 * 1024 * 1024  # 64 MiB
+
+
+def log(msg: str) -> None:
+    print(f"[{time.strftime('%H:%M:%S')}] {msg}", flush=True)
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="Bucket-to-bucket file copy.")
+    p.add_argument("--src", required=True, help="Source mount path (read-only).")
+    p.add_argument("--dst", required=True, help="Destination mount path (writable).")
+    return p.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    src = Path(args.src)
+    dst = Path(args.dst)
+
+    if not src.is_dir():
+        log(f"source mount not found at {src}")
+        return 1
+    if not dst.is_dir():
+        log(f"destination mount not found at {dst}")
+        return 1
+
+    log(f"scanning {src} ...")
+    files = [f for f in src.rglob("*") if f.is_file()]
+    total = len(files)
+    bytes_total = sum(f.stat().st_size for f in files)
+    log(f"found {total} file(s), {bytes_total / 1e9:.2f} GB")
+
+    if total == 0:
+        log("nothing to copy.")
+        return 0
+
+    bytes_copied = 0
+    failures = 0
+    started = time.monotonic()
+
+    for i, src_file in enumerate(files, 1):
+        rel = src_file.relative_to(src)
+        dst_file = dst / rel
+        size = src_file.stat().st_size
+        log(f"[{i}/{total}] {rel} ({size / 1e6:.1f} MB)")
+
+        try:
+            dst_file.parent.mkdir(parents=True, exist_ok=True)
+            with open(src_file, "rb") as sf, open(dst_file, "wb") as df:
+                while True:
+                    data = sf.read(CHUNK_SIZE)
+                    if not data:
+                        break
+                    df.write(data)
+        except Exception as e:
+            log(f"  error copying {rel}: {e}")
+            failures += 1
+            continue
+
+        bytes_copied += size
+        pct = bytes_copied / bytes_total * 100 if bytes_total else 100.0
+        elapsed = time.monotonic() - started
+        rate = bytes_copied / elapsed / 1e6 if elapsed > 0 else 0
+        log(f"  done ({pct:.1f}% overall, {rate:.1f} MB/s avg)")
+
+    elapsed = time.monotonic() - started
+    log(
+        f"transfer complete: {total - failures}/{total} file(s), "
+        f"{bytes_copied / 1e9:.2f} GB in {elapsed:.0f}s "
+        f"({(bytes_copied / elapsed / 1e6) if elapsed > 0 else 0:.1f} MB/s)"
+    )
+    if failures:
+        log(f"{failures} file(s) failed — see errors above")
+        return 2
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())