app.py

from flask import Flask, render_template, request, jsonify, send_file
import threading
import time
import os
from datetime import datetime
from google import genai
import uuid

app = Flask(__name__)

# Configuration
GOOGLE_API_KEY = "AIzaSyAPXOW7DCXOfGuryt8To1iqUADPzRcVApI"  # Remplacez par votre clé API
MODEL_ID = "gemini-2.5-flash-preview-05-20"  # Ou le modèle que vous utilisez
UPLOAD_FOLDER = 'uploads'
RESULTS_FOLDER = 'results'

# Créer les dossiers s'ils n'existent pas
os.makedirs(UPLOAD_FOLDER, exist_ok=True)
os.makedirs(RESULTS_FOLDER, exist_ok=True)

# Stockage des tâches en cours
tasks = {}

class TaskManager:
    def __init__(self):
        self.tasks = {}
    
    def create_task(self, task_id):
        self.tasks[task_id] = {
            'status': 'running',
            'progress': 0,
            'total': 470,
            'results_file': f'results_{task_id}.txt',
            'start_time': datetime.now(),
            'errors': [],
            'last_update': datetime.now()
        }
    
    def update_progress(self, task_id, progress):
        if task_id in self.tasks:
            self.tasks[task_id]['progress'] = progress
            self.tasks[task_id]['last_update'] = datetime.now()
    
    def add_error(self, task_id, error):
        if task_id in self.tasks:
            self.tasks[task_id]['errors'].append(error)
    
    def complete_task(self, task_id):
        if task_id in self.tasks:
            self.tasks[task_id]['status'] = 'completed'
            self.tasks[task_id]['last_update'] = datetime.now()
    
    def get_task(self, task_id):
        return self.tasks.get(task_id)

task_manager = TaskManager()

def generate_synthetic_data(file_path, task_id):
    """Fonction qui exécute les 470 requêtes en arrière-plan"""
    try:
        # Initialiser le client Google AI
        client = genai.Client(api_key=GOOGLE_API_KEY)
        
        # Uploader le fichier
        file_ref = client.files.upload(file=file_path)
        
        # Prompt pour chaque requête
        prompt = ("J'aimerais générer des nouvelles données synthétiques à partir de ça. "
                 "Une fang, une français. Je veux 400 phrases longues.\n\n"
                 "Selon le format : fang :.... / Français :...")
        
        # Fichier de résultats
        results_file = os.path.join(RESULTS_FOLDER, f'results_{task_id}.txt')
        
        with open(results_file, 'w', encoding='utf-8') as f:
            f.write(f"Génération de données synthétiques - Démarré le {datetime.now()}\n")
            f.write("="*60 + "\n\n")
            
            for i in range(470):
                try:
                    # Faire la requête
                    response = client.models.generate_content(
                        model=MODEL_ID,
                        contents=[file_ref, prompt]
                    )
                    
                    # Écrire la réponse dans le fichier
                    f.write(f"--- Requête {i+1}/470 ---\n")
                    f.write(response.text)
                    f.write("\n" + "="*60 + "\n\n")
                    f.flush()  # Forcer l'écriture immédiate
                    
                    # Mettre à jour le progrès
                    task_manager.update_progress(task_id, i + 1)
                    
                    print(f"Requête {i+1}/470 complétée")
                    
                    # Pause pour éviter de surcharger l'API
                    time.sleep(1)
                    
                except Exception as e:
                    error_msg = f"Erreur requête {i+1}: {str(e)}"
                    task_manager.add_error(task_id, error_msg)
                    f.write(f"ERREUR - Requête {i+1}: {str(e)}\n")
                    f.write("="*60 + "\n\n")
                    f.flush()  # Forcer l'écriture même en cas d'erreur
                    print(error_msg)
        
        task_manager.complete_task(task_id)
        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)

@app.route('/')
def index():
    # Servir directement le HTML depuis le même dossier
    render_template('index.html')

@app.route('/upload', methods=['POST'])
def upload_file():
    if 'file' not in request.files:
        return jsonify({'error': 'Aucun fichier sélectionné'}), 400
    
    file = request.files['file']
    if file.filename == '':
        return jsonify({'error': 'Aucun fichier sélectionné'}), 400
    
    if file:
        # Générer un ID unique pour cette tâche
        task_id = str(uuid.uuid4())
        
        # Sauvegarder le fichier
        filename = f"input_{task_id}.txt"
        file_path = os.path.join(UPLOAD_FOLDER, filename)
        file.save(file_path)
        
        # Créer la tâche
        task_manager.create_task(task_id)
        
        # Démarrer le traitement en arrière-plan
        thread = threading.Thread(
            target=generate_synthetic_data, 
            args=(file_path, task_id)
        )
        thread.daemon = True
        thread.start()
        
        return jsonify({
            'task_id': task_id,
            'message': 'Traitement démarré en arrière-plan'
        })

@app.route('/status/<task_id>')
def get_status(task_id):
    task = task_manager.get_task(task_id)
    if not task:
        return jsonify({'error': 'Tâche non trouvée'}), 404
    
    return jsonify({
        'status': task['status'],
        'progress': task['progress'],
        'total': task['total'],
        'percentage': round((task['progress'] / task['total']) * 100, 2),
        'errors_count': len(task['errors']),
        'start_time': task['start_time'].strftime('%Y-%m-%d %H:%M:%S'),
        'last_update': task['last_update'].strftime('%Y-%m-%d %H:%M:%S')
    })

@app.route('/download/<task_id>')
def download_results(task_id):
    task = task_manager.get_task(task_id)
    if not task:
        return jsonify({'error': 'Tâche non trouvée'}), 404
    
    results_file = os.path.join(RESULTS_FOLDER, f'results_{task_id}.txt')
    
    if not os.path.exists(results_file):
        return jsonify({'error': 'Fichier de résultats non trouvé'}), 404
    
    # Vérifier si c'est un téléchargement partiel
    is_partial = request.args.get('partial', 'false').lower() == 'true'
    
    if is_partial and task['status'] == 'running':
        # Créer un fichier temporaire avec les données actuelles
        temp_file = os.path.join(RESULTS_FOLDER, f'temp_results_{task_id}.txt')
        
        # Copier le contenu actuel vers le fichier temporaire
        try:
            with open(results_file, 'r', encoding='utf-8') as original:
                content = original.read()
            
            with open(temp_file, 'w', encoding='utf-8') as temp:
                temp.write(content)
                temp.write(f"\n\n--- TÉLÉCHARGEMENT PARTIEL ---\n")
                temp.write(f"Téléchargé le: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
                temp.write(f"Progrès: {task['progress']}/{task['total']} ({round((task['progress'] / task['total']) * 100, 2)}%)\n")
                temp.write("Génération en cours... Ce fichier contient les données générées jusqu'à présent.\n")
            
            return send_file(
                temp_file,
                as_attachment=True,
                download_name=f'donnees_synthetiques_partiel_{task_id}.txt'
            )
        except Exception as e:
            return jsonify({'error': f'Erreur lors de la création du fichier partiel: {str(e)}'}), 500
    
    # Téléchargement normal (complet)
    download_name = f'donnees_synthetiques_{"complet" if task["status"] == "completed" else "actuel"}_{task_id}.txt'
    
    return send_file(
        results_file,
        as_attachment=True,
        download_name=download_name
    )

@app.route('/tasks')
def list_tasks():
    """Liste toutes les tâches"""
    task_list = []
    for task_id, task_info in task_manager.tasks.items():
        task_list.append({
            'id': task_id,
            'status': task_info['status'],
            'progress': task_info['progress'],
            'total': task_info['total'],
            'percentage': round((task_info['progress'] / task_info['total']) * 100, 2),
            'start_time': task_info['start_time'].strftime('%Y-%m-%d %H:%M:%S'),
            'last_update': task_info['last_update'].strftime('%Y-%m-%d %H:%M:%S'),
            'errors_count': len(task_info['errors'])
        })
    
    # Trier par heure de début (plus récent en premier)
    task_list.sort(key=lambda x: x['start_time'], reverse=True)
    
    return jsonify(task_list)

@app.route('/cleanup')
def cleanup_temp_files():
    """Nettoyer les fichiers temporaires (optionnel)"""
    try:
        temp_files_deleted = 0
        for filename in os.listdir(RESULTS_FOLDER):
            if filename.startswith('temp_results_'):
                file_path = os.path.join(RESULTS_FOLDER, filename)
                os.remove(file_path)
                temp_files_deleted += 1
        
        return jsonify({
            'message': f'{temp_files_deleted} fichiers temporaires supprimés'
        })
    except Exception as e:
        return jsonify({'error': f'Erreur lors du nettoyage: {str(e)}'}), 500

if __name__ == '__main__':
    print("🚀 Démarrage du serveur...")
    print("📂 Dossiers créés:", UPLOAD_FOLDER, RESULTS_FOLDER)
    print("🌐 Application disponible sur: http://localhost:5000")
    app.run(debug=True, threaded=True)