Update app.py

app.py

@@ -1,126 +1,11 @@
 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 nltk.tokenize import sent_tokenize
-from transformers import pipeline
-import torch
-import asyncio
-
-# 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"
-
-# Solución robusta para obtener voces
-async def get_voices():
-    try:
-        voices = await edge_tts.list_voices()
-        voice_names = []
-        for v in voices:
-            try:
-                name = v.get('Name', v.get('ShortName', 'Desconocido'))
-                gender = v.get('Gender', 'Desconocido')
-                locale = v.get('Locale', v.get('Language', 'Desconocido'))
-                voice_names.append(f"{name} ({gender}, {locale})")
-            except Exception as e:
-                logger.warning(f"Error procesando voz: {v} - {str(e)}")
-                continue
-        return voice_names, voices
-    except Exception as e:
-        logger.error(f"Error al obtener voces: {str(e)}")
-        return [], []
-
-# Obtener voces de forma síncrona para la inicialización
-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"""
-    try:
-        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}':\n\n1. Introducción\n2. Desarrollo\n3. Conclusión\n\n",
-            max_length=800,
-            temperature=0.7,
-            num_return_sequences=1
-        )
-        
-        return response[0]['generated_text']
-        
-    except Exception as e:
-        logger.error(f"Error generando guion: {str(e)}")
-        return f"""Guión de respaldo sobre {prompt}:
-        
-1. INTRODUCCIÓN: Hoy exploraremos {prompt}
-2. DESARROLLO: Aspectos clave sobre el tema
-3. CONCLUSIÓN: Resumen y cierre"""
-
-def buscar_videos_avanzado(prompt, guion, num_videos=3):
-    """Búsqueda con múltiples respaldos"""
-    try:
-        palabras = re.findall(r'\b\w{4,}\b', prompt.lower())[:5]
-        response = requests.get(
-            f"https://api.pexels.com/videos/search?query={'+'.join(palabras)}&per_page={num_videos}",
-            headers={"Authorization": PEXELS_API_KEY},
-            timeout=10
-        )
-        return response.json().get('videos', [])[:num_videos]
-    except Exception as e:
-        logger.error(f"Error buscando videos: {str(e)}")
-        return []
-
-async def crear_video_profesional(prompt, custom_script, voz_index, musica=None):
-    try:
-        # 1. Generar guión
-        guion = custom_script if custom_script else generar_guion_profesional(prompt)
-        
-        # 2. Configurar voz
-        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)
+GRADIO_TIMEOUT = 6000  # 10 minutos (en segundos)
+MAX_VIDEO_DURATION = 1000  # 2 minutos (evita procesos eternos)
 
 async def crear_video_profesional(prompt, custom_script, voz_index, musica=None):
     try: