Update app.py

app.py

@@ -11,8 +11,9 @@ from psycopg2.extras import RealDictCursor
 from google import genai
 from google.genai import types
 from utils import load_prompt
-from weasyprint import HTML # <-- NOUVEL IMPORT
-import io # <-- NOUVEL IMPORT
+from weasyprint import HTML
+import io
+import mimetypes
 
 # --- Configuration de l'application ---
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -40,13 +41,13 @@ class Partie(BaseModel):
     transition: Optional[str] = Field(description="Phrase ou court paragraphe de transition.", default=None)
 
 class Dissertation(BaseModel):
-    sujet: str = Field(description="Le sujet exact de la dissertation, tel que posé par l'utilisateur.")
+    sujet: str = Field(description="Le sujet exact de la dissertation, tel que posé par l'utilisateur (ou le type de texte analysé).")
     prof: str = Field(description="Le nom du professeur, qui est toujours 'Mariam AI'.", default="Mariam AI")
     introduction: str = Field(description="L'introduction complète de la dissertation.")
     parties: List[Partie]
     conclusion: str = Field(description="La conclusion complète de la dissertation.")
 
-# --- Configuration Gemini (inchangée) ---
+# --- Configuration Gemini ---
 try:
     if not GOOGLE_API_KEY:
         logging.warning("La variable d'environnement TOKEN (GOOGLE_API_KEY) n'est pas définie.")
@@ -76,7 +77,7 @@ def create_connection():
         logging.error(f"Impossible de se connecter à la base de données : {e}")
         return None
 
-# --- Helpers pour la gestion des données (inchangés) ---
+# --- Helpers pour la gestion des données (inchangés dans leur fonction, ajustés pour le logging) ---
 def save_dissertation_data(input_data, output_data, success=True, error_message=None):
     """Sauvegarde les données d'entrée et de sortie dans un fichier JSON."""
     try:
@@ -86,10 +87,13 @@ def save_dissertation_data(input_data, output_data, success=True, error_message=
         else:
             data = []
         
+        # S'assurer que 'question' est bien dans input_data
+        question_logged = input_data.get('question', 'N/A (Image upload)') 
+
         record = {
             "timestamp": datetime.now().isoformat(),
             "input": {
-                "question": input_data.get('question', ''),
+                "question": question_logged,
                 "type": input_data.get('type', ''),
                 "courseId": input_data.get('courseId')
             },
@@ -180,87 +184,143 @@ def get_philosophy_courses():
         if conn:
             conn.close()
 
-# --- API pour la génération de dissertation (inchangée) ---
+# --- API pour la génération de dissertation (MISE À JOUR pour le Type 3) ---
 @app.route('/api/generate_dissertation', methods=['POST'])
 def generate_dissertation_api():
     if not client:
         error_msg = "Le service IA n'est pas correctement configuré."
-        save_dissertation_data(request.json or {}, None, False, error_msg)
+        # Le logging d'erreur ici est plus complexe car on ne sait pas encore si on a du JSON ou des fichiers
         return jsonify({"error": error_msg}), 503
 
-    data = request.json
-    sujet = data.get('question', '').strip()
-    dissertation_type = data.get('type', 'type1').strip()
-    course_id = data.get('courseId')
+    # Détecter le type de requête et extraire les données
+    is_file_upload = 'image' in request.files
+    data_for_log = {} # Structure pour le log
 
-    if not sujet:
-        error_msg = "Le champ 'question' est obligatoire."
-        save_dissertation_data(data, None, False, error_msg)
-        return jsonify({"error": error_msg}), 400
+    if is_file_upload:
+        dissertation_type = request.form.get('type', 'type3').strip()
+        data_for_log = {'type': dissertation_type, 'courseId': None} # Pas de courseId pour type3
+        
+        if dissertation_type != 'type3':
+            error_msg = "Le type 3 nécessite un fichier image."
+            save_dissertation_data(data_for_log, None, False, error_msg)
+            return jsonify({"error": error_msg}), 400
+
+    else: # JSON (Type 1 ou Type 2)
+        data = request.json
+        if not data:
+            error_msg = "Requête JSON vide ou format incorrect."
+            save_dissertation_data({'type': 'unknown'}, None, False, error_msg)
+            return jsonify({"error": error_msg}), 400
+
+        dissertation_type = data.get('type', 'type1').strip()
+        sujet = data.get('question', '').strip()
+        course_id = data.get('courseId')
         
-    if dissertation_type not in ['type1', 'type2']:
-        error_msg = "Type de méthodologie invalide."
-        save_dissertation_data(data, None, False, error_msg)
-        return jsonify({"error": error_msg}), 400
-
-    context_str = ""
-    if course_id:
-        conn = create_connection()
-        if not conn:
-            error_msg = "Connexion à la base de données échouée pour récupérer le contexte."
-            save_dissertation_data(data, None, False, error_msg)
-            return jsonify({"error": error_msg}), 503
-        try:
-            with conn.cursor(cursor_factory=RealDictCursor) as cur:
-                cur.execute("SELECT content FROM cours_philosophie WHERE id = %s", (course_id,))
-                result = cur.fetchone()
-                if result and result.get('content'):
-                    context_str = f"\n\n--- EXTRAIT DE COURS À UTILISER COMME CONTEXTE PRINCIPAL ---\n{result['content']}"
-        except Exception as e:
-            logging.error(f"Erreur lors de la récupération du contexte du cours {course_id}: {e}")
-        finally:
-            if conn:
-                conn.close()
+        data_for_log = {'type': dissertation_type, 'question': sujet, 'courseId': course_id}
+
+        if dissertation_type not in ['type1', 'type2']:
+            error_msg = "Type de méthodologie invalide."
+            save_dissertation_data(data_for_log, None, False, error_msg)
+            return jsonify({"error": error_msg}), 400
+            
+        if not sujet:
+            error_msg = "Le champ 'question' est obligatoire."
+            save_dissertation_data(data_for_log, None, False, error_msg)
+            return jsonify({"error": error_msg}), 400
 
     try:
         prompt_filename = f"philo_dissertation_{dissertation_type}.txt"
         prompt_template = load_prompt(prompt_filename)
         
         if "Erreur:" in prompt_template:
-            error_msg = "Configuration du prompt introuvable pour ce type."
+            error_msg = f"Configuration du prompt introuvable pour le type '{dissertation_type}'."
             logging.error(f"Fichier de prompt non trouvé : {prompt_filename}")
-            save_dissertation_data(data, None, False, error_msg)
+            save_dissertation_data(data_for_log, None, False, error_msg)
             return jsonify({"error": error_msg}), 500
+            
+        
+        # --- Préparation du contenu pour Gemini ---
+        contents = []
+        if dissertation_type == 'type3':
+            image_file = request.files['image']
+            image_bytes = image_file.read()
+            mime_type = image_file.mimetype or mimetypes.guess_type(image_file.filename)[0]
+            
+            # Mise à jour du log pour le commentaire de texte
+            data_for_log['question'] = f"Image: {image_file.filename}"
+            
+            # Contenu multimodal: le prompt + l'image
+            contents = [
+                prompt_template, 
+                types.Part.from_bytes(data=image_bytes, mime_type=mime_type)
+            ]
+            # Utiliser le modèle multimodal 1.5
+            model_name = "models/gemini-1.5-flash"
+
+        else: # Type 1 et 2 (texte uniquement)
+            context_str = ""
+            # Récupération du contexte du cours (uniquement pour type 1 et 2)
+            if data_for_log.get('courseId'):
+                conn = create_connection()
+                if conn:
+                    try:
+                        with conn.cursor(cursor_factory=RealDictCursor) as cur:
+                            cur.execute("SELECT content FROM cours_philosophie WHERE id = %s", (data_for_log['courseId'],))
+                            result = cur.fetchone()
+                            if result and result.get('content'):
+                                context_str = f"\n\n--- EXTRAIT DE COURS À UTILISER COMME CONTEXTE PRINCIPAL ---\n{result['content']}"
+                    except Exception as e:
+                        logging.error(f"Erreur lors de la récupération du contexte du cours {data_for_log['courseId']}: {e}")
+                    finally:
+                        conn.close()
+
+            final_prompt = prompt_template.format(phi_prompt=data_for_log['question'], context=context_str)
+            contents = [final_prompt]
+            model_name = "models/gemini-2.5-flash" # Modèle texte optimisé
 
-        final_prompt = prompt_template.format(phi_prompt=sujet, context=context_str)
+        
+        # --- Appel à l'IA ---
         config = types.GenerateContentConfig(
             safety_settings=SAFETY_SETTINGS,
             response_mime_type="application/json",
             response_schema=Dissertation,
         )
         response = client.models.generate_content(
-            model="gemini-flash-latest",
-            contents=final_prompt,
+            model=model_name,
+            contents=contents,
             config=config
         )
 
-        if response.parsed:
-            result = response.parsed.dict()
-            save_dissertation_data(data, result, True)
-            return jsonify(result)
+        # --- Traitement de la réponse ---
+        if response.text:
+            try:
+                # response.text contient la chaîne JSON
+                result = json.loads(response.text)
+                # Validation Pydantic optionnelle ici, mais on se fie au modèle pour être rigide
+                
+                # S'assurer que le sujet est bien rempli pour le log
+                if dissertation_type == 'type3' and 'sujet' in result:
+                     data_for_log['question'] = result['sujet']
+
+                save_dissertation_data(data_for_log, result, True)
+                return jsonify(result)
+            except json.JSONDecodeError:
+                error_msg = "Le modèle n'a pas pu générer une structure JSON valide."
+                logging.error(f"Erreur JSON Decode: Réponse brute : {response.text}")
+                save_dissertation_data(data_for_log, None, False, error_msg)
+                return jsonify({"error": error_msg}), 500
         else:
-            error_msg = "Le modèle n'a pas pu générer une structure valide."
-            logging.error(f"Erreur de parsing de la réponse structurée. Réponse brute : {response.text}")
-            save_dissertation_data(data, None, False, error_msg)
+            error_msg = "Le modèle n'a retourné aucune réponse textuelle."
+            save_dissertation_data(data_for_log, None, False, error_msg)
             return jsonify({"error": error_msg}), 500
 
     except Exception as e:
         error_msg = f"Une erreur est survenue avec le service IA : {e}"
         logging.error(f"Erreur de génération Gemini : {e}")
-        save_dissertation_data(data, None, False, error_msg)
+        save_dissertation_data(data_for_log, None, False, error_msg)
         return jsonify({"error": error_msg}), 500
 
-# --- NOUVELLE ROUTE API POUR LA GÉNÉRATION DE PDF ---
+# --- ROUTE API POUR LA GÉNÉRATION DE PDF (inchangée) ---
 @app.route('/api/generate_pdf', methods=['POST'])
 def generate_pdf_api():
     """Génère un PDF à partir des données JSON de la dissertation."""