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' # Mise à jour des modèles MODEL_PRO = 'gemini-2.5-pro-exp-03-25' # Mise à jour des modèles 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 --- selected_model_name = MODEL_PRO if use_advanced else MODEL_FLASH # 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}...") # Modification pour utiliser google_search_retrieval si la recherche web est activée if use_web_search: print(f"--- LOG [/api/chat]: Activation Google Search Retrieval...") response = active_model.generate_content( contents=contents_for_gemini, tools='google_search_retrieval' ) else: response = active_model.generate_content( contents=contents_for_gemini ) # --- 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, 'citation_metadata'): metadata = candidate.citation_metadata search_metadata = {} # Extraire les citations et références if hasattr(metadata, 'citations'): search_pages = [] for citation in metadata.citations: if hasattr(citation, 'start_index') and hasattr(citation, 'end_index'): search_pages.append({ "title": citation.title if hasattr(citation, 'title') else "Sans titre", "url": citation.uri if hasattr(citation, 'uri') else "#", "snippet": f"Citation: {citation.start_index}-{citation.end_index}" }) if search_pages: search_metadata["search_pages"] = search_pages print(f"--- LOG [/api/chat]: Métadonnées de citation récupérées:") if search_metadata and 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)))