Update app.py

app.py

@@ -1,9 +1,7 @@
-from flask import Flask, render_template, request, jsonify, Response
+from flask import Flask, render_template, request, Response
 from google import genai
 from google.genai import types
 import os
-from PIL import Image
-import io
 import logging
 import json
 
@@ -11,7 +9,10 @@ def load_prompt():
     return " fais une dissertation "
 
 # Configuration du logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
 
 app = Flask(__name__)
 
@@ -19,67 +20,58 @@ app = Flask(__name__)
 token = os.environ.get("TOKEN")
 client = genai.Client(api_key=token)
 
-# Configuration de génération par défaut
+# Configuration par défaut
 default_generation_config = types.GenerateContentConfig(
     temperature=1,
     max_output_tokens=8192
 )
 
-# Define model names
 STANDARD_MODEL_NAME = "gemini-2.5-flash"
 DEEPTHINK_MODEL_NAME = "gemini-2.5-pro"
 
 @app.route('/')
 def index():
-    logging.info("Rendering index.html")
+    logging.info("Page index demandée.")
     return render_template('index.html')
 
 @app.route('/api/francais', methods=['POST'])
 def gpt_francais():
-    """Handles French questions with streaming enabled by default."""
-    logging.info("Received request at /api/francais")
+    logging.info("Requête POST reçue sur /api/francais")
     french_prompt = request.form.get('sujet', '').strip()
     choix = request.form.get('choix', '').strip()
     style = request.form.get('style', '').strip()
-    use_deepthink_str = request.form.get('use_deepthink', 'false')
-    use_deepthink = use_deepthink_str.lower() == 'true'
+    use_deepthink = request.form.get('use_deepthink', 'false').lower() == 'true'
 
-    logging.info(f"Received data: french_prompt='{french_prompt}', choix='{choix}', style='{style}', use_deepthink='{use_deepthink}'")
+    logging.info(f"Données reçues : sujet='{french_prompt[:50]}', choix='{choix}', style='{style}', deepthink={use_deepthink}")
 
     if not french_prompt:
-        logging.warning("French prompt is empty.")
+        logging.warning("Sujet vide, retour erreur.")
         return Response(f"data: {json.dumps({'type': 'error', 'content': 'Erreur'})}\n\n",
                         mimetype='text/event-stream'), 400
 
-    # Sélectionner le modèle
     model_to_use = DEEPTHINK_MODEL_NAME if use_deepthink else STANDARD_MODEL_NAME
-    logging.info(f"Using model: {model_to_use}")
+    logging.info(f"Modèle utilisé : {model_to_use}")
 
-    # Charger l'instruction système
     try:
         system_instruction = load_prompt()
-    except Exception:
-        logging.error("Erreur")
+    except Exception as e:
+        logging.exception("Erreur lors du chargement du prompt système.")
         system_instruction = "Tu es un assistant spécialisé en français."
 
-    # Construire le prompt utilisateur
     user_prompt = f"Sujet: {french_prompt}\nType: {choix}\nStyle: {style}"
 
-    # Configuration pour cette requête
     config = types.GenerateContentConfig(
         system_instruction=system_instruction,
         temperature=1,
         max_output_tokens=8192
     )
 
-    # Ajouter la configuration de pensée pour DeepThink
     if use_deepthink:
-        config.thinking_config = types.ThinkingConfig(
-            include_thoughts=True
-        )
+        config.thinking_config = types.ThinkingConfig(include_thoughts=True)
 
     def generate_stream():
         try:
+            logging.info("Démarrage du streaming de génération...")
             thoughts = ""
             answer = ""
 
@@ -93,53 +85,59 @@ def gpt_francais():
                         continue
                     elif hasattr(part, 'thought') and part.thought:
                         if not thoughts:
+                            logging.info("Premiers éléments de réflexion envoyés.")
                             yield f"data: {json.dumps({'type': 'thoughts_start'})}\n\n"
                         thoughts += part.text
                         yield f"data: {json.dumps({'type': 'thought', 'content': part.text})}\n\n"
                     else:
                         if not answer:
+                            logging.info("Premiers éléments de réponse envoyés.")
                             yield f"data: {json.dumps({'type': 'answer_start'})}\n\n"
                         answer += part.text
                         yield f"data: {json.dumps({'type': 'answer', 'content': part.text})}\n\n"
 
+            logging.info("Fin du streaming de génération.")
             yield f"data: {json.dumps({'type': 'done'})}\n\n"
 
         except Exception:
-            logging.error("Erreur")
+            logging.exception("Erreur pendant la génération de contenu.")
             yield f"data: {json.dumps({'type': 'error', 'content': 'Erreur'})}\n\n"
 
     return Response(generate_stream(), mimetype='text/event-stream')
 
-
 @app.route('/api/etude-texte', methods=['POST'])
 def gpt_francais_cc():
-    """Analyse d'images avec streaming imposé."""
+    logging.info("Requête POST reçue sur /api/etude-texte")
+
     if 'images' not in request.files:
+        logging.warning("Aucun fichier image reçu.")
         return Response(f"data: {json.dumps({'type': 'error', 'content': 'Erreur'})}\n\n",
                         mimetype='text/event-stream'), 400
 
     images = request.files.getlist('images')
     if not images:
+        logging.warning("Liste d'images vide.")
         return Response(f"data: {json.dumps({'type': 'error', 'content': 'Erreur'})}\n\n",
                         mimetype='text/event-stream'), 400
 
     def generate_image_analysis():
         try:
-            # Charger l'instruction système
+            logging.info(f"Nombre d'images reçues : {len(images)}")
             try:
                 system_instruction = load_prompt()
             except Exception:
-                logging.error("Erreur")
+                logging.exception("Erreur lors du chargement du prompt système pour analyse texte.")
                 system_instruction = "Tu es un assistant spécialisé dans l'analyse de textes et de documents."
 
             content = ["Réponds aux questions présentes dans les images."]
 
-            for image in images:
-                if image.filename:
-                    img_data = image.read()
+            for img in images:
+                if img.filename:
+                    logging.info(f"Traitement image : {img.filename}")
+                    img_data = img.read()
                     img_part = types.Part.from_bytes(
                         data=img_data,
-                        mime_type=image.content_type or 'image/jpeg'
+                        mime_type=img.content_type or 'image/jpeg'
                     )
                     content.append(img_part)
 
@@ -149,6 +147,7 @@ def gpt_francais_cc():
                 max_output_tokens=4096
             )
 
+            logging.info("Démarrage du streaming d'analyse d'image...")
             for chunk in client.models.generate_content_stream(
                 model=STANDARD_MODEL_NAME,
                 contents=content,
@@ -158,15 +157,15 @@ def gpt_francais_cc():
                     if part.text:
                         yield f"data: {json.dumps({'type': 'content', 'content': part.text})}\n\n"
 
+            logging.info("Fin du streaming d'analyse d'image.")
             yield f"data: {json.dumps({'type': 'done'})}\n\n"
 
         except Exception:
-            logging.error("Erreur")
+            logging.exception("Erreur pendant l'analyse d'image.")
             yield f"data: {json.dumps({'type': 'error', 'content': 'Erreur'})}\n\n"
 
     return Response(generate_image_analysis(), mimetype='text/event-stream')
 
-
 if __name__ == '__main__':
-    logging.info("Starting the Flask app with new Gemini SDK...")
+    logging.info("Démarrage du serveur Flask avec Gemini SDK...")
     app.run(debug=True)