Update app.py

app.py

@@ -6,39 +6,36 @@ import json
 from datetime import datetime
 from google import genai
 from pydantic import BaseModel, Field
-import enum
+import typing_extensions as typing
 import uuid
-from typing import List
+import enum
 
 app = Flask(__name__)
 
 # Configuration
 GOOGLE_API_KEY = "AIzaSyAMYpF67aqFnWDJESWOx1dC-w3sEU29VcM"  # Remplacez par votre clé API
-MODEL_ID = "gemini-2.0-flash-lite"  # Modèle recommandé selon la documentation
+MODEL_ID = "gemini-2.0-flash"  # Modèle recommandé selon la documentation
 UPLOAD_FOLDER = 'uploads'
 RESULTS_FOLDER = 'results'
 
-# Créker les dossiers s'ils n'existent pas
+# 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")
+    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")
-    
-    class Config:
-        # Configuration pour un ordre de propriétés cohérent
-        fields = {
-            "request_number": {"title": "Numéro de requête"},
-            "generated_pairs": {"title": "Paires générées"},
-            "timestamp": {"title": "Horodatage"}
-        }
 
 # Stockage des tâches en cours
 class TaskManager:
@@ -85,16 +82,18 @@ def generate_synthetic_data(file_path, task_id):
         client = genai.Client(api_key=GOOGLE_API_KEY)
         
         # Uploader le fichier
-        with open(file_path, 'rb') as f:
-            uploaded_file = client.files.upload(file=f)
+        file_ref = client.files.upload(path=file_path)
         
-        # Prompt optimisé pour la génération de données synthétiques
-        prompt = """À partir du contenu de ce fichier, génère exactement 400 nouvelles paires de phrases :
-        - Une phrase en langue fang
+        # 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
         
-        Varie les structures grammaticales, les contextes et le vocabulaire pour créer des données d'entraînement diversifiées.
-        Assure-toi que chaque paire soit cohérente et naturelle dans les deux langues."""
+        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')
@@ -106,7 +105,7 @@ def generate_synthetic_data(file_path, task_id):
                 "start_time": datetime.now().isoformat(),
                 "total_requests": 470,
                 "model_used": MODEL_ID,
-                "schema_version": "1.0"
+                "expected_pairs_per_request": 400
             },
             "requests": [],
             "summary": {
@@ -119,138 +118,140 @@ def generate_synthetic_data(file_path, task_id):
         
         for i in range(470):
             try:
-                print(f"Traitement de la requête {i+1}/470...")
+                print(f"🔄 Démarrage requête {i+1}/470...")
                 
-                # Faire la requête avec schéma JSON selon la documentation
+                # Configuration selon la documentation avec schéma Pydantic
                 response = client.models.generate_content(
                     model=MODEL_ID,
-                    contents=[uploaded_file, prompt],
+                    contents=[file_ref, prompt],
                     config={
                         'response_mime_type': 'application/json',
                         'response_schema': SyntheticDataResponse,
                     }
                 )
                 
-                # Parser la réponse avec le schéma Pydantic
-                try:
-                    # Utiliser la méthode .parsed pour récupérer l'objet structuré
-                    if hasattr(response, 'parsed') and response.parsed:
-                        structured_data = response.parsed
-                        request_data = {
-                            "request_number": i + 1,
-                            "timestamp": datetime.now().isoformat(),
-                            "response": {
-                                "request_number": structured_data.request_number,
-                                "generated_pairs": [
-                                    {"fang": pair.fang, "francais": pair.francais} 
-                                    for pair in structured_data.generated_pairs
-                                ],
-                                "timestamp": structured_data.timestamp
-                            },
-                            "pairs_count": len(structured_data.generated_pairs),
-                            "status": "success"
-                        }
-                    else:
-                        # Fallback : parser manuellement la réponse JSON
-                        response_json = json.loads(response.text)
-                        request_data = {
-                            "request_number": i + 1,
-                            "timestamp": datetime.now().isoformat(),
-                            "response": response_json,
-                            "pairs_count": len(response_json.get("generated_pairs", [])),
-                            "status": "success"
-                        }
+                # Utiliser la propriété .parsed selon la documentation
+                if hasattr(response, 'parsed') and response.parsed:
+                    parsed_response = response.parsed
                     
-                    all_results["requests"].append(request_data)
-                    all_results["summary"]["total_pairs"] += request_data["pairs_count"]
-                    all_results["summary"]["completed_requests"] += 1
-                    
-                except (json.JSONDecodeError, AttributeError) as parse_error:
-                    # En cas d'erreur de parsing, sauvegarder la réponse brute
-                    error_data = {
+                    # Structurer la réponse selon le schéma
+                    request_data = {
                         "request_number": i + 1,
                         "timestamp": datetime.now().isoformat(),
-                        "raw_response": response.text,
-                        "pairs_count": 0,
-                        "status": "parse_error",
-                        "error": str(parse_error)
+                        "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"
                     }
-                    all_results["requests"].append(error_data)
-                    all_results["summary"]["failed_requests"] += 1
                     
-                    error_msg = f"Erreur de parsing requête {i+1}: {str(parse_error)}"
-                    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["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 - {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
+                # 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)
                 
-                print(f"Requête {i+1}/470 complétée avec {request_data.get('pairs_count', 0)} paires")
-                
-                # Pause pour respecter les limites de l'API
-                time.sleep(2)  # Réduit à 2 secondes selon les bonnes pratiques
+                # 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:
-                # Gestion des erreurs de requête
                 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
                 
-                error_data = {
+                # 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": "request_error",
+                    "status": "failed",
                     "error": error_msg
                 }
-                all_results["requests"].append(error_data)
-                all_results["summary"]["failed_requests"] += 1
-                all_results["summary"]["errors"].append({
-                    "request_number": i + 1,
-                    "error": error_msg,
-                    "timestamp": datetime.now().isoformat()
-                })
+                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)
                 
-                print(error_msg)
+                # 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 avec statistiques complètes
-        all_results["metadata"]["end_time"] = datetime.now().isoformat()
+        # Finaliser le fichier JSON
+        end_time = datetime.now()
         start_time = datetime.fromisoformat(all_results["metadata"]["start_time"])
-        duration = (datetime.now() - start_time).total_seconds()
+        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"] = round(duration / 60, 2)
+        all_results["metadata"]["duration_minutes"] = duration / 60
+        all_results["summary"]["success_rate"] = (
+            all_results["summary"]["completed_requests"] / 470 * 100
+        )
         
         # Statistiques finales
-        all_results["summary"]["success_rate"] = round(
-            (all_results["summary"]["completed_requests"] / 470) * 100, 2
-        )
+        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")
         
         with open(results_file, 'w', encoding='utf-8') as f:
             json.dump(all_results, f, ensure_ascii=False, indent=2)
         
         task_manager.complete_task(task_id)
-        print(f"Tâche {task_id} terminée avec succès")
-        print(f"Total de paires générées: {all_results['summary']['total_pairs']}")
-        print(f"Taux de succès: {all_results['summary']['success_rate']}%")
+        print(f"🎉 Tâche {task_id} terminée avec succès")
         
     except Exception as e:
         error_msg = f"Erreur générale: {str(e)}"
         task_manager.add_error(task_id, error_msg)
-        print(error_msg)
+        print(f"💥 {error_msg}")
 
 @app.route('/')
 def index():
@@ -288,7 +289,7 @@ def upload_file():
         return jsonify({
             'task_id': task_id,
             'message': 'Traitement démarré en arrière-plan',
-            'estimated_duration': '15-20 minutes'
+            'expected_duration_minutes': 8  # Estimation basée sur 1s par requête
         })
 
 @app.route('/status/<task_id>')
@@ -297,6 +298,15 @@ def get_status(task_id):
     if not task:
         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
+    
     return jsonify({
         'status': task['status'],
         'progress': task['progress'],
@@ -305,7 +315,7 @@ def get_status(task_id):
         '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'),
-        'estimated_remaining': max(0, (task['total'] - task['progress']) * 2) if task['status'] == 'running' else 0
+        'eta_minutes': round(eta_minutes) if eta_minutes else None
     })
 
 @app.route('/download/<task_id>')
@@ -400,7 +410,7 @@ def cleanup_temp_files():
 
 @app.route('/preview/<task_id>')
 def preview_results(task_id):
-    """Aperçu des résultats JSON avec statistiques"""
+    """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
@@ -414,17 +424,12 @@ def preview_results(task_id):
         with open(results_file, 'r', encoding='utf-8') as f:
             data = json.load(f)
         
-        # Retourner un aperçu enrichi des données
+        # 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", [])),
-            "structure_info": {
-                "schema_used": "SyntheticDataResponse",
-                "fields": ["request_number", "generated_pairs", "timestamp"],
-                "pair_structure": ["fang", "francais"]
-            }
+            "total_requests": len(data.get("requests", []))
         }
         
         return jsonify(preview)
@@ -432,40 +437,10 @@ def preview_results(task_id):
     except Exception as e:
         return jsonify({'error': f'Erreur lors de la lecture du fichier: {str(e)}'}), 500
 
-@app.route('/schema')
-def get_schema_info():
-    """Endpoint pour obtenir des informations sur le schéma utilisé"""
-    schema_info = {
-        "schema_version": "1.0",
-        "models": {
-            "TranslationPair": {
-                "fields": {
-                    "fang": "string - Phrase en langue fang",
-                    "francais": "string - Traduction française"
-                }
-            },
-            "SyntheticDataResponse": {
-                "fields": {
-                    "request_number": "integer - Numéro de la requête",
-                    "generated_pairs": "array[TranslationPair] - Liste des paires générées",
-                    "timestamp": "string - Horodatage ISO 8601"
-                }
-            }
-        },
-        "api_configuration": {
-            "model": MODEL_ID,
-            "response_mime_type": "application/json",
-            "structured_output": True
-        }
-    }
-    
-    return jsonify(schema_info)
-
 if __name__ == '__main__':
-    print("🚀 Démarrage du serveur avec configuration Gemini API optimisée...")
+    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)
-    print("📋 Endpoint de schéma disponible: /schema")
     app.run(debug=True, threaded=True)