Update app.py

app.py

@@ -12,6 +12,7 @@ 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__)
@@ -20,9 +21,10 @@ app = Flask(__name__)
 GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY")
 # IMPORTANT: For production, move these to environment variables or a secure config
 TELEGRAM_BOT_TOKEN = "8004545342:AAGcZaoDjYg8dmbbXRsR1N3TfSSbEiAGz88" 
-TELEGRAM_CHAT_ID = "-1002564204301"
+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)
@@ -143,43 +145,6 @@ 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 = {}
 
@@ -187,6 +152,7 @@ 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
@@ -199,15 +165,17 @@ 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()
+    return latex_code.strip() # Default to stripping whitespace if no fences found
 
 def latex_to_pdf(latex_code, output_filename_base="document"):
     """
@@ -218,6 +186,7 @@ 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)
@@ -228,23 +197,28 @@ 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" 
+            my_env["LC_ALL"] = "C.UTF-8" # Ensure UTF-8 locale for pdflatex
             my_env["LANG"] = "C.UTF-8"
             
             last_result = None
-            for i in range(2): 
+            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.
                 process = subprocess.run(
                     ["pdflatex", "-interaction=nonstopmode", "-output-directory", temp_dir_compile, tex_path],
-                    capture_output=True, 
-                    text=True,           
-                    check=False,         
-                    encoding="utf-8",    
-                    errors="replace",    
+                    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
                     env=my_env,
-                    timeout=120          
+                    timeout=120          # Timeout for pdflatex execution (e.g., 2 minutes)
                 )
                 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):
@@ -255,6 +229,7 @@ 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:
@@ -264,11 +239,12 @@ 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) 
+                    match = re.search(r"! LaTeX Error: (.*?)\n", error_log) # Get first line of error
                     if match:
                         return None, f"Erreur de compilation PDF: {match.group(1).strip()}"
                 
-                log_preview = error_log[-1000:] 
+                # Generic error if specific parsing fails
+                log_preview = error_log[-1000:] # Last 1000 characters of log for preview
                 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}"
         
@@ -283,9 +259,6 @@ 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)}
@@ -307,9 +280,6 @@ 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
@@ -317,11 +287,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: 
+        else: # Assuming text content
              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) 
+        response = requests.post(url, files=files, data=data, timeout=60) # Increased timeout for larger files
         
         if response.status_code == 200:
             print(f"Document '{filename}' envoyé avec succès à Telegram.")
@@ -337,7 +307,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, prompt_type="refined"):
+def process_image_background(task_id, image_data):
     """Traite l'image, génère LaTeX, convertit en PDF (si possible), et envoie via Telegram."""
     pdf_file_to_clean = None
     try:
@@ -347,70 +317,63 @@ def process_image_background(task_id, image_data, prompt_type="refined"):
             raise ConnectionError("Client Gemini non initialisé. Vérifiez la clé API et la configuration.")
 
         img = Image.open(io.BytesIO(image_data))
-        buffered_for_gemini = io.BytesIO()
-        img.save(buffered_for_gemini, format="PNG") 
-        img_bytes_for_gemini = buffered_for_gemini.getvalue()
+        buffered = io.BytesIO()
+        img.save(buffered, format="PNG") # Gemini prefers PNG or JPEG
+        img_base64_str = base64.b64encode(buffered.getvalue()).decode()
         
         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': base64.b64encode(img_bytes_for_gemini).decode()}},
-                    selected_prompt 
-                ],
-                generation_config={"response_mime_type": "text/plain"} 
+                    {'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)
             )
 
             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:
+                elif hasattr(candidate, 'text') and candidate.text: # Fallback for simpler candidate structure
                      full_latex_response = candidate.text
-            elif hasattr(gemini_response, 'text') and gemini_response.text: 
+            elif hasattr(gemini_response, 'text') and gemini_response.text: # Fallback for direct response.text
                 full_latex_response = gemini_response.text
             
             if not full_latex_response.strip():
-                raise ValueError("Mariam a retourné une réponse vide ou sans contenu textuel.")
+                raise ValueError("Gemini a retourné une réponse vide ou sans contenu textuel.")
             
             print(f"Task {task_id}: LaTeX brut reçu de Gemini (longueur: {len(full_latex_response)}).")
 
             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}_{prompt_type}.tex",
-                    caption=f"{caption_base} - Code LaTeX (pdflatex non dispo)"
+                    filename=f"solution_{task_id}.tex",
+                    caption=f"Code LaTeX pour tâche {task_id} (pdflatex non disponible)"
                 )
                 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}_{prompt_type}"
+            pdf_filename_base = f"solution_{task_id}"
             pdf_file_to_clean, pdf_message = latex_to_pdf(cleaned_latex, output_filename_base=pdf_filename_base)
 
             if pdf_file_to_clean:
@@ -418,59 +381,40 @@ def process_image_background(task_id, image_data, prompt_type="refined"):
                 send_document_to_telegram(
                     pdf_file_to_clean,
                     filename=f"{pdf_filename_base}.pdf",
-                    caption=f"{caption_base} - PDF",
+                    caption=f"Solution PDF pour tâche {task_id}",
                     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}" 
+                task_results[task_id]['error_detail'] = f"Erreur PDF: {pdf_message}" # Store PDF specific error
                 send_document_to_telegram(
                     cleaned_latex,
-                    filename=f"{pdf_filename_base}.tex",
-                    caption=f"{caption_base} - Code LaTeX (Erreur PDF: {pdf_message[:100]})"
+                    filename=f"solution_{task_id}.tex",
+                    caption=f"Code LaTeX pour tâche {task_id} (Erreur PDF: {pdf_message[:150]})"
                 )
+                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:
-            error_msg = f"Erreur lors de la génération Gemini ou traitement PDF: {e_gen}"
-            print(f"Task {task_id}: {error_msg}")
+            print(f"Task {task_id}: Erreur lors de la génération Gemini ou traitement PDF: {e_gen}")
             task_results[task_id]['status'] = 'error'
             task_results[task_id]['error'] = f"Erreur de traitement: {str(e_gen)}"
-            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']
+            # Optionally send a simple text error to Telegram
             send_document_to_telegram(
-                f"Erreur tâche {task_id}: {error_msg}\n\nLaTeX partiel (si disponible):\n{task_results[task_id].get('response','')}",
+                f"Erreur lors du traitement de la tâche {task_id}: {str(e_gen)}",
                 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:
-        error_msg = f"Exception majeure dans la tâche de fond: {e_outer}"
-        print(f"Task {task_id}: {error_msg}")
+        print(f"Task {task_id}: Exception majeure dans la tâche de fond: {e_outer}")
         task_results[task_id]['status'] = 'error'
         task_results[task_id]['error'] = 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']
+        task_results[task_id]['response'] = f"Erreur système: {str(e_outer)}"
     finally:
         if pdf_file_to_clean and os.path.exists(pdf_file_to_clean):
             try:
@@ -496,28 +440,25 @@ def solve():
 
         image_data = image_file.read()
         
-        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.")
+        # Envoyer l'image à Telegram (confirmation d'upload)
+        send_to_telegram(image_data, f"Nouvelle image pour résolution (Tâche à venir)")
         
         task_id = str(uuid.uuid4())
         task_results[task_id] = {
             'status': 'pending',
             'response': '',
             'error': None,
-            'error_detail': None, # Pour les erreurs spécifiques PDF
-            'time_started': time.time(),
-            'prompt_type': prompt_type 
+            'time_started': time.time()
         }
         
         threading.Thread(
             target=process_image_background,
-            args=(task_id, image_data, prompt_type)
+            args=(task_id, image_data)
         ).start()
         
         return jsonify({
             'task_id': task_id,
-            'status': 'pending' # Le statut initial est pending, le thread mettra à jour
+            'status': 'pending'
         })
 
     except Exception as e:
@@ -531,12 +472,21 @@ 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_detail': task.get('error_detail')
+        'error': task.get('error')
     }
+    if task.get('error_detail'): # Include PDF specific error if present
+        response_data['error_detail'] = task.get('error_detail')
         
     return jsonify(response_data)
 
@@ -548,16 +498,9 @@ 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: 
+            if not task: # Task might have been cleaned up
                 yield f'data: {json.dumps({"error": "Tâche disparue ou nettoyée", "status": "error"})}\n\n'
                 break
             
@@ -565,31 +508,29 @@ def stream_task_progress(task_id):
             
             if current_status != last_status_sent:
                 data_to_send = {"status": current_status}
-                if current_status in ['completed', 'completed_tex_only', 'pdf_error']:
+                if current_status == 'completed' or current_status == 'completed_tex_only':
                     data_to_send["response"] = task.get("response", "")
-                if current_status in ['error', 'pdf_error']: # S'il y a une erreur générale ou spécifique au PDF
+                elif current_status == 'error' or current_status == 'pdf_error':
                     data_to_send["error"] = task.get("error", "Erreur inconnue")
                     if task.get("error_detail"):
                          data_to_send["error_detail"] = task.get("error_detail")
-                    # 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"): 
+                    if task.get("response"): # Send partial response if available on error
                         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 
+                break # End stream for terminal states
             
-            time.sleep(1) 
+            time.sleep(1) # Check status every second
     
     return Response(
         stream_with_context(generate()),
         mimetype='text/event-stream',
         headers={
             'Cache-Control': 'no-cache',
-            'X-Accel-Buffering': 'no', 
+            'X-Accel-Buffering': 'no', # Important for Nginx or other reverse proxies
             'Connection': 'keep-alive'
         }
     )
@@ -599,10 +540,6 @@ 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)