Update app.py

app.py

@@ -13,7 +13,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__)
@@ -25,7 +24,6 @@ TELEGRAM_BOT_TOKEN = "8004545342:AAGcZaoDjYg8dmbbXRsR1N3TfSSbEiAGz88"
 TELEGRAM_CHAT_ID = "-1002564204301"
 
 # 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)
@@ -67,7 +65,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
@@ -117,23 +114,17 @@ def latex_to_pdf(latex_code, output_filename_base="document"):
             
             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.
                 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 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):
@@ -144,7 +135,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:
@@ -154,12 +144,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}"
         
@@ -170,27 +159,33 @@ def latex_to_pdf(latex_code, output_filename_base="document"):
             print(f"Exception inattendue lors de la génération du PDF ({output_filename_base}): {e}")
             return None, f"Exception inattendue lors de la génération du PDF: {str(e)}"
 
-
 # --- Telegram Functions ---
-def send_to_telegram(image_data, caption="Nouvelle image uploadée"):
-    """Envoie l'image à un chat Telegram spécifié"""
+def send_to_telegram(file_data, filename, caption="Nouveau fichier uploadé"):
+    """Envoie un fichier (image ou PDF) à un chat Telegram spécifié"""
     try:
-        url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendPhoto"
-        files = {'photo': ('image.png', image_data)}
+        if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.webp')):
+            # Envoyer comme photo
+            url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendPhoto"
+            files = {'photo': (filename, file_data)}
+        else:
+            # Envoyer comme document
+            url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendDocument"
+            files = {'document': (filename, file_data)}
+        
         data = {'chat_id': TELEGRAM_CHAT_ID, 'caption': caption}
         response = requests.post(url, files=files, data=data, timeout=30)
         
         if response.status_code == 200:
-            print("Image envoyée avec succès à Telegram")
+            print(f"Fichier '{filename}' envoyé avec succès à Telegram")
             return True
         else:
-            print(f"Erreur lors de l'envoi à Telegram: {response.status_code} - {response.text}")
+            print(f"Erreur lors de l'envoi de '{filename}' à Telegram: {response.status_code} - {response.text}")
             return False
     except requests.exceptions.RequestException as e:
-        print(f"Exception Request lors de l'envoi à Telegram: {e}")
+        print(f"Exception Request lors de l'envoi de '{filename}' à Telegram: {e}")
         return False
     except Exception as e:
-        print(f"Exception générale lors de l'envoi à Telegram: {e}")
+        print(f"Exception générale lors de l'envoi de '{filename}' à Telegram: {e}")
         return False
 
 def send_document_to_telegram(content_or_path, filename="reponse.txt", caption="Réponse", is_pdf=False):
@@ -206,7 +201,7 @@ def send_document_to_telegram(content_or_path, filename="reponse.txt", caption="
              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.")
@@ -215,45 +210,90 @@ def send_document_to_telegram(content_or_path, filename="reponse.txt", caption="
             print(f"Erreur lors de l'envoi du document '{filename}' à Telegram: {response.status_code} - {response.text}")
             return False
     except requests.exceptions.RequestException as e:
-        print(f"Exception Request lors de l'envoi du document '{filename}' à Telegram: {e}")
+        print(f"Exception Request lors de l'envoi du document '{filename}' à Telegram: ")
         return False
     except Exception as e:
-        print(f"Exception générale lors de l'envoi du document '{filename}' à Telegram: {e}")
+        print(f"Exception générale lors de l'envoi du document '{filename}' à Telegram:")
         return False
 
-# --- Background Image Processing ---
-def process_image_background(task_id, image_data, resolution_style='colorful'):
-    """Traite l'image, génère LaTeX, convertit en PDF (si possible), et envoie via Telegram."""
+# --- Background File Processing ---
+def process_files_background(task_id, files_data, resolution_style='colorful'):
+    """Traite les fichiers (images + PDF), génère LaTeX, convertit en PDF, et envoie via Telegram."""
     pdf_file_to_clean = None
+    uploaded_file_refs = []
+    
     try:
         task_results[task_id]['status'] = 'processing'
         
         if not client:
             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")
-        img_base64_str = base64.b64encode(buffered.getvalue()).decode()
+        # Préparer le contenu pour Gemini
+        contents = []
+        
+        # Traiter chaque fichier
+        for file_info in files_data:
+            filename = file_info['filename']
+            file_data = file_info['data']
+            file_type = file_info['type']
+            
+            if file_type.startswith('image/'):
+                # Traitement des images (comme avant)
+                img = Image.open(io.BytesIO(file_data))
+                buffered = io.BytesIO()
+                img.save(buffered, format="PNG")
+                img_base64_str = base64.b64encode(buffered.getvalue()).decode()
+                
+                contents.append({
+                    'inline_data': {
+                        'mime_type': 'image/png', 
+                        'data': img_base64_str
+                    }
+                })
+                
+            elif file_type == 'application/pdf':
+                # Upload du PDF vers l'API Gemini
+                try:
+                    # Créer un fichier temporaire pour le PDF
+                    with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as temp_pdf:
+                        temp_pdf.write(file_data)
+                        temp_pdf_path = temp_pdf.name
+                    
+                    # Upload vers l'API Gemini
+                    file_ref = client.files.upload(file=temp_pdf_path)
+                    uploaded_file_refs.append(file_ref)
+                    contents.append(file_ref)
+                    
+                    # Nettoyer le fichier temporaire
+                    os.unlink(temp_pdf_path)
+                    
+                    print(f"Task {task_id}: PDF '{filename}' uploadé vers Gemini avec succès")
+                    
+                except Exception as e:
+                    print(f"Task {task_id}: Erreur lors de l'upload du PDF '{filename}': {e}")
+                    raise ValueError(f"Impossible d'uploader le PDF '{filename}': {str(e)}")
+        
+        if not contents:
+            raise ValueError("Aucun contenu valide trouvé dans les fichiers uploadés")
+        
+        # Ajouter le prompt à la fin
+        prompt_to_use = get_prompt_for_style(resolution_style)
+        if not prompt_to_use:
+            raise ValueError(f"Impossible de charger le prompt pour le style '{resolution_style}'")
+        
+        contents.append(prompt_to_use)
         
         full_latex_response = ""
         
         try:
             task_results[task_id]['status'] = 'generating_latex'
             print(f"Task {task_id}: Génération LaTeX par Gemini (style: {resolution_style})...")
-            
-            # Charger le prompt approprié depuis le fichier
-            prompt_to_use = get_prompt_for_style(resolution_style)
-            if not prompt_to_use:
-                raise ValueError(f"Impossible de charger le prompt pour le style '{resolution_style}'")
+            print(f"Task {task_id}: Nombre d'éléments de contenu: {len(contents)}")
             
             gemini_response = client.models.generate_content(
-                model="gemini-2.5-flash-preview-04-17", 
-                contents=[
-                    {'inline_data': {'mime_type': 'image/png', 'data': img_base64_str}},
-                    prompt_to_use 
-                ],)
-                
+                model="gemini-2.5-flash-preview-05-20",  # Utilisation du modèle recommandé pour PDF
+                contents=contents
+            )
 
             if gemini_response.candidates:
                 candidate = gemini_response.candidates[0]
@@ -261,9 +301,9 @@ def process_image_background(task_id, image_data, resolution_style='colorful'):
                     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():
@@ -300,43 +340,51 @@ def process_image_background(task_id, image_data, resolution_style='colorful'):
                     is_pdf=True
                 )
                 task_results[task_id]['status'] = 'completed'
-                task_results[task_id]['response'] = cleaned_latex # Web UI still gets LaTeX source
+                task_results[task_id]['response'] = cleaned_latex
             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]})"
                 )
-                task_results[task_id]['response'] = cleaned_latex # Web UI gets LaTeX source
+                task_results[task_id]['response'] = cleaned_latex
         
         except Exception as e_gen:
             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)}"
-            # Optionally send a simple text error to Telegram
+            task_results[task_id]['error'] = f"Erreur de traitement: "
             send_document_to_telegram(
-                f"Erreur lors du traitement de la tâche {task_id}: {str(e_gen)}",
+                f"Erreur lors du traitement de la tâche {task_id}: ",
                 filename=f"error_{task_id}.txt",
                 caption=f"Erreur tâche {task_id}"
             )
             task_results[task_id]['response'] = f"Erreur: {str(e_gen)}"
 
-
     except Exception as e_outer:
         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)}"
         task_results[task_id]['response'] = f"Erreur système: {str(e_outer)}"
     finally:
+        # Nettoyer les fichiers temporaires
         if pdf_file_to_clean and os.path.exists(pdf_file_to_clean):
             try:
                 os.remove(pdf_file_to_clean)
                 print(f"Task {task_id}: Fichier PDF temporaire '{pdf_file_to_clean}' supprimé.")
             except Exception as e_clean:
                 print(f"Task {task_id}: Erreur lors de la suppression du PDF temporaire '{pdf_file_to_clean}': {e_clean}")
+        
+        # Nettoyer les références de fichiers uploadés (optionnel, ils expirent automatiquement)
+        for file_ref in uploaded_file_refs:
+            try:
+                # Les fichiers uploadés vers l'API Gemini expirent automatiquement
+                # mais on peut les supprimer explicitement si nécessaire
+                pass
+            except Exception as e_del:
+                print(f"Task {task_id}: Erreur lors de la suppression de la référence de fichier:")
 
 # --- Flask Routes ---
 @app.route('/')
@@ -346,26 +394,74 @@ def index():
 @app.route('/free')
 def free():
     return render_template('index.html')
-    
 
 @app.route('/solve', methods=['POST'])
 def solve():
     try:
-        if 'image' not in request.files:
-            return jsonify({'error': 'Aucun fichier image fourni'}), 400
+        # Vérifier si des fichiers ont été envoyés
+        if 'user_files' not in request.files:
+            return jsonify({'error': 'Aucun fichier fourni'}), 400
         
-        image_file = request.files['image']
-        if image_file.filename == '':
+        uploaded_files = request.files.getlist('user_files')
+        if not uploaded_files or all(f.filename == '' for f in uploaded_files):
             return jsonify({'error': 'Aucun fichier sélectionné'}), 400
 
         # Récupérer le style de résolution
-        resolution_style = request.form.get('style', 'colorful')  # 'colorful' par défaut
+        resolution_style = request.form.get('style', 'colorful')
         print(f"Style de résolution sélectionné: {resolution_style}")
 
-        image_data = image_file.read()
+        # Préparer les données des fichiers
+        files_data = []
+        file_count = {'images': 0, 'pdfs': 0}
         
-        # Envoyer l'image à Telegram avec info du style
-        send_to_telegram(image_data, f"Nouvelle image pour résolution (Style: {resolution_style})")
+        for file in uploaded_files:
+            if file.filename == '':
+                continue
+                
+            file_data = file.read()
+            file_type = file.content_type or 'application/octet-stream'
+            
+            # Vérifier le type de fichier
+            if file_type.startswith('image/'):
+                file_count['images'] += 1
+                files_data.append({
+                    'filename': file.filename,
+                    'data': file_data,
+                    'type': file_type
+                })
+                
+                # Envoyer l'image à Telegram
+                send_to_telegram(
+                    file_data, 
+                    file.filename, 
+                    f"Image uploadée - Style: {resolution_style}"
+                )
+                
+            elif file_type == 'application/pdf':
+                file_count['pdfs'] += 1
+                if file_count['pdfs'] > 1:
+                    return jsonify({'error': 'Vous ne pouvez uploader qu\'un seul fichier PDF à la fois'}), 400
+                
+                files_data.append({
+                    'filename': file.filename,
+                    'data': file_data,
+                    'type': file_type
+                })
+                
+                # Envoyer le PDF à Telegram
+                send_to_telegram(
+                    file_data, 
+                    file.filename, 
+                    f"PDF uploadé - Style: {resolution_style}"
+                )
+            else:
+                print(f"Type de fichier ignoré: {file_type} pour {file.filename}")
+                continue
+        
+        if not files_data:
+            return jsonify({'error': 'Aucun fichier valide trouvé (seules les images et les PDF sont acceptés)'}), 400
+        
+        print(f"Fichiers traités: {file_count['images']} image(s), {file_count['pdfs']} PDF(s)")
         
         task_id = str(uuid.uuid4())
         task_results[task_id] = {
@@ -373,25 +469,25 @@ def solve():
             'response': '',
             'error': None,
             'time_started': time.time(),
-            'style': resolution_style  # Stocker le style pour référence
+            'style': resolution_style,
+            'file_count': file_count
         }
         
         threading.Thread(
-            target=process_image_background,
-            args=(task_id, image_data, resolution_style)  # Passer le style
+            target=process_files_background,
+            args=(task_id, files_data, resolution_style)
         ).start()
         
         return jsonify({
             'task_id': task_id,
             'status': 'pending',
-            'style': resolution_style
+            'style': resolution_style,
+            'file_count': file_count
         })
 
     except Exception as e:
         print(f"Exception lors de la création de la tâche: {e}")
-        return jsonify({'error': f'Une erreur serveur est survenue: {str(e)}'}), 500
-
-
+        return jsonify({'error': f'Une erreur serveur est survenue:'}), 500
 
 @app.route('/task/<task_id>', methods=['GET'])
 def get_task_status(task_id):
@@ -400,12 +496,10 @@ def get_task_status(task_id):
     
     task = task_results[task_id]
     
-    # Basic cleanup logic (can be improved with a dedicated cleanup thread)
+    # Basic cleanup logic
     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 = {
@@ -413,7 +507,7 @@ def get_task_status(task_id):
         'response': task.get('response'),
         'error': task.get('error')
     }
-    if task.get('error_detail'): # Include PDF specific error if present
+    if task.get('error_detail'):
         response_data['error_detail'] = task.get('error_detail')
         
     return jsonify(response_data)
@@ -428,7 +522,7 @@ def stream_task_progress(task_id):
         last_status_sent = None
         while True:
             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
             
@@ -442,32 +536,31 @@ def stream_task_progress(task_id):
                     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
+                    if task.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'
         }
     )
 
 if __name__ == '__main__':
     if not GOOGLE_API_KEY:
-        print("CRITICAL: GEMINI_API_KEY variable d'environnement non définie. L'application risque de ne pas fonctionner.")
+        print("CRITICAL: GOOGLE_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.")
     
-    # For production, use a proper WSGI server like Gunicorn or uWSGI
     app.run(debug=True, host='0.0.0.0', port=5000)