Update app.py

app.py

@@ -5,24 +5,19 @@ import os
 from PIL import Image
 import tempfile
 import json
-import logging
-import sqlite3
-from datetime import datetime
-import base64
-import io
-import time
+import logging # Optional: for better logging
 
 app = Flask(__name__)
 
-# Configure logging
+# Configure logging (optional but recommended)
 logging.basicConfig(level=logging.INFO)
 
 # Configuration de l'API Gemini
 token = os.environ.get("TOKEN")
 if not token:
     logging.error("API Token (TOKEN environment variable) not found!")
-    raise ValueError("TOKEN environment variable must be set")
-
+    # Handle the error appropriately - maybe exit or raise an exception
+    # For now, we'll let it potentially fail later if the client is used without a key
 genai_client = genai.Client(api_key=token)
 
 SAFETY_SETTINGS = [
@@ -44,89 +39,6 @@ SAFETY_SETTINGS = [
     )
 ]
 
-# --- Database Setup ---
-def init_db():
-    """Initialize the SQLite database"""
-    conn = sqlite3.connect('analysis_data.db')
-    cursor = conn.cursor()
-    
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS analyses (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
-            image_name TEXT,
-            image_data TEXT,
-            gemini_file_uri TEXT,
-            consignes TEXT,
-            use_deepthink BOOLEAN,
-            model_used TEXT,
-            tableau_output TEXT,
-            dissertation_output TEXT,
-            user_ip TEXT,
-            processing_time REAL
-        )
-    ''')
-    
-    conn.commit()
-    conn.close()
-
-def save_analysis_data(image_name, image_data, gemini_file_uri, consignes, use_deepthink, model_used, tableau_output, dissertation_output, user_ip, processing_time):
-    """Save analysis data to database"""
-    conn = sqlite3.connect('analysis_data.db')
-    cursor = conn.cursor()
-    
-    cursor.execute('''
-        INSERT INTO analyses 
-        (image_name, image_data, gemini_file_uri, consignes, use_deepthink, model_used, tableau_output, dissertation_output, user_ip, processing_time)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    ''', (image_name, image_data, gemini_file_uri, consignes, use_deepthink, model_used, tableau_output, dissertation_output, user_ip, processing_time))
-    
-    conn.commit()
-    conn.close()
-
-def get_all_analyses():
-    """Get all analyses from database"""
-    conn = sqlite3.connect('analysis_data.db')
-    cursor = conn.cursor()
-    
-    cursor.execute('''
-        SELECT id, timestamp, image_name, consignes, use_deepthink, model_used, 
-               tableau_output, dissertation_output, user_ip, processing_time, gemini_file_uri
-        FROM analyses 
-        ORDER BY timestamp DESC
-    ''')
-    
-    analyses = cursor.fetchall()
-    conn.close()
-    
-    return analyses
-
-def get_analysis_image(analysis_id):
-    """Get image data for a specific analysis"""
-    conn = sqlite3.connect('analysis_data.db')
-    cursor = conn.cursor()
-    
-    cursor.execute('SELECT image_data FROM analyses WHERE id = ?', (analysis_id,))
-    result = cursor.fetchone()
-    conn.close()
-    
-    return result[0] if result else None
-
-def cleanup_gemini_file(file_uri):
-    """Clean up uploaded Gemini file"""
-    try:
-        # Extract file name from URI for deletion
-        if file_uri and file_uri.startswith('https://generativelanguage.googleapis.com'):
-            file_name = file_uri.split('/')[-1]
-            genai_client.files.delete(name=file_name)
-            logging.info(f"Cleaned up Gemini file: {file_name}")
-    except Exception as e:
-        logging.warning(f"Could not clean up Gemini file {file_uri}: {e}")
-
-# Initialize database on startup
-init_db()
-
-
 # --- Prompts (Keep them as they are) ---
 prompt_tableau = """
 Traite selon cette méthodologie :
@@ -208,20 +120,20 @@ Voici un exercice a trous présentant la rédaction.. référence textuelle= rep
 
 EXERCICE À TROUS
 
-Le thème de ... (thème du texte) a souvent fait l'objet de nombreuses préoccupations dans le monde littéraire (mais pas que). C'est dans ce cadre que s'inscrit l'extrait ... (titre du texte) qui fait l'objet de notre étude, de l'écrivain... (nom de l'auteur), tiré de son œuvre ... (préciser le genre littéraire de l'œuvre) ... (maison d'édition), en ... (date de publication) à la (aux) page (s) …. Dans ce texte (type du texte) à ton ... (tonalité du texte/facultative), structure, nous verrons en premier lieu,...(axe 1) et en second lieu, ...(axe 2).
+Le thème de ... (thème du texte) a souvent fait l'objet de nombreuses préoccupations dans le monde littéraire (mais pas que). C’est dans ce cadre que s'inscrit l'extrait ... (titre du texte) qui fait l'objet de notre étude, de l'écrivain... (nom de l'auteur), tiré de son œuvre ... (préciser le genre littéraire de l'œuvre) ... (maison d'édition), en ... (date de publication) à la (aux) page (s) …. Dans ce texte (type du texte) à ton ... (tonalité du texte/facultative), structure, nous verrons en premier lieu,...(axe 1) et en second lieu, ...(axe 2).
 
-Dans son extrait (poème), l'auteur met en relief ... (axe 1) à travers ... (sous-axe 1) et ... (sous-axe 2).
+Dans son extrait (poème), l’auteur met en relief ... (axe 1) à travers ... (sous-axe 1) et ... (sous-axe 2).
 
-S'agissant de ... (sous-axe 1), l'écrivain utilise ... (outil d'analyse 1 + référence textuelle) pour montrer ... (interprétation). Aussi (de plus), par l'usage de... (outil d'analyse 2 + référence textuelle), l'écrivain ... (interprétation). Mieux encore, ... (outil d'analyse 3 + référence textuelle) nous donne également la possibilité d'appréhender ... (sous-axe 2).
+S'agissant de ... (sous-axe 1), l’écrivain utilise ... (outil d'analyse 1 + référence textuelle) pour montrer ... (interprétation). Aussi (de plus), par l'usage de... (outil d'analyse 2 + référence textuelle), l'écrivain ... (interprétation). Mieux encore, ... (outil d'analyse 3 + référence textuelle) nous donne également la possibilité d’appréhender ... (sous-axe 2).
 De plus, l'homme de lettres emploie ... (outil d'analyse 1 + référence textuelle) pour ... (interprétation). Il se sert aussi de ...(outil d'analyse 2 + référence textuelle) afin de ... (interprétation). Pour continuer sa (description, représentation), le ...(nationalité de l'auteur) se manque pas de faire recours à ... (outil d'analyse 3 référence textuelle) Ici, il s'agit pour l'auteur autour de ... (sous-axe 1) et ... (sous-axe 2).
 
 Après avoir démontré ... (axe 1), voyons à présent ... (axe 2).
 
-En second lieu, le poète (l'écrivain ou l'homme de lettres) met en exergue ... (axe 2) en s'appuyant d'une part, sur... (sous-axe 1) et d'autre part, sur... (sous-axe 2). En ce qui concerne ... (sous-axe 1), l'homme de lettres met d'abord en évidence l'aspect (le caractère) ... (interprétation) comme en témoigne l'emploi (l'usage de) ... (outil d'analyse 1 + référence textuelle). Ensuite, ... (outil d'analyse 2 + référence textuelle) dévoile que... (interprétation) Enfin, ... (outil d'analyse 3 + référence textuelle) suggère que… (interprétation) . ... (axe 2) se révèle grâce à ….
-En parlant de ... (sous-axe 2), l'auteur met l'accent en premier sur… (interprétation), comme nous pouvons le voir avec la récurrence de (du/des) ... (rappel du sous-axe 2), le poète (l'auteur) souligne ... (interprétation) toujours dans le même sens de ... (rappel du sous-axe 2) . Il use de ... (outil d'analyse 2 + référence textuelle). Dès lors, on peut déduire que ...(interprétation) utilise ... (outil d'analyse 3 + référence textuelle).
+En second lieu, le poète (l’écrivain ou l’homme de lettres) met en exergue ... (axe 2) en s’appuyant d’une part, sur... (sous-axe 1) et d’autre part, sur... (sous-axe 2). En ce qui concerne ... (sous-axe 1), l'homme de lettres met d'abord en évidence l'aspect (le caractère) ... (interprétation) comme en témoigne l'emploi (l'usage de) ... (outil d’analyse 1 + référence textuelle). Ensuite, ... (outil d'analyse 2 + référence textuelle) dévoile que... (interprétation) Enfin, ... (outil d'analyse 3 + référence textuelle) suggère que… (interprétation) . ... (axe 2) se révèle grâce à ….
+En parlant de ... (sous-axe 2), l'auteur met l'accent en premier sur… (interprétation), comme nous pouvons le voir avec la récurrence de (du/des) ... (rappel du sous-axe 2), le poète (l'auteur) souligne ... (interprétation) toujours dans le même sens de ... (rappel du sous-axe 2) . Il use de ... (outil d’analyse 2 + référence textuelle). Dès lors, on peut déduire que ...(interprétation) utilise ... (outil d’analyse 3 + référence textuelle).
 Ainsi, ... (axe 2) est lié (e) à ... (sous-axe 1) et à ... (sous-axe 2).
 
-Somme toute, ... (titre du texte) organise son sens autour de … (axe 1) et de ... (axe 2). De ces deux centres d'intérêt découlent respectivement, d'une part, … (sous-axe 1 de l'axe 1) et ... (sous-axe 2 de l'axe 1) et, d'autre part, … (sous-axe 1 de l'axe 2) et … (sous-axe 2 de l'axe 2). À travers ce texte, ...(nom de l'auteur) nous ... (opinion personnelle). Une telle optique est perceptible dans la logique de... (nom de l'auteur nous permettant de faire un rapprochement thématique), dans son œuvre ...(titre de l'œuvre), dans lequel il aborde… (bref résumé de l'œuvre en question qui peut être facultatif).
+Somme toute, ... (titre du texte) organise son sens autour de … (axe 1) et de ... (axe 2). De ces deux centres d’intérêt découlent respectivement, d’une part, … (sous-axe 1 de l'axe 1) et ... (sous-axe 2 de l'axe 1) et, d’autre part, … (sous-axe 1 de l'axe 2) et … (sous-axe 2 de l'axe 2). À travers ce texte, ...(nom de l'auteur) nous ... (opinion personnelle). Une telle optique est perceptible dans la logique de... (nom de l'auteur nous permettant de faire un rapprochement thématique), dans son œuvre ...(titre de l’œuvre), dans lequel il aborde… (bref résumé de l'œuvre en question qui peut être facultatif).
 """
 # --- End Prompts ---
 
@@ -230,42 +142,22 @@ generate_config = types.GenerateContentConfig(
 )
 
 # --- Model IDs ---
-MODEL_ID_STANDARD = "gemini-2.5-flash"
-MODEL_ID_DEEPTHINK = "gemini-2.5-flash"
+MODEL_ID_STANDARD = "gemini-2.5-flash"  # Default model
+MODEL_ID_DEEPTHINK = "gemini-2.5-flash" # Advanced model for DeepThink
 # --- End Model IDs ---
 
-def upload_image_to_gemini(image_path, display_name=None):
-    """Upload image to Gemini using Files API"""
-    try:
-        logging.info(f"Uploading image to Gemini: {image_path}")
-        uploaded_file = genai_client.files.upload(file=image_path)
-        
-        # Wait for file to be processed
-        while uploaded_file.state == 'PROCESSING':
-            logging.info("File still processing, waiting...")
-            time.sleep(1)
-            uploaded_file = genai_client.files.get(name=uploaded_file.name)
-        
-        if uploaded_file.state == 'FAILED':
-            raise Exception(f"File upload failed: {uploaded_file.error}")
-            
-        logging.info(f"File uploaded successfully: {uploaded_file.uri}")
-        return uploaded_file
-    except Exception as e:
-        logging.error(f"Error uploading file to Gemini: {e}")
-        raise
-
-def generate_table_stream(uploaded_file, consignes="", model_id=MODEL_ID_STANDARD):
-    """Génère le tableau d'analyse à partir de l'image uploadée"""
+# --- Stream Generation Functions ---
+def generate_table_stream(image, consignes="", model_id=MODEL_ID_STANDARD):
+    """Génère le tableau d'analyse à partir de l'image en intégrant éventuellement des consignes"""
     prompt = prompt_tableau
     if consignes:
-        prompt += "\n\nConsignes supplémentaires de l'utilisateur :\n" + consignes
+        prompt += "\n\nConsignes supplémentaires de l'utilisateur :\n" + consignes # Make consignes clearer in prompt
 
     logging.info(f"Generating table using model: {model_id}")
     try:
         response_stream = genai_client.models.generate_content_stream(
-            model=model_id,
-            contents=[prompt, uploaded_file],
+            model=model_id, # Use the passed model_id
+            contents=[prompt, image],
             config=generate_config
         )
 
@@ -276,6 +168,7 @@ def generate_table_stream(uploaded_file, consignes="", model_id=MODEL_ID_STANDAR
         logging.error(f"Error during table generation stream: {e}", exc_info=True)
         yield json.dumps({"type": "error", "error": f"Erreur lors de la génération du tableau: {e}"}) + "\n"
 
+
 def generate_dissertation_stream(tableau, model_id=MODEL_ID_STANDARD):
     """Génère la dissertation basée sur le tableau"""
     prompt = f"""
@@ -285,13 +178,13 @@ def generate_dissertation_stream(tableau, model_id=MODEL_ID_STANDARD):
     {tableau}
     --- Fin du Tableau ---
 
-    Écris maintenant une rédaction structurée pour le commentaire composé basé EXCLUSIVEMENT sur le tableau d'analyse fourni ci-dessus.
+    Écris maintenant une rédaction structurée pour le commentaire composé basé EXCLUSIVEMENT sur le tableau d'analyse fourni ci-dessus, en suivant strictement le modèle de l'exercice à trous présenté dans la première partie de ce prompt. Assure-toi d'utiliser les "Repérage / Citation" du tableau quand le modèle le demande.
     """
 
     logging.info(f"Generating dissertation using model: {model_id}")
     try:
         response_stream = genai_client.models.generate_content_stream(
-            model=model_id,
+            model=model_id, # Use the passed model_id
             contents=prompt,
             config=generate_config
         )
@@ -303,55 +196,19 @@ def generate_dissertation_stream(tableau, model_id=MODEL_ID_STANDARD):
         logging.error(f"Error during dissertation generation stream: {e}", exc_info=True)
         yield json.dumps({"type": "error", "error": f"Erreur lors de la génération de la dissertation: {e}"}) + "\n"
 
+# --- End Stream Generation Functions ---
+
+
 # --- Flask Routes ---
 @app.route('/')
 def index():
+    # Assuming your main HTML file is index.html
     return render_template('index.html')
 
-@app.route('/gestion')
-def gestion():
-    """Page de gestion pour afficher toutes les analyses"""
-    return render_template('gestion.html')
-
-@app.route('/api/analyses')
-def get_analyses():
-    """API endpoint to get all analyses data"""
-    try:
-        analyses = get_all_analyses()
-        analyses_data = []
-        
-        for analysis in analyses:
-            analyses_data.append({
-                'id': analysis[0],
-                'timestamp': analysis[1],
-                'image_name': analysis[2],
-                'consignes': analysis[3],
-                'use_deepthink': analysis[4],
-                'model_used': analysis[5],
-                'tableau_output': analysis[6],
-                'dissertation_output': analysis[7],
-                'user_ip': analysis[8],
-                'processing_time': analysis[9],
-                'gemini_file_uri': analysis[10] if len(analysis) > 10 else None
-            })
-        
-        return jsonify(analyses_data)
-    except Exception as e:
-        logging.error(f"Error fetching analyses: {e}")
-        return jsonify({'error': 'Erreur lors de la récupération des données'}), 500
-
-@app.route('/api/analysis/<int:analysis_id>/image')
-def get_analysis_image_endpoint(analysis_id):
-    """API endpoint to get image for a specific analysis"""
-    try:
-        image_data = get_analysis_image(analysis_id)
-        if image_data:
-            return Response(base64.b64decode(image_data), mimetype='image/jpeg')
-        else:
-            return jsonify({'error': 'Image non trouvée'}), 404
-    except Exception as e:
-        logging.error(f"Error fetching image: {e}")
-        return jsonify({'error': 'Erreur lors de la récupération de l\'image'}), 500
+# Removed /free route as it wasn't mentioned in the final HTML
+# @app.route('/free')
+# def free():
+#     return render_template('free.html')
 
 @app.route('/analyze', methods=['POST'])
 def analyze():
@@ -361,173 +218,127 @@ def analyze():
 
     image_file = request.files['image']
     consignes = request.form.get("consignes", "")
+    # Check for the DeepThink flag
     use_deepthink = request.form.get('use_deepthink', 'false').lower() == 'true'
 
     # Select model based on the flag
-    model_id = MODEL_ID_DEEPTHINK if use_deepthink else MODEL_ID_STANDARD
-    logging.info(f"Using model: {model_id} (DeepThink: {use_deepthink})")
-
-    # Get user IP
-    user_ip = request.remote_addr
-    start_time = datetime.now()
-
-    temp_file_path = None
-    uploaded_file = None
-    
+    if use_deepthink:
+        model_id = MODEL_ID_DEEPTHINK
+        logging.info("DeepThink requested, using advanced model.")
+    else:
+        model_id = MODEL_ID_STANDARD
+        logging.info("Standard analysis requested, using standard model.")
+
+    # Use a temporary file to handle the image upload
+    temp_file = None # Initialize to None
     try:
-        # Create temporary file and validate image
+        # Create a temporary file with a specific suffix if needed, or let NamedTemporaryFile handle it
+        # Using 'delete=False' requires manual cleanup
         with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as temp_file:
-            temp_file_path = temp_file.name
-            image_file.save(temp_file_path)
-            
-            # Validate image
+            image_file.save(temp_file.name)
+            # Ensure image is valid before proceeding
             try:
-                image = Image.open(temp_file_path)
-                image.verify()
-                image = Image.open(temp_file_path)  # Re-open after verify
-                
-                # Convert image to base64 for storage
-                img_buffer = io.BytesIO()
-                
-                # Convert RGBA to RGB if necessary for JPEG compatibility
-                if image.mode in ('RGBA', 'LA', 'P'):
-                    # Create white background
-                    background = Image.new('RGB', image.size, (255, 255, 255))
-                    if image.mode == 'P':
-                        image = image.convert('RGBA')
-                    background.paste(image, mask=image.split()[-1] if image.mode == 'RGBA' else None)
-                    image = background
-                elif image.mode != 'RGB':
-                    image = image.convert('RGB')
-                
-                image.save(img_buffer, format='JPEG', quality=95)
-                image_base64 = base64.b64encode(img_buffer.getvalue()).decode('utf-8')
-                
+                image = Image.open(temp_file.name)
+                image.verify() # Verify image header
+                # Re-open after verify
+                image = Image.open(temp_file.name)
             except (IOError, SyntaxError) as e:
                 logging.error(f"Invalid image file uploaded: {e}")
                 return jsonify({'error': f'Invalid or corrupted image file: {e}'}), 400
 
-        # Upload image to Gemini
-        try:
-            uploaded_file = upload_image_to_gemini(temp_file_path)
-        except Exception as e:
-            logging.error(f"Error uploading to Gemini: {e}")
-            return jsonify({'error': f'Error uploading image to Gemini: {e}'}), 500
-
-        @stream_with_context
-        def generate():
-            full_tableau_content = ""
-            full_dissertation_content = ""
-            
-            try:
-                logging.info("Starting table generation stream...")
-                
-                # Phase 1: Génération du tableau
-                for chunk_json in generate_table_stream(uploaded_file, consignes, model_id):
-                    try:
-                        chunk_data = json.loads(chunk_json)
-                        if chunk_data.get("type") == "error":
-                            logging.error(f"Error received from table stream: {chunk_data.get('error')}")
-                            yield chunk_json
-                            return
-                        elif chunk_data.get("type") == "tableau":
-                            full_tableau_content += chunk_data.get("chunk", "")
-                            yield chunk_json
-                    except json.JSONDecodeError:
-                        logging.error(f"Received invalid JSON from table stream: {chunk_json}")
-                        yield json.dumps({"type": "error", "error": "Invalid data received during table generation."}) + "\n"
-                        return
-
-                logging.info("Table generation stream finished.")
-                logging.info("Starting dissertation generation stream...")
-
-                # Phase 2: Génération de la dissertation
-                if full_tableau_content:
-                    for chunk_json in generate_dissertation_stream(full_tableau_content, model_id):
+            # Now 'image' holds the PIL Image object
+            # We need to pass the image object to the stream function
+            # Note: google.generativeai often works directly with PIL Image objects
+
+            @stream_with_context
+            def generate():
+                temp_file_path = temp_file.name # Store path for finally block
+                full_tableau_content = "" # Accumulate full table content for dissertation
+                try:
+                    logging.info("Starting table generation stream...")
+                    # Phase 1: Génération du tableau, passing the selected model_id
+                    for chunk_json in generate_table_stream(image, consignes, model_id):
                         try:
                             chunk_data = json.loads(chunk_json)
                             if chunk_data.get("type") == "error":
-                                logging.error(f"Error received from dissertation stream: {chunk_data.get('error')}")
-                                yield chunk_json
-                            elif chunk_data.get("type") == "dissertation":
-                                full_dissertation_content += chunk_data.get("chunk", "")
-                                yield chunk_json
+                                logging.error(f"Error received from table stream: {chunk_data.get('error')}")
+                                yield chunk_json # Forward the error to the client
+                                return # Stop generation if table fails
+                            elif chunk_data.get("type") == "tableau":
+                                full_tableau_content += chunk_data.get("chunk", "")
+                                yield chunk_json # Stream chunk to client
                         except json.JSONDecodeError:
-                            logging.error(f"Received invalid JSON from dissertation stream: {chunk_json}")
-                            yield json.dumps({"type": "error", "error": "Invalid data received during dissertation generation."}) + "\n"
-                else:
-                    logging.warning("Tableau content is empty, skipping dissertation generation.")
-                    yield json.dumps({"type": "error", "error": "Tableau d'analyse non généré, impossible de créer la dissertation."}) + "\n"
-
-                logging.info("Dissertation generation stream finished.")
+                             logging.error(f"Received invalid JSON from table stream: {chunk_json}")
+                             # Decide how to handle: yield error, ignore, etc.
+                             yield json.dumps({"type": "error", "error": "Invalid data received during table generation."}) + "\n"
+                             return # Stop if data is corrupt
+
+                    logging.info("Table generation stream finished.")
+                    logging.info("Starting dissertation generation stream...")
+
+                    # Phase 2: Génération de la dissertation basée sur le tableau COMPLET, passing the selected model_id
+                    if full_tableau_content: # Only generate if table content exists
+                        for chunk_json in generate_dissertation_stream(full_tableau_content, model_id):
+                            try:
+                                chunk_data = json.loads(chunk_json)
+                                if chunk_data.get("type") == "error":
+                                     logging.error(f"Error received from dissertation stream: {chunk_data.get('error')}")
+                                     yield chunk_json # Forward the error
+                                     # Decide if you want to return here or let it finish
+                                elif chunk_data.get("type") == "dissertation":
+                                     yield chunk_json # Stream chunk to client
+                            except json.JSONDecodeError:
+                                logging.error(f"Received invalid JSON from dissertation stream: {chunk_json}")
+                                yield json.dumps({"type": "error", "error": "Invalid data received during dissertation generation."}) + "\n"
+                                # Potentially return here too
+                    else:
+                        logging.warning("Tableau content is empty, skipping dissertation generation.")
+                        yield json.dumps({"type": "error", "error": "Tableau d'analyse non généré, impossible de créer la dissertation."}) + "\n"
+
+                    logging.info("Dissertation generation stream finished.")
 
-                # Save analysis data to database
-                try:
-                    end_time = datetime.now()
-                    processing_time = (end_time - start_time).total_seconds()
-                    
-                    save_analysis_data(
-                        image_name=image_file.filename,
-                        image_data=image_base64,
-                        gemini_file_uri=uploaded_file.uri,
-                        consignes=consignes,
-                        use_deepthink=use_deepthink,
-                        model_used=model_id,
-                        tableau_output=full_tableau_content,
-                        dissertation_output=full_dissertation_content,
-                        user_ip=user_ip,
-                        processing_time=processing_time
-                    )
-                    logging.info(f"Analysis data saved successfully for image: {image_file.filename}")
-                except Exception as save_error:
-                    logging.error(f"Error saving analysis data: {save_error}")
-
-            except Exception as e:
-                logging.error(f"Error during streaming generation: {e}", exc_info=True)
-                yield json.dumps({"type": "error", "error": f"Une erreur interne est survenue: {e}"}) + "\n"
-
-        # Create response with cleanup
-        response = Response(generate(), content_type='text/event-stream')
-
-        # Setup cleanup function
-        def cleanup():
-            # Clean up temporary file
-            if temp_file_path and os.path.exists(temp_file_path):
-                try:
-                    os.unlink(temp_file_path)
-                    logging.info(f"Cleaned up temp file: {temp_file_path}")
-                except OSError as e:
-                    logging.error(f"Error cleaning up temp file: {e}")
-            
-            # Clean up Gemini file (optional - files auto-expire)
-            if uploaded_file:
-                try:
-                    genai_client.files.delete(name=uploaded_file.name)
-                    logging.info(f"Cleaned up Gemini file: {uploaded_file.name}")
                 except Exception as e:
-                    logging.warning(f"Could not clean up Gemini file: {e}")
+                    logging.error(f"Error during streaming generation: {e}", exc_info=True)
+                    # Yield a JSON error message for the client
+                    yield json.dumps({"type": "error", "error": f"Une erreur interne est survenue: {e}"}) + "\n"
+                finally:
+                    # Nettoyer le fichier temporaire in the finally block of generate
+                    # Ensure the image object is closed if necessary (PIL handles this reasonably well)
+                    # image.close() # Usually not needed with 'with open' or tempfile context
+                    pass # temp_file is closed by with statement, path needed for unlink
+
+            # Return the streaming response
+            # Make sure temp_file path is accessible for cleanup *after* streaming finishes
+            response = Response(generate(), content_type='text/event-stream')
+
+            # Use response.call_on_close for reliable cleanup after stream finishes/closes
+            if temp_file and os.path.exists(temp_file.name):
+                 cleanup_path = temp_file.name
+                 response.call_on_close(lambda: os.unlink(cleanup_path) if os.path.exists(cleanup_path) else None)
+                 logging.info(f"Scheduled cleanup for temp file: {cleanup_path}")
 
-        response.call_on_close(cleanup)
-        return response
+
+            return response
 
     except Exception as e:
-        # Cleanup on error
-        if temp_file_path and os.path.exists(temp_file_path):
-            try:
-                os.unlink(temp_file_path)
-                logging.info(f"Cleaned up temp file after error: {temp_file_path}")
-            except OSError:
-                pass
-        
-        if uploaded_file:
-            try:
-                genai_client.files.delete(name=uploaded_file.name)
-                logging.info(f"Cleaned up Gemini file after error: {uploaded_file.name}")
-            except Exception:
-                pass
-        
-        logging.error(f"Error processing upload: {e}", exc_info=True)
+        # Catch errors during file handling or initial PIL processing
+        logging.error(f"Error processing upload before streaming: {e}", exc_info=True)
+        # Ensure cleanup if temp_file was created before the error
+        if temp_file and os.path.exists(temp_file.name):
+             try:
+                 os.unlink(temp_file.name)
+                 logging.info(f"Cleaned up temp file due to pre-stream error: {temp_file.name}")
+             except OSError as unlink_error:
+                 logging.error(f"Error unlinking temp file during error handling: {unlink_error}")
         return jsonify({'error': f'Error processing file: {e}'}), 500
+    # Note: The 'finally' block for the 'with tempfile' is implicitly handled
+    # but explicit cleanup using response.call_on_close is better for streaming
+
+
+# --- End Flask Routes ---
+
 
 if __name__ == '__main__':
-    app.run(debug=True)
+    # Set debug=False for production
+    # Use a proper WSGI server like Gunicorn or Waitress in production
+    app.run(debug=True) # debug=True enables auto-reloading and detailed errors