Update app.py

app.py

@@ -1,176 +1,274 @@
-import logging
-from flask import Flask, render_template, request, jsonify, session
-from google import genai
+from flask import Flask, render_template, request, jsonify, send_file
 import os
-from datetime import datetime
+import json
 import uuid
+import threading
+import time
+from datetime import datetime
+import base64
+import mimetypes
+from google import genai
+from google.genai import types
+from reportlab.lib.pagesizes import A4
+from reportlab.platypus import SimpleDocTemplate, Image
+from reportlab.lib.utils import ImageReader
+from PIL import Image as PILImage
 import io
-import httpx
-
-# Configuration du logging
-logging.basicConfig(
-    level=logging.DEBUG,
-    format="%(asctime)s [%(levelname)s] %(message)s",
-    datefmt="%Y-%m-%d %H:%M:%S"
-)
 
 app = Flask(__name__)
-app.secret_key = os.urandom(24)  # Requis pour utiliser les sessions Flask
-
-# Configuration de l'API Gemini (idéalement à déplacer dans un fichier de configuration)
-# os.environ["GOOGLE_API_KEY"] = "VOTRE_GEMINI_API_KEY"
-client = genai.Client(api_key=os.environ.get("GOOGLE_API_KEY", "GEMINI_API_KEY"))
 
-# URL du PDF à analyser (fixe dans cette version)
-PDF_URL = "http://www.ddl.cnrs.fr/projets/clhass/PageWeb/ressources/fang.pdf"
+# Configuration
+UPLOAD_FOLDER = 'generated_pages'
+PDF_FOLDER = 'generated_pdfs'
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+os.makedirs(PDF_FOLDER, exist_ok=True)
 
-# Variable globale pour stocker le fichier PDF une fois téléchargé
-pdf_file = None
+# Stockage des tâches en cours
+active_tasks = {}
 
-def load_pdf():
-    """Télécharge et prépare le fichier PDF pour l'analyse"""
-    global pdf_file
-    if pdf_file is None:
+class MangaGenerator:
+    def __init__(self, api_key):
+        self.client = genai.Client(api_key=api_key)
+        self.model = "gemini-2.5-flash-image-preview"
+    
+    def save_binary_file(self, file_name, data):
+        """Sauvegarde un fichier binaire"""
+        try:
+            with open(file_name, "wb") as f:
+                f.write(data)
+            return True
+        except Exception as e:
+            print(f"Erreur lors de la sauvegarde: {e}")
+            return False
+    
+    def generate_page(self, prompt, page_number, task_id):
+        """Génère une page de manga avec le prompt donné"""
         try:
-            logging.info(f"Début du téléchargement du PDF depuis {PDF_URL}")
-            response = httpx.get(PDF_URL)
-            response.raise_for_status()
-            pdf_content = response.content
-            pdf_io = io.BytesIO(pdf_content)
+            contents = [
+                types.Content(
+                    role="user",
+                    parts=[
+                        types.Part.from_text(text=prompt),
+                    ],
+                ),
+            ]
             
-            logging.info("Téléchargement réussi. Envoi du PDF à l'API Gemini...")
-            # Télécharger le fichier via l'API Gemini
-            pdf_file = client.files.upload(
-                file=pdf_io,
-                config=dict(mime_type='application/pdf')
+            generate_content_config = types.GenerateContentConfig(
+                response_modalities=["IMAGE", "TEXT"],
             )
-            logging.info("PDF téléchargé et préparé avec succès par Gemini!")
+            
+            generated_files = []
+            
+            for chunk in self.client.models.generate_content_stream(
+                model=self.model,
+                contents=contents,
+                config=generate_content_config,
+            ):
+                if (
+                    chunk.candidates is None
+                    or chunk.candidates[0].content is None
+                    or chunk.candidates[0].content.parts is None
+                ):
+                    continue
+                
+                if (chunk.candidates[0].content.parts[0].inline_data and 
+                    chunk.candidates[0].content.parts[0].inline_data.data):
+                    
+                    file_name = f"{UPLOAD_FOLDER}/page_{page_number}_{task_id}"
+                    inline_data = chunk.candidates[0].content.parts[0].inline_data
+                    data_buffer = inline_data.data
+                    file_extension = mimetypes.guess_extension(inline_data.mime_type) or '.png'
+                    
+                    full_path = f"{file_name}{file_extension}"
+                    if self.save_binary_file(full_path, data_buffer):
+                        generated_files.append(full_path)
+                else:
+                    if hasattr(chunk, 'text') and chunk.text:
+                        print(f"Texte généré pour page {page_number}: {chunk.text}")
+            
+            return generated_files
+            
         except Exception as e:
-            logging.error(f"Erreur lors du téléchargement ou de la préparation du PDF: {str(e)}")
-            raise
-    else:
-        logging.debug("PDF déjà chargé, utilisation du cache.")
-    return pdf_file
-
-@app.route('/')
-def index():
-    # Créer un ID de session unique s'il n'existe pas déjà
-    if 'session_id' not in session:
-        session['session_id'] = str(uuid.uuid4())
-        logging.info(f"Nouvelle session créée avec l'ID : {session['session_id']}")
-    else:
-        logging.debug(f"Session existante détectée : {session['session_id']}")
+            print(f"Erreur lors de la génération de la page {page_number}: {e}")
+            return []
 
-    # Précharger le PDF au démarrage de l'application
+def create_pdf(image_paths, output_path):
+    """Crée un PDF à partir des images générées"""
     try:
-        load_pdf()
+        doc = SimpleDocTemplate(output_path, pagesize=A4)
+        story = []
+        
+        for img_path in sorted(image_paths):
+            if os.path.exists(img_path):
+                # Redimensionner l'image pour s'adapter à la page A4
+                with PILImage.open(img_path) as img:
+                    img_buffer = io.BytesIO()
+                    img.save(img_buffer, format='PNG')
+                    img_buffer.seek(0)
+                    
+                    # Calculer les dimensions pour s'adapter à A4
+                    page_width, page_height = A4
+                    img_width, img_height = img.size
+                    
+                    # Maintenir le ratio d'aspect
+                    ratio = min(page_width/img_width, page_height/img_height) * 0.9
+                    new_width = img_width * ratio
+                    new_height = img_height * ratio
+                    
+                    story.append(Image(ImageReader(img_buffer), 
+                                     width=new_width, height=new_height))
+        
+        doc.build(story)
+        return True
+        
     except Exception as e:
-        error_msg = f"Erreur de chargement du PDF: {str(e)}"
-        logging.error(error_msg)
-        return render_template('index.html', error=error_msg)
-    
-    logging.info("Chargement de la page d'accueil réussi.")
-    return render_template('index.html', pdf_url=PDF_URL)
-
-@app.route('/chat', methods=['POST'])
-def chat():
-    data = request.json
-    user_message = data.get('message', '')
-    logging.info(f"Message utilisateur reçu: {user_message}")
-
-    # Récupérer ou créer une session de chat pour cet utilisateur
-    session_id = session.get('session_id')
-    chat_session = get_or_create_chat_session(session_id)
-    logging.debug(f"Session de chat pour l'ID {session_id}: {chat_session}")
+        print(f"Erreur lors de la création du PDF: {e}")
+        return False
 
+def generate_manga_task(manga_data, task_id):
+    """Tâche de génération de manga qui s'exécute en arrière-plan"""
     try:
-        # S'assurer que le PDF est chargé
-        pdf_document = load_pdf()
-        logging.debug("PDF document récupéré pour le traitement du chat.")
-
-        # Construire le prompt pour Gemini avec référence au PDF
-        prompt = f"En vous basant sur le contenu du PDF sur la langue fang, veuillez répondre à: {user_message}"
-        logging.info(f"Prompt construit pour Gemini: {prompt}")
-
-        # Envoyer le message à Gemini avec le PDF comme contexte et obtenir la réponse
-        logging.info("Envoi du prompt à Gemini...")
-        response = client.models.generate_content(
-            model="gemini-2.0-pro-exp-02-05",
-            contents=[pdf_document, prompt]
-        )
-        logging.info("Réponse reçue de Gemini.")
-
-        # Ajouter cette paire question/réponse à l'historique local
-        if not hasattr(app, 'chat_histories'):
-            app.chat_histories = {}
-            logging.debug("Création de l'historique global des chats.")
-
-        if session_id not in app.chat_histories:
-            app.chat_histories[session_id] = []
-            logging.debug(f"Création d'un historique de chat pour la session {session_id}.")
-
-        timestamp = datetime.now().strftime("%H:%M")
-        app.chat_histories[session_id].append({
-            'role': 'user',
-            'content': user_message,
-            'timestamp': timestamp
-        })
-        logging.debug("Message utilisateur ajouté à l'historique du chat.")
-
-        app.chat_histories[session_id].append({
-            'role': 'model',
-            'content': response.text,
-            'timestamp': timestamp
-        })
-        logging.debug("Réponse du modèle ajoutée à l'historique du chat.")
+        api_key = os.environ.get("GEMINI_API_KEY")
+        if not api_key:
+            active_tasks[task_id]['status'] = 'error'
+            active_tasks[task_id]['error'] = 'API Key Gemini non trouvée'
+            return
+        
+        generator = MangaGenerator(api_key)
+        active_tasks[task_id]['status'] = 'generating'
+        active_tasks[task_id]['total_pages'] = len(manga_data)
+        active_tasks[task_id]['current_page'] = 0
+        
+        generated_files = []
+        
+        # Trier les parties par ordre numérique
+        sorted_parts = sorted(manga_data.items(), key=lambda x: int(x[0].split('-')[1]))
+        
+        for i, (part_key, prompt) in enumerate(sorted_parts, 1):
+            active_tasks[task_id]['current_page'] = i
+            active_tasks[task_id]['current_part'] = part_key
+            
+            print(f"Génération de la page {i}/{len(sorted_parts)} - {part_key}")
+            
+            page_files = generator.generate_page(prompt, i, task_id)
+            generated_files.extend(page_files)
+            
+            # Attendre un peu entre les générations pour éviter les limites de taux
+            time.sleep(2)
+        
+        # Créer le PDF
+        active_tasks[task_id]['status'] = 'creating_pdf'
+        pdf_path = f"{PDF_FOLDER}/manga_{task_id}.pdf"
+        
+        if create_pdf(generated_files, pdf_path):
+            active_tasks[task_id]['status'] = 'completed'
+            active_tasks[task_id]['pdf_path'] = pdf_path
+            active_tasks[task_id]['completed_at'] = datetime.now().isoformat()
+        else:
+            active_tasks[task_id]['status'] = 'error'
+            active_tasks[task_id]['error'] = 'Erreur lors de la création du PDF'
+            
+    except Exception as e:
+        active_tasks[task_id]['status'] = 'error'
+        active_tasks[task_id]['error'] = str(e)
+        print(f"Erreur dans la tâche {task_id}: {e}")
 
-        # Formater l'historique pour l'interface
-        history = app.chat_histories[session_id]
-        logging.info("Historique du chat formaté et prêt à être envoyé.")
+@app.route('/')
+def index():
+    return render_template('index.html')
 
+@app.route('/generate', methods=['POST'])
+def generate():
+    try:
+        data = request.get_json()
+        
+        if not data:
+            return jsonify({'error': 'Aucune donnée JSON fournie'}), 400
+        
+        # Valider que les données contiennent des parties
+        manga_parts = {k: v for k, v in data.items() if k.startswith('partie-')}
+        
+        if not manga_parts:
+            return jsonify({'error': 'Aucune partie trouvée dans les données'}), 400
+        
+        # Créer une nouvelle tâche
+        task_id = str(uuid.uuid4())
+        active_tasks[task_id] = {
+            'status': 'queued',
+            'created_at': datetime.now().isoformat(),
+            'manga_data': manga_parts
+        }
+        
+        # Lancer la génération en arrière-plan
+        thread = threading.Thread(target=generate_manga_task, args=(manga_parts, task_id))
+        thread.daemon = True
+        thread.start()
+        
         return jsonify({
-            'response': response.text,
-            'history': history
+            'task_id': task_id,
+            'status': 'queued',
+            'message': 'Génération démarrée'
         })
+        
     except Exception as e:
-        logging.error(f"Erreur lors du traitement du chat: {str(e)}")
         return jsonify({'error': str(e)}), 500
 
-def get_or_create_chat_session(session_id):
-    """
-    Récupère une session de chat existante ou en crée une nouvelle.
-    Dans une application réelle, vous pourriez stocker cela dans une base de données.
-    """
-    if not hasattr(app, 'chat_sessions'):
-        app.chat_sessions = {}
-        logging.debug("Création du dictionnaire global des sessions de chat.")
-
-    if session_id not in app.chat_sessions:
-        logging.info(f"Aucune session de chat existante pour {session_id}. Création d'une nouvelle session.")
-        app.chat_sessions[session_id] = client.chats.create(model="gemini-2.0-flash")
-    else:
-        logging.debug(f"Session de chat existante retrouvée pour {session_id}.")
+@app.route('/status/<task_id>')
+def get_status(task_id):
+    if task_id not in active_tasks:
+        return jsonify({'error': 'Tâche non trouvée'}), 404
     
-    return app.chat_sessions[session_id]
-
-@app.route('/reset', methods=['POST'])
-def reset_chat():
-    """Réinitialise la session de chat actuelle"""
-    session_id = session.get('session_id')
-    logging.info(f"Réinitialisation de la session de chat pour {session_id}")
-
-    # Réinitialiser l'historique stocké
-    if hasattr(app, 'chat_histories') and session_id in app.chat_histories:
-        app.chat_histories[session_id] = []
-        logging.debug("Historique de chat réinitialisé.")
+    task = active_tasks[task_id].copy()
+    # Ne pas renvoyer les données du manga dans le status pour économiser la bande passante
+    if 'manga_data' in task:
+        del task['manga_data']
+    
+    return jsonify(task)
 
-    # Réinitialiser la session de chat
-    if hasattr(app, 'chat_sessions') and session_id in app.chat_sessions:
-        app.chat_sessions[session_id] = client.chats.create(model="gemini-2.0-flash")
-        logging.debug("Session de chat réinitialisée dans le dictionnaire des sessions.")
+@app.route('/download/<task_id>')
+def download_pdf(task_id):
+    if task_id not in active_tasks:
+        return jsonify({'error': 'Tâche non trouvée'}), 404
+    
+    task = active_tasks[task_id]
+    if task['status'] != 'completed' or 'pdf_path' not in task:
+        return jsonify({'error': 'PDF non disponible'}), 400
+    
+    pdf_path = task['pdf_path']
+    if not os.path.exists(pdf_path):
+        return jsonify({'error': 'Fichier PDF non trouvé'}), 404
+    
+    return send_file(pdf_path, as_attachment=True, 
+                     download_name=f'manga_{task_id}.pdf')
 
-    return jsonify({'status': 'success'})
+@app.route('/tasks')
+def list_tasks():
+    # Nettoyer les tâches anciennes (plus de 24h)
+    current_time = datetime.now()
+    to_remove = []
+    
+    for task_id, task in active_tasks.items():
+        created_at = datetime.fromisoformat(task['created_at'])
+        if (current_time - created_at).total_seconds() > 86400:  # 24 heures
+            to_remove.append(task_id)
+    
+    for task_id in to_remove:
+        del active_tasks[task_id]
+    
+    # Retourner la liste des tâches sans les données manga
+    tasks_summary = {}
+    for task_id, task in active_tasks.items():
+        task_copy = task.copy()
+        if 'manga_data' in task_copy:
+            del task_copy['manga_data']
+        tasks_summary[task_id] = task_copy
+    
+    return jsonify(tasks_summary)
 
 if __name__ == '__main__':
-    logging.info("Démarrage de l'application Flask avec le mode debug activé.")
-    app.run(debug=True)
+    # Vérifier que l'API key est configurée
+    if not os.environ.get("GEMINI_API_KEY"):
+        print("⚠️  ATTENTION: La variable d'environnement GEMINI_API_KEY n'est pas définie!")
+        print("   Définissez-la avec: export GEMINI_API_KEY=votre_clé_api")
+    
+    app.run(debug=True, host='0.0.0.0', port=5000)