app.py

import gradio as gr
import os
import time
import requests
from datetime import datetime
from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic
from langchain_google_genai import ChatGoogleGenerativeAI
from langchain_core.messages import HumanMessage
import PyPDF2
import docx
import pandas as pd
from pptx import Presentation
import io
import tempfile
from urllib.parse import urlparse
import re

# Configuration des modèles
MODELS = {
    "Gemini 2.5 Flash (Google AI)": {
        "provider": "Google AI",
        "class": ChatGoogleGenerativeAI,
        "model_name": "gemini-2.0-flash-exp",
        "default_api": True
    },
    "ChatGPT 5 (OpenAI)": {
        "provider": "OpenAI", 
        "class": ChatOpenAI,
        "model_name": "gpt-4o",
        "default_api": False
    },
    "Claude Sonnet 4 (Anthropic)": {
        "provider": "Anthropic",
        "class": ChatAnthropic, 
        "model_name": "claude-3-5-sonnet-20241022",
        "default_api": False
    },
    "Gemini 2.5 Pro (Google AI)": {
        "provider": "Google AI",
        "class": ChatGoogleGenerativeAI,
        "model_name": "gemini-2.0-flash-exp",
        "default_api": False
    }
}

# API par défaut pour Gemini 2.5 Flash
DEFAULT_GEMINI_API = os.getenv("GOOGLE_API_KEY", "")

def extract_text_from_file(file):
    """Extrait le texte d'un fichier uploadé"""
    if file is None:
        return ""
    
    file_extension = os.path.splitext(file.name)[1].lower()
    
    try:
        if file_extension == '.pdf':
            with open(file.name, 'rb') as f:
                reader = PyPDF2.PdfReader(f)
                text = ""
                for page in reader.pages:
                    text += page.extract_text() + "\n"
                return text
                
        elif file_extension == '.docx':
            doc = docx.Document(file.name)
            text = ""
            for paragraph in doc.paragraphs:
                text += paragraph.text + "\n"
            return text
            
        elif file_extension == '.txt':
            with open(file.name, 'r', encoding='utf-8') as f:
                return f.read()
                
        elif file_extension in ['.xlsx', '.xls']:
            df = pd.read_excel(file.name)
            return df.to_string()
            
        elif file_extension == '.pptx':
            prs = Presentation(file.name)
            text = ""
            for slide in prs.slides:
                for shape in slide.shapes:
                    if hasattr(shape, "text"):
                        text += shape.text + "\n"
            return text
            
        else:
            return "Format de fichier non supporté"
            
    except Exception as e:
        return f"Erreur lors de la lecture du fichier: {str(e)}"

def extract_text_from_url(url):
    """Extrait le texte d'une URL"""
    try:
        response = requests.get(url, timeout=10)
        response.raise_for_status()
        
        # Simple extraction du contenu textuel
        content = response.text
        # Suppression basique des balises HTML
        content = re.sub(r'<[^>]+>', '', content)
        content = re.sub(r'\s+', ' ', content).strip()
        
        return content[:10000]  # Limite à 10k caractères
        
    except Exception as e:
        return f"Erreur lors de la récupération de l'URL: {str(e)}"

def get_document_content(text_input, url_input, file_input):
    """Récupère le contenu du document selon la source"""
    if text_input.strip():
        return text_input.strip()
    elif url_input.strip():
        return extract_text_from_url(url_input.strip())
    elif file_input is not None:
        return extract_text_from_file(file_input)
    else:
        return ""

def create_llm_instance(model_name, api_key):
    """Crée une instance du modèle LLM"""
    model_config = MODELS[model_name]
    
    if model_config["provider"] == "OpenAI":
        return model_config["class"](
            model=model_config["model_name"],
            api_key=api_key,
            temperature=0.7
        )
    elif model_config["provider"] == "Anthropic":
        return model_config["class"](
            model=model_config["model_name"],
            api_key=api_key,
            temperature=0.7
        )
    elif model_config["provider"] == "Google AI":
        api_to_use = api_key if api_key else DEFAULT_GEMINI_API
        return model_config["class"](
            model=model_config["model_name"],
            google_api_key=api_to_use,
            temperature=0.7
        )

def generate_html(model_name, api_key, text_input, url_input, file_input):
    """Génère le fichier HTML éducatif"""
    start_time = time.time()
    
    # Validation des entrées
    if model_name != "Gemini 2.5 Flash (Google AI)" and not api_key.strip():
        return None, "❌ Erreur: Veuillez fournir une clé API pour ce modèle.", 0
    
    document_content = get_document_content(text_input, url_input, file_input)
    if not document_content:
        return None, "❌ Erreur: Veuillez fournir un document (texte, URL ou fichier).", 0
    
    try:
        # Création de l'instance LLM
        llm = create_llm_instance(model_name, api_key)
        
        # Lecture du prompt template
        with open("creation_educational_html_from_any_document_18082025.txt", "r", encoding="utf-8") as f:
            prompt_template = f.read()
        
        # Remplacement des variables
        model_config = MODELS[model_name]
        prompt = prompt_template.format(
            model_name=model_config["model_name"],
            provider_name=model_config["provider"],
            document=document_content
        )
        
        # Génération du contenu
        message = HumanMessage(content=prompt)
        response = llm.invoke([message])
        
        html_content = response.content
        
        # Calcul du temps de génération
        generation_time = time.time() - start_time
        
        # Sauvegarde du fichier HTML
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"document_educatif_{timestamp}.html"
        
        with open(filename, "w", encoding="utf-8") as f:
            f.write(html_content)
        
        success_message = f"✅ Fichier HTML généré avec succès en {generation_time:.2f} secondes!"
        
        return filename, success_message, generation_time
        
    except Exception as e:
        error_message = f"❌ Erreur lors de la génération: {str(e)}"
        return None, error_message, 0

def reset_form():
    """Remet à zéro le formulaire"""
    return (
        "Gemini 2.5 Flash (Google AI)",  # model_name
        "",  # api_key
        "",  # text_input
        "",  # url_input
        None,  # file_input
        "",  # status_message
        None,  # html_file
        ""   # html_preview
    )

def update_api_info(model_name):
    """Met à jour les informations sur l'API selon le modèle sélectionné"""
    if model_name == "Gemini 2.5 Flash (Google AI)":
        return gr.update(
            label="Clé API (optionnelle)",
            placeholder="API gratuite disponible jusqu'à épuisement, ou utilisez votre propre clé",
            info="💡 Une API gratuite est déjà configurée pour ce modèle. Vous pouvez utiliser votre propre clé si vous le souhaitez."
        )
    else:
        return gr.update(
            label="Clé API (obligatoire)",
            placeholder="Entrez votre clé API",
            info="🔑 Clé API requise pour ce modèle"
        )

# Interface Gradio
with gr.Blocks(
    title="EduHTML Creator - Générateur de contenu éducatif HTML",
    theme=gr.themes.Soft(),
    css="""
    .main-container {
        max-width: 1200px;
        margin: 0 auto;
        padding: 20px;
    }
    .header {
        text-align: center;
        margin-bottom: 30px;
        padding: 30px;
        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
        border-radius: 15px;
        color: white;
    }
    .form-section {
        background: white;
        padding: 25px;
        border-radius: 15px;
        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
        margin-bottom: 20px;
    }
    .apple-button {
        background: #007AFF;
        color: white;
        border: none;
        border-radius: 8px;
        padding: 12px 24px;
        font-weight: 500;
        transition: all 0.3s ease;
    }
    .apple-button:hover {
        background: #0056CC;
        transform: translateY(-1px);
    }
    .reset-button {
        background: #FF3B30;
        color: white;
        border: none;
        border-radius: 8px;
        padding: 12px 24px;
        font-weight: 500;
    }
    .status-success {
        color: #34C759;
        font-weight: 500;
    }
    .status-error {
        color: #FF3B30;
        font-weight: 500;
    }
    """
) as app:
    
    gr.HTML("""
    <div class="header">
        <h1>🎓 EduHTML Creator</h1>
        <p style="font-size: 18px; margin: 10px 0;">Transformez n'importe quel document en contenu éducatif HTML interactif</p>
        <p style="font-size: 14px; opacity: 0.9;">
            Cette application utilise l'intelligence artificielle pour créer des pages HTML éducatives élégantes et interactives 
            à partir de vos documents. Le design s'inspire du style Apple pour une expérience utilisateur premium.
            L'objectif éducatif est de faciliter l'apprentissage grâce à la structuration, l'interactivité et la visualisation 
            des informations clés de vos documents originaux.
        </p>
    </div>
    """)
    
    with gr.Row():
        with gr.Column(scale=1):
            gr.HTML("<div class='form-section'>")
            
            # Sélection du modèle
            model_dropdown = gr.Dropdown(
                choices=list(MODELS.keys()),
                value="Gemini 2.5 Flash (Google AI)",
                label="🤖 Modèle LLM",
                info="Choisissez le modèle d'IA à utiliser"
            )
            
            # Champ API
            api_input = gr.Textbox(
                label="Clé API (optionnelle)",
                placeholder="API gratuite disponible jusqu'à épuisement, ou utilisez votre propre clé",
                info="💡 Une API gratuite est déjà configurée pour ce modèle. Vous pouvez utiliser votre propre clé si vous le souhaitez.",
                type="password"
            )
            
            gr.HTML("</div>")
            
            gr.HTML("<div class='form-section'>")
            gr.HTML("<h3>📄 Source du document</h3>")
            
            # Entrées de document
            text_input = gr.Textbox(
                label="Texte copié/collé",
                placeholder="Collez votre texte ici...",
                lines=5
            )
            
            url_input = gr.Textbox(
                label="Lien Web",
                placeholder="https://exemple.com/article"
            )
            
            file_input = gr.File(
                label="Fichier",
                file_types=[".pdf", ".txt", ".docx", ".xlsx", ".xls", ".pptx"]
            )
            
            gr.HTML("</div>")
            
            # Boutons
            with gr.Row():
                submit_btn = gr.Button(
                    "🚀 Générer le HTML",
                    variant="primary",
                    elem_classes=["apple-button"]
                )
                reset_btn = gr.Button(
                    "🔄 Reset",
                    elem_classes=["reset-button"]
                )
        
        with gr.Column(scale=1):
            # Statut et résultats
            status_output = gr.HTML(label="Statut")
            
            # Fichier téléchargeable
            html_file_output = gr.File(
                label="📥 Fichier HTML téléchargeable",
                visible=False
            )
            
            # Prévisualisation
            html_preview = gr.HTML(
                label="👀 Prévisualisation",
                visible=False
            )
    
    # Événements
    model_dropdown.change(
        fn=update_api_info,
        inputs=[model_dropdown],
        outputs=[api_input]
    )
    
    submit_btn.click(
        fn=generate_html,
        inputs=[model_dropdown, api_input, text_input, url_input, file_input],
        outputs=[html_file_output, status_output, gr.State()]
    ).then(
        fn=lambda file, status, time_taken: (
            gr.update(visible=file is not None),
            status,
            gr.update(visible=file is not None, value=open(file, 'r', encoding='utf-8').read() if file else "")
        ),
        inputs=[html_file_output, status_output, gr.State()],
        outputs=[html_file_output, status_output, html_preview]
    )
    
    reset_btn.click(
        fn=reset_form,
        outputs=[model_dropdown, api_input, text_input, url_input, file_input, status_output, html_file_output, html_preview]
    )

if __name__ == "__main__":
    app.launch(
        server_name="0.0.0.0",
        server_port=7860,
        share=True
    )