Add bucket-based atlas pipeline: build, deploy, and e2e scripts

New pipeline using HF Jobs + Storage Buckets + Spaces for building
and deploying large-scale Embedding Atlas visualizations:

- atlas-build-gpu.py: GPU atlas build with cuml.accel UMAP (~50x speedup)
- atlas-deploy.py: Deploy Docker Space from bucket data
- atlas-e2e.py: End-to-end orchestrator (experimental)
- atlas-build-gpu-test.py: Test script used during development
- hn-prep.py: DuckDB prep for Hacker News stories
- open-library-prep.py: DuckDB prep for Open Library works
- atlas-export-remote.py: Add --batch-size flag

Validated with 2M Open Library books (40 min on A100) and 1M TinyStories.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

atlas-build-gpu-test.py

@@ -0,0 +1,86 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "embedding-atlas>=0.18.0",
+#     "datasets",
+#     "cuml-cu12",
+# ]
+#
+# [[tool.uv.index]]
+# url = "https://pypi.nvidia.com/simple"
+# ///
+
+"""Test GPU UMAP via cuml.accel with embedding-atlas."""
+
+import os
+import subprocess
+import sys
+import time
+
+# Enable cuml acceleration before anything imports umap
+os.environ["CUML_ACCEL_ENABLED"] = "1"
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument("input", help="Dataset path or mount path (e.g. /input/dataset.parquet)")
+    parser.add_argument("--sample", type=int, default=None)
+    parser.add_argument("--output", default="/output/atlas")
+    parser.add_argument("--text", default="text")
+    parser.add_argument("--split", default=None)
+    parser.add_argument("--batch-size", type=int, default=256)
+    args = parser.parse_args()
+
+    print(f"Input: {args.input}")
+    print(f"Sample: {args.sample}")
+    print(f"Output: {args.output}")
+    print(f"Batch size: {args.batch_size}")
+    print(f"CUML_ACCEL_ENABLED={os.environ.get('CUML_ACCEL_ENABLED')}")
+
+    # Verify cuml is available
+    try:
+        import cuml
+        print(f"cuML version: {cuml.__version__}")
+    except ImportError as e:
+        print(f"WARNING: cuml not available: {e}")
+
+    # Verify GPU
+    try:
+        import torch
+        print(f"CUDA available: {torch.cuda.is_available()}")
+        if torch.cuda.is_available():
+            print(f"GPU: {torch.cuda.get_device_name()}")
+    except ImportError:
+        print("torch not installed, skipping GPU check")
+
+    start = time.time()
+
+    cmd = [
+        "embedding-atlas",
+        args.input,
+        "--text", args.text,
+        "--batch-size", str(args.batch_size),
+        "--export-application", args.output,
+    ]
+
+    if args.split:
+        cmd.extend(["--split", args.split])
+
+    if args.sample:
+        cmd.extend(["--sample", str(args.sample)])
+
+    print(f"\nRunning: {' '.join(cmd)}")
+    result = subprocess.run(cmd, env=os.environ)
+
+    elapsed = time.time() - start
+    print(f"\nCompleted in {elapsed:.1f}s (exit code: {result.returncode})")
+
+    if result.returncode == 0:
+        # Check output
+        parquet = os.path.join(args.output, "data", "dataset.parquet")
+        if os.path.exists(parquet):
+            size_mb = os.path.getsize(parquet) / (1024**2)
+            print(f"Output parquet: {size_mb:.1f} MB")
+
+if __name__ == "__main__":
+    main()

atlas-build-gpu.py

@@ -0,0 +1,132 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "embedding-atlas>=0.19.1",
+#     "datasets",
+#     "cuml-cu12",
+# ]
+#
+# [[tool.uv.index]]
+# url = "https://pypi.nvidia.com/simple"
+# ///
+
+"""Build an Embedding Atlas visualization with GPU-accelerated UMAP.
+
+Runs embedding-atlas with cuml.accel for ~50x faster UMAP on GPU.
+Designed to run as an HF Job with a bucket volume mount for output.
+
+Examples:
+
+    # From a prepped parquet in a bucket
+    hf jobs uv run --flavor a100-large \\
+        -v hf://buckets/user/atlas-data:/data \\
+        -s HF_TOKEN --timeout 2h \\
+        atlas-build-gpu.py /data/books.parquet \\
+        --text title --sample 2000000 --name my-atlas
+
+    # From an HF dataset
+    hf jobs uv run --flavor a100-large \\
+        -v hf://buckets/user/atlas-data:/data \\
+        -s HF_TOKEN --timeout 2h \\
+        atlas-build-gpu.py stanfordnlp/imdb \\
+        --text text --split train --name imdb-atlas
+"""
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+import time
+
+os.environ["CUML_ACCEL_ENABLED"] = "1"
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Build an Embedding Atlas with GPU UMAP")
+    parser.add_argument("input", help="Parquet path or HF dataset ID")
+    parser.add_argument("--name", required=True, help="Atlas name (output subdirectory)")
+    parser.add_argument("--text", default="text", help="Text column name")
+    parser.add_argument("--image", default=None, help="Image column name")
+    parser.add_argument("--split", default=None, help="Dataset split")
+    parser.add_argument("--sample", type=int, default=None, help="Number of rows to sample")
+    parser.add_argument("--batch-size", type=int, default=256, help="Embedding batch size")
+    parser.add_argument("--model", default=None, help="Embedding model name")
+    parser.add_argument("--output-dir", default="/data", help="Base output directory")
+    args = parser.parse_args()
+
+    atlas_output = os.path.join(args.output_dir, args.name)
+    config_path = os.path.join(atlas_output, "atlas-config.json")
+
+    print(f"Input: {args.input}")
+    print(f"Name: {args.name}")
+    print(f"Output: {atlas_output}")
+    print(f"Sample: {args.sample}")
+    print(f"Batch size: {args.batch_size}")
+
+    # Report GPU/cuml status
+    gpu_info = {}
+    try:
+        import cuml
+        print(f"cuML: {cuml.__version__}")
+        gpu_info["cuml_version"] = cuml.__version__
+    except ImportError:
+        print("WARNING: cuml not available, falling back to CPU UMAP")
+
+    try:
+        import torch
+        if torch.cuda.is_available():
+            gpu_info["gpu"] = torch.cuda.get_device_name()
+            print(f"GPU: {gpu_info['gpu']}")
+    except ImportError:
+        pass
+
+    start = time.time()
+
+    cmd = ["embedding-atlas", args.input, "--text", args.text,
+           "--batch-size", str(args.batch_size),
+           "--export-application", atlas_output]
+
+    if args.image:
+        cmd.extend(["--image", args.image])
+    if args.model:
+        cmd.extend(["--model", args.model])
+    if args.split:
+        cmd.extend(["--split", args.split])
+    if args.sample:
+        cmd.extend(["--sample", str(args.sample)])
+
+    print(f"\nRunning: {' '.join(cmd)}\n")
+    result = subprocess.run(cmd, env=os.environ)
+    elapsed = time.time() - start
+
+    if result.returncode != 0:
+        print(f"\nFailed with exit code {result.returncode} after {elapsed:.1f}s")
+        sys.exit(result.returncode)
+
+    # Write config sidecar for atlas-deploy.py
+    parquet_path = os.path.join(atlas_output, "data", "dataset.parquet")
+    parquet_mb = os.path.getsize(parquet_path) / (1024**2) if os.path.exists(parquet_path) else 0
+
+    config = {
+        "name": args.name,
+        "text_column": args.text,
+        "image_column": args.image,
+        "model": args.model,
+        "sample": args.sample,
+        "input": args.input,
+        "parquet_size_mb": round(parquet_mb, 1),
+        "build_time_seconds": round(elapsed, 1),
+        "gpu_info": gpu_info,
+    }
+    os.makedirs(os.path.dirname(config_path), exist_ok=True)
+    with open(config_path, "w") as f:
+        json.dump(config, f, indent=2)
+
+    print(f"\nCompleted in {elapsed:.1f}s")
+    print(f"Parquet: {parquet_mb:.1f} MB")
+    print(f"Config: {config_path}")
+
+
+if __name__ == "__main__":
+    main()

atlas-deploy.py

@@ -0,0 +1,203 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "huggingface-hub>=1.7.0",
+# ]
+# ///
+
+"""Deploy an Embedding Atlas Space from bucket data.
+
+Reads atlas-config.json from the bucket to generate the right Dockerfile,
+creates a Docker Space, and prints instructions to mount the bucket.
+
+Examples:
+
+    # Deploy from existing atlas build in a bucket
+    uv run atlas-deploy.py \\
+        --name my-atlas \\
+        --bucket user/atlas-data \\
+        --space-id user/my-atlas-space
+
+    # With custom Space hardware
+    uv run atlas-deploy.py \\
+        --name my-atlas \\
+        --bucket user/atlas-data \\
+        --space-id user/my-atlas-space \\
+        --hardware cpu-upgrade
+"""
+
+import argparse
+import json
+import os
+
+from huggingface_hub import HfApi, create_repo, upload_file
+
+
+DOCKERFILE_TEMPLATE = """FROM python:3.12-slim
+
+RUN useradd -m -u 1000 user
+RUN pip install --no-cache-dir "embedding-atlas>=0.19.1"
+
+USER user
+EXPOSE 7860
+
+CMD ["embedding-atlas", \\
+     "/data/{name}/data/dataset.parquet", \\
+     "--text", "{text_column}", \\
+     "--x", "projection_x", \\
+     "--y", "projection_y", \\
+     "--disable-projection", \\
+     "--duckdb", "server", \\
+     "--host", "0.0.0.0", \\
+     "--port", "7860"]
+"""
+
+README_TEMPLATE = """---
+title: {title}
+emoji: 🗺️
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+---
+
+# 🗺️ {title}
+
+Interactive embedding visualization of {sample_desc}.
+
+Built with [HF Jobs](https://huggingface.co/docs/hub/jobs) + [Storage Buckets](https://huggingface.co/docs/hub/storage-buckets) + [Embedding Atlas](https://github.com/apple/embedding-atlas).
+
+## How it works
+
+- **Data**: Stored in a Storage Bucket (mounted read-only)
+- **Server**: embedding-atlas in server mode with DuckDB
+- **Build**: GPU UMAP via cuml.accel ({build_info})
+
+## Features
+
+- Interactive scatter plot with WebGPU acceleration
+- Real-time search and filtering
+- SQL queries via DuckDB server mode
+- Click points to see details
+"""
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Deploy an Atlas Space from bucket data")
+    parser.add_argument("--name", required=True, help="Atlas name (subdirectory in bucket)")
+    parser.add_argument("--bucket", required=True, help="Data bucket ID (e.g. user/atlas-data)")
+    parser.add_argument("--space-id", default=None, help="Space ID (default: {user}/{name})")
+    parser.add_argument("--hardware", default="cpu-basic", help="Space hardware (default: cpu-basic)")
+    parser.add_argument("--text-column", default=None, help="Override text column (reads from config if not set)")
+    parser.add_argument("--private", action="store_true", help="Make Space private")
+    args = parser.parse_args()
+
+    api = HfApi()
+
+    # Resolve space ID
+    if args.space_id is None:
+        user = api.whoami()["name"]
+        args.space_id = f"{user}/{args.name}"
+
+    # Try to read config from bucket
+    text_column = args.text_column or "text"
+    sample_desc = "dataset"
+    build_info = ""
+
+    try:
+        from huggingface_hub import download_bucket_files
+        import tempfile
+
+        with tempfile.TemporaryDirectory() as tmp:
+            config_remote = f"{args.name}/atlas-config.json"
+            config_local = os.path.join(tmp, "atlas-config.json")
+            download_bucket_files(args.bucket, files=[(config_remote, config_local)])
+
+            with open(config_local) as f:
+                config = json.load(f)
+
+            text_column = config.get("text_column", text_column)
+            sample = config.get("sample")
+            build_time = config.get("build_time_seconds")
+            gpu = config.get("gpu_info", {}).get("gpu", "")
+
+            if sample:
+                sample_desc = f"{sample:,} samples"
+            if build_time and gpu:
+                build_info = f"{build_time:.0f}s on {gpu}"
+            elif build_time:
+                build_info = f"{build_time:.0f}s"
+
+            print(f"Read config from bucket: text_column={text_column}, sample={sample}")
+    except Exception as e:
+        print(f"Could not read atlas-config.json from bucket: {e}")
+        print(f"Using defaults: text_column={text_column}")
+
+    if args.text_column:
+        text_column = args.text_column
+
+    # Create Space
+    print(f"\nCreating Space: {args.space_id}")
+    create_repo(
+        args.space_id,
+        repo_type="space",
+        space_sdk="docker",
+        private=args.private,
+        exist_ok=True,
+    )
+
+    # Generate and upload Dockerfile
+    dockerfile = DOCKERFILE_TEMPLATE.format(name=args.name, text_column=text_column)
+    upload_file(
+        path_or_fileobj=dockerfile.encode(),
+        path_in_repo="Dockerfile",
+        repo_id=args.space_id,
+        repo_type="space",
+    )
+
+    # Generate and upload README
+    title = args.name.replace("-", " ").replace("_", " ").title()
+    readme = README_TEMPLATE.format(
+        title=title,
+        sample_desc=sample_desc,
+        build_info=build_info,
+    )
+    upload_file(
+        path_or_fileobj=readme.encode(),
+        path_in_repo="README.md",
+        repo_id=args.space_id,
+        repo_type="space",
+    )
+
+    # Set hardware
+    if args.hardware != "cpu-basic":
+        api.request_space_hardware(args.space_id, args.hardware)
+        print(f"Hardware: {args.hardware}")
+
+    # Try programmatic volume mount (requires latest huggingface_hub)
+    mounted = False
+    try:
+        from huggingface_hub._jobs_api import Volume
+        api.set_space_volumes(
+            args.space_id,
+            volumes=[
+                Volume(type="bucket", source=args.bucket, mount_path="/data", read_only=True),
+            ],
+        )
+        mounted = True
+        print(f"Bucket mounted: {args.bucket} -> /data (read-only)")
+    except (ImportError, AttributeError):
+        pass
+
+    space_url = f"https://huggingface.co/spaces/{args.space_id}"
+    print(f"\nSpace deployed: {space_url}")
+
+    if not mounted:
+        print("\n⚠️  Mount the bucket manually in Space settings:")
+        print(f"   Bucket: {args.bucket}")
+        print("   Mount path: /data")
+        print("   Access mode: Read-only")
+
+
+if __name__ == "__main__":
+    main()

atlas-e2e.py

@@ -0,0 +1,218 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "huggingface-hub>=1.7.0",
+# ]
+# ///
+
+"""Build and deploy an Embedding Atlas end-to-end.
+
+Orchestrates the full pipeline:
+1. Creates a storage bucket (if needed)
+2. Submits a GPU Job to build the atlas (embedding + UMAP)
+3. Waits for the Job to complete
+4. Deploys a Docker Space that serves the atlas from the bucket
+
+⚠️ EXPERIMENTAL — this workflow is new and may change.
+
+Examples:
+
+    # Minimal — from HF dataset to deployed Space
+    uv run atlas-e2e.py stanfordnlp/imdb \\
+        --text text --split train \\
+        --name imdb-atlas --sample 50000
+
+    # From prepped parquet (already in a bucket)
+    uv run atlas-e2e.py hf://buckets/user/atlas-data/books.parquet \\
+        --text title --name open-library-atlas --sample 2000000
+
+    # Full control
+    uv run atlas-e2e.py my-org/my-dataset \\
+        --text text --split train \\
+        --name my-atlas \\
+        --sample 1000000 \\
+        --bucket user/atlas-data \\
+        --space-id user/my-atlas-viz \\
+        --flavor a100-large \\
+        --timeout 2h \\
+        --batch-size 512
+"""
+
+import argparse
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+from huggingface_hub import HfApi, create_bucket
+
+
+def wait_for_job(api: HfApi, job_id: str, poll_interval: int = 30) -> str:
+    """Poll a Job until it completes. Returns the final stage."""
+    print(f"\nWaiting for Job {job_id}...")
+    while True:
+        job = api.inspect_job(job_id=job_id)
+        stage = job.status.stage
+        if stage in ("COMPLETED", "ERROR"):
+            msg = job.status.message or ""
+            print(f"Job {stage}" + (f": {msg}" if msg else ""))
+            return stage
+        time.sleep(poll_interval)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Build and deploy an Embedding Atlas end-to-end (experimental)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
+
+    # Required
+    parser.add_argument("input", help="HF dataset ID or parquet path")
+    parser.add_argument("--name", required=True, help="Atlas name")
+    parser.add_argument("--text", default="text", help="Text column name")
+
+    # Dataset options
+    parser.add_argument("--split", default=None, help="Dataset split")
+    parser.add_argument("--sample", type=int, default=None, help="Number of rows")
+    parser.add_argument("--image", default=None, help="Image column name")
+    parser.add_argument("--model", default=None, help="Embedding model")
+
+    # Infrastructure
+    parser.add_argument("--bucket", default=None, help="Bucket ID (default: {user}/atlas-data)")
+    parser.add_argument("--space-id", default=None, help="Space ID (default: {user}/{name})")
+    parser.add_argument("--flavor", default="a100-large", help="Job GPU flavor (default: a100-large)")
+    parser.add_argument("--timeout", default="2h", help="Job timeout (default: 2h)")
+    parser.add_argument("--batch-size", type=int, default=256, help="Embedding batch size")
+    parser.add_argument("--space-hardware", default="cpu-basic", help="Space hardware (default: cpu-basic)")
+    parser.add_argument("--private", action="store_true", help="Make Space private")
+
+    # Workflow control
+    parser.add_argument("--build-only", action="store_true", help="Only build, don't deploy Space")
+    parser.add_argument("--deploy-only", action="store_true", help="Only deploy from existing bucket data")
+
+    args = parser.parse_args()
+
+    api = HfApi()
+    user = api.whoami()["name"]
+
+    # Resolve defaults
+    if args.bucket is None:
+        args.bucket = f"{user}/atlas-data"
+    if args.space_id is None:
+        args.space_id = f"{user}/{args.name}"
+
+    print("=" * 60)
+    print("Embedding Atlas — End-to-End Pipeline")
+    print("=" * 60)
+    print(f"Input:    {args.input}")
+    print(f"Name:     {args.name}")
+    print(f"Bucket:   {args.bucket}")
+    print(f"Space:    {args.space_id}")
+    print(f"Flavor:   {args.flavor}")
+    print(f"Sample:   {args.sample}")
+    print("=" * 60)
+
+    # ── Step 1: Create bucket ──
+    if not args.deploy_only:
+        print(f"\n[1/3] Creating bucket {args.bucket}...")
+        create_bucket(args.bucket, exist_ok=True)
+
+    # ── Step 2: Submit build Job ──
+    if not args.deploy_only:
+        print(f"\n[2/3] Submitting build Job ({args.flavor})...")
+
+        build_script = Path(__file__).parent / "atlas-build-gpu.py"
+        if not build_script.exists():
+            print(f"ERROR: {build_script} not found")
+            print("atlas-build-gpu.py must be in the same directory as this script")
+            sys.exit(1)
+
+        # Build the hf jobs command
+        cmd = [
+            "hf", "jobs", "uv", "run",
+            "--flavor", args.flavor,
+            "-v", f"hf://buckets/{args.bucket}:/data",
+            "-s", "HF_TOKEN",
+            "--timeout", args.timeout,
+            str(build_script),
+            args.input,
+            "--name", args.name,
+            "--text", args.text,
+            "--batch-size", str(args.batch_size),
+        ]
+
+        if args.split:
+            cmd.extend(["--split", args.split])
+        if args.sample:
+            cmd.extend(["--sample", str(args.sample)])
+        if args.image:
+            cmd.extend(["--image", args.image])
+        if args.model:
+            cmd.extend(["--model", args.model])
+
+        print(f"Command: {' '.join(cmd)}\n")
+
+        # Run and capture job ID from output
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        output = result.stdout + result.stderr
+
+        # Extract job ID
+        job_id = None
+        for line in output.split("\n"):
+            if "Job started with ID:" in line:
+                job_id = line.split("Job started with ID:")[-1].strip()
+                break
+
+        if job_id is None:
+            print("ERROR: Could not extract Job ID from output:")
+            print(output)
+            sys.exit(1)
+
+        print(f"Job submitted: {job_id}")
+        print(f"View: https://huggingface.co/jobs/{user}/{job_id}")
+
+        # Wait for completion
+        stage = wait_for_job(api, job_id)
+        if stage != "COMPLETED":
+            print(f"\nJob failed. Check logs: https://huggingface.co/jobs/{user}/{job_id}")
+            sys.exit(1)
+
+        print("Build complete!")
+
+    if args.build_only:
+        print(f"\nBuild finished. Data in bucket: {args.bucket}/{args.name}/")
+        print(f"Deploy later with: uv run atlas-deploy.py --name {args.name} --bucket {args.bucket}")
+        return
+
+    # ── Step 3: Deploy Space ──
+    print(f"\n[3/3] Deploying Space {args.space_id}...")
+
+    deploy_script = Path(__file__).parent / "atlas-deploy.py"
+    if not deploy_script.exists():
+        print(f"ERROR: {deploy_script} not found")
+        sys.exit(1)
+
+    deploy_cmd = [
+        "uv", "run",
+        str(deploy_script),
+        "--name", args.name,
+        "--bucket", args.bucket,
+        "--space-id", args.space_id,
+        "--hardware", args.space_hardware,
+        "--text-column", args.text,
+    ]
+    if args.private:
+        deploy_cmd.append("--private")
+
+    subprocess.run(deploy_cmd, check=True)
+
+    print("\n" + "=" * 60)
+    print("Done!")
+    print(f"Space: https://huggingface.co/spaces/{args.space_id}")
+    print(f"Bucket: https://huggingface.co/buckets/{args.bucket}")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

atlas-export-remote.py

@@ -177,6 +177,9 @@ def build_atlas_command(args, data_repo_id: str) -> Tuple[list, str]:
     if args.sample:
         cmd.extend(["--sample", str(args.sample)])
 
+    if args.batch_size:
+        cmd.extend(["--batch-size", str(args.batch_size)])
+
     if args.trust_remote_code:
         cmd.append("--trust-remote-code")
 
@@ -509,6 +512,11 @@ def main():
         type=int,
         help="Number of samples to visualize",
     )
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        help="Batch size for embedding computation. Larger values are faster but use more GPU memory.",
+    )
     parser.add_argument(
         "--trust-remote-code",
         action="store_true",
@@ -627,12 +635,10 @@ def main():
             cmd, export_dir_name = build_atlas_command(args, data_repo_id)
             logger.info(f"Running: {' '.join(cmd)}")
 
-            result = subprocess.run(cmd, capture_output=True, text=True)
+            result = subprocess.run(cmd)
 
             if result.returncode != 0:
-                logger.error(f"Atlas export failed: {result.returncode}")
-                logger.error(f"STDOUT: {result.stdout}")
-                logger.error(f"STDERR: {result.stderr}")
+                logger.error(f"Atlas export failed with code {result.returncode}")
                 sys.exit(1)
 
             logger.info("Atlas export completed")

hn-prep.py

@@ -0,0 +1,94 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "duckdb",
+#     "huggingface-hub",
+# ]
+# ///
+
+"""Prep Hacker News stories for atlas visualization.
+
+Filters to stories with titles, adds year column for coloring.
+Uses DuckDB to query HF parquet files directly (no full download).
+Writes prepped parquet to output path (bucket mount or local).
+
+Usage (as HF Job):
+    hf jobs uv run --flavor cpu-upgrade \
+        -v hf://buckets/davanstrien/atlas-data:/output \
+        -s HF_TOKEN --timeout 1h \
+        hn-prep.py --output /output/hn-stories/stories.parquet
+"""
+
+import argparse
+import os
+import time
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output", default="/output/hn-stories/stories.parquet")
+    parser.add_argument("--max-rows", type=int, default=None,
+                        help="Cap total rows after filtering")
+    args = parser.parse_args()
+
+    import duckdb
+
+    start = time.time()
+
+    con = duckdb.connect()
+    con.execute("SET enable_http_metadata_cache=true")
+
+    # DuckDB hf:// protocol picks up HF_TOKEN from env automatically
+
+    source = "hf://datasets/open-index/hacker-news/data/**/*.parquet"
+
+    os.makedirs(os.path.dirname(args.output), exist_ok=True)
+    print("Querying HN stories from HF parquet files via DuckDB...")
+
+    limit_clause = f"LIMIT {args.max_rows}" if args.max_rows else ""
+
+    query = f"""
+    COPY (
+        SELECT
+            id,
+            title,
+            score,
+            CAST(year(time) AS VARCHAR) AS year,
+            CASE
+                WHEN score <= 5 THEN '0-5'
+                WHEN score <= 25 THEN '6-25'
+                WHEN score <= 100 THEN '26-100'
+                WHEN score <= 500 THEN '101-500'
+                ELSE '500+'
+            END AS score_bucket,
+            "by",
+            url,
+            descendants
+        FROM '{source}'
+        WHERE type = 1
+          AND title IS NOT NULL
+          AND trim(title) != ''
+        ORDER BY random()
+        {limit_clause}
+    ) TO '{args.output}' (FORMAT PARQUET)
+    """
+
+    con.execute(query)
+    elapsed = time.time() - start
+
+    # Check output
+    result = con.execute(f"SELECT count(*) FROM '{args.output}'").fetchone()
+    size_mb = os.path.getsize(args.output) / (1024**2)
+    print(f"\nWrote {result[0]:,} stories to {args.output} ({size_mb:.0f} MB)")
+    print(f"Total time: {elapsed:.0f}s")
+
+    # Quick stats
+    stats = con.execute(f"""
+        SELECT min(year) as min_year, max(year) as max_year, count(distinct year) as n_years
+        FROM '{args.output}'
+    """).fetchone()
+    print(f"Year range: {stats[0]} - {stats[1]} ({stats[2]} years)")
+
+
+if __name__ == "__main__":
+    main()

open-library-prep.py

@@ -0,0 +1,104 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "duckdb",
+#     "huggingface-hub",
+# ]
+# ///
+
+"""Prep Open Library works for atlas visualization.
+
+Filters to works with titles and subjects, adds broad category for coloring.
+Uses DuckDB to query HF parquet files directly.
+
+Usage (as HF Job):
+    hf jobs uv run --flavor cpu-upgrade \
+        -v hf://buckets/davanstrien/atlas-data:/output \
+        -s HF_TOKEN --timeout 1h \
+        open-library-prep.py --output /output/open-library/books.parquet
+"""
+
+import argparse
+import os
+import time
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output", default="/output/open-library/books.parquet")
+    parser.add_argument("--max-rows", type=int, default=2000000)
+    args = parser.parse_args()
+
+    import duckdb
+
+    start = time.time()
+    con = duckdb.connect()
+    con.execute("SET enable_http_metadata_cache=true")
+
+    os.makedirs(os.path.dirname(args.output), exist_ok=True)
+
+    source = "hf://datasets/open-index/open-library/data/works/*.parquet"
+
+    print(f"Querying Open Library works (max {args.max_rows:,} rows)...")
+
+    query = f"""
+    COPY (
+        SELECT
+            title,
+            CASE
+                WHEN subjects LIKE '%Fiction%' OR subjects LIKE '%Novel%' OR subjects LIKE '%Stories%' THEN 'Fiction'
+                WHEN subjects LIKE '%History%' OR subjects LIKE '%Antiquities%' OR subjects LIKE '%Civilization%' THEN 'History'
+                WHEN subjects LIKE '%Science%' OR subjects LIKE '%Physics%' OR subjects LIKE '%Chemistry%' OR subjects LIKE '%Biology%' OR subjects LIKE '%Geology%' OR subjects LIKE '%Astronomy%' THEN 'Science'
+                WHEN subjects LIKE '%Religion%' OR subjects LIKE '%Theology%' OR subjects LIKE '%Bible%' OR subjects LIKE '%Church%' THEN 'Religion'
+                WHEN subjects LIKE '%Biography%' OR subjects LIKE '%Correspondence%' THEN 'Biography'
+                WHEN subjects LIKE '%Poetry%' OR subjects LIKE '%Drama%' OR subjects LIKE '%Literature%' THEN 'Literature'
+                WHEN subjects LIKE '%Mathematics%' OR subjects LIKE '%Computer%' OR subjects LIKE '%Engineering%' OR subjects LIKE '%Technol%' THEN 'Tech & Engineering'
+                WHEN subjects LIKE '%Music%' THEN 'Music'
+                WHEN subjects LIKE '%Art%' OR subjects LIKE '%Photography%' OR subjects LIKE '%Architecture%' OR subjects LIKE '%Design%' THEN 'Art & Design'
+                WHEN subjects LIKE '%Law%' OR subjects LIKE '%Politics%' OR subjects LIKE '%Government%' OR subjects LIKE '%Foreign relations%' THEN 'Law & Politics'
+                WHEN subjects LIKE '%Education%' OR subjects LIKE '%Teaching%' THEN 'Education'
+                WHEN subjects LIKE '%Philosophy%' OR subjects LIKE '%Psychology%' THEN 'Philosophy'
+                WHEN subjects LIKE '%Medicine%' OR subjects LIKE '%Health%' OR subjects LIKE '%Disease%' THEN 'Medicine'
+                WHEN subjects LIKE '%Econom%' OR subjects LIKE '%Business%' OR subjects LIKE '%Commerce%' OR subjects LIKE '%Finance%' THEN 'Business & Economics'
+                WHEN subjects LIKE '%Children%' OR subjects LIKE '%Juvenile%' THEN 'Children'
+                WHEN subjects LIKE '%Travel%' OR subjects LIKE '%Guidebook%' OR subjects LIKE '%Description and travel%' THEN 'Travel'
+                WHEN subjects LIKE '%Agriculture%' OR subjects LIKE '%Gardening%' OR subjects LIKE '%Cook%' OR subjects LIKE '%Food%' THEN 'Food & Agriculture'
+                WHEN subjects LIKE '%Social%' OR subjects LIKE '%Sociology%' OR subjects LIKE '%Women%' OR subjects LIKE '%Feminism%' THEN 'Society'
+                WHEN subjects LIKE '%Military%' OR subjects LIKE '%War%' THEN 'Military'
+                WHEN subjects LIKE '%Sport%' OR subjects LIKE '%Games%' OR subjects LIKE '%Baseball%' OR subjects LIKE '%Football%' THEN 'Sports'
+                ELSE 'Other'
+            END as category,
+            first_publish_date,
+            json_extract_string(subjects, '$[0]') as primary_subject
+        FROM '{source}'
+        WHERE subjects IS NOT NULL
+          AND subjects != '[]'
+          AND title IS NOT NULL
+          AND trim(title) != ''
+          AND length(title) > 3
+        ORDER BY random()
+        LIMIT {args.max_rows}
+    ) TO '{args.output}' (FORMAT PARQUET)
+    """
+
+    con.execute(query)
+    elapsed = time.time() - start
+
+    # Stats
+    result = con.execute(f"SELECT count(*) FROM '{args.output}'").fetchone()
+    size_mb = os.path.getsize(args.output) / (1024**2)
+    print(f"\nWrote {result[0]:,} books to {args.output} ({size_mb:.0f} MB)")
+    print(f"Total time: {elapsed:.0f}s")
+
+    cats = con.execute(f"""
+        SELECT category, count(*) as cnt
+        FROM '{args.output}'
+        GROUP BY 1 ORDER BY 2 DESC
+    """).df()
+    print("\nCategory distribution:")
+    for _, row in cats.iterrows():
+        print(f"  {row['cnt']:6,}  {row['category']}")
+
+
+if __name__ == "__main__":
+    main()