Update app.py

app.py

@@ -1,9 +1,9 @@
 from flask import Flask, render_template, request, jsonify
 import os
 import tempfile
-from PIL import Image
+from PIL import Image # Make sure Pillow is installed: pip install Pillow
 from google import genai
-from google.genai import types
+from google.genai import types # Important pour thinking_config
 import uuid
 
 app = Flask(__name__)
@@ -13,15 +13,18 @@ app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 16 MB max upload
 # Ensure upload directory exists
 os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
 
-# Google Gemini API setup
+# Google Gemini API setup (ancienne méthode)
 def init_gemini():
     api_key = os.environ.get('GOOGLE_API_KEY')
     if not api_key:
         print("WARNING: GOOGLE_API_KEY environment variable not set")
         return None
-    return genai.Client(api_key=api_key)
+    # Note: genai.configure(api_key=api_key) n'est pas nécessaire si on utilise genai.Client()
+    # Cependant, cela ne fait pas de mal de le laisser si d'autres parties du code s'y attendent.
+    # genai.configure(api_key=api_key)
+    return genai.Client(api_key=api_key) # Retourne une instance du client
 
-client = init_gemini()
+client = init_gemini() # Store the client instance
 
 # Prompts for analysis
 ICONOGRAPHIC_PROMPT = """
@@ -157,48 +160,53 @@ Et voici le plan :
 
 *   **Opinion personnelle** (Donner son avis personnel)
 *   **Ressentis / Sentiments** (J'ai eu des sentiments mitigés à propos de......... / Ce que j'ai ressenti...)
-
-
-
 """
 
-def generate_response(file_path, file_type):
-    """Generate response using Gemini API based on file type"""
+# Nom du modèle utilisé précédemment
+MODEL_NAME = "gemini-2.5-flash-preview-04-17" # Ou le modèle que vous utilisiez
+
+def generate_response(file_path, file_type_option):
+    """Generate response using Gemini API based on file type option (ancienne méthode d'appel)"""
     try:
-        if not client:
-            return "Error: Google API key not configured properly."
+        if not client: # Vérifie si le client a été initialisé
+            return "Erreur: Le client Google API n'a pas été configuré correctement."
         
-        if file_type == 'image':
-            image_data = Image.open(file_path)
-            response = client.models.generate_content(
-                model="gemini-2.5-flash-preview-04-17",
-                contents=[image_data, ICONOGRAPHIC_PROMPT],
-                config=types.GenerateContentConfig(
-                    thinking_config=types.ThinkingConfig(
-                        thinking_budget=8000
-                    )
-                ),
-            )
-            return response.candidates[0].content.parts[0].text.strip()
+        image_data = Image.open(file_path) # Les deux options utilisent une image comme entrée
+
+        prompt_to_use = ""
+        if file_type_option == 'image': # Méthodologie iconographique
+            prompt_to_use = ICONOGRAPHIC_PROMPT
+        elif file_type_option == 'text_method_image_input': # Méthodologie textuelle (avec image en entrée)
+            prompt_to_use = TEXT_PROMPT
+        else:
+            return "Erreur: Type d'analyse non reconnu."
+
+        response = client.models.generate_content( # Utilisation de client.models.generate_content
+            model=MODEL_NAME, # Spécifier le modèle ici
+            contents=[image_data, prompt_to_use],
+            config=types.GenerateContentConfig(
+                thinking_config=types.ThinkingConfig(
+                    thinking_budget=8000 # Conserve la configuration thinking_budget
+                )
+            ),
+        )
         
-        elif file_type == 'text':
-            with open(file_path, 'r', encoding='utf-8') as f:
-                text_content = f.read()
-            
-            response = client.models.generate_content(
-                model="gemini-2.5-flash-preview-04-17",
-                contents=[text_content, TEXT_PROMPT],
-                config=types.GenerateContentConfig(
-                    thinking_config=types.ThinkingConfig(
-                        thinking_budget=8000
-                    )
-                ),
-            )
+        # Accéder au texte de la réponse comme dans la version originale
+        if response.candidates and response.candidates[0].content and response.candidates[0].content.parts:
             return response.candidates[0].content.parts[0].text.strip()
+        else:
+            # Gérer le cas où la réponse n'a pas la structure attendue
+            print(f"Réponse inattendue de l'API Gemini: {response}")
+            return "Erreur: La réponse de l'API Gemini n'a pas pu être traitée."
         
     except Exception as e:
-        print(f"Error generating response: ")
-        return f"Error durante el análisis: "
+        print(f"Error generating response: {e}")
+        # Vous pouvez ajouter une gestion d'erreur plus spécifique ici si nécessaire
+        if "API_KEY_INVALID" in str(e):
+             return "Erreur: Clé API Google invalide ou non autorisée."
+        if "billing account" in str(e).lower():
+            return "Erreur: Problème de facturation avec le compte Google Cloud. Veuillez vérifier votre compte."
+        return f"Erreur lors de l'analyse: {str(e)}"
 
 @app.route('/')
 def index():
@@ -207,28 +215,64 @@ def index():
 @app.route('/upload', methods=['POST'])
 def upload_file():
     if 'file' not in request.files:
-        return jsonify({'error': 'No file part'}), 400
+        return jsonify({'success': False, 'error': 'Aucun fichier reçu'}), 400
     
     file = request.files['file']
-    file_type = request.form.get('fileType', 'image')
+    # 'fileType' indique maintenant la méthodologie ('image' ou 'text_method_image_input')
+    file_type_option = request.form.get('fileType', 'image') 
     
     if file.filename == '':
-        return jsonify({'error': 'No selected file'}), 400
+        return jsonify({'success': False, 'error': 'Aucun fichier sélectionné'}), 400
     
     if file:
-        # Generate a unique filename
-        filename = f"{uuid.uuid4()}_{file.filename}"
+        # Générer un nom de fichier unique
+        filename = f"{uuid.uuid4()}_{os.path.splitext(file.filename)[0]}{os.path.splitext(file.filename)[1]}"
         file_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
-        file.save(file_path)
-        
-        # Generate analysis
-        analysis = generate_response(file_path, file_type)
         
-        return jsonify({
-            'success': True,
-            'file_url': f"/static/uploads/{filename}",
-            'analysis': analysis
-        })
+        try:
+            file.save(file_path)
+            
+            # S'assurer que le fichier est une image avant de continuer
+            try:
+                img_check = Image.open(file_path)
+                img_check.verify() # Vérifie si c'est une image
+                img_check.close() # Important de fermer le fichier après vérification
+                 # Réouvrir pour l'envoi à l'API car verify() peut corrompre certains formats
+                # Image.open(file_path) sera fait dans generate_response
+            except Exception as img_err:
+                if os.path.exists(file_path):
+                    os.remove(file_path) # Nettoyer le fichier invalide
+                print(f"Invalid image file uploaded: {img_err}")
+                return jsonify({'success': False, 'error': 'Le fichier téléversé n\'est pas une image valide.'}), 400
+
+            analysis = generate_response(file_path, file_type_option)
+            
+            # Vérifier si l'analyse a retourné une erreur
+            if analysis.startswith("Erreur:"):
+                # Ne pas supprimer le fichier immédiatement si l'analyse a échoué,
+                # l'utilisateur pourrait vouloir réessayer ou le voir.
+                return jsonify({'success': False, 'error': analysis}), 500
+
+            return jsonify({
+                'success': True,
+                'file_url': f"/static/uploads/{filename}", # Utile si vous voulez que l'utilisateur voie l'image téléversée
+                'analysis': analysis
+            })
+        except Exception as e:
+            print(f"Error in upload_file: {e}")
+            if os.path.exists(file_path): # Nettoyer si un fichier a été sauvegardé mais une erreur est survenue
+                try:
+                    os.remove(file_path)
+                except Exception as e_rem:
+                    print(f"Could not remove file {file_path}: {e_rem}")
+            return jsonify({'success': False, 'error': f'Une erreur serveur est survenue: {str(e)}'}), 500
+        # finally:
+            # Optionnel : nettoyer le fichier téléversé après traitement.
+            # if os.path.exists(file_path):
+            #     try:
+            #         os.remove(file_path)
+            #     except Exception as e:
+            #         print(f"Error removing uploaded file {file_path}: {e}")
 
 if __name__ == '__main__':
     app.run(debug=True)