Update app.py

app.py

@@ -1,90 +1,186 @@
 import os
-import re
+import subprocess
 import requests
 import gradio as gr
 from moviepy.editor import *
-import edge_tts
+from datetime import datetime
 import tempfile
 import logging
-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
+import nltk
 from nltk.tokenize import sent_tokenize
+import numpy as np
+from sklearn.feature_extraction.text import TfidfVectorizer
+import re
 
 # 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)
 logger = logging.getLogger(__name__)
 
-# Configuración de modelos
 PEXELS_API_KEY = os.getenv("PEXELS_API_KEY")
-MODEL_NAME = "DeepESP/gpt2-spanish"
 
-# Lista de voces disponibles
-async def get_voices():
-    voices = await edge_tts.list_voices()
-    return [v['ShortName'] for v in voices]
+# Lista de voces válidas
+VOICES = [
+    "es-MX-DaliaNeural", "es-ES-ElviraNeural", "es-AR-ElenaNeural",
+    "en-US-JennyNeural", "fr-FR-DeniseNeural", "de-DE-KatjaNeural",
+    "it-IT-ElsaNeural", "pt-BR-FranciscaNeural", "ja-JP-NanamiNeural"
+]
 
-VOICE_NAMES = asyncio.run(get_voices())
+# Inicializar el generador de texto
+try:
+    script_generator = pipeline(
+        "text-generation", 
+        model="gpt2",  # Modelo más flexible
+        device=0 if torch.cuda.is_available() else -1
+    )
+except:
+    logger.warning("No se pudo cargar el modelo de generación de texto")
+    script_generator = None
+
+def generar_guion(prompt):
+    """Genera un guion natural y extenso basado en el prompt"""
+    if script_generator:
+        try:
+            result = script_generator(
+                f"Genera un texto detallado y bien estructurado sobre '{prompt}' para un video de YouTube:",
+                max_length=500,  # Texto más largo
+                temperature=0.9,  # Más creatividad
+                num_return_sequences=1
+            )
+            guion = result[0]['generated_text']
+            
+            # Limpiar el guion generado
+            guion = re.sub(r'<.*?>', '', guion)
+            guion = re.sub(r'\n+', '\n', guion)
+            return guion.strip()
+        except Exception as e:
+            logger.error(f"Error generando guion: {str(e)}")
+    
+    # Fallback natural
+    return f"En este video exploraremos en profundidad el tema de {prompt}. " \
+           "Analizaremos diversos aspectos y perspectivas para ofrecer una visión completa. " \
+           "Veremos cómo este tema se relaciona con nuestra vida cotidiana y su impacto en la sociedad actual."
+
+def extraer_palabras_clave(texto, n=7):
+    """Extrae palabras clave relevantes usando TF-IDF"""
+    # Preprocesamiento del texto
+    texto = re.sub(r'[^\w\s]', '', texto.lower())
+    
+    # Tokenizar en oraciones
+    oraciones = sent_tokenize(texto)
+    
+    # Crear matriz TF-IDF
+    vectorizer = TfidfVectorizer(
+        stop_words=['el', 'la', 'los', 'las', 'de', 'en', 'y', 'que', 'un', 'una', 'con', 'para'],
+        max_features=500
+    )
+    X = vectorizer.fit_transform(oraciones)
+    
+    # Obtener palabras con mayor puntuación TF-IDF
+    suma_scores = np.asarray(X.sum(axis=0)).ravel()
+    indices = np.argsort(suma_scores)[::-1][:n]
+    palabras = vectorizer.get_feature_names_out()
+    
+    return [palabras[i] for i in indices]
 
-def generar_guion_profesional(prompt):
-    """Genera guiones detallados con sistema de 3 niveles"""
+def buscar_videos_pexels(palabras_clave, num_videos=3):
+    """Busca videos en Pexels usando palabras clave con enfoque en relevancia"""
     try:
-        generator = pipeline(
-            "text-generation",
-            model=MODEL_NAME,
-            device=0 if torch.cuda.is_available() else -1
-        )
+        headers = {"Authorization": PEXELS_API_KEY}
+        query = "+".join(palabras_clave[:3])  # Usar las 3 palabras más relevantes
         
-        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,
-            temperature=0.7,
-            top_k=50,
-            top_p=0.95,
-            num_return_sequences=1
-        )
+        logger.info(f"Buscando videos con palabras clave: {query}")
         
-        guion = response[0]['generated_text']
-        return guion
+        response = requests.get(
+            f"https://api.pexels.com/videos/search?query={query}&per_page={num_videos}",
+            headers=headers,
+            timeout=15
+        )
+        videos = response.json().get("videos", [])
         
+        # Filtrar videos de alta calidad
+        return sorted(
+            videos,
+            key=lambda x: x.get('duration', 0),
+            reverse=True
+        )[:num_videos]
+    except Exception as e:
+        logger.error(f"Error buscando videos: {str(e)}")
+        return []
+
+def descargar_video(url, output_path):
+    """Descarga un video de manera eficiente"""
+    try:
+        with requests.get(url, stream=True, timeout=25) as r:
+            r.raise_for_status()
+            with open(output_path, 'wb') as f:
+                for chunk in r.iter_content(chunk_size=8192):
+                    f.write(chunk)
+        return True
     except Exception as e:
-        logger.error(f"Error generando guion: {str(e)}")
-        return f"Guion de ejemplo sobre {prompt}. Introducción. Desarrollo. Conclusión."
+        logger.error(f"Error descargando video: {str(e)}")
+        return False
 
-async def crear_video_profesional(prompt, custom_script, voz_index, musica=None):
+def crear_video(prompt, custom_script, voz_seleccionada, musica=None):
     try:
-        # 1. Generar o usar guion
-        guion = custom_script if custom_script else generar_guion_profesional(prompt)
-        logger.info(f"Guion generado ({len(guion.split())} palabras)")
+        # 1. Generar guion natural
+        guion = custom_script if custom_script else generar_guion(prompt)
+        logger.info(f"Guion generado ({len(guion)} caracteres)")
+        
+        # 2. Extraer palabras clave del guion completo
+        palabras_clave = extraer_palabras_clave(guion)
+        logger.info(f"Palabras clave extraídas: {', '.join(palabras_clave)}")
+        
+        # 3. Buscar videos relevantes usando IA
+        videos_data = buscar_videos_pexels(palabras_clave)
+        
+        if not videos_data:
+            raise Exception("No se encontraron videos relevantes. Usando backup...")
         
-        # 2. Generar voz
+        # 4. Generar narración
         voz_archivo = "voz.mp3"
-        await edge_tts.Communicate(guion, VOICE_NAMES[voz_index]).save(voz_archivo)
+        subprocess.run([
+            'edge-tts',
+            '--voice', voz_seleccionada,
+            '--text', guion,
+            '--write-media', voz_archivo
+        ], check=True)
+        
+        # 5. Procesar audio
         audio = AudioFileClip(voz_archivo)
         duracion_total = audio.duration
         
-        # 3. Crear video simple (versión funcional)
-        clip = ColorClip(size=(1280, 720), color=(0, 0, 0), duration=duracion_total)
-        video_final = clip.set_audio(audio)
+        # 6. Descargar y preparar videos
+        clips = []
+        for i, video in enumerate(videos_data):
+            # Seleccionar la mejor calidad
+            video_file = max(
+                video['video_files'], 
+                key=lambda x: x.get('width', 0) * x.get('height', 0)
+            )
+            video_url = video_file['link']
+            temp_path = f"temp_video_{i}.mp4"
+            
+            if descargar_video(video_url, temp_path):
+                clip = VideoFileClip(temp_path)
+                
+                # Ajustar duración proporcional
+                duracion_clip = min(duracion_total / len(videos_data), clip.duration)
+                clips.append(clip.subclip(0, duracion_clip))
         
-        # 4. Exportar video
+        # 7. Combinar videos
+        video_final = concatenate_videoclips(clips)
+        video_final = video_final.set_audio(audio)
+        
+        # 8. Exportar
         output_path = f"video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
         video_final.write_videofile(
             output_path,
             fps=24,
             codec="libx264",
-            audio_codec="aac"
+            audio_codec="aac",
+            threads=2
         )
         
         return output_path
@@ -93,33 +189,27 @@ async def crear_video_profesional(prompt, custom_script, voz_index, musica=None)
         logger.error(f"ERROR: {str(e)}")
         return None
     finally:
+        # Limpieza
         if os.path.exists(voz_archivo):
             os.remove(voz_archivo)
+        for i in range(3):
+            temp_file = f"temp_video_{i}.mp4"
+            if os.path.exists(temp_file):
+                os.remove(temp_file)
 
-def run_async_func(prompt, custom_script, voz_index, musica=None):
-    return asyncio.run(crear_video_profesional(prompt, custom_script, voz_index, musica))
-
-# Interfaz profesional CORREGIDA
-with gr.Blocks(theme=gr.themes.Soft(), title="Generador de Videos Profesional") as app:
-    gr.Markdown("# 🎬 GENERADOR DE VIDEOS CON IA")
+# Interfaz simplificada y funcional
+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'")
-            voz = gr.Dropdown(
-                label="Selecciona una voz",
-                choices=VOICE_NAMES,
-                value=VOICE_NAMES[0]
-            )
-            btn = gr.Button("🚀 Generar Video", variant="primary", size="lg")
-            
-        with gr.Column(scale=2):
-            output = gr.Video(label="Video Resultante", format="mp4")
-            
-    # CORRECCIÓN: Quitar el parámetro timeout que causaba el error
+        prompt = gr.Textbox(label="Tema del video", placeholder="Ej: Exploración espacial")
+        voz = gr.Dropdown(label="Voz Narradora", choices=VOICES, value=VOICES[0])
+    
+    btn = gr.Button("Generar Video", variant="primary")
+    output = gr.Video(label="Resultado", format="mp4")
+    
     btn.click(
-        fn=run_async_func,
+        fn=crear_video,
         inputs=[prompt, gr.Textbox(visible=False), voz, gr.File(visible=False)],
         outputs=output
     )