first commit

.env.example

@@ -0,0 +1,3 @@
+ENVIRONMENT=development
+HF_TOKEN=xxx
+HF_HOME=.cache

.gitignore

@@ -0,0 +1,58 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+__pycache__
+.cache/
+
+# dependencies
+
+frontend/node_modules
+/.pnp
+.pnp.js
+
+# testing
+/coverage
+
+/backend/uploaded_files
+/backend/logs
+
+.venv/
+
+__pycache__/
+*.pkl
+model_info_cache.pkl
+model_size_cache.pkl
+gif.gif
+src/assets/scale-hf-logo.png
+
+.litellm_cache/
+
+# production
+
+/build
+
+# misc
+
+.DS_Store
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log\*
+
+src/dataframe.json
+
+yarn.lock
+package-lock.json
+
+/public
+
+.claudesync/
+
+# Environment variables
+.env
+.env.*
+!.env.example
+

Dockerfile

@@ -0,0 +1,61 @@
+# Build frontend
+FROM node:18 as frontend-build
+WORKDIR /app
+COPY frontend/package*.json ./
+RUN npm install
+COPY frontend/ ./
+
+RUN npm run build
+
+# Build backend
+FROM python:3.12-slim
+WORKDIR /app
+
+# Create non-root user
+RUN useradd -m -u 1000 user
+
+# Install uv instead of poetry
+RUN pip install uv
+
+# Create and configure cache directory
+RUN mkdir -p /app/.cache && \
+    chown -R user:user /app
+
+# Copy and install backend dependencies
+COPY backend/pyproject.toml ./
+RUN uv pip install -e . --system
+
+# Copy backend code
+COPY backend/ .
+
+# Install Node.js and npm
+RUN apt-get update && apt-get install -y \
+    curl \
+    netcat-openbsd \
+    && curl -fsSL https://deb.nodesource.com/setup_18.x | bash - \
+    && apt-get install -y nodejs \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy frontend server and build
+COPY --from=frontend-build /app/build ./frontend/build
+COPY --from=frontend-build /app/package*.json ./frontend/
+COPY --from=frontend-build /app/server.js ./frontend/
+
+# Install frontend production dependencies
+WORKDIR /app/frontend
+RUN npm install --production
+WORKDIR /app
+
+# Environment variables
+ENV HF_HOME=/app/.cache \
+    HF_DATASETS_CACHE=/app/.cache \
+    INTERNAL_API_PORT=7861 \
+    PORT=7860 \
+    NODE_ENV=production
+
+# Note: HF_TOKEN should be provided at runtime, not build time
+USER user
+EXPOSE 7860
+
+# Start both servers with wait-for
+CMD ["sh", "-c", "uvicorn app.asgi:app --host 0.0.0.0 --port 7861 & while ! nc -z localhost 7861; do sleep 1; done && cd frontend && npm run serve"]

README.md

@@ -0,0 +1,11 @@
+---
+title: Yourbench simple demo
+emoji: 🏆
+colorFrom: blue
+colorTo: red
+sdk: docker
+hf_oauth: true
+pinned: true
+license: apache-2.0
+short_description: Yourbench demo
+---

backend/Dockerfile.dev

@@ -0,0 +1,25 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# Install required system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install poetry
+RUN pip install poetry
+
+# Copy Poetry configuration files
+COPY pyproject.toml poetry.lock* ./
+
+# Install dependencies
+RUN poetry config virtualenvs.create false && \
+    poetry install --no-interaction --no-ansi --no-root
+
+# Environment variables configuration for logs
+ENV PYTHONUNBUFFERED=1
+ENV LOG_LEVEL=INFO
+
+# In dev, mount volume directly
+CMD ["uvicorn", "app.asgi:app", "--host", "0.0.0.0", "--port", "7860", "--reload", "--log-level", "warning", "--no-access-log"]

backend/README.md

@@ -0,0 +1,352 @@
+# Backend - Open LLM Leaderboard 🏆
+
+FastAPI backend for the Open LLM Leaderboard. This service is part of a larger architecture that includes a React frontend. For complete project installation, see the [main README](../README.md).
+
+## ✨ Features
+
+- 📊 REST API for LLM models leaderboard management
+- 🗳️ Voting and ranking system
+- 🔄 HuggingFace Hub integration
+- 🚀 Caching and performance optimizations
+
+## 🏗 Architecture
+
+```mermaid
+flowchart TD
+    Client(["**Frontend**<br><br>React Application"]) --> API["**API Server**<br><br>FastAPI REST Endpoints"]
+
+    subgraph Backend
+        API --> Core["**Core Layer**<br><br>• Middleware<br>• Cache<br>• Rate Limiting"]
+        Core --> Services["**Services Layer**<br><br>• Business Logic<br>• Data Processing"]
+
+        subgraph Services Layer
+            Services --> Models["**Model Service**<br><br>• Model Submission<br>• Evaluation Pipeline"]
+            Services --> Votes["**Vote Service**<br><br>• Vote Management<br>• Data Synchronization"]
+            Services --> Board["**Leaderboard Service**<br><br>• Rankings<br>• Performance Metrics"]
+        end
+
+        Models --> Cache["**Cache Layer**<br><br>• In-Memory Store<br>• Auto Invalidation"]
+        Votes --> Cache
+        Board --> Cache
+
+        Models --> HF["**HuggingFace Hub**<br><br>• Models Repository<br>• Datasets Access"]
+        Votes --> HF
+        Board --> HF
+    end
+
+    style Client fill:#f9f,stroke:#333,stroke-width:2px
+    style Models fill:#bbf,stroke:#333,stroke-width:2px
+    style Votes fill:#bbf,stroke:#333,stroke-width:2px
+    style Board fill:#bbf,stroke:#333,stroke-width:2px
+    style HF fill:#bfb,stroke:#333,stroke-width:2px
+```
+
+## 🛠️ HuggingFace Datasets
+
+The application uses several datasets on the HuggingFace Hub:
+
+### 1. Requests Dataset (`{HF_ORGANIZATION}/requests`)
+
+- **Operations**:
+  - 📤 `POST /api/models/submit`: Adds a JSON file for each new model submission
+  - 📥 `GET /api/models/status`: Reads files to get models status
+- **Format**: One JSON file per model with submission details
+- **Updates**: On each new model submission
+
+### 2. Votes Dataset (`{HF_ORGANIZATION}/votes`)
+
+- **Operations**:
+  - 📤 `POST /api/votes/{model_id}`: Adds a new vote
+  - 📥 `GET /api/votes/model/{provider}/{model}`: Reads model votes
+  - 📥 `GET /api/votes/user/{user_id}`: Reads user votes
+- **Format**: JSONL with one vote per line
+- **Sync**: Bidirectional between local cache and Hub
+
+### 3. Contents Dataset (`{HF_ORGANIZATION}/contents`)
+
+- **Operations**:
+  - 📥 `GET /api/leaderboard`: Reads raw data
+  - 📥 `GET /api/leaderboard/formatted`: Reads and formats data
+- **Format**: Main dataset containing all scores and metrics
+- **Updates**: Automatic after model evaluations
+
+### 4. Official Providers Dataset (`{HF_ORGANIZATION}/official-providers`)
+
+- **Operations**:
+  - 📥 Read-only access for highlighted models
+- **Format**: List of models selected by maintainers
+- **Updates**: Manual by maintainers
+
+## 🛠 Local Development
+
+### Prerequisites
+
+- Python 3.9+
+- [Poetry](https://python-poetry.org/docs/#installation)
+
+### Standalone Installation (without Docker)
+
+```bash
+# Install dependencies
+poetry install
+
+# Setup configuration
+cp .env.example .env
+
+# Start development server
+poetry run uvicorn app.asgi:app --host 0.0.0.0 --port 7860 --reload
+```
+
+Server will be available at http://localhost:7860
+
+## ⚙️ Configuration
+
+| Variable     | Description                          | Default     |
+| ------------ | ------------------------------------ | ----------- |
+| ENVIRONMENT  | Environment (development/production) | development |
+| HF_TOKEN     | HuggingFace authentication token     | -           |
+| PORT         | Server port                          | 7860        |
+| LOG_LEVEL    | Logging level (INFO/DEBUG/WARNING)   | INFO        |
+| CORS_ORIGINS | Allowed CORS origins                 | ["*"]       |
+| CACHE_TTL    | Cache Time To Live in seconds        | 300         |
+
+## 🔧 Middleware
+
+The backend uses several middleware layers for optimal performance and security:
+
+- **CORS Middleware**: Handles Cross-Origin Resource Sharing
+- **GZIP Middleware**: Compresses responses > 500 bytes
+- **Rate Limiting**: Prevents API abuse
+- **Caching**: In-memory caching with automatic invalidation
+
+## 📝 Logging
+
+The application uses a structured logging system with:
+
+- Formatted console output
+- Different log levels per component
+- Request/Response logging
+- Performance metrics
+- Error tracking
+
+## 📁 File Structure
+
+```
+backend/
+├── app/                  # Source code
+│   ├── api/             # Routes and endpoints
+│   │   └── endpoints/   # Endpoint handlers
+│   ├── core/           # Configurations
+│   ├── services/       # Business logic
+│   └── utils/          # Utilities
+└── tests/              # Tests
+```
+
+## 📚 API
+
+Swagger documentation available at http://localhost:7860/docs
+
+### Main Endpoints & Data Structures
+
+#### Leaderboard
+
+- `GET /api/leaderboard/formatted` - Formatted data with computed fields and metadata
+
+  ```typescript
+  Response {
+    models: [{
+      id: string,  // eval_name
+      model: {
+        name: string,  // fullname
+        sha: string,  // Model sha
+        precision: string,  // e.g. "fp16", "int8"
+        type: string,  // e.g. "fined-tuned-on-domain-specific-dataset"
+        weight_type: string,
+        architecture: string,
+        average_score: number,
+        has_chat_template: boolean
+      },
+      evaluations: {
+        ifeval: {
+          name: "IFEval",
+          value: number,  // Raw score
+          normalized_score: number
+        },
+        bbh: {
+          name: "BBH",
+          value: number,
+          normalized_score: number
+        },
+        math: {
+          name: "MATH Level 5",
+          value: number,
+          normalized_score: number
+        },
+        gpqa: {
+          name: "GPQA",
+          value: number,
+          normalized_score: number
+        },
+        musr: {
+          name: "MUSR",
+          value: number,
+          normalized_score: number
+        },
+        mmlu_pro: {
+          name: "MMLU-PRO",
+          value: number,
+          normalized_score: number
+        }
+      },
+      features: {
+        is_not_available_on_hub: boolean,
+        is_merged: boolean,
+        is_moe: boolean,
+        is_flagged: boolean,
+        is_official_provider: boolean
+      },
+      metadata: {
+        upload_date: string,
+        submission_date: string,
+        generation: string,
+        base_model: string,
+        hub_license: string,
+        hub_hearts: number,
+        params_billions: number,
+        co2_cost: number  // CO₂ cost in kg
+      }
+    }]
+  }
+  ```
+
+- `GET /api/leaderboard` - Raw data from the HuggingFace dataset
+  ```typescript
+  Response {
+    models: [{
+      eval_name: string,
+      Precision: string,
+      Type: string,
+      "Weight type": string,
+      Architecture: string,
+      Model: string,
+      fullname: string,
+      "Model sha": string,
+      "Average ⬆️": number,
+      "Hub License": string,
+      "Hub ❤️": number,
+      "#Params (B)": number,
+      "Available on the hub": boolean,
+      Merged: boolean,
+      MoE: boolean,
+      Flagged: boolean,
+      "Chat Template": boolean,
+      "CO₂ cost (kg)": number,
+      "IFEval Raw": number,
+      IFEval: number,
+      "BBH Raw": number,
+      BBH: number,
+      "MATH Lvl 5 Raw": number,
+      "MATH Lvl 5": number,
+      "GPQA Raw": number,
+      GPQA: number,
+      "MUSR Raw": number,
+      MUSR: number,
+      "MMLU-PRO Raw": number,
+      "MMLU-PRO": number,
+      "Maintainer's Highlight": boolean,
+      "Upload To Hub Date": string,
+      "Submission Date": string,
+      Generation: string,
+      "Base Model": string
+    }]
+  }
+  ```
+
+#### Models
+
+- `GET /api/models/status` - Get all models grouped by status
+  ```typescript
+  Response {
+    pending: [{
+      name: string,
+      submitter: string,
+      revision: string,
+      wait_time: string,
+      submission_time: string,
+      status: "PENDING" | "EVALUATING" | "FINISHED",
+      precision: string
+    }],
+    evaluating: Array<Model>,
+    finished: Array<Model>
+  }
+  ```
+- `GET /api/models/pending` - Get pending models only
+- `POST /api/models/submit` - Submit model
+
+  ```typescript
+  Request {
+    user_id: string,
+    model_id: string,
+    base_model?: string,
+    precision?: string,
+    model_type: string
+  }
+
+  Response {
+    status: string,
+    message: string
+  }
+  ```
+
+- `GET /api/models/{model_id}/status` - Get model status
+
+#### Votes
+
+- `POST /api/votes/{model_id}` - Vote
+
+  ```typescript
+  Request {
+    vote_type: "up" | "down",
+    user_id: string  // HuggingFace username
+  }
+
+  Response {
+    success: boolean,
+    message: string
+  }
+  ```
+
+- `GET /api/votes/model/{provider}/{model}` - Get model votes
+  ```typescript
+  Response {
+    total_votes: number,
+    up_votes: number,
+    down_votes: number
+  }
+  ```
+- `GET /api/votes/user/{user_id}` - Get user votes
+  ```typescript
+  Response Array<{
+    model_id: string,
+    vote_type: string,
+    timestamp: string
+  }>
+  ```
+
+## 🔒 Authentication
+
+The backend uses HuggingFace token-based authentication for secure API access. Make sure to:
+
+1. Set your HF_TOKEN in the .env file
+2. Include the token in API requests via Bearer authentication
+3. Keep your token secure and never commit it to version control
+
+## 🚀 Performance
+
+The backend implements several optimizations:
+
+- In-memory caching with configurable TTL (Time To Live)
+- Batch processing for model evaluations
+- Rate limiting for API endpoints
+- Efficient database queries with proper indexing
+- Automatic cache invalidation for votes

backend/main.py

@@ -0,0 +1,38 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+import os
+from dotenv import load_dotenv
+from routes import routers, session_files, active_bench_tasks
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Verify environment variables are loaded
+hf_token = os.getenv("HF_TOKEN")
+if not hf_token:
+    print("Warning: HF_TOKEN environment variable is not set. Make sure it's defined in your .env file.")
+
+hf_organization = os.getenv("HF_ORGANIZATION")
+if not hf_organization:
+    print("Warning: HF_ORGANIZATION environment variable is not set. Make sure it's defined in your .env file.")
+
+app = FastAPI(title="Yourbench API")
+
+# Activer CORS pour permettre les requêtes depuis le frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Dans un environnement de production, spécifiez les origines exactes
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Ajouter un gestionnaire d'événements pour afficher les session_files au démarrage
+@app.on_event("startup")
+async def startup_event():
+    print("Application startup")
+    print(f"Initial session_files: {session_files}")
+
+# Enregistrer toutes les routes
+for router in routers:
+    app.include_router(router) 

backend/old-pyproject.toml

@@ -0,0 +1,26 @@
+[tool.poetry]
+name = "llm-leaderboard-backend"
+version = "0.1.0"
+description = "Backend for the Open LLM Leaderboard"
+authors = ["Your Name <[email protected]>"]
+
+[tool.poetry.dependencies]
+python = ">=3.12,<3.13"
+fastapi = "^0.115.6"
+huggingface-hub = "0.29.3"
+python-dotenv = "^1.0.1"
+python-multipart = "^0.0.9"
+uvicorn = {extras = ["standard"], version = "^0.27.0"}
+loguru = "^0.7.3"
+lighteval = {version = ">=0.8.0", extras = ["math"]}
+tqdm = "^4.67.1"
+asyncio = "^3.4.3"
+datasets = "^3.3.0"
+yourbench = {git = "https://github.com/huggingface/yourbench.git"}
+tiktoken = "^0.9.0"
+requests = {extras = ["socks"], version = "^2.32.3"}
+httpx-socks = "^0.10.0"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api" 

backend/pyproject.toml

@@ -0,0 +1,47 @@
+[project]
+name = "yourbench-simple-demo"
+version = "0.1.0"
+authors = [
+    { name = "Sumuk Shashidhar", email = "[email protected]" },
+    { name = "Alina Lozovskaia", email = "[email protected]" },
+    { name = "Clémentine Fourrier", email = "[email protected]" },
+    { name = "Nathan Habib", email = "[email protected]" },
+]
+requires-python = ">=3.12, <3.13"
+
+dependencies = [
+    "yourbench @ git+https://github.com/huggingface/yourbench.git@main",
+    "asyncio>=3.4.3",
+    "datasets>=3.3.0",
+    "loguru>=0.7.3",
+    "python-dotenv>=1.0.1",
+    "tqdm>=4.67.1",
+    "ruff>=0.11.2",
+    "lighteval>=0.8.0",
+    "huggingface-hub>=0.22.0",
+]
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.ruff]
+line-length = 119
+exclude = ["**/*.ipynb"]
+
+lint.ignore = ["E501", "C901", "F841"]
+lint.select = ["C", "E", "F", "I", "W"]
+lint.fixable = ["A", "B", "C", "D", "E", "F", "I", "W"]
+preview = true
+
+[tool.ruff.lint.isort]
+length-sort = true
+lines-after-imports = 2
+no-lines-before = ["standard-library", "local-folder"]
+split-on-trailing-comma = true
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "auto"

backend/routes/__init__.py

@@ -0,0 +1,23 @@
+# Routes du module
+from .health import router as health_router
+from .upload import router as upload_router, session_files
+from .benchmark import router as benchmark_router, active_bench_tasks
+from .questions import router as questions_router
+from .download import router as download_router
+from .evaluation import router as evaluation_router, active_evaluation_tasks
+
+# Exposer les routeurs
+routers = [
+    health_router,
+    upload_router,
+    benchmark_router,
+    questions_router,
+    download_router,
+    evaluation_router
+]
+
+# Référencer les données partagées entre routes
+benchmark_router.session_files = session_files
+
+# Exposer les variables partagées pour main.py
+__all__ = ['routers', 'session_files', 'active_bench_tasks', 'active_evaluation_tasks'] 

backend/routes/benchmark.py

@@ -0,0 +1,132 @@
+from fastapi import APIRouter, HTTPException
+from typing import Dict, Any
+import os
+import time
+from tasks.createBenchConfigFile import CreateBenchConfigTask
+from tasks.createBench import CreateBenchTask
+
+router = APIRouter(tags=["benchmark"])
+
+# Store active tasks by session_id (importé dans main.py)
+active_bench_tasks = {}
+active_config_tasks = {}
+
+# Référence aux session_files (sera fournie par main.py)
+# Cette déclaration sera écrasée par l'affectation dans __init__.py
+session_files = {}
+
+@router.post("/generate-benchmark")
+async def generate_benchmark(data: Dict[str, Any]):
+    """
+    Generate a benchmark configuration and run the ingestion process
+    
+    Args:
+        data: Dictionary containing session_id
+        
+    Returns:
+        Dictionary with logs and config_path
+    """
+    session_id = data.get("session_id")
+    
+    # Débogage pour vérifier les session_files et le session_id reçu
+    print(f"DEBUG: Session ID reçu: {session_id}")
+    print(f"DEBUG: Session files disponibles: {list(router.session_files.keys())}")
+    
+    if not session_id or session_id not in router.session_files:
+        return {"error": "Invalid or missing session ID"}
+    
+    file_path = router.session_files[session_id]
+    all_logs = []
+    
+    try:
+        # Step 1: Generate configuration file
+        config_task = CreateBenchConfigTask(session_uid=session_id)
+        # Store the config task for later log retrieval
+        active_config_tasks[session_id] = config_task
+        
+        # Start configuration generation asynchronously
+        config_path = config_task.run(file_path=file_path)
+        
+        # Add initial logs
+        all_logs.extend(config_task.get_logs())
+        
+        # Step 2: Run the createBench task with the generated config
+        # Note: This will be started by a separate endpoint once configuration is done
+        
+        return {
+            "status": "running",
+            "config_path": config_path,
+            "logs": all_logs
+        }
+    except Exception as e:
+        return {
+            "status": "error",
+            "error": str(e),
+            "logs": all_logs
+        }
+
+@router.get("/config-logs/{session_id}")
+async def get_config_logs(session_id: str):
+    """
+    Get the logs for a running configuration task
+    
+    Args:
+        session_id: Session ID for the task
+        
+    Returns:
+        Dictionary with logs and completion status
+    """
+    if session_id not in active_config_tasks:
+        raise HTTPException(status_code=404, detail="Configuration task not found")
+    
+    config_task = active_config_tasks[session_id]
+    logs = config_task.get_logs()
+    is_completed = config_task.is_task_completed()
+    
+    # Si la configuration est terminée et que le benchmark n'est pas encore démarré,
+    # démarrer automatiquement le benchmark
+    if is_completed and session_id not in active_bench_tasks:
+        try:
+            # Ensure the config_path is a string
+            config_path_str = f"uploaded_files/{session_id}/config.yml"
+            bench_task = CreateBenchTask(session_uid=session_id, config_path=config_path_str)
+            
+            # Store the bench task for later log retrieval
+            active_bench_tasks[session_id] = bench_task
+            
+            # Add a transition log
+            logs.append("[INFO] Configuration file generated, starting benchmark creation")
+            
+            # Run the task
+            bench_task.run()
+        except Exception as bench_error:
+            error_msg = f"Error starting benchmark creation: {str(bench_error)}"
+            logs.append(f"[ERROR] {error_msg}")
+    
+    return {
+        "logs": logs,
+        "is_completed": is_completed
+    }
+
+@router.get("/benchmark-logs/{session_id}")
+async def get_benchmark_logs(session_id: str):
+    """
+    Get the logs for a running benchmark task
+    
+    Args:
+        session_id: Session ID for the task
+        
+    Returns:
+        Dictionary with logs and completion status
+    """
+    if session_id not in active_bench_tasks:
+        raise HTTPException(status_code=404, detail="Benchmark task not found")
+    
+    bench_task = active_bench_tasks[session_id]
+    logs = bench_task.get_logs()
+    is_completed = bench_task.is_task_completed()
+    
+    return {
+        "logs": logs,
+        "is_completed": is_completed
+    } 

backend/routes/download.py

@@ -0,0 +1,74 @@
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import StreamingResponse
+from huggingface_hub import hf_hub_download, snapshot_download
+import os
+import tempfile
+import shutil
+import zipfile
+import io
+import logging
+
+router = APIRouter(tags=["download"])
+
+@router.get("/download-dataset/{session_id}")
+async def download_dataset(session_id: str):
+    """
+    Télécharge le dataset HuggingFace associé à une session et le renvoie au client
+    
+    Args:
+        session_id: Identifiant de la session
+        
+    Returns:
+        Fichier ZIP contenant le dataset
+    """
+    try:
+        # Créer un répertoire temporaire pour stocker les fichiers du dataset
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Identifiant du repo HuggingFace
+            repo_id = f"yourbench/yourbench_{session_id}"
+            
+            try:
+                # Télécharger le snapshot du dataset depuis HuggingFace
+                logging.info(f"Téléchargement du dataset {repo_id}")
+                snapshot_path = snapshot_download(
+                    repo_id=repo_id,
+                    repo_type="dataset",
+                    local_dir=temp_dir,
+                    token=os.environ.get("HF_TOKEN")
+                )
+                
+                logging.info(f"Dataset téléchargé dans {snapshot_path}")
+                
+                # Créer un fichier ZIP en mémoire
+                zip_io = io.BytesIO()
+                with zipfile.ZipFile(zip_io, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+                    # Parcourir tous les fichiers du dataset et les ajouter au ZIP
+                    for root, _, files in os.walk(snapshot_path):
+                        for file in files:
+                            file_path = os.path.join(root, file)
+                            arc_name = os.path.relpath(file_path, snapshot_path)
+                            zip_file.write(file_path, arcname=arc_name)
+                
+                # Remettre le curseur au début du stream
+                zip_io.seek(0)
+                
+                # Renvoyer le ZIP au client
+                filename = f"yourbench_{session_id}_dataset.zip"
+                return StreamingResponse(
+                    zip_io,
+                    media_type="application/zip",
+                    headers={"Content-Disposition": f"attachment; filename={filename}"}
+                )
+                
+            except Exception as e:
+                logging.error(f"Erreur lors du téléchargement du dataset: {str(e)}")
+                raise HTTPException(
+                    status_code=500,
+                    detail=f"Erreur lors du téléchargement du dataset: {str(e)}"
+                )
+    except Exception as e:
+        logging.error(f"Erreur générale: {str(e)}")
+        raise HTTPException(
+            status_code=500, 
+            detail=f"Erreur lors du téléchargement: {str(e)}"
+        ) 

backend/routes/evaluation.py

@@ -0,0 +1,150 @@
+from fastapi import APIRouter, HTTPException
+from typing import Dict, Any
+import os
+from tasks.evaluationTask import EvaluationTask
+
+router = APIRouter(tags=["evaluation"])
+
+# Store active evaluation tasks by session_id
+active_evaluation_tasks = {}
+
+@router.post("/evaluate-benchmark")
+async def evaluate_benchmark(data: Dict[str, Any]):
+    """
+    Lancer l'évaluation d'un benchmark pour une session donnée
+    
+    Args:
+        data: Dictionary contenant session_id
+        
+    Returns:
+        Dictionary avec statut et logs initiaux
+    """
+    session_id = data.get("session_id")
+    
+    if not session_id:
+        return {"error": "Session ID manquant ou invalide"}
+    
+    # Vérifier si une évaluation est déjà en cours pour cette session
+    if session_id in active_evaluation_tasks:
+        evaluation_task = active_evaluation_tasks[session_id]
+        # Si l'évaluation est déjà terminée, on peut en lancer une nouvelle
+        if evaluation_task.is_task_completed():
+            # Suppression de l'ancienne tâche
+            del active_evaluation_tasks[session_id]
+        else:
+            # Une évaluation est déjà en cours
+            return {
+                "status": "already_running",
+                "message": "Une évaluation est déjà en cours pour cette session",
+                "logs": evaluation_task.get_logs()
+            }
+    
+    try:
+        # Nom du dataset basé sur l'ID de session
+        dataset_name = f"yourbench_{session_id}"
+        
+        # Créer et démarrer une nouvelle tâche d'évaluation
+        evaluation_task = EvaluationTask(session_uid=session_id, dataset_name=dataset_name)
+        active_evaluation_tasks[session_id] = evaluation_task
+        
+        # Démarrer l'évaluation de manière asynchrone
+        evaluation_task.run()
+        
+        # Récupérer les logs initiaux
+        initial_logs = evaluation_task.get_logs()
+        
+        return {
+            "status": "started",
+            "message": f"Évaluation démarrée pour le benchmark {dataset_name}",
+            "logs": initial_logs
+        }
+    except Exception as e:
+        return {
+            "status": "error",
+            "error": str(e),
+            "message": f"Erreur lors du démarrage de l'évaluation: {str(e)}"
+        }
+
+@router.get("/evaluation-logs/{session_id}")
+async def get_evaluation_logs(session_id: str):
+    """
+    Récupérer les logs d'une évaluation en cours
+    
+    Args:
+        session_id: ID de la session pour laquelle récupérer les logs
+        
+    Returns:
+        Dictionary avec logs et statut de complétion
+    """
+    if session_id not in active_evaluation_tasks:
+        raise HTTPException(status_code=404, detail="Tâche d'évaluation non trouvée")
+    
+    evaluation_task = active_evaluation_tasks[session_id]
+    logs = evaluation_task.get_logs()
+    is_completed = evaluation_task.is_task_completed()
+    
+    # Récupérer les résultats si disponibles et l'évaluation est terminée
+    results = None
+    if is_completed and hasattr(evaluation_task, 'results') and evaluation_task.results:
+        results = evaluation_task.results
+    
+    return {
+        "logs": logs,
+        "is_completed": is_completed,
+        "results": results
+    }
+
+@router.get("/evaluation-results/{session_id}")
+async def get_evaluation_results(session_id: str):
+    """
+    Retrieve results of a completed evaluation
+    
+    Args:
+        session_id: Session ID to retrieve results for
+        
+    Returns:
+        Dictionary with evaluation results
+    """
+    # First, check if the task is in memory
+    if session_id in active_evaluation_tasks:
+        evaluation_task = active_evaluation_tasks[session_id]
+        
+        if not evaluation_task.is_task_completed():
+            return {
+                "success": False,
+                "message": "Evaluation is still in progress"
+            }
+        
+        if hasattr(evaluation_task, 'results') and evaluation_task.results:
+            return {
+                "success": True,
+                "results": evaluation_task.results
+            }
+    
+    # If we get here, either the task is not in memory or it doesn't have results
+    # Try to load results from file
+    try:
+        # Construct the path to the results file
+        results_path = f"uploaded_files/{session_id}/lighteval_results/models_comparison.json"
+        
+        # Check if the file exists
+        if not os.path.exists(results_path):
+            return {
+                "success": False,
+                "message": "No evaluation results found for this session"
+            }
+        
+        # Read the file
+        import json
+        with open(results_path, 'r') as f:
+            results = json.load(f)
+        
+        return {
+            "success": True,
+            "results": results
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "message": f"Error retrieving evaluation results: {str(e)}"
+        } 

backend/routes/health.py

@@ -0,0 +1,13 @@
+from fastapi import APIRouter
+
+router = APIRouter(tags=["health"])
+
+@router.get("/health")
+async def health_check():
+    """
+    Check if the API is running properly
+    
+    Returns:
+        Dictionary with status
+    """
+    return {"status": "ok"} 

backend/routes/questions.py

@@ -0,0 +1,87 @@
+from fastapi import APIRouter, HTTPException
+import random
+from datasets import load_dataset
+from huggingface_hub import HfApi, dataset_info
+import os
+
+router = APIRouter(tags=["benchmark"])
+
+@router.get("/benchmark-questions/{session_id}")
+async def get_benchmark_questions(session_id: str):
+    """
+    Get example questions from the generated benchmark
+    
+    Args:
+        session_id: Session ID for the benchmark
+        
+    Returns:
+        Dictionary with sample questions from the dataset
+    """
+    try:
+        # Dataset path on Hugging Face
+        dataset_repo_id = f"yourbench/yourbench_{session_id}"
+        
+        # Initialize response
+        response = {
+            "success": False,
+            "questions": [],
+            "dataset_url": f"https://huggingface.co/datasets/{dataset_repo_id}"
+        }
+        
+        # Try to load the dataset
+        questions = []
+        
+        try:
+            # Essayer de charger les questions single-shot directement avec le nom de config
+            single_dataset = load_dataset(dataset_repo_id, 'single_shot_questions')
+            if single_dataset and len(single_dataset['train']) > 0:
+                # Get a random sample (up to 2) from single-shot questions
+                sample_indices = random.sample(range(len(single_dataset['train'])), min(2, len(single_dataset['train'])))
+                for idx in sample_indices:
+                    questions.append({
+                        "id": str(idx),
+                        "question": single_dataset['train'][idx].get("question", ""),
+                        "type": "single_shot"
+                    })
+                print(f"Loaded {len(questions)} single-shot questions")
+        except Exception as e:
+            print(f"Error loading single-shot questions: {str(e)}")
+        
+        try:
+            # Essayer de charger les questions multi-hop si nécessaire
+            if len(questions) < 2:
+                multi_dataset = load_dataset(dataset_repo_id, 'multi_hop_questions')
+                if multi_dataset and len(multi_dataset['train']) > 0:
+                    # Get remaining questions from multi-hop questions
+                    remaining = 2 - len(questions)
+                    sample_indices = random.sample(range(len(multi_dataset['train'])), min(remaining, len(multi_dataset['train'])))
+                    for idx in sample_indices:
+                        questions.append({
+                            "id": str(idx),
+                            "question": multi_dataset['train'][idx].get("question", ""),
+                            "type": "multi_hop"
+                        })
+                    print(f"Loaded {len(questions)} multi-hop questions")
+        except Exception as e:
+            print(f"Error loading multi-hop questions: {str(e)}")
+        
+        # If we couldn't load any questions, the dataset might not exist
+        if len(questions) == 0:
+            # Check if we have a directory for this session locally as fallback
+            session_dir = os.path.join("uploaded_files", session_id)
+            if not os.path.exists(session_dir):
+                raise HTTPException(status_code=404, detail="Dataset not found")
+        
+        # Update the response
+        response["success"] = len(questions) > 0
+        response["questions"] = questions
+        return response
+            
+    except HTTPException:
+        # Re-raise HTTP exceptions
+        raise
+    except Exception as e:
+        return {
+            "success": False,
+            "error": f"Error retrieving benchmark questions: {str(e)}"
+        } 

backend/routes/upload.py

@@ -0,0 +1,52 @@
+from fastapi import APIRouter, UploadFile, File
+import os
+import shutil
+import uuid
+
+router = APIRouter(tags=["files"])
+
+# Définir le stockage des fichiers par session (importé dans main.py)
+session_files = {}
+
+# Dossier racine pour les uploads
+UPLOAD_ROOT = "uploaded_files"
+os.makedirs(UPLOAD_ROOT, exist_ok=True)
+
+@router.post("/upload")
+async def upload_file(file: UploadFile = File(...)):
+    """
+    Upload a file to the server and generate a session ID
+    
+    Args:
+        file: The file to upload
+        
+    Returns:
+        Dictionary with filename, status and session_id
+    """
+    # Vérifier si le fichier est un PDF, TXT, HTML ou MD
+    if not file.filename.endswith(('.pdf', '.txt', '.html', '.md')):
+        return {"error": "Only PDF, TXT, HTML and MD files are accepted"}
+    
+    # Generate a session ID for this file
+    session_id = str(uuid.uuid4())
+    
+    # Create the session directory structure
+    session_dir = os.path.join(UPLOAD_ROOT, session_id)
+    uploaded_files_dir = os.path.join(session_dir, "uploaded_files")
+    os.makedirs(uploaded_files_dir, exist_ok=True)
+    
+    # Create the full path to save the file
+    file_path = os.path.join(uploaded_files_dir, file.filename)
+    
+    # Sauvegarder le fichier
+    with open(file_path, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+    
+    # Store file path for later use
+    session_files[session_id] = file_path
+    
+    # Débogage pour vérifier l'état des session_files
+    print(f"DEBUG UPLOAD: File uploaded with session_id: {session_id}")
+    print(f"DEBUG UPLOAD: Current session_files: {session_files}")
+    
+    return {"filename": file.filename, "status": "uploaded", "session_id": session_id} 

backend/tasks/__init__.py

@@ -0,0 +1,3 @@
+"""
+Tasks module for YourbenchSimpleDemo
+""" 

backend/tasks/createBench.py

@@ -0,0 +1,317 @@
+"""
+Task to ingest and transform documents to markdown using yourbench
+"""
+import os
+import time
+import pathlib
+import subprocess
+import threading
+from typing import Optional, List, Tuple, Dict, Any
+import yaml
+
+from loguru import logger
+
+
+class CreateBenchTask:
+    """
+    Task to ingest and transform documents to markdown using yourbench
+    """
+
+    def __init__(self, session_uid: str, config_path: Optional[str] = None):
+        """
+        Initialize the ingestion task
+        
+        Args:
+            session_uid: Session ID for this task
+            config_path: Path to the configuration file, will be generated if None
+        """
+        self.session_uid = session_uid
+        self.logs: List[str] = []
+        self.is_completed = False
+        self.process = None
+        self.is_running_flag = threading.Event()
+        
+        # Default config path if not provided
+        if config_path is None:
+            config_path = f"uploaded_files/{session_uid}/config.yml"
+        self.config_path = config_path
+        
+        # Command to run yourbench - modified to avoid error with uv run
+        self.command = ["yourbench", "run", "--config", str(self.config_path)]
+        
+        self._add_log("[INFO] Initializing ingestion task")
+        self._add_log(f"[INFO] Using configuration file: {self.config_path}")
+    
+    def _add_log(self, message: str) -> None:
+        """
+        Add a log message to the logs list
+        
+        Args:
+            message: Log message to add
+        """
+        if message not in self.logs:  # Avoid duplicates
+            self.logs.append(message)
+            # Force copy of the list to avoid reference problems
+            self.logs = self.logs.copy()
+            # Log to system logs
+            logger.info(f"[{self.session_uid}] {message}")
+    
+    def get_logs(self) -> List[str]:
+        """
+        Get all logs for this task
+        
+        Returns:
+            List of log messages
+        """
+        return self.logs.copy()  # Return a copy to avoid reference problems
+    
+    def is_task_completed(self) -> bool:
+        """
+        Check if the task is completed
+        
+        Returns:
+            True if completed, False otherwise
+        """
+        return self.is_completed
+    
+    def is_running(self) -> bool:
+        """
+        Check if the process is running
+        
+        Returns:
+            True if running, False otherwise
+        """
+        return self.is_running_flag.is_set()
+    
+    def stop(self) -> None:
+        """
+        Stop the process if it's running
+        """
+        if self.process and self.is_running():
+            self._add_log("[INFO] Stopping ingestion process")
+            try:
+                self.process.terminate()
+                # Wait 5 seconds for termination
+                self.process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self._add_log("[WARN] Process not responding, forcing termination")
+                self.process.kill()
+            finally:
+                self.is_running_flag.clear()
+                self.is_completed = True
+                self._add_log("[INFO] Ingestion process stopped")
+    
+    def _capture_output(self) -> None:
+        """
+        Capture and process the output from the yourbench process
+        """
+        self._add_log("[INFO] Starting output capture")
+        
+        try:
+            while self.is_running() and self.process:
+                line = self.process.stdout.readline()
+                if not line:
+                    # If no line is read and the process is no longer running
+                    if self.process.poll() is not None:
+                        self.is_running_flag.clear()
+                        break
+                    # Otherwise, wait a bit and continue
+                    time.sleep(0.1)
+                    continue
+                
+                # Process the output line
+                line = line.strip()
+                if line:
+                    # Filter and format the line as needed
+                    if "ERROR" in line:
+                        self._add_log(f"[ERROR] {line}")
+                    elif "WARNING" in line:
+                        self._add_log(f"[WARN] {line}")
+                    else:
+                        # Detect completed stages
+                        if "Completed stage:" in line:
+                            stage = line.split("'")[1] if "'" in line else line
+                            self._add_log(f"[SUCCESS] Stage completed: {stage}")
+                        else:
+                            self._add_log(f"[INFO] {line}")
+            
+            # Check exit code once the process is finished
+            if self.process:
+                exit_code = self.process.poll()
+                if exit_code == 0:
+                    self._add_log("[SUCCESS] Ingestion process completed successfully")
+                else:
+                    self._add_log(f"[ERROR] Ingestion process terminated with error code: {exit_code}")
+        except Exception as e:
+            self._add_log(f"[ERROR] Error during output capture: {str(e)}")
+        finally:
+            self.is_completed = True
+            self.is_running_flag.clear()
+            self._add_log("[INFO] Output capture completed")
+    
+    def run(self, token: Optional[str] = None) -> None:
+        """
+        Run the ingestion task
+        
+        Args:
+            token: Hugging Face token
+        """
+        try:
+            self._add_log("[INFO] Starting ingestion process")
+            
+            # Check if the configuration file exists
+            if not os.path.exists(self.config_path):
+                raise FileNotFoundError(f"Configuration file does not exist: {self.config_path}")
+            
+            # Examine the configuration to get information
+            try:
+                with open(self.config_path, 'r') as f:
+                    config_yaml = yaml.safe_load(f)
+                    
+                # Get source and destination paths
+                source_dir = config_yaml.get("pipeline", {}).get("ingestion", {}).get("source_documents_dir", "")
+                output_dir = config_yaml.get("pipeline", {}).get("ingestion", {}).get("output_dir", "")
+                
+                if source_dir:
+                    self._add_log(f"[INFO] Source directory: {source_dir}")
+                if output_dir:
+                    self._add_log(f"[INFO] Output directory: {output_dir}")
+                    
+                # List files to process if the directory exists
+                if source_dir and os.path.exists(source_dir):
+                    files = os.listdir(source_dir)
+                    if files:
+                        self._add_log(f"[INFO] Files to process: {', '.join(files)}")
+                    else:
+                        self._add_log("[WARN] No files found in source directory")
+                
+            except Exception as e:
+                self._add_log(f"[WARN] Unable to read configuration: {str(e)}")
+            
+            # Environment preparation
+            env = os.environ.copy()
+            
+            # Explicitly define environment variables for authentication
+            hf_token = os.getenv("HF_TOKEN")
+            if hf_token:
+                # Explicitly export these variables for yourbench
+                env["HF_TOKEN"] = hf_token
+                env["HUGGING_FACE_HUB_TOKEN"] = hf_token
+                env["HF_ORGANIZATION"] = os.getenv("HF_ORGANIZATION", "yourbench")
+                self._add_log("[INFO] Environment variables HF_TOKEN, HUGGING_FACE_HUB_TOKEN and HF_ORGANIZATION exported")
+            
+            # In development mode, only simulate ingestion
+            if os.environ.get("DEVELOPMENT_MODE", "").lower() == "true":
+                self._add_log("[INFO] Development mode enabled, simulating ingestion")
+                self._simulate_ingestion_process()
+                return
+            
+            # Start the process
+            self._add_log(f"[INFO] Executing command: {' '.join(self.command)}")
+            
+            self.process = subprocess.Popen(
+                self.command,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                bufsize=1,
+                universal_newlines=True,
+                env=env
+            )
+            
+            # Mark the process as running
+            self.is_running_flag.set()
+            
+            # Start a thread to capture output
+            output_thread = threading.Thread(target=self._capture_output)
+            output_thread.daemon = True
+            output_thread.start()
+            
+            self._add_log(f"[INFO] Process started with PID: {self.process.pid}")
+            
+        except Exception as e:
+            self._add_log(f"[ERROR] Error starting ingestion process: {str(e)}")
+            self.is_completed = True
+    
+    def _simulate_ingestion_process(self) -> None:
+        """
+        Simulate the ingestion process for testing/development
+        This will be removed in production
+        """
+        # This method is just to simulate logs during development
+        # It will be removed in production
+        
+        threading.Thread(target=self._simulate_logs).start()
+    
+    def _simulate_logs(self) -> None:
+        """
+        Simulate logs for testing/development
+        This will be used when yourbench isn't installed or in development mode
+        """
+        # Log simulation (used when yourbench is not available)
+        self._add_log("[INFO] Simulation mode enabled (yourbench is not actually running)")
+        
+        # Get filenames from source directory
+        source_files = []
+        try:
+            with open(self.config_path, 'r') as f:
+                config_yaml = yaml.safe_load(f)
+                
+            source_dir = config_yaml.get("pipeline", {}).get("ingestion", {}).get("source_documents_dir", "")
+            if source_dir and os.path.exists(source_dir):
+                source_files = [f for f in os.listdir(source_dir) 
+                               if os.path.isfile(os.path.join(source_dir, f))]
+        except Exception:
+            source_files = ["document.pdf", "document.txt"]  # Fallback
+        
+        # Create output directory if it doesn't exist
+        output_dir = ""
+        try:
+            output_dir = config_yaml.get("pipeline", {}).get("ingestion", {}).get("output_dir", "")
+            if output_dir:
+                os.makedirs(output_dir, exist_ok=True)
+        except Exception:
+            pass
+            
+        # Simulate file processing
+        time.sleep(1)
+        self._add_log("[INFO] Initializing document ingestion")
+        time.sleep(1.5)
+        self._add_log("[INFO] Loading configuration parameters")
+        time.sleep(1)
+        self._add_log("[INFO] Verifying source files")
+        
+        # Process each file
+        for file in source_files:
+            time.sleep(1.5)
+            self._add_log(f"[INFO] Processing file: {file}")
+            time.sleep(2)
+            self._add_log(f"[INFO] Extracting content from {file}")
+            time.sleep(1.5)
+            self._add_log(f"[INFO] Converting to markdown: {file}")
+            
+            # Create a simulated markdown file if an output directory is defined
+            if output_dir:
+                base_name = os.path.splitext(file)[0]
+                output_file = os.path.join(output_dir, f"{base_name}.md")
+                try:
+                    with open(output_file, 'w') as f:
+                        f.write(f"# {base_name}\n\n")
+                        f.write("This is a markdown document automatically generated by the simulation.\n\n")
+                        f.write("## Section 1\n\n")
+                        f.write("Content of section 1...\n\n")
+                        f.write("## Section 2\n\n")
+                        f.write("Content of section 2...\n\n")
+                    self._add_log(f"[INFO] Markdown file created: {output_file}")
+                except Exception as e:
+                    self._add_log(f"[ERROR] Error creating markdown file: {str(e)}")
+        
+        time.sleep(2)
+        self._add_log("[INFO] Finalizing processing")
+        time.sleep(1)
+        self._add_log("[SUCCESS] Stage completed: ingestion")
+        time.sleep(0.5)
+        self._add_log("[SUCCESS] Ingestion completed successfully")
+        
+        # Mark task as completed
+        self.is_completed = True 

backend/tasks/createBenchConfigFile.py

@@ -0,0 +1,313 @@
+"""
+Task to create and save the configuration file
+"""
+import os
+import pathlib
+import uuid
+import yaml
+import shutil
+import time
+import threading
+from typing import Optional, Dict, Any, List, Tuple
+
+from loguru import logger
+from huggingface_hub import HfApi
+
+
+class CreateBenchConfigTask:
+    """
+    Task to create and save a configuration file for YourbenchSimpleDemo
+    """
+
+    def __init__(self, session_uid: Optional[str] = None):
+        """
+        Initialize the task with a session ID
+        
+        Args:
+            session_uid: Optional session ID, will be generated if None
+        """
+        self.session_uid = session_uid or str(uuid.uuid4())
+        self.logs: List[str] = []
+        self.is_completed = False
+        self.is_running_flag = threading.Event()
+        self.thread = None
+        self._add_log("[INFO] Initializing configuration creation task")
+    
+    def _add_log(self, message: str) -> None:
+        """
+        Add a log message to the logs list
+        
+        Args:
+            message: Log message to add
+        """
+        if message not in self.logs:  # Avoid duplicates
+            self.logs.append(message)
+            # Force a copy of the list to avoid reference issues
+            self.logs = self.logs.copy()
+            # Log to system logs
+            logger.info(f"[{self.session_uid}] {message}")
+    
+    def get_logs(self) -> List[str]:
+        """
+        Get all logs for this task
+        
+        Returns:
+            List of log messages
+        """
+        return self.logs.copy()  # Retourner une copie pour éviter les problèmes de référence
+    
+    def save_uploaded_file(self, file_path: str) -> str:
+        """
+        Process the uploaded file that is already in the correct directory
+        
+        Args:
+            file_path: Path to the uploaded file
+            
+        Returns:
+            Path to the file (same as input)
+        """
+        try:
+            # The file is already in the correct location: uploaded_files/{session_id}/uploaded_files/
+            # Just log that we're processing it and return the path
+            self._add_log(f"[INFO] Processing file: {os.path.basename(file_path)}")
+            return file_path
+        except Exception as e:
+            error_msg = f"Error processing file: {str(e)}"
+            self._add_log(f"[ERROR] {error_msg}")
+            raise RuntimeError(error_msg)
+    
+    def generate_base_config(self, hf_org: str, hf_dataset_name: str) -> Dict[str, Any]:
+        """
+        Create the base configuration dictionary
+        
+        Args:
+            hf_org: Hugging Face organization name
+            hf_dataset_name: Hugging Face dataset name
+            
+        Returns:
+            Configuration dictionary
+        """
+        self._add_log(f"[INFO] Generating base configuration for {hf_dataset_name}")
+        
+        # Check if HF token is available
+        hf_token = os.getenv("HF_TOKEN")
+        if not hf_token:
+            raise RuntimeError("HF_TOKEN environment variable is not defined")
+        
+        return {
+            "hf_configuration": {
+                "token": "$HF_TOKEN",  # Utiliser directement le token de l'environnement
+                "hf_organization": "$HF_ORGANIZATION",
+                "private": True,
+                "hf_dataset_name": hf_dataset_name,
+                "concat_if_exist": False,
+            },
+            "model_list": [
+                {
+                    "model_name": "Qwen/Qwen2.5-VL-72B-Instruct",
+                    "provider": "novita",
+                    "api_key": "$HF_TOKEN",
+                    "max_concurrent_requests": 32,
+                },
+                {
+                    "model_name": "Qwen/Qwen2.5-72B-Instruct",
+                    "provider": "novita",
+                    "api_key": "$HF_TOKEN",
+                    "max_concurrent_requests": 32,
+                },
+            ],
+            
+            "model_roles": {
+                "ingestion": ["Qwen/Qwen2.5-VL-72B-Instruct"],
+                "summarization": ["Qwen/Qwen2.5-72B-Instruct"],
+                "chunking": ["intfloat/multilingual-e5-large-instruct"],
+                "single_shot_question_generation": ["Qwen/Qwen2.5-72B-Instruct"],
+                "multi_hop_question_generation": ["Qwen/Qwen2.5-72B-Instruct"],
+            },
+            "pipeline": {
+                "ingestion": {
+                    "source_documents_dir": f"uploaded_files/{self.session_uid}/uploaded_files/",
+                    "output_dir": f"uploaded_files/{self.session_uid}/ingested",
+                    "run": True,
+                },
+                "upload_ingest_to_hub": {
+                    "source_documents_dir": f"uploaded_files/{self.session_uid}/ingested",
+                    "run": True,  # Réactivé pour l'upload sur le Hub
+                },
+                "summarization": {
+                    "run": True,
+                },
+                "chunking": {
+                    "run": True,
+                    "chunking_configuration": {
+                        "l_min_tokens": 64,
+                        "l_max_tokens": 128,
+                        "tau_threshold": 0.8,
+                        "h_min": 2,
+                        "h_max": 5,
+                        "num_multihops_factor": 2,
+                    },
+                },
+                "single_shot_question_generation": {
+                    "run": True,
+                    "additional_instructions": "Generate questions to test a curious adult",
+                    "chunk_sampling": {
+                        "mode": "count",
+                        "value": 5,
+                        "random_seed": 123,
+                    },
+                },
+                "multi_hop_question_generation": {
+                    "run": True,
+                    "additional_instructions": "Generate questions to test a curious adult",
+                    "chunk_sampling": {
+                        "mode": "percentage",
+                        "value": 0.3,
+                        "random_seed": 42,
+                    },
+                },
+                "lighteval": {
+                    "run": True,
+                },
+            },
+        }
+    
+    def save_yaml_file(self, config: Dict[str, Any], path: str) -> str:
+        """
+        Save the given configuration dictionary to a YAML file
+        
+        Args:
+            config: Configuration dictionary
+            path: Path to save the file
+            
+        Returns:
+            Path to the saved file
+        """
+        try:
+            # Create directory if it doesn't exist
+            os.makedirs(os.path.dirname(path), exist_ok=True)
+            
+            with open(path, "w") as file:
+                yaml.dump(config, file, default_flow_style=False, sort_keys=False)
+            
+            self._add_log(f"[INFO] Configuration saved: {path}")
+            return path
+        except Exception as e:
+            error_msg = f"Error saving configuration: {str(e)}"
+            self._add_log(f"[ERROR] {error_msg}")
+            raise RuntimeError(error_msg)
+    
+    def _run_task(self, file_path: str) -> str:
+        """
+        Internal method to run the task in a separate thread
+        
+        Args:
+            file_path: Path to the uploaded file
+            
+        Returns:
+            Path to the configuration file
+        """
+        try:
+            # Use the default yourbench organization
+            org_name = os.getenv("HF_ORGANIZATION")
+            
+            # Check if HF token is available
+            hf_token = os.getenv("HF_TOKEN")
+            if not hf_token:
+                raise RuntimeError("HF_TOKEN environment variable is not defined")
+            
+            self._add_log(f"[INFO] Organization: {org_name}")
+            
+            time.sleep(0.5)  # Simulate delay
+            
+            # Save the uploaded file
+            saved_file_path = self.save_uploaded_file(file_path)
+            
+            time.sleep(1)  # Simulate delay
+            
+            # Path for the config file
+            config_dir = pathlib.Path(f"uploaded_files/{self.session_uid}")
+            config_path = config_dir / "config.yml"
+            
+            # Generate dataset name based on session ID
+            dataset_name = f"yourbench_{self.session_uid}"
+            self._add_log(f"[INFO] Dataset name: {dataset_name}")
+            
+            time.sleep(0.8)  # Simulate delay
+            
+            # Generate and save the configuration
+            config = self.generate_base_config(org_name, dataset_name)
+            
+            time.sleep(1.2)  # Simulate delay
+            
+            config_file_path = self.save_yaml_file(config, str(config_path))
+            
+            self._add_log(f"[INFO] Configuration generated successfully: {config_file_path}")
+            
+            # Simulate additional processing
+            time.sleep(1.5)  # Simulate delay
+            self._add_log("[INFO] Starting ingestion")
+            
+            time.sleep(2)  # Simulate delay
+            self._add_log(f"[INFO] Processing file: {dataset_name}")
+            
+            time.sleep(2)  # Simulate delay
+            self._add_log("[SUCCESS] Stage completed: config_generation")
+            
+            # Tâche terminée
+            self.mark_task_completed()
+            
+            return str(config_path)
+        except Exception as e:
+            error_msg = f"Error generating configuration: {str(e)}"
+            self._add_log(f"[ERROR] {error_msg}")
+            self.mark_task_completed()
+            raise RuntimeError(error_msg)
+    
+    def run(self, file_path: str, token: Optional[str] = None) -> str:
+        """
+        Run the task to create and save the configuration file asynchronously
+        
+        Args:
+            file_path: Path to the uploaded file
+            token: Hugging Face token (not used, using HF_TOKEN from environment)
+            
+        Returns:
+            Path to the configuration file
+        """
+        # Mark the task as running
+        self.is_running_flag.set()
+        
+        # Start the task in a separate thread
+        self.thread = threading.Thread(target=self._run_task, args=(file_path,))
+        self.thread.daemon = True
+        self.thread.start()
+        
+        # Return the expected config path
+        return f"uploaded_files/{self.session_uid}/config.yml"
+    
+    def is_running(self) -> bool:
+        """
+        Check if the task is running
+        
+        Returns:
+            True if running, False otherwise
+        """
+        return self.is_running_flag.is_set() and not self.is_completed
+    
+    def is_task_completed(self) -> bool:
+        """
+        Check if the task is completed
+        
+        Returns:
+            True if completed, False otherwise
+        """
+        return self.is_completed
+    
+    def mark_task_completed(self) -> None:
+        """
+        Mark the task as completed
+        """
+        self.is_completed = True
+        self.is_running_flag.clear()
+        self._add_log("[INFO] Configuration generation task completed") 

backend/tasks/evaluationTask.py

@@ -0,0 +1,471 @@
+"""
+Task to evaluate models on a YourbBench dataset using LightEval
+"""
+import os
+import sys
+import json
+import time
+import tempfile
+import asyncio
+import threading
+from pathlib import Path
+from typing import Optional, List, Dict, Any, Tuple
+
+from loguru import logger
+from huggingface_hub import HfApi, CommitOperationAdd
+
+from tasks.yourbench_lighteval_task import create_yourbench_task
+
+
+class EvaluationTask:
+    """
+    Task to evaluate models using LightEval on a YourbBench dataset
+    """
+
+    def __init__(self, session_uid: str, dataset_name: str):
+        """
+        Initialize the evaluation task
+        
+        Args:
+            session_uid: Session ID for this task
+            dataset_name: Name of the dataset to evaluate
+        """
+        self.session_uid = session_uid
+        self.dataset_name = dataset_name
+        self.logs: List[str] = []
+        self.is_completed = False
+        self.organization = os.getenv("HF_ORGANIZATION", "yourbench")
+        self.results: Dict[str, Any] = {}
+        self.output_dir = f"uploaded_files/{session_uid}/lighteval_results"
+        
+        # Models to evaluate - can be modified to allow customization
+        self.models = [
+            ("Qwen/Qwen2.5-72B-Instruct", "novita"),
+            ("Qwen/QwQ-32B", "novita"),
+        ]
+        
+        self._add_log("[INFO] Initializing evaluation task")
+        self._add_log(f"[INFO] Dataset to evaluate: {self.organization}/{dataset_name}")
+        self._add_log(f"[INFO] Output directory: {self.output_dir}")
+    
+    def _add_log(self, message: str) -> None:
+        """
+        Add a log message to the logs list
+        
+        Args:
+            message: Log message to add
+        """
+        if message not in self.logs:  # Avoid duplicates
+            self.logs.append(message)
+            # Force copy of the list to avoid reference problems
+            self.logs = self.logs.copy()
+            # Record in system logs
+            logger.info(f"[{self.session_uid}] {message}")
+    
+    def get_logs(self) -> List[str]:
+        """
+        Get all logs for this task
+        
+        Returns:
+            List of log messages
+        """
+        return self.logs.copy()  # Retourner une copie pour éviter les problèmes de référence
+    
+    def is_task_completed(self) -> bool:
+        """
+        Check if the task is completed
+        
+        Returns:
+            True if completed, False otherwise
+        """
+        return self.is_completed
+    
+    async def _evaluate_model(self, model_info: Tuple[str, str]) -> Dict[str, Any]:
+        """
+        Evaluate a specific model
+        
+        Args:
+            model_info: Tuple of (model_name, provider)
+            
+        Returns:
+            Dictionary with evaluation results
+        """
+        model_name, provider = model_info
+        self._add_log(f"[INFO] Starting evaluation for {model_name} with {provider}")
+        
+        # Create output directory
+        os.makedirs(self.output_dir, exist_ok=True)
+        
+        # Define full dataset path
+        dataset_path = f"{self.organization}/{self.dataset_name}"
+        
+        # Create temporary file
+        temp_file_path = tempfile.mktemp(suffix=".py")
+        self._add_log(f"[INFO] Creating temporary file for {model_name}: {temp_file_path}")
+        
+        with open(temp_file_path, 'w') as temp_file:
+            temp_file.write(f"""
+import os
+import sys
+sys.path.append("{os.getcwd()}")
+
+from tasks.yourbench_lighteval_task import create_yourbench_task
+
+# Create yourbench task
+yourbench = create_yourbench_task("{dataset_path}", "lighteval")
+
+# Define TASKS_TABLE needed by lighteval
+TASKS_TABLE = [yourbench]
+""")
+        
+        # Build lighteval command args
+        cmd_args = [
+            "lighteval",
+            "endpoint", 
+            "inference-providers",
+            f"model={model_name},provider={provider}",
+            "custom|yourbench|0|0",
+            "--custom-tasks",
+            temp_file_path,
+            "--max-samples", "5",
+            "--output-dir", self.output_dir,
+            "--save-details",
+            "--no-push-to-hub"
+        ]
+        
+        self._add_log(f"[INFO] Running command for {model_name}: {' '.join(cmd_args)}")
+        
+        results = {
+            "model_name": model_name,
+            "provider": provider,
+            "success": False,
+            "error": None,
+            "results": None,
+            "return_code": None
+        }
+        
+        try:
+            # Prepare environment with needed tokens
+            env = os.environ.copy()
+            hf_token = os.getenv("HF_TOKEN")
+            if hf_token:
+                env["HF_TOKEN"] = hf_token
+                env["HUGGING_FACE_HUB_TOKEN"] = hf_token
+                env["HF_ORGANIZATION"] = self.organization
+            
+            # Run the process asynchronously
+            process = await asyncio.create_subprocess_exec(
+                *cmd_args,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                env=env
+            )
+            
+            # Wait for the process to complete
+            stdout, stderr = await process.communicate()
+            
+            # Store return code
+            exit_code = process.returncode
+            results["return_code"] = exit_code
+            
+            # Log output
+            if stdout:
+                stdout_lines = stdout.decode().strip().split('\n')
+                for line in stdout_lines[:5]:  # Log only first 5 lines
+                    self._add_log(f"[INFO] {model_name} - {line}")
+            
+            # Log errors if any
+            if stderr and exit_code != 0:
+                stderr_lines = stderr.decode().strip().split('\n')
+                for line in stderr_lines[:5]:  # Log only first 5 lines
+                    self._add_log(f"[ERROR] {model_name} - {line}")
+            
+            # Find any JSON result files - LightEval organizes by model name in different ways
+            result_files = []
+            results_dir = Path(self.output_dir) / "results"
+            if results_dir.exists():
+                # Parcourir récursivement tous les répertoires pour trouver des fichiers JSON
+                for json_file in results_dir.glob("**/*.json"):
+                    # Check if the filename or path contains parts of the model name
+                    model_parts = [
+                        model_name,  # Full name
+                        model_name.replace('/', '_'),  # Name with / replaced by _
+                        model_name.split('/')[-1]  # Just the model name without the organization
+                    ]
+                    
+                    if any(part in str(json_file) for part in model_parts):
+                        result_files.append(json_file)
+            
+            # Traiter les fichiers de résultats trouvés
+            if result_files:
+                # Prendre le fichier le plus récent
+                result_files.sort(key=lambda x: x.stat().st_mtime, reverse=True)
+                latest_result = result_files[0]
+                self._add_log(f"[INFO] {model_name} - Found result file: {latest_result}")
+                
+                try:
+                    with open(latest_result, 'r') as f:
+                        test_results = json.load(f)
+                        
+                    # Vérifier si les résultats contiennent les informations essentielles
+                    if (test_results and 
+                        isinstance(test_results, dict) and 
+                        "results" in test_results and 
+                        "all" in test_results["results"]):
+                        
+                        # Enregistrer les résultats
+                        results["results"] = test_results
+                        results["success"] = True
+                        
+                        # Afficher la précision
+                        accuracy = test_results["results"]["all"]["accuracy"]
+                        accuracy_stderr = test_results["results"]["all"]["accuracy_stderr"]
+                        self._add_log(f"[SUCCESS] {model_name} - Accuracy: {accuracy:.4f} ± {accuracy_stderr:.4f}")
+                    else:
+                        results["error"] = "Incomplete or unexpected result format"
+                        self._add_log(f"[WARNING] {model_name} - Unexpected result format")
+                
+                except (json.JSONDecodeError, KeyError) as e:
+                    results["error"] = f"Error reading results: {str(e)}"
+                    self._add_log(f"[ERROR] {model_name} - {results['error']}")
+            
+            # Si aucun résultat trouvé
+            if not results["success"]:
+                if exit_code == 0:
+                    results["error"] = "Execution completed without error but no results found"
+                    self._add_log(f"[WARNING] {model_name} - {results['error']}")
+                else:
+                    results["error"] = f"Execution error (code: {exit_code})"
+                    self._add_log(f"[ERROR] {model_name} - {results['error']}")
+        
+        except Exception as e:
+            results["error"] = f"Exception: {str(e)}"
+            self._add_log(f"[ERROR] Exception during evaluation of {model_name}: {str(e)}")
+        finally:
+            # Delete temporary file
+            try:
+                os.unlink(temp_file_path)
+            except:
+                pass
+        
+        return results
+    
+    async def _run_evaluations(self) -> List[Dict[str, Any]]:
+        """
+        Run evaluations for all models
+        
+        Returns:
+            List of evaluation results
+        """
+        self._add_log(f"[INFO] Starting evaluations for {len(self.models)} models")
+        
+        # Create tasks for each model
+        tasks = [self._evaluate_model(model) for model in self.models]
+        
+        # Run all tasks concurrently and gather results
+        model_results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        # Process results
+        results = []
+        for i, result in enumerate(model_results):
+            if isinstance(result, Exception):
+                # Handle exception
+                model_name, provider = self.models[i]
+                self._add_log(f"[ERROR] Evaluation failed for {model_name}: {str(result)}")
+                results.append({
+                    "model_name": model_name,
+                    "provider": provider,
+                    "success": False,
+                    "error": str(result),
+                    "results": None,
+                    "return_code": None
+                })
+            else:
+                # Valid result
+                results.append(result)
+        
+        return results
+    
+    def _format_comparison_results(self, results: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """
+        Format results for easy comparison between models
+        
+        Args:
+            results: List of evaluation results
+            
+        Returns:
+            Dictionary with formatted comparison results
+        """
+        comparison = {
+            "metadata": {
+                "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
+                "dataset": f"{self.organization}/{self.dataset_name}",
+                "total_models_tested": len(results),
+                "successful_tests": len([r for r in results if r["success"]])
+            },
+            "models_comparison": []
+        }
+        
+        # Liste des modèles réussis et des modèles échoués
+        successful_models = [r for r in results if r["success"]]
+        failed_models = [r for r in results if not r["success"]]
+        
+        # Trier les modèles réussis par précision (du plus précis au moins précis)
+        if successful_models:
+            sorted_successful = sorted(
+                successful_models,
+                key=lambda x: x["results"]["results"]["all"]["accuracy"],
+                reverse=True  # Du plus grand au plus petit
+            )
+        else:
+            sorted_successful = []
+            
+        # Trier les modèles échoués par nom
+        sorted_failed = sorted(failed_models, key=lambda x: x["model_name"])
+        
+        # Concaténer: d'abord les réussites, puis les échecs
+        sorted_results = sorted_successful + sorted_failed
+            
+        # Créer l'entrée pour chaque modèle
+        for result in sorted_results:
+            model_result = {
+                "model_name": result["model_name"],
+                "provider": result["provider"],
+                "success": result["success"]
+            }
+            
+            if result["success"]:
+                # Ajouter les métriques de précision et temps d'exécution
+                model_result.update({
+                    "accuracy": result["results"]["results"]["all"]["accuracy"],
+                    "accuracy_stderr": result["results"]["results"]["all"]["accuracy_stderr"],
+                    "evaluation_time": float(result["results"]["config_general"]["total_evaluation_time_secondes"])
+                })
+            else:
+                # Ajouter l'erreur
+                model_result["error"] = result.get("error", "Unknown reason")
+            
+            comparison["models_comparison"].append(model_result)
+        
+        return comparison
+    
+    async def _upload_results_to_dataset(self, comparison_results: Dict[str, Any]) -> bool:
+        """
+        Upload evaluation results to the HuggingFace dataset
+        
+        Args:
+            comparison_results: The formatted comparison results
+            
+        Returns:
+            bool: True if upload succeeded, False otherwise
+        """
+        try:
+            # Create a timestamp for the results file
+            timestamp = time.strftime("%Y%m%d_%H%M%S")
+            result_filename = f"lighteval_results.json"
+            
+            # Create temporary file for upload
+            temp_file_path = tempfile.mktemp(suffix=".json")
+            with open(temp_file_path, 'w') as f:
+                json.dump(comparison_results, f, indent=2)
+            
+            # Initialize HF API
+            hf_token = os.getenv("HF_TOKEN")
+            if not hf_token:
+                self._add_log("[ERROR] HF_TOKEN not found, cannot upload results to dataset")
+                return False
+            
+            api = HfApi(token=hf_token)
+            dataset_id = f"{self.organization}/{self.dataset_name}"
+            
+            # Prepare the file operation
+            operation = CommitOperationAdd(
+                path_in_repo=f"lighteval_results/{result_filename}",
+                path_or_fileobj=temp_file_path
+            )
+            
+            # Upload the file
+            self._add_log(f"[INFO] Uploading results to dataset {dataset_id}")
+            api.create_commit(
+                repo_id=dataset_id,
+                repo_type="dataset",
+                operations=[operation],
+                commit_message=f"Add evaluation results from {timestamp}"
+            )
+            
+            # Cleanup temporary file
+            os.unlink(temp_file_path)
+            
+            self._add_log(f"[SUCCESS] Results uploaded to dataset {dataset_id} at lighteval_results/{result_filename}")
+            return True
+            
+        except Exception as e:
+            self._add_log(f"[ERROR] Failed to upload results to dataset: {str(e)}")
+            return False
+    
+    async def _process_evaluation_results(self, results: List[Dict[str, Any]]) -> None:
+        """
+        Process evaluation results, create summaries and save files
+        
+        Args:
+            results: List of evaluation results
+        """
+        if results:
+            try:
+                # Save detailed results
+                detailed_output_file = f"{self.output_dir}/detailed_results.json"
+                os.makedirs(os.path.dirname(detailed_output_file), exist_ok=True)
+                with open(detailed_output_file, 'w') as f:
+                    json.dump(results, f, indent=2)
+                self._add_log(f"[INFO] Detailed results saved in {detailed_output_file}")
+                
+                # Generate and save comparison results
+                comparison = self._format_comparison_results(results)
+                comparison_file = f"{self.output_dir}/models_comparison.json"
+                with open(comparison_file, 'w') as f:
+                    json.dump(comparison, f, indent=2)
+                self._add_log(f"[INFO] Models comparison saved in {comparison_file}")
+                
+                # Upload results to the dataset
+                await self._upload_results_to_dataset(comparison)
+                
+                # Store results for later access
+                self.results = comparison
+                self._add_log("[SUCCESS] Evaluation completed")
+            except Exception as e:
+                self._add_log(f"[ERROR] Error during evaluation execution: {str(e)}")
+            finally:
+                self.is_completed = True
+    
+    def _async_run(self) -> None:
+        """
+        Run the evaluation asynchronously
+        """
+        async def run_async():
+            try:
+                # Run evaluations
+                results = await self._run_evaluations()
+                
+                # Process evaluation results
+                await self._process_evaluation_results(results)
+            except Exception as e:
+                self._add_log(f"[ERROR] Error during evaluation execution: {str(e)}")
+            finally:
+                self.is_completed = True
+        
+        # Create and run the asyncio event loop
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        loop.run_until_complete(run_async())
+        loop.close()
+    
+    def run(self) -> None:
+        """
+        Run the evaluation task in a separate thread
+        """
+        self._add_log("[INFO] Starting evaluation")
+        
+        # Run in a separate thread to not block the main thread
+        thread = threading.Thread(target=self._async_run)
+        thread.daemon = True
+        thread.start()

backend/tasks/yourbench_lighteval_task.py

@@ -0,0 +1,273 @@
+#!/usr/bin/env python3
+# MIT License
+
+# Copyright (c) 2024 The HuggingFace Team
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+import logging
+import re
+
+import numpy as np
+from aenum import extend_enum
+
+from lighteval.metrics.metrics import Metrics
+from lighteval.metrics.metrics_sample import JudgeLLM
+from lighteval.metrics.utils.metric_utils import (
+    CorpusLevelMetricGrouping,
+    MetricCategory,
+    MetricUseCase,
+)
+from lighteval.tasks.lighteval_task import LightevalTaskConfig
+from lighteval.tasks.requests import Doc
+
+
+logger = logging.getLogger(__name__)
+
+JUDGE_ANSWER_SYSTEM_PROMPT = """You will be provided with the summary of a document, a piece of text, a question generated from that text, and the correct or "gold" answer to the question. Additionally, you will receive a model answer. Your task is to determine wether the model answer is correct using the provided "gold" answer as a reference.
+# Steps
+1. **Document Understanding**:
+   - Analyze the provided document summary to grasp the context and main themes.
+2. **Chunk Understanding**:
+   - Examine the provided text (chunk) to understand its content.
+3. **Question Understanding**:
+   - Interpret the given question to fully comprehend what is being asked.
+4. **Ground Truth Answer Understanding**:
+   - Understand the provided ground truth answer, identifying its key points.
+6. **Answer Understanding**:
+   - Examine the Model Answer, identifying key points and assessing accuracy and factuality.
+7. **Final Answer**:
+   - 0 or 1 (0 if the model answer is incorrect, 1 if it is correct).
+# Output Format
+- Provide your final evaluation of whether the answer is correct within `<final_answer>` XML tags.
+- Include a detailed analysis for each part within the designated XML tags: `<document_understanding>`, `<chunk_understanding>`, `<question_understanding>`, `<ground_truth_answer_understanding>`, `<model_answer_understanding>`, and `<final_answer>`.
+# Examples
+**Input**:
+```xml
+<document_summary>
+[Summary]
+</document_summary>
+<piece_of_text>
+[Text]
+</piece_of_text>
+<question>
+[Question]
+</question>
+<gold_answer>
+[Gold Answer]
+</gold_answer>
+<model_answer>
+[Model Answer]
+</model_answer>
+```
+**Output**:
+```xml
+<document_understanding>
+Understanding of the summary including key themes
+</document_understanding>
+<chunk_understanding>
+Analysis of the piece of text
+</chunk_understanding>
+<question_understanding>
+Comprehension of the question being asked
+</question_understanding>
+<ground_truth_answer_understanding>
+Key points from the gold answer
+</ground_truth_answer_understanding>
+<model_answer_understanding>
+Key points and accuracy of Answer A
+</model_answer_understanding>
+<final_answer>
+1 or 0 (1 if the model answer is correct, 0 if it is incorrect)
+</final_answer>
+```
+# Notes
+- Always focus on key points and factual correctness as per the ground truth.
+- Avoid any biases and rely solely on the evidence presented.
+- Enclose all evaluations and analyses in the specified XML tags for clarity and structure."""
+
+
+JUDGE_ANSWER_USER_PROMPT = """<document_summary>
+{summary}
+</document_summary>
+<piece_of_text>
+{chunk}
+</piece_of_text>
+<question>
+{question}
+</question>
+<gold_answer>
+{oracle_answer}
+</gold_answer>
+<model_answer>
+{model_answer}
+</model_answer>"""
+
+
+def get_judge_prompt(question: str, answer: str, gold: str, **kwargs):
+    chunk = kwargs.get("chunks", "")
+    summary = kwargs.get("documents", "")
+
+    return [
+        {"role": "system", "content": JUDGE_ANSWER_SYSTEM_PROMPT},
+        {
+            "role": "user",
+            "content": JUDGE_ANSWER_USER_PROMPT.format(
+                summary=summary, chunk=chunk, question=question, oracle_answer=gold, model_answer=answer
+            ),
+        },
+    ]
+
+
+def process_judge_response_yourbench(response):
+    # extract the final answer using regex from the response xml
+    try:
+        # Essayer d'abord le format XML
+        match = re.search(r"<final_answer>(.*?)</final_answer>", response, re.DOTALL)
+        if match:
+            answer_text = match.group(1).strip()
+            # Convertir différents formats possibles en 0 ou 1
+            if answer_text in ["1", "correct", "true", "yes", "True", "TRUE"]:
+                return 1
+            elif answer_text in ["0", "incorrect", "false", "no", "False", "FALSE"]:
+                return 0
+            # Essayer de convertir directement en nombre
+            try:
+                value = int(answer_text)
+                return 1 if value > 0 else 0
+            except ValueError:
+                pass
+        
+        # Rechercher des mots-clés dans la réponse
+        if re.search(r"\b(correct|vrai|true|yes)\b", response, re.IGNORECASE):
+            return 1
+        if re.search(r"\b(incorrect|faux|false|no)\b", response, re.IGNORECASE):
+            return 0
+            
+        logger.warning(f"Réponse du juge non reconnue, retournant 0 par défaut: {response[:100]}...")
+    except Exception as e:
+        logger.error(f"Error processing judge response: {e}")
+    return 0
+
+
+class JudgeLLMYourBench(JudgeLLM):
+    def __init__(self):
+        super().__init__(
+            judge_model_name="gpt-4o-2024-08-06",
+            template=get_judge_prompt,
+            process_judge_response=process_judge_response_yourbench,
+            judge_backend="openai",
+            short_judge_name="yourbench_judge",
+        )
+
+    def compute(self, sample_ids: list[str], responses: list, formatted_docs: list[Doc]) -> list[dict[str, float]]:
+        # If we are evaluating a multiturn task, we need to have specific field in the formatted doc
+        questions = [formatted_doc.specific["question"] for formatted_doc in formatted_docs]
+        golds = [formatted_doc.get_golds()[0] for formatted_doc in formatted_docs]
+        predictions = [response[0].result[0] for response in responses]
+        options = [None] * len(questions)
+        chunks = [formatted_doc.specific["chunks"][0] for formatted_doc in formatted_docs]
+        documents = [formatted_doc.specific["document"] for formatted_doc in formatted_docs]
+
+        score, _, _ = self.judge.evaluate_answer_batch(
+            questions, predictions, options, golds, chunks=chunks, documents=documents
+        )
+
+        metrics = []
+        for i in range(len(sample_ids)):
+            metrics.append(
+                {
+                    "accuracy": score[i],
+                }
+            )
+
+        return metrics
+
+
+ZEROSHOT_QA_USER_PROMPT = """Answer the following question:
+<question>
+{question}
+</question>
+Enclose your full answer in <answer> XML tags. For example:
+<answer>
+[your answer here]
+</answer>"""
+
+
+def yourbench_prompt(line, task_name: str = ""):
+    return Doc(
+        task_name=task_name,
+        query=ZEROSHOT_QA_USER_PROMPT.format(question=line["question"]),
+        choices=[line["ground_truth_answer"]],
+        gold_index=0,
+        specific={
+            "question_category": line["question_category"],
+            "kind": line["kind"],
+            "estimated_difficulty": line["estimated_difficulty"],
+            "document_id": line["document_id"],
+            "question_generating_model": line["question_generating_model"],
+            "chunks": line["chunks"],
+            "question": line["question"],
+            "document": line["document"],
+        },
+    )
+
+
+def create_yourbench_task(hf_dataset_name, subset="lighteval_single_shot_questions"):
+    """
+    Crée une tâche personnalisée yourbench pour lighteval.
+    
+    Args:
+        hf_dataset_name: Nom du dataset sur le Hub HF (format: "org/nom")
+        subset: Nom du sous-ensemble à utiliser
+        
+    Returns:
+        LightevalTaskConfig: Configuration de la tâche yourbench
+    """
+    yourbench_metrics = CorpusLevelMetricGrouping(
+        metric_name=["accuracy"],
+        higher_is_better={"accuracy": True},
+        category=MetricCategory.LLM_AS_JUDGE,
+        use_case=MetricUseCase.ACCURACY,
+        sample_level_fn=JudgeLLMYourBench().compute,
+        corpus_level_fn={"accuracy": np.mean},
+    )
+    
+    try:
+        extend_enum(Metrics, "accuracy", yourbench_metrics)
+    except Exception:
+        # L'enum a peut-être déjà été ajouté, on ignore l'erreur
+        pass
+    
+    return LightevalTaskConfig(
+        name="yourbench",
+        suite=["custom"],
+        prompt_function=yourbench_prompt,
+        hf_repo=hf_dataset_name,
+        hf_subset=subset,
+        hf_avail_splits=["train"],
+        evaluation_splits=["train"],
+        few_shots_split=None,
+        few_shots_select=None,
+        generation_size=8192,
+        metric=[Metrics.accuracy],
+        stop_sequence=[],
+        trust_dataset=True,
+        version=0,
+    ) 

backend/tests/test_evaluation.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+"""
+Script to test the evaluation task in standalone mode
+"""
+import os
+import sys
+import uuid
+import json
+import time
+import argparse
+from dotenv import load_dotenv
+from pathlib import Path
+import traceback
+
+# Ensure the environment is properly configured
+load_dotenv()
+
+# Add the current directory to the path to import modules
+sys.path.append(os.getcwd())
+from tasks.evaluationTask import EvaluationTask
+
+
+def setup_environment():
+    """
+    Configure the environment for testing
+    """
+    # Check if the HF token is defined
+    hf_token = os.getenv("HF_TOKEN")
+    if not hf_token:
+        print("⚠️  The HF_TOKEN is not defined in the environment or .env file")
+        print("    Please define this variable before continuing.")
+        sys.exit(1)
+    
+    # Set the default organization if not defined
+    if not os.getenv("HF_ORGANIZATION"):
+        os.environ["HF_ORGANIZATION"] = "yourbench"
+        print("ℹ️  The HF_ORGANIZATION variable is not defined, using 'yourbench' as default")
+
+
+def run_standalone_evaluation(dataset_name, models=None, max_wait_time=3600):
+    """
+    Run the evaluation task in standalone mode
+    
+    Args:
+        dataset_name: Name of the dataset to evaluate
+        models: List of models to evaluate (optional)
+        max_wait_time: Maximum waiting time in seconds
+    """
+    # Generate a unique session ID
+    session_uid = str(uuid.uuid4())
+    print(f"🔧 Session ID: {session_uid}")
+    
+    # Create the evaluation task instance
+    evaluation_task = EvaluationTask(session_uid, dataset_name)
+    
+    # If specific models are provided, use them
+    if models:
+        evaluation_task.models = models
+        print(f"🤖 Using custom models: {models}")
+    
+    # Display dataset information
+    organization = os.getenv("HF_ORGANIZATION", "yourbench")
+    print(f"📊 Evaluating dataset: {organization}/{dataset_name}")
+    print(f"💾 Results saved in: {evaluation_task.output_dir}")
+    
+    # Start the evaluation task
+    print("🚀 Starting evaluation...")
+    evaluation_task.run()
+    
+    # Wait for the task to complete while displaying logs
+    start_time = time.time()
+    last_log_count = 0
+    
+    while not evaluation_task.is_task_completed():
+        current_logs = evaluation_task.get_logs()
+        
+        # Display only new logs
+        if len(current_logs) > last_log_count:
+            for log in current_logs[last_log_count:]:
+                print(f"  {log}")
+            last_log_count = len(current_logs)
+        
+        # Check if the maximum time is reached
+        elapsed_time = time.time() - start_time
+        if elapsed_time > max_wait_time:
+            print("⚠️  Maximum waiting time reached, forced stop")
+            break
+        
+        time.sleep(1)
+    
+    # Check if results are available
+    results_file = Path(f"{evaluation_task.output_dir}/models_comparison.json")
+    if results_file.exists():
+        try:
+            with open(results_file, 'r') as f:
+                results = json.load(f)
+            
+            print("\n📈 Evaluation Results:")
+            print(f"  Dataset: {results['metadata']['dataset']}")
+            print(f"  Models tested: {results['metadata']['total_models_tested']}")
+            print(f"  Successful tests: {results['metadata']['successful_tests']}")
+            print(f"  Timestamp: {results['metadata']['timestamp']}")
+            
+            if results['metadata']['successful_tests'] > 0:
+                print("\n📊 Model ranking by accuracy:")
+                successful_models = [m for m in results['models_comparison'] if m['success']]
+                for i, model in enumerate(successful_models):
+                    print(f"  {i+1}. ✅ {model['model_name']} ({model['provider']})")
+                    print(f"     Accuracy: {model['accuracy']:.4f} ± {model['accuracy_stderr']:.4f}")
+                    print(f"     Evaluation time: {model['evaluation_time']:.2f}s")
+            
+            failed_models = [m for m in results['models_comparison'] if not m['success']]
+            if failed_models:
+                print("\n❌ Unevaluated models:")
+                for i, model in enumerate(failed_models):
+                    print(f"  {i+1}. {model['model_name']} ({model['provider']})")
+                    error_msg = model.get('error', 'Unknown reason')
+                    print(f"     Reason: {error_msg}")
+            
+            # Check detailed results files
+            detailed_file = Path(f"{evaluation_task.output_dir}/detailed_results.json")
+            if detailed_file.exists():
+                print(f"\n📄 Detailed results available in: {detailed_file}")
+            
+            # Check raw files
+            raw_results = list(Path(f"{evaluation_task.output_dir}/results").glob("**/*.json"))
+            if raw_results:
+                print(f"\n📁 {len(raw_results)} raw result files available in: {evaluation_task.output_dir}/results")
+            
+            print(f"\n✅ Evaluation completed!")
+        except Exception as e:
+            print(f"❌ Error reading results: {str(e)}")
+            print(f"   Details: {traceback.format_exc()}")
+    else:
+        print(f"❌ No evaluation results found in {results_file}")
+
+
+if __name__ == "__main__":
+    # Configure the argument parser
+    parser = argparse.ArgumentParser(description="Test the evaluation task in standalone mode")
+    parser.add_argument("dataset_name", type=str, help="Name of the dataset to evaluate (without the organization)")
+    parser.add_argument("--model", action="append", dest="models", 
+                        help="Model to evaluate in the format 'name/model,provider'. Can be used multiple times.")
+    parser.add_argument("--timeout", type=int, default=3600, 
+                        help="Maximum waiting time in seconds (default: 3600)")
+    
+    args = parser.parse_args()
+    
+    # Configure the environment
+    setup_environment()
+    
+    # Transform models into tuples if specified
+    models_to_evaluate = None
+    if args.models:
+        models_to_evaluate = []
+        for model_spec in args.models:
+            try:
+                model_name, provider = model_spec.split(",")
+                models_to_evaluate.append((model_name, provider))
+            except ValueError:
+                print(f"⚠️  Invalid model format: {model_spec}. Use 'name/model,provider'")
+                sys.exit(1)
+    
+    # Run the evaluation
+    run_standalone_evaluation(args.dataset_name, models_to_evaluate, args.timeout)

backend/tests/test_hf_upload.py

@@ -0,0 +1,78 @@
+"""
+Script de test pour vérifier l'upload vers Hugging Face Hub
+Ce script crée un dataset simple et tente de l'uploader vers le Hub
+en utilisant le token et l'organisation définis dans les variables d'environnement.
+"""
+import os
+import sys
+import datasets
+from huggingface_hub import HfApi, login
+from datasets import Dataset
+from dotenv import load_dotenv
+from pathlib import Path
+
+def test_hf_upload():
+    # Charger les variables d'environnement depuis le fichier .env
+    dotenv_path = Path('.env')
+    load_dotenv(dotenv_path=dotenv_path)
+    
+    # Récupérer le token et l'organisation des variables d'environnement
+    hf_token = os.getenv("HF_TOKEN")
+    org_name = os.getenv("HF_ORGANIZATION", "yourbench")
+    
+    if not hf_token:
+        print("Erreur: La variable HF_TOKEN n'est pas définie dans le fichier .env.")
+        sys.exit(1)
+    
+    dataset_name = "test_dataset_upload"
+    repo_id = f"{org_name}/{dataset_name}"
+    
+    print(f"Tentative d'upload vers {repo_id} avec le token {hf_token[:5]}... (token tronqué pour la sécurité)")
+    
+    try:
+        # Se connecter à l'API Hugging Face
+        print("Connexion à l'API Hugging Face...")
+        login(token=hf_token)
+        api = HfApi(token=hf_token)
+        
+        # Créer un dataset simple
+        print("Création d'un dataset de test...")
+        data = {
+            "text": ["Ceci est un test", "Un autre exemple", "Troisième exemple"],
+            "label": [1, 0, 1]
+        }
+        dataset = Dataset.from_dict(data)
+        
+        # Vérifier si le repo existe déjà et le supprimer si nécessaire
+        try:
+            api.delete_repo(repo_id=repo_id, repo_type="dataset")
+            print(f"Repo existant {repo_id} supprimé.")
+        except Exception:
+            print(f"Le repo {repo_id} n'existait pas encore.")
+        
+        # Uploader le dataset
+        print(f"Upload du dataset vers {repo_id}...")
+        dataset.push_to_hub(
+            repo_id=repo_id,
+            token=hf_token,
+            private=True,
+            commit_message="Test d'upload de dataset"
+        )
+        
+        print(f"Succès! Dataset uploadé vers https://huggingface.co/datasets/{repo_id}")
+        return True
+    
+    except Exception as e:
+        print(f"Erreur lors de l'upload: {str(e)}")
+        print("\nTraceback complet:")
+        import traceback
+        traceback.print_exc()
+        return False
+
+if __name__ == "__main__":
+    print("=== Test d'upload vers Hugging Face Hub ===")
+    success = test_hf_upload()
+    if success:
+        print("\n✅ Le test a réussi! L'upload fonctionne correctement.")
+    else:
+        print("\n❌ Le test a échoué. Vérifiez les erreurs ci-dessus.")

backend/tests/test_inference.py

@@ -0,0 +1,84 @@
+import time
+import signal
+from huggingface_hub import InferenceClient
+
+# Configuration - Modèles et leurs providers
+MODELS = [
+    ("Qwen/Qwen2.5-72B-Instruct", "sambanova"),
+    ("meta-llama/Llama-3.3-70B-Instruct", "sambanova"),
+    ("deepseek-ai/DeepSeek-R1-Distill-Llama-70B", "sambanova"),
+    ("Qwen/QwQ-32B", "novita"),
+    # ("mistralai/Mistral-Small-24B-Instruct-2501", "novita")
+]
+QUESTION = "What is the capital of France?"
+TIMEOUT = 10  # secondes
+
+
+class TimeoutException(Exception):
+    pass
+
+
+def timeout_handler(signum, frame):
+    raise TimeoutException("Timeout")
+
+
+def test_model(model, provider):
+    client = InferenceClient(provider=provider)
+    
+    # Configure le timeout
+    signal.signal(signal.SIGALRM, timeout_handler)
+    signal.alarm(TIMEOUT)
+    
+    start_time = time.time()
+    try:
+        response = client.chat_completion(
+            model=model,
+            messages=[{"role": "user", "content": QUESTION}]
+        )
+        result = response.choices[0].message.content
+        success = True
+    except TimeoutException:
+        result = f"TIMEOUT ({TIMEOUT}s)"
+        success = False
+    except Exception as e:
+        result = str(e)
+        success = False
+    finally:
+        # Désactive l'alarme
+        signal.alarm(0)
+    
+    execution_time = time.time() - start_time
+    
+    status = "✅" if success else "❌"
+    print(f"{status} {model} ({provider}) - Temps: {execution_time:.2f}s")
+    if success:
+        print(f"  Réponse: {result[:80]}..." if len(result) > 80 else f"  Réponse: {result}")
+    else:
+        print(f"  Erreur: {result}")
+    
+    return success, execution_time, result
+
+
+def main():
+    print(f"\nTest de {len(MODELS)} modèles avec leurs providers spécifiques")
+    print(f"Question: {QUESTION}")
+    print(f"Timeout: {TIMEOUT}s\n")
+    
+    results = []
+    for model, provider in MODELS:
+        success, time_taken, response = test_model(model, provider)
+        results.append({
+            "model": model,
+            "provider": provider,
+            "success": success,
+            "time": time_taken
+        })
+    
+    print("\n=== RÉSUMÉ ===")
+    for result in results:
+        status = "✅" if result["success"] else "❌"
+        print(f"{status} {result['model']} ({result['provider']}): {result['time']:.2f}s")
+
+
+if __name__ == "__main__":
+    main()

backend/tests/test_lighteval.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+"""
+Script minimal pour tester directement lighteval avec la tâche yourbench
+"""
+import os
+import sys
+import subprocess
+import json
+import time
+from pathlib import Path
+import logging
+
+# Assurez-vous que l'environnement est correctement configuré
+from dotenv import load_dotenv
+load_dotenv()
+
+# Importer le module de définition de tâche yourbench
+sys.path.append(os.getcwd())
+from tasks.yourbench_lighteval_task import create_yourbench_task
+
+def run_lighteval_test():
+    """
+    Exécuter un test minimal avec lighteval
+    """
+    # Parameters
+    dataset_name = "yourbench_a"
+    organization = "yourbench"
+    model_name = "Qwen/Qwen2.5-72B-Instruct"
+    provider = "novita"
+    output_dir = f"uploaded_files/test_{provider}/lighteval_results"
+    
+    # Créer le répertoire de sortie
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Définir le chemin d'accès complet au dataset
+    dataset_path = f"{organization}/{dataset_name}"
+    print(f"Dataset à évaluer: {dataset_path}")
+    
+    # Créer un fichier temporaire
+    import tempfile
+    temp_file_path = tempfile.mktemp(suffix=".py")
+    print(f"Création du fichier temporaire: {temp_file_path}")
+    
+    with open(temp_file_path, 'w') as temp_file:
+        # Écrire le contenu du fichier
+        temp_file.write(f"""
+import os
+import sys
+import logging
+sys.path.append("{os.getcwd()}")
+
+from tasks.yourbench_lighteval_task import create_yourbench_task
+
+# Configurer le logging
+logging.basicConfig(level=logging.INFO)
+
+# Créer la tâche yourbench
+yourbench = create_yourbench_task("{dataset_path}", "lighteval")
+
+# Définir la variable TASKS_TABLE dont lighteval a besoin
+TASKS_TABLE = [yourbench]
+""")
+    
+    # Construire la commande lighteval
+    cmd = [
+        "lighteval",
+        "endpoint", 
+        "inference-providers",
+        f"model={model_name},provider={provider}",
+        "custom|yourbench|0|0",
+        "--custom-tasks",
+        temp_file_path,
+        "--max-samples", "5",  # Seulement 1 échantillon
+        "--output-dir", output_dir,
+        "--save-details",
+        "--no-push-to-hub"  # Pas de push pour gagner du temps
+    ]
+    
+    # Afficher la commande
+    print(f"Exécution de la commande: {' '.join(cmd)}")
+    print(f"Heure de début: {time.strftime('%H:%M:%S')}")
+    
+    # Exécuter la commande
+    try:
+        # Exécuter avec capture des sorties
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        
+        # Afficher les résultats
+        print(f"Code de retour: {result.returncode}")
+        print("--- SORTIE STANDARD ---")
+        print(result.stdout)
+        print("--- ERREUR STANDARD ---")
+        print(result.stderr)
+        
+        # Vérifier si des résultats ont été générés
+        results_dir = Path(output_dir) / "results"
+        if results_dir.exists():
+            print(f"Dossier de résultats créé: {results_dir}")
+            # Lister les fichiers de résultats
+            result_files = list(results_dir.glob("**/*.json"))
+            if result_files:
+                print(f"Fichiers de résultats trouvés: {result_files}")
+                # Trier les fichiers par date de modification pour prendre le plus récent
+                result_files.sort(key=lambda x: x.stat().st_mtime, reverse=True)
+                latest_result = result_files[0]
+                print(f"Fichier de résultats le plus récent: {latest_result}")
+                
+                # Lire le fichier de résultats
+                with open(latest_result, 'r') as f:
+                    results = json.load(f)
+                    print("Contenu du fichier de résultats:")
+                    print(json.dumps(results, indent=2))
+                    
+                    # Analyse des résultats
+                    print("\n==== ANALYSE DES RÉSULTATS ====")
+                    if "results" in results:
+                        for task_name, task_results in results["results"].items():
+                            print(f"Tâche: {task_name}")
+                            for metric_name, metric_value in task_results.items():
+                                print(f"  {metric_name}: {metric_value}")
+                    else:
+                        print("Aucun résultat trouvé dans le fichier JSON")
+                
+                # Vérifier les détails
+                details_dir = Path(output_dir) / "details"
+                if details_dir.exists():
+                    print(f"\nDossier de détails trouvé: {details_dir}")
+                    model_details_dirs = list(details_dir.glob("**/*"))
+                    if model_details_dirs:
+                        print(f"Dossiers de détails par modèle: {model_details_dirs}")
+            else:
+                print("Aucun fichier de résultats trouvé.")
+        else:
+            print(f"Aucun dossier de résultats créé.")
+    
+    except subprocess.CalledProcessError as e:
+        print(f"Erreur lors de l'exécution de la commande: {e}")
+    except Exception as e:
+        print(f"Exception: {e}")
+    finally:
+        # Supprimer le fichier temporaire
+        try:
+            os.unlink(temp_file_path)
+            print(f"Fichier temporaire supprimé: {temp_file_path}")
+        except:
+            pass
+    
+    print(f"Heure de fin: {time.strftime('%H:%M:%S')}")
+
+if __name__ == "__main__":
+    run_lighteval_test() 

backend/tests/test_openai.py

@@ -0,0 +1,31 @@
+import os
+from openai import OpenAI
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+def test_openai_connection():
+    try:
+        # Initialize OpenAI client
+        client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
+        
+        # Make a simple request
+        response = client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "user", "content": "Say 'Hello World'"}
+            ]
+        )
+        
+        print("✅ OpenAI API connection successful!")
+        print(f"Response: {response.choices[0].message.content}")
+        return True
+        
+    except Exception as e:
+        print("❌ OpenAI API connection failed!")
+        print(f"Error: {str(e)}")
+        return False
+
+if __name__ == "__main__":
+    test_openai_connection() 

backend/tests/test_parallel_lighteval.py

@@ -0,0 +1,278 @@
+#!/usr/bin/env python3
+"""
+Script to run lighteval tests in parallel for multiple models
+"""
+import os
+import sys
+import json
+import time
+import tempfile
+import asyncio
+from pathlib import Path
+from typing import Tuple, List, Dict, Any
+
+# Ensure environment is properly configured
+from dotenv import load_dotenv
+load_dotenv()
+
+# Import yourbench task module
+sys.path.append(os.getcwd())
+from tasks.yourbench_lighteval_task import create_yourbench_task
+
+# Define models to test
+INIT_MODELS = [
+    # 70B
+    ("Qwen/Qwen2.5-72B-Instruct", "novita"),
+    ("meta-llama/Llama-3.3-70B-Instruct", "novita"),
+    ("deepseek-ai/DeepSeek-R1-Distill-Llama-70B", "novita"),
+    # 20 to 30B
+    ("Qwen/QwQ-32B", "novita"),
+    # ("mistralai/Mistral-Small-24B-Instruct-2501", "sambanova"),
+]
+
+async def run_lighteval_test_for_model(model_info: Tuple[str, str]) -> Dict[str, Any]:
+    """
+    Run lighteval test for a specific model
+    """
+    model_name, provider = model_info
+    
+    # Parameters
+    dataset_name = "yourbench_a"
+    organization = "yourbench"
+    output_dir = f"uploaded_files/test_parallel_{provider}/lighteval_results"
+    
+    # Create output directory
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Define full dataset path
+    dataset_path = f"{organization}/{dataset_name}"
+    print(f"Dataset to evaluate for {model_name}: {dataset_path}")
+    
+    # Create temporary file
+    temp_file_path = tempfile.mktemp(suffix=".py")
+    print(f"Creating temporary file for {model_name}: {temp_file_path}")
+    
+    with open(temp_file_path, 'w') as temp_file:
+        temp_file.write(f"""
+import os
+import sys
+sys.path.append("{os.getcwd()}")
+
+from tasks.yourbench_lighteval_task import create_yourbench_task
+
+# Create yourbench task
+yourbench = create_yourbench_task("{dataset_path}", "lighteval")
+
+# Define TASKS_TABLE needed by lighteval
+TASKS_TABLE = [yourbench]
+""")
+    
+    # Build lighteval command args
+    cmd_args = [
+        "lighteval",
+        "endpoint", 
+        "inference-providers",
+        f"model={model_name},provider={provider}",
+        "custom|yourbench|0|0",
+        "--custom-tasks",
+        temp_file_path,
+        "--max-samples", "5",
+        "--output-dir", output_dir,
+        "--save-details",
+        "--no-push-to-hub"
+    ]
+    
+    print(f"Running command for {model_name}: {' '.join(cmd_args)}")
+    print(f"Start time for {model_name}: {time.strftime('%H:%M:%S')}")
+    
+    results = {
+        "model_name": model_name,
+        "provider": provider,
+        "success": False,
+        "error": None,
+        "results": None,
+        "return_code": None
+    }
+    
+    try:
+        # Prepare environment with needed tokens
+        env = os.environ.copy()
+        hf_token = os.getenv("HF_TOKEN")
+        if hf_token:
+            env["HF_TOKEN"] = hf_token
+            env["HUGGING_FACE_HUB_TOKEN"] = hf_token
+            env["HF_ORGANIZATION"] = organization
+        
+        # Run the process asynchronously
+        process = await asyncio.create_subprocess_exec(
+            *cmd_args,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            env=env
+        )
+        
+        # Wait for the process to complete
+        stdout, stderr = await process.communicate()
+        
+        # Store return code
+        exit_code = process.returncode
+        results["return_code"] = exit_code
+        
+        # Log some output for debugging
+        if stdout:
+            stdout_lines = stdout.decode().strip().split('\n')
+            if stdout_lines and len(stdout_lines) > 0:
+                print(f"Output from {model_name}: {stdout_lines[0]}")
+        
+        # Check if results were generated
+        results_dir = Path(output_dir) / "results"
+        if results_dir.exists():
+            result_files = list(results_dir.glob("**/*.json"))
+            if result_files:
+                # Read the first results file
+                with open(result_files[0], 'r') as f:
+                    test_results = json.load(f)
+                    results["results"] = test_results
+                    results["success"] = True
+    
+    except asyncio.CancelledError:
+        results["error"] = "Task cancelled"
+        print(f"Task cancelled for {model_name}")
+    except Exception as e:
+        results["error"] = f"Exception: {str(e)}"
+        print(f"Error running test for {model_name}: {str(e)}")
+    finally:
+        # Delete temporary file
+        try:
+            os.unlink(temp_file_path)
+        except:
+            pass
+    
+    print(f"End time for {model_name}: {time.strftime('%H:%M:%S')}")
+    return results
+
+async def run_parallel_tests(models: List[Tuple[str, str]]) -> List[Dict[str, Any]]:
+    """
+    Run tests in parallel for multiple models using asyncio
+    """
+    print(f"Starting parallel tests for {len(models)} models")
+    
+    # Create tasks for each model
+    tasks = [run_lighteval_test_for_model(model) for model in models]
+    
+    # Run all tasks concurrently and gather results
+    model_results = await asyncio.gather(*tasks, return_exceptions=True)
+    
+    # Process results
+    results = []
+    for i, result in enumerate(model_results):
+        if isinstance(result, Exception):
+            # Handle exception
+            model_name, provider = models[i]
+            print(f"Test failed for {model_name}: {str(result)}")
+            results.append({
+                "model_name": model_name,
+                "provider": provider,
+                "success": False,
+                "error": str(result),
+                "results": None,
+                "return_code": None
+            })
+        else:
+            # Valid result
+            results.append(result)
+            print(f"Test completed for {result['model_name']}")
+    
+    return results
+
+def format_comparison_results(results: List[Dict[str, Any]]) -> Dict[str, Any]:
+    """
+    Format results for easy comparison between models
+    """
+    comparison = {
+        "metadata": {
+            "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
+            "total_models_tested": len(results),
+            "successful_tests": len([r for r in results if r["success"]])
+        },
+        "models_comparison": []
+    }
+    
+    # Sort models by accuracy (if available) or name
+    sorted_results = sorted(
+        results,
+        key=lambda x: (
+            x["results"]["results"]["all"]["accuracy"] if x["success"] and x["results"] else -1,
+            x["model_name"]
+        ),
+        reverse=True
+    )
+    
+    for result in sorted_results:
+        model_result = {
+            "model_name": result["model_name"],
+            "provider": result["provider"],
+            "success": result["success"]
+        }
+        
+        if result["success"] and result["results"]:
+            model_result.update({
+                "accuracy": result["results"]["results"]["all"]["accuracy"],
+                "accuracy_stderr": result["results"]["results"]["all"]["accuracy_stderr"],
+                "evaluation_time": float(result["results"]["config_general"]["total_evaluation_time_secondes"])
+            })
+        else:
+            model_result["error"] = result["error"]
+        
+        comparison["models_comparison"].append(model_result)
+    
+    return comparison
+
+async def main_async():
+    """
+    Async main function to run parallel tests
+    """
+    print("Starting parallel lighteval tests")
+    start_time = time.time()
+    
+    # Run tests in parallel
+    results = await run_parallel_tests(INIT_MODELS)
+    
+    # Save detailed results
+    detailed_output_file = "parallel_test_detailed_results.json"
+    with open(detailed_output_file, 'w') as f:
+        json.dump(results, f, indent=2)
+    
+    # Generate and save comparison results
+    comparison = format_comparison_results(results)
+    comparison_file = "models_comparison.json"
+    with open(comparison_file, 'w') as f:
+        json.dump(comparison, f, indent=2)
+    
+    # Print summary
+    print("\nTest Summary:")
+    for model in comparison["models_comparison"]:
+        status = "✅" if model["success"] else "❌"
+        print(f"{status} {model['model_name']} ({model['provider']})")
+        if not model["success"]:
+            print(f"   Error: {model['error']}")
+        else:
+            print(f"   Accuracy: {model['accuracy']:.2%} (±{model['accuracy_stderr']:.2%})")
+            print(f"   Evaluation time: {model['evaluation_time']:.2f}s")
+    
+    duration = time.time() - start_time
+    print(f"\nTotal execution time: {duration:.2f} seconds")
+    print(f"Detailed results saved to: {detailed_output_file}")
+    print(f"Comparison results saved to: {comparison_file}")
+
+def main():
+    """
+    Main function to run parallel tests
+    """
+    # Create event loop and run the async main
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(main_async())
+    loop.close()
+
+if __name__ == "__main__":
+    main() 

backend/tests/test_provider_parallel_support.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+"""
+Script pour tester si un fournisseur d'API supporte réellement les requêtes parallèles
+"""
+import os
+import sys
+import time
+import asyncio
+import json
+from pathlib import Path
+from datetime import datetime
+
+# Ensure environment is properly configured
+from dotenv import load_dotenv
+load_dotenv()
+
+# Définir le modèle et le fournisseur à tester
+MODEL_NAME = "Qwen/QwQ-32B"
+PROVIDER = "novita"
+REQUEST_COUNT = 5  # Nombre de requêtes
+
+# Liste de questions
+PROMPTS = [
+    "Explain in detail how parallel computing has transformed modern data processing.",
+    "Describe the fundamental differences between CPU and GPU architectures.",
+    "Analyze the key challenges in distributed systems design.",
+    "Discuss the evolution of natural language processing from rule-based systems to modern transformer architectures.",
+    "Explain the concept of quantum computing and how it differs from classical computing paradigms."
+]
+
+async def send_request(prompt, request_id=None, show_logs=True):
+    """Envoie une requête au modèle et mesure le temps d'exécution"""
+    if show_logs and request_id is not None:
+        print(f"Démarrage requête {request_id} à {datetime.now().strftime('%H:%M:%S.%f')[:-3]}")
+    
+    start_time = time.time()
+    
+    cmd_args = [
+        "curl", "-s",
+        "-X", "POST",
+        f"https://api-inference.huggingface.co/models/{MODEL_NAME}",
+        "-H", f"Authorization: Bearer {os.environ.get('HF_TOKEN')}",
+        "-H", "Content-Type: application/json",
+        "-d", json.dumps({
+            "inputs": prompt, 
+            "parameters": {
+                "provider": PROVIDER,
+                "max_new_tokens": 20
+            }
+        })
+    ]
+    
+    process = await asyncio.create_subprocess_exec(
+        *cmd_args,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE
+    )
+    
+    stdout, stderr = await process.communicate()
+    
+    end_time = time.time()
+    duration = end_time - start_time
+    
+    response = stdout.decode("utf-8")
+    stderr_output = stderr.decode("utf-8")
+    
+    # Déterminer le succès
+    is_success = False
+    try:
+        response_json = json.loads(response)
+        is_success = process.returncode == 0 and isinstance(response_json, list) and "generated_text" in response_json[0]
+    except json.JSONDecodeError:
+        is_success = process.returncode == 0 and not ("error" in response.lower())
+    except Exception:
+        is_success = process.returncode == 0
+    
+    # Extraire message d'erreur si échec
+    error_message = None
+    if not is_success:
+        try:
+            if "error" in response.lower():
+                try:
+                    response_json = json.loads(response)
+                    if "error" in response_json:
+                        error_message = response_json["error"]
+                except:
+                    error_message = f"Erreur non-JSON: {response}"
+            elif stderr_output:
+                error_message = stderr_output
+            else:
+                error_message = f"Réponse: {response}"
+        except:
+            error_message = f"Erreur inconnue. Code: {process.returncode}"
+    
+    if show_logs and request_id is not None:
+        print(f"Fin requête {request_id} à {datetime.now().strftime('%H:%M:%S.%f')[:-3]} (durée: {duration:.2f}s)")
+        if not is_success:
+            print(f"ERREUR requête {request_id}: {error_message[:100]}..." if error_message and len(error_message) > 100 else error_message)
+    
+    return {
+        "request_id": request_id,
+        "prompt": prompt,
+        "start_time": start_time,
+        "end_time": end_time,
+        "duration": duration,
+        "success": is_success,
+        "response": response,
+        "error_message": error_message
+    }
+
+async def run_parallel_requests(prompts):
+    """Exécute les requêtes en parallèle"""
+    print(f"\n=== Test parallèle: {len(prompts)} requêtes pour {MODEL_NAME} ({PROVIDER}) ===")
+    print(f"Heure de début: {datetime.now().strftime('%H:%M:%S')}")
+    
+    # Synchroniser le démarrage des requêtes
+    start_event = asyncio.Event()
+    
+    async def synchronized_request(prompt, req_id):
+        await start_event.wait()
+        return await send_request(prompt, req_id)
+    
+    # Créer toutes les tâches
+    tasks = [asyncio.create_task(synchronized_request(prompts[i], i)) for i in range(len(prompts))]
+    
+    # Attendre que toutes les tâches soient prêtes
+    await asyncio.sleep(1)
+    
+    # Lancer toutes les requêtes en même temps
+    parallel_start_time = time.time()
+    print(f"Démarrage synchronisé à {datetime.now().strftime('%H:%M:%S.%f')[:-3]}")
+    start_event.set()
+    
+    # Attendre que toutes les tâches se terminent
+    results = await asyncio.gather(*tasks)
+    parallel_end_time = time.time()
+    parallel_duration = parallel_end_time - parallel_start_time
+    
+    print(f"Test parallèle terminé en {parallel_duration:.2f}s\n")
+    return results, parallel_duration
+
+async def run_sequential_requests(prompts):
+    """Exécute les mêmes requêtes séquentiellement"""
+    print(f"\n=== Test séquentiel: {len(prompts)} requêtes pour {MODEL_NAME} ({PROVIDER}) ===")
+    print(f"Heure de début: {datetime.now().strftime('%H:%M:%S')}")
+    
+    sequential_start_time = time.time()
+    results = []
+    
+    for i, prompt in enumerate(prompts):
+        print(f"Requête séquentielle {i}...")
+        result = await send_request(prompt, i)
+        results.append(result)
+    
+    sequential_end_time = time.time()
+    sequential_duration = sequential_end_time - sequential_start_time
+    
+    print(f"Test séquentiel terminé en {sequential_duration:.2f}s\n")
+    return results, sequential_duration
+
+async def run_tests():
+    """Exécute les tests parallèles puis séquentiels et compare les résultats"""
+    global_start = time.time()
+    prompts = PROMPTS[:REQUEST_COUNT]  # Utiliser le nombre de prompts spécifié
+    
+    # 1. Test parallèle
+    parallel_results, parallel_duration = await run_parallel_requests(prompts)
+    
+    # 2. Test séquentiel
+    sequential_results, sequential_duration = await run_sequential_requests(prompts)
+    
+    # 3. Analyser les résultats
+    global_end = time.time()
+    total_duration = global_end - global_start
+    
+    # Calculer les métriques
+    parallel_success = sum(1 for r in parallel_results if r["success"])
+    sequential_success = sum(1 for r in sequential_results if r["success"])
+    
+    # Calculer le facteur de parallélisme réel (temps séquentiel / temps parallèle)
+    if parallel_duration > 0:
+        parallelism_factor = sequential_duration / parallel_duration
+    else:
+        parallelism_factor = 0
+    
+    # Pourcentage d'amélioration
+    improvement_percent = (1 - (parallel_duration / sequential_duration)) * 100 if sequential_duration > 0 else 0
+    
+    # Afficher le résumé
+    print("\n====== RÉSUMÉ DES TESTS ======")
+    print(f"Modèle: {MODEL_NAME}, Provider: {PROVIDER}, Requêtes: {len(prompts)}")
+    print(f"\nDurée test parallèle:  {parallel_duration:.2f}s ({parallel_success}/{len(prompts)} réussies)")
+    print(f"Durée test séquentiel: {sequential_duration:.2f}s ({sequential_success}/{len(prompts)} réussies)")
+    print(f"Facteur de parallélisme: {parallelism_factor:.2f}x")
+    print(f"Amélioration: {improvement_percent:.1f}%")
+    
+    if parallelism_factor >= len(prompts) * 0.8:
+        conclusion = "EXCELLENT parallélisme (proche du théorique maximum)"
+    elif parallelism_factor >= 2:
+        conclusion = "BON parallélisme (significativement meilleur que séquentiel)"
+    elif parallelism_factor >= 1.3:
+        conclusion = "MOYEN parallélisme (légèrement meilleur que séquentiel)"
+    else:
+        conclusion = "FAIBLE ou PAS DE parallélisme (pas d'avantage significatif)"
+    
+    print(f"\nConclusion: {conclusion}")
+    
+    # Enregistrer les résultats
+    output_file = f"parallel_test_{PROVIDER}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+    with open(output_file, 'w') as f:
+        json.dump({
+            "model": MODEL_NAME,
+            "provider": PROVIDER,
+            "request_count": len(prompts),
+            "parallel_duration": parallel_duration,
+            "sequential_duration": sequential_duration,
+            "parallelism_factor": parallelism_factor,
+            "improvement_percent": improvement_percent,
+            "conclusion": conclusion,
+            "parallel_results": parallel_results,
+            "sequential_results": sequential_results
+        }, f, indent=2)
+    
+    print(f"\nRésultats détaillés sauvegardés dans {output_file}")
+
+if __name__ == "__main__":
+    asyncio.run(run_tests()) 

backend/tests/test_yourbench_results.py

@@ -0,0 +1,394 @@
+#!/usr/bin/env python3
+"""
+Script pour tester les résultats de Yourbench et vérifier les datasets sur le Hub Hugging Face.
+"""
+
+import os
+import sys
+import json
+import argparse
+import requests
+import tempfile
+from datetime import datetime
+from typing import Dict, List, Any, Optional, Tuple
+
+# Vérifier si les bibliothèques nécessaires sont installées
+try:
+    from dotenv import load_dotenv
+    from huggingface_hub import HfApi, DatasetInfo, ModelInfo
+    from loguru import logger
+    import pandas as pd
+except ImportError:
+    print("Installation des dépendances...")
+    import subprocess
+    subprocess.run(["pip", "install", "python-dotenv", "huggingface_hub", "loguru", "pandas", "pyarrow"], check=True)
+    from dotenv import load_dotenv
+    from huggingface_hub import HfApi, DatasetInfo, ModelInfo
+    from loguru import logger
+    import pandas as pd
+
+# Charger les variables d'environnement depuis .env
+load_dotenv()
+
+# Configuration de la journalisation
+logger.remove()
+logger.add(sys.stderr, format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | <level>{message}</level>")
+logger.add("yourbench_tests.log", rotation="10 MB", retention="1 week")
+
+def configure_argument_parser() -> argparse.ArgumentParser:
+    """Configure le parser d'arguments."""
+    parser = argparse.ArgumentParser(description="Tester les résultats de Yourbench et vérifier les datasets")
+    parser.add_argument("--dataset", type=str, help="Nom du dataset à vérifier (sans le nom de l'organisation)")
+    parser.add_argument("--org", type=str, default=os.environ.get("HF_ORGANIZATION", "yourbench"), 
+                        help="Organisation Hugging Face (défaut: valeur de HF_ORGANIZATION dans .env ou 'yourbench')")
+    parser.add_argument("--verbose", "-v", action="store_true", help="Afficher des informations détaillées")
+    return parser
+
+class YourbenchTester:
+    """Classe pour tester les résultats et datasets de Yourbench."""
+    
+    def __init__(self, organization: str, verbose: bool = False):
+        """Initialise le testeur Yourbench.
+        
+        Args:
+            organization: Nom de l'organisation sur Hugging Face
+            verbose: Afficher des informations détaillées
+        """
+        self.organization = organization
+        self.verbose = verbose
+        self.hf_token = os.environ.get("HF_TOKEN")
+        
+        if not self.hf_token:
+            logger.error("Variable d'environnement HF_TOKEN non trouvée dans le fichier .env")
+            sys.exit(1)
+        
+        self.api = HfApi(token=self.hf_token)
+        logger.info(f"Initialisation du testeur pour l'organisation: {organization}")
+    
+    def test_dataset_exists(self, dataset_name: str) -> Optional[DatasetInfo]:
+        """Vérifie si un dataset existe sur le Hub.
+        
+        Args:
+            dataset_name: Nom du dataset à vérifier
+            
+        Returns:
+            Informations sur le dataset s'il existe, None sinon
+        """
+        full_dataset_name = f"{self.organization}/{dataset_name}"
+        logger.info(f"Vérification de l'existence du dataset: {full_dataset_name}")
+        
+        try:
+            dataset_info = self.api.dataset_info(full_dataset_name)
+            logger.success(f"Dataset {full_dataset_name} trouvé!")
+            
+            if self.verbose:
+                logger.info(f"ID: {dataset_info.id}")
+                logger.info(f"Dernière modification: {dataset_info.lastModified}")
+                logger.info(f"SHA: {dataset_info.sha}")
+            
+            return dataset_info
+        
+        except Exception as e:
+            logger.error(f"Impossible de trouver le dataset {full_dataset_name}: {str(e)}")
+            return None
+    
+    def analyze_dataset_content(self, dataset_name: str) -> Tuple[bool, Dict[str, Any]]:
+        """Analyse le contenu d'un dataset.
+        
+        Args:
+            dataset_name: Nom du dataset à analyser
+            
+        Returns:
+            Tuple contenant un booléen indiquant si l'analyse a réussi et un dictionnaire de statistiques
+        """
+        full_dataset_name = f"{self.organization}/{dataset_name}"
+        logger.info(f"Analyse du contenu du dataset: {full_dataset_name}")
+        
+        stats = {
+            "fichiers": 0,
+            "taille_totale": 0,
+            "fichiers_json": 0,
+            "fichiers_parquet": 0,
+            "a_questions": False,
+            "nb_questions": 0,
+            "structure_parquet": {},
+            "types_documents": set()
+        }
+        
+        try:
+            # Lister les fichiers dans le dataset
+            files = self.api.list_repo_files(full_dataset_name, repo_type="dataset")
+            stats["fichiers"] = len(files)
+            
+            if self.verbose:
+                logger.info(f"Fichiers trouvés dans le dataset: {len(files)}")
+                for file in files[:10]:  # Limiter à 10 fichiers pour éviter un affichage trop verbeux
+                    logger.info(f"  - {file}")
+                if len(files) > 10:
+                    logger.info(f"  ... et {len(files) - 10} fichiers supplémentaires")
+            
+            # Vérifier la présence de fichiers questions
+            question_files = [f for f in files if "question" in f.lower() and f.endswith(".json")]
+            stats["fichiers_json"] = len([f for f in files if f.endswith(".json")])
+            
+            # Vérifier les fichiers Parquet qui sont utilisés par Yourbench
+            parquet_files = [f for f in files if f.endswith(".parquet")]
+            stats["fichiers_parquet"] = len(parquet_files)
+            
+            if parquet_files:
+                logger.info(f"Fichiers Parquet trouvés: {len(parquet_files)}")
+                
+                # Analyser un échantillon de fichiers Parquet
+                for parquet_file in parquet_files[:3]:  # Limiter à 3 fichiers pour l'analyse
+                    category = parquet_file.split('/')[0] if '/' in parquet_file else "unknown"
+                    
+                    logger.info(f"Analyse du fichier Parquet: {parquet_file} (catégorie: {category})")
+                    
+                    try:
+                        # Télécharger le fichier Parquet
+                        temp_file = self.api.hf_hub_download(
+                            repo_id=full_dataset_name,
+                            filename=parquet_file,
+                            repo_type="dataset"
+                        )
+                        
+                        # Lire le fichier Parquet avec pandas
+                        df = pd.read_parquet(temp_file)
+                        
+                        # Ajouter des statistiques
+                        stats["structure_parquet"][category] = {
+                            "colonnes": list(df.columns),
+                            "nb_lignes": len(df),
+                            "exemple": df.iloc[0].to_dict() if len(df) > 0 else {}
+                        }
+                        
+                        # Vérifier si ce fichier contient des questions
+                        if any(col for col in df.columns if "question" in col.lower()):
+                            stats["a_questions"] = True
+                            question_col = next(col for col in df.columns if "question" in col.lower())
+                            stats["nb_questions"] = len(df)
+                            
+                            # Récupérer un exemple de question
+                            if len(df) > 0 and question_col in df.columns:
+                                logger.info(f"Exemple de question: {df[question_col].iloc[0][:100]}...")
+                        
+                        # Identifier les types de documents si disponible
+                        if "doc_type" in df.columns and len(df) > 0:
+                            doc_types = df["doc_type"].unique()
+                            stats["types_documents"].update(doc_types)
+                        
+                    except Exception as e:
+                        logger.warning(f"Erreur lors de l'analyse du fichier {parquet_file}: {str(e)}")
+            
+            # Convertir le set en liste pour la sérialisation JSON
+            stats["types_documents"] = list(stats["types_documents"])
+            
+            if question_files:
+                stats["a_questions"] = True
+                
+                # Analyser un fichier de questions pour comprendre sa structure
+                sample_file = question_files[0]
+                content = self.api.hf_hub_download(
+                    repo_id=full_dataset_name,
+                    filename=sample_file,
+                    repo_type="dataset"
+                )
+                
+                with open(content, 'r') as f:
+                    data = json.load(f)
+                
+                if isinstance(data, list):
+                    stats["nb_questions"] = len(data)
+                elif isinstance(data, dict) and "questions" in data:
+                    stats["nb_questions"] = len(data["questions"])
+                
+                logger.success(f"Fichiers de questions trouvés: {len(question_files)}")
+                logger.info(f"Exemple de fichier analysé: {sample_file}")
+                logger.info(f"Nombre de questions trouvées: {stats['nb_questions']}")
+            
+            return True, stats
+        
+        except Exception as e:
+            logger.error(f"Erreur lors de l'analyse du dataset {full_dataset_name}: {str(e)}")
+            return False, stats
+    
+    def check_evaluation_results(self, dataset_name: str) -> bool:
+        """Vérifie s'il existe des résultats d'évaluation pour ce dataset.
+        
+        Args:
+            dataset_name: Nom du dataset à vérifier
+            
+        Returns:
+            True si des résultats d'évaluation existent, False sinon
+        """
+        logger.info(f"Recherche de résultats d'évaluation pour le dataset: {dataset_name}")
+        
+        try:
+            # Lister tous les datasets de l'organisation
+            datasets = self.api.list_datasets(author=self.organization)
+            
+            # Chercher les datasets d'évaluation
+            eval_datasets = [ds for ds in datasets if ds.id.startswith(f"{self.organization}/evaluation-")]
+            
+            if self.verbose:
+                logger.info(f"Datasets d'évaluation trouvés: {len(eval_datasets)}")
+                for ds in eval_datasets[:5]:
+                    logger.info(f"  - {ds.id}")
+            
+            # Vérifier si le dataset spécifié est mentionné dans les évaluations
+            for eval_ds in eval_datasets:
+                try:
+                    # Télécharger le README pour voir si le dataset est mentionné
+                    readme_path = self.api.hf_hub_download(
+                        repo_id=eval_ds.id,
+                        filename="README.md",
+                        repo_type="dataset"
+                    )
+                    
+                    with open(readme_path, 'r') as f:
+                        readme_content = f.read()
+                    
+                    if dataset_name in readme_content:
+                        logger.success(f"Résultats d'évaluation trouvés dans: {eval_ds.id}")
+                        return True
+                except:
+                    continue
+            
+            logger.warning(f"Aucun résultat d'évaluation trouvé pour le dataset: {dataset_name}")
+            return False
+        
+        except Exception as e:
+            logger.error(f"Erreur lors de la recherche de résultats d'évaluation: {str(e)}")
+            return False
+    
+    def check_model_performances(self, dataset_name: str) -> Dict[str, float]:
+        """Vérifie les performances des modèles sur le dataset spécifié.
+        
+        Args:
+            dataset_name: Nom du dataset à vérifier
+            
+        Returns:
+            Dictionnaire des performances des modèles (model_name -> score)
+        """
+        logger.info(f"Vérification des performances des modèles sur le dataset: {dataset_name}")
+        performances = {}
+        
+        try:
+            # Cette partie est spéculative car nous ne connaissons pas la structure exacte
+            # des résultats. Une approche possible serait de chercher des fichiers JSON 
+            # contenant des métriques dans les datasets d'évaluation.
+            
+            # Chercher les datasets d'évaluation
+            datasets = self.api.list_datasets(author=self.organization)
+            eval_datasets = [ds for ds in datasets if ds.id.startswith(f"{self.organization}/evaluation-")]
+            
+            for eval_ds in eval_datasets:
+                try:
+                    files = self.api.list_repo_files(eval_ds.id, repo_type="dataset")
+                    result_files = [f for f in files if "result" in f.lower() and f.endswith(".json")]
+                    
+                    for result_file in result_files:
+                        file_path = self.api.hf_hub_download(
+                            repo_id=eval_ds.id,
+                            filename=result_file,
+                            repo_type="dataset"
+                        )
+                        
+                        with open(file_path, 'r') as f:
+                            results = json.load(f)
+                        
+                        # Analyse basique des résultats (à adapter selon la structure réelle)
+                        if "model_name" in results and "metrics" in results:
+                            model_name = results["model_name"]
+                            metrics = results["metrics"]
+                            
+                            # Prendre la première métrique trouvée comme score
+                            if metrics and isinstance(metrics, dict):
+                                first_metric = list(metrics.keys())[0]
+                                performances[model_name] = metrics[first_metric]
+                except:
+                    continue
+            
+            if performances:
+                logger.success(f"Performances trouvées pour {len(performances)} modèles")
+                for model, score in performances.items():
+                    logger.info(f"  - {model}: {score}")
+            else:
+                logger.warning("Aucune performance de modèle trouvée")
+            
+            return performances
+        
+        except Exception as e:
+            logger.error(f"Erreur lors de la vérification des performances: {str(e)}")
+            return {}
+
+def main():
+    """Fonction principale."""
+    parser = configure_argument_parser()
+    args = parser.parse_args()
+    
+    if not args.dataset:
+        logger.error("Veuillez spécifier un dataset avec --dataset")
+        parser.print_help()
+        return
+    
+    # Créer le testeur
+    tester = YourbenchTester(args.org, args.verbose)
+    
+    # 1. Vérifier l'existence du dataset
+    dataset_info = tester.test_dataset_exists(args.dataset)
+    
+    if not dataset_info:
+        logger.error(f"Le dataset {args.org}/{args.dataset} n'existe pas ou n'est pas accessible")
+        return
+    
+    # 2. Analyser le contenu du dataset
+    success, stats = tester.analyze_dataset_content(args.dataset)
+    
+    if success:
+        logger.info("\n=== Statistiques du dataset ===")
+        logger.info(f"Nombre de fichiers: {stats['fichiers']}")
+        logger.info(f"Fichiers JSON: {stats['fichiers_json']}")
+        logger.info(f"Fichiers Parquet: {stats['fichiers_parquet']}")
+        logger.info(f"Contient des questions: {'Oui' if stats['a_questions'] else 'Non'}")
+        
+        if stats['a_questions']:
+            logger.info(f"Nombre de questions: {stats['nb_questions']}")
+            
+        if 'types_documents' in stats and stats['types_documents']:
+            logger.info(f"Types de documents: {', '.join(stats['types_documents'])}")
+            
+        # Afficher la structure des fichiers Parquet
+        if 'structure_parquet' in stats and stats['structure_parquet']:
+            logger.info("\n=== Structure des fichiers Parquet ===")
+            for category, info in stats['structure_parquet'].items():
+                logger.info(f"\nCatégorie: {category}")
+                logger.info(f"Nombre de lignes: {info['nb_lignes']}")
+                logger.info(f"Colonnes: {', '.join(info['colonnes'])}")
+                
+                if args.verbose and 'exemple' in info and info['exemple']:
+                    logger.info("\nExemple de ligne:")
+                    for key, value in info['exemple'].items():
+                        # Tronquer les valeurs trop longues
+                        if isinstance(value, str) and len(value) > 100:
+                            value = value[:100] + "..."
+                        logger.info(f"  {key}: {value}")
+    
+    # 3. Vérifier s'il existe des résultats d'évaluation
+    has_evaluations = tester.check_evaluation_results(args.dataset)
+    
+    if has_evaluations:
+        # 4. Vérifier les performances des modèles
+        performances = tester.check_model_performances(args.dataset)
+        
+        if performances:
+            logger.info("\n=== Classement des modèles ===")
+            # Trier les modèles par score (du plus élevé au plus bas)
+            sorted_models = sorted(performances.items(), key=lambda x: x[1], reverse=True)
+            for i, (model, score) in enumerate(sorted_models, 1):
+                logger.info(f"{i}. {model}: {score:.4f}")
+    
+    logger.success("Test terminé !")
+
+if __name__ == "__main__":
+    main() 

docker-compose.yml

@@ -0,0 +1,33 @@
+services:
+  backend:
+    build:
+      context: ./backend
+      dockerfile: Dockerfile.dev
+      args:
+        - HF_TOKEN=${HF_TOKEN}
+    ports:
+      - "${BACKEND_PORT:-8000}:8000"
+    volumes:
+      - ./backend:/app
+    environment:
+      - ENVIRONMENT=${ENVIRONMENT:-development}
+      - HF_TOKEN=${HF_TOKEN}
+      - HF_HOME=${HF_HOME:-/.cache}
+    command: uvicorn app.asgi:app --host 0.0.0.0 --port 8000 --reload
+
+  frontend:
+    build:
+      context: ./frontend
+      dockerfile: Dockerfile.dev
+    ports:
+      - "${FRONTEND_PORT:-7860}:7860"
+    volumes:
+      - ./frontend:/app
+      - /app/node_modules
+    environment:
+      - NODE_ENV=${ENVIRONMENT:-development}
+      - CHOKIDAR_USEPOLLING=true
+      - PORT=${FRONTEND_PORT:-7860}
+    command: npm start
+    stdin_open: true
+    tty: true

frontend/Dockerfile.dev

@@ -0,0 +1,15 @@
+FROM node:18
+
+WORKDIR /app
+
+# Install required global dependencies
+RUN npm install -g react-scripts
+
+# Copy package.json and package-lock.json
+COPY package*.json ./
+
+# Install project dependencies
+RUN npm install
+
+# Volume will be mounted here, no need for COPY
+CMD ["npm", "start"]

frontend/README.md

@@ -0,0 +1,80 @@
+# Frontend - Open LLM Leaderboard 🏆
+
+React interface for exploring and comparing open-source language models.
+
+## 🏗 Architecture
+
+```mermaid
+flowchart TD
+    Client(["User Browser"]) --> Components["React Components"]
+
+    subgraph Frontend
+        Components --> Context["Context Layer<br>• LeaderboardContext<br>• Global State"]
+
+        API["API Layer<br>• /api/leaderboard/formatted<br>• TanStack Query"] --> |Data Feed| Context
+
+        Context --> Hooks["Hooks Layer<br>• Data Processing<br>• Filtering<br>• Caching"]
+
+        Hooks --> Features["Features<br>• Table Management<br>• Search & Filters<br>• Display Options"]
+        Features --> Cache["Cache Layer<br>• LocalStorage<br>• URL State"]
+    end
+
+    API --> Backend["Backend Server"]
+
+    style Backend fill:#f96,stroke:#333,stroke-width:2px
+```
+
+## ✨ Core Features
+
+- 🔍 **Search & Filters**: Real-time filtering, regex search, advanced filters
+- 📊 **Data Visualization**: Interactive table, customizable columns, sorting
+- 🔄 **State Management**: URL sync, client-side caching (5min TTL)
+- 📱 **Responsive Design**: Mobile-friendly, dark/light themes
+
+## 🛠 Tech Stack
+
+- React 18 + Material-UI
+- TanStack Query & Table
+- React Router v6
+
+## 📁 Project Structure
+
+```
+src/
+├── pages/
+│   └── LeaderboardPage/
+│       ├── components/      # UI Components
+│       ├── context/        # Global State
+│       └── hooks/          # Data Processing
+├── components/             # Shared Components
+└── utils/                 # Helper Functions
+```
+
+## 🚀 Development
+
+```bash
+# Install dependencies
+npm install
+
+# Start development server
+npm start
+
+# Production build
+npm run build
+```
+
+## 🔧 Environment Variables
+
+```env
+# API Configuration
+REACT_APP_API_URL=http://localhost:8000
+REACT_APP_CACHE_DURATION=300000  # 5 minutes
+```
+
+## 🔄 Data Flow
+
+1. API fetches leaderboard data from backend
+2. Context stores and manages global state
+3. Hooks handle data processing and filtering
+4. Components render based on processed data
+5. Cache maintains user preferences and URL state

frontend/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "open-llm-leaderboard",
+  "version": "0.1.0",
+  "private": true,
+  "dependencies": {
+    "@emotion/react": "^11.13.3",
+    "@emotion/styled": "^11.13.0",
+    "@huggingface/hub": "^0.14.0",
+    "@mui/icons-material": "^6.1.7",
+    "@mui/lab": "^6.0.0-beta.16",
+    "@mui/material": "^6.1.6",
+    "@mui/x-data-grid": "^7.22.2",
+    "@tanstack/react-query": "^5.62.2",
+    "@tanstack/react-table": "^8.20.5",
+    "@tanstack/react-virtual": "^3.10.9",
+    "@testing-library/jest-dom": "^5.17.0",
+    "@testing-library/react": "^13.4.0",
+    "@testing-library/user-event": "^13.5.0",
+    "compression": "^1.7.4",
+    "cors": "^2.8.5",
+    "express": "^4.18.2",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-router-dom": "^6.28.0",
+    "react-scripts": "5.0.1",
+    "serve-static": "^1.15.0",
+    "web-vitals": "^2.1.4"
+  },
+  "scripts": {
+    "start": "react-scripts start",
+    "build": "react-scripts build",
+    "test": "react-scripts test",
+    "eject": "react-scripts eject",
+    "serve": "node server.js"
+  },
+  "eslintConfig": {
+    "extends": [
+      "react-app",
+      "react-app/jest"
+    ]
+  },
+  "browserslist": {
+    "production": [
+      ">0.2%",
+      "not dead",
+      "not op_mini all"
+    ],
+    "development": [
+      "last 1 chrome version",
+      "last 1 firefox version",
+      "last 1 safari version"
+    ]
+  },
+  "proxy": "http://backend:8000"
+}

frontend/public/index.html

@@ -0,0 +1,96 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <link rel="icon" href="%PUBLIC_URL%/logo32.png" />
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no, viewport-fit=cover"
+    />
+    <meta
+      name="description"
+      content="Interactive leaderboard tracking and comparing open-source Large Language Models across multiple benchmarks: IFEval, BBH, MATH, GPQA, MUSR, and MMLU-PRO."
+    />
+
+    <!-- Open Graph / Facebook -->
+    <meta property="og:type" content="website" />
+    <meta
+      property="og:url"
+      content="https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard"
+    />
+    <meta
+      property="og:title"
+      content="Open LLM Leaderboard - Compare Open Source Large Language Models"
+    />
+    <meta
+      property="og:description"
+      content="Interactive leaderboard for comparing LLM performance across multiple benchmarks. Features real-time filtering, community voting, and comprehensive model analysis with benchmarks like IFEval, BBH, MATH, GPQA, MUSR, and MMLU-PRO."
+    />
+    <meta property="og:image" content="%PUBLIC_URL%/og-image.png" />
+
+    <!-- Twitter -->
+    <meta property="twitter:card" content="summary_large_image" />
+    <meta
+      property="twitter:url"
+      content="https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard"
+    />
+    <meta
+      property="twitter:title"
+      content="Open LLM Leaderboard - Compare Open Source Large Language Models"
+    />
+    <meta
+      property="twitter:description"
+      content="Interactive leaderboard for comparing LLM performance across multiple benchmarks. Features real-time filtering, community voting, and comprehensive model analysis with benchmarks like IFEval, BBH, MATH, GPQA, MUSR, and MMLU-PRO."
+    />
+    <meta property="twitter:image" content="%PUBLIC_URL%/og-image.png" />
+    <!--
+      Notice the use of %PUBLIC_URL% in the tags above.
+      It will be replaced with the URL of the `public` folder during the build.
+      Only files inside the `public` folder can be referenced from the HTML.
+
+      Unlike "/favicon.ico" or "favicon.ico", "%PUBLIC_URL%/favicon.ico" will
+      work correctly both with client-side routing and a non-root public URL.
+      Learn how to configure a non-root public URL by running `npm run build`.
+    -->
+    <title>
+      Open LLM Leaderboard - Compare Open Source Large Language Models
+    </title>
+    <link
+      href="https://fonts.googleapis.com/css2?family=Source+Sans+Pro:wght@400;600;700&display=swap"
+      rel="stylesheet"
+    />
+    <style>
+      html,
+      body {
+        position: fixed;
+        width: 100%;
+        height: 100%;
+        overflow: hidden;
+        -webkit-overflow-scrolling: touch;
+      }
+      #root {
+        position: absolute;
+        top: 0;
+        left: 0;
+        right: 0;
+        bottom: 0;
+        overflow-y: auto;
+        -webkit-overflow-scrolling: touch;
+      }
+    </style>
+  </head>
+  <body>
+    <noscript>You need to enable JavaScript to run this app.</noscript>
+    <div id="root"></div>
+    <!--
+      This HTML file is a template.
+      If you open it directly in the browser, you will see an empty page.
+
+      You can add webfonts, meta tags, or analytics to this file.
+      The build step will place the bundled scripts into the <body> tag.
+
+      To begin the development, run `npm start` or `yarn start`.
+      To create a production bundle, use `npm run build` or `yarn build`.
+    -->
+  </body>
+</html>

frontend/public/robots.txt

@@ -0,0 +1,3 @@
+# https://www.robotstxt.org/robotstxt.html
+User-agent: *
+Disallow:

frontend/server.js

@@ -0,0 +1,85 @@
+const express = require("express");
+const cors = require("cors");
+const compression = require("compression");
+const path = require("path");
+const serveStatic = require("serve-static");
+const { createProxyMiddleware } = require("http-proxy-middleware");
+
+const app = express();
+const port = process.env.PORT || 7860;
+const apiPort = process.env.INTERNAL_API_PORT || 7861;
+
+// Enable CORS for all routes
+app.use(cors());
+
+// Enable GZIP compression
+app.use(compression());
+
+// Proxy all API requests to the Python backend
+app.use(
+  "/api",
+  createProxyMiddleware({
+    target: `http://127.0.0.1:${apiPort}`,
+    changeOrigin: true,
+    onError: (err, req, res) => {
+      console.error("Proxy Error:", err);
+      res.status(500).json({ error: "Proxy Error", details: err.message });
+    },
+  })
+);
+
+// Serve static files from the build directory
+app.use(
+  express.static(path.join(__dirname, "build"), {
+    // Don't cache HTML files
+    setHeaders: (res, path) => {
+      if (path.endsWith(".html")) {
+        res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
+        res.setHeader("Pragma", "no-cache");
+        res.setHeader("Expires", "0");
+      } else {
+        // Cache other static resources for 1 year
+        res.setHeader("Cache-Control", "public, max-age=31536000");
+      }
+    },
+  })
+);
+
+// Middleware to preserve URL parameters
+app.use((req, res, next) => {
+  // Don't interfere with API requests
+  if (req.url.startsWith("/api")) {
+    return next();
+  }
+
+  // Preserve original URL parameters
+  req.originalUrl = req.url;
+  next();
+});
+
+// Handle all other routes by serving index.html
+app.get("*", (req, res) => {
+  // Don't interfere with API requests
+  if (req.url.startsWith("/api")) {
+    return next();
+  }
+
+  // Headers for client-side routing
+  res.set({
+    "Cache-Control": "no-cache, no-store, must-revalidate",
+    Pragma: "no-cache",
+    Expires: "0",
+  });
+
+  // Send index.html for all other routes
+  res.sendFile(path.join(__dirname, "build", "index.html"));
+});
+
+app.listen(port, "0.0.0.0", () => {
+  console.log(
+    `Frontend server is running on port ${port} in ${
+      process.env.NODE_ENV || "development"
+    } mode`
+  );
+  console.log(`API proxy target: http://127.0.0.1:${apiPort}`);
+});

frontend/src/App.js

@@ -0,0 +1,427 @@
+import React, { useState, useEffect } from "react";
+import {
+  Box,
+  Container,
+  CssBaseline,
+  Typography,
+  CircularProgress,
+} from "@mui/material";
+import {
+  BrowserRouter as Router,
+  Routes,
+  Route,
+  Navigate,
+  useNavigate,
+  useSearchParams,
+} from "react-router-dom";
+import getTheme from "./config/theme";
+import { useThemeMode } from "./hooks/useThemeMode";
+import { ThemeProvider } from "@mui/material/styles";
+import BenchmarkGenerator from "./components/BenchmarkGenerator";
+import BenchmarkCreateForm from "./components/BenchmarkCreateForm";
+import BenchmarkDisplay from "./components/BenchmarkDisplay";
+import BenchmarkEvaluation from "./components/BenchmarkEvaluation";
+import EvaluationDisplay from "./components/EvaluationDisplay";
+
+// Composant d'en-tête commun
+const Header = () => (
+  <Box sx={{ textAlign: "center", mb: 8 }}>
+    <h1>Yourbench Demo</h1>
+    <p>
+      Quickly create <b>zero-shot benchmarks</b> from your documents – keeping
+      models accurate and adaptable
+    </p>
+  </Box>
+);
+
+// Page d'accueil avec le formulaire
+function HomePage() {
+  const navigate = useNavigate();
+
+  const handleStartGeneration = (sid) => {
+    navigate(`/benchmark-generation?session=${sid}`);
+  };
+
+  return (
+    <>
+      <Header />
+      <BenchmarkCreateForm onStartGeneration={handleStartGeneration} />
+    </>
+  );
+}
+
+// Page de génération de benchmark
+function BenchmarkGenerationPage() {
+  const navigate = useNavigate();
+  const [searchParams] = useSearchParams();
+  const sessionId = searchParams.get("session");
+  const [isValidSession, setIsValidSession] = useState(true);
+
+  // Vérifier la validité de la session
+  useEffect(() => {
+    if (!sessionId) {
+      setIsValidSession(false);
+    }
+  }, [sessionId]);
+
+  const handleGenerationComplete = (result) => {
+    console.log("Benchmark generation completed:", result);
+    if (result && result.success) {
+      navigate(`/benchmark-display?session=${sessionId}`);
+    }
+  };
+
+  if (!isValidSession) {
+    return <Navigate to="/" />;
+  }
+
+  return (
+    <>
+      <Header />
+      <BenchmarkGenerator
+        sessionId={sessionId}
+        onComplete={handleGenerationComplete}
+      />
+    </>
+  );
+}
+
+// Page d'affichage du benchmark
+function BenchmarkDisplayPage() {
+  const navigate = useNavigate();
+  const [searchParams] = useSearchParams();
+  const sessionId = searchParams.get("session");
+  const [benchmarkQuestions, setBenchmarkQuestions] = useState([]);
+  const [datasetUrl, setDatasetUrl] = useState(null);
+  const [isValidSession, setIsValidSession] = useState(true);
+  const [isLoading, setIsLoading] = useState(true);
+
+  // Récupérer les questions du benchmark depuis l'API
+  useEffect(() => {
+    console.log("BenchmarkDisplayPage useEffect - sessionId:", sessionId);
+
+    if (!sessionId) {
+      console.log("Session ID manquante, redirection vers l'accueil");
+      setIsValidSession(false);
+      return;
+    }
+
+    setIsLoading(true);
+
+    const fetchBenchmarkQuestions = async () => {
+      console.log(
+        "Tentative de récupération des questions pour la session:",
+        sessionId
+      );
+      try {
+        const apiUrl = `http://localhost:3001/benchmark-questions/${sessionId}`;
+        console.log("Appel API:", apiUrl);
+
+        const response = await fetch(apiUrl);
+        console.log("Réponse API reçue:", response.status);
+
+        // Check if the response status is 404 (Not Found) or other error
+        if (!response.ok) {
+          if (response.status === 404) {
+            console.error("Session non trouvée");
+            setIsValidSession(false);
+            return;
+          } else {
+            console.error(`Erreur serveur: ${response.status}`);
+            setIsLoading(false);
+            return;
+          }
+        }
+
+        const data = await response.json();
+        console.log("Données API:", data);
+
+        if (data.success && data.questions && data.questions.length > 0) {
+          console.log("Questions chargées avec succès:", data.questions);
+          setBenchmarkQuestions(data.questions);
+        } else {
+          console.warn(
+            "Échec du chargement des questions, utilisation des valeurs par défaut"
+          );
+        }
+
+        if (data.dataset_url) {
+          setDatasetUrl(data.dataset_url);
+        } else {
+          const url = `https://huggingface.co/datasets/yourbench/yourbench_${sessionId}`;
+          setDatasetUrl(url);
+          console.log("URL du dataset générée:", url);
+        }
+      } catch (error) {
+        console.error("Erreur lors de la récupération des questions:", error);
+        setIsValidSession(false);
+      } finally {
+        setIsLoading(false);
+      }
+    };
+
+    fetchBenchmarkQuestions();
+  }, [sessionId]);
+
+  const handleStartEvaluation = () => {
+    console.log("Starting evaluation with session ID:", sessionId);
+    navigate(`/benchmark-evaluation?session=${sessionId}`);
+  };
+
+  // Questions par défaut si l'API échoue
+  const defaultSampleQuestions = [
+    {
+      id: 1,
+      question: "What are the key features discussed in the document?",
+      type: "single_shot",
+    },
+    {
+      id: 2,
+      question:
+        "How does the proposed solution address the challenges mentioned in section 2 in relation to the overall market trends?",
+      type: "multi_hop",
+    },
+  ];
+
+  if (!isValidSession) {
+    return <Navigate to="/" />;
+  }
+
+  return (
+    <>
+      <Header />
+      {isLoading ? (
+        <Box
+          sx={{
+            display: "flex",
+            justifyContent: "center",
+            alignItems: "center",
+            mt: 8,
+            mb: 8,
+          }}
+        >
+          <CircularProgress size={60} />
+        </Box>
+      ) : (
+        <BenchmarkDisplay
+          onStartEvaluation={handleStartEvaluation}
+          sessionId={sessionId}
+          datasetUrl={datasetUrl}
+          sampleQuestions={
+            benchmarkQuestions.length > 0
+              ? benchmarkQuestions
+              : defaultSampleQuestions
+          }
+        />
+      )}
+    </>
+  );
+}
+
+// Page d'évaluation du benchmark
+function BenchmarkEvaluationPage() {
+  const navigate = useNavigate();
+  const [searchParams] = useSearchParams();
+  const sessionId = searchParams.get("session");
+  const [isValidSession, setIsValidSession] = useState(true);
+  const [isLoading, setIsLoading] = useState(true);
+
+  // Vérifier la validité de la session
+  useEffect(() => {
+    if (!sessionId) {
+      console.log(
+        "Session ID manquante pour l'évaluation, redirection vers l'accueil"
+      );
+      setIsValidSession(false);
+      return;
+    }
+
+    // Verify session exists by calling the API
+    const checkSession = async () => {
+      try {
+        const response = await fetch(
+          `http://localhost:3001/benchmark-questions/${sessionId}`
+        );
+
+        if (!response.ok) {
+          console.error(
+            `Session invalide ou erreur serveur: ${response.status}`
+          );
+          setIsValidSession(false);
+        }
+      } catch (error) {
+        console.error("Erreur lors de la vérification de la session:", error);
+        setIsValidSession(false);
+      } finally {
+        setIsLoading(false);
+      }
+    };
+
+    checkSession();
+  }, [sessionId]);
+
+  const handleEvaluationComplete = (result) => {
+    console.log("Évaluation terminée:", result);
+    // On reste sur la même page car les résultats sont affichés directement
+    // dans le composant BenchmarkEvaluation
+  };
+
+  if (!isValidSession) {
+    return <Navigate to="/" />;
+  }
+
+  return (
+    <>
+      <Header />
+      {isLoading ? (
+        <Box
+          sx={{
+            display: "flex",
+            justifyContent: "center",
+            alignItems: "center",
+            mt: 8,
+            mb: 8,
+          }}
+        >
+          <CircularProgress size={60} />
+        </Box>
+      ) : (
+        <BenchmarkEvaluation
+          sessionId={sessionId}
+          onComplete={handleEvaluationComplete}
+        />
+      )}
+    </>
+  );
+}
+
+// Page d'affichage des résultats d'évaluation
+function EvaluationDisplayPage() {
+  const navigate = useNavigate();
+  const [searchParams] = useSearchParams();
+  const sessionId = searchParams.get("session");
+  const [isValidSession, setIsValidSession] = useState(true);
+  const [isLoading, setIsLoading] = useState(true);
+
+  // Vérifier la validité de la session
+  useEffect(() => {
+    if (!sessionId) {
+      console.log(
+        "Session ID manquante pour l'affichage des résultats, redirection vers l'accueil"
+      );
+      setIsValidSession(false);
+      return;
+    }
+
+    // Verify session exists by calling the API
+    const checkSession = async () => {
+      try {
+        const response = await fetch(
+          `http://localhost:3001/benchmark-questions/${sessionId}`
+        );
+
+        if (!response.ok) {
+          console.error(
+            `Session invalide ou erreur serveur: ${response.status}`
+          );
+          setIsValidSession(false);
+        }
+      } catch (error) {
+        console.error("Erreur lors de la vérification de la session:", error);
+        setIsValidSession(false);
+      } finally {
+        setIsLoading(false);
+      }
+    };
+
+    checkSession();
+  }, [sessionId]);
+
+  if (!isValidSession) {
+    return <Navigate to="/" />;
+  }
+
+  return (
+    <>
+      <Header />
+      {isLoading ? (
+        <Box
+          sx={{
+            display: "flex",
+            justifyContent: "center",
+            alignItems: "center",
+            mt: 8,
+            mb: 8,
+          }}
+        >
+          <CircularProgress size={60} />
+        </Box>
+      ) : (
+        <EvaluationDisplay sessionId={sessionId} />
+      )}
+    </>
+  );
+}
+
+// Raccourcis clavier
+function KeyboardShortcuts() {
+  useEffect(() => {
+    const handleKeyDown = (e) => {
+      if (e.key === "p") {
+        console.log("Debug key pressed: Clearing auth data and refreshing");
+        localStorage.removeItem("hf_oauth");
+        localStorage.removeItem("auth_return_to");
+        alert("Auth data cleared. Page will reload.");
+        window.location.reload();
+      }
+    };
+
+    window.addEventListener("keydown", handleKeyDown);
+    return () => {
+      window.removeEventListener("keydown", handleKeyDown);
+    };
+  }, []);
+
+  return null;
+}
+
+// Composant principal avec les routes
+function App() {
+  const { mode } = useThemeMode();
+  const theme = getTheme(mode);
+
+  return (
+    <ThemeProvider theme={theme}>
+      <CssBaseline />
+      <Router>
+        <Container maxWidth="md">
+          <Box sx={{ pt: 12, pb: 4 }}>
+            <KeyboardShortcuts />
+            <Routes>
+              <Route path="/" element={<HomePage />} />
+              <Route
+                path="/benchmark-generation"
+                element={<BenchmarkGenerationPage />}
+              />
+              <Route
+                path="/benchmark-display"
+                element={<BenchmarkDisplayPage />}
+              />
+              <Route
+                path="/benchmark-evaluation"
+                element={<BenchmarkEvaluationPage />}
+              />
+              <Route
+                path="/evaluation-display"
+                element={<EvaluationDisplayPage />}
+              />
+              <Route path="*" element={<Navigate to="/" replace />} />
+            </Routes>
+          </Box>
+        </Container>
+      </Router>
+    </ThemeProvider>
+  );
+}
+
+export default App;

frontend/src/components/BenchmarkCreateForm.jsx

@@ -0,0 +1,295 @@
+import React, { useState, useRef, useEffect } from "react";
+import {
+  Box,
+  Paper,
+  Typography,
+  CircularProgress,
+  Alert,
+  Button,
+  Stepper,
+  Step,
+  StepLabel,
+} from "@mui/material";
+import { useLocation } from "react-router-dom";
+import CloudUploadIcon from "@mui/icons-material/CloudUpload";
+import PlayArrowIcon from "@mui/icons-material/PlayArrow";
+import AuthContainer from "./shared/AuthContainer";
+import { useThemeMode } from "../hooks/useThemeMode";
+import getTheme from "../config/theme";
+
+/**
+ * Component to display a stepper with three steps: Login, Upload File, and Generate
+ *
+ * @param {Object} props - Component props
+ * @param {number} props.activeStep - Current active step (0-based index)
+ * @returns {JSX.Element} Stepper component
+ */
+const StepsDisplay = ({ activeStep }) => {
+  const steps = ["Login", "Upload File", "Generate"];
+
+  return (
+    <Box sx={{ width: "100%", mb: 4 }}>
+      <Stepper activeStep={activeStep} alternativeLabel>
+        {steps.map((label) => (
+          <Step key={label}>
+            <StepLabel>{label}</StepLabel>
+          </Step>
+        ))}
+      </Stepper>
+    </Box>
+  );
+};
+
+/**
+ * Component for creating a new benchmark, including authentication, file upload, and generation initiation
+ *
+ * @param {Object} props - Component props
+ * @param {Function} props.onStartGeneration - Callback when generation starts with sessionId
+ * @returns {JSX.Element} BenchmarkCreateForm component
+ */
+function BenchmarkCreateForm({ onStartGeneration }) {
+  const { mode } = useThemeMode();
+  const theme = getTheme(mode);
+  const [isDragging, setIsDragging] = useState(false);
+  const [uploadStatus, setUploadStatus] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [activeStep, setActiveStep] = useState(0);
+  const [sessionId, setSessionId] = useState(null);
+  const fileInputRef = useRef(null);
+  const location = useLocation();
+
+  // Check if we're coming back from an OAuth redirect
+  useEffect(() => {
+    // If we have code in URL parameters, it's an OAuth callback
+    const params = new URLSearchParams(window.location.search);
+    if (params.has("code")) {
+      console.log("Detected OAuth callback, cleaning URL");
+
+      // Remove the query parameters from the URL without reloading
+      window.history.replaceState({}, document.title, window.location.pathname);
+
+      // Check if we have auth data in localStorage after a brief delay to let OAuth process complete
+      setTimeout(() => {
+        const storedAuth = localStorage.getItem("hf_oauth");
+        if (storedAuth) {
+          console.log("Found auth data after redirect, refreshing UI state");
+          setActiveStep(1); // Move to next step if authenticated
+        }
+      }, 1000);
+    }
+  }, [location]);
+
+  const handleDragOver = (e) => {
+    e.preventDefault();
+    setIsDragging(true);
+  };
+
+  const handleDragLeave = () => {
+    setIsDragging(false);
+  };
+
+  const handleClick = () => {
+    fileInputRef.current.click();
+  };
+
+  const handleFileChange = (e) => {
+    const file = e.target.files[0];
+    if (!file) return;
+
+    // Vérifier si c'est un PDF, TXT, HTML ou MD
+    if (
+      !file.name.endsWith(".pdf") &&
+      !file.name.endsWith(".txt") &&
+      !file.name.endsWith(".html") &&
+      !file.name.endsWith(".md")
+    ) {
+      setUploadStatus({
+        success: false,
+        message: "Only PDF, TXT, HTML and MD files are accepted",
+      });
+      return;
+    }
+
+    handleFileUpload(file);
+  };
+
+  const handleFileUpload = async (file) => {
+    setIsLoading(true);
+    setUploadStatus(null);
+
+    try {
+      const formData = new FormData();
+      formData.append("file", file);
+
+      const response = await fetch("http://localhost:3001/upload", {
+        method: "POST",
+        body: formData,
+      });
+
+      const result = await response.json();
+
+      if (response.ok) {
+        setUploadStatus({
+          success: true,
+          message: `File ${result.filename} uploaded successfully`,
+        });
+        // Store the session ID for the benchmark generation
+        setSessionId(result.session_id);
+        setActiveStep(2); // Advance to Generate step after successful upload
+      } else {
+        setUploadStatus({
+          success: false,
+          message: result.error || "Upload failed",
+        });
+      }
+    } catch (error) {
+      setUploadStatus({
+        success: false,
+        message: "Server connection error",
+      });
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const handleDrop = async (e) => {
+    e.preventDefault();
+    setIsDragging(false);
+
+    const file = e.dataTransfer.files[0];
+    if (!file) {
+      setUploadStatus({ success: false, message: "No file detected" });
+      return;
+    }
+
+    // Vérifier si c'est un PDF, TXT, HTML ou MD
+    if (
+      !file.name.endsWith(".pdf") &&
+      !file.name.endsWith(".txt") &&
+      !file.name.endsWith(".html") &&
+      !file.name.endsWith(".md")
+    ) {
+      setUploadStatus({
+        success: false,
+        message: "Only PDF, TXT, HTML and MD files are accepted",
+      });
+      return;
+    }
+
+    handleFileUpload(file);
+  };
+
+  const handleGenerateClick = () => {
+    if (onStartGeneration && sessionId) {
+      onStartGeneration(sessionId);
+    }
+  };
+
+  return (
+    <>
+      <StepsDisplay activeStep={activeStep} />
+
+      {/* Authentication step */}
+      {activeStep === 0 && (
+        <AuthContainer
+          actionText="use this demo"
+          onSuccess={() => setActiveStep(1)}
+        />
+      )}
+
+      {/* File upload step */}
+      {activeStep === 1 && (
+        <Paper
+          elevation={3}
+          sx={{
+            p: 4,
+            mt: 3,
+            mb: 3,
+            border: isDragging
+              ? `2px dashed ${theme.palette.primary.main}`
+              : "2px dashed #ccc",
+            backgroundColor: isDragging ? "rgba(0, 0, 0, 0.05)" : "transparent",
+            display: "flex",
+            flexDirection: "column",
+            alignItems: "center",
+            justifyContent: "center",
+            minHeight: 200,
+            cursor: "pointer",
+            transition: "all 0.3s ease",
+          }}
+          onDragOver={handleDragOver}
+          onDragLeave={handleDragLeave}
+          onDrop={handleDrop}
+          onClick={handleClick}
+        >
+          <input
+            type="file"
+            ref={fileInputRef}
+            onChange={handleFileChange}
+            accept=".pdf,.txt,.html,.md"
+            style={{ display: "none" }}
+          />
+          <CloudUploadIcon
+            sx={{ fontSize: 60, color: "text.secondary", mb: 1 }}
+          />
+          <Typography variant="h6" component="div" gutterBottom>
+            Drag and drop your file here or click to browse
+          </Typography>
+          <Typography variant="body2" color="text.secondary">
+            Accepted formats: PDF, TXT, HTML, MD
+          </Typography>
+
+          {isLoading && (
+            <Box sx={{ mt: 2 }}>
+              <CircularProgress size={30} />
+            </Box>
+          )}
+
+          {uploadStatus && (
+            <Alert
+              severity={uploadStatus.success ? "success" : "error"}
+              sx={{ mt: 2, width: "100%" }}
+            >
+              {uploadStatus.message}
+            </Alert>
+          )}
+        </Paper>
+      )}
+
+      {/* Generate button step */}
+      {activeStep === 2 && (
+        <Paper
+          elevation={3}
+          sx={{
+            p: 4,
+            mt: 3,
+            mb: 3,
+            display: "flex",
+            flexDirection: "column",
+            alignItems: "center",
+            justifyContent: "center",
+            minHeight: 200,
+          }}
+        >
+          <PlayArrowIcon
+            sx={{ fontSize: 60, color: "text.secondary", mb: 1 }}
+          />
+          <Typography variant="h6" component="div" gutterBottom>
+            Ready to generate your benchmark
+          </Typography>
+          <Button
+            variant="contained"
+            color="primary"
+            onClick={handleGenerateClick}
+            sx={{ mt: 2 }}
+            startIcon={<PlayArrowIcon />}
+          >
+            Generate Benchmark
+          </Button>
+        </Paper>
+      )}
+    </>
+  );
+}
+
+export default BenchmarkCreateForm;

frontend/src/components/BenchmarkDisplay.jsx

@@ -0,0 +1,161 @@
+import React, { useState } from "react";
+import {
+  Box,
+  Typography,
+  Paper,
+  Button,
+  Divider,
+  Card,
+  CardContent,
+  Link,
+  CircularProgress,
+  Tooltip,
+} from "@mui/material";
+import PlayArrowIcon from "@mui/icons-material/PlayArrow";
+import AssessmentIcon from "@mui/icons-material/Assessment";
+import LinkIcon from "@mui/icons-material/Link";
+import DownloadIcon from "@mui/icons-material/Download";
+import CheckCircleIcon from "@mui/icons-material/CheckCircle";
+
+/**
+ * Component to display benchmark information and evaluation button
+ *
+ * @param {Object} props - Component props
+ * @param {Array} props.sampleQuestions - Array of sample questions to display
+ * @param {Function} props.onStartEvaluation - Function to call when evaluation button is clicked
+ * @param {string} props.sessionId - Session ID used for the benchmark generation
+ * @param {string} props.datasetUrl - URL to the Hugging Face dataset
+ * @returns {JSX.Element} Benchmark display component
+ */
+const BenchmarkDisplay = ({
+  sampleQuestions = [],
+  onStartEvaluation,
+  sessionId,
+  datasetUrl,
+}) => {
+  const [isDownloading, setIsDownloading] = useState(false);
+
+  // Default questions if none provided
+  const questions =
+    sampleQuestions.length > 0
+      ? sampleQuestions
+      : [
+          {
+            id: 1,
+            question: "What are the key benefits of the described technology?",
+            type: "single_shot",
+          },
+          {
+            id: 2,
+            question:
+              "Based on the context about machine learning frameworks, how does TensorFlow compare to PyTorch in terms of deployment capabilities?",
+            type: "multi_hop",
+          },
+        ];
+
+  const handleEvaluationClick = () => {
+    if (onStartEvaluation) {
+      onStartEvaluation();
+    }
+  };
+
+  const handleDownloadClick = async () => {
+    if (!sessionId) return;
+
+    setIsDownloading(true);
+    try {
+      // Requête pour télécharger le dataset
+      const downloadUrl = `http://localhost:3001/download-dataset/${sessionId}`;
+
+      // Créer un élément a temporaire pour déclencher le téléchargement
+      const link = document.createElement("a");
+      link.href = downloadUrl;
+      link.setAttribute("download", `yourbench_${sessionId}_dataset.zip`);
+      document.body.appendChild(link);
+      link.click();
+      document.body.removeChild(link);
+    } catch (error) {
+      console.error("Erreur lors du téléchargement du dataset:", error);
+      alert("Erreur lors du téléchargement. Veuillez réessayer.");
+    } finally {
+      setIsDownloading(false);
+    }
+  };
+
+  return (
+    <Box sx={{ width: "100%", mt: 3 }}>
+      {/* Header avec titre et bouton de téléchargement alignés */}
+      <Box
+        sx={{
+          mb: 4,
+          display: "flex",
+          justifyContent: "space-between",
+          alignItems: "center",
+        }}
+      >
+        <Box sx={{ display: "flex", alignItems: "center" }}>
+          <CheckCircleIcon color="success" sx={{ mr: 1.5, fontSize: 28 }} />
+          <Typography variant="h6">Benchmark Created Successfully</Typography>
+        </Box>
+
+        <Tooltip title="Télécharger le benchmark complet">
+          <Button
+            variant="contained"
+            color="primary"
+            endIcon={
+              isDownloading ? <CircularProgress size={16} /> : <DownloadIcon />
+            }
+            onClick={handleDownloadClick}
+            disabled={isDownloading || !sessionId}
+          >
+            {isDownloading ? "Téléchargement..." : "Download Benchmark"}
+          </Button>
+        </Tooltip>
+      </Box>
+
+      <Typography variant="body2" color="text.secondary" sx={{ mb: 2 }}>
+        Your benchmark has been generated. Here are some example questions:
+      </Typography>
+
+      <Box sx={{ mb: 3 }}>
+        {questions.map((q, index) => (
+          <Card
+            key={q.id || index}
+            variant="outlined"
+            sx={{
+              mb: 2,
+              backgroundColor: "#fafafa",
+            }}
+          >
+            <CardContent>
+              <Typography
+                variant="caption"
+                color="text.secondary"
+                sx={{ display: "block", mb: 1 }}
+              >
+                {q.type === "multi_hop"
+                  ? "Multi-hop Question"
+                  : "Single-shot Question"}
+              </Typography>
+              <Typography variant="body1">{q.question}</Typography>
+            </CardContent>
+          </Card>
+        ))}
+      </Box>
+
+      <Box sx={{ display: "flex", justifyContent: "center", mt: 8 }}>
+        <Button
+          variant="contained"
+          color="primary"
+          size="large"
+          startIcon={<AssessmentIcon />}
+          onClick={handleEvaluationClick}
+        >
+          Start Evaluation
+        </Button>
+      </Box>
+    </Box>
+  );
+};
+
+export default BenchmarkDisplay;

frontend/src/components/BenchmarkEvaluation.jsx

@@ -0,0 +1,364 @@
+import React, { useState, useEffect, useRef } from "react";
+import {
+  Box,
+  Typography,
+  CircularProgress,
+  Alert,
+  Paper,
+  Divider,
+  Button,
+} from "@mui/material";
+import AccessTimeIcon from "@mui/icons-material/AccessTime";
+import LogDisplay from "./LogDisplay";
+import { useNavigate } from "react-router-dom";
+
+// Evaluation steps
+const EVALUATION_STEPS = [
+  "preparation",
+  "model_evaluation",
+  "results_compilation",
+];
+
+// Friendly step names for display
+const STEP_LABELS = {
+  preparation: "Preparation",
+  model_evaluation: "Model Evaluation",
+  results_compilation: "Results Compilation",
+};
+
+/**
+ * Component to handle benchmark evaluation and display logs
+ *
+ * @param {Object} props - Component props
+ * @param {string} props.sessionId - Session ID of the benchmark to evaluate
+ * @param {Function} props.onComplete - Function to call when evaluation is complete
+ * @returns {JSX.Element} Benchmark evaluation component
+ */
+const BenchmarkEvaluation = ({ sessionId, onComplete }) => {
+  const [evaluating, setEvaluating] = useState(false);
+  const [evaluationComplete, setEvaluationComplete] = useState(false);
+  const [evaluationLogs, setEvaluationLogs] = useState([]);
+  const [error, setError] = useState(null);
+  const [currentPhase, setCurrentPhase] = useState("initializing");
+  const [completedSteps, setCompletedSteps] = useState([]);
+  const [activeStep, setActiveStep] = useState(0);
+  const [elapsedTime, setElapsedTime] = useState(0);
+
+  const pollingIntervalRef = useRef(null);
+  const timerIntervalRef = useRef(null);
+  const startTimeRef = useRef(null);
+
+  const navigate = useNavigate();
+
+  // Start evaluation when component mounts
+  useEffect(() => {
+    // Set start time
+    startTimeRef.current = Date.now();
+
+    // Start timer
+    timerIntervalRef.current = setInterval(() => {
+      const timeElapsed = Math.floor(
+        (Date.now() - startTimeRef.current) / 1000
+      );
+      setElapsedTime(timeElapsed);
+    }, 1000);
+
+    startEvaluation();
+
+    // Clean up intervals on unmount
+    return () => {
+      if (pollingIntervalRef.current) {
+        clearInterval(pollingIntervalRef.current);
+      }
+      if (timerIntervalRef.current) {
+        clearInterval(timerIntervalRef.current);
+      }
+    };
+  }, []);
+
+  // Determine current phase and completed steps from logs
+  useEffect(() => {
+    if (evaluationLogs.length === 0) return;
+
+    // Check all logs for completed steps
+    const newCompletedSteps = [...completedSteps];
+    let newActiveStep = activeStep;
+
+    evaluationLogs.forEach((log) => {
+      // Detect completed steps (format: [SUCCESS] Stage completed: step_name)
+      const match = log.match(/\[SUCCESS\] Stage completed: (\w+)/);
+      if (match && match[1]) {
+        const completedStep = match[1].trim();
+        if (
+          EVALUATION_STEPS.includes(completedStep) &&
+          !newCompletedSteps.includes(completedStep)
+        ) {
+          newCompletedSteps.push(completedStep);
+          // Set active step to index of next step
+          const stepIndex = EVALUATION_STEPS.indexOf(completedStep);
+          if (stepIndex >= 0 && stepIndex + 1 > newActiveStep) {
+            newActiveStep = stepIndex + 1;
+            if (newActiveStep >= EVALUATION_STEPS.length) {
+              newActiveStep = EVALUATION_STEPS.length;
+            }
+          }
+        }
+      }
+    });
+
+    // Update state if there are new completed steps
+    if (newCompletedSteps.length > completedSteps.length) {
+      setCompletedSteps(newCompletedSteps);
+      setActiveStep(newActiveStep);
+    }
+
+    // Check recent logs to determine current phase
+    const recentLogs = evaluationLogs.slice(-10);
+
+    // Detect completion conditions
+    const isComplete =
+      recentLogs.some((log) =>
+        log.includes("[SUCCESS] Evaluation completed")
+      ) ||
+      completedSteps.includes("results_compilation") ||
+      newCompletedSteps.includes("results_compilation");
+
+    if (isComplete) {
+      setCurrentPhase("complete");
+      setEvaluationComplete(true);
+      // Stop polling when evaluation is complete
+      if (pollingIntervalRef.current) {
+        clearInterval(pollingIntervalRef.current);
+      }
+      if (timerIntervalRef.current) {
+        clearInterval(timerIntervalRef.current);
+      }
+      // Notify parent component that evaluation is complete
+      if (onComplete) {
+        onComplete({
+          success: true,
+          sessionId,
+          logs: evaluationLogs,
+        });
+      }
+    } else if (recentLogs.some((log) => log.includes("Comparing models"))) {
+      setCurrentPhase("compiling_results");
+    } else if (recentLogs.some((log) => log.includes("Starting evaluations"))) {
+      setCurrentPhase("evaluating");
+    } else if (recentLogs.some((log) => log.includes("Initialization"))) {
+      setCurrentPhase("preparing");
+    }
+  }, [evaluationLogs, completedSteps, activeStep, sessionId, onComplete]);
+
+  // Format elapsed time as HH:MM:SS
+  const formatElapsedTime = () => {
+    const hours = Math.floor(elapsedTime / 3600);
+    const minutes = Math.floor((elapsedTime % 3600) / 60);
+    const seconds = elapsedTime % 60;
+
+    return [
+      hours.toString().padStart(2, "0"),
+      minutes.toString().padStart(2, "0"),
+      seconds.toString().padStart(2, "0"),
+    ].join(":");
+  };
+
+  // Start benchmark evaluation
+  const startEvaluation = async () => {
+    if (!sessionId) {
+      setError("Missing session ID");
+      return;
+    }
+
+    setEvaluating(true);
+    setEvaluationLogs([]);
+    setError(null);
+    setCurrentPhase("initializing");
+    setCompletedSteps([]);
+    setActiveStep(0);
+
+    try {
+      // Call API to start evaluation
+      const response = await fetch("http://localhost:3001/evaluate-benchmark", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          session_id: sessionId,
+        }),
+      });
+
+      const result = await response.json();
+
+      if (response.ok) {
+        setEvaluationLogs(result.logs || []);
+
+        // Set up polling to retrieve more logs
+        pollingIntervalRef.current = setInterval(async () => {
+          // Check if we're already done
+          if (evaluationComplete) {
+            clearInterval(pollingIntervalRef.current);
+            return;
+          }
+
+          try {
+            // Call API to get latest logs
+            const logsResponse = await fetch(
+              `http://localhost:3001/evaluation-logs/${sessionId}`
+            );
+
+            if (logsResponse.ok) {
+              const logsResult = await logsResponse.json();
+
+              // Update logs if there are new ones
+              if (
+                logsResult.logs &&
+                logsResult.logs.length > evaluationLogs.length
+              ) {
+                setEvaluationLogs(logsResult.logs);
+              }
+
+              // Check if evaluation is complete
+              if (logsResult.is_completed) {
+                setEvaluationComplete(true);
+                clearInterval(pollingIntervalRef.current);
+              }
+            }
+          } catch (error) {
+            console.log("Error polling logs:", error);
+            // Don't stop polling on network errors
+          }
+        }, 2000); // Poll every 2 seconds
+      } else {
+        // Handle error
+        setEvaluationLogs([`Error: ${result.error || "Unknown error"}`]);
+        setError(result.error || "Benchmark evaluation failed");
+      }
+    } catch (error) {
+      console.error("Error starting evaluation:", error);
+      setEvaluationLogs([`Error: ${error.message || "Unknown error"}`]);
+      setError("Error connecting to server");
+    } finally {
+      setEvaluating(false);
+    }
+  };
+
+  // Get title based on current phase
+  const getPhaseTitle = () => {
+    switch (currentPhase) {
+      case "initializing":
+        return "Preparing evaluation...";
+      case "preparing":
+        return "Preparing models...";
+      case "evaluating":
+        return "Evaluating models...";
+      case "compiling_results":
+        return "Compiling results...";
+      case "complete":
+        return "Evaluation completed successfully!";
+      default:
+        return "Processing...";
+    }
+  };
+
+  // Get current step info for display
+  const getCurrentStepInfo = () => {
+    const totalSteps = EVALUATION_STEPS.length;
+    const currentStepIndex = activeStep;
+
+    // If no active step yet
+    if (currentStepIndex === 0 && completedSteps.length === 0) {
+      return `Starting... (0%)`;
+    }
+
+    // If all steps completed
+    if (currentStepIndex >= totalSteps) {
+      return `Completed (100%)`;
+    }
+
+    // Calculate percentage
+    const percentage = Math.round((currentStepIndex / totalSteps) * 100);
+
+    // Get current step name
+    const currentStepName =
+      STEP_LABELS[EVALUATION_STEPS[currentStepIndex]] || "Processing";
+
+    return `${currentStepName} (${percentage}%)`;
+  };
+
+  // Function to navigate to results page
+  const viewResults = () => {
+    navigate(`/evaluation-display?session=${sessionId}`);
+  };
+
+  return (
+    <Paper
+      elevation={3}
+      sx={{
+        p: 4,
+        mt: 3,
+        mb: 3,
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        justifyContent: "center",
+        minHeight: 200,
+      }}
+    >
+      {error ? (
+        <Alert severity="error" sx={{ width: "100%" }}>
+          {error}
+        </Alert>
+      ) : (
+        <>
+          {evaluationComplete ? (
+            <>
+              <Alert severity="success" sx={{ width: "100%", mb: 3 }}>
+                Evaluation completed successfully!
+              </Alert>
+              <Button
+                variant="contained"
+                color="primary"
+                onClick={viewResults}
+                sx={{ mb: 3 }}
+              >
+                View Results Leaderboard
+              </Button>
+            </>
+          ) : (
+            <>
+              <CircularProgress size={60} sx={{ mb: 2 }} />
+              <Typography variant="h6" component="div" gutterBottom>
+                {getPhaseTitle()}
+              </Typography>
+
+              {/* Step progress indicator */}
+              <Typography variant="body1" color="text.secondary">
+                {getCurrentStepInfo()}
+              </Typography>
+
+              {/* Timer display */}
+              <Box
+                sx={{
+                  display: "flex",
+                  alignItems: "center",
+                  mt: 1,
+                  color: "text.secondary",
+                  opacity: 0.5,
+                }}
+              >
+                <Typography variant="body2">{formatElapsedTime()}</Typography>
+              </Box>
+            </>
+          )}
+        </>
+      )}
+
+      {/* Use the LogDisplay component for logs */}
+      <LogDisplay logs={evaluationLogs} height={300} />
+    </Paper>
+  );
+};
+
+export default BenchmarkEvaluation;

frontend/src/components/BenchmarkGenerator.jsx

@@ -0,0 +1,398 @@
+import React, { useState, useEffect, useRef } from "react";
+import { Box, Typography, CircularProgress, Alert, Paper } from "@mui/material";
+import PlayArrowIcon from "@mui/icons-material/PlayArrow";
+import AccessTimeIcon from "@mui/icons-material/AccessTime";
+import LogDisplay from "./LogDisplay";
+
+// Define all benchmark steps in sequence
+const BENCHMARK_STEPS = [
+  "ingestion",
+  "upload_ingest_to_hub",
+  "summarization",
+  "chunking",
+  "single_shot_question_generation",
+  "multi_hop_question_generation",
+  "lighteval",
+];
+
+// Step labels for display (more user-friendly names)
+const STEP_LABELS = {
+  ingestion: "Ingestion",
+  upload_ingest_to_hub: "Upload to Hub",
+  summarization: "Summarization",
+  chunking: "Chunking",
+  single_shot_question_generation: "Single-shot QG",
+  multi_hop_question_generation: "Multi-hop QG",
+  lighteval: "LightEval",
+};
+
+/**
+ * Component to handle benchmark generation and display logs
+ *
+ * @param {Object} props - Component props
+ * @param {string} props.sessionId - The session ID for the uploaded file
+ * @param {Function} props.onComplete - Function to call when generation is complete
+ * @returns {JSX.Element} Benchmark generator component
+ */
+const BenchmarkGenerator = ({ sessionId, onComplete }) => {
+  const [generating, setGenerating] = useState(false);
+  const [generationComplete, setGenerationComplete] = useState(false);
+  const [generationLogs, setGenerationLogs] = useState([]);
+  const [error, setError] = useState(null);
+  const [currentPhase, setCurrentPhase] = useState("initializing");
+  const [completedSteps, setCompletedSteps] = useState([]);
+  const [activeStep, setActiveStep] = useState(0);
+  const [elapsedTime, setElapsedTime] = useState(0);
+
+  // Reference to keep track of the polling interval
+  const pollingIntervalRef = useRef(null);
+
+  // Reference to keep track of the timer interval
+  const timerIntervalRef = useRef(null);
+
+  // Reference for starting time
+  const startTimeRef = useRef(null);
+
+  // Start generation on component mount
+  useEffect(() => {
+    // Set start time
+    startTimeRef.current = Date.now();
+
+    // Start timer
+    timerIntervalRef.current = setInterval(() => {
+      const timeElapsed = Math.floor(
+        (Date.now() - startTimeRef.current) / 1000
+      );
+      setElapsedTime(timeElapsed);
+    }, 1000);
+
+    generateBenchmark();
+
+    // Clean up the polling interval and timer when the component unmounts
+    return () => {
+      if (pollingIntervalRef.current) {
+        clearInterval(pollingIntervalRef.current);
+      }
+      if (timerIntervalRef.current) {
+        clearInterval(timerIntervalRef.current);
+      }
+    };
+  }, []);
+
+  // Determine the current phase and completed steps based on logs
+  useEffect(() => {
+    if (generationLogs.length === 0) return;
+
+    // Check all logs for completed stages
+    const newCompletedSteps = [...completedSteps];
+    let newActiveStep = activeStep;
+
+    generationLogs.forEach((log) => {
+      const match = log.match(/\[SUCCESS\] Stage completed: (\w+)/);
+      if (match && match[1]) {
+        const completedStep = match[1].trim();
+        if (
+          BENCHMARK_STEPS.includes(completedStep) &&
+          !newCompletedSteps.includes(completedStep)
+        ) {
+          newCompletedSteps.push(completedStep);
+          // Set active step to the index of the next step
+          const stepIndex = BENCHMARK_STEPS.indexOf(completedStep);
+          if (stepIndex >= 0 && stepIndex + 1 > newActiveStep) {
+            newActiveStep = stepIndex + 1;
+            if (newActiveStep >= BENCHMARK_STEPS.length) {
+              newActiveStep = BENCHMARK_STEPS.length;
+            }
+          }
+        }
+      }
+    });
+
+    // Update state if there are new completed steps
+    if (newCompletedSteps.length > completedSteps.length) {
+      setCompletedSteps(newCompletedSteps);
+      setActiveStep(newActiveStep);
+    }
+
+    // Check the latest logs to determine the current phase
+    const recentLogs = generationLogs.slice(-10); // Check more logs
+
+    // Detect completion conditions
+    const isComplete =
+      recentLogs.some((log) =>
+        log.includes("[SUCCESS] Ingestion process completed successfully")
+      ) ||
+      recentLogs.some((log) =>
+        log.includes(
+          "[SUCCESS] Configuration and ingestion completed successfully"
+        )
+      ) ||
+      completedSteps.includes("lighteval") ||
+      newCompletedSteps.includes("lighteval");
+
+    if (isComplete) {
+      setCurrentPhase("complete");
+      setGenerationComplete(true);
+      // Stop polling when benchmark is complete
+      if (pollingIntervalRef.current) {
+        clearInterval(pollingIntervalRef.current);
+      }
+      // Notify parent component that generation is complete
+      if (onComplete) {
+        console.log("Notifying parent that generation is complete");
+        onComplete({
+          success: true,
+          sessionId,
+          logs: generationLogs,
+        });
+      }
+    } else if (
+      recentLogs.some((log) => log.includes("starting benchmark creation"))
+    ) {
+      setCurrentPhase("benchmarking");
+    } else if (
+      recentLogs.some((log) => log.includes("Generating base configuration"))
+    ) {
+      setCurrentPhase("configuring");
+    }
+  }, [generationLogs, completedSteps, activeStep, sessionId, onComplete]);
+
+  const generateBenchmark = async () => {
+    if (!sessionId) {
+      setError("Missing session ID");
+      return;
+    }
+
+    setGenerating(true);
+    setGenerationLogs([]);
+    setError(null);
+    setCurrentPhase("initializing");
+    setCompletedSteps([]);
+    setActiveStep(0);
+
+    try {
+      // Call the API to generate the benchmark
+      const response = await fetch("http://localhost:3001/generate-benchmark", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          session_id: sessionId,
+        }),
+      });
+
+      const result = await response.json();
+
+      if (response.ok) {
+        setGenerationLogs(result.logs || []);
+
+        // D'abord, on commence par interroger les logs de configuration
+        const pollConfigLogs = async () => {
+          try {
+            // Call the API to get the config logs
+            const configLogsResponse = await fetch(
+              `http://localhost:3001/config-logs/${sessionId}`
+            );
+
+            if (configLogsResponse.ok) {
+              const configLogsResult = await configLogsResponse.json();
+
+              // Update logs if there are new ones
+              if (
+                configLogsResult.logs &&
+                configLogsResult.logs.length > generationLogs.length
+              ) {
+                setGenerationLogs(configLogsResult.logs);
+              }
+
+              // If config task is completed, switch to polling benchmark logs
+              if (configLogsResult.is_completed) {
+                // Attendre un court instant pour permettre au serveur de démarrer le benchmark
+                setTimeout(() => {
+                  console.log(
+                    "Configuration completed, switching to benchmark polling"
+                  );
+                  clearInterval(configPollingIntervalRef.current);
+                  pollBenchmarkLogs();
+                }, 1000);
+              }
+            }
+          } catch (error) {
+            console.log("Error polling for config logs:", error);
+            // Don't stop polling on network errors
+          }
+        };
+
+        // Fonction pour interroger les logs du benchmark
+        const pollBenchmarkLogs = async () => {
+          // Set up polling for benchmark logs
+          pollingIntervalRef.current = setInterval(async () => {
+            // Check if we already completed
+            if (generationComplete) {
+              clearInterval(pollingIntervalRef.current);
+              return;
+            }
+
+            try {
+              // Call the API to get the latest benchmark logs
+              const logsResponse = await fetch(
+                `http://localhost:3001/benchmark-logs/${sessionId}`
+              );
+
+              if (logsResponse.ok) {
+                const logsResult = await logsResponse.json();
+
+                // Update logs if there are new ones
+                if (
+                  logsResult.logs &&
+                  logsResult.logs.length > generationLogs.length
+                ) {
+                  setGenerationLogs(logsResult.logs);
+                }
+
+                // Check if the task is completed
+                if (logsResult.is_completed) {
+                  setGenerationComplete(true);
+                  clearInterval(pollingIntervalRef.current);
+                  // Notification is now handled in the useEffect above
+                }
+              }
+            } catch (error) {
+              console.log("Error polling for benchmark logs:", error);
+              // Don't stop polling on network errors
+            }
+          }, 3000); // Poll every 3 seconds
+        };
+
+        // Démarrer le polling des logs de configuration
+        const configPollingIntervalRef = { current: null };
+        configPollingIntervalRef.current = setInterval(pollConfigLogs, 1000); // Poll config logs more frequently (every second)
+      } else {
+        // Handle error
+        setGenerationLogs([`Error: ${result.error || "Unknown error"}`]);
+        setError(result.error || "Benchmark generation failed");
+      }
+    } catch (error) {
+      console.error("Error generating benchmark:", error);
+      setGenerationLogs([`Error: ${error.message || "Unknown error"}`]);
+      setError("Server connection error");
+    } finally {
+      setGenerating(false);
+    }
+  };
+
+  // Get title based on current phase
+  const getPhaseTitle = () => {
+    switch (currentPhase) {
+      case "initializing":
+        return "Benchmark generation...";
+      case "configuring":
+        return "Generating configuration file...";
+      case "benchmarking":
+        return "Creating benchmark...";
+      case "complete":
+        return "Benchmark generated successfully!";
+      default:
+        return "Processing...";
+    }
+  };
+
+  // Get the current step information for display
+  const getCurrentStepInfo = () => {
+    const totalSteps = BENCHMARK_STEPS.length;
+    const currentStepIndex = activeStep;
+
+    // If there's no active step yet
+    if (currentStepIndex === 0 && completedSteps.length === 0) {
+      return `Starting... (0%)`;
+    }
+
+    // If all steps are completed
+    if (currentStepIndex >= totalSteps) {
+      return `Complete (100%)`;
+    }
+
+    // Calculate percentage
+    const percentage = Math.round((currentStepIndex / totalSteps) * 100);
+
+    // Get current step name
+    const currentStepName =
+      STEP_LABELS[BENCHMARK_STEPS[currentStepIndex]] || "Processing";
+
+    return `${currentStepName} (${percentage}%)`;
+  };
+
+  // Format elapsed time in HH:MM:SS
+  const formatElapsedTime = () => {
+    const hours = Math.floor(elapsedTime / 3600);
+    const minutes = Math.floor((elapsedTime % 3600) / 60);
+    const seconds = elapsedTime % 60;
+
+    return [
+      hours.toString().padStart(2, "0"),
+      minutes.toString().padStart(2, "0"),
+      seconds.toString().padStart(2, "0"),
+    ].join(":");
+  };
+
+  // If complete, stop the timer
+  useEffect(() => {
+    if (generationComplete && timerIntervalRef.current) {
+      clearInterval(timerIntervalRef.current);
+    }
+  }, [generationComplete]);
+
+  return (
+    <Paper
+      elevation={3}
+      sx={{
+        p: 4,
+        mt: 3,
+        mb: 3,
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        justifyContent: "center",
+        minHeight: 200,
+      }}
+    >
+      {error ? (
+        <Alert severity="error" sx={{ width: "100%" }}>
+          {error}
+        </Alert>
+      ) : (
+        <>
+          <CircularProgress size={60} sx={{ mb: 2 }} />
+          <Typography variant="h6" component="div" gutterBottom>
+            {getPhaseTitle()}
+          </Typography>
+
+          {/* Step progress indicator */}
+          <Typography variant="body1" color="text.secondary">
+            {getCurrentStepInfo()}
+          </Typography>
+
+          {/* Timer display */}
+          <Box
+            sx={{
+              display: "flex",
+              alignItems: "center",
+              mt: 1,
+              color: "text.secondary",
+            }}
+          >
+            <Typography variant="body2" sx={{ opacity: 0.5 }}>
+              {formatElapsedTime()}
+            </Typography>
+          </Box>
+        </>
+      )}
+
+      {/* Use the LogDisplay component */}
+      <LogDisplay logs={generationLogs} height={300} />
+    </Paper>
+  );
+};
+
+export default BenchmarkGenerator;

frontend/src/components/EvaluationDisplay.jsx

@@ -0,0 +1,196 @@
+import React, { useState, useEffect } from "react";
+import {
+  Box,
+  Paper,
+  Typography,
+  Table,
+  TableBody,
+  TableCell,
+  TableContainer,
+  TableHead,
+  TableRow,
+  Alert,
+  LinearProgress,
+  Card,
+  CardContent,
+  Link,
+} from "@mui/material";
+import OpenInNewIcon from "@mui/icons-material/OpenInNew";
+
+const EvaluationDisplay = ({ sessionId }) => {
+  const [results, setResults] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+
+  useEffect(() => {
+    const fetchEvaluationResults = async () => {
+      if (!sessionId) {
+        setError("No session ID provided");
+        setLoading(false);
+        return;
+      }
+
+      try {
+        // Fetch evaluation results from the API
+        const response = await fetch(
+          `http://localhost:3001/evaluation-results/${sessionId}`
+        );
+
+        if (!response.ok) {
+          throw new Error(`Failed to fetch results: ${response.status}`);
+        }
+
+        const data = await response.json();
+
+        if (!data.success) {
+          throw new Error(data.message || "Failed to fetch evaluation results");
+        }
+
+        setResults(data.results);
+      } catch (err) {
+        console.error("Error fetching evaluation results:", err);
+        setError(err.message);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchEvaluationResults();
+  }, [sessionId]);
+
+  // Format accuracy as percentage
+  const formatAccuracy = (value) => {
+    return `${(value * 100).toFixed(2)}%`;
+  };
+
+  // Format evaluation time
+  const formatTime = (seconds) => {
+    return `${seconds.toFixed(2)}s`;
+  };
+
+  if (loading) {
+    return (
+      <Box sx={{ width: "100%", mt: 4, mb: 4 }}>
+        <Typography variant="h5" gutterBottom>
+          Loading Evaluation Results...
+        </Typography>
+        <LinearProgress />
+      </Box>
+    );
+  }
+
+  if (error) {
+    return (
+      <Alert severity="error" sx={{ mt: 4, mb: 4 }}>
+        {error}
+      </Alert>
+    );
+  }
+
+  if (
+    !results ||
+    !results.models_comparison ||
+    results.models_comparison.length === 0
+  ) {
+    return (
+      <Alert severity="info" sx={{ mt: 4, mb: 4 }}>
+        No evaluation results found for this benchmark.
+      </Alert>
+    );
+  }
+
+  return (
+    <Box sx={{ mt: 4, mb: 6 }}>
+      <Typography variant="h4" gutterBottom>
+        Evaluation Results
+      </Typography>
+
+      <TableContainer
+        component={Paper}
+        sx={{
+          border: "1px solid rgba(224, 224, 224, 1)",
+          boxShadow: "0 2px 4px rgba(0,0,0,0.05)",
+        }}
+      >
+        <Table sx={{ minWidth: 650 }}>
+          <TableHead>
+            <TableRow>
+              <TableCell>Rank</TableCell>
+              <TableCell>Model</TableCell>
+              <TableCell>Provider</TableCell>
+              <TableCell align="center">Accuracy</TableCell>
+              <TableCell align="center">Std Error</TableCell>
+              <TableCell align="center">Eval Time</TableCell>
+              <TableCell align="center">Status</TableCell>
+            </TableRow>
+          </TableHead>
+          <TableBody>
+            {results.models_comparison.map((model, index) => (
+              <TableRow
+                key={`${model.model_name}-${model.provider}`}
+                sx={{
+                  "&:last-child td, &:last-child th": { border: 0 },
+                  backgroundColor: model.success
+                    ? "inherit"
+                    : "rgba(0, 0, 0, 0.04)",
+                }}
+              >
+                <TableCell>{index + 1}</TableCell>
+                <TableCell component="th" scope="row">
+                  <Link
+                    href={`https://huggingface.co/${model.model_name}`}
+                    target="_blank"
+                    rel="noopener noreferrer"
+                    sx={{
+                      textDecoration: "none",
+                      "&:hover": {
+                        textDecoration: "underline",
+                      },
+                      display: "flex",
+                      alignItems: "center",
+                    }}
+                  >
+                    {model.model_name}
+                    <OpenInNewIcon sx={{ ml: 0.5, fontSize: 16 }} />
+                  </Link>
+                </TableCell>
+                <TableCell>{model.provider}</TableCell>
+                <TableCell align="center">
+                  {model.success ? formatAccuracy(model.accuracy) : "-"}
+                </TableCell>
+                <TableCell align="center">
+                  {model.success ? formatAccuracy(model.accuracy_stderr) : "-"}
+                </TableCell>
+                <TableCell align="center">
+                  {model.success ? formatTime(model.evaluation_time) : "-"}
+                </TableCell>
+                <TableCell align="center">
+                  {model.success ? (
+                    <span style={{ color: "green" }}>✓ Success</span>
+                  ) : (
+                    <span style={{ color: "red" }}>✗ Failed</span>
+                  )}
+                </TableCell>
+              </TableRow>
+            ))}
+          </TableBody>
+        </Table>
+      </TableContainer>
+
+      <Box sx={{ mt: 4, textAlign: "center" }}>
+        <Typography variant="body2" color="textSecondary">
+          Need larger evaluation?{" "}
+          <Link
+            href="https://huggingface.co/spaces/yourbench/yourbench"
+            target="_blank"
+            rel="noopener noreferrer"
+          >
+            Go to this page
+          </Link>
+        </Typography>
+      </Box>
+    </Box>
+  );
+};
+
+export default EvaluationDisplay;

frontend/src/components/Footer/Footer.js

@@ -0,0 +1,30 @@
+import React from "react";
+import { Box, Typography, Link } from "@mui/material";
+
+const Footer = () => {
+  return (
+    <Box
+      component="footer"
+      sx={{
+        width: "100%",
+        py: 4,
+        textAlign: "center",
+      }}
+    >
+      <Typography variant="body2" color="text.secondary" sx={{ mx: 4 }}>
+        © 2024 Hugging Face - Open LLM Leaderboard - Made with 🤗 by the HF team
+        -{" "}
+        <Link
+          href="https://huggingface.co"
+          target="_blank"
+          rel="noopener noreferrer"
+          color="inherit"
+        >
+          huggingface.co
+        </Link>
+      </Typography>
+    </Box>
+  );
+};
+
+export default Footer;

frontend/src/components/LogDisplay.jsx

@@ -0,0 +1,67 @@
+import React, { useRef, useEffect } from "react";
+import { Box, Typography } from "@mui/material";
+
+/**
+ * A reusable component for displaying logs with auto-scrolling and styling
+ *
+ * @param {Object} props - Component props
+ * @param {Array<string>} props.logs - Array of log messages to display
+ * @param {number} props.height - Height of the log container in pixels (default: 300)
+ * @param {Object} props.containerStyle - Additional styles for the container
+ * @returns {JSX.Element} Log display component
+ */
+const LogDisplay = ({ logs = [], height = 300, containerStyle = {} }) => {
+  const logsEndRef = useRef(null);
+
+  // Auto-scroll logs to bottom when new logs are added
+  useEffect(() => {
+    if (logsEndRef.current) {
+      logsEndRef.current.scrollIntoView({ behavior: "smooth" });
+    }
+  }, [logs]);
+
+  return (
+    <Box
+      sx={{
+        mt: 3,
+        width: "100%",
+        height: `${height}px`,
+        overflowY: "auto",
+        backgroundColor: "#f9f9f9",
+        p: 2,
+        borderRadius: 1,
+        fontFamily: "monospace",
+        fontSize: "0.85rem",
+        border: "1px solid #e0e0e0",
+        ...containerStyle,
+      }}
+    >
+      {logs.length === 0 ? (
+        <Typography color="text.secondary" variant="body2">
+          Waiting for logs...
+        </Typography>
+      ) : (
+        logs.map((log, index) => {
+          // Style logs based on content
+          let style = { opacity: 0.7 };
+          if (log.includes("[ERROR]")) {
+            style = { ...style, color: "#d32f2f" }; // Red for errors
+          } else if (log.includes("[WARN]")) {
+            style = { ...style, color: "#ed6c02" }; // Orange for warnings
+          } else if (log.includes("[SUCCESS]")) {
+            style = { ...style, color: "#2e7d32", opacity: 0.8 }; // Green for success
+          }
+
+          return (
+            <div key={index} style={{ ...style, marginBottom: "4px" }}>
+              {log}
+            </div>
+          );
+        })
+      )}
+      <div ref={logsEndRef} />
+    </Box>
+  );
+};
+
+export default LogDisplay;

frontend/src/components/Logo/HFLogo.js

@@ -0,0 +1,19 @@
+import React from 'react';
+
+const HFLogo = () => (
+<svg width="100%" viewBox="0 0 236 220" version="1.1" xmlns="http://www.w3.org/2000/svg" >
+    <title>hg-logo</title>
+    <g id="hg-logo" stroke="none" strokeWidth="1" fill="none">
+        <g id="Group" transform="translate(-1.000000, 0.000000)">
+            <path d="M236.188357,161.726225 C235.570415,159.393906 234.569281,157.181253 233.22638,155.176863 C233.514062,154.120588 233.732701,153.048205 233.879994,151.965466 C234.832798,145.089325 232.449638,138.794251 227.956041,133.922501 C225.522249,131.262254 222.913547,129.506398 220.150646,128.428262 C221.964195,120.669591 222.882477,112.729122 222.88708,104.761037 C222.88708,101.122758 222.681099,97.5581193 222.335881,94.046409 C222.155216,92.2928551 221.937728,90.5427531 221.683417,88.7984042 C220.891716,83.6516545 219.717972,78.5709507 218.171392,73.5986359 C217.1576,70.3316637 215.985007,67.1160095 214.658216,63.9632945 C212.668606,59.2945148 210.345284,54.7746261 207.706662,50.4388375 C205.974815,47.5549087 204.089921,44.7659066 202.058884,42.0841428 C201.063504,40.7298561 200.026697,39.4075568 198.947313,38.1190859 C195.750588,34.2338824 192.277687,30.5855928 188.552777,27.2030978 C187.316894,26.0660493 186.045339,24.9682371 184.739261,23.9111571 C183.453897,22.8390039 182.139764,21.8011393 180.799165,20.798714 C178.100706,18.7906417 175.311338,16.9066068 172.44142,15.1525926 C156.583223,5.52185376 137.986291,0 118.109749,0 C60.2385495,0 13.3336831,46.9018135 13.3336831,104.76564 C13.3321871,112.833829 14.2670394,120.874403 16.1195981,128.726274 C13.6340233,129.805561 11.2508635,131.486626 9.04261448,133.920199 C4.55016831,138.788498 2.16585774,145.06171 3.11981211,151.9367 C3.26365324,153.029795 3.48229176,154.111383 3.77227548,155.174561 C2.4301802,157.180102 1.42939115,159.393906 0.810298929,161.726225 C-0.570575919,166.97423 -0.116037948,171.706754 1.63882384,175.85246 C-0.267934182,181.273058 0.208467641,187.044598 2.69289164,192.062477 C4.49953623,195.727221 7.08522438,198.561213 10.2715931,201.096041 C14.0609438,204.107229 18.8042489,206.667372 24.5268244,209.121657 C31.3529491,212.032741 39.6842274,214.767779 43.4735781,215.771124 C53.2616793,218.305953 62.6470253,219.912227 72.1599872,219.989319 C85.7109724,220.115888 97.3816663,216.928654 105.738261,208.774168 C109.842911,209.276992 113.974028,209.528979 118.109749,209.527828 C122.479067,209.518623 126.843782,209.242473 131.179729,208.70398 C139.51561,216.910244 151.231182,220.126243 164.8328,219.996223 C174.343575,219.921432 183.728921,218.315158 193.491706,215.776877 C197.306373,214.773532 205.63535,212.038494 212.464927,209.128561 C218.187502,206.668523 222.929657,204.109531 226.745474,201.101795 C229.907678,198.568116 232.491064,195.732974 234.29886,192.068231 C236.8086,187.050351 237.260836,181.278811 235.378244,175.858213 C237.116995,171.712507 237.568081,166.969627 236.188357,161.726225 Z M226.477354,175.501519 C228.400223,179.150153 228.523351,183.272846 226.826025,187.112485 C224.252995,192.932351 217.861846,197.515294 205.448932,202.436521 C197.730992,205.498336 190.662064,207.4544 190.599924,207.47281 C180.390656,210.1204 171.157207,211.464332 163.164243,211.464332 C149.928557,211.464332 140.080618,207.813396 133.834461,200.601272 C123.271919,202.399701 112.486136,202.460684 101.904031,200.781921 C95.6509699,207.874379 85.857115,211.464332 72.7330503,211.464332 C64.7390507,211.464332 55.5067517,210.1204 45.2974836,207.47281 C45.2341935,207.4544 38.1698679,205.498336 30.4484761,202.436521 C18.0355619,197.515294 11.6432621,192.934652 9.07138271,187.112485 C7.37405737,183.272846 7.49718538,179.150153 9.4200536,175.501519 C9.59841661,175.163235 9.7882869,174.831854 9.99196594,174.513131 C8.83939573,172.78259 8.06645104,170.826526 7.72364885,168.77611 C7.38096175,166.725695 7.47635718,164.624652 8.00350616,162.613358 C8.76759024,159.711479 10.3463905,157.297466 12.489048,155.563473 C11.4573043,153.86745 10.7801003,151.980424 10.4982867,150.015155 C9.88149595,145.74173 11.2991941,141.474059 14.4913165,137.995716 C16.9757405,135.288294 20.4889162,133.798233 24.3795311,133.798233 L24.4830967,133.798233 C21.5502336,124.39877 20.0630314,114.608094 20.0723523,104.762188 C20.0723523,51.0601755 63.612487,7.52279222 117.324951,7.52279222 C171.038681,7.52279222 214.577665,51.0567236 214.577665,104.762188 C214.58457,114.634558 213.087471,124.450548 210.137002,133.871873 C210.606499,133.825848 211.066791,133.801685 211.517877,133.801685 C215.407341,133.801685 218.921668,135.290595 221.406092,137.998018 C224.595912,141.474059 226.017063,145.745182 225.399121,150.017456 C225.117193,151.982725 224.440564,153.870902 223.40836,155.566925 C225.551018,157.299767 227.129818,159.71378 227.893902,162.61681 C228.419785,164.628104 228.515296,166.727996 228.172378,168.779562 C227.829461,170.829977 227.057322,172.784891 225.905442,174.516583 C226.109121,174.831854 226.301293,175.163235 226.477354,175.501519 Z" id="Shape" fill="#FFFFFF" fillRule="nonzero"></path>
+            <path d="M226.52977,174.037682 C227.682419,172.305523 228.455074,170.350082 228.798221,168.299114 C229.141367,166.246994 229.045793,164.146536 228.519558,162.134699 C227.754964,159.232038 226.175108,156.817373 224.031019,155.082913 C225.062761,153.386432 225.740993,151.498897 226.02311,149.533098 C226.640313,145.258521 225.221668,140.989698 222.027412,137.510418 C219.541328,134.802265 216.024653,133.311802 212.13259,133.311802 C211.680051,133.311802 211.220603,133.334821 210.750792,133.382009 C213.699779,123.958143 215.195575,114.139506 215.186363,104.265624 C215.186363,50.5501622 171.617132,7 117.873265,7 C64.1293973,7 20.5555606,50.5455585 20.5555606,104.265624 C20.5462334,114.114185 22.0344295,123.907502 24.9692525,133.3095 L24.8656177,133.3095 C20.9735543,133.3095 17.4580309,134.799963 14.9719466,137.508116 C11.7799941,140.985094 10.3590456,145.256219 10.9762485,149.530796 C11.2580201,151.496595 11.9356766,153.384131 12.9683401,155.080611 C10.8242508,156.815072 9.24439546,159.229736 8.48095227,162.133548 C7.95379648,164.145385 7.85868274,166.246994 8.20205945,168.299114 C8.54543616,170.350082 9.31935798,172.306674 10.4730439,174.037682 C10.2669257,174.356491 10.07808,174.687961 9.90074934,175.026336 C7.97774764,178.675955 7.85338585,182.79976 9.55184544,186.640434 C12.1254435,192.460719 18.522015,197.0472 30.9432242,201.968603 C38.6663215,205.031245 45.7399738,206.987836 45.8021547,207.006251 C56.0182452,209.654556 65.2567139,211 73.2550191,211 C86.3890056,211 96.1882538,207.409079 102.446646,200.313557 C113.035821,201.992773 123.828812,201.931773 134.398413,200.13286 C140.647592,207.346928 150.503264,211 163.747794,211 C171.7461,211 180.98572,209.654556 191.20181,207.006251 C191.263991,206.987836 198.334189,205.031245 206.060741,201.968603 C218.48195,197.0472 224.878521,192.460719 227.45212,186.640434 C229.150579,182.79976 229.027369,178.675955 227.103216,175.026336 C226.927036,174.684508 226.733585,174.354189 226.52977,174.037682 Z M97.9684697,189.207022 C97.4295686,190.149639 96.8526681,191.069237 96.2377682,191.963514 C94.6199135,194.33099 92.4919451,196.139111 90.0231334,197.484555 C85.30084,200.056898 79.3257167,200.95693 73.2538676,200.95693 C63.6641921,200.95693 53.832702,198.713755 48.3216324,197.284293 C48.0510304,197.214085 14.5435894,187.75454 18.7857081,179.70259 C19.4996369,178.349089 20.6753163,177.808149 22.1538398,177.808149 C28.1266601,177.808149 39.0026741,186.697981 43.677756,186.697981 C44.7210132,186.697981 45.4578568,186.252568 45.7583978,185.169537 C47.7504894,178.027978 15.4820603,175.026336 18.1995956,164.686325 C18.6797703,162.856336 19.9798115,162.113982 21.8095419,162.113982 C29.7053639,162.112831 47.4292214,175.993123 51.1358936,175.993123 C51.4203136,175.993123 51.6241287,175.910255 51.7346726,175.735313 L51.7830355,175.655898 C53.5217975,172.784312 52.5246002,170.696514 40.6042927,163.399578 L39.4597036,162.703262 C26.3441411,154.767556 17.1367629,149.993472 22.3737759,144.296338 C22.9760094,143.638002 23.8292694,143.346815 24.8667692,143.346815 C26.0977205,143.346815 27.5866075,143.758851 29.2263407,144.448261 C36.1537528,147.368187 45.7549433,155.331515 49.7656109,158.80504 C50.9481994,159.833977 51.6448557,160.462389 51.6448557,160.462389 C51.6448557,160.462389 56.722962,165.740582 59.7940072,165.740582 C60.501027,165.740582 61.099806,165.463207 61.5062848,164.773796 C63.684919,161.104611 41.282525,144.137509 40.0193317,137.137514 C39.1637686,132.393355 40.6204136,129.991351 43.3160705,129.991351 C44.5965363,129.991351 46.1602706,130.535744 47.8863662,131.630284 C53.240832,135.027848 63.5789812,152.784493 67.3639552,159.691261 C68.6329061,162.006945 70.7988738,162.985241 72.750663,162.985241 C76.6231508,162.985241 79.6504392,159.137661 73.1053244,154.248484 C63.2680768,146.890548 66.7202678,134.865566 71.4149253,134.125514 C71.6152859,134.094439 71.8179496,134.078326 72.0194617,134.077175 C76.2892164,134.077175 78.1730672,141.431658 78.1730672,141.431658 C78.1730672,141.431658 83.6921972,155.286628 93.1747834,164.756532 C101.779928,173.352875 102.980941,180.408114 97.9684697,189.207022 Z M128.631711,190.829842 L128.140021,190.88854 L127.300579,190.985218 C126.859555,191.030105 126.418531,191.07384 125.975205,191.115274 L125.542241,191.154406 L125.148429,191.187783 L124.58765,191.23267 C124.381531,191.247632 124.175413,191.263745 123.969295,191.276405 L123.352092,191.317839 L123.216215,191.325896 L122.730283,191.354669 L122.524165,191.365027 L121.948416,191.393801 L121.279396,191.421423 L120.671405,191.44214 L120.266077,191.453649 L120.061111,191.453649 C119.934446,191.453649 119.808933,191.460555 119.682268,191.461706 L119.480756,191.461706 C119.354091,191.461706 119.228578,191.461706 119.101913,191.468612 L118.587193,191.474366 L117.866356,191.474366 C117.30097,191.474366 116.737888,191.468612 116.174805,191.458253 L115.718812,191.447895 C115.589844,191.447895 115.459725,191.440989 115.330757,191.437536 L114.848279,191.422574 L114.247197,191.399555 L113.707145,191.376537 L113.566662,191.370782 L113.051942,191.34316 C112.909157,191.335103 112.766371,191.328197 112.624737,191.31899 L112.291954,191.299424 C111.87396,191.272952 111.455966,191.243028 111.037972,191.210802 L110.600403,191.176274 L110.047684,191.129085 L109.401694,191.069237 C109.041275,191.03586 108.680856,190.99903 108.320437,190.958747 L108.303164,190.958747 C113.56551,179.224952 110.904399,168.266887 100.270314,157.646048 C93.2968422,150.685185 88.6563052,140.403871 87.6948043,138.146885 C85.7464697,131.4657 80.58891,124.038709 72.0252192,124.038709 C71.300927,124.03986 70.5789377,124.097406 69.8638574,124.210198 C66.1111254,124.799478 62.831659,126.958634 60.491815,130.206576 C57.9642769,127.063369 55.5058286,124.564687 53.2834374,123.152488 C49.9325781,121.030161 46.5897794,119.952885 43.33104,119.952885 C39.2662519,119.952885 35.6309727,121.621743 33.097677,124.648705 L33.0343446,124.725818 L32.8915589,124.12618 L32.8858014,124.100859 C32.4040146,122.040683 31.9992631,119.962092 31.6721225,117.871992 C31.6721225,117.85703 31.6721225,117.843219 31.6652135,117.829408 L31.5938206,117.356373 C31.5552454,117.100865 31.5175914,116.844206 31.4809738,116.588698 C31.4510349,116.375775 31.4210959,116.162852 31.39346,115.95108 C31.365824,115.739307 31.3358851,115.526384 31.3105521,115.313461 C31.2829161,115.099387 31.2575832,114.886464 31.2322502,114.67354 C31.2079536,114.470976 31.1845782,114.268411 31.1620089,114.065846 L31.155215,114.014054 C31.0513499,113.079494 30.9623391,112.143782 30.8879523,111.20692 L30.8476499,110.664829 C30.8361349,110.516359 30.8257714,110.366737 30.8165594,110.215964 C30.8165594,110.181436 30.8119535,110.145757 30.8096505,110.113531 L30.7717662,109.512742 C30.7579482,109.295215 30.7474696,109.077688 30.7359546,108.860161 C30.7244396,108.643785 30.7129246,108.426258 30.7037126,108.20758 L30.6806827,107.637867 L30.6737737,107.465226 L30.6565012,106.938098 L30.6439499,106.491534 C30.6439499,106.313139 30.6357743,106.133593 30.6323198,105.955198 L30.6231078,105.39239 C30.6208048,105.204788 30.6231078,105.018336 30.6185018,104.830733 C30.6127443,104.64198 30.6185018,104.454377 30.6185018,104.265624 C30.6185018,56.0965241 69.6899812,17.0441057 117.887083,17.0441057 C166.084184,17.0441057 205.154512,56.0942222 205.154512,104.265624 L205.154512,105.39239 C205.154512,105.579993 205.149906,105.768746 205.1453,105.955198 C205.1453,106.111725 205.139542,106.2648 205.134936,106.421327 C205.134936,106.560591 205.129179,106.698703 205.123421,106.833362 C205.123421,107.009456 205.113058,107.184398 205.1073,107.360491 L205.1073,107.375453 C205.092331,107.757564 205.07621,108.139675 205.060089,108.521786 L205.05318,108.648389 L205.023241,109.219253 L204.995605,109.671571 C204.931121,110.743093 204.847062,111.814615 204.744579,112.883834 L204.744579,112.898797 C204.726155,113.09906 204.705428,113.300473 204.683549,113.500736 C204.632883,113.966865 204.581066,114.432995 204.529248,114.899124 L204.470522,115.367555 L204.397978,115.917702 C204.372645,116.119116 204.345009,116.319379 204.316221,116.519642 C204.285131,116.744075 204.251737,116.967356 204.219495,117.190638 L204.138891,117.717767 L204.044468,118.316254 C204.012226,118.515366 203.979984,118.713327 203.941984,118.912439 C203.902833,119.1104 203.872894,119.308361 203.83835,119.507473 C203.76926,119.903395 203.697867,120.298166 203.620716,120.692937 C203.467567,121.479026 203.307509,122.262814 203.138239,123.045451 C203.095633,123.239959 203.051876,123.435618 203.006968,123.630126 C200.550823,121.244235 197.298992,119.944828 193.710924,119.944828 C190.45564,119.944828 187.109386,121.020954 183.759679,123.144431 C181.536136,124.555479 179.079991,127.055313 176.550149,130.19852 C174.206851,126.949427 170.927385,124.791421 167.179258,124.200991 C166.464178,124.08935 165.741037,124.031803 165.016745,124.030652 C156.450751,124.030652 151.296646,131.457644 149.34716,138.138829 C148.381053,140.395815 143.740516,150.675978 136.758984,157.648349 C126.13296,168.234661 123.451121,179.144386 128.631711,190.829842 Z M218.724916,167.341535 L218.690371,167.443968 C218.66619,167.509571 218.642008,167.575175 218.615524,167.639627 C218.57407,167.737457 218.530313,167.832984 218.484253,167.928512 C218.372558,168.156398 218.245893,168.377377 218.106562,168.58915 C217.914261,168.875733 217.703537,169.149656 217.474389,169.407465 C217.42142,169.467314 217.370754,169.526012 217.310876,169.584709 C217.230272,169.673332 217.143909,169.759652 217.058698,169.845972 C215.507631,171.382472 213.144757,172.727916 210.473281,173.964022 C210.170437,174.100983 209.864139,174.237945 209.553234,174.374906 L209.244633,174.511868 C209.038515,174.602792 208.833548,174.693716 208.617066,174.782338 C208.406342,174.872111 208.194467,174.960733 207.982591,175.048204 L207.340055,175.31407 C205.83735,175.932123 204.297797,176.520251 202.795092,177.102625 L202.153708,177.351227 L201.518081,177.59983 C201.096633,177.764414 200.67979,177.928997 200.268706,178.093581 L199.65726,178.339882 L199.05733,178.586182 L198.761395,178.709332 C198.56564,178.7922 198.372188,178.872765 198.18104,178.955633 C193.76159,180.850074 190.583456,182.777892 191.251325,185.170688 C191.269749,185.238594 191.290476,185.303046 191.313506,185.365197 C191.373383,185.542441 191.45514,185.710477 191.556472,185.867005 C191.61635,185.961382 191.685439,186.050004 191.76259,186.130569 C192.547911,186.945432 193.97692,186.816527 195.779015,186.169701 C195.925255,186.116758 196.07495,186.060362 196.225796,186.000513 C196.329431,185.961382 196.431914,185.919948 196.535549,185.878514 L196.691001,185.812911 C197.103238,185.637968 197.539655,185.44346 197.986437,185.230537 C198.098132,185.178745 198.210979,185.128104 198.323826,185.068255 C200.526641,183.99213 203.02424,182.540799 205.502264,181.220675 C205.882259,181.014658 206.263404,180.817847 206.642247,180.622188 C207.261753,180.301077 207.887017,179.991475 208.518038,179.695685 C210.86479,178.593088 213.069909,177.810451 214.844368,177.810451 C215.675749,177.810451 216.411556,177.98079 217.023002,178.372108 L217.125485,178.440013 C217.435238,178.658691 217.704689,178.926859 217.924625,179.23531 C217.975291,179.307819 218.02826,179.38263 218.073168,179.459743 C218.121531,179.539157 218.167591,179.620874 218.211348,179.703741 C219.087638,181.365693 218.354134,183.088645 216.638402,184.777068 C214.990608,186.397586 212.427373,187.987029 209.512932,189.459077 C209.297602,189.568416 209.079969,189.677755 208.861184,189.783641 C200.189252,194.039803 188.835482,197.245161 188.676575,197.285443 C185.650438,198.069231 181.323109,199.099319 176.448818,199.869295 L175.726828,199.980936 L175.609375,199.9982 C174.503937,200.163935 173.395045,200.310104 172.283849,200.436707 L172.181366,200.447065 C170.160487,200.677253 168.08779,200.844138 166.011639,200.914346 L165.980549,200.914346 C165.234378,200.941968 164.489359,200.954628 163.743188,200.954628 L162.884171,200.954628 C161.746491,200.938515 160.609962,200.887874 159.475737,200.800403 C159.449252,200.800403 159.421616,200.800403 159.39398,200.794648 C158.988653,200.763573 158.582174,200.725592 158.177998,200.680705 C157.482494,200.605895 156.78814,200.51382 156.09609,200.405632 C155.826639,200.360745 155.538765,200.313557 155.261254,200.265217 C155.134589,200.242199 155.009076,200.21918 154.883563,200.193859 L154.853624,200.188105 C154.454054,200.112143 154.056787,200.028125 153.660672,199.937201 C153.431524,199.885408 153.201224,199.833616 152.974379,199.772617 L152.838502,199.736938 C152.725655,199.709315 152.615111,199.679391 152.504568,199.649467 L152.443538,199.633353 L152.087725,199.53092 C151.958758,199.49409 151.830941,199.456109 151.701974,199.418128 L151.655914,199.404317 L151.320828,199.301884 C151.194163,199.262752 151.06865,199.221318 150.943136,199.181036 C150.839501,199.146507 150.737018,199.110828 150.633383,199.077451 L150.406538,198.998037 C150.187754,198.922075 149.971272,198.841509 149.75479,198.758642 L149.549824,198.679227 L149.380554,198.611322 C149.05468,198.480115 148.729957,198.343154 148.408689,198.199287 L148.194511,198.096854 L148.158814,198.08074 C148.082815,198.045061 148.007968,198.009382 147.931969,197.977156 C147.783426,197.905798 147.636034,197.832138 147.489794,197.757327 L147.446037,197.73546 L147.234161,197.623819 C146.857621,197.42816 146.48799,197.218689 146.12642,196.995408 L145.928362,196.874559 C145.825879,196.812409 145.732608,196.749107 145.63473,196.685806 L145.376795,196.514316 C145.283524,196.452166 145.190252,196.388864 145.099284,196.323261 L144.933468,196.205865 C144.75844,196.080413 144.586867,195.952659 144.417597,195.820302 C144.32778,195.751245 144.239115,195.679887 144.150449,195.614284 C143.953543,195.456606 143.761243,195.294324 143.571246,195.127438 L143.563185,195.120532 C143.377794,194.960552 143.197009,194.794817 143.02083,194.62563 L143.011618,194.61412 C142.919498,194.526649 142.829681,194.439178 142.739864,194.348254 C142.651199,194.25733 142.561382,194.167557 142.47502,194.076633 C142.387506,193.984558 142.299992,193.891332 142.214781,193.795805 C142.131873,193.706032 142.051269,193.615108 141.970664,193.523033 L141.943028,193.491958 C141.527337,193.009715 141.138131,192.504454 140.777712,191.978476 L140.634926,191.767855 C140.540503,191.628592 140.447232,191.488178 140.355112,191.347763 L140.083358,190.929973 C139.949785,190.726258 139.819665,190.52024 139.693001,190.313072 C139.602032,190.165752 139.512215,190.018432 139.42355,189.869961 C139.348703,189.743358 139.273855,189.617906 139.202462,189.493605 C139.16216,189.4257 139.124161,189.356644 139.086161,189.287587 C139.048162,189.216229 139.003253,189.14372 138.962951,189.071211 L138.898467,188.957269 C138.876589,188.919288 138.86968,188.907778 138.858165,188.882458 C138.779863,188.745496 138.703864,188.606233 138.630168,188.464668 C138.596775,188.403668 138.563381,188.341518 138.527685,188.280518 L138.42405,188.082557 L138.321566,187.885747 L138.123509,187.486372 C138.091267,187.420769 138.060176,187.355165 138.029086,187.289562 C137.961148,187.147997 137.896664,187.008734 137.83218,186.86947 C137.806847,186.813074 137.780362,186.756679 137.757332,186.700283 C137.668667,186.508076 137.584608,186.313568 137.505154,186.116758 C137.451034,185.986702 137.40152,185.857797 137.348551,185.728892 C137.200007,185.349083 137.060676,184.965822 136.93286,184.577956 C136.89486,184.462863 136.856861,184.34892 136.823468,184.233826 C136.74056,183.972564 136.665712,183.708999 136.598925,183.443133 C136.517169,183.133531 136.444625,182.820477 136.383595,182.506271 C136.344444,182.32097 136.309899,182.134518 136.281112,181.946916 C136.250022,181.761615 136.223537,181.576314 136.201659,181.392165 C136.154447,181.025016 136.121054,180.656716 136.101478,180.287266 C136.101478,180.226266 136.095721,180.164116 136.094569,180.103116 C136.088812,179.981117 136.085357,179.859118 136.084206,179.737118 C136.019722,174.820319 138.510412,170.091121 143.833788,164.772645 C153.315222,155.303892 158.835504,141.447771 158.835504,141.447771 C158.835504,141.447771 158.984047,140.866548 159.2938,140.030968 C159.397435,139.753592 159.505676,139.477368 159.619674,139.204596 C159.749793,138.896145 159.889124,138.591147 160.038819,138.291903 L160.082576,138.204432 C160.274876,137.822321 160.483297,137.450569 160.710143,137.088024 C160.76196,137.004006 160.812626,136.919987 160.872504,136.83712 C161.040622,136.586216 161.219105,136.343368 161.406799,136.107426 C161.551888,135.926729 161.706188,135.751787 161.86855,135.586052 C162.418966,135.019792 163.046532,134.557115 163.757006,134.309664 L163.846823,134.280891 C163.906701,134.261325 163.965427,134.24291 164.026457,134.225646 C164.09785,134.207231 164.169243,134.189967 164.240636,134.175004 L164.272877,134.16925 C164.423724,134.139325 164.57457,134.118608 164.727719,134.10825 L164.741537,134.10825 C164.820991,134.10825 164.900444,134.100194 164.9822,134.100194 C165.186015,134.101344 165.388679,134.117458 165.590191,134.148533 C166.444603,134.283192 167.258712,134.791906 167.958823,135.576845 L168.053245,135.687335 C168.281242,135.954352 168.488512,136.239784 168.672751,136.539027 C168.810931,136.761158 168.94105,136.994798 169.064261,137.239948 C169.113775,137.343532 169.160987,137.437909 169.208198,137.539191 C169.231228,137.590983 169.254258,137.641624 169.276136,137.694567 C169.322196,137.797001 169.364802,137.900585 169.407407,138.008773 C169.64807,138.625675 169.834613,139.262143 169.965884,139.911271 C170.105215,140.612191 170.18582,141.32347 170.20885,142.038201 C170.21691,142.352407 170.21691,142.670065 170.20885,142.992327 C170.203092,143.114326 170.197335,143.237477 170.188123,143.360627 C170.0937,144.72909 169.795462,146.075685 169.302621,147.356677 C169.253106,147.48328 169.198986,147.612185 169.14832,147.74109 C168.900748,148.332671 168.612873,148.905838 168.288151,149.458287 C168.10276,149.773644 167.902399,150.086698 167.688221,150.397451 L167.55695,150.583903 C167.049139,151.292879 166.482602,151.958121 165.863096,152.572721 C165.252802,153.183868 164.598751,153.748977 163.906701,154.265748 C163.212348,154.777914 162.561751,155.346477 161.960669,155.96453 C160.229968,157.780707 159.826944,159.381659 160.21615,160.595897 C160.26221,160.732859 160.31633,160.867518 160.378511,160.997574 C160.522448,161.279553 160.708991,161.538514 160.932382,161.764098 L160.993411,161.825097 C161.056743,161.886097 161.12353,161.944795 161.191469,162.00119 L161.260559,162.057586 C161.428677,162.186491 161.606008,162.301585 161.791399,162.401716 C161.844368,162.43049 161.893883,162.459263 161.954912,162.486886 C162.209393,162.613489 162.475389,162.714771 162.749446,162.791884 L162.825444,162.81145 L162.927928,162.839072 L163.017745,162.86094 L163.113319,162.881657 L163.208893,162.901223 L163.299862,162.916185 C163.3678,162.928845 163.43689,162.939203 163.504828,162.948411 L163.571615,162.957618 L163.690219,162.970279 L163.763915,162.977184 L163.885974,162.986392 L163.956215,162.986392 L164.08288,162.992147 L164.48245,162.992147 L164.596448,162.986392 L164.727719,162.978335 L164.887777,162.963373 L165.037472,162.944958 C165.070866,162.944958 165.105411,162.935751 165.139955,162.929996 C165.667342,162.852883 166.18091,162.704412 166.666842,162.488036 C166.770477,162.444301 166.87296,162.395962 166.967383,162.34532 C167.170046,162.244038 167.366953,162.130095 167.555798,162.004643 C167.819491,161.832003 168.068215,161.637495 168.301969,161.425722 L168.46433,161.271497 C168.489663,161.246176 168.516148,161.222007 168.540329,161.195535 C168.699236,161.036706 168.848931,160.868669 168.988262,160.692576 C169.234682,160.381823 169.453467,160.051504 169.643464,159.703922 C171.896946,155.60889 174.258668,151.573708 176.726329,147.604129 L177.064869,147.062038 L177.406864,146.518796 C177.578437,146.244873 177.75001,145.973252 177.921584,145.705084 L178.09546,145.434614 L178.442061,144.894825 C178.907266,144.17549 179.373623,143.464211 179.843434,142.759838 L180.194641,142.235011 C180.899357,141.192263 181.602923,140.177137 182.298428,139.211501 L182.64618,138.735014 C183.402714,137.689964 184.19149,136.669083 185.010205,135.672372 L185.336079,135.283356 C185.389048,135.217753 185.438563,135.154451 185.497289,135.09115 L185.816254,134.721699 C185.869223,134.660699 185.919889,134.600851 185.975161,134.542153 L186.283762,134.193419 L186.439214,134.025383 C186.588909,133.863101 186.740907,133.703121 186.895208,133.544291 C186.998842,133.441858 187.094417,133.338274 187.194597,133.242746 C187.778407,132.64541 188.422094,132.110225 189.116447,131.646397 L189.276506,131.543964 L189.438867,131.44038 C189.542502,131.375927 189.647288,131.313777 189.754377,131.255079 C192.476519,129.711674 194.731152,129.597731 196.027738,130.893685 C196.814212,131.679775 197.248326,132.981483 197.225296,134.791906 C197.225296,134.872472 197.225296,134.951886 197.218387,135.034754 L197.218387,135.124527 C197.218387,135.206243 197.211478,135.290262 197.205721,135.37428 C197.205721,135.476713 197.193054,135.580298 197.182691,135.682731 C197.172327,135.786315 197.167722,135.864579 197.157358,135.955503 C197.157358,135.981974 197.151601,136.008446 197.148146,136.034917 C197.140086,136.115483 197.129722,136.197199 197.119359,136.277765 C197.119359,136.303086 197.119359,136.327255 197.108995,136.352576 C197.09748,136.461915 197.081359,136.571254 197.061784,136.679442 C197.049117,136.779573 197.032996,136.879705 197.013421,136.979836 C197.00536,137.037383 196.993845,137.093779 196.984633,137.151326 C196.954694,137.314759 196.915543,137.477041 196.868332,137.63587 C196.779667,137.932811 196.671426,138.223998 196.54361,138.507128 C196.488338,138.630279 196.429611,138.753429 196.369733,138.874277 C196.245372,139.12403 196.104889,139.379538 195.950588,139.644253 C195.873438,139.774309 195.793984,139.908969 195.708774,140.043628 L195.579806,140.248495 C195.448535,140.454513 195.311507,140.662832 195.168721,140.873453 C195.025935,141.084075 194.872786,141.2993 194.708122,141.516827 C194.495095,141.806863 194.270552,142.102653 194.033344,142.401897 L193.85371,142.628631 C193.3459,143.260495 192.825422,143.882001 192.29343,144.493148 L191.870831,144.970787 L191.6555,145.212483 C191.361868,145.5405 191.067085,145.866215 190.769998,146.189628 L190.542002,146.435928 C190.391156,146.599361 190.2334,146.765096 190.082554,146.92968 C189.928253,147.096566 189.77165,147.262301 189.615046,147.428035 L189.140629,147.927542 L188.660454,148.428199 C188.500396,148.595085 188.339186,148.764272 188.176825,148.931158 L187.199203,149.938227 C182.529879,154.724971 177.609528,159.495602 175.944461,162.469621 C175.833918,162.66413 175.733737,162.863242 175.642769,163.066957 C175.406712,163.607897 175.307683,164.070574 175.37447,164.444628 C175.396348,164.567778 175.440105,164.686325 175.503438,164.793362 C175.597861,164.955644 175.711859,165.105266 175.84313,165.238774 C175.904159,165.298623 175.967491,165.355019 176.036581,165.40566 C176.378576,165.649658 176.793115,165.77511 177.213412,165.76245 L177.344683,165.76245 L177.479408,165.753243 L177.615285,165.73713 L177.72698,165.721016 C177.74195,165.719865 177.756919,165.716413 177.771889,165.71296 L177.874372,165.693394 L177.902008,165.686488 L178.014855,165.662319 L178.055157,165.65196 L178.176065,165.620885 L178.320002,165.5783 C178.414425,165.549527 178.508848,165.517301 178.605573,165.481622 C178.813994,165.407962 179.01781,165.322792 179.217019,165.227265 C179.267685,165.203095 179.319502,165.180076 179.369017,165.153605 L179.522166,165.077643 C179.722526,164.976361 179.921736,164.867022 180.122096,164.748475 C180.282154,164.654099 180.441061,164.55742 180.599968,164.454987 L180.754269,164.352553 C180.804935,164.320327 180.856752,164.28695 180.907418,164.248969 L181.060567,164.146536 L181.141172,164.09014 L181.36226,163.935914 C181.568378,163.793198 181.760678,163.647029 181.956433,163.498559 L181.973705,163.485898 L182.282307,163.246503 C182.704906,162.912732 183.106779,162.576659 183.469501,162.260151 L183.711316,162.047228 L183.734346,162.026511 L183.859859,161.91487 C184.156945,161.649004 184.42179,161.400402 184.642877,161.194384 L184.732694,161.106913 L184.950327,160.900895 L185.080447,160.774292 L185.125355,160.728255 L185.138022,160.715595 C185.248565,160.605105 185.248565,160.605105 185.359109,160.493464 L185.368321,160.484256 L185.409775,160.447426 C185.422442,160.433615 185.439714,160.419804 185.45929,160.40254 L185.475411,160.387578 L185.519167,160.348446 L185.752922,160.142428 L185.884192,160.023882 C185.948676,159.968637 186.018918,159.905335 186.090311,159.83743 L186.248066,159.699318 C186.275702,159.676299 186.303338,159.649828 186.332125,159.624507 L186.496789,159.48064 L186.739755,159.268868 L186.867572,159.157227 C187.368473,158.721022 187.978767,158.195044 188.677727,157.602312 L188.96445,157.360615 L189.438867,156.963542 L189.922496,156.558413 C190.55582,156.033586 191.237507,155.475382 191.958344,154.89531 L192.43161,154.515501 C192.834634,154.195541 193.249174,153.867524 193.668319,153.538356 C193.836438,153.405998 194.008011,153.273641 194.183039,153.142434 C194.612547,152.810964 195.044359,152.480646 195.477322,152.154931 C196.465308,151.409124 197.484383,150.662166 198.514974,149.933624 L198.958301,149.626324 C199.266902,149.41225 199.575504,149.199326 199.885257,148.991007 L200.165071,148.801102 C200.718941,148.428199 201.277418,148.063352 201.8405,147.706562 L202.120315,147.530469 L202.397826,147.357828 C202.675337,147.186339 202.952848,147.016 203.226904,146.851416 L203.502112,146.687983 L204.05368,146.366872 C204.234465,146.262137 204.414099,146.159704 204.593732,146.058421 L204.701973,145.997422 L205.13033,145.763782 C205.307661,145.667103 205.486143,145.573877 205.662322,145.482953 L205.927167,145.347143 L206.1828,145.217087 C206.767761,144.923598 207.363085,144.651977 207.968773,144.403375 C208.051681,144.368847 208.133437,144.33547 208.215194,144.299791 C208.377555,144.231885 208.538764,144.169735 208.698823,144.11449 C208.858881,144.060396 209.016636,144.004 209.172088,143.948755 C209.313723,143.901567 209.450751,143.857831 209.584325,143.816397 L209.629233,143.802586 C209.700626,143.780718 209.772019,143.760002 209.843412,143.741587 L209.864139,143.735832 C210.009227,143.694398 210.154316,143.656417 210.300556,143.621889 L210.312071,143.621889 C210.527402,143.570097 210.736974,143.526362 210.941941,143.491833 C211.012182,143.480324 211.081272,143.468815 211.148059,143.459607 C211.347268,143.429683 211.547629,143.408966 211.747989,143.395155 C211.874654,143.385947 212.002471,143.382494 212.129135,143.382494 L212.225861,143.382494 C212.354829,143.382494 212.479191,143.390551 212.602401,143.403211 C212.658824,143.403211 212.715248,143.41357 212.77052,143.421626 L212.79355,143.421626 C212.848822,143.427381 212.905245,143.436588 212.959365,143.448098 C213.013486,143.459607 213.068758,143.467664 213.121727,143.480324 L213.140151,143.480324 C213.19312,143.491833 213.242634,143.506796 213.297906,143.521758 C213.737778,143.640304 214.141954,143.863586 214.47704,144.172037 L214.506979,144.201961 L214.565705,144.259508 L214.62328,144.320508 C215.085031,144.806203 215.467328,145.362105 215.755203,145.967497 L215.800111,146.069931 C215.897988,146.300118 215.975139,146.538362 216.029259,146.78236 C216.178954,147.462564 216.138651,148.17154 215.911806,148.829876 C215.813929,149.116459 215.694173,149.394986 215.552539,149.662003 L215.458116,149.832341 C215.098849,150.434281 214.675097,150.994787 214.19262,151.503501 L214.088985,151.61284 C213.86214,151.853385 213.626083,152.087025 213.383117,152.311458 C213.305966,152.383967 213.226513,152.456476 213.145908,152.528985 L213.023849,152.639475 C212.77052,152.863907 212.511433,153.082585 212.248891,153.296659 C212.202831,153.333489 212.15562,153.370319 212.110711,153.409451 C211.927623,153.556771 211.738777,153.706393 211.543023,153.856014 C210.868245,154.371634 210.180801,154.868838 209.48069,155.348779 C209.068454,155.630758 208.642399,155.915039 208.202527,156.203924 C207.38266,156.741412 206.557036,157.26739 205.723352,157.783009 C205.482689,157.93148 205.240874,158.082252 204.994454,158.231874 C202.729457,159.624507 200.21804,161.113819 197.539655,162.733186 L196.846454,163.154429 C196.087616,163.617105 195.371385,164.059064 194.697758,164.479156 L194.358066,164.69323 L193.71553,165.105266 C193.461049,165.266397 193.213477,165.425226 192.972814,165.581753 C192.790878,165.697998 192.613547,165.813091 192.439671,165.927034 L192.096524,166.152618 C191.929557,166.261956 191.763741,166.371295 191.597926,166.482936 L191.436716,166.58537 C191.266294,166.699312 191.100478,166.810953 190.939269,166.921443 L190.675576,167.100989 L190.365823,167.316214 L190.080251,167.515326 C189.628864,167.831834 189.183234,168.155247 188.741059,168.484414 L188.586758,168.60181 C188.412882,168.733017 188.244763,168.864223 188.082402,168.991977 L187.870526,169.161165 C187.513562,169.447748 187.189991,169.722822 186.897511,169.985235 L186.754725,170.116442 C186.672969,170.191253 186.592364,170.266064 186.516365,170.339724 C186.462244,170.390365 186.41273,170.442157 186.35861,170.492798 L186.283762,170.566458 C186.119098,170.731042 185.95904,170.90023 185.803588,171.074021 L185.727589,171.161492 C185.558318,171.357151 185.410927,171.544754 185.280807,171.727753 L185.223232,171.81062 C185.073538,172.029298 184.941115,172.260636 184.828269,172.501182 L184.789118,172.5852 L184.764936,172.643898 L184.745361,172.694539 L184.718876,172.764746 C184.710816,172.788916 184.694695,172.831501 184.685483,172.868331 C184.638272,173.005292 184.603727,173.146857 184.580697,173.290724 L184.569182,173.367837 L184.55997,173.438044 L184.554212,173.505949 L184.554212,173.867343 C184.554212,173.897268 184.554212,173.928343 184.561121,173.959418 C184.562273,173.977833 184.564576,173.996248 184.566879,174.014663 C184.566879,174.044587 184.574939,174.074512 184.578394,174.105587 L184.600272,174.23219 L184.600272,174.237945 C184.608333,174.278228 184.616393,174.31851 184.626757,174.358793 C184.63712,174.399076 184.647483,174.443962 184.66015,174.486547 C184.696998,174.616603 184.741906,174.745508 184.793724,174.87096 C184.793724,174.880167 184.801784,174.890526 184.805239,174.899733 C184.819057,174.930808 184.831723,174.963035 184.846693,174.99411 C184.903116,175.125317 184.966448,175.253071 185.035538,175.378523 L185.108083,175.508578 L185.184082,175.639785 L185.263535,175.770992 C185.277353,175.79286 185.292322,175.812426 185.309595,175.831992 L185.336079,175.859614 L185.363715,175.884935 L185.394806,175.909104 C185.415533,175.924066 185.437411,175.936727 185.460441,175.949387 C185.483471,175.959745 185.508804,175.971255 185.534137,175.980462 C185.561773,175.98967 185.589409,175.997726 185.617045,176.004632 C186.281459,176.154254 187.647136,175.604106 189.460745,174.646527 L189.786619,174.473887 L190.338187,174.173492 L190.608789,174.023871 C190.799937,173.920286 190.996844,173.805193 191.196053,173.69125 L191.561078,173.485232 C193.959648,172.10526 196.825727,170.331667 199.78738,168.600659 C200.063739,168.438377 200.342402,168.277246 200.621064,168.116115 L201.180692,167.759325 C201.460506,167.598193 201.739169,167.439364 202.018983,167.282837 C203.209632,166.606086 204.416402,165.955807 205.635838,165.333151 L206.1828,165.055775 C206.546673,164.876229 206.907092,164.701287 207.262905,164.530948 C207.952652,164.204082 208.649308,163.894481 209.352874,163.600992 L209.738625,163.444465 L209.785837,163.42605 C211.828594,162.616941 213.681355,162.116284 215.180605,162.116284 C215.505328,162.113982 215.828898,162.140454 216.149015,162.195699 L216.158227,162.195699 C216.261862,162.214114 216.355133,162.23483 216.449556,162.259 L216.466828,162.259 C216.605008,162.292377 216.740885,162.334962 216.872156,162.387905 C216.976942,162.425886 217.078274,162.470772 217.176151,162.523715 C217.60566,162.741242 217.972988,163.062354 218.247044,163.458276 C218.270074,163.491653 218.291953,163.526181 218.31268,163.56186 C218.414012,163.716085 218.501525,163.878367 218.572918,164.048706 C218.615524,164.146536 218.654675,164.247818 218.691523,164.357157 C218.728371,164.467647 218.760612,164.573533 218.794006,164.687476 C219.038123,165.559885 219.013942,166.482936 218.724916,167.341535 Z" id="Shape" fill="#FF9D00" fillRule="nonzero"></path>
+            <path d="M205.169417,104.827718 L205.169417,104.263487 C205.169417,56.0689579 166.09852,17 117.882512,17 C69.6688088,17 30.5830519,56.0712609 30.5830519,104.263487 L30.5805699,104.452331 C30.5805699,104.577844 30.5805699,104.702205 30.5805699,104.827718 C30.5874292,105.015411 30.5893875,105.203104 30.5876596,105.390797 L30.5945712,105.805334 L30.596875,105.955028 L30.6026346,106.159993 C30.6049385,106.270536 30.6083942,106.379928 30.6083942,106.490471 L30.6199134,106.938402 L30.6383442,107.464633 L30.6441038,107.637357 L30.6671422,108.182012 L30.6671422,108.207345 L30.6993961,108.84412 L30.6993961,108.860241 C30.7109153,109.077873 30.7224345,109.295505 30.7362576,109.511985 C30.7477768,109.713496 30.7604479,109.913856 30.774271,110.114215 L30.7777268,110.149912 C30.7878637,110.321484 30.7993829,110.494208 30.8122844,110.66578 L30.8157402,110.710688 C30.8272594,110.876503 30.8399306,111.043469 30.8537536,111.208132 L30.8560575,111.240374 L30.8790959,111.528247 C30.9480961,112.358472 31.0287306,113.188698 31.1209996,114.01662 L31.1267592,114.068437 L31.1958745,114.676425 L31.2753572,115.316654 C31.3286912,115.742706 31.3855961,116.167607 31.4458417,116.592507 C31.4817816,116.84929 31.5191039,117.104921 31.5575781,117.360552 L31.5633377,117.391642 C31.6493863,117.969691 31.7422312,118.54774 31.8421029,119.123486 C32.1285859,120.7943 32.4650624,122.457054 32.8511867,124.108293 L32.8569463,124.134777 L32.8938079,124.290228 C32.9283655,124.437619 32.9629232,124.58501 32.9997847,124.733552 L33.0631404,124.656403 C35.5973693,121.62798 39.2328357,119.958317 43.300273,119.958317 C46.5602128,119.958317 49.9053949,121.034962 53.2563365,123.159464 C55.4795464,124.571192 57.9377483,127.072232 60.4673695,130.216955 C62.8080754,126.966295 66.0886346,124.807248 69.8415971,124.217684 C70.5580927,124.104838 71.2814999,124.047264 72.004907,124.046112 C80.5717524,124.046112 85.7312119,131.477839 87.6802643,138.161096 C88.6421193,140.420322 93.2843658,150.704294 100.283445,157.661606 C110.921447,168.286419 113.583539,179.250921 108.319254,190.990378 L108.336533,190.990378 C108.695933,191.029529 109.056484,191.066377 109.418188,191.09977 C109.633597,191.120497 109.849007,191.141224 110.064416,191.159647 L110.140443,191.166556 C110.298257,191.181526 110.457222,191.195344 110.616187,191.206859 L111.053918,191.242555 C111.470913,191.274797 111.889061,191.303584 112.309513,191.33122 L112.641266,191.350795 L112.905057,191.365764 L113.069781,191.374976 L113.583539,191.402612 L113.724073,191.40837 L114.265477,191.431399 L114.865628,191.454429 L115.349435,191.468247 L115.43007,191.471702 C115.531439,191.475156 115.635112,191.479762 115.737633,191.479762 L115.847066,191.482065 C116.5267,191.498186 117.205182,191.506246 117.884816,191.506246 L118.605919,191.506246 L119.121981,191.500489 C119.248692,191.49358 119.374252,191.49358 119.500963,191.49358 L119.701397,191.49358 L119.875338,191.490126 C119.943301,191.487823 120.012416,191.48552 120.08038,191.48552 L120.286574,191.48552 L120.690899,191.474005 L121.299114,191.453278 L121.969532,191.424491 C122.161903,191.41643 122.353122,191.407218 122.545493,191.396855 L122.751687,191.38534 L123.056947,191.368067 L123.237799,191.357704 L123.372574,191.349644 L123.991156,191.30819 C124.19735,191.295523 124.403544,191.279403 124.609738,191.263282 L125.169572,191.219525 L125.564681,191.186132 L125.996652,191.146981 C126.440142,191.105527 126.88248,191.061771 127.322515,191.015711 C127.603584,190.984621 127.882349,190.95353 128.162266,190.920137 L128.654137,190.861411 C123.471639,179.170317 126.154466,168.255328 136.749846,157.671969 C143.732798,150.697385 148.375045,140.41111 149.342659,138.153035 C151.292864,131.468627 156.447716,124.038052 165.016865,124.038052 C165.741424,124.039203 166.464831,124.095626 167.180175,124.209624 C170.929681,124.799188 174.211508,126.959386 176.555669,130.208895 C179.086443,127.064171 181.543493,124.563132 183.766702,123.151403 C187.117644,121.026901 190.46513,119.950256 193.721614,119.950256 C197.311004,119.950256 200.565184,121.251442 203.022234,123.637333 C203.157009,123.036254 203.287176,122.435175 203.411584,121.831794 C203.48761,121.455256 203.562485,121.077567 203.636208,120.698726 C203.726058,120.233523 203.811301,119.766018 203.889631,119.298512 C203.910366,119.171848 203.932252,119.045184 203.956443,118.917369 C203.994456,118.71816 204.027862,118.521255 204.058964,118.320896 L204.071635,118.244897 L204.153421,117.723272 L204.234056,117.194737 L204.235208,117.18898 C204.267462,116.967893 204.300867,116.745655 204.330817,116.523418 C204.355008,116.3553 204.378046,116.187182 204.399933,116.017913 L204.413756,115.921187 L204.485175,115.370774 L204.543923,114.902117 C204.579633,114.593518 204.61419,114.284918 204.647596,113.975167 C204.662571,113.851957 204.675242,113.727596 204.687913,113.603235 L204.699433,113.503055 C204.721319,113.296938 204.740902,113.091973 204.759333,112.885856 L204.805409,112.406835 C204.901019,111.34516 204.978198,110.283485 205.038098,109.219506 L205.038098,109.212597 L205.0692,108.648367 L205.074959,108.521703 L205.097998,107.986259 C205.107213,107.784748 205.115276,107.580934 205.122188,107.374817 L205.122188,107.359847 L205.127948,107.211305 C205.133707,107.084641 205.138315,106.957977 205.138315,106.832464 L205.140619,106.780647 C205.145226,106.663195 205.149834,106.541137 205.149834,106.42023 L205.15329,106.316596 C205.156746,106.19569 205.160201,106.075934 205.160201,105.955028 L205.162505,105.852545 C205.165961,105.698245 205.169417,105.545097 205.169417,105.390797 L205.169417,104.827718 Z M96.2309827,192.003691 C103.143668,181.868262 102.654101,174.261508 93.1680216,164.784733 C83.6819423,155.307957 78.1607792,141.448604 78.1607792,141.448604 C78.1607792,141.448604 76.0999904,133.397375 71.4001479,134.137784 C66.7003053,134.877042 63.2527174,146.906674 73.0923216,154.270463 C82.932041,161.634252 71.1352058,166.627119 67.3476856,159.717018 C63.5591287,152.805766 53.219475,135.041705 47.8572772,131.643653 C42.4962313,128.245602 38.7259899,130.150169 39.9896486,137.153541 C40.6174462,140.629894 46.4553879,146.562378 51.9097395,152.105659 C57.4435737,157.730695 62.5822986,162.95271 61.4845168,164.800854 C59.3039281,168.471809 51.6240628,160.488518 51.6240628,160.488518 C51.6240628,160.488518 27.576535,138.613632 22.3410486,144.314667 C17.5156465,149.568923 24.9570639,154.035559 36.4256013,160.919175 C37.4012794,161.505285 38.4057556,162.108666 39.4344221,162.730472 C52.5548159,170.671158 53.575419,172.765721 51.7139127,175.769962 C51.0262152,176.88 46.6339358,174.244236 41.2314207,171.001636 C32.0218028,165.474476 19.877087,158.186686 18.1630268,164.709886 C16.6781991,170.355649 25.6125077,173.81473 33.7151284,176.952544 C40.4653925,179.56643 46.6396954,181.956927 45.7319807,185.20183 C44.7908603,188.565337 39.6889969,185.760303 34.1113896,182.69273 C27.8506925,179.248619 20.9909958,175.475181 18.7470514,179.733396 C14.50337,187.782323 48.0173944,197.257947 48.2927038,197.327036 C59.1207724,200.134373 86.6193439,206.082978 96.2309827,192.003691 Z M140.768903,192.003691 C133.855066,181.868262 134.345784,174.261508 143.831864,164.784733 C153.317943,155.307957 158.840258,141.448604 158.840258,141.448604 C158.840258,141.448604 160.899895,133.397375 165.599737,134.137784 C170.29958,134.877042 173.748435,146.906674 163.907564,154.270463 C154.066692,161.634252 165.86468,166.627119 169.653352,159.717018 C173.440872,152.805766 183.775918,135.041705 189.136964,131.643653 C194.49801,128.245602 198.269403,130.150169 197.005744,137.153541 C196.377947,140.629894 190.540005,146.56353 185.084501,152.10681 C179.551819,157.730695 174.413094,162.95271 175.510876,164.800854 C177.690313,168.471809 185.37709,160.483912 185.37709,160.483912 C185.37709,160.483912 209.423465,138.609026 214.658952,144.310061 C219.484354,149.564317 212.041785,154.032104 200.573247,160.916873 C199.597569,161.50183 198.594245,162.10406 197.565578,162.727017 C184.444033,170.666552 183.424581,172.762266 185.286088,175.765356 C185.973785,176.875394 190.366065,174.23963 195.767428,170.998181 C204.978198,165.471022 217.122913,158.18208 218.836974,164.70528 C220.321801,170.351043 211.387493,173.811275 203.28372,176.94909 C196.533456,179.562976 190.360305,181.952321 191.266868,185.198376 C192.207988,188.561882 197.307548,185.755697 202.882851,182.688124 C209.143548,179.244013 216.004397,175.469423 218.249493,179.72879 C222.493175,187.783474 188.974543,197.248735 188.702689,197.318976 C177.87462,200.134373 150.375934,206.082978 140.768903,192.003691 Z" id="Shape" fill="#FFD21E"></path>
+            <path d="M146.614758,80.6109193 C147.976342,81.0911 148.989747,82.5534685 149.953577,83.9434653 C151.256362,85.8239816 152.46922,87.5723908 154.330012,86.5867567 C156.5263,85.424214 158.325988,83.6390445 159.503106,81.456405 C160.680224,79.2743398 161.180586,76.793253 160.941934,74.3272149 C160.764386,72.4833439 160.178709,70.7015059 159.226408,69.1104765 C158.274107,67.5193323 156.979392,66.1585139 155.436803,65.1258957 C153.89306,64.0933923 152.138336,63.414936 150.300602,63.139349 C148.461715,62.8637621 146.584783,62.9980518 144.804694,63.532339 C142.423941,64.2467514 140.30951,65.6481209 138.727721,67.5595388 C137.147086,69.4708418 136.169421,71.806381 135.91924,74.2709257 C135.670212,76.7360448 136.160198,79.2193143 137.326939,81.4070084 C138.189314,83.0233104 140.10314,82.2616841 142.123033,81.456405 C143.707127,80.825737 145.355784,80.1686476 146.614758,80.6109193 Z M87.3830077,80.6120681 C86.0214245,81.0922488 85.0068663,82.5546173 84.043036,83.9446141 C82.7402511,85.8239816 81.5273929,87.5735396 79.666601,86.5879055 C78.0260143,85.7182959 76.5998684,84.4960178 75.4896189,83.0106741 C74.3793695,81.5253304 73.6138392,79.8136815 73.2472148,77.9977254 C72.8805903,76.1821139 72.922095,74.3082604 73.3694229,72.5107992 C73.8179037,70.7133381 74.6595259,69.036956 75.8343381,67.6023875 C77.0114562,66.168623 78.4917888,65.0125133 80.1704214,64.2172284 C81.849054,63.4219434 83.684482,63.0074717 85.5429681,63.0033066 C87.4014542,62.9993155 89.238035,63.4058608 90.9201264,64.1936788 C92.6022177,64.9816117 94.0883149,66.1312884 95.2711974,67.5598834 C96.8529859,69.4711864 97.830651,71.8071852 98.0808318,74.2723042 C98.3298598,76.7374233 97.8398743,79.2208077 96.6719795,81.4081571 C95.8072992,83.0244592 93.8934736,82.2616841 91.8735805,81.456405 C90.2906392,80.825737 88.6419821,80.1686476 87.3830077,80.6120681 Z M137.451453,134.317638 C146.839575,126.947209 150.28792,114.91627 150.28792,107.504485 C150.28792,101.645821 146.331143,103.489577 139.998225,106.613049 L139.641977,106.789958 C133.827867,109.658406 126.089555,113.476876 117.594936,113.476876 C109.099164,113.476876 101.360852,109.657257 95.549048,106.788809 C89.0109124,103.561949 84.9100221,101.537838 84.9100221,107.505634 C84.9100221,115.150616 88.5785722,127.705389 98.649215,135 C99.9773639,132.311907 101.847379,129.925937 104.14397,127.991429 C106.439408,126.056922 109.111846,124.616379 111.992961,123.758257 C112.998296,123.45958 114.033606,125.183866 115.094281,126.948357 C116.116909,128.651965 117.161443,130.393482 118.225576,130.393482 C119.357731,130.393482 120.471439,128.677238 121.55863,127.0012 C122.694244,125.250494 123.801034,123.54344 124.872085,123.884621 C130.263078,125.608906 134.772098,129.348112 137.451453,134.317638 Z" id="Shape" fill="#32343D"></path>
+            <path d="M137,134.589063 C132.085163,138.426668 125.552521,141 117.046296,141 C109.053457,141 102.801266,138.72867 98,135.271151 C99.3361959,132.585286 101.217068,130.200275 103.524411,128.267693 C105.831753,126.333962 108.518052,124.892851 111.41295,124.033925 C113.398122,123.447146 115.500342,130.666483 117.67673,130.666483 C120.00725,130.666483 122.252013,123.493078 124.358868,124.160238 C129.775503,125.884979 134.306748,129.622682 137,134.589063 Z" id="Path" fill="#FF323D" fillRule="nonzero"></path>
+            <path d="M64.7091655,90.6371141 C63.8188025,91.2251504 62.8188988,91.6348571 61.7668713,91.8425321 C60.7147288,92.0502071 59.6311738,92.0524645 58.5782258,91.8493041 C57.5252778,91.6450151 56.5236482,91.2398231 55.6307538,90.6563014 C54.7378594,90.0716511 53.971305,89.3210865 53.3749298,88.4452396 C52.7785546,87.5705215 52.3642101,86.5874511 52.1555996,85.555848 C51.9469891,84.5231163 51.9481398,83.4599105 52.1590515,82.4271787 C52.3699633,81.3955756 52.786609,80.4147626 53.3848253,79.5400444 C53.9831565,78.6662292 54.7514369,77.9166804 55.645597,77.3345131 C57.4440428,76.1637452 59.642335,75.7399301 61.7587018,76.1560702 C63.8750686,76.5722103 65.7370296,77.7943327 66.9366838,79.5547171 C68.1356477,81.3154401 68.5751911,83.4700685 68.1575098,85.5468187 C67.7398285,87.6246976 66.4994417,89.455398 64.7091655,90.6371141 Z M181.39746,90.6371141 C180.506867,91.2251504 179.506963,91.6348571 178.455281,91.8425321 C177.403599,92.0502071 176.319699,92.0524645 175.266866,91.8493041 C174.214033,91.6450151 173.211828,91.2398231 172.318933,90.6563014 C171.426039,90.0716511 170.659715,89.3210865 170.063685,88.4452396 C169.466504,87.5705215 169.052275,86.5874511 168.844009,85.555848 C168.635744,84.5231163 168.636895,83.4599105 168.847461,82.4271787 C169.058028,81.3955756 169.474559,80.4147626 170.07289,79.5400444 C170.671221,78.6662292 171.439847,77.9166804 172.333892,77.3345131 C174.132338,76.1637452 176.331205,75.7399301 178.447227,76.1560702 C180.563248,76.5722103 182.424979,77.7943327 183.625094,79.5547171 C184.824057,81.3154401 185.263601,83.4700685 184.84592,85.5468187 C184.428238,87.6246976 183.187852,89.455398 181.39746,90.6371141 Z" id="Shape" fill="#FFAD03"></path>
+        </g>
+    </g>
+</svg>
+);
+
+export default HFLogo; 

frontend/src/components/Logo/Logo.js

@@ -0,0 +1,56 @@
+import React from "react";
+import { useNavigate, useSearchParams, useLocation } from "react-router-dom";
+import { Box } from "@mui/material";
+import HFLogo from "./HFLogo";
+import { useLeaderboard } from "../../pages/LeaderboardPage/components/Leaderboard/context/LeaderboardContext";
+
+const Logo = ({ height = "40px" }) => {
+  const navigate = useNavigate();
+  const [searchParams, setSearchParams] = useSearchParams();
+  const location = useLocation();
+  const { actions } = useLeaderboard();
+
+  const handleReset = () => {
+    // Reset all leaderboard state first
+    actions.resetAll();
+
+    // Then clean URL in one go
+    if (
+      location.pathname !== "/" ||
+      searchParams.toString() !== "" ||
+      location.hash !== ""
+    ) {
+      window.history.replaceState(null, "", "/");
+      navigate("/", { replace: true, state: { skipUrlSync: true } });
+      setSearchParams({}, { replace: true, state: { skipUrlSync: true } });
+    }
+  };
+
+  return (
+    <Box
+      onClick={handleReset}
+      sx={{
+        height,
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        cursor: "pointer",
+        transition: "opacity 0.2s ease",
+        "&:hover": {
+          opacity: 0.8,
+        },
+      }}
+    >
+      <Box
+        sx={{
+          height: "100%",
+          aspectRatio: "95/88", // Ratio du SVG original (width/height)
+        }}
+      >
+        <HFLogo />
+      </Box>
+    </Box>
+  );
+};
+
+export default Logo;