import os import json import mimetypes import time import re # Pour la détection d'URL YouTube 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 Markdown en HTML # --- Configuration Initiale --- load_dotenv() # Charge les variables depuis .env app = Flask(__name__) # Clé secrète FORTEMENT recommandée pour la sécurité des sessions app.config['SECRET_KEY'] = os.getenv('FLASK_SECRET_KEY', 'une-cle-secrete-tres-difficile-a-deviner') # Configuration pour les uploads UPLOAD_FOLDER = 'temp' # Extensions autorisées (incluant vidéo) ALLOWED_EXTENSIONS = {'txt', 'pdf', 'png', 'jpg', 'jpeg', 'mp4', 'mov', 'avi', 'mkv', 'webm'} VIDEO_EXTENSIONS = {'mp4', 'mov', 'avi', 'mkv', 'webm'} # Pour identifier les vidéos app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER # Augmenter la limite pour les vidéos (ex: 100MB) - Ajustez si nécessaire app.config['MAX_CONTENT_LENGTH'] = 100 * 1024 * 1024 # Crée le dossier temporaire s'il n'existe pas os.makedirs(UPLOAD_FOLDER, exist_ok=True) print(f"Dossier d'upload configuré : {os.path.abspath(UPLOAD_FOLDER)}") # --- Configuration de l'API Gemini --- # Utilisez les noms de modèles les plus récents auxquels vous avez accès MODEL_FLASH = 'gemini-2.0-flash' MODEL_PRO = 'gemini-2.5-pro-03-25' # Pro est souvent nécessaire/meilleur pour la vidéo # Instruction système pour le modèle SYSTEM_INSTRUCTION = "Tu es un assistant intelligent et amical nommé Mariam. Tu assistes les utilisateurs au mieux de tes capacités, y compris dans l'analyse de texte, d'images et de vidéos (via upload ou lien YouTube). Tu as été créé par Aenir." # Paramètres de sécurité (ajuster si nécessaire, BLOCK_NONE est très permissif) SAFETY_SETTINGS = [ {"category": c, "threshold": "BLOCK_NONE"} for c in [ "HARM_CATEGORY_HARASSMENT", "HARM_CATEGORY_HATE_SPEECH", "HARM_CATEGORY_SEXUALLY_EXPLICIT", "HARM_CATEGORY_DANGEROUS_CONTENT"]] GEMINI_CONFIGURED = False gemini_client = None # Client API pour les opérations sur les fichiers (upload vidéo) try: gemini_api_key = os.getenv("GOOGLE_API_KEY") if not gemini_api_key: raise ValueError("Clé API GOOGLE_API_KEY manquante dans le fichier .env") # Initialise le client pour les opérations sur les fichiers ET pour lister les modèles gemini_client = genai.Client(api_key=gemini_api_key) # Configure également l'espace de noms global pour GenerativeModel, etc. # genai.configure(api_key=gemini_api_key) # Cette ligne peut être redondante si le client est utilisé partout # Vérifie si les modèles requis sont disponibles en utilisant le client print("Vérification des modèles Gemini disponibles...") models_list = [m.name for m in gemini_client.models.list()] # <-- LIGNE CORRIGÉE required_models = [f'models/{MODEL_FLASH}', f'models/{MODEL_PRO}'] if all(model in models_list for model in required_models): print(f"Configuration Gemini effectuée. Modèles requis trouvés.") print(f"Instruction Système: {SYSTEM_INSTRUCTION}") GEMINI_CONFIGURED = True else: missing = [model for model in required_models if model not in models_list] raise ValueError(f"Les modèles Gemini requis suivants sont manquants: {missing}") 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.") gemini_client = None # S'assure que le client est None si la config échoue GEMINI_CONFIGURED = False # S'assurer qu'il est False en cas d'erreur # --- Fonctions Utilitaires --- def get_file_extension(filename): """Retourne l'extension du fichier en minuscules, ou None.""" return filename.rsplit('.', 1)[1].lower() if '.' in filename else None def allowed_file(filename): """Vérifie si l'extension du fichier est dans la liste autorisée.""" return get_file_extension(filename) in ALLOWED_EXTENSIONS def is_video_file(filename): """Vérifie si l'extension correspond à un type vidéo connu.""" return get_file_extension(filename) in VIDEO_EXTENSIONS def is_youtube_url(url): """Vérifie si la chaîne ressemble à une URL YouTube valide.""" if not url: # Gère les cas où l'URL est None ou vide return False # Regex simple pour les formats courants d'URL YouTube youtube_regex = re.compile( r'(https?://)?(www.)?' # Protocole et www optionnels r'(youtube|youtu|youtube-nocookie).(com|be)/' # Domaines youtube.com, youtu.be, etc. r'(watch?v=|embed/|v/|.+?v=)?' # Différents chemins possibles r'([^&=%\?]{11})') # L'ID vidéo de 11 caractères return youtube_regex.match(url) is not None # --- Fonction d'Upload Vidéo avec Polling --- def upload_video_with_polling(filepath, mime_type, max_wait_seconds=300, poll_interval=10): """ Upload une vidéo via client.files.upload et attend son traitement. Retourne l'objet File traité ou lève une exception. """ if not gemini_client: raise ConnectionError("Le client Gemini n'est pas initialisé.") print(f"Début de l'upload vidéo via client.files: {filepath} ({mime_type})") video_file = None # Initialise la variable pour le bloc finally try: # Lance l'upload video_file = gemini_client.files.upload(path=filepath, mime_type=mime_type) print(f"Upload initialisé. Nom du fichier distant: {video_file.name}. Attente du traitement...") start_time = time.time() # Boucle de polling tant que l'état est "PROCESSING" while video_file.state == genai.types.FileState.PROCESSING: elapsed_time = time.time() - start_time # Vérifie le timeout if elapsed_time > max_wait_seconds: raise TimeoutError(f"Le traitement de la vidéo a dépassé le délai de {max_wait_seconds} secondes.") print(f"Vidéo en cours de traitement... (État: {video_file.state.name}, {int(elapsed_time)}s écoulées)") time.sleep(poll_interval) # Récupère l'état mis à jour du fichier video_file = gemini_client.files.get(name=video_file.name) # Vérifie l'état final après la boucle if video_file.state == genai.types.FileState.FAILED: print(f"ERREUR: Le traitement de la vidéo a échoué. État: {video_file.state.name}") raise ValueError("Le traitement de la vidéo a échoué côté serveur.") if video_file.state == genai.types.FileState.ACTIVE: print(f"Traitement vidéo terminé avec succès: {video_file.uri}") return video_file # Retourne l'objet fichier SDK réussi else: # Gère d'autres états inattendus si nécessaire print(f"AVERTISSEMENT: État inattendu du fichier vidéo après traitement: {video_file.state.name}") raise RuntimeError(f"État inattendu du fichier vidéo: {video_file.state.name}") except Exception as e: print(f"Erreur lors de l'upload/traitement vidéo via client.files: {e}") # Tente de supprimer le fichier distant en cas d'erreur pendant le polling/upload if video_file and hasattr(video_file, 'name'): try: gemini_client.files.delete(name=video_file.name) print(f"Tentative de nettoyage du fichier distant {video_file.name} après erreur.") except Exception as delete_err: print(f"Échec du nettoyage du fichier distant {video_file.name} après erreur: {delete_err}") raise # Relance l'exception originale pour qu'elle soit gérée par l'appelant # --- Fonctions de Recherche Web (inchangées - implémentez si nécessaire) --- def perform_web_search(query): """Effectue une recherche web via l'API Serper (Exemple).""" serper_api_key = os.getenv("SERPER_API_KEY") if not serper_api_key: print("AVERTISSEMENT: Clé API SERPER_API_KEY manquante. Recherche web désactivée.") return None # ... (votre implémentation de la recherche Serper) ... print(f"Recherche Web (simulation) pour : {query}") # Simuler des résultats pour le test # return {"organic": [{"title": "Résultat Web 1", "link": "#", "snippet": "Description du résultat 1..."}]} return None # Désactivé par défaut def format_search_results(data): """Met en forme les résultats de recherche (Exemple).""" if not data: return "Aucun résultat de recherche web pertinent." # ... (votre implémentation du formatage) ... results = ["Résultats Web:"] if data.get('organic'): for item in data['organic'][:3]: results.append(f"- {item.get('title', '')}: {item.get('snippet', '')}") return "\n".join(results) # --- Préparation Historique (inchangé) --- def prepare_gemini_history(chat_history): """Convertit l'historique de session pour l'API Gemini (texte seulement).""" gemini_history = [] for message in chat_history: # Ne transmet que le texte brut des messages précédents role = 'user' if message['role'] == 'user' else 'model' text_part = message.get('raw_text', '') # Utilise raw_text stocké # Ne pas inclure les fichiers/médias des tours précédents pour simplifier if text_part: # N'ajoute que s'il y a du texte gemini_history.append({'role': role, 'parts': [text_part]}) return gemini_history # --- Routes Flask --- @app.route('/') def root(): """Sert la page HTML principale.""" return render_template('index.html') @app.route('/api/history', methods=['GET']) def get_history(): """Fournit l'historique de chat (formaté pour affichage) en JSON.""" if 'chat_history' not in session: session['chat_history'] = [] # Prépare l'historique pour l'affichage (contient 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 historique ({len(display_history)} messages)") # Debug return jsonify({'success': True, 'history': display_history}) @app.route('/api/chat', methods=['POST']) def chat_api(): """Gère les requêtes de chat (texte, fichier/vidéo uploadé, URL YouTube).""" # Vérifie si Gemini est configuré correctement if not GEMINI_CONFIGURED or not gemini_client: print("API ERREUR: Tentative d'appel à /api/chat 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() youtube_url = request.form.get('youtube_url', '').strip() # Récupère le champ YouTube dédié use_web_search = request.form.get('web_search', 'false').lower() == 'true' use_advanced = request.form.get('advanced_reasoning', 'false').lower() == 'true' file = request.files.get('file') # Récupère le fichier uploadé # --- Validation de l'entrée (au moins un type d'input requis) --- if not file and not youtube_url and not prompt: return jsonify({'success': False, 'error': 'Veuillez fournir un message, un fichier/vidéo ou un lien YouTube.'}), 400 print(f"\n--- Nouvelle requête /api/chat ---") print(f" Prompt: '{prompt[:50]}...'") print(f" Fichier: {file.filename if file else 'Non'}") print(f" URL YouTube: {youtube_url if youtube_url else 'Non'}") print(f" Web Search: {use_web_search}, Advanced: {use_advanced}") # Initialise l'historique de session si nécessaire if 'chat_history' not in session: session['chat_history'] = [] # --- Variables pour le traitement --- uploaded_media_part = None # Part(file_data=...) pour Gemini uploaded_filename_for_display = None # Nom à afficher dans le chat user filepath_to_delete = None # Chemin du fichier temporaire à supprimer is_media_request = False # True si fichier ou URL YT est l'input principal media_type = None # 'file', 'video', 'youtube', ou 'text' # --- Traitement de l'entrée (Priorité: Fichier > YouTube > Texte) --- try: # 1. Traiter le fichier uploadé s'il existe if file and file.filename != '': is_media_request = True media_type = 'file' # Par défaut, pourrait devenir 'video' uploaded_filename_for_display = secure_filename(file.filename) if not allowed_file(uploaded_filename_for_display): raise ValueError(f"Type de fichier non autorisé: {uploaded_filename_for_display}") # Sauvegarde temporaire du fichier filepath = os.path.join(app.config['UPLOAD_FOLDER'], uploaded_filename_for_display) file.save(filepath) filepath_to_delete = filepath # Marque pour suppression future print(f" Fichier '{uploaded_filename_for_display}' sauvegardé -> '{filepath}'") mime_type = mimetypes.guess_type(filepath)[0] or 'application/octet-stream' # Utilise le polling pour les vidéos, upload direct pour les autres if is_video_file(uploaded_filename_for_display): media_type = 'video' print(" Traitement VIDÉO Uploadée (avec polling)...") # Appel bloquant qui attend le traitement processed_media_file = upload_video_with_polling(filepath, mime_type) # Crée le Part Gemini à partir de l'objet File retourné uploaded_media_part = genai.types.Part(file_data=processed_media_file) else: print(" Traitement FICHIER standard...") # Utilise l'upload global plus simple pour les non-vidéos processed_media_file = genai.upload_file(path=filepath, mime_type=mime_type) uploaded_media_part = genai.types.Part(file_data=processed_media_file) print(f" Part Média ({media_type}) créé: {processed_media_file.uri}") # 2. Sinon, traiter l'URL YouTube si fournie et valide elif youtube_url: if not is_youtube_url(youtube_url): print(f" AVERTISSEMENT: '{youtube_url}' n'est pas un lien YouTube valide, sera ignoré ou traité comme texte si prompt vide.") # Si le prompt est aussi vide, on ne fait rien de spécial ici, # la validation initiale aurait dû échouer. Si prompt existe, il sera traité. media_type = 'text' # Considéré comme texte simple si invalide else: is_media_request = True media_type = 'youtube' print(" Traitement LIEN YouTube...") uploaded_filename_for_display = youtube_url # Affiche l'URL pour l'utilisateur youtube_uri = youtube_url # Utilise l'URL validée comme URI # Crée un Part FileData directement à partir de l'URI # On peut spécifier un mime_type générique, Gemini gère les liens YT uploaded_media_part = genai.types.Part( file_data=genai.types.FileData(file_uri=youtube_uri, mime_type="video/mp4") ) print(f" Part YouTube créé pour: {youtube_uri}") # Ajoute un prompt par défaut si l'utilisateur n'en a pas mis if not prompt: prompt = "Décris ou analyse le contenu de cette vidéo YouTube." print(f" Prompt par défaut ajouté pour YouTube: '{prompt}'") # 3. Si ni fichier ni URL YT valide, c'est une requête texte elif prompt: media_type = 'text' print(" Traitement PROMPT texte seul.") else: # Ce cas ne devrait pas arriver à cause de la validation initiale raise ValueError("Aucune entrée valide (fichier, URL YouTube ou texte) fournie.") # --- Préparer et stocker le message utilisateur dans l'historique --- # Construit le texte qui sera affiché dans l'historique du chat display_user_text = prompt # Par défaut, le prompt texte if media_type == 'file' or media_type == 'video': # Précède le prompt par le nom du fichier entre crochets display_user_text = f"[{uploaded_filename_for_display}]" + (f" {prompt}" if prompt else "") elif media_type == 'youtube': # Précède par [YouTube], ajoute le prompt, puis l'URL sur une nouvelle ligne display_user_text = f"[YouTube]" + (f" {prompt}" if prompt else "") + f"\n{uploaded_filename_for_display}" user_history_entry = { 'role': 'user', 'text': display_user_text, # Texte formaté pour l'affichage 'raw_text': prompt # Texte brut original pour futurs appels Gemini # Note: On ne stocke pas l'objet media_part dans la session } session['chat_history'].append(user_history_entry) session.modified = True # Marque la session comme modifiée # --- Préparer les 'parts' pour l'appel API Gemini --- current_gemini_parts = [] # Ajouter le média (fichier uploadé ou URL YT) s'il existe if uploaded_media_part: current_gemini_parts.append(uploaded_media_part) # Préparer le prompt textuel final (peut être enrichi par la recherche web) final_prompt_for_gemini = prompt # --- Recherche Web (Optionnelle, uniquement pour les requêtes texte) --- if use_web_search and prompt and media_type == 'text': print(" Activation Recherche Web...") search_data = perform_web_search(prompt) if search_data: formatted_results = format_search_results(search_data) # Construit un prompt enrichi final_prompt_for_gemini = f"""Basé sur la question suivante et les informations web ci-dessous, fournis une réponse complète. Question Originale: "{prompt}" Informations Web Pertinentes: --- DEBUT RESULTATS WEB --- {formatted_results} --- FIN RESULTATS WEB --- Réponse:""" print(" Prompt enrichi avec les résultats web.") else: print(" Aucun résultat de recherche web trouvé ou pertinent.") # Ajouter la partie texte (originale ou enrichie) s'il y a du texte if final_prompt_for_gemini: current_gemini_parts.append(genai.types.Part(text=final_prompt_for_gemini)) # Vérification de sécurité : il doit y avoir au moins une partie (média ou texte) if not current_gemini_parts: print("ERREUR: Aucune partie (média ou texte) à envoyer à Gemini.") raise ValueError("Impossible de traiter la requête : contenu vide.") # --- Appel à l'API Gemini --- # Prépare l'historique des messages PRÉCÉDENTS (texte seulement) gemini_history = prepare_gemini_history(session['chat_history'][:-1]) # Exclut le message actuel # Construit le contenu complet pour l'appel API contents_for_gemini = gemini_history + [{'role': 'user', 'parts': current_gemini_parts}] # Sélectionne le modèle : Pro pour média ou si avancé demandé, sinon Flash selected_model_name = MODEL_PRO if is_media_request or use_advanced else MODEL_FLASH print(f" Modèle sélectionné: {selected_model_name}") # Crée l'instance du modèle spécifique pour cette requête active_model = gemini_client.models.generate_content( model_name=selected_model_name, contents = contents_for_gemini, # Virgule ajoutée ici config = genai.types.GenerateContentConfig( system_instruction=SYSTEM_INSTRUCTION, safety_settings=[ genai.types.SafetySetting( category=genai.types.HarmCategory.HARM_CATEGORY_HATE_SPEECH, threshold=genai.types.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE, ), genai.types.SafetySetting( category=genai.types.HarmCategory.HARM_CATEGORY_HARASSMENT, threshold=genai.types.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE, ), genai.types.SafetySetting( category=genai.types.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT, threshold=genai.types.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE, ), genai.types.SafetySetting( category=genai.types.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT, threshold=genai.types.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE, ) ] ), ) print(f" Envoi de la requête à {selected_model_name} ({len(contents_for_gemini)} messages/tours)...") # Appel API (non-streamé pour correspondre au code précédent) response = active_model # --- Traitement de la Réponse --- response_text_raw = "" response_html = "" try: # Accède au texte de la réponse. Peut lever une exception si bloqué. response_text_raw = response.text except ValueError: # Typiquement levé si la réponse est bloquée par les filtres print(" ERREUR: La réponse de Gemini a été bloquée (probablement par les safety settings).") # Fournit les détails du blocage si disponibles try: print(f" Détails du blocage : {response.prompt_feedback}") except Exception: pass # Ignore si prompt_feedback n'est pas accessible response_text_raw = "Désolé, ma réponse a été bloquée car elle pourrait enfreindre les règles de sécurité." except Exception as resp_err: # Gère d'autres erreurs potentielles print(f" ERREUR inattendue lors de l'accès à response.text : {resp_err}") print(f" Réponse brute complète : {response}") # Log la réponse brute pour le debug response_text_raw = "Désolé, une erreur interne s'est produite lors de la réception de la réponse." # Convertit la réponse (même les messages d'erreur) en HTML print(f" Réponse reçue (début): '{response_text_raw[:100]}...'") response_html = markdown.markdown(response_text_raw, extensions=['fenced_code', 'tables', 'nl2br']) print(" Réponse convertie en HTML.") # --- Stocker la réponse de l'assistant et retourner au client --- assistant_history_entry = { 'role': 'assistant', 'text': response_html, # HTML pour l'affichage via get_history 'raw_text': response_text_raw # Texte brut pour les futurs appels Gemini } session['chat_history'].append(assistant_history_entry) session.modified = True print(" Envoi de la réponse HTML au client.") return jsonify({'success': True, 'message': response_html}) # --- Gestion des Erreurs spécifiques (Timeout, Fichier invalide, etc.) --- except (TimeoutError, ValueError, ConnectionError, FileNotFoundError) as e: error_message = f"Erreur lors du traitement de la requête: {e}" print(f"ERREUR (Traitement/Appel API): {error_message}") # Retire le dernier message utilisateur de l'historique en cas d'erreur pour éviter les boucles if session.get('chat_history'): session['chat_history'].pop() session.modified = True print(" Dernier message utilisateur retiré de l'historique après erreur.") return jsonify({'success': False, 'error': error_message}), 500 # Erreur serveur # --- Gestion des Erreurs Génériques/Inattendues --- except Exception as e: error_message = f"Une erreur interne inattendue est survenue: {e}" print(f"ERREUR CRITIQUE INATTENDUE: {error_message}", exc_info=True) # Log la traceback complète if session.get('chat_history'): session['chat_history'].pop() session.modified = True print(" Dernier message utilisateur retiré de l'historique après erreur inattendue.") return jsonify({'success': False, 'error': error_message}), 500 # --- Nettoyage (Exécuté dans tous les cas : succès ou erreur) --- finally: 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}") @app.route('/clear', methods=['POST']) def clear_chat(): """Efface l'historique de chat dans la session.""" session.pop('chat_history', None) # Supprime la clé de la session print("API: Historique de chat effacé via /clear.") # Détecte si la requête vient d'AJAX (fetch) pour répondre en JSON is_ajax = request.headers.get('X-Requested-With') == 'XMLHttpRequest' or \ 'application/json' in request.headers.get('Accept', '') if is_ajax: return jsonify({'success': True, 'message': 'Historique effacé.'}) else: # Comportement pour une soumission de formulaire classique (moins probable ici) flash("Conversation effacée.", "info") return redirect(url_for('root')) # Redirige vers la page d'accueil # --- Démarrage de l'application Flask --- if __name__ == '__main__': print("Démarrage du serveur Flask...") # Utiliser un port différent si 5000 est déjà pris (ex: 5001) port = int(os.environ.get('PORT', 5001)) # debug=True : Rechargement auto, messages d'erreur détaillés (NE PAS UTILISER EN PRODUCTION) # host='0.0.0.0' : Rend l'app accessible sur le réseau local app.run(debug=True, host='0.0.0.0', port=port)