refactor: Amélioration de la robustesse de la détection de langue avec gestion des erreurs et fallback

core/DetectLanguage.py

@@ -2,6 +2,7 @@
 from os import getenv
 from typing import Optional
 import requests
+import streamlit as st
 
 from openai import OpenAI
 
@@ -12,7 +13,24 @@ def detect_language(input_text: str,
                     ) -> str:
     """
     Détecte la langue d'un texte donné avec une vérification croisée si doute.
+
+    Args:
+        input_text (str): Le texte dont la langue doit être détectée.
+        temperature (Optional[float]): Paramètre de température pour l'API. Par défaut 0.2.
+        context_window (Optional[int]): Taille de la fenêtre de contexte. Par défaut 128.
+        model (Optional[str]): Modèle à utiliser. Par défaut "gpt-4o-mini".
+
+    Returns:
+        str: Code de langue ISO-639-1 détecté.
+
+    Raises:
+        ValueError: Si le texte est vide ou invalide.
+        requests.RequestException: Si une erreur de communication avec l'API se produit.
     """
+    if not input_text or not isinstance(input_text, str):
+        st.error("Erreur : Le texte à analyser est vide ou invalide")
+        return "en"  # Fallback sur l'anglais par défaut
+
     system_prompt = (
         "Agissez comme une fonction de détection de langue. "
         "Fournissez la langue d'entrée au format ISO-639-1. "
@@ -20,40 +38,60 @@ def detect_language(input_text: str,
     )
     
     try:
-        client = OpenAI(api_key=getenv("OPENAI_API_KEY"))
+        # Vérifier la clé API
+        api_key = getenv("OPENAI_API_KEY")
+        if not api_key:
+            raise ValueError("Clé API OpenAI non trouvée dans les variables d'environnement")
+
+        client = OpenAI(api_key=api_key)
+
+        # Appel à l'API avec gestion du timeout
+        try:
+            response = client.chat.completions.create(
+                model=model,
+                temperature=temperature,
+                messages=[
+                    {
+                        "role": "system",
+                        "content": system_prompt
+                    },
+                    {
+                        "role": "user",
+                        "content": input_text
+                    }
+                ],
+                max_tokens=context_window,
+                timeout=10  # Timeout de 10 secondes
+            )
+        except requests.Timeout:
+            st.warning("Délai d'attente dépassé pour la détection de langue, utilisation du modèle de secours")
+            return call_precise_language_model(input_text)
 
-        response = client.chat.completions.create(
-            model=model,
-            temperature=temperature,
-            messages=[
-                {
-                    "role": "system",
-                    "content": system_prompt
-                },
-                {
-                    "role": "user",
-                    "content": input_text
-                }
-            ],
-            max_tokens=context_window
-        )
+        if not response or not response.choices:
+            raise ValueError("Réponse invalide de l'API")
 
         detected_language = response.choices[0].message.content.strip()
 
-        # Si le modèle indique un doute, faire appel à un modèle plus précis ou à un autre service de vérification
+        # Vérification de la validité du code de langue
+        if not detected_language or len(detected_language) < 2:
+            raise ValueError("Code de langue invalide reçu de l'API")
+
+        # Si le modèle indique un doute, faire appel à un modèle plus précis
         if "doute" in detected_language.lower():
-            print("[INFO] - (detect_language) : Doute détecté, appel d'un modèle plus précis.")
+            st.info("Doute sur la détection de langue, utilisation du modèle de secours")
             return call_precise_language_model(input_text)
 
-        if detected_language:
-            return detected_language
-        else:
-            raise ValueError("La réponse de l'API est vide ou invalide.")
-    
+        return detected_language
+
     except requests.RequestException as e:
-        raise requests.RequestException(f"Erreur de communication avec l'API : {str(e)}")
+        st.error(f"Erreur de communication avec l'API : {e}")
+        return "en"  # Fallback sur l'anglais
+    except ValueError as e:
+        st.error(f"Erreur de configuration : {e}")
+        return "en"  # Fallback sur l'anglais
     except Exception as e:
-        raise ValueError(f"Erreur inattendue lors de la détection de la langue : {str(e)}")
+        st.error(f"Erreur inattendue lors de la détection de la langue : {e}")
+        return "en"  # Fallback sur l'anglais
 
 def call_precise_language_model(input_text: str) -> str:
     """