Update app.py

app.py

@@ -1,50 +1,164 @@
 import os
-import asyncio
-from concurrent.futures import ThreadPoolExecutor
+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
+import random
+from transformers import pipeline
+import torch
+import asyncio
+import nest_asyncio
+from nltk.tokenize import sent_tokenize
 
-# Configuración CRÍTICA para evitar timeouts
-GRADIO_TIMEOUT = 6000  # 10 minutos (en segundos)
-MAX_VIDEO_DURATION = 1000  # 2 minutos (evita procesos eternos)
+# Setup
+nltk.download('punkt', quiet=True)
+nest_asyncio.apply()
 
-async def crear_video_profesional(prompt, custom_script, voz_index, musica=None):
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+PEXELS_API_KEY = os.getenv("PEXELS_API_KEY")
+MODEL_NAME = "DeepESP/gpt2-spanish"
+
+VOICE_NAMES, VOICES = [], []
+
+async def get_voices():
+    voces = await edge_tts.list_voices()
+    voice_names = [f"{v['Name']} ({v['Gender']}, {v['LocaleName']})" for v in voces]
+    return voice_names, voces
+
+async def get_and_set_voices():
+    global VOICE_NAMES, VOICES
     try:
-        # 1. Simulamos un proceso largo (¡esto es lo que causa el timeout!)
-        # Reemplaza esto con tu lógica real de generación
-        await asyncio.sleep(30)  # Solo para prueba
-        
-        # 2. Devuelve un video de prueba (eliminar en producción)
-        return "video_prueba.mp4"
-        
+        VOICE_NAMES, VOICES = await get_voices()
+        if not VOICES:
+            raise Exception("No se encontraron voces.")
     except Exception as e:
-        print(f"ERROR: {str(e)}")
-        return None
+        logger.warning(f"Fallo al cargar voces: {e}")
+        VOICE_NAMES = ["Voz Predeterminada (Femenino, es-ES)"]
+        VOICES = [{'ShortName': 'es-ES-ElviraNeural'}]
 
-# 👇 **Solución Mágica**: Ejecución en hilos separados
-def run_async_with_timeout(prompt, script, voz_index, musica=None):
-    with ThreadPoolExecutor() as executor:
-        future = executor.submit(
-            lambda: asyncio.run(crear_video_profesional(prompt, script, voz_index, musica))
+asyncio.get_event_loop().run_until_complete(get_and_set_voices())
+
+def generar_guion_profesional(prompt):
+    try:
+        generator = pipeline(
+            "text-generation",
+            model=MODEL_NAME,
+            device=0 if torch.cuda.is_available() else -1
         )
-        return future.result(timeout=GRADIO_TIMEOUT)
+        response = generator(
+            f"Escribe un guion profesional para un video de YouTube sobre '{prompt}'. "
+            "Incluye introducción, desarrollo en 3 secciones y conclusión:",
+            max_length=1000,
+            temperature=0.7,
+            top_k=50,
+            top_p=0.95,
+            num_return_sequences=1
+        )
+        guion = response[0]['generated_text']
+        if len(guion.split()) < 100:
+            raise ValueError("Guion demasiado breve")
+        return guion
+    except Exception as e:
+        logger.error(f"Error generando guion: {e}")
+        return f"""Introducción sobre {prompt}. 
+        Sección 1: Orígenes e historia.
+        Sección 2: Estado actual.
+        Sección 3: Futuro e impacto.
+        Conclusión reflexiva."""
 
-# Interfaz Minimalista (para enfocarnos en el timeout)
-with gr.Blocks() as app:
+def buscar_videos_avanzado(prompt, guion, num_videos=5):
+    try:
+        oraciones = sent_tokenize(guion)
+        vectorizer = TfidfVectorizer(stop_words='spanish')
+        tfidf = vectorizer.fit_transform(oraciones)
+        palabras = vectorizer.get_feature_names_out()
+        scores = np.asarray(tfidf.sum(axis=0)).ravel()
+        top_indices = np.argsort(scores)[-5:]
+        palabras_clave = [palabras[i] for i in top_indices]
+
+        palabras_prompt = re.findall(r'\b\w{4,}\b', prompt.lower())
+        todas = list(set(palabras_clave + palabras_prompt))[:5]
+
+        headers = {"Authorization": PEXELS_API_KEY}
+        response = requests.get(
+            f"https://api.pexels.com/videos/search?query={'+'.join(todas)}&per_page={num_videos}",
+            headers=headers,
+            timeout=15
+        )
+        return response.json().get('videos', [])
+    except Exception as e:
+        logger.error(f"Error buscando videos: {e}")
+        return []
+
+async def crear_video_profesional(prompt, custom_script, voz_index, musica=None):
+    voz_archivo = "voz.mp3"
+    try:
+        guion = custom_script if custom_script.strip() else generar_guion_profesional(prompt)
+        voz_seleccionada = VOICES[voz_index]['ShortName'] if VOICES else 'es-ES-ElviraNeural'
+
+        # Generar audio
+        await edge_tts.Communicate(guion, voz_seleccionada).save(voz_archivo)
+        audio = AudioFileClip(voz_archivo)
+
+        # Obtener videos
+        videos_data = buscar_videos_avanzado(prompt, guion)
+        if not videos_data:
+            raise Exception("No se encontraron videos")
+
+        # Procesar videos
+        clips = []
+        for video in videos_data[:3]:
+            video_file = next((vf for vf in video['video_files'] if vf['quality'] == 'sd'), video['video_files'][0])
+            with tempfile.NamedTemporaryFile(suffix='.mp4', delete=False) as temp_video:
+                response = requests.get(video_file['link'], stream=True)
+                for chunk in response.iter_content(chunk_size=1024 * 1024):
+                    temp_video.write(chunk)
+                clip = VideoFileClip(temp_video.name).subclip(0, min(10, video['duration']))
+                clips.append(clip)
+
+        # Crear video final
+        video_final = concatenate_videoclips(clips)
+        video_final = video_final.set_audio(audio)
+
+        output_path = f"video_output_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
+        video_final.write_videofile(output_path, fps=24, threads=2)
+        return output_path
+
+    except Exception as e:
+        logger.error(f"Error crítico: {e}")
+        return None
+    finally:
+        if os.path.exists(voz_archivo):
+            os.remove(voz_archivo)
+
+# Gradio app
+with gr.Blocks(title="Generador de Videos") as app:
     with gr.Row():
-        prompt = gr.Textbox(label="Tema")
-        btn = gr.Button("Generar")
-    output = gr.Video()
-    
+        with gr.Column():
+            prompt = gr.Textbox(label="Tema del video")
+            custom_script = gr.TextArea(label="Guión personalizado (opcional)")
+            voz = gr.Dropdown(VOICE_NAMES, label="Voz", value=VOICE_NAMES[0])
+            btn = gr.Button("Generar Video", variant="primary")
+        with gr.Column():
+            output = gr.Video(label="Resultado", format="mp4")
+
+    async def wrapper(p, cs, v):
+        return await crear_video_profesional(p, cs, VOICE_NAMES.index(v))
+
     btn.click(
-        fn=run_async_with_timeout,  # 👈 Usamos el wrapper anti-timeout
-        inputs=[prompt, gr.Textbox(visible=False), gr.Number(visible=False)],
+        fn=wrapper,
+        inputs=[prompt, custom_script, voz],
         outputs=output
     )
 
 if __name__ == "__main__":
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        # ⚠️ Configuración CLAVE para el timeout
-        app_kwargs={"timeout": GRADIO_TIMEOUT}
-    )
+    app.launch(server_name="0.0.0.0", server_port=7860)