Generate cached results (#376)

* feat: add script and workflow to generate cached results for leaderboard

Adds generate_cached_results.py script to pre-generate __cached_results.json
containing all benchmark results. This optimizes leaderboard startup by
saving 100+ seconds on fresh builds.

The GitHub Actions workflow automatically regenerates this cache file
whenever new results are merged to main.

* refactor: compress cached results with gzip

Changes output from __cached_results.json to __cached_results.json.gz
using gzip compression. This reduces file size by ~80-90% while
maintaining fast decompression.

Updated both the generation script and workflow to handle gzipped files.

* Apply suggestions from code review

Co-authored-by: Roman Solomatin <samoed.roman@gmail.com>

* fix: make cached results compatible with leaderboard app

- Add step to create uncompressed __cached_results.json in mteb/leaderboard/
- Update change detection to track both compressed and uncompressed files
- Modify commit step to include both cache file formats
- Enhance reporting to show sizes of both cache files

This resolves the compatibility issue where app.py couldn't find
the cache file created by the generate script due to:
- File format mismatch (gzip vs plain JSON)
- Location mismatch (repo root vs mteb/leaderboard/)

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

Co-Authored-By: Claude Sonnet 4 <noreply@anthropic.com>

* feat: commit cached results to cached-data branch

- Replace commit logic to push __cached_results.json.gz to cached-data branch
- Switch to orphaned cached-data branch to store only cache files
- Add timestamp and file size to commit messages for better tracking
- Include proper error handling and status reporting
- Use same pattern as update-cached-results.yml for consistency

This creates a dedicated branch for storing cached results separately
from the main codebase, making it easier to manage large cache files.

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

Co-Authored-By: Claude Sonnet 4 <noreply@anthropic.com>

* Preserve README.md file when updating cached-data branch

- Replace 'git rm -rf .' with selective file removal
- Exclude README.md and __cached_results.json.gz from removal
- Ensures branch documentation remains intact during workflow runs

* Use model_dump_json() instead of manual JSON serialization

- Replace model_dump(mode='json') + json.dumps() with direct model_dump_json()
- Simplifies code and makes it more idiomatic
- Combines serialization and writing steps for better readability

Addresses review comment: https://github.com/embeddings-benchmark/results/pull/376#discussion_r2645537795

---------

Co-authored-by: Roman Solomatin <samoed.roman@gmail.com>
Co-authored-by: Claude Sonnet 4 <noreply@anthropic.com>

.github/workflows/generate_cached_results.yml

@@ -0,0 +1,90 @@
+name: Generate Cached Results
+
+on:
+  push:
+    branches: [main]
+  # Allow manual trigger for testing
+  workflow_dispatch:
+
+jobs:
+  generate-cache:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Free disk space
+        run: |
+          sudo rm -rf /usr/share/dotnet
+          sudo rm -rf /opt/ghc
+          sudo rm -rf /usr/local/share/boost
+          docker system prune -af
+
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+          cache: 'pip'
+
+      - name: Install dependencies
+        run: |
+           pip install git+https://github.com/embeddings-benchmark/mteb.git
+
+      - name: Generate cached results
+        run: |
+          python scripts/generate_cached_results.py
+        env:
+          PYTHONUNBUFFERED: 1
+
+      - name: Configure Git
+        run: |
+          git config --global user.name "github-actions[bot]"
+          git config --global user.email "github-actions[bot]@users.noreply.github.com"
+
+      - name: Update cached-data branch
+        run: |
+          # Check if __cached_results.json.gz was created
+          if [ ! -f "__cached_results.json.gz" ]; then
+            echo "❌ Cached results file not found"
+            exit 1
+          fi
+
+          # Get file size for logging
+          FILE_SIZE=$(stat -f%z __cached_results.json.gz 2>/dev/null || stat -c%s __cached_results.json.gz)
+          echo "📦 Generated cache file: $(echo "scale=1; $FILE_SIZE/1024/1024" | bc -l)MB"
+
+          # Switch to cached-data branch (create if doesn't exist)
+          git checkout --orphan cached-data 2>/dev/null || git checkout cached-data
+
+          # Remove all files except README.md and the cached results
+          git ls-files | grep -v "README.md" | grep -v "__cached_results.json.gz" | xargs -r git rm 2>/dev/null || true
+
+          # Add only the cached results file
+          git add __cached_results.json.gz
+
+          # Check if there are changes to commit
+          if git diff --staged --quiet; then
+            echo "✅ No changes in cached results, skipping commit"
+          else
+            # Commit with timestamp and file size
+            TIMESTAMP=$(date -u '+%Y-%m-%d %H:%M:%S UTC')
+            COMMIT_MSG="Update cached results - $TIMESTAMP ($(echo "scale=1; $FILE_SIZE/1024/1024" | bc -l)MB)"
+            git commit -m "$COMMIT_MSG"
+
+            # Push to remote
+            git push origin cached-data
+            echo "✅ Successfully updated cached-data branch"
+          fi
+
+      - name: Report status
+        if: always()
+        run: |
+          if [ -f "__cached_results.json.gz" ]; then
+            FILE_SIZE=$(stat -f%z __cached_results.json.gz 2>/dev/null || stat -c%s __cached_results.json.gz)
+            echo "✅ Workflow completed. Cache file size: $(echo "scale=1; $FILE_SIZE/1024/1024" | bc -l)MB"
+          else
+            echo "❌ Workflow failed - no cache file generated"
+          fi

scripts/generate_cached_results.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""
+Script to generate __cached_results.json.gz for the MTEB leaderboard.
+
+This pre-generates the cached results file that the leaderboard uses,
+which can save 100+ seconds on fresh leaderboard builds.
+
+Usage:
+    python generate_cached_results.py
+
+Output:
+    Creates __cached_results.json.gz in the remote repo root directory
+"""
+
+import gzip
+import json
+import logging
+import sys
+import time
+from pathlib import Path
+
+import mteb
+from mteb.cache import ResultCache
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='[%(asctime)s] %(levelname)s - %(message)s',
+    datefmt='%H:%M:%S'
+)
+logger = logging.getLogger(__name__)
+
+
+def generate_cached_results():
+    """Generate the cached results JSON file."""
+    start_time = time.time()
+    
+    logger.info("Initializing ResultCache...")
+    cache = ResultCache(Path(__file__).parent.parent)
+    
+    # The remote repo should already be cloned from previous runs
+    logger.info("Using existing remote results repository...")
+    
+    # Load all model names
+    logger.info("Getting all model names...")
+    models_start = time.time()
+    all_model_names = [model_meta.name for model_meta in mteb.get_model_metas()]
+    models_time = time.time() - models_start
+    logger.info(f"Found {len(all_model_names)} models in {models_time:.2f}s")
+    
+    # Load results for all models
+    logger.info("Loading results from cache...")
+    load_start = time.time()
+    all_results = cache.load_results(
+        models=all_model_names,
+        only_main_score=True,
+        require_model_meta=False,
+        include_remote=True,
+    )
+    load_time = time.time() - load_start
+    logger.info(f"Loaded results in {load_time:.2f}s")
+    
+    # Serialize to JSON and write to gzip file
+    repo_root = Path(__file__).parent.parent
+    output_path = repo_root / "__cached_results.json.gz"
+    logger.info(f"Serializing to JSON and writing to {output_path}...")
+    write_start = time.time()
+    json_str = all_results.model_dump_json()
+    with gzip.open(output_path, 'wt', encoding='utf-8') as f:
+        f.write(json_str)
+    write_time = time.time() - write_start
+    logger.info(f"Serialized and written in {write_time:.2f}s")
+    
+    # Report file size
+    file_size_mb = output_path.stat().st_size / (1024 * 1024)
+    uncompressed_size_mb = len(json_str) / (1024 * 1024)
+    compression_ratio = (1 - file_size_mb / uncompressed_size_mb) * 100
+    logger.info(f"Generated {output_path} ({file_size_mb:.1f} MB)")
+    logger.info(f"Uncompressed size: {uncompressed_size_mb:.1f} MB")
+    logger.info(f"Compression ratio: {compression_ratio:.1f}%")
+    
+    total_time = time.time() - start_time
+    logger.info(f"Total time: {total_time:.2f}s")
+    
+    return output_path
+
+
+if __name__ == "__main__":
+    try:
+        output_file = generate_cached_results()
+        logger.info(f"✅ Success! Generated {output_file}")
+    except Exception as e:
+        logger.error(f"❌ Failed: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)