fix votes and update submit limitation

backend/app/api/endpoints/votes.py

@@ -1,14 +1,17 @@
-from fastapi import APIRouter, HTTPException, Query, Depends
+from fastapi import APIRouter, HTTPException, Query, Depends, Response
 from typing import Dict, Any, List
 from app.services.votes import VoteService
 from app.core.fastapi_cache import cached, build_cache_key, invalidate_cache_key
 import logging
 from app.core.formatting import LogFormatter
+from datetime import datetime, timezone
 
 logger = logging.getLogger(__name__)
 router = APIRouter()
 vote_service = VoteService()
 
+CACHE_TTL = 30  # 30 seconds cache
+
 def model_votes_key_builder(func, namespace: str = "model_votes", **kwargs):
     """Build cache key for model votes"""
     provider = kwargs.get('provider')
@@ -26,22 +29,25 @@ 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")
+    user_id: str = Query(..., description="HuggingFace username"),
+    vote_data: Dict[str, Any] = None
 ) -> Dict[str, Any]:
     try:
         logger.info(LogFormatter.section("ADDING VOTE"))
         stats = {
             "Model": model_id,
             "User": user_id,
-            "Type": vote_type
+            "Type": vote_type,
+            "Config": vote_data or {}
         }
         for line in LogFormatter.tree(stats, "Vote Details"):
             logger.info(line)
         
         await vote_service.initialize()
-        result = await vote_service.add_vote(model_id, user_id, vote_type)
+        result = await vote_service.add_vote(model_id, user_id, vote_type, vote_data)
         
         # Invalidate affected caches
         try:
@@ -52,8 +58,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)
             
-            invalidate_cache_key(model_cache_key)
-            invalidate_cache_key(user_cache_key)
+            await invalidate_cache_key(model_cache_key)
+            await invalidate_cache_key(user_cache_key)
             
             cache_stats = {
                 "Model_Cache": model_cache_key,
@@ -65,14 +71,18 @@ 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=60, key_builder=model_votes_key_builder)
+@cached(expire=CACHE_TTL, key_builder=model_votes_key_builder)
 async def get_model_votes(
+    response: Response,
     provider: str, 
     model: str
 ) -> Dict[str, Any]:
@@ -82,6 +92,11 @@ 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:
@@ -89,8 +104,9 @@ async def get_model_votes(
         raise HTTPException(status_code=400, detail=str(e))
 
 @router.get("/user/{user_id}")
-@cached(expire=60, key_builder=user_votes_key_builder)
+@cached(expire=CACHE_TTL, key_builder=user_votes_key_builder)
 async def get_user_votes(
+    response: Response,
     user_id: str
 ) -> List[Dict[str, Any]]:
     """Get all votes from a specific user"""
@@ -98,6 +114,11 @@ 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/core/fastapi_cache.py

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

backend/app/services/models.py

@@ -217,24 +217,25 @@ class ModelService(HuggingFaceService):
             
             try:
                 logger.info(LogFormatter.subsection("DATASET LOADING"))
-                logger.info(LogFormatter.info("Loading dataset files..."))
+                logger.info(LogFormatter.info("Loading dataset..."))
                 
-                # List files in repository
+                # Download entire dataset snapshot
                 with suppress_output():
-                    files = self.hf_api.list_repo_files(
+                    local_dir = self.hf_api.snapshot_download(
                         repo_id=QUEUE_REPO,
                         repo_type="dataset",
                         token=self.token
                     )
                 
-                # Filter JSON files
-                json_files = [f for f in files if f.endswith('.json')]
+                # List JSON files in local directory
+                local_path = Path(local_dir)
+                json_files = list(local_path.glob("**/*.json"))
                 total_files = len(json_files)
                 
                 # Log repository stats
                 stats = {
-                    "Total_Files": len(files),
-                    "JSON_Files": total_files,
+                    "Total_Files": total_files,
+                    "Local_Dir": str(local_path),
                 }
                 for line in LogFormatter.stats(stats, "Repository Statistics"):
                     logger.info(line)
@@ -245,28 +246,67 @@ class ModelService(HuggingFaceService):
                 # Initialize progress tracker
                 progress = ProgressTracker(total_files, "PROCESSING FILES")
                 
-                try:
-                    # Create aiohttp session to reuse connections
-                    async with aiohttp.ClientSession() as session:
-                        # Process files in chunks
-                        chunk_size = 50
+                # Process local files
+                model_submissions = {}  # Dict to track latest submission for each (model_id, revision, precision)
+                for file_path in json_files:
+                    try:
+                        with open(file_path, 'r') as f:
+                            content = json.load(f)
+                            
+                        # Get status and determine target status
+                        status = content.get("status", "PENDING").upper()
+                        target_status = None
+                        status_map = {
+                            "PENDING": ["PENDING"],
+                            "EVALUATING": ["RUNNING"],
+                            "FINISHED": ["FINISHED"]
+                        }
                         
-                        for 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)
+                        for target, source_statuses in status_map.items():
+                            if status in source_statuses:
+                                target_status = target
+                                break
+                                
+                        if not target_status:
+                            progress.update()
+                            continue
+                            
+                        # Calculate wait time
+                        try:
+                            submit_time = datetime.fromisoformat(content["submitted_time"].replace("Z", "+00:00"))
+                            if submit_time.tzinfo is None:
+                                submit_time = submit_time.replace(tzinfo=timezone.utc)
+                            current_time = datetime.now(timezone.utc)
+                            wait_time = current_time - submit_time
+                            
+                            model_info = {
+                                "name": content["model"],
+                                "submitter": content.get("sender", "Unknown"),
+                                "revision": content["revision"],
+                                "wait_time": f"{wait_time.total_seconds():.1f}s",
+                                "submission_time": content["submitted_time"],
+                                "status": target_status,
+                                "precision": content.get("precision", "Unknown")
+                            }
+                            
+                            # Use (model_id, revision, precision) as key to track latest submission
+                            key = (content["model"], content["revision"], content.get("precision", "Unknown"))
+                            if key not in model_submissions or submit_time > datetime.fromisoformat(model_submissions[key]["submission_time"].replace("Z", "+00:00")):
+                                model_submissions[key] = model_info
+                            
+                        except (ValueError, TypeError) as e:
+                            logger.error(LogFormatter.error(f"Failed to process {file_path.name}", e))
                             
-                            # Process results
-                            for result in results:
-                                if result:
-                                    status = result.pop("status")
-                                    models[status.lower()].append(result)
+                    except Exception as e:
+                        logger.error(LogFormatter.error(f"Failed to load {file_path.name}", e))
+                    finally:
+                        progress.update()
                 
-                finally:
-                    progress.close()
+                # Populate models dict with deduplicated submissions
+                for model_info in model_submissions.values():
+                    models[model_info["status"].lower()].append(model_info)
+                
+                progress.close()
                 
                 # Final summary with fancy formatting
                 logger.info(LogFormatter.section("CACHE SUMMARY"))
@@ -516,7 +556,7 @@ class ModelService(HuggingFaceService):
             # Construct the path in the dataset
             org_or_user = model_data["model_id"].split("/")[0] if "/" in model_data["model_id"] else ""
             model_path = model_data["model_id"].split("/")[-1]
-            relative_path = f"{org_or_user}/{model_path}_eval_request_False_{model_data['precision']}_{model_data['weight_type']}.json"
+            relative_path = f"{org_or_user}/{model_path}_eval_request_False_{model_data['precision']}.json"
             
             # Create a temporary file with the request
             with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as temp_file:
@@ -550,7 +590,11 @@ class ModelService(HuggingFaceService):
             await self.vote_service.add_vote(
                 model_data["model_id"],
                 user_id,
-                "up"
+                "up",
+                {
+                    "precision": model_data["precision"],
+                    "revision": model_data["revision"]
+                }
             )
             logger.info(LogFormatter.success("Vote recorded successfully"))
         except Exception as e:
@@ -587,26 +631,26 @@ class ModelService(HuggingFaceService):
         return {"status": "not_found"}
 
     async def get_organization_submissions(self, organization: str, days: int = 7) -> List[Dict[str, Any]]:
-        """Get all submissions from an organization in the last n days"""
+        """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 organization and submission time
-            org_submissions = []
+            # Filter models by submitter and submission time
+            user_submissions = []
             for status, models in all_models.items():
                 for model in models:
-                    # Check if model belongs to organization
-                    if model["name"].startswith(f"{organization}/"):
+                    # 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:
-                            org_submissions.append({
+                            user_submissions.append({
                                 "name": model["name"],
                                 "status": status,
                                 "submission_time": model["submission_time"],
@@ -614,7 +658,7 @@ class ModelService(HuggingFaceService):
                             })
             
             return sorted(
-                org_submissions,
+                user_submissions,
                 key=lambda x: x["submission_time"],
                 reverse=True
             )

backend/app/services/votes.py

@@ -6,7 +6,8 @@ import asyncio
 from pathlib import Path
 import aiohttp
 from huggingface_hub import HfApi
-import datasets
+import tempfile
+import os
 
 from app.services.hf_service import HuggingFaceService
 from app.config import HF_TOKEN
@@ -30,17 +31,15 @@ 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]] = set()
+            self.vote_check_set: Set[Tuple[str, str, str, str]] = set()
             self._votes_by_model: Dict[str, List[Dict[str, Any]]] = {}
             self._votes_by_user: Dict[str, List[Dict[str, Any]]] = {}
-            self._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
 
@@ -56,29 +55,21 @@ class VoteService(HuggingFaceService):
             # Ensure votes directory exists
             self.votes_file.parent.mkdir(parents=True, exist_ok=True)
             
-            # 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:,})"))
+            # Load remote votes
+            remote_votes = await self._fetch_remote_votes()
+            if remote_votes:
+                logger.info(LogFormatter.info(f"Loaded {len(remote_votes)} votes from hub"))
+                
+                # Save to local file
+                with open(self.votes_file, 'w') as f:
+                    for vote in remote_votes:
+                        json.dump(vote, f)
+                        f.write('\n')
+                
+                # Load into memory
                 await self._load_existing_votes()
             else:
-                logger.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"))
+                logger.warning(LogFormatter.warning("No votes found on hub"))
             
             self._initialized = True
             self._last_sync = datetime.now(timezone.utc)
@@ -96,80 +87,105 @@ class VoteService(HuggingFaceService):
             logger.error(LogFormatter.error("Initialization failed", e))
             raise
 
-    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"""
+    async def _fetch_remote_votes(self) -> List[Dict[str, Any]]:
+        """Fetch votes from HF hub"""
         url = f"https://huggingface.co/datasets/{HF_ORGANIZATION}/votes/raw/main/votes_data.jsonl"
-        headers = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
+        headers = {"Authorization": f"Bearer {self.token}"} if self.token else {}
         
         try:
             async with aiohttp.ClientSession() as session:
                 async with session.get(url, headers=headers) as response:
                     if response.status == 200:
-                        count = 0
+                        votes = []
                         async for line in response.content:
-                            if line.strip():  # Skip empty lines
-                                count += 1
-                        return count
+                            if line.strip():
+                                try:
+                                    vote = json.loads(line.decode())
+                                    votes.append(vote)
+                                except json.JSONDecodeError:
+                                    continue
+                        return votes
                     else:
                         logger.error(f"Failed to get remote votes: HTTP {response.status}")
-                        return 0
+                        return []
         except Exception as e:
-            logger.error(f"Error counting remote votes: {str(e)}")
-            return 0
+            logger.error(f"Error fetching remote votes: {str(e)}")
+            return []
+
+    async def _check_for_new_votes(self):
+        """Check for new votes on the hub and sync if needed"""
+        try:
+            remote_votes = await self._fetch_remote_votes()
+            if len(remote_votes) != self._total_votes:
+                logger.info(f"Vote count changed: Local ({self._total_votes}) ≠ Remote ({len(remote_votes)})")
+                # Save to local file
+                with open(self.votes_file, 'w') as f:
+                    for vote in remote_votes:
+                        json.dump(vote, f)
+                        f.write('\n')
+                
+                # Reload into memory
+                await self._load_existing_votes()
+            else:
+                logger.info("Votes are in sync")
+                
+        except Exception as e:
+            logger.error(f"Error checking for new votes: {str(e)}")
 
     async def _sync_with_hub(self):
-        """Sync votes with HuggingFace hub using datasets"""
+        """Sync votes with HuggingFace hub"""
         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")
-            )
-            
-            remote_votes = len(dataset)
-            logger.info(LogFormatter.info(f"Dataset loaded with {remote_votes:,} votes"))
             
-            # 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')
+            # Get current remote votes
+            remote_votes = await self._fetch_remote_votes()
+            logger.info(LogFormatter.info(f"Loaded {len(remote_votes)} votes from hub"))
             
-            # If we have 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..."))
+            # 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..."))
                 
-                # Save votes to local file
-                with open(self.votes_file, 'w') as f:
+                # Add new votes to remote votes
+                remote_votes.extend(self.votes_to_upload)
+                
+                # Create temporary file with all votes
+                with tempfile.NamedTemporaryFile(mode='w', suffix='.jsonl', delete=False) as temp_file:
                     for vote in remote_votes:
-                        f.write(json.dumps(vote) + '\n')
+                        json.dump(vote, temp_file)
+                        temp_file.write('\n')
+                    temp_path = temp_file.name
                 
-                # 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"))
+                try:
+                    # Upload JSONL file directly
+                    self.hf_api.upload_file(
+                        path_or_fileobj=temp_path,
+                        path_in_repo="votes_data.jsonl",
+                        repo_id=f"{HF_ORGANIZATION}/votes",
+                        repo_type="dataset",
+                        commit_message=f"Update votes: +{len(self.votes_to_upload)} new votes",
+                        token=self.token
+                    )
+                    
+                    # Clear pending votes only if upload succeeded
+                    self.votes_to_upload.clear()
+                    logger.info(LogFormatter.success("Pending votes uploaded successfully"))
+                    
+                except Exception as e:
+                    logger.error(LogFormatter.error("Failed to upload votes to hub", e))
+                    raise
+                finally:
+                    # Clean up temp file
+                    os.unlink(temp_path)
+            
+            # Update local state
+            with open(self.votes_file, 'w') as f:
+                for vote in remote_votes:
+                    json.dump(vote, f)
+                    f.write('\n')
+            
+            # Reload votes in memory
+            await self._load_existing_votes()
+            logger.info(LogFormatter.success("Sync completed successfully"))
 
             self._last_sync = datetime.now(timezone.utc)
             
@@ -177,23 +193,6 @@ 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():
@@ -261,7 +260,13 @@ class VoteService(HuggingFaceService):
     def _add_vote_to_memory(self, vote: Dict[str, Any]):
         """Add vote to memory structures"""
         try:
-            check_tuple = (vote["model"], vote["revision"], vote["username"])
+            # Create a unique identifier tuple that includes precision
+            check_tuple = (
+                vote["model"],
+                vote.get("revision", "main"),
+                vote["username"],
+                vote.get("precision", "unknown")
+            )
             
             # Skip if we already have this vote
             if check_tuple in self.vote_check_set:
@@ -280,13 +285,19 @@ class VoteService(HuggingFaceService):
             self._votes_by_user[vote["username"]].append(vote)
             
         except KeyError as e:
-            logger.error(f"Malformed vote data, missing key: {str(e)}")
+            logger.error(LogFormatter.error("Malformed vote data, missing key", str(e)))
         except Exception as e:
-            logger.error(f"Error adding vote to memory: {str(e)}")
+            logger.error(LogFormatter.error("Error adding vote to memory", str(e)))
 
     async def get_user_votes(self, user_id: str) -> List[Dict[str, Any]]:
         """Get all votes from a specific user"""
         logger.info(LogFormatter.info(f"Fetching votes for user: {user_id}"))
+        
+        # Check if we need to refresh votes
+        if (datetime.now(timezone.utc) - self._last_sync).total_seconds() > self._sync_interval:
+            logger.info(LogFormatter.info("Cache expired, refreshing votes..."))
+            await self._check_for_new_votes()
+            
         votes = self._votes_by_user.get(user_id, [])
         logger.info(LogFormatter.success(f"Found {len(votes):,} votes"))
         return votes
@@ -294,19 +305,31 @@ 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
-        votes_by_revision = {}
+        # Group votes by revision and precision
+        votes_by_config = {}
         for vote in votes:
-            revision = vote["revision"]
-            if revision not in votes_by_revision:
-                votes_by_revision[revision] = 0
-            votes_by_revision[revision] += 1
+            revision = vote.get("revision", "main")
+            precision = vote.get("precision", "unknown")
+            config_key = f"{revision}_{precision}"
+            if config_key not in votes_by_config:
+                votes_by_config[config_key] = {
+                    "revision": revision,
+                    "precision": precision,
+                    "count": 0
+                }
+            votes_by_config[config_key]["count"] += 1
         
         stats = {
             "Total_Votes": len(votes),
-            **{f"Revision_{k}": v for k, v in votes_by_revision.items()}
+            **{f"Config_{k}": v["count"] for k, v in votes_by_config.items()}
         }
         
         logger.info(LogFormatter.section("VOTE STATISTICS"))
@@ -315,7 +338,7 @@ class VoteService(HuggingFaceService):
         
         return {
             "total_votes": len(votes),
-            "votes_by_revision": votes_by_revision,
+            "votes_by_config": votes_by_config,
             "votes": votes
         }
 
@@ -337,7 +360,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) -> Dict[str, Any]:
+    async def add_vote(self, model_id: str, user_id: str, vote_type: str, vote_data: Dict[str, Any] = None) -> Dict[str, Any]:
         """Add a vote for a model"""
         try:
             self._log_repo_operation("add", f"{HF_ORGANIZATION}/votes", f"Adding {vote_type} vote for {model_id} by {user_id}")
@@ -345,23 +368,48 @@ class VoteService(HuggingFaceService):
             stats = {
                 "Model": model_id,
                 "User": user_id,
-                "Type": vote_type
+                "Type": vote_type,
+                "Config": vote_data or {}
             }
             for line in LogFormatter.tree(stats, "Vote Details"):
                 logger.info(line)
             
-            revision = await self._get_model_revision(model_id)
-            check_tuple = (model_id, revision, user_id)
+            # Use provided configuration or fallback to model info
+            precision = None
+            revision = None
+            
+            if vote_data:
+                precision = vote_data.get("precision")
+                revision = vote_data.get("revision")
+            
+            # If any info is missing, try to get it from model info
+            if not all([precision, revision]):
+                try:
+                    model_info = await asyncio.to_thread(self.hf_api.model_info, model_id)
+                    model_card_data = model_info.cardData if hasattr(model_info, 'cardData') else {}
+                    
+                    if not precision:
+                        precision = model_card_data.get("precision", "unknown")
+                    if not revision:
+                        revision = model_info.sha
+                except Exception as e:
+                    logger.warning(LogFormatter.warning(f"Failed to get model info: {str(e)}. Using default values."))
+                    precision = precision or "unknown"
+                    revision = revision or "main"
+            
+            # Check if vote already exists with this configuration
+            check_tuple = (model_id, revision, user_id, precision)
             
             if check_tuple in self.vote_check_set:
-                raise ValueError("Vote already recorded for this model")
+                raise ValueError(f"Vote already recorded for this model configuration (precision: {precision}, revision: {revision[:7] if revision else 'unknown'})")
 
             vote = {
                 "model": model_id,
                 "revision": revision,
                 "username": user_id,
                 "timestamp": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
-                "vote_type": vote_type
+                "vote_type": vote_type,
+                "precision": precision
             }
 
             # Update local storage
@@ -373,15 +421,18 @@ class VoteService(HuggingFaceService):
             
             stats = {
                 "Status": "Success",
-                "Queue_Size": len(self.votes_to_upload)
+                "Queue_Size": len(self.votes_to_upload),
+                "Model_Config": {
+                    "Precision": precision,
+                    "Revision": revision[:7] if revision else "unknown"
+                }
             }
             for line in LogFormatter.stats(stats):
                 logger.info(line)
             
-            # 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()
+            # Force immediate sync
+            logger.info(LogFormatter.info("Forcing immediate sync with hub"))
+            await self._sync_with_hub()
             
             return {"status": "success", "message": "Vote added successfully"}
             

frontend/src/pages/AddModelPage/AddModelPage.js

@@ -26,7 +26,7 @@ function AddModelPage() {
   }
 
   return (
-    <Box sx={{ width: "100%", maxWidth: 1200, margin: "0 auto", padding: 4 }}>
+    <Box sx={{ width: "100%", maxWidth: 1200, margin: "0 auto", py: 4, px: 0 }}>
       <PageHeader
         title="Submit a Model for Evaluation"
         subtitle={

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

@@ -192,16 +192,13 @@ 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);
@@ -222,7 +219,6 @@ const ModelTable = ({ models, emptyMessage, status }) => {
                       hover
                     >
                       <TableCell
-                        component="div"
                         sx={{
                           flex: `0 0 ${columns[0].width}`,
                           padding: "12px 16px",
@@ -258,7 +254,6 @@ const ModelTable = ({ models, emptyMessage, status }) => {
                         </Link>
                       </TableCell>
                       <TableCell
-                        component="div"
                         sx={{
                           flex: `0 0 ${columns[1].width}`,
                           padding: "12px 16px",
@@ -274,7 +269,6 @@ const ModelTable = ({ models, emptyMessage, status }) => {
                         {model.submitter}
                       </TableCell>
                       <TableCell
-                        component="div"
                         align={columns[2].align}
                         sx={{
                           flex: `0 0 ${columns[2].width}`,
@@ -303,7 +297,6 @@ const ModelTable = ({ models, emptyMessage, status }) => {
                         </Tooltip>
                       </TableCell>
                       <TableCell
-                        component="div"
                         align={columns[3].align}
                         sx={{
                           flex: `0 0 ${columns[3].width}`,
@@ -320,7 +313,6 @@ const ModelTable = ({ models, emptyMessage, status }) => {
                         </Typography>
                       </TableCell>
                       <TableCell
-                        component="div"
                         align={columns[4].align}
                         sx={{
                           flex: `0 0 ${columns[4].width}`,
@@ -336,7 +328,6 @@ 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}`,
@@ -351,7 +342,7 @@ const ModelTable = ({ models, emptyMessage, status }) => {
                     </TableRow>
                   );
                 })}
-              </div>
+              </>
             </TableCell>
           </TableRow>
         </TableBody>

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", padding: 4 }}>
+    <Box sx={{ width: "100%", maxWidth: 1200, margin: "0 auto", py: 4, px: 0 }}>
       <PageHeader
         title="Citation Information"
         subtitle="How to cite the Open LLM Leaderboard in your work"

frontend/src/pages/VoteModelPage/VoteModelPage.js

@@ -74,6 +74,12 @@ function VoteModelPage() {
   const [loadingModels, setLoadingModels] = useState(true);
   const [error, setError] = useState(null);
   const [userVotes, setUserVotes] = useState(new Set());
+  const [loadingVotes, setLoadingVotes] = useState({});
+
+  // 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";
@@ -98,173 +104,209 @@ function VoteModelPage() {
     return `${diffInWeeks}w`;
   };
 
-  // Fetch user's votes
-  useEffect(() => {
-    const fetchUserVotes = async () => {
-      if (!isAuthenticated || !user) return;
+  const getConfigVotes = (votesData, model) => {
+    // Afficher les données pour le debug
+    console.log("Checking votes for model:", {
+      model_name: model.name,
+      precision: model.precision,
+      revision: model.revision,
+      votes_data: votesData,
+    });
+
+    // Parcourir toutes les configurations pour trouver celle qui correspond
+    for (const [key, config] of Object.entries(votesData.votes_by_config)) {
+      if (
+        config.precision === model.precision &&
+        config.revision === model.revision
+      ) {
+        return config.count;
+      }
+    }
+    return 0;
+  };
 
-      try {
-        // Récupérer les votes du localStorage
-        const localVotes = JSON.parse(
-          localStorage.getItem(`votes_${user.username}`) || "[]"
-        );
-        const localVotesSet = new Set(localVotes);
+  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;
+      }
 
-        // 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();
+      // 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;
 
-        // 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);
+        if (aIsUserModel && !bIsUserModel) return -1;
+        if (!aIsUserModel && bIsUserModel) return 1;
       }
-    };
 
-    fetchUserVotes();
-  }, [isAuthenticated, user]);
+      // Si égalité, trier par date de soumission (le plus récent d'abord)
+      return new Date(b.submission_time) - new Date(a.submission_time);
+    });
+  };
 
+  // Fetch user's votes and models together
   useEffect(() => {
-    const fetchModels = async () => {
+    const fetchData = async () => {
       try {
-        const response = await fetch("/api/models/pending");
-        if (!response.ok) {
+        setLoadingModels(true);
+        setError(null);
+
+        // Fetch user votes only if authenticated
+        let votedModels = new Set();
+        if (isAuthenticated && user) {
+          const userVotesResponse = await fetch(
+            `/api/votes/user/${user.username}`
+          );
+          if (!userVotesResponse.ok) {
+            throw new Error("Failed to fetch user votes");
+          }
+          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);
+          });
+        }
+        setUserVotes(votedModels);
+
+        // Fetch pending models
+        const pendingModelsResponse = await fetch("/api/models/pending");
+        if (!pendingModelsResponse.ok) {
           throw new Error("Failed to fetch pending models");
         }
-        const data = await response.json();
+        const modelsData = await pendingModelsResponse.json();
 
         // Fetch votes for each model
         const modelsWithVotes = await Promise.all(
-          data.map(async (model) => {
-            const [provider, modelName] = model.name.split("/");
-            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),
-            };
+          modelsData.map(async (model) => {
+            try {
+              const [provider, modelName] = model.name.split("/");
+              const votesResponse = await fetch(
+                `/api/votes/model/${provider}/${modelName}`
+              );
+
+              if (!votesResponse.ok) {
+                return {
+                  ...model,
+                  votes: 0,
+                  votes_by_config: {},
+                  wait_time: formatWaitTime(model.submission_time),
+                  hasVoted: votedModels.has(getModelUniqueId(model)),
+                };
+              }
+
+              const votesData = await votesResponse.json();
+              return {
+                ...model,
+                votes: getConfigVotes(votesData, model),
+                votes_by_config: votesData.votes_by_config || {},
+                wait_time: formatWaitTime(model.submission_time),
+                hasVoted: votedModels.has(getModelUniqueId(model)),
+              };
+            } catch (err) {
+              console.error(`Error fetching votes for ${model.name}:`, err);
+              return {
+                ...model,
+                votes: 0,
+                votes_by_config: {},
+                wait_time: formatWaitTime(model.submission_time),
+                hasVoted: votedModels.has(getModelUniqueId(model)),
+              };
+            }
           })
         );
 
-        // Sort models by vote score in descending order
-        const sortedModels = modelsWithVotes.sort((a, b) => b.votes - a.votes);
-
+        // Sort models
+        const sortedModels = sortModels(modelsWithVotes);
         setPendingModels(sortedModels);
       } catch (err) {
+        console.error("Error fetching data:", err);
         setError(err.message);
       } finally {
         setLoadingModels(false);
       }
     };
 
-    fetchModels();
-  }, [userVotes]);
+    fetchData();
+  }, [isAuthenticated, user]);
 
-  const handleVote = async (modelName) => {
+  const handleVote = async (model) => {
     if (!isAuthenticated) return;
 
     try {
-      // 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;
-      });
+      setError(null);
+      // Set loading state for this specific model
+      setLoadingVotes((prev) => ({ ...prev, [getModelUniqueId(model)]: true }));
 
-      // Split modelName into provider and model
-      const [provider, model] = modelName.split("/");
+      // Encode model name for URL
+      const encodedModelName = encodeURIComponent(model.name);
 
       const response = await fetch(
-        `/api/votes/${modelName}?vote_type=up&user_id=${user.username}`,
+        `/api/votes/${encodedModelName}?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) {
-        // 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
+      // Refresh votes for this model with cache bypass
+      const [provider, modelName] = model.name.split("/");
+      const timestamp = Date.now();
       const votesResponse = await fetch(
-        `/api/votes/model/${provider}/${model}`
+        `/api/votes/model/${provider}/${modelName}?nocache=${timestamp}`
       );
-      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);
+      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
 
       // Update model and resort the list
       setPendingModels((models) => {
-        const updatedModels = models.map((model) =>
-          model.name === modelName
+        const updatedModels = models.map((m) =>
+          getModelUniqueId(m) === getModelUniqueId(model)
             ? {
-                ...model,
-                votes: totalScore,
-                votes_by_revision: votesData.votes_by_revision,
+                ...m,
+                votes: getConfigVotes(votesData, m),
+                votes_by_config: votesData.votes_by_config || {},
+                hasVoted: true,
               }
-            : model
+            : m
         );
-        return updatedModels.sort((a, b) => b.votes - a.votes);
+        const sortedModels = sortModels(updatedModels);
+        console.log("Updated and sorted models:", sortedModels); // Debug log
+        return sortedModels;
       });
+
+      // 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,
+        [getModelUniqueId(model)]: false,
+      }));
     }
   };
 
@@ -284,7 +326,15 @@ function VoteModelPage() {
   }
 
   return (
-    <Box sx={{ width: "100%", maxWidth: 1200, margin: "0 auto", padding: 4 }}>
+    <Box
+      sx={{
+        width: "100%",
+        maxWidth: 1200,
+        margin: "0 auto",
+        py: 4,
+        px: 0,
+      }}
+    >
       <PageHeader
         title="Vote for the Next Models"
         subtitle={
@@ -441,7 +491,7 @@ function VoteModelPage() {
             {pendingModels.map((model, index) => {
               const isTopThree = index < 3;
               return (
-                <React.Fragment key={model.name}>
+                <React.Fragment key={getModelUniqueId(model)}>
                   {index > 0 && <Divider />}
                   <ListItem
                     sx={{
@@ -462,37 +512,74 @@ function VoteModelPage() {
                       <Stack spacing={1}>
                         {/* Model name and link */}
                         <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",
-                              },
-                            }}
+                          <Stack
+                            direction="row"
+                            spacing={1}
+                            alignItems="center"
+                            sx={{ flexGrow: 1 }}
                           >
-                            {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": {
+                            <Link
+                              href={`https://huggingface.co/${model.name}`}
+                              target="_blank"
+                              rel="noopener noreferrer"
+                              sx={{
+                                textDecoration: "none",
                                 color: "primary.main",
-                              },
-                            }}
-                          >
-                            <OpenInNewIcon sx={{ fontSize: "1rem" }} />
-                          </IconButton>
+                                fontWeight: 500,
+                                "&:hover": {
+                                  textDecoration: "underline",
+                                },
+                              }}
+                            >
+                              {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}>
+                            <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>
                         </Stack>
                         {/* Metadata row */}
                         <Stack direction="row" spacing={2} alignItems="center">
@@ -600,8 +687,12 @@ function VoteModelPage() {
                         <Button
                           variant={model.hasVoted ? "contained" : "outlined"}
                           size="large"
-                          onClick={() => handleVote(model.name)}
-                          disabled={!isAuthenticated || model.hasVoted}
+                          onClick={() => handleVote(model)}
+                          disabled={
+                            !isAuthenticated ||
+                            model.hasVoted ||
+                            loadingVotes[getModelUniqueId(model)]
+                          }
                           color="primary"
                           sx={{
                             minWidth: "100px",
@@ -629,7 +720,9 @@ function VoteModelPage() {
                                 }),
                           }}
                         >
-                          {model.hasVoted ? (
+                          {loadingVotes[getModelUniqueId(model)] ? (
+                            <CircularProgress size={24} color="inherit" />
+                          ) : model.hasVoted ? (
                             <Stack
                               direction="row"
                               spacing={0.5}