Add finepdfs-stats.py - Polars streaming aggregation demo

Computes aggregate statistics on FinePDFs datasets using Polars
streaming without downloading the full dataset.

Features:
- Supports both finepdfs-edu (49.5M rows) and finepdfs (476M rows)
- --lang flag for language+script selection (70+ languages)
- --show-plan to display Polars query optimization
- --limit for quick testing
- Uploads results to HF Hub with auto-generated dataset_info
- Timing summary included in output

Demonstrates polars#25521 which reduced API calls from 139 → 1.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

finepdfs-stats.py

@@ -0,0 +1,543 @@
+# /// script
+# requires-python = ">=3.12"
+# dependencies = [
+#     "polars>=1.31.0",
+#     "huggingface-hub",
+#     "datasets",
+# ]
+# ///
+"""
+Compute aggregate statistics on FinePDFs datasets using Polars streaming.
+
+Demonstrates the new Polars HF Hub integration (polars#25521) which reduces
+API calls from 139 → 1 for datasets like finepdfs-edu, enabling efficient
+streaming aggregation without downloading the full dataset.
+
+Supported datasets:
+- HuggingFaceFW/finepdfs-edu (49.5M rows, 350B tokens) - educational subset
+- HuggingFaceFW/finepdfs (476M rows, 3T tokens) - full dataset
+
+This script computes:
+- Per-language statistics (doc count, token totals, avg edu scores)
+- Per-extractor statistics
+- Per-dump statistics
+- Global summary metrics
+
+The result is a small summary DataFrame that can be uploaded as a new dataset.
+
+Example usage:
+    # List available language+script combinations
+    uv run finepdfs-stats.py --list-languages
+
+    # Compute stats for English (default: finepdfs-edu)
+    uv run finepdfs-stats.py
+
+    # Process French documents
+    uv run finepdfs-stats.py --lang fra_Latn
+
+    # Use full finepdfs dataset (476M rows)
+    uv run finepdfs-stats.py --source-dataset HuggingFaceFW/finepdfs
+
+    # Show query plan before execution
+    uv run finepdfs-stats.py --show-plan --limit 1000
+
+    # Limit to first N rows for testing
+    uv run finepdfs-stats.py --limit 10000
+
+    # Save results and upload to HF
+    uv run finepdfs-stats.py --output-repo username/finepdfs-edu-stats
+
+    # Run on HF Jobs (CPU is sufficient, no GPU needed)
+    hf jobs uv run finepdfs-stats.py \\
+        -s HF_TOKEN \\
+        -e HF_XET_HIGH_PERFORMANCE=1 \\
+        -- --output-repo username/finepdfs-edu-stats
+
+    # Or run from a URL
+    hf jobs uv run \\
+        -s HF_TOKEN \\
+        -e HF_XET_HIGH_PERFORMANCE=1 \\
+        "https://huggingface.co/datasets/uv-scripts/data-stats/raw/main/finepdfs-stats.py" \\
+        -- --output-repo username/finepdfs-edu-stats
+
+Why Polars scan_parquet?
+    - Lazy evaluation: builds query plan without loading data
+    - Streaming execution: processes data in chunks, constant memory
+    - Native HF Hub support: hf://datasets/... paths just work
+    - Optimized API calls: PR #25521 reduced API calls 10-100x for HF datasets
+
+Performance tips:
+    - Set HF_XET_HIGH_PERFORMANCE=1 to maximize network/disk utilization
+    - Use --limit for quick tests before running on full dataset
+    - Use --show-plan to see Polars query optimization (projection pushdown)
+"""
+
+import argparse
+import logging
+import os
+import sys
+import time
+from pathlib import Path
+
+import polars as pl
+from datasets import Dataset
+from huggingface_hub import HfApi, create_repo, list_repo_tree, login
+
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+# Common language+script codes for finepdfs-edu
+COMMON_LANGUAGES = {
+    "eng_Latn": "English (Latin script)",
+    "fra_Latn": "French (Latin script)",
+    "deu_Latn": "German (Latin script)",
+    "spa_Latn": "Spanish (Latin script)",
+    "por_Latn": "Portuguese (Latin script)",
+    "ita_Latn": "Italian (Latin script)",
+    "nld_Latn": "Dutch (Latin script)",
+    "pol_Latn": "Polish (Latin script)",
+    "rus_Cyrl": "Russian (Cyrillic script)",
+    "zho_Hans": "Chinese (Simplified)",
+    "zho_Hant": "Chinese (Traditional)",
+    "jpn_Jpan": "Japanese",
+    "kor_Hang": "Korean",
+    "ara_Arab": "Arabic",
+    "hin_Deva": "Hindi (Devanagari)",
+}
+
+
+def list_available_languages(dataset_id: str) -> list[str]:
+    """List available language subsets in the dataset."""
+    try:
+        tree = list_repo_tree(dataset_id, path_in_repo="data", repo_type="dataset")
+        languages = [
+            item.path.replace("data/", "")
+            for item in tree
+            if item.path.startswith("data/")
+            and "/" not in item.path.replace("data/", "")
+        ]
+        return sorted(languages)
+    except Exception as e:
+        logger.warning(f"Could not list languages: {e}")
+        return list(COMMON_LANGUAGES.keys())
+
+
+def compute_language_stats(df: pl.LazyFrame) -> pl.DataFrame:
+    """Compute per-language statistics."""
+    return (
+        df.group_by("language")
+        .agg(
+            pl.len().alias("doc_count"),
+            pl.col("token_count").sum().alias("total_tokens"),
+            pl.col("token_count").mean().alias("avg_tokens"),
+            pl.col("token_count").median().alias("median_tokens"),
+            pl.col("token_count").min().alias("min_tokens"),
+            pl.col("token_count").max().alias("max_tokens"),
+            pl.col("page_average_lid_score").mean().alias("avg_lid_score"),
+            pl.col("is_truncated").sum().alias("truncated_count"),
+            pl.col("minhash_cluster_size").mean().alias("avg_cluster_size"),
+            pl.col("duplicate_count").sum().alias("total_duplicates"),
+        )
+        .sort("doc_count", descending=True)
+        .collect(engine="streaming")
+    )
+
+
+def compute_extractor_stats(df: pl.LazyFrame) -> pl.DataFrame:
+    """Compute per-extractor statistics."""
+    return (
+        df.group_by("extractor")
+        .agg(
+            pl.len().alias("doc_count"),
+            pl.col("token_count").sum().alias("total_tokens"),
+            pl.col("token_count").mean().alias("avg_tokens"),
+            pl.col("is_truncated").sum().alias("truncated_count"),
+            pl.col("page_average_lid_score").mean().alias("avg_lid_score"),
+        )
+        .sort("doc_count", descending=True)
+        .collect(engine="streaming")
+    )
+
+
+def compute_dump_stats(df: pl.LazyFrame) -> pl.DataFrame:
+    """Compute per-dump statistics."""
+    return (
+        df.group_by("dump")
+        .agg(
+            pl.len().alias("doc_count"),
+            pl.col("token_count").sum().alias("total_tokens"),
+            pl.col("token_count").mean().alias("avg_tokens"),
+        )
+        .sort("doc_count", descending=True)
+        .collect(engine="streaming")
+    )
+
+
+def compute_global_stats(df: pl.LazyFrame) -> pl.DataFrame:
+    """Compute global summary statistics."""
+    return df.select(
+        pl.len().alias("total_docs"),
+        pl.col("token_count").sum().alias("total_tokens"),
+        pl.col("token_count").mean().alias("avg_tokens"),
+        pl.col("token_count").median().alias("median_tokens"),
+        pl.col("token_count").std().alias("std_tokens"),
+        pl.col("is_truncated").sum().alias("truncated_docs"),
+        pl.col("is_truncated").mean().alias("truncation_rate"),
+        pl.col("minhash_cluster_size").mean().alias("avg_cluster_size"),
+        pl.col("duplicate_count").sum().alias("total_duplicates"),
+        pl.col("language").n_unique().alias("unique_languages"),
+        pl.col("extractor").n_unique().alias("unique_extractors"),
+        pl.col("dump").n_unique().alias("unique_dumps"),
+    ).collect(engine="streaming")
+
+
+def create_readme(
+    args,
+    global_stats: pl.DataFrame,
+    timings: dict[str, float],
+) -> str:
+    """Create README content for the stats dataset."""
+    stats = global_stats.to_dicts()[0]
+    lang_name = COMMON_LANGUAGES.get(args.lang, args.lang)
+    total_time = sum(timings.values())
+
+    # Format timings table
+    timing_rows = "\n".join(f"| {name} | {t:.2f}s |" for name, t in timings.items())
+
+    return f"""---
+tags:
+  - statistics
+  - polars
+  - finepdfs-edu
+license: odc-by
+---
+
+# Statistics for {args.source_dataset} ({lang_name})
+
+Aggregate statistics computed using Polars streaming on the [{args.source_dataset}](https://huggingface.co/datasets/{args.source_dataset}) dataset.
+
+## Performance
+
+Processed **{stats.get("total_docs", 0):,} documents** in **{total_time:.2f} seconds**.
+
+| Step | Time |
+|------|------|
+{timing_rows}
+| **Total** | **{total_time:.2f}s** |
+
+> Speed comes from Polars only reading metadata columns (not the `text` column),
+> thanks to Parquet's columnar format and lazy evaluation.
+
+## How This Was Generated
+
+This dataset demonstrates **Polars streaming aggregation** with HuggingFace Hub integration.
+Thanks to [polars#25521](https://github.com/pola-rs/polars/pull/25521), `scan_parquet`
+with `hf://` paths now uses far fewer API calls (139 → 1 for finepdfs-edu).
+
+```bash
+uv run finepdfs-stats.py --lang {args.lang} --output-repo {args.output_repo or "username/stats"}
+```
+
+## Global Summary
+
+| Metric | Value |
+|--------|-------|
+| Language | {lang_name} (`{args.lang}`) |
+| Total Documents | {stats.get("total_docs", "N/A"):,} |
+| Total Tokens | {stats.get("total_tokens", "N/A"):,} |
+| Average Tokens/Doc | {stats.get("avg_tokens", 0):,.0f} |
+| Truncated Documents | {stats.get("truncated_docs", 0):,} ({stats.get("truncation_rate", 0) * 100:.1f}%) |
+| Unique Languages | {stats.get("unique_languages", "N/A")} |
+| Unique Extractors | {stats.get("unique_extractors", "N/A")} |
+| Unique Dumps | {stats.get("unique_dumps", "N/A")} |
+
+## Configs
+
+- `global_stats` - Overall summary (1 row)
+- `language_stats` - Per-language aggregations
+- `extractor_stats` - Per-extractor aggregations
+- `dump_stats` - Per-dump aggregations
+
+## Usage
+
+```python
+from datasets import load_dataset
+
+# Load all configs
+global_stats = load_dataset("{args.output_repo or "username/stats"}", "global_stats")
+lang_stats = load_dataset("{args.output_repo or "username/stats"}", "language_stats")
+extractor_stats = load_dataset("{args.output_repo or "username/stats"}", "extractor_stats")
+dump_stats = load_dataset("{args.output_repo or "username/stats"}", "dump_stats")
+```
+
+## Source
+
+- **Dataset**: [{args.source_dataset}](https://huggingface.co/datasets/{args.source_dataset})
+- **Language**: {args.lang}
+- **Script**: [finepdfs-stats.py](https://huggingface.co/datasets/uv-scripts/data-stats)
+"""
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Compute aggregate statistics on HF datasets using Polars streaming",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
+
+    parser.add_argument(
+        "--source-dataset",
+        type=str,
+        default="HuggingFaceFW/finepdfs-edu",
+        help="Source dataset: HuggingFaceFW/finepdfs-edu (49.5M rows) or HuggingFaceFW/finepdfs (476M rows)",
+    )
+
+    parser.add_argument(
+        "--show-plan",
+        action="store_true",
+        help="Show Polars query plan before execution (demonstrates optimization)",
+    )
+
+    parser.add_argument(
+        "--lang",
+        type=str,
+        default="eng_Latn",
+        help="Language+script code to process, e.g., eng_Latn, fra_Latn, zho_Hans (default: eng_Latn)",
+    )
+
+    parser.add_argument(
+        "--list-languages",
+        action="store_true",
+        help="List available language+script codes and exit",
+    )
+
+    parser.add_argument(
+        "--limit",
+        type=int,
+        help="Limit to first N rows (for testing)",
+    )
+
+    parser.add_argument(
+        "--output-repo",
+        type=str,
+        help="HuggingFace dataset repository to upload results",
+    )
+
+    parser.add_argument(
+        "--output-dir",
+        type=str,
+        default="./stats_output",
+        help="Local directory for output files (default: ./stats_output)",
+    )
+
+    parser.add_argument(
+        "--hf-token",
+        type=str,
+        help="HuggingFace API token (or set HF_TOKEN env var)",
+    )
+
+    parser.add_argument(
+        "--private",
+        action="store_true",
+        help="Make the output dataset private",
+    )
+
+    args = parser.parse_args()
+
+    # Check for high-performance mode
+    if os.environ.get("HF_XET_HIGH_PERFORMANCE"):
+        logger.info("High-performance mode enabled (HF_XET_HIGH_PERFORMANCE=1)")
+
+    # List languages mode
+    if args.list_languages:
+        print(f"Available language+script codes for {args.source_dataset}:\n")
+        print("Common languages:")
+        for code, name in COMMON_LANGUAGES.items():
+            print(f"  {code:12} - {name}")
+        print("\nFetching full list from HF Hub...")
+        all_langs = list_available_languages(args.source_dataset)
+        print(f"\nAll available ({len(all_langs)} total):")
+        for lang in all_langs[:30]:  # Show first 30
+            name = COMMON_LANGUAGES.get(lang, "")
+            print(f"  {lang:12} {name}")
+        if len(all_langs) > 30:
+            print(f"  ... and {len(all_langs) - 30} more")
+        sys.exit(0)
+
+    # Build the parquet path
+    source_path = (
+        f"hf://datasets/{args.source_dataset}/data/{args.lang}/train/*.parquet"
+    )
+    logger.info(f"Scanning: {source_path}")
+    logger.info(f"Language: {args.lang} ({COMMON_LANGUAGES.get(args.lang, 'unknown')})")
+
+    # Create lazy frame - this doesn't load any data yet!
+    logger.info("Creating lazy query plan...")
+    df = pl.scan_parquet(source_path)
+
+    # Apply limit if specified
+    if args.limit:
+        logger.info(f"Limiting to first {args.limit:,} rows")
+        df = df.head(args.limit)
+
+    # Show query plan if requested
+    if args.show_plan:
+        # Build a sample query to show the plan
+        sample_query = df.select(
+            pl.len(),
+            pl.col("token_count").sum(),
+            pl.col("language").n_unique(),
+        )
+        print("\nQuery Plan (showing Polars optimization):")
+        print("=" * 60)
+        print(sample_query.explain())
+        print("=" * 60)
+        print("\nNote: Polars uses projection pushdown - only reads columns needed!")
+        print("The 'text' column is never loaded, making this very fast.\n")
+
+    # Create output directory
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Track timings
+    timings: dict[str, float] = {}
+
+    # Compute statistics (streaming execution happens here)
+    logger.info("Computing global statistics...")
+    start = time.perf_counter()
+    global_stats = compute_global_stats(df)
+    timings["Global stats"] = time.perf_counter() - start
+    print("\nGlobal Statistics:")
+    print(global_stats)
+    global_stats.write_parquet(output_dir / "global_stats.parquet")
+
+    logger.info("Computing per-language statistics...")
+    start = time.perf_counter()
+    # Need to re-scan since we consumed the lazy frame
+    df = pl.scan_parquet(source_path)
+    if args.limit:
+        df = df.head(args.limit)
+    lang_stats = compute_language_stats(df)
+    timings["Language stats"] = time.perf_counter() - start
+    print(f"\nLanguage Statistics ({len(lang_stats)} languages):")
+    print(lang_stats.head(20))
+    lang_stats.write_parquet(output_dir / "language_stats.parquet")
+
+    logger.info("Computing per-extractor statistics...")
+    start = time.perf_counter()
+    df = pl.scan_parquet(source_path)
+    if args.limit:
+        df = df.head(args.limit)
+    extractor_stats = compute_extractor_stats(df)
+    timings["Extractor stats"] = time.perf_counter() - start
+    print("\nExtractor Statistics:")
+    print(extractor_stats)
+    extractor_stats.write_parquet(output_dir / "extractor_stats.parquet")
+
+    logger.info("Computing per-dump statistics...")
+    start = time.perf_counter()
+    df = pl.scan_parquet(source_path)
+    if args.limit:
+        df = df.head(args.limit)
+    dump_stats = compute_dump_stats(df)
+    timings["Dump stats"] = time.perf_counter() - start
+    print(f"\nDump Statistics ({len(dump_stats)} dumps):")
+    print(dump_stats.head(20))
+    dump_stats.write_parquet(output_dir / "dump_stats.parquet")
+
+    # Print timing summary
+    total_time = sum(timings.values())
+    print("\nTiming Summary:")
+    print("-" * 30)
+    for name, t in timings.items():
+        print(f"  {name}: {t:.2f}s")
+    print("-" * 30)
+    print(f"  Total: {total_time:.2f}s")
+
+    logger.info(f"Results saved to: {output_dir}")
+
+    # Upload to HF Hub if requested
+    if args.output_repo:
+        hf_token = args.hf_token or os.environ.get("HF_TOKEN")
+        if hf_token:
+            login(token=hf_token)
+
+        api = HfApi(token=hf_token)
+
+        logger.info(f"Creating dataset repository: {args.output_repo}")
+        try:
+            create_repo(
+                args.output_repo,
+                repo_type="dataset",
+                private=args.private,
+                token=hf_token,
+            )
+            logger.info(f"Created new dataset: {args.output_repo}")
+        except Exception as e:
+            if "already exists" in str(e).lower():
+                logger.info(f"Dataset {args.output_repo} already exists, updating...")
+            else:
+                raise
+
+        # Upload each stats DataFrame as a separate config using datasets
+        configs = {
+            "global_stats": global_stats,
+            "language_stats": lang_stats,
+            "extractor_stats": extractor_stats,
+            "dump_stats": dump_stats,
+        }
+
+        for config_name, df in configs.items():
+            logger.info(f"Uploading {config_name}...")
+            ds = Dataset.from_polars(df)
+            ds.push_to_hub(
+                args.output_repo,
+                config_name=config_name,
+                token=hf_token,
+                private=args.private,
+            )
+
+        # Create and upload README
+        readme_content = create_readme(args, global_stats, timings)
+        api.upload_file(
+            path_or_fileobj=readme_content.encode(),
+            path_in_repo="README.md",
+            repo_id=args.output_repo,
+            repo_type="dataset",
+            token=hf_token,
+        )
+
+        dataset_url = f"https://huggingface.co/datasets/{args.output_repo}"
+        logger.info(f"Dataset uploaded: {dataset_url}")
+        print(f"\nResults uploaded to: {dataset_url}")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) == 1:
+        print("FinePDFs Statistics - Polars Streaming Demo")
+        print("=" * 45)
+        print("\nCompute aggregate statistics on FinePDFs datasets")
+        print("using Polars streaming - no need to download the full dataset!\n")
+        print("Example commands:\n")
+        print("# List available languages:")
+        print("uv run finepdfs-stats.py --list-languages\n")
+        print("# Quick test with 10k rows:")
+        print("uv run finepdfs-stats.py --limit 10000\n")
+        print("# Show query plan (see Polars optimization):")
+        print("uv run finepdfs-stats.py --show-plan --limit 1000\n")
+        print("# Process English (default: finepdfs-edu):")
+        print("uv run finepdfs-stats.py\n")
+        print("# Use full finepdfs dataset (476M rows):")
+        print("uv run finepdfs-stats.py --source-dataset HuggingFaceFW/finepdfs\n")
+        print("# Save results to HF Hub:")
+        print("uv run finepdfs-stats.py --output-repo username/finepdfs-edu-stats\n")
+        print("# Run on HF Jobs (CPU, with high-performance transfers):")
+        print("hf jobs uv run finepdfs-stats.py \\")
+        print("    -s HF_TOKEN \\")
+        print("    -e HF_XET_HIGH_PERFORMANCE=1 \\")
+        print("    -- --output-repo username/stats")
+        sys.exit(0)
+
+    main()