app.py

from flask import Flask, render_template, request, jsonify, session
from google import genai
import os
from datetime import datetime
import uuid
import io
import httpx

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"

# Variable globale pour stocker le fichier PDF une fois téléchargé
pdf_file = None

def load_pdf():
    """Télécharge et prépare le fichier PDF pour l'analyse"""
    global pdf_file
    if pdf_file is None:
        try:
            print(f"Téléchargement du PDF depuis {PDF_URL}...")
            pdf_content = httpx.get(PDF_URL).content
            pdf_io = io.BytesIO(pdf_content)
            
            # Télécharger le fichier via l'API Gemini
            pdf_file = client.files.upload(
                file=pdf_io,
                config=dict(mime_type='application/pdf')
            )
            print("PDF téléchargé et préparé avec succès!")
        except Exception as e:
            print(f"Erreur lors du téléchargement du PDF: {str(e)}")
            raise
    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())
    
    # Précharger le PDF au démarrage de l'application
    try:
        load_pdf()
    except Exception as e:
        return render_template('index.html', error=f"Erreur de chargement du PDF: {str(e)}")
    
    return render_template('index.html', pdf_url=PDF_URL)

@app.route('/chat', methods=['POST'])
def chat():
    data = request.json
    user_message = data.get('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)
    
    try:
        # S'assurer que le PDF est chargé
        pdf_document = load_pdf()
        
        # 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}"
        
        # Envoyer le message à Gemini avec le PDF comme contexte et obtenir la réponse
        # Note: Pour utiliser le PDF dans chaque message, nous devons créer un nouveau message avec le PDF
        response = client.models.generate_content(
            model="gemini-2.0-flash",
            contents=[pdf_document, prompt]
        )
        
        # Ajouter cette paire question/réponse à l'historique local
        if not hasattr(app, 'chat_histories'):
            app.chat_histories = {}
        
        if session_id not in app.chat_histories:
            app.chat_histories[session_id] = []
        
        app.chat_histories[session_id].append({
            'role': 'user',
            'content': user_message,
            'timestamp': datetime.now().strftime("%H:%M")
        })
        
        app.chat_histories[session_id].append({
            'role': 'model',
            'content': response.text,
            'timestamp': datetime.now().strftime("%H:%M")
        })
        
        # Formater l'historique pour l'interface
        history = app.chat_histories[session_id]
        
        return jsonify({
            'response': response.text,
            'history': history
        })
    except Exception as 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.
    """
    # Utilisation d'un dictionnaire global pour stocker les sessions (pour cet exemple)
    # Dans une application réelle, utilisez Redis ou une base de données
    if not hasattr(app, 'chat_sessions'):
        app.chat_sessions = {}
    
    if session_id not in app.chat_sessions:
        app.chat_sessions[session_id] = client.chats.create(model="gemini-2.0-flash")
    
    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')
    
    # Réinitialiser l'historique stocké
    if hasattr(app, 'chat_histories') and session_id in app.chat_histories:
        app.chat_histories[session_id] = []
    
    # 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")
    
    return jsonify({'status': 'success'})

if __name__ == '__main__':
    app.run(debug=True)