initial commit

.env.example

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

.gitignore

@@ -0,0 +1,45 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+__pycache__
+.cache/
+
+# dependencies
+
+frontend/node_modules
+/.pnp
+.pnp.js
+
+# testing
+
+/coverage
+
+# 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,62 @@
+# 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 poetry
+RUN pip install poetry
+
+# Create and configure cache directory
+RUN mkdir -p /app/.cache && \
+    chown -R user:user /app
+
+# Copy and install backend dependencies
+COPY backend/pyproject.toml backend/poetry.lock* ./
+RUN poetry config virtualenvs.create false \
+    && poetry install --no-interaction --no-ansi --no-root --only main
+
+# 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

@@ -1,12 +1,91 @@
 ---
-title: Open Llm Leaderboard
-emoji: 👀
-colorFrom: red
-colorTo: blue
+title: Open LLM Leaderboard
+emoji: 🏆
+colorFrom: blue
+colorTo: red
 sdk: docker
-pinned: false
+hf_oauth: true
+pinned: true
 license: apache-2.0
-short_description: copy of official llm leaderboard
+duplicated_from: open-llm-leaderboard/open_llm_leaderboard
+tags:
+- leaderboard
+- modality:text
+- submission:automatic
+- test:public
+- language:english
+- eval:code
+- eval:math
+short_description: Track, rank and evaluate open LLMs and chatbots
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Open LLM Leaderboard
+
+Modern React interface for comparing Large Language Models (LLMs) in an open and reproducible way.
+
+## Features
+
+- 📊 Interactive table with advanced sorting and filtering
+- 🔍 Semantic model search
+- 📌 Pin models for comparison
+- 📱 Responsive and modern interface
+- 🎨 Dark/Light mode
+- ⚡️ Optimized performance with virtualization
+
+## Architecture
+
+The project is split into two main parts:
+
+### Frontend (React)
+
+```
+frontend/
+├── src/
+│   ├── components/     # Reusable UI components
+│   ├── pages/         # Application pages
+│   ├── hooks/         # Custom React hooks
+│   ├── context/       # React contexts
+│   └── constants/     # Constants and configurations
+├── public/            # Static assets
+└── server.js          # Express server for production
+```
+
+### Backend (FastAPI)
+
+```
+backend/
+├── app/
+│   ├── api/           # API router and endpoints
+│   │   └── endpoints/ # Specific API endpoints
+│   ├── core/          # Core functionality
+│   ├── config/        # Configuration
+│   └── services/      # Business logic services
+│       ├── leaderboard.py
+│       ├── models.py
+│       ├── votes.py
+│       └── hf_service.py
+└── utils/             # Utility functions
+```
+
+## Technologies
+
+### Frontend
+
+- React
+- Material-UI
+- TanStack Table & Virtual
+- Express.js
+
+### Backend
+
+- FastAPI
+- Hugging Face API
+- Docker
+
+## Development
+
+The application is containerized using Docker and can be run using:
+
+```bash
+docker-compose up
+```

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/app/api/__init__.py

@@ -0,0 +1,5 @@
+"""
+API package initialization
+"""
+
+__all__ = ["endpoints"]

backend/app/api/dependencies.py

@@ -0,0 +1,34 @@
+from fastapi import Depends, HTTPException
+import logging
+from app.services.models import ModelService
+from app.services.votes import VoteService
+from app.core.formatting import LogFormatter
+
+logger = logging.getLogger(__name__)
+
+model_service = ModelService()
+vote_service = VoteService()
+
+async def get_model_service() -> ModelService:
+    """Dependency to get ModelService instance"""
+    try:
+        logger.info(LogFormatter.info("Initializing model service dependency"))
+        await model_service.initialize()
+        logger.info(LogFormatter.success("Model service initialized"))
+        return model_service
+    except Exception as e:
+        error_msg = "Failed to initialize model service"
+        logger.error(LogFormatter.error(error_msg, e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+async def get_vote_service() -> VoteService:
+    """Dependency to get VoteService instance"""
+    try:
+        logger.info(LogFormatter.info("Initializing vote service dependency"))
+        await vote_service.initialize()
+        logger.info(LogFormatter.success("Vote service initialized"))
+        return vote_service
+    except Exception as e:
+        error_msg = "Failed to initialize vote service"
+        logger.error(LogFormatter.error(error_msg, e))
+        raise HTTPException(status_code=500, detail=str(e)) 

backend/app/api/endpoints/leaderboard.py

@@ -0,0 +1,49 @@
+from fastapi import APIRouter
+from typing import List, Dict, Any
+from app.services.leaderboard import LeaderboardService
+from app.core.fastapi_cache import cached, build_cache_key
+import logging
+from app.core.formatting import LogFormatter
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+leaderboard_service = LeaderboardService()
+
+def leaderboard_key_builder(func, namespace: str = "leaderboard", **kwargs):
+    """Build cache key for leaderboard data"""
+    key_type = "raw" if func.__name__ == "get_leaderboard" else "formatted"
+    key = build_cache_key(namespace, key_type)
+    logger.debug(LogFormatter.info(f"Built leaderboard cache key: {key}"))
+    return key
+
+@router.get("")
+@cached(expire=300, key_builder=leaderboard_key_builder)
+async def get_leaderboard() -> List[Dict[str, Any]]:
+    """
+    Get raw leaderboard data
+    Response will be automatically GZIP compressed if size > 500 bytes
+    """
+    try:
+        logger.info(LogFormatter.info("Fetching raw leaderboard data"))
+        data = await leaderboard_service.fetch_raw_data()
+        logger.info(LogFormatter.success(f"Retrieved {len(data)} leaderboard entries"))
+        return data
+    except Exception as e:
+        logger.error(LogFormatter.error("Failed to fetch raw leaderboard data", e))
+        raise
+
+@router.get("/formatted")
+@cached(expire=300, key_builder=leaderboard_key_builder)
+async def get_formatted_leaderboard() -> List[Dict[str, Any]]:
+    """
+    Get formatted leaderboard data with restructured objects
+    Response will be automatically GZIP compressed if size > 500 bytes
+    """
+    try:
+        logger.info(LogFormatter.info("Fetching formatted leaderboard data"))
+        data = await leaderboard_service.get_formatted_data()
+        logger.info(LogFormatter.success(f"Retrieved {len(data)} formatted entries"))
+        return data
+    except Exception as e:
+        logger.error(LogFormatter.error("Failed to fetch formatted leaderboard data", e))
+        raise 

backend/app/api/endpoints/models.py

@@ -0,0 +1,116 @@
+from fastapi import APIRouter, HTTPException, Depends, Query
+from typing import Dict, Any, List
+import logging
+from app.services.models import ModelService
+from app.api.dependencies import get_model_service
+from app.core.fastapi_cache import cached
+from app.core.formatting import LogFormatter
+
+logger = logging.getLogger(__name__)
+router = APIRouter(tags=["models"])
+
+@router.get("/status")
+@cached(expire=300)
+async def get_models_status(
+    model_service: ModelService = Depends(get_model_service)
+) -> Dict[str, List[Dict[str, Any]]]:
+    """Get all models grouped by status"""
+    try:
+        logger.info(LogFormatter.info("Fetching status for all models"))
+        result = await model_service.get_models()
+        stats = {
+            status: len(models) for status, models in result.items()
+        }
+        for line in LogFormatter.stats(stats, "Models by Status"):
+            logger.info(line)
+        return result
+    except Exception as e:
+        logger.error(LogFormatter.error("Failed to get models status", e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/pending")
+@cached(expire=60)
+async def get_pending_models(
+    model_service: ModelService = Depends(get_model_service)
+) -> List[Dict[str, Any]]:
+    """Get all models waiting for evaluation"""
+    try:
+        logger.info(LogFormatter.info("Fetching pending models"))
+        models = await model_service.get_models()
+        pending = models.get("pending", [])
+        logger.info(LogFormatter.success(f"Found {len(pending)} pending models"))
+        return pending
+    except Exception as e:
+        logger.error(LogFormatter.error("Failed to get pending models", e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/submit")
+async def submit_model(
+    model_data: Dict[str, Any],
+    model_service: ModelService = Depends(get_model_service)
+) -> Dict[str, Any]:
+    try:
+        logger.info(LogFormatter.section("MODEL SUBMISSION"))
+        
+        user_id = model_data.pop('user_id', None)
+        if not user_id:
+            error_msg = "user_id is required"
+            logger.error(LogFormatter.error("Validation failed", error_msg))
+            raise ValueError(error_msg)
+            
+        # Log submission details
+        submission_info = {
+            "Model_ID": model_data.get("model_id"),
+            "User": user_id,
+            "Base_Model": model_data.get("base_model"),
+            "Precision": model_data.get("precision"),
+            "Model_Type": model_data.get("model_type")
+        }
+        for line in LogFormatter.tree(submission_info, "Submission Details"):
+            logger.info(line)
+            
+        result = await model_service.submit_model(model_data, user_id)
+        logger.info(LogFormatter.success("Model submitted successfully"))
+        return result
+        
+    except ValueError as e:
+        logger.error(LogFormatter.error("Invalid submission data", e))
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error(LogFormatter.error("Submission failed", e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/organization/{organization}/submissions")
+async def get_organization_submissions(
+    organization: str,
+    days: int = Query(default=7, ge=1, le=30),
+    model_service: ModelService = Depends(get_model_service)
+) -> List[Dict[str, Any]]:
+    """Get all submissions from an organization in the last n days"""
+    try:
+        submissions = await model_service.get_organization_submissions(organization, days)
+        return submissions
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/{model_id}/status")
+async def get_model_status(
+    model_id: str,
+    model_service: ModelService = Depends(get_model_service)
+) -> Dict[str, Any]:
+    try:
+        logger.info(LogFormatter.info(f"Checking status for model: {model_id}"))
+        status = await model_service.get_model_status(model_id)
+        
+        if status["status"] != "not_found":
+            logger.info(LogFormatter.success("Status found"))
+            for line in LogFormatter.tree(status, "Model Status"):
+                logger.info(line)
+        else:
+            logger.warning(LogFormatter.warning(f"No status found for model: {model_id}"))
+            
+        return status
+        
+    except Exception as e:
+        logger.error(LogFormatter.error("Failed to get model status", e))
+        raise HTTPException(status_code=500, detail=str(e)) 

backend/app/api/endpoints/votes.py

@@ -0,0 +1,126 @@
+from fastapi import APIRouter, HTTPException, Query, Depends, Response
+from typing import Dict, Any, List
+from app.services.votes import VoteService
+from app.core.fastapi_cache import cached, build_cache_key, invalidate_cache_key
+import logging
+from app.core.formatting import LogFormatter
+from datetime import datetime, timezone
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+vote_service = VoteService()
+
+CACHE_TTL = 30  # 30 seconds cache
+
+def model_votes_key_builder(func, namespace: str = "model_votes", **kwargs):
+    """Build cache key for model votes"""
+    provider = kwargs.get('provider')
+    model = kwargs.get('model')
+    key = build_cache_key(namespace, provider, model)
+    logger.debug(LogFormatter.info(f"Built model votes cache key: {key}"))
+    return key
+
+def user_votes_key_builder(func, namespace: str = "user_votes", **kwargs):
+    """Build cache key for user votes"""
+    user_id = kwargs.get('user_id')
+    key = build_cache_key(namespace, user_id)
+    logger.debug(LogFormatter.info(f"Built user votes cache key: {key}"))
+    return key
+
+@router.post("/{model_id:path}")
+async def add_vote(
+    response: Response,
+    model_id: str,
+    vote_type: str = Query(..., description="Type of vote (up/down)"),
+    user_id: str = Query(..., description="HuggingFace username"),
+    vote_data: Dict[str, Any] = None
+) -> Dict[str, Any]:
+    try:
+        logger.info(LogFormatter.section("ADDING VOTE"))
+        stats = {
+            "Model": model_id,
+            "User": user_id,
+            "Type": vote_type,
+            "Config": vote_data or {}
+        }
+        for line in LogFormatter.tree(stats, "Vote Details"):
+            logger.info(line)
+        
+        await vote_service.initialize()
+        result = await vote_service.add_vote(model_id, user_id, vote_type, vote_data)
+        
+        # Invalidate affected caches
+        try:
+            logger.info(LogFormatter.subsection("CACHE INVALIDATION"))
+            provider, model = model_id.split('/', 1)
+            
+            # Build and invalidate cache keys
+            model_cache_key = build_cache_key("model_votes", provider, model)
+            user_cache_key = build_cache_key("user_votes", user_id)
+            
+            await invalidate_cache_key(model_cache_key)
+            await invalidate_cache_key(user_cache_key)
+            
+            cache_stats = {
+                "Model_Cache": model_cache_key,
+                "User_Cache": user_cache_key
+            }
+            for line in LogFormatter.tree(cache_stats, "Invalidated Caches"):
+                logger.info(line)
+                
+        except Exception as e:
+            logger.error(LogFormatter.error("Failed to invalidate cache", e))
+        
+        # Add cache control headers
+        response.headers["Cache-Control"] = "no-cache"
+        
+        return result
+    except Exception as e:
+        logger.error(LogFormatter.error("Failed to add vote", e))
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.get("/model/{provider}/{model}")
+@cached(expire=CACHE_TTL, key_builder=model_votes_key_builder)
+async def get_model_votes(
+    response: Response,
+    provider: str, 
+    model: str
+) -> Dict[str, Any]:
+    """Get all votes for a specific model"""
+    try:
+        logger.info(LogFormatter.info(f"Fetching votes for model: {provider}/{model}"))
+        await vote_service.initialize()
+        model_id = f"{provider}/{model}"
+        result = await vote_service.get_model_votes(model_id)
+        
+        # Add cache control headers
+        response.headers["Cache-Control"] = f"max-age={CACHE_TTL}"
+        response.headers["Last-Modified"] = vote_service._last_sync.strftime("%a, %d %b %Y %H:%M:%S GMT")
+        
+        logger.info(LogFormatter.success(f"Found {result.get('total_votes', 0)} votes"))
+        return result
+    except Exception as e:
+        logger.error(LogFormatter.error("Failed to get model votes", e))
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.get("/user/{user_id}")
+@cached(expire=CACHE_TTL, key_builder=user_votes_key_builder)
+async def get_user_votes(
+    response: Response,
+    user_id: str
+) -> List[Dict[str, Any]]:
+    """Get all votes from a specific user"""
+    try:
+        logger.info(LogFormatter.info(f"Fetching votes for user: {user_id}"))
+        await vote_service.initialize()
+        votes = await vote_service.get_user_votes(user_id)
+        
+        # Add cache control headers
+        response.headers["Cache-Control"] = f"max-age={CACHE_TTL}"
+        response.headers["Last-Modified"] = vote_service._last_sync.strftime("%a, %d %b %Y %H:%M:%S GMT")
+        
+        logger.info(LogFormatter.success(f"Found {len(votes)} votes"))
+        return votes
+    except Exception as e:
+        logger.error(LogFormatter.error("Failed to get user votes", e))
+        raise HTTPException(status_code=400, detail=str(e)) 

backend/app/api/router.py

@@ -0,0 +1,9 @@
+from fastapi import APIRouter
+
+from app.api.endpoints import leaderboard, votes, models
+
+router = APIRouter()
+
+router.include_router(leaderboard.router, prefix="/leaderboard", tags=["leaderboard"])
+router.include_router(votes.router, prefix="/votes", tags=["votes"])
+router.include_router(models.router, prefix="/models", tags=["models"]) 

backend/app/asgi.py

@@ -0,0 +1,106 @@
+"""
+ASGI entry point for the Open LLM Leaderboard API.
+"""
+import os
+import uvicorn
+import logging
+import logging.config
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.middleware.gzip import GZipMiddleware
+import sys
+
+from app.api.router import router
+from app.core.fastapi_cache import setup_cache
+from app.core.formatting import LogFormatter
+from app.config import hf_config
+
+# Configure logging before anything else
+LOGGING_CONFIG = {
+    "version": 1,
+    "disable_existing_loggers": True,
+    "formatters": {
+        "default": {
+            "format": "%(name)s - %(levelname)s - %(message)s",
+        }
+    },
+    "handlers": {
+        "default": {
+            "formatter": "default",
+            "class": "logging.StreamHandler",
+            "stream": "ext://sys.stdout",
+        }
+    },
+    "loggers": {
+        "uvicorn": {
+            "handlers": ["default"],
+            "level": "WARNING",
+            "propagate": False,
+        },
+        "uvicorn.error": {
+            "level": "WARNING",
+            "handlers": ["default"],
+            "propagate": False,
+        },
+        "uvicorn.access": {
+            "handlers": ["default"],
+            "level": "WARNING",
+            "propagate": False,
+        },
+        "app": {
+            "handlers": ["default"],
+            "level": "WARNING",
+            "propagate": False,
+        }
+    },
+    "root": {
+        "handlers": ["default"],
+        "level": "WARNING",
+    }
+}
+
+# Apply logging configuration
+logging.config.dictConfig(LOGGING_CONFIG)
+logger = logging.getLogger("app")
+
+# Create FastAPI application
+app = FastAPI(
+    title="Open LLM Leaderboard",
+    version="1.0.0",
+    docs_url="/docs",
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Add GZIP compression
+app.add_middleware(GZipMiddleware, minimum_size=500)
+
+# Include API router
+app.include_router(router, prefix="/api")
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize services on startup"""
+    logger.info("\n")
+    logger.info(LogFormatter.section("APPLICATION STARTUP"))
+    
+    # Log HF configuration
+    logger.info(LogFormatter.section("HUGGING FACE CONFIGURATION"))
+    logger.info(LogFormatter.info(f"Organization: {hf_config.HF_ORGANIZATION}"))
+    logger.info(LogFormatter.info(f"Token Status: {'Present' if hf_config.HF_TOKEN else 'Missing'}"))
+    logger.info(LogFormatter.info(f"Using repositories:"))
+    logger.info(LogFormatter.info(f"  - Queue: {hf_config.QUEUE_REPO}"))
+    logger.info(LogFormatter.info(f"  - Aggregated: {hf_config.AGGREGATED_REPO}"))
+    logger.info(LogFormatter.info(f"  - Votes: {hf_config.VOTES_REPO}"))
+    logger.info(LogFormatter.info(f"  - Official Providers: {hf_config.OFFICIAL_PROVIDERS_REPO}"))
+    
+    # Setup cache
+    setup_cache()
+    logger.info(LogFormatter.success("FastAPI Cache initialized with in-memory backend")) 

backend/app/config/__init__.py

@@ -0,0 +1,6 @@
+"""
+Configuration module for the Open LLM Leaderboard backend.
+All configuration values are imported from base.py to avoid circular dependencies.
+"""
+
+from .base import *

backend/app/config/base.py

@@ -0,0 +1,38 @@
+import os
+from pathlib import Path
+
+# Server configuration
+HOST = "0.0.0.0"
+PORT = 7860
+WORKERS = 4
+RELOAD = True if os.environ.get("ENVIRONMENT") == "development" else False
+
+# CORS configuration
+ORIGINS = ["http://localhost:3000"] if os.getenv("ENVIRONMENT") == "development" else ["*"]
+
+# Cache configuration
+CACHE_TTL = int(os.environ.get("CACHE_TTL", 300))  # 5 minutes default
+
+# Rate limiting
+RATE_LIMIT_PERIOD = 7  # days
+RATE_LIMIT_QUOTA = 5
+HAS_HIGHER_RATE_LIMIT = []
+
+# HuggingFace configuration
+HF_TOKEN = os.environ.get("HF_TOKEN")
+HF_ORGANIZATION = "open-llm-leaderboard"
+API = {
+    "INFERENCE": "https://api-inference.huggingface.co/models",
+    "HUB": "https://huggingface.co"
+}
+
+# Cache paths
+CACHE_ROOT = Path(os.environ.get("HF_HOME", ".cache"))
+DATASETS_CACHE = CACHE_ROOT / "datasets"
+MODELS_CACHE = CACHE_ROOT / "models"
+VOTES_CACHE = CACHE_ROOT / "votes"
+EVAL_CACHE = CACHE_ROOT / "eval-queue"
+
+# Repository configuration
+QUEUE_REPO = f"{HF_ORGANIZATION}/requests"
+EVAL_REQUESTS_PATH = EVAL_CACHE / "eval_requests.jsonl"

backend/app/config/hf_config.py

@@ -0,0 +1,30 @@
+import os
+import logging
+from typing import Optional
+from huggingface_hub import HfApi
+from pathlib import Path
+from app.core.cache import cache_config
+
+logger = logging.getLogger(__name__)
+
+# Organization or user who owns the datasets
+HF_ORGANIZATION = "open-llm-leaderboard"
+
+# Get HF token directly from environment
+HF_TOKEN = os.environ.get("HF_TOKEN")
+if not HF_TOKEN:
+    logger.warning("HF_TOKEN not found in environment variables. Some features may be limited.")
+
+# Initialize HF API
+API = HfApi(token=HF_TOKEN)
+
+# Repository configuration
+QUEUE_REPO = f"{HF_ORGANIZATION}/requests"
+AGGREGATED_REPO = f"{HF_ORGANIZATION}/contents"
+VOTES_REPO = f"{HF_ORGANIZATION}/votes"
+OFFICIAL_PROVIDERS_REPO = f"{HF_ORGANIZATION}/official-providers"
+
+# File paths from cache config
+VOTES_PATH = cache_config.votes_file
+EVAL_REQUESTS_PATH = cache_config.eval_requests_file
+MODEL_CACHE_DIR = cache_config.models_cache

backend/app/config/logging_config.py

@@ -0,0 +1,38 @@
+import logging
+import sys
+from tqdm import tqdm
+
+def get_tqdm_handler():
+    """
+    Creates a special handler for tqdm that doesn't interfere with other logs.
+    """
+    class TqdmLoggingHandler(logging.Handler):
+        def emit(self, record):
+            try:
+                msg = self.format(record)
+                tqdm.write(msg)
+                self.flush()
+            except Exception:
+                self.handleError(record)
+
+    return TqdmLoggingHandler()
+
+def setup_service_logger(service_name: str) -> logging.Logger:
+    """
+    Configure a specific logger for a given service.
+    """
+    logger = logging.getLogger(f"app.services.{service_name}")
+    
+    # If the logger already has handlers, don't reconfigure it
+    if logger.handlers:
+        return logger
+    
+    # Add tqdm handler for this service
+    tqdm_handler = get_tqdm_handler()
+    tqdm_handler.setFormatter(logging.Formatter('%(name)s - %(levelname)s - %(message)s'))
+    logger.addHandler(tqdm_handler)
+    
+    # Don't propagate logs to parent loggers
+    logger.propagate = False
+    
+    return logger

backend/app/core/cache.py

@@ -0,0 +1,109 @@
+import os
+import shutil
+from pathlib import Path
+from datetime import timedelta
+import logging
+from app.core.formatting import LogFormatter
+from app.config.base import (
+    CACHE_ROOT,
+    DATASETS_CACHE,
+    MODELS_CACHE,
+    VOTES_CACHE,
+    EVAL_CACHE,
+    CACHE_TTL
+)
+
+logger = logging.getLogger(__name__)
+
+class CacheConfig:
+    def __init__(self):
+        # Get cache paths from config
+        self.cache_root = CACHE_ROOT
+        self.datasets_cache = DATASETS_CACHE
+        self.models_cache = MODELS_CACHE
+        self.votes_cache = VOTES_CACHE
+        self.eval_cache = EVAL_CACHE
+        
+        # Specific files
+        self.votes_file = self.votes_cache / "votes_data.jsonl"
+        self.eval_requests_file = self.eval_cache / "eval_requests.jsonl"
+        
+        # Cache TTL
+        self.cache_ttl = timedelta(seconds=CACHE_TTL)
+        
+        self._initialize_cache_dirs()
+        self._setup_environment()
+        
+    def _initialize_cache_dirs(self):
+        """Initialize all necessary cache directories"""
+        try:
+            logger.info(LogFormatter.section("CACHE INITIALIZATION"))
+            
+            cache_dirs = {
+                "Root": self.cache_root,
+                "Datasets": self.datasets_cache,
+                "Models": self.models_cache,
+                "Votes": self.votes_cache,
+                "Eval": self.eval_cache
+            }
+            
+            for name, cache_dir in cache_dirs.items():
+                cache_dir.mkdir(parents=True, exist_ok=True)
+                logger.info(LogFormatter.success(f"{name} cache directory: {cache_dir}"))
+                
+        except Exception as e:
+            logger.error(LogFormatter.error("Failed to create cache directories", e))
+            raise
+            
+    def _setup_environment(self):
+        """Configure HuggingFace environment variables"""
+        logger.info(LogFormatter.subsection("ENVIRONMENT SETUP"))
+
+        env_vars = {
+            "HF_HOME": str(self.cache_root),
+            "HF_DATASETS_CACHE": str(self.datasets_cache)
+        }
+
+        for var, value in env_vars.items():
+            os.environ[var] = value
+            logger.info(LogFormatter.info(f"Set {var}={value}"))
+
+        
+    def get_cache_path(self, cache_type: str) -> Path:
+        """Returns the path for a specific cache type"""
+        cache_paths = {
+            "datasets": self.datasets_cache,
+            "models": self.models_cache,
+            "votes": self.votes_cache,
+            "eval": self.eval_cache
+        }
+        return cache_paths.get(cache_type, self.cache_root)
+
+    def flush_cache(self, cache_type: str = None):
+        """Flush specified cache or all caches if no type is specified"""
+        try:
+            if cache_type:
+                logger.info(LogFormatter.section(f"FLUSHING {cache_type.upper()} CACHE"))
+                cache_dir = self.get_cache_path(cache_type)
+                if cache_dir.exists():
+                    stats = {
+                        "Cache_Type": cache_type,
+                        "Directory": str(cache_dir)
+                    }
+                    for line in LogFormatter.tree(stats, "Cache Details"):
+                        logger.info(line)
+                    shutil.rmtree(cache_dir)
+                    cache_dir.mkdir(parents=True, exist_ok=True)
+                    logger.info(LogFormatter.success("Cache cleared successfully"))
+            else:
+                logger.info(LogFormatter.section("FLUSHING ALL CACHES"))
+                for cache_type in ["datasets", "models", "votes", "eval"]:
+                    self.flush_cache(cache_type)
+                logger.info(LogFormatter.success("All caches cleared successfully"))
+                
+        except Exception as e:
+            logger.error(LogFormatter.error("Failed to flush cache", e))
+            raise
+
+# Singleton instance of cache configuration
+cache_config = CacheConfig() 

backend/app/core/fastapi_cache.py

@@ -0,0 +1,76 @@
+from fastapi_cache import FastAPICache
+from fastapi_cache.backends.inmemory import InMemoryBackend
+from fastapi_cache.decorator import cache
+from datetime import timedelta
+from app.config import CACHE_TTL
+import logging
+from app.core.formatting import LogFormatter
+from typing import Optional, Any
+
+logger = logging.getLogger(__name__)
+
+class CustomInMemoryBackend(InMemoryBackend):
+    def __init__(self):
+        """Initialize the cache backend"""
+        super().__init__()
+        self.cache = {}
+
+    async def delete(self, key: str) -> bool:
+        """Delete a key from the cache"""
+        try:
+            if key in self.cache:
+                del self.cache[key]
+                return True
+            return False
+        except Exception as e:
+            logger.error(LogFormatter.error(f"Failed to delete key {key} from cache", e))
+            return False
+
+    async def get(self, key: str) -> Any:
+        """Get a value from the cache"""
+        return self.cache.get(key)
+
+    async def set(self, key: str, value: Any, expire: Optional[int] = None) -> None:
+        """Set a value in the cache"""
+        self.cache[key] = value
+
+def setup_cache():
+    """Initialize FastAPI Cache with in-memory backend"""
+    try:
+        logger.info(LogFormatter.section("CACHE INITIALIZATION"))
+        FastAPICache.init(
+            backend=CustomInMemoryBackend(),
+            prefix="fastapi-cache"
+        )
+        logger.info(LogFormatter.success("Cache initialized successfully"))
+    except Exception as e:
+        logger.error(LogFormatter.error("Failed to initialize cache", e))
+        raise
+
+async def invalidate_cache_key(key: str):
+    """Invalidate a specific cache key"""
+    try:
+        backend = FastAPICache.get_backend()
+        if hasattr(backend, 'delete'):
+            await backend.delete(key)
+            logger.info(LogFormatter.success(f"Cache invalidated for key: {key}"))
+        else:
+            logger.warning(LogFormatter.warning("Cache backend does not support deletion"))
+    except Exception as e:
+        logger.error(LogFormatter.error(f"Failed to invalidate cache key: {key}", e))
+
+def build_cache_key(*args) -> str:
+    """Build a cache key from multiple arguments"""
+    return ":".join(str(arg) for arg in args if arg is not None)
+
+def cached(expire: int = CACHE_TTL, key_builder=None):
+    """Decorator for caching endpoint responses
+    
+    Args:
+        expire (int): Cache TTL in seconds
+        key_builder (callable, optional): Custom key builder function
+    """
+    return cache(
+        expire=expire,
+        key_builder=key_builder
+    ) 

backend/app/core/formatting.py

@@ -0,0 +1,104 @@
+import logging
+from typing import Dict, Any, List, Optional
+
+logger = logging.getLogger(__name__)
+
+class LogFormatter:
+    """Utility class for consistent log formatting across the application"""
+    
+    @staticmethod
+    def section(title: str) -> str:
+        """Create a section header"""
+        return f"\n{'='*20} {title.upper()} {'='*20}"
+    
+    @staticmethod
+    def subsection(title: str) -> str:
+        """Create a subsection header"""
+        return f"\n{'─'*20} {title} {'─'*20}"
+    
+    @staticmethod
+    def tree(items: Dict[str, Any], title: str = None) -> List[str]:
+        """Create a tree view of dictionary data"""
+        lines = []
+        if title:
+            lines.append(f"📊 {title}:")
+        
+        # Get the maximum length for alignment
+        max_key_length = max(len(str(k)) for k in items.keys())
+        
+        # Format each item
+        for i, (key, value) in enumerate(items.items()):
+            prefix = "└──" if i == len(items) - 1 else "├──"
+            if isinstance(value, (int, float)):
+                value = f"{value:,}"  # Add thousand separators
+            lines.append(f"{prefix} {str(key):<{max_key_length}}: {value}")
+        
+        return lines
+    
+    @staticmethod
+    def stats(stats: Dict[str, int], title: str = None) -> List[str]:
+        """Format statistics with icons"""
+        lines = []
+        if title:
+            lines.append(f"📊 {title}:")
+        
+        # Get the maximum length for alignment
+        max_key_length = max(len(str(k)) for k in stats.keys())
+        
+        # Format each stat with an appropriate icon
+        icons = {
+            "total": "📌",
+            "success": "✅",
+            "error": "❌",
+            "pending": "⏳",
+            "processing": "⚙️",
+            "finished": "✨",
+            "evaluating": "🔄",
+            "downloads": "⬇️",
+            "files": "📁",
+            "cached": "💾",
+            "size": "📏",
+            "time": "⏱️",
+            "rate": "🚀"
+        }
+        
+        # Format each item
+        for i, (key, value) in enumerate(stats.items()):
+            prefix = "└──" if i == len(stats) - 1 else "├──"
+            icon = icons.get(key.lower().split('_')[0], "•")
+            if isinstance(value, (int, float)):
+                value = f"{value:,}"  # Add thousand separators
+            lines.append(f"{prefix} {icon} {str(key):<{max_key_length}}: {value}")
+        
+        return lines
+    
+    @staticmethod
+    def progress_bar(current: int, total: int, width: int = 20) -> str:
+        """Create a progress bar"""
+        percentage = (current * 100) // total
+        filled = "█" * (percentage * width // 100)
+        empty = "░" * (width - len(filled))
+        return f"{filled}{empty} {percentage:3d}%"
+    
+    @staticmethod
+    def error(message: str, error: Optional[Exception] = None) -> str:
+        """Format error message"""
+        error_msg = f"\n❌ Error: {message}"
+        if error:
+            error_msg += f"\n   └── Details: {str(error)}"
+        return error_msg
+    
+    @staticmethod
+    def success(message: str) -> str:
+        """Format success message"""
+        return f"✅ {message}"
+    
+    @staticmethod
+    def warning(message: str) -> str:
+        """Format warning message"""
+        return f"⚠️  {message}"
+    
+    @staticmethod
+    def info(message: str) -> str:
+        """Format info message"""
+        return f"ℹ️  {message}"

backend/app/main.py

@@ -0,0 +1,18 @@
+from fastapi import FastAPI
+from app.config.logging_config import setup_logging
+import logging
+
+# Initialize logging configuration
+setup_logging()
+logger = logging.getLogger(__name__)
+
+app = FastAPI(title="Open LLM Leaderboard API")
+
+@app.on_event("startup")
+async def startup_event():
+    logger.info("Starting up the application...")
+
+# Import and include routers after app initialization
+from app.api import models, votes
+app.include_router(models.router, prefix="/api", tags=["models"])
+app.include_router(votes.router, prefix="/api", tags=["votes"]) 

backend/app/services/__init__.py

@@ -0,0 +1,3 @@
+from . import hf_service, leaderboard, votes, models
+
+__all__ = ["hf_service", "leaderboard", "votes", "models"]

backend/app/services/hf_service.py

@@ -0,0 +1,50 @@
+from typing import Optional
+from huggingface_hub import HfApi
+from app.config import HF_TOKEN, API
+from app.core.cache import cache_config
+from app.core.formatting import LogFormatter
+import logging
+
+logger = logging.getLogger(__name__)
+
+class HuggingFaceService:
+    def __init__(self):
+        self.api = API
+        self.token = HF_TOKEN
+        self.cache_dir = cache_config.models_cache
+
+    async def check_authentication(self) -> bool:
+        """Check if the HF token is valid"""
+        if not self.token:
+            return False
+        try:
+            logger.info(LogFormatter.info("Checking HF token validity..."))
+            self.api.get_token_permission()
+            logger.info(LogFormatter.success("HF token is valid"))
+            return True
+        except Exception as e:
+            logger.error(LogFormatter.error("HF token validation failed", e))
+            return False
+
+    async def get_user_info(self) -> Optional[dict]:
+        """Get information about the authenticated user"""
+        try:
+            logger.info(LogFormatter.info("Fetching user information..."))
+            info = self.api.get_token_permission()
+            logger.info(LogFormatter.success(f"User info retrieved for: {info.get('user', 'Unknown')}"))
+            return info
+        except Exception as e:
+            logger.error(LogFormatter.error("Failed to get user info", e))
+            return None
+
+    def _log_repo_operation(self, operation: str, repo: str, details: str = None):
+        """Helper to log repository operations"""
+        logger.info(LogFormatter.section(f"HF REPOSITORY OPERATION - {operation.upper()}"))
+        stats = {
+            "Operation": operation,
+            "Repository": repo,
+        }
+        if details:
+            stats["Details"] = details
+        for line in LogFormatter.tree(stats):
+            logger.info(line) 

backend/app/services/leaderboard.py

@@ -0,0 +1,208 @@
+from app.core.cache import cache_config
+from datetime import datetime
+from typing import List, Dict, Any
+import datasets
+from fastapi import HTTPException
+import logging
+from app.config.base import HF_ORGANIZATION
+from app.core.formatting import LogFormatter
+
+logger = logging.getLogger(__name__)
+
+class LeaderboardService:
+    def __init__(self):
+        pass
+        
+    async def fetch_raw_data(self) -> List[Dict[str, Any]]:
+        """Fetch raw leaderboard data from HuggingFace dataset"""
+        try:
+            logger.info(LogFormatter.section("FETCHING LEADERBOARD DATA"))
+            logger.info(LogFormatter.info(f"Loading dataset from {HF_ORGANIZATION}/contents"))
+            
+            dataset = datasets.load_dataset(
+                f"{HF_ORGANIZATION}/contents",
+                cache_dir=cache_config.get_cache_path("datasets")
+            )["train"]
+            
+            df = dataset.to_pandas()
+            data = df.to_dict('records')
+            
+            stats = {
+                "Total_Entries": len(data),
+                "Dataset_Size": f"{df.memory_usage(deep=True).sum() / 1024 / 1024:.1f}MB"
+            }
+            for line in LogFormatter.stats(stats, "Dataset Statistics"):
+                logger.info(line)
+                
+            return data
+            
+        except Exception as e:
+            logger.error(LogFormatter.error("Failed to fetch leaderboard data", e))
+            raise HTTPException(status_code=500, detail=str(e))
+
+    async def get_formatted_data(self) -> List[Dict[str, Any]]:
+        """Get formatted leaderboard data"""
+        try:
+            logger.info(LogFormatter.section("FORMATTING LEADERBOARD DATA"))
+            
+            raw_data = await self.fetch_raw_data()
+            formatted_data = []
+            type_counts = {}
+            error_count = 0
+            
+            # Initialize progress tracking
+            total_items = len(raw_data)
+            logger.info(LogFormatter.info(f"Processing {total_items:,} entries..."))
+            
+            for i, item in enumerate(raw_data, 1):
+                try:
+                    formatted_item = await self.transform_data(item)
+                    formatted_data.append(formatted_item)
+                    
+                    # Count model types
+                    model_type = formatted_item["model"]["type"]
+                    type_counts[model_type] = type_counts.get(model_type, 0) + 1
+                    
+                except Exception as e:
+                    error_count += 1
+                    logger.error(LogFormatter.error(f"Failed to format entry {i}/{total_items}", e))
+                    continue
+                
+                # Log progress every 10%
+                if i % max(1, total_items // 10) == 0:
+                    progress = (i / total_items) * 100
+                    logger.info(LogFormatter.info(f"Progress: {LogFormatter.progress_bar(i, total_items)}"))
+            
+            # Log final statistics
+            stats = {
+                "Total_Processed": total_items,
+                "Successful": len(formatted_data),
+                "Failed": error_count
+            }
+            logger.info(LogFormatter.section("PROCESSING SUMMARY"))
+            for line in LogFormatter.stats(stats, "Processing Statistics"):
+                logger.info(line)
+            
+            # Log model type distribution
+            type_stats = {f"Type_{k}": v for k, v in type_counts.items()}
+            logger.info(LogFormatter.subsection("MODEL TYPE DISTRIBUTION"))
+            for line in LogFormatter.stats(type_stats):
+                logger.info(line)
+                
+            return formatted_data
+            
+        except Exception as e:
+            logger.error(LogFormatter.error("Failed to format leaderboard data", e))
+            raise HTTPException(status_code=500, detail=str(e))
+
+    async def transform_data(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Transform raw data into the format expected by the frontend"""
+        try:
+            # Extract model name for logging
+            model_name = data.get("fullname", "Unknown")
+            logger.debug(LogFormatter.info(f"Transforming data for model: {model_name}"))
+            
+            # Create unique ID combining model name, precision, sha and chat template status
+            unique_id = f"{data.get('fullname', 'Unknown')}_{data.get('Precision', 'Unknown')}_{data.get('Model sha', 'Unknown')}_{str(data.get('Chat Template', False))}"
+            
+            evaluations = {
+                "ifeval": {
+                    "name": "IFEval",
+                    "value": data.get("IFEval Raw", 0),
+                    "normalized_score": data.get("IFEval", 0)
+                },
+                "bbh": {
+                    "name": "BBH",
+                    "value": data.get("BBH Raw", 0),
+                    "normalized_score": data.get("BBH", 0)
+                },
+                "math": {
+                    "name": "MATH Level 5",
+                    "value": data.get("MATH Lvl 5 Raw", 0),
+                    "normalized_score": data.get("MATH Lvl 5", 0)
+                },
+                "gpqa": {
+                    "name": "GPQA",
+                    "value": data.get("GPQA Raw", 0),
+                    "normalized_score": data.get("GPQA", 0)
+                },
+                "musr": {
+                    "name": "MUSR",
+                    "value": data.get("MUSR Raw", 0),
+                    "normalized_score": data.get("MUSR", 0)
+                },
+                "mmlu_pro": {
+                    "name": "MMLU-PRO",
+                    "value": data.get("MMLU-PRO Raw", 0),
+                    "normalized_score": data.get("MMLU-PRO", 0)
+                }
+            }
+
+            features = {
+                "is_not_available_on_hub": data.get("Available on the hub", False),
+                "is_merged": data.get("Merged", False),
+                "is_moe": data.get("MoE", False),
+                "is_flagged": data.get("Flagged", False),
+                "is_official_provider": data.get("Official Providers", False)
+            }
+
+            metadata = {
+                "upload_date": data.get("Upload To Hub Date"),
+                "submission_date": data.get("Submission Date"),
+                "generation": data.get("Generation"),
+                "base_model": data.get("Base Model"),
+                "hub_license": data.get("Hub License"),
+                "hub_hearts": data.get("Hub ❤️"),
+                "params_billions": data.get("#Params (B)"),
+                "co2_cost": data.get("CO₂ cost (kg)", 0)
+            }
+
+            # Clean model type by removing emojis if present
+            original_type = data.get("Type", "")
+            model_type = original_type.lower().strip()
+            
+            # Remove emojis and parentheses
+            if "(" in model_type:
+                model_type = model_type.split("(")[0].strip()
+            model_type = ''.join(c for c in model_type if not c in '🔶🟢🟩💬🤝🌸 ')
+                
+            # Map old model types to new ones
+            model_type_mapping = {
+                "fine-tuned": "fined-tuned-on-domain-specific-dataset",
+                "fine tuned": "fined-tuned-on-domain-specific-dataset",
+                "finetuned": "fined-tuned-on-domain-specific-dataset",
+                "fine_tuned": "fined-tuned-on-domain-specific-dataset",
+                "ft": "fined-tuned-on-domain-specific-dataset",
+                "finetuning": "fined-tuned-on-domain-specific-dataset",
+                "fine tuning": "fined-tuned-on-domain-specific-dataset",
+                "fine-tuning": "fined-tuned-on-domain-specific-dataset"
+            }
+
+            mapped_type = model_type_mapping.get(model_type.lower().strip(), model_type)
+            
+            if mapped_type != model_type:
+                logger.debug(LogFormatter.info(f"Model type mapped: {original_type} -> {mapped_type}"))
+            
+            transformed_data = {
+                "id": unique_id,
+                "model": {
+                    "name": data.get("fullname"),
+                    "sha": data.get("Model sha"),
+                    "precision": data.get("Precision"),
+                    "type": mapped_type,
+                    "weight_type": data.get("Weight type"),
+                    "architecture": data.get("Architecture"),
+                    "average_score": data.get("Average ⬆️"),
+                    "has_chat_template": data.get("Chat Template", False)
+                },
+                "evaluations": evaluations,
+                "features": features,
+                "metadata": metadata
+            }
+            
+            logger.debug(LogFormatter.success(f"Successfully transformed data for {model_name}"))
+            return transformed_data
+            
+        except Exception as e:
+            logger.error(LogFormatter.error(f"Failed to transform data for {data.get('fullname', 'Unknown')}", e))
+            raise

backend/app/services/models.py

@@ -0,0 +1,668 @@
+from datetime import datetime, timezone, timedelta
+from typing import Dict, Any, Optional, List
+import json
+import os
+from pathlib import Path
+import logging
+import aiohttp
+import asyncio
+import time
+from huggingface_hub import HfApi, CommitOperationAdd
+from huggingface_hub.utils import build_hf_headers
+from datasets import disable_progress_bar
+import sys
+import contextlib
+from concurrent.futures import ThreadPoolExecutor
+import tempfile
+
+from app.config import (
+    QUEUE_REPO,
+    HF_TOKEN,
+    EVAL_REQUESTS_PATH
+)
+from app.config.hf_config import HF_ORGANIZATION
+from app.services.hf_service import HuggingFaceService
+from app.utils.model_validation import ModelValidator
+from app.services.votes import VoteService
+from app.core.cache import cache_config
+from app.core.formatting import LogFormatter
+
+# Disable datasets progress bars globally
+disable_progress_bar()
+
+logger = logging.getLogger(__name__)
+
+# Context manager to temporarily disable stdout and stderr
+@contextlib.contextmanager
+def suppress_output():
+    stdout = sys.stdout
+    stderr = sys.stderr
+    devnull = open(os.devnull, 'w')
+    try:
+        sys.stdout = devnull
+        sys.stderr = devnull
+        yield
+    finally:
+        sys.stdout = stdout
+        sys.stderr = stderr
+        devnull.close()
+
+class ProgressTracker:
+    def __init__(self, total: int, desc: str = "Progress", update_frequency: int = 10):
+        self.total = total
+        self.current = 0
+        self.desc = desc
+        self.start_time = time.time()
+        self.update_frequency = update_frequency  # Percentage steps
+        self.last_update = -1
+        
+        # Initial log with fancy formatting
+        logger.info(LogFormatter.section(desc))
+        logger.info(LogFormatter.info(f"Starting processing of {total:,} items..."))
+        sys.stdout.flush()
+    
+    def update(self, n: int = 1):
+        self.current += n
+        current_percentage = (self.current * 100) // self.total
+        
+        # Only update on frequency steps (e.g., 0%, 10%, 20%, etc.)
+        if current_percentage >= self.last_update + self.update_frequency or current_percentage == 100:
+            elapsed = time.time() - self.start_time
+            rate = self.current / elapsed if elapsed > 0 else 0
+            remaining = (self.total - self.current) / rate if rate > 0 else 0
+            
+            # Create progress stats
+            stats = {
+                "Progress": LogFormatter.progress_bar(self.current, self.total),
+                "Items": f"{self.current:,}/{self.total:,}",
+                "Time": f"⏱️  {elapsed:.1f}s elapsed, {remaining:.1f}s remaining",
+                "Rate": f"🚀 {rate:.1f} items/s"
+            }
+            
+            # Log progress using tree format
+            for line in LogFormatter.tree(stats):
+                logger.info(line)
+            sys.stdout.flush()
+            
+            self.last_update = (current_percentage // self.update_frequency) * self.update_frequency
+    
+    def close(self):
+        elapsed = time.time() - self.start_time
+        rate = self.total / elapsed if elapsed > 0 else 0
+        
+        # Final summary with fancy formatting
+        logger.info(LogFormatter.section("COMPLETED"))
+        stats = {
+            "Total": f"{self.total:,} items",
+            "Time": f"{elapsed:.1f}s",
+            "Rate": f"{rate:.1f} items/s"
+        }
+        for line in LogFormatter.stats(stats):
+            logger.info(line)
+        logger.info("="*50)
+        sys.stdout.flush()
+
+class ModelService(HuggingFaceService):
+    _instance: Optional['ModelService'] = None
+    _initialized = False
+    
+    def __new__(cls):
+        if cls._instance is None:
+            logger.info(LogFormatter.info("Creating new ModelService instance"))
+            cls._instance = super(ModelService, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        if not hasattr(self, '_init_done'):
+            logger.info(LogFormatter.section("MODEL SERVICE INITIALIZATION"))
+            super().__init__()
+            self.validator = ModelValidator()
+            self.vote_service = VoteService()
+            self.eval_requests_path = cache_config.eval_requests_file
+            logger.info(LogFormatter.info(f"Using eval requests path: {self.eval_requests_path}"))
+            
+            self.eval_requests_path.parent.mkdir(parents=True, exist_ok=True)
+            self.hf_api = HfApi(token=HF_TOKEN)
+            self.cached_models = None
+            self.last_cache_update = 0
+            self.cache_ttl = cache_config.cache_ttl.total_seconds()
+            self._init_done = True
+            logger.info(LogFormatter.success("Initialization complete"))
+
+    async def _download_and_process_file(self, file: str, session: aiohttp.ClientSession, progress: ProgressTracker) -> Optional[Dict]:
+        """Download and process a file asynchronously"""
+        try:
+            # Build file URL
+            url = f"https://huggingface.co/datasets/{QUEUE_REPO}/resolve/main/{file}"
+            headers = build_hf_headers(token=self.token)
+            
+            # Download file
+            async with session.get(url, headers=headers) as response:
+                if response.status != 200:
+                    logger.error(LogFormatter.error(f"Failed to download {file}", f"HTTP {response.status}"))
+                    progress.update()
+                    return None
+                
+                try:
+                    # First read content as text
+                    text_content = await response.text()
+                    # Then parse JSON
+                    content = json.loads(text_content)
+                except json.JSONDecodeError as e:
+                    logger.error(LogFormatter.error(f"Failed to decode JSON from {file}", e))
+                    progress.update()
+                    return None
+                
+            # Get status and determine target status
+            status = content.get("status", "PENDING").upper()
+            target_status = None
+            status_map = {
+                "PENDING": ["PENDING"],
+                "EVALUATING": ["RUNNING"],
+                "FINISHED": ["FINISHED"]
+            }
+            
+            for target, source_statuses in status_map.items():
+                if status in source_statuses:
+                    target_status = target
+                    break
+                    
+            if not target_status:
+                progress.update()
+                return None
+                
+            # Calculate wait time
+            try:
+                submit_time = datetime.fromisoformat(content["submitted_time"].replace("Z", "+00:00"))
+                if submit_time.tzinfo is None:
+                    submit_time = submit_time.replace(tzinfo=timezone.utc)
+                current_time = datetime.now(timezone.utc)
+                wait_time = current_time - submit_time
+                
+                model_info = {
+                    "name": content["model"],
+                    "submitter": content.get("sender", "Unknown"),
+                    "revision": content["revision"],
+                    "wait_time": f"{wait_time.total_seconds():.1f}s",
+                    "submission_time": content["submitted_time"],
+                    "status": target_status,
+                    "precision": content.get("precision", "Unknown")
+                }
+                
+                progress.update()
+                return model_info
+                    
+            except (ValueError, TypeError) as e:
+                logger.error(LogFormatter.error(f"Failed to process {file}", e))
+                progress.update()
+                return None
+                
+        except Exception as e:
+            logger.error(LogFormatter.error(f"Failed to load {file}", e))
+            progress.update()
+            return None
+
+    async def _refresh_models_cache(self):
+        """Refresh the models cache"""
+        try:
+            logger.info(LogFormatter.section("CACHE REFRESH"))
+            self._log_repo_operation("read", f"{HF_ORGANIZATION}/requests", "Refreshing models cache")
+            
+            # Initialize models dictionary
+            models = {
+                "finished": [],
+                "evaluating": [],
+                "pending": []
+            }
+            
+            try:
+                logger.info(LogFormatter.subsection("DATASET LOADING"))
+                logger.info(LogFormatter.info("Loading dataset..."))
+                
+                # Download entire dataset snapshot
+                with suppress_output():
+                    local_dir = self.hf_api.snapshot_download(
+                        repo_id=QUEUE_REPO,
+                        repo_type="dataset",
+                        token=self.token
+                    )
+                
+                # List JSON files in local directory
+                local_path = Path(local_dir)
+                json_files = list(local_path.glob("**/*.json"))
+                total_files = len(json_files)
+                
+                # Log repository stats
+                stats = {
+                    "Total_Files": total_files,
+                    "Local_Dir": str(local_path),
+                }
+                for line in LogFormatter.stats(stats, "Repository Statistics"):
+                    logger.info(line)
+                
+                if not json_files:
+                    raise Exception("No JSON files found in repository")
+                
+                # Initialize progress tracker
+                progress = ProgressTracker(total_files, "PROCESSING FILES")
+                
+                # Process local files
+                model_submissions = {}  # Dict to track latest submission for each (model_id, revision, precision)
+                for file_path in json_files:
+                    try:
+                        with open(file_path, 'r') as f:
+                            content = json.load(f)
+                            
+                        # Get status and determine target status
+                        status = content.get("status", "PENDING").upper()
+                        target_status = None
+                        status_map = {
+                            "PENDING": ["PENDING"],
+                            "EVALUATING": ["RUNNING"],
+                            "FINISHED": ["FINISHED"]
+                        }
+                        
+                        for target, source_statuses in status_map.items():
+                            if status in source_statuses:
+                                target_status = target
+                                break
+                                
+                        if not target_status:
+                            progress.update()
+                            continue
+                            
+                        # Calculate wait time
+                        try:
+                            submit_time = datetime.fromisoformat(content["submitted_time"].replace("Z", "+00:00"))
+                            if submit_time.tzinfo is None:
+                                submit_time = submit_time.replace(tzinfo=timezone.utc)
+                            current_time = datetime.now(timezone.utc)
+                            wait_time = current_time - submit_time
+                            
+                            model_info = {
+                                "name": content["model"],
+                                "submitter": content.get("sender", "Unknown"),
+                                "revision": content["revision"],
+                                "wait_time": f"{wait_time.total_seconds():.1f}s",
+                                "submission_time": content["submitted_time"],
+                                "status": target_status,
+                                "precision": content.get("precision", "Unknown")
+                            }
+                            
+                            # Use (model_id, revision, precision) as key to track latest submission
+                            key = (content["model"], content["revision"], content.get("precision", "Unknown"))
+                            if key not in model_submissions or submit_time > datetime.fromisoformat(model_submissions[key]["submission_time"].replace("Z", "+00:00")):
+                                model_submissions[key] = model_info
+                            
+                        except (ValueError, TypeError) as e:
+                            logger.error(LogFormatter.error(f"Failed to process {file_path.name}", e))
+                            
+                    except Exception as e:
+                        logger.error(LogFormatter.error(f"Failed to load {file_path.name}", e))
+                    finally:
+                        progress.update()
+                
+                # Populate models dict with deduplicated submissions
+                for model_info in model_submissions.values():
+                    models[model_info["status"].lower()].append(model_info)
+                
+                progress.close()
+                
+                # Final summary with fancy formatting
+                logger.info(LogFormatter.section("CACHE SUMMARY"))
+                stats = {
+                    "Finished": len(models["finished"]),
+                    "Evaluating": len(models["evaluating"]),
+                    "Pending": len(models["pending"])
+                }
+                for line in LogFormatter.stats(stats, "Models by Status"):
+                    logger.info(line)
+                logger.info("="*50)
+                
+            except Exception as e:
+                logger.error(LogFormatter.error("Error processing files", e))
+                raise
+            
+            # Update cache
+            self.cached_models = models
+            self.last_cache_update = time.time()
+            logger.info(LogFormatter.success("Cache updated successfully"))
+            
+            return models
+            
+        except Exception as e:
+            logger.error(LogFormatter.error("Cache refresh failed", e))
+            raise
+
+    async def initialize(self):
+        """Initialize the model service"""
+        if self._initialized:
+            logger.info(LogFormatter.info("Service already initialized, using cached data"))
+            return
+        
+        try:
+            logger.info(LogFormatter.section("MODEL SERVICE INITIALIZATION"))
+            
+            # Check if cache already exists
+            cache_path = cache_config.get_cache_path("datasets")
+            if not cache_path.exists() or not any(cache_path.iterdir()):
+                logger.info(LogFormatter.info("No existing cache found, initializing datasets cache..."))
+                cache_config.flush_cache("datasets")
+            else:
+                logger.info(LogFormatter.info("Using existing datasets cache"))
+            
+            # Ensure eval requests directory exists
+            self.eval_requests_path.parent.mkdir(parents=True, exist_ok=True)
+            logger.info(LogFormatter.info(f"Eval requests directory: {self.eval_requests_path}"))
+            
+            # List existing files
+            if self.eval_requests_path.exists():
+                files = list(self.eval_requests_path.glob("**/*.json"))
+                stats = {
+                    "Total_Files": len(files),
+                    "Directory": str(self.eval_requests_path)
+                }
+                for line in LogFormatter.stats(stats, "Eval Requests"):
+                    logger.info(line)
+            
+            # Load initial cache
+            await self._refresh_models_cache()
+            
+            self._initialized = True
+            logger.info(LogFormatter.success("Model service initialization complete"))
+            
+        except Exception as e:
+            logger.error(LogFormatter.error("Initialization failed", e))
+            raise
+
+    async def get_models(self) -> Dict[str, List[Dict[str, Any]]]:
+        """Get all models with their status"""
+        if not self._initialized:
+            logger.info(LogFormatter.info("Service not initialized, initializing now..."))
+            await self.initialize()
+            
+        current_time = time.time()
+        cache_age = current_time - self.last_cache_update
+        
+        # Check if cache needs refresh
+        if not self.cached_models:
+            logger.info(LogFormatter.info("No cached data available, refreshing cache..."))
+            return await self._refresh_models_cache()
+        elif cache_age > self.cache_ttl:
+            logger.info(LogFormatter.info(f"Cache expired ({cache_age:.1f}s old, TTL: {self.cache_ttl}s)"))
+            return await self._refresh_models_cache()
+        else:
+            logger.info(LogFormatter.info(f"Using cached data ({cache_age:.1f}s old)"))
+            return self.cached_models
+
+    async def submit_model(
+        self, 
+        model_data: Dict[str, Any],
+        user_id: str
+    ) -> Dict[str, Any]:
+        logger.info(LogFormatter.section("MODEL SUBMISSION"))
+        self._log_repo_operation("write", f"{HF_ORGANIZATION}/requests", f"Submitting model {model_data['model_id']} by {user_id}")
+        stats = {
+            "Model": model_data["model_id"],
+            "User": user_id,
+            "Revision": model_data["revision"],
+            "Precision": model_data["precision"],
+            "Type": model_data["model_type"]
+        }
+        for line in LogFormatter.tree(stats, "Submission Details"):
+            logger.info(line)
+        
+        # Validate required fields
+        required_fields = [
+            "model_id", "base_model", "revision", "precision",
+            "weight_type", "model_type", "use_chat_template"
+        ]
+        for field in required_fields:
+            if field not in model_data:
+                raise ValueError(f"Missing required field: {field}")
+
+        # Get model info and validate it exists on HuggingFace
+        try:
+            logger.info(LogFormatter.subsection("MODEL VALIDATION"))
+            
+            # Get the model info to check if it exists
+            model_info = self.hf_api.model_info(
+                model_data["model_id"],
+                revision=model_data["revision"],
+                token=self.token
+            )
+            
+            if not model_info:
+                raise Exception(f"Model {model_data['model_id']} not found on HuggingFace Hub")
+            
+            logger.info(LogFormatter.success("Model exists on HuggingFace Hub"))
+            
+        except Exception as e:
+            logger.error(LogFormatter.error("Model validation failed", e))
+            raise
+        
+        # Update model revision with commit sha
+        model_data["revision"] = model_info.sha
+
+        # Check if model already exists in the system
+        try:
+            logger.info(LogFormatter.subsection("CHECKING EXISTING SUBMISSIONS"))
+            existing_models = await self.get_models()
+            
+            # Call the official provider status check
+            is_valid, error_message = await self.validator.check_official_provider_status(
+                model_data["model_id"],
+                existing_models
+            )
+            if not is_valid:
+                raise ValueError(error_message)
+
+            # Check in all statuses (pending, evaluating, finished)
+            for status, models in existing_models.items():
+                for model in models:
+                    if model["name"] == model_data["model_id"] and model["revision"] == model_data["revision"]:
+                        error_msg = f"Model {model_data['model_id']} revision {model_data['revision']} is already in the system with status: {status}"
+                        logger.error(LogFormatter.error("Submission rejected", error_msg))
+                        raise ValueError(error_msg)
+            
+            logger.info(LogFormatter.success("No existing submission found"))
+        except ValueError:
+            raise
+        except Exception as e:
+            logger.error(LogFormatter.error("Failed to check existing submissions", e))
+            raise
+
+        # Check that model on hub and valid
+        valid, error, model_config = await self.validator.is_model_on_hub(
+            model_data["model_id"], 
+            model_data["revision"], 
+            test_tokenizer=True
+        )
+        if not valid:
+            logger.error(LogFormatter.error("Model on hub validation failed", error))
+            raise Exception(error)
+        logger.info(LogFormatter.success("Model on hub validation passed"))
+
+        # Validate model card
+        valid, error, model_card = await self.validator.check_model_card(
+            model_data["model_id"]
+        )
+        if not valid:
+            logger.error(LogFormatter.error("Model card validation failed", error))
+            raise Exception(error)
+        logger.info(LogFormatter.success("Model card validation passed"))
+
+        # Check size limits
+        model_size, error = await self.validator.get_model_size(
+            model_info,
+            model_data["precision"],
+            model_data["base_model"],
+            revision=model_data["revision"]
+        )
+        if model_size is None:
+            logger.error(LogFormatter.error("Model size validation failed", error))
+            raise Exception(error)
+        logger.info(LogFormatter.success(f"Model size validation passed: {model_size:.1f}B"))
+
+        # Size limits based on precision
+        if model_data["precision"] in ["float16", "bfloat16"] and model_size > 100:
+            error_msg = f"Model too large for {model_data['precision']} (limit: 100B)"
+            logger.error(LogFormatter.error("Size limit exceeded", error_msg))
+            raise Exception(error_msg)
+
+        # Chat template validation if requested
+        if model_data["use_chat_template"]:
+            valid, error = await self.validator.check_chat_template(
+                model_data["model_id"],
+                model_data["revision"]
+            )
+            if not valid:
+                logger.error(LogFormatter.error("Chat template validation failed", error))
+                raise Exception(error)
+            logger.info(LogFormatter.success("Chat template validation passed"))
+
+
+        architectures = model_info.config.get("architectures", "")     
+        if architectures:
+            architectures = ";".join(architectures)
+
+        # Create eval entry
+        eval_entry = {
+            "model": model_data["model_id"],
+            "base_model": model_data["base_model"],
+            "revision": model_info.sha,
+            "precision": model_data["precision"],
+            "params": model_size,
+            "architectures": architectures,
+            "weight_type": model_data["weight_type"],
+            "status": "PENDING",
+            "submitted_time": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+            "model_type": model_data["model_type"],
+            "job_id": -1,
+            "job_start_time": None,
+            "use_chat_template": model_data["use_chat_template"],
+            "sender": user_id
+        }
+        
+        logger.info(LogFormatter.subsection("EVALUATION ENTRY"))
+        for line in LogFormatter.tree(eval_entry):
+            logger.info(line)
+
+        # Upload to HF dataset
+        try:
+            logger.info(LogFormatter.subsection("UPLOADING TO HUGGINGFACE"))
+            logger.info(LogFormatter.info(f"Uploading to {HF_ORGANIZATION}/requests..."))
+            
+            # Construct the path in the dataset
+            org_or_user = model_data["model_id"].split("/")[0] if "/" in model_data["model_id"] else ""
+            model_path = model_data["model_id"].split("/")[-1]
+            relative_path = f"{org_or_user}/{model_path}_eval_request_False_{model_data['precision']}_{model_data['weight_type']}.json"
+            
+            # Create a temporary file with the request
+            with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as temp_file:
+                json.dump(eval_entry, temp_file, indent=2)
+                temp_file.flush()
+                temp_path = temp_file.name
+            
+            # Upload file directly
+            self.hf_api.upload_file(
+                path_or_fileobj=temp_path,
+                path_in_repo=relative_path,
+                repo_id=f"{HF_ORGANIZATION}/requests",
+                repo_type="dataset",
+                commit_message=f"Add {model_data['model_id']} to eval queue",
+                token=self.token
+            )
+            
+            # Clean up temp file
+            os.unlink(temp_path)
+            
+            logger.info(LogFormatter.success("Upload successful"))
+            
+        except Exception as e:
+            logger.error(LogFormatter.error("Upload failed", e))
+            raise
+
+        # Add automatic vote
+        try:
+            logger.info(LogFormatter.subsection("AUTOMATIC VOTE"))
+            logger.info(LogFormatter.info(f"Adding upvote for {model_data['model_id']} by {user_id}"))
+            await self.vote_service.add_vote(
+                model_data["model_id"],
+                user_id,
+                "up",
+                {
+                    "precision": model_data["precision"],
+                    "revision": model_data["revision"]
+                }
+            )
+            logger.info(LogFormatter.success("Vote recorded successfully"))
+        except Exception as e:
+            logger.error(LogFormatter.error("Failed to record vote", e))
+            # Don't raise here as the main submission was successful
+
+        return {
+            "status": "success",
+            "message": "The model was submitted successfully, and the vote has been recorded"
+        }
+
+    async def get_model_status(self, model_id: str) -> Dict[str, Any]:
+        """Get evaluation status of a model"""
+        logger.info(LogFormatter.info(f"Checking status for model: {model_id}"))
+        eval_path = self.eval_requests_path
+        
+        for user_folder in eval_path.iterdir():
+            if user_folder.is_dir():
+                for file in user_folder.glob("*.json"):
+                    with open(file, "r") as f:
+                        data = json.load(f)
+                        if data["model"] == model_id:
+                            status = {
+                                "status": data["status"],
+                                "submitted_time": data["submitted_time"],
+                                "job_id": data.get("job_id", -1)
+                            }
+                            logger.info(LogFormatter.success("Status found"))
+                            for line in LogFormatter.tree(status, "Model Status"):
+                                logger.info(line)
+                            return status
+        
+        logger.warning(LogFormatter.warning(f"No status found for model: {model_id}"))
+        return {"status": "not_found"}
+
+    async def get_organization_submissions(self, organization: str, days: int = 7) -> List[Dict[str, Any]]:
+        """Get all submissions from a user in the last n days"""
+        try:
+            # Get all models
+            all_models = await self.get_models()
+            current_time = datetime.now(timezone.utc)
+            cutoff_time = current_time - timedelta(days=days)
+            
+            # Filter models by submitter and submission time
+            user_submissions = []
+            for status, models in all_models.items():
+                for model in models:
+                    # Check if model was submitted by the user
+                    if model["submitter"] == organization:
+                        # Parse submission time
+                        submit_time = datetime.fromisoformat(
+                            model["submission_time"].replace("Z", "+00:00")
+                        )
+                        # Check if within time window
+                        if submit_time > cutoff_time:
+                            user_submissions.append({
+                                "name": model["name"],
+                                "status": status,
+                                "submission_time": model["submission_time"],
+                                "precision": model["precision"]
+                            })
+            
+            return sorted(
+                user_submissions,
+                key=lambda x: x["submission_time"],
+                reverse=True
+            )
+            
+        except Exception as e:
+            logger.error(LogFormatter.error(f"Failed to get submissions for {organization}", e))
+            raise 

backend/app/services/rate_limiter.py

@@ -0,0 +1,72 @@
+"""
+import logging
+from datetime import datetime, timedelta, timezone
+from typing import Tuple, Dict, List
+
+logger = logging.getLogger(__name__)
+
+class RateLimiter:
+    def __init__(self, period_days: int = 7, quota: int = 5):
+        self.period_days = period_days
+        self.quota = quota
+        self.submission_history: Dict[str, List[datetime]] = {}
+        self.higher_quota_users = set()  # Users with higher quotas
+        self.unlimited_users = set()  # Users with no quota limits
+        
+    def add_unlimited_user(self, user_id: str):
+        """Add a user to the unlimited users list"""
+        self.unlimited_users.add(user_id)
+        
+    def add_higher_quota_user(self, user_id: str):
+        """Add a user to the higher quota users list"""
+        self.higher_quota_users.add(user_id)
+        
+    def record_submission(self, user_id: str):
+        """Record a new submission for a user"""
+        current_time = datetime.now(timezone.utc)
+        if user_id not in self.submission_history:
+            self.submission_history[user_id] = []
+        self.submission_history[user_id].append(current_time)
+        
+    def clean_old_submissions(self, user_id: str):
+        """Remove submissions older than the period"""
+        if user_id not in self.submission_history:
+            return
+            
+        current_time = datetime.now(timezone.utc)
+        cutoff_time = current_time - timedelta(days=self.period_days)
+        
+        self.submission_history[user_id] = [
+            time for time in self.submission_history[user_id]
+            if time > cutoff_time
+        ]
+        
+    async def check_rate_limit(self, user_id: str) -> Tuple[bool, str]:
+        """Check if a user has exceeded their rate limit
+        
+        Returns:
+            Tuple[bool, str]: (is_allowed, error_message)
+        """
+        # Unlimited users bypass all checks
+        if user_id in self.unlimited_users:
+            return True, ""
+            
+        # Clean old submissions
+        self.clean_old_submissions(user_id)
+        
+        # Get current submission count
+        submission_count = len(self.submission_history.get(user_id, []))
+        
+        # Calculate user's quota
+        user_quota = self.quota * 2 if user_id in self.higher_quota_users else self.quota
+        
+        # Check if user has exceeded their quota
+        if submission_count >= user_quota:
+            error_msg = (
+                f"User '{user_id}' has reached the limit of {user_quota} submissions "
+                f"in the last {self.period_days} days. Please wait before submitting again."
+            )
+            return False, error_msg
+            
+        return True, ""
+""" 

backend/app/services/votes.py

@@ -0,0 +1,441 @@
+from datetime import datetime, timezone
+from typing import Dict, Any, List, Set, Tuple, Optional
+import json
+import logging
+import asyncio
+from pathlib import Path
+import aiohttp
+from huggingface_hub import HfApi
+import tempfile
+import os
+
+from app.services.hf_service import HuggingFaceService
+from app.config import HF_TOKEN
+from app.config.hf_config import HF_ORGANIZATION
+from app.core.cache import cache_config
+from app.core.formatting import LogFormatter
+
+logger = logging.getLogger(__name__)
+
+class VoteService(HuggingFaceService):
+    _instance: Optional['VoteService'] = None
+    _initialized = False
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(VoteService, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        if not hasattr(self, '_init_done'):
+            super().__init__()
+            self.votes_file = cache_config.votes_file
+            self.votes_to_upload: List[Dict[str, Any]] = []
+            self.vote_check_set: Set[Tuple[str, str, str, str]] = set()
+            self._votes_by_model: Dict[str, List[Dict[str, Any]]] = {}
+            self._votes_by_user: Dict[str, List[Dict[str, Any]]] = {}
+            self._last_sync = None
+            self._sync_interval = 300  # 5 minutes
+            self._total_votes = 0
+            self._last_vote_timestamp = None
+            self._max_retries = 3
+            self._retry_delay = 1  # seconds
+            self.hf_api = HfApi(token=HF_TOKEN)
+            self._init_done = True
+
+    async def initialize(self):
+        """Initialize the vote service"""
+        if self._initialized:
+            await self._check_for_new_votes()
+            return
+        
+        try:
+            logger.info(LogFormatter.section("VOTE SERVICE INITIALIZATION"))
+            
+            # Ensure votes directory exists
+            self.votes_file.parent.mkdir(parents=True, exist_ok=True)
+            
+            # Load remote votes
+            remote_votes = await self._fetch_remote_votes()
+            if remote_votes:
+                logger.info(LogFormatter.info(f"Loaded {len(remote_votes)} votes from hub"))
+                
+                # Save to local file
+                with open(self.votes_file, 'w') as f:
+                    for vote in remote_votes:
+                        json.dump(vote, f)
+                        f.write('\n')
+                
+                # Load into memory
+                await self._load_existing_votes()
+            else:
+                logger.warning(LogFormatter.warning("No votes found on hub"))
+            
+            self._initialized = True
+            self._last_sync = datetime.now(timezone.utc)
+            
+            # Final summary
+            stats = {
+                "Total_Votes": self._total_votes,
+                "Last_Sync": self._last_sync.strftime("%Y-%m-%d %H:%M:%S UTC")
+            }
+            logger.info(LogFormatter.section("INITIALIZATION COMPLETE"))
+            for line in LogFormatter.stats(stats):
+                logger.info(line)
+            
+        except Exception as e:
+            logger.error(LogFormatter.error("Initialization failed", e))
+            raise
+
+    async def _fetch_remote_votes(self) -> List[Dict[str, Any]]:
+        """Fetch votes from HF hub"""
+        url = f"https://huggingface.co/datasets/{HF_ORGANIZATION}/votes/raw/main/votes_data.jsonl"
+        headers = {"Authorization": f"Bearer {self.token}"} if self.token else {}
+        
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url, headers=headers) as response:
+                    if response.status == 200:
+                        votes = []
+                        async for line in response.content:
+                            if line.strip():
+                                try:
+                                    vote = json.loads(line.decode())
+                                    votes.append(vote)
+                                except json.JSONDecodeError:
+                                    continue
+                        return votes
+                    else:
+                        logger.error(f"Failed to get remote votes: HTTP {response.status}")
+                        return []
+        except Exception as e:
+            logger.error(f"Error fetching remote votes: {str(e)}")
+            return []
+
+    async def _check_for_new_votes(self):
+        """Check for new votes on the hub and sync if needed"""
+        try:
+            remote_votes = await self._fetch_remote_votes()
+            if len(remote_votes) != self._total_votes:
+                logger.info(f"Vote count changed: Local ({self._total_votes}) ≠ Remote ({len(remote_votes)})")
+                # Save to local file
+                with open(self.votes_file, 'w') as f:
+                    for vote in remote_votes:
+                        json.dump(vote, f)
+                        f.write('\n')
+                
+                # Reload into memory
+                await self._load_existing_votes()
+            else:
+                logger.info("Votes are in sync")
+                
+        except Exception as e:
+            logger.error(f"Error checking for new votes: {str(e)}")
+
+    async def _sync_with_hub(self):
+        """Sync votes with HuggingFace hub"""
+        try:
+            logger.info(LogFormatter.section("VOTE SYNC"))
+            
+            # Get current remote votes
+            remote_votes = await self._fetch_remote_votes()
+            logger.info(LogFormatter.info(f"Loaded {len(remote_votes)} votes from hub"))
+            
+            # If we have pending votes to upload
+            if self.votes_to_upload:
+                logger.info(LogFormatter.info(f"Adding {len(self.votes_to_upload)} pending votes..."))
+                
+                # Add new votes to remote votes
+                remote_votes.extend(self.votes_to_upload)
+                
+                # Create temporary file with all votes
+                with tempfile.NamedTemporaryFile(mode='w', suffix='.jsonl', delete=False) as temp_file:
+                    for vote in remote_votes:
+                        json.dump(vote, temp_file)
+                        temp_file.write('\n')
+                    temp_path = temp_file.name
+                
+                try:
+                    # Upload JSONL file directly
+                    self.hf_api.upload_file(
+                        path_or_fileobj=temp_path,
+                        path_in_repo="votes_data.jsonl",
+                        repo_id=f"{HF_ORGANIZATION}/votes",
+                        repo_type="dataset",
+                        commit_message=f"Update votes: +{len(self.votes_to_upload)} new votes",
+                        token=self.token
+                    )
+                    
+                    # Clear pending votes only if upload succeeded
+                    self.votes_to_upload.clear()
+                    logger.info(LogFormatter.success("Pending votes uploaded successfully"))
+                    
+                except Exception as e:
+                    logger.error(LogFormatter.error("Failed to upload votes to hub", e))
+                    raise
+                finally:
+                    # Clean up temp file
+                    os.unlink(temp_path)
+            
+            # Update local state
+            with open(self.votes_file, 'w') as f:
+                for vote in remote_votes:
+                    json.dump(vote, f)
+                    f.write('\n')
+            
+            # Reload votes in memory
+            await self._load_existing_votes()
+            logger.info(LogFormatter.success("Sync completed successfully"))
+
+            self._last_sync = datetime.now(timezone.utc)
+            
+        except Exception as e:
+            logger.error(LogFormatter.error("Sync failed", e))
+            raise
+
+    async def _load_existing_votes(self):
+        """Load existing votes from file"""
+        if not self.votes_file.exists():
+            logger.warning(LogFormatter.warning("No votes file found"))
+            return
+
+        try:
+            logger.info(LogFormatter.section("LOADING VOTES"))
+            
+            # Clear existing data structures
+            self.vote_check_set.clear()
+            self._votes_by_model.clear()
+            self._votes_by_user.clear()
+            
+            vote_count = 0
+            latest_timestamp = None
+            
+            with open(self.votes_file, "r") as f:
+                for line in f:
+                    try:
+                        vote = json.loads(line.strip())
+                        vote_count += 1
+                        
+                        # Track latest timestamp
+                        try:
+                            vote_timestamp = datetime.fromisoformat(vote["timestamp"].replace("Z", "+00:00"))
+                            if not latest_timestamp or vote_timestamp > latest_timestamp:
+                                latest_timestamp = vote_timestamp
+                            vote["timestamp"] = vote_timestamp.strftime("%Y-%m-%dT%H:%M:%SZ")
+                        except (KeyError, ValueError) as e:
+                            logger.warning(LogFormatter.warning(f"Invalid timestamp in vote: {str(e)}"))
+                            continue
+                        
+                        if vote_count % 1000 == 0:
+                            logger.info(LogFormatter.info(f"Processed {vote_count:,} votes..."))
+                        
+                        self._add_vote_to_memory(vote)
+                        
+                    except json.JSONDecodeError as e:
+                        logger.error(LogFormatter.error("Vote parsing failed", e))
+                        continue
+                    except Exception as e:
+                        logger.error(LogFormatter.error("Vote processing failed", e))
+                        continue
+            
+            self._total_votes = vote_count
+            self._last_vote_timestamp = latest_timestamp
+            
+            # Final summary
+            stats = {
+                "Total_Votes": vote_count,
+                "Latest_Vote": latest_timestamp.strftime("%Y-%m-%d %H:%M:%S UTC") if latest_timestamp else "None",
+                "Unique_Models": len(self._votes_by_model),
+                "Unique_Users": len(self._votes_by_user)
+            }
+            
+            logger.info(LogFormatter.section("VOTE SUMMARY"))
+            for line in LogFormatter.stats(stats):
+                logger.info(line)
+            
+        except Exception as e:
+            logger.error(LogFormatter.error("Failed to load votes", e))
+            raise
+
+    def _add_vote_to_memory(self, vote: Dict[str, Any]):
+        """Add vote to memory structures"""
+        try:
+            # Create a unique identifier tuple that includes precision
+            check_tuple = (
+                vote["model"],
+                vote.get("revision", "main"),
+                vote["username"],
+                vote.get("precision", "unknown")
+            )
+            
+            # Skip if we already have this vote
+            if check_tuple in self.vote_check_set:
+                return
+                
+            self.vote_check_set.add(check_tuple)
+            
+            # Update model votes
+            if vote["model"] not in self._votes_by_model:
+                self._votes_by_model[vote["model"]] = []
+            self._votes_by_model[vote["model"]].append(vote)
+            
+            # Update user votes
+            if vote["username"] not in self._votes_by_user:
+                self._votes_by_user[vote["username"]] = []
+            self._votes_by_user[vote["username"]].append(vote)
+            
+        except KeyError as e:
+            logger.error(LogFormatter.error("Malformed vote data, missing key", str(e)))
+        except Exception as e:
+            logger.error(LogFormatter.error("Error adding vote to memory", str(e)))
+
+    async def get_user_votes(self, user_id: str) -> List[Dict[str, Any]]:
+        """Get all votes from a specific user"""
+        logger.info(LogFormatter.info(f"Fetching votes for user: {user_id}"))
+        
+        # Check if we need to refresh votes
+        if (datetime.now(timezone.utc) - self._last_sync).total_seconds() > self._sync_interval:
+            logger.info(LogFormatter.info("Cache expired, refreshing votes..."))
+            await self._check_for_new_votes()
+            
+        votes = self._votes_by_user.get(user_id, [])
+        logger.info(LogFormatter.success(f"Found {len(votes):,} votes"))
+        return votes
+
+    async def get_model_votes(self, model_id: str) -> Dict[str, Any]:
+        """Get all votes for a specific model"""
+        logger.info(LogFormatter.info(f"Fetching votes for model: {model_id}"))
+        
+        # Check if we need to refresh votes
+        if (datetime.now(timezone.utc) - self._last_sync).total_seconds() > self._sync_interval:
+            logger.info(LogFormatter.info("Cache expired, refreshing votes..."))
+            await self._check_for_new_votes()
+        
+        votes = self._votes_by_model.get(model_id, [])
+        
+        # Group votes by revision and precision
+        votes_by_config = {}
+        for vote in votes:
+            revision = vote.get("revision", "main")
+            precision = vote.get("precision", "unknown")
+            config_key = f"{revision}_{precision}"
+            if config_key not in votes_by_config:
+                votes_by_config[config_key] = {
+                    "revision": revision,
+                    "precision": precision,
+                    "count": 0
+                }
+            votes_by_config[config_key]["count"] += 1
+        
+        stats = {
+            "Total_Votes": len(votes),
+            **{f"Config_{k}": v["count"] for k, v in votes_by_config.items()}
+        }
+        
+        logger.info(LogFormatter.section("VOTE STATISTICS"))
+        for line in LogFormatter.stats(stats):
+            logger.info(line)
+        
+        return {
+            "total_votes": len(votes),
+            "votes_by_config": votes_by_config,
+            "votes": votes
+        }
+
+    async def _get_model_revision(self, model_id: str) -> str:
+        """Get current revision of a model with retries"""
+        logger.info(f"Getting revision for model: {model_id}")
+        for attempt in range(self._max_retries):
+            try:
+                model_info = await asyncio.to_thread(self.hf_api.model_info, model_id)
+                logger.info(f"Successfully got revision {model_info.sha} for model {model_id}")
+                return model_info.sha
+            except Exception as e:
+                logger.error(f"Error getting model revision for {model_id} (attempt {attempt + 1}): {str(e)}")
+                if attempt < self._max_retries - 1:
+                    retry_delay = self._retry_delay * (attempt + 1)
+                    logger.info(f"Retrying in {retry_delay} seconds...")
+                    await asyncio.sleep(retry_delay)
+                else:
+                    logger.warning(f"Using 'main' as fallback revision for {model_id} after {self._max_retries} failed attempts")
+                    return "main"
+
+    async def add_vote(self, model_id: str, user_id: str, vote_type: str, vote_data: Dict[str, Any] = None) -> Dict[str, Any]:
+        """Add a vote for a model"""
+        try:
+            self._log_repo_operation("add", f"{HF_ORGANIZATION}/votes", f"Adding {vote_type} vote for {model_id} by {user_id}")
+            logger.info(LogFormatter.section("NEW VOTE"))
+            stats = {
+                "Model": model_id,
+                "User": user_id,
+                "Type": vote_type,
+                "Config": vote_data or {}
+            }
+            for line in LogFormatter.tree(stats, "Vote Details"):
+                logger.info(line)
+            
+            # Use provided configuration or fallback to model info
+            precision = None
+            revision = None
+            
+            if vote_data:
+                precision = vote_data.get("precision")
+                revision = vote_data.get("revision")
+            
+            # If any info is missing, try to get it from model info
+            if not all([precision, revision]):
+                try:
+                    model_info = await asyncio.to_thread(self.hf_api.model_info, model_id)
+                    model_card_data = model_info.cardData if hasattr(model_info, 'cardData') else {}
+                    
+                    if not precision:
+                        precision = model_card_data.get("precision", "unknown")
+                    if not revision:
+                        revision = model_info.sha
+                except Exception as e:
+                    logger.warning(LogFormatter.warning(f"Failed to get model info: {str(e)}. Using default values."))
+                    precision = precision or "unknown"
+                    revision = revision or "main"
+            
+            # Check if vote already exists with this configuration
+            check_tuple = (model_id, revision, user_id, precision)
+            
+            if check_tuple in self.vote_check_set:
+                raise ValueError(f"Vote already recorded for this model configuration (precision: {precision}, revision: {revision[:7] if revision else 'unknown'})")
+
+            vote = {
+                "model": model_id,
+                "revision": revision,
+                "username": user_id,
+                "timestamp": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+                "vote_type": vote_type,
+                "precision": precision
+            }
+
+            # Update local storage
+            with open(self.votes_file, "a") as f:
+                f.write(json.dumps(vote) + "\n")
+            
+            self._add_vote_to_memory(vote)
+            self.votes_to_upload.append(vote)
+            
+            stats = {
+                "Status": "Success",
+                "Queue_Size": len(self.votes_to_upload),
+                "Model_Config": {
+                    "Precision": precision,
+                    "Revision": revision[:7] if revision else "unknown"
+                }
+            }
+            for line in LogFormatter.stats(stats):
+                logger.info(line)
+            
+            # Force immediate sync
+            logger.info(LogFormatter.info("Forcing immediate sync with hub"))
+            await self._sync_with_hub()
+            
+            return {"status": "success", "message": "Vote added successfully"}
+            
+        except Exception as e:
+            logger.error(LogFormatter.error("Failed to add vote", e))
+            raise

backend/app/utils/__init__.py

@@ -0,0 +1,3 @@
+from . import model_validation
+
+__all__ = ["model_validation"]

backend/app/utils/logging.py

@@ -0,0 +1,3 @@
+from app.core.formatting import LogFormatter
+
+__all__ = ['LogFormatter']

backend/app/utils/model_validation.py

@@ -0,0 +1,266 @@
+import json
+import logging
+import asyncio
+from typing import Tuple, Optional, Dict, Any
+from datasets import load_dataset
+from huggingface_hub import HfApi, ModelCard, hf_hub_download
+from huggingface_hub import hf_api
+from transformers import AutoConfig, AutoTokenizer
+from app.config.base import HF_TOKEN
+from app.config.hf_config import OFFICIAL_PROVIDERS_REPO
+from app.core.formatting import LogFormatter
+
+logger = logging.getLogger(__name__)
+
+class ModelValidator:
+    def __init__(self):
+        self.token = HF_TOKEN
+        self.api = HfApi(token=self.token)
+        self.headers = {"Authorization": f"Bearer {self.token}"} if self.token else {}
+        
+    async def check_model_card(self, model_id: str) -> Tuple[bool, str, Optional[Dict[str, Any]]]:
+        """Check if model has a valid model card"""
+        try:
+            logger.info(LogFormatter.info(f"Checking model card for {model_id}"))
+            
+            # Get model card content using ModelCard.load
+            try:
+                model_card = await asyncio.to_thread(
+                    ModelCard.load,
+                    model_id
+                )
+                logger.info(LogFormatter.success("Model card found"))
+            except Exception as e:
+                error_msg = "Please add a model card to your model to explain how you trained/fine-tuned it."
+                logger.error(LogFormatter.error(error_msg, e))
+                return False, error_msg, None
+            
+            # Check license in model card data
+            if model_card.data.license is None and not ("license_name" in model_card.data and "license_link" in model_card.data):
+                error_msg = "License not found. Please add a license to your model card using the `license` metadata or a `license_name`/`license_link` pair."
+                logger.warning(LogFormatter.warning(error_msg))
+                return False, error_msg, None
+
+            # Enforce card content length
+            if len(model_card.text) < 200:
+                error_msg = "Please add a description to your model card, it is too short."
+                logger.warning(LogFormatter.warning(error_msg))
+                return False, error_msg, None
+            
+            logger.info(LogFormatter.success("Model card validation passed"))
+            return True, "", model_card
+            
+        except Exception as e:
+            error_msg = "Failed to validate model card"
+            logger.error(LogFormatter.error(error_msg, e))
+            return False, str(e), None
+            
+    async def get_safetensors_metadata(self, model_id: str, is_adapter: bool = False, revision: str = "main")  -> Optional[Dict]:
+        """Get metadata from a safetensors file"""
+        try:
+            if is_adapter:
+                metadata = await asyncio.to_thread(
+                    hf_api.parse_safetensors_file_metadata,
+                    model_id,
+                    "adapter_model.safetensors",
+                    token=self.token,
+                    revision=revision,
+                )
+            else:
+                metadata = await asyncio.to_thread(
+                    hf_api.get_safetensors_metadata,
+                    repo_id=model_id,
+                    token=self.token,
+                    revision=revision,
+                )
+            return metadata
+
+        except Exception as e:
+            logger.error(f"Failed to get safetensors metadata: {str(e)}")
+            return None
+
+    async def get_model_size(
+        self,
+        model_info: Any,
+        precision: str,
+        base_model: str,
+        revision: str
+    ) -> Tuple[Optional[float], Optional[str]]:
+        """Get model size in billions of parameters"""
+        try:
+            logger.info(LogFormatter.info(f"Checking model size for {model_info.modelId}"))
+
+            # Check if model is adapter
+            is_adapter = any(s.rfilename == "adapter_config.json" for s in model_info.siblings if hasattr(s, 'rfilename'))
+
+            # Try to get size from safetensors first
+            model_size = None
+
+            if is_adapter and base_model:
+                # For adapters, we need both adapter and base model sizes
+                adapter_meta = await self.get_safetensors_metadata(model_info.id, is_adapter=True, revision=revision)
+                base_meta = await self.get_safetensors_metadata(base_model, revision="main")
+
+                if adapter_meta and base_meta:
+                    adapter_size = sum(adapter_meta.parameter_count.values())
+                    base_size = sum(base_meta.parameter_count.values())
+                    model_size = adapter_size + base_size
+            else:
+                # For regular models, just get the model size
+                meta = await self.get_safetensors_metadata(model_info.id, revision=revision)
+                if meta:
+                    model_size = sum(meta.parameter_count.values()) # total params
+
+            if model_size is None:
+                # If model size could not be determined, return an error
+                return None, "Model size could not be determined"
+
+            # Adjust size for GPTQ models
+            size_factor = 8 if (precision == "GPTQ" or "gptq" in model_info.id.lower()) else 1
+            model_size = model_size / 1e9  # Convert to billions, assuming float16
+            model_size = round(size_factor * model_size, 3)
+
+            logger.info(LogFormatter.success(f"Model size: {model_size}B parameters"))
+            return model_size, None
+
+        except Exception as e:
+            logger.error(LogFormatter.error(f"Error while determining model size: {e}"))
+            return None, str(e)
+
+            
+    async def check_chat_template(
+        self,
+        model_id: str,
+        revision: str
+    ) -> Tuple[bool, Optional[str]]:
+        """Check if model has a valid chat template"""
+        try:
+            logger.info(LogFormatter.info(f"Checking chat template for {model_id}"))
+            
+            try:
+                config_file = await asyncio.to_thread(
+                    hf_hub_download,
+                    repo_id=model_id,
+                    filename="tokenizer_config.json",
+                    revision=revision,
+                    repo_type="model"
+                )
+                
+                with open(config_file, 'r') as f:
+                    tokenizer_config = json.load(f)
+                
+                if 'chat_template' not in tokenizer_config:
+                    error_msg = f"The model {model_id} doesn't have a chat_template in its tokenizer_config.json. Please add a chat_template before submitting or submit without it."
+                    logger.error(LogFormatter.error(error_msg))
+                    return False, error_msg
+                
+                logger.info(LogFormatter.success("Valid chat template found"))
+                return True, None
+                
+            except Exception as e:
+                error_msg = f"Error checking chat_template: {str(e)}"
+                logger.error(LogFormatter.error(error_msg))
+                return False, error_msg
+                    
+        except Exception as e:
+            error_msg = "Failed to check chat template"
+            logger.error(LogFormatter.error(error_msg, e))
+            return False, str(e)
+            
+    async def is_model_on_hub(
+        self,
+        model_name: str,
+        revision: str,
+        test_tokenizer: bool = False,
+        trust_remote_code: bool = False
+    ) -> Tuple[bool, Optional[str], Optional[Any]]:
+        """Check if model exists and is properly configured on the Hub"""
+        try:
+            config = await asyncio.to_thread(
+                AutoConfig.from_pretrained,
+                model_name,
+                revision=revision,
+                trust_remote_code=trust_remote_code,
+                token=self.token,
+                force_download=True
+            )
+            
+            if test_tokenizer:
+                try:
+                    await asyncio.to_thread(
+                        AutoTokenizer.from_pretrained,
+                        model_name,
+                        revision=revision,
+                        trust_remote_code=trust_remote_code,
+                        token=self.token
+                    )
+                except ValueError as e:
+                    return False, f"The tokenizer is not available in an official Transformers release: {e}", None
+                except Exception:
+                    return False, "The tokenizer cannot be loaded. Ensure the tokenizer class is part of a stable Transformers release and correctly configured.", None
+            
+            return True, None, config
+            
+        except ValueError:
+            return False, "The model requires `trust_remote_code=True` to launch, and for safety reasons, we don't accept such models automatically.", None
+        except Exception as e:
+            if "You are trying to access a gated repo." in str(e):
+                return True, "The model is gated and requires special access permissions.", None
+            return False, f"The model was not found or is misconfigured on the Hub. Error: {e.args[0]}", None
+
+    async def check_official_provider_status(
+        self, 
+        model_id: str,
+        existing_models: Dict[str, list]
+    ) -> Tuple[bool, Optional[str]]:
+        """
+        Check if model is from official provider and has finished submission.
+        
+        Args:
+            model_id: The model identifier (org/model-name)
+            existing_models: Dictionary of models by status from get_models()
+            
+        Returns:
+            Tuple[bool, Optional[str]]: (is_valid, error_message)
+        """
+        try:
+            logger.info(LogFormatter.info(f"Checking official provider status for {model_id}"))
+            
+            # Get model organization
+            model_org = model_id.split('/')[0] if '/' in model_id else None
+            
+            if not model_org:
+                return True, None
+                
+            # Load official providers dataset
+            dataset = load_dataset(OFFICIAL_PROVIDERS_REPO)
+            official_providers = dataset["train"][0]["CURATED_SET"]
+            
+            # Check if model org is in official providers
+            is_official = model_org in official_providers
+            
+            if is_official:
+                logger.info(LogFormatter.info(f"Model organization '{model_org}' is an official provider"))
+                
+                # Check for finished submissions
+                if "finished" in existing_models:
+                    for model in existing_models["finished"]:
+                        if model["name"] == model_id:
+                            error_msg = (
+                                f"Model {model_id} is an official provider model "
+                                f"with a completed evaluation. "
+                                f"To re-evaluate, please open a discussion."
+                            )
+                            logger.error(LogFormatter.error("Validation failed", error_msg))
+                            return False, error_msg
+                
+                logger.info(LogFormatter.success("No finished submission found for this official provider model"))
+            else:
+                logger.info(LogFormatter.info(f"Model organization '{model_org}' is not an official provider"))
+            
+            return True, None
+            
+        except Exception as e:
+            error_msg = f"Failed to check official provider status: {str(e)}"
+            logger.error(LogFormatter.error(error_msg))
+            return False, error_msg

backend/pyproject.toml

@@ -0,0 +1,31 @@
+[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"
+fastapi = "^0.115.6"
+uvicorn = {extras = ["standard"], version = "^0.34.0"}
+numpy = "^2.2.0"
+pandas = "^2.2.3"
+datasets = "^3.3.2"
+pyarrow = "^18.1.0"
+python-multipart = "^0.0.20"
+huggingface-hub = "0.29.1"
+transformers = "4.49.0"
+safetensors = "^0.5.3"
+aiofiles = "^24.1.0"
+fastapi-cache2 = "^0.2.1"
+python-dotenv = "^1.0.1"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.3.4"
+black = "^24.10.0"
+isort = "^5.13.2"
+flake8 = "^6.1.0"
+    
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api" 

backend/utils/analyze_prod_datasets.py

@@ -0,0 +1,170 @@
+import os
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Any, List
+from huggingface_hub import HfApi
+from dotenv import load_dotenv
+from app.config.hf_config import HF_ORGANIZATION
+
+# Get the backend directory path
+BACKEND_DIR = Path(__file__).parent.parent
+ROOT_DIR = BACKEND_DIR.parent
+
+# Load environment variables from .env file in root directory
+load_dotenv(ROOT_DIR / ".env")
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Initialize Hugging Face API
+HF_TOKEN = os.getenv("HF_TOKEN")
+if not HF_TOKEN:
+    raise ValueError("HF_TOKEN not found in environment variables")
+api = HfApi(token=HF_TOKEN)
+
+def analyze_dataset(repo_id: str) -> Dict[str, Any]:
+    """Analyze a dataset and return statistics"""
+    try:
+        # Get dataset info
+        dataset_info = api.dataset_info(repo_id=repo_id)
+        
+        # Get file list
+        files = api.list_repo_files(repo_id, repo_type="dataset")
+        
+        # Get last commit info
+        commits = api.list_repo_commits(repo_id, repo_type="dataset")
+        last_commit = next(commits, None)
+        
+        # Count lines in jsonl files
+        total_entries = 0
+        for file in files:
+            if file.endswith('.jsonl'):
+                try:
+                    # Download file content
+                    content = api.hf_hub_download(
+                        repo_id=repo_id,
+                        filename=file,
+                        repo_type="dataset"
+                    )
+                    
+                    # Count lines
+                    with open(content, 'r') as f:
+                        for _ in f:
+                            total_entries += 1
+                            
+                except Exception as e:
+                    logger.error(f"Error processing file {file}: {str(e)}")
+                    continue
+        
+        # Special handling for requests dataset
+        if repo_id == f"{HF_ORGANIZATION}/requests":
+            pending_count = 0
+            completed_count = 0
+            
+            try:
+                content = api.hf_hub_download(
+                    repo_id=repo_id,
+                    filename="eval_requests.jsonl",
+                    repo_type="dataset"
+                )
+                
+                with open(content, 'r') as f:
+                    for line in f:
+                        try:
+                            entry = json.loads(line)
+                            if entry.get("status") == "pending":
+                                pending_count += 1
+                            elif entry.get("status") == "completed":
+                                completed_count += 1
+                        except json.JSONDecodeError:
+                            continue
+                            
+            except Exception as e:
+                logger.error(f"Error analyzing requests: {str(e)}")
+        
+        # Build response
+        response = {
+            "id": repo_id,
+            "last_modified": last_commit.created_at if last_commit else None,
+            "total_entries": total_entries,
+            "file_count": len(files),
+            "size_bytes": dataset_info.size_in_bytes,
+            "downloads": dataset_info.downloads,
+        }
+        
+        # Add request-specific info if applicable
+        if repo_id == f"{HF_ORGANIZATION}/requests":
+            response.update({
+                "pending_requests": pending_count,
+                "completed_requests": completed_count
+            })
+            
+        return response
+        
+    except Exception as e:
+        logger.error(f"Error analyzing dataset {repo_id}: {str(e)}")
+        return {
+            "id": repo_id,
+            "error": str(e)
+        }
+
+def main():
+    """Main function to analyze all datasets"""
+    try:
+        # List of datasets to analyze
+        datasets = [
+            {
+                "id": f"{HF_ORGANIZATION}/contents",
+                "description": "Aggregated results"
+            },
+            {
+                "id": f"{HF_ORGANIZATION}/requests",
+                "description": "Evaluation requests"
+            },
+            {
+                "id": f"{HF_ORGANIZATION}/votes",
+                "description": "User votes"
+            },
+            {
+                "id": f"{HF_ORGANIZATION}/official-providers",
+                "description": "Highlighted models"
+            }
+        ]
+        
+        # Analyze each dataset
+        results = []
+        for dataset in datasets:
+            logger.info(f"\nAnalyzing {dataset['description']} ({dataset['id']})...")
+            result = analyze_dataset(dataset['id'])
+            results.append(result)
+            
+            if 'error' in result:
+                logger.error(f"❌ Error: {result['error']}")
+            else:
+                logger.info(f"✓ {result['total_entries']} entries")
+                logger.info(f"✓ {result['file_count']} files")
+                logger.info(f"✓ {result['size_bytes'] / 1024:.1f} KB")
+                logger.info(f"✓ {result['downloads']} downloads")
+                
+                if 'pending_requests' in result:
+                    logger.info(f"✓ {result['pending_requests']} pending requests")
+                    logger.info(f"✓ {result['completed_requests']} completed requests")
+                
+                if result['last_modified']:
+                    last_modified = datetime.fromisoformat(result['last_modified'].replace('Z', '+00:00'))
+                    logger.info(f"✓ Last modified: {last_modified.strftime('%Y-%m-%d %H:%M:%S')}")
+        
+        return results
+            
+    except Exception as e:
+        logger.error(f"Global error: {str(e)}")
+        return []
+
+if __name__ == "__main__":
+    main() 

backend/utils/analyze_prod_models.py

@@ -0,0 +1,106 @@
+import os
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+from huggingface_hub import HfApi
+from dotenv import load_dotenv
+from app.config.hf_config import HF_ORGANIZATION
+
+# Get the backend directory path
+BACKEND_DIR = Path(__file__).parent.parent
+ROOT_DIR = BACKEND_DIR.parent
+
+# Load environment variables from .env file in root directory
+load_dotenv(ROOT_DIR / ".env")
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Initialize Hugging Face API
+HF_TOKEN = os.getenv("HF_TOKEN")
+if not HF_TOKEN:
+    raise ValueError("HF_TOKEN not found in environment variables")
+api = HfApi(token=HF_TOKEN)
+
+def count_evaluated_models():
+    """Count the number of evaluated models"""
+    try:
+        # Get dataset info
+        dataset_info = api.dataset_info(repo_id=f"{HF_ORGANIZATION}/contents", repo_type="dataset")
+        
+        # Get file list
+        files = api.list_repo_files(f"{HF_ORGANIZATION}/contents", repo_type="dataset")
+        
+        # Get last commit info
+        commits = api.list_repo_commits(f"{HF_ORGANIZATION}/contents", repo_type="dataset")
+        last_commit = next(commits, None)
+        
+        # Count lines in jsonl files
+        total_entries = 0
+        for file in files:
+            if file.endswith('.jsonl'):
+                try:
+                    # Download file content
+                    content = api.hf_hub_download(
+                        repo_id=f"{HF_ORGANIZATION}/contents",
+                        filename=file,
+                        repo_type="dataset"
+                    )
+                    
+                    # Count lines
+                    with open(content, 'r') as f:
+                        for _ in f:
+                            total_entries += 1
+                            
+                except Exception as e:
+                    logger.error(f"Error processing file {file}: {str(e)}")
+                    continue
+        
+        # Build response
+        response = {
+            "total_models": total_entries,
+            "last_modified": last_commit.created_at if last_commit else None,
+            "file_count": len(files),
+            "size_bytes": dataset_info.size_in_bytes,
+            "downloads": dataset_info.downloads
+        }
+        
+        return response
+        
+    except Exception as e:
+        logger.error(f"Error counting evaluated models: {str(e)}")
+        return {
+            "error": str(e)
+        }
+
+def main():
+    """Main function to count evaluated models"""
+    try:
+        logger.info("\nAnalyzing evaluated models...")
+        result = count_evaluated_models()
+        
+        if 'error' in result:
+            logger.error(f"❌ Error: {result['error']}")
+        else:
+            logger.info(f"✓ {result['total_models']} models evaluated")
+            logger.info(f"✓ {result['file_count']} files")
+            logger.info(f"✓ {result['size_bytes'] / 1024:.1f} KB")
+            logger.info(f"✓ {result['downloads']} downloads")
+            
+            if result['last_modified']:
+                last_modified = datetime.fromisoformat(result['last_modified'].replace('Z', '+00:00'))
+                logger.info(f"✓ Last modified: {last_modified.strftime('%Y-%m-%d %H:%M:%S')}")
+        
+        return result
+            
+    except Exception as e:
+        logger.error(f"Global error: {str(e)}")
+        return {"error": str(e)}
+
+if __name__ == "__main__":
+    main() 

backend/utils/fix_wrong_model_size.py

@@ -0,0 +1,110 @@
+import os
+import json
+import pytz
+import logging
+import asyncio
+from datetime import datetime
+from pathlib import Path
+import huggingface_hub
+from huggingface_hub.errors import RepositoryNotFoundError, RevisionNotFoundError
+from dotenv import load_dotenv
+from git import Repo
+from datetime import datetime
+from tqdm.auto import tqdm
+from tqdm.contrib.logging import logging_redirect_tqdm
+
+from app.config.hf_config import HF_TOKEN, API
+
+from app.utils.model_validation import ModelValidator
+
+huggingface_hub.logging.set_verbosity_error()
+huggingface_hub.utils.disable_progress_bars()
+
+logging.basicConfig(
+    level=logging.ERROR,
+    format='%(message)s'
+)
+logger = logging.getLogger(__name__)
+load_dotenv()
+
+validator = ModelValidator()
+
+def get_changed_files(repo_path, start_date, end_date):
+    repo = Repo(repo_path)
+    start = datetime.strptime(start_date, '%Y-%m-%d')
+    end = datetime.strptime(end_date, '%Y-%m-%d')
+    
+    changed_files = set()
+    pbar = tqdm(repo.iter_commits(), desc=f"Reading commits from {end_date} to {start_date}")
+    for commit in pbar:
+        commit_date = datetime.fromtimestamp(commit.committed_date)
+        pbar.set_postfix_str(f"Commit date: {commit_date}")
+        if start <= commit_date <= end:
+            changed_files.update(item.a_path for item in commit.diff(commit.parents[0]))
+
+        if commit_date < start:
+            break
+
+    return changed_files
+
+
+def read_json(repo_path, file):
+    with open(f"{repo_path}/{file}") as file:
+        return json.load(file)
+
+
+def write_json(repo_path, file, content):
+    with open(f"{repo_path}/{file}", "w") as file:
+        json.dump(content, file, indent=2)
+
+
+def main():
+    requests_path = "/requests"
+    start_date = "2024-12-09"
+    end_date = "2025-01-07"
+  
+    changed_files = get_changed_files(requests_path, start_date, end_date)
+
+    for file in tqdm(changed_files):
+        try:
+            request_data = read_json(requests_path, file)
+        except FileNotFoundError as e:
+            tqdm.write(f"File {file} not found")
+            continue
+    
+        try:
+            model_info = API.model_info(
+                repo_id=request_data["model"],
+                revision=request_data["revision"],
+                token=HF_TOKEN
+            )
+        except (RepositoryNotFoundError, RevisionNotFoundError) as e:
+            tqdm.write(f"Model info for {request_data["model"]} not found")
+            continue
+        
+        with logging_redirect_tqdm():
+            new_model_size, error = asyncio.run(validator.get_model_size(
+                model_info=model_info,
+                precision=request_data["precision"],
+                base_model=request_data["base_model"],
+                revision=request_data["revision"]
+            ))
+
+        if error:
+            tqdm.write(f"Error getting model size info for {request_data["model"]}, {error}")
+            continue
+        
+        old_model_size = request_data["params"]
+        if old_model_size != new_model_size:
+            if new_model_size > 100:
+                tqdm.write(f"Model: {request_data["model"]}, size is more 100B: {new_model_size}")
+            
+            tqdm.write(f"Model: {request_data["model"]}, old size: {request_data["params"]} new size: {new_model_size}")
+            tqdm.write(f"Updating request file {file}")
+
+            request_data["params"] = new_model_size
+            write_json(requests_path, file, content=request_data)
+
+
+if __name__ == "__main__":
+    main()

backend/utils/last_activity.py

@@ -0,0 +1,164 @@
+import os
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Any, List, Tuple
+from huggingface_hub import HfApi
+from dotenv import load_dotenv
+
+# Get the backend directory path
+BACKEND_DIR = Path(__file__).parent.parent
+ROOT_DIR = BACKEND_DIR.parent
+
+# Load environment variables from .env file in root directory
+load_dotenv(ROOT_DIR / ".env")
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Initialize Hugging Face API
+HF_TOKEN = os.getenv("HF_TOKEN")
+if not HF_TOKEN:
+    raise ValueError("HF_TOKEN not found in environment variables")
+api = HfApi(token=HF_TOKEN)
+
+# Default organization
+HF_ORGANIZATION = os.getenv('HF_ORGANIZATION', 'open-llm-leaderboard')
+
+def get_last_votes(limit: int = 5) -> List[Dict]:
+    """Get the last votes from the votes dataset"""
+    try:
+        logger.info("\nFetching last votes...")
+        
+        # Download and read votes file
+        logger.info("Downloading votes file...")
+        votes_file = api.hf_hub_download(
+            repo_id=f"{HF_ORGANIZATION}/votes",
+            filename="votes_data.jsonl",
+            repo_type="dataset"
+        )
+        
+        logger.info("Reading votes file...")
+        votes = []
+        with open(votes_file, 'r') as f:
+            for line in f:
+                try:
+                    vote = json.loads(line)
+                    votes.append(vote)
+                except json.JSONDecodeError:
+                    continue
+        
+        # Sort by timestamp and get last n votes
+        logger.info("Sorting votes...")
+        votes.sort(key=lambda x: x.get('timestamp', ''), reverse=True)
+        last_votes = votes[:limit]
+        
+        logger.info(f"✓ Found {len(last_votes)} recent votes")
+        return last_votes
+        
+    except Exception as e:
+        logger.error(f"Error reading votes: {str(e)}")
+        return []
+
+def get_last_models(limit: int = 5) -> List[Dict]:
+    """Get the last models from the requests dataset using commit history"""
+    try:
+        logger.info("\nFetching last model submissions...")
+        
+        # Get commit history
+        logger.info("Getting commit history...")
+        commits = list(api.list_repo_commits(
+            repo_id=f"{HF_ORGANIZATION}/requests",
+            repo_type="dataset"
+        ))
+        logger.info(f"Found {len(commits)} commits")
+        
+        # Track processed files to avoid duplicates
+        processed_files = set()
+        models = []
+        
+        # Process commits until we have enough models
+        for i, commit in enumerate(commits):
+            logger.info(f"Processing commit {i+1}/{len(commits)} ({commit.created_at})")
+            
+            # Look at added/modified files in this commit
+            files_to_process = [f for f in (commit.added + commit.modified) if f.endswith('.json')]
+            if files_to_process:
+                logger.info(f"Found {len(files_to_process)} JSON files in commit")
+            
+            for file in files_to_process:
+                if file in processed_files:
+                    continue
+                    
+                processed_files.add(file)
+                logger.info(f"Downloading {file}...")
+                
+                try:
+                    # Download and read the file
+                    content = api.hf_hub_download(
+                        repo_id=f"{HF_ORGANIZATION}/requests",
+                        filename=file,
+                        repo_type="dataset"
+                    )
+                    
+                    with open(content, 'r') as f:
+                        model_data = json.load(f)
+                        models.append(model_data)
+                        logger.info(f"✓ Added model {model_data.get('model', 'Unknown')}")
+                        
+                        if len(models) >= limit:
+                            logger.info("Reached desired number of models")
+                            break
+                            
+                except Exception as e:
+                    logger.error(f"Error reading file {file}: {str(e)}")
+                    continue
+                    
+            if len(models) >= limit:
+                break
+        
+        logger.info(f"✓ Found {len(models)} recent model submissions")
+        return models
+        
+    except Exception as e:
+        logger.error(f"Error reading models: {str(e)}")
+        return []
+
+def main():
+    """Display last activities from the leaderboard"""
+    try:
+        # Get last votes
+        logger.info("\n=== Last Votes ===")
+        last_votes = get_last_votes()
+        if last_votes:
+            for vote in last_votes:
+                logger.info(f"\nModel: {vote.get('model')}")
+                logger.info(f"User: {vote.get('username')}")
+                logger.info(f"Timestamp: {vote.get('timestamp')}")
+        else:
+            logger.info("No votes found")
+        
+        # Get last model submissions
+        logger.info("\n=== Last Model Submissions ===")
+        last_models = get_last_models()
+        if last_models:
+            for model in last_models:
+                logger.info(f"\nModel: {model.get('model')}")
+                logger.info(f"Submitter: {model.get('sender', 'Unknown')}")
+                logger.info(f"Status: {model.get('status', 'Unknown')}")
+                logger.info(f"Submission Time: {model.get('submitted_time', 'Unknown')}")
+                logger.info(f"Precision: {model.get('precision', 'Unknown')}")
+                logger.info(f"Weight Type: {model.get('weight_type', 'Unknown')}")
+        else:
+            logger.info("No models found")
+            
+    except Exception as e:
+        logger.error(f"Global error: {str(e)}")
+
+if __name__ == "__main__":
+    main() 

backend/utils/sync_datasets_locally.py

@@ -0,0 +1,130 @@
+import os
+import shutil
+import tempfile
+import logging
+from pathlib import Path
+from huggingface_hub import HfApi, snapshot_download, upload_folder, create_repo
+from dotenv import load_dotenv
+
+# Configure source and destination usernames
+SOURCE_USERNAME = "open-llm-leaderboard"
+DESTINATION_USERNAME = "tfrere"
+
+# Get the backend directory path
+BACKEND_DIR = Path(__file__).parent.parent
+ROOT_DIR = BACKEND_DIR.parent
+
+# Load environment variables from .env file in root directory
+load_dotenv(ROOT_DIR / ".env")
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# List of dataset names to sync
+DATASET_NAMES = [
+    "votes",
+    "results",
+    "requests",
+    "contents",
+    "official-providers",
+]
+
+# Build list of datasets with their source and destination paths
+DATASETS = [
+    (name, f"{SOURCE_USERNAME}/{name}", f"{DESTINATION_USERNAME}/{name}")
+    for name in DATASET_NAMES
+]
+
+# Initialize Hugging Face API
+api = HfApi()
+
+def ensure_repo_exists(repo_id, token):
+    """Ensure the repository exists, create it if it doesn't"""
+    try:
+        api.repo_info(repo_id=repo_id, repo_type="dataset")
+        logger.info(f"✓ Repository {repo_id} already exists")
+    except Exception:
+        logger.info(f"Creating repository {repo_id}...")
+        create_repo(
+            repo_id=repo_id,
+            repo_type="dataset",
+            token=token,
+            private=True
+        )
+        logger.info(f"✓ Repository {repo_id} created")
+
+def process_dataset(dataset_info, token):
+    """Process a single dataset"""
+    name, source_dataset, destination_dataset = dataset_info
+    try:
+        logger.info(f"\n📥 Processing dataset: {name}")
+        
+        # Ensure destination repository exists
+        ensure_repo_exists(destination_dataset, token)
+        
+        # Create a temporary directory for this dataset
+        with tempfile.TemporaryDirectory() as temp_dir:
+            try:
+                # List files in source dataset
+                logger.info(f"Listing files in {source_dataset}...")
+                files = api.list_repo_files(source_dataset, repo_type="dataset")
+                logger.info(f"Detected structure: {len(files)} files")
+                
+                # Download dataset
+                logger.info(f"Downloading from {source_dataset}...")
+                local_dir = snapshot_download(
+                    repo_id=source_dataset,
+                    repo_type="dataset",
+                    local_dir=temp_dir,
+                    token=token
+                )
+                logger.info(f"✓ Download complete")
+                
+                # Upload to destination while preserving structure
+                logger.info(f"📤 Uploading to {destination_dataset}...")
+                api.upload_folder(
+                    folder_path=local_dir,
+                    repo_id=destination_dataset,
+                    repo_type="dataset",
+                    token=token
+                )
+                logger.info(f"✅ {name} copied successfully!")
+                return True
+                
+            except Exception as e:
+                logger.error(f"❌ Error processing {name}: {str(e)}")
+                return False
+
+    except Exception as e:
+        logger.error(f"❌ Error for {name}: {str(e)}")
+        return False
+
+def copy_datasets():
+    try:
+        logger.info("🔑 Checking authentication...")
+        # Get token from .env file
+        token = os.getenv("HF_TOKEN")
+        if not token:
+            raise ValueError("HF_TOKEN not found in .env file")
+        
+        # Process datasets sequentially
+        results = []
+        for dataset_info in DATASETS:
+            success = process_dataset(dataset_info, token)
+            results.append((dataset_info[0], success))
+            
+        # Print final summary
+        logger.info("\n📊 Final summary:")
+        for dataset, success in results:
+            status = "✅ Success" if success else "❌ Failure"
+            logger.info(f"{dataset}: {status}")
+            
+    except Exception as e:
+        logger.error(f"❌ Global error: {str(e)}")
+
+if __name__ == "__main__":
+    copy_datasets() 

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,121 @@
+import React, { useEffect } from "react";
+import {
+  HashRouter as Router,
+  Routes,
+  Route,
+  useSearchParams,
+  useLocation,
+} from "react-router-dom";
+import { ThemeProvider } from "@mui/material/styles";
+import { Box, CssBaseline } from "@mui/material";
+import Navigation from "./components/Navigation/Navigation";
+import LeaderboardPage from "./pages/LeaderboardPage/LeaderboardPage";
+import QuotePage from "./pages/QuotePage/QuotePage";
+import Footer from "./components/Footer/Footer";
+import getTheme from "./config/theme";
+import { useThemeMode } from "./hooks/useThemeMode";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import LeaderboardProvider from "./pages/LeaderboardPage/components/Leaderboard/context/LeaderboardContext";
+
+const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      retry: 1,
+      refetchOnWindowFocus: false,
+    },
+  },
+});
+
+function UrlHandler() {
+  const location = useLocation();
+  const [searchParams] = useSearchParams();
+
+  // Synchroniser l'URL avec la page parente HF
+  useEffect(() => {
+    // Vérifier si nous sommes dans un iframe HF Space
+    const isHFSpace = window.location !== window.parent.location;
+    if (!isHFSpace) return;
+
+    // Sync query and hash from this embedded app to the parent page URL
+    const queryString = window.location.search;
+    const hash = window.location.hash;
+
+    // HF Spaces' special message type to update the query string and the hash in the parent page URL
+    window.parent.postMessage(
+      {
+        queryString,
+        hash,
+      },
+      "https://huggingface.co"
+    );
+  }, [location, searchParams]);
+
+  // Read the updated hash reactively
+  useEffect(() => {
+    const handleHashChange = (event) => {
+      console.log("hash change event", event);
+    };
+
+    window.addEventListener("hashchange", handleHashChange);
+    return () => window.removeEventListener("hashchange", handleHashChange);
+  }, []);
+
+  return null;
+}
+
+function App() {
+  const { mode, toggleTheme } = useThemeMode();
+  const theme = getTheme(mode);
+
+  return (
+    <div
+      className="App"
+      style={{
+        height: "100%",
+        width: "100%",
+        WebkitOverflowScrolling: "touch",
+        overflow: "auto",
+      }}
+    >
+      <QueryClientProvider client={queryClient}>
+        <ThemeProvider theme={theme}>
+          <CssBaseline />
+          <Router>
+            <LeaderboardProvider>
+              <UrlHandler />
+              <Box
+                sx={{
+                  minHeight: "100vh",
+                  display: "flex",
+                  flexDirection: "column",
+                  bgcolor: "background.default",
+                  color: "text.primary",
+                }}
+              >
+                <Navigation onToggleTheme={toggleTheme} mode={mode} />
+                <Box
+                  sx={{
+                    flex: 1,
+                    display: "flex",
+                    flexDirection: "column",
+                    width: "100%",
+                    px: 4,
+                    pb: 4,
+                  }}
+                >
+                  <Routes>
+                    <Route path="/" element={<LeaderboardPage />} />
+                    <Route path="/quote" element={<QuotePage />} />
+                  </Routes>
+                </Box>
+                <Footer />
+              </Box>
+            </LeaderboardProvider>
+          </Router>
+        </ThemeProvider>
+      </QueryClientProvider>
+    </div>
+  );
+}
+
+export default App;

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/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;