Update app.py

app.py

@@ -1,27 +1,20 @@
-from flask import Flask, render_template, request, jsonify, send_file
+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 time
-import uuid
 import base64
-from dotenv import load_dotenv
-
-# Chargement des variables d'environnement
-load_dotenv()
-
-app = Flask(__name__)
 
 # --- Constantes ---
 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}}"
 
-# --- Fonctions Utilitaires ---
+app = Flask(__name__)
 
+# --- Fonctions Utilitaires ---
 def check_latex_installation():
     """Vérifie si pdflatex est accessible dans le PATH système."""
     try:
@@ -29,11 +22,13 @@ def check_latex_installation():
         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:
-        return False, f"pdflatex introuvable ou ne répond pas. Veuillez installer une distribution LaTeX. Erreur: {e}"
+        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:
+        # Dans un environnement Flask, vous devrez configurer votre API key différemment
+        # Par exemple, en utilisant les variables d'environnement
         api_key = os.environ.get("GOOGLE_API_KEY")
         if not api_key:
             return None, "Clé API Google non trouvée dans les variables d'environnement."
@@ -65,9 +60,9 @@ def clean_latex(raw_latex_text):
     if cleaned.endswith("```"):
         cleaned = cleaned[:-3].strip()  # Enlève ``` et les espaces potentiels avant
 
-    # Vérification du début du document
+    # Assure que le document commence correctement
     if not cleaned.startswith("\\documentclass"):
-        app.logger.warning("Le code LaTeX reçu ne commence pas par \\documentclass.")
+        pass  # On log un avertissement dans l'application web
 
     # Assure que le document se termine exactement par \end{document}
     end_doc_tag = "\\end{document}"
@@ -75,13 +70,13 @@ def clean_latex(raw_latex_text):
         end_idx = cleaned.rfind(end_doc_tag) + len(end_doc_tag)
         cleaned = cleaned[:end_idx]
     else:
-        app.logger.warning("Le code LaTeX reçu ne contient pas \\end{document}. Tentative d'ajout.")
         # 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}"
 
     return cleaned.strip()  # Retourne le résultat nettoyé
 
+# --- Fonction Principale (API GenAI) ---
 def generate_complete_latex(client, image):
     """
     Génère une solution complète en LaTeX à partir de l'image en une seule étape,
@@ -123,8 +118,6 @@ Agis en tant qu'expert en mathématiques et tuteur pédagogue. Ton objectif est
 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
     """
     try:
-        from google.genai import types
-        
         response = client.models.generate_content(
             model=MODEL_SINGLE_GENERATION,
             contents=[image, prompt],
@@ -148,7 +141,6 @@ Agis en tant qu'expert en mathématiques et tuteur pédagogue. Ton objectif est
             
             # Vérification supplémentaire : est-ce que la mention obligatoire est présente ?
             if LATEX_MENTION not in latex_content_cleaned:
-                app.logger.warning("La mention obligatoire semble manquer. Tentative d'insertion.")
                 # Tente de l'insérer avant \end{document}
                 end_doc_tag = "\\end{document}"
                 if end_doc_tag in latex_content_cleaned:
@@ -157,14 +149,16 @@ Agis en tant qu'expert en mathématiques et tuteur pédagogue. Ton objectif est
                     # 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
+            return latex_content_cleaned, thinking_content, None
         else:
-            return None, thinking_content
+            return None, thinking_content, "Aucun contenu LaTeX n'a été généré par le modèle."
 
+    except types.StopCandidateException as e:
+         return None, None, "Génération stoppée (possible contenu inapproprié)"
     except Exception as e:
-        app.logger.error(f"Erreur lors de la génération du LaTeX: {e}")
-        return None, None
+        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.
@@ -186,9 +180,9 @@ def compile_latex_to_pdf(latex_content):
             with open(tex_filepath, "w", encoding="utf-8") as f:
                 f.write(latex_content)
         except IOError as e:
-            return None, f"Erreur lors de l'écriture du fichier .tex temporaire: {e}"
+            return None, f"Erreur lors de l'écriture du fichier .tex temporaire: {str(e)}"
 
-        # Commande pdflatex
+        # Exécute pdflatex
         command = [
             "pdflatex",
             "-interaction=nonstopmode",
@@ -198,31 +192,41 @@ def compile_latex_to_pdf(latex_content):
         ]
 
         pdf_generated = False
-        log_output = ""
+        compile_log = []
         
         for pass_num in range(1, 3):  # Lance jusqu'à 2 passes
+            compile_log.append(f"Compilation LaTeX (Passe {pass_num})...")
             try:
                 # Augmentation du timeout pour les compilations potentiellement longues
-                result = subprocess.run(command, capture_output=True, check=True, text=True, encoding='utf-8', errors='replace', timeout=60)
+                result = subprocess.run(command, capture_output=True, check=True, text=True, 
+                                       encoding='utf-8', errors='replace', timeout=60)
+                compile_log.append(result.stdout)
                 # Vérifie si le PDF a été créé après la première passe (au moins)
                 if os.path.exists(pdf_filepath):
                     pdf_generated = True
 
             except subprocess.CalledProcessError as e:
-                error_msg = f"Erreur lors de la compilation LaTeX (Passe {pass_num}). Code: {e.returncode}"
+                compile_log.append(f"Erreur lors de la compilation LaTeX (Passe {pass_num}).")
+                compile_log.append(f"Code de retour: {e.returncode}")
+                compile_log.append("Sortie de pdflatex (stdout):")
+                compile_log.append(e.stdout or "Aucune sortie standard.")
+                compile_log.append("Erreurs de pdflatex (stderr):")
+                compile_log.append(e.stderr or "Aucune sortie d'erreur.")
+                
                 # Essayer de lire le fichier .log pour plus d'infos
                 try:
                     with open(log_filepath, "r", encoding="utf-8", errors='replace') as log_file:
-                        log_output = log_file.read()[-2000:]  # Dernières lignes du log
+                        compile_log.append("Extrait du fichier log (solution.log):")
+                        compile_log.append(log_file.read()[-2000:])  # Affiche les dernières lignes
                 except IOError:
-                    log_output = "Impossible de lire le fichier log de LaTeX."
-                return None, f"{error_msg}\n{log_output}"
+                    compile_log.append("Impossible de lire le fichier log de LaTeX.")
                 
+                return None, "\n".join(compile_log)  # Arrête la compilation en cas d'erreur
+            
             except subprocess.TimeoutExpired:
-                return None, "La compilation LaTeX a dépassé le délai imparti."
-                
+                 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:
-                return None, f"Erreur inattendue lors de l'exécution de pdflatex: {e}"
+                 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 les passes
         if pdf_generated and os.path.exists(pdf_filepath):
@@ -232,120 +236,112 @@ def compile_latex_to_pdf(latex_content):
                     pdf_data = f.read()
                 return pdf_data, "PDF généré avec succès !"
             except IOError as e:
-                return None, f"Erreur lors de la lecture du fichier PDF généré: {e}"
+                return None, f"Erreur lors de la lecture du fichier PDF généré: {str(e)}"
         else:
-            # Tenter de lire le log si le PDF n'a pas été généré
+            compile_log.append("Le fichier PDF n'a pas été généré après la compilation LaTeX.")
+            # Tenter de lire le log même si CalledProcessError n'a pas été levée
             try:
                 with open(log_filepath, "r", encoding="utf-8", errors='replace') as log_file:
-                    log_output = log_file.read()[-2000:]
+                    compile_log.append("Extrait du fichier log (solution.log) après échec de génération PDF:")
+                    compile_log.append(log_file.read()[-2000:])
             except IOError:
-                log_output = "Impossible de lire le fichier log de LaTeX."
-            return None, f"Le PDF n'a pas été généré après la compilation LaTeX.\n{log_output}"
-
-# --- Routes Flask ---
+                compile_log.append("Impossible de lire le fichier log de LaTeX.")
+            
+            return None, "\n".join(compile_log)
 
 @app.route('/')
 def index():
     return render_template('index.html')
 
-@app.route('/check_latex', methods=['GET'])
+@app.route('/check-latex')
 def check_latex():
-    latex_installed, message = check_latex_installation()
-    return jsonify({
-        'success': latex_installed,
-        'message': message
-    })
-
-@app.route('/check_api', methods=['GET'])
-def check_api():
-    client, message = initialize_genai_client()
+    latex_ok, message = check_latex_installation()
     return jsonify({
-        'success': client is not None,
-        'message': message
+        "success": latex_ok,
+        "message": message
     })
 
-@app.route('/process_image', methods=['POST'])
+@app.route('/process-image', methods=['POST'])
 def process_image():
     if 'image' not in request.files:
-        return jsonify({'success': False, 'message': 'Aucune image téléchargée'})
+        return jsonify({"success": False, "message": "Aucune image téléchargée"})
     
     file = request.files['image']
     if file.filename == '':
-        return jsonify({'success': False, 'message': 'Aucun fichier sélectionné'})
+        return jsonify({"success": False, "message": "Aucun fichier sélectionné"})
     
     try:
-        # Lecture de l'image
-        image_data = file.read()
-        image = Image.open(io.BytesIO(image_data))
-        
-        # Initialisation du client
+        # Initialisation du client GenAI
         client, client_message = initialize_genai_client()
         if not client:
-            return jsonify({'success': False, 'message': client_message})
+            return jsonify({"success": False, "message": client_message})
+        
+        # Traitement de l'image
+        image = Image.open(file.stream)
         
         # Génération du LaTeX
-        latex_content, thinking_content = generate_complete_latex(client, image)
+        latex_content, thinking_process, error_message = generate_complete_latex(client, image)
+        
         if not latex_content:
             return jsonify({
-                'success': False, 
-                'message': 'Échec de la génération de la solution LaTeX',
-                'thinking': thinking_content
+                "success": False,
+                "message": error_message or "Échec de la génération de la solution LaTeX"
             })
         
         # Compilation en PDF
         pdf_data, pdf_message = compile_latex_to_pdf(latex_content)
+        
         if not pdf_data:
             return jsonify({
-                'success': False, 
-                'message': f'Échec de la compilation PDF: {pdf_message}',
-                'latex': latex_content,
-                'thinking': thinking_content
+                "success": False,
+                "message": "Échec de la compilation PDF",
+                "latex": latex_content,
+                "thinking": thinking_process,
+                "compilation_log": pdf_message
             })
         
-        # Génération d'un ID unique pour le PDF
-        pdf_id = str(uuid.uuid4())
-        pdf_path = os.path.join(app.root_path, 'static', 'pdfs')
-        
-        # Créer le dossier s'il n'existe pas
-        os.makedirs(pdf_path, exist_ok=True)
-        
-        # Sauvegarder le PDF
-        full_pdf_path = os.path.join(pdf_path, f"{pdf_id}.pdf")
-        with open(full_pdf_path, 'wb') as f:
-            f.write(pdf_data)
-        
-        # Convertir l'image en base64 pour l'affichage
-        image_base64 = base64.b64encode(image_data).decode('utf-8')
+        # Convertir le PDF en base64 pour l'affichage dans le navigateur
+        pdf_base64 = base64.b64encode(pdf_data).decode('utf-8')
         
+        # Préparer les données de réponse
         return jsonify({
-            'success': True,
-            'message': 'PDF généré avec succès',
-            'pdf_url': f'/static/pdfs/{pdf_id}.pdf',
-            'latex': latex_content,
-            'thinking': thinking_content,
-            'image_base64': image_base64
+            "success": True,
+            "message": "PDF généré avec succès",
+            "latex": latex_content,
+            "thinking": thinking_process,
+            "pdf_base64": pdf_base64
         })
         
     except Exception as e:
-        app.logger.error(f"Erreur dans process_image: {e}")
-        return jsonify({'success': False, 'message': f'Erreur inattendue: {str(e)}'})
-
-@app.route('/download_pdf/<pdf_id>', methods=['GET'])
-def download_pdf(pdf_id):
-    # Vérifier que l'ID ne contient pas de caractères dangereux
-    if not pdf_id.isalnum() and '-' not in pdf_id:
-        return "ID PDF invalide", 400
+        return jsonify({
+            "success": False,
+            "message": f"Erreur lors du traitement: {str(e)}"
+        })
+
+@app.route('/download-pdf', methods=['POST'])
+def download_pdf():
+    # Récupérer le contenu LaTeX
+    latex_content = request.form.get('latex')
+    if not latex_content:
+        return jsonify({"success": False, "message": "Aucun contenu LaTeX fourni"})
+    
+    # Compiler en PDF
+    pdf_data, pdf_message = compile_latex_to_pdf(latex_content)
     
-    pdf_path = os.path.join(app.root_path, 'static', 'pdfs', f"{pdf_id}.pdf")
+    if not pdf_data:
+        return jsonify({"success": False, "message": pdf_message})
     
-    if not os.path.exists(pdf_path):
-        return "PDF introuvable", 404
+    # Créer un fichier temporaire pour le téléchargement
+    temp_pdf = tempfile.NamedTemporaryFile(delete=False)
+    temp_pdf.write(pdf_data)
+    temp_pdf.close()
     
-    return send_file(pdf_path, as_attachment=True, download_name="solution_mariam_ai.pdf")
+    return send_file(
+        temp_pdf.name,
+        as_attachment=True,
+        download_name="solution_mariam_ai.pdf",
+        mimetype="application/pdf"
+    )
 
 if __name__ == '__main__':
-    # Création du dossier pour les PDFs
-    os.makedirs(os.path.join(app.root_path, 'static', 'pdfs'), exist_ok=True)
-    
-    # Lancement de l'application
     app.run(debug=True)