Update app.py

app.py

@@ -10,25 +10,47 @@ from datetime import datetime
 import numpy as np
 from sklearn.feature_extraction.text import TfidfVectorizer
 import nltk
+from nltk.tokenize import sent_tokenize
 import random
 from transformers import pipeline
 import torch
 import asyncio
+import nest_asyncio
+
+# Aplicar patch para event loop en entornos como Jupyter o Gradio
+nest_asyncio.apply()
 
+# Configuración inicial
 nltk.download('punkt', quiet=True)
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
+# Variables de configuración
 PEXELS_API_KEY = os.getenv("PEXELS_API_KEY")
-MODEL_NAME = "DeepESP/gpt2-spanish"
+MODEL_NAME = "DeepESP/gpt2-spanish"  # Modelo en español
+
+# Función async para obtener voces de edge-tts
+async def get_voices():
+    try:
+        voices = await edge_tts.list_voices()
+        return voices
+    except Exception as e:
+        logger.error(f"Error obteniendo voces: {e}")
+        return []
 
-# Obtener voces de edge-tts de forma síncrona (wrapper)
-def get_voices_sync():
-    return asyncio.run(edge_tts.list_voices())
+# Obtener voces sincrónicamente para inicializar
+VOICES = asyncio.get_event_loop().run_until_complete(get_voices())
 
-VOICES = get_voices_sync()
-VOICE_NAMES = [f"{v['Name']} ({v['Gender']}, {v.get('LocaleName', 'Unknown')})" for v in VOICES]
+# Preparar lista segura de nombres de voces
+VOICE_NAMES = [
+    f"{v.get('Name', 'Desconocido')} ({v.get('Gender', 'Desconocido')}, {v.get('LocaleName', 'es-ES')})"
+    for v in VOICES
+]
 
+# Fallback si no se pudieron obtener voces
+if not VOICES:
+    VOICE_NAMES = ["Voz Predeterminada (Femenino, es-ES)"]
+    VOICES = [{'ShortName': 'es-ES-ElviraNeural'}]
 
 def generar_guion_profesional(prompt):
     try:
@@ -44,12 +66,12 @@ def generar_guion_profesional(prompt):
             "2. Tres secciones detalladas con subtítulos\n"
             "3. Conclusión impactante\n"
             "Usa un estilo natural para narración:",
-            max_length=1000,
+            max_length=1500,
             temperature=0.7,
             top_k=50,
             top_p=0.95,
             num_return_sequences=1,
-            truncation=True
+            truncation=True  # Para evitar warnings y límites
         )
         guion = response[0]['generated_text']
         if len(guion.split()) < 100:
@@ -89,8 +111,6 @@ def generar_guion_profesional(prompt):
         ¿Listos para profundizar? ¡Empecemos!
         """
 
-from nltk.tokenize import sent_tokenize
-
 def buscar_videos_avanzado(prompt, guion, num_videos=5):
     try:
         oraciones = sent_tokenize(guion)
@@ -102,6 +122,7 @@ def buscar_videos_avanzado(prompt, guion, num_videos=5):
         palabras_clave = [palabras[i] for i in indices_importantes]
         palabras_prompt = re.findall(r'\b\w{4,}\b', prompt.lower())
         todas_palabras = 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_palabras)}&per_page={num_videos}",
@@ -130,55 +151,85 @@ async def crear_video_profesional(prompt, custom_script, voz_index, musica=None)
     try:
         guion = custom_script if custom_script else generar_guion_profesional(prompt)
         logger.info(f"Guion generado ({len(guion.split())} palabras)")
+
         voz_seleccionada = VOICES[voz_index]['ShortName'] if VOICES else 'es-ES-ElviraNeural'
+
         voz_archivo = "voz.mp3"
         await edge_tts.Communicate(guion, voz_seleccionada).save(voz_archivo)
         audio = AudioFileClip(voz_archivo)
         duracion_total = audio.duration
+
         videos_data = buscar_videos_avanzado(prompt, guion)
         if not videos_data:
-            raise Exception("No se encontraron videos")
+            raise Exception("No se encontraron videos relevantes")
+
         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)
-        video_final = concatenate_videoclips(clips)
+            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']
+            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()
+            clip = VideoFileClip(temp_video.name)
+            clips.append(clip)
+
+        duracion_por_clip = duracion_total / len(clips)
+
+        clips_procesados = []
+        for clip in clips:
+            if clip.duration < duracion_por_clip:
+                clip = clip.loop(duration=duracion_por_clip)
+            else:
+                clip = clip.subclip(0, duracion_por_clip)
+            clips_procesados.append(clip)
+
+        video_final = concatenate_videoclips(clips_procesados)
+
+        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)
-        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)
+
+        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=2,
+            preset='fast',
+            fps=24
+        )
+
         return output_path
+
     except Exception as e:
-        logger.error(f"Error crítico: {str(e)}")
+        logger.error(f"ERROR: {str(e)}")
         return None
+
     finally:
         if voz_archivo and os.path.exists(voz_archivo):
             os.remove(voz_archivo)
 
-def run_async_wrapper(prompt, custom_script, voz, musica):
-    voz_index = VOICE_NAMES.index(voz)
-    return asyncio.run(crear_video_profesional(prompt, custom_script, voz_index, musica))
+# Interfaz Gradio
+
+with gr.Blocks(theme=gr.themes.Soft(), title="Generador de Videos Profesional") as app:
+    gr.Markdown("# 🎬 GENERADOR DE VIDEOS CON IA")
 
-with gr.Blocks(title="Generador de Videos") as app:
     with gr.Row():
-        with gr.Column():
-            prompt = gr.Textbox(label="Tema del video")
-            custom_script = gr.TextArea(label="Guion personalizado (opcional)")
-            voz = gr.Dropdown(VOICE_NAMES, label="Voz", value=VOICE_NAMES[0])
-            musica = gr.File(label="Música de fondo (opcional)", file_types=["audio"])
-            btn = gr.Button("Generar Video", variant="primary")
-        with gr.Column():
-            output = gr.Video(label="Resultado", format="mp4")
-    
-    btn.click(
-        fn=run_async_wrapper,
-        inputs=[prompt, custom_script, voz, musica],
-        outputs=output
-    )
-
-if __name__ == "__main__":
-    app.launch(server_name="0.0.0.0", server_port=7860)
+        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...",