translate some comments in english

backend/clean_and_restart_eval.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-Script pour relancer l'évaluation LightEval avec un timeout personnalisé
+Script for relaunching LightEval evaluation with a custom timeout
 """
 import os
 import sys
@@ -9,7 +9,7 @@ import asyncio
 from pathlib import Path
 from datetime import datetime
 
-# Importer la tâche d'évaluation
+# Import evaluation task
 from tasks.evaluation_task import EvaluationTask, DEFAULT_EVALUATION_TIMEOUT
 
 
@@ -27,33 +27,33 @@ async def main(session_id, dataset_name, timeout=None):
         dataset_name: Nom du dataset à évaluer
         timeout: Timeout en secondes pour chaque évaluation de modèle (utilise la valeur par défaut si None)
     """
-    # Vérifier que le dossier de session existe
+    # Check that session folder exists
     session_dir = Path(f"uploaded_files/{session_id}")
     if not session_dir.exists():
         log(f"Erreur: Le dossier de session {session_id} n'existe pas")
         return 1
     
-    # Afficher le timeout utilisé
+    # Display used timeout
     timeout_value = timeout if timeout is not None else DEFAULT_EVALUATION_TIMEOUT
     log(f"Utilisation d'un timeout de {timeout_value} secondes pour l'évaluation")
     
-    # Créer une nouvelle tâche d'évaluation avec le timeout spécifié
+    # Create new evaluation task with specified timeout
     log("Initialisation d'une nouvelle tâche d'évaluation")
     evaluation_task = EvaluationTask(
         session_uid=session_id,
         dataset_name=dataset_name,
-        clean_old_results=True,  # Nettoyer automatiquement les anciens résultats
+        clean_old_results=True,  # Automatically clean old results
         timeout=timeout
     )
     
-    # Exécuter l'évaluation
+    # Run evaluation
     log("Démarrage de l'évaluation...")
     await evaluation_task.run()
     
-    # Vérifier les résultats
+    # Check results
     if evaluation_task.is_completed:
         log("Évaluation terminée avec succès")
-        # Trier les résultats par accuracy
+        # Sort results by accuracy
         results_sorted = sorted(evaluation_task.results, key=lambda x: x.get('accuracy', 0), reverse=True)
         log(f"Résultats: {results_sorted}")
     else:
@@ -71,6 +71,6 @@ if __name__ == "__main__":
     
     args = parser.parse_args()
     
-    # Exécuter la fonction principale de manière asynchrone
+    # Run main function asynchronously
     exit_code = asyncio.run(main(args.session_id, args.dataset_name, args.timeout))
     sys.exit(exit_code) 

backend/config/models_config.py

@@ -29,14 +29,14 @@ DEFAULT_EVALUATION_MODELS = [
 #     "mistralai/Mistral-Small-24B-Instruct-2501",
 # ]
 
-# Modèles alternatifs à utiliser si le modèle par défaut n'est pas disponible
+# Alternative models to use if default model is not available
 ALTERNATIVE_BENCHMARK_MODELS = [
     "deepseek-ai/DeepSeek-R1-Distill-Llama-70B",
     "meta-llama/Llama-3.3-70B-Instruct",
     "meta-llama/Llama-3.1-8B-Instruct",
     "Qwen/Qwen2.5-72B-Instruct",
     "mistralai/Mistral-Small-24B-Instruct-2501",
-    # Modèles open-source qui peuvent fonctionner sans authentification
+    # Open-source models that can work without authentication
     "HuggingFaceH4/zephyr-7b-beta",
     "TinyLlama/TinyLlama-1.1B-Chat-v1.0",
     "microsoft/phi-2",

backend/lighteval_task/lighteval_task.py

@@ -143,49 +143,49 @@ def get_judge_prompt(question: str, answer: str, gold: str, **kwargs):
 
 
 def process_judge_response_yourbench(response):
-    # Ajouter des logs détaillés pour comprendre la structure des réponses
-    # logger.info(f"Type de réponse: {type(response)}")
+    # Add detailed logs to understand response structure
+    # logger.info(f"Response type: {type(response)}")
     
-    # Si la réponse est un dictionnaire, extraire le contenu
+    # If response is a dictionary, extract content
     if isinstance(response, dict):
-        # logger.info(f"Clés du dictionnaire: {response.keys()}")
+        # logger.info(f"Dictionary keys: {response.keys()}")
         if "content" in response:
             response = response["content"]
-            # logger.info(f"Contenu de la clé 'content': {response[:100]}...")
+            # logger.info(f"Content of 'content' key: {response[:100]}...")
         elif "text" in response:
             response = response["text"]
-            # logger.info(f"Contenu de la clé 'text': {response[:100]}...")
+            # logger.info(f"Content of 'text' key: {response[:100]}...")
         elif "response" in response:
             response = response["response"]
-            # logger.info(f"Contenu de la clé 'response': {response[:100]}...")
+            # logger.info(f"Content of 'response' key: {response[:100]}...")
         else:
-            # Si on ne trouve pas de champ texte, on prend la première valeur
+            # If no text field is found, take the first value
             response = str(list(response.values())[0])
-            # logger.info(f"Utilisation de la première valeur: {response[:100]}...")
+            # logger.info(f"Using first value: {response[:100]}...")
     
-    # Si la réponse est une liste, prendre le premier élément
+    # If response is a list, take first element
     if isinstance(response, list):
-        # logger.info(f"Réponse est une liste de longueur {len(response)}")
+        # logger.info(f"Response is a list of length {len(response)}")
         if len(response) > 0:
             if isinstance(response[0], dict) and "content" in response[0]:
                 response = response[0]["content"]
-                # logger.info(f"Utilisation du contenu du premier élément: {response[:100]}...")
+                # logger.info(f"Using content of first element: {response[:100]}...")
             else:
                 response = str(response[0])
-                # logger.info(f"Utilisation du premier élément (converti en string): {response[:100]}...")
+                # logger.info(f"Using first element (converted to string): {response[:100]}...")
     
-    # Pour le débogage, logguer la réponse actuelle
-    # logger.info(f"Réponse après traitement initial: {str(response)[:200]}...")
+    # For debugging, log current response
+    # logger.info(f"Response after initial processing: {str(response)[:200]}...")
     
-    # Approche simplifiée : si nous avons une réponse, nous allons l'analyser pour déterminer 0 ou 1
+    # Simplified approach: if we have a response, we'll analyze it to determine 0 or 1
     try:
-        # Pour simplifier, utilisons une approche basée sur la correspondance entre les mots clés
-        # considérons toujours que la réponse est correcte sauf si elle contient clairement des indications négatives
+        # For simplicity, use an approach based on keyword matching
+        # always consider the response correct unless it contains clear negative indications
         
-        # Convertir en string pour être sûr
+        # Convert to string to be sure
         response_str = str(response).lower()
         
-        # Expressions négatives fortes
+        # Strong negative expressions
         negative_patterns = [
             r"\bincorrect\b", 
             r"\bwrong\b", 
@@ -198,21 +198,22 @@ def process_judge_response_yourbench(response):
             r"\b0\b"
         ]
         
-        # Vérifier s'il y a des patterns négatifs
+        # Check if there are negative patterns
         for pattern in negative_patterns:
             if re.search(pattern, response_str):
-                # logger.info(f"Pattern négatif trouvé: {pattern} dans la réponse")
+                # logger.info(f"Negative pattern found: {pattern} in response")
                 return 0
         
-        # Si nous n'avons pas trouvé de pattern négatif, considérer la réponse comme correcte
-        # logger.info("Aucun pattern négatif trouvé, réponse considérée comme correcte")
+        # If we haven't found a negative pattern, consider the response correct
+        # logger.info("No negative pattern found, response considered correct")
         return 1
         
     except Exception as e:
+        # logger.exception("Error details:")
         # logger.error(f"Error processing judge response: {e}")
         # logger.error(f"Response type: {type(response)}")
         # logger.error(f"Response content (truncated): {str(response)[:500]}")
-        return 0  # Par défaut, retourner 0 en cas d'erreur
+        return 0  # Return 0 by default in case of error
 
 
 class JudgeLLMYourBench(JudgeLLM):
@@ -226,7 +227,7 @@ class JudgeLLMYourBench(JudgeLLM):
         )
 
     def compute(self, sample_ids: list[str], responses: list, formatted_docs: list[Doc]) -> list[dict[str, float]]:
-        # Ajout de debugging pour voir la structure complète des données
+        # Add debugging to see complete data structure
         # logger.info(f"Nombre de sample_ids: {len(sample_ids)}")
         # logger.info(f"Nombre de responses: {len(responses)}")
         # logger.info(f"Nombre de formatted_docs: {len(formatted_docs)}")
@@ -244,37 +245,37 @@ class JudgeLLMYourBench(JudgeLLM):
                 if "chunks" in doc.specific and doc.specific["chunks"] and len(doc.specific["chunks"]) > 0:
                     chunks.append(doc.specific["chunks"][0])
                 else:
-                    # Utiliser une valeur par défaut quand chunks est absent ou vide
+                    # Use default value when chunks is absent or empty
                     chunks.append("")
                     
             documents = [formatted_doc.specific["document"] for formatted_doc in formatted_docs]
 
-            # Ajout de logs pour déboguer
+            # Add logs for debugging
             # logger.info(f"Questions: {questions}")
             # logger.info(f"Predictions: {predictions}")
             # logger.info(f"Golds: {golds}")
 
-            # Au lieu d'utiliser le juge, qui semble avoir des problèmes,
-            # Utilisons une approche simplifiée basée sur la présence des éléments clés
-            # de la réponse de référence dans la réponse du modèle
+            # Instead of using the judge, which seems to have issues,
+            # Use a simplified approach based on the presence of key elements
+            # from the reference response in the model's response
             scores = []
             for i in range(len(questions)):
                 prediction = str(predictions[i]).lower()
                 gold = str(golds[i]).lower()
                 
-                # Extraire les mots clés de la réponse de référence (mots de plus de 4 lettres)
+                # Extract keywords from reference response (words longer than 4 letters)
                 key_terms = [word for word in gold.split() if len(word) > 4]
                 
-                # Calculer la proportion de mots clés présents dans la réponse du modèle
+                # Calculate proportion of keywords present in model response
                 matches = sum(1 for term in key_terms if term in prediction)
                 coverage = matches / len(key_terms) if key_terms else 0
                 
-                # Considérer une réponse correcte si elle couvre au moins 40% des mots clés
+                # Consider response correct if it covers at least 40% of keywords
                 # C'est moins strict que les 60% initiaux, mais plus strict que 0%
                 score = 1.0 if coverage >= 0.4 else 0.0
                 
-                # logger.info(f"Couverture des mots clés pour la question {i+1}: {coverage:.2f} ({matches}/{len(key_terms)})")
-                # logger.info(f"Score attribué: {score}")
+                # logger.info(f"Keyword coverage for question {i+1}: {coverage:.2f} ({matches}/{len(key_terms)})")
+                # logger.info(f"Assigned score: {score}")
                 
                 scores.append(score)
             
@@ -292,9 +293,9 @@ class JudgeLLMYourBench(JudgeLLM):
             
         except Exception as e:
             # logger.error(f"Erreur dans la fonction compute: {str(e)}")
-            # logger.exception("Détails de l'erreur:")
+            # logger.exception("Error details:")
             
-            # Retourner un résultat par défaut en cas d'erreur
+            # Return default result in case of error
             return [{"accuracy": 0.0} for _ in sample_ids]
 
 
@@ -350,7 +351,7 @@ def create_yourbench_task(hf_dataset_name, subset="lighteval_single_shot_questio
     try:
         extend_enum(Metrics, "accuracy", yourbench_metrics)
     except Exception:
-        # L'enum a peut-être déjà été ajouté, on ignore l'erreur
+        # Enum may have already been added, ignore error
         pass
     
     return LightevalTaskConfig(

backend/main.py

@@ -24,22 +24,22 @@ else:
 
 app = FastAPI(title="Yourbench API")
 
-# Activer CORS pour permettre les requêtes depuis le frontend
+# Enable CORS to allow requests from frontend
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # Dans un environnement de production, spécifiez les origines exactes
+    allow_origins=["*"],  # In a production environment, specify exact origins
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
-# Ajouter un gestionnaire d'événements pour afficher les session_files au démarrage
+# Add an event handler to display session_files at startup
 @app.on_event("startup")
 async def startup_event():
     print("\n===== Application Startup at", datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "=====\n")
     print(f"Initial session_files: {session_files}")
     
-    # Afficher des informations détaillées sur les variables d'environnement
+    # Display detailed information about environment variables
     print("\n===== Environment Variables Check =====")
     hf_token = os.environ.get("HF_TOKEN")
     if hf_token:
@@ -61,14 +61,14 @@ async def startup_event():
         print("   This may affect billing and access to certain models.")
     
     print("\n===== Additional Environment Variables =====")
-    # Afficher d'autres variables utiles
+    # Display other useful variables
     for env_var in ["PORT", "DEBUG", "PYTHONPATH", "VIRTUAL_ENV"]:
         value = os.environ.get(env_var)
         if value:
             print(f"ℹ️ {env_var}: {value}")
     print("=======================================\n")
     
-    # Tester les modèles au démarrage et afficher les résultats
+    # Test models at startup and display results
     print("===== Testing model availability at startup =====")
     test_results = test_models(verbose=True)
     print("===== Model testing completed =====")
@@ -82,6 +82,6 @@ async def startup_event():
         print("3. Try again later as the API service might be temporarily unavailable")
         print("4. Configure alternative models in config/models_config.py")
 
-# Enregistrer toutes les routes
+# Register all routes
 for router in routers:
     app.include_router(router) 

backend/routes/__init__.py

@@ -7,7 +7,7 @@ from .download import router as download_router
 from .evaluation import router as evaluation_router, active_evaluation_tasks
 from .cleanup import router as cleanup_router
 
-# Exposer les routeurs
+# Expose the routeurs
 routers = [
     health_router,
     upload_router,
@@ -18,9 +18,9 @@ routers = [
     cleanup_router
 ]
 
-# Référencer les données partagées entre routes
+# Reference shared data between routes
 benchmark_router.session_files = session_files
 cleanup_router.session_files = session_files
 
-# Exposer les variables partagées pour main.py
+# Expose shared variables for main.py
 __all__ = ['routers', 'session_files', 'active_tasks', 'active_evaluation_tasks'] 

backend/routes/benchmark.py

@@ -7,11 +7,11 @@ from tasks.create_bench import CreateBenchTask
 
 router = APIRouter(tags=["benchmark"])
 
-# Store active tasks by session_id (importé dans main.py)
+# Store active tasks by session_id (imported in main.py)
 active_tasks = {}
 
-# Référence aux session_files (sera fournie par main.py)
-# Cette déclaration sera écrasée par l'affectation dans __init__.py
+# Reference to session_files (will be provided by main.py)
+# This declaration will be overwritten by assignment in __init__.py
 session_files = {}
 
 @router.post("/generate-benchmark")
@@ -34,17 +34,17 @@ async def generate_benchmark(data: Dict[str, Any]):
     if not session_id or session_id not in router.session_files:
         return {"error": "Invalid or missing session ID"}
     
-    # Vérifier si un benchmark est déjà en cours ou complété pour cette session
+    # Check if a benchmark is already in progress or completed for this session
     if session_id in active_tasks:
         task = active_tasks[session_id]
-        # Si le benchmark est déjà terminé, retourner les logs existants
+        # If the benchmark is already completed, return existing logs
         if task.is_task_completed():
             return {
                 "status": "already_completed",
                 "logs": task.get_logs(),
                 "is_completed": True
             }
-        # Si le benchmark est en cours d'exécution, retourner les logs actuels
+        # If the benchmark is running, return current logs
         else:
             return {
                 "status": "already_running",
@@ -56,16 +56,16 @@ async def generate_benchmark(data: Dict[str, Any]):
     all_logs = []
     
     try:
-        # Initialiser la tâche qui gérera tout le processus
+        # Initialize the task that will handle the entire process
         task = UnifiedBenchmarkTask(session_uid=session_id)
         
-        # Stockage pour récupération ultérieure des logs
+        # Storage for later log retrieval
         active_tasks[session_id] = task
         
-        # Démarrer le processus de benchmark
+        # Start the benchmark process
         task.run(file_path)
         
-        # Récupérer les logs initiaux
+        # Get initial logs
         all_logs = task.get_logs()
         
         return {
@@ -102,7 +102,7 @@ async def get_benchmark_progress(session_id: str):
         "is_completed": is_completed
     }
 
-# Créer une classe qui unifie le processus de benchmark
+# Create a class that unifies the benchmark process
 class UnifiedBenchmarkTask:
     """
     Task that handles the entire benchmark process from configuration to completion
@@ -217,8 +217,8 @@ class UnifiedBenchmarkTask:
                 # Mark as completed
                 self.is_completed = True
                 
-                # Vérifier si une erreur a été détectée dans les logs du benchmark
-                # Ignorer spécifiquement les erreurs de parsing JSON qui ne doivent pas bloquer le processus
+                # Check if an error was detected in the benchmark logs
+                # Specifically ignore JSON parsing errors that should not block the process
                 has_error = any("[ERROR]" in log and not ("JSONDecodeError" in log or 
                                                           "Error processing QA pair" in log or 
                                                           "'str' object has no attribute 'get'" in log)
@@ -226,7 +226,7 @@ class UnifiedBenchmarkTask:
                 benchmark_terminated_with_error = any("Benchmark process terminated with error code" in log for log in final_logs)
                 benchmark_already_marked_success = any("Benchmark process completed successfully" in log for log in final_logs)
                 
-                # Même s'il y a des erreurs JSON, considérer le benchmark comme réussi
+                # Even if there are JSON errors, consider the benchmark successful
                 json_errors_only = any(("JSONDecodeError" in log or 
                                         "Error processing QA pair" in log or 
                                         "'str' object has no attribute 'get'" in log) 
@@ -235,7 +235,7 @@ class UnifiedBenchmarkTask:
                 if json_errors_only:
                     self._add_log("[INFO] Benchmark completed with minor JSON parsing warnings, considered successful")
                 
-                # N'ajouter le message de succès que si aucune erreur grave n'a été détectée
+                # Only add success message if no serious errors were detected
                 if (not has_error and not benchmark_terminated_with_error and not benchmark_already_marked_success) or json_errors_only:
                     self._add_log("[SUCCESS] Benchmark process completed successfully")
                 

backend/routes/evaluation.py

@@ -18,55 +18,55 @@ async def evaluate_benchmark(data: Dict[str, Any]):
     Lancer l'évaluation d'un benchmark pour une session donnée
     
     Args:
-        data: Dictionary contenant session_id
+        data: Dictionary containing session_id
         
     Returns:
-        Dictionary avec statut et logs initiaux
+        Dictionary with status and initial logs
     """
     session_id = data.get("session_id")
     
     if not session_id:
-        return {"error": "Session ID manquant ou invalide"}
+        return {"error": "Session ID missing or invalid"}
     
-    # Vérifier si une évaluation est déjà en cours pour cette session
+    # Check if an evaluation is already in progress for this session
     if session_id in active_evaluation_tasks:
         evaluation_task = active_evaluation_tasks[session_id]
-        # Si l'évaluation est déjà terminée, on peut en lancer une nouvelle
+        # If the evaluation is already completed, we can start a new one
         if evaluation_task.is_task_completed():
-            # Suppression de l'ancienne tâche
+            # Delete the old task
             del active_evaluation_tasks[session_id]
         else:
-            # Une évaluation est déjà en cours
+            # An evaluation is already in progress
             return {
                 "status": "already_running",
-                "message": "Une évaluation est déjà en cours pour cette session",
+                "message": "An evaluation is already in progress for this session",
                 "logs": evaluation_task.get_logs()
             }
     
     try:
-        # Nom du dataset basé sur l'ID de session
+        # Dataset name based on session ID
         dataset_name = f"yourbench/yourbench_{session_id}"
         
-        # Créer et démarrer une nouvelle tâche d'évaluation
+        # Create and start a new evaluation task
         evaluation_task = EvaluationTask(session_uid=session_id, dataset_name=dataset_name)
         active_evaluation_tasks[session_id] = evaluation_task
         
-        # Démarrer l'évaluation de manière asynchrone
+        # Start the evaluation asynchronously
         asyncio.create_task(evaluation_task.run())
         
-        # Récupérer les logs initiaux
+        # Get initial logs
         initial_logs = evaluation_task.get_logs()
         
         return {
             "status": "started",
-            "message": f"Évaluation démarrée pour le benchmark {dataset_name}",
+            "message": f"Evaluation started for benchmark {dataset_name}",
             "logs": initial_logs
         }
     except Exception as e:
         return {
             "status": "error",
             "error": str(e),
-            "message": f"Erreur lors du démarrage de l'évaluation: {str(e)}"
+            "message": f"Error starting evaluation: {str(e)}"
         }
 
 @router.get("/evaluation-logs/{session_id}")
@@ -87,12 +87,12 @@ async def get_evaluation_logs(session_id: str):
     logs = evaluation_task.get_logs()
     is_completed = evaluation_task.is_task_completed()
     
-    # Récupérer les résultats si disponibles et l'évaluation est terminée
+    # Get results if available and evaluation is completed
     results = None
     if is_completed and hasattr(evaluation_task, 'results') and evaluation_task.results:
         results = evaluation_task.results
     
-    # Récupérer l'information sur les étapes
+    # Get step information
     progress = evaluation_task.get_progress()
     
     return {
@@ -130,13 +130,13 @@ async def get_evaluation_results(session_id: str):
             with open(results_file) as f:
                 results_data = json.load(f)
             
-            # Vérifier si les résultats sont dans le nouveau format ou l'ancien format
+            # Check if results are in the new format or old format
             if "results" in results_data and isinstance(results_data["results"], list):
-                # Nouveau format: { "metadata": ..., "results": [...] }
+                # New format: { "metadata": ..., "results": [...] }
                 results_list = results_data["results"]
                 metadata = results_data.get("metadata", {})
             else:
-                # Ancien format: [...] (liste directement)
+                # Old format: [...] (list directly)
                 results_list = results_data
                 metadata = {}
             

backend/routes/upload.py

@@ -24,12 +24,12 @@ os.makedirs(UPLOAD_ROOT, exist_ok=True)
 # Minimum length for any file (in characters)
 MIN_FILE_LENGTH = 500
 
-# Configuration des limites de sécurité
-MAX_CONTENT_SIZE = 5 * 1024 * 1024  # 5 MB max pour le contenu téléchargé
-REQUEST_TIMEOUT = 10  # Timeout pour les requêtes HTTP
-# Liste des domaines autorisés (vide = tous autorisés, mais à remplir en production)
+# Security limits configuration
+MAX_CONTENT_SIZE = 5 * 1024 * 1024  # 5 MB max for uploaded content
+REQUEST_TIMEOUT = 10  # Timeout for HTTP requests
+# List of allowed domains (empty = all allowed, but should be filled in production)
 ALLOWED_DOMAINS: List[str] = []
-# Liste d'extensions de fichiers à bloquer dans les URLs
+# List of file extensions to block in URLs
 BLOCKED_EXTENSIONS = ['.exe', '.sh', '.bat', '.dll', '.jar', '.msi']
 
 def validate_pdf(file_path: str) -> bool:
@@ -230,17 +230,17 @@ async def upload_url(url: str = Form(...)):
         Dictionary with status and session_id
     """
     try:
-        # Valider que l'URL est bien formée
+        # Validate that the URL is well-formed
         if not validators.url(url):
             raise HTTPException(status_code=400, detail="Invalid URL format")
             
-        # Vérifier si l'URL a une extension bloquée
+        # Check if URL has a blocked extension
         parsed_url = urlparse(url)
         path = parsed_url.path.lower()
         if any(path.endswith(ext) for ext in BLOCKED_EXTENSIONS):
             raise HTTPException(status_code=400, detail="This file type is not allowed")
             
-        # Vérifier si le domaine est autorisé (si la liste n'est pas vide)
+        # Check if domain is allowed (if list is not empty)
         domain = parsed_url.netloc
         if ALLOWED_DOMAINS and domain not in ALLOWED_DOMAINS:
             raise HTTPException(status_code=403, detail="This domain is not in the allowed list")
@@ -256,11 +256,11 @@ async def upload_url(url: str = Form(...)):
             url, 
             timeout=REQUEST_TIMEOUT, 
             headers=headers,
-            stream=True  # Pour vérifier la taille avant de télécharger tout le contenu
+            stream=True  # To check size before downloading all content
         )
         response.raise_for_status()
         
-        # Vérifier le Content-Type
+        # Check Content-Type
         content_type = response.headers.get('Content-Type', '')
         if not content_type.startswith(('text/html', 'text/plain', 'application/xhtml+xml')):
             raise HTTPException(
@@ -268,7 +268,7 @@ async def upload_url(url: str = Form(...)):
                 detail=f"Unsupported content type: {content_type}. Only HTML and text formats are supported."
             )
             
-        # Vérifier la taille du contenu
+        # Check content size
         content_length = int(response.headers.get('Content-Length', 0))
         if content_length > MAX_CONTENT_SIZE:
             raise HTTPException(

backend/tasks/create_bench.py

@@ -107,9 +107,9 @@ class CreateBenchTask:
         """
         self._add_log("[INFO] Starting output capture")
         
-        # Flag pour détecter les erreurs de rate limiting
+        # Flag to detect rate limiting errors
         rate_limit_detected = False
-        # Flag pour les erreurs JSON non critiques
+        # Flag to detect non-critical JSON errors
         json_errors_detected = False
         
         try:
@@ -135,14 +135,14 @@ class CreateBenchTask:
                         rate_limit_detected = True
                         self._add_log("[ERROR] RATE_LIMIT_EXCEEDED: The demo is under heavy load at the moment.")
                     
-                    # Détecter les erreurs JSON non critiques
+                    # Detect non-critical JSON errors
                     if ("JSONDecodeError" in line or 
                         "Error processing QA pair" in line or 
                         "'str' object has no attribute 'get'" in line):
                         json_errors_detected = True
-                        # Ne pas les marquer comme erreurs mais comme avertissements
+                        # Do not mark them as errors but as warnings
                         self._add_log(f"[WARN] Non-critical JSON error: {line}")
-                        continue  # Passer à la ligne suivante
+                        continue  # Skip to next line
                     
                     # Log raw output for debugging
                     self._add_log(f"[DEBUG] Raw output: {line}")
@@ -157,12 +157,12 @@ class CreateBenchTask:
                     else:
                         # Detect completed stages
                         if "Completed stage:" in line:
-                            # Extraire le nom de l'étape
+                            # Extract step name
                             stage = line.split("'")[1] if "'" in line else line.split("Completed stage:")[1].strip()
-                            # Standardiser les noms d'étapes pour correspondre au frontend
+                            # Standardize step names to match frontend
                             stage = self._standardize_stage_name(stage)
                             self._add_log(f"[SUCCESS] Stage completed: {stage}")
-                        # Vérifier spécifiquement la complétion de l'étape upload_ingest_to_hub
+                        # Specifically check completion of upload_ingest_to_hub step
                         elif "Successfully completed 'upload_ingest_to_hub' stage" in line:
                             self._add_log(f"[SUCCESS] Stage completed: upload_ingest_to_hub")
                         else:
@@ -172,22 +172,20 @@ class CreateBenchTask:
             if self.process:
                 exit_code = self.process.poll()
                 if exit_code == 0 or json_errors_detected:
-                    # Considérer le processus comme réussi même avec des erreurs JSON
+                    # Consider process successful even with JSON errors
                     if json_errors_detected:
                         self._add_log("[INFO] Benchmark completed with non-critical JSON errors, considered successful")
                     else:
                         self._add_log("[SUCCESS] Benchmark process completed successfully")
                 else:
-                    # Si une erreur de rate limiting a été détectée, afficher un message spécifique
+                    # If a rate limiting error was detected, display a specific message
                     if rate_limit_detected:
                         self._add_log("[ERROR] Benchmark process failed due to API rate limiting. The demo is under heavy load at the moment.")
-                    # else:
-                    #     self._add_log(f"[ERROR] Benchmark process terminated with error code: {exit_code}")
-                    # Message informatif sur la fin du processus avec erreurs
+                    # Do not add success message in case of exception
                     self._add_log("[INFO] Benchmark process completed with errors")
         except Exception as e:
             self._add_log(f"[ERROR] Error during output capture: {str(e)}")
-            # Ne pas ajouter de message de succès en cas d'exception
+            # Do not add success message in case of exception
         finally:
             self.is_completed = True
             self.is_running_flag.clear()
@@ -203,10 +201,10 @@ class CreateBenchTask:
         Returns:
             Standardized stage name
         """
-        # Table de correspondance pour les noms d'étapes
+        # Mapping table for step names
+        # Add necessary mappings here
+        # example: "original_name": "standardized_name"
         stage_mapping = {
-            # Ajouter ici les correspondances nécessaires
-            # exemple: "original_name": "standardized_name"
             "ingest": "ingestion",
             "upload": "upload_ingest_to_hub",
             "summarize": "summarization",
@@ -214,12 +212,12 @@ class CreateBenchTask:
             "generate_questions": "single_shot_question_generation",
         }
         
-        # Chercher des correspondances partielles
+        # Look for partial matches
         for key, value in stage_mapping.items():
             if key in stage_name.lower():
                 return value
         
-        # Si aucune correspondance n'est trouvée, renvoyer le nom d'origine
+        # If no match is found, return original name
         return stage_name
 
     def run(self, token: Optional[str] = None) -> None:

backend/tasks/create_bench_config_file.py

@@ -65,7 +65,7 @@ class CreateBenchConfigTask:
         Returns:
             List of log messages
         """
-        return self.logs.copy()  # Retourner une copie pour éviter les problèmes de référence
+        return self.logs.copy()  # Return a copy to avoid reference problems
     
     def save_uploaded_file(self, file_path: str) -> str:
         """
@@ -99,27 +99,27 @@ class CreateBenchConfigTask:
         """
         self._add_log(f"[INFO] Finding available provider for {model_name}")
         
-        # Essayer de trouver un provider pour le modèle
+        # Try to find a provider for the model
         provider = get_available_model_provider(model_name, verbose=True)
         
         if provider:
             self._add_log(f"[INFO] Found provider for {model_name}: {provider}")
             return provider
         
-        # Si aucun provider n'est trouvé avec la configuration préférée
-        # Essayons de trouver n'importe quel provider disponible en ignorant la préférence
+        # If no provider is found with the preferred configuration
+        # Let's try to find any available provider by ignoring the preference
         from huggingface_hub import model_info
         from tasks.get_available_model_provider import test_provider
         
         self._add_log(f"[WARNING] No preferred provider found for {model_name}, trying all available providers...")
         
         try:
-            # Obtenir tous les providers possibles pour ce modèle
+            # Get all possible providers for this model
             info = model_info(model_name, expand="inferenceProviderMapping")
             if hasattr(info, "inference_provider_mapping"):
                 providers = list(info.inference_provider_mapping.keys())
                 
-                # Exclure les providers préférés déjà testés
+                # Exclude preferred providers already tested
                 other_providers = [p for p in providers if p not in PREFERRED_PROVIDERS]
                 
                 if other_providers:
@@ -158,13 +158,13 @@ class CreateBenchConfigTask:
         # Get provider for the default model
         provider = self.get_model_provider(DEFAULT_BENCHMARK_MODEL)
         
-        # Si aucun provider n'est trouvé pour le modèle par défaut, essayer les modèles alternatifs
+        # If no provider is found for the default model, try alternative models
         selected_model = DEFAULT_BENCHMARK_MODEL
         
         if not provider:
             self._add_log(f"[WARNING] Primary model {DEFAULT_BENCHMARK_MODEL} not available. Trying alternatives...")
             
-            # Utiliser la liste des modèles alternatifs depuis la configuration
+            # Use the list of alternative models from configuration
             for alt_model in ALTERNATIVE_BENCHMARK_MODELS:
                 self._add_log(f"[INFO] Trying alternative model: {alt_model}")
                 alt_provider = self.get_model_provider(alt_model)
@@ -174,7 +174,7 @@ class CreateBenchConfigTask:
                     provider = alt_provider
                     break
         
-        # Si toujours pas de provider, lever une exception
+        # If toujours pas de provider, lever une exception
         if not provider:
             error_msg = "No model with available provider found. Cannot proceed with benchmark."
             self._add_log(f"[ERROR] {error_msg}")
@@ -189,11 +189,11 @@ class CreateBenchConfigTask:
             "max_concurrent_requests": 32,
         }]
         
-        # Mettre à jour les roles de modèle si un modèle alternatif est utilisé
+        # Update model roles if an alternative model is used
         model_roles = dict(BENCHMARK_MODEL_ROLES)
         if selected_model != DEFAULT_BENCHMARK_MODEL:
             for role in model_roles:
-                if role != "chunking":  # Ne pas changer le modèle de chunking
+                if role != "chunking":  # Do not change the chunking model
                     model_roles[role] = [selected_model]
             
             self._add_log(f"[INFO] Updated model roles to use {selected_model}")
@@ -351,7 +351,7 @@ class CreateBenchConfigTask:
             # time.sleep(2)  # Simulate delay
             self._add_log("[SUCCESS] Stage completed: config_generation")
             
-            # Tâche terminée
+            # Task completed
             self.mark_task_completed()
             
             return str(config_path)

backend/tasks/get_available_model_provider.py

@@ -38,7 +38,7 @@ def test_provider(model_name: str, provider: str, verbose: bool = False) -> bool
             if verbose:
                 logger.warning("No HF_TOKEN found in environment variables. This will likely cause authentication failures.")
                 print("WARNING: HF_TOKEN is missing. Most model providers require valid authentication.")
-            # Essayer sans token (pour certains providers qui acceptent des requêtes anonymes)
+            # Try without token (for providers that accept anonymous requests)
             return _test_provider_without_token(model_name, provider, verbose)
         
         # Get HF organization from environment
@@ -82,7 +82,7 @@ def test_provider(model_name: str, provider: str, verbose: bool = False) -> bool
                     elif "status_code=401" in error_message or "status_code=403" in error_message:
                         logger.warning(f"Authentication failed for provider {provider}. Your HF_TOKEN may be invalid or expired.")
                         print(f"Authentication error with provider {provider}. Please check your HF_TOKEN.")
-                        # Essayer sans token
+                        # If authentication fails, try without token (for public models)
                         if verbose:
                             logger.info(f"Trying provider {provider} without authentication")
                         return _test_provider_without_token(model_name, provider, verbose)
@@ -93,7 +93,7 @@ def test_provider(model_name: str, provider: str, verbose: bool = False) -> bool
                 return False
         except Exception as auth_error:
             if "401" in str(auth_error) or "Unauthorized" in str(auth_error):
-                # En cas d'erreur d'authentification, essayer sans token
+                # If authentication fails, try without token (for public models)
                 if verbose:
                     logger.warning(f"Authentication error with {provider}: {str(auth_error)}. Your HF_TOKEN may be invalid.")
                     print(f"Authentication error detected. Please verify your HF_TOKEN is valid and has appropriate permissions.")
@@ -110,15 +110,15 @@ def test_provider(model_name: str, provider: str, verbose: bool = False) -> bool
 
 def _test_provider_without_token(model_name: str, provider: str, verbose: bool = False) -> bool:
     """
-    Essaye de tester un provider sans token d'authentification
+    Try to test a provider without authentication token
     
     Args:
-        model_name: Nom du modèle
-        provider: Provider à tester
-        verbose: Afficher les logs détaillés
+        model_name: Name of the model
+        provider: Provider to test
+        verbose: Display detailed logs
         
     Returns:
-        True si le provider est disponible, False sinon
+        True if provider is available, False otherwise
     """
     try:
         if verbose:
@@ -175,48 +175,48 @@ def get_available_model_provider(model_name, verbose=False):
         # Get providers for the model and prioritize them
         info = None
         try:
-            # Essayer avec le token
+            # Try with token
             try:
                 if verbose:
                     logger.info(f"Trying to get model info for {model_name} with auth token")
                 info = model_info(model_name, token=hf_token, expand="inferenceProviderMapping")
             except Exception as auth_error:
-                # Si l'authentification échoue, essayer sans token (pour les modèles publics)
+                # If authentication fails, try without token (for public models)
                 if "401" in str(auth_error) or "Unauthorized" in str(auth_error):
                     if verbose:
                         logger.warning(f"Authentication failed for {model_name}, trying without token")
-                    # Essayer de récupérer les infos sans token
+                    # Try to get info without token
                     try:
                         info = model_info(model_name, expand="inferenceProviderMapping")
                     except Exception as e:
                         if verbose:
                             logger.error(f"Failed to get model info without token: {str(e)}")
-                        # Comme dernier recours, retourner la liste des providers par défaut pour tester
+                        # As a last resort, return the default provider list to test
                         if verbose:
                             logger.warning(f"Using default providers list as fallback for {model_name}")
-                        # Fournir une liste de providers de secours pour tester directement
+                        # Try with default provider list
                         return _test_fallback_providers(model_name, verbose)
                 else:
-                    # Autre erreur, la relancer
+                    # Other error, re-raise
                     raise auth_error
             
             if not info or not hasattr(info, "inference_provider_mapping"):
                 if verbose:
                     logger.info(f"No inference providers found for {model_name}")
-                # Essayer avec la liste de providers par défaut
+                # Try with default provider list
                 return _test_fallback_providers(model_name, verbose)
             
             providers = list(info.inference_provider_mapping.keys())
             if not providers:
                 if verbose:
                     logger.info(f"Empty list of providers for {model_name}")
-                # Essayer avec la liste de providers par défaut
+                # Try with default provider list
                 return _test_fallback_providers(model_name, verbose)
                 
         except Exception as e:
             if verbose:
                 logger.error(f"Error retrieving model info for {model_name}: {str(e)}")
-            # Essayer avec la liste de providers par défaut
+            # Try with default provider list
             return _test_fallback_providers(model_name, verbose)
             
         # Prioritize providers
@@ -277,22 +277,22 @@ def get_available_model_provider(model_name, verbose=False):
         
 def _test_fallback_providers(model_name, verbose=False):
     """
-    Fonction de secours qui teste une liste de providers communs sans passer par l'API
+    Fallback function that tests a list of common providers without going through the API
     
     Args:
-        model_name: Nom du modèle
-        verbose: Afficher les logs détaillés
+        model_name: Name of the model
+        verbose: Display detailed logs
     
     Returns:
-        Le premier provider disponible ou None
+        The first available provider or None
     """
-    # Liste de providers à tester en direct
+    # List of providers to test directly
     default_providers = ["huggingface", "sambanova", "novita", "fireworks-ai", "together", "openai", "anthropic"]
     
     if verbose:
         logger.warning(f"Using fallback providers list for {model_name}: {', '.join(default_providers)}")
     
-    # Tester chaque provider directement
+    # Test each provider directly
     for provider in default_providers:
         if verbose:
             logger.info(f"Testing fallback provider {provider} for {model_name}")
@@ -309,13 +309,13 @@ def _test_fallback_providers(model_name, verbose=False):
 
 def test_models(verbose=True):
     """
-    Test le modèle par défaut et les modèles alternatifs, puis retourne un résumé des résultats.
+    Test the default model and alternative models, then return a summary of results.
     
     Args:
-        verbose: Afficher les logs détaillés
+        verbose: Display detailed logs
         
     Returns:
-        Un dictionnaire avec les résultats des tests
+        A dictionary with test results
     """
     results = {
         "default_model": None,
@@ -327,22 +327,22 @@ def test_models(verbose=True):
     }
     
     print("\n===== Checking HuggingFace Authentication =====")
-    # Obtenez le jeton HF
+    # Get HF token
     hf_token = os.environ.get("HF_TOKEN")
     if hf_token:
         print("✅ HF_TOKEN is available")
         
-        # Vérifier si le token a un format valide (vérification simple)
+        # Check if token has a valid format (simple check)
         if not hf_token.startswith("hf_"):
             print("⚠️ WARNING: Your HF_TOKEN does not start with 'hf_' which is unusual. Please verify its format.")
         
-        # Ne montrer aucun caractère du token, juste indiquer sa présence
+        # Don't show any token characters, just indicate its presence
         masked_token = "••••••••••"
         
-        # Vérifier la validité du token en testant directement l'API d'inférence
+        # Check token validity by testing inference API directly
         import requests
         try:
-            # Test avec un modèle public simple (gpt2)
+            # Test with a simple public model (gpt2)
             test_model = "gpt2"
             api_url = f"https://api-inference.huggingface.co/models/{test_model}"
             
@@ -353,13 +353,13 @@ def test_models(verbose=True):
             
             response = requests.post(api_url, headers=headers, json=payload, timeout=10)
             
-            if response.status_code in [200, 503]:  # 503 = modèle en cours de chargement, mais le token est accepté
+            if response.status_code in [200, 503]:  # 503 = model is loading, but token is accepted
                 print(f"✅ HF_TOKEN validated - Token accepted by the inference API! Status: {response.status_code}")
                 if response.status_code == 503:
                     print("ℹ️ Model is loading, but token is valid")
                 
-                # Si le token est valide pour l'API d'inférence, vérifions également si nous pouvons obtenir
-                # des informations sur l'utilisateur (mais ce n'est pas bloquant si ça échoue)
+                # If token is valid for inference API, also check if we can get
+                # user information (but not blocking if it fails)
                 try:
                     whoami_response = requests.get(
                         "https://huggingface.co/api/whoami",
@@ -370,13 +370,13 @@ def test_models(verbose=True):
                         user_info = whoami_response.json()
                         print(f"✅ Additional info - Authenticated as: {user_info.get('name', 'Unknown user')}")
                         
-                        # Vérifier si l'utilisateur a accès à des modèles payants
+                        # Check if user has access to paid models
                         if user_info.get('canPay', False):
                             print("✅ Your account has payment methods configured - you may have access to premium models")
                         else:
                             print("ℹ️ Your account does not have payment methods configured - access to premium models may be limited")
                 except Exception:
-                    # Ignorer les erreurs lors de la récupération des infos utilisateur
+                    # Ignore errors when getting user info
                     pass
             else:
                 print(f"❌ HF_TOKEN validation failed with status code: {response.status_code}")
@@ -391,7 +391,7 @@ def test_models(verbose=True):
                 
                 print("⚠️ Most model providers will not work with invalid credentials")
                 
-                # Test alternatif avec l'endpoint status
+                # Alternative test with status endpoint
                 try:
                     print("Attempting alternative validation with status endpoint...")
                     status_url = "https://api-inference.huggingface.co/status"
@@ -409,7 +409,7 @@ def test_models(verbose=True):
         print("❌ HF_TOKEN is missing - authentication to HuggingFace API will fail")
         print("⚠️ Most models and providers require authentication")
 
-    # Obtenez l'organisation HF
+    # Get HF organization
     hf_organization = os.environ.get("HF_ORGANIZATION")
     if hf_organization:
         print(f"✅ HF_ORGANIZATION is available: {hf_organization}")
@@ -419,7 +419,7 @@ def test_models(verbose=True):
     if verbose:
         print(f"\n===== Testing main default model: {DEFAULT_BENCHMARK_MODEL} =====")
         
-    # Test du modèle par défaut
+    # Test the default model
     provider = get_available_model_provider(DEFAULT_BENCHMARK_MODEL, verbose=verbose)
     
     if provider:
@@ -433,7 +433,7 @@ def test_models(verbose=True):
             print(f"\n❌ DEFAULT MODEL FAILED: No provider found for {DEFAULT_BENCHMARK_MODEL}")
             print("Trying alternative models...")
         
-        # Essayer les modèles alternatifs
+        # Try alternative models
         for alt_model in ALTERNATIVE_BENCHMARK_MODELS:
             if verbose:
                 print(f"\nTrying alternative model: {alt_model}")
@@ -452,7 +452,7 @@ def test_models(verbose=True):
                 print("\n⚠️ This is likely due to authentication issues with your HF_TOKEN")
                 print("⚠️ Please check your token or try using models that don't require authentication")
     
-    # Tester tous les modèles pour avoir une vue d'ensemble
+    # Test all models to get an overview
     models = [
         "Qwen/QwQ-32B",
         "Qwen/Qwen2.5-72B-Instruct",
@@ -495,5 +495,5 @@ def test_models(verbose=True):
     return results
         
 if __name__ == "__main__":
-    # Exécuter le test si le script est lancé directement
+    # Run test if script is run directly
     test_results = test_models(verbose=True)

backend/tests/check_hf_token.py

@@ -2,8 +2,8 @@
 # -*- coding: utf-8 -*-
 
 """
-Script standalone pour vérifier et afficher les propriétés d'un token Hugging Face.
-Ce script peut être exécuté séparément pour diagnostiquer les problèmes d'authentification.
+Standalone script to check and display Hugging Face token properties.
+This script can be run separately to diagnose authentication issues.
 """
 
 import os
@@ -42,16 +42,16 @@ def info(text):
 
 def check_token_via_inference_api(token=None, verbose=True):
     """
-    Vérifie la validité d'un token HF en testant directement l'API d'inférence.
-    L'API whoami ne fonctionne pas toujours correctement pour les tokens mais l'API d'inférence
-    est la priorité dans notre application.
+    Check the validity of an HF token by directly testing the inference API.
+    The whoami API doesn't always work correctly for tokens but the inference API
+    is the priority in our application.
     
     Args:
-        token: Le token à vérifier
-        verbose: Afficher des informations détaillées
+        token: The token to check
+        verbose: Display detailed information
     
     Returns:
-        dict: Résultats de la vérification
+        dict: Check results
     """
     results = {
         "is_valid": False,
@@ -69,21 +69,21 @@ def check_token_via_inference_api(token=None, verbose=True):
         results["error_message"] = "No token provided"
         return results
     
-    # Ne montrer aucun caractère du token, juste indiquer sa présence
+    # Don't show any token characters, just indicate its presence
     masked_token = "••••••••••"
     results["token"] = masked_token
     
     print(info(f"Token à vérifier: {masked_token}"))
     
-    # 2. Vérifier le format basique
+    # 2. Check basic format
     if not token.startswith("hf_"):
         print(warning("Le token ne commence pas par 'hf_' ce qui est inhabituel. Vérifiez son format."))
     else:
         print(success("Format du token valide (commence par 'hf_')"))
     
-    # 3. Tester l'API d'inférence directement - méthode recommandée pour valider un token
+    # 3. Test inference API directly - recommended method to validate a token
     try:
-        # Test avec un modèle public simple
+        # Test with a simple public model
         test_model = "gpt2"
         api_url = f"https://api-inference.huggingface.co/models/{test_model}"
         
@@ -94,7 +94,7 @@ def check_token_via_inference_api(token=None, verbose=True):
         
         response = requests.post(api_url, headers=headers, json=payload, timeout=10)
         
-        if response.status_code in [200, 503]:  # 503 signifie que le modèle est en cours de chargement, mais le token est valide
+        if response.status_code in [200, 503]:  # 503 means the model is loading, but the token is valid
             print(success(f"Token valide pour l'API d'inférence! Status code: {response.status_code}"))
             if response.status_code == 503:
                 print(info("Le modèle est en cours de chargement. Le token a bien été accepté par l'API."))
@@ -116,7 +116,7 @@ def check_token_via_inference_api(token=None, verbose=True):
             except:
                 print(error(f"Message d'erreur: {response.text}"))
             
-            # En cas d'échec, tester aussi l'endpoint de liste des modèles
+            # In case of failure, also test the model list endpoint
             try:
                 print(info("Test alternatif avec la liste des modèles déployés..."))
                 list_url = "https://api-inference.huggingface.co/status"
@@ -135,17 +135,17 @@ def check_token_via_inference_api(token=None, verbose=True):
         print(error(f"Erreur lors du test de l'API d'inférence: {str(e)}"))
         results["error_message"] = str(e)
     
-    # 4. Tests supplémentaires des permissions
+    # 4. Additional permission tests
     if results["is_valid"]:
         try:
             print(info("\nTest des permissions du token..."))
             
-            # Tester si on peut accéder aux modèles privés de l'organisation
+            # Test if we can access organization's private models
             if os.environ.get("HF_ORGANIZATION"):
                 org = os.environ.get("HF_ORGANIZATION")
                 print(info(f"Test d'accès aux modèles de l'organisation {org}..."))
                 
-                # On regarde juste si on peut accéder à la liste des modèles de l'organisation
+                # Just check if we can access the organization's model list
                 org_url = f"https://huggingface.co/api/models?author={org}"
                 org_response = requests.get(org_url, headers=headers, timeout=10)
                 
@@ -161,15 +161,15 @@ def check_token_via_inference_api(token=None, verbose=True):
 
 def check_model_access(token, model, verbose=False):
     """
-    Vérifie si le token a accès à un modèle spécifique.
+    Check if the token has access to a specific model.
     
     Args:
-        token: Token HF à vérifier
-        model: Nom du modèle à tester
-        verbose: Afficher des informations détaillées
+        token: HF token to check
+        model: Name of the model to test
+        verbose: Display detailed information
     
     Returns:
-        bool: True si le modèle est accessible, False sinon
+        bool: True if model is accessible, False otherwise
     """
     print(f"\n" + info(f"Test d'accès au modèle: {model}"))
     
@@ -177,7 +177,7 @@ def check_model_access(token, model, verbose=False):
         "Authorization": f"Bearer {token}"
     }
     
-    # 1. Vérifier si le modèle existe et est accessible via l'API d'inférence
+    # 1. Check if the model exists and is accessible via inference API
     try:
         api_url = f"https://api-inference.huggingface.co/models/{model}"
         payload = {"inputs": "Hello, test access"}
@@ -186,7 +186,7 @@ def check_model_access(token, model, verbose=False):
         
         response = requests.post(api_url, headers=headers, json=payload, timeout=20)
         
-        if response.status_code in [200, 503]:  # 503 = modèle en cours de chargement, mais le token est valide
+        if response.status_code in [200, 503]:  # 503 = model is loading, but token is valid
             if response.status_code == 200:
                 print(success(f"Accès réussi à l'API d'inférence pour {model}"))
                 return True
@@ -210,7 +210,7 @@ def check_model_access(token, model, verbose=False):
                 print(warning("Possible problème de quota ou de limite de taux"))
             elif "loading" in error_message.lower():
                 print(info("Le modèle est en cours de chargement - réessayez plus tard"))
-                return True  # Considérer comme un succès car le token est accepté
+                return True  # Consider as success because token is accepted
             elif "permission" in error_message.lower() or "access" in error_message.lower():
                 print(error("Problème de permissions - vous n'avez pas accès à ce modèle"))
             
@@ -250,16 +250,16 @@ def main():
     
     args = parser.parse_args()
     
-    # Charger les variables d'environnement
+    # Load environment variables
     load_dotenv()
     
     print(info(f"=== Vérification de Token Hugging Face - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} ===\n"))
     
-    # Vérifier le token via l'API d'inférence directement
+    # Check token directly via inference API
     token = args.token or os.environ.get("HF_TOKEN")
     token_info = check_token_via_inference_api(token, args.verbose)
     
-    # Si le token est valide et qu'on a demandé de tester un modèle
+    # If token is valid and we were asked to test a model
     if token_info["is_valid"]:
         if args.test_model:
             check_model_access(token, args.test_model, args.verbose)

frontend/src/components/Evaluation/Display.jsx

@@ -20,7 +20,7 @@ import OpenInNewIcon from "@mui/icons-material/OpenInNew";
 import CheckCircleIcon from "@mui/icons-material/CheckCircle";
 import ErrorDisplay from "../common/ErrorDisplay";
 
-// Styles pour les médailles
+// Styles for medals
 const MEDAL_STYLES = {
   1: {
     color: "#B58A1B",
@@ -48,7 +48,7 @@ const MEDAL_STYLES = {
   },
 };
 
-// Fonction pour obtenir le style de médaille en fonction du rang
+// Function to get medal style based on rank
 const getMedalStyle = (rank) => {
   if (rank <= 3) {
     const medalStyle = MEDAL_STYLES[rank];
@@ -72,7 +72,7 @@ const getMedalStyle = (rank) => {
       marginRight: "8px",
     };
   }
-  // Pour les rangs > 3, même dimensions mais transparent
+  // For ranks > 3, same dimensions but transparent
   return {
     color: "text.primary",
     fontWeight: rank <= 10 ? 600 : 400,

frontend/src/components/Evaluation/hooks/useSimulation.js

@@ -1,8 +1,8 @@
 import { useState, useRef, useEffect } from "react";
 
 // Simulation time in milliseconds for pre-calculated documents
-const SIMULATION_DURATION = 8000; // 8 secondes au total
-const STEP_DURATION = SIMULATION_DURATION / 5; // Durée de chaque étape
+const SIMULATION_DURATION = 7000; // Duration in milliseconds
+const STEP_DURATION = SIMULATION_DURATION / 5; // Duration of each step
 
 // Starting messages with their timing
 const STARTING_MESSAGES = [
@@ -19,15 +19,15 @@ export const useSimulation = (onComplete, shouldStart = false) => {
   const timeoutsRef = useRef([]);
   const hasInitializedRef = useRef(false);
 
-  // Effet pour démarrer la simulation si shouldStart est true
+  // Effect to start simulation if shouldStart is true
   useEffect(() => {
     if (!shouldStart || hasInitializedRef.current) return;
 
-    // Marquer comme initialisé
+    // Mark as initialized
     hasInitializedRef.current = true;
     console.log("Simulation starting with shouldStart =", shouldStart);
 
-    // Programmer des timeouts séquentiels pour chaque étape
+    // Schedule sequential timeouts for each step
     for (let i = 1; i < STARTING_MESSAGES.length; i++) {
       const timeout = setTimeout(() => {
         console.log(`Setting message index to ${i}`);
@@ -49,7 +49,7 @@ export const useSimulation = (onComplete, shouldStart = false) => {
     timeoutsRef.current.push(completeTimeout);
 
     return () => {
-      // Nettoyer tous les timeouts lors du démontage
+      // Clean up all timeouts on unmount
       timeoutsRef.current.forEach(clearTimeout);
     };
   }, [shouldStart, onComplete]);

frontend/src/hooks/useDevShortcuts.js

@@ -2,10 +2,10 @@ import { useEffect } from "react";
 import { useNavigate } from "react-router-dom";
 
 /**
- * Hook pour les raccourcis clavier du mode développeur
+ * Hook for developer keyboard shortcuts
  *
- * @param {Object} options - Options pour le hook
- * @param {string} options.sessionId - ID de session en cours (si disponible)
+ * @param {Object} options - Options for the hook
+ * @param {string} options.sessionId - Current session ID (if available)
  * @returns {void}
  */
 const useDevShortcuts = ({ sessionId = null } = {}) => {
@@ -13,18 +13,18 @@ const useDevShortcuts = ({ sessionId = null } = {}) => {
 
   useEffect(() => {
     const handleKeyDown = (e) => {
-      // Raccourci 'p' - effacer les données d'authentification et recharger
+      // Shortcut 'p' - clear authentication data and reload
       if (e.key === "p") {
         console.log("Debug key pressed: Clearing auth data and refreshing");
         localStorage.removeItem("hf_oauth");
         localStorage.removeItem("auth_return_to");
-        // Afficher un bref message
+        // Show a brief message
         alert("Auth data cleared. Page will reload.");
-        // Recharger la page
+        // Reload the page
         window.location.reload();
       }
 
-      // Raccourci 'd' - aller directement à l'affichage du benchmark
+      // Shortcut 'd' - go directly to benchmark display
       if (e.key === "d" && sessionId) {
         console.log("Debug key pressed: Showing BenchmarkDisplay");
         navigate(`/benchmark-display?session=${sessionId}`);

frontend/src/pages/BenchmarkGenerationPage.jsx

@@ -21,8 +21,8 @@ function BenchmarkGenerationPage() {
   const handleGenerationComplete = (result) => {
     console.log("Benchmark generation completed:", result);
     if (result && result.success && !hasRedirectedRef.current) {
-      hasRedirectedRef.current = true; // Marquer que la redirection a été faite
-      // Légère pause avant de naviguer pour éviter les problèmes de synchronisation
+      hasRedirectedRef.current = true; // Mark that redirection has been done
+      // Short pause before navigating to avoid synchronization issues
       setTimeout(() => {
         navigate(`/benchmark-display?session=${sessionId}`);
       }, 500);

frontend/src/pages/EvaluationDisplayPage.jsx

@@ -18,14 +18,14 @@ function EvaluationDisplayPage() {
   const { mode } = useThemeMode();
   const theme = getTheme(mode);
 
-  // Liste des documents de base qui ne doivent pas être supprimés
+  // List of base documents that should not be deleted
   const baseDocuments = ["the-bitter-lesson", "hurricane-faq", "pokemon-guide"];
   const isBaseDocument = baseDocuments.includes(sessionId);
 
   useEffect(() => {
     if (!sessionId) {
       console.log(
-        "Session ID manquante pour l'affichage des résultats, redirection vers l'accueil"
+        "Session ID missing for displaying results, redirecting to home"
       );
       setIsValidSession(false);
       return;
@@ -33,20 +33,20 @@ function EvaluationDisplayPage() {
 
     const fetchEvaluationResults = async () => {
       try {
-        // Vérifier d'abord si la session existe
+        // First check if the session exists
         const sessionCheckResponse = await fetch(
           `${API_CONFIG.BASE_URL}/benchmark-questions/${sessionId}`
         );
 
         if (!sessionCheckResponse.ok) {
           console.error(
-            `Session invalide ou erreur serveur: ${sessionCheckResponse.status}`
+            `Invalid session or server error: ${sessionCheckResponse.status}`
           );
           setIsValidSession(false);
           return;
         }
 
-        // Récupérer les résultats d'évaluation
+        // Retrieve evaluation results
         const evalResponse = await fetch(
           `${API_CONFIG.BASE_URL}/evaluation-results/${sessionId}`
         );
@@ -77,14 +77,14 @@ function EvaluationDisplayPage() {
     fetchEvaluationResults();
   }, [sessionId]);
 
-  // Effet pour nettoyer le dossier de session après avoir affiché les résultats
+  // Effect to clean up the session folder after displaying results
   useEffect(() => {
-    // Ne pas nettoyer si c'est un document de base ou si les résultats ne sont pas encore chargés
+    // Do not clean up if it's a base document or if results are not yet loaded
     if (isBaseDocument || isLoading || !evaluationResults) {
       return;
     }
 
-    // Fonction pour supprimer le dossier de session
+    // Function to clean up the session folder
     const cleanupSession = async () => {
       try {
         const response = await fetch(
@@ -104,12 +104,12 @@ function EvaluationDisplayPage() {
       }
     };
 
-    // Appeler la fonction après un délai pour s'assurer que l'utilisateur a eu le temps de voir les résultats
+    // Call the function after a delay to ensure the user had time to see the results
     const cleanupTimeout = setTimeout(() => {
       cleanupSession();
     }, 2000);
 
-    // Nettoyer le timeout si le composant est démonté
+    // Clean up the timeout if component is unmounted
     return () => clearTimeout(cleanupTimeout);
   }, [sessionId, isBaseDocument, isLoading, evaluationResults]);