Update app.py

app.py

@@ -10,10 +10,10 @@ from datetime import datetime
 import numpy as np
 from sklearn.feature_extraction.text import TfidfVectorizer
 import nltk
-import random
+from nltk.tokenize import sent_tokenize
 from transformers import pipeline
 import torch
-import asyncio  # ¡Importación crítica que faltaba!
+import asyncio
 
 # Configuración inicial
 nltk.download('punkt', quiet=True)
@@ -22,16 +22,36 @@ 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
-VOICES = asyncio.run(edge_tts.list_voices())  # Ahora funciona correctamente
-VOICE_NAMES = [f"{v['Name']} ({v['Gender']}, {v['LocaleName']})" for v in VOICES]
+# 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
+VOICE_NAMES, VOICES = asyncio.run(get_voices())
+if not VOICES:
+    VOICE_NAMES = ["Voz Predeterminada (Femenino, es-ES)"]
+    VOICES = [{'ShortName': 'es-ES-ElviraNeural'}]
 
 def generar_guion_profesional(prompt):
-    """Genera guiones detallados con sistema de 3 niveles"""
+    """Genera guiones con respaldo robusto"""
     try:
-        # 1. Intento con modelo principal
         generator = pipeline(
             "text-generation",
             model=MODEL_NAME,
@@ -39,269 +59,95 @@ 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 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,
-            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)}")
+        return f"""Guión de respaldo sobre {prompt}:
         
-        # 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!
-        """
+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=5):
-    """Búsqueda inteligente de videos usando análisis de contenido"""
+def buscar_videos_avanzado(prompt, guion, num_videos=3):
+    """Búsqueda con múltiples respaldos"""
     try:
-        # Dividir el guion en oraciones
-        oraciones = nltk.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
+        palabras = re.findall(r'\b\w{4,}\b', prompt.lower())[:5]
         response = requests.get(
-            f"https://api.pexels.com/videos/search?query={prompt}&per_page={num_videos}",
+            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, progress=gr.Progress()):
-    """SOLUCIÓN: Añadido parámetro progress para mantener la conexión activa"""
+async def crear_video_profesional(prompt, custom_script, voz_index, musica=None):
     try:
-        # 1. Generar o usar guion (con progreso)
-        progress(0.1, desc="Generando guion...")
+        # 1. Generar guión
         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']
+        # 2. Configurar voz
+        voz_seleccionada = VOICES[voz_index]['ShortName'] if VOICES else 'es-ES-ElviraNeural'
         
-        # 3. Generar voz (con progreso)
-        progress(0.3, desc="Generando voz...")
+        # 3. Generar audio
         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 (con progreso)
-        progress(0.4, desc="Buscando videos...")
+        # 4. Obtener videos
         videos_data = buscar_videos_avanzado(prompt, guion)
-        
         if not videos_data:
-            raise Exception("No se encontraron videos relevantes")
-        
-        # 5. Descargar y preparar videos (con progreso)
-        clips = []
-        total_videos = len(videos_data)
-        
-        for i, video in enumerate(videos_data):
-            progress(0.5 + (i * 0.4 / total_videos), desc=f"Descargando video {i+1}/{total_videos}...")
+            raise Exception("No se encontraron videos")
             
-            # 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()
-            
-            # 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 (con progreso)
-        progress(0.8, desc="Procesando videos...")
-        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)
-        
-        # 9. Procesar música (con progreso)
-        progress(0.9, desc="Añadiendo 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)])
-        
+        # 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)
         
-        # 10. Exportar video (con progreso)
-        progress(0.95, desc="Exportando video final...")
-        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
-        )
+        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: {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, progress=gr.Progress()):
-    """SOLUCIÓN: Añadido parámetro progress para mantener la conexión activa"""
-    return asyncio.run(crear_video_profesional(prompt, custom_script, voz_index, musica, progress))
-
-# Interfaz profesional
-with gr.Blocks(theme=gr.themes.Soft(), title="Generador de Videos Profesional") as app:
-    gr.Markdown("# 🎬 GENERADOR DE VIDEOS CON IA")
-    
+# Interfaz optimizada
+with gr.Blocks(title="Generador de Videos") as app:
     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"
-            )
-
-    # SOLUCIÓN: Añadido parámetro progress para mantener la conexión activa
+        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")
+    
     btn.click(
-        fn=run_async_func,
-        inputs=[prompt, custom_script, voz, musica],
+        fn=lambda p, cs, v: asyncio.run(crear_video_profesional(p, cs, VOICE_NAMES.index(v))),
+        inputs=[prompt, custom_script, voz],
         outputs=output
     )