Update app.py

app.py

@@ -143,6 +143,71 @@ def upload_file_to_genai_api(file_data, filename, mime_type):
             pass
         return None
 
+def call_gemini_with_fallback(contents, task_id):
+    """Appelle Gemini 2.5 Pro en premier, puis 2.5 Flash en cas d'échec."""
+    models_to_try = [
+        {"name": "gemini-2.5-pro", "display_name": "Gemini 2.5 Pro"},
+        {"name": "gemini-2.5-flash", "display_name": "Gemini 2.5 Flash"}
+    ]
+    
+    last_error = None
+    
+    for i, model_info in enumerate(models_to_try):
+        model_name = model_info["name"]
+        model_display = model_info["display_name"]
+        
+        try:
+            logger.info(f"[Task {task_id}] Tentative {i+1}/2: Appel de {model_display}...")
+            
+            # Mettre à jour le statut pour indiquer quel modèle est en cours d'utilisation
+            if model_name == "gemini-2.5-pro":
+                task_results[task_id]['status'] = 'generating_latex_pro'
+                task_results[task_id]['current_model'] = 'Gemini 2.5 Pro'
+            else:
+                task_results[task_id]['status'] = 'generating_latex_flash'
+                task_results[task_id]['current_model'] = 'Gemini 2.5 Flash (fallback)'
+            
+            # Faire l'appel à l'API
+            gemini_response = client.models.generate_content(
+                model=model_name, 
+                contents=contents,
+                config=types.GenerateContentConfig(tools=[types.Tool(code_execution=types.ToolCodeExecution)])
+            )
+            
+            # Vérifier si la réponse est valide
+            full_latex_response = ""
+            if gemini_response.candidates and gemini_response.candidates[0].content and gemini_response.candidates[0].content.parts:
+                for part in gemini_response.candidates[0].content.parts:
+                    if hasattr(part, 'text') and part.text:
+                        full_latex_response += part.text
+            
+            if not full_latex_response.strip():
+                raise ValueError(f"Réponse vide de {model_display}")
+            
+            logger.info(f"[Task {task_id}] ✓ Succès avec {model_display}")
+            task_results[task_id]['used_model'] = model_display
+            return full_latex_response
+            
+        except Exception as e:
+            error_msg = str(e)
+            logger.warning(f"[Task {task_id}] ✗ Échec avec {model_display}: {error_msg}")
+            last_error = e
+            
+            # Si c'est le dernier modèle et qu'il a échoué, on lève l'erreur
+            if i == len(models_to_try) - 1:
+                logger.error(f"[Task {task_id}] Tous les modèles ont échoué. Dernière erreur: {error_msg}")
+                task_results[task_id]['model_failures'] = [
+                    f"{models_to_try[0]['display_name']}: Échec",
+                    f"{models_to_try[1]['display_name']}: {error_msg}"
+                ]
+                raise last_error
+            
+            # Attendre un peu avant d'essayer le modèle suivant
+            time.sleep(2)
+    
+    # Cette ligne ne devrait jamais être atteinte, mais au cas où
+    raise last_error if last_error else Exception("Erreur inconnue lors des appels aux modèles Gemini")
+
 def get_all_tasks_info():
     """Récupère toutes les informations des tâches pour le centre de gestion."""
     tasks_info = []
@@ -159,6 +224,9 @@ def get_all_tasks_info():
             'pdf_filename': task_data.get('pdf_filename'),
             'error': task_data.get('error'),
             'response': task_data.get('response', ''),
+            'used_model': task_data.get('used_model', 'N/A'),
+            'current_model': task_data.get('current_model', ''),
+            'model_failures': task_data.get('model_failures', []),
             'user_images': []
         }
         
@@ -181,6 +249,10 @@ def get_system_stats():
     error_tasks = sum(1 for task in task_results.values() if task['status'] == 'error')
     pending_tasks = sum(1 for task in task_results.values() if task['status'] not in ['completed', 'error'])
     
+    # Statistiques d'utilisation des modèles
+    pro_usage = sum(1 for task in task_results.values() if task.get('used_model') == 'Gemini 2.5 Pro')
+    flash_usage = sum(1 for task in task_results.values() if task.get('used_model') == 'Gemini 2.5 Flash (fallback)')
+    
     # Compter les fichiers PDF générés
     pdf_files = 0
     if os.path.exists(GENERATED_PDF_DIR):
@@ -198,7 +270,9 @@ def get_system_stats():
         'pending_tasks': pending_tasks,
         'pdf_files': pdf_files,
         'user_images': user_images,
-        'latex_installed': IS_LATEX_INSTALLED
+        'latex_installed': IS_LATEX_INSTALLED,
+        'pro_usage': pro_usage,
+        'flash_usage': flash_usage
     }
 
 def clean_latex_code(latex_code):
@@ -328,24 +402,11 @@ def process_files_background(task_id, files_data, resolution_style):
             raise ValueError(f"Le fichier de prompt pour le style '{resolution_style}' est introuvable ou vide.")
         contents.append(prompt_to_use)
 
-        task_results[task_id]['status'] = 'generating_latex'
-        logger.info(f"[Task {task_id}] Envoi de la requête à l'API Gemini (modèle gemini-2.5-flash) avec {len(uploaded_file_refs)} fichier(s).")
-        
-        gemini_response = client.models.generate_content(
-            model="gemini-2.5-flash", 
-            contents=contents,
-            config=types.GenerateContentConfig(tools=[types.Tool(code_execution=types.ToolCodeExecution)])
-        )
-
-        logger.info(f"[Task {task_id}] Réponse reçue de Gemini.")
-        full_latex_response = ""
-        if gemini_response.candidates and gemini_response.candidates[0].content and gemini_response.candidates[0].content.parts:
-            for part in gemini_response.candidates[0].content.parts:
-                if hasattr(part, 'text') and part.text:
-                    full_latex_response += part.text
-        
-        if not full_latex_response.strip():
-            raise ValueError("La réponse de Gemini était vide.")
+        # Appeler Gemini avec fallback Pro -> Flash
+        logger.info(f"[Task {task_id}] Début des appels aux modèles Gemini avec {len(uploaded_file_refs)} fichier(s).")
+        full_latex_response = call_gemini_with_fallback(contents, task_id)
+
+        logger.info(f"[Task {task_id}] Réponse reçue de Gemini ({task_results[task_id].get('used_model', 'modèle inconnu')}).")
         logger.debug(f"[Task {task_id}] Réponse brute de Gemini:\n---\n{full_latex_response[:500]}...\n---")
 
         task_results[task_id]['status'] = 'cleaning_latex'
@@ -359,8 +420,9 @@ def process_files_background(task_id, files_data, resolution_style):
         if pdf_file_path:
             task_results[task_id]['status'] = 'completed'
             task_results[task_id]['pdf_filename'] = os.path.basename(pdf_file_path)
-            task_results[task_id]['response'] = f"PDF généré avec succès: {os.path.basename(pdf_file_path)}"
-            logger.info(f"[Task {task_id}] Tâche terminée avec succès. PDF: {os.path.basename(pdf_file_path)}")
+            used_model = task_results[task_id].get('used_model', 'modèle inconnu')
+            task_results[task_id]['response'] = f"PDF généré avec succès: {os.path.basename(pdf_file_path)} (généré par {used_model})"
+            logger.info(f"[Task {task_id}] Tâche terminée avec succès. PDF: {os.path.basename(pdf_file_path)} (modèle: {used_model})")
         else:
             raise RuntimeError(f"Échec de la génération du PDF: {pdf_message}")
 
@@ -515,7 +577,14 @@ def get_task_status(task_id):
         logger.warning(f"Tentative d'accès à une tâche inexistante: {task_id}")
         return jsonify({'error': 'Tâche introuvable'}), 404
     
-    response_data = {'status': task['status'], 'response': task.get('response'), 'error': task.get('error')}
+    response_data = {
+        'status': task['status'], 
+        'response': task.get('response'), 
+        'error': task.get('error'),
+        'current_model': task.get('current_model', ''),
+        'used_model': task.get('used_model', ''),
+        'model_failures': task.get('model_failures', [])
+    }
     if task['status'] == 'completed':
         response_data['download_url'] = f"/download/{task_id}"
         
@@ -527,6 +596,8 @@ def stream_task_progress(task_id):
     def generate():
         logger.info(f"Nouvelle connexion de streaming (SSE) pour la tâche {task_id}")
         last_status_sent = None
+        last_model_sent = None
+        
         while True:
             task = task_results.get(task_id)
             if not task:
@@ -535,17 +606,27 @@ def stream_task_progress(task_id):
                 break
             
             current_status = task['status']
-            if current_status != last_status_sent:
-                data_to_send = {"status": current_status}
+            current_model = task.get('current_model', '')
+            
+            # Envoyer une mise à jour si le statut ou le modèle a changé
+            if current_status != last_status_sent or current_model != last_model_sent:
+                data_to_send = {
+                    "status": current_status,
+                    "current_model": current_model,
+                    "used_model": task.get('used_model', '')
+                }
+                
                 if current_status == 'completed':
                     data_to_send["response"] = task.get("response", "")
                     data_to_send["download_url"] = f"/download/{task_id}"
                 elif current_status == 'error':
                     data_to_send["error"] = task.get("error", "Erreur inconnue")
+                    data_to_send["model_failures"] = task.get("model_failures", [])
 
-                logger.info(f"[Task {task_id}] Envoi de la mise à jour de statut via SSE: {current_status}")
+                logger.info(f"[Task {task_id}] Envoi de la mise à jour de statut via SSE: {current_status} ({current_model})")
                 yield f'data: {json.dumps(data_to_send)}\n\n'
                 last_status_sent = current_status
+                last_model_sent = current_model
             
             if current_status in ['completed', 'error']:
                 logger.info(f"Fermeture de la connexion SSE pour la tâche terminée/échouée {task_id}")