Update app.py

app.py

@@ -5,54 +5,42 @@ import os
 import json
 from datetime import datetime
 from google import genai
-from google.genai import types
-import typing_extensions as typing
+from pydantic import BaseModel, Field
+import enum
 import uuid
+from typing import List
 
 app = Flask(__name__)
 
-# Configuratiyon
+# Configuration
 GOOGLE_API_KEY = "AIzaSyAMYpF67aqFnWDJESWOx1dC-w3sEU29VcM"  # Remplacez par votre clé API
-MODEL_ID = "gemini-2.0-flash-lite"  # Ou le modèle que vous utilisez
+MODEL_ID = "gemini-2.0-flash"  # Modèle recommandé selon la documentation
 UPLOAD_FOLDER = 'uploads'
 RESULTS_FOLDER = 'results'
 
-safety_settings = [
-    types.SafetySetting(
-        category="HARM_CATEGORY_HARASSMENT",
-        threshold="BLOCK_NONE",
-    ),
-    types.SafetySetting(
-        category="HARM_CATEGORY_HATE_SPEECH",
-        threshold="BLOCK_NONE",
-    ),
-    types.SafetySetting(
-        category="HARM_CATEGORY_SEXUALLY_EXPLICIT",
-        threshold="BLOCK_NONE",
-    ),
-    types.SafetySetting(
-        category="HARM_CATEGORY_DANGEROUS_CONTENT",
-        threshold="BLOCK_NONE",
-    ),
-]
-
 # 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 du schéma JSON pour les réponses
-class TranslationPair(typing.TypedDict):
-    fang: str
-    francais: str
+# Définition des schémas Pydantic selon la documentation
+class TranslationPair(BaseModel):
+    fang: str = Field(description="Phrase en langue fang")
+    francais: str = Field(description="Traduction française de la phrase")
 
-class SyntheticDataResponse(typing.TypedDict):
-    request_number: int
-    generated_pairs: list[TranslationPair]
-    timestamp: str
+class SyntheticDataResponse(BaseModel):
+    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")
+    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
-tasks = {}
-
 class TaskManager:
     def __init__(self):
         self.tasks = {}
@@ -62,11 +50,11 @@ class TaskManager:
             'status': 'running',
             'progress': 0,
             'total': 470,
-            'results_file': f'results_{task_id}.json',  # Changé en .json
+            'results_file': f'results_{task_id}.json',
             'start_time': datetime.now(),
             'errors': [],
             'last_update': datetime.now(),
-            'all_data': []  # Stocker toutes les données JSON
+            'all_data': []
         }
     
     def update_progress(self, task_id, progress, data=None):
@@ -90,50 +78,23 @@ class TaskManager:
 
 task_manager = TaskManager()
 
-def parse_response_to_pairs(response_text, request_num):
-    """Parse la réponse textuelle pour extraire les paires fang/français"""
-    pairs = []
-    lines = response_text.strip().split('\n')
-    
-    current_fang = ""
-    current_francais = ""
-    
-    for line in lines:
-        line = line.strip()
-        if line.lower().startswith('fang :') or line.lower().startswith('fang:'):
-            current_fang = line.split(':', 1)[1].strip() if ':' in line else line
-        elif line.lower().startswith('français :') or line.lower().startswith('francais:') or line.lower().startswith('français:'):
-            current_francais = line.split(':', 1)[1].strip() if ':' in line else line
-            
-            # Si on a une paire complète, l'ajouter
-            if current_fang and current_francais:
-                pairs.append({
-                    "fang": current_fang,
-                    "francais": current_francais
-                })
-                current_fang = ""
-                current_francais = ""
-    
-    return {
-        "request_number": request_num,
-        "generated_pairs": pairs,
-        "timestamp": datetime.now().isoformat()
-    }
-
 def generate_synthetic_data(file_path, task_id):
-    """Fonction qui exécute les 470 requêtes en arrière-plan avec sortie JSON"""
+    """Fonction qui exécute les 470 requêtes en arrière-plan avec sortie JSON structurée"""
     try:
-        # Initialiser le client Google AI
+        # Initialiser le client Google AI selon la documentation
         client = genai.Client(api_key=GOOGLE_API_KEY)
         
         # Uploader le fichier
-        file_ref = client.files.upload(file=file_path)
+        with open(file_path, 'rb') as f:
+            uploaded_file = client.files.upload(file=f)
         
-        # Prompt modifié pour avoir une sortie plus structurée
-        prompt = """J'aimerais générer des nouvelles données synthétiques à partir de ça. 
-        Une en fang, une en français. Génère exactement 400 paires de phrases. (respecte strictement cela).
-
-        """
+        # 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
+        - 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."""
         
         # Fichier de résultats JSON
         results_file = os.path.join(RESULTS_FOLDER, f'results_{task_id}.json')
@@ -144,51 +105,86 @@ def generate_synthetic_data(file_path, task_id):
                 "task_id": task_id,
                 "start_time": datetime.now().isoformat(),
                 "total_requests": 470,
-                "model_used": MODEL_ID
+                "model_used": MODEL_ID,
+                "schema_version": "1.0"
             },
             "requests": [],
             "summary": {
                 "total_pairs": 0,
                 "completed_requests": 0,
+                "failed_requests": 0,
                 "errors": []
             }
         }
         
         for i in range(470):
             try:
-                # Faire la requête avec schéma JSON
+                print(f"Traitement de la requête {i+1}/470...")
+                
+                # Faire la requête avec schéma JSON selon la documentation
                 response = client.models.generate_content(
                     model=MODEL_ID,
-                    contents=[file_ref, prompt],
-                    config=types.GenerateContentConfig(
-                        safety_settings=safety_settings,
-                        response_mime_type='application/json',
-                        response_schema=SyntheticDataResponse,
-                    )
+                    contents=[uploaded_file, prompt],
+                    config={
+                        'response_mime_type': 'application/json',
+                        'response_schema': SyntheticDataResponse,
+                    }
                 )
                 
+                # Parser la réponse avec le schéma Pydantic
                 try:
-                    # Parser la réponse JSON
-                    response_data = json.loads(response.text)
-                    
-                    # Structurer la réponse
-                    request_data = {
-                        "request_number": i + 1,
-                        "timestamp": datetime.now().isoformat(),
-                        "response": response_data,
-                        "pairs_count": len(response_data.get("pairs", []))
-                    }
+                    # 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"
+                        }
                     
                     all_results["requests"].append(request_data)
                     all_results["summary"]["total_pairs"] += request_data["pairs_count"]
                     all_results["summary"]["completed_requests"] += 1
                     
-                except json.JSONDecodeError:
-                    # Si la réponse n'est pas du JSON valide, essayer de parser manuellement
-                    parsed_data = parse_response_to_pairs(response.text, i + 1)
-                    all_results["requests"].append(parsed_data)
-                    all_results["summary"]["total_pairs"] += len(parsed_data.get("generated_pairs", []))
-                    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 = {
+                        "request_number": i + 1,
+                        "timestamp": datetime.now().isoformat(),
+                        "raw_response": response.text,
+                        "pairs_count": 0,
+                        "status": "parse_error",
+                        "error": str(parse_error)
+                    }
+                    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()
+                    })
                 
                 # Sauvegarder après chaque requête
                 with open(results_file, 'w', encoding='utf-8') as f:
@@ -197,14 +193,25 @@ def generate_synthetic_data(file_path, task_id):
                 # Mettre à jour le progrès
                 task_manager.update_progress(task_id, i + 1)
                 
-                print(f"Requête {i+1}/470 complétée")
+                print(f"Requête {i+1}/470 complétée avec {request_data.get('pairs_count', 0)} paires")
                 
-                # Pause pour éviter de surcharger l'API
-                time.sleep(50)
+                # Pause pour respecter les limites de l'API
+                time.sleep(2)  # Réduit à 2 secondes selon les bonnes pratiques
                 
             except Exception as e:
+                # Gestion des erreurs de requête
                 error_msg = f"Erreur requête {i+1}: {str(e)}"
                 task_manager.add_error(task_id, error_msg)
+                
+                error_data = {
+                    "request_number": i + 1,
+                    "timestamp": datetime.now().isoformat(),
+                    "pairs_count": 0,
+                    "status": "request_error",
+                    "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,
@@ -216,16 +223,29 @@ def generate_synthetic_data(file_path, task_id):
                     json.dump(all_results, f, ensure_ascii=False, indent=2)
                 
                 print(error_msg)
+                
+                # Pause plus longue en cas d'erreur
+                time.sleep(5)
         
-        # Finaliser le fichier JSON
+        # Finaliser le fichier JSON avec statistiques complètes
         all_results["metadata"]["end_time"] = datetime.now().isoformat()
-        all_results["metadata"]["duration_minutes"] = (datetime.now() - datetime.fromisoformat(all_results["metadata"]["start_time"])).total_seconds() / 60
+        start_time = datetime.fromisoformat(all_results["metadata"]["start_time"])
+        duration = (datetime.now() - start_time).total_seconds()
+        all_results["metadata"]["duration_seconds"] = duration
+        all_results["metadata"]["duration_minutes"] = round(duration / 60, 2)
+        
+        # Statistiques finales
+        all_results["summary"]["success_rate"] = round(
+            (all_results["summary"]["completed_requests"] / 470) * 100, 2
+        )
         
         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']}%")
         
     except Exception as e:
         error_msg = f"Erreur générale: {str(e)}"
@@ -267,7 +287,8 @@ def upload_file():
         
         return jsonify({
             'task_id': task_id,
-            'message': 'Traitement démarré en arrière-plan'
+            'message': 'Traitement démarré en arrière-plan',
+            'estimated_duration': '15-20 minutes'
         })
 
 @app.route('/status/<task_id>')
@@ -283,7 +304,8 @@ def get_status(task_id):
         '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')
+        '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
     })
 
 @app.route('/download/<task_id>')
@@ -361,7 +383,7 @@ def list_tasks():
 
 @app.route('/cleanup')
 def cleanup_temp_files():
-    """Nettoyer les fichiers temporaires (optionnel)"""
+    """Nettoyer les fichiers temporaires"""
     try:
         temp_files_deleted = 0
         for filename in os.listdir(RESULTS_FOLDER):
@@ -378,7 +400,7 @@ def cleanup_temp_files():
 
 @app.route('/preview/<task_id>')
 def preview_results(task_id):
-    """Aperçu des résultats JSON pour debug"""
+    """Aperçu des résultats JSON avec statistiques"""
     task = task_manager.get_task(task_id)
     if not task:
         return jsonify({'error': 'Tâche non trouvée'}), 404
@@ -392,12 +414,17 @@ def preview_results(task_id):
         with open(results_file, 'r', encoding='utf-8') as f:
             data = json.load(f)
         
-        # Retourner un aperçu des données
+        # Retourner un aperçu enrichi 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", []))
+            "total_requests": len(data.get("requests", [])),
+            "structure_info": {
+                "schema_used": "SyntheticDataResponse",
+                "fields": ["request_number", "generated_pairs", "timestamp"],
+                "pair_structure": ["fang", "francais"]
+            }
         }
         
         return jsonify(preview)
@@ -405,9 +432,40 @@ 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...")
+    print("🚀 Démarrage du serveur avec configuration Gemini API optimisée...")
     print("📂 Dossiers créés:", UPLOAD_FOLDER, RESULTS_FOLDER)
     print("🌐 Application disponible sur: http://localhost:5000")
-    print("📊 Sortie JSON activée")
+    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)