Update app.py

app.py

@@ -1,11 +1,13 @@
-#--- START OF FILE app - 2025-04-08T095242.046.py ---
-
 from flask import Flask, render_template, request, jsonify
 import google.generativeai as genai
 from google.generativeai import types
 import os
 from PIL import Image
 import io
+import logging
+
+# Configuration du logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
 app = Flask(__name__)
 
@@ -41,11 +43,13 @@ default_model = genai.GenerativeModel(
 
 @app.route('/')
 def index():
+    logging.info("Rendering index.html")
     return render_template('index.html')
 
 @app.route('/api/francais', methods=['POST'])
 def gpt_francais():
     """Handles French questions with optional DeepThink model."""
+    logging.info("Received request at /api/francais")
     french_prompt = request.form.get('sujet', '').strip()
     choix = request.form.get('choix', '').strip()
     style = request.form.get('style', '').strip()
@@ -53,12 +57,15 @@ def gpt_francais():
     use_deepthink_str = request.form.get('use_deepthink', 'false')
     use_deepthink = use_deepthink_str.lower() == 'true'
 
+    logging.info(f"Received data: french_prompt='{french_prompt}', choix='{choix}', style='{style}', use_deepthink='{use_deepthink}'")
+
     if not french_prompt:
+        logging.warning("French prompt is empty.")
         return jsonify({"output": "Veuillez saisir un thème."}), 400
 
     # MODIFICATION: Sélectionner le nom du modèle basé sur use_deepthink
     model_to_use_name = DEEPTHINK_MODEL_NAME if use_deepthink else STANDARD_MODEL_NAME
-    print(f"Using model: {model_to_use_name}") # Log for debugging
+    logging.info(f"Using model: {model_to_use_name}") # Log for debugging
 
     # Le reste de la logique de construction du prompt reste identique...
     if choix == "discuter":
@@ -179,31 +186,39 @@ def gpt_francais():
     try:
         # MODIFICATION: Instancier le modèle spécifique pour cette requête
         # Utiliser les mêmes configurations que le modèle par défaut
+        logging.info(f"Creating GenerativeModel instance with model name: {model_to_use_name}")
         selected_model = genai.GenerativeModel(
             model_name=model_to_use_name,
             generation_config=generation_config,
             safety_settings=safety_settings
         )
+        logging.info("Generating content...")
         response = selected_model.generate_content(prompt)
+        logging.info("Content generated successfully.")
         return jsonify({"output": response.text}), 200
     except Exception as e:
         # Log l'erreur pour le débogage côté serveur
-        print(f"Error generating content with model {model_to_use_name}: {e}")
+        logging.exception(f"Error generating content with model {model_to_use_name}: {e}")
         # Retourne un message d'erreur générique à l'utilisateur
         # Vérifier si l'erreur est due à un modèle invalide/non disponible
         if "model" in str(e).lower() and "not found" in str(e).lower():
+             logging.error(f"Model '{model_to_use_name}' not found.")
              return jsonify({"output": f"Erreur: Le modèle '{model_to_use_name}' n'est pas accessible ou n'existe pas. Essayez sans l'option DeepThink."}), 500
-        return jsonify({"output": f"Une erreur interne est survenue lors de la génération du contenu ({type(e).__name__}). Veuillez réessayer."}), 500
+        logging.error(f"Internal error occurred: {e}")
+        return jsonify({"output":"Une erreur interne est survenue lors de la génération du contenu. Veuillez réessayer."}), 500
 
 
 @app.route('/api/etude-texte', methods=['POST'])
 def gpt_francais_cc():
     """Handles text analysis for French with multiple images (uses default model)."""
+    logging.info("Received request at /api/etude-texte")
     if 'images' not in request.files:
+        logging.warning("No images were uploaded.")
         return jsonify({"output": "Aucune image n'a été téléchargée."}), 400
 
     images = request.files.getlist('images')
     if not images or all(not image.filename for image in images):
+        logging.warning("No images selected or files are empty.")
         return jsonify({"output": "Aucune image sélectionnée ou les fichiers sont vides."}), 400
 
     pre_prompt = "Analyse de manière exhaustive et structurée le contenu du devoir présenté dans les images suivantes. Identifie les questions, extrais le texte si présent, et réponds aux questions de manière détaillée en te basant uniquement sur les informations fournies dans les images."
@@ -212,10 +227,11 @@ def gpt_francais_cc():
     valid_images_found = False
     for image in images:
         if image and image.filename:
+            logging.info(f"Processing image: {image.filename}")
             try:
                 img_bytes = image.read()
                 if not img_bytes:
-                    print(f"Skipping empty file: {image.filename}")
+                    logging.warning(f"Skipping empty file: {image.filename}")
                     continue
 
                 img = Image.open(io.BytesIO(img_bytes))
@@ -226,27 +242,30 @@ def gpt_francais_cc():
                 valid_images_found = True
 
             except (IOError, SyntaxError) as e:
-                print(f"Error processing image {image.filename}: {e}. It might be corrupted or not a valid image format.")
+                logging.error(f"Error processing image {image.filename}: {e}. It might be corrupted or not a valid image format.")
             except Exception as e:
-                print(f"Unexpected error processing image {image.filename}: {e}")
+                logging.exception(f"Unexpected error processing image {image.filename}: {e}")
 
     if not valid_images_found:
-         return jsonify({"output": "Aucune image valide n'a été trouvée parmi les fichiers téléchargés."}), 400
+        logging.warning("No valid images were found among the uploaded files.")
+        return jsonify({"output": "Aucune image valide n'a été trouvée parmi les fichiers téléchargés."}), 400
 
     try:
         # Utilisation du modèle par défaut (non-DeepThink) pour l'analyse d'images
+        logging.info("Generating content with default model for image analysis...")
         response = default_model.generate_content(contents)
+        logging.info("Content generated successfully for image analysis.")
         return jsonify({"output": response.text}), 200
     except types.generation_types.BlockedPromptException as e:
-         print(f"Content generation blocked: {e}")
-         return jsonify({"output": "La génération de contenu a été bloquée car la requête ou les images contenaient potentiellement du contenu non autorisé."}), 400
+        logging.warning(f"Content generation blocked: {e}")
+        return jsonify({"output": "La génération de contenu a été bloquée car la requête ou les images contenaient potentiellement du contenu non autorisé."}), 400
     except Exception as e:
-        print(f"Error during Gemini generation (etude-texte): {e}")
-        return jsonify({"output": f"Une erreur interne est survenue lors de l'analyse des images ({type(e).__name__}). Veuillez réessayer."}), 500
+        logging.exception(f"Error during  generation (etude-texte): {e}")
+        return jsonify({"output":"Une erreur interne est survenue lors de l'analyse des images.Veuillez réessayer."}), 500
 
 
 if __name__ == '__main__':
     # Désactiver le reloader Flask si vous avez des problèmes avec les instances multiples de modèle ou la mémoire
     # app.run(debug=True, use_reloader=False)
-    app.run(debug=True)
-#--- END OF FILE app - 2025-04-08T095242.046.py ---
+    logging.info("Starting the Flask app...")
+    app.run(debug=True)