Update app.py

app.py

@@ -1,223 +1,365 @@
-from flask import Flask, render_template, request, redirect, url_for, flash, jsonify, send_from_directory
-from flask_sqlalchemy import SQLAlchemy
+from flask import Flask, Response, request, stream_with_context
+from google import genai
+from google.genai import types
 import os
-import requests
-from urllib.parse import urlparse
-import logging
+from PIL import Image
+import io
+import base64
+import json
+import requests # Pour les requêtes HTTP vers l'API Telegram
 
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+# --- Configuration ---
+GOOGLE_API_KEY = os.environ.get("GEMINI_API_KEY")
+TELEGRAM_BOT_TOKEN = os.environ.get("TELEGRAM_BOT_TOKEN") # Récupérer depuis les variables d'env
+TELEGRAM_CHAT_ID = os.environ.get("TELEGRAM_CHAT_ID")     # Récupérer depuis les variables d'env
 
-app = Flask(__name__)
-app.secret_key = os.environ.get('FLASK_SECRET_KEY', 'une_cle_secrete_par_defaut_pour_dev')
+if not GOOGLE_API_KEY:
+    raise ValueError("La variable d'environnement GEMINI_API_KEY n'est pas définie.")
+# Optionnel: vérifier aussi TELEGRAM_BOT_TOKEN et TELEGRAM_CHAT_ID si vous voulez forcer leur utilisation
+# if not TELEGRAM_BOT_TOKEN or not TELEGRAM_CHAT_ID:
+#     print("Attention: Les variables d'environnement Telegram ne sont pas toutes définies. L'envoi à Telegram pourrait échouer.")
 
-# Configuration de la base de données PostgreSQL
-app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://Podcast_owner:npg_gFdMDLO9lVa0@ep-delicate-surf-a4v7wopn-pooler.us-east-1.aws.neon.tech/Podcast?sslmode=require'
-app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
 
-db = SQLAlchemy(app)
+app = Flask(__name__)
 
-# Configuration du répertoire de cache audio
-AUDIO_CACHE_DIR = '/tmp/audio_cache'
 try:
-    os.makedirs(AUDIO_CACHE_DIR, exist_ok=True)
-    logger.info(f"Répertoire de cache audio configuré sur : {AUDIO_CACHE_DIR}")
-except OSError as e:
-    logger.error(f"Impossible de créer le répertoire de cache audio à {AUDIO_CACHE_DIR}: {e}")
-
-# Modèle de base de données pour les Podcasts
-class Podcast(db.Model):
-    __tablename__ = 'podcast'
-    id = db.Column(db.Integer, primary_key=True)
-    name = db.Column(db.String(200), nullable=False)
-    url = db.Column(db.String(500), nullable=False, unique=True)
-    subject = db.Column(db.String(100), nullable=False)
-    filename_cache = db.Column(db.String(255), nullable=True) # Nom du fichier dans le cache
-
-    def __repr__(self):
-        return f'<Podcast {self.name}>'
-
-# Création des tables de la base de données si elles n'existent pas
-# Ceci est déplacé ici pour s'assurer qu'il s'exécute au démarrage de l'application,
-# que ce soit via `flask run` ou un serveur WSGI.
-with app.app_context():
+    client = genai.GenerativeModel(
+        model_name="gemini-1.5-flash-latest", # Ou "gemini-1.5-pro-latest" ou celui que vous voulez utiliser par défaut
+        api_key=GOOGLE_API_KEY,
+        generation_config=types.GenerationConfig(
+            # candidate_count=1, # Inutile pour le streaming simple
+            # stop_sequences=['$'], # Si besoin
+            # max_output_tokens=2048, # Si besoin
+            temperature=0.7, # Ajustez selon le besoin
+        ),
+        # safety_settings = Adjust safety settings
+        # See https://ai.google.dev/gemini-api/docs/safety-settings
+    )
+except Exception as e:
+    print(f"Erreur lors de l'initialisation du client GenAI : {e}")
+    client = None # Pour éviter des erreurs si l'initialisation échoue
+
+# --- Fonctions Utilitaires ---
+def send_to_telegram(image_data, caption="Nouvelle image pour résolution"):
+    if not TELEGRAM_BOT_TOKEN or not TELEGRAM_CHAT_ID:
+        print("Envoi à Telegram désactivé (variables d'environnement manquantes).")
+        return False
     try:
-        db.create_all()
-        logger.info("Tables de base de données vérifiées/créées (si elles n'existaient pas).")
+        url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendPhoto"
+        files = {'photo': ('image.png', image_data, 'image/png')}
+        data = {'chat_id': TELEGRAM_CHAT_ID, 'caption': caption}
+        response = requests.post(url, files=files, data=data, timeout=10)
+        if response.status_code == 200:
+            print("Image envoyée avec succès à Telegram.")
+            return True
+        else:
+            print(f"Erreur lors de l'envoi à Telegram ({response.status_code}): {response.text}")
+            return False
     except Exception as e:
-        logger.error(f"Erreur lors de la création des tables de la base de données: {e}")
-        # Il est crucial de gérer cette erreur. Si la base de données n'est pas accessible ou
-        # si les tables ne peuvent pas être créées, l'application ne fonctionnera pas correctement.
+        print(f"Exception lors de l'envoi à Telegram: {e}")
+        return False
+
+# --- Code HTML/CSS/JS pour le Frontend ---
+HTML_PAGE = """
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Gemini Image Solver</title>
+    <style>
+        body { font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; margin: 0; padding: 20px; background-color: #f0f2f5; color: #333; display: flex; flex-direction: column; align-items: center; }
+        .container { background-color: #fff; padding: 25px; border-radius: 8px; box-shadow: 0 4px 12px rgba(0,0,0,0.1); width: 100%; max-width: 700px; }
+        h1 { color: #1a73e8; text-align: center; margin-bottom: 25px; }
+        input[type="file"] { display: block; margin-bottom: 15px; padding: 10px; border: 1px solid #ddd; border-radius: 4px; width: calc(100% - 22px); }
+        button { background-color: #1a73e8; color: white; padding: 12px 20px; border: none; border-radius: 4px; cursor: pointer; font-size: 16px; transition: background-color 0.3s; }
+        button:hover { background-color: #1558b0; }
+        button:disabled { background-color: #ccc; cursor: not-allowed; }
+        #response-container { margin-top: 25px; }
+        #status { margin-bottom: 10px; font-style: italic; color: #555; }
+        #response-area { background-color: #e8f0fe; border: 1px solid #d1e0fc; border-radius: 4px; padding: 15px; min-height: 100px; white-space: pre-wrap; word-wrap: break-word; }
+        .copy-button { background-color: #34a853; margin-top: 10px; }
+        .copy-button:hover { background-color: #2a8442; }
+        .thinking-dot { display: inline-block; width: 8px; height: 8px; background-color: #1a73e8; border-radius: 50%; margin: 0 2px; animation: blink 1.4s infinite both; }
+        .thinking-dot:nth-child(2) { animation-delay: .2s; }
+        .thinking-dot:nth-child(3) { animation-delay: .4s; }
+        @keyframes blink { 0%, 80%, 100% { opacity: 0; } 40% { opacity: 1; } }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>Résoudre une image avec Gemini</h1>
+        <input type="file" id="imageUpload" accept="image/*">
+        <button id="solveButton">Envoyer et Résoudre</button>
+        
+        <div id="response-container">
+            <div id="status">Prêt à recevoir une image.</div>
+            <h2>Réponse de Gemini:</h2>
+            <div id="response-area"></div>
+            <button id="copyButton" class="copy-button" style="display:none;">Copier la Réponse</button>
+        </div>
+    </div>
+
+    <script>
+        const imageUpload = document.getElementById('imageUpload');
+        const solveButton = document.getElementById('solveButton');
+        const responseArea = document.getElementById('response-area');
+        const statusDiv = document.getElementById('status');
+        const copyButton = document.getElementById('copyButton');
+        let fullResponse = '';
+
+        solveButton.addEventListener('click', async () => {
+            const file = imageUpload.files[0];
+            if (!file) {
+                statusDiv.textContent = 'Veuillez sélectionner une image.';
+                return;
+            }
+
+            solveButton.disabled = true;
+            responseArea.textContent = '';
+            fullResponse = '';
+            copyButton.style.display = 'none';
+            statusDiv.innerHTML = 'Envoi et traitement en cours <span class="thinking-dot"></span><span class="thinking-dot"></span><span class="thinking-dot"></span>';
+
+            const formData = new FormData();
+            formData.append('image', file);
 
+            try {
+                const response = await fetch('/solve', {
+                    method: 'POST',
+                    body: formData
+                });
+
+                if (!response.ok) {
+                    const errorData = await response.json();
+                    throw new Error(errorData.error || `Erreur serveur: ${response.status}`);
+                }
+
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = '';
+
+                statusDiv.textContent = 'Réception de la réponse...';
+
+                while (true) {
+                    const { value, done } = await reader.read();
+                    if (done) break;
+                    
+                    buffer += decoder.decode(value, { stream: true });
+                    
+                    // Process Server-Sent Events
+                    let eventEndIndex;
+                    while ((eventEndIndex = buffer.indexOf('\\n\\n')) !== -1) {
+                        const eventString = buffer.substring(0, eventEndIndex);
+                        buffer = buffer.substring(eventEndIndex + 2); // Length of '\n\n'
+
+                        if (eventString.startsWith('data: ')) {
+                            try {
+                                const jsonData = JSON.parse(eventString.substring(6)); // Length of 'data: '
+                                if (jsonData.error) {
+                                    responseArea.textContent += `ERREUR: ${jsonData.error}\\n`;
+                                    statusDiv.textContent = 'Erreur lors de la génération.';
+                                    console.error("SSE Error:", jsonData.error);
+                                    break; 
+                                }
+                                if (jsonData.mode === 'thinking') {
+                                    statusDiv.innerHTML = 'Gemini réfléchit <span class="thinking-dot"></span><span class="thinking-dot"></span><span class="thinking-dot"></span>';
+                                } else if (jsonData.mode === 'answering') {
+                                    statusDiv.textContent = 'Gemini répond...';
+                                }
+                                if (jsonData.content) {
+                                    responseArea.textContent += jsonData.content;
+                                    fullResponse += jsonData.content;
+                                }
+                            } catch (e) {
+                                console.error("Error parsing SSE JSON:", e, "Data:", eventString);
+                            }
+                        }
+                    }
+                }
+                // Process any remaining buffer content if needed (though for SSE, it should end with \n\n)
+                statusDiv.textContent = 'Terminé.';
+                if(fullResponse) {
+                    copyButton.style.display = 'block';
+                }
+
+            } catch (error) {
+                console.error('Erreur:', error);
+                responseArea.textContent = `Erreur: ${error.message}`;
+                statusDiv.textContent = 'Une erreur est survenue.';
+            } finally {
+                solveButton.disabled = false;
+            }
+        });
+
+        copyButton.addEventListener('click', () => {
+            if (navigator.clipboard && fullResponse) {
+                navigator.clipboard.writeText(fullResponse)
+                    .then(() => {
+                        const originalText = copyButton.textContent;
+                        copyButton.textContent = 'Copié !';
+                        setTimeout(() => { copyButton.textContent = originalText; }, 2000);
+                    })
+                    .catch(err => {
+                        console.error('Erreur de copie: ', err);
+                        statusDiv.textContent = 'Erreur lors de la copie.';
+                    });
+            } else {
+                 // Fallback for older browsers or if clipboard API not available
+                try {
+                    const textArea = document.createElement("textarea");
+                    textArea.value = fullResponse;
+                    document.body.appendChild(textArea);
+                    textArea.focus();
+                    textArea.select();
+                    document.execCommand('copy');
+                    document.body.removeChild(textArea);
+                    const originalText = copyButton.textContent;
+                    copyButton.textContent = 'Copié !';
+                    setTimeout(() => { copyButton.textContent = originalText; }, 2000);
+                } catch (err) {
+                    console.error('Fallback copy error:', err);
+                    statusDiv.textContent = "La copie a échoué. Veuillez copier manuellement.";
+                }
+            }
+        });
+    </script>
+</body>
+</html>
+"""
+
+# --- Routes Flask ---
 @app.route('/')
 def index():
-    try:
-        podcasts = Podcast.query.order_by(Podcast.name).all()
-    except Exception as e:
-        logger.error(f"Erreur lors de la récupération des podcasts: {e}")
-        flash("Erreur lors du chargement des podcasts depuis la base de données.", "error")
-        podcasts = [] # Fournir une liste vide en cas d'erreur pour que le template fonctionne
-    return render_template('index.html', podcasts=podcasts)
-
-@app.route('/gestion', methods=['GET', 'POST'])
-def gestion():
-    if request.method == 'POST':
-        name = request.form.get('name')
-        url = request.form.get('url')
-        subject = request.form.get('subject')
-
-        if not name or not url or not subject:
-            flash('Tous les champs sont requis !', 'error')
-        else:
-            # Vérifier si un podcast avec la même URL existe déjà
-            existing_podcast = Podcast.query.filter_by(url=url).first()
-            if existing_podcast:
-                flash('Un podcast avec cette URL existe déjà.', 'warning')
-            else:
-                try:
-                    new_podcast = Podcast(name=name, url=url, subject=subject)
-                    db.session.add(new_podcast)
-                    db.session.commit()
-                    flash('Podcast ajouté avec succès !', 'success')
-                    return redirect(url_for('gestion')) # Rediriger pour éviter la resoumission du formulaire
-                except Exception as e:
-                    db.session.rollback() # Annuler les changements en cas d'erreur
-                    logger.error(f"Erreur lors de l'ajout du podcast: {e}")
-                    flash(f"Erreur lors de l'ajout du podcast: {e}", 'error')
-    
-    # Charger les podcasts pour l'affichage sur la page de gestion (méthode GET ou après POST)
-    try:
-        podcasts = Podcast.query.order_by(Podcast.name).all()
-    except Exception as e:
-        logger.error(f"Erreur lors de la récupération des podcasts pour la gestion: {e}")
-        flash("Erreur lors du chargement des podcasts pour la gestion.", "error")
-        podcasts = []
+    return HTML_PAGE
+
+@app.route('/solve', methods=['POST'])
+def solve_image_route():
+    if client is None:
+        return Response(
+            stream_with_context(iter([f'data: {json.dumps({"error": "Le client Gemini n\'est pas initialisé."})}\n\n'])),
+            mimetype='text/event-stream'
+        )
         
-    return render_template('gestion.html', podcasts=podcasts)
+    if 'image' not in request.files:
+        return Response(
+            stream_with_context(iter([f'data: {json.dumps({"error": "Aucun fichier image fourni."})}\n\n'])),
+            mimetype='text/event-stream'
+        )
 
-@app.route('/delete_podcast/<int:podcast_id>', methods=['POST'])
-def delete_podcast(podcast_id):
-    try:
-        podcast_to_delete = db.session.get(Podcast, podcast_id) # Utilisation de db.session.get pour Flask-SQLAlchemy >= 3.0
-        if not podcast_to_delete:
-            flash('Podcast non trouvé.', 'error')
-            return redirect(url_for('gestion'))
-
-        # Supprimer le fichier cache associé s'il existe
-        if podcast_to_delete.filename_cache:
-            cached_file_path = os.path.join(AUDIO_CACHE_DIR, podcast_to_delete.filename_cache)
-            if os.path.exists(cached_file_path):
-                try:
-                    os.remove(cached_file_path)
-                    logger.info(f"Fichier cache {podcast_to_delete.filename_cache} supprimé.")
-                except OSError as e:
-                    logger.error(f"Erreur lors de la suppression du fichier cache {podcast_to_delete.filename_cache}: {e}")
-                    flash(f'Erreur lors de la suppression du fichier cache {podcast_to_delete.filename_cache}.', 'error')
-            else:
-                logger.warning(f"Fichier cache {podcast_to_delete.filename_cache} listé dans la DB mais non trouvé sur le disque pour suppression.")
-
-
-        db.session.delete(podcast_to_delete)
-        db.session.commit()
-        flash('Podcast supprimé avec succès.', 'success')
-    except Exception as e:
-        db.session.rollback()
-        logger.error(f"Erreur lors de la suppression du podcast ID {podcast_id}: {e}")
-        flash(f"Erreur lors de la suppression du podcast: {e}", 'error')
-    return redirect(url_for('gestion'))
-
-@app.route('/play/<int:podcast_id>')
-def play_podcast_route(podcast_id):
-    podcast = db.session.get(Podcast, podcast_id) # Utilisation de db.session.get
-
-    if not podcast:
-        logger.warning(f"Tentative de lecture d'un podcast non trouvé: ID {podcast_id}")
-        return jsonify({'error': 'Podcast non trouvé'}), 404
-
-    # Vérifier si le fichier est déjà en cache
-    if podcast.filename_cache:
-        cached_filepath = os.path.join(AUDIO_CACHE_DIR, podcast.filename_cache)
-        if os.path.exists(cached_filepath):
-            logger.info(f"Service du podcast {podcast.id} depuis le cache: {podcast.filename_cache}")
-            audio_url = url_for('serve_cached_audio', filename=podcast.filename_cache)
-            return jsonify({'audio_url': audio_url})
-        else:
-            # Le fichier cache est référencé mais n'existe pas, il faut le re-télécharger
-            logger.warning(f"Fichier cache {podcast.filename_cache} pour podcast {podcast.id} non trouvé sur le disque. Re-téléchargement.")
-            podcast.filename_cache = None # Marquer comme non-caché pour forcer le re-téléchargement
-            # Pas besoin de db.session.commit() ici immédiatement, sera fait après le téléchargement réussi
+    file = request.files['image']
+    if file.filename == '':
+        return Response(
+            stream_with_context(iter([f'data: {json.dumps({"error": "Aucun fichier sélectionné."})}\n\n'])),
+            mimetype='text/event-stream'
+        )
 
-    # Si le fichier n'est pas en cache ou si le cache était invalide
-    final_cached_filepath = None # Initialiser pour la clause finally
     try:
-        # Déterminer l'extension à partir de l'URL ou du Content-Type
-        parsed_url = urlparse(podcast.url)
-        _, url_ext = os.path.splitext(parsed_url.path)
-        extension = url_ext if url_ext else '.audio' # Extension par défaut
-        
-        # Utiliser l'ID du podcast pour un nom de fichier unique et simple
-        base_filename = str(podcast.id)
+        image_data = file.read()
+        # Pour réutiliser image_data, il faut le "rembobiner" si on le lit plusieurs fois
+        # ou le stocker après la première lecture.
         
-        logger.info(f"Téléchargement de {podcast.url} pour le podcast ID {podcast.id}")
-        # Timeout: (connect_timeout, read_timeout)
-        response = requests.get(podcast.url, stream=True, timeout=(10, 60)) 
-        response.raise_for_status() # Lèvera une exception pour les codes d'erreur HTTP (4xx ou 5xx)
-
-        # Essayer d'obtenir une meilleure extension à partir de l'en-tête Content-Type
-        content_type = response.headers.get('Content-Type')
-        if content_type:
-            if 'mpeg' in content_type: extension = '.mp3'
-            elif 'ogg' in content_type: extension = '.ogg'
-            elif 'wav' in content_type: extension = '.wav'
-            elif 'aac' in content_type: extension = '.aac'
-            elif 'mp4' in content_type: extension = '.m4a' # Souvent utilisé pour l'audio dans un conteneur mp4
-
-        # Construire le nom de fichier final avec l'extension déterminée
-        cached_filename_with_ext = f"{base_filename}{extension}"
-        final_cached_filepath = os.path.join(AUDIO_CACHE_DIR, cached_filename_with_ext)
-
-        # Écrire le contenu dans le fichier cache
-        with open(final_cached_filepath, 'wb') as f:
-            for chunk in response.iter_content(chunk_size=8192): # Taille de chunk raisonnable
-                f.write(chunk)
-        logger.info(f"Téléchargement terminé: {final_cached_filepath}")
-
-        # Mettre à jour la base de données avec le nom du fichier en cache
-        podcast.filename_cache = cached_filename_with_ext
-        db.session.commit()
+        # Envoyer l'image à Telegram (optionnel)
+        # Note: send_to_telegram attend des bytes, image_data est déjà en bytes.
+        send_to_telegram(image_data, "Image reçue pour résolution Gemini")
+
+        # Préparer l'image pour Gemini
+        img = Image.open(io.BytesIO(image_data))
+        # Assurez-vous que le format est supporté par Gemini (PNG, JPEG, WEBP, HEIC, HEIF)
+        if img.format not in ['PNG', 'JPEG', 'WEBP', 'HEIC', 'HEIF']:
+            print(f"Format d'image original {img.format} non optimal, conversion en PNG.")
+            output_format = "PNG"
+        else:
+            output_format = img.format
         
-        audio_url = url_for('serve_cached_audio', filename=cached_filename_with_ext)
-        return jsonify({'audio_url': audio_url})
-
-    except requests.exceptions.Timeout:
-        logger.error(f"Timeout lors du téléchargement de {podcast.url}")
-        # Nettoyer le fichier partiel si le téléchargement a échoué
-        if final_cached_filepath and os.path.exists(final_cached_filepath):
-            try: os.remove(final_cached_filepath); logger.info(f"Fichier partiel (Timeout) nettoyé : {final_cached_filepath}")
-            except OSError as e_clean: logger.error(f"Erreur nettoyage fichier partiel (Timeout) {final_cached_filepath}: {e_clean}")
-        return jsonify({'error': 'Le téléchargement du podcast a pris trop de temps.'}), 504
-    except requests.exceptions.RequestException as e:
-        logger.error(f"Erreur de téléchargement pour {podcast.url}: {e}")
-        if final_cached_filepath and os.path.exists(final_cached_filepath):
-            try: os.remove(final_cached_filepath); logger.info(f"Fichier partiel (RequestException) nettoyé : {final_cached_filepath}")
-            except OSError as e_clean: logger.error(f"Erreur nettoyage fichier partiel (RequestException) {final_cached_filepath}: {e_clean}")
-        return jsonify({'error': f'Impossible de télécharger le podcast: {e}'}), 500
+        buffered = io.BytesIO()
+        img.save(buffered, format=output_format)
+        img_bytes_for_gemini = buffered.getvalue()
+
+        # Le prompt pour Gemini
+        prompt_parts = [
+            types.Part.from_data(data=img_bytes_for_gemini, mime_type=f'image/{output_format.lower()}'),
+            types.Part.from_text("Résous ceci. Explique clairement ta démarche en français. Si c'est une équation ou un calcul, utilise le format LaTeX pour les formules mathématiques.")
+        ]
+
+        def generate_stream():
+            current_mode = 'starting'
+            try:
+                # Utilisation de generate_content avec stream=True
+                # Le modèle choisi est "gemini-1.5-flash-latest" dans l'init du client
+                # Vous pouvez le changer ici si besoin pour cette route spécifique
+                # ou utiliser un client différent pour un modèle différent.
+                response_stream = client.generate_content(
+                    contents=prompt_parts,
+                    stream=True,
+                    # generation_config peut être surchargé ici si besoin
+                    # request_options={"timeout": 600} # Optionnel: timeout pour la requête
+                )
+
+                for chunk in response_stream:
+                    # La structure de 'chunk' pour 1.5 peut différer un peu de l'API client précédente
+                    # Il n'y a plus de 'thought' directement visible comme avant dans les chunks.
+                    # La gestion "thinking" / "answering" devient moins directe.
+                    # On va simplifier : on envoie le contenu dès qu'il arrive.
+                    if current_mode != "answering":
+                        yield f'data: {json.dumps({"mode": "answering"})}\n\n'
+                        current_mode = "answering"
+                    
+                    if chunk.parts:
+                        for part in chunk.parts:
+                            if hasattr(part, 'text') and part.text:
+                                yield f'data: {json.dumps({"content": part.text})}\n\n'
+                    elif hasattr(chunk, 'text') and chunk.text: # Pour certains retours directs
+                         yield f'data: {json.dumps({"content": chunk.text})}\n\n'
+
+
+            except types.generation_types.BlockedPromptException as bpe:
+                print(f"Blocked Prompt Exception: {bpe}")
+                yield f'data: {json.dumps({"error": f"La requête a été bloquée en raison des filtres de sécurité: {bpe}"})}\n\n'
+            except types.generation_types.StopCandidateException as sce:
+                print(f"Stop Candidate Exception: {sce}")
+                yield f'data: {json.dumps({"error": f"La génération s'est arrêtée prématurément: {sce}"})}\n\n'
+            except Exception as e:
+                print(f"Erreur pendant la génération Gemini: {e}")
+                yield f'data: {json.dumps({"error": f"Une erreur est survenue avec Gemini: {str(e)}"})}\n\n'
+            finally:
+                yield f'data: {json.dumps({"mode": "finished"})}\n\n'
+
+
+        return Response(
+            stream_with_context(generate_stream()),
+            mimetype='text/event-stream',
+            headers={
+                'Cache-Control': 'no-cache',
+                'X-Accel-Buffering': 'no', # Important pour Nginx si utilisé comme reverse proxy
+                'Connection': 'keep-alive'
+            }
+        )
+
     except Exception as e:
-        db.session.rollback() # Assurer la cohérence de la session DB
-        logger.error(f"Erreur inattendue lors du traitement du podcast {podcast.id}: {e}")
-        if final_cached_filepath and os.path.exists(final_cached_filepath):
-             try: os.remove(final_cached_filepath); logger.info(f"Fichier partiel (Exception) nettoyé : {final_cached_filepath}")
-             except OSError as e_clean: logger.error(f"Erreur nettoyage fichier partiel (Exception) {final_cached_filepath}: {e_clean}")
-        return jsonify({'error': f'Erreur inattendue: {e}'}), 500
-
-@app.route('/audio_cache/<path:filename>')
-def serve_cached_audio(filename):
-    logger.debug(f"Service du fichier cache: {filename} depuis {AUDIO_CACHE_DIR}")
-    # Assurez-vous que le chemin est sécurisé et ne permet pas de sortir du répertoire de cache
-    # send_from_directory s'en charge généralement.
-    return send_from_directory(AUDIO_CACHE_DIR, filename)
+        print(f"Erreur générale dans /solve: {e}")
+        # Renvoyer l'erreur en SSE pour que le client puisse l'afficher
+        return Response(
+            stream_with_context(iter([f'data: {json.dumps({"error": f"Une erreur inattendue est survenue sur le serveur: {str(e)}"})}\n\n'])),
+            mimetype='text/event-stream'
+        )
+
 
 if __name__ == '__main__':
-    # db.create_all() est maintenant appelé au niveau global du module.
-    # La ligne `app.run(...):19:12 =====` dans le log original contenait une syntaxe incorrecte, corrigée ici.
-    app.run(debug=True, host='0.0.0.0', port=int(os.environ.get('PORT', 5000)))
+    # Assurez-vous que les variables d'environnement sont chargées
+    # par exemple, si vous utilisez un fichier .env avec python-dotenv:
+    # from dotenv import load_dotenv
+    # load_dotenv()
+    # GOOGLE_API_KEY = os.environ.get("GEMINI_API_KEY")
+    # TELEGRAM_BOT_TOKEN = os.environ.get("TELEGRAM_BOT_TOKEN")
+    # TELEGRAM_CHAT_ID = os.environ.get("TELEGRAM_CHAT_ID")
+    # (et réinitialisez le client si les clés sont chargées après l'init initiale)
+
+    # Vérification finale avant de lancer
+    if not GOOGLE_API_KEY:
+        print("ERREUR CRITIQUE: GEMINI_API_KEY n'est pas défini. L'application ne peut pas démarrer correctement.")
+    elif client is None:
+        print("ERREUR CRITIQUE: Le client Gemini n'a pas pu être initialisé. Vérifiez votre clé API et la connectivité.")
+    else:
+        print("Prêt à démarrer Flask.")
+        app.run(debug=True, host='0.0.0.0', port=5000)