update

.gitignore

@@ -30,3 +30,8 @@ client/*.local
 
 client/.env
 server/.env
+server/data/leaderboards_discussions.json
+server/data/leaderboards_list.json
+server/data/leaderboards_results.json
+server/data/leaderboards_runtime.json
+

client/src/components/LeaderboardFilters/LeaderboardFilters.jsx

@@ -20,9 +20,9 @@ import { useMediaQuery } from "@mui/material";
 const getSectionGroup = (id) => {
   const groups = {
     modalities: ["agentic", "vision", "audio"],
-    capabilities: ["code", "math"],
+    capabilities: ["code", "math", "rag"],
     languages: ["language"],
-    domains: ["financial", "medical", "legal"],
+    domains: ["financial", "medical", "legal", "biology"],
     evaluation: ["safety"],
     misc: ["uncategorized"],
   };
@@ -89,15 +89,25 @@ const LeaderboardFilters = ({ allSections }) => {
       );
       return categorySection ? categorySection.data.length : 0;
     }
-    // Quand aucune catégorie n'est sélectionnée, on compte tous les leaderboards de toutes les sections
-    return allSections.reduce(
-      (total, section) => total + section.data.length,
-      0
-    );
+    // Quand aucune catégorie n'est sélectionnée, on compte les leaderboards uniques
+    const uniqueIds = new Set();
+    allSections.forEach((section) => {
+      section.data.forEach((board) => {
+        if (board.approval_status === "approved") {
+          uniqueIds.add(board.id);
+        }
+      });
+    });
+    return uniqueIds.size;
   }, [selectedCategory, allSections]);
 
   // Calculer le nombre filtré en prenant en compte tous les filtres
   const currentFilteredCount = useMemo(() => {
+    // Si on a uniquement le filtre arena actif (pas de recherche ni de catégorie)
+    if (arenaOnly && !debouncedSearch && !selectedCategory) {
+      return totalArenaCount;
+    }
+
     if (selectedCategory) {
       const categorySection = allSections.find(
         (section) => section.id === selectedCategory
@@ -105,13 +115,26 @@ const LeaderboardFilters = ({ allSections }) => {
       if (!categorySection) return 0;
       return filterLeaderboards(categorySection.data).length;
     }
-    // Quand aucune catégorie n'est sélectionnée, on compte dans toutes les sections
-    const allBoards = allSections.reduce(
-      (acc, section) => [...acc, ...section.data],
-      []
-    );
-    return filterLeaderboards(allBoards).length;
-  }, [selectedCategory, allSections, filterLeaderboards]);
+
+    // Quand aucune catégorie n'est sélectionnée, on utilise un Set pour éviter les doublons
+    const uniqueFilteredIds = new Set();
+    allSections.forEach((section) => {
+      const filteredBoards = filterLeaderboards(section.data);
+      filteredBoards.forEach((board) => {
+        if (board.approval_status === "approved") {
+          uniqueFilteredIds.add(board.id);
+        }
+      });
+    });
+    return uniqueFilteredIds.size;
+  }, [
+    selectedCategory,
+    allSections,
+    filterLeaderboards,
+    arenaOnly,
+    debouncedSearch,
+    totalArenaCount,
+  ]);
 
   const isMobile = useMediaQuery((theme) => theme.breakpoints.down("md"));
 
@@ -221,7 +244,7 @@ const LeaderboardFilters = ({ allSections }) => {
           placeholder={
             isMobile
               ? "Search by name or tags..."
-              : "Search by name or use domain:, language:, judge:, test:, modality:, submission:"
+              : "Search by name or use domain:, language:, eval:, judge:, test:, modality:, submission:"
           }
           value={inputValue}
           onChange={(e) => setInputValue(e.target.value)}

client/src/components/LeaderboardSection.jsx

@@ -181,14 +181,14 @@ const LeaderboardSection = ({
   }, [id, leaderboards]);
 
   // Calculer le nombre de leaderboards par langue
-  // On utilise les leaderboards bruts pour avoir toutes les langues
+  // On utilise les leaderboards filtrés pour avoir les bonnes statistiques
   const languageStats = useMemo(() => {
     if (!languages) return null;
     const stats = new Map();
 
-    // Compter les leaderboards pour chaque langue
+    // Compter les leaderboards pour chaque langue en tenant compte des filtres
     languages.forEach((lang) => {
-      const count = leaderboards.filter((board) =>
+      const count = filteredLeaderboards.filter((board) =>
         board.tags?.some(
           (tag) => tag.toLowerCase() === `language:${lang.toLowerCase()}`
         )
@@ -197,7 +197,7 @@ const LeaderboardSection = ({
     });
 
     return stats;
-  }, [languages, leaderboards]);
+  }, [languages, filteredLeaderboards]);
 
   // Filtrer pour n'avoir que les leaderboards approuvés
   const approvedLeaderboards = filteredLeaderboards.filter(
@@ -361,10 +361,16 @@ const LeaderboardSection = ({
                 return langFamily === family;
               });
 
-              // Ne pas retourner si pas de langues, SAUF pour Other Languages qui doit toujours être affiché
+              // Toujours afficher toutes les familles qui ont des langues dans la liste complète
               if (familyLanguages.length === 0 && family !== "Other Languages")
                 return null;
 
+              // Calculer le nombre total de leaderboards dans cette famille
+              const familyTotal = familyLanguages.reduce(
+                (sum, lang) => sum + (languageStats?.get(lang) || 0),
+                0
+              );
+
               return (
                 <Box key={family} sx={{ mb: 3 }}>
                   <Typography
@@ -373,13 +379,11 @@ const LeaderboardSection = ({
                       color: "text.secondary",
                       mb: 1,
                       fontWeight: 500,
-                      opacity: 0.8,
+                      opacity: familyTotal === 0 ? 0.5 : 0.8,
                     }}
                   >
                     {family}{" "}
-                    {familyLanguages.length > 0
-                      ? `(${familyLanguages.length})`
-                      : ""}
+                    {familyLanguages.length > 0 ? `(${familyTotal})` : ""}
                   </Typography>
                   <Box
                     sx={{
@@ -392,6 +396,7 @@ const LeaderboardSection = ({
                     {familyLanguages.map((lang) => {
                       const isActive = selectedLanguage === lang;
                       const count = languageStats?.get(lang) || 0;
+                      const isDisabled = count === 0 && !isActive;
 
                       return (
                         <Button
@@ -401,9 +406,11 @@ const LeaderboardSection = ({
                           }
                           variant={isActive ? "contained" : "outlined"}
                           size="small"
+                          disabled={isDisabled}
                           sx={{
                             textTransform: "none",
                             m: 0.125,
+                            opacity: isDisabled ? 0.5 : 1,
                             backgroundColor: (theme) =>
                               isActive
                                 ? undefined
@@ -417,6 +424,7 @@ const LeaderboardSection = ({
                                   : theme.palette.mode === "dark"
                                   ? "background.paper"
                                   : "white",
+                              opacity: isDisabled ? 0.5 : 0.8,
                             },
                             "& .MuiTouchRipple-root": {
                               transition: "none",

client/src/context/LeaderboardContext.jsx

@@ -45,7 +45,10 @@ const CATEGORIZATION_TAGS = [
   "domain:financial",
   "domain:medical",
   "domain:legal",
+  "domain:biology",
   "eval:safety",
+  "eval:performance",
+  "eval:rag",
 ];
 
 // Helper pour déterminer si un leaderboard est non catégorisé
@@ -77,7 +80,9 @@ export const LeaderboardProvider = ({ children }) => {
   const [selectedLanguage, setSelectedLanguage] = useState(
     initialParams.language
   );
-  const [expandedSections, setExpandedSections] = useState(new Set());
+  const [expandedSections, setExpandedSections] = useState(
+    new Set(initialParams.category ? [initialParams.category] : [])
+  );
 
   // Mettre à jour l'URL quand les filtres changent
   useEffect(() => {
@@ -97,6 +102,7 @@ export const LeaderboardProvider = ({ children }) => {
       setArenaOnly(params.arena);
       setSelectedCategory(params.category);
       setSelectedLanguage(params.language);
+      setExpandedSections(new Set(params.category ? [params.category] : []));
     };
 
     window.addEventListener("popstate", handleURLChange);
@@ -196,6 +202,8 @@ export const LeaderboardProvider = ({ children }) => {
               return tags.includes("eval:code");
             case "math":
               return tags.includes("eval:math");
+            case "rag":
+              return tags.includes("eval:rag");
             case "language":
               return tags.some((tag) => tag.startsWith("language:"));
             case "vision":
@@ -212,8 +220,12 @@ export const LeaderboardProvider = ({ children }) => {
               return tags.includes("domain:medical");
             case "legal":
               return tags.includes("domain:legal");
+            case "biology":
+              return tags.includes("domain:biology");
             case "safety":
               return tags.includes("eval:safety");
+            case "performance":
+              return tags.includes("eval:performance");
             case "uncategorized":
               return isUncategorized(board);
             default:
@@ -254,7 +266,12 @@ export const LeaderboardProvider = ({ children }) => {
 
   // Calculate total number of unique leaderboards (excluding duplicates)
   const totalLeaderboards = useMemo(() => {
-    const uniqueIds = new Set(leaderboards.map((board) => board.id));
+    // On ne compte que les leaderboards approuvés
+    const uniqueIds = new Set(
+      leaderboards
+        .filter((board) => board.approval_status === "approved")
+        .map((board) => board.id)
+    );
     return uniqueIds.size;
   }, [leaderboards]);
 
@@ -300,12 +317,12 @@ export const LeaderboardProvider = ({ children }) => {
   const getSectionGroup = (id) => {
     const groups = {
       agentic: ["agentic"],
-      capabilities: ["code", "math"],
+      capabilities: ["code", "math", "rag"],
       languages: ["language"],
       modalities: ["vision", "audio"],
       threeD: ["threeD"],
-      domains: ["financial", "medical", "legal"],
-      evaluation: ["safety"],
+      domains: ["financial", "medical", "legal", "biology"],
+      evaluation: ["safety", "performance"],
       misc: ["uncategorized"],
     };
 
@@ -349,6 +366,14 @@ export const LeaderboardProvider = ({ children }) => {
           return board;
         }),
       },
+      {
+        id: "rag",
+        title: "RAG",
+        data: filterByTag("eval:rag", leaderboards).map((board) => {
+          categorizedIds.add(board.id);
+          return board;
+        }),
+      },
       {
         id: "language",
         title: "Language Specific",
@@ -397,6 +422,14 @@ export const LeaderboardProvider = ({ children }) => {
           return board;
         }),
       },
+      {
+        id: "biology",
+        title: "Biology",
+        data: filterByTag("domain:biology", leaderboards).map((board) => {
+          categorizedIds.add(board.id);
+          return board;
+        }),
+      },
       {
         id: "legal",
         title: "Legal",
@@ -413,6 +446,14 @@ export const LeaderboardProvider = ({ children }) => {
           return board;
         }),
       },
+      {
+        id: "performance",
+        title: "Performance",
+        data: filterByTag("eval:performance", leaderboards).map((board) => {
+          categorizedIds.add(board.id);
+          return board;
+        }),
+      },
       {
         id: "uncategorized",
         title: "Uncategorized",
@@ -487,6 +528,7 @@ export const LeaderboardProvider = ({ children }) => {
       "test:",
       "modality:",
       "submission:",
+      "eval:",
     ];
 
     // Si c'est une recherche par tag, on ne highlight rien

client/src/pages/HowToSubmitPage/HowToSubmitPage.jsx

@@ -235,6 +235,7 @@ const getTagEmoji = (tag) => {
       financial: "💰",
       medical: "⚕️",
       legal: "⚖️",
+      biology: "🧬",
     },
   };
 
@@ -318,6 +319,7 @@ const TagSection = ({ title, description, tags, explanations }) => {
     "Submission type",
     "Test set status",
     "Judges",
+    "Domain",
   ].includes(title);
 
   return (
@@ -717,7 +719,12 @@ const HowToSubmitPage = () => {
         <TagSection
           title="Domain"
           description="Indicates the specific domain of the leaderboard:"
-          tags={["domain:financial", "domain:medical", "domain:legal"]}
+          tags={[
+            "domain:financial",
+            "domain:medical",
+            "domain:legal",
+            "domain:biology",
+          ]}
         />
 
         <Typography

server/.env.example

@@ -11,3 +11,7 @@ HUGGING_FACE_STORAGE_FILE_PATH=final_leaderboards.json
 
 # Update interval in minutes (optional, default: 15)
 UPDATE_INTERVAL_MINUTES=15
+
+# Server configuration
+API_HOST=0.0.0.0
+API_PORT=3002

server/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "leaderboard-explorer-server"
 version = "0.1.0"
-description = "Backend server for Leaderboard Explorer"
+description = "Static file server for Leaderboard Explorer"
 authors = ["Your Name <[email protected]>"]
 packages = [
     { include = "server.py" }
@@ -12,10 +12,6 @@ python = "^3.9"
 fastapi = "^0.109.0"
 uvicorn = "^0.27.0"
 python-dotenv = "^1.0.0"
-requests = "^2.31.0"
-python-jose = {extras = ["cryptography"], version = "^3.3.0"}
-apscheduler = "^3.10.4"
-huggingface-hub = "^0.21.3"
 
 [tool.poetry.scripts]
 dev = "uvicorn server:app --reload --host 0.0.0.0 --port 3002"

server/server.py

@@ -1,20 +1,7 @@
-from fastapi import FastAPI, HTTPException, Request
-from fastapi.middleware.cors import CORSMiddleware
+from fastapi import FastAPI
 from fastapi.staticfiles import StaticFiles
-from fastapi.responses import FileResponse
-from apscheduler.schedulers.background import BackgroundScheduler
-from datetime import datetime
 import os
 from dotenv import load_dotenv
-from huggingface_hub import HfApi
-import json
-import logging
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s'
-)
 
 # Load environment variables
 load_dotenv()
@@ -25,123 +12,6 @@ API_PORT = int(os.getenv("API_PORT", "3002"))
 
 app = FastAPI()
 
-# Add CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=[
-        "http://localhost:5173",  # Vite dev server
-        f"http://localhost:{API_PORT}",  # API port
-        "https://huggingface.co",  # HF main domain
-        "https://*.hf.space",      # HF Spaces domains
-    ],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Cache storage
-cache = {
-    "data": None,
-    "last_updated": None
-}
-
-# HF API configuration
-HF_TOKEN = os.getenv("HUGGING_FACE_HUB_TOKEN")
-REPO_ID = os.getenv("HUGGING_FACE_STORAGE_REPO")
-FILE_PATH = os.getenv("HUGGING_FACE_STORAGE_FILE_PATH")
-CACHE_DURATION_MINUTES = int(os.getenv("UPDATE_INTERVAL_MINUTES", "15"))
-
-# Initialize HF API client
-hf_api = HfApi(token=HF_TOKEN)
-
-def fetch_leaderboards():
-    """Fetch leaderboards data from Hugging Face"""
-    try:
-        logging.info(f"Fetching leaderboards from {REPO_ID}/{FILE_PATH}")
-        # Download the JSON file directly with force_download to ensure we get the latest version
-        json_path = hf_api.hf_hub_download(
-            repo_id=REPO_ID,
-            filename=FILE_PATH,
-            repo_type="dataset",
-            force_download=True,  # Force download to ensure we get the latest version
-            force_filename="leaderboards_latest.json"  # Force a specific filename to avoid caching issues
-        )
-        
-        logging.info(f"File downloaded to: {json_path}")
-        
-        with open(json_path, 'r') as f:
-            new_data = json.load(f)
-            old_data = cache["data"]
-            cache["data"] = new_data
-            cache["last_updated"] = datetime.now()
-            
-            # Log the differences
-            old_len = len(old_data) if old_data and isinstance(old_data, list) else 0
-            new_len = len(new_data) if isinstance(new_data, list) else 0
-            logging.info(f"Cache updated: Old entries: {old_len}, New entries: {new_len}")
-            logging.info(f"Cache update timestamp: {cache['last_updated']}")
-            
-    except Exception as e:
-        logging.error(f"Error fetching data: {str(e)}", exc_info=True)
-        if not cache["data"]:  # Only raise if we don't have any cached data
-            raise HTTPException(status_code=500, detail="Failed to fetch leaderboards data")
-
-# Initial fetch
-fetch_leaderboards()
-
-@app.get("/api/leaderboards")
-async def get_leaderboards():
-    """Get leaderboards data from cache"""
-    if not cache["data"]:
-        fetch_leaderboards()
-    
-    return {
-        "data": cache["data"],
-        "last_updated": cache["last_updated"].isoformat() if cache["last_updated"] else None
-    }
-
-@app.get("/api/health")
-async def health_check():
-    """Health check endpoint"""
-    return {
-        "status": "healthy",
-        "cache_status": "initialized" if cache["data"] else "empty",
-        "last_updated": cache["last_updated"].isoformat() if cache["last_updated"] else None
-    }
-
-@app.post("/api/webhook")
-async def handle_webhook(request: Request):
-    """Handle webhook notifications from Hugging Face Hub"""
-    try:
-        body = await request.json()
-        logging.info(f"Received webhook with payload: {body}")
-        
-        # Get the event details
-        event = body.get("event", {})
-        
-        # Verify if it's a relevant update (repo content update)
-        if event.get("action") == "update" and event.get("scope") == "repo.content":
-            try:
-                logging.info(f"Dataset update detected for repo {REPO_ID}, file {FILE_PATH}")
-                # Force a clean fetch
-                fetch_leaderboards()
-                if cache["last_updated"]:
-                    logging.info(f"Cache successfully updated at {cache['last_updated']}")
-                    return {"status": "success", "message": "Cache updated"}
-                else:
-                    logging.error("Cache update failed: last_updated is None")
-                    return {"status": "error", "message": "Cache update failed"}
-            except Exception as fetch_error:
-                logging.error(f"Error during fetch_leaderboards: {str(fetch_error)}", exc_info=True)
-                return {"status": "error", "message": f"Failed to update cache: {str(fetch_error)}"}
-        
-        logging.info(f"Ignoring webhook event: action={event.get('action')}, scope={event.get('scope')}")
-        return {"status": "ignored", "message": "Event type not relevant"}
-        
-    except Exception as e:
-        logging.error(f"Error processing webhook: {str(e)}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Failed to process webhook: {str(e)}")
-
 # Mount static files for the React client
 app.mount("/", StaticFiles(directory="static", html=True), name="static")