Add ASCII trend charts to temporal analysis

- Add ascii-graph dependency for text-based visualizations
- Show both high_edu_rate and avg_edu_score charts by year
- Embed charts in README dataset card
- Display charts in console output

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

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

finepdfs-stats.py

@@ -4,72 +4,35 @@
 #     "polars>=1.31.0",
 #     "huggingface-hub",
 #     "datasets",
+#     "ascii-graph",
 # ]
 # ///
 """
-Compute aggregate statistics on FinePDFs datasets using Polars streaming.
+Analyze educational quality trends across CommonCrawl dumps 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.
+Answers: "Is the web getting more educational over time?"
 
-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.
+Demonstrates Polars HF Hub integration - process 23M+ docs without downloading 300GB.
 
 Example usage:
-    # List available language+script combinations
-    uv run finepdfs-stats.py --list-languages
-
-    # Compute stats for English (default: finepdfs-edu)
+    # Analyze English PDFs (default)
     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
+    # Analyze all 70+ languages
+    uv run finepdfs-stats.py --all-languages
 
-    # Limit to first N rows for testing
-    uv run finepdfs-stats.py --limit 10000
+    # Quick test
+    uv run finepdfs-stats.py --limit 10000 --show-plan
 
-    # Save results and upload to HF
-    uv run finepdfs-stats.py --output-repo username/finepdfs-edu-stats
+    # Save results to HF Hub
+    uv run finepdfs-stats.py --output-repo username/finepdfs-temporal-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
+    # Run on HF Jobs
     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)
+        https://huggingface.co/datasets/uv-scripts/dataset-stats/raw/main/finepdfs-stats.py \\
+        -- --output-repo username/stats
 """
 
 import argparse
@@ -80,6 +43,7 @@ import time
 from pathlib import Path
 
 import polars as pl
+from ascii_graph import Pyasciigraph
 from datasets import Dataset
 from huggingface_hub import HfApi, create_repo, list_repo_tree, login
 
@@ -124,165 +88,173 @@ def list_available_languages(dataset_id: str) -> list[str]:
         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_temporal_stats(df: pl.LazyFrame, output_path: Path) -> pl.DataFrame:
+    """Single scan: compute stats grouped by dump for temporal analysis."""
+    query = df.group_by("dump").agg(
+        pl.len().alias("doc_count"),
+        pl.col("token_count").sum().alias("total_tokens"),
+        pl.col("fw_edu_scores").list.mean().mean().alias("avg_edu_score"),
+        (pl.col("fw_edu_scores").list.mean() >= 3).sum().alias("high_edu_count"),
+    )
+    query.sink_parquet(output_path, engine="streaming")
+    return pl.read_parquet(output_path)
+
+
+def compute_global_stats(temporal: pl.DataFrame) -> pl.DataFrame:
+    """Compute global stats from temporal breakdown."""
+    total = temporal["doc_count"].sum()
+    return pl.DataFrame(
+        {
+            "total_docs": [total],
+            "total_tokens": [temporal["total_tokens"].sum()],
+            "avg_edu_score": [
+                (temporal["avg_edu_score"] * temporal["doc_count"]).sum() / total
+            ],
+            "high_edu_rate": [temporal["high_edu_count"].sum() / total],
+            "num_dumps": [len(temporal)],
+        }
     )
 
 
-def compute_extractor_stats(df: pl.LazyFrame) -> pl.DataFrame:
-    """Compute per-extractor statistics."""
+def format_temporal_stats(temporal: pl.DataFrame) -> pl.DataFrame:
+    """Format temporal stats with high_edu_rate, sorted chronologically."""
     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"),
+        temporal.with_columns(
+            (pl.col("high_edu_count") / pl.col("doc_count")).alias("high_edu_rate")
         )
-        .sort("doc_count", descending=True)
-        .collect(engine="streaming")
+        .select(["dump", "doc_count", "avg_edu_score", "high_edu_rate"])
+        .sort(
+            "dump"
+        )  # Chronological order (CC-MAIN-2017-xx comes before CC-MAIN-2024-xx)
     )
 
 
-def compute_dump_stats(df: pl.LazyFrame) -> pl.DataFrame:
-    """Compute per-dump statistics."""
-    return (
-        df.group_by("dump")
+def create_ascii_charts(temporal_stats: pl.DataFrame) -> str:
+    """Create ASCII bar charts showing temporal trends."""
+    # Extract year from dump name (CC-MAIN-2024-42 -> 2024)
+    # Group by year and average the values for cleaner display
+    yearly = (
+        temporal_stats.with_columns(
+            pl.col("dump").str.extract(r"CC-MAIN-(\d{4})", 1).alias("year")
+        )
+        .group_by("year")
         .agg(
-            pl.len().alias("doc_count"),
-            pl.col("token_count").sum().alias("total_tokens"),
-            pl.col("token_count").mean().alias("avg_tokens"),
+            pl.col("doc_count").sum(),
+            pl.col("avg_edu_score").mean(),
+            pl.col("high_edu_rate").mean(),
         )
-        .sort("doc_count", descending=True)
-        .collect(engine="streaming")
+        .sort("year")
     )
 
+    lines = []
 
-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")
+    # High edu rate chart (more dramatic differences)
+    data_rate = [
+        (row["year"], row["high_edu_rate"] * 100)
+        for row in yearly.iter_rows(named=True)
+    ]
+    graph = Pyasciigraph(line_length=60, float_format="{0:.1f}%")
+    lines.extend(graph.graph("High Educational Content (edu >= 3)", data_rate))
+
+    lines.append("")
+
+    # Avg edu score chart
+    data_score = [
+        (row["year"], row["avg_edu_score"]) for row in yearly.iter_rows(named=True)
+    ]
+    graph2 = Pyasciigraph(line_length=60, float_format="{0:.2f}")
+    lines.extend(graph2.graph("Average Educational Score", data_score))
+
+    return "\n".join(lines)
 
 
 def create_readme(
     args,
     global_stats: pl.DataFrame,
-    timings: dict[str, float],
+    temporal_stats: pl.DataFrame,
+    scan_time: float,
+    ascii_charts: str,
 ) -> 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())
+    total_docs = stats.get("total_docs", 0)
+    docs_per_sec = total_docs / scan_time if scan_time > 0 else 0
 
-    # Format timings table
-    timing_rows = "\n".join(f"| {name} | {t:.2f}s |" for name, t in timings.items())
+    # Get first and last dumps for trend
+    first_dump = temporal_stats.head(1).to_dicts()[0]
+    last_dump = temporal_stats.tail(1).to_dicts()[0]
+
+    scope = (
+        "all languages"
+        if args.all_languages
+        else COMMON_LANGUAGES.get(args.lang, args.lang)
+    )
 
     return f"""---
 tags:
   - statistics
   - polars
   - finepdfs-edu
+  - temporal-analysis
 license: odc-by
 ---
 
-# Statistics for {args.source_dataset} ({lang_name})
+# Is the Web Getting More Educational?
 
-Aggregate statistics computed using Polars streaming on the [{args.source_dataset}](https://huggingface.co/datasets/{args.source_dataset}) dataset.
+Temporal analysis of educational quality across {stats.get("num_dumps", 0)} CommonCrawl dumps.
 
-## Performance
+## Trend
 
-Processed **{stats.get("total_docs", 0):,} documents** in **{total_time:.2f} seconds**.
+```
+{ascii_charts}
+```
 
-| Step | Time |
-|------|------|
-{timing_rows}
-| **Total** | **{total_time:.2f}s** |
+## Key Finding
 
-> Speed comes from Polars only reading metadata columns (not the `text` column),
-> thanks to Parquet's columnar format and lazy evaluation.
+| Period | Avg Edu Score | High Edu Rate |
+|--------|---------------|---------------|
+| {first_dump["dump"]} | {first_dump["avg_edu_score"]:.3f} | {first_dump["high_edu_rate"] * 100:.1f}% |
+| {last_dump["dump"]} | {last_dump["avg_edu_score"]:.3f} | {last_dump["high_edu_rate"] * 100:.1f}% |
 
-## How This Was Generated
+## Performance
 
-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).
+- **{total_docs:,} documents** processed in **{scan_time:.0f} seconds**
+- **{docs_per_sec:,.0f} docs/sec** using Polars streaming
+- Single scan, no download of 300GB+ dataset
 
-```bash
-uv run finepdfs-stats.py --lang {args.lang} --output-repo {args.output_repo or "username/stats"}
-```
-
-## Global Summary
+## 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")
+| Scope | {scope} |
+| Total Documents | {total_docs:,} |
+| Total Tokens | {stats.get("total_tokens", 0):,} |
+| Avg Edu Score | {stats.get("avg_edu_score", 0):.3f} |
+| High Edu Rate | {stats.get("high_edu_rate", 0) * 100:.1f}% |
+| CommonCrawl Dumps | {stats.get("num_dumps", 0)} |
+
+## Files
+
+- `global_stats` - Overall summary
+- `temporal_stats` - Per-dump breakdown (sorted chronologically)
+
+## Reproduce
+
+```bash
+uv run https://huggingface.co/datasets/uv-scripts/dataset-stats/raw/main/finepdfs-stats.py \\
+    {"--all-languages" if args.all_languages else f"--lang {args.lang}"} --output-repo your-username/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)
+- **Script**: [uv-scripts/dataset-stats](https://huggingface.co/datasets/uv-scripts/dataset-stats)
 """
 
 
 def main():
     parser = argparse.ArgumentParser(
-        description="Compute aggregate statistics on HF datasets using Polars streaming",
+        description="Analyze educational quality trends across CommonCrawl dumps",
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog=__doc__,
     )
@@ -291,26 +263,32 @@ def main():
         "--source-dataset",
         type=str,
         default="HuggingFaceFW/finepdfs-edu",
-        help="Source dataset: HuggingFaceFW/finepdfs-edu (49.5M rows) or HuggingFaceFW/finepdfs (476M rows)",
+        help="Source dataset (default: HuggingFaceFW/finepdfs-edu)",
     )
 
     parser.add_argument(
-        "--show-plan",
+        "--lang",
+        type=str,
+        default="eng_Latn",
+        help="Language+script code (default: eng_Latn)",
+    )
+
+    parser.add_argument(
+        "--all-languages",
         action="store_true",
-        help="Show Polars query plan before execution (demonstrates optimization)",
+        help="Analyze all languages (70+) instead of single language",
     )
 
     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)",
+        "--show-plan",
+        action="store_true",
+        help="Show Polars query plan (demonstrates optimization)",
     )
 
     parser.add_argument(
         "--list-languages",
         action="store_true",
-        help="List available language+script codes and exit",
+        help="List available languages and exit",
     )
 
     parser.add_argument(
@@ -329,7 +307,7 @@ def main():
         "--output-dir",
         type=str,
         default="./stats_output",
-        help="Local directory for output files (default: ./stats_output)",
+        help="Local directory for output files",
     )
 
     parser.add_argument(
@@ -367,11 +345,17 @@ def main():
         sys.exit(0)
 
     # Build the parquet path
-    source_path = (
-        f"hf://datasets/{args.source_dataset}/data/{args.lang}/train/*.parquet"
-    )
+    if args.all_languages:
+        source_path = f"hf://datasets/{args.source_dataset}/data/*/train/*.parquet"
+        scope_desc = "all languages"
+    else:
+        source_path = (
+            f"hf://datasets/{args.source_dataset}/data/{args.lang}/train/*.parquet"
+        )
+        scope_desc = f"{args.lang} ({COMMON_LANGUAGES.get(args.lang, 'unknown')})"
+
     logger.info(f"Scanning: {source_path}")
-    logger.info(f"Language: {args.lang} ({COMMON_LANGUAGES.get(args.lang, 'unknown')})")
+    logger.info(f"Scope: {scope_desc}")
 
     # Create lazy frame - this doesn't load any data yet!
     logger.info("Creating lazy query plan...")
@@ -401,60 +385,64 @@ def main():
     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...")
+    # Single scan: compute temporal stats
+    logger.info("Computing temporal stats (single scan)...")
     start = time.perf_counter()
-    global_stats = compute_global_stats(df)
-    timings["Global stats"] = time.perf_counter() - start
-    print("\nGlobal Statistics:")
-    print(global_stats)
+    temporal_path = output_dir / "temporal_stats.parquet"
+    temporal_raw = compute_temporal_stats(df, temporal_path)
+    scan_time = time.perf_counter() - start
+    logger.info(f"Scan complete in {scan_time:.2f}s - {len(temporal_raw)} dumps")
+
+    # Compute stats
+    global_stats = compute_global_stats(temporal_raw)
+    temporal_stats = format_temporal_stats(temporal_raw)
+
+    # Save
     global_stats.write_parquet(output_dir / "global_stats.parquet")
+    temporal_stats.write_parquet(output_dir / "temporal_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")
+    # Print results
+    total_docs = global_stats["total_docs"][0]
+    docs_per_sec = total_docs / scan_time if scan_time > 0 else 0
 
-    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")
+    print("\n" + "=" * 70)
+    print("IS THE WEB GETTING MORE EDUCATIONAL?")
+    print("=" * 70)
 
-    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")
+    print(f"\nScope: {scope_desc}")
+    print(f"Dataset: {args.source_dataset}")
+
+    print("\n" + "-" * 70)
+    print("GLOBAL STATS")
+    print("-" * 70)
+    print(global_stats)
+
+    print("\n" + "-" * 70)
+    print(f"TEMPORAL TREND ({len(temporal_stats)} CommonCrawl dumps)")
+    print("-" * 70)
+    # Show first 5 and last 5
+    if len(temporal_stats) > 10:
+        print("Earliest dumps:")
+        print(temporal_stats.head(5))
+        print("\n...")
+        print("\nLatest dumps:")
+        print(temporal_stats.tail(5))
+    else:
+        print(temporal_stats)
+
+    # Create ASCII charts
+    ascii_charts = create_ascii_charts(temporal_stats)
+    print("\n" + "-" * 70)
+    print("TREND VISUALIZATION")
+    print("-" * 70)
+    print(ascii_charts)
+
+    print("\n" + "-" * 70)
+    print("PERFORMANCE")
+    print("-" * 70)
+    print(f"Scan time: {scan_time:.2f}s")
+    print(f"Documents: {total_docs:,}")
+    print(f"Throughput: {docs_per_sec:,.0f} docs/sec")
 
     logger.info(f"Results saved to: {output_dir}")
 
@@ -481,26 +469,27 @@ def main():
             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,
-        }
+        # Upload each as a dataset config
+        configs = [
+            ("global_stats", global_stats),
+            ("temporal_stats", temporal_stats),
+        ]
 
-        for config_name, df in configs.items():
+        for config_name, stats_df in configs:
             logger.info(f"Uploading {config_name}...")
-            ds = Dataset.from_polars(df)
+            ds = Dataset.from_polars(stats_df)
             ds.push_to_hub(
                 args.output_repo,
                 config_name=config_name,
                 token=hf_token,
                 private=args.private,
             )
+            time.sleep(1)  # Avoid 409 conflicts
 
-        # Create and upload README
-        readme_content = create_readme(args, global_stats, timings)
+        # Upload README
+        readme_content = create_readme(
+            args, global_stats, temporal_stats, scan_time, ascii_charts
+        )
         api.upload_file(
             path_or_fileobj=readme_content.encode(),
             path_in_repo="README.md",
@@ -516,27 +505,28 @@ def main():
 
 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("Is the Web Getting More Educational?")
+        print("=" * 40)
+        print("\nAnalyze educational quality trends across CommonCrawl dumps")
+        print("using Polars streaming - no download needed!\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("# Quick test:")
         print("uv run finepdfs-stats.py --limit 10000\n")
+        print("# Analyze English PDFs:")
+        print("uv run finepdfs-stats.py\n")
+        print("# Analyze ALL 70+ languages:")
+        print("uv run finepdfs-stats.py --all-languages\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("uv run finepdfs-stats.py --output-repo username/temporal-stats\n")
+        print("# Run on HF Jobs:")
+        print("hf jobs uv run \\")
         print("    -s HF_TOKEN \\")
         print("    -e HF_XET_HIGH_PERFORMANCE=1 \\")
+        print(
+            "    https://huggingface.co/datasets/uv-scripts/dataset-stats/raw/main/finepdfs-stats.py \\"
+        )
         print("    -- --output-repo username/stats")
         sys.exit(0)