update token test

.env.example

@@ -1,3 +1,4 @@
-ENVIRONMENT=development
-HF_TOKEN=xxx
-HF_HOME=.cache
+ENVIRONEMENT=development
+HF_ORGANIZATION=yourbench
+HF_TOKEN=hf_xxx
+OPENAI_API_KEY=sk-proj-xxxx

backend/main.py

@@ -44,14 +44,21 @@ async def startup_event():
     hf_token = os.environ.get("HF_TOKEN")
     if hf_token:
         print("✅ HF_TOKEN AVAILABLE")
+        
+        # Basic format validation
+        if not hf_token.startswith("hf_"):
+            print("⚠️ WARNING: Your HF_TOKEN does not start with 'hf_' which is unusual.")
+            print("   Please verify its format and source.")
     else:
         print("❌ HF_TOKEN MISSING - HuggingFace models will not work correctly")
+        print("   Please set this environment variable for proper functionality.")
     
     hf_organization = os.environ.get("HF_ORGANIZATION")
     if hf_organization:
         print(f"✅ HF_ORGANIZATION: {hf_organization}")
     else:
         print("❌ HF_ORGANIZATION MISSING")
+        print("   This may affect billing and access to certain models.")
     
     print("\n===== Additional Environment Variables =====")
     # Afficher d'autres variables utiles
@@ -69,6 +76,11 @@ async def startup_event():
         print(f"✅ Found working model: {test_results['working_model']} with provider: {test_results['provider']}")
     else:
         print("❌ WARNING: No working models found. The application might not function correctly!")
+        print("\nPossible solutions:")
+        print("1. Check your HF_TOKEN is valid and has appropriate permissions")
+        print("2. Verify your internet connection")
+        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
 for router in routers:

backend/tasks/get_available_model_provider.py

@@ -36,7 +36,8 @@ def test_provider(model_name: str, provider: str, verbose: bool = False) -> bool
         hf_token = os.environ.get("HF_TOKEN")
         if not hf_token:
             if verbose:
-                logger.warning("HF_TOKEN not defined in environment, trying without token")
+                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)
             return _test_provider_without_token(model_name, provider, verbose)
         
@@ -79,7 +80,8 @@ def test_provider(model_name: str, provider: str, verbose: bool = False) -> bool
                     if "status_code=429" in error_message:
                         logger.warning(f"Provider {provider} rate limited. You may need to wait or upgrade your plan.")
                     elif "status_code=401" in error_message or "status_code=403" in error_message:
-                        logger.warning(f"Authentication failed for provider {provider}. Check your token.")
+                        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 verbose:
                             logger.info(f"Trying provider {provider} without authentication")
@@ -93,7 +95,8 @@ def test_provider(model_name: str, provider: str, verbose: bool = False) -> bool
             if "401" in str(auth_error) or "Unauthorized" in str(auth_error):
                 # En cas d'erreur d'authentification, essayer sans token
                 if verbose:
-                    logger.warning(f"Authentication error with {provider}: {str(auth_error)}. Trying without token.")
+                    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.")
                 return _test_provider_without_token(model_name, provider, verbose)
             else:
                 if verbose:
@@ -320,22 +323,99 @@ def test_models(verbose=True):
         "unavailable_models": []
     }
     
+    print("\n===== Checking HuggingFace Authentication =====")
     # Obtenez le jeton HF
     hf_token = os.environ.get("HF_TOKEN")
     if hf_token:
-        print("HF_TOKEN is available")
+        print("✅ HF_TOKEN is available")
+        
+        # Vérifier si le token a un format valide (vérification simple)
+        if not hf_token.startswith("hf_"):
+            print("⚠️ WARNING: Your HF_TOKEN does not start with 'hf_' which is unusual. Please verify its format.")
+        
+        # Masquer partiellement le token pour l'affichage
+        visible_chars = 4
+        masked_token = hf_token[:visible_chars] + "*" * (len(hf_token) - visible_chars * 2) + hf_token[-visible_chars:]
+        
+        # Vérifier la validité du token en testant directement l'API d'inférence
+        import requests
+        try:
+            # Test avec un modèle public simple (gpt2)
+            test_model = "gpt2"
+            api_url = f"https://api-inference.huggingface.co/models/{test_model}"
+            
+            print(f"Testing token {masked_token} with inference API on public model {test_model}...")
+            
+            headers = {"Authorization": f"Bearer {hf_token}"}
+            payload = {"inputs": "Hello, how are you?"}
+            
+            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é
+                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)
+                try:
+                    whoami_response = requests.get(
+                        "https://huggingface.co/api/whoami",
+                        headers={"Authorization": f"Bearer {hf_token}"}
+                    )
+                    
+                    if whoami_response.status_code == 200:
+                        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
+                        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
+                    pass
+            else:
+                print(f"❌ HF_TOKEN validation failed with status code: {response.status_code}")
+                error_message = "Unknown error"
+                try:
+                    error_data = response.json()
+                    if "error" in error_data:
+                        error_message = error_data["error"]
+                        print(f"❌ Error message: {error_message}")
+                except:
+                    print(f"❌ Error message: {response.text}")
+                
+                print("⚠️ Most model providers will not work with invalid credentials")
+                
+                # Test alternatif avec l'endpoint status
+                try:
+                    print("Attempting alternative validation with status endpoint...")
+                    status_url = "https://api-inference.huggingface.co/status"
+                    status_response = requests.get(status_url, headers=headers, timeout=10)
+                    
+                    if status_response.status_code == 200:
+                        print("✅ Token can access the status endpoint. This is partially good news.")
+                    else:
+                        print(f"❌ Status endpoint test also failed: {status_response.status_code}")
+                except Exception as e:
+                    print(f"❌ Alternative validation also failed: {str(e)}")
+        except Exception as e:
+            print(f"❌ Error validating HF_TOKEN with inference API: {str(e)}")
     else:
-        print("HF_TOKEN is missing")
+        print("❌ HF_TOKEN is missing - authentication to HuggingFace API will fail")
+        print("⚠️ Most models and providers require authentication")
 
     # Obtenez l'organisation HF
     hf_organization = os.environ.get("HF_ORGANIZATION")
     if hf_organization:
-        print(f"HF_ORGANIZATION is available: {hf_organization}")
+        print(f"✅ HF_ORGANIZATION is available: {hf_organization}")
     else:
-        print("HF_ORGANIZATION is missing")
+        print("ℹ️ HF_ORGANIZATION is not set")
     
     if verbose:
-        print(f"Testing main default model: {DEFAULT_BENCHMARK_MODEL}")
+        print(f"\n===== Testing main default model: {DEFAULT_BENCHMARK_MODEL} =====")
         
     # Test du modèle par défaut
     provider = get_available_model_provider(DEFAULT_BENCHMARK_MODEL, verbose=verbose)
@@ -367,6 +447,8 @@ def test_models(verbose=True):
         else:
             if verbose:
                 print("\n❌ ALL MODELS FAILED: No provider found for any model")
+                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
     models = [
@@ -380,7 +462,7 @@ def test_models(verbose=True):
     ]
     
     if verbose:
-        print("\n=== Testing all available models ===")
+        print("\n===== Testing all available models =====")
         
     for model in models:
         provider = get_available_model_provider(model, verbose)
@@ -391,14 +473,22 @@ def test_models(verbose=True):
             results["unavailable_models"].append(model)
     
     if verbose:
-        print("\n=== Results Summary ===")
-        for model, provider in results["available_models"]:
-            print(f"Model: {model}, Provider: {provider}")
+        print("\n===== Results Summary =====")
+        if results["available_models"]:
+            print("Models with available providers:")
+            for model, provider in results["available_models"]:
+                print(f"✅ Model: {model}, Provider: {provider}")
+        else:
+            print("❌ No models with available providers found")
+            print("⚠️ Please check your HF_TOKEN and permissions")
             
         if results["unavailable_models"]:
-            print(f"Models with no available providers: {', '.join(results['unavailable_models'])}")
+            print("\nModels with no available providers:")
+            for model in results["unavailable_models"]:
+                print(f"❌ {model}")
         
-        print(f"Total Available Models: {len(results['available_models'])}")
+        print(f"\nTotal Available Models: {len(results['available_models'])}")
+        print(f"Total Unavailable Models: {len(results['unavailable_models'])}")
     
     return results
         

backend/tests/check_hf_token.py

@@ -0,0 +1,283 @@
+#!/usr/bin/env python3
+# -*- 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.
+"""
+
+import os
+import sys
+import json
+import requests
+from datetime import datetime
+from dotenv import load_dotenv
+from argparse import ArgumentParser
+
+
+def color_text(text, color_code):
+    """Format text with color for terminal output."""
+    return f"\033[{color_code}m{text}\033[0m"
+
+
+def success(text):
+    """Format text as success message (green)."""
+    return color_text(f"✅ {text}", "92")
+
+
+def warning(text):
+    """Format text as warning message (yellow)."""
+    return color_text(f"⚠️ {text}", "93")
+
+
+def error(text):
+    """Format text as error message (red)."""
+    return color_text(f"❌ {text}", "91")
+
+
+def info(text):
+    """Format text as info message (blue)."""
+    return color_text(f"ℹ️ {text}", "94")
+
+
+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.
+    
+    Args:
+        token: Le token à vérifier
+        verbose: Afficher des informations détaillées
+    
+    Returns:
+        dict: Résultats de la vérification
+    """
+    results = {
+        "is_valid": False,
+        "token": None,
+        "error_message": None,
+        "can_access_inference": False
+    }
+    
+    # 1. Obtenir le token
+    if token is None:
+        token = os.environ.get("HF_TOKEN")
+    
+    if not token:
+        print(error("Aucun token trouvé. Veuillez spécifier un token avec --token ou définir la variable d'environnement HF_TOKEN."))
+        results["error_message"] = "No token provided"
+        return results
+    
+    # Masquer une partie du token pour l'affichage
+    visible_chars = 4
+    masked_token = token[:visible_chars] + "*" * (len(token) - visible_chars * 2) + token[-visible_chars:]
+    results["token"] = masked_token
+    
+    print(info(f"Token à vérifier: {masked_token}"))
+    
+    # 2. Vérifier le format basique
+    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
+    try:
+        # Test avec un modèle public simple
+        test_model = "gpt2"
+        api_url = f"https://api-inference.huggingface.co/models/{test_model}"
+        
+        print(info(f"Test du token avec l'API d'inférence sur le modèle public {test_model}..."))
+        
+        headers = {"Authorization": f"Bearer {token}"}
+        payload = {"inputs": "Hello, how are you?"}
+        
+        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
+            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."))
+            results["is_valid"] = True
+            results["can_access_inference"] = True
+            
+            if verbose and response.status_code == 200:
+                print(info("Résultat de l'inférence:"))
+                print(json.dumps(response.json(), indent=2))
+        else:
+            print(error(f"Échec du test de l'API d'inférence. Status code: {response.status_code}"))
+            results["error_message"] = response.text
+            
+            try:
+                error_data = response.json()
+                if "error" in error_data:
+                    print(error(f"Message d'erreur: {error_data['error']}"))
+                    results["error_message"] = error_data['error']
+            except:
+                print(error(f"Message d'erreur: {response.text}"))
+            
+            # En cas d'échec, tester aussi l'endpoint de liste des modèles
+            try:
+                print(info("Test alternatif avec la liste des modèles déployés..."))
+                list_url = "https://api-inference.huggingface.co/status"
+                list_response = requests.get(list_url, headers=headers, timeout=10)
+                
+                if list_response.status_code == 200:
+                    print(success("Le token peut accéder à la liste des modèles déployés"))
+                    results["can_access_inference"] = True
+                    results["is_valid"] = True
+                else:
+                    print(error(f"Échec de l'accès à la liste des modèles. Status code: {list_response.status_code}"))
+            except Exception as e:
+                print(error(f"Erreur lors du test alternatif: {str(e)}"))
+                
+    except Exception as e:
+        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
+    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
+            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
+                org_url = f"https://huggingface.co/api/models?author={org}"
+                org_response = requests.get(org_url, headers=headers, timeout=10)
+                
+                if org_response.status_code == 200:
+                    print(success(f"Accès autorisé aux modèles de l'organisation {org}"))
+                else:
+                    print(warning(f"Le token n'a pas accès aux modèles de l'organisation {org}"))
+        except Exception as e:
+            print(error(f"Erreur lors du test des permissions: {str(e)}"))
+    
+    return results
+
+
+def check_model_access(token, model, verbose=False):
+    """
+    Vérifie si le token a accès à un modèle spécifique.
+    
+    Args:
+        token: Token HF à vérifier
+        model: Nom du modèle à tester
+        verbose: Afficher des informations détaillées
+    
+    Returns:
+        bool: True si le modèle est accessible, False sinon
+    """
+    print(f"\n" + info(f"Test d'accès au modèle: {model}"))
+    
+    headers = {
+        "Authorization": f"Bearer {token}"
+    }
+    
+    # 1. Vérifier si le modèle existe et est accessible via l'API d'inférence
+    try:
+        api_url = f"https://api-inference.huggingface.co/models/{model}"
+        payload = {"inputs": "Hello, test access"}
+        
+        print(info(f"Test d'accès à l'API d'inférence pour {model}..."))
+        
+        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 == 200:
+                print(success(f"Accès réussi à l'API d'inférence pour {model}"))
+                return True
+            else:
+                print(success(f"Accès autorisé pour {model} (modèle en cours de chargement)"))
+                return True
+        else:
+            error_message = "Unknown error"
+            try:
+                error_data = response.json()
+                if "error" in error_data:
+                    error_message = error_data["error"]
+            except:
+                error_message = response.text
+                
+            print(error(f"Échec d'accès à l'API d'inférence pour {model}: {response.status_code}"))
+            print(error(f"Message: {error_message}"))
+            
+            # Analyse de l'erreur
+            if "quota" in error_message.lower() or "rate" in error_message.lower():
+                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é
+            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"))
+            
+            # Faire un test alternatif via l'API du Hub
+            try:
+                print(info(f"Test alternatif via l'API du Hub pour {model}..."))
+                hub_url = f"https://huggingface.co/api/models/{model}"
+                hub_response = requests.get(hub_url, headers=headers, timeout=10)
+                
+                if hub_response.status_code == 200:
+                    print(warning(f"Le modèle {model} existe et est accessible via l'API Hub, mais pas via l'API d'inférence"))
+                    print(info("Cela peut être dû à des restrictions sur le modèle ou à des problèmes temporaires de l'API"))
+                    if verbose:
+                        model_info = hub_response.json()
+                        if model_info.get("private", False):
+                            print(info("Ce modèle est privé"))
+                        if model_info.get("gated", False):
+                            print(info("Ce modèle est à accès restreint (gated)"))
+                else:
+                    print(error(f"Le modèle {model} n'est pas accessible via l'API Hub non plus: {hub_response.status_code}"))
+            except Exception as e:
+                print(error(f"Erreur lors du test alternatif: {str(e)}"))
+                
+            return False
+            
+    except Exception as e:
+        print(error(f"Erreur lors du test d'accès au modèle: {str(e)}"))
+        return False
+
+
+def main():
+    parser = ArgumentParser(description="Vérifiez les propriétés d'un token Hugging Face")
+    parser.add_argument("--token", type=str, help="Token Hugging Face à vérifier (si non spécifié, utilise HF_TOKEN)")
+    parser.add_argument("--verbose", "-v", action="store_true", help="Afficher des informations détaillées")
+    parser.add_argument("--test-model", "-m", type=str, help="Tester l'accès à un modèle spécifique")
+    parser.add_argument("--test-premium", action="store_true", help="Tester l'accès aux modèles premium courants")
+    
+    args = parser.parse_args()
+    
+    # Charger les variables d'environnement
+    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
+    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_info["is_valid"]:
+        if args.test_model:
+            check_model_access(token, args.test_model, args.verbose)
+        
+        if args.test_premium:
+            print("\n" + info("=== Test d'accès aux modèles premium ==="))
+            premium_models = [
+                "meta-llama/Llama-3.3-70B-Instruct",
+                "mistralai/Mistral-Small-24B-Instruct-2501",
+                "deepseek-ai/DeepSeek-R1-Distill-Llama-70B"
+            ]
+            
+            for model in premium_models:
+                result = check_model_access(token, model, args.verbose)
+                print(info(f"Résultat pour {model}: {success('Accessible') if result else error('Non accessible')}"))
+                print("-" * 50)
+
+
+if __name__ == "__main__":
+    main()