Update app.py

app.py

@@ -1,257 +1,337 @@
-from flask import Flask, render_template, request, jsonify, send_file
-import threading
-import time
 import os
 import json
-from datetime import datetime
-from google import genai
-from pydantic import BaseModel, Field
-import typing_extensions as typing
 import uuid
-import enum
+import threading
+import time
+from datetime import datetime
+from flask import Flask, request, render_template, jsonify, send_file
+from flask_socketio import SocketIO, emit
+from werkzeug.utils import secure_filename
+import base64
+from io import BytesIO
+from PIL import Image
+import pytesseract
+from crewai import Agent, Task, Crew, Process, LLM
+import re
+import logging
 
+# Configuration Flask
 app = Flask(__name__)
+app.config['SECRET_KEY'] = 'votre_cle_secrete_ici'
+app.config['UPLOAD_FOLDER'] = 'uploads'
+app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 16MB max
 
-# Configurbation
-GOOGLE_API_KEY = "AIzaSyAMYpF67aqFnWDJESWOx1dC-w3sEU29VcM"  # Remplacez par votre clé API
-MODEL_ID = "gemini-2.0-flash"  # Modèle recommandé selon la documentation
-UPLOAD_FOLDER = 'uploads'
-RESULTS_FOLDER = 'results'
-
-# Créer les dossiers s'ils n'existent pas
-os.makedirs(UPLOAD_FOLDER, exist_ok=True)
-os.makedirs(RESULTS_FOLDER, exist_ok=True)
-
-# Définition des schémas Pydantic selon la documentation
-class TranslationPair(BaseModel):
-    """Paire de traductions fang/français"""
-    fang: str = Field(description="Phrase en langue fang")
-    francais: str = Field(description="Traduction française de la phrase")
-
-class SyntheticDataResponse(BaseModel):
-    """Réponse structurée pour la génération de données synthétiques"""
-    request_number: int = Field(description="Numéro de la requête")
-    generated_pairs: list[TranslationPair] = Field(
-        description="Liste des paires de traduction générées", 
-        min_items=1
-    )
-    timestamp: str = Field(description="Horodatage de la génération")
-
-# Stockage des tâches en cours
-class TaskManager:
-    def __init__(self):
-        self.tasks = {}
-    
-    def create_task(self, task_id):
-        self.tasks[task_id] = {
-            'status': 'running',
-            'progress': 0,
-            'total': 470,
-            'results_file': f'results_{task_id}.json',
-            'start_time': datetime.now(),
-            'errors': [],
-            'last_update': datetime.now(),
-            'all_data': []
-        }
-    
-    def update_progress(self, task_id, progress, data=None):
-        if task_id in self.tasks:
-            self.tasks[task_id]['progress'] = progress
-            self.tasks[task_id]['last_update'] = datetime.now()
-            if data:
-                self.tasks[task_id]['all_data'].append(data)
-    
-    def add_error(self, task_id, error):
-        if task_id in self.tasks:
-            self.tasks[task_id]['errors'].append(error)
+# Configuration SocketIO pour les logs en temps réel
+socketio = SocketIO(app, cors_allowed_origins="*")
+
+# Créer les dossiers nécessaires
+os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
+os.makedirs('solutions', exist_ok=True)
+
+# Extensions d'images autorisées
+ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg', 'gif', 'bmp', 'tiff'}
+
+# Configuration Gemini API
+os.environ["GEMINI_API_KEY"] = os.environ.get("GEMINI_API_KEY", "your_api_key_here")
+
+# Dictionnaire global pour stocker les tâches en cours
+active_tasks = {}
+
+# Configuration du LLM
+llm = LLM(
+    model="gemini/gemini-2.0-flash",
+    temperature=0.1,
+    timeout=120,
+    max_tokens=8000,
+)
+
+# Paramètres du pipeline
+MAX_ITERATIONS = 5
+PASSES_NEEDED_FOR_SUCCESS = 2
+
+# ==============================================================================
+# UTILITAIRES
+# ==============================================================================
+
+def allowed_file(filename):
+    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
+def extract_text_from_image(image_path):
+    """Extrait le texte d'une image en utilisant OCR."""
+    try:
+        # Ouvrir l'image
+        image = Image.open(image_path)
+        
+        # Convertir en RGB si nécessaire
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        
+        # Extraire le texte avec pytesseract
+        text = pytesseract.image_to_string(image, lang='eng')
+        
+        return text.strip()
+    except Exception as e:
+        return f"Erreur lors de l'extraction du texte: {str(e)}"
+
+def emit_log(task_id, level, message):
+    """Émet un log vers le client via WebSocket."""
+    log_data = {
+        'timestamp': datetime.now().strftime('%H:%M:%S'),
+        'level': level,
+        'message': message
+    }
+    socketio.emit('log_update', {'task_id': task_id, 'log': log_data})
+
+# ==============================================================================
+# PROMPTS (MÊME LOGIQUE QUE L'ORIGINAL)
+# ==============================================================================
+
+def get_imo_paper_solver_prompt(problem_statement, hint=""):
+    full_problem = f"{problem_statement}\n{hint}" if hint else problem_statement
+    return f"""
+### Core Instructions ###
+**Rigor is Paramount:** Your primary goal is to produce a complete and rigorously justified solution.
+You are solving an International Mathematical Olympiad (IMO) level problem.
+
+### Problem ###
+{full_problem}
+
+### Your Task ###
+Provide a complete, rigorous mathematical proof. Structure your solution clearly with:
+1. A brief summary of your approach
+2. A detailed step-by-step proof
+3. Clear justification for each step
+"""
+
+def get_self_improve_prompt(solution_attempt):
+    return f"""
+You are a world-class mathematician. You have just produced the following draft solution.
+Review it carefully for flaws, gaps, or unclear parts, then produce a new, improved, and more rigorous version.
+
+### Draft Solution ###
+{solution_attempt}
+
+### Your Task ###
+Provide the improved and finalized version of the solution. Only output the final, clean proof.
+"""
+
+def get_imo_paper_verifier_prompt(problem_statement, solution_to_verify):
+    return f"""
+You are an expert mathematician and a meticulous grader for an IMO level exam.
+
+### Problem ###
+{problem_statement}
+
+### Solution ###
+{solution_to_verify}
+
+### Verification Task ###
+Act as an IMO grader. Analyze the solution for:
+1. Mathematical correctness
+2. Logical gaps or errors
+3. Clarity and rigor
+
+Provide your verdict in the format:
+**Final Verdict:** [The solution is correct / Critical error found / Justification gaps found]
+
+Then provide detailed feedback on any issues found.
+"""
+
+def get_correction_prompt(solution_attempt, verification_report):
+    return f"""
+You are a brilliant mathematician. Your previous solution attempt has been reviewed by a verifier.
+Your task is to write a new, corrected version of your solution that addresses all the issues raised.
+
+### Verification Report ###
+{verification_report}
+
+### Your Previous Solution ###
+{solution_attempt}
+
+### Your Task ###
+Provide a new, complete, and rigorously correct solution that fixes all identified issues.
+"""
+
+# ==============================================================================
+# AGENTS CREWAI
+# ==============================================================================
+
+solver_agent = Agent(
+    role='Mathématicien de classe mondiale et résolveur de problèmes créatifs',
+    goal='Générer et affiner des preuves mathématiques complètes et rigoureuses pour des problèmes de niveau Olympiades.',
+    backstory="""Médaillé d'or des OIM, vous êtes connu pour votre capacité à trouver des solutions
+    à la fois non conventionnelles et impeccablement rigoureuses. Vous excellez à décomposer
+    des problèmes complexes et à présenter des arguments clairs, étape par étape.""",
+    verbose=True,
+    allow_delegation=False,
+    llm=llm
+)
+
+verifier_agent = Agent(
+    role='Examinateur méticuleux pour les Olympiades Internationales de Mathématiques',
+    goal='Analyser de manière critique une preuve mathématique pour y trouver la moindre erreur logique ou le moindre manque de justification.',
+    backstory="""Professeur de mathématiques réputé, membre du comité de notation des OIM. Votre devise est 'la rigueur avant tout'.
+    Vous ne corrigez jamais, vous ne faites que juger et rapporter les failles.""",
+    verbose=True,
+    allow_delegation=False,
+    llm=llm
+)
+
+# ==============================================================================
+# PIPELINE DE RÉSOLUTION
+# ==============================================================================
+
+def parse_verifier_verdict(report):
+    if not report: 
+        return "ERROR"
     
-    def complete_task(self, task_id):
-        if task_id in self.tasks:
-            self.tasks[task_id]['status'] = 'completed'
-            self.tasks[task_id]['last_update'] = datetime.now()
+    report_text = str(report)
+    match = re.search(r"\*\*Final Verdict:\*\* (.*)", report_text, re.IGNORECASE)
+    if not match: 
+        return "UNKNOWN"
     
-    def get_task(self, task_id):
-        return self.tasks.get(task_id)
-
-task_manager = TaskManager()
+    verdict_text = match.group(1).lower()
+    if "the solution is correct" in verdict_text:
+        return "CORRECT"
+    if "critical error" in verdict_text:
+        return "CRITICAL_ERROR"
+    if "justification gap" in verdict_text:
+        return "GAPS"
+    return "UNKNOWN"
 
-def generate_synthetic_data(file_path, task_id):
-    """Fonction qui exécute les 470 requêtes en arrière-plan avec sortie JSON structurée"""
+def run_imo_pipeline_async(task_id, problem_statement, initial_hint=""):
+    """Version asynchrone du pipeline avec émission de logs."""
     try:
-        # Initialiser le client Google AI selon la documentation
-        client = genai.Client(api_key=GOOGLE_API_KEY)
-        
-        # Uploader le fichier
-        file_ref = client.files.upload(path=file_path)
-        
-        # Prompt optimisé pour une sortie structurée
-        prompt = """
-        À partir du fichier fourni, génère exactement 400 nouvelles paires de phrases synthétiques.
-        Chaque paire doit contenir :
-        - Une phrase en fang (langue locale)
-        - Sa traduction en français
-        
-        Les phrases doivent être variées, naturelles et représentatives de la structure linguistique 
-        présente dans le fichier source. Respecte strictement le nombre de 400 paires demandées.
-        """
-        
-        # Fichier de résultats JSON
-        results_file = os.path.join(RESULTS_FOLDER, f'results_{task_id}.json')
-        
-        # Structure pour stocker toutes les données
-        all_results = {
-            "metadata": {
-                "task_id": task_id,
-                "start_time": datetime.now().isoformat(),
-                "total_requests": 470,
-                "model_used": MODEL_ID,
-                "expected_pairs_per_request": 400
-            },
-            "requests": [],
-            "summary": {
-                "total_pairs": 0,
-                "completed_requests": 0,
-                "failed_requests": 0,
-                "errors": []
-            }
-        }
+        emit_log(task_id, 'info', "🚀 Démarrage du Pipeline de Résolution Mathématique")
         
-        for i in range(470):
-            try:
-                print(f"🔄 Démarrage requête {i+1}/470...")
-                
-                # Configuration selon la documentation avec schéma Pydantic
-                response = client.models.generate_content(
-                    model=MODEL_ID,
-                    contents=[file_ref, prompt],
-                    config={
-                        'response_mime_type': 'application/json',
-                        'response_schema': SyntheticDataResponse,
-                    }
-                )
-                
-                # Utiliser la propriété .parsed selon la documentation
-                if hasattr(response, 'parsed') and response.parsed:
-                    parsed_response = response.parsed
+        # Étape 1: Génération Initiale
+        emit_log(task_id, 'info', "--- ÉTAPE 1: Génération de la Solution Initiale ---")
+        
+        initial_task = Task(
+            description=get_imo_paper_solver_prompt(problem_statement, initial_hint),
+            expected_output="Une ébauche de preuve mathématique structurée avec un résumé et une solution détaillée.",
+            agent=solver_agent
+        )
+        
+        initial_crew = Crew(
+            agents=[solver_agent],
+            tasks=[initial_task],
+            process=Process.sequential,
+            verbose=False
+        )
+        
+        initial_result = initial_crew.kickoff()
+        initial_solution = initial_result.raw if hasattr(initial_result, 'raw') else str(initial_result)
+        
+        emit_log(task_id, 'success', "✅ Solution initiale générée")
+        
+        # Étape 2: Auto-Amélioration
+        emit_log(task_id, 'info', "--- ÉTAPE 2: Auto-Amélioration de la Solution ---")
+        
+        improve_task = Task(
+            description=get_self_improve_prompt(initial_solution),
+            expected_output="Une version améliorée et plus rigoureuse de la preuve.",
+            agent=solver_agent
+        )
+        
+        improve_crew = Crew(
+            agents=[solver_agent],
+            tasks=[improve_task],
+            process=Process.sequential,
+            verbose=False
+        )
+        
+        improve_result = improve_crew.kickoff()
+        current_solution = improve_result.raw if hasattr(improve_result, 'raw') else str(improve_result)
+        
+        emit_log(task_id, 'success', "✅ Solution améliorée")
+        
+        # Boucle de Vérification
+        iteration = 0
+        consecutive_passes = 0
+        
+        while iteration < MAX_ITERATIONS:
+            iteration += 1
+            emit_log(task_id, 'info', f"--- CYCLE DE VÉRIFICATION {iteration}/{MAX_ITERATIONS} ---")
+
+            verify_task = Task(
+                description=get_imo_paper_verifier_prompt(problem_statement, current_solution),
+                expected_output="Un rapport de vérification complet au format OIM.",
+                agent=verifier_agent
+            )
+            
+            correct_task = Task(
+                description=get_correction_prompt(current_solution, "Rapport du vérificateur (voir contexte)"),
+                expected_output="Une nouvelle version complète et corrigée de la preuve mathématique.",
+                agent=solver_agent,
+                context=[verify_task]
+            )
+            
+            correction_crew = Crew(
+                agents=[verifier_agent, solver_agent],
+                tasks=[verify_task, correct_task],
+                process=Process.sequential,
+                verbose=False
+            )
+            
+            cycle_result = correction_crew.kickoff()
+            
+            if hasattr(cycle_result, 'tasks_output') and len(cycle_result.tasks_output) >= 2:
+                verification_report = cycle_result.tasks_output[0].raw
+                corrected_solution = cycle_result.tasks_output[1].raw
+            else:
+                verification_report = str(cycle_result)
+                corrected_solution = str(cycle_result)
+            
+            verdict = parse_verifier_verdict(verification_report)
+            
+            emit_log(task_id, 'info', f"VERDICT DU CYCLE {iteration}: {verdict}")
+            
+            if verdict == "CORRECT":
+                consecutive_passes += 1
+                emit_log(task_id, 'success', f"✅ PASSAGE RÉUSSI ! Passes consécutives : {consecutive_passes}/{PASSES_NEEDED_FOR_SUCCESS}")
+                if consecutive_passes >= PASSES_NEEDED_FOR_SUCCESS:
+                    emit_log(task_id, 'success', "🏆 La solution a été validée avec succès ! 🏆")
                     
-                    # Structurer la réponse selon le schéma
-                    request_data = {
-                        "request_number": i + 1,
-                        "timestamp": datetime.now().isoformat(),
-                        "response": {
-                            "request_number": parsed_response.request_number,
-                            "generated_pairs": [
-                                {
-                                    "fang": pair.fang,
-                                    "francais": pair.francais
-                                } for pair in parsed_response.generated_pairs
-                            ],
-                            "timestamp": parsed_response.timestamp
-                        },
-                        "pairs_count": len(parsed_response.generated_pairs),
-                        "status": "success"
-                    }
+                    # Sauvegarder la solution
+                    solution_file = f"solutions/solution_{task_id}.txt"
+                    with open(solution_file, 'w', encoding='utf-8') as f:
+                        f.write(f"Problème:\n{problem_statement}\n\n")
+                        f.write(f"Solution finale:\n{current_solution}")
                     
-                    all_results["requests"].append(request_data)
-                    all_results["summary"]["total_pairs"] += request_data["pairs_count"]
-                    all_results["summary"]["completed_requests"] += 1
+                    active_tasks[task_id]['status'] = 'completed'
+                    active_tasks[task_id]['solution_file'] = solution_file
                     
-                    print(f"✅ Requête {i+1} réussie - {request_data['pairs_count']} paires générées")
-                
-                else:
-                    # Fallback : parser le JSON manuellement si .parsed n'est pas disponible
-                    try:
-                        response_data = json.loads(response.text)
-                        request_data = {
-                            "request_number": i + 1,
-                            "timestamp": datetime.now().isoformat(),
-                            "response": response_data,
-                            "pairs_count": len(response_data.get("generated_pairs", [])),
-                            "status": "success_fallback"
-                        }
-                        
-                        all_results["requests"].append(request_data)
-                        all_results["summary"]["total_pairs"] += request_data["pairs_count"]
-                        all_results["summary"]["completed_requests"] += 1
-                        
-                        print(f"✅ Requête {i+1} réussie (fallback) - {request_data['pairs_count']} paires")
-                        
-                    except json.JSONDecodeError as json_error:
-                        raise Exception(f"Impossible de parser la réponse JSON: {json_error}")
-                
-                # Sauvegarder après chaque requête réussie
-                with open(results_file, 'w', encoding='utf-8') as f:
-                    json.dump(all_results, f, ensure_ascii=False, indent=2)
-                
-                # Mettre à jour le progrès
-                task_manager.update_progress(task_id, i + 1)
-                
-                # Pause pour respecter les limites de l'API (ajustable selon vos besoins)
-                time.sleep(1)  # Réduit à 1 seconde, ajustez selon vos limites API
-                
-            except Exception as e:
-                error_msg = f"Erreur requête {i+1}: {str(e)}"
-                print(f"❌ {error_msg}")
-                
-                task_manager.add_error(task_id, error_msg)
-                all_results["summary"]["errors"].append({
-                    "request_number": i + 1,
-                    "error": error_msg,
-                    "timestamp": datetime.now().isoformat()
-                })
-                all_results["summary"]["failed_requests"] += 1
-                
-                # Créer une entrée vide pour cette requête échouée
-                failed_request_data = {
-                    "request_number": i + 1,
-                    "timestamp": datetime.now().isoformat(),
-                    "response": None,
-                    "pairs_count": 0,
-                    "status": "failed",
-                    "error": error_msg
-                }
-                all_results["requests"].append(failed_request_data)
-                
-                # Sauvegarder même en cas d'erreur
-                with open(results_file, 'w', encoding='utf-8') as f:
-                    json.dump(all_results, f, ensure_ascii=False, indent=2)
-                
-                # Mettre à jour le progrès même en cas d'erreur
-                task_manager.update_progress(task_id, i + 1)
-                
-                # Pause plus longue en cas d'erreur
-                time.sleep(5)
-        
-        # Finaliser le fichier JSON
-        end_time = datetime.now()
-        start_time = datetime.fromisoformat(all_results["metadata"]["start_time"])
-        duration = (end_time - start_time).total_seconds()
-        
-        all_results["metadata"]["end_time"] = end_time.isoformat()
-        all_results["metadata"]["duration_seconds"] = duration
-        all_results["metadata"]["duration_minutes"] = duration / 60
-        all_results["summary"]["success_rate"] = (
-            all_results["summary"]["completed_requests"] / 470 * 100
-        )
+                    socketio.emit('task_completed', {'task_id': task_id})
+                    return current_solution
+            else:
+                consecutive_passes = 0
+                emit_log(task_id, 'warning', "⚠️ Problèmes détectés. Correction en cours...")
+                current_solution = corrected_solution
+
+        emit_log(task_id, 'error', f"❌ Échec après {MAX_ITERATIONS} itérations")
         
-        # Statistiques finales
-        print(f"\n📊 STATISTIQUES FINALES:")
-        print(f"   • Requêtes réussies: {all_results['summary']['completed_requests']}/470")
-        print(f"   • Requêtes échouées: {all_results['summary']['failed_requests']}/470")
-        print(f"   • Total paires générées: {all_results['summary']['total_pairs']}")
-        print(f"   • Taux de réussite: {all_results['summary']['success_rate']:.1f}%")
-        print(f"   • Durée totale: {duration/60:.1f} minutes")
+        # Sauvegarder la solution partielle
+        solution_file = f"solutions/solution_{task_id}_partial.txt"
+        with open(solution_file, 'w', encoding='utf-8') as f:
+            f.write(f"Problème:\n{problem_statement}\n\n")
+            f.write(f"Solution partielle (non validée):\n{current_solution}")
         
-        with open(results_file, 'w', encoding='utf-8') as f:
-            json.dump(all_results, f, ensure_ascii=False, indent=2)
+        active_tasks[task_id]['status'] = 'failed'
+        active_tasks[task_id]['solution_file'] = solution_file
         
-        task_manager.complete_task(task_id)
-        print(f"🎉 Tâche {task_id} terminée avec succès")
+        socketio.emit('task_failed', {'task_id': task_id})
+        return current_solution
         
     except Exception as e:
-        error_msg = f"Erreur générale: {str(e)}"
-        task_manager.add_error(task_id, error_msg)
-        print(f"💥 {error_msg}")
+        emit_log(task_id, 'error', f"❌ Erreur critique: {str(e)}")
+        active_tasks[task_id]['status'] = 'error'
+        active_tasks[task_id]['error'] = str(e)
+        socketio.emit('task_error', {'task_id': task_id, 'error': str(e)})
+
+# ==============================================================================
+# ROUTES FLASK
+# ==============================================================================
 
 @app.route('/')
 def index():
@@ -260,187 +340,386 @@ def index():
 @app.route('/upload', methods=['POST'])
 def upload_file():
     if 'file' not in request.files:
-        return jsonify({'error': 'Aucun fichier sélectionné'}), 400
+        return jsonify({'error': 'Aucun fichier fourni'}), 400
     
     file = request.files['file']
     if file.filename == '':
         return jsonify({'error': 'Aucun fichier sélectionné'}), 400
     
-    if file:
-        # Générer un ID unique pour cette tâche
+    if file and allowed_file(file.filename):
+        # Générer un ID de tâche unique
         task_id = str(uuid.uuid4())
         
         # Sauvegarder le fichier
-        filename = f"input_{task_id}.txt"
-        file_path = os.path.join(UPLOAD_FOLDER, filename)
-        file.save(file_path)
-        
-        # Créer la tâche
-        task_manager.create_task(task_id)
-        
-        # Démarrer le traitement en arrière-plan
-        thread = threading.Thread(
-            target=generate_synthetic_data, 
-            args=(file_path, task_id)
-        )
-        thread.daemon = True
-        thread.start()
+        filename = secure_filename(file.filename)
+        filepath = os.path.join(app.config['UPLOAD_FOLDER'], f"{task_id}_{filename}")
+        file.save(filepath)
         
-        return jsonify({
-            'task_id': task_id,
-            'message': 'Traitement démarré en arrière-plan',
-            'expected_duration_minutes': 8  # Estimation bas��e sur 1s par requête
-        })
+        # Extraire le texte de l'image
+        try:
+            extracted_text = extract_text_from_image(filepath)
+            
+            # Initialiser la tâche
+            active_tasks[task_id] = {
+                'status': 'processing',
+                'problem': extracted_text,
+                'started_at': datetime.now(),
+                'filename': filename
+            }
+            
+            # Lancer le pipeline en arrière-plan
+            thread = threading.Thread(
+                target=run_imo_pipeline_async,
+                args=(task_id, extracted_text)
+            )
+            thread.daemon = True
+            thread.start()
+            
+            return jsonify({
+                'task_id': task_id,
+                'extracted_text': extracted_text,
+                'message': 'Traitement commencé'
+            })
+            
+        except Exception as e:
+            return jsonify({'error': f'Erreur lors du traitement de l\'image: {str(e)}'}), 500
+    
+    return jsonify({'error': 'Type de fichier non autorisé'}), 400
 
 @app.route('/status/<task_id>')
 def get_status(task_id):
-    task = task_manager.get_task(task_id)
-    if not task:
+    if task_id not in active_tasks:
         return jsonify({'error': 'Tâche non trouvée'}), 404
     
-    # Calculer ETA si la tâche est en cours
-    eta_minutes = None
-    if task['status'] == 'running' and task['progress'] > 0:
-        elapsed = (datetime.now() - task['start_time']).total_seconds()
-        rate = task['progress'] / elapsed  # requêtes par seconde
-        remaining = task['total'] - task['progress']
-        eta_seconds = remaining / rate if rate > 0 else None
-        eta_minutes = eta_seconds / 60 if eta_seconds else None
-    
+    task = active_tasks[task_id]
     return jsonify({
+        'task_id': task_id,
         'status': task['status'],
-        'progress': task['progress'],
-        'total': task['total'],
-        'percentage': round((task['progress'] / task['total']) * 100, 2),
-        'errors_count': len(task['errors']),
-        'start_time': task['start_time'].strftime('%Y-%m-%d %H:%M:%S'),
-        'last_update': task['last_update'].strftime('%Y-%m-%d %H:%M:%S'),
-        'eta_minutes': round(eta_minutes) if eta_minutes else None
+        'problem': task.get('problem', ''),
+        'started_at': task['started_at'].isoformat(),
+        'has_solution': 'solution_file' in task
     })
 
 @app.route('/download/<task_id>')
-def download_results(task_id):
-    task = task_manager.get_task(task_id)
-    if not task:
+def download_solution(task_id):
+    if task_id not in active_tasks:
         return jsonify({'error': 'Tâche non trouvée'}), 404
     
-    results_file = os.path.join(RESULTS_FOLDER, f'results_{task_id}.json')
-    
-    if not os.path.exists(results_file):
-        return jsonify({'error': 'Fichier de résultats non trouvé'}), 404
-    
-    # Vérifier si c'est un téléchargement partiel
-    is_partial = request.args.get('partial', 'false').lower() == 'true'
-    
-    if is_partial and task['status'] == 'running':
-        # Créer un fichier temporaire avec les données actuelles
-        temp_file = os.path.join(RESULTS_FOLDER, f'temp_results_{task_id}.json')
-        
-        try:
-            # Charger les données actuelles
-            with open(results_file, 'r', encoding='utf-8') as f:
-                current_data = json.load(f)
-            
-            # Ajouter des métadonnées pour le téléchargement partiel
-            current_data["partial_download"] = {
-                "downloaded_at": datetime.now().isoformat(),
-                "is_partial": True,
-                "progress": f"{task['progress']}/{task['total']}",
-                "percentage": round((task['progress'] / task['total']) * 100, 2)
-            }
-            
-            # Sauvegarder le fichier temporaire
-            with open(temp_file, 'w', encoding='utf-8') as f:
-                json.dump(current_data, f, ensure_ascii=False, indent=2)
-            
-            return send_file(
-                temp_file,
-                as_attachment=True,
-                download_name=f'donnees_synthetiques_partiel_{task_id}.json'
-            )
-        except Exception as e:
-            return jsonify({'error': f'Erreur lors de la création du fichier partiel: {str(e)}'}), 500
-    
-    # Téléchargement normal (complet)
-    download_name = f'donnees_synthetiques_{"complet" if task["status"] == "completed" else "actuel"}_{task_id}.json'
+    task = active_tasks[task_id]
+    if 'solution_file' not in task:
+        return jsonify({'error': 'Aucune solution disponible'}), 404
     
-    return send_file(
-        results_file,
-        as_attachment=True,
-        download_name=download_name
-    )
+    return send_file(task['solution_file'], as_attachment=True, download_name=f'solution_{task_id}.txt')
 
 @app.route('/tasks')
 def list_tasks():
-    """Liste toutes les tâches"""
-    task_list = []
-    for task_id, task_info in task_manager.tasks.items():
-        task_list.append({
-            'id': task_id,
-            'status': task_info['status'],
-            'progress': task_info['progress'],
-            'total': task_info['total'],
-            'percentage': round((task_info['progress'] / task_info['total']) * 100, 2),
-            'start_time': task_info['start_time'].strftime('%Y-%m-%d %H:%M:%S'),
-            'last_update': task_info['last_update'].strftime('%Y-%m-%d %H:%M:%S'),
-            'errors_count': len(task_info['errors'])
+    tasks_info = []
+    for task_id, task in active_tasks.items():
+        tasks_info.append({
+            'task_id': task_id,
+            'status': task['status'],
+            'filename': task.get('filename', ''),
+            'started_at': task['started_at'].isoformat(),
+            'has_solution': 'solution_file' in task
         })
-    
-    # Trier par heure de début (plus récent en premier)
-    task_list.sort(key=lambda x: x['start_time'], reverse=True)
-    
-    return jsonify(task_list)
+    return jsonify(tasks_info)
 
-@app.route('/cleanup')
-def cleanup_temp_files():
-    """Nettoyer les fichiers temporaires"""
-    try:
-        temp_files_deleted = 0
-        for filename in os.listdir(RESULTS_FOLDER):
-            if filename.startswith('temp_results_') and filename.endswith('.json'):
-                file_path = os.path.join(RESULTS_FOLDER, filename)
-                os.remove(file_path)
-                temp_files_deleted += 1
-        
-        return jsonify({
-            'message': f'{temp_files_deleted} fichiers temporaires supprimés'
-        })
-    except Exception as e:
-        return jsonify({'error': f'Erreur lors du nettoyage: {str(e)}'}), 500
+# ==============================================================================
+# TEMPLATE HTML
+# ==============================================================================
 
-@app.route('/preview/<task_id>')
-def preview_results(task_id):
-    """Aperçu des résultats JSON pour debug"""
-    task = task_manager.get_task(task_id)
-    if not task:
-        return jsonify({'error': 'Tâche non trouvée'}), 404
-    
-    results_file = os.path.join(RESULTS_FOLDER, f'results_{task_id}.json')
-    
-    if not os.path.exists(results_file):
-        return jsonify({'error': 'Fichier de résultats non trouvé'}), 404
-    
-    try:
-        with open(results_file, 'r', encoding='utf-8') as f:
-            data = json.load(f)
-        
-        # Retourner un aperçu des données
-        preview = {
-            "metadata": data.get("metadata", {}),
-            "summary": data.get("summary", {}),
-            "sample_requests": data.get("requests", [])[:3],  # 3 premiers échantillons
-            "total_requests": len(data.get("requests", []))
+@app.route('/template')
+def get_template():
+    template_content = '''<!DOCTYPE html>
+<html lang="fr">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Résolveur Mathématique IMO</title>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/4.0.4/socket.io.js"></script>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body { 
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; 
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            padding: 20px;
+        }
+        .container { 
+            max-width: 1200px; 
+            margin: 0 auto; 
+            background: white; 
+            border-radius: 15px;
+            box-shadow: 0 20px 40px rgba(0,0,0,0.1);
+            overflow: hidden;
+        }
+        .header {
+            background: linear-gradient(135deg, #2196F3, #21CBF3);
+            padding: 30px;
+            text-align: center;
+            color: white;
         }
+        .header h1 { font-size: 2.5em; margin-bottom: 10px; }
+        .header p { font-size: 1.1em; opacity: 0.9; }
         
-        return jsonify(preview)
-    
-    except Exception as e:
-        return jsonify({'error': f'Erreur lors de la lecture du fichier: {str(e)}'}), 500
+        .upload-section {
+            padding: 40px;
+            text-align: center;
+            border-bottom: 1px solid #eee;
+        }
+        .upload-box {
+            border: 3px dashed #ddd;
+            border-radius: 10px;
+            padding: 40px;
+            transition: all 0.3s ease;
+            cursor: pointer;
+        }
+        .upload-box:hover { border-color: #2196F3; background: #f8f9ff; }
+        .upload-box.dragover { border-color: #2196F3; background: #e3f2fd; }
+        
+        .btn {
+            background: linear-gradient(135deg, #2196F3, #21CBF3);
+            color: white;
+            padding: 12px 30px;
+            border: none;
+            border-radius: 25px;
+            font-size: 16px;
+            cursor: pointer;
+            transition: all 0.3s ease;
+        }
+        .btn:hover { transform: translateY(-2px); box-shadow: 0 5px 15px rgba(33,150,243,0.3); }
+        
+        .logs-section {
+            display: flex;
+            height: 600px;
+        }
+        .extracted-text {
+            flex: 1;
+            padding: 20px;
+            border-right: 1px solid #eee;
+        }
+        .logs-panel {
+            flex: 1;
+            padding: 20px;
+        }
+        .log-container {
+            height: 500px;
+            overflow-y: auto;
+            background: #1e1e1e;
+            color: #fff;
+            padding: 15px;
+            border-radius: 8px;
+            font-family: 'Courier New', monospace;
+            font-size: 13px;
+        }
+        .log-entry {
+            margin-bottom: 5px;
+            padding: 5px;
+            border-radius: 3px;
+        }
+        .log-info { color: #4CAF50; }
+        .log-success { color: #8BC34A; background: rgba(139,195,74,0.1); }
+        .log-warning { color: #FF9800; }
+        .log-error { color: #F44336; background: rgba(244,67,54,0.1); }
+        
+        .status-bar {
+            padding: 20px;
+            background: #f5f5f5;
+            text-align: center;
+        }
+        .status-badge {
+            display: inline-block;
+            padding: 8px 16px;
+            border-radius: 20px;
+            font-weight: bold;
+            text-transform: uppercase;
+        }
+        .status-processing { background: #FFC107; color: #333; }
+        .status-completed { background: #4CAF50; color: white; }
+        .status-failed { background: #F44336; color: white; }
+        
+        .download-section {
+            padding: 20px;
+            text-align: center;
+            display: none;
+        }
+        .hidden { display: none; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>🧮 Résolveur Mathématique IMO</h1>
+            <p>Uploadez une image de votre problème mathématique et obtenez une solution rigoureuse</p>
+        </div>
+        
+        <div class="upload-section">
+            <div class="upload-box" id="uploadBox">
+                <h3>📁 Glisser-déposer votre image ici</h3>
+                <p>ou cliquez pour sélectionner un fichier</p>
+                <input type="file" id="fileInput" accept="image/*" style="display: none;">
+                <button class="btn" onclick="document.getElementById('fileInput').click()">
+                    Choisir un fichier
+                </button>
+            </div>
+        </div>
+        
+        <div class="status-bar">
+            <div id="statusBadge" class="status-badge" style="display: none;">En attente</div>
+            <div id="taskInfo" style="margin-top: 10px; display: none;"></div>
+        </div>
+        
+        <div class="logs-section hidden" id="logsSection">
+            <div class="extracted-text">
+                <h3>📝 Texte extrait de l'image</h3>
+                <div id="extractedText" style="background: #f9f9f9; padding: 15px; border-radius: 8px; margin-top: 10px; white-space: pre-wrap; max-height: 450px; overflow-y: auto;"></div>
+            </div>
+            <div class="logs-panel">
+                <h3>📊 Logs de traitement en temps réel</h3>
+                <div id="logContainer" class="log-container"></div>
+            </div>
+        </div>
+        
+        <div class="download-section" id="downloadSection">
+            <h3>✅ Solution prête !</h3>
+            <button class="btn" id="downloadBtn">📥 Télécharger la solution</button>
+        </div>
+    </div>
+
+    <script>
+        const socket = io();
+        let currentTaskId = null;
+        
+        // Gestion de l'upload
+        const uploadBox = document.getElementById('uploadBox');
+        const fileInput = document.getElementById('fileInput');
+        
+        uploadBox.addEventListener('click', () => fileInput.click());
+        uploadBox.addEventListener('dragover', (e) => {
+            e.preventDefault();
+            uploadBox.classList.add('dragover');
+        });
+        uploadBox.addEventListener('dragleave', () => {
+            uploadBox.classList.remove('dragover');
+        });
+        uploadBox.addEventListener('drop', (e) => {
+            e.preventDefault();
+            uploadBox.classList.remove('dragover');
+            const files = e.dataTransfer.files;
+            if (files.length > 0) {
+                uploadFile(files[0]);
+            }
+        });
+        
+        fileInput.addEventListener('change', (e) => {
+            if (e.target.files.length > 0) {
+                uploadFile(e.target.files[0]);
+            }
+        });
+        
+        function uploadFile(file) {
+            const formData = new FormData();
+            formData.append('file', file);
+            
+            updateStatus('processing', 'Upload en cours...');
+            
+            fetch('/upload', {
+                method: 'POST',
+                body: formData
+            })
+            .then(response => response.json())
+            .then(data => {
+                if (data.error) {
+                    updateStatus('failed', data.error);
+                } else {
+                    currentTaskId = data.task_id;
+                    document.getElementById('extractedText').textContent = data.extracted_text;
+                    document.getElementById('logsSection').classList.remove('hidden');
+                    updateStatus('processing', 'Résolution en cours...');
+                }
+            })
+            .catch(error => {
+                updateStatus('failed', 'Erreur lors de l\'upload');
+                console.error('Error:', error);
+            });
+        }
+        
+        function updateStatus(status, message) {
+            const badge = document.getElementById('statusBadge');
+            const info = document.getElementById('taskInfo');
+            
+            badge.style.display = 'inline-block';
+            badge.className = `status-badge status-${status}`;
+            badge.textContent = status === 'processing' ? 'En cours' : 
+                              status === 'completed' ? 'Terminé' : 'Échec';
+            
+            info.style.display = 'block';
+            info.textContent = message;
+        }
+        
+        function addLog(timestamp, level, message) {
+            const container = document.getElementById('logContainer');
+            const logEntry = document.createElement('div');
+            logEntry.className = `log-entry log-${level}`;
+            logEntry.innerHTML = `<span style="color: #666;">[${timestamp}]</span> ${message}`;
+            container.appendChild(logEntry);
+            container.scrollTop = container.scrollHeight;
+        }
+        
+        // WebSocket events
+        socket.on('log_update', (data) => {
+            if (data.task_id === currentTaskId) {
+                addLog(data.log.timestamp, data.log.level, data.log.message);
+            }
+        });
+        
+        socket.on('task_completed', (data) => {
+            if (data.task_id === currentTaskId) {
+                updateStatus('completed', 'Solution générée avec succès !');
+                const downloadSection = document.getElementById('downloadSection');
+                downloadSection.style.display = 'block';
+                
+                document.getElementById('downloadBtn').onclick = () => {
+                    window.location.href = `/download/${currentTaskId}`;
+                };
+            }
+        });
+        
+        socket.on('task_failed', (data) => {
+            if (data.task_id === currentTaskId) {
+                updateStatus('failed', 'Échec de la résolution (solution partielle disponible)');
+                const downloadSection = document.getElementById('downloadSection');
+                downloadSection.style.display = 'block';
+                
+                document.getElementById('downloadBtn').onclick = () => {
+                    window.location.href = `/download/${currentTaskId}`;
+                };
+            }
+        });
+        
+        socket.on('task_error', (data) => {
+            if (data.task_id === currentTaskId) {
+                updateStatus('failed', `Erreur: ${data.error}`);
+            }
+        });
+    </script>
+</body>
+</html>'''
+    return template_content
 
 if __name__ == '__main__':
-    print("🚀 Démarrage du serveur Flask...")
-    print("📂 Dossiers créés:", UPLOAD_FOLDER, RESULTS_FOLDER)
-    print("🌐 Application disponible sur: http://localhost:5000")
-    print("📊 Sortie JSON structurée activée avec schémas Pydantic")
-    print("🔧 Modèle utilisé:", MODEL_ID)
-    app.run(debug=True, threaded=True)
+    # Créer le template dans le dossier templates
+    os.makedirs('templates', exist_ok=True)
+    with open('templates/index.html', 'w', encoding='utf-8') as f:
+        # Récupérer le contenu du template depuis la route
+        from flask import Flask
+        temp_app = Flask(__name__)
+        with temp_app.app_context():
+            template_content = get_template()
+            f.write(template_content)
+    
+    print("🚀 Démarrage de l'application Flask...")
+    print("📝 Template HTML créé dans templates/index.html")
+    print("🌐 Application disponible sur http://localhost:5000")
+    
+    socketio.run(app, debug=True, host='0.0.0.0', port=5000)