first commit

.env.example

@@ -0,0 +1,15 @@
+# Hugging Face Hub token (required)
+# Create one at https://huggingface.co/settings/tokens
+HUGGING_FACE_HUB_TOKEN=your_token_here
+
+OPENAI_API_KEY=sk-proj-xxxx
+
+# Repository ID for storing leaderboard data (required)
+# Format: username/repo-name
+HUGGING_FACE_STORAGE_REPO=username/leaderboard-data
+
+# Intervalle de temps en heures avant de retraiter un leaderboard déjà analysé
+LEADERBOARD_REPROCESS_INTERVAL_HOURS=24
+
+# Nombre maximum de tentatives de traitement d'un leaderboard avant de considérer qu'il a échoué
+LEADERBOARD_MAX_RETRIES=3

.gitignore

@@ -0,0 +1,3 @@
+.env
+data/best_model_for_results.json
+data/final_leaderboards.json

Dockerfile

@@ -0,0 +1,83 @@
+FROM python:3.10-slim
+WORKDIR /app
+
+# Create non-root user
+RUN useradd -m -u 1000 user
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    netcat-openbsd \
+    wget \
+    gnupg \
+    curl \
+    libnss3 \
+    libnspr4 \
+    libatk1.0-0 \
+    libatk-bridge2.0-0 \
+    libcups2 \
+    libdrm2 \
+    libdbus-1-3 \
+    libxkbcommon0 \
+    libx11-6 \
+    libxcomposite1 \
+    libxdamage1 \
+    libxext6 \
+    libxfixes3 \
+    libxrandr2 \
+    libgbm1 \
+    libpango-1.0-0 \
+    libcairo2 \
+    libasound2 \
+    libatspi2.0-0 \
+    unzip \
+    xvfb \
+    libglib2.0-0 \
+    && pip install --upgrade pip \
+    && pip install poetry
+
+# Install Chrome - required for Helium
+RUN wget -q -O - https://dl-ssl.google.com/linux/linux_signing_key.pub | apt-key add - \
+    && echo "deb [arch=amd64] http://dl.google.com/linux/chrome/deb/ stable main" >> /etc/apt/sources.list.d/google.list \
+    && apt-get update \
+    && apt-get install -y google-chrome-stable \
+    && rm -rf /var/lib/apt/lists/*
+
+# Configure environment variables for Chrome
+ENV CHROMEDRIVER_PATH=/usr/bin/chromedriver \
+    CHROME_PATH=/usr/bin/google-chrome-stable \
+    CHROME_BIN=/usr/bin/google-chrome-stable
+
+# Copy application files
+COPY . /app/
+
+# Install Python dependencies
+RUN poetry config virtualenvs.create false \
+    && poetry install --no-interaction --no-ansi
+
+# Environment variables
+ENV API_HOST=0.0.0.0 \
+    API_PORT=7860 \
+    PYTHONPATH=/app \
+    DISPLAY=:99 \
+    PYTHONUNBUFFERED=1 \
+    SELENIUM_DRIVER_EXECUTABLE_PATH=/usr/bin/chromedriver \
+    LEADERBOARD_REPROCESS_INTERVAL_HOURS=24 \
+    HOME=/home/user
+
+# Create cache directory and set permissions
+RUN mkdir -p /app/cache /home/user/.cache && chown -R user:user /app/cache /app/ /home/user/.cache
+
+# Install additional fonts
+RUN apt-get update && apt-get install -y \
+    fonts-noto-color-emoji \
+    fonts-freefont-ttf \
+    libharfbuzz-icu0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Switch to non-root user
+USER user
+
+EXPOSE 7860
+
+# Start the server in server mode
+CMD ["python", "main.py", "--server", "--retry-rejected"]

README.md

@@ -0,0 +1,90 @@
+# Leaderboard Parser
+
+Un outil pour extraire automatiquement les données des leaderboards Hugging Face à l'aide d'agents IA.
+
+## Structure du projet
+
+```
+leaderboard-parser/
+├── main.py                # Point d'entrée principal
+├── data/                  # Données d'entrée et de sortie
+│   ├── leaderboards.json  # Liste des URLs des leaderboards à traiter
+│   └── leaderboard_results.json # Résultats de l'extraction
+├── src/                   # Code source principal
+│   ├── agent.py           # Gestion de l'agent IA
+│   ├── browser.py         # Gestion du navigateur
+│   └── tools.py           # Outils utilisés par l'agent
+├── experiments/           # Scripts expérimentaux
+├── pyproject.toml         # Configuration Poetry
+└── README.md              # Documentation
+```
+
+## Description
+
+Ce projet utilise Playwright et smolagents pour naviguer sur les leaderboards Hugging Face et extraire les informations du premier modèle de chaque leaderboard. Les informations extraites incluent :
+
+- Nom du modèle
+- Score
+- Position/rang
+- Créateur/auteur
+
+## Prérequis
+
+- Python 3.10 ou supérieur
+- Poetry (gestionnaire de dépendances)
+
+## Installation
+
+1. Assurez-vous d'avoir Python 3.10+ installé
+2. Installez Poetry si ce n'est pas déjà fait : `pip install poetry`
+3. Installez les dépendances : `poetry install`
+
+## Configuration
+
+1. Copiez le fichier `.env.example` vers `.env`
+2. Configurez vos clés API dans le fichier `.env`
+3. Modifiez le fichier `data/leaderboards.json` pour ajouter ou supprimer des URLs de leaderboards
+
+## Utilisation
+
+Pour exécuter le parser sur tous les leaderboards définis dans `data/leaderboards.json` :
+
+```bash
+poetry run leaderboard-parser
+```
+
+Ou directement :
+
+```bash
+poetry run python main.py
+```
+
+Les résultats seront sauvegardés dans `data/leaderboard_results.json`.
+
+## Fonctionnement
+
+L'outil utilise un agent IA basé sur `smolagents` pour :
+
+1. Naviguer vers chaque URL de leaderboard
+2. Analyser la page pour trouver le tableau de classement
+3. Extraire les trois premiers modèles avec leurs scores
+4. Sauvegarder les résultats dans un fichier JSON
+
+## Développement
+
+Pour ajouter un nouvel outil à l'agent, créez une fonction dans `src/tools.py` et décorez-la avec `@tool`.
+
+Pour modifier les instructions données à l'agent, modifiez la variable `leaderboard_instructions` dans `src/agent.py`.
+
+## Expériences
+
+Le dossier `experiments/` contient des scripts expérimentaux qui ont été utilisés pour développer et tester différentes approches.
+
+## Comment ça fonctionne
+
+1. Le script charge les URLs des leaderboards depuis `data/leaderboards.json`
+2. Pour chaque URL, il lance un navigateur et utilise un agent IA pour :
+   - Naviguer vers l'URL du leaderboard
+   - Analyser la page pour trouver les trois premiers modèles
+   - Extraire les informations pertinentes
+3. Les résultats sont sauvegardés dans `data/leaderboard_results.json`

data/best.backup.json

@@ -0,0 +1,185 @@
+[
+  {
+    "category": "text generation",
+    "emoji": "📝",
+    "leaderboards": [
+      {
+        "uid": "6468923b99182de17844bf7b",
+        "additionnal_agent_rules": "",
+        "is_open_source": false
+      },
+      {
+        "uid": "643d3016d2c1e08a5eca0c22",
+        "additionnal_agent_rules": "you have to check the 'only official providers' filter before trying to get the best models. It is mandatory to check this filter.",
+        "is_open_source": true
+      }
+    ]
+  },
+  {
+    "category": "uncensored text generation",
+    "emoji": "🔓",
+    "leaderboards": [
+      {
+        "uid": "65f0f612555caedb299e54d9",
+        "additionnal_agent_rules": "You have to remove models where are 'unavailable'",
+        "is_open_source": true
+      }
+    ]
+  },
+  {
+    "category": "image understanding",
+    "emoji": "📷",
+    "leaderboards": [
+      {
+        "uid": "6468923b99182de17844bf7b",
+        "additionnal_agent_rules": "you have to search for 'Arena (vision)' tab. You are searching for the best VLM models. It is mandatory to check this tab. If there is no informations about models in this tab, fail.",
+        "is_open_source": false
+      }
+    ]
+  },
+  {
+    "category": "agentic",
+    "emoji": "🤖",
+    "leaderboards": [
+      {
+        "uid": "67909d72a1832c8a7cdd4599",
+        "additionnal_agent_rules": "",
+        "is_open_source": false
+      }
+    ]
+  },
+  {
+    "category": "math",
+    "emoji": "🧮",
+    "leaderboards": [
+      {
+        "uid": "643d3016d2c1e08a5eca0c22",
+        "additionnal_agent_rules": "You have to click on MATH to sort the leaderboard by score. We are searching for the best math models.",
+        "is_open_source": true
+      }
+    ]
+  },
+  {
+    "category": "code",
+    "emoji": "💻",
+    "leaderboards": [
+      {
+        "uid": "6662b2c6cc6519da32cd6f4d",
+        "additionnal_agent_rules": "",
+        "is_open_source": false
+      },
+      {
+        "uid": "657b23848e7790a347c7e4ea",
+        "additionnal_agent_rules": "",
+        "is_open_source": false
+      }
+    ]
+  },
+  {
+    "category": "embedding",
+    "emoji": "📦",
+    "leaderboards": [
+      {
+        "uid": "633581939ac57cf2967be686",
+        "additionnal_agent_rules": "",
+        "is_open_source": false
+      }
+    ]
+  },
+  {
+    "category": "text to image",
+    "emoji": "🎨",
+    "leaderboards": [
+      {
+        "uid": "665e7241f8cb81b0a476eccb",
+        "additionnal_agent_rules": "",
+        "is_open_source": false
+      },
+      {
+        "uid": "6670f4cffc615a6257ab35dd",
+        "additionnal_agent_rules": "You have to search for the 'image generation' leaderboard before trying to get the best models. If you don't find it. Fail."
+      }
+    ]
+  },
+  {
+    "category": "text to video",
+    "emoji": "🎬",
+    "leaderboards": [
+      {
+        "uid": "6719d6a46937670ca681151e",
+        "additionnal_agent_rules": "",
+        "is_open_source": false
+      },
+      {
+        "uid": "6670f4cffc615a6257ab35dd",
+        "additionnal_agent_rules": "You have to search for the 'video generation' tab to access the leaderboard before trying to get the best models. If you don't find it. Fail."
+      }
+    ]
+  },
+  {
+    "category": "text to 3d",
+    "emoji": "🧊",
+    "leaderboards": [
+      {
+        "uid": "651f831f128d26b399db9ea5",
+        "additionnal_agent_rules": "",
+        "is_open_source": false
+      }
+    ]
+  },
+  {
+    "category": "text to speech",
+    "emoji": "🔊",
+    "leaderboards": [
+      {
+        "uid": "65a5a7c26145ebc6e7e39243",
+        "additionnal_agent_rules": "",
+        "is_open_source": false
+      }
+    ]
+  },
+  {
+    "category": "speech to text",
+    "emoji": "🎤",
+    "leaderboards": [
+      {
+        "uid": "64f9e6dd59eae6df399ba1e9",
+        "additionnal_agent_rules": "",
+        "is_open_source": true
+      }
+    ]
+  },
+  {
+    "category": "image to text",
+    "emoji": "📝",
+    "leaderboards": [
+      {
+        "uid": "65b0a64db233ea8ce65f0bc5",
+        "additionnal_agent_rules": "",
+        "is_open_source": false
+      }
+    ]
+  },
+  {
+    "category": "image background removal",
+    "emoji": "🖼️",
+    "leaderboards": [
+      {
+        "uid": "674eea98c6a6ef2849b4a0ac",
+        "additionnal_agent_rules": "",
+        "is_open_source": false
+      }
+    ]
+  },
+  {
+    "category": "medical QA tasks",
+    "emoji": "🩺",
+    "leaderboards": [
+      {
+        "uid": "65d70863ef58a69470ead2fc",
+        "additionnal_agent_rules": "",
+        "is_open_source": true
+      }
+    ]
+  }
+]

data/best_model_for_category_list.json

@@ -0,0 +1,190 @@
+[
+  {
+    "category": "text generation",
+    "emoji": "📝",
+    "leaderboards": [
+      {
+        "uid": "6468923b99182de17844bf7b",
+        "additionnal_agent_rules": "",
+        "is_open_source": false
+      },
+      {
+        "uid": "643d3016d2c1e08a5eca0c22",
+        "additionnal_agent_rules": "you have to check the 'only official providers' filter before trying to get the best models. It is mandatory to check this filter.",
+        "is_open_source": true
+      }
+    ]
+  },
+  {
+    "category": "uncensored text generation",
+    "emoji": "🔓",
+    "leaderboards": [
+      {
+        "uid": "65f0f612555caedb299e54d9",
+        "additionnal_agent_rules": "You have to remove models where are '(no longer available)'. Keep all the other models.",
+        "is_open_source": true
+      }
+    ]
+  },
+  {
+    "category": "image understanding",
+    "emoji": "📷",
+    "leaderboards": [
+      {
+        "uid": "6468923b99182de17844bf7b",
+        "additionnal_agent_rules": "you have to search for 'Arena (vision)' tab. You are searching for the best VLM models. It is mandatory to check this tab. If there is no informations about models in this tab, fail.",
+        "is_open_source": false
+      }
+    ]
+  },
+  {
+    "category": "agentic",
+    "emoji": "🤖",
+    "leaderboards": [
+      {
+        "uid": "67909d72a1832c8a7cdd4599",
+        "additionnal_agent_rules": "",
+        "is_open_source": false
+      }
+    ]
+  },
+  {
+    "category": "math",
+    "emoji": "🧮",
+    "leaderboards": [
+      {
+        "uid": "643d3016d2c1e08a5eca0c22",
+        "additionnal_agent_rules": "You have to click on MATH to sort the leaderboard by score. We are searching for the best math models.",
+        "is_open_source": true
+      }
+    ]
+  },
+  {
+    "category": "code",
+    "emoji": "💻",
+    "leaderboards": [
+      {
+        "uid": "6662b2c6cc6519da32cd6f4d",
+        "additionnal_agent_rules": "",
+        "is_open_source": false
+      },
+      {
+        "uid": "657b23848e7790a347c7e4ea",
+        "additionnal_agent_rules": "",
+        "is_open_source": false
+      }
+    ]
+  },
+  {
+    "category": "embedding",
+    "emoji": "📦",
+    "leaderboards": [
+      {
+        "uid": "633581939ac57cf2967be686",
+        "additionnal_agent_rules": "",
+        "is_open_source": false
+      }
+    ]
+  },
+  {
+    "category": "text to image",
+    "emoji": "🎨",
+    "leaderboards": [
+      {
+        "uid": "665e7241f8cb81b0a476eccb",
+        "additionnal_agent_rules": "",
+        "is_open_source": false
+      },
+      {
+        "uid": "6670f4cffc615a6257ab35dd",
+        "additionnal_agent_rules": "You have to search for the 'image generation' leaderboard before trying to get the best models. If you don't find it. Fail."
+      }
+    ]
+  },
+  {
+    "category": "text to video",
+    "emoji": "🎬",
+    "leaderboards": [
+      {
+        "uid": "65adcd10d6b10af9119fc960",
+        "additionnal_agent_rules": "",
+        "is_open_source": false
+      },
+      {
+        "uid": "6719d6a46937670ca681151e",
+        "additionnal_agent_rules": "",
+        "is_open_source": false
+      },
+      {
+        "uid": "6670f4cffc615a6257ab35dd",
+        "additionnal_agent_rules": "You have to search for the 'video generation' tab to access the leaderboard before trying to get the best models. If you don't find it. Fail."
+      }
+    ]
+  },
+  {
+    "category": "text to 3d",
+    "emoji": "🧊",
+    "leaderboards": [
+      {
+        "uid": "651f831f128d26b399db9ea5",
+        "additionnal_agent_rules": "",
+        "is_open_source": false
+      }
+    ]
+  },
+  {
+    "category": "text to speech",
+    "emoji": "🔊",
+    "leaderboards": [
+      {
+        "uid": "65a5a7c26145ebc6e7e39243",
+        "additionnal_agent_rules": "",
+        "is_open_source": false
+      }
+    ]
+  },
+  {
+    "category": "speech to text",
+    "emoji": "🎤",
+    "leaderboards": [
+      {
+        "uid": "64f9e6dd59eae6df399ba1e9",
+        "additionnal_agent_rules": "",
+        "is_open_source": true
+      }
+    ]
+  },
+  {
+    "category": "image to text",
+    "emoji": "📝",
+    "leaderboards": [
+      {
+        "uid": "65b0a64db233ea8ce65f0bc5",
+        "additionnal_agent_rules": "",
+        "is_open_source": false
+      }
+    ]
+  },
+  {
+    "category": "image background removal",
+    "emoji": "🖼️",
+    "leaderboards": [
+      {
+        "uid": "674eea98c6a6ef2849b4a0ac",
+        "additionnal_agent_rules": "",
+        "is_open_source": false
+      }
+    ]
+  },
+  {
+    "category": "medical QA tasks",
+    "emoji": "🩺",
+    "leaderboards": [
+      {
+        "uid": "65d70863ef58a69470ead2fc",
+        "additionnal_agent_rules": "",
+        "is_open_source": true
+      }
+    ]
+  }
+]

experiments/simple_smolagent.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Simple SmoLAgent - Un script simple pour tester l'authentification avec Hugging Face
+"""
+
+import os
+import asyncio
+from dotenv import load_dotenv
+from huggingface_hub import login
+from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel
+
+# Charger les variables d'environnement depuis le fichier .env
+load_dotenv()
+
+# Récupérer le token Hugging Face
+hf_token = os.getenv("HUGGING_FACE_HUB_TOKEN")
+
+def main():
+    """Fonction principale pour tester l'authentification avec Hugging Face."""
+    
+    agent = CodeAgent(tools=[DuckDuckGoSearchTool()], model=HfApiModel())
+
+    response = agent.run("Search for the best music recommendations for a party at the Wayne's mansion.")
+    # Tester l'agent avec une requête simple
+    print(f"Réponse de l'agent: {response}")
+    
+
+if __name__ == "__main__":
+    main()

experiments/smolagent_parser.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+SmoLAgent Parser - Extrait le premier modèle de chaque leaderboard Hugging Face
+en utilisant Playwright et smolagents.
+"""
+
+import json
+import os
+import asyncio
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+from dotenv import load_dotenv
+from huggingface_hub import login
+
+from playwright.async_api import async_playwright
+from smolagents import CodeAgent
+from smolagents.models import HfApiModel
+from smolagents.tools import Tool
+
+# Charger les variables d'environnement depuis le fichier .env
+load_dotenv()
+
+# Récupérer le token Hugging Face
+hf_token = os.getenv("HUGGING_FACE_HUB_TOKEN")
+
+# Charger les leaderboards depuis le fichier JSON
+def load_leaderboards() -> List[str]:
+    """Charger les URLs des leaderboards depuis le fichier JSON."""
+    with open("leaderboards.json", "r") as f:
+        return json.load(f)
+
+# Définir un outil pour utiliser Playwright
+class PlaywrightBrowserTool(Tool):
+    """Outil pour interagir avec un navigateur web via Playwright."""
+    
+    name = "browser"
+    description = "Outil pour interagir avec un navigateur web via Playwright."
+    inputs = {
+        "goto": {
+            "url": {
+                "type": "string",
+                "description": "L'URL vers laquelle naviguer"
+            }
+        },
+        "get_content": {},
+        "get_title": {},
+        "take_screenshot": {
+            "path": {
+                "type": "string",
+                "description": "Le chemin où enregistrer la capture d'écran"
+            }
+        },
+        "run_js": {
+            "script": {
+                "type": "string",
+                "description": "Le code JavaScript à exécuter dans le contexte de la page"
+            }
+        },
+        "wait_for": {
+            "selector": {
+                "type": "string",
+                "description": "Le sélecteur CSS à attendre"
+            },
+            "timeout": {
+                "type": "integer",
+                "description": "Le temps maximum d'attente en millisecondes"
+            }
+        },
+        "click": {
+            "selector": {
+                "type": "string",
+                "description": "Le sélecteur CSS de l'élément à cliquer"
+            }
+        },
+        "fill": {
+            "selector": {
+                "type": "string",
+                "description": "Le sélecteur CSS du champ de formulaire"
+            },
+            "value": {
+                "type": "string",
+                "description": "La valeur à remplir dans le champ de formulaire"
+            }
+        }
+    }
+    output_type = "any"
+    
+    def __init__(self, page):
+        self.page = page
+    
+    async def goto(self, url: str) -> str:
+        """Naviguer vers une URL."""
+        await self.page.goto(url, wait_until="networkidle", timeout=60000)
+        return f"Navigué vers {url}"
+    
+    async def get_content(self) -> str:
+        """Obtenir le contenu HTML de la page."""
+        return await self.page.content()
+    
+    async def get_title(self) -> str:
+        """Obtenir le titre de la page."""
+        return await self.page.title()
+    
+    async def take_screenshot(self, path: str = "screenshot.png") -> str:
+        """Prendre une capture d'écran de la page."""
+        await self.page.screenshot(path=path)
+        return f"Capture d'écran enregistrée dans {path}"
+    
+    async def run_js(self, script: str) -> Any:
+        """Exécuter du JavaScript dans le contexte de la page."""
+        return await self.page.evaluate(script)
+    
+    async def wait_for(self, selector: str, timeout: int = 30000) -> str:
+        """Attendre qu'un élément correspondant au sélecteur apparaisse."""
+        await self.page.wait_for_selector(selector, timeout=timeout)
+        return f"Élément avec le sélecteur '{selector}' trouvé"
+    
+    async def click(self, selector: str) -> str:
+        """Cliquer sur un élément correspondant au sélecteur."""
+        await self.page.click(selector)
+        return f"Cliqué sur l'élément avec le sélecteur '{selector}'"
+    
+    async def fill(self, selector: str, value: str) -> str:
+        """Remplir un champ de formulaire."""
+        await self.page.fill(selector, value)
+        return f"Rempli '{value}' dans l'élément avec le sélecteur '{selector}'"
+
+async def extract_first_model(url: str) -> Optional[Dict[str, Any]]:
+    """
+    Extraire le premier modèle d'un leaderboard en utilisant un agent.
+    
+    Args:
+        url: L'URL du leaderboard
+        
+    Returns:
+        Un dictionnaire contenant les informations sur le premier modèle, ou None si l'extraction a échoué
+    """
+    async with async_playwright() as p:
+        browser = await p.chromium.launch(headless=False)  # Mettre à True pour la production
+        page = await browser.new_page()
+        
+        try:
+            # Créer l'outil Playwright
+            browser_tool = PlaywrightBrowserTool(page)
+            
+            # Créer l'agent
+            agent = CodeAgent(
+                tools=[browser_tool],
+                model=HfApiModel()
+            )
+            
+            # Exécuter l'agent
+            prompt = f"""
+            Extrais les informations sur le premier modèle du leaderboard à l'URL suivante: {url}
+            
+            Utilise l'outil browser pour naviguer sur la page et extraire les informations suivantes:
+            - Nom du modèle
+            - Score
+            - Position/rang
+            - Créateur/auteur
+            
+            Retourne les informations sous forme de dictionnaire Python.
+            """
+            
+            result = await agent.run(prompt)
+            print(f"Résultat brut de l'agent: {result}")
+            
+            # Essayer de parser le résultat comme un dictionnaire
+            try:
+                # L'agent peut retourner une représentation textuelle d'un dictionnaire
+                if isinstance(result, str):
+                    # Essayer de trouver une structure de dictionnaire dans la chaîne
+                    import re
+                    dict_match = re.search(r'\{.*\}', result, re.DOTALL)
+                    if dict_match:
+                        dict_str = dict_match.group(0)
+                        # Remplacer les guillemets simples par des guillemets doubles pour un JSON valide
+                        dict_str = dict_str.replace("'", '"')
+                        return json.loads(dict_str)
+                    return {"raw_result": result}
+                return result
+            except Exception as e:
+                print(f"Erreur lors du parsing du résultat: {e}")
+                return {"raw_result": str(result)}
+        except Exception as e:
+            print(f"Erreur lors de l'extraction des données de {url}: {e}")
+            await page.screenshot(path=f"error_{url.replace('://', '_').replace('/', '_')}.png")
+            return {"error": str(e)}
+        finally:
+            await browser.close()
+
+async def main():
+    """Fonction principale pour traiter tous les leaderboards."""
+    # Se connecter à Hugging Face
+    if hf_token:
+        print("Token Hugging Face trouvé dans le fichier .env")
+        login(token=hf_token)
+        print("Connexion à Hugging Face réussie!")
+    else:
+        print("Erreur: Token Hugging Face non trouvé dans le fichier .env")
+        return
+    
+    leaderboards = load_leaderboards()
+    results = {}
+    
+    for url in leaderboards:
+        print(f"Traitement du leaderboard: {url}")
+        result = await extract_first_model(url)
+        results[url] = result
+        print(f"Résultat: {result}")
+    
+    # Sauvegarder les résultats dans un fichier JSON
+    with open("results_smolagent.json", "w") as f:
+        json.dump(results, f, indent=2)
+    
+    print(f"Résultats sauvegardés dans results_smolagent.json")
+
+if __name__ == "__main__":
+    asyncio.run(main()) 

experiments/vision_web_browser.py

@@ -0,0 +1,210 @@
+import argparse
+from io import BytesIO
+from time import sleep
+
+import helium
+from dotenv import load_dotenv
+from PIL import Image
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.common.keys import Keys
+
+from smolagents import CodeAgent, DuckDuckGoSearchTool, tool
+from smolagents.agents import ActionStep
+from smolagents.cli import load_model
+
+
+github_request = """
+I'm trying to find how hard I have to work to get a repo in github.com/trending.
+Can you navigate to the profile for the top author of the top trending repo, and give me their total number of commits over the last year?
+"""  # The agent is able to achieve this request only when powered by GPT-4o or Claude-3.5-sonnet.
+
+search_request = """
+Please navigate to https://en.wikipedia.org/wiki/Chicago and give me a sentence containing the word "1992" that mentions a construction accident.
+"""
+
+
+def parse_arguments():
+    parser = argparse.ArgumentParser(description="Run a web browser automation script with a specified model.")
+    parser.add_argument(
+        "prompt",
+        type=str,
+        nargs="?",  # Makes it optional
+        default=github_request,
+        help="The prompt to run with the agent",
+    )
+    parser.add_argument(
+        "--model-type",
+        type=str,
+        default="LiteLLMModel",
+        help="The model type to use (e.g., OpenAIServerModel, LiteLLMModel, TransformersModel, HfApiModel)",
+    )
+    parser.add_argument(
+        "--model-id",
+        type=str,
+        default="gpt-4o",
+        help="The model ID to use for the specified model type",
+    )
+    return parser.parse_args()
+
+
+def save_screenshot(memory_step: ActionStep, agent: CodeAgent) -> None:
+    sleep(1.0)  # Let JavaScript animations happen before taking the screenshot
+    driver = helium.get_driver()
+    current_step = memory_step.step_number
+    if driver is not None:
+        for previous_memory_step in agent.memory.steps:  # Remove previous screenshots from logs for lean processing
+            if isinstance(previous_memory_step, ActionStep) and previous_memory_step.step_number <= current_step - 2:
+                previous_memory_step.observations_images = None
+        png_bytes = driver.get_screenshot_as_png()
+        image = Image.open(BytesIO(png_bytes))
+        print(f"Captured a browser screenshot: {image.size} pixels")
+        memory_step.observations_images = [image.copy()]  # Create a copy to ensure it persists, important!
+
+    # Update observations with current URL
+    url_info = f"Current url: {driver.current_url}"
+    memory_step.observations = (
+        url_info if memory_step.observations is None else memory_step.observations + "\n" + url_info
+    )
+    return
+
+
+@tool
+def search_item_ctrl_f(text: str, nth_result: int = 1) -> str:
+    """
+    Searches for text on the current page via Ctrl + F and jumps to the nth occurrence.
+    Args:
+        text: The text to search for
+        nth_result: Which occurrence to jump to (default: 1)
+    """
+    elements = driver.find_elements(By.XPATH, f"//*[contains(text(), '{text}')]")
+    if nth_result > len(elements):
+        raise Exception(f"Match n°{nth_result} not found (only {len(elements)} matches found)")
+    result = f"Found {len(elements)} matches for '{text}'."
+    elem = elements[nth_result - 1]
+    driver.execute_script("arguments[0].scrollIntoView(true);", elem)
+    result += f"Focused on element {nth_result} of {len(elements)}"
+    return result
+
+
+@tool
+def go_back() -> None:
+    """Goes back to previous page."""
+    driver.back()
+
+
+@tool
+def close_popups() -> str:
+    """
+    Closes any visible modal or pop-up on the page. Use this to dismiss pop-up windows! This does not work on cookie consent banners.
+    """
+    webdriver.ActionChains(driver).send_keys(Keys.ESCAPE).perform()
+
+
+def initialize_driver():
+    """Initialize the Selenium WebDriver."""
+    chrome_options = webdriver.ChromeOptions()
+    chrome_options.add_argument("--force-device-scale-factor=1")
+    chrome_options.add_argument("--window-size=1000,1350")
+    chrome_options.add_argument("--disable-pdf-viewer")
+    chrome_options.add_argument("--window-position=0,0")
+    return helium.start_chrome(headless=False, options=chrome_options)
+
+
+def initialize_agent(model):
+    """Initialize the CodeAgent with the specified model."""
+    return CodeAgent(
+        tools=[DuckDuckGoSearchTool(), go_back, close_popups, search_item_ctrl_f],
+        model=model,
+        additional_authorized_imports=["helium"],
+        step_callbacks=[save_screenshot],
+        max_steps=20,
+        verbosity_level=2,
+    )
+
+
+helium_instructions = """
+Use your web_search tool when you want to get Google search results.
+Then you can use helium to access websites. Don't use helium for Google search, only for navigating websites!
+Don't bother about the helium driver, it's already managed.
+We've already ran "from helium import *"
+Then you can go to pages!
+Code:
+```py
+go_to('github.com/trending')
+```<end_code>
+
+You can directly click clickable elements by inputting the text that appears on them.
+Code:
+```py
+click("Top products")
+```<end_code>
+
+If it's a link:
+Code:
+```py
+click(Link("Top products"))
+```<end_code>
+
+If you try to interact with an element and it's not found, you'll get a LookupError.
+In general stop your action after each button click to see what happens on your screenshot.
+Never try to login in a page.
+
+To scroll up or down, use scroll_down or scroll_up with as an argument the number of pixels to scroll from.
+Code:
+```py
+scroll_down(num_pixels=1200) # This will scroll one viewport down
+```<end_code>
+
+When you have pop-ups with a cross icon to close, don't try to click the close icon by finding its element or targeting an 'X' element (this most often fails).
+Just use your built-in tool `close_popups` to close them:
+Code:
+```py
+close_popups()
+```<end_code>
+
+You can use .exists() to check for the existence of an element. For example:
+Code:
+```py
+if Text('Accept cookies?').exists():
+    click('I accept')
+```<end_code>
+
+Proceed in several steps rather than trying to solve the task in one shot.
+And at the end, only when you have your answer, return your final answer.
+Code:
+```py
+final_answer("YOUR_ANSWER_HERE")
+```<end_code>
+
+If pages seem stuck on loading, you might have to wait, for instance `import time` and run `time.sleep(5.0)`. But don't overuse this!
+To list elements on page, DO NOT try code-based element searches like 'contributors = find_all(S("ol > li"))': just look at the latest screenshot you have and read it visually, or use your tool search_item_ctrl_f.
+Of course, you can act on buttons like a user would do when navigating.
+After each code blob you write, you will be automatically provided with an updated screenshot of the browser and the current browser url.
+But beware that the screenshot will only be taken at the end of the whole action, it won't see intermediate states.
+Don't kill the browser.
+When you have modals or cookie banners on screen, you should get rid of them before you can click anything else.
+"""
+
+
+def main():
+    # Load environment variables
+    load_dotenv()
+
+    # Parse command line arguments
+    args = parse_arguments()
+
+    # Initialize the model based on the provided arguments
+    model = load_model(args.model_type, args.model_id)
+
+    global driver
+    driver = initialize_driver()
+    agent = initialize_agent(model)
+
+    # Run the agent with the provided prompt
+    agent.python_executor("from helium import *", agent.state)
+    agent.run(args.prompt + helium_instructions)
+
+
+if __name__ == "__main__":
+    main()

main.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python
+"""
+Main script for the leaderboard parser.
+This script processes leaderboards specified in data/best_model_for_category_list.json file
+by matching their UIDs with hosts in data/final_leaderboards.json.
+
+Environment variables:
+    HUGGING_FACE_HUB_TOKEN: Authentication token for Hugging Face Hub (required)
+    HUGGING_FACE_STORAGE_REPO: Target dataset name on the Hub (optional, default: leaderboard-explorer/leaderboard_explorer)
+    LEADERBOARD_REPROCESS_INTERVAL_HOURS: Interval in hours between leaderboard processing runs (default: 24)
+"""
+import argparse
+import logging
+from dotenv import load_dotenv
+import uvicorn
+import sys
+
+# Import from src modules
+from src.processor import process_leaderboards
+from src.server import app, initialize_server
+from src.scheduler import initialize_scheduler, start_scheduler
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)
+logger = logging.getLogger("leaderboard-parser")
+
+def main():
+    """
+    Main function to process leaderboards specified in best_model_for_category_list.json.
+    """
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description="Leaderboard Parser")
+    parser.add_argument("--clean", action="store_true", help="Clean the results file before starting")
+    parser.add_argument("--force-retry-uid", help="Force retry for a specific leaderboard UID")
+    parser.add_argument("--force-retry-category", help="Force retry for all leaderboards of a specific category")
+    parser.add_argument("--upload-only", action="store_true", help="Only upload local files to the Hub without processing leaderboards")
+    parser.add_argument("--local-only", action="store_true", help="Local mode only: do not download from the Hub and do not upload to the Hub")
+    parser.add_argument("--retry-rejected", action="store_true", help="Force reprocessing of rejected leaderboards even if it's been less than 24h")
+    parser.add_argument("--server", action="store_true", help="Run as a web server with scheduled processing")
+    args = parser.parse_args()
+    
+    # Load environment variables
+    load_dotenv()
+
+    # Check if we should run in server mode
+    if args.server:
+        run_server_mode()
+        return
+
+    # Convert args to dict for process_leaderboards
+    args_dict = vars(args)
+    
+    # Process the leaderboards
+    success, message = process_leaderboards(args_dict)
+    
+    if success:
+        logger.info(message)
+        return 0
+    else:
+        logger.error(message)
+        return 1
+
+def run_server_mode():
+    """Run the application in server mode with periodic processing"""
+    # Initialize server and scheduler with the process_leaderboards function
+    initialize_server(process_leaderboards)
+    initialize_scheduler(process_leaderboards)
+    
+    # Start the scheduler thread
+    scheduler = start_scheduler()
+    
+    try:
+        # Log startup information
+        logger.info("Running in server mode with periodic processing")
+        
+        # Run the FastAPI server
+        uvicorn.run(app, host="0.0.0.0", port=8000)
+    except KeyboardInterrupt:
+        logger.info("Server stopped by user")
+    except Exception as e:
+        logger.error(f"Error running server: {e}")
+
+if __name__ == "__main__":
+    sys.exit(main()) 

pyproject.toml

@@ -0,0 +1,27 @@
+[tool.poetry]
+name = "leaderboard-parser"
+version = "0.1.0"
+description = "Parser for Hugging Face leaderboards"
+authors = ["Thibaud Frere"]
+readme = "README.md"
+packages = [{include = "src"}]
+package-mode = false
+
+[tool.poetry.dependencies]
+python = ">=3.10,<3.14"
+python-dotenv = "^1.0.1"
+opentelemetry-sdk = "^1.30.0"
+opentelemetry-exporter-otlp = "^1.30.0"
+openinference-instrumentation-smolagents = "^0.1.6"
+helium = "^5.1.1"
+huggingface-hub = "^0.29.1"
+fastapi = "^0.115.11"
+uvicorn = "^0.34.0"
+smolagents = {version = "^1.9.2", extras = ["litellm"]}
+
+[tool.poetry.scripts]
+leaderboard-parser = "main:main"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

scripts/test_agent.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python
+"""
+Script de test pour l'agent de parsing de leaderboard.
+Ce script permet de tester l'agent en standalone en lui donnant une URL.
+
+Usage:
+    python test_agent.py <url>
+    
+Exemple:
+    python test_agent.py https://lmarena-ai-chatbot-arena-leaderboard.hf.space
+"""
+import json
+import os
+import sys
+import argparse
+import datetime
+from dotenv import load_dotenv
+
+# Assurez-vous que le répertoire parent est dans le chemin d'importation
+script_dir = os.path.dirname(os.path.abspath(__file__))
+root_dir = os.path.dirname(script_dir)
+sys.path.insert(0, root_dir)
+
+from src.agent import get_default_model, process_leaderboard
+from src.browser import initialize_driver, close_driver, take_initial_screenshot
+
+
+def main():
+    """
+    Fonction principale qui teste l'agent sur une URL spécifiée.
+    """
+    # Charger les variables d'environnement
+    load_dotenv()
+    
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description="Test de l'agent de parsing de leaderboard")
+    parser.add_argument("url", help="URL du leaderboard à parser")
+    parser.add_argument("--save", help="Chemin où sauvegarder le résultat JSON (optionnel)")
+    parser.add_argument("--uid", help="UID à utiliser pour la capture d'écran (optionnel)")
+    parser.add_argument("--wait", type=int, default=10, help="Temps d'attente initial en secondes (défaut: 10)")
+    args = parser.parse_args()
+    
+    # Assurez-vous que nous sommes dans le bon répertoire
+    os.chdir(root_dir)
+    
+    # Vérifier que la clé API est disponible
+    if not os.getenv("OPENAI_API_KEY"):
+        print("ERREUR: La variable d'environnement OPENAI_API_KEY n'est pas définie.")
+        print("Veuillez créer un fichier .env à la racine du projet avec votre clé API.")
+        print("Exemple: OPENAI_API_KEY=votre-clé-api")
+        sys.exit(1)
+    
+    # Créer le répertoire d'images si nécessaire
+    if args.uid:
+        images_dir = os.path.join("data", "images")
+        os.makedirs(images_dir, exist_ok=True)
+    
+    # Obtenir le modèle par défaut
+    model = get_default_model()
+    
+    print(f"Test de l'agent sur l'URL: {args.url}")
+    if args.uid:
+        print(f"UID utilisé pour la capture d'écran: {args.uid}")
+    print(f"Temps d'attente initial: {args.wait} secondes")
+    
+    # Initialiser le navigateur et prendre une capture d'écran initiale avec le temps d'attente personnalisé
+    initialize_driver()
+    
+    if args.uid:
+        # Remplacer la fonction take_initial_screenshot par une version personnalisée avec le temps d'attente spécifié
+        import time
+        from helium import go_to
+        from io import BytesIO
+        from PIL import Image
+        
+        # Naviguer vers l'URL
+        go_to(args.url)
+        
+        # Attendre que la page se charge
+        print(f"Attente de {args.wait} secondes pour le chargement complet de la page...")
+        time.sleep(args.wait)
+        
+        # Prendre la capture d'écran
+        from src.browser import driver
+        png_bytes = driver.get_screenshot_as_png()
+        image = Image.open(BytesIO(png_bytes))
+        
+        # Sauvegarder la capture d'écran
+        images_dir = os.path.join("data", "images")
+        os.makedirs(images_dir, exist_ok=True)
+        screenshot_path = os.path.join(images_dir, f"{args.uid}.png")
+        image.save(screenshot_path)
+        
+        print(f"Capture d'écran initiale sauvegardée dans: {screenshot_path}")
+    
+    # Fermer le navigateur pour le réinitialiser
+    close_driver()
+    
+    # Traiter le leaderboard
+    result = process_leaderboard(args.url, model, 0, args.uid)
+    
+    # Ajouter des métadonnées
+    result["url"] = args.url
+    if args.uid:
+        result["uid"] = args.uid
+        result["screenshot"] = f"images/{args.uid}.png" if os.path.exists(os.path.join("data", "images", f"{args.uid}.png")) else None
+    
+    # Afficher le résultat en JSON
+    json_result = json.dumps(result, indent=2)
+    print("\nRésultat JSON:")
+    print(json_result)
+    
+    # Sauvegarder le résultat si demandé
+    if args.save:
+        with open(args.save, "w") as f:
+            f.write(json_result)
+        print(f"\nRésultat sauvegardé dans: {args.save}")
+
+
+if __name__ == "__main__":
+    main() 

src/agents/browser.py

@@ -0,0 +1,148 @@
+"""
+Browser management for the leaderboard agent.
+"""
+import os
+import gc
+import logging
+from io import BytesIO
+from time import sleep
+
+import helium
+from PIL import Image
+from selenium import webdriver
+from smolagents import CodeAgent
+from smolagents.agents import ActionStep
+
+# Configuration du logger
+logger = logging.getLogger("leaderboard-parser")
+
+# Global driver variable
+driver = None
+
+
+def save_screenshot(memory_step: ActionStep, agent: CodeAgent) -> None:
+    """
+    Save a screenshot of the current browser state in memory for the agent.
+    This is used as a callback for the agent to visualize the page.
+    The screenshot is only kept in memory and not saved to disk.
+    """
+    sleep(2.0)  # Increased to allow time for JavaScript animations
+    current_step = memory_step.step_number
+    if driver is not None:
+        for previous_memory_step in agent.memory.steps:  # Remove previous screenshots from logs for lean processing
+            if isinstance(previous_memory_step, ActionStep) and previous_memory_step.step_number <= current_step - 2:
+                previous_memory_step.observations_images = None
+        
+        # Capture screenshot for agent visualization only (not saved to disk)
+        png_bytes = driver.get_screenshot_as_png()
+        image = Image.open(BytesIO(png_bytes))
+        print(f"Captured a browser screenshot for agent: {image.size} pixels")
+        memory_step.observations_images = [image.copy()]  # Create a copy to ensure it persists, important!
+
+    # Update observations with current URL
+    url_info = f"Current url: {driver.current_url}"
+    memory_step.observations = (
+        url_info if memory_step.observations is None else memory_step.observations + "\n" + url_info
+    )
+    return
+
+
+def initialize_driver():
+    """
+    Initialize the Selenium WebDriver.
+    Returns a configured Chrome WebDriver instance.
+    """
+    global driver
+    
+    # Si le driver existe déjà, on le nettoie d'abord pour éviter les fuites mémoire
+    if driver is not None:
+        close_driver()
+    
+    print("Démarrage de l'initialisation du navigateur Chrome...")
+    
+    chrome_options = webdriver.ChromeOptions()
+    chrome_options.add_argument("--force-device-scale-factor=1")
+    chrome_options.add_argument("--window-size=1600,1400")
+    chrome_options.add_argument("--disable-pdf-viewer")
+    chrome_options.add_argument("--window-position=0,0")
+    
+    # Options essentielles pour l'environnement conteneurisé
+    chrome_options.add_argument("--no-sandbox")
+    chrome_options.add_argument("--disable-dev-shm-usage")
+    chrome_options.add_argument("--disable-gpu")
+    chrome_options.add_argument("--disable-extensions")
+    chrome_options.add_argument("--disable-software-rasterizer")
+    chrome_options.add_argument("--no-first-run")
+    chrome_options.add_argument("--no-zygote")
+    chrome_options.add_argument("--single-process")
+    
+    # Path to Chrome binary
+    chrome_path = os.environ.get("CHROME_PATH", "/usr/bin/google-chrome-stable")
+    if os.path.exists(chrome_path):
+        print(f"Utilisation de Chrome à l'emplacement: {chrome_path}")
+        chrome_options.binary_location = chrome_path
+    
+    # Afficher les options pour le diagnostic
+    print(f"Options Chrome configurées: {chrome_options.arguments}")
+    
+    try:
+        print("Tentative de démarrage de Chrome avec Helium...")
+        driver = helium.start_chrome(headless=True, options=chrome_options)
+        print("Chrome démarré avec succès!")
+        
+        # Informations sur le navigateur
+        print(f"Version de Chrome: {driver.capabilities.get('browserVersion', 'Inconnue')}")
+        print(f"Plateforme: {driver.capabilities.get('platformName', 'Inconnue')}")
+        
+        # Set page load timeout
+        driver.set_page_load_timeout(30)  # Increased to 30 seconds
+        
+        return driver
+    except Exception as e:
+        print(f"ERREUR lors du démarrage de Chrome: {str(e)}")
+        # Capturer la trace complète pour diagnostic
+        import traceback
+        print("Trace d'erreur complète:")
+        traceback.print_exc()
+        
+        # Vérifier si Chrome est disponible
+        try:
+            import subprocess
+            chrome_version_cmd = f"{chrome_path} --version"
+            version_output = subprocess.check_output(chrome_version_cmd, shell=True, stderr=subprocess.STDOUT).decode()
+            print(f"Version de Chrome installée: {version_output.strip()}")
+        except Exception as chrome_check_error:
+            print(f"Impossible de vérifier la version de Chrome: {str(chrome_check_error)}")
+        
+        raise
+
+
+def close_driver():
+    """
+    Close the browser and clean up resources.
+    """
+    global driver
+    
+    try:
+        print("Fermeture du navigateur et nettoyage des ressources...")
+        
+        # Utiliser helium.kill_browser() pour fermer proprement le navigateur
+        helium.kill_browser()
+        
+        # Libérer la référence
+        driver = None
+        
+        # Forcer le garbage collector
+        gc.collect()
+        
+        print("Navigateur fermé avec succès")
+    except Exception as e:
+        print(f"Error closing browser: {e}")
+
+
+# Alias de close_driver pour compatibilité avec browser_utils.cleanup_browser
+def cleanup_browser():
+    """
+    Alias de close_driver pour compatibilité avec l'API existante.
+    """
+    close_driver() 

src/agents/fact_checker/fact_checker_agent.py

@@ -0,0 +1,3 @@
+"""
+Agent management for the agent leaderboard parser fact checker.
+"""

src/agents/parser/parser_agent.py

@@ -0,0 +1,362 @@
+"""
+Agent management for the leaderboard parser.
+"""
+import datetime
+from smolagents import CodeAgent
+from smolagents.cli import load_model
+
+from src.agents.browser import save_screenshot
+from src.agents.tools import (
+    map_clickable_elements,
+    close_popups,
+    extract_table_data,
+    find_leaderboard_elements,
+    go_back,
+    search_item_ctrl_f,
+    copy_link_from_element,
+    validate_json_results,
+    find_model_links,
+    click_at_coordinates,
+)
+
+
+def initialize_agent(model):
+    """
+    Initialize the CodeAgent with the specified model.
+    
+    Args:
+        model: The LLM model to use for the agent
+        
+    Returns:
+        A configured CodeAgent instance
+    """
+    return CodeAgent(
+        tools=[go_back, map_clickable_elements, validate_json_results, close_popups, search_item_ctrl_f, extract_table_data, find_leaderboard_elements, copy_link_from_element, find_model_links, click_at_coordinates],
+        model=model,
+        additional_authorized_imports=["selenium", "helium", "time", "json", "re"],
+        step_callbacks=[save_screenshot],
+        max_steps=25,
+        verbosity_level=2,
+    )
+
+
+def get_default_model():
+    """
+    Get the default model for the agent.
+    
+    Returns:
+        A configured model instance
+    """
+    model_type = "LiteLLMModel"
+    model_id = "gpt-4o"
+    return load_model(model_type, model_id)
+
+
+# Instructions for the agent
+leaderboard_instructions = """
+Your task is to extract the three BEST models from the leaderboard. It is crucial that you identify the models that are at the top of the ranking, not just any three models present on the page.
+
+You must also identify the main criterion on which the models are evaluated (for example: accuracy, speed, performance on a specific benchmark, etc.). Formulate a short description (less than 60 words) that explains what the models are judged on.
+
+For each model, try to find a link to its page or repository. This can be any link (GitHub, Hugging Face, model website, etc.). If you cannot find a link for a model, indicate null for this field.
+
+IMPORTANT: If you fail to clearly identify the top three models AND the evaluation criterion, the leaderboard will be rejected. It is essential that you provide this information accurately and completely.
+
+You can use helium to navigate the website. We have already executed "from helium import *".
+You can go to pages with:
+```py
+go_to('url')
+```<end_code>
+
+You can click on clickable elements by entering the text that appears on them:
+```py
+click("Button text")
+```<end_code>
+
+If it's a link:
+```py
+click(Link("Link text"))
+```<end_code>
+
+To scroll up or down, use scroll_down or scroll_up with the number of pixels as an argument:
+```py
+scroll_down(num_pixels=1200) # This will scroll down one view
+```<end_code>
+
+To close popups with an X icon, use the built-in tool `close_popups`:
+```py
+close_popups()
+```<end_code>
+
+You can use .exists() to check for the existence of an element:
+```py
+if Text('Accept cookies?').exists():
+    click('I accept')
+```<end_code>
+
+If you encounter situations where you cannot click on elements using text, you can use click_at_coordinates to click at specific x,y coordinates on the page:
+```py
+click_at_coordinates(x=500, y=300)  # Click at the position 500px from left, 300px from top
+```<end_code>
+
+If pages seem stuck while loading, you may need to wait:
+```py
+import time
+time.sleep(20.0)  # Wait at least 10 seconds for the initial loading
+```<end_code>
+
+To extract data from a table, use the extract_table_data tool:
+```py
+table_info = extract_table_data()
+print(table_info)
+```<end_code>
+
+If you cannot easily find a standard table, use find_leaderboard_elements to search for elements that might contain ranking data:
+```py
+leaderboard_elements = find_leaderboard_elements()
+print(leaderboard_elements)
+```<end_code>
+
+RECOMMENDED METHODS FOR FINDING MODEL LINKS:
+
+```py
+# For a model named "BERT-Large"
+model_name = "BERT-Large"
+links_info = find_model_links(model_name)
+print(links_info)
+
+# If links were found, the best candidate is displayed at the end of the result
+if "Best candidate for" in links_info:
+    # Extract the URL of the best candidate
+    best_url_line = links_info.split("Best candidate for")[1].split("\n")[1]
+    url = best_url_line.replace("URL:", "").strip()
+    print(f"URL for model {model_name}: {url}")
+else:
+    print(f"No link found for model {model_name}")
+    url = None
+```<end_code>
+
+
+IMPORTANT: If none of the methods can find a URL, do NOT try other methods such as extracting URLs from the source code. Simply use null for the model URL. It is better to have a missing URL (null) than an incorrect or irrelevant URL.
+
+IMPORTANT - PAGE EXPLORATION ORDER:
+If you don't immediately see the leaderboard table or ranking information, STRICTLY follow this order:
+
+1. ABSOLUTE PRIORITY:
+    Look for and click on buttons, tabs, or links with text like "Leaderboard", "Results", "Ranking", "Benchmark", "Scores", "Evaluation", etc.
+    Examine ALL visible buttons and tabs before moving to the next step.
+   IMPORTANT: Be flexible with text matching! Some elements may contain emojis or other characters before/after the keywords.
+   
+   ```py
+   # Examples of searching for leaderboard buttons/tabs
+   for text in ["🏆 Leaderboard", "Leaderboard", "Results", "Ranking", "Benchmark", "Scores", "Evaluation", "Performance"]:
+       if Button(text).exists() or Link(text).exists() or Text(text).exists():
+           print(f"Found clickable element: {text}")
+           click(text)
+           time.sleep(5)  # Wait for the page to update
+           break
+   
+   # If exact matches fail, try more flexible matching
+   # This is crucial for elements with emojis or other characters
+   if True:  # This will execute if no exact match was found above
+       print("No exact matches found. Trying flexible text matching...")
+       import time
+       from src.agents.browser import driver
+       from selenium.webdriver.common.by import By
+       
+       for text in ["🏆 Leaderboard", "Leaderboard", "Results", "Ranking", "Benchmark", "Scores"]:
+           # Try to find elements CONTAINING the text (not exact match)
+           matching_elements = driver.find_elements(By.XPATH, f"//*[contains(text(), '{text}')]")
+           
+           if matching_elements:
+               print(f"Found {len(matching_elements)} elements containing '{text}'")
+               for element in matching_elements[:3]:  # Try first three matches
+                   try:
+                       element_text = element.text
+                       print(f"Element text: '{element_text}'")
+                       driver.execute_script("arguments[0].scrollIntoView(true);", element)
+                       time.sleep(1)
+                       element.click()
+                       print(f"Successfully clicked on element with text: '{element_text}'")
+                       time.sleep(5)
+                       break
+                   except Exception as e:
+                       print(f"Could not click: {e}")
+                       # Try JavaScript click as fallback
+                       try:
+                           driver.execute_script("arguments[0].click();", element)
+                           print(f"Clicked using JavaScript on element with text: '{element_text}'")
+                           time.sleep(5)
+                           break
+                       except:
+                           continue
+   ```<end_code>
+
+2. ONLY AFTER checking all buttons and tabs, scroll down to see if the content is lower down:
+   ```py
+   scroll_down(1200)  # Try scrolling to see more content
+   ```<end_code>
+
+3. Check if there are dropdown menus or filters to activate
+4. Explore the different sections of the page
+
+Proceed step by step:
+1. Navigate to the provided URL
+2. Wait for the page to load completely (use time.sleep(20.0))
+3. EXPLORE the page by STRICTLY following the order above (first buttons/tabs, then scroll if necessary)
+4. Look for the table or section containing the model ranking
+5. Identify the three BEST models (those at the top of the ranking) ( DO NOT CHANGE MODEL NAMES UNDER ANY CIRCUMSTANCES )
+6. Determine the main evaluation criterion for the models
+7. IMPORTANT : For each identified model, use the method described above to find its URL. If the URL is not found, use null.
+8. If you cannot find links at the first try for any reason, you can try again with the same method if you want.
+9. Validate the results using the validate_json_results tool. VERY IMPORTANT TO DO BEFORE SENDING RESULTS.
+10. Send final results
+
+```py
+final_answer({
+    "top_models": [
+        {"rank": 1, "name": "Model name 1", "url": "Model URL or null if not available"},
+        {"rank": 2, "name": "Model name 2", "url": "Model URL or null if not available"},
+        {"rank": 3, "name": "Model name 3", "url": "Model URL or null if not available"}
+    ],
+    "evaluation_criteria": "Short description of the evaluation criterion (less than 60 words)"
+})
+```<end_code>
+
+After each block of code you write, you will automatically receive an updated screenshot of the browser and the current URL of the browser.
+But be careful, the screenshot will only be taken at the end of the complete action, it will not see intermediate states.
+
+IMPORTANT: DO NOT CHANGE MODEL NAMES UNDER ANY CIRCUMSTANCES
+"""
+
+
+def validate_results(result):
+    """Checks that the results do not contain generic placeholders."""
+    if not result or not isinstance(result, dict):
+        return False, "Invalid result"
+    
+    if "top_models" not in result or len(result.get("top_models", [])) < 3:
+        return False, "Less than 3 models found"
+    
+    # Check for generic names
+    generic_names = ["model a", "model b", "model c", "model 1", "model 2", "model 3", "model name", "unavailable"]
+    model_names = [m.get("name", "").lower() for m in result.get("top_models", [])]
+    if any(name in generic_names for name in model_names):
+        return False, "Generic model names detected"
+    
+    # Check for generic URLs
+    generic_urls = ["example.com", "example.org"]
+    model_urls = [m.get("url", "").lower() for m in result.get("top_models", []) if m.get("url") is not None]
+    if any(generic in url for url in model_urls for generic in generic_urls):
+        return False, "Generic URLs detected"
+    
+    # Check the evaluation criterion
+    if "evaluation_criteria" not in result or len(result.get("evaluation_criteria", "")) < 10:
+        return False, "Evaluation criterion missing or too short"
+    
+    return True, "Valid results"
+
+
+def process_leaderboard(url, model, index, uid=None, additional_rules=None):
+    """
+    Process a single leaderboard URL and return the results.
+    
+    Args:
+        url: The URL of the leaderboard to process
+        model: The LLM model to use
+        index: The index of the leaderboard in the list
+        uid: The UID of the leaderboard (for saving screenshots)
+        additional_rules: Additional rules specific to this leaderboard
+        
+    Returns:
+        A dictionary with the results or error information
+    """
+    from src.agents.browser import initialize_driver, close_driver
+    
+    print(f"\n\n{'='*50}")
+    print(f"Processing leaderboard {index+1}: {url}")
+    if uid:
+        print(f"UID: {uid}")
+    if additional_rules:
+        print(f"Additional rules: {additional_rules}")
+    print(f"{'='*50}\n")
+    
+    # Get current date and time
+    now = datetime.datetime.now()
+    parsed_at = now.isoformat()
+    
+    initialize_driver()
+    
+    agent = initialize_agent(model)
+    
+    # Create the prompt with the target URL
+    prompt = f"Visit {url} and extract the three BEST models from the leaderboard (those at the top of the ranking). Also identify the main evaluation criterion for the models and look for links associated with the models."
+    
+    # Add additional rules if provided
+    instructions = leaderboard_instructions
+    if additional_rules:
+        instructions = f"""
+
+ADDITIONAL RULES SPECIFIC TO THIS LEADERBOARD:
+{additional_rules}
+
+{leaderboard_instructions}
+        
+ADDITIONAL RULES SPECIFIC TO THIS LEADERBOARD:
+{additional_rules}
+"""
+    
+    try:
+        # Run the agent with the provided prompt
+        agent.python_executor("from helium import *")
+        result = agent.run(prompt + instructions)
+        
+        print(f"\nResult for {url}:")
+        print(result)
+        
+        # Check if the result is None or empty
+        if not result:
+            return {
+                "results": None,
+                "parsing_status": "error",
+                "parsing_message": "Empty result from agent",
+                "parsed_at": parsed_at
+            }
+            
+        # Validate the results
+        is_valid, reason = validate_results(result)
+        if not is_valid:
+            print(f"WARNING: {reason}")
+            return {
+                "results": result,
+                "parsing_status": "invalid",
+                "parsing_message": reason,
+                "parsed_at": parsed_at
+            }
+        
+        # Make sure the response is in the correct format
+        if not isinstance(result, dict) or "top_models" not in result:
+            print("WARNING: Agent did not use final_answer() correctly")
+            return {
+                "results": None,
+                "parsing_status": "error",
+                "parsing_message": "Agent returned improperly formatted response (did not use final_answer correctly)",
+                "parsed_at": parsed_at
+            }
+            
+        return {
+            "results": result,
+            "parsing_status": "success",
+            "parsed_at": parsed_at
+        }
+    except Exception as e:
+        print(f"An error occurred while processing {url}: {e}")
+        return {
+            "results": None,
+            "parsing_status": "error",
+            "parsing_message": str(e),
+            "parsed_at": parsed_at
+        }
+    finally:
+        # Ensure browser is closed
+        close_driver() 

src/agents/tools.py

@@ -0,0 +1,443 @@
+"""
+Tools for the leaderboard agent.
+"""
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.common.keys import Keys
+from selenium.webdriver.common.action_chains import ActionChains
+import re
+import time
+import helium
+
+from smolagents import tool
+
+
+@tool
+def search_item_ctrl_f(text: str, nth_result: int = 1) -> str:
+    """
+    Searches for text on the current page via Ctrl + F and jumps to the nth occurrence.
+    Args:
+        text: The text to search for
+        nth_result: Which occurrence to jump to (default: 1)
+    """
+    from src.agents.browser import driver
+    
+    elements = driver.find_elements(By.XPATH, f"//*[contains(text(), '{text}')]")
+    if nth_result > len(elements):
+        raise Exception(f"Match n°{nth_result} not found (only {len(elements)} matches found)")
+    result = f"Found {len(elements)} matches for '{text}'."
+    elem = elements[nth_result - 1]
+    driver.execute_script("arguments[0].scrollIntoView(true);", elem)
+    result += f"Focused on element {nth_result} of {len(elements)}"
+    return result
+
+
+@tool
+def go_back() -> str:
+    """
+    Navigate back to the previous page.
+    """
+    from src.agents.browser import driver
+    
+    driver.back()
+    time.sleep(2)  # Wait for page to load
+    return "Navigated back to previous page"
+
+
+@tool
+def close_popups() -> str:
+    """
+    Closes any popup/modal dialogs that might be open on the page.
+    Useful when pop-ups appear (cookies, login prompts, etc.) that block interaction.
+    """
+    from src.agents.browser import driver
+    
+    # Try to find common popup elements
+    popup_selectors = [
+        "//button[contains(text(), 'Accept')]",
+        "//button[contains(text(), 'Close')]", 
+        "//button[contains(text(), 'Fermer')]",
+        "//button[contains(text(), 'OK')]",
+        "//button[contains(text(), 'Got it')]",
+        "//button[contains(@class, 'close')]",
+        "//div[contains(@class, 'popup')]//button",
+        "//div[contains(@class, 'modal')]//button",
+        "//div[contains(@class, 'dialog')]//button"
+    ]
+    
+    found = False
+    for selector in popup_selectors:
+        try:
+            popup_elements = driver.find_elements(By.XPATH, selector)
+            for elem in popup_elements:
+                if elem.is_displayed():
+                    elem.click()
+                    found = True
+                    time.sleep(0.5)  # Wait for popup to disappear
+        except Exception as e:
+            pass  # Ignore errors, try next selector
+    
+    return "Closed popup dialogs" if found else "No popup dialogs found"
+
+
+@tool
+def extract_table_data(table_caption: str = None, table_index: int = 1) -> str:
+    """
+    Extracts data from a table on the page. Can find a table by caption/title or by index.
+    Args:
+        table_caption: Text in or near the table to find (default: None - will use index)
+        table_index: The index of the table if caption is not provided (1-based)
+    """
+    from src.agents.browser import driver
+    
+    tables = driver.find_elements(By.TAG_NAME, "table")
+    if not tables:
+        return "No tables found on the page."
+    
+    result = f"Found {len(tables)} table(s) on the page.\n"
+    
+    for i, table in enumerate(tables):
+        result += f"\nTable {i+1}:\n"
+        
+        # Try to get headers
+        headers = table.find_elements(By.TAG_NAME, "th")
+        if headers:
+            header_texts = [header.text for header in headers]
+            result += f"Headers: {', '.join(header_texts)}\n"
+        
+        # Get rows
+        rows = table.find_elements(By.TAG_NAME, "tr")
+        result += f"Found {len(rows)} rows.\n"
+        
+        # Get first 5 rows as sample
+        for j, row in enumerate(rows[:5]):
+            cells = row.find_elements(By.TAG_NAME, "td")
+            if cells:
+                cell_texts = [cell.text for cell in cells]
+                result += f"Row {j+1}: {' | '.join(cell_texts)}\n"
+    
+    return result
+
+
+@tool
+def find_leaderboard_elements() -> str:
+    """
+    Find key elements of a leaderboard: title, evaluation criteria, and model rankings.
+    Returns a structured description of what was found.
+    """
+    from src.agents.browser import driver
+    
+    result = ""
+    
+    # Check for tables first
+    tables = driver.find_elements(By.TAG_NAME, "table")
+    if tables:
+        result += f"Found {len(tables)} table(s) that might contain leaderboard data.\n"
+    
+    # Check for ordered lists
+    ol_elements = driver.find_elements(By.TAG_NAME, "ol")
+    if ol_elements:
+        result += f"Found {len(ol_elements)} ordered list(s) that might contain rankings.\n"
+    
+    # Check for div elements with grid or flex display that might be custom leaderboards
+    grid_elements = driver.find_elements(By.XPATH, "//div[contains(@class, 'grid') or contains(@class, 'flex') or contains(@class, 'table') or contains(@class, 'rank') or contains(@class, 'leaderboard')]")
+    if grid_elements:
+        result += f"Found {len(grid_elements)} div elements with grid/flex/table classes that might be custom leaderboards.\n"
+    
+    # Look for elements with rank or position indicators
+    rank_elements = driver.find_elements(By.XPATH, "//*[contains(@class, 'rank') or contains(@class, 'position') or contains(@class, 'standing')]")
+    if rank_elements:
+        result += f"Found {len(rank_elements)} elements with rank/position classes.\n"
+    
+    if not result:
+        return "Could not find any obvious leaderboard elements. Try scrolling or navigating to the correct section."
+    
+    return result
+
+@tool
+def map_clickable_elements(keyword: str = None) -> str:
+    """
+    Displays a list of all clickable elements on the page with their coordinates.
+    
+    Args:
+        keyword: Optional keyword to filter elements. If specified, only elements containing this keyword will be displayed.
+    
+    Returns:
+        A string listing all clickable elements with their coordinates.
+    """
+    from src.agents.browser import driver
+    
+    clickable_selectors = [
+        "a", "button", "input[type='button']", "input[type='submit']", 
+        ".clickable", "[role='button']", "[onclick]"
+    ]
+    
+    result = "Éléments cliquables détectés:\n"
+    total = 0
+    
+    for selector in clickable_selectors:
+        elements = driver.find_elements(By.CSS_SELECTOR, selector)
+        for i, element in enumerate(elements):
+            try:
+                text = element.text.strip()
+                if not text and element.get_attribute("value"):
+                    text = element.get_attribute("value")
+                
+                # Ignorer les éléments vides ou non visibles
+                if not text or not element.is_displayed():
+                    continue
+                    
+                # Filtrer par mot-clé si spécifié
+                if keyword and keyword.lower() not in text.lower():
+                    continue
+                
+                rect = element.rect
+                x = int(rect['x'] + rect['width']/2)
+                y = int(rect['y'] + rect['height']/2)
+                
+                result += f"{total+1}. '{text}' ({selector}) - coords: x={x}, y={y}\n"
+                total += 1
+            except:
+                continue
+    
+    result += f"\nTotal: {total} éléments cliquables" + (" contenant '" + keyword + "'" if keyword else "")
+    return result
+
+@tool
+def copy_link_from_element(text_to_find: str, link_position: int = 1) -> str:
+    """
+    Find elements with specified text and return the URL if it's a link or has a parent link.
+    Args:
+        text_to_find: Text to search for
+        link_position: If multiple matches, which one to use (1-based)
+    """
+    from src.agents.browser import driver
+    
+    try:
+        # Try to find an element with the given text
+        element = driver.find_element_by_xpath(f"//*[contains(text(), '{text_to_find}')]")
+        if not element:
+            return f"No element containing the text '{text_to_find}' was found."
+        
+        # Try to find URL directly from the element
+        href = element.get_attribute("href")
+        if href:
+            return f"URL found: {href}"
+        
+        # Try to find a parent that is a link
+        parent = element.find_element_by_xpath("./ancestor::a")
+        if parent:
+            href = parent.get_attribute("href")
+            if href:
+                return f"URL found in parent element: {href}"
+        
+        # Try to find a child that is a link
+        child = element.find_element_by_xpath(".//a")
+        if child:
+            href = child.get_attribute("href")
+            if href:
+                return f"URL found in child element: {href}"
+        
+        # Méthode 4: Essayer le clic droit et "Copier l'adresse du lien"
+        actions = ActionChains(driver)
+        actions.context_click(element).perform()
+        
+        # Attendre un peu pour que le menu contextuel s'affiche
+        import time
+        time.sleep(1)
+        
+        # Essayer de trouver et cliquer sur "Copier l'adresse du lien" ou équivalent
+        # Note: Cette partie est très dépendante du navigateur et de la langue
+        copy_link_texts = ["Copy link address", "Copier l'adresse du lien", "Copy Link", "Copier le lien"]
+        
+        for text in copy_link_texts:
+            try:
+                link_option = driver.find_element(By.XPATH, f"//div[contains(text(), '{text}')]")
+                link_option.click()
+                return f"Action 'Copier l'adresse du lien' effectuée pour '{text_to_find}'"
+            except:
+                continue
+        
+        # Annuler le menu contextuel
+        webdriver.ActionChains(driver).send_keys(Keys.ESCAPE).perform()
+        
+        return f"Impossible de trouver un lien pour l'élément '{text_to_find}' avec les méthodes disponibles."
+    
+    except Exception as e:
+        return f"Erreur lors de la recherche du lien: {str(e)}"
+
+@tool
+def validate_json_results(result: dict) -> tuple[bool, str]:
+    """
+    Checks that the results do not contain generic placeholders.
+    Args:
+        result: The result to validate
+    Returns:
+        A tuple containing a boolean indicating if the result is valid and a message
+        explaining why the result is invalid if it is not valid.
+    """
+    if not result or not isinstance(result, dict):
+        return False, "Invalid result"
+    
+    if "top_models" not in result or len(result.get("top_models", [])) < 3:
+        return False, "Less than 3 models found"
+    
+    # Check for duplicate models
+    seen_models = set()
+    for model in result.get("top_models", []):
+        model_name = model.get("name", "").lower()
+        if model_name in seen_models:
+            return False, f"Duplicate model '{model.get('name')}' found. Please ensure each model is unique."
+        seen_models.add(model_name)
+    
+    # Check for generic names
+    generic_names = ["model a", "model b", "model c", "model 1", "model 2", "model 3", "model name", "unavailable"]
+    model_names = [m.get("name", "").lower() for m in result.get("top_models", [])]
+    if any(name in generic_names for name in model_names):
+        return False, "Generic model names detected"
+    
+    # Check for unwanted suffixes in model names
+    unwanted_suffix_pattern = r"\(.*\)$"
+    for model in result.get("top_models", []):
+        if re.search(unwanted_suffix_pattern, model.get("name", "")):
+            return False, f"Model name '{model.get('name')}' contains unwanted suffixes. Please remove them if you think they are not part of the model name. If it's a version number or a date, keep it."
+    
+    # Check for generic URLs
+    generic_urls = ["example.com", "example.org"]
+    model_urls = [m.get("url", "").lower() for m in result.get("top_models", []) if m.get("url") is not None]
+    if any(generic in url for url in model_urls for generic in generic_urls):
+        return False, "Generic URLs detected"
+    
+    # Check for submatch between model name and URL
+    for model in result.get("top_models", []):
+        name = model.get("name", "").lower()
+        url = model.get("url")
+        
+        # Skip validation if URL is None or empty - this is acceptable, so no warning
+        if not url:
+            continue
+        
+        url = url.lower()
+        if url and not any(name[i:i+4] in url for i in range(len(name) - 3)):
+            return False, f"URL for model '{model.get('name')}' does not have a valid submatch with the name. This is probably a wrong URL. Please check the URL and try again."
+    
+    # Check the evaluation criterion
+    if "evaluation_criteria" not in result or len(result.get("evaluation_criteria", "")) < 10:
+        return False, "Evaluation criterion missing or too short"
+    
+    return True, "Valid results"
+
+@tool
+def find_model_links(model_name: str) -> str:
+    """
+    Search for links that might point to a model based on their URL
+    and their match with the model name.
+    Args:
+        model_name: The name of the model to search for
+    
+    Returns:
+        A list of potential links to the model
+    """
+    from src.agents.browser import driver
+    try:
+        # 1. Retrieve all links on the page
+        all_links = driver.find_elements(By.TAG_NAME, "a")
+        if not all_links:
+            return "No links were found on the page."
+        
+        # 2. Known patterns for model repositories
+        model_url_patterns = [
+            r'huggingface\.co/[^/]+/[^/]+',  # Hugging Face model repo
+            r'github\.com/[^/]+/[^/]+',      # GitHub repo
+        ]
+        
+        model_links = []
+        model_name_lower = model_name.lower()
+        
+        for link in all_links:
+            try:
+                # Check if the link is visible and has an href attribute
+                if not link.is_displayed() or not link.get_attribute('href'):
+                    continue
+                
+                link_url = link.get_attribute('href')
+                link_text = link.text.strip()
+                
+                # Ignore links to non-relevant resources
+                if link_url.endswith(('.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.ico', '.css', '.js')):
+                    continue
+                
+                # Check if the URL matches a known pattern
+                matches_pattern = any(re.search(pattern, link_url, re.IGNORECASE) for pattern in model_url_patterns)
+                
+                if matches_pattern:
+                    # Check for a 3-character submatch between the model name and the URL
+                    url_lower = link_url.lower()
+                    has_submatch = False
+                    
+                    # Search for a 3-character submatch in the model name
+                    for i in range(len(model_name_lower) - 4):
+                        if model_name_lower[i:i+5] in url_lower and model_name_lower[i:i+5] in link_text.lower():
+                            has_submatch = True
+                            break
+
+                    if has_submatch:
+                        # Calculate the confidence based on character matches
+                        confidence = sum(1 for c in model_name_lower if c in link_text.lower())
+                        model_links.append({
+                            'url': link_url,
+                            'text': link_text,
+                            'confidence': confidence
+                        })
+            except Exception as e:
+                continue  # Ignore errors and continue
+        
+        # 3. Format the result
+        if not model_links:
+            return f"No potential links to the model '{model_name}' were found."
+        
+        result = f"Found {len(model_links)} potential links for the model '{model_name}':\n\n"
+        
+        for i, link in enumerate(model_links):
+            result += f"Candidate {i+1}:\n"
+            result += f"URL: {link['url']}\n"
+            result += f"Text: {link['text']}\n"
+            result += f"Confidence: {link['confidence']}\n\n"
+        
+        # 4. Suggest the best candidate (the one with the highest confidence)
+        if model_links:
+            best_candidate = max(model_links, key=lambda x: x['confidence'])
+            result += f"Best candidate for '{model_name}':\nURL: {best_candidate['url']}\nText: {best_candidate['text']} "
+        
+        return result
+    except Exception as e:
+        return f"Error while searching for links for the model '{model_name}': {str(e)}"
+
+@tool
+def click_at_coordinates(x: int, y: int) -> str:
+    """
+    Clicks at the specified x,y coordinates on the page.
+    This is useful when other targeting methods fail or when dealing with complex UI elements.
+    
+    Args:
+        x: The x-coordinate to click at
+        y: The y-coordinate to click at
+        
+    Returns:
+        A message confirming the click action
+    """
+    from src.agents.browser import driver
+    
+    try:
+        # Using ActionChains for precise coordinate clicks
+        actions = ActionChains(driver)
+        actions.move_by_offset(x, y).click().perform()
+        actions.reset_actions()  # Reset position after click
+        
+        # Alternative approach using Helium
+        # helium.click_at_point(x, y)
+        
+        time.sleep(1)  # Wait a moment for any reactions to the click
+        return f"Successfully clicked at coordinates ({x}, {y})"
+    except Exception as e:
+        return f"Failed to click at coordinates ({x}, {y}): {str(e)}" 

src/file_utils.py

@@ -0,0 +1,316 @@
+"""
+Utilities for file management.
+"""
+import json
+import os
+import datetime
+import shutil
+import time
+import random
+import tempfile
+import logging
+from filelock import FileLock
+
+logger = logging.getLogger("leaderboard-parser")
+
+def save_results(results, file_path):
+    """
+    Save results to a JSON file.
+    
+    Args:
+        results: The results to save
+        file_path: The path to the file
+    """
+    with open(file_path, "w") as f:
+        json.dump(results, f, indent=2)
+
+
+def create_category_slug(category_name):
+    """
+    Creates a slug from a category name.
+    The slug uses only hyphens as separators (no underscore).
+    
+    Args:
+        category_name: The category name
+        
+    Returns:
+        The category slug
+    """
+    if not category_name:
+        return ""
+    # Convert to lowercase and replace spaces with hyphens
+    # Ensure no underscores are used in the category slug
+    return category_name.lower().replace(" ", "-").replace("_", "-")
+
+
+def create_combined_id(category, uid):
+    """
+    Creates a normalized combined identifier from a category and UID.
+    First normalizes the category using create_category_slug.
+    
+    Args:
+        category: The category name
+        uid: The UID of the leaderboard
+        
+    Returns:
+        The combined identifier in the format category_slug_uid
+    """
+    normalized_category = create_category_slug(category)
+    return f"{normalized_category}_{uid}"
+
+
+def validate_leaderboard_result(result):
+    """
+    Validates and corrects if necessary a leaderboard result to ensure identifier consistency.
+    
+    This function checks:
+    1. That 'uid' is present and correctly formatted (category_original_uid)
+    2. That 'original_uid' is present
+    3. That 'category' is present and normalized
+    4. That 'uid' corresponds to the combination of category and original_uid
+    
+    Args:
+        result: The leaderboard result to validate (dict)
+        
+    Returns:
+        The validated and corrected result, or None if validation is impossible
+    """
+    if not isinstance(result, dict):
+        logger.error(f"Validation error: the result is not a dictionary")
+        return None
+        
+    # Check if required fields are present
+    if "original_uid" not in result:
+        logger.error(f"Validation error: original_uid missing from result")
+        return None
+    
+    if "category" not in result:
+        logger.error(f"Validation error: category missing from result")
+        return None
+    
+    original_uid = result["original_uid"]
+    category = result["category"]
+    
+    # Normalize the category if necessary
+    normalized_category = create_category_slug(category)
+    if normalized_category != category:
+        logger.warning(f"Category not normalized: '{category}' -> '{normalized_category}'")
+        result["category"] = normalized_category
+    
+    # Recalculate the correct combined uid
+    correct_uid = create_combined_id(normalized_category, original_uid)
+    
+    # Check if existing uid is correct
+    if "uid" not in result:
+        logger.warning(f"uid missing, adding calculated uid: {correct_uid}")
+        result["uid"] = correct_uid
+    elif result["uid"] != correct_uid:
+        logger.warning(f"uid inconsistent: '{result['uid']}' does not match '{correct_uid}', correction applied")
+        result["uid"] = correct_uid
+    
+    return result
+
+
+def load_and_validate_results(file_path):
+    """
+    Loads results from the file without strict validation.
+    
+    Args:
+        file_path: Path to the results file
+        
+    Returns:
+        List of results, or empty list in case of error
+    """
+    try:
+        # Load results from the file
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                results_data = json.load(f)
+        except (FileNotFoundError, json.JSONDecodeError) as e:
+            logger.warning(f"Unable to load file {file_path}: {str(e)}")
+            return []
+            
+        # Convert from dict with "leaderboards" to array if necessary
+        if isinstance(results_data, dict) and "leaderboards" in results_data:
+            array_results = []
+            for uid, item in results_data["leaderboards"].items():
+                item_copy = item.copy()
+                item_copy["uid"] = uid
+                array_results.append(item_copy)
+            results_data = array_results
+        
+        # Ensure results_data is a list
+        if not isinstance(results_data, list):
+            logger.warning(f"Invalid data format in {file_path}, initializing empty list")
+            return []
+        
+        # Sort results
+        results_data.sort(key=lambda x: (x.get("category", ""), x.get("original_uid", "")))
+        
+        logger.info(f"Load successful: {len(results_data)} results")
+        return results_data
+        
+    except Exception as e:
+        logger.error(f"Error loading results: {str(e)}")
+        return []
+
+
+def update_leaderboard_result(leaderboard_result, file_path, max_wait_seconds=30):
+    """
+    Updates a leaderboard result in the specified file.
+    If an entry with the same uid already exists, it is updated.
+    Otherwise, a new entry is added.
+    
+    Args:
+        leaderboard_result: The leaderboard result to update (must contain a uid)
+        file_path: Path to the results file
+        max_wait_seconds: Maximum wait time for file lock (in seconds)
+        
+    Returns:
+        Updated results list or None in case of error
+    """
+    if not leaderboard_result or "uid" not in leaderboard_result:
+        logger.error("Unable to update: invalid or missing leaderboard result or uid")
+        return None
+        
+    # Create parent directory if necessary
+    os.makedirs(os.path.dirname(file_path), exist_ok=True)
+    
+    # Use a lock to avoid concurrent writes
+    lock_path = f"{file_path}.lock"
+    lock = FileLock(lock_path, timeout=max_wait_seconds)
+    
+    try:
+        with lock:
+            # Load existing results
+            current_results = load_and_validate_results(file_path)
+            
+            # Index by uid for easy update
+            results_by_uid = {r.get("uid", ""): r for r in current_results if "uid" in r}
+            
+            # Update or add result
+            uid = leaderboard_result["uid"]
+            if uid in results_by_uid:
+                # Update existing result
+                results_by_uid[uid].update(leaderboard_result)
+                logger.info(f"Result updated for uid: {uid}")
+            else:
+                # Add new result
+                results_by_uid[uid] = leaderboard_result
+                logger.info(f"New result added for uid: {uid}")
+                
+            # Convert to list for writing
+            updated_results = list(results_by_uid.values())
+            
+            # Sort results
+            updated_results.sort(key=lambda x: (x.get("category", ""), x.get("original_uid", "")))
+            
+            # Write to temporary file then rename for atomicity
+            fd, temp_path = tempfile.mkstemp(dir=os.path.dirname(file_path))
+            try:
+                with os.fdopen(fd, 'w', encoding='utf-8') as f:
+                    json.dump(updated_results, f, indent=2, ensure_ascii=False)
+                    
+                # Replace original file with temporary file
+                shutil.move(temp_path, file_path)
+                logger.info(f"File updated successfully: {file_path}")
+                
+                return updated_results
+            except Exception as e:
+                # Clean up in case of error
+                if os.path.exists(temp_path):
+                    os.unlink(temp_path)
+                raise e
+                
+    except Exception as e:
+        logger.error(f"Error updating file {file_path}: {str(e)}")
+        return None
+
+
+def split_combined_id(combined_id):
+    """
+    Splits a combined identifier (category_uid) into its components.
+    Uses only the first underscore "_" as separator.
+    
+    Args:
+        combined_id: The combined identifier (category_uid)
+        
+    Returns:
+        A tuple (category, uid) or (None, combined_id) if no underscore
+    """
+    if not combined_id:
+        return None, None
+    
+    # Search for the first underscore to separate category and uid
+    parts = combined_id.split("_", 1)
+    if len(parts) == 2:
+        return parts[0], parts[1]
+    else:
+        # If no underscore, consider it as just a uid without category
+        return None, combined_id
+
+
+def format_datetime(dt_str):
+    """
+    Format a datetime string to a human readable format.
+    
+    Args:
+        dt_str: The datetime string to format
+        
+    Returns:
+        A formatted datetime string
+    """
+    try:
+        # Check if input is already a datetime object
+        if isinstance(dt_str, datetime.datetime):
+            dt = dt_str
+        else:
+            # Convert ISO format to datetime object
+            # Handle different formats of ISO dates including fractional seconds and timezone
+            try:
+                dt = datetime.datetime.fromisoformat(dt_str)
+            except ValueError:
+                # Handle other common formats
+                formats = [
+                    "%Y-%m-%dT%H:%M:%S.%f%z",
+                    "%Y-%m-%dT%H:%M:%S.%f",
+                    "%Y-%m-%dT%H:%M:%S%z",
+                    "%Y-%m-%dT%H:%M:%S",
+                    "%Y-%m-%d %H:%M:%S",
+                    "%Y-%m-%d"
+                ]
+                
+                for fmt in formats:
+                    try:
+                        dt = datetime.datetime.strptime(dt_str, fmt)
+                        break
+                    except ValueError:
+                        continue
+                else:
+                    # If no format matches
+                    return dt_str
+                    
+        # Format the datetime object
+        return dt.strftime("%d/%m/%Y à %H:%M:%S")
+    except (ValueError, TypeError) as e:
+        print(f"Error formatting date {dt_str}: {e}")
+        return dt_str
+
+
+def clean_output_files(results_file):
+    """
+    Clean the output files, but keep a backup of the original.
+    
+    Args:
+        results_file: The results file to clean
+    """
+    # If results file exists, make a backup
+    if os.path.exists(results_file):
+        backup_file = f"{results_file}.backup"
+        shutil.copy2(results_file, backup_file)
+        print(f"Backup of {results_file} created in {backup_file}")
+        
+        # Create an empty results file
+        with open(results_file, "w") as f:
+            json.dump([], f, indent=2)
+        print(f"File {results_file} cleaned") 

src/hub_utils.py

@@ -0,0 +1,175 @@
+"""
+Utilities for interacting with the Hugging Face Hub.
+"""
+import os
+from huggingface_hub import HfApi, login, hf_hub_download
+
+
+def upload_to_hub(to_parse_file, results_file, repo_id=None):
+    """
+    Uploads files to the Hugging Face Hub.
+    
+    Args:
+        to_parse_file: Path to the categories file
+        results_file: Path to the results file
+        repo_id: Hub repository ID
+        
+    Returns:
+        True if upload succeeded, False otherwise
+    """
+    try:
+        # Use environment variable HUGGING_FACE_STORAGE_REPO if available
+        # Otherwise, use default value
+        if repo_id is None:
+            repo_id = os.getenv("HUGGING_FACE_STORAGE_REPO", "leaderboard-explorer/leaderboard_explorer")
+            if os.getenv("HUGGING_FACE_STORAGE_REPO"):
+                print(f"Using target dataset specified in HUGGING_FACE_STORAGE_REPO: {repo_id}")
+            else:
+                print(f"No target dataset specified, using default value: {repo_id}")
+        
+        # Check if token is available
+        token = os.getenv("HUGGING_FACE_HUB_TOKEN")
+        if not token:
+            print("ERROR: Environment variable HUGGING_FACE_HUB_TOKEN is not defined.")
+            return False
+        
+        # Connect to Hub
+        print("Connecting to Hugging Face Hub...")
+        login(token=token)
+        api = HfApi()
+        
+        # Upload JSON files
+        print(f"\n--- UPLOADING CATEGORIES FILE ---")
+        print(f"Local file: {to_parse_file}")
+        print(f"Destination: {repo_id}/best_model_for_category_list.json")
+        print(f"Uploading...")
+        
+        try:
+            api.upload_file(
+                path_or_fileobj=to_parse_file,
+                path_in_repo="best_model_for_category_list.json",
+                repo_id=repo_id,
+                repo_type="dataset",
+                commit_message="Update leaderboard categories"
+            )
+            print(f"Upload of {to_parse_file} successful!")
+        except Exception as e:
+            print(f"Note when uploading {to_parse_file}: {e}")
+            if "No files have been modified since last commit" in str(e):
+                print("→ The categories file is identical to the one already on the Hub. No changes needed.")
+            else:
+                print(f"→ ERROR: Upload failed for another reason.")
+                raise e
+        
+        print(f"\n--- UPLOADING RESULTS FILE ---")
+        print(f"Local file: {results_file}")
+        print(f"Destination: {repo_id}/best_model_for_results.json")
+        print(f"Uploading...")
+        
+        try:
+            api.upload_file(
+                path_or_fileobj=results_file,
+                path_in_repo="best_model_for_results.json",
+                repo_id=repo_id,
+                repo_type="dataset",
+                commit_message="Update leaderboard results"
+            )
+            print(f"Upload of {results_file} successful!")
+        except Exception as e:
+            print(f"Note when uploading {results_file}: {e}")
+            if "No files have been modified since last commit" in str(e):
+                print("→ The results file is identical to the one already on the Hub. No changes needed.")
+            else:
+                print(f"→ ERROR: Upload failed for another reason.")
+                raise e
+        
+        print(f"\nUpload operation completed: files have been processed!")
+        return True
+    except Exception as e:
+        print(f"GENERAL ERROR during file upload to Hub: {e}")
+        return False
+
+
+def download_from_hub(repo_id=None):
+    """
+    Downloads files from the Hugging Face Hub.
+    
+    Args:
+        repo_id: Hub repository ID
+        
+    Returns:
+        True if download succeeded, False otherwise
+    """
+    try:
+        # Use environment variable HUGGING_FACE_STORAGE_REPO if available
+        # Otherwise, use default value
+        if repo_id is None:
+            repo_id = os.getenv("HUGGING_FACE_STORAGE_REPO", "leaderboard-explorer/leaderboard_explorer")
+            if os.getenv("HUGGING_FACE_STORAGE_REPO"):
+                print(f"Using source dataset specified in HUGGING_FACE_STORAGE_REPO: {repo_id}")
+            else:
+                print(f"No source dataset specified, using default value: {repo_id}")
+        
+        # Check if token is available
+        token = os.getenv("HUGGING_FACE_HUB_TOKEN")
+        if not token:
+            print("ERROR: Environment variable HUGGING_FACE_HUB_TOKEN is not defined.")
+            return False
+        
+        # Connect to Hub
+        login(token=token)
+        
+        # Create data directory if it doesn't exist
+        script_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        data_dir = os.path.join(script_dir, "data")
+        os.makedirs(data_dir, exist_ok=True)
+        
+        # List of required and optional files
+        required_files = [
+            "final_leaderboards.json",
+            "best_model_for_category_list.json"
+        ]
+        
+        optional_files = [
+            "best_model_for_results.json"
+        ]
+        
+        # Download required files first
+        for filename in required_files:
+            local_path = os.path.join(data_dir, filename)
+            try:
+                # Download file
+                print(f"Downloading {filename} from {repo_id}...")
+                hf_hub_download(
+                    repo_id=repo_id,
+                    filename=filename,
+                    repo_type="dataset",
+                    local_dir=data_dir,
+                    local_dir_use_symlinks=False
+                )
+                print(f"File {filename} successfully downloaded to {local_path}")
+            except Exception as e:
+                print(f"ERROR: Unable to download required file {filename}: {e}")
+                return False
+        
+        # Download optional files next
+        for filename in optional_files:
+            local_path = os.path.join(data_dir, filename)
+            try:
+                print(f"Downloading {filename} from {repo_id}...")
+                hf_hub_download(
+                    repo_id=repo_id,
+                    filename=filename,
+                    repo_type="dataset",
+                    local_dir=data_dir,
+                    local_dir_use_symlinks=False
+                )
+                print(f"File {filename} successfully downloaded to {local_path}")
+            except Exception as e:
+                print(f"WARNING: Unable to download optional file {filename}: {e}")
+                print(f"This is not a problem, a new file will be created if necessary.")
+        
+        return True
+    except Exception as e:
+        print(f"ERROR during file download from Hub: {e}")
+        return False 

src/leaderboard_processor.py

@@ -0,0 +1,158 @@
+"""
+Leaderboard processing.
+"""
+import datetime
+import os
+from src.agents.parser.parser_agent import process_leaderboard
+from src.file_utils import create_category_slug, split_combined_id
+
+
+def normalize_category(category_name):
+    """
+    Normalizes a category name by replacing spaces and underscores with hyphens and converting to lowercase.
+    
+    Args:
+        category_name: The category name to normalize
+        
+    Returns:
+        The normalized category
+    """
+    # Use the create_category_slug function from file_utils.py
+    return create_category_slug(category_name)
+
+
+def process_single_leaderboard(uid, host, model, index, all_results, additional_rules=None, category=None):
+    """
+    Process a single leaderboard and update the results.
+    
+    Args:
+        uid: The UID of the leaderboard to process
+        host: The URL of the leaderboard
+        model: The model to use
+        index: The index of the leaderboard
+        all_results: The list of all results
+        additional_rules: Additional specific rules for this leaderboard
+        category: The category of the leaderboard (for combined identifier)
+        
+    Returns:
+        The updated list of results
+    """
+    print(f"\n\nProcessing leaderboard: {uid} - {host}")
+    if additional_rules:
+        print(f"Additional rules for this leaderboard: {additional_rules}")
+    if category:
+        normalized_category = normalize_category(category)
+        print(f"Category: {category} (normalized: {normalized_category})")
+    else:
+        normalized_category = None
+    
+    # Get the maximum number of retries from environment variables
+    max_retries = int(os.getenv("LEADERBOARD_MAX_RETRIES", "3"))
+    print(f"Maximum number of retries configured: {max_retries}")
+    
+    attempt = 0
+    last_error = None
+    
+    # Try to process the leaderboard multiple times
+    while attempt < max_retries:
+        attempt += 1
+        if attempt > 1:
+            print(f"Retry attempt {attempt}/{max_retries} for leaderboard {uid} - {host}")
+        
+        # Process the leaderboard
+        result = process_leaderboard(host, model, index, uid, additional_rules)
+        
+        # If the parsing was successful or we've reached the maximum number of retries
+        if result.get("parsing_status") == "success" or attempt >= max_retries:
+            break
+        
+        # If there was an error, save it for later
+        if result.get("parsing_status") == "error":
+            last_error = result.get("parsing_message", "Unknown error")
+            print(f"Error during attempt {attempt}: {last_error}")
+        
+    # Get parsing date from result or generate a new one if not available
+    if result and "parsed_at" in result:
+        parsed_at = result["parsed_at"]
+    else:
+        # Fallback to current time if not provided by process_leaderboard
+        now = datetime.datetime.now()
+        parsed_at = now.isoformat()
+    
+    # Create combined ID if category is provided
+    result_uid = uid
+    if normalized_category:
+        # Format of the combined UID: category_uid
+        # The category is already normalized (slugified) by normalize_category
+        # The underscore "_" is the ONLY separator between the category and the UID
+        result_uid = f"{normalized_category}_{uid}"
+    
+    # Create base result object with uid, host, and thumbnail
+    leaderboard_result = {
+        "uid": result_uid,
+        "original_uid": uid,
+        "category": normalized_category,
+        "host": host,
+        "parsing_status": "rejected",  # Default to rejected
+        "parsed_at": parsed_at
+    }
+    
+    # Check if we have valid results
+    valid_result = False
+    if result and result.get("results"):
+        if isinstance(result["results"], dict):
+            # Check if we have top models with required fields
+            if "top_models" in result["results"] and len(result["results"]["top_models"]) > 0:
+                valid_models = True
+                for model_info in result["results"]["top_models"]:
+                    # Each model must have at least rank and name
+                    if not model_info.get("rank") or not model_info.get("name"):
+                        valid_models = False
+                        break
+                
+                # Check if we have evaluation criteria
+                if valid_models and "evaluation_criteria" in result["results"] and result["results"]["evaluation_criteria"]:
+                    valid_result = True
+        else:
+            print(f"Invalid results format: {type(result['results']).__name__}, expected dict")
+    else:
+        print(f"Missing or empty results in agent response")
+    
+    # If we have valid results, extract the data
+    if valid_result:
+        leaderboard_result["parsing_status"] = "approved"
+        leaderboard_result["top_models"] = []
+        leaderboard_result["evaluation_criteria"] = result["results"]["evaluation_criteria"]
+        
+        # Extract top models
+        for model_info in result["results"]["top_models"]:
+            model_entry = {
+                "rank": model_info.get("rank"),
+                "name": model_info.get("name"),
+                "url": model_info.get("url", None)
+            }
+            leaderboard_result["top_models"].append(model_entry)
+    else:
+        print(f"Leaderboard rejected: {uid} - Incomplete or invalid information")
+    
+    # Check if this UID already exists in the results
+    for i, existing_result in enumerate(all_results):
+        if existing_result["uid"] == result_uid:
+            # Replace the existing result
+            all_results[i] = leaderboard_result
+            print(f"Result updated for UID: {result_uid}")
+            return all_results
+    
+    # ADDITIONAL CHECK: Make sure there's no confusion with other categories
+    # for the same original_uid
+    for existing_result in all_results:
+        if existing_result["original_uid"] == uid and existing_result["category"] != normalized_category:
+            print(f"WARNING: A result already exists for original_uid {uid} but with a different category:")
+            print(f"  - Existing category: {existing_result['category']}, UID: {existing_result['uid']}")
+            print(f"  - New category: {normalized_category}, UID: {result_uid}")
+            # We continue anyway, as it's a valid case to have the same leaderboard in different categories
+    
+    # If we get here, this is a new result
+    all_results.append(leaderboard_result)
+    print(f"New result added for UID: {result_uid}")
+    return all_results 

src/processor.py

@@ -0,0 +1,414 @@
+"""
+Leaderboard processing module for the leaderboard parser.
+This module contains the main functions for processing leaderboards.
+"""
+import json
+import os
+import datetime
+import logging
+import time
+import argparse
+from typing import Dict, Any, List, Tuple, Optional
+
+# Import functions from other modules
+from src.file_utils import save_results, format_datetime, clean_output_files, update_leaderboard_result
+from src.file_utils import create_category_slug, split_combined_id, create_combined_id
+from src.file_utils import load_and_validate_results, validate_leaderboard_result
+from src.hub_utils import upload_to_hub, download_from_hub
+from src.leaderboard_processor import process_single_leaderboard
+from src.agents.parser.parser_agent import get_default_model
+from src.agents.browser import cleanup_browser
+
+# Configure logger
+logger = logging.getLogger("leaderboard-parser")
+
+# Update state variables in server module
+def update_server_status(status, error=None):
+    """
+    Updates the server status.
+    
+    Args:
+        status: The new status ('idle', 'running', 'completed', 'failed')
+        error: The error message in case of failure
+    """
+    try:
+        from src.server import processing_status, processing_error
+        
+        # Update global variables in server.py
+        globals()['processing_status'] = status
+        globals()['processing_error'] = error
+        
+        # Update server module variables
+        import src.server
+        src.server.processing_status = status
+        src.server.processing_error = error
+    except ImportError:
+        # In non-server mode, these variables don't exist
+        pass
+
+def process_leaderboards(args_dict=None) -> Tuple[bool, str]:
+    """
+    Process leaderboards with the given arguments.
+    Returns a tuple of (success, message)
+    """
+    # Update status
+    update_server_status("running")
+    
+    # Set default arguments if none provided
+    if args_dict is None:
+        args_dict = {"local_only": False}
+    
+    # Create an argparse.Namespace object from the dictionary
+    args = argparse.Namespace(**args_dict)
+    
+    try:
+        # Ensure we're in the correct directory
+        script_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        os.chdir(script_dir)
+        
+        # Verify that the HF token is set
+        if not os.environ.get("HUGGING_FACE_HUB_TOKEN") and not args.local_only:
+            raise ValueError("HUGGING_FACE_HUB_TOKEN environment variable is not set!")
+        
+        # Use default paths for category list and leaderboards
+        category_list_file = "data/best_model_for_category_list.json"
+        leaderboards_file = "data/final_leaderboards.json"
+        results_file = "data/best_model_for_results.json"
+        
+        # Clean if requested
+        if getattr(args, "clean", False):
+            clean_output_files(results_file)
+        
+        # Check if we're just uploading
+        if getattr(args, "upload_only", False):
+            upload_to_hub(to_parse_file=category_list_file, results_file=results_file)
+            update_server_status("completed")
+            return True, "Upload completed successfully"
+        
+        # Download data from the Hub if not in local-only mode
+        if not getattr(args, "local_only", False):
+            download_from_hub()
+        
+        # Just before the line that generates the error
+        logger.info(f"Starting leaderboard processing")
+        
+        # Load the category list and leaderboards data
+        try:
+            with open(category_list_file, "r", encoding="utf-8") as f:
+                category_list = json.load(f)
+            
+            with open(leaderboards_file, "r", encoding="utf-8") as f:
+                leaderboards = json.load(f)
+                
+            # Create a mapping UID -> HOST for all leaderboards
+            uid_to_host = {lb["uid"]: lb["host"] for lb in leaderboards if "uid" in lb and "host" in lb}
+            logger.info(f"Loaded {len(uid_to_host)} UID -> HOST mappings from {leaderboards_file}")
+        except FileNotFoundError as e:
+            update_server_status("failed", str(e))
+            return False, f"File not found: {e}"
+        
+        # Load existing results if any
+        try:
+            logger.info(f"Loading and validating results from {results_file}")
+            results_data = load_and_validate_results(results_file)
+            all_results = results_data
+            logger.info(f"Loaded and validated {len(all_results)} existing results")
+        except Exception as e:
+            logger.warning(f"Error loading results: {str(e)}")
+            results_data = []
+            all_results = []
+        
+        # Create a map of combined UIDs to their complete data (for checking parsing date)
+        processed_results_map = {}
+        for result in results_data:
+            if "uid" in result:
+                processed_results_map[result["uid"]] = result
+        
+        # Get reprocessing interval from environment variable (in hours)
+        # Default value: 24 hours
+        reprocess_interval_hours = int(os.getenv("LEADERBOARD_REPROCESS_INTERVAL_HOURS", "24"))
+        
+        # Maximum age without update (in seconds)
+        max_age_seconds = reprocess_interval_hours * 60 * 60
+        logger.info(f"Leaderboard reprocessing interval: {reprocess_interval_hours} hours")
+        
+        # Current date and time
+        now = datetime.datetime.now()
+        print(f"Current system date: {now.isoformat()} - Readable format: {format_datetime(now.isoformat())}")
+        
+        # Get the default agent
+        model = get_default_model()
+        
+        # Collect all leaderboards to process
+        leaderboards_to_process = []
+        force_retry_leaderboards = []
+        
+        # Add logs for debugging
+        logger.info(f"Available categories: {len(category_list)}")
+        logger.info(f"Available leaderboards: {len(uid_to_host)}")
+        logger.info(f"Sample of available UIDs: {list(uid_to_host.keys())[:5]}")
+        
+        # Check if a specific category is requested
+        target_category = getattr(args, "force_retry_category", None)
+        target_uid = getattr(args, "force_retry_uid", None)
+        
+        # Exclusive mode (only process specified leaderboards)
+        exclusive_mode = target_category is not None or target_uid is not None
+        
+        if target_category:
+            logger.info(f"Force retry category mode enabled (exclusive): {target_category}")
+            
+        if target_uid:
+            logger.info(f"Force retry UID mode enabled (exclusive): {target_uid}")
+        
+        # Process leaderboards
+        for category in category_list:
+            category_name = category["category"]
+            normalized_category = create_category_slug(category_name)
+            
+            # If in specific category mode and this is not the target category, skip to the next
+            if target_category and target_category != normalized_category:
+                logger.info(f"Category {category_name} (normalized: {normalized_category}) ignored - Does not match target category {target_category}")
+                continue
+                
+            # ADDITIONAL SAFETY: Reload data from file before each new category
+            # This ensures there is no contamination between categories
+            try:
+                logger.info(f"Reloading data from file before processing category: {category_name}")
+                all_results = load_and_validate_results(results_file)
+                logger.info(f"Data reloaded successfully: {len(all_results)} results available")
+            except Exception as e:
+                logger.warning(f"Unable to reload data before category {category_name}: {str(e)}")
+                # In case of error, keep existing data if possible
+                if not isinstance(all_results, list):
+                    all_results = []
+            
+            # Check if category has leaderboards
+            if "leaderboards" not in category or not isinstance(category["leaderboards"], list):
+                logger.warning(f"Category '{category_name}' has no leaderboards or incorrect format.")
+                continue
+            
+            # Process each leaderboard in the category
+            for leaderboard in category["leaderboards"]:
+                if "uid" not in leaderboard:
+                    logger.warning(f"Leaderboard in category '{category_name}' has no UID.")
+                    continue
+                
+                leaderboard_uid = leaderboard["uid"]
+                
+                # In specific UID mode, ignore all other leaderboards
+                if target_uid and target_uid != leaderboard_uid:
+                    logger.info(f"Leaderboard {leaderboard_uid} ignored - Does not match target UID {target_uid}")
+                    continue
+                
+                # Get additional rules if available
+                additional_rules = leaderboard.get("additionnal_agent_rules", None)
+                
+                # Check if we should force processing this leaderboard
+                # Using the new distinct options
+                force_retry_uid = getattr(args, "force_retry_uid", None) == leaderboard_uid
+                force_retry_category = getattr(args, "force_retry_category", None) == normalized_category
+                
+                # Support for the old option for backward compatibility (to be removed later)
+                legacy_force_retry = False
+                if hasattr(args, "force_retry") and getattr(args, "force_retry", None) is not None:
+                    legacy_force_retry = (
+                        getattr(args, "force_retry", None) == leaderboard_uid or
+                        getattr(args, "force_retry", None) == normalized_category
+                    )
+                    if legacy_force_retry:
+                        logger.warning("The --force-retry option is obsolete. Use --force-retry-uid or --force-retry-category instead.")
+                
+                # Combine different sources of force_retry
+                force_retry = force_retry_uid or force_retry_category or legacy_force_retry
+                
+                # Add explicit logs about the reason for force retry
+                if force_retry:
+                    if force_retry_uid:
+                        logger.info(f"Force retry enabled for leaderboard UID: {leaderboard_uid}")
+                    elif force_retry_category:
+                        logger.info(f"Force retry enabled for all leaderboards in category: {normalized_category}")
+                    elif legacy_force_retry:
+                        logger.info(f"Force retry enabled via the old --force-retry option for: {getattr(args, 'force_retry', None)}")
+                
+                # Search for the leaderboard URL in uid_to_host (direct dictionary lookup)
+                host = uid_to_host.get(leaderboard_uid)
+                
+                if not host:
+                    logger.warning(f"UID '{leaderboard_uid}' (category: {normalized_category}) not found in leaderboards.")
+                    # Show more information for debugging
+                    logger.debug(f"Total number of UIDs available: {len(uid_to_host)}")
+                    continue
+                
+                # Create combined identifier (category_uid)
+                # The category is already normalized by create_category_slug
+                combined_uid = create_combined_id(normalized_category, leaderboard_uid)
+                
+                # If force_retry is enabled, process the leaderboard without checking the time since last processing
+                if force_retry:
+                    logger.info(f"Force retry enabled for {combined_uid} - Processing forced independently of last processing date.")
+                    leaderboards_to_process.append({
+                        "uid": leaderboard_uid,
+                        "host": host,
+                        "category": normalized_category,
+                        "additional_rules": additional_rules,
+                        "force_retry": force_retry
+                    })
+                    continue  # Skip directly to the next leaderboard
+                
+                # Check if the leaderboard has already been processed recently
+                needs_reprocessing = True
+                if combined_uid in processed_results_map:
+                    # Check if the leaderboard has been processed within the interval
+                    result = processed_results_map[combined_uid]
+                    
+                    # If the --retry-rejected option is active and the status is "rejected", force reprocessing
+                    if getattr(args, "retry_rejected", False) and result.get("parsing_status") == "rejected":
+                        logger.info(f"Leaderboard {combined_uid} previously rejected, forced reprocessing with --retry-rejected.")
+                    elif "parsed_at" in result:
+                        try:
+                            # Convert parsing date to datetime object
+                            parsed_at = datetime.datetime.fromisoformat(result["parsed_at"])
+                            
+                            # Calculate time elapsed since last parsing
+                            time_diff = now - parsed_at
+                            
+                            # Add logs for debugging date checks
+                            logger.info(f"DEBUG: Current date: {now.isoformat()}")
+                            logger.info(f"DEBUG: Last parsing date: {parsed_at.isoformat()}")
+                            logger.info(f"DEBUG: Time difference in seconds: {time_diff.total_seconds()}")
+                            logger.info(f"DEBUG: Reprocessing threshold (seconds): {max_age_seconds}")
+                            
+                            # Strictly check if the duration in seconds is greater than the threshold
+                            time_seconds = time_diff.total_seconds()
+                            
+                            # If time elapsed is greater than max_age_seconds, reparse
+                            if time_seconds > max_age_seconds:
+                                needs_reprocessing = True
+                                print(f"\n\nLeaderboard {combined_uid} - {host} parsed more than {reprocess_interval_hours} hours ago ({format_datetime(result['parsed_at'])}), reprocessing necessary.")
+                            else:
+                                print(f"\n\nLeaderboard {combined_uid} - {host} already processed recently ({format_datetime(result['parsed_at'])}), moving to next. Age: {time_seconds} seconds (threshold: {max_age_seconds})")
+                                continue
+                        except (ValueError, TypeError):
+                            # If date is invalid, reprocess by precaution
+                            logger.info(f"Leaderboard {combined_uid} has an invalid processing date, reprocessing necessary.")
+                    else:
+                        # If parsing date is missing, reprocess by precaution
+                        logger.info(f"Leaderboard {combined_uid} has no processing date, reprocessing necessary.")
+                else:
+                    # If the leaderboard has never been processed, process it
+                    logger.info(f"New leaderboard {combined_uid} to process.")
+                
+                if needs_reprocessing or force_retry:
+                    leaderboards_to_process.append({
+                        "uid": leaderboard_uid,
+                        "host": host,
+                        "category": normalized_category,
+                        "additional_rules": additional_rules,
+                        "force_retry": force_retry
+                    })
+        
+        # Information on the number of leaderboards to process
+        logger.info(f"Total number of leaderboards to process: {len(leaderboards_to_process)}")
+        
+        # Process each leaderboard
+        for index, leaderboard_info in enumerate(leaderboards_to_process):
+            leaderboard_uid = leaderboard_info["uid"]
+            host = leaderboard_info["host"]
+            category_name = leaderboard_info["category"]
+            additional_rules = leaderboard_info["additional_rules"]
+            force_retry = leaderboard_info["force_retry"]
+            
+            # Process this leaderboard
+            logger.info(f"Processing leaderboard {index+1}/{len(leaderboards_to_process)}: {leaderboard_uid} (category: {category_name})")
+            
+            try:
+                # Force restart of browser every 2 leaderboards to avoid memory leaks
+                if index > 0 and index % 2 == 0:
+                    logger.info(f"Periodic browser cleanup after {index} leaderboards to avoid memory leaks")
+                    cleanup_browser()
+                    # Force garbage collection
+                    import gc
+                    gc.collect()
+                    # Small pause to let the system clean up
+                    time.sleep(3)
+                
+                # Process the leaderboard
+                all_results = process_single_leaderboard(
+                    leaderboard_uid, 
+                    host, 
+                    model, 
+                    index, 
+                    all_results, 
+                    additional_rules, 
+                    category_name
+                )
+                
+                # Add detailed logs for diagnosing problems
+                logger.info(f"Results after processing: {len(all_results)} elements")
+                # Search for results corresponding to the processed leaderboard
+                for idx, res in enumerate(all_results):
+                    if res.get("original_uid") == leaderboard_uid:
+                        logger.info(f"Found result {idx}: uid={res.get('uid')}, original_uid={res.get('original_uid')}, category={res.get('category')}")
+                
+                # Clean up after each processing
+                cleanup_browser()
+                
+                # Verify if the leaderboard exists with the exact normalized category
+                # MODIFICATION: Strict search by original_uid AND category
+                normalized_category_name = create_category_slug(category_name)
+                current_result = None
+                for result in all_results:
+                    # Always compare normalized categories to avoid format issues
+                    result_category = result.get("category", "")
+                    if result.get("original_uid") == leaderboard_uid and create_category_slug(result_category) == normalized_category_name:
+                        current_result = result
+                        logger.info(f"Found result for {leaderboard_uid}, category: {result.get('category')}")
+                        break
+                
+                # SUPPRESSION: No longer search for alternatives with only original_uid
+                # If result is not found, it's probably an error or processing failed
+                if not current_result:
+                    logger.error(f"RESULT NOT FOUND for {leaderboard_uid}, normalized_category: {normalized_category_name}")
+                    logger.error(f"Search for all results corresponding to this UID:")
+                    for res in all_results:
+                        if res.get("original_uid") == leaderboard_uid:
+                            logger.error(f"  - Result with category={res.get('category')}, uid={res.get('uid')}")
+                    logger.error(f"Leaderboard {leaderboard_uid} (category: {category_name}) not updated because result not found")
+                    continue
+                
+                # Update only this specific leaderboard in the results file
+                logger.info(f"Updating leaderboard {leaderboard_uid} (category: {category_name}) in file")
+                updated_results = update_leaderboard_result(current_result, results_file)
+                
+                # CORRECTION CRITIQUE: Update all_results list with file data
+                # to avoid desynchronization between file and in-memory list
+                all_results = updated_results
+                
+                # Update global result for next leaderboard
+                results_data = updated_results
+                
+                logger.info(f"Leaderboard {leaderboard_uid} (category: {category_name}) saved")
+                
+                # Upload to HF Hub after each leaderboard if not in local-only mode
+                if not getattr(args, "local_only", False):
+                    logger.info(f"Uploading results to HF Hub after processing leaderboard {leaderboard_uid}")
+                    try:
+                        upload_to_hub(to_parse_file=category_list_file, results_file=results_file)
+                        logger.info(f"Upload successful to HF Hub for leaderboard {leaderboard_uid}")
+                    except Exception as upload_err:
+                        logger.warning(f"Upload to HF Hub failed after processing leaderboard {leaderboard_uid}: {str(upload_err)}")
+            except Exception as e:
+                logger.error(f"Error processing leaderboard {leaderboard_uid} (category: {category_name}): {str(e)}")
+                continue
+        
+        # Final save not necessary as all leaderboards have already been updated individually
+        logger.info("Leaderboard processing completed")
+        
+        update_server_status("completed")
+        return True, "Processing completed successfully"
+    
+    except Exception as e:
+        update_server_status("failed", str(e))
+        logger.exception("Error processing leaderboards")
+        return False, f"Error processing leaderboards: {str(e)}" 

src/scheduler.py

@@ -0,0 +1,99 @@
+"""
+Scheduling module for the leaderboard parser.
+This module contains scheduling functions for periodic execution of leaderboard processing.
+"""
+import datetime
+import threading
+import time
+import logging
+import os
+
+# Initialize logger
+logger = logging.getLogger("leaderboard-parser")
+
+# Global variables for scheduler
+stop_thread = False
+last_run_time = None
+
+# Reference to the processing function (will be defined by initialize_scheduler)
+process_leaderboards_function = None
+
+def initialize_scheduler(process_function):
+    """
+    Initialize the scheduler with the leaderboard processing function.
+    
+    Args:
+        process_function: Function that processes leaderboards
+    """
+    global process_leaderboards_function
+    process_leaderboards_function = process_function
+    logger.info("Scheduler initialized with processing function")
+
+def scheduler_thread():
+    """Thread that checks when to run the leaderboard processing job"""
+    global stop_thread, last_run_time, process_leaderboards_function
+    
+    if not process_leaderboards_function:
+        logger.error("Scheduler has not been initialized with a processing function")
+        return
+    
+    logger.info("Scheduler thread started")
+    
+    # Get the reprocess interval from environment, default to 24 hours
+    interval_hours = int(os.environ.get("LEADERBOARD_REPROCESS_INTERVAL_HOURS", 24))
+    interval_seconds = interval_hours * 3600
+    
+    logger.info(f"Leaderboard reprocess interval set to {interval_hours} hours")
+    
+    while not stop_thread:
+        now = datetime.datetime.now()
+        
+        # If no previous run or if the interval has passed since last run
+        if last_run_time is None or (now - last_run_time).total_seconds() >= interval_seconds:
+            logger.info(f"{interval_hours} hours have passed since last run, executing the job")
+            
+            # Get the current status
+            from src.server import processing_status
+            
+            # If we're not already processing
+            if processing_status != "running":
+                # Run the processing job
+                last_run_time = now
+                success, message = process_leaderboards_function({"local_only": False})
+                logger.info(f"Processing job completed with status: {success}, message: {message}")
+            
+            # Wait at least 80% of the interval before checking again
+            # This prevents multiple executions and provides a buffer
+            time.sleep(interval_seconds * 0.8)
+        else:
+            # Calculate time until next run
+            seconds_until_next_run = interval_seconds - (now - last_run_time).total_seconds()
+            hours_until_next_run = seconds_until_next_run / 3600
+            
+            # Log progress every hour
+            if int(seconds_until_next_run) % 3600 < 10:  # Log within the first 10 seconds of each hour
+                logger.info(f"Next scheduled run in {hours_until_next_run:.1f} hours")
+            
+            # Sleep for a minute before checking again
+            time.sleep(60)
+
+def start_scheduler():
+    """Start the scheduler thread"""
+    global stop_thread
+    
+    # Reset stop flag
+    stop_thread = False
+    
+    # Start the scheduler thread
+    scheduler = threading.Thread(target=scheduler_thread)
+    scheduler.daemon = True
+    scheduler.start()
+    
+    logger.info("Scheduler thread started")
+    return scheduler
+
+def stop_scheduler():
+    """Stop the scheduler thread"""
+    global stop_thread
+    stop_thread = True
+    logger.info("Scheduler thread stop requested") 

src/server.py

@@ -0,0 +1,75 @@
+"""
+Module de serveur API pour le leaderboard parser.
+Ce module contient la configuration FastAPI et les endpoints pour le mode serveur.
+"""
+import datetime
+import threading
+import logging
+import os
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse
+from src.file_utils import format_datetime
+
+# Initialiser le logger
+logger = logging.getLogger("leaderboard-parser")
+
+# Variables globales pour suivre l'état du serveur
+processing_status = "idle"
+processing_error = None
+last_run_time = None
+
+# Initialiser l'application FastAPI
+app = FastAPI(title="Leaderboard Parser API")
+
+# Cette fonction sera importée depuis main.py
+process_leaderboards = None
+
+def initialize_server(process_function):
+    """
+    Initialise le serveur avec la fonction de traitement des leaderboards.
+    Cette fonction doit être appelée avant de démarrer le serveur.
+    
+    Args:
+        process_function: Fonction qui traite les leaderboards
+    """
+    global process_leaderboards
+    process_leaderboards = process_function
+    logger.info("Serveur initialisé avec la fonction de traitement")
+
+# Endpoints API
+@app.get("/")
+async def root():
+    """Root endpoint returning basic info"""
+    return {
+        "name": "Leaderboard Parser API",
+        "status": "running",
+        "version": "1.0.0"
+    }
+
+@app.get("/status")
+async def get_status():
+    """Get the current status of the parser"""
+    global processing_status, last_run_time, processing_error
+    
+    return {
+        "status": processing_status,
+        "last_run": format_datetime(last_run_time) if last_run_time else None,
+        "next_run": format_datetime(last_run_time + datetime.timedelta(hours=int(os.environ.get("LEADERBOARD_REPROCESS_INTERVAL_HOURS", 24)))) if last_run_time else None,
+        "error": processing_error
+    }
+
+@app.post("/run")
+async def trigger_run():
+    """Manually trigger a leaderboard processing run"""
+    global processing_status, process_leaderboards
+    
+    if not process_leaderboards:
+        raise HTTPException(status_code=500, detail="Server not properly initialized")
+    
+    if processing_status == "running":
+        raise HTTPException(status_code=409, detail="Processing is already running")
+    
+    # Start processing in a separate thread
+    threading.Thread(target=lambda: process_leaderboards()).start()
+    
+    return {"status": "started", "message": "Processing started"}