# --- START OF FILE app.py --- import os import json import mimetypes 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 import requests 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." # Nouveaux réglages de sécurité avec le nouveau SDK SAFETY_SETTINGS = [ types.SafetySetting( category=types.HarmCategory.HARM_CATEGORY_HATE_SPEECH, threshold=types.HarmBlockThreshold.BLOCK_NONE, ), types.SafetySetting( category=types.HarmCategory.HARM_CATEGORY_HARASSMENT, threshold=types.HarmBlockThreshold.BLOCK_NONE, ), types.SafetySetting( category=types.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT, threshold=types.HarmBlockThreshold.BLOCK_NONE, ), types.SafetySetting( category=types.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT, threshold=types.HarmBlockThreshold.BLOCK_NONE, ) ] GEMINI_CONFIGURED = False genai_client = None 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: # Initialisation du client avec le nouveau SDK genai_client = genai.Client(api_key=gemini_api_key) # Vérification de la disponibilité des modèles try: # Le nouveau SDK peut avoir une méthode différente pour lister les modèles models = genai_client.list_models() models_list = [model.name for model in models] # Vérifier si les modèles requis sont disponibles if any(MODEL_FLASH in model for model in models_list) and any(MODEL_PRO in model for model 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_models: print(f"ERREUR lors de la vérification des modèles: {e_models}") # En cas d'échec de la vérification des modèles, supposons que les modèles sont disponibles print("Tentative de continuer sans vérification des modèles disponibles.") GEMINI_CONFIGURED = True 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 perform_web_search_with_gemini(query, client, model_id): """Effectue une recherche web via l'API Google Search intégrée à Gemini.""" try: print(f"--- LOG WEBSEARCH: Recherche Google avec Gemini pour: '{query}'") # Utiliser l'outil de recherche Google intégré à Gemini response = client.models.generate_content( model=model_id, contents=query, config=types.GenerateContentConfig( tools=[{"google_search": {}}] ) ) print("--- LOG WEBSEARCH: Résultats de recherche Google obtenus.") # Extraction des informations de recherche pour le débogage if hasattr(response, 'candidates') and response.candidates: if hasattr(response.candidates[0], 'grounding_metadata'): search_queries = getattr(response.candidates[0].grounding_metadata, 'web_search_queries', None) if search_queries: print(f"--- LOG WEBSEARCH: Requêtes utilisées: {search_queries}") grounding_chunks = getattr(response.candidates[0].grounding_metadata, 'grounding_chunks', None) if grounding_chunks: sources = [getattr(chunk, 'web', None) for chunk in grounding_chunks] source_titles = [getattr(source, 'title', 'Sans titre') for source in sources if source] print(f"--- LOG WEBSEARCH: Sources utilisées: {', '.join(source_titles)}") return response except Exception as e: print(f"--- LOG WEBSEARCH: Erreur lors de la recherche web avec Gemini : {e}") return None def format_search_response(response): """Extrait et met en forme le texte de la réponse de recherche web.""" if not response: return "Aucun résultat de recherche web trouvé pertinent." try: return response.text except Exception as e: print(f"--- LOG WEBSEARCH: Erreur lors de l'extraction du texte de la réponse : {e}") return "Impossible d'extraire les résultats de recherche." 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 # Avec le nouveau SDK, la structure de l'historique pourrait être différente 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' # 'model' au lieu de 'assistant' pour le nouveau SDK 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 gemini_history.append({ 'role': role, 'parts': [text_part] }) 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 or not genai_client: 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 uploaded_file_part = 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]: Préparation du fichier pour Gemini (Mime: {mime_type})...") # Avec le nouveau SDK, la méthode d'upload a peut-être changé with open(filepath, "rb") as f: file_data = f.read() # Création d'une partie de type fichier pour l'API uploaded_file_part = { "inline_data": { "mime_type": mime_type, "data": file_data } } print(f" [/api/chat]: Fichier préparé pour Gemini.") 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 # --- Sélection du modèle --- selected_model_name = MODEL_PRO if use_advanced else MODEL_FLASH # --- Préparation des contenus pour l'appel Gemini --- final_prompt_for_gemini = raw_user_text # Gérer le cas où seul un fichier est envoyé if uploaded_file_part 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 print(f" [/api/chat]: Fichier seul détecté, prompt généré: '{final_prompt_for_gemini}'") # --- Recherche Web si demandée --- web_search_results = None if use_web_search and final_prompt_for_gemini: print(f"--- LOG [/api/chat]: Activation recherche web pour: '{final_prompt_for_gemini[:60]}...'") web_search_response = perform_web_search_with_gemini(final_prompt_for_gemini, genai_client, selected_model_name) if web_search_response: web_search_results = format_search_response(web_search_response) print(f" [/api/chat]: Résultats de recherche obtenus.") # Avec le nouveau SDK et l'outil de recherche intégré, pas besoin de reformater le prompt # car la recherche est gérée directement par l'API # Préparer l'historique des messages PRÉCÉDENTS pour Gemini history_for_gemini_prep = list(session.get('chat_history', []))[:-1] # Sans le dernier message utilisateur gemini_history_to_send = prepare_gemini_history(history_for_gemini_prep) # --- Appel à l'API Gemini --- try: print(f"--- DEBUG [/api/chat]: Préparation de l'envoi à l'API Gemini (Modèle: {selected_model_name}) ---") # LOG 11 # Construire le contenu pour l'appel avec le nouveau SDK contents = [] # Ajouter l'historique for message in gemini_history_to_send: contents.append({ "role": message["role"], "parts": message["parts"] }) # Ajouter le message actuel de l'utilisateur current_user_parts = [] # Si un fichier est présent, l'ajouter d'abord if uploaded_file_part: current_user_parts.append(uploaded_file_part) # Ajouter le texte du message if final_prompt_for_gemini: current_user_parts.append(final_prompt_for_gemini) if current_user_parts: contents.append({ "role": "user", "parts": current_user_parts }) # Log détaillé de ce qui est envoyé print(f" Nombre total de messages pour Gemini: {len(contents)}") for i, content in enumerate(contents): role = content.get("role") parts = content.get("parts", []) parts_info = [] for part in parts: if isinstance(part, str): parts_info.append(f"Text({len(part)} chars): '{part[:50]}...'") elif isinstance(part, dict) and "inline_data" in part: parts_info.append(f"File(mime={part['inline_data']['mime_type']})") else: parts_info.append(f"Part({type(part)})") print(f" Message {i} (role: {role}): {', '.join(parts_info)}") # Configuration de l'appel à l'API generate_config = types.GenerateContentConfig( system_instruction=SYSTEM_INSTRUCTION, safety_settings=SAFETY_SETTINGS ) # Ajouter la configuration de recherche web si demandée if use_web_search: generate_config.tools = [{"google_search": {}}] # Appel à l'API avec le nouveau SDK print(f"--- LOG [/api/chat]: Envoi de la requête à {selected_model_name}...") response = genai_client.models.generate_content( model=selected_model_name, contents=contents, config=generate_config ) # --- Traitement de la réponse (avec logs) --- response_text_raw = "" response_html = "" try: # Extraction du texte de la réponse avec le nouveau SDK if hasattr(response, 'text'): response_text_raw = response.text print(f"--- LOG [/api/chat]: Réponse reçue de Gemini (brute, début): '{response_text_raw[:100]}...'") elif hasattr(response, 'parts'): response_text_raw = ' '.join([str(part) for part in response.parts]) print(f"--- LOG [/api/chat]: Réponse extraite des parts: '{response_text_raw[:100]}...'") else: # Gestion des erreurs de sécurité ou autres if hasattr(response, 'prompt_feedback'): feedback = response.prompt_feedback if feedback: block_reason = getattr(feedback, 'block_reason', None) if block_reason: response_text_raw = f"Désolé, ma réponse a été bloquée ({block_reason})." else: response_text_raw = "Désolé, je n'ai pas pu générer de réponse (restrictions de sécurité)." else: response_text_raw = "Désolé, je n'ai pas pu générer de réponse." print(f" [/api/chat]: Message d'erreur généré: '{response_text_raw}'") # Conversion Markdown response_html = markdown.markdown(response_text_raw, extensions=['fenced_code', 'tables', 'nl2br']) if response_html != response_text_raw: print(f" [/api/chat]: Réponse convertie en HTML.") except Exception as e_resp: print(f"--- ERREUR [/api/chat]: Erreur lors du traitement de la réponse Gemini : {e_resp}") print(f" Réponse brute: {response}") response_text_raw = f"Désolé, erreur inattendue ({type(e_resp).__name__})." response_html = markdown.markdown(response_text_raw) # --- Ajout de la réponse Assistant à l'historique de session --- assistant_history_entry = { 'role': 'assistant', 'text': response_html, 'raw_text': response_text_raw } if not isinstance(session.get('chat_history'), list): print("--- ERREUR [/api/chat]: 'chat_history' n'est pas liste avant ajout assistant! Réinitialisation.") session['chat_history'] = [user_history_entry] # Garder au moins user msg session['chat_history'].append(assistant_history_entry) # --- Log de l'état final de l'historique pour ce tour --- history_final_turn = list(session.get('chat_history', [])) print(f"--- DEBUG [/api/chat]: Historique en session FINAL après ajout assistant: {len(history_final_turn)} messages") # LOG 14 # --- Renvoyer la réponse au frontend --- print(f"--- LOG [/api/chat]: Envoi de la réponse HTML au client.") print(f"---==================================---\n") return jsonify({'success': True, 'message': response_html}) except Exception as e: print(f"--- ERREUR CRITIQUE [/api/chat]: Échec appel Gemini ou traitement réponse : {e}") # Tentative de retrait du dernier message utilisateur en cas d'erreur current_history = session.get('chat_history') if isinstance(current_history, list) and current_history: try: if current_history[-1].get('role') == 'user': current_history.pop() print(" [/api/chat]: Dernier message user retiré de l'historique suite à l'erreur.") else: print(" [/api/chat]: Dernier message n'était pas 'user', historique non modifié après erreur.") except Exception as pop_e: print(f" Erreur lors tentative retrait message user: {pop_e}") print(f"---==================================---\n") return jsonify({'success': False, 'error': f"Erreur interne: {e}"}), 500 finally: # --- Nettoyage des fichiers locaux --- if filepath_to_delete and os.path.exists(filepath_to_delete): try: os.remove(filepath_to_delete) print(f"--- LOG [/api/chat FINALLY]: Fichier temporaire local '{filepath_to_delete}' supprimé.") except OSError as e_del_local: print(f"--- ERREUR [/api/chat FINALLY]: Échec suppression fichier local '{filepath_to_delete}': {e_del_local}") @app.route('/clear', methods=['POST']) def clear_chat(): """Efface l'historique de chat dans la session.""" print("\n--- DEBUG [/clear]: Requête POST reçue ---") session.clear() # Efface toutes les données de la session serveur actuelle print(" [/clear]: Session serveur effacée.") is_ajax = 'XMLHttpRequest' == request.headers.get('X-Requested-With') or \ 'application/json' in request.headers.get('Accept', '') if is_ajax: print(" [/clear]: Réponse JSON (AJAX).") return jsonify({'success': True, 'message': 'Historique effacé.'}) else: print(" [/clear]: Réponse Flash + Redirect (non-AJAX).") flash("Conversation effacée.", "info") return redirect(url_for('root')) # --- Démarrage de l'application --- if __name__ == '__main__': print("--- Démarrage du serveur Flask ---") port = int(os.environ.get('PORT', 5001)) # Mettre debug=True pour le développement et voir les logs facilement. # ATTENTION: NE PAS UTILISER debug=True en production ! app.run(debug=True, host='0.0.0.0', port=port) # --- END OF FILE app.py ---