app.py

from flask import Flask, render_template, request, jsonify
import google.generativeai as genai
import os
from PIL import Image
import tempfile
import PIL.Image
import subprocess
import logging
from urllib.parse import urlparse
import requests
import time
import ssl
from logging.handlers import RotatingFileHandler

app = Flask(__name__)

# Configuration des logs
log_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
log_file = 'app.log'

# Handler pour fichier avec rotation
file_handler = RotatingFileHandler(log_file, maxBytes=10485760, backupCount=5)  # 10MB par fichier, max 5 fichiers
file_handler.setFormatter(log_formatter)

# Handler pour console
console_handler = logging.StreamHandler()
console_handler.setFormatter(log_formatter)

# Configuration du logger principal
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
logger.addHandler(file_handler)
logger.addHandler(console_handler)

# Configuration de l'API Gemini
token = os.environ.get("TOKEN")
if not token:
    logger.error("Token API non trouvé dans les variables d'environnement")
    raise ValueError("Token API manquant")

genai.configure(api_key=token)

generation_config = {
    "temperature": 1,
    "max_output_tokens": 8192,
}

safety_settings = [
    {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
    {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
    {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
    {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
]

@app.route('/')
def generale():
    logger.info("Accès à la page principale")
    return render_template("generale.html")

def upload_and_process_file(file_path):
    """Upload et traite un fichier avec l'API Gemini avec gestion des erreurs améliorée"""
    max_retries = 3
    retry_delay = 2  # secondes
    
    for attempt in range(max_retries):
        try:
            logger.info(f"Tentative d'upload {attempt + 1}/{max_retries} pour {file_path}")
            
            # Vérification du fichier
            if not os.path.exists(file_path):
                logger.error(f"Fichier non trouvé: {file_path}")
                raise FileNotFoundError(f"Le fichier {file_path} n'existe pas")
                
            file_size = os.path.getsize(file_path)
            if file_size == 0:
                logger.error(f"Fichier vide: {file_path}")
                raise ValueError(f"Le fichier {file_path} est vide")
                
            # Upload du fichier
            uploaded_file = genai.upload_file(path=file_path)
            logger.info(f"Upload réussi: {uploaded_file.uri}")

            # Attente du traitement
            timeout = 300  # 5 minutes
            start_time = time.time()
            
            while uploaded_file.state.name == "PROCESSING":
                if time.time() - start_time > timeout:
                    logger.error("Timeout pendant le traitement du fichier")
                    raise TimeoutError("Timeout pendant le traitement du fichier")
                
                logger.debug(f"En attente du traitement... Temps écoulé: {int(time.time() - start_time)}s")
                time.sleep(10)
                uploaded_file = genai.get_file(uploaded_file.name)

            if uploaded_file.state.name == "FAILED":
                logger.error(f"Échec du traitement: {uploaded_file.state.name}")
                raise ValueError(f"Échec du traitement: {uploaded_file.state.name}")
                
            logger.info(f"Traitement terminé avec succès: {uploaded_file.uri}")
            return uploaded_file

        except ssl.SSLError as e:
            logger.error(f"Erreur SSL lors de l'upload (tentative {attempt + 1}): {e}")
            if attempt < max_retries - 1:
                time.sleep(retry_delay * (attempt + 1))
            else:
                raise
                
        except Exception as e:
            logger.error(f"Erreur lors de l'upload (tentative {attempt + 1}): {e}")
            if attempt < max_retries - 1:
                time.sleep(retry_delay * (attempt + 1))
            else:
                raise

def is_youtube_url(url):
    """Vérifie si l'URL est une URL YouTube"""
    parsed = urlparse(url)
    return any(domain in parsed.netloc for domain in ['youtube.com', 'youtu.be'])

def download_youtube_video(url):
    """Télécharge une vidéo YouTube en utilisant subprocess avec youtube-dl"""
    try:
        with tempfile.TemporaryDirectory() as temp_dir:
            output_template = os.path.join(temp_dir, '%(title)s.%(ext)s')
            
            command = [
                'youtube-dl',
                '--format', 'best[filesize<50M]',
                '--quiet',
                '--no-warnings',
                '--output', output_template,
                url
            ]
            
            logger.info(f"Début du téléchargement de la vidéo: {url}")
            
            process = subprocess.Popen(
                command,
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
                universal_newlines=True
            )
            
            stdout, stderr = process.communicate()
            
            if process.returncode != 0:
                logger.error(f"Erreur youtube-dl: {stderr}")
                raise Exception(f"Erreur youtube-dl: {stderr}")
            
            downloaded_files = os.listdir(temp_dir)
            if not downloaded_files:
                logger.error("Aucun fichier n'a été téléchargé")
                raise FileNotFoundError("Aucun fichier n'a été téléchargé")
            
            video_path = os.path.join(temp_dir, downloaded_files[0])
            
            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(video_path)[1])
            with open(video_path, 'rb') as f:
                temp_file.write(f.read())
            
            logger.info(f"Vidéo téléchargée avec succès: {temp_file.name}")
            return temp_file.name
                
    except Exception as e:
        logger.error(f"Erreur lors du téléchargement de la vidéo: {e}")
        return None

def telecharger_pdf(url):
    """Télécharge un PDF et retourne le chemin du fichier"""
    try:
        logger.info(f"Début du téléchargement du PDF: {url}")
        response = requests.get(url)
        response.raise_for_status()

        with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as temp_file:
            temp_file.write(response.content)
            logger.info(f"PDF téléchargé avec succès: {temp_file.name}")
            return temp_file.name
    except Exception as e:
        logger.error(f"Erreur lors du téléchargement du PDF: {e}")
        return None

def allowed_file(filename):
    """Vérifie si l'extension du fichier est autorisée"""
    ALLOWED_EXTENSIONS = {'pdf', 'png', 'jpg', 'jpeg', 'gif', 'mp4', 'mov', 'avi'}
    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS

@app.route('/submit', methods=['POST'])
def submit_question():
    logger.info("Nouvelle soumission reçue")
    question = request.form.get('question')
    urls = request.form.getlist('urls')
    files = request.files.getlist('files')
    
    logger.info(f"Question reçue: {question}")
    logger.info(f"URLs reçues: {urls}")
    logger.info(f"Nombre de fichiers reçus: {len(files)}")
    
    content = [question]
    temp_files = []
    
    try:
        # Traitement des fichiers uploadés
        for file in files:
            if file and allowed_file(file.filename):
                logger.info(f"Traitement du fichier: {file.filename}")
                with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(file.filename)[1]) as temp_file:
                    file.save(temp_file.name)
                    temp_files.append(temp_file.name)
                    if file.filename.lower().endswith(('.png', '.jpg', '.jpeg', '.gif')):
                        content.append(PIL.Image.open(temp_file.name))
                        logger.info(f"Image ajoutée au contenu: {file.filename}")
                    else:
                        uploaded_file = upload_and_process_file(temp_file.name)
                        content.append(uploaded_file)
                        logger.info(f"Fichier uploadé et ajouté au contenu: {file.filename}")

        # Traitement des URLs
        for url in urls:
            logger.info(f"Traitement de l'URL: {url}")
            if is_youtube_url(url):
                video_path = download_youtube_video(url)
                if video_path:
                    temp_files.append(video_path)
                    uploaded_file = upload_and_process_file(video_path)
                    content.append(uploaded_file)
                    logger.info(f"Vidéo YouTube traitée et ajoutée au contenu: {url}")
            elif url.lower().endswith('.pdf'):
                pdf_path = telecharger_pdf(url)
                if pdf_path:
                    temp_files.append(pdf_path)
                    uploaded_file = upload_and_process_file(pdf_path)
                    content.append(uploaded_file)
                    logger.info(f"PDF téléchargé et ajouté au contenu: {url}")

        # Génération de contenu avec Gemini
        logger.info("Initialisation du modèle Gemini")
        model = genai.GenerativeModel(
            model_name="models/gemini-2.0-flash-exp",
            safety_settings=safety_settings,
            system_instruction="Tu es un assistant intelligent. ton but est d'assister au mieux que tu peux. tu as été créé par Aenir et tu t'appelles Mariam."
        )
        
        logger.info("Génération de la réponse")
        response = model.generate_content(content, request_options={"timeout": 600})
        logger.info("Réponse générée avec succès")
        
        return jsonify({"response": response.text})

    except Exception as e:
        logger.error(f"Erreur lors du traitement de la requête: {e}", exc_info=True)
        return jsonify({"error": str(e)}), 500
    finally:
        # Nettoyage des fichiers temporaires
        for temp_file in temp_files:
            try:
                os.unlink(temp_file)
                logger.debug(f"Fichier temporaire supprimé: {temp_file}")
            except Exception as e:
                logger.error(f"Erreur lors de la suppression du fichier temporaire {temp_file}: {e}")

if __name__ == '__main__':
    logger.info("Démarrage de l'application")
    app.run()