Update app.py

app.py

@@ -1,4 +1,4 @@
-#-- START OF FILE app - 2025-04-08T095242.046.py ---
+#--- START OF FILE app - 2025-04-08T095242.046.py ---
 
 from flask import Flask, render_template, request, jsonify
 import google.generativeai as genai
@@ -25,9 +25,16 @@ safety_settings = [
     {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
 ]
 
-# Choose the Gemini model
-model = genai.GenerativeModel(
-    model_name="gemini-2.0-flash", # Modèle mis à jour vers 1.5-flash pour potentiellement de meilleures performances
+# Define model names
+STANDARD_MODEL_NAME = "gemini-2.0-flash" # Using latest flash
+# MODIFICATION: Utilisation du nom de modèle Pro spécifié (attention: peut être expérimental/non disponible)
+DEEPTHINK_MODEL_NAME = "gemini-2.5-pro-exp-03-25" # Using stable latest Pro model is generally safer
+# DEEPTHINK_MODEL_NAME = "models/gemini-1.5-pro-exp-0325" # Si vous voulez absolument tester ce modèle expérimental spécifique
+# Note: Les noms de modèles expérimentaux peuvent nécessiter un préfixe "models/"
+
+# Default model instance (used for etude-texte)
+default_model = genai.GenerativeModel(
+    model_name=STANDARD_MODEL_NAME,
     generation_config=generation_config,
     safety_settings=safety_settings
 )
@@ -38,14 +45,22 @@ def index():
 
 @app.route('/api/francais', methods=['POST'])
 def gpt_francais():
-    """Handles French questions."""
+    """Handles French questions with optional DeepThink model."""
     french_prompt = request.form.get('sujet', '').strip()
     choix = request.form.get('choix', '').strip()
     style = request.form.get('style', '').strip()
+    # MODIFICATION: Lire le nouveau paramètre 'use_deepthink'
+    use_deepthink_str = request.form.get('use_deepthink', 'false')
+    use_deepthink = use_deepthink_str.lower() == 'true'
 
     if not french_prompt:
         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
+
+    # Le reste de la logique de construction du prompt reste identique...
     if choix == "discuter":
         prompt = f""" Je veux faire mon travail de français de niveau lycée sous la forme d'un travail argumentatif.
         La question du travail est la suivante : "{french_prompt}". Tu devras discuter ce thème.
@@ -89,7 +104,7 @@ def gpt_francais():
 
         Je veux que tu utilises un style d'écriture {style}."""
 
-    elif choix == "dissertation": # NOUVEAU BLOC POUR LA DISSERTATION
+    elif choix == "dissertation":
         prompt = f""" Je veux faire mon travail de français de niveau lycée sous la forme d'une dissertation.
         La question du travail est la suivante : "{french_prompt}". Tu devras traiter ce sujet de manière approfondie.
         tu utiliseras la méthodologie suivante :
@@ -162,78 +177,76 @@ def gpt_francais():
         Je veux que tu utilises un style d'écriture {style}."""
 
     try:
-        response = model.generate_content(prompt)
+        # MODIFICATION: Instancier le modèle spécifique pour cette requête
+        # Utiliser les mêmes configurations que le modèle par défaut
+        selected_model = genai.GenerativeModel(
+            model_name=model_to_use_name,
+            generation_config=generation_config,
+            safety_settings=safety_settings
+        )
+        response = selected_model.generate_content(prompt)
         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: {e}")
+        print(f"Error generating content with model {model_to_use_name}: {e}")
         # Retourne un message d'erreur générique à l'utilisateur
-        return jsonify({"output": f"Une erreur interne est survenue lors de la génération du contenu. Veuillez réessayer."}), 500
+        # 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():
+             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
 
 
 @app.route('/api/etude-texte', methods=['POST'])
 def gpt_francais_cc():
-    """Handles text analysis for French with multiple images."""
+    """Handles text analysis for French with multiple images (uses default model)."""
     if 'images' not in request.files:
         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): # Vérifie si la liste est vide ou ne contient que des objets vides
+    if not images or all(not image.filename for image in images):
         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."
 
-    # Préparer les images pour l'API Gemini
     contents = [pre_prompt]
-
     valid_images_found = False
     for image in images:
-        if image and image.filename: # S'assure que l'objet fichier n'est pas vide et a un nom
+        if image and image.filename:
             try:
-                # Lire l'image avec PIL
                 img_bytes = image.read()
-                # Vérifier si les bytes lus ne sont pas vides
                 if not img_bytes:
                     print(f"Skipping empty file: {image.filename}")
-                    continue # Ignore les fichiers vides
+                    continue
 
                 img = Image.open(io.BytesIO(img_bytes))
-                img.verify() # Vérifie si l'image est valide/non corrompue
-                # Re-ouvrir après verify()
+                img.verify()
                 img = Image.open(io.BytesIO(img_bytes))
 
-                # Convertir en format compatible avec Gemini
                 contents.append(img)
                 valid_images_found = True
 
             except (IOError, SyntaxError) as e:
-                # Log l'erreur spécifique
                 print(f"Error processing image {image.filename}: {e}. It might be corrupted or not a valid image format.")
-                # Optionnel: informer l'utilisateur qu'une image spécifique a échoué
-                # return jsonify({"output": f"Erreur lors du traitement de l'image {image.filename}: Format invalide ou fichier corrompu."}), 400
             except Exception as e:
                 print(f"Unexpected error processing image {image.filename}: {e}")
-                # Optionnel: retourner une erreur générique
-                # return jsonify({"output": f"Erreur inattendue lors du traitement de l'image {image.filename}."}), 500
 
     if not valid_images_found:
          return jsonify({"output": "Aucune image valide n'a été trouvée parmi les fichiers téléchargés."}), 400
 
-
     try:
-        # Générer le contenu avec toutes les images valides
-        response = model.generate_content(contents)
+        # Utilisation du modèle par défaut (non-DeepThink) pour l'analyse d'images
+        response = default_model.generate_content(contents)
         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
     except Exception as e:
-        # Log l'erreur pour le débogage côté serveur
-        print(f"Error during Gemini generation: {e}")
-        # Retourne un message d'erreur générique
-        return jsonify({"output": f"Une erreur interne est survenue lors de l'analyse des images. Veuillez réessayer."}), 500
+        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
 
 
 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 ---