Update app.py

app.py

@@ -44,10 +44,28 @@ async def get_voices():
         return [], []
 
 # Obtener voces de forma síncrona para la inicialización
-VOICE_NAMES, VOICES = asyncio.run(get_voices())
-if not VOICES:
-    VOICE_NAMES = ["Voz Predeterminada (Femenino, es-ES)"]
-    VOICES = [{'ShortName': 'es-ES-ElviraNeural'}]
+import nest_asyncio
+nest_asyncio.apply()
+
+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:
+        VOICE_NAMES, VOICES = await get_voices()
+        if not VOICES:
+            raise Exception("No se obtuvieron voces.")
+    except Exception as e:
+        logging.warning(f"No se pudieron cargar voces dinámicamente: {e}")
+        VOICE_NAMES = ["Voz Predeterminada (Femenino, es-ES)"]
+        VOICES = [{'ShortName': 'es-ES-ElviraNeural'}]
+
+asyncio.get_event_loop().run_until_complete(get_and_set_voices())
 
 def generar_guion_profesional(prompt):
     """Genera guiones con respaldo robusto"""
@@ -95,61 +113,53 @@ async def crear_video_profesional(prompt, custom_script, voz_index, musica=None)
         guion = custom_script if custom_script else generar_guion_profesional(prompt)
         
         # 2. Configurar voz
-        voz_seleccionada = VOICES[voz_index]['ShortName'] if VOICES else 'es-ES-ElviraNeural'
-        
-        # 3. Generar audio
-        voz_archivo = "voz.mp3"
-        await edge_tts.Communicate(guion, voz_seleccionada).save(voz_archivo)
-        audio = AudioFileClip(voz_archivo)
-        
-        # 4. Obtener videos
-        videos_data = buscar_videos_avanzado(prompt, guion)
-        if not videos_data:
-            raise Exception("No se encontraron videos")
-            
-        # 5. Procesar videos
-        clips = []
-        for video in videos_data[:3]:  # Usar máximo 3 videos
-            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)
-        
-        # 6. 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)
+        voz_seleccionada = VOICES[voz_indimport os
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+import gradio as gr
+
+# Configuración CRÍTICA para evitar timeouts
+GRADIO_TIMEOUT = 600  # 10 minutos (en segundos)
+MAX_VIDEO_DURATION = 120  # 2 minutos (evita procesos eternos)
+
+async def crear_video_profesional(prompt, custom_script, voz_index, musica=None):
+    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
         
-        return output_path
+        # 2. Devuelve un video de prueba (eliminar en producción)
+        return "video_prueba.mp4"
         
     except Exception as e:
-        logger.error(f"Error crítico: {str(e)}")
+        print(f"ERROR: {str(e)}")
         return None
-    finally:
-        if os.path.exists(voz_archivo):
-            os.remove(voz_archivo)
 
-# Interfaz optimizada
-with gr.Blocks(title="Generador de Videos") as app:
+# 👇 **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))
+        )
+        return future.result(timeout=GRADIO_TIMEOUT)
+
+# Interfaz Minimalista (para enfocarnos en el timeout)
+with gr.Blocks() as app:
     with gr.Row():
-        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")
+        prompt = gr.Textbox(label="Tema")
+        btn = gr.Button("Generar")
+    output = gr.Video()
     
     btn.click(
-        fn=lambda p, cs, v: asyncio.run(crear_video_profesional(p, cs, VOICE_NAMES.index(v))),
-        inputs=[prompt, custom_script, voz],
+        fn=run_async_with_timeout,  # 👈 Usamos el wrapper anti-timeout
+        inputs=[prompt, gr.Textbox(visible=False), gr.Number(visible=False)],
         outputs=output
     )
 
 if __name__ == "__main__":
-    app.launch(server_name="0.0.0.0", server_port=7860)
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        # ⚠️ Configuración CLAVE para el timeout
+        app_kwargs={"timeout": GRADIO_TIMEOUT}
+    )