Update backend/utils.py

backend/utils.py

@@ -8,10 +8,10 @@ import os
 import re
 
 # Configuration
-MAX_PDF_PAGES = 50
-MAX_TEXT_LENGTH = 50000
-CHUNK_SIZE = 2000
-MAX_CHUNK_RETRIES = 3
+MAX_PDF_PAGES = 50  # Limite de pages PDF à traiter
+MAX_TEXT_LENGTH = 50000  # Limite de caractères
+CHUNK_SIZE = 2000  # Taille des morceaux de texte à traduire
+MAX_CHUNK_RETRIES = 3  # Nombre de tentatives en cas d'échec
 
 # Logging
 logging.basicConfig(
@@ -25,38 +25,51 @@ os.makedirs('/cache/huggingface', exist_ok=True)
 os.environ['TRANSFORMERS_CACHE'] = '/cache/huggingface'
 os.environ['HF_HOME'] = '/cache/huggingface'
 
-# Modèles de traduction par langue
+# Modèles de traduction spécifiques par langue
 TRANSLATION_MODELS = {
-    'en': 'Helsinki-NLP/opus-mt-fr-en',
-    'es': 'Helsinki-NLP/opus-mt-fr-es',
-    'ar': 'Helsinki-NLP/opus-mt-fr-ar',
-    'de': 'Helsinki-NLP/opus-mt-fr-de'
+    'en': {'model': 'Helsinki-NLP/opus-mt-fr-en', 'src': 'fr', 'tgt': 'en'},
+    'es': {'model': 'Helsinki-NLP/opus-mt-fr-es', 'src': 'fr', 'tgt': 'es'},
+    'ar': {'model': 'Helsinki-NLP/opus-mt-fr-ar', 'src': 'fr', 'tgt': 'ar'},
+    'de': {'model': 'Helsinki-NLP/opus-mt-fr-de', 'src': 'fr', 'tgt': 'de'}
 }
 
+# Dictionnaire pour stocker les modèles chargés
 translators = {}
 
-def init_translator(target_lang='en') -> pipeline:
-    """Initialise le modèle de traduction pour la langue cible"""
+def load_translation_model(target_lang='en'):
+    """Charge le modèle de traduction pour la langue cible"""
     try:
         if target_lang not in translators:
-            logger.info(f"Chargement du modèle {target_lang}...")
-            model_name = TRANSLATION_MODELS.get(target_lang, TRANSLATION_MODELS['en'])
+            if target_lang not in TRANSLATION_MODELS:
+                raise ValueError(f"Langue non supportée: {target_lang}")
+            
+            config = TRANSLATION_MODELS[target_lang]
+            logger.info(f"Chargement du modèle {target_lang} ({config['model']})...")
+            
             translators[target_lang] = pipeline(
                 "translation",
-                model=model_name,
-                device=-1,
+                model=config['model'],
+                src_lang=config['src'],
+                tgt_lang=config['tgt'],
+                device=-1,  # CPU
                 torch_dtype="auto"
             )
-            logger.info(f"✅ Modèle {target_lang} chargé")
+            logger.info(f"✅ Modèle {target_lang} chargé avec succès")
+        
         return translators[target_lang]
+    
     except Exception as e:
         logger.error(f"❌ Erreur de chargement du modèle {target_lang}: {str(e)}")
         return None
 
 def extract_text_from_file(file_bytes: bytes, filename: str) -> str:
-    """Extrait le texte des fichiers avec gestion des limites"""
+    """
+    Extrait le texte des fichiers avec gestion des limites
+    Retourne: texte ou message d'erreur commençant par "Erreur:"
+    """
     try:
-        if len(file_bytes) > 10 * 1024 * 1024:
+        # Vérification taille
+        if len(file_bytes) > 10 * 1024 * 1024:  # 10MB
             return "Erreur: Fichier trop volumineux (>10MB)"
 
         if filename.lower().endswith('.pdf'):
@@ -88,15 +101,19 @@ def extract_text_from_file(file_bytes: bytes, filename: str) -> str:
         return f"Erreur: Impossible de lire le fichier ({str(e)})"
 
 def translate_text(text: str, target_lang: str = "en") -> str:
-    """Traduit le texte vers la langue cible"""
+    """
+    Traduit le texte vers la langue cible avec gestion d'erreur
+    Retourne: traduction ou message d'erreur commençant par "Erreur:"
+    """
     if not text.strip():
         return "Erreur: Aucun texte à traduire"
 
-    translator = init_translator('en')  
+    translator = load_translation_model(target_lang)
     if translator is None:
-        return "Erreur: Service de traduction indisponible"
+        return f"Erreur: Service de traduction {target_lang} indisponible"
 
     try:
+        # Découpage intelligent en chunks
         sentences = re.split(r'(?<=[.!?])\s+', text)
         chunks = []
         current_chunk = ""
@@ -111,25 +128,30 @@ def translate_text(text: str, target_lang: str = "en") -> str:
         if current_chunk.strip():
             chunks.append(current_chunk.strip())
 
+        logger.info(f"Traduction en {target_lang} - {len(chunks)} chunks")
+        
         translated = []
         for i, chunk in enumerate(chunks, 1):
+            logger.info(f"Traitement du chunk {i}/{len(chunks)}")
+            
             for attempt in range(MAX_CHUNK_RETRIES):
                 try:
-                    result = translator(chunk, max_length=CHUNK_SIZE + 1000)
+                    result = translator(chunk, max_length=CHUNK_SIZE+1000)
                     translated.append(result[0]['translation_text'])
                     break
                 except Exception as chunk_error:
                     if attempt == MAX_CHUNK_RETRIES - 1:
-                        logger.error(f"Échec sur chunk {i}: {str(chunk_error)}")
-                        translated.append(f"[TEXT NON TRADUIT]")
+                        logger.error(f"Échec après {MAX_CHUNK_RETRIES} tentatives")
+                        translated.append(f"[TEXTE NON TRADUIT]")
                     else:
                         chunk = chunk[:len(chunk)//2]
+                        logger.warning(f"Nouvelle tentative avec chunk réduit")
 
         return " ".join(translated)
-        # Initialisation d'un traducteur par défaut au chargement
-        default_translator = init_translator('en')
 
     except Exception as e:
-        logger.error(f"Erreur traduction: {str(e)}")
+        logger.error(f"Erreur traduction {target_lang}: {str(e)}")
         return f"Erreur: Échec de la traduction ({str(e)})"
-        
+
+# Initialisation du modèle anglais par défaut au démarrage
+default_translator = load_translation_model('en')