Update app.py

app.py

@@ -1,126 +1,95 @@
-# --- SyTART OF FILE app - 2025-04-25T003524.273.py ---
-
-from flask import Flask, render_template, request, send_file, jsonify, current_app
+from flask import Flask, render_template, request, send_file, jsonify
 from google import genai
-from google.genai import types
 from PIL import Image
 import subprocess
 import tempfile
 import os
 import io
+import shutil
 import base64
-import logging # Importer le module de logging
+
+app = Flask(__name__)
 
 # --- Constantes ---
-MODEL_SINGLE_GENERATION = "gemini-2.5-pro-exp-03-25"
+MODEL_SINGLE_GENERATION = "gemini-2.5-pro-exp-03-25"  # Modèle avec "thinking" pour la génération complète
 LATEX_MENTION = r"\vspace{1cm}\noindent\textit{Ce devoir a été généré par Mariam AI. \url{https://mariam-241.vercel.app}}"
 
-app = Flask(__name__)
-
-# Configuration du logging
-logging.basicConfig(level=logging.DEBUG) # Afficher les messages DEBUG et supérieurs
+# --- Configuration des secrets ---
+# Dans un environnement de production, utilisez les variables d'environnement ou un fichier .env
+GOOGLE_API_KEY = os.environ.get('GOOGLE_API_KEY', '')
 
 # --- Fonctions Utilitaires ---
+
 def check_latex_installation():
     """Vérifie si pdflatex est accessible dans le PATH système."""
     try:
-        # Tente d'exécuter pdflatex pour vérifier son existence et son fonctionnement
-        current_app.logger.info("Vérification de l'installation de pdflatex...")
-        result = subprocess.run(['pdflatex', '--version'], capture_output=True, check=True, timeout=10, text=True, encoding='utf-8', errors='replace')
-        current_app.logger.info(f"pdflatex trouvé. Version: {result.stdout.splitlines()[0]}")
-        return True, "Installation LaTeX (pdflatex) trouvée."
+        subprocess.run(['pdflatex', '--version'], capture_output=True, check=True, timeout=10)
+        return True, "✅ Installation LaTeX (pdflatex) trouvée."
     except (subprocess.CalledProcessError, FileNotFoundError, TimeoutError) as e:
-        error_msg = f"pdflatex introuvable ou ne répond pas. Veuillez installer une distribution LaTeX (comme TeX Live ou MiKTeX) et vous assurer qu'elle est dans le PATH système. Erreur: {e}"
-        current_app.logger.error(error_msg)
-        # Si FileNotFoundError, donner plus de détails
-        if isinstance(e, FileNotFoundError):
-             error_msg += f"\nLe système ne trouve pas l'exécutable 'pdflatex'. Est-il dans le PATH ?"
-        elif isinstance(e, TimeoutError):
-             error_msg += f"\nLa commande 'pdflatex --version' a dépassé le délai. L'installation est peut-être corrompue."
-        elif isinstance(e, subprocess.CalledProcessError):
-             error_msg += f"\nLa commande 'pdflatex --version' a retourné une erreur: {e.stderr}"
-        return False, error_msg
-    except Exception as e:
-        error_msg = f"Erreur inattendue lors de la vérification de pdflatex: {e}"
-        current_app.logger.error(error_msg)
-        return False, error_msg
+        return False, f"❌ pdflatex introuvable ou ne répond pas. Veuillez installer une distribution LaTeX (comme TeX Live ou MiKTeX) et vous assurer qu'elle est dans le PATH système. Erreur: {e}"
 
 def initialize_genai_client():
     """Initialise et retourne le client Google GenAI."""
     try:
-        current_app.logger.info("Initialisation du client GenAI...")
-        api_key = os.environ.get("GOOGLE_API_KEY")
-        if not api_key:
-            current_app.logger.error("Clé API Google non trouvée dans les variables d'environnement.")
+        if not GOOGLE_API_KEY:
             return None, "Clé API Google non trouvée dans les variables d'environnement."
-
-        client = genai.Client(api_key=api_key, http_options={'api_version':'v1alpha'})
-        # Test rapide de la connexion (optionnel mais utile)
-        #client.models.get_model(f'models/{MODEL_SINGLE_GENERATION}')
-        current_app.logger.info("Client GenAI initialisé et modèle vérifié.")
-        return client, "Client Mariam AI initialisé."
+            
+        client = genai.Client(api_key=GOOGLE_API_KEY, http_options={'api_version':'v1alpha'})
+        return client, "✅ Client Mariam AI initialisé."
     except Exception as e:
-        error_msg = f"Erreur lors de l'initialisation ou de la vérification du client GenAI: {e}"
-        current_app.logger.error(error_msg)
-        return None, error_msg
-
+        return None, f"❌ Erreur lors de l'initialisation du client: {str(e)}"
 
 def clean_latex(raw_latex_text):
     """Nettoie le code LaTeX brut potentiellement fourni par Gemini."""
     if not isinstance(raw_latex_text, str):
-        current_app.logger.warning("clean_latex reçu une entrée non-string.")
-        return ""
+        return ""  # Retourne une chaîne vide si l'entrée n'est pas une chaîne
 
-    current_app.logger.debug(f"LaTeX brut reçu:\n{raw_latex_text[:500]}...\n...\n{raw_latex_text[-500:]}") # Log début et fin
     cleaned = raw_latex_text.strip()
 
-    # Supprime les marqueurs de bloc de code (```latex ... ``` ou ``` ... ```) de manière plus robuste
-    if cleaned.startswith("```"):
-        cleaned = cleaned.split('\n', 1)[-1] # Prend tout après la première ligne
-        if cleaned.startswith("latex"): # Gère le cas ```latex
-            cleaned = cleaned[len("latex"):].lstrip() # Enlève 'latex' et espaces suivants
+    # Supprime les marqueurs de bloc de code (```latex ... ``` ou ``` ... ```)
+    if cleaned.startswith("```latex"):
+        cleaned = cleaned[8:]
+    elif cleaned.startswith("```"):
+        # Gère le cas où il y a un saut de ligne après ```
+        lines = cleaned.split('\n', 1)
+        if len(lines) > 1:
+            cleaned = lines[1]
+        else:
+            cleaned = cleaned[3:]  # Si pas de saut de ligne, juste enlever ```
 
     # Supprime les marqueurs de fin de bloc de code
     if cleaned.endswith("```"):
-        cleaned = cleaned[:-3].rstrip() # Enlève ``` et les espaces/sauts de ligne potentiels avant
+        cleaned = cleaned[:-3].strip()  # Enlève ``` et les espaces potentiels avant
 
-    # Vérification de la structure minimale
-    if not cleaned.strip().startswith("\\documentclass"):
-        current_app.logger.warning("Code LaTeX nettoyé ne commence pas par \\documentclass.")
-        # Ne pas ajouter \documentclass ici, car on ne sait pas quel type ou options sont nécessaires.
-        # L'erreur de compilation qui suivra sera plus informative.
+    # Assure que le document commence correctement
+    if not cleaned.startswith("\\documentclass"):
+        # On pourrait choisir de lever une erreur ou de tenter une correction
+        pass
 
+    # Assure que le document se termine exactement par \end{document}
     end_doc_tag = "\\end{document}"
-    if end_doc_tag not in cleaned:
-         # Si \documentclass est présent mais pas \end{document}, c'est probablement une erreur de génération
-         if cleaned.strip().startswith("\\documentclass"):
-              current_app.logger.warning(f"Tag '{end_doc_tag}' manquant dans le LaTeX généré. Tentative d'ajout.")
-              cleaned += f"\n{end_doc_tag}"
-         else:
-              # Si même \documentclass manque, le code est probablement inutile
-              current_app.logger.error("Structure LaTeX de base manquante (\\documentclass et \\end{document}).")
-              # On retourne quand même ce qu'on a, la compilation échouera.
-              pass
+    if end_doc_tag in cleaned:
+        end_idx = cleaned.rfind(end_doc_tag) + len(end_doc_tag)
+        cleaned = cleaned[:end_idx]
     else:
-         # Assurer qu'il n'y a rien après \end{document} (sauf des espaces/sauts de ligne)
-         end_idx = cleaned.rfind(end_doc_tag) + len(end_doc_tag)
-         trailing_content = cleaned[end_idx:].strip()
-         if trailing_content:
-             current_app.logger.warning(f"Contenu trouvé après {end_doc_tag} : '{trailing_content[:100]}...' - Suppression.")
-             cleaned = cleaned[:end_idx]
-
+        # Ajoute seulement si \documentclass est présent pour éviter de créer un doc invalide
+        if cleaned.strip().startswith("\\documentclass"):
+            cleaned += f"\n{end_doc_tag}"
 
-    current_app.logger.debug(f"LaTeX nettoyé:\n{cleaned[:500]}...\n...\n{cleaned[-500:]}")
-    return cleaned.strip() # Retourne le résultat nettoyé final
+    return cleaned.strip()  # Retourne le résultat nettoyé
 
 # --- Fonction Principale (API GenAI) ---
-def generate_complete_latex(client, image):
+
+def generate_complete_latex(client, image_bytes):
     """
-    Génère une solution complète en LaTeX à partir de l'image en une seule étape,
-    en utilisant un modèle capable de "réfléchir" (thinking) et de produire un document bien formaté.
+    Génère une solution complète en LaTeX à partir de l'image en une seule étape.
     """
-    prompt = f"""
-    # ROLE & OBJECTIF
+    try:
+        # Convertir les bytes en image PIL
+        image = Image.open(io.BytesIO(image_bytes))
+        
+        prompt = f"""
+        # ROLE & OBJECTIF
 Agis en tant qu'expert en mathématiques et tuteur pédagogue. Ton objectif est de créer une correction détaillée et irréprochable pour l'exercice mathématique présenté dans l'image fournie. La correction doit être sous forme de document LaTeX complet et directement compilable.
 
 # CONTEXTE
@@ -134,395 +103,243 @@ Agis en tant qu'expert en mathématiques et tuteur pédagogue. Ton objectif est
 3.  Rédige la solution complète directement en code LaTeX, en respectant **toutes** les spécifications ci-dessous.
 
 # SPÉCIFICATIONS TECHNIQUES DU CODE LATEX
-1.  **Structure du Document:** Commence **strictement** par `\\documentclass{{article}}` et se termine **strictement** par `\\end{{document}}`. N'ajoute rien avant `\\documentclass` ou après `\\end{{document}}`.
-2.  **Packages Requis:** Inclus impérativement les packages suivants dans le préambule (entre `\\documentclass` et `\\begin{{document}}`): `amsmath`, `amssymb`, `geometry` (avec `\\geometry{{a4paper, margin=2cm}}`), `hyperref` (charge-le en dernier si possible), `graphicx` (si des figures sont nécessaires), `inputenc` (avec `\\usepackage[utf8]{{inputenc}}`), `fontenc` (avec `\\usepackage[T1]{{fontenc}}`), `babel` (avec `\\usepackage[french]{{babel}}`), `url`.
-3.  **Encodage:** Assure-toi que le document est encodé en UTF-8 (implicite avec `inputenc`). Utilise correctement les accents français (é, à, ç, etc.) directement ou via les commandes LaTeX appropriées si nécessaire.
-4.  **Compilabilité:** Le code généré doit être valide et compilable sans erreur avec `pdflatex`. Évite les packages ou commandes obsolètes ou trop exotiques.
-5.  **Formatage du Code:** Produis un code LaTeX propre, bien indenté et lisible.
-6.  **Environnements Mathématiques:** Utilise les environnements LaTeX appropriés (`align`, `align*`, `equation`, `gather`, `cases`, etc.) pour présenter les calculs et les équations de manière claire et standard. Préfère `align*` pour les suites d'égalités non numérotées. Utilise `\( ... \)` ou `$ ... $` pour les maths en ligne, et `\[ ... \]` ou `$$ ... $$` (préférer `\[ ... \]` ou `equation*`) pour les maths hors ligne non numérotées.
-7.  **AUCUN Marqueur de Code:** Le résultat doit être **uniquement** le code LaTeX brut. N'inclus **JAMAIS** de marqueurs de code comme ```latex ... ``` ou ``` ... ``` au début ou à la fin.
+1.  **Structure du Document:** Commence **strictement** par `\\documentclass{{article}}` et se termine **strictement** par `\\end{{document}}`.
+2.  **Packages Requis:** Inclus impérativement les packages suivants via `\\usepackage{{...}}`: `amsmath`, `amssymb`, `geometry`, `hyperref`, `url`. Assure-toi qu'ils sont déclarés dans le préambule.
+3.  **Compilabilité:** Le code généré doit être valide et compilable sans erreur avec `pdflatex`.
+4.  **Formatage du Code:** Produis un code LaTeX propre, bien indenté et lisible.
+5.  **Environnements Mathématiques:** Utilise les environnements LaTeX appropriés (`align`, `equation`, `gather`, etc.) pour présenter les calculs et les équations de manière claire et standard.
+6.  **AUCUN Marqueur de Code:** Le résultat doit être **uniquement** le code LaTeX brut. N'inclus **JAMAIS** de marqueurs de code comme ```latex ... ``` ou ``` ... ``` au début ou à la fin.
 
 # STYLE & CONTENU DE LA SOLUTION
-1.  **Pédagogie:** La correction doit être claire, aérée et facile à comprendre pour un élève de Terminale S. Utilise des phrases complètes.
-2.  **Justifications:** Justifie **chaque** étape clé du raisonnement mathématique. Explique *pourquoi* une certaine méthode est utilisée ou *comment* on passe d'une étape à l'autre. N'hésite pas à rappeler brièvement une propriété ou une formule utilisée.
-3.  **Rigueur:** Assure l'exactitude mathématique complète de la solution. Vérifie les calculs.
-4.  **Structure Logique:** Organise la solution de manière logique. Numérote les questions si l'exercice en comporte plusieurs. Utilise des sections (`\\section*{{...}}`, `\\subsection*{{...}}`) si cela améliore la clarté pour des problèmes longs ou multi-parties. Commence par un titre simple comme `\\title*{{Correction de l'exercice}} \\date{{}} \\maketitle`.
+1.  **Pédagogie:** La correction doit être claire, aérée et facile à comprendre pour un élève de Terminale S.
+2.  **Justifications:** Justifie **chaque** étape clé du raisonnement mathématique. Explique *pourquoi* une certaine méthode est utilisée ou *comment* on passe d'une étape à l'autre.
+3.  **Rigueur:** Assure l'exactitude mathématique complète de la solution.
+4.  **Structure Logique:** Organise la solution de manière logique. Utilise des sections (`\\section*{{...}}`, `\\subsection*{{...}}`) si cela améliore la clarté pour des problèmes longs ou multi-parties.
 5.  **Mention Obligatoire:** Insère la ligne suivante **exactement** telle quelle, juste avant la ligne `\\end{{document}}`:
     {LATEX_MENTION}
 
 # PROCESSUS INTERNE RECOMMANDÉ (Pour l'IA)
-1.  **Analyse Approfondie:** Décompose le problème en sous-étapes logiques. Identifie les concepts mathématiques clés.
-2.  **Résolution Étape par Étape:** Effectue la résolution mathématique complète en interne. Sois très détaillé dans ton raisonnement.
-3.  **Traduction en LaTeX:** Convertis ta résolution raisonnée en code LaTeX, en appliquant méticuleusement toutes les spécifications de formatage et de style demandées. Porte une attention particulière aux packages requis et à la structure du document. Vérifie que la mention obligatoire est bien placée.
-    """
-    try:
-        current_app.logger.info(f"Génération LaTeX demandée au modèle {MODEL_SINGLE_GENERATION}...")
+1.  **Analyse Approfondie:** Décompose le problème en sous-étapes logiques.
+2.  **Résolution Étape par Étape:** Effectue la résolution mathématique complète en interne.
+3.  **Traduction en LaTeX:** Convertis ta résolution raisonnée en code LaTeX, en appliquant méticuleusement toutes les spécifications de formatage et de style demandées
+        """
+
         response = client.models.generate_content(
             model=MODEL_SINGLE_GENERATION,
             contents=[image, prompt],
-            config=types.GenerateContentConfig(
-                temperature=0.3, # Température basse pour plus de consistance
-                # max_output_tokens=8192, # Augmenter si nécessaire
-            ),
-            # request_options={'timeout': 120} # Timeout pour la requête API elle-même si besoin
+            config=genai.types.GenerateContentConfig(
+                temperature=0.3,
             )
+        )
 
         latex_content_raw = None
         thinking_content = None
 
         # Extrait le contenu LaTeX et le raisonnement (thought)
-        # La structure peut varier légèrement, tentons d'être robustes
-        if response.candidates:
-            candidate = response.candidates[0]
-            if candidate.content and candidate.content.parts:
-                 # Parfois le 'thought' est dans une part séparée, parfois attaché
-                 if hasattr(candidate, 'thought') and candidate.thought:
-                      thinking_content = candidate.thought
-                 # Le contenu textuel est généralement la dernière partie
-                 latex_content_raw = candidate.text # .text combine les parts textuelles
-                 # Chercher explicitement le 'thought' dans les parts si non trouvé avant
-                 if not thinking_content:
-                     for part in candidate.content.parts:
-                          if hasattr(part, 'thought') and part.thought:
-                               thinking_content = part.thought
-                               # Si le thought est dans une part, le latex brut est peut-être ailleurs
-                               # Re-extraire le texte des autres parts si nécessaire
-                               text_parts = [p.text for p in candidate.content.parts if not hasattr(p, 'thought')]
-                               if text_parts:
-                                    latex_content_raw = "\n".join(text_parts)
-                               break # Supposons qu'il n'y a qu'un seul 'thought'
-
-            # Log de ce qui a été extrait
-            current_app.logger.info(f"Génération terminée. Contenu brut extrait: {'Oui' if latex_content_raw else 'Non'}, Thinking process extrait: {'Oui' if thinking_content else 'Non'}")
-            if thinking_content:
-                current_app.logger.debug(f"Thinking process:\n{thinking_content[:500]}...")
-
-        else:
-             current_app.logger.warning("Aucun candidat trouvé dans la réponse de l'API.")
-             # Tenter de voir s'il y a une erreur dans la réponse 'prompt_feedback'
-             if response.prompt_feedback and response.prompt_feedback.block_reason:
-                  block_reason = response.prompt_feedback.block_reason.name
-                  current_app.logger.error(f"Génération bloquée par l'API. Raison: {block_reason}")
-                  safety_ratings = response.prompt_feedback.safety_ratings
-                  current_app.logger.error(f"Safety Ratings: {safety_ratings}")
-                  return None, None, f"Génération bloquée (Raison: {block_reason}). Vérifiez les Safety Ratings dans les logs serveur."
-             else:
-                  return None, None, "Aucun candidat retourné par l'API GenAI."
-
+        if response.candidates and response.candidates[0].content and response.candidates[0].content.parts:
+            for part in response.candidates[0].content.parts:
+                if getattr(part, 'thought', None):
+                    thinking_content = part.text
+                else:
+                    latex_content_raw = part.text
 
         if latex_content_raw:
             latex_content_cleaned = clean_latex(latex_content_raw)
-
-            # Vérification et insertion de la mention obligatoire AVANT la balise de fin
-            end_doc_tag = "\\end{document}"
+            
+            # Vérification supplémentaire : est-ce que la mention obligatoire est présente ?
             if LATEX_MENTION not in latex_content_cleaned:
-                 current_app.logger.warning("Mention obligatoire non trouvée dans le LaTeX nettoyé. Tentative d'insertion.")
-                 if end_doc_tag in latex_content_cleaned:
-                     # Insère juste avant \end{document}
-                     cleaned_parts = latex_content_cleaned.rsplit(end_doc_tag, 1)
-                     latex_content_cleaned = cleaned_parts[0].rstrip() + f"\n{LATEX_MENTION}\n{end_doc_tag}" + cleaned_parts[1] # Conserve ce qui pourrait être après (même si clean_latex devrait l'enlever)
-                 else:
-                     # Si \end{document} manque (malgré clean_latex), on l'ajoute avec la mention
-                     current_app.logger.warning(f"'{end_doc_tag}' manquait aussi. Ajout de la mention et de la balise à la fin.")
-                     latex_content_cleaned += f"\n{LATEX_MENTION}\n{end_doc_tag}"
-            else:
-                 current_app.logger.info("Mention obligatoire trouvée dans le LaTeX nettoyé.")
-
-
+                # Tente de l'insérer avant \end{document}
+                end_doc_tag = "\\end{document}"
+                if end_doc_tag in latex_content_cleaned:
+                    latex_content_cleaned = latex_content_cleaned.replace(end_doc_tag, f"{LATEX_MENTION}\n{end_doc_tag}")
+                else:
+                    # Si \end{document} n'est pas là, ajoute les deux à la fin
+                    latex_content_cleaned += f"\n{LATEX_MENTION}\n{end_doc_tag}"
+                    
             return latex_content_cleaned, thinking_content, None
         else:
-             current_app.logger.error("Aucun contenu LaTeX brut n'a pu être extrait de la réponse de l'API.")
-             return None, thinking_content, "Aucun contenu LaTeX n'a été généré ou extrait de la réponse de l'API."
+            return None, thinking_content, "Aucun contenu LaTeX n'a été généré par le modèle."
 
+    except genai.types.StopCandidateException as e:
+        return None, None, "❌ Génération stoppée (possible contenu inapproprié)"
     except Exception as e:
-        current_app.logger.exception("Erreur imprévue lors de la génération du LaTeX via l'API GenAI.")
-        return None, None, f"Erreur lors de la génération du LaTeX: {str(e)}"
+        return None, None, f"❌ Erreur lors de la génération du LaTeX: {str(e)}"
 
 # --- Fonction de Compilation LaTeX ---
+
 def compile_latex_to_pdf(latex_content):
     """
     Compile une chaîne de caractères contenant du code LaTeX en fichier PDF.
     Utilise un répertoire temporaire pour les fichiers intermédiaires.
     """
-    if not latex_content or not latex_content.strip():
-        current_app.logger.error("Tentative de compilation de contenu LaTeX vide.")
+    if not latex_content:
         return None, "Impossible de compiler : contenu LaTeX vide."
 
     # Utilise un répertoire temporaire sécurisé qui sera nettoyé automatiquement
     with tempfile.TemporaryDirectory() as temp_dir:
-        base_filename = "solution"
-        tex_filename = f"{base_filename}.tex"
-        pdf_filename = f"{base_filename}.pdf"
-        log_filename = f"{base_filename}.log"
-        aux_filename = f"{base_filename}.aux" # Aussi utile pour le debug
-
+        tex_filename = "solution.tex"
+        pdf_filename = "solution.pdf"
         tex_filepath = os.path.join(temp_dir, tex_filename)
         pdf_filepath = os.path.join(temp_dir, pdf_filename)
-        log_filepath = os.path.join(temp_dir, log_filename)
-        aux_filepath = os.path.join(temp_dir, aux_filename)
-
-        current_app.logger.info(f"Tentative de compilation LaTeX dans le répertoire temporaire : {temp_dir}")
-        current_app.logger.debug(f"Chemin du fichier .tex : {tex_filepath}")
+        log_filepath = os.path.join(temp_dir, "solution.log")  # Pour le débogage
 
         # Écrit le contenu LaTeX dans le fichier .tex avec encodage UTF-8
         try:
             with open(tex_filepath, "w", encoding="utf-8") as f:
                 f.write(latex_content)
-            current_app.logger.info(f"Fichier .tex écrit avec succès ({len(latex_content)} octets).")
         except IOError as e:
-            error_msg = f"Erreur lors de l'écriture du fichier .tex temporaire: {str(e)}"
-            current_app.logger.error(error_msg)
-            return None, error_msg
+            return None, f"❌ Erreur lors de l'écriture du fichier .tex temporaire: {str(e)}"
 
         # Exécute pdflatex
-        # -interaction=nonstopmode : N'attend pas d'input utilisateur en cas d'erreur
-        # -halt-on-error : S'arrête à la première erreur (peut être utile pour debug, mais nonstopmode est plus courant pour l'automatisation)
-        # -file-line-error : Affiche les erreurs avec nom de fichier et numéro de ligne
         command = [
             "pdflatex",
             "-interaction=nonstopmode",
-            "-file-line-error",
             f"-output-directory={temp_dir}",
-            f"-jobname={base_filename}", # Nom sans extension
+            f"-jobname={os.path.splitext(pdf_filename)[0]}",  # Nom sans extension
             tex_filepath
         ]
-        current_app.logger.info(f"Commande pdflatex (passe 1): {' '.join(command)}")
 
         pdf_generated = False
-        compile_log_lines = [] # Stocke toutes les lignes de log (stdout, stderr, infos custom)
-        max_passes = 2 # Généralement suffisant pour les références croisées/table des matières simples
-
-        for pass_num in range(1, max_passes + 1):
-            compile_log_lines.append(f"--- Compilation LaTeX (Passe {pass_num}/{max_passes}) ---")
-            current_app.logger.info(f"Lancement de la passe {pass_num} de pdflatex...")
+        compilation_output = ""
+        
+        for pass_num in range(1, 3):  # Lance jusqu'à 2 passes
             try:
                 # Augmentation du timeout pour les compilations potentiellement longues
-                result = subprocess.run(command, capture_output=True, check=False, # check=False pour analyser nous-mêmes le résultat
-                                       text=True, encoding='utf-8', errors='replace', timeout=90) # Timeout augmenté à 90s
-
-                compile_log_lines.append(f"Code de retour pdflatex: {result.returncode}")
-                compile_log_lines.append("--- Sortie Standard (stdout) ---")
-                compile_log_lines.append(result.stdout if result.stdout else "Aucune sortie standard.")
-                compile_log_lines.append("--- Sortie Erreur (stderr) ---")
-                compile_log_lines.append(result.stderr if result.stderr else "Aucune sortie d'erreur.")
-
-                # Essayer de lire le fichier .log de LaTeX pour des détails cruciaux
-                log_content = ""
-                try:
-                    if os.path.exists(log_filepath):
-                        with open(log_filepath, "r", encoding="utf-8", errors='replace') as log_file:
-                            log_content = log_file.read()
-                        compile_log_lines.append(f"--- Contenu du fichier log ({log_filename}) ---")
-                        compile_log_lines.append(log_content)
-                        current_app.logger.debug(f"Fichier log lu ({len(log_content)} octets).")
-                    else:
-                        compile_log_lines.append(f"--- Fichier log ({log_filename}) non trouvé. ---")
-                        current_app.logger.warning(f"Fichier log non trouvé après la passe {pass_num}.")
-
-                except IOError as log_e:
-                    log_read_error = f"Impossible de lire le fichier log de LaTeX ({log_filename}): {log_e}"
-                    compile_log_lines.append(f"--- ERREUR LECTURE LOG: {log_read_error} ---")
-                    current_app.logger.error(log_read_error)
-
-
-                # Vérification cruciale : le PDF existe-t-il ?
+                result = subprocess.run(command, capture_output=True, check=True, text=True, encoding='utf-8', errors='replace', timeout=60)
+                compilation_output += f"Passe {pass_num}: Succès\n"
+                
+                # Vérifie si le PDF a été créé après la première passe (au moins)
                 if os.path.exists(pdf_filepath):
-                    current_app.logger.info(f"Fichier PDF trouvé après la passe {pass_num}.")
                     pdf_generated = True
-                    # Si le PDF est là et c'est la dernière passe, ou s'il n'y a pas d'erreurs majeures signalées
-                    # dans le log (heuristique simple : chercher "!")
-                    # et que le return code est 0 (ou même 1 parfois avec nonstopmode si le PDF est quand même généré)
-                    # on pourrait arrêter plus tôt. Pour la robustesse, faisons les 2 passes si pas d'erreur fatale.
-                    # Si une erreur fatale est détectée (e.g., "! LaTeX Error:"), on arrête.
-                    if "! LaTeX Error:" in log_content or "Fatal error occurred" in log_content:
-                         current_app.logger.error(f"Erreur fatale détectée dans le log LaTeX pendant la passe {pass_num}. Arrêt de la compilation.")
-                         compile_log_lines.append("--- ERREUR FATALE DÉTECTÉE DANS LE LOG - COMPILATION INTERROMPUE ---")
-                         return None, "\n".join(compile_log_lines)
-
-                    # Si on est à la dernière passe et le PDF existe, c'est bon signe
-                    if pass_num == max_passes:
-                        break # Sortir de la boucle des passes
-
-                else:
-                    # Si le PDF n'existe pas après une passe, il y a un problème sérieux
-                    current_app.logger.error(f"Fichier PDF non généré après la passe {pass_num}.")
-                    compile_log_lines.append(f"--- ERREUR: Fichier PDF non trouvé après la passe {pass_num}. ---")
-                    # Si le fichier log existe, il contient probablement la raison
-                    if not log_content and os.path.exists(log_filepath): # Relire le log si pas déjà fait
-                         try:
-                            with open(log_filepath, "r", encoding="utf-8", errors='replace') as log_file:
-                                log_content = log_file.read()
-                            compile_log_lines.append(f"--- Contenu du fichier log ({log_filename}) après échec PDF ---")
-                            compile_log_lines.append(log_content)
-                         except IOError: pass # Déjà loggué plus haut si erreur de lecture
-                    
-                    # Inutile de faire une autre passe si la première a échoué si gravement
-                    return None, "\n".join(compile_log_lines)
 
+            except subprocess.CalledProcessError as e:
+                error_message = f"❌ Erreur lors de la compilation LaTeX (Passe {pass_num}).\n"
+                error_message += f"Code de retour: {e.returncode}\n"
+                error_message += f"Sortie: {e.stdout}\n"
+                error_message += f"Erreurs: {e.stderr}\n"
+                
+                # Essayer de lire le fichier .log pour plus d'infos
+                try:
+                    with open(log_filepath, "r", encoding="utf-8", errors='replace') as log_file:
+                        error_message += f"Extrait du fichier log (solution.log):\n{log_file.read()[-2000:]}"
+                except IOError:
+                    error_message += "Impossible de lire le fichier log de LaTeX."
+                
+                return None, error_message
 
             except subprocess.TimeoutExpired:
-                 timeout_msg = f"La compilation LaTeX (Passe {pass_num}) a dépassé le délai de {90} secondes. Le document est peut-être trop complexe ou contient une boucle infinie."
-                 current_app.logger.error(timeout_msg)
-                 compile_log_lines.append(f"--- ERREUR: TIMEOUT ({timeout_msg}) ---")
-                 # Essayer de lire le log même après timeout
-                 try:
-                     if os.path.exists(log_filepath):
-                         with open(log_filepath, "r", encoding="utf-8", errors='replace') as log_file:
-                             compile_log_lines.append(f"--- Contenu partiel du log ({log_filename}) après timeout ---")
-                             compile_log_lines.append(log_file.read()[-5000:]) # Derniers 5000 caractères
-                 except IOError: pass
-                 return None, "\n".join(compile_log_lines)
-
+                return None, "❌ La compilation LaTeX a dépassé le délai imparti. Le document est peut-être trop complexe ou contient une boucle infinie."
+            
             except Exception as e:
-                 exec_error = f"Une erreur inattendue est survenue lors de l'exécution de pdflatex (Passe {pass_num}): {str(e)}"
-                 current_app.logger.exception(exec_error) # Log l'exception complète
-                 compile_log_lines.append(f"--- ERREUR SYSTÈME PENDANT L'EXÉCUTION: {exec_error} ---")
-                 return None, "\n".join(compile_log_lines)
-
-        # Fin de la boucle des passes
+                return None, f"❌ Une erreur inattendue est survenue lors de l'exécution de pdflatex: {str(e)}"
 
-        # Vérifie si le fichier PDF existe après toutes les passes
+        # Vérifie si le fichier PDF existe après les passes
         if pdf_generated and os.path.exists(pdf_filepath):
             try:
-                current_app.logger.info("Compilation terminée avec succès. Lecture du fichier PDF...")
                 # Lit le contenu binaire du PDF généré
                 with open(pdf_filepath, "rb") as f:
                     pdf_data = f.read()
-                current_app.logger.info(f"PDF lu avec succès ({len(pdf_data)} octets).")
-                # Retourner aussi une partie du log pour info, même en cas de succès
-                success_log_summary = "\n".join(compile_log_lines[-10:]) # Dernières 10 lignes du log interne
-                return pdf_data, f"PDF généré avec succès !\n--- Extrait final du log ---\n{success_log_summary}"
+                return pdf_data, "✅ PDF généré avec succès !"
             except IOError as e:
-                read_error = f"PDF généré mais erreur lors de la lecture du fichier: {str(e)}"
-                current_app.logger.error(read_error)
-                compile_log_lines.append(f"--- ERREUR LECTURE PDF: {read_error} ---")
-                return None, "\n".join(compile_log_lines)
+                return None, f"❌ Erreur lors de la lecture du fichier PDF généré: {str(e)}"
         else:
-            current_app.logger.error("Le fichier PDF n'a pas été généré après toutes les passes de compilation.")
-            compile_log_lines.append("--- ÉCHEC FINAL: Le fichier PDF n'a pas été trouvé après toutes les passes. ---")
-            # Le log contient déjà les détails des erreurs des passes précédentes.
-            return None, "\n".join(compile_log_lines)
+            error_message = "❌ Le fichier PDF n'a pas été généré après la compilation LaTeX.\n"
+            # Tenter de lire le log
+            try:
+                with open(log_filepath, "r", encoding="utf-8", errors='replace') as log_file:
+                    error_message += f"Extrait du fichier log (solution.log) après échec de génération PDF:\n{log_file.read()[-2000:]}"
+            except IOError:
+                error_message += "Impossible de lire le fichier log de LaTeX."
+            return None, error_message
 
+# --- Routes Flask ---
 
 @app.route('/')
 def index():
-    # Log l'accès à la page d'accueil
-    current_app.logger.info(f"Requête reçue pour / par {request.remote_addr}")
     return render_template('index.html')
 
-@app.route('/check-latex')
+@app.route('/check-latex', methods=['GET'])
 def check_latex():
-    current_app.logger.info(f"Requête reçue pour /check-latex par {request.remote_addr}")
-    latex_ok, message = check_latex_installation()
+    latex_installed, message = check_latex_installation()
     return jsonify({
-        "success": latex_ok,
-        "message": message
+        'success': latex_installed,
+        'message': message
     })
 
-@app.route('/process-image', methods=['POST'])
-def process_image():
-    current_app.logger.info(f"Requête reçue pour /process-image par {request.remote_addr}")
-    if 'image' not in request.files:
-        current_app.logger.warning("Aucune image reçue dans la requête /process-image")
-        return jsonify({"success": False, "message": "Aucune image téléchargée"})
+@app.route('/check-api', methods=['GET'])
+def check_api():
+    client, message = initialize_genai_client()
+    return jsonify({
+        'success': client is not None,
+        'message': message
+    })
 
+@app.route('/process', methods=['POST'])
+def process():
+    if 'image' not in request.files:
+        return jsonify({'success': False, 'message': 'Aucune image téléchargée'})
+        
     file = request.files['image']
     if file.filename == '':
-        current_app.logger.warning("Nom de fichier vide dans la requête /process-image")
-        return jsonify({"success": False, "message": "Aucun fichier sélectionné"})
-
-    # Vérifier l'extension (simple vérification côté serveur)
-    allowed_extensions = {'png', 'jpg', 'jpeg'}
-    if '.' not in file.filename or file.filename.rsplit('.', 1)[1].lower() not in allowed_extensions:
-         current_app.logger.warning(f"Type de fichier non autorisé: {file.filename}")
-         return jsonify({"success": False, "message": "Type de fichier non autorisé. Utilisez PNG, JPG ou JPEG."})
-
-    current_app.logger.info(f"Image reçue: {file.filename}, type: {file.mimetype}")
-
-    try:
-        # Initialisation du client GenAI
-        client, client_message = initialize_genai_client()
-        if not client:
-            # Message déjà loggué dans initialize_genai_client
-            return jsonify({"success": False, "message": client_message})
-
-        # Traitement de l'image
-        current_app.logger.info("Ouverture de l'image...")
-        try:
-            image = Image.open(file.stream)
-             # Optionnel: Redimensionner si trop grande pour l'API ?
-             # image.thumbnail((1024, 1024))
-            current_app.logger.info(f"Image ouverte avec succès. Format: {image.format}, Taille: {image.size}")
-        except Exception as img_e:
-            current_app.logger.error(f"Erreur lors de l'ouverture de l'image: {img_e}")
-            return jsonify({"success": False, "message": f"Impossible de lire le fichier image: {img_e}"})
-
-
-        # Génération du LaTeX
-        latex_content, thinking_process, error_message = generate_complete_latex(client, image)
-
-        if error_message:
-            current_app.logger.error(f"Erreur retournée par generate_complete_latex: {error_message}")
-            # Ne pas retourner immédiatement s'il y a quand même du contenu LaTeX partiel
-            # return jsonify({"success": False, "message": error_message})
-
-        if not latex_content:
-            current_app.logger.error("Échec final de la génération LaTeX, aucun contenu retourné.")
-            # S'assurer qu'un message d'erreur est fourni
-            final_error_msg = error_message or "Échec de la génération de la solution LaTeX par l'API."
-            return jsonify({
-                "success": False,
-                "message": final_error_msg,
-                "thinking": thinking_process # Retourner le thinking même si le latex a échoué
-            })
-
-        # S'il y avait une erreur non fatale mais qu'on a du contenu, on le logge et on continue
-        if error_message:
-             current_app.logger.warning(f"Erreur mineure durant la génération LaTeX ({error_message}), mais du contenu a été produit. Tentative de compilation...")
-
-
-        # Compilation en PDF
-        current_app.logger.info("Lancement de la compilation LaTeX vers PDF...")
-        pdf_data, pdf_message = compile_latex_to_pdf(latex_content)
-
-        if not pdf_data:
-            current_app.logger.error(f"Échec de la compilation PDF. Message/Log: {pdf_message[:1000]}...") # Log début du message/log d'erreur
-            return jsonify({
-                "success": False,
-                "message": "Échec de la compilation PDF.", # Message générique pour l'utilisateur
-                "latex": latex_content,
-                "thinking": thinking_process,
-                "compilation_log": pdf_message # Le log complet est crucial ici
-            })
-
-        # Succès !
-        current_app.logger.info("PDF généré et lu avec succès.")
-        # Convertir le PDF en base64 pour l'affichage dans le navigateur
-        pdf_base64 = base64.b64encode(pdf_data).decode('utf-8')
-        current_app.logger.info(f"PDF encodé en base64 (longueur: {len(pdf_base64)}).")
-
-        # Préparer les données de réponse
+        return jsonify({'success': False, 'message': 'Aucun fichier sélectionné'})
+    
+    # Lire l'image
+    image_bytes = file.read()
+    
+    # Initialiser le client
+    client, message = initialize_genai_client()
+    if client is None:
+        return jsonify({'success': False, 'message': message})
+    
+    # Générer le LaTeX
+    latex_content, thinking_content, error = generate_complete_latex(client, image_bytes)
+    if error:
+        return jsonify({'success': False, 'message': error})
+        
+    # Compiler en PDF
+    pdf_data, message = compile_latex_to_pdf(latex_content)
+    if pdf_data is None:
         return jsonify({
-            "success": True,
-            "message": "PDF généré avec succès",
-            "latex": latex_content,
-            "thinking": thinking_process,
-            "pdf_base64": pdf_base64,
-            "compilation_log": pdf_message # Retourner aussi le log de succès (peut contenir des warnings utiles)
+            'success': False, 
+            'message': message,
+            'latex': latex_content,
+            'thinking': thinking_content
         })
+    
+    # Encoder le PDF en base64 pour le retourner au front-end
+    pdf_base64 = base64.b64encode(pdf_data).decode('utf-8')
+    
+    # Retourner les données
+    return jsonify({
+        'success': True,
+        'message': 'PDF généré avec succès',
+        'latex': latex_content,
+        'thinking': thinking_content,
+        'pdf_base64': pdf_base64
+    })
 
+@app.route('/download-pdf', methods=['POST'])
+def download_pdf():
+    if 'pdf_data' not in request.json:
+        return jsonify({'success': False, 'message': 'Données PDF manquantes'})
+    
+    try:
+        pdf_data = base64.b64decode(request.json['pdf_data'])
+        
+        # Créer un fichier temporaire pour le PDF
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as temp_file:
+            temp_file.write(pdf_data)
+            temp_path = temp_file.name
+        
+        # Envoyer le fichier
+        return send_file(
+            temp_path,
+            mimetype='application/pdf',
+            as_attachment=True,
+            download_name='solution_mariam_ai.pdf'
+        )
     except Exception as e:
-        current_app.logger.exception("Erreur non gérée dans /process-image") # Log l'exception complète
-        return jsonify({
-            "success": False,
-            "message": f"Erreur serveur inattendue lors du traitement: {str(e)}"
-        })
-
-# @app.route('/download-pdf', methods=['POST']) # Déprécié, téléchargement via JS+Base64
-# def download_pdf():
-#     # ... (gardé pour référence mais non utilisé par le frontend actuel)
+        return jsonify({'success': False, 'message': f'Erreur lors du téléchargement: {str(e)}'})
 
-if __name__ == '__main__':
-    # Utiliser '0.0.0.0' pour rendre accessible sur le réseau local si besoin
-    # debug=True active le rechargement auto et le débuggeur (NE PAS UTILISER EN PRODUCTION)
-    app.run(debug=True, port=5000)
+if __name__ == "__main__":
+    app.run(debug=True)