Delete game_engine.py

game_engine.py

@@ -1,724 +0,0 @@
-# ==========================================
-# game_engine.py - Calcul OCR v3.0
-# ==========================================
-
-"""
-Moteur de jeu mathématique complet
-"""
-
-import random
-import time
-import datetime
-import gradio as gr
-import os
-import uuid
-import gc
-import base64
-from io import BytesIO
-import numpy as np
-from PIL import Image
-import threading
-import queue
-from typing import Dict, Tuple, Optional
-
-# Auto-détection intelligente CPU/GPU avec fallbacks
-ocr_module = None
-ocr_info = {"model_name": "Unknown", "device": "Unknown"}
-
-# Tentative 1: GPU/TrOCR (si disponible et packages installés)
-try:
-    import torch
-    if torch.cuda.is_available():
-        from image_processing_gpu import (
-            recognize_number_fast_with_image, 
-            create_thumbnail_fast, 
-            create_white_canvas,
-            cleanup_memory,
-            log_memory_usage,
-            get_ocr_model_info
-        )
-        ocr_module = "gpu"
-        print("✅ Mode GPU détecté - TrOCR activé")
-    else:
-        raise ImportError("GPU non disponible")
-except (ImportError, Exception) as e:
-    print(f"⚠️ GPU/TrOCR non disponible: {e}")
-    
-    # Tentative 2: CPU/EasyOCR (fallback)
-    try:
-        from image_processing_cpu import (
-            recognize_number_fast_with_image, 
-            create_thumbnail_fast, 
-            create_white_canvas,
-            cleanup_memory,
-            log_memory_usage,
-            get_ocr_model_info
-        )
-        ocr_module = "cpu"
-        print("✅ Mode CPU détecté - EasyOCR activé")
-    except ImportError:
-        
-        # Tentative 3: Fallback vers ancien fichier (sécurité)
-        try:
-            from image_processing import (
-                recognize_number_fast_with_image, 
-                create_thumbnail_fast, 
-                create_white_canvas,
-                cleanup_memory,
-                log_memory_usage
-            )
-            def get_ocr_model_info():
-                return {"model_name": "Legacy", "device": "Unknown"}
-            ocr_module = "legacy"
-            print("⚠️ Fallback vers image_processing.py legacy")
-        except ImportError:
-            print("❌ ERREUR: Aucun module OCR disponible!")
-            raise
-
-# Récupérer les infos du modèle sélectionné
-try:
-    ocr_info = get_ocr_model_info()
-    print(f"🎯 OCR sélectionné: {ocr_info['model_name']} sur {ocr_info['device']}")
-except:
-    print("⚠️ Impossible de récupérer les infos OCR")
-
-# Imports dataset avec gestion d'erreur
-try:
-    from datasets import Dataset, load_dataset
-    DATASET_AVAILABLE = True
-    print("✅ Modules dataset disponibles")
-except ImportError as e:
-    DATASET_AVAILABLE = False
-    print(f"⚠️ Modules dataset non disponibles: {e}")
-
-# Nom du nouveau dataset
-DATASET_NAME = "hoololi/calcul_ocr_dataset"
-
-# Configuration des difficultés par opération
-DIFFICULTY_RANGES = {
-    "×": {
-        "Facile": (2, 9),
-        "Difficile": (4, 12)
-    },
-    "+": {
-        "Facile": (1, 50),
-        "Difficile": (10, 100)
-    },
-    "-": {
-        "Facile": (1, 50),
-        "Difficile": (10, 100)
-    },
-    "÷": {
-        "Facile": (1, 10),    # Pour les résultats
-        "Difficile": (2, 12)  # Pour les résultats
-    }
-}
-
-def create_result_row_with_images(i: int, image: dict | np.ndarray | Image.Image, expected: int, operation_data: tuple[int, int, str, int]) -> dict:
-    
-    # OCR optimisé
-    recognized, optimized_image, dataset_image_data = recognize_number_fast_with_image(image)
-    
-    try:
-        recognized_num = int(recognized) if recognized.isdigit() else 0
-    except:
-        recognized_num = 0
-
-    is_correct = recognized_num == expected
-    a, b, operation, correct_result = operation_data
-
-    status_icon = "✅" if is_correct else "❌"
-    status_text = "Correct" if is_correct else "Incorrect"
-    row_color = "#e8f5e8" if is_correct else "#ffe8e8"
-    
-    # Miniature
-    image_thumbnail = create_thumbnail_fast(optimized_image, size=(50, 50))
-    
-    # Libérer mémoire
-    if optimized_image and hasattr(optimized_image, 'close'):
-        try:
-            optimized_image.close()
-        except:
-            pass
-
-    return {
-        'html_row': f"""
-            <tr style="background-color: {row_color};">
-                <td style="text-align: center; padding: 8px; border: 1px solid #ddd; color: #333;">{i+1}</td>
-                <td style="text-align: center; padding: 8px; border: 1px solid #ddd; font-weight: bold; color: #333;">{a}</td>
-                <td style="text-align: center; padding: 8px; border: 1px solid #ddd; font-weight: bold; color: #333;">{operation}</td>
-                <td style="text-align: center; padding: 8px; border: 1px solid #ddd; font-weight: bold; color: #333;">{b}</td>
-                <td style="text-align: center; padding: 8px; border: 1px solid #ddd; font-weight: bold; color: #333;">{expected}</td>
-                <td style="text-align: center; padding: 8px; border: 1px solid #ddd;">{image_thumbnail}</td>
-                <td style="text-align: center; padding: 8px; border: 1px solid #ddd; font-weight: bold; color: #333;">{recognized_num}</td>
-                <td style="text-align: center; padding: 8px; border: 1px solid #ddd; color: #333;">{status_icon} {status_text}</td>
-            </tr>
-        """,
-        'is_correct': is_correct,
-        'recognized': recognized,
-        'recognized_num': recognized_num,
-        'dataset_image_data': dataset_image_data
-    }
-
-
-class MathGame:
-    """Moteur de jeu mathématique avec traitement parallèle"""
-    
-    def __init__(self):
-        self.is_running = False
-        self.start_time = 0
-        self.current_operation = ""
-        self.correct_answer = 0
-        self.user_images = []
-        self.expected_answers = []
-        self.operations_history = []
-        self.question_count = 0
-        self.time_remaining = 30
-        self.session_data = []
-        
-        # Configuration session
-        self.duration = 30
-        self.operation_type = "×"
-        self.difficulty = "Facile"
-        
-        # Gestion export
-        self.export_status = "not_exported"
-        self.export_timestamp = None
-        self.export_result = None
-        
-        # NOUVEAU: Traitement parallèle
-        self.processing_queue = queue.Queue()
-        self.results_cache: Dict[int, dict] = {}  # {question_number: result_data}
-        self.worker_thread: Optional[threading.Thread] = None
-        self.processing_active = False
-
-    def _start_background_processing(self) -> None:
-        """Démarre le thread de traitement en arrière-plan"""
-        if self.worker_thread is None or not self.worker_thread.is_alive():
-            self.processing_active = True
-            self.worker_thread = threading.Thread(target=self._process_images_worker, daemon=True)
-            self.worker_thread.start()
-            print("🔄 Thread de traitement parallèle démarré")
-
-    def _stop_background_processing(self) -> None:
-        """Arrête le thread de traitement"""
-        self.processing_active = False
-        if self.worker_thread and self.worker_thread.is_alive():
-            print("⏹️ Arrêt du thread de traitement parallèle")
-
-    def _process_images_worker(self) -> None:
-        """Worker thread qui traite les images en arrière-plan"""
-        print("🚀 Worker thread démarré")
-        while self.processing_active:
-            try:
-                if not self.processing_queue.empty():
-                    question_num, image, expected, operation_data = self.processing_queue.get(timeout=1)
-                    print(f"🔄 Traitement parallèle image {question_num}...")
-                    
-                    start_time = time.time()
-                    result_data = create_result_row_with_images(question_num, image, expected, operation_data)
-                    processing_time = time.time() - start_time
-                    
-                    # Stocker le résultat
-                    self.results_cache[question_num] = result_data
-                    print(f"✅ Image {question_num} traitée en {processing_time:.1f}s (parallèle)")
-                    
-                else:
-                    time.sleep(0.1)  # Éviter la consommation CPU excessive
-                    
-            except queue.Empty:
-                continue
-            except Exception as e:
-                print(f"❌ Erreur traitement parallèle: {e}")
-                
-        print("🛑 Worker thread terminé")
-
-    def _add_image_to_processing_queue(self, question_num: int, image: dict | np.ndarray | Image.Image, 
-                                     expected: int, operation_data: tuple) -> None:
-        """Ajoute une image à la queue de traitement"""
-        if image is not None:
-            self.processing_queue.put((question_num, image, expected, operation_data))
-            print(f"📝 Image {question_num} ajoutée à la queue de traitement")
-        return {
-            "status": self.export_status,
-            "timestamp": self.export_timestamp,
-            "result": self.export_result,
-            "can_export": self.export_status == "not_exported" and len(self.session_data) > 0
-        }
-
-    def mark_export_in_progress(self) -> None:
-        self.export_status = "exporting"
-        self.export_timestamp = datetime.datetime.now().isoformat()
-
-    def mark_export_completed(self, result: str) -> None:
-        self.export_status = "exported"
-        self.export_result = result
-
-    def generate_multiplication(self, difficulty: str) -> tuple[str, int]:
-        """Génère une multiplication"""
-        min_val, max_val = DIFFICULTY_RANGES["×"][difficulty]
-        a = random.randint(min_val, max_val)
-        b = random.randint(min_val, max_val)
-        return f"{a} × {b}", a * b
-
-    def generate_addition(self, difficulty: str) -> tuple[str, int]:
-        """Génère une addition"""
-        min_val, max_val = DIFFICULTY_RANGES["+"][difficulty]
-        a = random.randint(min_val, max_val)
-        b = random.randint(min_val, max_val)
-        return f"{a} + {b}", a + b
-
-    def generate_subtraction(self, difficulty: str) -> tuple[str, int]:
-        """Génère une soustraction (résultat toujours positif)"""
-        min_val, max_val = DIFFICULTY_RANGES["-"][difficulty]
-        a = random.randint(min_val, max_val)
-        b = random.randint(min_val, a)  # b <= a pour éviter les négatifs
-        return f"{a} - {b}", a - b
-
-    def generate_division(self, difficulty: str) -> tuple[str, int]:
-        """Génère une division exacte"""
-        min_result, max_result = DIFFICULTY_RANGES["÷"][difficulty]
-        result = random.randint(min_result, max_result)
-        if difficulty == "Facile":
-            divisor = random.randint(2, 9)
-        else:
-            divisor = random.randint(2, 12)
-        dividend = result * divisor
-        return f"{dividend} ÷ {divisor}", result
-
-    def generate_operation(self, operation_type: str, difficulty: str) -> tuple[str, int]:
-        """Génère une opération selon le type et la difficulté"""
-        if operation_type == "×":
-            return self.generate_multiplication(difficulty)
-        elif operation_type == "+":
-            return self.generate_addition(difficulty)
-        elif operation_type == "-":
-            return self.generate_subtraction(difficulty)
-        elif operation_type == "÷":
-            return self.generate_division(difficulty)
-        elif operation_type == "Aléatoire":
-            # Choisir aléatoirement une opération
-            random_op = random.choice(["×", "+", "-", "÷"])
-            return self.generate_operation(random_op, difficulty)
-        else:
-            # Par défaut, multiplication
-            return self.generate_multiplication(difficulty)
-
-    def start_game(self, duration: str, operation: str, difficulty: str) -> tuple[str, Image.Image, str, str, gr.update, gr.update, str]:
-        """Démarre le jeu avec la configuration choisie"""
-        
-        # log_memory_usage("avant nettoyage start_game")  # DEBUG: Désactivé
-        
-        # Configuration
-        self.duration = 60 if duration == "60 secondes" else 30
-        self.operation_type = operation
-        self.difficulty = difficulty
-        
-        # Nettoyage
-        if hasattr(self, 'user_images') and self.user_images:
-            for img in self.user_images:
-                if hasattr(img, 'close'):
-                    try:
-                        img.close()
-                    except:
-                        pass
-        
-        if hasattr(self, 'session_data') and self.session_data:
-            for entry in self.session_data:
-                if 'user_drawing' in entry and entry['user_drawing']:
-                    entry['user_drawing'] = None
-            self.session_data.clear()
-        
-        # Réinit avec nettoyage parallèle
-        self._stop_background_processing()
-        self.results_cache.clear()
-        while not self.processing_queue.empty():
-            try:
-                self.processing_queue.get_nowait()
-            except queue.Empty:
-                break
-        
-        self.is_running = True
-        self.start_time = time.time()
-        self.user_images = []
-        self.expected_answers = []
-        self.operations_history = []
-        self.question_count = 0
-        self.time_remaining = self.duration
-        self.session_data = []
-        
-        # Reset export
-        self.export_status = "not_exported"
-        self.export_timestamp = None
-        self.export_result = None
-        
-        # Démarrer le traitement parallèle
-        self._start_background_processing()
-        
-        gc.collect()
-        # log_memory_usage("après nettoyage start_game")  # DEBUG: Désactivé
-
-        # Première opération
-        operation_str, answer = self.generate_operation(self.operation_type, self.difficulty)
-        self.current_operation = operation_str
-        self.correct_answer = answer
-
-        # Parser l'opération pour l'historique
-        parts = operation_str.split()
-        a, op, b = int(parts[0]), parts[1], int(parts[2])
-        self.operations_history.append((a, b, op, answer))
-
-        # Affichage adapté selon l'opération
-        operation_emoji = {
-            "×": "✖️", "+": "➕", "-": "➖", "÷": "➗", "Aléatoire": "🎲"
-        }
-        emoji = operation_emoji.get(self.operation_type, "🔢")
-
-        return (
-            f'<div style="font-size: 3em; font-weight: bold; text-align: center; padding: 20px; background: linear-gradient(45deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px;">{operation_str}</div>',
-            create_white_canvas(),
-            f"🎯 {emoji} {self.operation_type} • {self.difficulty} • Écrivez votre réponse !",
-            f"⏱️ Temps restant: {self.time_remaining}s",
-            gr.update(interactive=False),
-            gr.update(interactive=True),
-            ""
-        )
-
-    def next_question(self, image_data: dict | np.ndarray | Image.Image | None) -> tuple[str, Image.Image, str, str, gr.update, gr.update, str]:
-        if not self.is_running:
-            return (
-                f'<div style="font-size: 3em; font-weight: bold; text-align: center; padding: 20px; background: linear-gradient(45deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px;">{self.current_operation}</div>',
-                image_data,
-                "❌ Le jeu n'est pas en cours !",
-                "⏱️ Temps: 0s",
-                gr.update(interactive=True),
-                gr.update(interactive=False),
-                ""
-            )
-
-        elapsed_time = time.time() - self.start_time
-        if elapsed_time >= self.duration:
-            return self.end_game(image_data)
-
-        if image_data is not None:
-            # Ajouter l'image à la liste ET au traitement parallèle
-            self.user_images.append(image_data)
-            self.expected_answers.append(self.correct_answer)
-            
-            # Parser l'opération actuelle pour le traitement
-            parts = self.current_operation.split()
-            a, op, b = int(parts[0]), parts[1], int(parts[2])
-            current_operation_data = (a, b, op, self.correct_answer)
-            
-            # Lancer le traitement en parallèle de l'image qu'on vient de recevoir
-            self._add_image_to_processing_queue(self.question_count, image_data, self.correct_answer, current_operation_data)
-            
-            self.question_count += 1
-
-        # Nouvelle opération
-        operation_str, answer = self.generate_operation(self.operation_type, self.difficulty)
-        self.current_operation = operation_str
-        self.correct_answer = answer
-
-        # Parser pour l'historique
-        parts = operation_str.split()
-        a, op, b = int(parts[0]), parts[1], int(parts[2])
-        self.operations_history.append((a, b, op, answer))
-
-        time_remaining = max(0, self.duration - int(elapsed_time))
-        self.time_remaining = time_remaining
-
-        if time_remaining <= 0:
-            return self.end_game(image_data)
-
-        # Emoji pour l'opération
-        operation_emoji = {
-            "×": "✖️", "+": "➕", "-": "➖", "÷": "➗", "Aléatoire": "🎲"
-        }
-        emoji = operation_emoji.get(self.operation_type, "🔢")
-
-        return (
-            f'<div style="font-size: 3em; font-weight: bold; text-align: center; padding: 20px; background: linear-gradient(45deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px;">{operation_str}</div>',
-            create_white_canvas(),
-            f"🎯 {emoji} Question {self.question_count + 1} • {self.difficulty}",
-            f"⏱️ Temps restant: {time_remaining}s",
-            gr.update(interactive=False),
-            gr.update(interactive=True),
-            ""
-        )
-
-    def end_game(self, final_image: dict | np.ndarray | Image.Image | None) -> tuple[str, Image.Image, str, str, gr.update, gr.update, str]:
-
-        self.is_running = False
-        
-        # log_memory_usage("début end_game")  # DEBUG: Désactivé
-
-        if final_image is not None:
-            self.user_images.append(final_image)
-            self.expected_answers.append(self.correct_answer)
-            self.question_count += 1
-            if len(self.operations_history) < len(self.user_images):
-                parts = self.current_operation.split()
-                a, op, b = int(parts[0]), parts[1], int(parts[2])
-                self.operations_history.append((a, b, op, self.correct_answer))
-
-        correct_answers = 0
-        total_questions = len(self.user_images)
-        table_rows_html = ""
-        
-        session_timestamp = datetime.datetime.now().isoformat()
-        session_id = f"session_{int(datetime.datetime.now().timestamp())}_{str(uuid.uuid4())[:8]}"
-        
-        self.session_data = []
-        images_saved = 0
-        total_image_size_kb = 0
-        
-        # Traitement optimisé avec DEBUG
-        print(f"🔄 Traitement de {total_questions} images...")
-        start_processing = time.time()
-        
-        for i, (image, expected, operation_data) in enumerate(zip(self.user_images, self.expected_answers, self.operations_history)):
-            print(f"  → Image {i+1}/{total_questions}...")
-            img_start = time.time()
-            
-            row_data = create_result_row_with_images(i, image, expected, operation_data)
-            table_rows_html += row_data['html_row']
-            
-            img_time = time.time() - img_start
-            print(f"    ✅ Traitée en {img_time:.1f}s")
-            
-            if row_data['is_correct']:
-                correct_answers += 1
-                
-            # Structure pour NOUVEAU DATASET CALCUL OCR
-            a, b, operation, correct_result = operation_data
-            
-            entry = {
-                "session_id": session_id,
-                "timestamp": session_timestamp,
-                "question_number": i + 1,
-                
-                # Configuration session
-                "session_duration": self.duration,
-                "operation_type": self.operation_type,
-                "difficulty_level": self.difficulty,
-                
-                # Mathématiques
-                "operand_a": a,
-                "operand_b": b,
-                "operation": operation,
-                "correct_answer": expected,
-                
-                # OCR & Résultats avec détection automatique du modèle
-                ocr_info = get_ocr_model_info()
-                "ocr_model": ocr_info.get("model_name", "Unknown"),
-                "ocr_device": ocr_info.get("device", "Unknown"),
-                "user_answer_ocr": row_data['recognized'],
-                "user_answer_parsed": row_data['recognized_num'],
-                "is_correct": row_data['is_correct'],
-                
-                # Métadonnées
-                "total_questions": total_questions,
-                "app_version": "3.0_calcul_ocr_parallel"  # Mis à jour pour le parallélisme
-            }
-            
-            # Ajouter image si disponible
-            if row_data['dataset_image_data']:
-                entry["handwriting_image"] = row_data['dataset_image_data']["image_base64"]
-                entry["image_width"] = int(row_data['dataset_image_data']["compressed_size"][0])
-                entry["image_height"] = int(row_data['dataset_image_data']["compressed_size"][1])
-                entry["image_size_kb"] = float(row_data['dataset_image_data']["file_size_kb"])
-                entry["has_image"] = True
-                images_saved += 1
-                total_image_size_kb += row_data['dataset_image_data']["file_size_kb"]
-            else:
-                entry["has_image"] = False
-                
-            self.session_data.append(entry)
-
-        processing_time = time.time() - start_processing
-        print(f"⏱️ Traitement total: {processing_time:.1f}s")
-
-        accuracy = (correct_answers / total_questions * 100) if total_questions > 0 else 0
-        
-        for entry in self.session_data:
-            entry["session_accuracy"] = accuracy
-
-        # Nettoyage mémoire
-        for img in self.user_images:
-            if hasattr(img, 'close'):
-                try:
-                    img.close()
-                except:
-                    pass
-        
-        gc.collect()
-        # log_memory_usage("après nettoyage end_game")  # DEBUG: Désactivé
-
-        # HTML résultats
-        table_html = f"""
-        <div style="overflow-x: auto; margin: 20px 0;">
-            <table style="width: 100%; border-collapse: collapse; border: 2px solid #4a90e2;">
-                <thead>
-                    <tr style="background: #4a90e2; color: white;">
-                        <th style="padding: 8px;">Question</th>
-                        <th style="padding: 8px;">A</th>
-                        <th style="padding: 8px;">Op</th>
-                        <th style="padding: 8px;">B</th>
-                        <th style="padding: 8px;">Réponse</th>
-                        <th style="padding: 8px;">Votre dessin</th>
-                        <th style="padding: 8px;">OCR</th>
-                        <th style="padding: 8px;">Statut</th>
-                    </tr>
-                </thead>
-                <tbody>
-                    {table_rows_html}
-                </tbody>
-            </table>
-        </div>
-        """
-
-        # Configuration session pour affichage
-        config_display = f"{self.operation_type} • {self.difficulty} • {self.duration}s"
-        operation_emoji = {
-            "×": "✖️", "+": "➕", "-": "➖", "÷": "➗", "Aléatoire": "🎲"
-        }
-        emoji = operation_emoji.get(self.operation_type, "🔢")
-
-        export_info = self.get_export_status()
-        if export_info["can_export"]:
-            export_section = f"""
-            <div style="margin-top: 20px; padding: 15px; background-color: #e8f5e8; border-radius: 8px;">
-                <h3 style="color: #2e7d32;">📤 Ajouter cette série au dataset ?</h3>
-                <p style="color: #2e7d32;">
-                    ✅ {total_questions} réponses • 📊 {accuracy:.1f}% de précision<br>
-                    📸 {images_saved} opérations et images sauvegardées ({total_image_size_kb:.1f}KB)<br>
-                    ⚙️ Configuration: {config_display}
-                </p>
-            </div>
-            """
-        else:
-            export_section = ""
-
-        final_results = f"""
-        <div style="margin: 20px 0;">
-            <h1 style="text-align: center; color: #4a90e2;">🎉 Session terminée !</h1>
-            <div style="background: linear-gradient(45deg, #667eea 0%, #764ba2 100%); color: white; padding: 20px; border-radius: 10px; margin: 20px 0;">
-                <h2>📈 Résultats</h2>
-                <div style="text-align: center; margin-bottom: 15px;">
-                    <strong>{emoji} {config_display}</strong>
-                </div>
-                <div style="display: flex; justify-content: space-around; flex-wrap: wrap;">
-                    <div style="text-align: center; margin: 10px;">
-                        <div style="font-size: 2em; font-weight: bold;">{total_questions}</div>
-                        <div>Questions</div>
-                    </div>
-                    <div style="text-align: center; margin: 10px;">
-                        <div style="font-size: 2em; font-weight: bold; color: #90EE90;">{correct_answers}</div>
-                        <div>Correctes</div>
-                    </div>
-                    <div style="text-align: center; margin: 10px;">
-                        <div style="font-size: 2em; font-weight: bold; color: #FFB6C1;">{total_questions - correct_answers}</div>
-                        <div>Incorrectes</div>
-                    </div>
-                    <div style="text-align: center; margin: 10px;">
-                        <div style="font-size: 2em; font-weight: bold;">{accuracy:.1f}%</div>
-                        <div>Précision</div>
-                    </div>
-                </div>
-            </div>
-            <h2 style="color: #4a90e2;">📊 Détail des Réponses</h2>
-            {table_html}
-            {export_section}
-        </div>
-        """
-
-        return (
-            """<div style="font-size: 3em; font-weight: bold; text-align: center; padding: 20px; background: linear-gradient(45deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px;">🏁 C'est fini !</div>""",
-            create_white_canvas(),
-            f"✨ Session {config_display} terminée !",
-            "⏱️ Temps écoulé !",
-            gr.update(interactive=True),
-            gr.update(interactive=False),
-            final_results
-        )
-
-
-def export_to_clean_dataset(session_data: list[dict], dataset_name: str = DATASET_NAME) -> str:
-    """Export vers le nouveau dataset calcul_ocr_dataset"""
-    if not DATASET_AVAILABLE:
-        return "❌ Modules dataset non disponibles"
-    
-    hf_token = os.getenv("HF_TOKEN") or os.getenv("tk_calcul_ocr")  # Support des deux noms
-    if not hf_token:
-        return "❌ Token HuggingFace manquant (HF_TOKEN ou tk_calcul_ocr)"
-    
-    try:
-        print(f"\n🚀 === EXPORT VERS DATASET CALCUL OCR ===")
-        print(f"📊 Dataset: {dataset_name}")
-        
-        # Filtrer les entrées avec images
-        clean_entries = []
-        
-        for entry in session_data:
-            if entry.get('has_image', False):
-                clean_entries.append(entry)
-        
-        print(f"✅ {len(clean_entries)} entrées avec images converties")
-        
-        if len(clean_entries) == 0:
-            return "❌ Aucune entrée avec image à exporter"
-        
-        # Charger dataset existant OU créer nouveau
-        try:
-            existing_dataset = load_dataset(dataset_name, split="train")
-            existing_data = existing_dataset.to_list()
-            print(f"📊 {len(existing_data)} entrées existantes")
-        except:
-            existing_data = []
-            print("📊 Création nouveau dataset calcul_ocr")
-        
-        # Combiner
-        combined_data = existing_data + clean_entries
-        clean_dataset = Dataset.from_list(combined_data)
-        
-        print(f"✅ Dataset créé - Features:")
-        for feature_name in clean_dataset.features:
-            print(f"  - {feature_name}: {clean_dataset.features[feature_name]}")
-        
-        # Statistiques par opération
-        operations_count = {}
-        for entry in clean_entries:
-            op = entry.get('operation_type', 'unknown')
-            operations_count[op] = operations_count.get(op, 0) + 1
-        
-        operations_summary = ", ".join([f"{op}: {count}" for op, count in operations_count.items()])
-        
-        # Push vers HuggingFace  
-        print(f"📤 Push vers {dataset_name}...")
-        clean_dataset.push_to_hub(
-            dataset_name,
-            private=False,
-            token=hf_token,
-            commit_message=f"Add {len(clean_entries)} handwriting samples for math OCR ({operations_summary})"
-        )
-        
-        cleanup_memory()
-        
-        success_message = f"""✅ Session ajoutée au dataset avec succès !
-
-📊 Dataset: {dataset_name}
-📸 Images: {len(clean_entries)}
-🔢 Opérations: {operations_summary}
-📈 Total: {len(clean_dataset)}
-
-🔗 Le dataset est consultable ici : https://huggingface.co/datasets/{dataset_name}"""
-        
-        return success_message
-        
-    except Exception as e:
-        print(f"❌ ERREUR: {e}")
-        import traceback
-        traceback.print_exc()
-        error_message = f"❌ Erreur: {str(e)}"
-        return error_message