Sync from GitHub via hub-sync

README.md

@@ -0,0 +1,87 @@
+---
+viewer: false
+tags:
+  - uv-script
+  - data-processing
+  - parquet
+  - buckets
+  - webhooks
+---
+
+# Data processing
+
+> Part of [uv-scripts](https://huggingface.co/uv-scripts) — self-contained UV scripts you run on Hugging Face Jobs in one command.
+
+General data processing recipes: convert, clean and prepare data files.
+
+| Script | What it does |
+|---|---|
+| [`optimize-parquet.py`](#optimize-parquetpy-optimized-parquet-from-bucket-uploads) | Converts CSV, JSON and Parquet files uploaded to a bucket into optimized Parquet, triggered by a bucket webhook |
+
+## optimize-parquet.py: optimized Parquet from bucket uploads
+
+Upload a CSV, JSON or Parquet file to a [Storage Bucket](https://huggingface.co/docs/hub/storage-buckets) and get an optimized Parquet version in a second bucket, automatically. A bucket [webhook](https://huggingface.co/docs/hub/webhooks) starts a [Job](https://huggingface.co/docs/hub/jobs) for each upload, and the Job converts only the files that changed.
+
+```
+input bucket  ──upload──▶  webhook  ──▶  Job (optimize-parquet.py)  ──▶  output bucket
+data.csv                                                                 data.csv/data/train-00000-of-00001.parquet
+```
+
+The output is written by [`datasets`](https://huggingface.co/docs/datasets), so it gets the same [optimizations](https://huggingface.co/docs/hub/datasets-libraries#optimized-parquet-files) as `push_to_hub`: content-defined chunking for Xet deduplication, a page index for fast filtering and random access, and row groups of at most 100 MB.
+
+### Setup
+
+You need two buckets: one you upload to, and one for the output. The Job writes to a different bucket so that its own output does not trigger it again.
+
+```bash
+hf buckets create my-raw-files --private
+hf buckets create my-parquet --private
+```
+
+**1. Create a base Job for the webhook to re-run.** With no webhook payload, this first run exits straight away:
+
+```bash
+hf jobs run --flavor cpu-upgrade --timeout 2h -e OUTPUT_BUCKET=<user>/my-parquet \
+    ghcr.io/astral-sh/uv:python3.12-bookworm \
+    uv run https://huggingface.co/datasets/uv-scripts/data-processing/raw/main/optimize-parquet.py
+```
+
+Use `hf jobs run ... uv run <url>` here, not `hf jobs uv run <url>`. `hf jobs uv run` uploads the script as a volume, and webhook runs don't keep volumes.
+
+**2. Create a webhook on the input bucket that re-runs this Job:**
+
+```python
+from huggingface_hub import create_webhook
+
+create_webhook(
+    job_id="<job id from step 1>",
+    watched=[{"type": "bucket", "name": "<user>/my-raw-files"}],
+    domains=["repo"],
+    secret="<fine-grained token>",
+)
+```
+
+The Job uses the webhook `secret` as its token to read and write the buckets. Use a fine-grained token, not your main one.
+
+**3. Upload a file:**
+
+```bash
+hf buckets cp data.csv hf://buckets/<user>/my-raw-files/data.csv
+```
+
+After about a minute, the output is in `<user>/my-parquet/data.csv/`: the Parquet file(s) under `data/`, plus a README written by `datasets`.
+
+### Options
+
+| Environment variable | Default | Meaning |
+|---|---|---|
+| `OUTPUT_BUCKET` | required | Bucket to write the Parquet files to. Must differ from the watched bucket. |
+| `STREAM_ABOVE_BYTES` | 1/3 of free disk | Files larger than this are streamed instead of loaded to disk. |
+
+Files that fit on the Job's disk are loaded in full. Larger files are streamed, so they don't need to fit on the disk (50 GB on `cpu-upgrade`); raise `--timeout` for very large files. Supported inputs: `.csv`, `.json`, `.jsonl`, `.parquet`. Other files are skipped, and deleted files are ignored.
+
+### Notes
+
+- **Cost:** a small file takes about 20 seconds on `cpu-upgrade` ($0.03/hour). In testing, one `hf buckets sync` of several files sent one webhook event, so it started one Job.
+- **Pin the script:** each webhook run downloads the script again. To stop changes to this recipe from reaching your webhook, replace `main` in the URL with a commit hash.
+- **Limits:** a webhook can trigger at most 1,000 times per 24 hours. Above 10,000 changed files in one event, the payload list is truncated; those files are not converted.

optimize-parquet.py

@@ -0,0 +1,82 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = ["datasets>=5"]
+# ///
+"""Convert CSV, JSON and Parquet files added to a bucket into optimized Parquet
+in a second bucket (OUTPUT_BUCKET).
+
+Meant to run as a Job triggered by a bucket webhook: the Job receives the list of
+changed files in WEBHOOK_PAYLOAD. `datasets` writes optimized Parquet by default
+(content-defined chunking, page index, row groups of at most 100MB).
+
+Setup (once):
+
+    # 1. A base Job for the webhook to re-run. With no payload, this first run exits.
+    #    Use `hf jobs run ... uv run <url>`, not `hf jobs uv run <url>`: the latter uploads
+    #    the script as a volume, and webhook runs don't keep volumes.
+    hf jobs run --flavor cpu-upgrade --timeout 2h -e OUTPUT_BUCKET=<user>/<output-bucket> \\
+        ghcr.io/astral-sh/uv:python3.12-bookworm \\
+        uv run https://huggingface.co/datasets/uv-scripts/data-processing/raw/main/optimize-parquet.py
+
+    # 2. A webhook on the input bucket that re-runs that Job on every change.
+    from huggingface_hub import create_webhook
+    create_webhook(
+        job_id="<job id from step 1>",
+        watched=[{"type": "bucket", "name": "<user>/<input-bucket>"}],
+        domains=["repo"],
+        secret="<fine-grained token>",
+    )
+
+Then upload files to the input bucket, e.g.
+`hf buckets cp data.csv hf://buckets/<user>/<input-bucket>/data.csv`,
+and the output appears at `<output-bucket>/data.csv/data/train-00000-of-00001.parquet`.
+"""
+
+import json
+import os
+import shutil
+import tempfile
+from pathlib import PurePosixPath
+
+from datasets import load_dataset
+
+# Use the webhook secret as the token when HF_TOKEN is not set.
+if "HF_TOKEN" not in os.environ and "WEBHOOK_SECRET" in os.environ:
+    os.environ["HF_TOKEN"] = os.environ["WEBHOOK_SECRET"]
+
+BUILDERS = {".csv": "csv", ".json": "json", ".jsonl": "json", ".parquet": "parquet"}
+
+event = json.loads(os.environ.get("WEBHOOK_PAYLOAD", "{}"))
+input_bucket = os.environ.get("WEBHOOK_REPO_ID")
+output_bucket = os.environ["OUTPUT_BUCKET"]
+# Writing to the watched bucket would trigger this Job again for its own output.
+if output_bucket == input_bucket:
+    raise SystemExit("OUTPUT_BUCKET must be different from the watched bucket")
+
+# A full load needs disk for the download, the Arrow cache and the output.
+# Larger files are streamed instead.
+free_disk = shutil.disk_usage(tempfile.gettempdir()).free
+stream_above = int(os.environ.get("STREAM_ABOVE_BYTES", free_disk // 3))
+
+for changed_file in event.get("updatedFiles", []):
+    path = PurePosixPath(changed_file["path"])
+    if changed_file["action"] != "add":
+        continue
+    if path.suffix not in BUILDERS:
+        print(f"Skipping {path}: unsupported file type")
+        continue
+
+    streaming = changed_file["size"] > stream_above
+    mode = "streaming" if streaming else "full load"
+    print(f"{path} ({changed_file['size']:,} bytes): {mode}")
+    dataset = load_dataset(
+        BUILDERS[path.suffix],
+        data_files=f"hf://buckets/{input_bucket}/{path}",
+        split="train",
+        streaming=streaming,
+    )
+    # a/b.csv -> <output bucket>/a/b.csv/data/train-*.parquet (keeps b.csv and b.jsonl apart)
+    # Tabular files have no image/audio files to embed. Setting this also avoids a
+    # crash when pushing a streamed CSV/JSON dataset (its features are not known yet).
+    dataset.push_to_hub(f"buckets/{output_bucket}/{path}", embed_external_files=False)
+    print(f"Wrote buckets/{output_bucket}/{path}")