docker-container-test

Dockerfile

@@ -49,6 +49,7 @@ WORKDIR /app
 
 # Environment variables
 ENV HF_HOME=/app/.cache \
+    TRANSFORMERS_CACHE=/app/.cache \
     HF_DATASETS_CACHE=/app/.cache \
     INTERNAL_API_PORT=7861 \
     PORT=7860 \

README.md

@@ -10,12 +10,6 @@ license: apache-2.0
 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
 ---
 

backend/README.md

@@ -70,7 +70,7 @@ The application uses several datasets on the HuggingFace Hub:
 - **Format**: Main dataset containing all scores and metrics
 - **Updates**: Automatic after model evaluations
 
-### 4. Official Providers Dataset (`{HF_ORGANIZATION}/official-providers`)
+### 4. Maintainers Highlight Dataset (`{HF_ORGANIZATION}/maintainers-highlight`)
 
 - **Operations**:
   - 📥 Read-only access for highlighted models
@@ -203,7 +203,7 @@ Swagger documentation available at http://localhost:7860/docs
         is_merged: boolean,
         is_moe: boolean,
         is_flagged: boolean,
-        is_official_provider: boolean
+        is_highlighted_by_maintainer: boolean
       },
       metadata: {
         upload_date: string,

backend/app/api/dependencies.py

@@ -2,7 +2,7 @@ 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
+from app.utils.logging import LogFormatter
 
 logger = logging.getLogger(__name__)
 

backend/app/api/endpoints/leaderboard.py

@@ -3,7 +3,7 @@ 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
+from app.utils.logging import LogFormatter
 
 logger = logging.getLogger(__name__)
 router = APIRouter()

backend/app/api/endpoints/models.py

@@ -1,10 +1,10 @@
-from fastapi import APIRouter, HTTPException, Depends, Query
+from fastapi import APIRouter, HTTPException, Depends
 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
+from app.utils.logging import LogFormatter
 
 logger = logging.getLogger(__name__)
 router = APIRouter(tags=["models"])
@@ -80,19 +80,6 @@ async def submit_model(
         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,

backend/app/api/endpoints/votes.py

@@ -1,17 +1,14 @@
-from fastapi import APIRouter, HTTPException, Query, Depends, Response
+from fastapi import APIRouter, HTTPException, Query, Depends
 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
+from app.utils.logging import LogFormatter
 
 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')
@@ -29,25 +26,22 @@ def user_votes_key_builder(func, namespace: str = "user_votes", **kwargs):
 
 @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
+    user_id: str = Query(..., description="HuggingFace username")
 ) -> Dict[str, Any]:
     try:
         logger.info(LogFormatter.section("ADDING VOTE"))
         stats = {
             "Model": model_id,
             "User": user_id,
-            "Type": vote_type,
-            "Config": vote_data or {}
+            "Type": vote_type
         }
         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)
+        result = await vote_service.add_vote(model_id, user_id, vote_type)
         
         # Invalidate affected caches
         try:
@@ -58,8 +52,8 @@ async def add_vote(
             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)
+            invalidate_cache_key(model_cache_key)
+            invalidate_cache_key(user_cache_key)
             
             cache_stats = {
                 "Model_Cache": model_cache_key,
@@ -71,18 +65,14 @@ async def add_vote(
         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)
+@cached(expire=60, key_builder=model_votes_key_builder)
 async def get_model_votes(
-    response: Response,
     provider: str, 
     model: str
 ) -> Dict[str, Any]:
@@ -92,11 +82,6 @@ async def get_model_votes(
         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:
@@ -104,9 +89,8 @@ async def get_model_votes(
         raise HTTPException(status_code=400, detail=str(e))
 
 @router.get("/user/{user_id}")
-@cached(expire=CACHE_TTL, key_builder=user_votes_key_builder)
+@cached(expire=60, 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"""
@@ -114,11 +98,6 @@ async def get_user_votes(
         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:

backend/app/asgi.py

@@ -12,7 +12,7 @@ import sys
 
 from app.api.router import router
 from app.core.fastapi_cache import setup_cache
-from app.core.formatting import LogFormatter
+from app.utils.logging import LogFormatter
 from app.config import hf_config
 
 # Configure logging before anything else
@@ -99,7 +99,7 @@ async def startup_event():
     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}"))
+    logger.info(LogFormatter.info(f"  - Maintainers Highlight: {hf_config.MAINTAINERS_HIGHLIGHT_REPO}"))
     
     # Setup cache
     setup_cache()

backend/app/config/hf_config.py

@@ -1,9 +1,13 @@
+"""
+Hugging Face configuration module
+"""
 import os
 import logging
 from typing import Optional
 from huggingface_hub import HfApi
 from pathlib import Path
 from app.core.cache import cache_config
+from app.utils.logging import LogFormatter
 
 logger = logging.getLogger(__name__)
 
@@ -22,7 +26,7 @@ API = HfApi(token=HF_TOKEN)
 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"
+MAINTAINERS_HIGHLIGHT_REPO = f"{HF_ORGANIZATION}/maintainers-highlight"
 
 # File paths from cache config
 VOTES_PATH = cache_config.votes_file

backend/app/core/cache.py

@@ -3,7 +3,7 @@ import shutil
 from pathlib import Path
 from datetime import timedelta
 import logging
-from app.core.formatting import LogFormatter
+from app.utils.logging import LogFormatter
 from app.config.base import (
     CACHE_ROOT,
     DATASETS_CACHE,
@@ -58,16 +58,16 @@ class CacheConfig:
     def _setup_environment(self):
         """Configure HuggingFace environment variables"""
         logger.info(LogFormatter.subsection("ENVIRONMENT SETUP"))
-
+        
         env_vars = {
             "HF_HOME": str(self.cache_root),
+            "TRANSFORMERS_CACHE": str(self.models_cache),
             "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"""

backend/app/core/fastapi_cache.py

@@ -4,64 +4,36 @@ 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
+from app.utils.logging import LogFormatter
 
 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):
+    FastAPICache.init(
+        backend=InMemoryBackend(),
+        prefix="fastapi-cache",
+        expire=CACHE_TTL
+    )
+    logger.info(LogFormatter.success("FastAPI Cache initialized with in-memory backend"))
+
+def invalidate_cache_key(key: str):
     """Invalidate a specific cache key"""
     try:
         backend = FastAPICache.get_backend()
         if hasattr(backend, 'delete'):
-            await backend.delete(key)
+            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 build_cache_key(namespace: str, *args) -> str:
+    """Build a consistent cache key"""
+    key = f"fastapi-cache:{namespace}:{':'.join(str(arg) for arg in args)}"
+    logger.debug(LogFormatter.info(f"Built cache key: {key}"))
+    return key
 
 def cached(expire: int = CACHE_TTL, key_builder=None):
     """Decorator for caching endpoint responses

backend/app/core/formatting.py

@@ -1,104 +0,0 @@
-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/services/hf_service.py

@@ -2,7 +2,7 @@ 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
+from app.utils.logging import LogFormatter
 import logging
 
 logger = logging.getLogger(__name__)

backend/app/services/leaderboard.py

@@ -5,7 +5,7 @@ import datasets
 from fastapi import HTTPException
 import logging
 from app.config.base import HF_ORGANIZATION
-from app.core.formatting import LogFormatter
+from app.utils.logging import LogFormatter
 
 logger = logging.getLogger(__name__)
 
@@ -143,7 +143,7 @@ class LeaderboardService:
                 "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)
+                "is_highlighted_by_maintainer": data.get("Official Providers", False)
             }
 
             metadata = {

backend/app/services/models.py

@@ -1,4 +1,4 @@
-from datetime import datetime, timezone, timedelta
+from datetime import datetime, timezone
 from typing import Dict, Any, Optional, List
 import json
 import os
@@ -25,7 +25,7 @@ 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
+from app.utils.logging import LogFormatter
 
 # Disable datasets progress bars globally
 disable_progress_bar()
@@ -217,25 +217,24 @@ class ModelService(HuggingFaceService):
             
             try:
                 logger.info(LogFormatter.subsection("DATASET LOADING"))
-                logger.info(LogFormatter.info("Loading dataset..."))
+                logger.info(LogFormatter.info("Loading dataset files..."))
                 
-                # Download entire dataset snapshot
+                # List files in repository
                 with suppress_output():
-                    local_dir = self.hf_api.snapshot_download(
+                    files = self.hf_api.list_repo_files(
                         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"))
+                # Filter JSON files
+                json_files = [f for f in files if f.endswith('.json')]
                 total_files = len(json_files)
                 
                 # Log repository stats
                 stats = {
-                    "Total_Files": total_files,
-                    "Local_Dir": str(local_path),
+                    "Total_Files": len(files),
+                    "JSON_Files": total_files,
                 }
                 for line in LogFormatter.stats(stats, "Repository Statistics"):
                     logger.info(line)
@@ -246,67 +245,28 @@ class ModelService(HuggingFaceService):
                 # 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"]
-                        }
+                try:
+                    # Create aiohttp session to reuse connections
+                    async with aiohttp.ClientSession() as session:
+                        # Process files in chunks
+                        chunk_size = 50
                         
-                        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")
-                            }
+                        for i in range(0, len(json_files), chunk_size):
+                            chunk = json_files[i:i + chunk_size]
+                            chunk_tasks = [
+                                self._download_and_process_file(file, session, progress)
+                                for file in chunk
+                            ]
+                            results = await asyncio.gather(*chunk_tasks)
                             
-                            # 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)
+                            # Process results
+                            for result in results:
+                                if result:
+                                    status = result.pop("status")
+                                    models[status.lower()].append(result)
                 
-                progress.close()
+                finally:
+                    progress.close()
                 
                 # Final summary with fancy formatting
                 logger.info(LogFormatter.section("CACHE SUMMARY"))
@@ -449,14 +409,6 @@ class ModelService(HuggingFaceService):
             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:
@@ -502,11 +454,11 @@ class ModelService(HuggingFaceService):
         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"))
+        logger.info(LogFormatter.success(f"Model size validation passed: {model_size:.1f}GB"))
 
         # 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)"
+            error_msg = f"Model too large for {model_data['precision']} (limit: 100GB)"
             logger.error(LogFormatter.error("Size limit exceeded", error_msg))
             raise Exception(error_msg)
 
@@ -590,11 +542,7 @@ class ModelService(HuggingFaceService):
             await self.vote_service.add_vote(
                 model_data["model_id"],
                 user_id,
-                "up",
-                {
-                    "precision": model_data["precision"],
-                    "revision": model_data["revision"]
-                }
+                "up"
             )
             logger.info(LogFormatter.success("Vote recorded successfully"))
         except Exception as e:
@@ -628,41 +576,4 @@ class ModelService(HuggingFaceService):
                             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 
+        return {"status": "not_found"} 

backend/app/services/votes.py

@@ -4,16 +4,16 @@ import json
 import logging
 import asyncio
 from pathlib import Path
+import os
 import aiohttp
 from huggingface_hub import HfApi
-import tempfile
-import os
+import datasets
 
 from app.services.hf_service import HuggingFaceService
-from app.config import HF_TOKEN
+from app.config import HF_TOKEN, API
 from app.config.hf_config import HF_ORGANIZATION
 from app.core.cache import cache_config
-from app.core.formatting import LogFormatter
+from app.utils.logging import LogFormatter
 
 logger = logging.getLogger(__name__)
 
@@ -31,15 +31,17 @@ class VoteService(HuggingFaceService):
             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.vote_check_set: Set[Tuple[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._upload_lock = asyncio.Lock()
             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._upload_batch_size = 10
             self.hf_api = HfApi(token=HF_TOKEN)
             self._init_done = True
 
@@ -55,21 +57,29 @@ class VoteService(HuggingFaceService):
             # 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
+            # Load existing votes if file exists
+            local_vote_count = 0
+            if self.votes_file.exists():
+                logger.info(LogFormatter.info(f"Loading votes from {self.votes_file}"))
+                local_vote_count = await self._count_local_votes()
+                logger.info(LogFormatter.info(f"Found {local_vote_count:,} local votes"))
+            
+            # Check remote votes count
+            remote_vote_count = await self._count_remote_votes()
+            logger.info(LogFormatter.info(f"Found {remote_vote_count:,} remote votes"))
+            
+            if remote_vote_count > local_vote_count:
+                logger.info(LogFormatter.info(f"Fetching {remote_vote_count - local_vote_count:,} new votes"))
+                await self._sync_with_hub()
+            elif remote_vote_count < local_vote_count:
+                logger.warning(LogFormatter.warning(f"Local votes ({local_vote_count:,}) > Remote votes ({remote_vote_count:,})"))
                 await self._load_existing_votes()
             else:
-                logger.warning(LogFormatter.warning("No votes found on hub"))
+                logger.info(LogFormatter.success("Local and remote votes are in sync"))
+                if local_vote_count > 0:
+                    await self._load_existing_votes()
+                else:
+                    logger.info(LogFormatter.info("No votes found"))
             
             self._initialized = True
             self._last_sync = datetime.now(timezone.utc)
@@ -87,105 +97,80 @@ class VoteService(HuggingFaceService):
             logger.error(LogFormatter.error("Initialization failed", e))
             raise
 
-    async def _fetch_remote_votes(self) -> List[Dict[str, Any]]:
-        """Fetch votes from HF hub"""
+    async def _count_local_votes(self) -> int:
+        """Count votes in local file"""
+        if not self.votes_file.exists():
+            return 0
+            
+        count = 0
+        try:
+            with open(self.votes_file, 'r') as f:
+                for _ in f:
+                    count += 1
+            return count
+        except Exception as e:
+            logger.error(f"Error counting local votes: {str(e)}")
+            return 0
+
+    async def _count_remote_votes(self) -> int:
+        """Count votes in remote file"""
         url = f"https://huggingface.co/datasets/{HF_ORGANIZATION}/votes/raw/main/votes_data.jsonl"
-        headers = {"Authorization": f"Bearer {self.token}"} if self.token else {}
+        headers = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
         
         try:
             async with aiohttp.ClientSession() as session:
                 async with session.get(url, headers=headers) as response:
                     if response.status == 200:
-                        votes = []
+                        count = 0
                         async for line in response.content:
-                            if line.strip():
-                                try:
-                                    vote = json.loads(line.decode())
-                                    votes.append(vote)
-                                except json.JSONDecodeError:
-                                    continue
-                        return votes
+                            if line.strip():  # Skip empty lines
+                                count += 1
+                        return count
                     else:
                         logger.error(f"Failed to get remote votes: HTTP {response.status}")
-                        return []
+                        return 0
         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)}")
+            logger.error(f"Error counting remote votes: {str(e)}")
+            return 0
 
     async def _sync_with_hub(self):
-        """Sync votes with HuggingFace hub"""
+        """Sync votes with HuggingFace hub using datasets"""
         try:
             logger.info(LogFormatter.section("VOTE SYNC"))
+            self._log_repo_operation("sync", f"{HF_ORGANIZATION}/votes", "Syncing local votes with HF hub")
+            logger.info(LogFormatter.info("Syncing with HuggingFace hub..."))
+            
+            # Load votes from HF dataset
+            dataset = datasets.load_dataset(
+                f"{HF_ORGANIZATION}/votes", 
+                split="train",
+                cache_dir=cache_config.get_cache_path("datasets")
+            )
             
-            # Get current remote votes
-            remote_votes = await self._fetch_remote_votes()
-            logger.info(LogFormatter.info(f"Loaded {len(remote_votes)} votes from hub"))
+            remote_votes = len(dataset)
+            logger.info(LogFormatter.info(f"Dataset loaded with {remote_votes:,} votes"))
             
-            # 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)
+            # Convert to list of dictionaries
+            df = dataset.to_pandas()
+            if 'timestamp' in df.columns:
+                df['timestamp'] = df['timestamp'].dt.strftime('%Y-%m-%dT%H:%M:%SZ')
+            remote_votes = df.to_dict('records')
+            
+            # If we have more remote votes than local
+            if len(remote_votes) > self._total_votes:
+                new_votes = len(remote_votes) - self._total_votes
+                logger.info(LogFormatter.info(f"Processing {new_votes:,} new votes..."))
                 
-                # Create temporary file with all votes
-                with tempfile.NamedTemporaryFile(mode='w', suffix='.jsonl', delete=False) as temp_file:
+                # Save votes to local file
+                with open(self.votes_file, 'w') as f:
                     for vote in remote_votes:
-                        json.dump(vote, temp_file)
-                        temp_file.write('\n')
-                    temp_path = temp_file.name
+                        f.write(json.dumps(vote) + '\n')
                 
-                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"))
+                # Reload votes in memory
+                await self._load_existing_votes()
+                logger.info(LogFormatter.success("Sync completed successfully"))
+            else:
+                logger.info(LogFormatter.success("Local votes are up to date"))
 
             self._last_sync = datetime.now(timezone.utc)
             
@@ -193,6 +178,23 @@ class VoteService(HuggingFaceService):
             logger.error(LogFormatter.error("Sync failed", e))
             raise
 
+    async def _check_for_new_votes(self):
+        """Check for new votes on the hub"""
+        try:
+            self._log_repo_operation("check", f"{HF_ORGANIZATION}/votes", "Checking for new votes")
+            # Load only dataset metadata
+            dataset_info = datasets.load_dataset(f"{HF_ORGANIZATION}/votes", split="train")
+            remote_vote_count = len(dataset_info)
+            
+            if remote_vote_count > self._total_votes:
+                logger.info(f"Found {remote_vote_count - self._total_votes} new votes on hub")
+                await self._sync_with_hub()
+            else:
+                logger.info("No new votes found on hub")
+                
+        except Exception as e:
+            logger.error(f"Error checking for new votes: {str(e)}")
+
     async def _load_existing_votes(self):
         """Load existing votes from file"""
         if not self.votes_file.exists():
@@ -260,13 +262,7 @@ class VoteService(HuggingFaceService):
     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")
-            )
+            check_tuple = (vote["model"], vote["revision"], vote["username"])
             
             # Skip if we already have this vote
             if check_tuple in self.vote_check_set:
@@ -285,19 +281,13 @@ class VoteService(HuggingFaceService):
             self._votes_by_user[vote["username"]].append(vote)
             
         except KeyError as e:
-            logger.error(LogFormatter.error("Malformed vote data, missing key", str(e)))
+            logger.error(f"Malformed vote data, missing key: {str(e)}")
         except Exception as e:
-            logger.error(LogFormatter.error("Error adding vote to memory", str(e)))
+            logger.error(f"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
@@ -305,31 +295,19 @@ class VoteService(HuggingFaceService):
     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 = {}
+        # Group votes by revision
+        votes_by_revision = {}
         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
+            revision = vote["revision"]
+            if revision not in votes_by_revision:
+                votes_by_revision[revision] = 0
+            votes_by_revision[revision] += 1
         
         stats = {
             "Total_Votes": len(votes),
-            **{f"Config_{k}": v["count"] for k, v in votes_by_config.items()}
+            **{f"Revision_{k}": v for k, v in votes_by_revision.items()}
         }
         
         logger.info(LogFormatter.section("VOTE STATISTICS"))
@@ -338,7 +316,7 @@ class VoteService(HuggingFaceService):
         
         return {
             "total_votes": len(votes),
-            "votes_by_config": votes_by_config,
+            "votes_by_revision": votes_by_revision,
             "votes": votes
         }
 
@@ -360,7 +338,7 @@ class VoteService(HuggingFaceService):
                     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]:
+    async def add_vote(self, model_id: str, user_id: str, vote_type: str) -> 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}")
@@ -368,48 +346,23 @@ class VoteService(HuggingFaceService):
             stats = {
                 "Model": model_id,
                 "User": user_id,
-                "Type": vote_type,
-                "Config": vote_data or {}
+                "Type": vote_type
             }
             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)
+            revision = await self._get_model_revision(model_id)
+            check_tuple = (model_id, revision, user_id)
             
             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'})")
+                raise ValueError("Vote already recorded for this model")
 
             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
+                "vote_type": vote_type
             }
 
             # Update local storage
@@ -421,18 +374,15 @@ class VoteService(HuggingFaceService):
             
             stats = {
                 "Status": "Success",
-                "Queue_Size": len(self.votes_to_upload),
-                "Model_Config": {
-                    "Precision": precision,
-                    "Revision": revision[:7] if revision else "unknown"
-                }
+                "Queue_Size": len(self.votes_to_upload)
             }
             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()
+            # Try to upload if batch size reached
+            if len(self.votes_to_upload) >= self._upload_batch_size:
+                logger.info(LogFormatter.info(f"Upload batch size reached ({self._upload_batch_size}), triggering sync"))
+                await self._sync_with_hub()
             
             return {"status": "success", "message": "Vote added successfully"}
             

backend/app/utils/logging.py

@@ -1,3 +1,105 @@
-from app.core.formatting import LogFormatter
+import logging
+import sys
+from typing import Dict, Any, List, Optional
 
-__all__ = ['LogFormatter']
+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/utils/model_validation.py

@@ -1,14 +1,15 @@
 import json
 import logging
 import asyncio
+import re
 from typing import Tuple, Optional, Dict, Any
-from datasets import load_dataset
+import aiohttp
 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
+from app.config.base import HF_TOKEN, API
+from app.utils.logging import LogFormatter
+
 
 logger = logging.getLogger(__name__)
 
@@ -104,12 +105,13 @@ class ModelValidator:
                 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
+                    model_size = (adapter_size + base_size) / (2 * 1e9)  # Convert to billions, assuming float16
             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
+                    total_params = sum(meta.parameter_count.values())
+                    model_size = total_params / (2 * 1e9)  # Convert to billions, assuming float16
 
             if model_size is None:
                 # If model size could not be determined, return an error
@@ -117,7 +119,6 @@ class ModelValidator:
 
             # 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"))
@@ -206,61 +207,4 @@ class ModelValidator:
         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
+            return False, f"The model was not found or is misconfigured on the Hub. Error: {e.args[0]}", None

backend/pyproject.toml

@@ -10,12 +10,12 @@ fastapi = "^0.115.6"
 uvicorn = {extras = ["standard"], version = "^0.34.0"}
 numpy = "^2.2.0"
 pandas = "^2.2.3"
-datasets = "^3.3.2"
+datasets = "^3.2.0"
 pyarrow = "^18.1.0"
 python-multipart = "^0.0.20"
-huggingface-hub = "0.29.1"
-transformers = "4.49.0"
-safetensors = "^0.5.3"
+huggingface-hub = "^0.27.0"
+transformers = "^4.47.0"
+safetensors = "^0.4.5"
 aiofiles = "^24.1.0"
 fastapi-cache2 = "^0.2.1"
 python-dotenv = "^1.0.1"

backend/utils/analyze_prod_datasets.py

@@ -132,7 +132,7 @@ def main():
                 "description": "User votes"
             },
             {
-                "id": f"{HF_ORGANIZATION}/official-providers",
+                "id": f"{HF_ORGANIZATION}/maintainers-highlight",
                 "description": "Highlighted models"
             }
         ]

backend/utils/fix_wrong_model_size.py

@@ -1,110 +0,0 @@
-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/sync_datasets_locally.py

@@ -30,7 +30,7 @@ DATASET_NAMES = [
     "results",
     "requests",
     "contents",
-    "official-providers",
+    "maintainers-highlight",
 ]
 
 # Build list of datasets with their source and destination paths

frontend/src/components/shared/AuthContainer.js

@@ -7,8 +7,6 @@ import {
   Stack,
   Paper,
   CircularProgress,
-  useTheme,
-  useMediaQuery,
 } from "@mui/material";
 import HFLogo from "../Logo/HFLogo";
 import { useAuth } from "../../hooks/useAuth";
@@ -18,8 +16,6 @@ import { useNavigate } from "react-router-dom";
 function AuthContainer({ actionText = "DO_ACTION" }) {
   const { isAuthenticated, user, login, logout, loading } = useAuth();
   const navigate = useNavigate();
-  const theme = useTheme();
-  const isMobile = useMediaQuery(theme.breakpoints.down("sm"));
 
   const handleLogout = () => {
     if (isAuthenticated && logout) {
@@ -67,14 +63,7 @@ function AuthContainer({ actionText = "DO_ACTION" }) {
         <Typography variant="h6" align="center">
           Login to {actionText}
         </Typography>
-        <Typography
-          variant="body2"
-          color="text.secondary"
-          align="center"
-          sx={{
-            px: isMobile ? 2 : 0,
-          }}
-        >
+        <Typography variant="body2" color="text.secondary" align="center">
           You need to be logged in with your Hugging Face account to{" "}
           {actionText.toLowerCase()}
         </Typography>
@@ -98,7 +87,6 @@ function AuthContainer({ actionText = "DO_ACTION" }) {
             fontWeight: 600,
             py: 1,
             px: 2,
-            width: isMobile ? "100%" : "auto",
           }}
         >
           Sign in with Hugging Face
@@ -113,22 +101,13 @@ function AuthContainer({ actionText = "DO_ACTION" }) {
       sx={{ p: 2, border: "1px solid", borderColor: "grey.300", mb: 4 }}
     >
       <Stack
-        direction={isMobile ? "column" : "row"}
+        direction="row"
         spacing={2}
-        alignItems={isMobile ? "stretch" : "center"}
+        alignItems="center"
         justifyContent="space-between"
       >
-        <Stack
-          direction={isMobile ? "column" : "row"}
-          spacing={1}
-          alignItems={isMobile ? "stretch" : "center"}
-          sx={{ width: "100%" }}
-        >
-          <Typography
-            variant="body1"
-            align={isMobile ? "center" : "left"}
-            sx={{ mb: isMobile ? 1 : 0 }}
-          >
+        <Stack direction="row" spacing={1} alignItems="center">
+          <Typography variant="body1">
             Connected as <strong>{user?.username}</strong>
           </Typography>
           <Chip
@@ -136,13 +115,6 @@ function AuthContainer({ actionText = "DO_ACTION" }) {
             color="success"
             size="small"
             variant="outlined"
-            sx={{
-              width: isMobile ? "100%" : "auto",
-              height: isMobile ? 32 : 24,
-              "& .MuiChip-label": {
-                px: isMobile ? 2 : 1,
-              },
-            }}
           />
         </Stack>
         <Button
@@ -155,7 +127,6 @@ function AuthContainer({ actionText = "DO_ACTION" }) {
             height: 36,
             textTransform: "none",
             fontSize: "0.9375rem",
-            width: isMobile ? "100%" : "auto",
           }}
         >
           Logout

frontend/src/pages/AddModelPage/AddModelPage.js

@@ -5,7 +5,6 @@ import PageHeader from "../../components/shared/PageHeader";
 import EvaluationQueues from "./components/EvaluationQueues/EvaluationQueues";
 import ModelSubmissionForm from "./components/ModelSubmissionForm/ModelSubmissionForm";
 import SubmissionGuide from "./components/SubmissionGuide/SubmissionGuide";
-import SubmissionLimitChecker from "./components/SubmissionLimitChecker/SubmissionLimitChecker";
 
 function AddModelPage() {
   const { isAuthenticated, loading, user } = useAuth();
@@ -26,7 +25,7 @@ function AddModelPage() {
   }
 
   return (
-    <Box sx={{ width: "100%", maxWidth: 1200, margin: "0 auto", py: 4, px: 0 }}>
+    <Box sx={{ width: "100%", maxWidth: 1200, margin: "0 auto", padding: 4 }}>
       <PageHeader
         title="Submit a Model for Evaluation"
         subtitle={
@@ -39,9 +38,7 @@ function AddModelPage() {
 
       <SubmissionGuide />
 
-      <SubmissionLimitChecker user={user}>
-        <ModelSubmissionForm user={user} isAuthenticated={isAuthenticated} />
-      </SubmissionLimitChecker>
+      <ModelSubmissionForm user={user} isAuthenticated={isAuthenticated} />
 
       <EvaluationQueues defaultExpanded={false} />
     </Box>

frontend/src/pages/AddModelPage/components/EvaluationQueues/EvaluationQueues.js

@@ -17,8 +17,6 @@ import {
   AccordionDetails,
   Stack,
   Tooltip,
-  useTheme,
-  useMediaQuery,
 } from "@mui/material";
 import AccessTimeIcon from "@mui/icons-material/AccessTime";
 import CheckCircleIcon from "@mui/icons-material/CheckCircle";
@@ -194,13 +192,16 @@ const ModelTable = ({ models, emptyMessage, status }) => {
               style={{
                 height: `${rowVirtualizer.getTotalSize()}px`,
                 padding: 0,
-                position: "relative",
-                width: "100%",
-                height: `${rowVirtualizer.getTotalSize()}px`,
               }}
               colSpan={columns.length}
             >
-              <>
+              <div
+                style={{
+                  position: "relative",
+                  width: "100%",
+                  height: `${rowVirtualizer.getTotalSize()}px`,
+                }}
+              >
                 {rowVirtualizer.getVirtualItems().map((virtualRow) => {
                   const model = models[virtualRow.index];
                   const waitTime = formatWaitTime(model.wait_time);
@@ -221,6 +222,7 @@ const ModelTable = ({ models, emptyMessage, status }) => {
                       hover
                     >
                       <TableCell
+                        component="div"
                         sx={{
                           flex: `0 0 ${columns[0].width}`,
                           padding: "12px 16px",
@@ -256,6 +258,7 @@ const ModelTable = ({ models, emptyMessage, status }) => {
                         </Link>
                       </TableCell>
                       <TableCell
+                        component="div"
                         sx={{
                           flex: `0 0 ${columns[1].width}`,
                           padding: "12px 16px",
@@ -271,6 +274,7 @@ const ModelTable = ({ models, emptyMessage, status }) => {
                         {model.submitter}
                       </TableCell>
                       <TableCell
+                        component="div"
                         align={columns[2].align}
                         sx={{
                           flex: `0 0 ${columns[2].width}`,
@@ -299,6 +303,7 @@ const ModelTable = ({ models, emptyMessage, status }) => {
                         </Tooltip>
                       </TableCell>
                       <TableCell
+                        component="div"
                         align={columns[3].align}
                         sx={{
                           flex: `0 0 ${columns[3].width}`,
@@ -315,6 +320,7 @@ const ModelTable = ({ models, emptyMessage, status }) => {
                         </Typography>
                       </TableCell>
                       <TableCell
+                        component="div"
                         align={columns[4].align}
                         sx={{
                           flex: `0 0 ${columns[4].width}`,
@@ -330,6 +336,7 @@ const ModelTable = ({ models, emptyMessage, status }) => {
                         {model.revision.substring(0, 7)}
                       </TableCell>
                       <TableCell
+                        component="div"
                         align={columns[5].align}
                         sx={{
                           flex: `0 0 ${columns[5].width}`,
@@ -344,7 +351,7 @@ const ModelTable = ({ models, emptyMessage, status }) => {
                     </TableRow>
                   );
                 })}
-              </>
+              </div>
             </TableCell>
           </TableRow>
         </TableBody>
@@ -361,133 +368,90 @@ const QueueAccordion = ({
   expanded,
   onChange,
   loading,
-}) => {
-  const theme = useTheme();
-  const isMobile = useMediaQuery(theme.breakpoints.down("sm"));
-
-  return (
-    <Accordion
-      expanded={expanded}
-      onChange={onChange}
-      disabled={loading}
-      sx={{
-        "&:before": { display: "none" },
-        boxShadow: "none",
-        border: "none",
-      }}
-    >
-      <AccordionSummary
-        expandIcon={<ExpandMoreIcon />}
-        sx={{
-          px: { xs: 2, sm: 3 },
-          py: { xs: 1.5, sm: 2 },
-          alignItems: { xs: "flex-start", sm: "center" },
-          "& .MuiAccordionSummary-expandIconWrapper": {
-            marginTop: { xs: "4px", sm: 0 },
-          },
-        }}
-      >
-        <Stack
-          direction={{ xs: "column", sm: "row" }}
-          spacing={{ xs: 1, sm: 2 }}
-          alignItems={{ xs: "flex-start", sm: "center" }}
-          sx={{ width: "100%" }}
-        >
-          <Typography
-            sx={{
-              fontSize: { xs: "0.95rem", sm: "1rem" },
-              fontWeight: 500,
-            }}
-          >
-            {title}
-          </Typography>
-          <Stack
-            direction={{ xs: "column", sm: "row" }}
-            spacing={1}
-            alignItems={{ xs: "stretch", sm: "center" }}
-            sx={{
-              ml: { xs: 0, sm: "auto" },
-              width: { xs: "100%", sm: "auto" },
-            }}
-          >
-            <Chip
-              label={models.length}
-              size={isMobile ? "small" : "medium"}
-              color={
+}) => (
+  <Accordion
+    expanded={expanded}
+    onChange={onChange}
+    disabled={loading}
+    sx={{
+      "&:before": { display: "none" },
+      boxShadow: "none",
+      border: "none",
+    }}
+  >
+    <AccordionSummary expandIcon={<ExpandMoreIcon />}>
+      <Stack direction="row" spacing={2} alignItems="center">
+        <Typography>{title}</Typography>
+        <Stack direction="row" spacing={1} alignItems="center">
+          <Chip
+            label={models.length}
+            size="small"
+            color={
+              status === "finished"
+                ? "success"
+                : status === "evaluating"
+                ? "warning"
+                : "info"
+            }
+            variant="outlined"
+            sx={(theme) => ({
+              borderWidth: 2,
+              fontWeight: 600,
+              bgcolor:
+                status === "finished"
+                  ? theme.palette.success[100]
+                  : status === "evaluating"
+                  ? theme.palette.warning[100]
+                  : theme.palette.info[100],
+              borderColor:
                 status === "finished"
-                  ? "success"
+                  ? theme.palette.success[400]
                   : status === "evaluating"
-                  ? "warning"
-                  : "info"
-              }
-              variant="outlined"
-              sx={(theme) => ({
-                borderWidth: 2,
-                fontWeight: 600,
-                fontSize: { xs: "0.75rem", sm: "0.875rem" },
-                height: { xs: "24px", sm: "32px" },
-                width: { xs: "100%", sm: "auto" },
+                  ? theme.palette.warning[400]
+                  : theme.palette.info[400],
+              color:
+                status === "finished"
+                  ? theme.palette.success[700]
+                  : status === "evaluating"
+                  ? theme.palette.warning[700]
+                  : theme.palette.info[700],
+              "& .MuiChip-label": {
+                px: 1.2,
+              },
+              "&:hover": {
                 bgcolor:
                   status === "finished"
-                    ? theme.palette.success[100]
-                    : status === "evaluating"
-                    ? theme.palette.warning[100]
-                    : theme.palette.info[100],
-                borderColor:
-                  status === "finished"
-                    ? theme.palette.success[400]
+                    ? theme.palette.success[200]
                     : status === "evaluating"
-                    ? theme.palette.warning[400]
-                    : theme.palette.info[400],
-                color:
-                  status === "finished"
-                    ? theme.palette.success[700]
-                    : status === "evaluating"
-                    ? theme.palette.warning[700]
-                    : theme.palette.info[700],
-                "& .MuiChip-label": {
-                  px: { xs: 1, sm: 1.2 },
-                  width: "100%",
-                },
-                "&:hover": {
-                  bgcolor:
-                    status === "finished"
-                      ? theme.palette.success[200]
-                      : status === "evaluating"
-                      ? theme.palette.warning[200]
-                      : theme.palette.info[200],
-                },
-              })}
-            />
-            {loading && (
-              <CircularProgress
-                size={isMobile ? 14 : 16}
-                color="inherit"
-                sx={{ opacity: 0.5 }}
-              />
-            )}
-          </Stack>
-        </Stack>
-      </AccordionSummary>
-      <AccordionDetails sx={{ p: { xs: 1, sm: 2 } }}>
-        <Box
-          sx={{
-            border: "1px solid",
-            borderColor: "grey.200",
-            borderRadius: 1,
-            overflow: "hidden",
-          }}
-        >
-          <ModelTable
-            models={models}
-            emptyMessage={emptyMessage}
-            status={status}
+                    ? theme.palette.warning[200]
+                    : theme.palette.info[200],
+              },
+            })}
           />
-        </Box>
-      </AccordionDetails>
-    </Accordion>
-  );
-};
+          {loading && (
+            <CircularProgress size={16} color="inherit" sx={{ opacity: 0.5 }} />
+          )}
+        </Stack>
+      </Stack>
+    </AccordionSummary>
+    <AccordionDetails sx={{ p: 2 }}>
+      <Box
+        sx={{
+          border: "1px solid",
+          borderColor: "grey.200",
+          borderRadius: 1,
+          overflow: "hidden",
+        }}
+      >
+        <ModelTable
+          models={models}
+          emptyMessage={emptyMessage}
+          status={status}
+        />
+      </Box>
+    </AccordionDetails>
+  </Accordion>
+);
 
 const EvaluationQueues = ({ defaultExpanded = true }) => {
   const [expanded, setExpanded] = useState(defaultExpanded);
@@ -499,8 +463,6 @@ const EvaluationQueues = ({ defaultExpanded = true }) => {
   });
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState(null);
-  const theme = useTheme();
-  const isMobile = useMediaQuery(theme.breakpoints.down("sm"));
 
   useEffect(() => {
     const fetchModels = async () => {
@@ -581,12 +543,11 @@ const EvaluationQueues = ({ defaultExpanded = true }) => {
           opacity: 0.9,
         },
         "& .MuiAccordionSummary-root": {
-          minHeight: { xs: 56, sm: 64 },
+          minHeight: 64,
           bgcolor: "background.paper",
           borderRadius: "8px",
-          alignItems: { xs: "flex-start", sm: "center" },
           "&.Mui-expanded": {
-            minHeight: { xs: 56, sm: 64 },
+            minHeight: 64,
             borderRadius: "8px 8px 0 0",
           },
         },
@@ -601,70 +562,52 @@ const EvaluationQueues = ({ defaultExpanded = true }) => {
       <AccordionSummary
         expandIcon={<ExpandMoreIcon />}
         sx={{
-          px: { xs: 2, sm: 3 },
+          px: 3,
           "& .MuiAccordionSummary-expandIconWrapper": {
             color: "text.secondary",
             transform: "rotate(0deg)",
             transition: "transform 150ms",
-            marginTop: { xs: "4px", sm: 0 },
             "&.Mui-expanded": {
               transform: "rotate(180deg)",
             },
           },
         }}
       >
-        <Stack
-          direction={{ xs: "column", sm: "row" }}
-          spacing={{ xs: 1, sm: 2 }}
-          alignItems={{ xs: "flex-start", sm: "center" }}
-          sx={{ width: "100%" }}
-        >
+        <Stack direction="row" spacing={2} alignItems="center">
           <Typography
             variant="h6"
             sx={{
               fontWeight: 600,
               color: "text.primary",
               letterSpacing: "-0.01em",
-              fontSize: { xs: "1.1rem", sm: "1.25rem" },
             }}
           >
             Evaluation Status
           </Typography>
           {!loading && (
             <Stack
-              direction={{ xs: "column", sm: "row" }}
+              direction="row"
               spacing={1}
               sx={{
                 transition: "opacity 0.2s",
                 ".Mui-expanded &": {
                   opacity: 0,
-                  height: 0,
-                  m: 0,
-                  overflow: "hidden",
                 },
-                width: { xs: "100%", sm: "auto" },
-                alignItems: { xs: "stretch", sm: "center" },
               }}
             >
               <Chip
                 label={`${models.pending.length} In Queue`}
-                size={isMobile ? "small" : "medium"}
+                size="small"
                 color="info"
                 variant="outlined"
                 sx={{
                   borderWidth: 2,
                   fontWeight: 600,
-                  fontSize: { xs: "0.75rem", sm: "0.875rem" },
-                  height: { xs: "24px", sm: "32px" },
                   bgcolor: "info.100",
                   borderColor: "info.400",
                   color: "info.700",
-                  width: { xs: "100%", sm: "auto" },
                   "& .MuiChip-label": {
-                    px: { xs: 1, sm: 1.2 },
-                    width: "100%",
-                    display: "flex",
-                    justifyContent: "center",
+                    px: 1.2,
                   },
                   "&:hover": {
                     bgcolor: "info.200",
@@ -673,23 +616,17 @@ const EvaluationQueues = ({ defaultExpanded = true }) => {
               />
               <Chip
                 label={`${models.evaluating.length} Evaluating`}
-                size={isMobile ? "small" : "medium"}
+                size="small"
                 color="warning"
                 variant="outlined"
                 sx={{
                   borderWidth: 2,
                   fontWeight: 600,
-                  fontSize: { xs: "0.75rem", sm: "0.875rem" },
-                  height: { xs: "24px", sm: "32px" },
                   bgcolor: "warning.100",
                   borderColor: "warning.400",
                   color: "warning.700",
-                  width: { xs: "100%", sm: "auto" },
                   "& .MuiChip-label": {
-                    px: { xs: 1, sm: 1.2 },
-                    width: "100%",
-                    display: "flex",
-                    justifyContent: "center",
+                    px: 1.2,
                   },
                   "&:hover": {
                     bgcolor: "warning.200",
@@ -698,23 +635,17 @@ const EvaluationQueues = ({ defaultExpanded = true }) => {
               />
               <Chip
                 label={`${models.finished.length} Evaluated`}
-                size={isMobile ? "small" : "medium"}
+                size="small"
                 color="success"
                 variant="outlined"
                 sx={{
                   borderWidth: 2,
                   fontWeight: 600,
-                  fontSize: { xs: "0.75rem", sm: "0.875rem" },
-                  height: { xs: "24px", sm: "32px" },
                   bgcolor: "success.100",
                   borderColor: "success.400",
                   color: "success.700",
-                  width: { xs: "100%", sm: "auto" },
                   "& .MuiChip-label": {
-                    px: { xs: 1, sm: 1.2 },
-                    width: "100%",
-                    display: "flex",
-                    justifyContent: "center",
+                    px: 1.2,
                   },
                   "&:hover": {
                     bgcolor: "success.200",
@@ -725,7 +656,7 @@ const EvaluationQueues = ({ defaultExpanded = true }) => {
           )}
           {loading && (
             <CircularProgress
-              size={isMobile ? 18 : 20}
+              size={20}
               sx={{
                 color: "primary.main",
               }}

frontend/src/pages/AddModelPage/components/ModelSubmissionForm/ModelSubmissionForm.js

@@ -18,6 +18,7 @@ import {
 } from "@mui/material";
 import RocketLaunchIcon from "@mui/icons-material/RocketLaunch";
 import CheckCircleOutlineIcon from "@mui/icons-material/CheckCircleOutline";
+import ThumbUpIcon from "@mui/icons-material/ThumbUp";
 import { alpha } from "@mui/material/styles";
 import InfoIconWithTooltip from "../../../../components/shared/InfoIconWithTooltip";
 import { MODEL_TYPES } from "../../../../pages/LeaderboardPage/components/Leaderboard/constants/modelTypes";
@@ -112,10 +113,9 @@ const HELP_TEXTS = {
         Chat Template Support
       </Typography>
       <Typography variant="body2" sx={{ opacity: 0.9, lineHeight: 1.4 }}>
-        Activates automatically for chat models. It uses the standardized
-        Hugging Face chat template for consistent prompt formatting during
-        evaluation. Required for models using RLHF, DPO, or instruction
-        fine-tuning.
+        Activates automatically for chat models. It uses the standardized Hugging
+        Face chat template for consistent prompt formatting during evaluation.
+        Required for models using RLHF, DPO, or instruction fine-tuning.
       </Typography>
     </Box>
   ),
@@ -411,7 +411,7 @@ function ModelSubmissionForm({ user, isAuthenticated }) {
                   placeholder="organization/model-name"
                   value={formData.modelName}
                   onChange={handleChange}
-                  helperText="Example: meta-llama/Llama-3.2-1B"
+                  helperText="Example: meta-llama/Llama-2-7b-hf"
                   InputProps={{
                     endAdornment: (
                       <InfoIconWithTooltip tooltip={HELP_TEXTS.modelName} />

frontend/src/pages/AddModelPage/components/SubmissionLimitChecker/SubmissionLimitChecker.js

@@ -1,85 +0,0 @@
-import React, { useState, useEffect } from "react";
-import { Alert, Box, CircularProgress } from "@mui/material";
-
-const MAX_SUBMISSIONS_PER_WEEK = 10;
-
-function SubmissionLimitChecker({ user, children }) {
-  const [loading, setLoading] = useState(true);
-  const [reachedLimit, setReachedLimit] = useState(false);
-  const [error, setError] = useState(false);
-
-  useEffect(() => {
-    const checkSubmissionLimit = async () => {
-      if (!user?.username) {
-        setLoading(false);
-        return;
-      }
-
-      try {
-        const response = await fetch(
-          `/api/models/organization/${user.username}/submissions?days=7`
-        );
-        if (!response.ok) {
-          throw new Error("Failed to fetch submission data");
-        }
-
-        const submissions = await response.json();
-        console.log(`Recent submissions for ${user.username}:`, submissions);
-        setReachedLimit(submissions.length >= MAX_SUBMISSIONS_PER_WEEK);
-        setError(false);
-      } catch (error) {
-        console.error("Error checking submission limit:", error);
-        setError(true);
-      } finally {
-        setLoading(false);
-      }
-    };
-
-    checkSubmissionLimit();
-  }, [user?.username]);
-
-  if (loading) {
-    return (
-      <Box sx={{ display: "flex", justifyContent: "center", py: 4 }}>
-        <CircularProgress />
-      </Box>
-    );
-  }
-
-  if (error) {
-    return (
-      <Alert
-        severity="error"
-        sx={{
-          mb: 3,
-          "& .MuiAlert-message": {
-            fontSize: "1rem",
-          },
-        }}
-      >
-        Unable to verify submission limits. Please try again in a few minutes.
-      </Alert>
-    );
-  }
-
-  if (reachedLimit) {
-    return (
-      <Alert
-        severity="warning"
-        sx={{
-          mb: 3,
-          "& .MuiAlert-message": {
-            fontSize: "1rem",
-          },
-        }}
-      >
-        For fairness reasons, you cannot submit more than{" "}
-        {MAX_SUBMISSIONS_PER_WEEK} models per week. Please try again later.
-      </Alert>
-    );
-  }
-
-  return children;
-}
-
-export default SubmissionLimitChecker;

frontend/src/pages/LeaderboardPage/components/Leaderboard/components/Filters/FilteredModelCount.js

@@ -19,7 +19,7 @@ const useModelCount = ({ totalCount, filteredCount, data, table, loading }) => {
       };
     }
     const displayCount = isOfficialProviderActive
-      ? officialOnlyCounts.officialProviders
+      ? officialOnlyCounts.maintainersHighlight
       : totalCount;
 
     // Calculate total number of pinned models
@@ -46,8 +46,8 @@ const useModelCount = ({ totalCount, filteredCount, data, table, loading }) => {
         // Filter by official providers
         if (filterConfig.isOfficialProviderActive) {
           if (
-            !model.features?.is_official_provider &&
-            !model.metadata?.is_official_provider
+            !model.features?.is_highlighted_by_maintainer &&
+            !model.metadata?.is_highlighted_by_maintainer
           ) {
             return false;
           }
@@ -100,7 +100,7 @@ const useModelCount = ({ totalCount, filteredCount, data, table, loading }) => {
                 typeof filter === "object" ? filter.value : filter;
 
               // Maintainer's Highlight keeps positive logic
-              if (filterValue === "is_official_provider") {
+              if (filterValue === "is_highlighted_by_maintainer") {
                 return model.features[filterValue];
               }
 
@@ -134,7 +134,7 @@ const useModelCount = ({ totalCount, filteredCount, data, table, loading }) => {
     data,
     state.filters,
     isOfficialProviderActive,
-    officialOnlyCounts.officialProviders,
+    officialOnlyCounts.maintainersHighlight,
   ]);
 };
 

frontend/src/pages/LeaderboardPage/components/Leaderboard/components/Filters/Filters.js

@@ -781,18 +781,18 @@ const LeaderboardFilters = ({
                           <FilterTag
                             label={filter.label}
                             checked={
-                              filter.value === "is_official_provider"
+                              filter.value === "is_highlighted_by_maintainer"
                                 ? isOfficialProviderActive
                                 : selectedBooleanFilters.includes(filter.value)
                             }
                             onChange={
-                              filter.value === "is_official_provider"
+                              filter.value === "is_highlighted_by_maintainer"
                                 ? handleOfficialProviderToggle
                                 : () => handleBooleanFilterToggle(filter.value)
                             }
                             count={
-                              filter.value === "is_official_provider"
-                                ? currentCounts.officialProviders
+                              filter.value === "is_highlighted_by_maintainer"
+                                ? currentCounts.maintainersHighlight
                                 : 0
                             }
                             showCheckbox={true}
@@ -815,7 +815,7 @@ const LeaderboardFilters = ({
                                 borderRadius: "50%",
                                 backgroundColor: (
                                   filter.value ===
-                                  "is_official_provider"
+                                  "is_highlighted_by_maintainer"
                                     ? isOfficialProviderActive
                                     : selectedBooleanFilters.includes(
                                         filter.value
@@ -826,7 +826,7 @@ const LeaderboardFilters = ({
                               }}
                             />
                             {(
-                              filter.value === "is_official_provider"
+                              filter.value === "is_highlighted_by_maintainer"
                                 ? isOfficialProviderActive
                                 : selectedBooleanFilters.includes(filter.value)
                             )

frontend/src/pages/LeaderboardPage/components/Leaderboard/components/Filters/QuickFilters.js

@@ -206,7 +206,7 @@ const QuickFilters = ({ totalCount = 0, loading = false }) => {
               label={officialProvidersPreset.label}
               checked={isOfficialProviderActive}
               onChange={handleOfficialProviderToggle}
-              count={currentCounts.officialProviders}
+              count={currentCounts.maintainersHighlight}
               totalCount={totalCount}
               showCheckbox={true}
               variant="secondary"

frontend/src/pages/LeaderboardPage/components/Leaderboard/components/Filters/hooks/useOfficialProvidersMode.js

@@ -23,7 +23,7 @@ export const useOfficialProvidersMode = () => {
 
     const filters = searchParams.get("filters");
     const isHighlighted =
-      filters?.includes("is_official_provider") || false;
+      filters?.includes("is_highlighted_by_maintainer") || false;
 
     // On initial load
     if (isInitialLoadRef.current) {
@@ -33,7 +33,7 @@ export const useOfficialProvidersMode = () => {
       if (isHighlighted && filters) {
         const initialNormalFilters = filters
           .split(",")
-          .filter((f) => f !== "is_official_provider" && f !== "")
+          .filter((f) => f !== "is_highlighted_by_maintainer" && f !== "")
           .filter(Boolean);
         if (initialNormalFilters.length > 0) {
           normalFiltersRef.current = initialNormalFilters.join(",");
@@ -70,7 +70,7 @@ export const useOfficialProvidersMode = () => {
       const currentFiltersStr = searchParams.get("filters");
       const currentFilters =
         currentFiltersStr?.split(",").filter(Boolean) || [];
-      const highlightFilter = "is_official_provider";
+      const highlightFilter = "is_highlighted_by_maintainer";
       const newSearchParams = new URLSearchParams(searchParams);
 
       if (currentFilters.includes(highlightFilter)) {

frontend/src/pages/LeaderboardPage/components/Leaderboard/constants/defaults.js

@@ -59,14 +59,14 @@ const FILTERS = {
       hide: true,
     },
     {
-      value: "is_official_provider",
+      value: "is_highlighted_by_maintainer",
       label: "Only Official Providers",
       hide: false,
     },
   ],
   HIGHLIGHT_OPTIONS: [
     {
-      value: "is_official_provider",
+      value: "is_highlighted_by_maintainer",
       label: "Only Official Providers",
     },
   ],
@@ -237,7 +237,7 @@ const COLUMNS = {
       defaultVisible: false,
       label: "Hub Availability",
     },
-    "features.is_official_provider": {
+    "features.is_highlighted_by_maintainer": {
       group: "additional_info",
       size: COLUMN_SIZES.OFFICIAL_PROVIDER,
       defaultVisible: false,

frontend/src/pages/LeaderboardPage/components/Leaderboard/constants/quickFilters.js

@@ -45,7 +45,7 @@ export const QUICK_FILTER_PRESETS = [
     shortDescription: 'Officially provided models',
     description: 'Models that are officially provided and maintained by official creators or organizations.',
     filters: {
-      selectedBooleanFilters: ['is_official_provider']
+      selectedBooleanFilters: ['is_highlighted_by_maintainer']
     }
   }
 ]; 

frontend/src/pages/LeaderboardPage/components/Leaderboard/constants/tooltips.js

@@ -258,7 +258,7 @@ export const COLUMN_TOOLTIPS = {
         "For detailed information about our CO₂ calculation methodology, visit:",
       subItems: [
         <a
-          href="https://huggingface.co/docs/leaderboards/open_llm_leaderboard/emissions"
+          href="https://huggingface.co/docs/hub/carbon-emissions"
           target="_blank"
           rel="noopener noreferrer"
           style={{ color: "#90caf9" }}

frontend/src/pages/LeaderboardPage/components/Leaderboard/context/LeaderboardContext.js

@@ -47,7 +47,7 @@ const createInitialCounts = () => {
   return {
     modelTypes,
     precisions,
-    officialProviders: 0,
+    maintainersHighlight: 0,
     mixtureOfExperts: 0,
     flagged: 0,
     merged: 0,
@@ -129,7 +129,7 @@ const modelMatchesFilters = (model, filters) => {
       const filterValue = typeof filter === "object" ? filter.value : filter;
 
       // Maintainer's Highlight keeps positive logic
-      if (filterValue === "is_official_provider") {
+      if (filterValue === "is_highlighted_by_maintainer") {
         return model.features[filterValue];
       }
 
@@ -187,8 +187,8 @@ const calculateModelCounts = (models) => {
 
   models.forEach((model) => {
     const isOfficial =
-      model.features?.is_official_provider ||
-      model.metadata?.is_official_provider;
+      model.features?.is_highlighted_by_maintainer ||
+      model.metadata?.is_highlighted_by_maintainer;
     const countsToUpdate = [normalCounts];
 
     if (isOfficial) {
@@ -214,10 +214,10 @@ const calculateModelCounts = (models) => {
 
       // Boolean filters
       if (
-        model.features?.is_official_provider ||
-        model.metadata?.is_official_provider
+        model.features?.is_highlighted_by_maintainer ||
+        model.metadata?.is_highlighted_by_maintainer
       )
-        counts.officialProviders++;
+        counts.maintainersHighlight++;
       if (model.features?.is_moe || model.metadata?.is_moe)
         counts.mixtureOfExperts++;
       if (model.features?.is_flagged || model.metadata?.is_flagged)

frontend/src/pages/LeaderboardPage/components/Leaderboard/hooks/useDataUtils.js

@@ -4,7 +4,6 @@ import {
   parseSearchQuery,
   getValueByPath,
 } from "../utils/searchUtils";
-import { MODEL_TYPE_ORDER } from "../constants/modelTypes";
 
 // Calculate min/max averages
 export const useAverageRange = (data) => {
@@ -59,7 +58,9 @@ export const useProcessedData = (data, averageMode, visibleColumns) => {
         ...item.features,
         is_moe: Boolean(item.features.is_moe),
         is_flagged: Boolean(item.features.is_flagged),
-        is_official_provider: Boolean(item.features.is_official_provider),
+        is_highlighted_by_maintainer: Boolean(
+          item.features.is_highlighted_by_maintainer
+        ),
         is_merged: Boolean(item.features.is_merged),
         is_not_available_on_hub: Boolean(item.features.is_not_available_on_hub),
       };
@@ -83,12 +84,10 @@ export const useProcessedData = (data, averageMode, visibleColumns) => {
       return b.model.average_score - a.model.average_score;
     });
 
-    const result = processed.map((item, index) => ({
+    return processed.map((item, index) => ({
       ...item,
       static_rank: index + 1,
     }));
-
-    return result;
   }, [data, averageMode, visibleColumns]);
 };
 
@@ -108,7 +107,6 @@ export const useFilteredData = (
     const pinnedData = processedData.filter((row) => {
       return pinnedModels.includes(row.id);
     });
-
     const unpinnedData = processedData.filter((row) => {
       return !pinnedModels.includes(row.id);
     });
@@ -119,8 +117,8 @@ export const useFilteredData = (
     if (isOfficialProviderActive) {
       filteredUnpinned = filteredUnpinned.filter(
         (row) =>
-          row.features?.is_official_provider ||
-          row.metadata?.is_official_provider
+          row.features?.is_highlighted_by_maintainer ||
+          row.metadata?.is_highlighted_by_maintainer
       );
     }
 
@@ -132,10 +130,7 @@ export const useFilteredData = (
     }
 
     // Filter by type
-    if (
-      selectedTypes.length > 0 &&
-      selectedTypes.length < MODEL_TYPE_ORDER.length
-    ) {
+    if (selectedTypes.length > 0) {
       filteredUnpinned = filteredUnpinned.filter((row) => {
         const modelType = row.model.type?.toLowerCase().trim();
         return selectedTypes.some((type) => modelType?.includes(type));
@@ -143,14 +138,15 @@ export const useFilteredData = (
     }
 
     // Filter by parameters
-    if (!(paramsRange[0] === -1 && paramsRange[1] === 140)) {
-      filteredUnpinned = filteredUnpinned.filter((row) => {
-        const params =
-          row.metadata?.params_billions || row.features?.params_billions;
-        if (params === undefined || params === null) return false;
-        return params >= paramsRange[0] && params < paramsRange[1];
-      });
-    }
+    filteredUnpinned = filteredUnpinned.filter((row) => {
+      // Skip parameter filtering if no filter is active
+      if (paramsRange[0] === -1 && paramsRange[1] === 140) return true;
+
+      const params =
+        row.metadata?.params_billions || row.features?.params_billions;
+      if (params === undefined || params === null) return false;
+      return params >= paramsRange[0] && params < paramsRange[1];
+    });
 
     // Filter by search
     if (searchValue) {
@@ -201,7 +197,7 @@ export const useFilteredData = (
             typeof filter === "object" ? filter.value : filter;
 
           // Maintainer's Highlight keeps positive logic
-          if (filterValue === "is_official_provider") {
+          if (filterValue === "is_highlighted_by_maintainer") {
             return row.features[filterValue];
           }
 

frontend/src/pages/LeaderboardPage/components/Leaderboard/hooks/useLeaderboardData.js

@@ -4,6 +4,9 @@ import { useSearchParams } from "react-router-dom";
 import { useLeaderboard } from "../context/LeaderboardContext";
 import { useDataProcessing } from "../components/Table/hooks/useDataProcessing";
 
+const CACHE_KEY = "leaderboardData";
+const CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
+
 export const useLeaderboardData = () => {
   const queryClient = useQueryClient();
   const [searchParams] = useSearchParams();
@@ -12,41 +15,44 @@ export const useLeaderboardData = () => {
   const { data, isLoading, error } = useQuery({
     queryKey: ["leaderboard"],
     queryFn: async () => {
-      console.log("🔄 Starting API fetch attempt...");
       try {
-        console.log("🌐 Fetching from API...");
-        const response = await fetch("/api/leaderboard/formatted");
-        console.log("📡 API Response status:", response.status);
+        const cachedData = localStorage.getItem(CACHE_KEY);
+        if (cachedData) {
+          const { data: cached, timestamp } = JSON.parse(cachedData);
+          const age = Date.now() - timestamp;
+          if (age < CACHE_DURATION) {
+            return cached;
+          }
+        }
 
+        const response = await fetch("/api/leaderboard/formatted");
         if (!response.ok) {
-          const errorText = await response.text();
-          console.error("🚨 API Error:", {
-            status: response.status,
-            statusText: response.statusText,
-            body: errorText,
-          });
           throw new Error(`HTTP error! status: ${response.status}`);
         }
 
         const newData = await response.json();
-        console.log("📥 Received data size:", JSON.stringify(newData).length);
+        localStorage.setItem(
+          CACHE_KEY,
+          JSON.stringify({
+            data: newData,
+            timestamp: Date.now(),
+          })
+        );
+
         return newData;
       } catch (error) {
-        console.error("🔥 Detailed error:", {
-          name: error.name,
-          message: error.message,
-          stack: error.stack,
-        });
+        console.error("Detailed error:", error);
         throw error;
       }
     },
+    staleTime: CACHE_DURATION,
+    cacheTime: CACHE_DURATION * 2,
     refetchOnWindowFocus: false,
     enabled: isInitialLoadRef.current || !!searchParams.toString(),
   });
 
   useMemo(() => {
     if (data && isInitialLoadRef.current) {
-      console.log("🎯 Initial load complete");
       isInitialLoadRef.current = false;
     }
   }, [data]);

frontend/src/pages/LeaderboardPage/components/Leaderboard/utils/columnUtils.js

@@ -1003,18 +1003,18 @@ export const createColumns = (
       ],
     },
     {
-      accessorKey: "features.is_official_provider",
+      accessorKey: "features.is_highlighted_by_maintainer",
       header: createHeaderCell(
         "Official Providers",
         "Models that are officially provided and maintained by their original creators or organizations"
       ),
       cell: ({ row }) => (
         <BooleanValue
-          value={row.original.features.is_official_provider}
+          value={row.original.features.is_highlighted_by_maintainer}
         />
       ),
       size: TABLE_DEFAULTS.COLUMNS.COLUMN_SIZES[
-        "features.is_official_provider"
+        "features.is_highlighted_by_maintainer"
       ],
       enableSorting: true,
     },
@@ -1061,7 +1061,7 @@ export const createColumns = (
           "metadata.base_model": 10,
           "model.has_chat_template": 11,
           "features.is_not_available_on_hub": 12,
-          "features.is_official_provider": 13,
+          "features.is_highlighted_by_maintainer": 13,
           "features.is_moe": 14,
           "features.is_flagged": 15,
         };

frontend/src/pages/QuotePage/QuotePage.js

@@ -226,7 +226,7 @@ const CitationBlock = ({ citation, title, authors, url, type }) => {
 
 function QuotePage() {
   return (
-    <Box sx={{ width: "100%", maxWidth: 1200, margin: "0 auto", py: 4, px: 0 }}>
+    <Box sx={{ width: "100%", maxWidth: 1200, margin: "0 auto", padding: 4 }}>
       <PageHeader
         title="Citation Information"
         subtitle="How to cite the Open LLM Leaderboard in your work"

frontend/src/pages/VoteModelPage/VoteModelPage.js

@@ -13,8 +13,6 @@ import {
   IconButton,
   Stack,
   Link,
-  useTheme,
-  useMediaQuery,
 } from "@mui/material";
 import AccessTimeIcon from "@mui/icons-material/AccessTime";
 import PersonIcon from "@mui/icons-material/Person";
@@ -70,23 +68,12 @@ const NoModelsToVote = () => (
   </Box>
 );
 
-const LOCAL_STORAGE_KEY = "pending_votes";
-
 function VoteModelPage() {
-  const { isAuthenticated, user, loading: authLoading } = useAuth();
+  const { isAuthenticated, user, loading } = useAuth();
   const [pendingModels, setPendingModels] = useState([]);
   const [loadingModels, setLoadingModels] = useState(true);
   const [error, setError] = useState(null);
   const [userVotes, setUserVotes] = useState(new Set());
-  const [loadingVotes, setLoadingVotes] = useState({});
-  const [localVotes, setLocalVotes] = useState(new Set());
-  const theme = useTheme();
-  const isMobile = useMediaQuery(theme.breakpoints.down("sm"));
-
-  // Create a unique identifier for a model
-  const getModelUniqueId = (model) => {
-    return `${model.name}_${model.precision}_${model.revision}`;
-  };
 
   const formatWaitTime = (submissionTime) => {
     if (!submissionTime) return "N/A";
@@ -111,263 +98,177 @@ function VoteModelPage() {
     return `${diffInWeeks}w`;
   };
 
-  const getConfigVotes = (votesData, model) => {
-    // Créer l'identifiant unique du modèle
-    const modelUniqueId = getModelUniqueId(model);
-
-    // Compter les votes du serveur
-    let serverVotes = 0;
-    for (const [key, config] of Object.entries(votesData.votes_by_config)) {
-      if (
-        config.precision === model.precision &&
-        config.revision === model.revision
-      ) {
-        serverVotes = config.count;
-        break;
-      }
-    }
-
-    // Ajouter les votes en attente du localStorage
-    const pendingVote = localVotes.has(modelUniqueId) ? 1 : 0;
-
-    return serverVotes + pendingVote;
-  };
+  // Fetch user's votes
+  useEffect(() => {
+    const fetchUserVotes = async () => {
+      if (!isAuthenticated || !user) return;
 
-  const sortModels = (models) => {
-    // Trier d'abord par nombre de votes décroissant, puis par soumission de l'utilisateur
-    return [...models].sort((a, b) => {
-      // Comparer d'abord le nombre de votes
-      if (b.votes !== a.votes) {
-        return b.votes - a.votes;
-      }
+      try {
+        // Récupérer les votes du localStorage
+        const localVotes = JSON.parse(
+          localStorage.getItem(`votes_${user.username}`) || "[]"
+        );
+        const localVotesSet = new Set(localVotes);
 
-      // Si l'utilisateur est connecté, mettre ses modèles en priorité
-      if (user) {
-        const aIsUserModel = a.submitter === user.username;
-        const bIsUserModel = b.submitter === user.username;
+        // Récupérer les votes du serveur
+        const response = await fetch(`/api/votes/user/${user.username}`);
+        if (!response.ok) {
+          throw new Error("Failed to fetch user votes");
+        }
+        const data = await response.json();
 
-        if (aIsUserModel && !bIsUserModel) return -1;
-        if (!aIsUserModel && bIsUserModel) return 1;
+        // Fusionner les votes du serveur avec les votes locaux
+        const votedModels = new Set([
+          ...data.map((vote) => vote.model),
+          ...localVotesSet,
+        ]);
+        setUserVotes(votedModels);
+      } catch (err) {
+        console.error("Error fetching user votes:", err);
       }
+    };
 
-      // Si égalité, trier par date de soumission (le plus récent d'abord)
-      return new Date(b.submission_time) - new Date(a.submission_time);
-    });
-  };
-
-  // Add this function to handle localStorage
-  const updateLocalVotes = (modelUniqueId, action = "add") => {
-    const storedVotes = JSON.parse(
-      localStorage.getItem(LOCAL_STORAGE_KEY) || "[]"
-    );
-    if (action === "add") {
-      if (!storedVotes.includes(modelUniqueId)) {
-        storedVotes.push(modelUniqueId);
-      }
-    } else {
-      const index = storedVotes.indexOf(modelUniqueId);
-      if (index > -1) {
-        storedVotes.splice(index, 1);
-      }
-    }
-    localStorage.setItem(LOCAL_STORAGE_KEY, JSON.stringify(storedVotes));
-    setLocalVotes(new Set(storedVotes));
-  };
+    fetchUserVotes();
+  }, [isAuthenticated, user]);
 
   useEffect(() => {
-    const fetchData = async () => {
+    const fetchModels = async () => {
       try {
-        // Ne pas afficher le loading si on a déjà des données
-        if (pendingModels.length === 0) {
-          setLoadingModels(true);
-        }
-        setError(null);
-
-        // Charger d'abord les votes en attente du localStorage
-        const storedVotes = JSON.parse(
-          localStorage.getItem(LOCAL_STORAGE_KEY) || "[]"
-        );
-        const localVotesSet = new Set(storedVotes);
-
-        // Préparer toutes les requêtes en parallèle
-        const [pendingModelsResponse, userVotesResponse] = await Promise.all([
-          fetch("/api/models/pending"),
-          isAuthenticated && user
-            ? fetch(`/api/votes/user/${user.username}`)
-            : Promise.resolve(null),
-        ]);
-
-        if (!pendingModelsResponse.ok) {
+        const response = await fetch("/api/models/pending");
+        if (!response.ok) {
           throw new Error("Failed to fetch pending models");
         }
+        const data = await response.json();
 
-        const modelsData = await pendingModelsResponse.json();
-        const votedModels = new Set();
-
-        // Traiter les votes de l'utilisateur si connecté
-        if (userVotesResponse && userVotesResponse.ok) {
-          const votesData = await userVotesResponse.json();
-          const userVotes = Array.isArray(votesData) ? votesData : [];
-
-          userVotes.forEach((vote) => {
-            const uniqueId = `${vote.model}_${vote.precision || "unknown"}_${
-              vote.revision || "main"
-            }`;
-            votedModels.add(uniqueId);
-            if (localVotesSet.has(uniqueId)) {
-              localVotesSet.delete(uniqueId);
-              updateLocalVotes(uniqueId, "remove");
-            }
-          });
-        }
-
-        // Préparer et exécuter toutes les requêtes de votes en une seule fois
-        const modelVotesResponses = await Promise.all(
-          modelsData.map((model) => {
+        // Fetch votes for each model
+        const modelsWithVotes = await Promise.all(
+          data.map(async (model) => {
             const [provider, modelName] = model.name.split("/");
-            return fetch(`/api/votes/model/${provider}/${modelName}`)
-              .then((response) =>
-                response.ok
-                  ? response.json()
-                  : { total_votes: 0, votes_by_config: {} }
-              )
-              .catch(() => ({ total_votes: 0, votes_by_config: {} }));
+            const votesResponse = await fetch(
+              `/api/votes/model/${provider}/${modelName}`
+            );
+            const votesData = await votesResponse.json();
+
+            // Calculate total vote score from votes_by_revision
+            const totalScore = Object.values(
+              votesData.votes_by_revision || {}
+            ).reduce((a, b) => a + b, 0);
+
+            // Calculate wait time based on submission_time from model data
+            const waitTimeDisplay = formatWaitTime(model.submission_time);
+
+            return {
+              ...model,
+              votes: totalScore,
+              votes_by_revision: votesData.votes_by_revision,
+              wait_time: waitTimeDisplay,
+              hasVoted: userVotes.has(model.name),
+            };
           })
         );
 
-        // Construire les modèles avec toutes les données
-        const modelsWithVotes = modelsData.map((model, index) => {
-          const votesData = modelVotesResponses[index];
-          const modelUniqueId = getModelUniqueId(model);
-          const isVotedByUser =
-            votedModels.has(modelUniqueId) || localVotesSet.has(modelUniqueId);
-
-          return {
-            ...model,
-            votes: getConfigVotes(
-              {
-                ...votesData,
-                votes_by_config: votesData.votes_by_config || {},
-              },
-              model
-            ),
-            votes_by_config: votesData.votes_by_config || {},
-            wait_time: formatWaitTime(model.submission_time),
-            hasVoted: isVotedByUser,
-          };
-        });
-
-        // Mettre à jour tous les états en une seule fois
-        const sortedModels = sortModels(modelsWithVotes);
-
-        // Batch updates
-        const updates = () => {
-          setPendingModels(sortedModels);
-          setUserVotes(votedModels);
-          setLocalVotes(localVotesSet);
-          setLoadingModels(false);
-        };
+        // Sort models by vote score in descending order
+        const sortedModels = modelsWithVotes.sort((a, b) => b.votes - a.votes);
 
-        updates();
+        setPendingModels(sortedModels);
       } catch (err) {
-        console.error("Error fetching data:", err);
         setError(err.message);
+      } finally {
         setLoadingModels(false);
       }
     };
 
-    fetchData();
-  }, [isAuthenticated, user]);
+    fetchModels();
+  }, [userVotes]);
 
-  // Modify the handleVote function
-  const handleVote = async (model) => {
+  const handleVote = async (modelName) => {
     if (!isAuthenticated) return;
 
-    const modelUniqueId = getModelUniqueId(model);
-
     try {
-      setError(null);
-      setLoadingVotes((prev) => ({ ...prev, [modelUniqueId]: true }));
-
-      // Add to localStorage immediately
-      updateLocalVotes(modelUniqueId, "add");
+      // Disable the button immediately by adding the model to userVotes
+      setUserVotes((prev) => {
+        const newSet = new Set([...prev, modelName]);
+        // Sauvegarder dans le localStorage
+        if (user) {
+          const localVotes = JSON.parse(
+            localStorage.getItem(`votes_${user.username}`) || "[]"
+          );
+          if (!localVotes.includes(modelName)) {
+            localVotes.push(modelName);
+            localStorage.setItem(
+              `votes_${user.username}`,
+              JSON.stringify(localVotes)
+            );
+          }
+        }
+        return newSet;
+      });
 
-      // Encode model name for URL
-      const encodedModelName = encodeURIComponent(model.name);
+      // Split modelName into provider and model
+      const [provider, model] = modelName.split("/");
 
       const response = await fetch(
-        `/api/votes/${encodedModelName}?vote_type=up&user_id=${user.username}`,
+        `/api/votes/${modelName}?vote_type=up&user_id=${user.username}`,
         {
           method: "POST",
           headers: {
             "Content-Type": "application/json",
           },
-          body: JSON.stringify({
-            precision: model.precision,
-            revision: model.revision,
-          }),
         }
       );
 
       if (!response.ok) {
-        // If the request fails, remove from localStorage
-        updateLocalVotes(modelUniqueId, "remove");
+        // Si le vote échoue, on retire le vote du localStorage et du state
+        setUserVotes((prev) => {
+          const newSet = new Set(prev);
+          newSet.delete(modelName);
+          if (user) {
+            const localVotes = JSON.parse(
+              localStorage.getItem(`votes_${user.username}`) || "[]"
+            );
+            const updatedVotes = localVotes.filter(
+              (vote) => vote !== modelName
+            );
+            localStorage.setItem(
+              `votes_${user.username}`,
+              JSON.stringify(updatedVotes)
+            );
+          }
+          return newSet;
+        });
         throw new Error("Failed to submit vote");
       }
 
-      // Refresh votes for this model with cache bypass
-      const [provider, modelName] = model.name.split("/");
-      const timestamp = Date.now();
+      // Refresh votes for this model
       const votesResponse = await fetch(
-        `/api/votes/model/${provider}/${modelName}?nocache=${timestamp}`
+        `/api/votes/model/${provider}/${model}`
       );
-
-      if (!votesResponse.ok) {
-        throw new Error("Failed to fetch updated votes");
-      }
-
       const votesData = await votesResponse.json();
-      console.log(`Updated votes for ${model.name}:`, votesData); // Debug log
+
+      // Calculate total vote score from votes_by_revision
+      const totalScore = Object.values(
+        votesData.votes_by_revision || {}
+      ).reduce((a, b) => a + b, 0);
 
       // Update model and resort the list
       setPendingModels((models) => {
-        const updatedModels = models.map((m) =>
-          getModelUniqueId(m) === getModelUniqueId(model)
+        const updatedModels = models.map((model) =>
+          model.name === modelName
             ? {
-                ...m,
-                votes: getConfigVotes(votesData, m),
-                votes_by_config: votesData.votes_by_config || {},
-                hasVoted: true,
+                ...model,
+                votes: totalScore,
+                votes_by_revision: votesData.votes_by_revision,
               }
-            : m
+            : model
         );
-        const sortedModels = sortModels(updatedModels);
-        console.log("Updated and sorted models:", sortedModels); // Debug log
-        return sortedModels;
+        return updatedModels.sort((a, b) => b.votes - a.votes);
       });
-
-      // Update user votes with unique ID
-      setUserVotes((prev) => new Set([...prev, getModelUniqueId(model)]));
     } catch (err) {
-      console.error("Error voting:", err);
       setError(err.message);
-    } finally {
-      // Clear loading state for this model
-      setLoadingVotes((prev) => ({
-        ...prev,
-        [modelUniqueId]: false,
-      }));
     }
   };
 
-  // Modify the rendering logic to consider both server and local votes
-  // Inside the map function where you render models
-  const isVoted = (model) => {
-    const modelUniqueId = getModelUniqueId(model);
-    return userVotes.has(modelUniqueId) || localVotes.has(modelUniqueId);
-  };
-
-  if (authLoading || (loadingModels && pendingModels.length === 0)) {
+  if (loading) {
     return (
       <Box
         sx={{
@@ -383,15 +284,7 @@ function VoteModelPage() {
   }
 
   return (
-    <Box
-      sx={{
-        width: "100%",
-        maxWidth: 1200,
-        margin: "0 auto",
-        py: 4,
-        px: 0,
-      }}
-    >
+    <Box sx={{ width: "100%", maxWidth: 1200, margin: "0 auto", padding: 4 }}>
       <PageHeader
         title="Vote for the Next Models"
         subtitle={
@@ -504,7 +397,7 @@ function VoteModelPage() {
             borderBottom: "1px solid",
             borderColor: "divider",
             bgcolor: "background.paper",
-            display: { xs: "none", sm: "grid" },
+            display: "grid",
             gridTemplateColumns: "1fr 200px 160px",
             gap: 3,
             alignItems: "center",
@@ -548,16 +441,16 @@ function VoteModelPage() {
             {pendingModels.map((model, index) => {
               const isTopThree = index < 3;
               return (
-                <React.Fragment key={getModelUniqueId(model)}>
+                <React.Fragment key={model.name}>
                   {index > 0 && <Divider />}
                   <ListItem
                     sx={{
                       py: 2.5,
                       px: 3,
                       display: "grid",
-                      gridTemplateColumns: { xs: "1fr", sm: "1fr 200px 160px" },
-                      gap: { xs: 2, sm: 3 },
-                      alignItems: "start",
+                      gridTemplateColumns: "1fr 200px 160px",
+                      gap: 3,
+                      alignItems: "center",
                       position: "relative",
                       "&:hover": {
                         bgcolor: "action.hover",
@@ -568,100 +461,41 @@ function VoteModelPage() {
                     <Box>
                       <Stack spacing={1}>
                         {/* Model name and link */}
-                        <Stack
-                          direction={{ xs: "column", sm: "row" }}
-                          spacing={1}
-                          alignItems={{ xs: "stretch", sm: "center" }}
-                        >
-                          <Stack
-                            direction="row"
-                            spacing={1}
-                            alignItems="center"
-                            sx={{ flexGrow: 1 }}
+                        <Stack direction="row" spacing={1} alignItems="center">
+                          <Link
+                            href={`https://huggingface.co/${model.name}`}
+                            target="_blank"
+                            rel="noopener noreferrer"
+                            sx={{
+                              textDecoration: "none",
+                              color: "primary.main",
+                              fontWeight: 500,
+                              "&:hover": {
+                                textDecoration: "underline",
+                              },
+                            }}
                           >
-                            <Link
-                              href={`https://huggingface.co/${model.name}`}
-                              target="_blank"
-                              rel="noopener noreferrer"
-                              sx={{
-                                textDecoration: "none",
-                                color: "primary.main",
-                                fontWeight: 500,
-                                "&:hover": {
-                                  textDecoration: "underline",
-                                },
-                                fontSize: { xs: "0.9rem", sm: "inherit" },
-                                wordBreak: "break-word",
-                              }}
-                            >
-                              {model.name}
-                            </Link>
-                            <IconButton
-                              size="small"
-                              href={`https://huggingface.co/${model.name}`}
-                              target="_blank"
-                              rel="noopener noreferrer"
-                              sx={{
-                                ml: 0.5,
-                                p: 0.5,
-                                color: "action.active",
-                                "&:hover": {
-                                  color: "primary.main",
-                                },
-                              }}
-                            >
-                              <OpenInNewIcon sx={{ fontSize: "1rem" }} />
-                            </IconButton>
-                          </Stack>
-                          <Stack
-                            direction="row"
-                            spacing={1}
+                            {model.name}
+                          </Link>
+                          <IconButton
+                            size="small"
+                            href={`https://huggingface.co/${model.name}`}
+                            target="_blank"
+                            rel="noopener noreferrer"
                             sx={{
-                              width: { xs: "100%", sm: "auto" },
-                              justifyContent: {
-                                xs: "flex-start",
-                                sm: "flex-end",
+                              ml: 0.5,
+                              p: 0.5,
+                              color: "action.active",
+                              "&:hover": {
+                                color: "primary.main",
                               },
-                              flexWrap: "wrap",
-                              gap: 1,
                             }}
                           >
-                            <Chip
-                              label={model.precision}
-                              size="small"
-                              variant="outlined"
-                              sx={{
-                                borderColor: "grey.300",
-                                bgcolor: "grey.50",
-                                "& .MuiChip-label": {
-                                  fontSize: "0.75rem",
-                                  fontWeight: 600,
-                                  color: "text.secondary",
-                                },
-                              }}
-                            />
-                            <Chip
-                              label={`rev: ${model.revision.slice(0, 7)}`}
-                              size="small"
-                              variant="outlined"
-                              sx={{
-                                borderColor: "grey.300",
-                                bgcolor: "grey.50",
-                                "& .MuiChip-label": {
-                                  fontSize: "0.75rem",
-                                  fontWeight: 600,
-                                  color: "text.secondary",
-                                },
-                              }}
-                            />
-                          </Stack>
+                            <OpenInNewIcon sx={{ fontSize: "1rem" }} />
+                          </IconButton>
                         </Stack>
                         {/* Metadata row */}
-                        <Stack
-                          direction={{ xs: "column", sm: "row" }}
-                          spacing={{ xs: 1, sm: 2 }}
-                          alignItems={{ xs: "flex-start", sm: "center" }}
-                        >
+                        <Stack direction="row" spacing={2} alignItems="center">
                           <Stack
                             direction="row"
                             spacing={0.5}
@@ -697,22 +531,17 @@ function VoteModelPage() {
                     </Box>
 
                     {/* Vote Column */}
-                    <Box
-                      sx={{
-                        textAlign: { xs: "left", sm: "right" },
-                        mt: { xs: 2, sm: 0 },
-                      }}
-                    >
+                    <Box sx={{ textAlign: "right" }}>
                       <Stack
-                        direction={{ xs: "row", sm: "row" }}
+                        direction="row"
                         spacing={2.5}
-                        justifyContent={{ xs: "space-between", sm: "flex-end" }}
+                        justifyContent="flex-end"
                         alignItems="center"
                       >
                         <Stack
-                          alignItems={{ xs: "flex-start", sm: "center" }}
+                          alignItems="center"
                           sx={{
-                            minWidth: { xs: "auto", sm: "90px" },
+                            minWidth: "90px",
                           }}
                         >
                           <Typography
@@ -721,7 +550,7 @@ function VoteModelPage() {
                             sx={{
                               fontWeight: 700,
                               lineHeight: 1,
-                              fontSize: { xs: "1.75rem", sm: "2rem" },
+                              fontSize: "2rem",
                               display: "flex",
                               alignItems: "center",
                               justifyContent: "center",
@@ -730,7 +559,7 @@ function VoteModelPage() {
                             <Typography
                               component="span"
                               sx={{
-                                fontSize: { xs: "1.25rem", sm: "1.5rem" },
+                                fontSize: "1.5rem",
                                 fontWeight: 600,
                                 color: "primary.main",
                                 lineHeight: 1,
@@ -769,22 +598,18 @@ function VoteModelPage() {
                           </Typography>
                         </Stack>
                         <Button
-                          variant={isVoted(model) ? "contained" : "outlined"}
-                          size={isMobile ? "medium" : "large"}
-                          onClick={() => handleVote(model)}
-                          disabled={
-                            !isAuthenticated ||
-                            isVoted(model) ||
-                            loadingVotes[getModelUniqueId(model)]
-                          }
+                          variant={model.hasVoted ? "contained" : "outlined"}
+                          size="large"
+                          onClick={() => handleVote(model.name)}
+                          disabled={!isAuthenticated || model.hasVoted}
                           color="primary"
                           sx={{
-                            minWidth: { xs: "80px", sm: "100px" },
-                            height: { xs: "36px", sm: "40px" },
+                            minWidth: "100px",
+                            height: "40px",
                             textTransform: "none",
                             fontWeight: 600,
-                            fontSize: { xs: "0.875rem", sm: "0.95rem" },
-                            ...(isVoted(model)
+                            fontSize: "0.95rem",
+                            ...(model.hasVoted
                               ? {
                                   bgcolor: "primary.main",
                                   "&:hover": {
@@ -804,9 +629,7 @@ function VoteModelPage() {
                                 }),
                           }}
                         >
-                          {loadingVotes[getModelUniqueId(model)] ? (
-                            <CircularProgress size={20} color="inherit" />
-                          ) : isVoted(model) ? (
+                          {model.hasVoted ? (
                             <Stack
                               direction="row"
                               spacing={0.5}
@@ -823,13 +646,7 @@ function VoteModelPage() {
                     </Box>
 
                     {/* Priority Column */}
-                    <Box
-                      sx={{
-                        textAlign: { xs: "left", sm: "right" },
-                        mt: { xs: 2, sm: 0 },
-                        display: { xs: "none", sm: "block" },
-                      }}
-                    >
+                    <Box sx={{ textAlign: "right" }}>
                       <Chip
                         label={
                           <Stack