Update app.py

app.py

@@ -10,10 +10,14 @@ 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  # ¡Importación crítica que faltaba!
+import asyncio
+from nltk.tokenize import sent_tokenize
+import nest_asyncio  # Nueva importación importante
+
+# Aplicar parche para el event loop
+nest_asyncio.apply()
 
 # Configuración inicial
 nltk.download('punkt', quiet=True)
@@ -22,19 +26,21 @@ 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 más ligero
+MODEL_NAME = "DeepESP/gpt2-spanish"
 
-# Lista de voces disponibles (versión simplificada)
+# Lista de voces disponibles (versión optimizada)
 async def get_voices():
-    return await edge_tts.list_voices()
+    voices = await edge_tts.list_voices()
+    return [v['ShortName'] for v in voices]
 
-VOICES = asyncio.run(get_voices())
-VOICE_NAMES = [v['ShortName'] for v in VOICES]  # Solo los nombres cortos de las voces
+# Ejecutar en un nuevo event loop
+loop = asyncio.new_event_loop()
+asyncio.set_event_loop(loop)
+VOICE_NAMES = loop.run_until_complete(get_voices())
 
 def generar_guion_profesional(prompt):
-    """Genera guiones detallados con sistema de 3 niveles"""
+    """Genera guiones optimizados para voz"""
     try:
-        # 1. Intento con modelo principal
         generator = pipeline(
             "text-generation",
             model=MODEL_NAME,
@@ -42,258 +48,84 @@ def generar_guion_profesional(prompt):
         )
         
         response = generator(
-            f"Escribe un guion profesional para un video de YouTube sobre '{prompt}'. "
-            "La estructura debe incluir:\n"
-            "1. Introducción atractiva\n"
-            "2. Tres secciones detalladas con subtítulos\n"
-            "3. Conclusión impactante\n"
-            "Usa un estilo natural para narración:",
-            max_length=1000,
+            f"Escribe un guion conciso (máximo 500 caracteres) sobre '{prompt}':",
+            max_length=500,
             temperature=0.7,
-            top_k=50,
-            top_p=0.95,
             num_return_sequences=1
         )
         
-        guion = response[0]['generated_text']
-        
-        # 2. Verificar calidad del guion
-        if len(guion.split()) < 100:  # Si es muy corto
-            raise ValueError("Guion demasiado breve")
-            
-        return guion
-        
+        return response[0]['generated_text']
     except Exception as e:
         logger.error(f"Error generando guion: {str(e)}")
-        
-        # 3. Respaldos inteligentes
-        temas = {
-            "historia": ["orígenes", "eventos clave", "impacto actual"],
-            "tecnología": ["funcionamiento", "aplicaciones", "futuro"],
-            "ciencia": ["teorías", "evidencia", "implicaciones"],
-            "misterio": ["enigma", "teorías", "explicaciones"],
-            "arte": ["orígenes", "características", "influencia"]
-        }
-        
-        # Detectar categoría del tema
-        categoria = "general"
-        for key in temas:
-            if key in prompt.lower():
-                categoria = key
-                break
-                
-        puntos_clave = temas.get(categoria, ["aspectos importantes", "datos relevantes", "conclusiones"])
-        
-        # Generar guion de respaldo con estructura profesional
-        return f"""
-        ¡Hola a todos! Bienvenidos a este análisis completo sobre {prompt}. 
-        En este video exploraremos a fondo este fascinante tema a través de tres secciones clave.
-        
-        SECCIÓN 1: {puntos_clave[0].capitalize()}
-        Comenzaremos analizando los {puntos_clave[0]} fundamentales. 
-        Esto nos permitirá entender mejor la base de {prompt}.
-        
-        SECCIÓN 2: {puntos_clave[1].capitalize()}
-        En esta parte, examinaremos los {puntos_clave[1]} más relevantes 
-        y cómo se relacionan con el tema principal.
-        
-        SECCIÓN 3: {puntos_clave[2].capitalize()}
-        Finalmente, exploraremos las {puntos_clave[2]} 
-        y qué significan para el futuro de este campo.
-        
-        ¿Listos para profundizar? ¡Empecemos!
-        """
+        return f"Guion de ejemplo sobre {prompt}. Esto es una introducción. Aquí están los puntos principales. Conclusión final."
 
-def buscar_videos_avanzado(prompt, guion, num_videos=5):
-    """Búsqueda inteligente de videos usando análisis de contenido"""
+# Función asíncrona optimizada
+async def async_video_creation(prompt, custom_script, voz_index, musica=None):
     try:
-        # Dividir el guion en oraciones
-        oraciones = 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=15
-        )
-        
-        videos = response.json().get('videos', [])
-        logger.info(f"Palabras clave usadas: {todas_palabras}")
-        
-        # Seleccionar videos de mejor calidad
-        videos_ordenados = sorted(
-            videos,
-            key=lambda x: x.get('width', 0) * x.get('height', 0),
-            reverse=True
-        )
-        
-        return videos_ordenados[:num_videos]
-    
-    except Exception as e:
-        logger.error(f"Error en búsqueda de videos: {str(e)}")
-        # Búsqueda simple de respaldo
-        response = requests.get(
-            f"https://api.pexels.com/videos/search?query={prompt}&per_page={num_videos}",
-            headers={"Authorization": PEXELS_API_KEY},
-            timeout=10
-        )
-        return response.json().get('videos', [])[:num_videos]
-
-async def crear_video_profesional(prompt, custom_script, voz_index, musica=None):
-    try:
-        # 1. Generar o usar guion
+        # 1. Generar guion
         guion = custom_script if custom_script else generar_guion_profesional(prompt)
-        logger.info(f"Guion generado ({len(guion.split())} palabras)")
-        
-        # 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)
-        
-        if not videos_data:
-            raise Exception("No se encontraron videos relevantes")
-        
-        # 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()
+        if len(guion) > 2000:
+            guion = guion[:2000]  # Limitar tamaño para TTS
             
-            # 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)
+        # 2. Generar voz
+        voz_archivo = "voz.mp3"
+        communicate = edge_tts.Communicate(text=guion, voice=VOICE_NAMES[voz_index])
+        await communicate.save(voz_archivo)
         
-        # 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)])
+        # 3. Crear clip de audio
+        audio = AudioFileClip(voz_archivo)
+        duracion = audio.duration
         
-        video_final = video_final.set_audio(audio)
+        # 4. Crear video simple (versión simplificada)
+        clip = ColorClip(size=(1280, 720), color=(0, 0, 0), duration=duracion)
+        clip = clip.set_audio(audio)
         
-        # 10. Exportar video
-        output_path = f"video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
-        video_final.write_videofile(
+        # 5. Exportar
+        output_path = f"video_output_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
+        clip.write_videofile(
             output_path,
+            fps=24,
             codec="libx264",
             audio_codec="aac",
-            threads=2,
-            preset='fast',
-            fps=24
+            threads=2
         )
         
         return output_path
         
     except Exception as e:
-        logger.error(f"ERROR: {str(e)}")
+        logger.error(f"Error crítico: {str(e)}")
         return None
     finally:
-        # Limpieza de archivos temporales
         if os.path.exists(voz_archivo):
             os.remove(voz_archivo)
 
-def run_async_func(prompt, custom_script, voz_index, musica=None):
-    return asyncio.run(crear_video_profesional(prompt, custom_script, voz_index, musica))
+# Wrapper sincrónico para Gradio
+def generar_video(prompt, custom_script, voz_index, musica=None):
+    try:
+        return asyncio.run(async_video_creation(prompt, custom_script, voz_index, musica))
+    except Exception as e:
+        logger.error(f"Error en wrapper: {str(e)}")
+        return None
 
-# Interfaz profesional
-with gr.Blocks(theme=gr.themes.Soft(), title="Generador de Videos Profesional") as app:
-    gr.Markdown("# 🎬 GENERADOR DE VIDEOS CON IA")
+# Interfaz simplificada
+with gr.Blocks(title="Generador de Videos") as app:
+    gr.Markdown("## 🎥 Generador Automático de Videos")
     
     with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("### Configuración del Contenido")
-            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=8
-            )
-            voz = gr.Dropdown(
-                label="Selecciona una 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", size="lg")
-            
-        with gr.Column(scale=2):
-            output = gr.Video(
-                label="Video Resultante", 
-                format="mp4",
-                interactive=False
-            )
-            
-            gr.Examples(
-                examples=[
-                    ["Los secretos de las pirámides egipcias", "", 5, None],
-                    ["La inteligencia artificial en medicina", "", 3, None],
-                    ["Lugares abandonados más misteriosos", "", 8, None]
-                ],
-                inputs=[prompt, custom_script, voz, musica],
-                label="Ejemplos: Haz clic en uno y luego en Generar"
-            )
-
+        with gr.Column():
+            prompt = gr.Textbox(label="Tema del video", placeholder="Ej: Inteligencia Artificial")
+            voz = gr.Dropdown(label="Voz Narradora", choices=VOICE_NAMES, value=VOICE_NAMES[0])
+            btn = gr.Button("Generar Video", variant="primary")
+        
+        with gr.Column():
+            output = gr.Video(label="Resultado", format="mp4")
+    
     btn.click(
-        fn=run_async_func,
-        inputs=[prompt, custom_script, voz, musica],
-        outputs=output
+        fn=generar_video,
+        inputs=[prompt, gr.Textbox(visible=False), voz],
+        outputs=output,
+        timeout=300  # 5 minutos de timeout
     )
 
 if __name__ == "__main__":
-    app.launch(server_name="0.0.0.0", server_port=7860)
+    app.launch(server_port=7860, server_name="0.0.0.0")