Update app.py

app.py

@@ -12,7 +12,6 @@ import time
 import tempfile # Added
 import subprocess # Added
 import shutil # Added
-# import platform # Not strictly needed for app.py modifications
 import re # Added
 
 app = Flask(__name__)
@@ -24,7 +23,6 @@ TELEGRAM_BOT_TOKEN = "8004545342:AAGcZaoDjYg8dmbbXRsR1N3TfSSbEiAGz88"
 TELEGRAM_CHAT_ID = "-1002497861230"
 
 # Initialize Gemini client
-# Assuming genai.Client and client.models.generate_content are part of user's specific library setup
 if GOOGLE_API_KEY:
     try:
         client = genai.Client(api_key=GOOGLE_API_KEY)
@@ -145,6 +143,43 @@ rend  le très espacer. Ça doit être très aéré
 
 """
 
+PPMQTH_LIGHT = r"""
+# RÔLE & OBJECTIF
+Tu es un expert en mathématiques capable de fournir une solution claire et concise. Ton objectif est de générer une correction LaTeX directement compilable pour l'exercice fourni.
+
+# CONTEXTE
+*   **Input:** L'énoncé de l'exercice (texte).
+*   **Niveau Cible:** Terminale (scientifique).
+*   **Output Attendu:** **Uniquement** le code source LaTeX (`.tex`) brut et complet. Pas de texte d'accompagnement en dehors du code.
+
+# TÂCHE PRINCIPALE
+1.  **Analyse:** Comprends l'énoncé.
+2.  **Résolution:** Résous l'exercice.
+3.  **Rédaction LaTeX:** Rédige la solution en LaTeX standard.
+
+# SPÉCIFICATIONS TECHNIQUES DU CODE LATEX (Minimal)
+*   Classe: `\documentclass[12pt,a4paper]{article}`
+*   Encodage: `\usepackage[utf8]{inputenc}`, `\usepackage[T1]{fontenc}`
+*   Langue: `\usepackage[french]{babel}`
+*   Maths: `\usepackage{amsmath}`, `\usepackage{amssymb}`
+*   Optionnel: `\usepackage{graphicx}` si l'énoncé peut contenir des schémas à reproduire (rare pour du texte).
+*   Pas de packages de mise en page complexes (pas de tcolorbox, fancyhdr, tikz, etc. sauf si *absolument* indispensable pour représenter la solution mathématique elle-même).
+*   Utilise des environnements mathématiques standards (`align*`, `equation*`, `\[ ... \]`).
+
+# CONTENU PÉDAGOGIQUE DE LA SOLUTION
+*   Rappeler l'énoncé.
+*   Structurer la solution logiquement.
+*   Justifier les étapes principales.
+*   Langage mathématique précis.
+
+# CONTRAINTES STRICTES
+*   Le seul output doit être le code LaTeX brut.
+*   Aucun texte avant `\documentclass` ou après `\end{document}`.
+*   Inclure la ligne `Concu par Mariam AI` juste avant `\end{document}`.
+*   L'objectif est une solution fonctionnelle et lisible, sans mise en page sophistiquée.
+"""
+
+
 # Dictionnaire pour stocker les résultats des tâches en cours
 task_results = {}
 
@@ -152,7 +187,6 @@ task_results = {}
 def check_latex_installation():
     """Vérifie si pdflatex est installé sur le système"""
     try:
-        # Using timeout to prevent hanging if pdflatex is unresponsive
         subprocess.run(["pdflatex", "-version"], capture_output=True, check=True, timeout=10)
         print("INFO: pdflatex est installé et accessible.")
         return True
@@ -165,17 +199,15 @@ IS_LATEX_INSTALLED = check_latex_installation()
 
 def clean_latex_code(latex_code):
     """Removes markdown code block fences (```latex ... ``` or ``` ... ```) if present."""
-    # Pattern for ```latex ... ```
     match_latex = re.search(r"```(?:latex|tex)\s*(.*?)\s*```", latex_code, re.DOTALL | re.IGNORECASE)
     if match_latex:
         return match_latex.group(1).strip()
     
-    # Pattern for generic ``` ... ```, checking if it likely contains LaTeX
     match_generic = re.search(r"```\s*(\\documentclass.*?)\s*```", latex_code, re.DOTALL | re.IGNORECASE)
     if match_generic:
         return match_generic.group(1).strip()
         
-    return latex_code.strip() # Default to stripping whitespace if no fences found
+    return latex_code.strip()
 
 def latex_to_pdf(latex_code, output_filename_base="document"):
     """
@@ -186,7 +218,6 @@ def latex_to_pdf(latex_code, output_filename_base="document"):
     if not IS_LATEX_INSTALLED:
         return None, "pdflatex n'est pas disponible sur le système."
 
-    # Create a temporary directory for LaTeX compilation files
     with tempfile.TemporaryDirectory() as temp_dir_compile:
         tex_filename = f"{output_filename_base}.tex"
         tex_path = os.path.join(temp_dir_compile, tex_filename)
@@ -197,28 +228,23 @@ def latex_to_pdf(latex_code, output_filename_base="document"):
                 tex_file.write(latex_code)
             
             my_env = os.environ.copy()
-            my_env["LC_ALL"] = "C.UTF-8" # Ensure UTF-8 locale for pdflatex
+            my_env["LC_ALL"] = "C.UTF-8" 
             my_env["LANG"] = "C.UTF-8"
             
             last_result = None
-            for i in range(2): # Run pdflatex twice for references, TOC, etc.
-                # Added -file-line-error for more precise error messages
-                # Added -halt-on-error to stop on first error (more efficient)
-                # Note: -halt-on-error might prevent a second pass that could fix some issues.
-                # For robustness, -interaction=nonstopmode is often preferred to try to complete.
+            for i in range(2): 
                 process = subprocess.run(
                     ["pdflatex", "-interaction=nonstopmode", "-output-directory", temp_dir_compile, tex_path],
-                    capture_output=True, # Capture stdout and stderr
-                    text=True,           # Decode output as text
-                    check=False,         # Do not raise exception on non-zero exit code
-                    encoding="utf-8",    # Specify encoding for output decoding
-                    errors="replace",    # Replace undecodable characters
+                    capture_output=True, 
+                    text=True,           
+                    check=False,         
+                    encoding="utf-8",    
+                    errors="replace",    
                     env=my_env,
-                    timeout=120          # Timeout for pdflatex execution (e.g., 2 minutes)
+                    timeout=120          
                 )
                 last_result = process
                 if not os.path.exists(pdf_path_in_compile_dir) and process.returncode != 0:
-                    # If PDF not created and there was an error, no point in second pass
                     break
             
             if os.path.exists(pdf_path_in_compile_dir):
@@ -229,7 +255,6 @@ def latex_to_pdf(latex_code, output_filename_base="document"):
             else:
                 error_log = last_result.stdout + "\n" + last_result.stderr if last_result else "Aucun résultat de compilation."
                 
-                # Try to extract more specific error messages
                 if "LaTeX Error: File `" in error_log:
                     match = re.search(r"LaTeX Error: File `(.*?)' not found.", error_log)
                     if match:
@@ -239,12 +264,11 @@ def latex_to_pdf(latex_code, output_filename_base="document"):
                      return None, "Erreur de compilation PDF: Commande LaTeX non définie. Vérifiez le code LaTeX pour des erreurs de syntaxe."
 
                 if "! LaTeX Error:" in error_log:
-                    match = re.search(r"! LaTeX Error: (.*?)\n", error_log) # Get first line of error
+                    match = re.search(r"! LaTeX Error: (.*?)\n", error_log) 
                     if match:
                         return None, f"Erreur de compilation PDF: {match.group(1).strip()}"
                 
-                # Generic error if specific parsing fails
-                log_preview = error_log[-1000:] # Last 1000 characters of log for preview
+                log_preview = error_log[-1000:] 
                 print(f"Erreur de compilation PDF complète pour {output_filename_base}:\n{error_log}")
                 return None, f"Erreur lors de la compilation du PDF. Détails dans les logs du serveur. Aperçu: ...{log_preview}"
         
@@ -259,6 +283,9 @@ def latex_to_pdf(latex_code, output_filename_base="document"):
 # --- Telegram Functions ---
 def send_to_telegram(image_data, caption="Nouvelle image uploadée"):
     """Envoie l'image à un chat Telegram spécifié"""
+    if not TELEGRAM_BOT_TOKEN or not TELEGRAM_CHAT_ID:
+        print("AVERTISSEMENT: TELEGRAM_BOT_TOKEN ou TELEGRAM_CHAT_ID non configuré. Envoi Telegram désactivé.")
+        return False
     try:
         url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendPhoto"
         files = {'photo': ('image.png', image_data)}
@@ -280,6 +307,9 @@ def send_to_telegram(image_data, caption="Nouvelle image uploadée"):
 
 def send_document_to_telegram(content_or_path, filename="reponse.txt", caption="Réponse", is_pdf=False):
     """Envoie un fichier (texte ou PDF) à un chat Telegram spécifié"""
+    if not TELEGRAM_BOT_TOKEN or not TELEGRAM_CHAT_ID:
+        print("AVERTISSEMENT: TELEGRAM_BOT_TOKEN ou TELEGRAM_CHAT_ID non configuré. Envoi Telegram désactivé.")
+        return False
     try:
         url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendDocument"
         files = None
@@ -287,11 +317,11 @@ def send_document_to_telegram(content_or_path, filename="reponse.txt", caption="
         if is_pdf:
             with open(content_or_path, 'rb') as f_pdf:
                 files = {'document': (filename, f_pdf.read(), 'application/pdf')}
-        else: # Assuming text content
+        else: 
              files = {'document': (filename, content_or_path.encode('utf-8'), 'text/plain')}
         
         data = {'chat_id': TELEGRAM_CHAT_ID, 'caption': caption}
-        response = requests.post(url, files=files, data=data, timeout=60) # Increased timeout for larger files
+        response = requests.post(url, files=files, data=data, timeout=60) 
         
         if response.status_code == 200:
             print(f"Document '{filename}' envoyé avec succès à Telegram.")
@@ -307,7 +337,7 @@ def send_document_to_telegram(content_or_path, filename="reponse.txt", caption="
         return False
 
 # --- Background Image Processing ---
-def process_image_background(task_id, image_data):
+def process_image_background(task_id, image_data, prompt_type="refined"):
     """Traite l'image, génère LaTeX, convertit en PDF (si possible), et envoie via Telegram."""
     pdf_file_to_clean = None
     try:
@@ -317,38 +347,43 @@ def process_image_background(task_id, image_data):
             raise ConnectionError("Client Gemini non initialisé. Vérifiez la clé API et la configuration.")
 
         img = Image.open(io.BytesIO(image_data))
-        buffered = io.BytesIO()
-        img.save(buffered, format="PNG") # Gemini prefers PNG or JPEG
-        img_base64_str = base64.b64encode(buffered.getvalue()).decode()
+        buffered_for_gemini = io.BytesIO()
+        img.save(buffered_for_gemini, format="PNG") 
+        img_bytes_for_gemini = buffered_for_gemini.getvalue()
         
         full_latex_response = ""
         
+        selected_prompt = ppmqth
+        if prompt_type == "light":
+            selected_prompt = PPMQTH_LIGHT
+            print(f"Task {task_id}: Utilisation du prompt LÉGER.")
+        else:
+            print(f"Task {task_id}: Utilisation du prompt RAFFINÉ ET COMPLET.")
+
         try:
             task_results[task_id]['status'] = 'generating_latex'
             print(f"Task {task_id}: Génération LaTeX par Gemini...")
             
-            # User's original model: "gemini-2.5-pro-exp-03-25"
-            # Using "gemini-1.5-pro-latest" as a robust alternative. User can change if needed.
-            # The user's original Gemini call structure:
             gemini_response = client.models.generate_content(
                 model="gemini-2.5-pro-exp-03-25", 
                 contents=[
-                    {'inline_data': {'mime_type': 'image/png', 'data': img_base64_str}},
-                    ppmqth 
-                ]
-                # Consider adding generation_config for token limits, temperature if needed
-                # generation_config=genai.types.GenerationConfig(max_output_tokens=8192)
+                     {'inline_data': {'mime_type': 'image/png', 'data': base64.b64encode(img_bytes_for_gemini).decode()}},
+                    selected_prompt 
+                ],
+                generation_config={"response_mime_type": "text/plain"} 
             )
 
             if gemini_response.candidates:
                 candidate = gemini_response.candidates[0]
+                if candidate.finish_reason.name == "SAFETY": # Check for safety blocking
+                     raise genai.types.BlockedPromptException("Contenu bloqué pour des raisons de sécurité.")
                 if candidate.content and candidate.content.parts:
                     for part in candidate.content.parts:
                         if hasattr(part, 'text') and part.text:
                             full_latex_response += part.text
-                elif hasattr(candidate, 'text') and candidate.text: # Fallback for simpler candidate structure
+                elif hasattr(candidate, 'text') and candidate.text:
                      full_latex_response = candidate.text
-            elif hasattr(gemini_response, 'text') and gemini_response.text: # Fallback for direct response.text
+            elif hasattr(gemini_response, 'text') and gemini_response.text: 
                 full_latex_response = gemini_response.text
             
             if not full_latex_response.strip():
@@ -359,21 +394,23 @@ def process_image_background(task_id, image_data):
             task_results[task_id]['status'] = 'cleaning_latex'
             cleaned_latex = clean_latex_code(full_latex_response)
             print(f"Task {task_id}: LaTeX nettoyé (longueur: {len(cleaned_latex)}).")
+            task_results[task_id]['response'] = cleaned_latex 
+
+            caption_base = f"Solution tâche {task_id} (Style: {prompt_type})"
 
             if not IS_LATEX_INSTALLED:
                 print(f"Task {task_id}: pdflatex non disponible. Envoi du .tex uniquement.")
                 send_document_to_telegram(
                     cleaned_latex,
-                    filename=f"solution_{task_id}.tex",
-                    caption=f"Code LaTeX pour tâche {task_id} (pdflatex non disponible)"
+                    filename=f"solution_{task_id}_{prompt_type}.tex",
+                    caption=f"{caption_base} - Code LaTeX (pdflatex non dispo)"
                 )
                 task_results[task_id]['status'] = 'completed_tex_only'
-                task_results[task_id]['response'] = cleaned_latex
                 return
 
             task_results[task_id]['status'] = 'generating_pdf'
             print(f"Task {task_id}: Génération du PDF...")
-            pdf_filename_base = f"solution_{task_id}"
+            pdf_filename_base = f"solution_{task_id}_{prompt_type}"
             pdf_file_to_clean, pdf_message = latex_to_pdf(cleaned_latex, output_filename_base=pdf_filename_base)
 
             if pdf_file_to_clean:
@@ -381,40 +418,59 @@ def process_image_background(task_id, image_data):
                 send_document_to_telegram(
                     pdf_file_to_clean,
                     filename=f"{pdf_filename_base}.pdf",
-                    caption=f"Solution PDF pour tâche {task_id}",
+                    caption=f"{caption_base} - PDF",
                     is_pdf=True
                 )
                 task_results[task_id]['status'] = 'completed'
-                task_results[task_id]['response'] = cleaned_latex # Web UI still gets LaTeX source
             else:
                 print(f"Task {task_id}: Échec de la génération PDF: {pdf_message}. Envoi du .tex en fallback.")
                 task_results[task_id]['status'] = 'pdf_error'
-                task_results[task_id]['error_detail'] = f"Erreur PDF: {pdf_message}" # Store PDF specific error
+                task_results[task_id]['error_detail'] = f"Erreur PDF: {pdf_message}" 
                 send_document_to_telegram(
                     cleaned_latex,
-                    filename=f"solution_{task_id}.tex",
-                    caption=f"Code LaTeX pour tâche {task_id} (Erreur PDF: {pdf_message[:150]})"
+                    filename=f"{pdf_filename_base}.tex",
+                    caption=f"{caption_base} - Code LaTeX (Erreur PDF: {pdf_message[:100]})"
                 )
-                task_results[task_id]['response'] = cleaned_latex # Web UI gets LaTeX source
         
+        except genai.types.BlockedPromptException as e_blocked:
+            error_msg = f"Prompt ou image bloqué par le filtre de sécurité Gemini: {e_blocked}"
+            print(f"Task {task_id}: {error_msg}")
+            task_results[task_id]['status'] = 'error'
+            task_results[task_id]['error'] = "Le prompt ou l'image a été bloqué par le filtre de sécurité de l'IA. Essayez une autre image ou un prompt différent."
+            if not task_results[task_id].get('response'):
+                task_results[task_id]['response'] = task_results[task_id]['error']
+            send_document_to_telegram(
+                f"Erreur tâche {task_id}: {error_msg}",
+                filename=f"error_{task_id}.txt",
+                caption=f"Erreur Tâche {task_id} - Prompt Bloqué"
+            )
         except Exception as e_gen:
-            print(f"Task {task_id}: Erreur lors de la génération Gemini ou traitement PDF: {e_gen}")
+            error_msg = f"Erreur lors de la génération Gemini ou traitement PDF: {e_gen}"
+            print(f"Task {task_id}: {error_msg}")
             task_results[task_id]['status'] = 'error'
             task_results[task_id]['error'] = f"Erreur de traitement: {str(e_gen)}"
-            # Optionally send a simple text error to Telegram
+            if not task_results[task_id].get('response'): # S'il n'y a pas de LaTeX partiel
+                 task_results[task_id]['response'] = task_results[task_id]['error']
             send_document_to_telegram(
-                f"Erreur lors du traitement de la tâche {task_id}: {str(e_gen)}",
+                f"Erreur tâche {task_id}: {error_msg}\n\nLaTeX partiel (si disponible):\n{task_results[task_id].get('response','')}",
                 filename=f"error_{task_id}.txt",
                 caption=f"Erreur Tâche {task_id}"
             )
-            task_results[task_id]['response'] = f"Erreur: {str(e_gen)}"
 
+    except ConnectionError as e_conn:
+        error_msg = f"Erreur de connexion Gemini: {e_conn}"
+        print(f"Task {task_id}: {error_msg}")
+        task_results[task_id]['status'] = 'error'
+        task_results[task_id]['error'] = str(e_conn)
+        task_results[task_id]['response'] = str(e_conn) # Mettre l'erreur dans response pour affichage
 
     except Exception as e_outer:
-        print(f"Task {task_id}: Exception majeure dans la tâche de fond: {e_outer}")
+        error_msg = f"Exception majeure dans la tâche de fond: {e_outer}"
+        print(f"Task {task_id}: {error_msg}")
         task_results[task_id]['status'] = 'error'
         task_results[task_id]['error'] = f"Erreur système: {str(e_outer)}"
-        task_results[task_id]['response'] = f"Erreur système: {str(e_outer)}"
+        if not task_results[task_id].get('response'):
+            task_results[task_id]['response'] = task_results[task_id]['error']
     finally:
         if pdf_file_to_clean and os.path.exists(pdf_file_to_clean):
             try:
@@ -440,25 +496,28 @@ def solve():
 
         image_data = image_file.read()
         
-        # Envoyer l'image à Telegram (confirmation d'upload)
-        send_to_telegram(image_data, f"Nouvelle image pour résolution (Tâche à venir)")
+        prompt_type = request.form.get('prompt_type', 'refined') 
+        
+        send_to_telegram(image_data, f"Nouvelle image pour résolution (Style: {prompt_type}). Tâche à venir.")
         
         task_id = str(uuid.uuid4())
         task_results[task_id] = {
             'status': 'pending',
             'response': '',
             'error': None,
-            'time_started': time.time()
+            'error_detail': None, # Pour les erreurs spécifiques PDF
+            'time_started': time.time(),
+            'prompt_type': prompt_type 
         }
         
         threading.Thread(
             target=process_image_background,
-            args=(task_id, image_data)
+            args=(task_id, image_data, prompt_type)
         ).start()
         
         return jsonify({
             'task_id': task_id,
-            'status': 'pending'
+            'status': 'pending' # Le statut initial est pending, le thread mettra à jour
         })
 
     except Exception as e:
@@ -472,21 +531,12 @@ def get_task_status(task_id):
     
     task = task_results[task_id]
     
-    # Basic cleanup logic (can be improved with a dedicated cleanup thread)
-    current_time = time.time()
-    if task['status'] in ['completed', 'error', 'pdf_error', 'completed_tex_only'] and \
-       (current_time - task.get('time_started', 0) > 3600): # Cleanup after 1 hour
-        # del task_results[task_id] # Potentially remove, or mark for removal
-        # For now, just don't error if it's old
-        pass 
-    
     response_data = {
         'status': task['status'],
         'response': task.get('response'),
-        'error': task.get('error')
+        'error': task.get('error'),
+        'error_detail': task.get('error_detail')
     }
-    if task.get('error_detail'): # Include PDF specific error if present
-        response_data['error_detail'] = task.get('error_detail')
         
     return jsonify(response_data)
 
@@ -498,9 +548,16 @@ def stream_task_progress(task_id):
             return
         
         last_status_sent = None
+        timeout_start = time.time() # Pour éviter que le stream ne dure indéfiniment
+        MAX_STREAM_DURATION = 300 # 5 minutes max pour le stream
+
         while True:
+            if time.time() - timeout_start > MAX_STREAM_DURATION:
+                yield f'data: {json.dumps({"error": "Timeout du stream de statut", "status": "error"})}\n\n'
+                break
+
             task = task_results.get(task_id)
-            if not task: # Task might have been cleaned up
+            if not task: 
                 yield f'data: {json.dumps({"error": "Tâche disparue ou nettoyée", "status": "error"})}\n\n'
                 break
             
@@ -508,29 +565,31 @@ def stream_task_progress(task_id):
             
             if current_status != last_status_sent:
                 data_to_send = {"status": current_status}
-                if current_status == 'completed' or current_status == 'completed_tex_only':
+                if current_status in ['completed', 'completed_tex_only', 'pdf_error']:
                     data_to_send["response"] = task.get("response", "")
-                elif current_status == 'error' or current_status == 'pdf_error':
+                if current_status in ['error', 'pdf_error']: # S'il y a une erreur générale ou spécifique au PDF
                     data_to_send["error"] = task.get("error", "Erreur inconnue")
                     if task.get("error_detail"):
                          data_to_send["error_detail"] = task.get("error_detail")
-                    if task.get("response"): # Send partial response if available on error
+                    # Envoyer aussi la réponse (LaTeX partiel) s'il y en a une, même en cas d'erreur PDF
+                    if task.get("response") and not data_to_send.get("response"): 
                         data_to_send["response"] = task.get("response")
 
+
                 yield f'data: {json.dumps(data_to_send)}\n\n'
                 last_status_sent = current_status
             
             if current_status in ['completed', 'error', 'pdf_error', 'completed_tex_only']:
-                break # End stream for terminal states
+                break 
             
-            time.sleep(1) # Check status every second
+            time.sleep(1) 
     
     return Response(
         stream_with_context(generate()),
         mimetype='text/event-stream',
         headers={
             'Cache-Control': 'no-cache',
-            'X-Accel-Buffering': 'no', # Important for Nginx or other reverse proxies
+            'X-Accel-Buffering': 'no', 
             'Connection': 'keep-alive'
         }
     )
@@ -540,6 +599,10 @@ if __name__ == '__main__':
         print("CRITICAL: GEMINI_API_KEY variable d'environnement non définie. L'application risque de ne pas fonctionner.")
     if not TELEGRAM_BOT_TOKEN or not TELEGRAM_CHAT_ID:
         print("CRITICAL: TELEGRAM_BOT_TOKEN ou TELEGRAM_CHAT_ID non définis. L'intégration Telegram échouera.")
+    else:
+        print(f"INFO: Prêt à envoyer des notifications Telegram au CHAT_ID: {TELEGRAM_CHAT_ID}")
+    
+    print(f"INFO: LaTeX est {'installé et activé' if IS_LATEX_INSTALLED else 'NON installé/activé. Les PDFs ne seront pas générés.'}")
     
     # For production, use a proper WSGI server like Gunicorn or uWSGI
     app.run(debug=True, host='0.0.0.0', port=5000)