Create app.py

app.py

@@ -0,0 +1,412 @@
+import os
+import json
+import mimetypes
+from flask import Flask, request, session, jsonify, redirect, url_for, flash, render_template
+from dotenv import load_dotenv
+import google.generativeai as genai
+from werkzeug.utils import secure_filename
+import markdown # Pour convertir la réponse en HTML
+from flask_session import Session # <-- Importer Session
+import pprint # Pour un affichage plus lisible des structures complexes (optionnel)
+
+# --- Configuration Initiale ---
+load_dotenv()
+
+app = Flask(__name__)
+
+# --- 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 (vous l'avez déjà)
+UPLOAD_FOLDER = 'temp'
+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 (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
+
+app.config['SESSION_COOKIE_SAMESITE'] = 'None'
+# Nécessite HTTPS pour que 'None' fonctionne
+app.config['SESSION_COOKIE_SECURE'] = True
+
+# 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 ---
+server_session = Session(app)
+
+# --- Configuration de l'API Gemini ---
+MODEL_FLASH = 'gemini-2.0-flash'
+MODEL_PRO = 'gemini-2.5-pro-exp-03-25'
+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"},
+    {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
+    {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
+    {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
+]
+GEMINI_CONFIGURED = False
+try:
+    gemini_api_key = os.getenv("GOOGLE_API_KEY")
+    if not gemini_api_key:
+        print("ERREUR: Clé API GOOGLE_API_KEY manquante dans le fichier .env")
+    else:
+        genai.configure(api_key=gemini_api_key)
+        models_list = [m.name for m in genai.list_models()]
+        if f'models/{MODEL_FLASH}' in models_list and f'models/{MODEL_PRO}' in models_list:
+             print(f"Configuration Gemini effectuée. Modèles requis ({MODEL_FLASH}, {MODEL_PRO}) disponibles.")
+             print(f"System instruction: {SYSTEM_INSTRUCTION}")
+             GEMINI_CONFIGURED = True
+        else:
+            print(f"ERREUR: Les modèles requis ({MODEL_FLASH}, {MODEL_PRO}) ne sont pas tous disponibles via l'API.")
+            print(f"Modèles trouvés: {models_list}")
+
+except Exception as e:
+    print(f"ERREUR Critique lors de la configuration initiale de Gemini : {e}")
+    print("L'application fonctionnera sans les fonctionnalités IA.")
+
+# --- Fonctions Utilitaires ---
+
+def allowed_file(filename):
+    """Vérifie si l'extension du fichier est autorisée."""
+    return '.' in filename and \
+           filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
+def prepare_gemini_history(chat_history):
+    """Convertit l'historique stocké en session au format attendu par Gemini API."""
+    print(f"--- DEBUG [prepare_gemini_history]: Entrée avec {len(chat_history)} messages") # LOG 1
+    gemini_history = []
+    for i, message in enumerate(list(chat_history)): # Utiliser list() pour itérer sur une copie
+        role = 'user' if message.get('role') == 'user' else 'model'
+        text_part = message.get('raw_text')
+        # Log détaillé pour chaque message traité
+        print(f"  [prepare_gemini_history] Message {i} (rôle session: {message.get('role')}, rôle gemini: {role}): raw_text présent? {'Oui' if text_part is not None else 'NON'}, contenu début: '{str(text_part)[:60]}...'") # LOG 2
+
+        if text_part: # Important: Ne pas ajouter de messages vides à l'historique Gemini
+            parts = [text_part]
+            gemini_history.append({'role': role, 'parts': parts})
+        else:
+            # Log si un message est ignoré car vide
+            print(f"  AVERTISSEMENT [prepare_gemini_history]: raw_text vide ou absent pour le message {i}, ignoré pour l'historique Gemini.") # LOG 3
+
+    print(f"--- DEBUG [prepare_gemini_history]: Sortie avec {len(gemini_history)} messages formatés pour Gemini") # LOG 4
+    return gemini_history
+
+# --- Routes Flask ---
+
+@app.route('/')
+def root():
+    """Sert la page HTML principale."""
+    print("--- LOG: Appel route '/' ---")
+    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."""
+    print("\n--- DEBUG [/api/history]: Début requête GET ---") # LOG 5
+    if 'chat_history' not in session:
+        session['chat_history'] = []
+        print("  [/api/history]: Session 'chat_history' initialisée (vide).")
+
+    display_history = []
+    current_history = session.get('chat_history', [])
+    print(f"  [/api/history]: Historique récupéré de la session serveur: {len(current_history)} messages.") # LOG 6
+
+    # Optionnel: Afficher la structure brute pour un debug profond
+    # print("  [/api/history]: Contenu brut de l'historique session:")
+    # pprint.pprint(current_history)
+
+    for i, msg in enumerate(current_history):
+         # Vérifier la structure de chaque message récupéré
+         if isinstance(msg, dict) and 'role' in msg and 'text' in msg:
+             display_history.append({
+                 'role': msg.get('role'),
+                 'text': msg.get('text') # On envoie bien le HTML ('text') au frontend
+             })
+         else:
+             # Log si un message dans la session est mal formé
+             print(f"  AVERTISSEMENT [/api/history]: Format invalide dans l'historique session au message {i}: {msg}") # LOG 7
+
+    print(f"  [/api/history]: Historique préparé pour le frontend: {len(display_history)} messages.") # LOG 8
+    return jsonify({'success': True, 'history': display_history})
+
+@app.route('/api/chat', methods=['POST'])
+def chat_api():
+    """Gère les nouvelles requêtes de chat via AJAX."""
+    print(f"\n---===================================---")
+    print(f"--- DEBUG [/api/chat]: Nouvelle requête POST ---")
+
+    if not GEMINI_CONFIGURED:
+        print("--- ERREUR [/api/chat]: Tentative d'appel sans configuration Gemini valide.")
+        return jsonify({'success': False, 'error': "Le service IA n'est pas configuré correctement."}), 503
+
+    # Récupération des données du formulaire
+    prompt = request.form.get('prompt', '').strip()
+    use_web_search = request.form.get('web_search', 'false').lower() == 'true'
+    file = request.files.get('file')
+    use_advanced = request.form.get('advanced_reasoning', 'false').lower() == 'true'
+
+    print(f"  [/api/chat]: Prompt reçu: '{prompt[:50]}...'")
+    print(f"  [/api/chat]: Recherche Web: {use_web_search}, Raisonnement Avancé: {use_advanced}")
+    print(f"  [/api/chat]: Fichier: {file.filename if file else 'Aucun'}")
+
+    # Validation
+    if not prompt and not file:
+        print("--- ERREUR [/api/chat]: Prompt et fichier vides.")
+        return jsonify({'success': False, 'error': 'Veuillez fournir un message ou un fichier.'}), 400
+
+    # --- Log de l'état de l'historique AVANT toute modification ---
+    if 'chat_history' not in session:
+        session['chat_history'] = []
+    history_before_user_add = list(session.get('chat_history', [])) # Copie pour le log
+    print(f"--- DEBUG [/api/chat]: Historique en session AVANT ajout user message: {len(history_before_user_add)} messages") # LOG 9
+    # Optionnel: Afficher les derniers messages pour voir le contexte précédent
+    # if history_before_user_add:
+    #     print("  [/api/chat]: Dernier(s) message(s) avant ajout:")
+    #     pprint.pprint(history_before_user_add[-2:]) # Afficher les 2 derniers
+
+    uploaded_gemini_file = None
+    uploaded_filename = None
+    filepath_to_delete = None
+
+    # --- Gestion de l'upload de fichier (avec logs) ---
+    if file and file.filename != '':
+        print(f"--- LOG [/api/chat]: Traitement du fichier '{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)
+                filepath_to_delete = filepath
+                uploaded_filename = filename
+                print(f"  [/api/chat]: Fichier '{filename}' sauvegardé dans '{filepath}'")
+                mime_type = mimetypes.guess_type(filepath)[0] or 'application/octet-stream'
+                print(f"  [/api/chat]: Upload Google AI (Mime: {mime_type})...")
+                uploaded_gemini_file = genai.upload_file(path=filepath, mime_type=mime_type)
+                print(f"  [/api/chat]: Fichier Google AI '{uploaded_gemini_file.name}' uploadé.")
+            except Exception as e:
+                print(f"--- ERREUR [/api/chat]: Échec traitement/upload fichier '{filename}': {e}")
+                if filepath_to_delete and os.path.exists(filepath_to_delete):
+                    try: os.remove(filepath_to_delete)
+                    except OSError as del_e: print(f"  Erreur suppression fichier temp après erreur: {del_e}")
+                return jsonify({'success': False, 'error': f"Erreur traitement fichier: {e}"}), 500
+        else:
+            print(f"--- ERREUR [/api/chat]: Type de fichier non autorisé: {file.filename}")
+            return jsonify({'success': False, 'error': f"Type de fichier non autorisé."}), 400
+
+    # --- Préparation du message utilisateur pour l'historique et Gemini ---
+    raw_user_text = prompt
+    display_user_text = f"[{uploaded_filename}] {prompt}" if uploaded_filename and prompt else (prompt or f"[{uploaded_filename}]")
+    user_history_entry = {
+        'role': 'user',
+        'text': display_user_text,
+        'raw_text': raw_user_text,
+    }
+
+    # Ajout à l'historique de session (vérifier que c'est une liste)
+    if not isinstance(session.get('chat_history'), list):
+        print("--- ERREUR [/api/chat]: 'chat_history' n'est pas une liste! Réinitialisation.")
+        session['chat_history'] = []
+    session['chat_history'].append(user_history_entry)
+
+    # --- Log de l'état de l'historique APRES ajout du message utilisateur ---
+    history_after_user_add = list(session.get('chat_history', [])) # Nouvelle copie
+    print(f"--- DEBUG [/api/chat]: Historique en session APRES ajout user message: {len(history_after_user_add)} messages") # LOG 10
+    # print("  [/api/chat]: Dernier message ajouté (user):")
+    # pprint.pprint(history_after_user_add[-1])
+
+
+    # --- Préparation des 'parts' pour l'appel Gemini ACTUEL ---
+    current_gemini_parts = []
+    # Gérer le cas où seul un fichier est envoyé
+    if uploaded_gemini_file and not raw_user_text:
+         raw_user_text = f"Décris le contenu de ce fichier : {uploaded_filename}"
+         final_prompt_for_gemini = raw_user_text
+         current_gemini_parts.append(uploaded_gemini_file)
+         current_gemini_parts.append(final_prompt_for_gemini)
+         print(f"  [/api/chat]: Fichier seul détecté, prompt généré: '{final_prompt_for_gemini}'")
+    elif uploaded_gemini_file and raw_user_text:
+        final_prompt_for_gemini = raw_user_text
+        current_gemini_parts.append(uploaded_gemini_file)
+        current_gemini_parts.append(final_prompt_for_gemini)
+    else: # Seulement du texte (ou ni texte ni fichier valide, géré plus bas)
+        final_prompt_for_gemini = raw_user_text
+        if final_prompt_for_gemini:
+             current_gemini_parts.append(final_prompt_for_gemini)
+
+    # --- Préparation des paramètres de configuration et modèle ---
+    config = {}
+    selected_model_name = MODEL_PRO if use_advanced else MODEL_FLASH
+    
+    # --- Intégration Google Search ---
+    if use_web_search and final_prompt_for_gemini:
+        print(f"--- LOG [/api/chat]: Activation Google Search pour: '{final_prompt_for_gemini[:60]}...'")
+        # Configurer Google Search comme outil
+        config["tools"] = [{"google_search": {}}]
+        print(f"  [/api/chat]: Configuration Google Search ajoutée")
+
+    # Vérifier si on a quelque chose à envoyer
+    if not current_gemini_parts:
+        print("--- ERREUR [/api/chat]: Aucune donnée (texte ou fichier valide) à envoyer après traitement.")
+        if session.get('chat_history'): session['chat_history'].pop() # Retirer le user message vide/inutile
+        return jsonify({'success': False, 'error': "Impossible d'envoyer une requête vide."}), 400
+
+    # --- Appel à l'API Gemini ---
+    try:
+        # Préparer l'historique des messages PRÉCÉDENTS pour Gemini
+        # Important: Utiliser une copie de l'historique SANS le dernier message utilisateur ajouté
+        history_for_gemini_prep = list(session.get('chat_history', []))[:-1]
+        gemini_history_to_send = prepare_gemini_history(history_for_gemini_prep)
+
+        # Construire le contenu complet pour l'appel
+        contents_for_gemini = gemini_history_to_send + [{'role': 'user', 'parts': current_gemini_parts}]
+
+        # --- LOG DÉTAILLÉ : Ce qui est envoyé à l'API ---
+        print(f"--- DEBUG [/api/chat]: Préparation de l'envoi à l'API Gemini (Modèle: {selected_model_name}) ---") # LOG 11
+        print(f"  Nombre total de tours (historique + actuel): {len(contents_for_gemini)}") # LOG 12a
+        print(f"  Nombre de messages d'historique formatés envoyés: {len(gemini_history_to_send)}") # LOG 12b
+        print(f"  Google Search activé: {use_web_search}")
+        print(f"  Contenu détaillé des 'parts' envoyées:") # LOG 13
+        for i, turn in enumerate(contents_for_gemini):
+            role = turn.get('role')
+            parts_details = []
+            for part in turn.get('parts', []):
+                if isinstance(part, str):
+                    parts_details.append(f"Text({len(part)} chars): '{part[:60].replace(chr(10), ' ')}...'") # Remplacer newline pour log sur 1 ligne
+                elif hasattr(part, 'name') and hasattr(part, 'mime_type'):
+                    parts_details.append(f"File(name={part.name}, mime={part.mime_type})")
+                else:
+                    parts_details.append(f"UnknownPart({type(part)})")
+            print(f"    Turn {i} (role: {role}): {', '.join(parts_details)}")
+        print("--------------------------------------------------------------------")
+
+        # Créer l'instance du modèle et appeler l'API
+        active_model = genai.GenerativeModel(
+            model_name=selected_model_name,
+            safety_settings=SAFETY_SETTINGS,
+            system_instruction=SYSTEM_INSTRUCTION
+        )
+        print(f"--- LOG [/api/chat]: Envoi de la requête à {selected_model_name}...")
+        response = active_model.generate_content(
+            contents=contents_for_gemini,
+            config=config
+        )
+
+        # --- Traitement de la réponse (avec logs) ---
+        response_text_raw = ""
+        response_html = ""
+        search_metadata = None
+        
+        try:
+            if response.parts:
+                response_text_raw = response.text # .text concatène les parts textuelles
+                print(f"--- LOG [/api/chat]: Réponse reçue de Gemini (brute, début): '{response_text_raw[:100]}...'")
+                
+                # Récupération des métadonnées de recherche si disponibles
+                if use_web_search and hasattr(response, 'candidates') and response.candidates:
+                    candidate = response.candidates[0]
+                    if hasattr(candidate, 'grounding_metadata'):
+                        metadata = candidate.grounding_metadata
+                        search_metadata = {}
+                        
+                        # Requêtes de recherche
+                        if hasattr(metadata, 'web_search_queries'):
+                            search_metadata["search_queries"] = metadata.web_search_queries
+                        
+                        # Pages de recherche utilisées
+                        if hasattr(metadata, 'grounding_chunks'):
+                            search_pages = [
+                                {
+                                    "title": site.web.title if hasattr(site, 'web') and hasattr(site.web, 'title') else "Sans titre",
+                                    "url": site.web.url if hasattr(site, 'web') and hasattr(site.web, 'url') else "#",
+                                    "snippet": site.web.snippet if hasattr(site, 'web') and hasattr(site.web, 'snippet') else ""
+                                }
+                                for site in metadata.grounding_chunks if hasattr(site, 'web')
+                            ]
+                            search_metadata["search_pages"] = search_pages
+                        
+                        # Contenu HTML rendu
+                        if hasattr(metadata, 'search_entry_point') and hasattr(metadata.search_entry_point, 'rendered_content'):
+                            search_metadata["rendered_content"] = metadata.search_entry_point.rendered_content
+                        
+                        print(f"--- LOG [/api/chat]: Métadonnées de recherche Google récupérées:")
+                        if search_metadata.get("search_queries"):
+                            print(f"  Requêtes: {search_metadata['search_queries']}")
+                        if search_metadata.get("search_pages"):
+                            print(f"  Pages: {len(search_metadata['search_pages'])} sources")
+            else:
+                feedback_info = f"Feedback: {response.prompt_feedback}" if response.prompt_feedback else "Pas de feedback détaillé."
+                print(f"--- AVERTISSEMENT [/api/chat]: Réponse Gemini sans 'parts'. {feedback_info}")
+                if response.prompt_feedback and response.prompt_feedback.block_reason:
+                    reason = response.prompt_feedback.block_reason.name
+                    response_text_raw = f"Désolé, ma réponse a été bloquée ({reason})."
+
+            # Convertir le Markdown en HTML pour l'affichage
+            response_html = markdown.markdown(response_text_raw, extensions=['extra'])
+            print(f"--- LOG [/api/chat]: Réponse convertie en HTML")
+
+            # --- Créer l'entrée d'historique et l'ajouter à la session ---
+            assistant_history_entry = {
+                'role': 'assistant',
+                'text': response_html, # Version HTML pour affichage
+                'raw_text': response_text_raw, # Version brute pour l'historique Gemini
+                'search_metadata': search_metadata # Métadonnées de recherche
+            }
+            
+            # Ajouter à l'historique en vérifiant que c'est bien une liste
+            if not isinstance(session.get('chat_history'), list):
+                print("--- ERREUR [/api/chat]: 'chat_history' n'est pas une liste pendant l'ajout de réponse!")
+                session['chat_history'] = [] # Reset
+            session['chat_history'].append(assistant_history_entry)
+            
+            # --- Nettoyer le fichier temporaire si nécessaire ---
+            if filepath_to_delete and os.path.exists(filepath_to_delete):
+                try:
+                    os.remove(filepath_to_delete)
+                    print(f"--- LOG [/api/chat]: Fichier temporaire '{filepath_to_delete}' supprimé.")
+                except OSError as e:
+                    print(f"--- ERREUR [/api/chat]: Impossible de supprimer le fichier temporaire: {e}")
+            
+            # --- Préparer la réponse JSON pour le client ---
+            response_object = {
+                'success': True,
+                'text': response_html,
+                'search_metadata': search_metadata
+            }
+            return jsonify(response_object)
+        
+        except Exception as process_error:
+            print(f"--- ERREUR [/api/chat]: Traitement de la réponse: {process_error}")
+            # Nettoyer en cas d'erreur
+            if filepath_to_delete and os.path.exists(filepath_to_delete):
+                try: os.remove(filepath_to_delete)
+                except OSError as e: print(f"  Erreur suppression fichier temp après erreur: {e}")
+            return jsonify({'success': False, 'error': f"Erreur traitement réponse: {process_error}"}), 500
+    
+    except Exception as call_error:
+        print(f"--- ERREUR [/api/chat]: Appel à l'API Gemini: {call_error}")
+        # Nettoyer en cas d'erreur
+        if filepath_to_delete and os.path.exists(filepath_to_delete):
+            try: os.remove(filepath_to_delete)
+            except OSError as e: print(f"  Erreur suppression fichier temp après erreur: {e}")
+        return jsonify({'success': False, 'error': f"Erreur API Gemini: {call_error}"}), 500
+
+if __name__ == '__main__':
+    # Vérifier si la variable d'environnement API_KEY est définie
+    if 'GOOGLE_API_KEY' not in os.environ:
+        print("Attention: La variable d'environnement GOOGLE_API_KEY n'est pas définie.")
+        print("Vous devrez la définir avant d'exécuter l'application:")
+        print("export GOOGLE_API_KEY=votre_clé_api")
+    
+    app.run(debug=True, host='0.0.0.0', port=int(os.environ.get('PORT', 5000)))