Add GAM and GDM metrics to the table

.claude/skills/hf-dataset-storage/SKILL.md

@@ -1,387 +0,0 @@
----
-name: hf-dataset-storage
-description: Implement persistent storage for Hugging Face Spaces using dataset storage. Use when working with HF Spaces persistence, saving space data to datasets, scheduled uploads to HuggingFace Hub, or when the user mentions dataset storage, space persistence, CommitScheduler, or backing up space data.
-allowed-tools: Read, Write, Edit, Bash, Grep, Glob
----
-
-# Hugging Face Dataset Storage for Spaces
-
-This skill helps you implement persistent storage for Hugging Face Spaces using dataset repositories as a data store.
-
-## When to Use Dataset Storage
-
-Use dataset storage for Hugging Face Spaces when:
-- You need data to persist beyond the Space's lifecycle
-- You want to collect user feedback or logs from a Space
-- You need append-only storage for analytics or training data
-- You want to avoid paying for persistent storage upgrades
-- You need to version your data over time
-
-## Quick Start
-
-### 1. Install Required Package
-
-```bash
-uv add huggingface_hub
-```
-
-### 2. Basic Setup with CommitScheduler (Recommended)
-
-For append-only data that should be uploaded periodically (e.g., logs, user feedback):
-
-```python
-import json
-import uuid
-from pathlib import Path
-from huggingface_hub import CommitScheduler
-
-# Create a unique file to avoid conflicts across restarts
-feedback_file = Path("user_feedback/") / f"data_{uuid.uuid4()}.json"
-feedback_folder = feedback_file.parent
-
-# Schedule uploads every 10 minutes (minimum recommended: 5 minutes)
-scheduler = CommitScheduler(
-    repo_id="username/my-dataset",  # Will be created if doesn't exist
-    repo_type="dataset",
-    folder_path=feedback_folder,
-    path_in_repo="data",  # Upload to /data folder in the dataset
-    every=10,  # Upload every 10 minutes
-)
-
-# Append data with thread safety
-def save_data(data_dict):
-    """Save data to file with thread lock for concurrent writes."""
-    with scheduler.lock:
-        with feedback_file.open("a") as f:
-            f.write(json.dumps(data_dict))
-            f.write("\n")
-```
-
-### 3. Manual Upload Methods
-
-For one-time or controlled uploads:
-
-```python
-from huggingface_hub import HfApi
-
-api = HfApi()
-
-# Upload a single file
-api.upload_file(
-    path_or_fileobj="/path/to/local/file.json",
-    path_in_repo="data/file.json",
-    repo_id="username/my-dataset",
-    repo_type="dataset",
-)
-
-# Upload an entire folder
-api.upload_folder(
-    folder_path="/path/to/local/folder",
-    path_in_repo="data",
-    repo_id="username/my-dataset",
-    repo_type="dataset",
-)
-```
-
-## Authentication
-
-Before uploading, you need to authenticate with Hugging Face:
-
-### Option 1: Login via CLI
-```bash
-huggingface-cli login
-```
-
-### Option 2: Use Token Programmatically
-```python
-from huggingface_hub import HfApi
-
-api = HfApi(token="hf_...")
-```
-
-### Option 3: Set Environment Variable
-```bash
-export HF_TOKEN="hf_..."
-```
-
-For Spaces, add `HF_TOKEN` as a secret in Space settings.
-
-## Advanced Patterns
-
-### Pattern 1: Gradio Space with User Feedback
-
-```python
-import json
-import uuid
-from pathlib import Path
-import gradio as gr
-from huggingface_hub import CommitScheduler
-
-# Setup
-feedback_file = Path("user_feedback/") / f"data_{uuid.uuid4()}.json"
-feedback_folder = feedback_file.parent
-
-scheduler = CommitScheduler(
-    repo_id="username/user-feedback-dataset",
-    repo_type="dataset",
-    folder_path=feedback_folder,
-    path_in_repo="feedback",
-    every=10,
-)
-
-def save_feedback(input_text, output_text, rating):
-    """Save user feedback with thread safety."""
-    with scheduler.lock:
-        with feedback_file.open("a") as f:
-            f.write(json.dumps({
-                "input": input_text,
-                "output": output_text,
-                "rating": rating,
-                "timestamp": str(uuid.uuid4())
-            }))
-            f.write("\n")
-
-# Use in Gradio interface
-with gr.Blocks() as demo:
-    # ... define your Gradio UI
-    submit_btn.click(save_feedback, inputs=[input_box, output_box, rating])
-
-demo.launch()
-```
-
-### Pattern 2: Training Logs with Progress Tracking
-
-```python
-import json
-from pathlib import Path
-from huggingface_hub import CommitScheduler
-from tqdm import tqdm
-
-# Setup
-log_file = Path("training_logs/") / "metrics.jsonl"
-log_folder = log_file.parent
-log_folder.mkdir(exist_ok=True)
-
-scheduler = CommitScheduler(
-    repo_id="username/training-logs",
-    repo_type="dataset",
-    folder_path=log_folder,
-    path_in_repo="logs",
-    every=5,  # Upload every 5 minutes
-)
-
-# Training loop
-for epoch in tqdm(range(num_epochs), desc="Training"):
-    # ... training code ...
-
-    # Log metrics
-    with scheduler.lock:
-        with log_file.open("a") as f:
-            f.write(json.dumps({
-                "epoch": epoch,
-                "loss": loss,
-                "accuracy": accuracy
-            }))
-            f.write("\n")
-```
-
-### Pattern 3: Large File Upload with Background Processing
-
-```python
-from huggingface_hub import HfApi
-
-api = HfApi()
-
-# Upload large files in the background (non-blocking)
-future = api.upload_folder(
-    repo_id="username/large-dataset",
-    folder_path="./data",
-    repo_type="dataset",
-    run_as_future=True,  # Non-blocking upload
-)
-
-# Continue working while upload happens
-# ... do other work ...
-
-# Wait for upload to complete when needed
-future.result()  # This blocks until upload finishes
-```
-
-### Pattern 4: Scheduled Uploads with Multiple File Types
-
-```python
-import zipfile
-import tempfile
-from pathlib import Path
-from huggingface_hub import CommitScheduler
-
-class ImageArchiveScheduler(CommitScheduler):
-    """Custom scheduler that zips images before uploading."""
-
-    def push_to_hub(self):
-        # Find all PNG files
-        png_files = list(self.folder_path.glob("*.png"))
-        if len(png_files) == 0:
-            return None  # Skip if nothing to commit
-
-        # Zip files
-        with tempfile.TemporaryDirectory() as tmpdir:
-            archive_path = Path(tmpdir) / "images.zip"
-            with zipfile.ZipFile(archive_path, "w", zipfile.ZIP_DEFLATED) as zip_file:
-                for png_file in png_files:
-                    zip_file.write(filename=png_file, arcname=png_file.name)
-
-            # Upload archive
-            self.api.upload_file(
-                path_or_fileobj=archive_path,
-                path_in_repo=f"{self.path_in_repo}/images.zip",
-                repo_id=self.repo_id,
-                repo_type=self.repo_type,
-            )
-
-        # Clean up local files
-        for png_file in png_files:
-            png_file.unlink()
-
-# Usage
-scheduler = ImageArchiveScheduler(
-    repo_id="username/image-dataset",
-    repo_type="dataset",
-    folder_path=Path("./images"),
-    path_in_repo="archives",
-    every=15,
-)
-```
-
-## Best Practices
-
-### 1. File Naming for Concurrent Access
-Always use UUIDs or timestamps to avoid filename conflicts:
-```python
-import uuid
-filename = f"data_{uuid.uuid4()}.json"
-```
-
-### 2. Thread Safety
-Always use the scheduler lock when writing:
-```python
-with scheduler.lock:
-    with file.open("a") as f:
-        f.write(data)
-```
-
-### 3. Append-Only Data
-CommitScheduler assumes append-only operations. Only:
-- Create new files
-- Append to existing files
-- Never delete or overwrite files (this can corrupt the repo)
-
-### 4. Upload Frequency
-- Minimum recommended: 5 minutes
-- For user-facing apps: 10-15 minutes
-- For training logs: 5-10 minutes
-
-### 5. Data Format
-Use formats readable by the Datasets library:
-- JSON Lines (`.jsonl`) for structured data
-- CSV for tabular data
-- Parquet for large datasets
-- ZIP for grouped files
-
-### 6. Error Handling
-The scheduler silently handles errors and retries. For critical data:
-```python
-import logging
-
-logging.basicConfig(level=logging.INFO)
-# Scheduler will log errors automatically
-```
-
-### 7. Large Files
-For very large datasets (>1GB), consider:
-```python
-from huggingface_hub import HfApi
-
-api = HfApi()
-
-# Upload large folders with automatic chunking
-api.upload_large_folder(
-    repo_id="username/huge-dataset",
-    folder_path="./data",
-    repo_type="dataset",
-)
-```
-
-## Common Use Cases
-
-### Use Case 1: A/B Testing Results
-```python
-# Save A/B test results from a Gradio Space
-def log_ab_test(user_id, variant, conversion):
-    with scheduler.lock:
-        with ab_test_file.open("a") as f:
-            f.write(json.dumps({
-                "user_id": user_id,
-                "variant": variant,
-                "conversion": conversion,
-                "timestamp": datetime.now().isoformat()
-            }))
-            f.write("\n")
-```
-
-### Use Case 2: Model Predictions Storage
-```python
-# Store model predictions for analysis
-def save_prediction(input_data, prediction, confidence):
-    with scheduler.lock:
-        with predictions_file.open("a") as f:
-            f.write(json.dumps({
-                "input": input_data,
-                "prediction": prediction,
-                "confidence": confidence,
-                "model_version": "v1.0"
-            }))
-            f.write("\n")
-```
-
-### Use Case 3: Dataset Versioning
-```python
-# Create versioned snapshots of data
-api = HfApi()
-
-api.upload_folder(
-    folder_path="./current_data",
-    path_in_repo=f"snapshots/{datetime.now().strftime('%Y%m%d')}",
-    repo_id="username/versioned-dataset",
-    repo_type="dataset",
-    commit_message=f"Snapshot for {datetime.now().date()}"
-)
-```
-
-## Troubleshooting
-
-### Issue: Upload fails with authentication error
-**Solution:** Ensure you're logged in or have set the `HF_TOKEN` environment variable.
-
-### Issue: Empty commits being created
-**Solution:** The scheduler automatically skips empty commits. If you see them, check if files are being created correctly.
-
-### Issue: Files not appearing in dataset
-**Solution:** Wait for the next scheduled upload (check the `every` parameter) or the scheduler may be encountering errors.
-
-### Issue: Out of memory errors
-**Solution:** Use `upload_large_folder()` for very large datasets or upload files one at a time.
-
-### Issue: Concurrent write conflicts
-**Solution:** Always use `scheduler.lock` when writing to files that the scheduler is monitoring.
-
-## References
-
-- [HF Hub Dataset Storage Documentation](https://huggingface.co/docs/hub/spaces-storage#dataset-storage)
-- [CommitScheduler API Reference](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/hf_api#huggingface_hub.CommitScheduler)
-- [Upload Guide](https://huggingface.co/docs/huggingface_hub/main/en/guides/upload)
-- [Space to Dataset Saver Example](https://huggingface.co/spaces/Wauplin/space_to_dataset_saver)
-
-## Example: Complete Gradio App with Dataset Storage
-
-See [examples.md](examples.md) for a complete working example of a Gradio Space with dataset storage.

.claude/skills/hf-dataset-storage/demo.py

@@ -1,217 +0,0 @@
-#!/usr/bin/env python3
-"""
-Demo script showing HuggingFace Dataset Storage patterns.
-This demonstrates the skill's capabilities without requiring actual HF authentication.
-"""
-
-import json
-from pathlib import Path
-from datetime import datetime
-
-
-def demo_file_structure():
-    """Show how to structure files for dataset storage."""
-    print("=" * 60)
-    print("📁 File Structure Demo")
-    print("=" * 60)
-
-    # Example 1: JSON Lines format (recommended for append-only data)
-    demo_folder = Path("demo_data")
-    demo_folder.mkdir(exist_ok=True)
-
-    # Create sample JSONL file
-    sample_file = demo_folder / "sample_data.jsonl"
-    sample_data = [
-        {"id": 1, "timestamp": datetime.now().isoformat(), "value": "first entry"},
-        {"id": 2, "timestamp": datetime.now().isoformat(), "value": "second entry"},
-        {"id": 3, "timestamp": datetime.now().isoformat(), "value": "third entry"},
-    ]
-
-    with sample_file.open("w") as f:
-        for entry in sample_data:
-            f.write(json.dumps(entry))
-            f.write("\n")
-
-    print(f"✅ Created sample JSONL file: {sample_file}")
-    print(f"   Contains {len(sample_data)} entries\n")
-
-    # Show the content
-    print("📄 File contents:")
-    print(sample_file.read_text())
-    print()
-
-
-def demo_scheduler_pattern():
-    """Show the CommitScheduler pattern (without actual upload)."""
-    print("=" * 60)
-    print("🔄 CommitScheduler Pattern")
-    print("=" * 60)
-
-    code_example = '''
-from pathlib import Path
-from huggingface_hub import CommitScheduler
-
-# Setup
-feedback_folder = Path("user_feedback")
-feedback_file = feedback_folder / "data.jsonl"
-
-# Create scheduler (uploads every 10 minutes)
-scheduler = CommitScheduler(
-    repo_id="username/my-dataset",
-    repo_type="dataset",
-    folder_path=feedback_folder,
-    path_in_repo="feedback",
-    every=10,
-)
-
-# Save data with thread safety
-def save_feedback(data):
-    with scheduler.lock:
-        with feedback_file.open("a") as f:
-            f.write(json.dumps(data))
-            f.write("\\n")
-'''
-
-    print("💡 Recommended Pattern for Continuous Data Collection:")
-    print(code_example)
-    print()
-
-
-def demo_manual_upload_pattern():
-    """Show manual upload patterns."""
-    print("=" * 60)
-    print("📤 Manual Upload Pattern")
-    print("=" * 60)
-
-    code_example = '''
-from huggingface_hub import HfApi
-
-api = HfApi()
-
-# Method 1: Upload single file
-api.upload_file(
-    path_or_fileobj="data.json",
-    path_in_repo="data/data.json",
-    repo_id="username/my-dataset",
-    repo_type="dataset",
-)
-
-# Method 2: Upload entire folder
-api.upload_folder(
-    folder_path="./my_data",
-    repo_id="username/my-dataset",
-    repo_type="dataset",
-)
-
-# Method 3: Large folder (resumable)
-api.upload_large_folder(
-    repo_id="username/huge-dataset",
-    folder_path="/path/to/huge/folder",
-    repo_type="dataset",
-    num_workers=4,
-)
-'''
-
-    print("💡 Manual Upload Options:")
-    print(code_example)
-    print()
-
-
-def demo_use_cases():
-    """Show common use cases."""
-    print("=" * 60)
-    print("🎯 Common Use Cases")
-    print("=" * 60)
-
-    use_cases = {
-        "1. Gradio Space User Feedback": {
-            "description": "Collect and store user interactions",
-            "pattern": "CommitScheduler",
-            "frequency": "Every 10-15 minutes",
-            "format": "JSON Lines (.jsonl)",
-        },
-        "2. Training Logs": {
-            "description": "Store model training metrics over time",
-            "pattern": "CommitScheduler",
-            "frequency": "Every 5 minutes",
-            "format": "JSON Lines (.jsonl) or CSV",
-        },
-        "3. A/B Testing Results": {
-            "description": "Track experiment variants and conversions",
-            "pattern": "CommitScheduler",
-            "frequency": "Every 10 minutes",
-            "format": "JSON Lines (.jsonl)",
-        },
-        "4. Dataset Versioning": {
-            "description": "Create snapshots of evolving datasets",
-            "pattern": "Manual upload_folder()",
-            "frequency": "On-demand",
-            "format": "Any format (Parquet recommended)",
-        },
-        "5. Image Collection": {
-            "description": "Archive images periodically",
-            "pattern": "Custom Scheduler (zip files)",
-            "frequency": "Every 15 minutes",
-            "format": "ZIP archives",
-        },
-    }
-
-    for use_case, details in use_cases.items():
-        print(f"\n{use_case}")
-        print(f"  📝 {details['description']}")
-        print(f"  🔧 Pattern: {details['pattern']}")
-        print(f"  ⏱️  Frequency: {details['frequency']}")
-        print(f"  📄 Format: {details['format']}")
-
-    print()
-
-
-def demo_best_practices():
-    """Show best practices."""
-    print("=" * 60)
-    print("⭐ Best Practices")
-    print("=" * 60)
-
-    practices = [
-        "✅ Use UUID filenames to avoid conflicts across restarts",
-        "✅ Always use scheduler.lock for thread-safe writes",
-        "✅ Use JSON Lines (.jsonl) for structured append-only data",
-        "✅ Set minimum upload frequency to 5 minutes",
-        "✅ Never delete or overwrite files with CommitScheduler",
-        "✅ Use upload_large_folder() for datasets > 1GB",
-        "✅ Store HF_TOKEN as environment variable or Space secret",
-        "✅ Use Parquet format for very large tabular datasets",
-    ]
-
-    for practice in practices:
-        print(f"  {practice}")
-
-    print()
-
-
-def main():
-    """Run all demonstrations."""
-    print("\n" + "=" * 60)
-    print("🚀 HuggingFace Dataset Storage Skill Demo")
-    print("=" * 60)
-    print()
-
-    demo_file_structure()
-    demo_scheduler_pattern()
-    demo_manual_upload_pattern()
-    demo_use_cases()
-    demo_best_practices()
-
-    print("=" * 60)
-    print("✅ Demo Complete!")
-    print("=" * 60)
-    print()
-    print("📚 For more information, see:")
-    print("   - examples.md: Complete working examples")
-    print("   - reference.md: Detailed API documentation")
-    print("   - SKILL.md: Quick start guide")
-    print()
-
-
-if __name__ == "__main__":
-    main()

.claude/skills/hf-dataset-storage/demo_data/sample_data.jsonl

@@ -1,3 +0,0 @@
-{"id": 1, "timestamp": "2025-12-31T12:54:45.073335", "value": "first entry"}
-{"id": 2, "timestamp": "2025-12-31T12:54:45.073347", "value": "second entry"}
-{"id": 3, "timestamp": "2025-12-31T12:54:45.073348", "value": "third entry"}

.claude/skills/hf-dataset-storage/examples.md

@@ -1,728 +0,0 @@
-# Complete Examples for HF Dataset Storage
-
-This file contains complete, working examples for implementing dataset storage in Hugging Face Spaces.
-
-## Example 1: Complete Gradio App with User Feedback Storage
-
-This example shows a complete Gradio application that collects user feedback and saves it to a dataset.
-
-```python
-# app.py
-import json
-import uuid
-from pathlib import Path
-from datetime import datetime
-import gradio as gr
-from huggingface_hub import CommitScheduler
-
-# ============================================================================
-# Setup Dataset Storage
-# ============================================================================
-
-# Create unique feedback file using UUID to avoid conflicts
-feedback_file = Path("user_feedback") / f"feedback_{uuid.uuid4()}.jsonl"
-feedback_folder = feedback_file.parent
-
-# Create folder if it doesn't exist
-feedback_folder.mkdir(parents=True, exist_ok=True)
-
-# Initialize CommitScheduler
-# This will automatically upload data every 10 minutes
-scheduler = CommitScheduler(
-    repo_id="your-username/app-feedback-dataset",  # Replace with your repo
-    repo_type="dataset",
-    folder_path=feedback_folder,
-    path_in_repo="feedback",
-    every=10,  # Upload every 10 minutes
-)
-
-print(f"✅ Dataset storage initialized. Data will be saved to: {scheduler.repo_id}")
-
-# ============================================================================
-# Application Logic
-# ============================================================================
-
-def translate_text(text, target_language):
-    """
-    Mock translation function. Replace with your actual model/API.
-    """
-    # Simulated translations
-    translations = {
-        "French": f"[FR] {text}",
-        "Spanish": f"[ES] {text}",
-        "German": f"[DE] {text}",
-    }
-    return translations.get(target_language, text)
-
-def save_feedback(input_text, translation, language, rating, comments):
-    """
-    Save user feedback to the dataset with thread safety.
-    """
-    if not input_text or not translation:
-        return "⚠️ No data to save"
-
-    feedback_data = {
-        "timestamp": datetime.now().isoformat(),
-        "input_text": input_text,
-        "translation": translation,
-        "target_language": language,
-        "rating": rating,
-        "comments": comments,
-        "session_id": str(uuid.uuid4())
-    }
-
-    # Use scheduler lock for thread-safe writes
-    with scheduler.lock:
-        with feedback_file.open("a") as f:
-            f.write(json.dumps(feedback_data))
-            f.write("\n")
-
-    return "✅ Feedback saved! Thank you!"
-
-# ============================================================================
-# Gradio Interface
-# ============================================================================
-
-with gr.Blocks(title="Translation App with Feedback") as demo:
-    gr.Markdown("# Translation App")
-    gr.Markdown("Translate text and provide feedback to help us improve!")
-
-    with gr.Row():
-        with gr.Column():
-            input_text = gr.Textbox(
-                label="Enter text to translate",
-                placeholder="Type something...",
-                lines=3
-            )
-            language = gr.Dropdown(
-                choices=["French", "Spanish", "German"],
-                label="Target Language",
-                value="French"
-            )
-            translate_btn = gr.Button("Translate", variant="primary")
-
-        with gr.Column():
-            output_text = gr.Textbox(
-                label="Translation",
-                lines=3,
-                interactive=False
-            )
-
-    gr.Markdown("### How was the translation?")
-
-    with gr.Row():
-        rating = gr.Slider(
-            minimum=1,
-            maximum=5,
-            step=1,
-            label="Rating (1-5 stars)",
-            value=3
-        )
-        comments = gr.Textbox(
-            label="Additional comments (optional)",
-            placeholder="Any suggestions?",
-            lines=2
-        )
-
-    feedback_status = gr.Textbox(label="Status", interactive=False)
-    submit_feedback_btn = gr.Button("Submit Feedback", variant="secondary")
-
-    # Connect the functions
-    translate_btn.click(
-        fn=translate_text,
-        inputs=[input_text, language],
-        outputs=output_text
-    )
-
-    submit_feedback_btn.click(
-        fn=save_feedback,
-        inputs=[input_text, output_text, language, rating, comments],
-        outputs=feedback_status
-    )
-
-    gr.Markdown("---")
-    gr.Markdown(
-        f"💾 Feedback is automatically saved to the dataset: "
-        f"[{scheduler.repo_id}](https://huggingface.co/datasets/{scheduler.repo_id})"
-    )
-
-if __name__ == "__main__":
-    demo.launch()
-```
-
-### Requirements for Example 1
-
-```toml
-# pyproject.toml or requirements.txt
-[project]
-dependencies = [
-    "gradio>=4.0.0",
-    "huggingface_hub>=0.20.0",
-]
-```
-
----
-
-## Example 2: Training Logger with Dataset Storage
-
-This example shows how to log training metrics to a dataset during model training.
-
-```python
-# train.py
-import json
-import time
-from pathlib import Path
-from datetime import datetime
-from tqdm import tqdm
-from huggingface_hub import CommitScheduler
-
-# ============================================================================
-# Setup Dataset Storage for Training Logs
-# ============================================================================
-
-log_folder = Path("training_logs")
-log_folder.mkdir(exist_ok=True)
-
-# Create separate files for different log types
-metrics_file = log_folder / "metrics.jsonl"
-checkpoints_file = log_folder / "checkpoints.jsonl"
-
-# Initialize scheduler - uploads every 5 minutes during training
-scheduler = CommitScheduler(
-    repo_id="your-username/training-logs",
-    repo_type="dataset",
-    folder_path=log_folder,
-    path_in_repo="runs",
-    every=5,
-)
-
-print(f"📊 Training logs will be saved to: {scheduler.repo_id}")
-
-# ============================================================================
-# Training Configuration
-# ============================================================================
-
-config = {
-    "model": "my-model-v1",
-    "learning_rate": 0.001,
-    "batch_size": 32,
-    "num_epochs": 10,
-    "dataset": "training-data-v1"
-}
-
-# Save configuration
-with scheduler.lock:
-    config_file = log_folder / "config.json"
-    with config_file.open("w") as f:
-        json.dump(config, f, indent=2)
-
-# ============================================================================
-# Training Functions
-# ============================================================================
-
-def log_metrics(epoch, step, loss, accuracy, learning_rate):
-    """Log training metrics."""
-    metrics = {
-        "timestamp": datetime.now().isoformat(),
-        "epoch": epoch,
-        "step": step,
-        "loss": float(loss),
-        "accuracy": float(accuracy),
-        "learning_rate": learning_rate
-    }
-
-    with scheduler.lock:
-        with metrics_file.open("a") as f:
-            f.write(json.dumps(metrics))
-            f.write("\n")
-
-def log_checkpoint(epoch, model_path, metrics):
-    """Log checkpoint information."""
-    checkpoint_info = {
-        "timestamp": datetime.now().isoformat(),
-        "epoch": epoch,
-        "model_path": model_path,
-        "metrics": metrics
-    }
-
-    with scheduler.lock:
-        with checkpoints_file.open("a") as f:
-            f.write(json.dumps(checkpoint_info))
-            f.write("\n")
-
-def train_epoch(epoch, num_steps=100):
-    """Mock training epoch."""
-    epoch_loss = 0
-    pbar = tqdm(range(num_steps), desc=f"Epoch {epoch}")
-
-    for step in pbar:
-        # Simulate training
-        time.sleep(0.1)
-
-        # Mock metrics
-        loss = 1.0 / (step + 1 + epoch * 10)
-        accuracy = min(0.95, 0.5 + step * 0.005 + epoch * 0.05)
-
-        epoch_loss += loss
-
-        # Log every 10 steps
-        if step % 10 == 0:
-            log_metrics(
-                epoch=epoch,
-                step=step,
-                loss=loss,
-                accuracy=accuracy,
-                learning_rate=config["learning_rate"]
-            )
-
-        pbar.set_postfix({"loss": f"{loss:.4f}", "acc": f"{accuracy:.4f}"})
-
-    return epoch_loss / num_steps, accuracy
-
-# ============================================================================
-# Main Training Loop
-# ============================================================================
-
-def main():
-    print("🚀 Starting training...")
-
-    for epoch in range(config["num_epochs"]):
-        print(f"\n📍 Epoch {epoch + 1}/{config['num_epochs']}")
-
-        # Train for one epoch
-        avg_loss, final_accuracy = train_epoch(epoch)
-
-        # Log checkpoint
-        checkpoint_path = f"checkpoints/model_epoch_{epoch}.pt"
-        log_checkpoint(
-            epoch=epoch,
-            model_path=checkpoint_path,
-            metrics={"loss": avg_loss, "accuracy": final_accuracy}
-        )
-
-        print(f"✅ Epoch {epoch + 1} complete - Loss: {avg_loss:.4f}, Acc: {final_accuracy:.4f}")
-
-    print(f"\n🎉 Training complete! Logs saved to: {scheduler.repo_id}")
-
-    # Force final upload
-    # Note: scheduler will upload automatically, but we can trigger it manually if needed
-    print("📤 Uploading final logs...")
-    time.sleep(2)  # Give scheduler time to complete
-
-if __name__ == "__main__":
-    main()
-```
-
----
-
-## Example 3: Dataset Snapshot Saver
-
-This example shows how to create versioned snapshots of data.
-
-```python
-# snapshot_saver.py
-import json
-from pathlib import Path
-from datetime import datetime
-from huggingface_hub import HfApi
-from tqdm import tqdm
-
-class DatasetSnapshotSaver:
-    """Save versioned snapshots of data to HuggingFace datasets."""
-
-    def __init__(self, repo_id, repo_type="dataset"):
-        self.api = HfApi()
-        self.repo_id = repo_id
-        self.repo_type = repo_type
-
-        # Create repo if it doesn't exist
-        try:
-            self.api.create_repo(
-                repo_id=repo_id,
-                repo_type=repo_type,
-                exist_ok=True
-            )
-            print(f"✅ Repository ready: {repo_id}")
-        except Exception as e:
-            print(f"❌ Error creating repo: {e}")
-
-    def save_snapshot(self, data_folder, snapshot_name=None):
-        """
-        Save a snapshot of the data folder to the dataset.
-
-        Args:
-            data_folder: Path to local folder containing data
-            snapshot_name: Optional custom name, defaults to timestamp
-        """
-        if snapshot_name is None:
-            snapshot_name = datetime.now().strftime("%Y%m%d_%H%M%S")
-
-        data_path = Path(data_folder)
-        if not data_path.exists():
-            raise ValueError(f"Data folder not found: {data_folder}")
-
-        print(f"📸 Creating snapshot: {snapshot_name}")
-
-        # Upload folder
-        self.api.upload_folder(
-            folder_path=str(data_path),
-            path_in_repo=f"snapshots/{snapshot_name}",
-            repo_id=self.repo_id,
-            repo_type=self.repo_type,
-            commit_message=f"Snapshot: {snapshot_name}"
-        )
-
-        print(f"✅ Snapshot saved: snapshots/{snapshot_name}")
-        return snapshot_name
-
-    def save_metadata(self, snapshot_name, metadata):
-        """Save metadata for a snapshot."""
-        metadata_content = json.dumps(metadata, indent=2)
-
-        self.api.upload_file(
-            path_or_fileobj=metadata_content.encode(),
-            path_in_repo=f"snapshots/{snapshot_name}/metadata.json",
-            repo_id=self.repo_id,
-            repo_type=self.repo_type,
-            commit_message=f"Add metadata for {snapshot_name}"
-        )
-
-        print(f"✅ Metadata saved for snapshot: {snapshot_name}")
-
-# ============================================================================
-# Usage Example
-# ============================================================================
-
-if __name__ == "__main__":
-    # Initialize saver
-    saver = DatasetSnapshotSaver(
-        repo_id="your-username/data-snapshots"
-    )
-
-    # Create sample data
-    data_folder = Path("./sample_data")
-    data_folder.mkdir(exist_ok=True)
-
-    # Generate some sample files
-    print("📝 Generating sample data...")
-    for i in tqdm(range(10)):
-        sample_file = data_folder / f"data_{i}.json"
-        with sample_file.open("w") as f:
-            json.dump({"id": i, "value": i * 10}, f)
-
-    # Save snapshot
-    snapshot_name = saver.save_snapshot(
-        data_folder=data_folder,
-        snapshot_name="initial_snapshot"
-    )
-
-    # Save metadata
-    saver.save_metadata(
-        snapshot_name=snapshot_name,
-        metadata={
-            "created_at": datetime.now().isoformat(),
-            "num_files": 10,
-            "description": "Initial data snapshot",
-            "version": "1.0"
-        }
-    )
-
-    print(f"\n🎉 Complete! View at: https://huggingface.co/datasets/{saver.repo_id}")
-```
-
----
-
-## Example 4: Image Collection Archiver
-
-This example shows how to collect images and periodically archive them to a dataset.
-
-```python
-# image_archiver.py
-import zipfile
-import tempfile
-from pathlib import Path
-from datetime import datetime
-from huggingface_hub import CommitScheduler
-
-class ImageArchiveScheduler(CommitScheduler):
-    """
-    Custom scheduler that collects images and uploads them as ZIP archives.
-    """
-
-    def push_to_hub(self):
-        """Override to zip images before uploading."""
-
-        # Find all image files
-        image_extensions = ["*.png", "*.jpg", "*.jpeg", "*.gif"]
-        image_files = []
-        for ext in image_extensions:
-            image_files.extend(list(self.folder_path.glob(ext)))
-
-        if len(image_files) == 0:
-            print("No images to archive")
-            return None
-
-        print(f"📦 Archiving {len(image_files)} images...")
-
-        # Create ZIP archive
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        archive_name = f"images_{timestamp}.zip"
-
-        with tempfile.TemporaryDirectory() as tmpdir:
-            archive_path = Path(tmpdir) / archive_name
-
-            with zipfile.ZipFile(archive_path, "w", zipfile.ZIP_DEFLATED) as zip_file:
-                for img_file in image_files:
-                    zip_file.write(
-                        filename=img_file,
-                        arcname=f"{timestamp}/{img_file.name}"
-                    )
-
-            # Upload archive
-            self.api.upload_file(
-                path_or_fileobj=str(archive_path),
-                path_in_repo=f"{self.path_in_repo}/{archive_name}",
-                repo_id=self.repo_id,
-                repo_type=self.repo_type,
-                commit_message=f"Archive {len(image_files)} images from {timestamp}"
-            )
-
-        # Delete local images after successful upload
-        for img_file in image_files:
-            img_file.unlink()
-
-        print(f"✅ Archived and uploaded {len(image_files)} images")
-
-# ============================================================================
-# Usage Example
-# ============================================================================
-
-if __name__ == "__main__":
-    import time
-    from PIL import Image
-    import numpy as np
-
-    # Setup image folder
-    image_folder = Path("./collected_images")
-    image_folder.mkdir(exist_ok=True)
-
-    # Initialize custom scheduler
-    scheduler = ImageArchiveScheduler(
-        repo_id="your-username/image-archives",
-        repo_type="dataset",
-        folder_path=image_folder,
-        path_in_repo="archives",
-        every=5,  # Archive every 5 minutes
-    )
-
-    print(f"📸 Image archiver started. Saving to: {scheduler.repo_id}")
-
-    # Simulate image collection
-    print("Generating sample images...")
-    for i in range(5):
-        # Create a random image
-        img_array = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8)
-        img = Image.fromarray(img_array)
-
-        # Save image
-        img_path = image_folder / f"image_{i}_{datetime.now().strftime('%H%M%S')}.png"
-        img.save(img_path)
-        print(f"  Generated: {img_path.name}")
-
-        time.sleep(2)
-
-    print("\n⏳ Waiting for scheduler to archive images...")
-    print("   (In production, your app would continue running)")
-
-    # In a real application, the scheduler runs in the background
-    # and you can continue processing
-```
-
----
-
-## Example 5: A/B Testing Results Collector
-
-This example shows how to collect A/B testing results from a Gradio Space.
-
-```python
-# ab_testing_app.py
-import json
-import uuid
-import random
-from pathlib import Path
-from datetime import datetime
-import gradio as gr
-from huggingface_hub import CommitScheduler
-
-# ============================================================================
-# Setup Dataset Storage for A/B Testing
-# ============================================================================
-
-results_folder = Path("ab_test_results")
-results_folder.mkdir(exist_ok=True)
-
-results_file = results_folder / f"results_{uuid.uuid4()}.jsonl"
-
-scheduler = CommitScheduler(
-    repo_id="your-username/ab-test-results",
-    repo_type="dataset",
-    folder_path=results_folder,
-    path_in_repo="experiments",
-    every=10,
-)
-
-print(f"📊 A/B test results will be saved to: {scheduler.repo_id}")
-
-# ============================================================================
-# A/B Testing Logic
-# ============================================================================
-
-def assign_variant():
-    """Randomly assign user to variant A or B."""
-    return random.choice(["A", "B"])
-
-def get_recommendation(user_input, variant):
-    """
-    Generate recommendation based on variant.
-    Variant A: Conservative recommendations
-    Variant B: Aggressive recommendations
-    """
-    if variant == "A":
-        return f"Conservative recommendation for: {user_input}"
-    else:
-        return f"Aggressive recommendation for: {user_input}"
-
-def log_interaction(session_id, variant, user_input, recommendation, user_clicked):
-    """Log A/B test interaction."""
-    result = {
-        "timestamp": datetime.now().isoformat(),
-        "session_id": session_id,
-        "variant": variant,
-        "user_input": user_input,
-        "recommendation": recommendation,
-        "user_clicked": user_clicked,
-        "conversion": user_clicked
-    }
-
-    with scheduler.lock:
-        with results_file.open("a") as f:
-            f.write(json.dumps(result))
-            f.write("\n")
-
-# ============================================================================
-# Gradio Interface
-# ============================================================================
-
-def process_request(user_input, session_state):
-    """Process user request and assign variant."""
-    if session_state is None:
-        session_state = {
-            "session_id": str(uuid.uuid4()),
-            "variant": assign_variant()
-        }
-
-    recommendation = get_recommendation(user_input, session_state["variant"])
-
-    return (
-        recommendation,
-        f"You are in variant: {session_state['variant']}",
-        session_state,
-        session_state["session_id"],
-        session_state["variant"],
-        user_input,
-        recommendation
-    )
-
-def log_click(session_id, variant, user_input, recommendation):
-    """Log when user clicks the recommendation."""
-    if session_id:
-        log_interaction(session_id, variant, user_input, recommendation, True)
-        return "✅ Click logged!"
-    return "⚠️ No session data"
-
-with gr.Blocks(title="A/B Testing Demo") as demo:
-    gr.Markdown("# A/B Testing Demo")
-    gr.Markdown("Test two different recommendation strategies")
-
-    # Session state
-    session_state = gr.State(None)
-    session_id_state = gr.State(None)
-    variant_state = gr.State(None)
-    input_state = gr.State(None)
-    recommendation_state = gr.State(None)
-
-    with gr.Row():
-        user_input = gr.Textbox(
-            label="What are you looking for?",
-            placeholder="Enter your query..."
-        )
-        submit_btn = gr.Button("Get Recommendation", variant="primary")
-
-    recommendation_output = gr.Textbox(
-        label="Recommendation",
-        interactive=False
-    )
-
-    variant_display = gr.Textbox(
-        label="Your Test Variant",
-        interactive=False
-    )
-
-    click_btn = gr.Button("I like this recommendation!", variant="secondary")
-    click_status = gr.Textbox(label="Status", interactive=False)
-
-    # Connect functions
-    submit_btn.click(
-        fn=process_request,
-        inputs=[user_input, session_state],
-        outputs=[
-            recommendation_output,
-            variant_display,
-            session_state,
-            session_id_state,
-            variant_state,
-            input_state,
-            recommendation_state
-        ]
-    )
-
-    click_btn.click(
-        fn=log_click,
-        inputs=[session_id_state, variant_state, input_state, recommendation_state],
-        outputs=click_status
-    )
-
-    gr.Markdown("---")
-    gr.Markdown(f"📊 Results are saved to: [{scheduler.repo_id}](https://huggingface.co/datasets/{scheduler.repo_id})")
-
-if __name__ == "__main__":
-    demo.launch()
-```
-
----
-
-## Running the Examples
-
-For any of these examples:
-
-1. **Install dependencies:**
-   ```bash
-   uv add gradio huggingface_hub
-   # For image example: uv add pillow numpy
-   ```
-
-2. **Login to Hugging Face:**
-   ```bash
-   huggingface-cli login
-   ```
-
-3. **Update repo_id:**
-   Replace `"your-username/repo-name"` with your actual HuggingFace username and desired dataset name.
-
-4. **Run the script:**
-   ```bash
-   uv run app.py
-   ```
-
-5. **View results:**
-   Visit `https://huggingface.co/datasets/your-username/repo-name` to see your data!

.claude/skills/hf-dataset-storage/reference.md

@@ -1,767 +0,0 @@
-# API Reference for HF Dataset Storage
-
-This reference provides detailed documentation for all the APIs and configuration options related to Hugging Face dataset storage.
-
-## Table of Contents
-
-1. [CommitScheduler](#commitscheduler)
-2. [HfApi Upload Methods](#hfapi-upload-methods)
-3. [Commit Operations](#commit-operations)
-4. [Authentication](#authentication)
-5. [Configuration](#configuration)
-6. [Error Handling](#error-handling)
-
----
-
-## CommitScheduler
-
-The `CommitScheduler` class automatically uploads files to a dataset repository at regular intervals.
-
-### Constructor
-
-```python
-from huggingface_hub import CommitScheduler
-
-scheduler = CommitScheduler(
-    repo_id: str,
-    folder_path: str | Path,
-    *,
-    repo_type: str = "dataset",
-    revision: str = "main",
-    path_in_repo: str = ".",
-    every: int | float = 5,
-    token: str | None = None,
-    allow_patterns: str | List[str] | None = None,
-    ignore_patterns: str | List[str] | None = None,
-)
-```
-
-### Parameters
-
-| Parameter | Type | Default | Description |
-|-----------|------|---------|-------------|
-| `repo_id` | `str` | Required | Repository ID (e.g., "username/dataset-name") |
-| `folder_path` | `str | Path` | Required | Local folder to monitor and upload |
-| `repo_type` | `str` | `"dataset"` | Type of repo: "dataset", "model", or "space" |
-| `revision` | `str` | `"main"` | Git revision/branch to commit to |
-| `path_in_repo` | `str` | `"."` | Path in the repo where files will be uploaded |
-| `every` | `int | float` | `5` | Minutes between uploads (minimum 5 recommended) |
-| `token` | `str | None` | `None` | HuggingFace token (uses cached token if None) |
-| `allow_patterns` | `str | List[str] | None` | `None` | Glob patterns for files to include |
-| `ignore_patterns` | `str | List[str] | None` | `None` | Glob patterns for files to exclude |
-
-### Attributes
-
-| Attribute | Type | Description |
-|-----------|------|-------------|
-| `lock` | `threading.Lock` | Thread lock for safe concurrent writes |
-| `api` | `HfApi` | HuggingFace API client instance |
-| `repo_id` | `str` | The repository ID |
-| `folder_path` | `Path` | The monitored folder path |
-
-### Methods
-
-#### `push_to_hub()`
-
-Manually trigger an upload. Called automatically by the scheduler.
-
-```python
-scheduler.push_to_hub()
-```
-
-**Note:** You can override this method in a subclass for custom behavior.
-
-### Example: Basic Usage
-
-```python
-from pathlib import Path
-from huggingface_hub import CommitScheduler
-
-# Create scheduler
-scheduler = CommitScheduler(
-    repo_id="username/my-dataset",
-    folder_path=Path("./data"),
-    every=10,
-)
-
-# Files in ./data will be uploaded every 10 minutes
-# Use scheduler.lock when writing to ensure thread safety
-```
-
-### Example: Custom Upload Logic
-
-```python
-from huggingface_hub import CommitScheduler
-import zipfile
-from pathlib import Path
-
-class CustomScheduler(CommitScheduler):
-    def push_to_hub(self):
-        """Custom logic to zip files before upload."""
-        files = list(self.folder_path.glob("*.txt"))
-        if not files:
-            return None
-
-        # Create archive
-        archive_path = self.folder_path / "archive.zip"
-        with zipfile.ZipFile(archive_path, "w") as zf:
-            for file in files:
-                zf.write(file, file.name)
-
-        # Upload using parent's API
-        self.api.upload_file(
-            path_or_fileobj=str(archive_path),
-            path_in_repo="archives/archive.zip",
-            repo_id=self.repo_id,
-            repo_type=self.repo_type,
-        )
-
-        # Cleanup
-        archive_path.unlink()
-        for file in files:
-            file.unlink()
-```
-
----
-
-## HfApi Upload Methods
-
-The `HfApi` class provides methods for uploading files and folders.
-
-### upload_file()
-
-Upload a single file to a repository.
-
-```python
-from huggingface_hub import HfApi
-
-api = HfApi()
-
-api.upload_file(
-    path_or_fileobj: str | Path | bytes | BinaryIO,
-    path_in_repo: str,
-    repo_id: str,
-    *,
-    repo_type: str = "model",
-    revision: str = "main",
-    commit_message: str | None = None,
-    commit_description: str | None = None,
-    token: str | None = None,
-    run_as_future: bool = False,
-)
-```
-
-#### Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `path_or_fileobj` | `str | Path | bytes | BinaryIO` | File path or file-like object to upload |
-| `path_in_repo` | `str` | Destination path in the repository |
-| `repo_id` | `str` | Repository ID |
-| `repo_type` | `str` | "model", "dataset", or "space" |
-| `revision` | `str` | Branch/tag to commit to |
-| `commit_message` | `str | None` | Custom commit message |
-| `commit_description` | `str | None` | Extended commit description |
-| `token` | `str | None` | Authentication token |
-| `run_as_future` | `bool` | Run upload in background (returns Future) |
-
-#### Returns
-
-- `str`: Commit hash (URL to the commit)
-- `concurrent.futures.Future`: If `run_as_future=True`
-
-#### Example
-
-```python
-# Upload file from path
-api.upload_file(
-    path_or_fileobj="/path/to/file.json",
-    path_in_repo="data/file.json",
-    repo_id="username/my-dataset",
-    repo_type="dataset",
-    commit_message="Add new data file"
-)
-
-# Upload bytes
-data = b'{"key": "value"}'
-api.upload_file(
-    path_or_fileobj=data,
-    path_in_repo="config.json",
-    repo_id="username/my-dataset",
-    repo_type="dataset",
-)
-
-# Background upload
-future = api.upload_file(
-    path_or_fileobj="large_file.bin",
-    path_in_repo="large_file.bin",
-    repo_id="username/my-dataset",
-    repo_type="dataset",
-    run_as_future=True,
-)
-# Do other work...
-future.result()  # Wait for completion
-```
-
----
-
-### upload_folder()
-
-Upload an entire folder to a repository.
-
-```python
-api.upload_folder(
-    folder_path: str | Path,
-    repo_id: str,
-    *,
-    repo_type: str = "model",
-    revision: str = "main",
-    path_in_repo: str = ".",
-    commit_message: str | None = None,
-    commit_description: str | None = None,
-    token: str | None = None,
-    allow_patterns: str | List[str] | None = None,
-    ignore_patterns: str | List[str] | None = None,
-    delete_patterns: str | List[str] | None = None,
-    run_as_future: bool = False,
-)
-```
-
-#### Additional Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `folder_path` | `str | Path` | Local folder to upload |
-| `allow_patterns` | `str | List[str] | None` | Glob patterns to include |
-| `ignore_patterns` | `str | List[str] | None` | Glob patterns to exclude |
-| `delete_patterns` | `str | List[str] | None` | Patterns to delete from repo before upload |
-
-#### Example
-
-```python
-# Upload entire folder
-api.upload_folder(
-    folder_path="./my_dataset",
-    repo_id="username/my-dataset",
-    repo_type="dataset",
-)
-
-# Upload only CSV files
-api.upload_folder(
-    folder_path="./data",
-    repo_id="username/my-dataset",
-    repo_type="dataset",
-    allow_patterns="*.csv",
-)
-
-# Upload and delete old files
-api.upload_folder(
-    folder_path="./new_data",
-    path_in_repo="data",
-    repo_id="username/my-dataset",
-    repo_type="dataset",
-    delete_patterns="*.old",  # Delete .old files first
-)
-```
-
----
-
-### upload_large_folder()
-
-Upload very large folders with resume capability.
-
-```python
-api.upload_large_folder(
-    repo_id: str,
-    folder_path: str | Path,
-    *,
-    repo_type: str = "model",
-    revision: str = "main",
-    private: bool = False,
-    token: str | None = None,
-    allow_patterns: str | List[str] | None = None,
-    ignore_patterns: str | List[str] | None = None,
-    num_workers: int = 1,
-)
-```
-
-#### Key Features
-
-- **Resumable**: Caches progress locally, can resume after interruption
-- **Multi-threaded**: Parallel uploads with `num_workers`
-- **Resilient**: Automatic retries on errors
-
-#### Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `num_workers` | `int` | Number of parallel upload threads |
-
-#### Limitations
-
-- Cannot set custom `path_in_repo` (upload to root)
-- Cannot set custom commit message
-- Cannot delete files while uploading
-- Cannot create PR directly
-
-#### Example
-
-```python
-# Upload huge dataset
-api.upload_large_folder(
-    repo_id="username/huge-dataset",
-    folder_path="/data/massive_dataset",
-    repo_type="dataset",
-    num_workers=4,  # Use 4 parallel threads
-)
-
-# If interrupted, re-run the same command to resume
-```
-
----
-
-## Commit Operations
-
-For fine-grained control over commits, use `create_commit()` with operation objects.
-
-### create_commit()
-
-Create a commit with multiple operations (add/delete/copy files).
-
-```python
-api.create_commit(
-    repo_id: str,
-    operations: List[CommitOperation],
-    *,
-    commit_message: str,
-    commit_description: str | None = None,
-    repo_type: str = "model",
-    revision: str = "main",
-    token: str | None = None,
-    create_pr: bool = False,
-)
-```
-
-### Operation Types
-
-#### CommitOperationAdd
-
-Add or update a file.
-
-```python
-from huggingface_hub import CommitOperationAdd
-
-op = CommitOperationAdd(
-    path_in_repo="path/to/file.txt",
-    path_or_fileobj="/local/path/file.txt"  # or bytes or file object
-)
-```
-
-#### CommitOperationDelete
-
-Delete a file or folder.
-
-```python
-from huggingface_hub import CommitOperationDelete
-
-op = CommitOperationDelete(
-    path_in_repo="path/to/delete.txt"  # or "folder/" for directories
-)
-```
-
-#### CommitOperationCopy
-
-Copy a file within the repository.
-
-```python
-from huggingface_hub import CommitOperationCopy
-
-op = CommitOperationCopy(
-    src_path_in_repo="original.txt",
-    path_in_repo="copy.txt",
-    src_revision="main"  # optional: copy from different branch
-)
-```
-
-### Example: Multi-operation Commit
-
-```python
-from huggingface_hub import HfApi, CommitOperationAdd, CommitOperationDelete
-
-api = HfApi()
-
-operations = [
-    CommitOperationAdd(
-        path_in_repo="data/new_file.json",
-        path_or_fileobj="/local/new_file.json"
-    ),
-    CommitOperationAdd(
-        path_in_repo="config.yaml",
-        path_or_fileobj=b"key: value"
-    ),
-    CommitOperationDelete(
-        path_in_repo="old_data/"  # Delete entire folder
-    ),
-]
-
-api.create_commit(
-    repo_id="username/my-dataset",
-    operations=operations,
-    commit_message="Update dataset files",
-    commit_description="Added new data and removed old files",
-    repo_type="dataset",
-)
-```
-
----
-
-## Authentication
-
-### Method 1: CLI Login (Recommended)
-
-```bash
-huggingface-cli login
-```
-
-This caches your token locally. All subsequent API calls use this token automatically.
-
-### Method 2: Environment Variable
-
-```bash
-export HF_TOKEN="hf_..."
-```
-
-```python
-import os
-from huggingface_hub import HfApi
-
-api = HfApi(token=os.environ["HF_TOKEN"])
-```
-
-### Method 3: Programmatic Token
-
-```python
-from huggingface_hub import HfApi
-
-api = HfApi(token="hf_your_token_here")
-```
-
-### For Hugging Face Spaces
-
-1. Go to Space Settings → Repository secrets
-2. Add secret: `HF_TOKEN` = your token value
-3. Access in code:
-
-```python
-import os
-token = os.environ.get("HF_TOKEN")
-```
-
----
-
-## Configuration
-
-### Environment Variables
-
-| Variable | Description | Default |
-|----------|-------------|---------|
-| `HF_TOKEN` | Authentication token | None |
-| `HF_HOME` | Cache directory | `~/.cache/huggingface` |
-| `HF_HUB_CACHE` | Hub cache directory | `$HF_HOME/hub` |
-| `HF_ENDPOINT` | Hub endpoint URL | `https://huggingface.co` |
-| `HF_XET_CACHE` | Xet cache directory | `$HF_HOME/xet` |
-| `HF_XET_HIGH_PERFORMANCE` | Enable high-performance mode | `0` |
-
-### Example: Custom Cache Location
-
-```python
-import os
-
-# Set cache to local SSD for better performance
-os.environ["HF_HOME"] = "/mnt/local-ssd/.cache/huggingface"
-
-from huggingface_hub import HfApi
-api = HfApi()
-```
-
----
-
-## Error Handling
-
-### Common Errors and Solutions
-
-#### 1. Authentication Error
-
-```python
-from huggingface_hub import HfApi
-from huggingface_hub.utils import HfHubHTTPError
-
-api = HfApi()
-
-try:
-    api.upload_file(
-        path_or_fileobj="file.txt",
-        path_in_repo="file.txt",
-        repo_id="username/dataset",
-        repo_type="dataset",
-    )
-except HfHubHTTPError as e:
-    if e.response.status_code == 401:
-        print("❌ Authentication failed. Run: huggingface-cli login")
-    else:
-        raise
-```
-
-#### 2. Repository Not Found
-
-```python
-from huggingface_hub import HfApi
-from huggingface_hub.utils import RepositoryNotFoundError
-
-api = HfApi()
-
-try:
-    api.upload_file(...)
-except RepositoryNotFoundError:
-    print("❌ Repository not found. Creating...")
-    api.create_repo(repo_id="username/dataset", repo_type="dataset")
-    api.upload_file(...)  # Retry
-```
-
-#### 3. File Too Large
-
-```python
-from huggingface_hub import HfApi
-
-api = HfApi()
-
-file_size = os.path.getsize("huge_file.bin")
-
-if file_size > 5 * 1024**3:  # > 5GB
-    print("⚠️ Large file detected, using upload_large_folder")
-    # Move file to folder and use upload_large_folder
-else:
-    api.upload_file(
-        path_or_fileobj="huge_file.bin",
-        path_in_repo="huge_file.bin",
-        repo_id="username/dataset",
-        repo_type="dataset",
-    )
-```
-
-#### 4. Network Interruption
-
-```python
-from huggingface_hub import HfApi
-import time
-
-api = HfApi()
-
-max_retries = 3
-for attempt in range(max_retries):
-    try:
-        api.upload_folder(
-            folder_path="./data",
-            repo_id="username/dataset",
-            repo_type="dataset",
-        )
-        break
-    except Exception as e:
-        if attempt < max_retries - 1:
-            wait_time = 2 ** attempt  # Exponential backoff
-            print(f"⚠️ Upload failed, retrying in {wait_time}s...")
-            time.sleep(wait_time)
-        else:
-            print("❌ Upload failed after all retries")
-            raise
-```
-
----
-
-## Advanced Patterns
-
-### Pattern 1: Atomic Updates
-
-Ensure all files are updated together or not at all.
-
-```python
-from huggingface_hub import HfApi, CommitOperationAdd
-
-api = HfApi()
-
-# Prepare all operations
-operations = [
-    CommitOperationAdd("file1.json", path_or_fileobj=data1),
-    CommitOperationAdd("file2.json", path_or_fileobj=data2),
-    CommitOperationAdd("file3.json", path_or_fileobj=data3),
-]
-
-# Single atomic commit
-api.create_commit(
-    repo_id="username/dataset",
-    operations=operations,
-    commit_message="Atomic update of all files",
-    repo_type="dataset",
-)
-```
-
-### Pattern 2: Concurrent Uploads
-
-Upload multiple files in parallel.
-
-```python
-from huggingface_hub import HfApi
-from concurrent.futures import ThreadPoolExecutor
-
-api = HfApi()
-files = ["file1.txt", "file2.txt", "file3.txt"]
-
-def upload_file(filename):
-    api.upload_file(
-        path_or_fileobj=filename,
-        path_in_repo=filename,
-        repo_id="username/dataset",
-        repo_type="dataset",
-    )
-
-with ThreadPoolExecutor(max_workers=3) as executor:
-    executor.map(upload_file, files)
-```
-
-### Pattern 3: Progressive Dataset Building
-
-Build dataset incrementally with versioning.
-
-```python
-from huggingface_hub import HfApi
-
-api = HfApi()
-
-for version in range(1, 11):
-    # Generate data for this version
-    data = generate_data(version)
-
-    # Upload to versioned path
-    api.upload_file(
-        path_or_fileobj=data,
-        path_in_repo=f"versions/v{version}/data.json",
-        repo_id="username/dataset",
-        repo_type="dataset",
-        commit_message=f"Add version {version}",
-    )
-```
-
----
-
-## Performance Tips
-
-### 1. Use High-Performance Mode
-
-For maximum upload speed (uses all CPU cores and bandwidth):
-
-```bash
-export HF_XET_HIGH_PERFORMANCE=1
-```
-
-### 2. Local Cache for Cluster Uploads
-
-When uploading from distributed filesystems:
-
-```bash
-# Point cache to local SSD, not network filesystem
-export HF_XET_CACHE=/local-ssd/.cache/xet
-```
-
-### 3. Batch Small Files
-
-Instead of uploading thousands of small files individually:
-
-```python
-import zipfile
-from huggingface_hub import HfApi
-
-# Zip small files
-with zipfile.ZipFile("archive.zip", "w") as zf:
-    for file in small_files:
-        zf.write(file)
-
-# Upload single archive
-api.upload_file(
-    path_or_fileobj="archive.zip",
-    path_in_repo="data/archive.zip",
-    repo_id="username/dataset",
-    repo_type="dataset",
-)
-```
-
-### 4. Use Background Uploads
-
-Don't block your main thread:
-
-```python
-from huggingface_hub import HfApi
-
-api = HfApi()
-
-# Start upload in background
-future = api.upload_folder(
-    folder_path="./data",
-    repo_id="username/dataset",
-    repo_type="dataset",
-    run_as_future=True,
-)
-
-# Do other work
-process_more_data()
-
-# Wait for completion when ready
-future.result()
-```
-
----
-
-## Comparison Table
-
-| Feature | CommitScheduler | upload_folder() | upload_large_folder() |
-|---------|----------------|-----------------|----------------------|
-| Automatic uploads | ✅ Yes | ❌ No | ❌ No |
-| Resumable | ❌ No | ❌ No | ✅ Yes |
-| Custom commit message | ❌ No | ✅ Yes | ❌ No |
-| Background operation | ✅ Yes | ✅ Yes (with flag) | ❌ No |
-| Path in repo | ✅ Yes | ✅ Yes | ❌ No (root only) |
-| Multi-threaded | ❌ No | ❌ No | ✅ Yes |
-| Best for | Continuous logging | One-time uploads | Huge datasets |
-
----
-
-## Quick Reference
-
-### Upload Single File
-```python
-api.upload_file(path_or_fileobj="file.txt", path_in_repo="file.txt",
-                repo_id="user/dataset", repo_type="dataset")
-```
-
-### Upload Folder
-```python
-api.upload_folder(folder_path="./data", repo_id="user/dataset",
-                  repo_type="dataset")
-```
-
-### Scheduled Uploads
-```python
-scheduler = CommitScheduler(repo_id="user/dataset", folder_path="./data",
-                            every=10, repo_type="dataset")
-```
-
-### Background Upload
-```python
-future = api.upload_folder(..., run_as_future=True)
-future.result()  # Wait for completion
-```
-
-### Large Folder
-```python
-api.upload_large_folder(repo_id="user/dataset", folder_path="./big_data",
-                        repo_type="dataset", num_workers=4)
-```

app.py

@@ -85,7 +85,7 @@ def calculate_table(matches_list):
         all_teams.add(match[2])  # away team
 
     # Initialize stats for all teams
-    table = {t: {"P": 0, "W": 0, "D": 0, "L": 0, "GF": 0, "GA": 0, "Pts": 0, "GPM": 0.0, "WP": 0.0}
+    table = {t: {"P": 0, "W": 0, "D": 0, "L": 0, "GF": 0, "GA": 0, "Pts": 0, "GPM": 0.0, "GAM": 0.0, "GDM": 0.0, "WP": 0.0}
              for t in all_teams}
 
     # Process each match
@@ -117,6 +117,8 @@ def calculate_table(matches_list):
     for t in all_teams:
         if table[t]["P"] > 0:
             table[t]["GPM"] = round(table[t]["GF"] / table[t]["P"], 2)
+            table[t]["GAM"] = round(table[t]["GA"] / table[t]["P"], 2)
+            table[t]["GDM"] = round((table[t]["GF"] - table[t]["GA"]) / table[t]["P"], 2)
             table[t]["WP"] = round((table[t]["W"] / table[t]["P"]) * 100, 2)
 
     # Create DataFrame
@@ -126,7 +128,7 @@ def calculate_table(matches_list):
     df.rename(columns={"index": "Team"}, inplace=True)
 
     # Sort by WP descending (as per requirements)
-    df = df[["Team", "WP", "GPM", "P", "W", "D", "L", "GF", "GA", "GD", "Pts"]]
+    df = df[["Team", "WP", "GPM", "GAM", "GDM", "P", "W", "D", "L", "GF", "GA", "GD", "Pts"]]
     df = df.sort_values(by=["WP"], ascending=False)
 
     return df