Update app.py

app.py

@@ -1,3 +1,5 @@
+# --- START OF FILE app.py ---
+
 import os
 import json
 import mimetypes
@@ -7,28 +9,49 @@ import google.generativeai as genai
 import requests
 from werkzeug.utils import secure_filename
 import markdown # Pour convertir la réponse en HTML
+from flask_session import Session # <-- Importer Session
 
 # --- Configuration Initiale ---
 load_dotenv()
 
 app = Flask(__name__)
 
-# Clé secrète FORTEMENT recommandée pour les sessions
-app.config['SECRET_KEY'] = os.getenv('FLASK_SECRET_KEY', 'dev-secret-key-replace-in-prod')
+# --- Configuration Flask Standard ---
+# Clé secrète FORTEMENT recommandée (vous l'avez déjà)
+# Gardez-la secrète en production !
+app.config['SECRET_KEY'] = os.getenv('FLASK_SECRET_KEY', 'une-super-cle-secrete-a-changer')
 
-# Configuration pour les uploads
+# Configuration pour les uploads (vous l'avez déjà)
 UPLOAD_FOLDER = 'temp'
-ALLOWED_EXTENSIONS = {'txt', 'pdf', 'png', 'jpg', 'jpeg'} # Extensions autorisées
+ALLOWED_EXTENSIONS = {'txt', 'pdf', 'png', 'jpg', 'jpeg'}
 app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
 app.config['MAX_CONTENT_LENGTH'] = 25 * 1024 * 1024  # Limite de taille (ex: 25MB)
 
-# Créer le dossier temp s'il n'existe pas
+# Créer le dossier temp s'il n'existe pas (vous l'avez déjà)
 os.makedirs(UPLOAD_FOLDER, exist_ok=True)
 print(f"Dossier d'upload configuré : {os.path.abspath(UPLOAD_FOLDER)}")
 
+# --- Configuration pour Flask-Session (Backend Filesystem) ---
+app.config['SESSION_TYPE'] = 'filesystem'  # Indique d'utiliser le stockage par fichiers
+app.config['SESSION_PERMANENT'] = False  # La session expire quand le navigateur est fermé
+app.config['SESSION_USE_SIGNER'] = True  # Signe l'ID de session dans le cookie pour sécurité
+app.config['SESSION_FILE_DIR'] = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'flask_session') # Chemin où stocker les fichiers de session
+# os.path.join(...) crée un chemin vers un dossier nommé 'flask_session'
+# à côté de votre fichier app.py
+
+# Crée le dossier pour les sessions filesystem s'il n'existe pas
+os.makedirs(app.config['SESSION_FILE_DIR'], exist_ok=True)
+print(f"Dossier pour les sessions serveur configuré : {app.config['SESSION_FILE_DIR']}")
+
+
+# --- Initialisation de Flask-Session ---
+# Doit être fait APRÈS avoir défini la configuration de session
+server_session = Session(app) # <-- Lie l'extension à votre application
+
 # --- Configuration de l'API Gemini ---
 MODEL_FLASH = 'gemini-2.0-flash' # Default model
 MODEL_PRO = 'gemini-2.5-pro-exp-03-25' # Advanced model
+# ASSUREZ-VOUS QUE SYSTEM_INSTRUCTION EST BIEN DÉFINI ICI OU CHARGÉ
 SYSTEM_INSTRUCTION = "Tu es un assistant intelligent et amical nommé Mariam. Tu assistes les utilisateurs au mieux de tes capacités. Tu as été créé par Aenir."
 SAFETY_SETTINGS = [
     {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
@@ -128,8 +151,10 @@ def format_search_results(data):
         if title and description:
              results.append(f"**{title} ({type})**\n{description}\n")
         if kg.get('attributes'):
+             results.append("\n**Attributs :**") # Ajout titre pour clarté
              for attr, value in kg['attributes'].items():
                   results.append(f"- {attr}: {value}")
+             results.append("") # Ligne vide après les attributs
 
 
     # Résultats organiques
@@ -156,16 +181,24 @@ def format_search_results(data):
 def prepare_gemini_history(chat_history):
     """Convertit l'historique stocké en session au format attendu par Gemini API."""
     gemini_history = []
-    for message in chat_history:
-        role = 'user' if message['role'] == 'user' else 'model'
+    # Itérer sur une copie pour éviter les problèmes si on modifie pendant l'itération (peu probable ici mais bonne pratique)
+    for message in list(chat_history):
+        role = 'user' if message.get('role') == 'user' else 'model'
         # Utiliser le 'raw_text' stocké pour Gemini
-        text_part = message.get('raw_text', '') # Fallback au cas où
-        parts = [text_part]
-        # NOTE: La gestion des fichiers des tours PRÉCÉDENTS n'est pas gérée ici.
-        # L'API generate_content se concentre généralement sur le fichier du tour ACTUEL.
-        # Si une référence de fichier passée était nécessaire, il faudrait la stocker
-        # et la ré-attacher ici (potentiellement plus complexe).
-        gemini_history.append({'role': role, 'parts': parts})
+        text_part = message.get('raw_text') # Utiliser get pour éviter KeyError si 'raw_text' manque
+        if text_part is None:
+             print(f"AVERTISSEMENT: 'raw_text' manquant pour un message {role}, utilisation de 'text'. Message: {message.get('text', '')[:50]}...")
+             text_part = message.get('text', '') # Fallback vers 'text' si raw_text est absent
+
+        # Vérifier si text_part n'est pas vide avant d'ajouter
+        if text_part:
+            parts = [text_part]
+            # NOTE: La gestion des fichiers des tours PRÉCÉDENTS n'est pas gérée ici.
+            # L'API generate_content se concentre généralement sur le fichier du tour ACTUEL.
+            gemini_history.append({'role': role, 'parts': parts})
+        else:
+            print(f"AVERTISSEMENT: Message vide détecté et ignoré pour l'historique Gemini (role: {role}).")
+
     return gemini_history
 
 # --- Routes Flask ---
@@ -173,20 +206,31 @@ def prepare_gemini_history(chat_history):
 @app.route('/')
 def root():
     """Sert la page HTML principale."""
+    # Pas besoin de toucher à l'historique ici, le frontend le demandera via /api/history
     return render_template('index.html')
 
 @app.route('/api/history', methods=['GET'])
 def get_history():
     """Fournit l'historique de chat stocké en session au format JSON."""
+    # Flask-Session gère la session (filesystem dans ce cas)
     if 'chat_history' not in session:
         session['chat_history'] = []
 
     # Préparer l'historique pour l'affichage (contient déjà le HTML pour l'assistant)
-    display_history = [
-        {'role': msg.get('role', 'unknown'), 'text': msg.get('text', '')}
-        for msg in session.get('chat_history', [])
-    ]
-    print(f"API: Récupération de l'historique ({len(display_history)} messages)")
+    # Il est crucial que les messages stockés aient 'role' et 'text'
+    display_history = []
+    for msg in session.get('chat_history', []):
+         # Vérification minimale pour éviter les erreurs si la structure est corrompue
+         if isinstance(msg, dict) and 'role' in msg and 'text' in msg:
+             display_history.append({
+                 'role': msg.get('role'),
+                 'text': msg.get('text')
+             })
+         else:
+             print(f"AVERTISSEMENT: Format de message invalide dans l'historique de session ignoré: {msg}")
+
+
+    print(f"API: Récupération de l'historique ({len(display_history)} messages depuis la session serveur)")
     return jsonify({'success': True, 'history': display_history})
 
 @app.route('/api/chat', methods=['POST'])
@@ -214,7 +258,7 @@ def chat_api():
     print(f"Raisonnement avancé demandé: {use_advanced}")
     print(f"Fichier reçu: {file.filename if file else 'Aucun'}")
 
-    # Initialiser l'historique de session si nécessaire
+    # Initialiser l'historique de session si nécessaire (géré par Flask-Session)
     if 'chat_history' not in session:
         session['chat_history'] = []
 
@@ -273,18 +317,32 @@ def chat_api():
         'raw_text': raw_user_text,   # Pour l'envoi à Gemini via prepare_gemini_history
         # On ne stocke PAS l'objet 'uploaded_gemini_file' dans la session
     }
+    # Vérifier que l'historique est bien une liste avant d'ajouter
+    if not isinstance(session.get('chat_history'), list):
+        print("ERREUR: chat_history dans la session n'est pas une liste! Réinitialisation.")
+        session['chat_history'] = []
     session['chat_history'].append(user_history_entry)
-    session.modified = True # Indiquer que la session a été modifiée
+    # session.modified = True # Normalement plus nécessaire avec Flask-Session Filesystem/Redis etc.
+                               # mais ne fait pas de mal de le laisser pour l'instant.
 
     # --- Préparation des 'parts' pour l'appel Gemini ACTUEL ---
     current_gemini_parts = []
     if uploaded_gemini_file:
-        current_gemini_parts.append(uploaded_gemini_file) # L'objet fichier uploadé
+        # Important: Ne pas envoyer l'objet fichier lui-même si le prompt est vide.
+        # Gemini pourrait avoir du mal à l'interpréter sans contexte textuel.
+        if raw_user_text:
+             current_gemini_parts.append(uploaded_gemini_file)
+        else:
+             # Si seulement un fichier est envoyé, créer un prompt minimal
+             raw_user_text = f"Décris le contenu de ce fichier : {uploaded_filename}"
+             print(f"INFO: Fichier seul détecté, utilisation du prompt généré: '{raw_user_text}'")
+             current_gemini_parts.append(uploaded_gemini_file)
+
 
-    final_prompt_for_gemini = raw_user_text # Commencer avec le texte brut
+    final_prompt_for_gemini = raw_user_text # Commencer avec le texte brut (potentiellement généré ci-dessus)
 
     # --- Recherche Web (si activée et si un prompt textuel existe) ---
-    if use_web_search and raw_user_text:
+    if use_web_search and raw_user_text: # Vérifier qu'on a bien du texte pour chercher
         print("Activation de la recherche web...")
         search_data = perform_web_search(raw_user_text)
         if search_data:
@@ -301,20 +359,38 @@ J'ai effectué une recherche web et voici les informations pertinentes trouvées
 En te basant sur ces informations ET sur ta connaissance générale, fournis une réponse complète et bien structurée à la question originale de l'utilisateur."""
             print("Prompt enrichi avec les résultats de recherche web.")
         else:
-            print("Aucun résultat de recherche web pertinent trouvé ou erreur, utilisation du prompt original.")
-            # final_prompt_for_gemini reste raw_user_text
+            print("Aucun résultat de recherche web pertinent trouvé ou erreur, utilisation du prompt original/généré.")
+            # final_prompt_for_gemini reste raw_user_text ou le prompt généré
+
+    # Ajouter le texte (potentiellement enrichi) aux parts pour Gemini UNIQUEMENT s'il y a du texte
+    if final_prompt_for_gemini:
+         current_gemini_parts.append(final_prompt_for_gemini)
+    elif not current_gemini_parts: # Si on n'a ni fichier utile ni texte
+         print("ERREUR: Aucune donnée (texte ou fichier valide) à envoyer à Gemini.")
+         # Retirer le message utilisateur vide ajouté précédemment
+         if session.get('chat_history'):
+            session['chat_history'].pop()
+         return jsonify({'success': False, 'error': "Impossible d'envoyer une requête vide à l'IA."}), 400
 
-    # Ajouter le texte (potentiellement enrichi) aux parts pour Gemini
-    current_gemini_parts.append(final_prompt_for_gemini)
 
     # --- Appel à l'API Gemini ---
     try:
         # Préparer l'historique des messages PRÉCÉDENTS
-        gemini_history = prepare_gemini_history(session['chat_history'][:-1]) # Exclut le message actuel
+        # Utiliser une copie de la session pour éviter les modifications pendant la préparation
+        history_copy = list(session.get('chat_history', []))
+        gemini_history = prepare_gemini_history(history_copy[:-1]) # Exclut le message actuel
         print(f"Préparation de l'appel Gemini avec {len(gemini_history)} messages d'historique.")
+
         # Construire le contenu complet pour l'appel
         contents_for_gemini = gemini_history + [{'role': 'user', 'parts': current_gemini_parts}]
 
+        # DEBUG: Afficher ce qui va être envoyé (peut être très verbeux)
+        # print("--- Contenu envoyé à Gemini ---")
+        # import pprint
+        # pprint.pprint(contents_for_gemini)
+        # print("-----------------------------")
+
+
         # Choisir le nom du modèle à utiliser
         selected_model_name = MODEL_PRO if use_advanced else MODEL_FLASH
         print(f"Utilisation du modèle Gemini: {selected_model_name}")
@@ -335,24 +411,49 @@ En te basant sur ces informations ET sur ta connaissance générale, fournis une
 
         # Extraire le texte de la réponse (gestion d'erreur potentielle ici si la réponse est bloquée etc.)
         # Gérer le cas où la réponse est bloquée par les safety settings
+        response_text_raw = ""
+        response_html = ""
         try:
-             response_text_raw = response.text
-        except ValueError:
-            # Si response.text échoue, la réponse a probablement été bloquée.
-            print("ERREUR: La réponse de Gemini a été bloquée (probablement par les safety settings).")
-            print(f"Détails du blocage : {response.prompt_feedback}")
-            # Vous pouvez décider quoi renvoyer au client ici.
-            # Soit une erreur spécifique, soit un message générique.
-            response_text_raw = "Désolé, ma réponse a été bloquée car elle pourrait enfreindre les règles de sécurité."
-            # Convertir ce message d'erreur en HTML aussi pour la cohérence
+             # Vérifier si la réponse a des 'parts' avant d'essayer d'accéder à .text
+             if response.parts:
+                response_text_raw = response.text # .text concatène les parts textuelles
+             else:
+                # Si pas de parts, vérifier le prompt_feedback pour la raison (blocage probable)
+                print(f"AVERTISSEMENT: Réponse de Gemini sans contenu textuel ('parts'). Feedback: {response.prompt_feedback}")
+                # Donner un message d'erreur plus informatif basé sur le feedback si possible
+                if response.prompt_feedback and response.prompt_feedback.block_reason:
+                    reason = response.prompt_feedback.block_reason.name # Ex: 'SAFETY', 'OTHER'
+                    response_text_raw = f"Désolé, ma réponse a été bloquée ({reason})."
+                    # Si SAFETY, vérifier les ratings spécifiques si disponibles
+                    if reason == 'SAFETY' and response.prompt_feedback.safety_ratings:
+                        blocked_categories = [r.category.name for r in response.prompt_feedback.safety_ratings if r.probability.name not in ['NEGLIGIBLE', 'LOW']]
+                        if blocked_categories:
+                            response_text_raw += f" Catégories potentiellement concernées: {', '.join(blocked_categories)}."
+
+                else:
+                     response_text_raw = "Désolé, je n'ai pas pu générer de réponse pour cette demande."
+
+
+             # Convertir en HTML même si c'est un message d'erreur
+             response_html = markdown.markdown(response_text_raw, extensions=['fenced_code', 'tables', 'nl2br'])
+
+        except ValueError as e:
+            # Gérer le cas où .text échoue même avec des parts (rare, mais possible si structure inattendue)
+            print(f"ERREUR: Impossible d'extraire le texte de la réponse Gemini. Erreur: {e}")
+            print(f"Réponse brute: {response}")
+            print(f"Feedback: {response.prompt_feedback}")
+            response_text_raw = "Désolé, une erreur interne est survenue lors de la lecture de la réponse."
+            response_html = markdown.markdown(response_text_raw)
+        except Exception as e_resp: # Capturer toute autre exception inattendue
+            print(f"ERREUR INATTENDUE lors du traitement de la réponse Gemini : {e_resp}")
+            print(f"Réponse brute: {response}")
+            response_text_raw = f"Désolé, une erreur inattendue est survenue ({type(e_resp).__name__})."
             response_html = markdown.markdown(response_text_raw)
 
-        else:
-            # Si response.text réussit, continuer normalement
-            print(f"Réponse reçue de Gemini (brute, début): '{response_text_raw[:100]}...'")
-            # Convertir la réponse Markdown en HTML pour l'affichage
-            response_html = markdown.markdown(response_text_raw, extensions=['fenced_code', 'tables', 'nl2br'])
-            print("Réponse convertie en HTML.")
+
+        print(f"Réponse reçue de Gemini (brute, début): '{response_text_raw[:100]}...'")
+        if response_html != response_text_raw: # Log seulement si Markdown a fait quelque chose
+             print("Réponse convertie en HTML.")
 
 
         # Ajouter la réponse de l'assistant à l'historique de session
@@ -361,8 +462,12 @@ En te basant sur ces informations ET sur ta connaissance générale, fournis une
             'text': response_html,      # HTML pour l'affichage via get_history
             'raw_text': response_text_raw # Texte brut pour les futurs appels Gemini
         }
+        # Re-vérifier que l'historique est une liste avant d'ajouter
+        if not isinstance(session.get('chat_history'), list):
+            print("ERREUR: chat_history dans la session n'est pas une liste avant ajout assistant! Réinitialisation.")
+            session['chat_history'] = [user_history_entry] # Garder au moins le user msg
         session['chat_history'].append(assistant_history_entry)
-        session.modified = True
+        # session.modified = True # Probablement pas nécessaire mais sans danger
 
         # Renvoyer la réponse HTML au frontend
         print("Envoi de la réponse HTML au client.")
@@ -373,37 +478,54 @@ En te basant sur ces informations ET sur ta connaissance générale, fournis une
         # En cas d'erreur, retirer le dernier message utilisateur de l'historique
         # pour éviter les boucles d'erreur si le message lui-même pose problème.
         # Vérifier si l'historique n'est pas vide avant de pop
-        if session.get('chat_history'):
-            session['chat_history'].pop()
-            session.modified = True
-            print("Le dernier message utilisateur a été retiré de l'historique suite à l'erreur.")
+        current_history = session.get('chat_history')
+        if isinstance(current_history, list) and current_history:
+            try:
+                # S'assurer que le dernier élément était bien le message utilisateur
+                if current_history[-1].get('role') == 'user':
+                    current_history.pop()
+                    # session.modified = True # Si on modifie directement la liste obtenue par .get()
+                    print("Le dernier message utilisateur a été retiré de l'historique suite à l'erreur.")
+                else:
+                    print("Le dernier message n'était pas 'user', historique non modifié après erreur.")
+            except Exception as pop_e:
+                 print(f"Erreur lors de la tentative de retrait du message utilisateur de l'historique: {pop_e}")
         else:
-            print("L'historique était déjà vide lors de l'erreur.")
+            print("L'historique était vide ou invalide lors de l'erreur.")
 
         # Renvoyer une erreur générique mais informative
         return jsonify({'success': False, 'error': f"Une erreur interne est survenue lors de la génération de la réponse. Détails: {e}"}), 500
 
     finally:
-        # --- Nettoyage du fichier temporaire ---
+        # --- Nettoyage du fichier uploadé vers Google AI ---
+        if uploaded_gemini_file:
+             try:
+                 print(f"Tentative de suppression du fichier Google AI : {uploaded_gemini_file.name}")
+                 genai.delete_file(uploaded_gemini_file.name)
+                 print(f"Fichier Google AI '{uploaded_gemini_file.name}' supprimé.")
+             except Exception as e_del_gcp:
+                 # Ne pas bloquer l'utilisateur pour ça, juste logguer
+                 print(f"AVERTISSEMENT: Échec de la suppression du fichier Google AI '{uploaded_gemini_file.name}': {e_del_gcp}")
+
+
+        # --- Nettoyage du fichier temporaire local ---
         if filepath_to_delete and os.path.exists(filepath_to_delete):
             try:
                 os.remove(filepath_to_delete)
-                print(f"Fichier temporaire '{filepath_to_delete}' supprimé avec succès.")
-            except OSError as e:
-                print(f"ERREUR lors de la suppression du fichier temporaire '{filepath_to_delete}': {e}")
+                print(f"Fichier temporaire local '{filepath_to_delete}' supprimé avec succès.")
+            except OSError as e_del_local:
+                print(f"ERREUR lors de la suppression du fichier temporaire local '{filepath_to_delete}': {e_del_local}")
 
 
 @app.route('/clear', methods=['POST'])
 def clear_chat():
     """Efface l'historique de chat dans la session."""
-    session.pop('chat_history', None)
-    # session.pop('web_search', None) # On ne stocke pas ça en session
-    print("API: Historique de chat effacé via /clear.")
+    session.clear() # Efface toutes les données de la session serveur actuelle
+    print("API: Historique de chat effacé via /clear (session serveur).")
 
     # Adapter la réponse selon si c'est une requête AJAX (fetch) ou une soumission classique
-    # Vérification si la requête vient probablement de fetch (simple)
     is_ajax = 'XMLHttpRequest' == request.headers.get('X-Requested-With') or \
-              'application/json' in request.headers.get('Accept', '') # Plus robuste
+              'application/json' in request.headers.get('Accept', '')
 
     if is_ajax:
          return jsonify({'success': True, 'message': 'Historique effacé.'})
@@ -418,7 +540,8 @@ if __name__ == '__main__':
     print("Démarrage du serveur Flask...")
     # Utiliser host='0.0.0.0' pour rendre accessible sur le réseau local
     # debug=True est pratique pour le développement, mais à désactiver en production !
-    # Changer le port si nécessaire (ex: 5000, 5001, 8080)
     # Utiliser un port différent si le port 5000 est déjà pris
     port = int(os.environ.get('PORT', 5001))
-    app.run(debug=True, host='0.0.0.0', port=port)
+    # Mettre debug=False pour la production
+    app.run(debug=False, host='0.0.0.0', port=port)
+# --- END OF FILE app.py ---