Update app.py

app.py

@@ -3,10 +3,12 @@ import json
 import mimetypes
 import time
 import re # Pour la détection d'URL YouTube
+import traceback # Ajout pour afficher les tracebacks complets
+
 from flask import Flask, request, session, jsonify, redirect, url_for, flash, render_template
 from dotenv import load_dotenv
 from google import genai
-from google.genai import types
+from google.genai import types # Important pour Part, FileData, etc.
 import requests
 from werkzeug.utils import secure_filename
 import markdown # Pour convertir la réponse Markdown en HTML
@@ -36,22 +38,38 @@ os.makedirs(UPLOAD_FOLDER, exist_ok=True)
 print(f"Dossier d'upload configuré : {os.path.abspath(UPLOAD_FOLDER)}")
 
 # --- Configuration de l'API Gemini ---
-# Utilisez les noms de modèles les plus récents auxquels vous avez accès
-MODEL_FLASH = 'gemini-2.0-flash'
-MODEL_PRO = 'gemini-2.5-pro-exp-03-25' # Pro est souvent nécessaire/meilleur pour la vidéo
+# Utilisez les noms de modèles spécifiés
+MODEL_FLASH = 'gemini-2.0-flash' # Mis à jour
+MODEL_PRO = 'gemini-2.5-pro-exp-03-25' # Mis à jour - Pro est souvent nécessaire/meilleur pour la vidéo
 
 # Instruction système pour le modèle
 SYSTEM_INSTRUCTION = "Tu es un assistant intelligent et amical nommé Mariam. Tu assistes les utilisateurs au mieux de tes capacités, y compris dans l'analyse de texte, d'images et de vidéos (via upload ou lien YouTube). Tu as été créé par Aenir."
 
-# Paramètres de sécurité (ajuster si nécessaire, BLOCK_NONE est très permissif)
-SAFETY_SETTINGS = [ {"category": c, "threshold": "BLOCK_NONE"} for c in [
-"HARM_CATEGORY_HARASSMENT", "HARM_CATEGORY_HATE_SPEECH",
-"HARM_CATEGORY_SEXUALLY_EXPLICIT", "HARM_CATEGORY_DANGEROUS_CONTENT"]]
+# Paramètres de sécurité (ajuster si nécessaire)
+# Utilisation de la structure attendue par GenerateContentConfig
+SAFETY_SETTINGS_CONFIG = [
+    types.SafetySetting(
+      category=types.HarmCategory.HARM_CATEGORY_HATE_SPEECH,
+      threshold=types.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
+    ),
+    types.SafetySetting(
+      category=types.HarmCategory.HARM_CATEGORY_HARASSMENT,
+      threshold=types.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
+    ),
+    types.SafetySetting(
+      category=types.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
+      threshold=types.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
+    ),
+    types.SafetySetting(
+      category=types.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
+      threshold=types.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
+    )
+]
+
 
 GEMINI_CONFIGURED = False
 gemini_client = None # Client API pour les opérations sur les fichiers (upload vidéo)
 
-
 try:
     gemini_api_key = os.getenv("GOOGLE_API_KEY")
     if not gemini_api_key:
@@ -59,20 +77,29 @@ try:
 
     # Initialise le client pour les opérations sur les fichiers ET pour lister les modèles
     gemini_client = genai.Client(api_key=gemini_api_key)
-    # Configure également l'espace de noms global pour GenerativeModel, etc.
-    # genai.configure(api_key=gemini_api_key) # Cette ligne peut être redondante si le client est utilisé partout
+    # Configure également l'espace de noms global pour GenerativeModel, etc. (Peut être redondant si client est utilisé)
+    # genai.configure(api_key=gemini_api_key)
 
-    # Vérifie si les modèles requis sont disponibles en utilisant le client
+    # Vérifie si les modèles requis sont disponibles en utilisant le client (Correction: client.models.list())
     print("Vérification des modèles Gemini disponibles...")
-    models_list = [m.name for m in gemini_client.models.list()] # <-- LIGNE CORRIGÉE
-    required_models = [f'models/{MODEL_FLASH}', f'models/{MODEL_PRO}']
-    if all(model in models_list for model in required_models):
-         print(f"Configuration Gemini effectuée. Modèles requis trouvés.")
+    # Note: l'API liste les modèles sans le préfixe 'models/', on l'ajoute pour la comparaison
+    available_models_full_names = [m.name for m in gemini_client.models.list()]
+    required_models_prefixes = [MODEL_FLASH, MODEL_PRO] # Noms courts
+    # Vérifie si les modèles requis (commençant par les noms courts) existent dans la liste complète
+    models_found = {req: False for req in required_models_prefixes}
+    for available in available_models_full_names:
+        for req in required_models_prefixes:
+            # Vérifie si le nom disponible commence par 'models/' suivi du nom requis
+            if available.startswith(f'models/{req}'):
+                models_found[req] = True
+
+    if all(models_found.values()):
+         print(f"Configuration Gemini effectuée. Modèles requis ({', '.join(required_models_prefixes)}) trouvés.")
          print(f"Instruction Système: {SYSTEM_INSTRUCTION}")
          GEMINI_CONFIGURED = True
     else:
-        missing = [model for model in required_models if model not in models_list]
-        raise ValueError(f"Les modèles Gemini requis suivants sont manquants: {missing}")
+        missing = [req for req, found in models_found.items() if not found]
+        raise ValueError(f"Les modèles Gemini requis suivants (ou commençant par) sont manquants : {missing}")
 
 
 except Exception as e:
@@ -81,7 +108,6 @@ except Exception as e:
     gemini_client = None # S'assure que le client est None si la config échoue
     GEMINI_CONFIGURED = False # S'assurer qu'il est False en cas d'erreur
 
-
 # --- Fonctions Utilitaires ---
 
 def get_file_extension(filename):
@@ -127,7 +153,7 @@ def upload_video_with_polling(filepath, mime_type, max_wait_seconds=300, poll_in
 
         start_time = time.time()
         # Boucle de polling tant que l'état est "PROCESSING"
-        while video_file.state == genai.types.FileState.PROCESSING:
+        while video_file.state == types.FileState.PROCESSING: # Utilise types.FileState
             elapsed_time = time.time() - start_time
             # Vérifie le timeout
             if elapsed_time > max_wait_seconds:
@@ -139,11 +165,11 @@ def upload_video_with_polling(filepath, mime_type, max_wait_seconds=300, poll_in
             video_file = gemini_client.files.get(name=video_file.name)
 
         # Vérifie l'état final après la boucle
-        if video_file.state == genai.types.FileState.FAILED:
+        if video_file.state == types.FileState.FAILED: # Utilise types.FileState
             print(f"ERREUR: Le traitement de la vidéo a échoué. État: {video_file.state.name}")
             raise ValueError("Le traitement de la vidéo a échoué côté serveur.")
 
-        if video_file.state == genai.types.FileState.ACTIVE:
+        if video_file.state == types.FileState.ACTIVE: # Utilise types.FileState
             print(f"Traitement vidéo terminé avec succès: {video_file.uri}")
             return video_file # Retourne l'objet fichier SDK réussi
 
@@ -187,7 +213,7 @@ def format_search_results(data):
             results.append(f"- {item.get('title', '')}: {item.get('snippet', '')}")
         return "\n".join(results)
 
-# --- Préparation Historique (inchangé) ---
+# --- Préparation Historique (Corrigé pour utiliser types.Part) ---
 
 def prepare_gemini_history(chat_history):
     """Convertit l'historique de session pour l'API Gemini (texte seulement)."""
@@ -195,10 +221,14 @@ def prepare_gemini_history(chat_history):
     for message in chat_history:
         # Ne transmet que le texte brut des messages précédents
         role = 'user' if message['role'] == 'user' else 'model'
-        text_part = message.get('raw_text', '') # Utilise raw_text stocké
+        raw_text_content = message.get('raw_text', '') # Utilise raw_text stocké
+
         # Ne pas inclure les fichiers/médias des tours précédents pour simplifier
-        if text_part: # N'ajoute que s'il y a du texte
-            gemini_history.append({'role': role, 'parts': [text_part]})
+        if raw_text_content: # N'ajoute que s'il y a du texte
+            # Correction: Créer un objet Part pour le texte
+            text_part_object = types.Part(text=raw_text_content)
+            # Ajouter le dictionnaire avec le rôle et la liste contenant l'objet Part
+            gemini_history.append({'role': role, 'parts': [text_part_object]})
     return gemini_history
 
 # --- Routes Flask ---
@@ -206,7 +236,14 @@ def prepare_gemini_history(chat_history):
 @app.route('/')
 def root():
     """Sert la page HTML principale."""
-    return render_template('index.html')
+    # Assurez-vous d'avoir un fichier templates/index.html
+    try:
+        return render_template('index.html')
+    except Exception as e:
+        # Retourne une erreur simple si le template n'est pas trouvé
+        print(f"Erreur lors du rendu du template index.html: {e}")
+        return "Erreur: Impossible de charger la page principale. Vérifiez que 'templates/index.html' existe.", 500
+
 
 @app.route('/api/history', methods=['GET'])
 def get_history():
@@ -283,20 +320,33 @@ def chat_api():
                 # Appel bloquant qui attend le traitement
                 processed_media_file = upload_video_with_polling(filepath, mime_type)
                 # Crée le Part Gemini à partir de l'objet File retourné
-                uploaded_media_part = genai.types.Part(file_data=processed_media_file)
+                uploaded_media_part = types.Part(file_data=processed_media_file) # Utilise types.Part
             else:
                 print("  Traitement FICHIER standard...")
                 # Utilise l'upload global plus simple pour les non-vidéos
-                processed_media_file = genai.upload_file(path=filepath, mime_type=mime_type)
-                uploaded_media_part = genai.types.Part(file_data=processed_media_file)
+                # Note: genai.upload_file n'existe pas directement, utiliser client.files.upload
+                # S'il s'agit d'une image ou autre fichier non-vidéo, l'upload avec polling peut
+                # retourner rapidement si le traitement est rapide, ou on peut simplifier.
+                # Utilisons le client ici aussi pour la cohérence.
+                print(f"  Upload via client.files pour fichier non-vidéo: {filepath}")
+                processed_media_file = gemini_client.files.upload(path=filepath, mime_type=mime_type)
+                # Pas besoin de polling complexe ici en général, on suppose que c'est rapide.
+                # On peut ajouter un petit wait ou une vérification simple si nécessaire.
+                # Attente très courte pour s'assurer que l'état passe à ACTIVE (simplifié)
+                time.sleep(2)
+                processed_media_file = gemini_client.files.get(name=processed_media_file.name)
+                if processed_media_file.state != types.FileState.ACTIVE:
+                     print(f"AVERTISSEMENT: Fichier non-vidéo '{processed_media_file.name}' n'est pas ACTIF après upload ({processed_media_file.state.name}). Tentative de continuer.")
+                     # On pourrait lever une erreur ici si l'état ACTIVE est crucial
+                     # raise RuntimeError(f"Échec de l'activation du fichier {processed_media_file.name}")
+
+                uploaded_media_part = types.Part(file_data=processed_media_file) # Utilise types.Part
             print(f"  Part Média ({media_type}) créé: {processed_media_file.uri}")
 
         # 2. Sinon, traiter l'URL YouTube si fournie et valide
         elif youtube_url:
              if not is_youtube_url(youtube_url):
                  print(f"  AVERTISSEMENT: '{youtube_url}' n'est pas un lien YouTube valide, sera ignoré ou traité comme texte si prompt vide.")
-                 # Si le prompt est aussi vide, on ne fait rien de spécial ici,
-                 # la validation initiale aurait dû échouer. Si prompt existe, il sera traité.
                  media_type = 'text' # Considéré comme texte simple si invalide
              else:
                 is_media_request = True
@@ -305,12 +355,10 @@ def chat_api():
                 uploaded_filename_for_display = youtube_url # Affiche l'URL pour l'utilisateur
                 youtube_uri = youtube_url # Utilise l'URL validée comme URI
                 # Crée un Part FileData directement à partir de l'URI
-                # On peut spécifier un mime_type générique, Gemini gère les liens YT
-                uploaded_media_part = genai.types.Part(
-                    file_data=genai.types.FileData(file_uri=youtube_uri, mime_type="video/mp4")
+                uploaded_media_part = types.Part( # Utilise types.Part
+                    file_data=types.FileData(file_uri=youtube_uri, mime_type="video/mp4") # Utilise types.FileData
                 )
                 print(f"  Part YouTube créé pour: {youtube_uri}")
-                # Ajoute un prompt par défaut si l'utilisateur n'en a pas mis
                 if not prompt:
                     prompt = "Décris ou analyse le contenu de cette vidéo YouTube."
                     print(f"  Prompt par défaut ajouté pour YouTube: '{prompt}'")
@@ -320,44 +368,35 @@ def chat_api():
             media_type = 'text'
             print("  Traitement PROMPT texte seul.")
         else:
-            # Ce cas ne devrait pas arriver à cause de la validation initiale
             raise ValueError("Aucune entrée valide (fichier, URL YouTube ou texte) fournie.")
 
         # --- Préparer et stocker le message utilisateur dans l'historique ---
-        # Construit le texte qui sera affiché dans l'historique du chat
-        display_user_text = prompt # Par défaut, le prompt texte
+        display_user_text = prompt
         if media_type == 'file' or media_type == 'video':
-            # Précède le prompt par le nom du fichier entre crochets
             display_user_text = f"[{uploaded_filename_for_display}]" + (f" {prompt}" if prompt else "")
         elif media_type == 'youtube':
-             # Précède par [YouTube], ajoute le prompt, puis l'URL sur une nouvelle ligne
              display_user_text = f"[YouTube]" + (f" {prompt}" if prompt else "") + f"\n{uploaded_filename_for_display}"
 
         user_history_entry = {
             'role': 'user',
-            'text': display_user_text,    # Texte formaté pour l'affichage
-            'raw_text': prompt            # Texte brut original pour futurs appels Gemini
-            # Note: On ne stocke pas l'objet media_part dans la session
+            'text': display_user_text,
+            'raw_text': prompt
         }
         session['chat_history'].append(user_history_entry)
-        session.modified = True # Marque la session comme modifiée
+        session.modified = True
 
         # --- Préparer les 'parts' pour l'appel API Gemini ---
         current_gemini_parts = []
-        # Ajouter le média (fichier uploadé ou URL YT) s'il existe
         if uploaded_media_part:
             current_gemini_parts.append(uploaded_media_part)
 
-        # Préparer le prompt textuel final (peut être enrichi par la recherche web)
         final_prompt_for_gemini = prompt
 
-        # --- Recherche Web (Optionnelle, uniquement pour les requêtes texte) ---
         if use_web_search and prompt and media_type == 'text':
             print("  Activation Recherche Web...")
             search_data = perform_web_search(prompt)
             if search_data:
                 formatted_results = format_search_results(search_data)
-                # Construit un prompt enrichi
                 final_prompt_for_gemini = f"""Basé sur la question suivante et les informations web ci-dessous, fournis une réponse complète.
 
     Question Originale:
@@ -373,70 +412,59 @@ def chat_api():
             else:
                 print("  Aucun résultat de recherche web trouvé ou pertinent.")
 
-        # Ajouter la partie texte (originale ou enrichie) s'il y a du texte
         if final_prompt_for_gemini:
-             current_gemini_parts.append(genai.types.Part(text=final_prompt_for_gemini))
+             # Correction: Toujours créer un objet Part pour le texte
+             current_gemini_parts.append(types.Part(text=final_prompt_for_gemini)) # Utilise types.Part
 
-        # Vérification de sécurité : il doit y avoir au moins une partie (média ou texte)
         if not current_gemini_parts:
              print("ERREUR: Aucune partie (média ou texte) à envoyer à Gemini.")
              raise ValueError("Impossible de traiter la requête : contenu vide.")
 
-
         # --- Appel à l'API Gemini ---
-        # Prépare l'historique des messages PRÉCÉDENTS (texte seulement)
-        gemini_history = prepare_gemini_history(session['chat_history'][:-1]) # Exclut le message actuel
-        # Construit le contenu complet pour l'appel API
+        gemini_history = prepare_gemini_history(session['chat_history'][:-1])
         contents_for_gemini = gemini_history + [{'role': 'user', 'parts': current_gemini_parts}]
 
         # Sélectionne le modèle : Pro pour média ou si avancé demandé, sinon Flash
-        selected_model_name = MODEL_PRO if is_media_request or use_advanced else MODEL_FLASH
-        print(f"  Modèle sélectionné: {selected_model_name}")
-
-        # Crée l'instance du modèle spécifique pour cette requête
-        active_model = gemini_client.models.generate_content(
-            model=selected_model_name,
-            contents = contents_for_gemini, # Virgule ajoutée ici
-            config = genai.types.GenerateContentConfig(
-                system_instruction=SYSTEM_INSTRUCTION,
-                safety_settings=[
-
-                    genai.types.SafetySetting(
-                      category=genai.types.HarmCategory.HARM_CATEGORY_HATE_SPEECH,
-                      threshold=genai.types.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
-                    ),
-                    genai.types.SafetySetting(
-                      category=genai.types.HarmCategory.HARM_CATEGORY_HARASSMENT,
-                      threshold=genai.types.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
-                    ),
-                    genai.types.SafetySetting(
-                      category=genai.types.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
-                      threshold=genai.types.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
-                    ),
-                    genai.types.SafetySetting(
-                      category=genai.types.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
-                      threshold=genai.types.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
-                    )
-                ]
-            ),
+        # Préfixe 'models/' nécessaire pour l'API generate_content
+        selected_model = f'models/{MODEL_PRO}' if is_media_request or use_advanced else f'models/{MODEL_FLASH}'
+        print(f"  Modèle sélectionné pour l'API: {selected_model}")
+
+        # Crée l'instance de configuration
+        generation_config = types.GenerationConfig(
+            # candidate_count=1, # Optionnel: demander une seule réponse
+            # stop_sequences=["..."], # Optionnel
+            # max_output_tokens=..., # Optionnel
+            # temperature=..., # Optionnel
+            # top_p=..., # Optionnel
+            # top_k=..., # Optionnel
+        )
+
+        # Appel API (Correction: utilise 'model', non 'model_name')
+        # Utilisation de la méthode generate_content sur le client
+        print(f"  Envoi de la requête à {selected_model} ({len(contents_for_gemini)} messages/tours)...")
+        response = gemini_client.generate_content(
+            model=selected_model, # Correction: utilise 'model'
+            contents=contents_for_gemini,
+            generation_config=generation_config, # Passe l'objet config
+            safety_settings=SAFETY_SETTINGS_CONFIG, # Passe les safety settings
+            system_instruction=types.Content(parts=[types.Part(text=SYSTEM_INSTRUCTION)], role="system") # Instruction système formatée
         )
 
-        print(f"  Envoi de la requête à {selected_model_name} ({len(contents_for_gemini)} messages/tours)...")
-        # Appel API (non-streamé pour correspondre au code précédent)
-        response = active_model
 
         # --- Traitement de la Réponse ---
         response_text_raw = ""
         response_html = ""
         try:
-             # Accède au texte de la réponse. Peut lever une exception si bloqué.
              response_text_raw = response.text
-        except ValueError: # Typiquement levé si la réponse est bloquée par les filtres
-            print("  ERREUR: La réponse de Gemini a été bloquée (probablement par les safety settings).")
-            # Fournit les détails du blocage si disponibles
-            try: print(f"  Détails du blocage : {response.prompt_feedback}")
-            except Exception: pass # Ignore si prompt_feedback n'est pas accessible
-            response_text_raw = "Désolé, ma réponse a été bloquée car elle pourrait enfreindre les règles de sécurité."
+        except ValueError as ve: # Typiquement levé si la réponse est bloquée
+            print(f"  ERREUR: La réponse de Gemini a été bloquée (ValueError): {ve}")
+            try:
+                print(f"  Détails du blocage (Prompt Feedback): {response.prompt_feedback}")
+                block_reason = response.prompt_feedback.block_reason_message or "Raison non spécifiée"
+                response_text_raw = f"Désolé, ma réponse a été bloquée car elle pourrait enfreindre les règles de sécurité ({block_reason})."
+            except Exception as feedback_err:
+                print(f"  Impossible de récupérer les détails du blocage: {feedback_err}")
+                response_text_raw = "Désolé, ma réponse a été bloquée car elle pourrait enfreindre les règles de sécurité."
         except Exception as resp_err: # Gère d'autres erreurs potentielles
              print(f"  ERREUR inattendue lors de l'accès à response.text : {resp_err}")
              print(f"  Réponse brute complète : {response}") # Log la réponse brute pour le debug
@@ -450,8 +478,8 @@ def chat_api():
         # --- Stocker la réponse de l'assistant et retourner au client ---
         assistant_history_entry = {
             'role': 'assistant',
-            'text': response_html,      # HTML pour l'affichage via get_history
-            'raw_text': response_text_raw # Texte brut pour les futurs appels Gemini
+            'text': response_html,
+            'raw_text': response_text_raw
         }
         session['chat_history'].append(assistant_history_entry)
         session.modified = True
@@ -460,25 +488,32 @@ def chat_api():
         return jsonify({'success': True, 'message': response_html})
 
     # --- Gestion des Erreurs spécifiques (Timeout, Fichier invalide, etc.) ---
-    except (TimeoutError, ValueError, ConnectionError, FileNotFoundError) as e:
+    except (TimeoutError, ValueError, ConnectionError, FileNotFoundError, types.StopCandidateException) as e:
         error_message = f"Erreur lors du traitement de la requête: {e}"
         print(f"ERREUR (Traitement/Appel API): {error_message}")
-        # Retire le dernier message utilisateur de l'historique en cas d'erreur pour éviter les boucles
+        if isinstance(e, types.StopCandidateException):
+            error_message = "La génération a été stoppée, probablement à cause du contenu."
+            print(f"  StopCandidateException: {e}")
+
         if session.get('chat_history'):
-            session['chat_history'].pop()
-            session.modified = True
-            print("  Dernier message utilisateur retiré de l'historique après erreur.")
-        return jsonify({'success': False, 'error': error_message}), 500 # Erreur serveur
+            # Retire le dernier message utilisateur SEULEMENT s'il a été ajouté dans ce try
+            if session['chat_history'][-1]['role'] == 'user':
+                 session['chat_history'].pop()
+                 session.modified = True
+                 print("  Dernier message utilisateur retiré de l'historique après erreur.")
+        return jsonify({'success': False, 'error': error_message}), 500
 
     # --- Gestion des Erreurs Génériques/Inattendues ---
     except Exception as e:
         error_message = f"Une erreur interne inattendue est survenue: {e}"
-        print(f"ERREUR CRITIQUE INATTENDUE: {error_message}", exc_info=True) # Log la traceback complète
+        print(f"ERREUR CRITIQUE INATTENDUE: {error_message}")
+        traceback.print_exc() # Correction: Utilise traceback pour afficher les détails
         if session.get('chat_history'):
-            session['chat_history'].pop()
-            session.modified = True
-            print("  Dernier message utilisateur retiré de l'historique après erreur inattendue.")
-        return jsonify({'success': False, 'error': error_message}), 500
+             if session['chat_history'][-1]['role'] == 'user':
+                 session['chat_history'].pop()
+                 session.modified = True
+                 print("  Dernier message utilisateur retiré de l'historique après erreur inattendue.")
+        return jsonify({'success': False, 'error': "Une erreur interne inattendue est survenue."}), 500 # Message générique au client
 
     # --- Nettoyage (Exécuté dans tous les cas : succès ou erreur) ---
     finally:
@@ -495,23 +530,23 @@ def clear_chat():
     session.pop('chat_history', None) # Supprime la clé de la session
     print("API: Historique de chat effacé via /clear.")
 
-    # Détecte si la requête vient d'AJAX (fetch) pour répondre en JSON
     is_ajax = request.headers.get('X-Requested-With') == 'XMLHttpRequest' or \
               'application/json' in request.headers.get('Accept', '')
 
     if is_ajax:
          return jsonify({'success': True, 'message': 'Historique effacé.'})
     else:
-        # Comportement pour une soumission de formulaire classique (moins probable ici)
         flash("Conversation effacée.", "info")
-        return redirect(url_for('root')) # Redirige vers la page d'accueil
+        return redirect(url_for('root'))
 
 # --- Démarrage de l'application Flask ---
 
 if __name__ == '__main__':
     print("Démarrage du serveur Flask...")
-    # Utiliser un port différent si 5000 est déjà pris (ex: 5001)
-    port = int(os.environ.get('PORT', 5001))
-    # debug=True : Rechargement auto, messages d'erreur détaillés (NE PAS UTILISER EN PRODUCTION)
-    # host='0.0.0.0' : Rend l'app accessible sur le réseau local
+    # Utiliser un port différent si 5000/7860 est déjà pris (ex: 5001)
+    # Le port 7860 est souvent utilisé par Gradio/Streamlit, vérifiez la disponibilité
+    port = int(os.environ.get('PORT', 7860)) # Garde 7860 comme vu dans vos logs
+    # debug=False en production ! debug=True pour développement seulement.
+    # ATTENTION: Les logs indiquaient debug=off, mais app.run(debug=True) force le mode debug.
+    # Mettez debug=False si vous ne voulez pas le rechargement auto et les tracebacks dans le navigateur.
     app.run(debug=True, host='0.0.0.0', port=port)