Update app.py

app.py

@@ -11,20 +11,24 @@ from reportlab.lib.units import inch
 from datetime import datetime
 import secrets
 import re
+import sqlite3
+import threading
+import time
+import uuid
 
 app = Flask(__name__)
 app.secret_key = secrets.token_hex(16)
 app.config['UPLOAD_FOLDER'] = 'uploads'
 app.config['MAX_CONTENT_LENGTH'] = 50 * 1024 * 1024  # 50MB max
+app.config['DATABASE'] = 'tasks.db'
 
-# Créer le dossier uploads
+# Créer les dossiers nécessaires
 os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
 
 # Configuration Gemini
 GEMINI_API_KEY = os.environ.get('GEMINI_API_KEY', 'YOUR_API_KEY_HERE')
 client = genai.Client(api_key=GEMINI_API_KEY)
 
-# Limite de tokens pour les vidéos
 MAX_VIDEO_TOKENS = 600000
 
 ALLOWED_EXTENSIONS = {
@@ -43,6 +47,113 @@ SUMMARY_TYPES = {
     'detaille': 'Fais un résumé exhaustif et détaillé avec tous les points importants, citations clés et analyse approfondie.'
 }
 
+# =======================
+# Base de données
+# =======================
+
+def init_db():
+    """Initialise la base de données"""
+    conn = sqlite3.connect(app.config['DATABASE'])
+    c = conn.cursor()
+    c.execute('''
+        CREATE TABLE IF NOT EXISTS tasks (
+            task_id TEXT PRIMARY KEY,
+            user_session TEXT,
+            filename TEXT,
+            summary_type TEXT,
+            status TEXT,
+            progress INTEGER,
+            summary TEXT,
+            error TEXT,
+            created_at TEXT,
+            completed_at TEXT,
+            source_type TEXT,
+            source_path TEXT
+        )
+    ''')
+    conn.commit()
+    conn.close()
+
+def get_db_connection():
+    """Retourne une connexion à la base de données"""
+    conn = sqlite3.connect(app.config['DATABASE'])
+    conn.row_factory = sqlite3.Row
+    return conn
+
+def create_task(user_session, filename, summary_type, source_type, source_path):
+    """Crée une nouvelle tâche dans la base de données"""
+    task_id = str(uuid.uuid4())
+    conn = get_db_connection()
+    conn.execute('''
+        INSERT INTO tasks (task_id, user_session, filename, summary_type, status, 
+                          progress, created_at, source_type, source_path)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ''', (task_id, user_session, filename, summary_type, 'pending', 0, 
+          datetime.now().isoformat(), source_type, source_path))
+    conn.commit()
+    conn.close()
+    return task_id
+
+def update_task_status(task_id, status, progress=None, summary=None, error=None):
+    """Met à jour le statut d'une tâche"""
+    conn = get_db_connection()
+    
+    if status == 'completed' or status == 'failed':
+        if progress is None:
+            progress = 100 if status == 'completed' else 0
+        conn.execute('''
+            UPDATE tasks 
+            SET status = ?, progress = ?, summary = ?, error = ?, completed_at = ?
+            WHERE task_id = ?
+        ''', (status, progress, summary, error, datetime.now().isoformat(), task_id))
+    else:
+        query = 'UPDATE tasks SET status = ?'
+        params = [status]
+        
+        if progress is not None:
+            query += ', progress = ?'
+            params.append(progress)
+        
+        query += ' WHERE task_id = ?'
+        params.append(task_id)
+        
+        conn.execute(query, params)
+    
+    conn.commit()
+    conn.close()
+
+def get_task(task_id):
+    """Récupère une tâche par son ID"""
+    conn = get_db_connection()
+    task = conn.execute('SELECT * FROM tasks WHERE task_id = ?', (task_id,)).fetchone()
+    conn.close()
+    return task
+
+def get_user_tasks(user_session):
+    """Récupère toutes les tâches d'un utilisateur"""
+    conn = get_db_connection()
+    tasks = conn.execute(
+        'SELECT * FROM tasks WHERE user_session = ? ORDER BY created_at DESC',
+        (user_session,)
+    ).fetchall()
+    conn.close()
+    return tasks
+
+def delete_old_tasks():
+    """Supprime les tâches de plus de 7 jours"""
+    conn = get_db_connection()
+    seven_days_ago = datetime.now().timestamp() - (7 * 24 * 60 * 60)
+    conn.execute('''
+        DELETE FROM tasks 
+        WHERE datetime(created_at) < datetime(?, 'unixepoch')
+    ''', (seven_days_ago,))
+    conn.commit()
+    conn.close()
+
+# =======================
+# Fonctions utilitaires
+# =======================
+
 def allowed_file(filename):
     return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
 
@@ -55,47 +166,68 @@ def is_youtube_url(url):
     youtube_regex = r'(https?://)?(www\.)?(youtube\.com/watch\?v=|youtu\.be/)[\w-]+'
     return bool(re.match(youtube_regex, url))
 
-def estimate_video_tokens(video_duration_seconds, fps=1, use_low_resolution=False):
-    """Estime le nombre de tokens pour une vidéo"""
-    # Tokens par frame
-    tokens_per_frame = 66 if use_low_resolution else 258
-    # Tokens audio par seconde
-    tokens_per_second_audio = 32
-    # Total par seconde
-    tokens_per_second = (tokens_per_frame * fps) + tokens_per_second_audio
-    return video_duration_seconds * tokens_per_second
-
-def generate_summary(file_path, filename, summary_type):
-    """Génère un résumé avec l'API Gemini"""
-    mime_type = get_mime_type(filename)
-    prompt = SUMMARY_TYPES.get(summary_type, SUMMARY_TYPES['moyen'])
-    
+def get_session_id():
+    """Récupère ou crée un ID de session"""
+    if 'session_id' not in session:
+        session['session_id'] = str(uuid.uuid4())
+    return session['session_id']
+
+# =======================
+# Traitement en arrière-plan
+# =======================
+
+def process_file_background(task_id, file_path, filename, summary_type):
+    """Traite un fichier en arrière-plan"""
     try:
-        # Upload le fichier via File API
+        update_task_status(task_id, 'processing', progress=10)
+        
+        mime_type = get_mime_type(filename)
+        prompt = SUMMARY_TYPES.get(summary_type, SUMMARY_TYPES['moyen'])
+        
+        update_task_status(task_id, 'processing', progress=30)
+        
+        # Upload le fichier
         uploaded_file = client.files.upload(file=file_path)
         
+        update_task_status(task_id, 'processing', progress=60)
+        
         # Génère le résumé
         response = client.models.generate_content(
             model="gemini-2.5-flash",
             contents=[uploaded_file, prompt]
         )
         
-        return response.text
+        summary = response.text
+        
+        update_task_status(task_id, 'completed', progress=100, summary=summary)
+        
     except Exception as e:
-        return f"Erreur lors de la génération du résumé: {str(e)}"
-
-def generate_summary_from_youtube(youtube_url, summary_type):
-    """Génère un résumé à partir d'une URL YouTube"""
-    prompt = SUMMARY_TYPES.get(summary_type, SUMMARY_TYPES['moyen'])
+        update_task_status(task_id, 'failed', error=str(e))
     
+    finally:
+        # Nettoie le fichier
+        if os.path.exists(file_path):
+            try:
+                os.remove(file_path)
+            except:
+                pass
+
+def process_youtube_background(task_id, youtube_url, summary_type):
+    """Traite une vidéo YouTube en arrière-plan"""
     try:
+        update_task_status(task_id, 'processing', progress=10)
+        
+        prompt = SUMMARY_TYPES.get(summary_type, SUMMARY_TYPES['moyen'])
+        
+        update_task_status(task_id, 'processing', progress=30)
+        
         # Vérifier les informations du modèle
         model_info = client.models.get(model="gemini-2.5-flash")
         context_window = model_info.input_token_limit
         
-        print(f"Context window: {context_window} tokens")
+        update_task_status(task_id, 'processing', progress=50)
         
-        # Générer le contenu avec l'URL YouTube
+        # Générer le contenu
         response = client.models.generate_content(
             model='gemini-2.5-flash',
             contents=types.Content(
@@ -108,13 +240,19 @@ def generate_summary_from_youtube(youtube_url, summary_type):
             )
         )
         
-        return response.text
+        summary = response.text
+        
+        update_task_status(task_id, 'completed', progress=100, summary=summary)
+        
     except Exception as e:
         error_msg = str(e)
-        # Vérifier si l'erreur est liée à la limite de tokens
         if 'token' in error_msg.lower() or 'too large' in error_msg.lower():
-            return f"Erreur: La vidéo est trop longue (dépasse la limite de {MAX_VIDEO_TOKENS:,} tokens). Veuillez utiliser une vidéo plus courte."
-        return f"Erreur lors de la génération du résumé: {error_msg}"
+            error_msg = f"La vidéo est trop longue (dépasse la limite de {MAX_VIDEO_TOKENS:,} tokens). Veuillez utiliser une vidéo plus courte."
+        update_task_status(task_id, 'failed', error=error_msg)
+
+# =======================
+# Fonction PDF
+# =======================
 
 def create_pdf(summary_text, original_filename, summary_type):
     """Crée un PDF du résumé"""
@@ -123,7 +261,6 @@ def create_pdf(summary_text, original_filename, summary_type):
     styles = getSampleStyleSheet()
     story = []
     
-    # Titre
     title_style = ParagraphStyle(
         'CustomTitle',
         parent=styles['Heading1'],
@@ -133,13 +270,11 @@ def create_pdf(summary_text, original_filename, summary_type):
     title = Paragraph(f"Résumé: {original_filename}", title_style)
     story.append(title)
     
-    # Info
     info_style = styles['Normal']
     info = Paragraph(f"Type: {summary_type.upper()} | Date: {datetime.now().strftime('%d/%m/%Y %H:%M')}", info_style)
     story.append(info)
     story.append(Spacer(1, 0.3*inch))
     
-    # Contenu du résumé
     for paragraph in summary_text.split('\n\n'):
         if paragraph.strip():
             p = Paragraph(paragraph.replace('\n', '<br/>'), styles['Normal'])
@@ -150,14 +285,17 @@ def create_pdf(summary_text, original_filename, summary_type):
     buffer.seek(0)
     return buffer
 
+# =======================
+# Routes
+# =======================
+
 @app.route('/')
 def index():
-    if 'history' not in session:
-        session['history'] = []
     return render_template('index.html')
 
 @app.route('/upload', methods=['POST'])
 def upload_file():
+    user_session = get_session_id()
     youtube_url = request.form.get('youtube_url', '').strip()
     summary_type = request.form.get('summary_type', 'moyen')
     
@@ -166,39 +304,30 @@ def upload_file():
         if not is_youtube_url(youtube_url):
             return jsonify({'error': 'URL YouTube invalide'}), 400
         
-        try:
-            summary = generate_summary_from_youtube(youtube_url, summary_type)
-            
-            # Vérifier si c'est un message d'erreur
-            if summary.startswith("Erreur:"):
-                return jsonify({'error': summary}), 400
-            
-            # Ajouter à l'historique
-            if 'history' not in session:
-                session['history'] = []
-            
-            history_item = {
-                'id': len(session['history']),
-                'filename': 'Vidéo YouTube',
-                'summary_type': summary_type,
-                'summary': summary,
-                'date': datetime.now().strftime('%d/%m/%Y %H:%M'),
-                'filepath': youtube_url
-            }
-            
-            session['history'].append(history_item)
-            session.modified = True
-            
-            return jsonify({
-                'success': True,
-                'summary': summary,
-                'history_id': history_item['id']
-            })
+        # Créer la tâche
+        task_id = create_task(
+            user_session=user_session,
+            filename='Vidéo YouTube',
+            summary_type=summary_type,
+            source_type='youtube',
+            source_path=youtube_url
+        )
+        
+        # Lancer le traitement en arrière-plan
+        thread = threading.Thread(
+            target=process_youtube_background,
+            args=(task_id, youtube_url, summary_type)
+        )
+        thread.daemon = True
+        thread.start()
         
-        except Exception as e:
-            return jsonify({'error': str(e)}), 500
+        return jsonify({
+            'success': True,
+            'task_id': task_id,
+            'message': 'Traitement en cours...'
+        })
     
-    # Traitement fichier normal
+    # Traitement fichier
     if 'file' not in request.files:
         return jsonify({'error': 'Aucun fichier ou URL YouTube fourni'}), 400
     
@@ -211,65 +340,142 @@ def upload_file():
         return jsonify({'error': 'Type de fichier non supporté'}), 400
     
     filename = secure_filename(file.filename)
-    filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+    filepath = os.path.join(app.config['UPLOAD_FOLDER'], f"{uuid.uuid4()}_{filename}")
     file.save(filepath)
     
-    try:
-        # Génère le résumé
-        summary = generate_summary(filepath, filename, summary_type)
-        
-        # Ajoute à l'historique
-        if 'history' not in session:
-            session['history'] = []
-        
-        history_item = {
-            'id': len(session['history']),
-            'filename': filename,
-            'summary_type': summary_type,
-            'summary': summary,
-            'date': datetime.now().strftime('%d/%m/%Y %H:%M'),
-            'filepath': filepath
-        }
-        
-        session['history'].append(history_item)
-        session.modified = True
-        
-        return jsonify({
-            'success': True,
-            'summary': summary,
-            'history_id': history_item['id']
+    # Créer la tâche
+    task_id = create_task(
+        user_session=user_session,
+        filename=filename,
+        summary_type=summary_type,
+        source_type='file',
+        source_path=filepath
+    )
+    
+    # Lancer le traitement en arrière-plan
+    thread = threading.Thread(
+        target=process_file_background,
+        args=(task_id, filepath, filename, summary_type)
+    )
+    thread.daemon = True
+    thread.start()
+    
+    return jsonify({
+        'success': True,
+        'task_id': task_id,
+        'message': 'Traitement en cours...'
+    })
+
+@app.route('/task/<task_id>')
+def get_task_status(task_id):
+    """Récupère le statut d'une tâche"""
+    task = get_task(task_id)
+    
+    if not task:
+        return jsonify({'error': 'Tâche non trouvée'}), 404
+    
+    return jsonify({
+        'task_id': task['task_id'],
+        'filename': task['filename'],
+        'summary_type': task['summary_type'],
+        'status': task['status'],
+        'progress': task['progress'],
+        'summary': task['summary'],
+        'error': task['error'],
+        'created_at': task['created_at'],
+        'completed_at': task['completed_at']
+    })
+
+@app.route('/tasks')
+def get_all_tasks():
+    """Récupère toutes les tâches de l'utilisateur"""
+    user_session = get_session_id()
+    tasks = get_user_tasks(user_session)
+    
+    task_list = []
+    for task in tasks:
+        task_list.append({
+            'task_id': task['task_id'],
+            'filename': task['filename'],
+            'summary_type': task['summary_type'],
+            'status': task['status'],
+            'progress': task['progress'],
+            'summary': task['summary'],
+            'error': task['error'],
+            'created_at': task['created_at'],
+            'completed_at': task['completed_at']
         })
     
-    except Exception as e:
-        return jsonify({'error': str(e)}), 500
-    finally:
-        # Nettoie le fichier après traitement
-        if os.path.exists(filepath):
-            os.remove(filepath)
-
-@app.route('/download/<int:history_id>')
-def download_pdf(history_id):
-    if 'history' not in session or history_id >= len(session['history']):
-        return jsonify({'error': 'Résumé non trouvé'}), 404
+    return jsonify(task_list)
+
+@app.route('/download/<task_id>')
+def download_pdf(task_id):
+    """Télécharge le PDF d'une tâche"""
+    task = get_task(task_id)
     
-    item = session['history'][history_id]
-    pdf_buffer = create_pdf(item['summary'], item['filename'], item['summary_type'])
+    if not task:
+        return jsonify({'error': 'Tâche non trouvée'}), 404
+    
+    if task['status'] != 'completed':
+        return jsonify({'error': 'Résumé non encore disponible'}), 400
+    
+    pdf_buffer = create_pdf(task['summary'], task['filename'], task['summary_type'])
     
     return send_file(
         pdf_buffer,
         mimetype='application/pdf',
         as_attachment=True,
-        download_name=f"resume_{item['filename']}.pdf"
+        download_name=f"resume_{task['filename']}.pdf"
     )
 
-@app.route('/history')
-def get_history():
-    return jsonify(session.get('history', []))
+@app.route('/delete-task/<task_id>', methods=['DELETE'])
+def delete_task(task_id):
+    """Supprime une tâche"""
+    user_session = get_session_id()
+    task = get_task(task_id)
+    
+    if not task:
+        return jsonify({'error': 'Tâche non trouvée'}), 404
+    
+    if task['user_session'] != user_session:
+        return jsonify({'error': 'Non autorisé'}), 403
+    
+    conn = get_db_connection()
+    conn.execute('DELETE FROM tasks WHERE task_id = ?', (task_id,))
+    conn.commit()
+    conn.close()
+    
+    return jsonify({'success': True})
 
-@app.route('/clear-history', methods=['POST'])
-def clear_history():
-    session['history'] = []
+@app.route('/clear-tasks', methods=['POST'])
+def clear_all_tasks():
+    """Supprime toutes les tâches de l'utilisateur"""
+    user_session = get_session_id()
+    
+    conn = get_db_connection()
+    conn.execute('DELETE FROM tasks WHERE user_session = ?', (user_session,))
+    conn.commit()
+    conn.close()
+    
     return jsonify({'success': True})
 
+# =======================
+# Initialisation
+# =======================
+
+# Initialiser la base de données au démarrage
+with app.app_context():
+    init_db()
+
+# Nettoyage périodique des anciennes tâches
+def cleanup_old_tasks():
+    while True:
+        time.sleep(86400)  # Toutes les 24 heures
+        delete_old_tasks()
+
+cleanup_thread = threading.Thread(target=cleanup_old_tasks)
+cleanup_thread.daemon = True
+cleanup_thread.start()
+
 if __name__ == '__main__':
     app.run(debug=True)