Sync from GitHub via hub-sync

CLAUDE.md

@@ -14,21 +14,14 @@ if not torch.cuda.is_available():
 ```
 
 ### 2. vLLM Docker Image
-Run on the pinned **`vllm/vllm-openai:0.22.1`** image for HF Jobs (ships vLLM + the CUDA toolkit, so FlashInfer works) with `--python /usr/bin/python3 -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages`. **Pin the tag (test-then-pin), not `:latest`.** Tested 2026-06-05 on `l4x1` (vLLM 0.22.1).
+Run on the pinned **`vllm/vllm-openai:v0.32.0`** image for HF Jobs (ships vLLM + the CUDA toolkit, so FlashInfer works) with `--python /usr/bin/python3 -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages`. Each script's `[tool.hf-jobs]` header sets these. **Pin the tag (test-then-pin), not `:latest`.** Tested 2026-11-05 on `a10g-small`, `a10g-large` and `a100-large` (vLLM 0.32.0).
 
-The custom nightly / FlashInfer `[[tool.uv.index]]` blocks (§3) are **no longer needed** — the image provides vLLM; keep a `vllm>=0.11.0` floor in the PEP 723 header for the local path.
+**Do not list `vllm`, `torch`, `transformers` or `flashinfer-python` in the PEP 723 dependencies.** uv would install newer PyPI copies next to the image's. `PYTHONPATH` shadows those, but the `flashinfer-python` 0.7.2.post1 wheel also ships a top-level `b12x` module that the image lacks; the image's vLLM imports it and crashes (`FileNotFoundError: .../flashinfer/experimental/b12x/_api.py`). Import these packages inside `main()` so `uv run <script> --help` works without them. Local GPU runs use `uv run --with vllm <script>`. The custom nightly / FlashInfer `[[tool.uv.index]]` blocks (§3) are **no longer needed**.
 
 **APIs (verified):** structured outputs use `StructuredOutputsParams` (`structured_outputs=`, ≥0.11.0 — `GuidedDecodingParams`/`guided_decoding=` removed in 0.12.0); classification auto-detects the pooling runner from the model architecture (the old `LLM(..., task="classify")` arg was removed → use `LLM(model)`).
 
 ### 3. Dependencies
-Include custom PyPI indexes for vLLM and FlashInfer:
-```python
-# [[tool.uv.index]]
-# url = "https://flashinfer.ai/whl/cu126/torch2.6"
-# 
-# [[tool.uv.index]]
-# url = "https://wheels.vllm.ai/nightly"
-```
+List only what the image does not provide (for example `datasets`, `huggingface-hub`, `toolz`). No custom `[[tool.uv.index]]` blocks are needed; see §2.
 
 ## Current Scripts
 

README.md

@@ -7,7 +7,7 @@ tags: [uv-script, vllm, gpu, inference, hf-jobs]
 
 Ready-to-run UV scripts for GPU-accelerated inference using [vLLM](https://github.com/vllm-project/vllm).
 
-These scripts use [UV's inline script metadata](https://docs.astral.sh/uv/guides/scripts/) to automatically manage dependencies - just run with `uv run` and everything installs automatically!
+These scripts use [UV's inline script metadata](https://docs.astral.sh/uv/guides/scripts/) to manage dependencies. On HF Jobs they run on the `vllm/vllm-openai` image, which provides vLLM, PyTorch and Transformers, so the script headers leave those out. On your own Linux + CUDA machine, add vLLM explicitly: `uv run --with vllm <script>.py ...`.
 
 ## 📋 Available Scripts
 
@@ -18,7 +18,7 @@ Vision Language Model (VLM) image classification with structured output constrai
 **Features:**
 
 - 🖼️ Process images through state-of-the-art VLMs (Qwen2-VL)
-- 🎯 Structured classification using vLLM's `GuidedDecodingParams`
+- 🎯 Structured classification using vLLM's `StructuredOutputsParams`
 - 📐 Automatic image resizing to optimize token usage
 - 💾 Memory-efficient lazy batch processing
 - 🏷️ Simple CLI interface for defining classes
@@ -28,13 +28,13 @@ Vision Language Model (VLM) image classification with structured output constrai
 
 ```bash
 # Basic classification
-uv run vlm-classify.py \
+uv run --with vllm vlm-classify.py \
     username/input-dataset \
     username/output-dataset \
     --classes "document,photo,diagram,other"
 
 # With custom prompt and image resizing
-uv run vlm-classify.py \
+uv run --with vllm vlm-classify.py \
     username/input-dataset \
     username/output-dataset \
     --classes "index-card,manuscript,title-page,other" \
@@ -42,7 +42,7 @@ uv run vlm-classify.py \
     --max-size 768
 
 # Quick test with sample limit
-uv run vlm-classify.py \
+uv run --with vllm vlm-classify.py \
     davanstrien/sloane-index-cards \
     username/test-output \
     --classes "index,content,other" \
@@ -89,7 +89,7 @@ Batch text classification using BERT-style encoder models (e.g., BERT, RoBERTa,
 
 ```bash
 # Local execution (requires GPU)
-uv run classify-dataset.py \
+uv run --with vllm classify-dataset.py \
     davanstrien/ModernBERT-base-is-new-arxiv-dataset \
     username/input-dataset \
     username/output-dataset \
@@ -103,7 +103,7 @@ uv run classify-dataset.py \
 hf jobs uv run \
     --flavor l4x1 \
     --image vllm/vllm-openai:v0.32.0 \
-    https://huggingface.co/datasets/uv-scripts/vllm/resolve/main/classify-dataset.py \
+    https://huggingface.co/datasets/uv-scripts/vllm/raw/main/classify-dataset.py \
     davanstrien/ModernBERT-base-is-new-arxiv-dataset \
     username/input-dataset \
     username/output-dataset \
@@ -130,14 +130,14 @@ Generate responses for prompts using generative LLMs (e.g., Llama, Qwen, Mistral
 
 ```bash
 # With chat-formatted messages (default)
-uv run generate-responses.py \
+uv run --with vllm generate-responses.py \
     username/input-dataset \
     username/output-dataset \
     --messages-column messages \
     --max-tokens 1024
 
 # With plain text prompts (NEW!)
-uv run generate-responses.py \
+uv run --with vllm generate-responses.py \
     username/input-dataset \
     username/output-dataset \
     --prompt-column question \
@@ -145,7 +145,7 @@ uv run generate-responses.py \
     --max-samples 100
 
 # With custom model and parameters
-uv run generate-responses.py \
+uv run --with vllm generate-responses.py \
     username/input-dataset \
     username/output-dataset \
     --model-id meta-llama/Llama-3.1-8B-Instruct \
@@ -207,22 +207,29 @@ vLLM is a high-throughput inference engine optimized for:
 
 ### Dependencies
 
-Scripts use UV's inline metadata for automatic dependency management:
+Scripts use UV's inline metadata for dependency management, plus a `[tool.hf-jobs]` table that sets the image, flavor and secrets for `hf jobs uv run`:
 
 ```python
 # /// script
 # requires-python = ">=3.10"
 # dependencies = [
 #     "datasets",
-#     "flashinfer-python",
-#     "huggingface-hub[hf_transfer]",
-#     "torch",
-#     "transformers",
-#     "vllm",
+#     "huggingface-hub",
+#     "hf-xet>= 1.1.7",
 # ]
+#
+# [tool.hf-jobs]
+# image = "vllm/vllm-openai:v0.32.0"
+# python = "/usr/bin/python3"
+# env = { PYTHONPATH = "/usr/local/lib/python3.12/dist-packages" }
+# flavor = "a100-large"
+# secrets = ["HF_TOKEN"]
+# timeout = "2h"
 # ///
 ```
 
+vLLM, PyTorch, Transformers and FlashInfer come from the image: `PYTHONPATH` points at its packages. Do not add them to `dependencies`. uv would then install newer PyPI copies next to the image's, and the current `flashinfer-python` wheel adds a `b12x` module that the v0.32.0 image's vLLM imports and crashes on. For a local GPU run, use `uv run --with vllm <script>.py ...`. `hf jobs uv run` reads the `[tool.hf-jobs]` table from hf CLI 1.32; with an older CLI, pass the header's settings as flags yourself: `--image`, `--flavor`, `--timeout`, `--secrets HF_TOKEN`, `--python /usr/bin/python3` and `-e PYTHONPATH=/usr/local/lib/python3.12/dist-packages`.
+
 For bleeding-edge features, use the `UV_PRERELEASE=if-necessary` environment variable to allow pre-release versions when needed.
 
 ### Docker Image

classify-dataset.py

@@ -6,12 +6,14 @@
 #     "huggingface-hub",
 #     "setuptools",
 #     "toolz",
-#     "torch",
-#     "transformers",
-#     "vllm>=0.11.0",
 # ]
 #
 # [tool.hf-jobs]
+# # vllm, torch and transformers come from the image (PYTHONPATH). Listing them above makes uv
+# # install newer PyPI copies plus their deps. PYTHONPATH shadows the copies, but the current
+# # flashinfer-python wheel (0.7.2.post1) also ships a top-level b12x module that the image lacks.
+# # The image's vllm imports it and crashes (missing flashinfer/experimental/b12x/_api.py).
+# # Seen on v0.32.0 (2026-11-05); re-test before moving the tag. Local GPU: uv run --with vllm.
 # image = "vllm/vllm-openai:v0.32.0"
 # python = "/usr/bin/python3"
 # env = { PYTHONPATH = "/usr/local/lib/python3.12/dist-packages" }
@@ -27,16 +29,17 @@ a BERT-style model via vLLM, and saves the results back to the Hub with predicte
 labels and confidence scores.
 
 Example usage:
-    # Local execution
-    uv run classify-dataset.py \\
+    # Local execution (Linux + CUDA). The header leaves vllm, torch and
+    # transformers to the HF Jobs image, so add vllm with --with.
+    uv run --with vllm classify-dataset.py \\
         davanstrien/ModernBERT-base-is-new-arxiv-dataset \\
         username/input-dataset \\
         username/output-dataset \\
         --inference-column text \\
         --batch-size 10000
 
-    # HF Jobs execution (see script output for full command)
-    hfjobs run --flavor l4x1 ...
+    # HF Jobs execution (the header sets the vLLM image, flavor and HF_TOKEN secret)
+    hf jobs uv run classify-dataset.py model/name input-dataset output-dataset
 """
 
 import argparse
@@ -46,14 +49,14 @@ import sys
 from typing import Optional
 
 import httpx
-import torch
-import torch.nn.functional as F
-import vllm
 from datasets import load_dataset
 from huggingface_hub import hf_hub_url, login
 from toolz import concat, keymap, partition_all
 from tqdm.auto import tqdm
-from vllm import LLM
+
+# torch and vllm are imported inside the functions that use them, so
+# `uv run classify-dataset.py --help` works without them. On HF Jobs they come from
+# the vLLM image (see the header).
 
 logging.basicConfig(
     level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
@@ -63,6 +66,9 @@ logger = logging.getLogger(__name__)
 
 def check_gpu_availability():
     """Check if CUDA is available and log GPU information."""
+    import torch
+    import vllm
+
     if not torch.cuda.is_available():
         logger.error("CUDA is not available. This script requires a GPU.")
         logger.error(
@@ -114,6 +120,9 @@ def get_top_label(output, label_map: Optional[dict[int, str]] = None):
     Returns:
         Tuple of (label, confidence_score)
     """
+    import torch
+    import torch.nn.functional as F
+
     logits = torch.tensor(output.outputs.probs)
     probs = F.softmax(logits, dim=0)
     top_idx = torch.argmax(probs).item()
@@ -143,6 +152,8 @@ def main(
         batch_size: Number of examples to process at once
         hf_token: Hugging Face authentication token
     """
+    from vllm import LLM
+
     # GPU check
     check_gpu_availability()
 
@@ -215,16 +226,18 @@ if __name__ == "__main__":
             formatter_class=argparse.RawDescriptionHelpFormatter,
             epilog="""
 Examples:
+  # Local GPU (Linux + CUDA): the header leaves vllm/torch/transformers to
+  # the HF Jobs image, so add vllm with --with.
   # Basic usage
-  uv run classify-dataset.py model/name input-dataset output-dataset
+  uv run --with vllm classify-dataset.py model/name input-dataset output-dataset
   
   # With custom column and batch size
-  uv run classify-dataset.py model/name input-dataset output-dataset \\
+  uv run --with vllm classify-dataset.py model/name input-dataset output-dataset \\
     --inference-column prompt \\
     --batch-size 50000
   
   # Using environment variable for token
-  HF_TOKEN=hf_xxx uv run classify-dataset.py model/name input-dataset output-dataset
+  HF_TOKEN=hf_xxx uv run --with vllm classify-dataset.py model/name input-dataset output-dataset
             """,
         )
 
@@ -276,19 +289,12 @@ vLLM Classification Script
 This script requires arguments. For usage information:
     uv run classify-dataset.py --help
 
-Example HF Jobs command:
-    hfjobs run \\
-        --flavor l4x1 \\
-        --secret HF_TOKEN=$(python -c "from huggingface_hub import HfFolder; print(HfFolder.get_token())") \\
-        vllm/vllm-openai:latest \\
-        /bin/bash -c '
-            uv run https://huggingface.co/datasets/uv-scripts/vllm/resolve/main/classify-dataset.py \\
-                davanstrien/ModernBERT-base-is-new-arxiv-dataset \\
-                username/input-dataset \\
-                username/output-dataset \\
-                --inference-column text \\
-                --batch-size 100000
-        ' \\
-        --project vllm-classify \\
-        --name my-classification-job
+Example HF Jobs command (the header sets the vLLM image, l4x1 and the HF_TOKEN secret):
+    hf jobs uv run \\
+        https://huggingface.co/datasets/uv-scripts/vllm/raw/main/classify-dataset.py \\
+        davanstrien/ModernBERT-base-is-new-arxiv-dataset \\
+        username/input-dataset \\
+        username/output-dataset \\
+        --inference-column text \\
+        --batch-size 100000
         """)

generate-responses.py

@@ -2,15 +2,16 @@
 # requires-python = ">=3.10"
 # dependencies = [
 #     "datasets",
-#     "flashinfer-python",
 #     "huggingface-hub",
 #     "hf-xet>= 1.1.7",
-#     "torch",
-#     "transformers",
-#     "vllm>=0.11.0",
 # ]
 #
 # [tool.hf-jobs]
+# # vllm, torch, transformers and flashinfer come from the image (PYTHONPATH). Listing them above
+# # makes uv install newer PyPI copies. PYTHONPATH shadows the copies, but the current
+# # flashinfer-python wheel (0.7.2.post1) also ships a top-level b12x module that the image lacks.
+# # The image's vllm imports it and crashes (missing flashinfer/experimental/b12x/_api.py).
+# # Seen on v0.32.0 (2026-11-05); re-test before moving the tag. Local GPU: uv run --with vllm.
 # image = "vllm/vllm-openai:v0.32.0"
 # python = "/usr/bin/python3"
 # env = { PYTHONPATH = "/usr/local/lib/python3.12/dist-packages" }
@@ -26,14 +27,15 @@ applies the model's chat template, generates responses using vLLM, and saves the
 results back to the Hub with a comprehensive dataset card.
 
 Example usage:
-    # Local execution with auto GPU detection
-    uv run generate-responses.py \\
+    # Local execution with auto GPU detection. The header leaves vllm, torch and
+    # transformers to the HF Jobs image, so add vllm with --with.
+    uv run --with vllm generate-responses.py \\
         username/input-dataset \\
         username/output-dataset \\
         --messages-column messages
 
     # With custom model and sampling parameters
-    uv run generate-responses.py \\
+    uv run --with vllm generate-responses.py \\
         username/input-dataset \\
         username/output-dataset \\
         --model-id meta-llama/Llama-3.1-8B-Instruct \\
@@ -51,14 +53,18 @@ import logging
 import os
 import sys
 from datetime import datetime
-from typing import Optional
+from typing import TYPE_CHECKING, Optional
 
 from datasets import load_dataset
 from huggingface_hub import DatasetCard, get_token, login
-from torch import cuda
 from tqdm.auto import tqdm
-from transformers import AutoTokenizer
-from vllm import LLM, SamplingParams
+
+if TYPE_CHECKING:
+    from vllm import SamplingParams
+
+# torch, transformers and vllm are imported inside the functions that use them, so
+# `uv run generate-responses.py --help` works without them. On HF Jobs they come from
+# the vLLM image (see the header).
 
 logging.basicConfig(
     level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
@@ -68,6 +74,8 @@ logger = logging.getLogger(__name__)
 
 def check_gpu_availability() -> int:
     """Check if CUDA is available and return the number of GPUs."""
+    from torch import cuda
+
     if not cuda.is_available():
         logger.error("CUDA is not available. This script requires a GPU.")
         logger.error(
@@ -89,7 +97,7 @@ def create_dataset_card(
     model_id: str,
     messages_column: str,
     prompt_column: Optional[str],
-    sampling_params: SamplingParams,
+    sampling_params: "SamplingParams",
     tensor_parallel_size: int,
     num_examples: int,
     generation_time: str,
@@ -112,6 +120,12 @@ def create_dataset_card(
 
 Note: Prompts exceeding the maximum model length were skipped and have empty responses."""
 
+    # Built outside the card f-string: a backslash inside an f-string expression is a
+    # SyntaxError before Python 3.12.
+    max_model_len_line = (
+        f" \\\n    --max-model-len {max_model_len_used}" if max_model_len_used else ""
+    )
+
     return f"""---
 tags:
 - generated
@@ -154,10 +168,10 @@ The dataset contains all columns from the source dataset plus:
 
 Generated using the vLLM inference script from [uv-scripts/vllm](https://huggingface.co/datasets/uv-scripts/vllm).
 
-To reproduce this generation:
+To reproduce this generation on HF Jobs (the script header sets the vLLM image, flavor and HF_TOKEN secret):
 
 ```bash
-uv run https://huggingface.co/datasets/uv-scripts/vllm/raw/main/generate-responses.py \\
+hf jobs uv run https://huggingface.co/datasets/uv-scripts/vllm/raw/main/generate-responses.py \\
     {source_dataset} \\
     <output-dataset> \\
     --model-id {model_id} \\
@@ -165,7 +179,7 @@ uv run https://huggingface.co/datasets/uv-scripts/vllm/raw/main/generate-respons
     --temperature {sampling_params.temperature} \\
     --top-p {sampling_params.top_p} \\
     --top-k {sampling_params.top_k} \\
-    --max-tokens {sampling_params.max_tokens}{f" \\\\\\n    --max-model-len {max_model_len_used}" if max_model_len_used else ""}
+    --max-tokens {sampling_params.max_tokens}{max_model_len_line}
 ```
 """
 
@@ -213,6 +227,9 @@ def main(
         max_samples: Maximum number of samples to process (None for all)
         hf_token: Hugging Face authentication token
     """
+    from transformers import AutoTokenizer
+    from vllm import LLM, SamplingParams
+
     generation_start_time = datetime.now().isoformat()
 
     # GPU check and configuration
@@ -423,22 +440,24 @@ if __name__ == "__main__":
             formatter_class=argparse.RawDescriptionHelpFormatter,
             epilog="""
 Examples:
+  # Local GPU (Linux + CUDA): the header leaves vllm/torch/transformers to
+  # the HF Jobs image, so add vllm with --with.
   # Basic usage with default Qwen model
-  uv run generate-responses.py input-dataset output-dataset
+  uv run --with vllm generate-responses.py input-dataset output-dataset
   
   # With custom model and parameters
-  uv run generate-responses.py input-dataset output-dataset \\
+  uv run --with vllm generate-responses.py input-dataset output-dataset \\
     --model-id meta-llama/Llama-3.1-8B-Instruct \\
     --temperature 0.9 \\
     --max-tokens 2048
   
   # Force specific GPU configuration
-  uv run generate-responses.py input-dataset output-dataset \\
+  uv run --with vllm generate-responses.py input-dataset output-dataset \\
     --tensor-parallel-size 2 \\
     --gpu-memory-utilization 0.95
   
   # Using environment variable for token
-  HF_TOKEN=hf_xxx uv run generate-responses.py input-dataset output-dataset
+  HF_TOKEN=hf_xxx uv run --with vllm generate-responses.py input-dataset output-dataset
             """,
         )
 

vlm-classify.py

@@ -5,13 +5,15 @@
 #     "huggingface-hub",
 #     "pillow",
 #     "toolz",
-#     "torch",
 #     "tqdm",
-#     "transformers",
-#     "vllm>=0.11.0",  # StructuredOutputsParams API (guided_decoding removed in 0.12.0)
 # ]
 #
 # [tool.hf-jobs]
+# # vllm, torch and transformers come from the image (PYTHONPATH). Listing them above makes uv
+# # install newer PyPI copies plus their deps. PYTHONPATH shadows the copies, but the current
+# # flashinfer-python wheel (0.7.2.post1) also ships a top-level b12x module that the image lacks.
+# # The image's vllm imports it and crashes (missing flashinfer/experimental/b12x/_api.py).
+# # Seen on v0.32.0 (2026-11-05); re-test before moving the tag. Local GPU: uv run --with vllm.
 # image = "vllm/vllm-openai:v0.32.0"
 # python = "/usr/bin/python3"
 # env = { PYTHONPATH = "/usr/local/lib/python3.12/dist-packages" }
@@ -24,17 +26,19 @@
 Classify images using Vision Language Models with vLLM.
 
 This script processes images through VLMs to classify them into user-defined categories,
-using vLLM's GuidedDecodingParams for structured output.
+using vLLM's StructuredOutputsParams for structured output.
 
 Examples:
+    # Local GPU (Linux + CUDA): the header leaves vllm/torch/transformers to
+    # the HF Jobs image, so add vllm with --with.
     # Basic classification
-    uv run vlm-classify.py \\
+    uv run --with vllm vlm-classify.py \\
         username/input-dataset \\
         username/output-dataset \\
         --classes "document,photo,diagram,other"
     
     # With custom prompt and model
-    uv run vlm-classify.py \\
+    uv run --with vllm vlm-classify.py \\
         username/input-dataset \\
         username/output-dataset \\
         --classes "index-card,manuscript,title-page,other" \\
@@ -42,7 +46,7 @@ Examples:
         --model Qwen/Qwen2-VL-7B-Instruct
     
     # Quick test with sample limit
-    uv run vlm-classify.py \\
+    uv run --with vllm vlm-classify.py \\
         davanstrien/sloane-index-cards \\
         username/test-output \\
         --classes "index,content,other" \\
@@ -58,14 +62,14 @@ import sys
 from collections import Counter
 from typing import List, Optional, Union, Dict, Any
 
-import torch
 from PIL import Image
 from datasets import load_dataset
 from huggingface_hub import login
 from toolz import partition_all
 from tqdm.auto import tqdm
-from vllm import LLM, SamplingParams
-from vllm.sampling_params import StructuredOutputsParams
+
+# torch and vllm are imported inside main(), so `uv run vlm-classify.py --help` works
+# without them. On HF Jobs they come from the vLLM image (see the header).
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -142,6 +146,9 @@ def main(
     private: bool = False,
 ):
     """Classify images from a dataset using a Vision Language Model."""
+    import torch
+    from vllm import LLM, SamplingParams
+    from vllm.sampling_params import StructuredOutputsParams
 
     # Check GPU availability
     if not torch.cuda.is_available():
@@ -303,14 +310,16 @@ if __name__ == "__main__":
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog="""
 Examples:
+    # Local GPU (Linux + CUDA): the header leaves vllm/torch/transformers to
+    # the HF Jobs image, so add vllm with --with.
     # Basic classification
-    uv run vlm-classify.py \\
+    uv run --with vllm vlm-classify.py \\
         username/input-dataset \\
         username/output-dataset \\
         --classes "document,photo,diagram,other"
     
     # With custom prompt
-    uv run vlm-classify.py \\
+    uv run --with vllm vlm-classify.py \\
         username/input-dataset \\
         username/output-dataset \\
         --classes "index-card,manuscript,other" \\