app.py

import os
import re
import requests
import gradio as gr
from moviepy.editor import *
import edge_tts
import tempfile
import logging
from datetime import datetime
import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
import nltk
from transformers import pipeline
import torch
import asyncio
import time

# Configuración inicial
nltk.download('punkt', quiet=True)
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

# Configuración de modelos
PEXELS_API_KEY = os.getenv("PEXELS_API_KEY")
MODEL_NAME = "DeepESP/gpt2-spanish"  # Modelo en español

# Lista de voces disponibles
VOICES = asyncio.run(edge_tts.list_voices())
VOICE_NAMES = [f"{v['Name']} ({v['Gender']}, {v['Locale']})" for v in VOICES]

def generar_guion_profesional(prompt):
    """Genera guiones detallados"""
    generator = pipeline(
        "text-generation",
        model=MODEL_NAME,
        device=0 if torch.cuda.is_available() else -1
    )
    
    response = generator(
        f"Escribe un guion profesional para un video de YouTube sobre '{prompt}':",
        max_length=600,
        temperature=0.7,
        num_return_sequences=1
    )
    
    return response[0]['generated_text']

def buscar_videos_avanzado(prompt, guion, num_videos=5):
    """Búsqueda inteligente de videos usando análisis de contenido"""
    # Dividir el guion en oraciones
    oraciones = nltk.sent_tokenize(guion)
    
    # Extraer palabras clave con TF-IDF
    vectorizer = TfidfVectorizer(stop_words=['el', 'la', 'los', 'las', 'de', 'en', 'y', 'que'])
    tfidf = vectorizer.fit_transform(oraciones)
    palabras = vectorizer.get_feature_names_out()
    scores = np.asarray(tfidf.sum(axis=0)).ravel()
    indices_importantes = np.argsort(scores)[-5:]
    palabras_clave = [palabras[i] for i in indices_importantes]
    
    # Mezclar palabras clave del prompt y del guion
    palabras_prompt = re.findall(r'\b\w{4,}\b', prompt.lower())
    todas_palabras = list(set(palabras_clave + palabras_prompt))[:5]
    
    # Buscar en Pexels
    headers = {"Authorization": PEXELS_API_KEY}
    response = requests.get(
        f"https://api.pexels.com/videos/search?query={'+'.join(todas_palabras)}&per_page={num_videos}",
        headers=headers,
        timeout=10
    )
    
    videos = response.json().get('videos', [])
    
    # Seleccionar videos de mejor calidad
    return sorted(
        videos,
        key=lambda x: x.get('width', 0) * x.get('height', 0),
        reverse=True
    )[:num_videos]

async def crear_video_profesional(prompt, custom_script, voz_index, musica=None):
    try:
        # 1. Generar o usar guion
        guion = custom_script if custom_script else generar_guion_profesional(prompt)
        
        # 2. Seleccionar voz
        voz_seleccionada = VOICES[voz_index]['ShortName']
        
        # 3. Generar voz
        voz_archivo = "voz.mp3"
        await edge_tts.Communicate(guion, voz_seleccionada).save(voz_archivo)
        audio = AudioFileClip(voz_archivo)
        duracion_total = audio.duration
        
        # 4. Buscar videos relevantes
        videos_data = buscar_videos_avanzado(prompt, guion)
        
        # 5. Descargar y preparar videos
        clips = []
        for video in videos_data:
            # Seleccionar la mejor calidad de video
            video_files = sorted(
                video['video_files'],
                key=lambda x: x.get('width', 0) * x.get('height', 0),
                reverse=True
            )
            video_url = video_files[0]['link']
            
            # Descargar video
            response = requests.get(video_url, stream=True)
            temp_video = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4')
            for chunk in response.iter_content(chunk_size=1024*1024):
                temp_video.write(chunk)
            temp_video.close()
            
            # Crear clip
            clip = VideoFileClip(temp_video.name)
            clips.append(clip)
        
        # 6. Calcular duración por clip
        duracion_por_clip = duracion_total / len(clips)
        
        # 7. Procesar clips de video
        clips_procesados = []
        for clip in clips:
            # Si el clip es más corto que la duración asignada, hacer loop
            if clip.duration < duracion_por_clip:
                clip = clip.loop(duration=duracion_por_clip)
            # Si es más largo, recortar
            else:
                clip = clip.subclip(0, duracion_por_clip)
            clips_procesados.append(clip)
        
        # 8. Combinar videos
        video_final = concatenate_videoclips(clips_procesados)
        
        # 9. Procesar música
        if musica:
            musica_clip = AudioFileClip(musica.name)
            if musica_clip.duration < duracion_total:
                musica_clip = musica_clip.loop(duration=duracion_total)
            else:
                musica_clip = musica_clip.subclip(0, duracion_total)
            audio = CompositeAudioClip([audio, musica_clip.volumex(0.25)])
        
        video_final = video_final.set_audio(audio)
        
        # 10. Exportar video
        output_path = f"video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
        video_final.write_videofile(
            output_path,
            codec="libx264",
            audio_codec="aac",
            threads=4,
            preset='ultrafast',
            fps=24,
            logger=None
        )
        
        return output_path
        
    except Exception as e:
        logger.error(f"ERROR: {str(e)}")
        return None
    finally:
        # Limpieza de archivos temporales
        if 'voz_archivo' in locals() and os.path.exists(voz_archivo):
            os.remove(voz_archivo)

# Función para ejecutar la tarea asíncrona
def run_async_task(prompt, custom_script, voz_index, musica=None):
    return asyncio.run(crear_video_profesional(prompt, custom_script, voz_index, musica))

# Interfaz profesional con queue deshabilitado
with gr.Blocks(theme=gr.themes.Soft(), title="Generador de Videos") as app:
    gr.Markdown("# 🎬 GENERADOR DE VIDEOS CON IA")
    
    with gr.Row():
        with gr.Column(scale=1):
            gr.Markdown("### Configuración")
            prompt = gr.Textbox(label="Tema principal", placeholder="Ej: 'Los misterios de la antigua Grecia'")
            custom_script = gr.TextArea(
                label="Guion personalizado (opcional)", 
                placeholder="Pega aquí tu propio guion completo...",
                lines=6
            )
            voz = gr.Dropdown(
                label="Voz",
                choices=VOICE_NAMES,
                value=VOICE_NAMES[0],
                type="index"
            )
            musica = gr.File(label="Música de fondo (opcional)", file_types=["audio"])
            btn = gr.Button("🚀 Generar Video", variant="primary")
            
        with gr.Column(scale=2):
            output = gr.Video(label="Video Resultante", format="mp4")
            
            gr.Examples(
                examples=[
                    ["Los secretos de las pirámides egipcias", "", 5, None],
                    ["La inteligencia artificial en medicina", "", 3, None]
                ],
                inputs=[prompt, custom_script, voz, musica],
                label="Ejemplos"
            )

    # SOLUCIÓN CLAVE: Deshabilitar el sistema de colas
    btn.click(
        fn=run_async_task,
        inputs=[prompt, custom_script, voz, musica],
        outputs=output,
        queue=False  # Deshabilitar el sistema de colas
    )

if __name__ == "__main__":
    app.launch(
        server_name="0.0.0.0", 
        server_port=7860,
        enable_queue=False  # Asegurar que el queue esté deshabilitado globalmente
    )