Upload game_engine.py

game_engine.py

@@ -1,5 +1,5 @@
 # ==========================================
-# game_engine.py - Calcul OCR v3.0 CLEAN
+# game_engine.py - Calcul OCR v3.0 CLEAN (Modifié)
 # ==========================================
 
 """
@@ -21,76 +21,62 @@ import threading
 import queue
 from typing import Dict, Tuple, Optional
 
-# Auto-détection propre : GPU OU CPU uniquement
-ocr_module = None
-ocr_info = {"model_name": "Unknown", "device": "Unknown"}
+# Import des fonctions utilitaires communes
+from utils import (
+    optimize_image_for_ocr,
+    prepare_image_for_dataset,
+    create_thumbnail_fast,
+    create_white_canvas,
+    log_memory_usage,
+    cleanup_memory,
+    decode_image_from_dataset,
+    validate_ocr_result,
+    analyze_calculation_complexity # Nouvelle importation
+)
 
-# Auto-détection adaptée ZeroGPU
+# Auto-détection propre : GPU OU CPU uniquement
 ocr_module = None
 ocr_info = {"model_name": "Unknown", "device": "Unknown"}
 
 # Debug des variables d'environnement HF
-import os
 space_id = os.getenv("SPACE_ID")
-space_hardware = os.getenv("SPACE_HARDWARE") 
+space_hardware = os.getenv("SPACE_HARDWARE")
 hf_space = os.getenv("HF_SPACE")
 space_author = os.getenv("SPACE_AUTHOR_NAME")
-zero_gpu = os.getenv("ZERO_GPU")  # Variable ZeroGPU
+zero_gpu_env = os.getenv("ZERO_GPU") # Variable ZeroGPU
 
 print(f"🔍 Debug HF Env:")
 print(f"  SPACE_ID: {space_id}")
 print(f"  SPACE_HARDWARE: {space_hardware}")
 print(f"  HF_SPACE: {hf_space}")
 print(f"  SPACE_AUTHOR_NAME: {space_author}")
-print(f"  ZERO_GPU: {zero_gpu}")
-
-# Détecter ZeroGPU (GPU dynamique HF)
-is_zerogpu = space_id and ("hoololi" in str(space_id))  # On est sur HF Spaces
+print(f"  ZERO_GPU: {zero_gpu_env}")
 
-print(f"🎯 ZeroGPU détecté: {is_zerogpu}")
-
-if is_zerogpu:
-    # On est sur ZeroGPU, forcer le mode GPU
-    try:
-        print("🚀 Force mode ZeroGPU - Import GPU...")
-        # Créer un simple import qui satisfait ZeroGPU
-        from simple_gpu import gpu_dummy_function
-        print("✅ Simple GPU importé")
-        
-        # Utiliser le vrai TrOCR qu'on a chargé !
+# ==========================================
+# LOGIQUE DE DÉTECTION OCR AMÉLIORÉE
+# ==========================================
+# Tenter d'importer le module GPU en premier
+try:
+    import torch
+    # Vérifier la disponibilité CUDA ou la variable d'environnement ZeroGPU
+    if torch.cuda.is_available() or zero_gpu_env == "1":
         from image_processing_gpu import (
-            recognize_number_fast_with_image as gpu_recognize,
-            create_thumbnail_fast, 
-            create_white_canvas,
-            cleanup_memory,
-            log_memory_usage,
-            get_ocr_model_info
-        )
-        
-        # Pas de wrapper, utiliser directement TrOCR
-        recognize_number_fast_with_image = gpu_recognize
-        
-        ocr_module = "zerogpu_trocr"
-        print("✅ Game Engine: Mode ZeroGPU - TrOCR directement utilisé")
-        
-    except Exception as e:
-        print(f"❌ Erreur ZeroGPU: {e}")
-        # Fallback CPU pur
-        from image_processing_cpu import (
-            recognize_number_fast_with_image, 
-            create_thumbnail_fast, 
+            recognize_number_fast_with_image,
+            create_thumbnail_fast,
             create_white_canvas,
             cleanup_memory,
             log_memory_usage,
             get_ocr_model_info
         )
-        ocr_module = "cpu"
-        print("✅ Game Engine: Mode CPU - EasyOCR (fallback)")
-else:
-    # Mode local/classique
+        ocr_module = "gpu"
+        print("✅ Game Engine: Mode GPU/ZeroGPU détecté - TrOCR")
+    else:
+        raise ImportError("No CUDA available and ZERO_GPU not set, falling back to CPU") # Force CPU path
+except ImportError as e:
+    print(f"⚠️ GPU/TrOCR non disponible ou erreur: {e}. Fallback CPU...")
     from image_processing_cpu import (
-        recognize_number_fast_with_image, 
-        create_thumbnail_fast, 
+        recognize_number_fast_with_image,
+        create_thumbnail_fast,
         create_white_canvas,
         cleanup_memory,
         log_memory_usage,
@@ -102,19 +88,19 @@ else:
 # 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']}")
+    print(f"🎯 OCR sélectionné: {ocr_info.get('model_name', 'Unknown')} sur {ocr_info.get('device', 'Unknown')}")
 except Exception as e:
     print(f"⚠️ Impossible de récupérer les infos OCR: {e}")
     ocr_info = {"model_name": "Error", "device": "Unknown"}
 
-# Imports dataset avec gestion d'erreur
+# Imports dataset avec gestion d'erreur 
 try:
-    from datasets import Dataset, load_dataset
-    DATASET_AVAILABLE = True
-    print("✅ Modules dataset disponibles")
+    from datasets import Dataset, load_dataset [cite: 2]
+    DATASET_AVAILABLE = True [cite: 2]
+    print("✅ Modules dataset disponibles") [cite: 2]
 except ImportError as e:
-    DATASET_AVAILABLE = False
-    print(f"⚠️ Modules dataset non disponibles: {e}")
+    DATASET_AVAILABLE = False [cite: 2]
+    print(f"⚠️ Modules dataset non disponibles: {e}") [cite: 2]
 
 # Nom du dataset cohérent avec le space
 DATASET_NAME = "hoololi/calcul_ocr_dataset"
@@ -129,21 +115,21 @@ DIFFICULTY_RANGES = {
 
 def create_result_row_with_images(i: int, image: dict | np.ndarray | Image.Image, expected: int, operation_data: tuple[int, int, str, int]) -> dict:
     
-    print(f"🔍 create_result_row_with_images #{i}")
-    print(f"🔍 Expected: {expected}")
-    print(f"🔍 Image type: {type(image)}")
+    # print(f"🔍 create_result_row_with_images #{i}")
+    # print(f"🔍 Expected: {expected}")
+    # print(f"🔍 Image type: {type(image)}")
     
     # OCR optimisé avec debug
     recognized, optimized_image, dataset_image_data = recognize_number_fast_with_image(image, debug=True)
     
-    print(f"🔍 OCR recognized: '{recognized}' (type: {type(recognized)})")
+    # print(f"🔍 OCR recognized: '{recognized}' (type: {type(recognized)})")
     
     try:
         recognized_num = int(recognized) if recognized.isdigit() else 0
     except:
         recognized_num = 0
         
-    print(f"🔍 OCR parsed num: {recognized_num}")
+    # print(f"🔍 OCR parsed num: {recognized_num}")
 
     is_correct = recognized_num == expected
     a, b, operation, correct_result = operation_data
@@ -192,10 +178,10 @@ class MathGame:
         self.correct_answer = 0
         self.user_images = []
         self.expected_answers = []
-        self.operations_history = []
+        self.operations_history = [] # Stocke (a, b, op, correct_result)
         self.question_count = 0
         self.time_remaining = 30
-        self.session_data = []
+        self.session_data = [] # Données complètes de la session pour l'export
         
         # Configuration session
         self.duration = 30
@@ -241,35 +227,40 @@ class MathGame:
         """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")
+            # Optionnel: worker_thread.join(timeout=X) pour attendre la fin, mais peut bloquer l'UI
+            print("⏹️ Arrêt du thread de traitement parallèle demandé")
 
     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)
-                    
+                # Blocage avec timeout pour permettre l'arrêt propre
+                question_num, image, expected, operation_data = self.processing_queue.get(timeout=0.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)")
+                self.processing_queue.task_done() # Indiquer que la tâche est terminée
+
             except queue.Empty:
-                continue
+                continue # Continuer si la queue est vide, ré-vérifier processing_active
             except Exception as e:
                 print(f"❌ Erreur traitement parallèle: {e}")
+                import traceback
+                traceback.print_exc()
+                # Marquer la tâche comme faite même en cas d'erreur pour éviter le blocage
+                if not self.processing_queue.empty():
+                    self.processing_queue.task_done()
                 
         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"""
@@ -333,38 +324,40 @@ class MathGame:
         self.operation_type = operation
         self.difficulty = difficulty
         
-        # Nettoyage
+        # Nettoyage des anciennes images (PIL) et données de session
         if hasattr(self, 'user_images') and self.user_images:
-            for img in self.user_images:
-                if hasattr(img, 'close'):
+            for img_data in self.user_images:
+                # Gradio retourne un dict, le composite peut être une PIL Image ou numpy array
+                if isinstance(img_data, dict) and 'composite' in img_data and hasattr(img_data['composite'], 'close'):
                     try:
-                        img.close()
+                        img_data['composite'].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()
+                elif isinstance(img_data, Image.Image) and hasattr(img_data, 'close'):
+                    try:
+                        img_data.close()
+                    except:
+                        pass
+        self.user_images.clear()
+        self.expected_answers.clear()
+        self.operations_history.clear()
+        self.session_data.clear()
         
         # Réinit avec nettoyage parallèle
         self._stop_background_processing()
         self.results_cache.clear()
+        # Vider la queue pour les nouvelles sessions
         while not self.processing_queue.empty():
             try:
                 self.processing_queue.get_nowait()
+                self.processing_queue.task_done()
             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"
@@ -382,9 +375,13 @@ class MathGame:
         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))
+        parts = operation_str.replace(' ', '').split('×') if '×' in operation_str else \
+                operation_str.replace(' ', '').split('+') if '+' in operation_str else \
+                operation_str.replace(' ', '').split('-') if '-' in operation_str else \
+                operation_str.replace(' ', '').split('÷') # gérer les espaces
+        
+        a, op_char, b = int(parts[0]), operation_str.split()[1], int(parts[2])
+        self.operations_history.append((a, b, op_char, answer))
 
         # Affichage adapté selon l'opération
         operation_emoji = {
@@ -424,9 +421,13 @@ class MathGame:
             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)
+            parts = self.current_operation.replace(' ', '').split('×') if '×' in self.current_operation else \
+                    self.current_operation.replace(' ', '').split('+') if '+' in self.current_operation else \
+                    self.current_operation.replace(' ', '').split('-') if '-' in self.current_operation else \
+                    self.current_operation.replace(' ', '').split('÷')
+            
+            a, op_char, b = int(parts[0]), self.current_operation.split()[1], int(parts[2])
+            current_operation_data = (a, b, op_char, 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)
@@ -439,9 +440,13 @@ class MathGame:
         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))
+        parts = operation_str.replace(' ', '').split('×') if '×' in operation_str else \
+                operation_str.replace(' ', '').split('+') if '+' in operation_str else \
+                operation_str.replace(' ', '').split('-') if '-' in operation_str else \
+                operation_str.replace(' ', '').split('÷')
+        
+        a, op_char, b = int(parts[0]), operation_str.split()[1], int(parts[2])
+        self.operations_history.append((a, b, op_char, answer))
 
         time_remaining = max(0, self.duration - int(elapsed_time))
         self.time_remaining = time_remaining
@@ -469,37 +474,46 @@ class MathGame:
 
         self.is_running = False
         
-        # Arrêter le traitement parallèle
+        # Arrêter le traitement parallèle et attendre qu'il se vide
         self._stop_background_processing()
-        
+        self.processing_queue.join(timeout=5) # Attendre que toutes les tâches soient terminées (max 5s)
+
         print("🏁 Fin de jeu - Assemblage des résultats...")
 
         if final_image is not None:
             self.user_images.append(final_image)
             self.expected_answers.append(self.correct_answer)
             
-            # Traitement de la dernière image
-            parts = self.current_operation.split()
-            a, op, b = int(parts[0]), parts[1], int(parts[2])
-            final_operation_data = (a, b, op, self.correct_answer)
-            
-            # Traiter la dernière image immédiatement (pas en parallèle)
-            print(f"🔄 Traitement final de l'image {self.question_count}...")
-            final_result = create_result_row_with_images(self.question_count, final_image, self.correct_answer, final_operation_data)
-            self.results_cache[self.question_count] = final_result
-            
-            self.question_count += 1
+            # Traitement de la dernière image si elle n'a pas été ajoutée
             if len(self.operations_history) < len(self.user_images):
-                self.operations_history.append((a, b, op, self.correct_answer))
-
-        # Attendre que toutes les images soient traitées
-        max_wait = 10
+                # Cela signifie que la dernière question n'a pas encore été historisée
+                # Ré-parser la dernière opération affichée pour l'historique
+                parts = self.current_operation.replace(' ', '').split('×') if '×' in self.current_operation else \
+                        self.current_operation.replace(' ', '').split('+') if '+' in self.current_operation else \
+                        self.current_operation.replace(' ', '').split('-') if '-' in self.current_operation else \
+                        self.current_operation.replace(' ', '').split('÷')
+                a, op_char, b = int(parts[0]), self.current_operation.split()[1], int(parts[2])
+                self.operations_history.append((a, b, op_char, self.correct_answer))
+
+            # Assurer que la dernière image est traitée si ce n'est pas déjà fait
+            if self.question_count not in self.results_cache and len(self.user_images) > self.question_count:
+                print(f"🔄 Traitement final de l'image {self.question_count} (synchrone)...")
+                final_operation_data = self.operations_history[self.question_count]
+                final_result = create_result_row_with_images(self.question_count, final_image, self.correct_answer, final_operation_data)
+                self.results_cache[self.question_count] = final_result
+                self.question_count += 1
+            elif self.question_count in self.results_cache:
+                print(f"✅ Dernière image {self.question_count} déjà traitée en parallèle.")
+                self.question_count += 1 # Incrémenter si déjà dans le cache
+
+        # Attendre que toutes les images soient traitées (petite attente finale)
+        max_wait = 2 # temps max d'attente supplémentaire
         wait_start = time.time()
         expected_results = len(self.user_images)
         
-        print(f"⏳ Attente de {expected_results} résultats...")
+        print(f"⏳ Attente finale des {expected_results} résultats...")
         while len(self.results_cache) < expected_results and (time.time() - wait_start) < max_wait:
-            time.sleep(0.1)
+            time.sleep(0.05) # Petite pause pour laisser le worker finir
             
         results_ready = len(self.results_cache)
         print(f"✅ {results_ready}/{expected_results} résultats prêts")
@@ -519,33 +533,36 @@ class MathGame:
         print(f"📊 Assemblage de {total_questions} résultats...")
         
         for i in range(total_questions):
-            if i in self.results_cache:
-                row_data = self.results_cache[i]
-                print(f"  ✅ Résultat {i} du cache parallèle")
-            else:
-                print(f"  🔄 Traitement fallback pour résultat {i}...")
-                if i < len(self.operations_history):
+            row_data = self.results_cache.get(i)
+            if row_data is None:
+                # Fallback si le résultat n'est pas dans le cache (erreur parallèle ou non traité)
+                print(f"  ❌ Résultat {i} manquant du cache, traitement synchrone de fallback...")
+                if i < len(self.operations_history) and i < len(self.user_images) and i < len(self.expected_answers):
                     row_data = create_result_row_with_images(i, self.user_images[i], self.expected_answers[i], self.operations_history[i])
                 else:
                     row_data = {
-                        'html_row': f'<tr><td>{i+1}</td><td colspan="7">Erreur traitement</td></tr>',
+                        'html_row': f'<tr><td>{i+1}</td><td colspan="7">Erreur traitement (données manquantes)</td></tr>',
                         'is_correct': False,
                         'recognized': "0",
                         'recognized_num': 0,
                         'dataset_image_data': None
                     }
+            else:
+                print(f"  ✅ Résultat {i} récupéré du cache parallèle")
             
             table_rows_html += row_data['html_row']
             
             if row_data['is_correct']:
                 correct_answers += 1
 
-            # Structure pour dataset avec debug OCR
-            a, b, operation, correct_result = self.operations_history[i] if i < len(self.operations_history) else (0, 0, "×", 0)
+            # Structure pour dataset avec debug OCR et COMPLEXITÉ
+            a, b, operation, correct_result_op = self.operations_history[i] if i < len(self.operations_history) else (0, 0, "×", 0)
             
+            # Analyse de la complexité
+            complexity_analysis = analyze_calculation_complexity(a, b, operation)
+
             try:
                 ocr_info_data = get_ocr_model_info()
-                print(f"🔍 Debug OCR info: {ocr_info_data}")
             except Exception as e:
                 print(f"❌ Erreur get_ocr_model_info: {e}")
                 ocr_info_data = {"model_name": "Error", "device": "Unknown"}
@@ -555,11 +572,11 @@ class MathGame:
                 "timestamp": session_timestamp,
                 "question_number": i + 1,
                 "session_duration": self.duration,
-                "operation_type": self.operation_type,
-                "difficulty_level": self.difficulty,
+                "operation_type": self.operation_type, # Type d'opération de la session globale
+                "difficulty_level": self.difficulty, # Difficulté de la session globale
                 "operand_a": a,
                 "operand_b": b,
-                "operation": operation,
+                "operation": operation, # Opération spécifique de la question
                 "correct_answer": self.expected_answers[i] if i < len(self.expected_answers) else 0,
                 "ocr_model": ocr_info_data.get("model_name", "Unknown"),
                 "ocr_device": ocr_info_data.get("device", "Unknown"),
@@ -567,12 +584,13 @@ class MathGame:
                 "user_answer_parsed": row_data['recognized_num'],
                 "is_correct": row_data['is_correct'],
                 "total_questions": total_questions,
-                "app_version": "3.0_calcul_ocr_parallel"
+                "app_version": "3.0_calcul_ocr_parallel_v2",
+                # Ajout des métadonnées de complexité
+                "complexity_score": complexity_analysis["complexity_score"],
+                "difficulty_category": complexity_analysis["difficulty_category"],
+                "operation_specific_type": complexity_analysis["operation_type"], # Redondant mais explicite
             }
             
-            print(f"🔍 Debug entry OCR fields: ocr_model={entry['ocr_model']}, ocr_device={entry['ocr_device']}")
-            
-            
             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])
@@ -591,13 +609,19 @@ class MathGame:
         for entry in self.session_data:
             entry["session_accuracy"] = accuracy
 
-        # Nettoyage mémoire
-        for img in self.user_images:
-            if hasattr(img, 'close'):
+        # Nettoyage mémoire des images PIL originales (Gradio dict ou PIL.Image)
+        for img_data in self.user_images:
+            if isinstance(img_data, dict) and 'composite' in img_data and hasattr(img_data['composite'], 'close'):
+                try:
+                    img_data['composite'].close()
+                except:
+                    pass
+            elif isinstance(img_data, Image.Image) and hasattr(img_data, 'close'):
                 try:
-                    img.close()
+                    img_data.close()
                 except:
                     pass
+        self.user_images.clear() # Vider la liste une fois traitée
         
         gc.collect()
 
@@ -702,26 +726,8 @@ def export_to_clean_dataset(session_data: list[dict], dataset_name: str = None)
         print(f"\n🚀 === EXPORT VERS DATASET CALCUL OCR ===")
         print(f"📊 Dataset: {dataset_name}")
         
-        # Filtrer les entrées avec images et ajouter les infos OCR globalement
-        clean_entries = []
-        
-        # Récupérer une seule fois les infos OCR pour toute la session
-        try:
-            global_ocr_info = get_ocr_model_info()
-            print(f"🔍 Infos OCR globales: {global_ocr_info}")
-        except Exception as e:
-            print(f"❌ Erreur infos OCR globales: {e}")
-            global_ocr_info = {"model_name": "Unknown", "device": "Unknown"}
-        
-        for entry in session_data:
-            if entry.get('has_image', False):
-                # Ajouter explicitement les champs OCR manquants
-                entry_with_ocr = entry.copy()
-                entry_with_ocr["ocr_model"] = global_ocr_info.get("model_name", "Unknown")
-                entry_with_ocr["ocr_device"] = global_ocr_info.get("device", "Unknown")
-                
-                print(f"🔍 Entry avec OCR: ocr_model={entry_with_ocr['ocr_model']}, ocr_device={entry_with_ocr['ocr_device']}")
-                clean_entries.append(entry_with_ocr)
+        # Filtrer les entrées avec images
+        clean_entries = [entry for entry in session_data if entry.get('has_image', False)]
         
         # Créer un dataset de test avec structure forcée
         if len(clean_entries) == 0:
@@ -730,23 +736,22 @@ def export_to_clean_dataset(session_data: list[dict], dataset_name: str = None)
         # Vérifier la structure de la première entrée
         sample_entry = clean_entries[0]
         print(f"🔍 Structure première entrée: {list(sample_entry.keys())}")
-        print(f"🔍 OCR dans entrée: ocr_model={sample_entry.get('ocr_model', 'MISSING')}, ocr_device={sample_entry.get('ocr_device', 'MISSING')}")
         
-        # Charger dataset existant et combiner (IMPORTANT!)
+        # Charger dataset existant et combiner (IMPORTANT!) 
         try:
-            existing_dataset = load_dataset(dataset_name, split="train")
-            existing_data = existing_dataset.to_list()
-            print(f"📊 {len(existing_data)} entrées existantes trouvées")
+            existing_dataset = load_dataset(dataset_name, split="train") [cite: 2]
+            existing_data = existing_dataset.to_list() [cite: 2]
+            print(f"📊 {len(existing_data)} entrées existantes trouvées") [cite: 2]
             
-            # Combiner ancien + nouveau
-            combined_data = existing_data + clean_entries
-            clean_dataset = Dataset.from_list(combined_data)
-            print(f"📊 Dataset combiné: {len(existing_data)} existantes + {len(clean_entries)} nouvelles = {len(combined_data)} total")
+            # Combiner ancien + nouveau 
+            combined_data = existing_data + clean_entries [cite: 2]
+            clean_dataset = Dataset.from_list(combined_data) [cite: 2]
+            print(f"📊 Dataset combiné: {len(existing_data)} existantes + {len(clean_entries)} nouvelles = {len(combined_data)} total") [cite: 2]
             
         except Exception as e:
             print(f"📊 Dataset non trouvé, création nouveau: {e}")
             # Si le dataset n'existe pas, créer depuis les nouvelles entrées
-            clean_dataset = Dataset.from_list(clean_entries)
+            clean_dataset = Dataset.from_list(clean_entries) [cite: 2]
             print(f"📊 Nouveau dataset créé avec {len(clean_entries)} entrées")
         
         print(f"✅ Dataset créé - Features:")
@@ -756,19 +761,19 @@ def export_to_clean_dataset(session_data: list[dict], dataset_name: str = None)
         # Statistiques par opération
         operations_count = {}
         for entry in clean_entries:
-            op = entry.get('operation_type', 'unknown')
+            op = entry.get('operation', 'unknown') # Utiliser 'operation' qui est spécifique à la question
             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})"
-        )
+        # Push vers HuggingFace 
+        print(f"📤 Push vers {dataset_name}...") [cite: 2]
+        clean_dataset.push_to_hub( [cite: 2]
+            dataset_name, [cite: 2]
+            private=False, [cite: 2]
+            token=hf_token, [cite: 2]
+            commit_message=f"Add {len(clean_entries)} handwriting samples for math OCR ({operations_summary})" [cite: 2]
+        ) [cite: 2]
         
         cleanup_memory()