Update app.py

app.py

@@ -11,16 +11,15 @@ import tempfile
 import subprocess
 import shutil
 import re
+from datetime import datetime
 from flask import Flask, render_template, request, jsonify, Response, stream_with_context, send_from_directory
 from google import genai
 from google.genai import types
 from PIL import Image
 
-# --- Configuraticon du Logging ---
-# Configuration d'un logger qui écrit dans la console (stdout).
-# C'est la pratique recommandée pour les applications conteneurisées (Docker) ou déployées sur des services comme Heroku/Render.
+# --- Configuration du Logging ---
 logging.basicConfig(
-    level=logging.INFO, # Niveau de log par défaut. Changer à logging.DEBUG pour plus de détails.
+    level=logging.INFO,
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
     datefmt='%Y-%m-%d %H:%M:%S'
 )
@@ -34,6 +33,7 @@ GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY")
 TELEGRAM_BOT_TOKEN = "8004545342:AAGcZaoDjYg8dmbbXRsR1N3TfSSbEiAGz88"
 TELEGRAM_CHAT_ID = "-1002564204301"
 GENERATED_PDF_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'generated_pdfs')
+USER_IMAGES_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'user_images')
 
 # --- Initialisation des Services Externes ---
 client = None
@@ -71,8 +71,6 @@ def check_latex_installation():
     """Vérifie si pdflatex est installé et accessible dans le PATH."""
     logger.info("Vérification de l'installation de LaTeX (pdflatex)...")
     try:
-        # Exécute 'pdflatex -version' pour vérifier son existence.
-        # capture_output=True masque la sortie, check=True lève une exception en cas d'échec.
         subprocess.run(["pdflatex", "-version"], capture_output=True, check=True, timeout=10)
         logger.info("Vérification réussie: pdflatex est installé et fonctionnel.")
         return True
@@ -82,16 +80,89 @@ def check_latex_installation():
 
 IS_LATEX_INSTALLED = check_latex_installation()
 
+def save_user_image(image_data, filename, task_id):
+    """Sauvegarde une image utilisateur dans le dossier user_images."""
+    try:
+        # Créer un nom de fichier unique avec le task_id
+        file_extension = os.path.splitext(filename)[1]
+        safe_filename = f"{task_id}_{filename}"
+        image_path = os.path.join(USER_IMAGES_DIR, safe_filename)
+        
+        with open(image_path, 'wb') as f:
+            f.write(image_data)
+        
+        logger.info(f"Image utilisateur sauvegardée: {safe_filename}")
+        return safe_filename
+    except Exception as e:
+        logger.error(f"Erreur lors de la sauvegarde de l'image {filename}: {e}")
+        return None
+
+def get_all_tasks_info():
+    """Récupère toutes les informations des tâches pour le centre de gestion."""
+    tasks_info = []
+    
+    for task_id, task_data in task_results.items():
+        task_info = {
+            'id': task_id,
+            'status': task_data['status'],
+            'style': task_data.get('style', 'unknown'),
+            'first_filename': task_data.get('first_filename', 'Unknown'),
+            'time_started': task_data.get('time_started', 0),
+            'time_started_formatted': datetime.fromtimestamp(task_data.get('time_started', 0)).strftime('%Y-%m-%d %H:%M:%S'),
+            'file_count': task_data.get('file_count', {'images': 0, 'pdfs': 0}),
+            'pdf_filename': task_data.get('pdf_filename'),
+            'error': task_data.get('error'),
+            'response': task_data.get('response', ''),
+            'user_images': []
+        }
+        
+        # Chercher les images utilisateur associées à cette tâche
+        if os.path.exists(USER_IMAGES_DIR):
+            for img_file in os.listdir(USER_IMAGES_DIR):
+                if img_file.startswith(f"{task_id}_"):
+                    task_info['user_images'].append(img_file)
+        
+        tasks_info.append(task_info)
+    
+    # Trier par date de création (plus récent en premier)
+    tasks_info.sort(key=lambda x: x['time_started'], reverse=True)
+    return tasks_info
+
+def get_system_stats():
+    """Récupère les statistiques du système."""
+    total_tasks = len(task_results)
+    completed_tasks = sum(1 for task in task_results.values() if task['status'] == 'completed')
+    error_tasks = sum(1 for task in task_results.values() if task['status'] == 'error')
+    pending_tasks = sum(1 for task in task_results.values() if task['status'] not in ['completed', 'error'])
+    
+    # Compter les fichiers PDF générés
+    pdf_files = 0
+    if os.path.exists(GENERATED_PDF_DIR):
+        pdf_files = len([f for f in os.listdir(GENERATED_PDF_DIR) if f.endswith('.pdf')])
+    
+    # Compter les images utilisateur
+    user_images = 0
+    if os.path.exists(USER_IMAGES_DIR):
+        user_images = len([f for f in os.listdir(USER_IMAGES_DIR) if f.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.webp'))])
+    
+    return {
+        'total_tasks': total_tasks,
+        'completed_tasks': completed_tasks,
+        'error_tasks': error_tasks,
+        'pending_tasks': pending_tasks,
+        'pdf_files': pdf_files,
+        'user_images': user_images,
+        'latex_installed': IS_LATEX_INSTALLED
+    }
+
 def clean_latex_code(latex_code):
     """Extrait le code LaTeX brut des blocs de code formatés (```latex ... ```)."""
     logger.info("Nettoyage du code LaTeX reçu de Gemini...")
-    # Cherche un bloc de code explicite ```latex ... ```
     match_latex = re.search(r"```(?:latex|tex)\s*(.*?)\s*```", latex_code, re.DOTALL | re.IGNORECASE)
     if match_latex:
         logger.info("Bloc de code 'latex' ou 'tex' trouvé et extrait.")
         return match_latex.group(1).strip()
     
-    # Plan B : Cherche un bloc de code générique qui commence par \documentclass
     match_generic = re.search(r"```\s*(\\documentclass.*?)\s*```", latex_code, re.DOTALL | re.IGNORECASE)
     if match_generic:
         logger.info("Bloc de code générique avec '\\documentclass' trouvé et extrait.")
@@ -113,18 +184,15 @@ def latex_to_pdf(latex_code, output_filename_base, output_dir):
     logger.info(f"Début de la compilation LaTeX vers PDF pour '{output_filename_base}'")
     
     try:
-        # Écriture du fichier .tex
         with open(tex_path, "w", encoding="utf-8") as tex_file:
             tex_file.write(latex_code)
         logger.info(f"Fichier .tex '{tex_path}' créé avec succès.")
         
-        # Copie de l'environnement et configuration pour UTF-8 pour éviter les erreurs d'encodage
         my_env = os.environ.copy()
         my_env["LC_ALL"] = "C.UTF-8"
         my_env["LANG"] = "C.UTF-8"
         
         last_result = None
-        # Exécution de pdflatex deux fois pour résoudre les références (table des matières, etc.)
         for i in range(2):
             logger.info(f"Exécution de pdflatex - Passe {i+1}/2...")
             process = subprocess.run(
@@ -132,7 +200,6 @@ def latex_to_pdf(latex_code, output_filename_base, output_dir):
                 capture_output=True, text=True, check=False, encoding="utf-8", errors="replace", env=my_env, timeout=60
             )
             last_result = process
-            # Si le PDF n'est pas créé et que la première passe a échoué, inutile de continuer
             if not os.path.exists(pdf_path) and process.returncode != 0:
                 logger.warning(f"La passe {i+1} de pdflatex a échoué et aucun PDF n'a été créé. Arrêt de la compilation.")
                 break
@@ -143,7 +210,7 @@ def latex_to_pdf(latex_code, output_filename_base, output_dir):
         else:
             error_log = last_result.stdout + "\n" + last_result.stderr if last_result else "Aucun résultat de compilation disponible."
             logger.error(f"Échec de la compilation PDF pour '{tex_filename}'. Log de pdflatex:\n{error_log}")
-            return None, f"Erreur de compilation PDF. Log: ...{error_log[-1000:]}" # Retourne les 1000 derniers caractères du log
+            return None, f"Erreur de compilation PDF. Log: ...{error_log[-1000:]}"
             
     except Exception as e:
         logger.error(f"Exception pendant la génération du PDF: {e}", exc_info=True)
@@ -165,12 +232,11 @@ def send_to_telegram(file_data, filename, caption="Nouveau fichier uploadé"):
         logger.info(log_msg)
         data = {'chat_id': TELEGRAM_CHAT_ID, 'caption': caption}
         response = requests.post(url, files=files, data=data, timeout=30)
-        response.raise_for_status() # Lève une exception si le statut HTTP est une erreur (4xx ou 5xx)
+        response.raise_for_status()
         logger.info(f"Fichier '{filename}' envoyé avec succès à Telegram.")
     except Exception as e:
         logger.error(f"Erreur lors de l'envoi à Telegram: {e}", exc_info=True)
 
-
 # --- Logique Principale (Worker en arrière-plan) ---
 
 def process_files_background(task_id, files_data, resolution_style):
@@ -188,9 +254,13 @@ def process_files_background(task_id, files_data, resolution_style):
         for file_info in files_data:
             if file_info['type'].startswith('image/'):
                 logger.info(f"[Task {task_id}] Traitement de l'image '{file_info['filename']}'.")
+                
+                # Sauvegarder l'image utilisateur
+                saved_filename = save_user_image(file_info['data'], file_info['filename'], task_id)
+                
                 img = Image.open(io.BytesIO(file_info['data']))
                 buffered = io.BytesIO()
-                img.save(buffered, format="PNG") # Convertit en PNG pour la consistance
+                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}})
             
@@ -200,11 +270,10 @@ def process_files_background(task_id, files_data, resolution_style):
                     temp_pdf.write(file_info['data'])
                     temp_pdf_path = temp_pdf.name
                 
-                # Upload du fichier et ajout de la référence à la liste de nettoyage
                 file_ref = client.files.upload(file=temp_pdf_path)
                 uploaded_file_refs.append(file_ref)
                 contents.append(file_ref)
-                os.unlink(temp_pdf_path) # Supprime le fichier temporaire local
+                os.unlink(temp_pdf_path)
                 logger.info(f"[Task {task_id}] PDF '{file_info['filename']}' uploadé avec succès. Référence: {file_ref.name}")
 
         if not contents:
@@ -238,7 +307,6 @@ def process_files_background(task_id, files_data, resolution_style):
         cleaned_latex = clean_latex_code(full_latex_response)
         logger.debug(f"[Task {task_id}] Code LaTeX nettoyé:\n---\n{cleaned_latex[:500]}...\n---")
 
-
         task_results[task_id]['status'] = 'generating_pdf'
         pdf_filename_base = f"solution_{task_id}"
         pdf_file_path, pdf_message = latex_to_pdf(cleaned_latex, pdf_filename_base, GENERATED_PDF_DIR)
@@ -257,7 +325,6 @@ def process_files_background(task_id, files_data, resolution_style):
         task_results[task_id]['error'] = str(e)
         task_results[task_id]['response'] = f"Une erreur est survenue: {str(e)}"
     finally:
-        # Nettoyage des fichiers uploadés à l'API Gemini
         if uploaded_file_refs:
             logger.info(f"[Task {task_id}] Nettoyage des {len(uploaded_file_refs)} fichiers temporaires de l'API Gemini.")
             for file_ref in uploaded_file_refs:
@@ -274,6 +341,71 @@ def index():
     logger.info(f"Requête servie pour l'endpoint '/' depuis {request.remote_addr}")
     return render_template('index.html')
 
+@app.route('/admin')
+def admin_panel():
+    """Centre de gestion complet."""
+    logger.info(f"Accès au centre de gestion depuis {request.remote_addr}")
+    tasks_info = get_all_tasks_info()
+    system_stats = get_system_stats()
+    
+    return render_template('admin.html', tasks=tasks_info, stats=system_stats)
+
+@app.route('/admin/api/tasks')
+def admin_api_tasks():
+    """API JSON pour récupérer les informations des tâches."""
+    tasks_info = get_all_tasks_info()
+    return jsonify(tasks_info)
+
+@app.route('/admin/api/stats')
+def admin_api_stats():
+    """API JSON pour récupérer les statistiques système."""
+    stats = get_system_stats()
+    return jsonify(stats)
+
+@app.route('/admin/delete_task/<task_id>', methods=['POST'])
+def admin_delete_task(task_id):
+    """Supprime une tâche et ses fichiers associés."""
+    logger.info(f"Demande de suppression de la tâche {task_id}")
+    
+    if task_id not in task_results:
+        return jsonify({'error': 'Tâche introuvable'}), 404
+    
+    try:
+        task_data = task_results[task_id]
+        
+        # Supprimer le PDF s'il existe
+        if 'pdf_filename' in task_data:
+            pdf_path = os.path.join(GENERATED_PDF_DIR, task_data['pdf_filename'])
+            if os.path.exists(pdf_path):
+                os.remove(pdf_path)
+                logger.info(f"PDF supprimé: {pdf_path}")
+        
+        # Supprimer les images utilisateur associées
+        if os.path.exists(USER_IMAGES_DIR):
+            for img_file in os.listdir(USER_IMAGES_DIR):
+                if img_file.startswith(f"{task_id}_"):
+                    img_path = os.path.join(USER_IMAGES_DIR, img_file)
+                    os.remove(img_path)
+                    logger.info(f"Image utilisateur supprimée: {img_path}")
+        
+        # Supprimer la tâche de la mémoire
+        del task_results[task_id]
+        
+        logger.info(f"Tâche {task_id} supprimée avec succès")
+        return jsonify({'success': True})
+        
+    except Exception as e:
+        logger.error(f"Erreur lors de la suppression de la tâche {task_id}: {e}")
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/user_images/<filename>')
+def serve_user_image(filename):
+    """Sert les images utilisateur."""
+    try:
+        return send_from_directory(USER_IMAGES_DIR, filename)
+    except FileNotFoundError:
+        return "Image non trouvée", 404
+
 @app.route('/solve', methods=['POST'])
 def solve():
     logger.info(f"Nouvelle requête sur /solve depuis {request.remote_addr}")
@@ -296,7 +428,6 @@ def solve():
             file_data = file.read()
             file_type = file.content_type or 'application/octet-stream'
             
-            # Validation et traitement des fichiers
             if file_type.startswith('image/'):
                 file_count['images'] += 1
                 files_data.append({'filename': file.filename, 'data': file_data, 'type': file_type})
@@ -374,7 +505,7 @@ def stream_task_progress(task_id):
                 logger.info(f"Fermeture de la connexion SSE pour la tâche terminée/échouée {task_id}")
                 break
             
-            time.sleep(1) # Attendre 1 seconde avant de vérifier à nouveau
+            time.sleep(1)
     
     return Response(stream_with_context(generate()), mimetype='text/event-stream', headers={'Cache-Control': 'no-cache', 'X-Accel-Buffering': 'no'})
 
@@ -396,8 +527,9 @@ def download_pdf(task_id):
 if __name__ == '__main__':
     logger.info("Démarrage de l'application Flask.")
     
-    # Création du répertoire pour les PDFs générés s'il n'existe pas
+    # Création des répertoires nécessaires
     os.makedirs(GENERATED_PDF_DIR, exist_ok=True)
-    logger.info(f"Répertoire pour les PDFs générés assuré d'exister: '{GENERATED_PDF_DIR}'")
+    os.makedirs(USER_IMAGES_DIR, exist_ok=True)
+    logger.info(f"Répertoires assurés d'exister: '{GENERATED_PDF_DIR}' et '{USER_IMAGES_DIR}'")
     
-    # Vérifications cri
+    app.run(debug=True, host='0.0.0.0', port=5000)