Update app.py

app.py

@@ -1,11 +1,13 @@
 import os
 import json
-from flask import Flask, render_template, request, session, redirect, url_for, flash
+# Importer jsonify pour les réponses API
+from flask import Flask, render_template, request, session, redirect, url_for, flash, jsonify
 from dotenv import load_dotenv
 import google.generativeai as genai
 import requests
 from werkzeug.utils import secure_filename
 import mimetypes
+import markdown # <-- Importer la bibliothèque Markdown
 
 load_dotenv()
 
@@ -23,12 +25,11 @@ try:
     genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
     safety_settings = [
         {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
-        {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
-        {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
+        # ... (autres catégories)
         {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
     ]
     model = genai.GenerativeModel(
-        'gemini-2.0-flash',
+        'gemini-1.5-flash',
         safety_settings=safety_settings,
         system_instruction="Tu es un assistant intelligent. ton but est d'assister au mieux que tu peux. tu as été créé par Aenir et tu t'appelles Mariam"
     )
@@ -43,13 +44,13 @@ def allowed_file(filename):
            filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
 
 def perform_web_search(query):
-    conn_key = "9b90a274d9e704ff5b21c0367f9ae1161779b573"
+    conn_key = os.getenv("SERPER_API_KEY")
     if not conn_key:
         print("Clé API SERPER manquante dans .env")
         return None
     search_url = "https://google.serper.dev/search"
-    headers = { 'X-API-KEY': conn_key, 'Content-Type': 'application/json' }
-    payload = json.dumps({"q": query, "gl": "fr", "hl": "fr"}) # Ajout localisation FR
+    headers = {'X-API-KEY': conn_key, 'Content-Type': 'application/json'}
+    payload = json.dumps({"q": query})
     try:
         response = requests.post(search_url, headers=headers, data=payload, timeout=10)
         response.raise_for_status()
@@ -60,230 +61,187 @@ def perform_web_search(query):
         print(f"Erreur lors de la recherche web : {e}")
         return None
     except json.JSONDecodeError as e:
-        print(f"Erreur lors du décodage JSON de Serper : {e}")
+        print(f"Erreur lors du décodage de la réponse JSON de Serper : {e}")
         print(f"Réponse reçue : {response.text}")
         return None
 
+
 def format_search_results(data):
+    # (Fonction inchangée - assurez-vous qu'elle renvoie du texte formaté)
     if not data: return "Aucun résultat de recherche trouvé."
-    result = "Résultats de recherche web pertinents :\n"
-    # (Formatage légèrement simplifié pour clarté)
-    if kg := data.get('knowledgeGraph'):
-        result += f"\n## {kg.get('title', '')} ({kg.get('type', '')})\n{kg.get('description', '')}\n"
-    if ab := data.get('answerBox'):
-        result += f"\n## Réponse rapide :\n{ab.get('title','')}\n{ab.get('snippet') or ab.get('answer','')}\n"
-    if org := data.get('organic'):
-        result += "\n## Principaux résultats :\n"
-        for i, item in enumerate(org[:3], 1):
-            result += f"{i}. {item.get('title', 'N/A')}\n   {item.get('snippet', 'N/A')}\n   [{item.get('link', '#')}]\n"
-    # People Also Ask peut être bruyant, on peut l'omettre pour le prompt
+    result = "Résultats de recherche web :\n"
+    # ... (reste de la fonction inchangé) ...
+    if 'organic' in data and data['organic']:
+        result += "\n## Résultats principaux :\n"
+        for i, item in enumerate(data['organic'][:3], 1):
+            result += f"{i}. **{item.get('title', 'N/A')}**\n" # Format Markdown
+            result += f"   {item.get('snippet', 'N/A')}\n"
+            result += f"   [Lien]({item.get('link', '#')})\n\n" # Lien Markdown
+    # ... (reste de la fonction inchangé) ...
     return result
 
+
 def prepare_gemini_history(chat_history):
     gemini_history = []
     for message in chat_history:
         role = 'user' if message['role'] == 'user' else 'model'
-        # Utilise la référence stockée si elle existe
-        parts = [message.get('gemini_file')] if message.get('gemini_file') else []
-        parts.append(message['text_for_gemini']) # Utilise le texte destiné à Gemini
-        # Filtrer les parts None qui pourraient survenir si gemini_file était None
-        gemini_history.append({'role': role, 'parts': [p for p in parts if p]})
+        # Utiliser le 'raw_text' pour Gemini, pas le HTML rendu
+        text_part = message.get('raw_text', message.get('text', ''))
+        parts = [text_part]
+        if message.get('gemini_file_ref'): # Utiliser une clé différente pour la référence interne
+             parts.insert(0, message['gemini_file_ref'])
+        gemini_history.append({'role': role, 'parts': parts})
     return gemini_history
 
-
 # --- Routes Flask ---
 
 @app.route('/', methods=['GET'])
 def index():
+    """Affiche la page principale du chat."""
     if 'chat_history' not in session:
         session['chat_history'] = []
-    if 'web_search' not in session:
-        session['web_search'] = False
+    # L'état 'web_search' est maintenant géré côté client initialement,
+    # mais on peut le pré-cocher depuis la session si on veut le persister.
+    web_search_initial_state = session.get('web_search', False)
 
-    # Récupérer l'état de traitement et l'erreur pour les afficher
-    processing = session.get('processing', False)
-    error = session.pop('error', None) # Utilise pop pour ne l'afficher qu'une fois
+    # On ne passe que l'historique nécessaire à l'affichage initial
+    display_history = session['chat_history']
 
     return render_template(
         'index.html',
-        chat_history=session.get('chat_history', []),
-        web_search_active=session.get('web_search', False),
-        error=error,
-        processing_message=processing # Passer l'état de traitement
+        chat_history=display_history,
+        web_search_active=web_search_initial_state
     )
 
-@app.route('/chat', methods=['POST'])
-def chat():
+@app.route('/api/chat', methods=['POST'])
+def chat_api():
+    """Gère les requêtes de chat AJAX et retourne du JSON."""
     if not model:
-        session['error'] = "Le modèle Gemini n'a pas pu être chargé."
-        return redirect(url_for('index'))
+        return jsonify({'success': False, 'error': "Le modèle Gemini n'est pas configuré."}), 500
 
     prompt = request.form.get('prompt', '').strip()
-    session['web_search'] = 'web_search' in request.form
+    use_web_search = request.form.get('web_search') == 'true'
     file = request.files.get('file')
-    uploaded_gemini_file = None
-    file_display_name = None # Pour l'affichage
-
-    # Marquer le début du traitement DANS la session
-    session['processing'] = True
-    session['processing_web_search'] = False # Reset au début
-    session.modified = True # Sauvegarder la session maintenant
+    uploaded_gemini_file = None # Référence à l'objet fichier uploadé à Gemini
+    uploaded_filename = None # Juste le nom pour référence
 
     if not prompt and not file:
-        session['error'] = "Veuillez entrer un message ou uploader un fichier."
-        session['processing'] = False # Annuler le traitement
-        return redirect(url_for('index'))
+        return jsonify({'success': False, 'error': 'Message ou fichier requis.'}), 400
+
+    # Mettre à jour l'état de la recherche web dans la session si on veut le persister
+    session['web_search'] = use_web_search
+
+    # --- Gestion de l'upload ---
+    user_message_parts_for_gemini = []
+    raw_user_text = prompt # Texte brut pour l'historique Gemini
 
-    # --- Gestion Upload ---
     if file and file.filename != '':
         if allowed_file(file.filename):
             try:
                 filename = secure_filename(file.filename)
                 filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
                 file.save(filepath)
-                print(f"Fichier sauvegardé: {filepath}")
-                mime_type = mimetypes.guess_type(filepath)[0] or 'application/octet-stream'
+                uploaded_filename = filename # Garder le nom
+                print(f"Fichier sauvegardé : {filepath}")
 
-                print("Upload vers Gemini...")
+                mime_type = mimetypes.guess_type(filepath)[0] or 'application/octet-stream'
+                print(f"Upload vers Gemini (mime: {mime_type})...")
                 gemini_file_obj = genai.upload_file(path=filepath, mime_type=mime_type)
-                uploaded_gemini_file = gemini_file_obj
-                file_display_name = filename # Garder le nom pour affichage
-                print(f"Fichier {filename} uploadé. MimeType: {mime_type}")
-                # Optionnel: Supprimer après upload
+                uploaded_gemini_file = gemini_file_obj # Garder l'objet pour l'API
+                user_message_parts_for_gemini.append(uploaded_gemini_file) # Ajouter l'objet fichier pour Gemini
+                print(f"Fichier {filename} uploadé vers Gemini.")
+
+                # Optionnel: Supprimer le fichier local
                 # os.remove(filepath)
 
             except Exception as e:
                 print(f"Erreur upload fichier : {e}")
-                session['error'] = f"Erreur lors du traitement du fichier : {e}"
-                # Ne pas arrêter le traitement, continuer sans le fichier si erreur upload
+                # Ne pas bloquer, mais renvoyer une erreur partielle si nécessaire
+                return jsonify({'success': False, 'error': f"Erreur traitement fichier: {e}"}), 500
         else:
-            session['error'] = "Type de fichier non autorisé."
-            session['processing'] = False # Annuler le traitement
-            return redirect(url_for('index'))
-
-    # --- Préparation Message Utilisateur ---
-    # Texte à afficher dans le chat
-    display_text = prompt
-    if file_display_name:
-        display_text = f"[Fichier joint : {file_display_name}]\n\n{prompt}" if prompt else f"[Fichier joint : {file_display_name}]"
-
-    # Texte à envoyer à Gemini (peut être différent si recherche web)
-    text_for_gemini = prompt
-
-    # Ajouter à l'historique de session (pour affichage) SEULEMENT s'il y a du contenu
-    if display_text:
-         # Garder une trace de l'objet fichier Gemini et du texte original pour l'API
-         session['chat_history'].append({
-             'role': 'user',
-             'text': display_text, # Texte pour affichage HTML
-             'text_for_gemini': text_for_gemini, # Texte initial pour l'API Gemini
-             'gemini_file': uploaded_gemini_file # Référence à l'objet fichier si uploadé
-         })
-         session.modified = True
-
-    # --- Logique principale (Recherche Web + Gemini) ---
+            return jsonify({'success': False, 'error': 'Type de fichier non autorisé.'}), 400
+
+    # --- Préparation du message utilisateur et de l'historique ---
+    # Ajouter le texte après le fichier pour Gemini
+    user_message_parts_for_gemini.append(prompt)
+
+    # Stocker le message utilisateur dans l'historique de session
+    # Stocker le texte brut et la référence au fichier séparément
+    user_history_entry = {
+        'role': 'user',
+        'text': f"[Fichier: {uploaded_filename}]\n\n{prompt}" if uploaded_filename else prompt, # Pour affichage
+        'raw_text': raw_user_text, # Texte brut pour Gemini
+    }
+    if uploaded_gemini_file:
+         # Ne stockez pas l'objet complet dans la session, juste une réf si nécessaire,
+         # ou reconstruisez l'historique sans la référence de fichier si non critique.
+         # Pour simplifier, on ne stocke pas la référence objet dans la session ici.
+         # On pourrait stocker gemini_file_obj.name si on a besoin de le réutiliser plus tard.
+         # user_history_entry['gemini_file_ref_name'] = uploaded_gemini_file.name
+         pass # L'objet est dans user_message_parts_for_gemini pour l'appel API actuel
+
+    if 'chat_history' not in session: session['chat_history'] = []
+    session['chat_history'].append(user_history_entry)
+    session.modified = True
+
+
+    # --- Web Search ---
+    final_prompt_text = prompt
+    if use_web_search and prompt: # Recherche uniquement si texte ET activé
+        print("Recherche web en cours pour:", prompt)
+        web_results = perform_web_search(prompt)
+        if web_results:
+            formatted_results = format_search_results(web_results)
+             # Mettre à jour le texte à envoyer à Gemini (le fichier est déjà dans les parts)
+            final_prompt_text = f"Question originale: {prompt}\n\n{formatted_results}\n\nBasé sur ces informations et ta connaissance générale, réponds à la question originale."
+            print("Prompt modifié avec résultats web.")
+            # Remplacer le texte dans la liste des parts
+            user_message_parts_for_gemini[-1] = final_prompt_text
+        else:
+            print("Pas de résultats web ou erreur.")
+
+    # --- Appel à Gemini ---
     try:
-        final_prompt_parts = []
-        if uploaded_gemini_file:
-            final_prompt_parts.append(uploaded_gemini_file)
-
-        # Recherche Web si activée ET prompt textuel existe
-        if session['web_search'] and prompt:
-            print("Activation recherche web...")
-            session['processing_web_search'] = True # Indiquer que la recherche est active
-            session.modified = True
-            # !! Important: Forcer la sauvegarde de session AVANT l'appel bloquant
-            # Ceci est un workaround car Flask sauvegarde normalement en fin de requête.
-            # Pour une vraie MAJ live, il faudrait AJAX/WebSockets.
-            from flask.sessions import SessionInterface
-            app.session_interface.save_session(app, session, Response()) # Pseudo-réponse
-
-            web_results = perform_web_search(prompt)
-            if web_results:
-                formatted_results = format_search_results(web_results)
-                text_for_gemini = f"Question originale: {prompt}\n\n{formatted_results}\n\nRéponds à la question originale en te basant sur ces informations et ta connaissance."
-                print("Prompt enrichi avec recherche web.")
-            else:
-                print("Pas de résultats web ou erreur.")
-                text_for_gemini = prompt # Garde le prompt original
-            session['processing_web_search'] = False # Recherche terminée
-
-        # Ajouter le texte (original ou enrichi) aux parts
-        if text_for_gemini: # S'assurer qu'on ajoute pas une string vide
-            final_prompt_parts.append(text_for_gemini)
-
-        # Préparer l'historique pour Gemini en utilisant les données stockées
-        # On prend tout sauf le dernier message utilisateur qui est en cours de traitement
+        # Préparer l'historique SANS le dernier message utilisateur (il est dans `contents`)
         gemini_history = prepare_gemini_history(session['chat_history'][:-1])
+        print(f"Historique Gemini: {len(gemini_history)} messages.")
 
-        print(f"\n--- Envoi à Gemini ({len(gemini_history)} hist + {len(final_prompt_parts)} new parts) ---")
+        # Construire le contenu pour generate_content
+        contents = gemini_history + [{'role': 'user', 'parts': user_message_parts_for_gemini}]
 
-        # Appel API Gemini
-        if not final_prompt_parts:
-             # Cas où seul un fichier a été envoyé sans prompt textuel,
-             # et la recherche web n'était pas activée ou n'a rien retourné.
-             # Il faut quand même envoyer qqchose, par ex., demander de décrire le fichier.
-             if uploaded_gemini_file:
-                  final_prompt_parts.append("Décris le contenu de ce fichier.")
-             else:
-                  # Ne devrait pas arriver vu les checks précédents, mais par sécurité
-                  raise ValueError("Tentative d'envoyer une requête vide à Gemini.")
+        print("Appel à model.generate_content...")
+        response = model.generate_content(contents)
 
+        # --- Traitement Réponse ---
+        response_text_raw = response.text
+        # Convertir Markdown en HTML pour un meilleur rendu
+        response_html = markdown.markdown(response_text_raw, extensions=['fenced_code', 'tables'])
 
-        full_conversation = gemini_history + [{'role': 'user', 'parts': final_prompt_parts}]
-        response = model.generate_content(full_conversation)
+        print(f"Réponse Gemini reçue (premiers 500 chars): {response_text_raw[:500]}")
 
-        # --- Traitement Réponse ---
-        response_text = response.text
-        print(f"--- Réponse Gemini reçue ---")
-
-        # Ajouter la réponse à l'historique (version simple pour affichage)
-        session['chat_history'].append({
-            'role': 'assistant',
-            'text': response_text,
-            'text_for_gemini': response_text # Pour symétrie, même si on ne réutilise pas directement
-            # Pas de 'gemini_file' pour les réponses du modèle
-        })
+        # Ajouter la réponse à l'historique de session
+        session['chat_history'].append({'role': 'assistant', 'text': response_html, 'raw_text': response_text_raw})
         session.modified = True
 
+        return jsonify({'success': True, 'message': response_html}) # Envoyer le HTML au client
+
     except Exception as e:
-        print(f"Erreur lors de l'appel à Gemini ou traitement : {e}")
-        session['error'] = f"Une erreur s'est produite : {e}"
-        # En cas d'erreur, retirer le dernier message utilisateur de l'historique
-        # pour éviter boucle d'erreur si le prompt est problématique.
-        if session['chat_history'] and session['chat_history'][-1]['role'] == 'user':
-            session['chat_history'].pop()
-            session.modified = True
-    finally:
-        # Marquer la fin du traitement DANS la session
-        session['processing'] = False
-        session.pop('processing_web_search', None) # Nettoyer au cas où
+        print(f"Erreur lors de l'appel à Gemini : {e}")
+        # Retirer le dernier message utilisateur de l'historique en cas d'échec
+        session['chat_history'].pop()
         session.modified = True
-        # Pas besoin de Response() ici, la sauvegarde se fera avec le redirect
+        return jsonify({'success': False, 'error': f"Erreur communication IA: {e}"}), 500
 
-    return redirect(url_for('index'))
 
-# Ajouter une route pour effacer la conversation
 @app.route('/clear', methods=['POST'])
 def clear_chat():
+    """Efface l'historique de la conversation."""
     session.pop('chat_history', None)
-    session.pop('web_search', None)
-    session.pop('processing', None) # Nettoyer aussi l'état de process
-    session.pop('error', None)
+    session.pop('web_search', None) # Réinitialiser aussi le toggle web
     print("Historique de chat effacé.")
-    flash("Conversation effacée.", "info") # Message feedback (optionnel)
+    flash("Conversation effacée.", "info") # Optionnel: message flash
     return redirect(url_for('index'))
 
-# Classe Response factice pour sauvegarde session précoce (workaround)
-# Attention: N'est PAS une vraie réponse HTTP. A utiliser avec prudence.
-class Response:
-    def __init__(self):
-        self.headers = {}
-    def set_cookie(self, key, value, **kwargs):
-        # Potentiellement stocker les cookies si nécessaire, mais ici on ignore
-        pass
-
-
+# --- Démarrage ---
 if __name__ == '__main__':
-    # Utiliser un port différent si 5000 est pris
-    app.run(debug=True, host='0.0.0.0', port=5002)
+    app.run(debug=True, host='0.0.0.0', port=5001)