Update app.py

app.py

@@ -1,154 +1,217 @@
 import os
-import subprocess
+import re
 import requests
+import numpy as np
 import gradio as gr
-from moviepy.editor import *
 from datetime import datetime
+from moviepy.editor import *
+from transformers import pipeline, AutoTokenizer, AutoModel
+import torch
+import torch.nn.functional as F
+import edge_tts
 import tempfile
 import logging
-from transformers import pipeline
+from sklearn.metrics.pairwise import cosine_similarity
+from sklearn.feature_extraction.text import TfidfVectorizer
+from nltk.tokenize import sent_tokenize
+import nltk
+
+# Descargar recursos para NLTK
+nltk.download('punkt')
 
-# Configuración inicial
-logging.basicConfig(level=logging.INFO)
+# Configuración avanzada
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-PEXELS_API_KEY = os.getenv("PEXELS_API_KEY")  # Configurar en Hugging Face
+# Configuración de modelos
+PEXELS_API_KEY = os.getenv("PEXELS_API_KEY")
+HF_TOKEN = os.getenv("HF_TOKEN")  # Para modelos privados
 
-# Lista de voces válidas (puedes añadir más)
-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"
-]
+# 1. Modelo para generación de guiones (MBART grande para español)
+script_generator = pipeline(
+    "text2text-generation", 
+    model="facebook/mbart-large-50",
+    tokenizer="facebook/mbart-large-50",
+    device=0 if torch.cuda.is_available() else -1
+)
 
-# Inicializar el generador de texto
-try:
-    script_generator = pipeline("text-generation", model="facebook/mbart-large-50")
-except:
-    logger.warning("No se pudo cargar el modelo de generación de texto")
-    script_generator = None
+# 2. Modelo para embeddings semánticos (multilingüe)
+tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/paraphrase-multilingual-mpnet-base-v2")
+embedding_model = AutoModel.from_pretrained("sentence-transformers/paraphrase-multilingual-mpnet-base-v2")
 
-def generar_guion(prompt):
-    """Genera un guion automático usando IA"""
-    if script_generator:
-        try:
-            result = script_generator(
-                f"Genera un guion breve para un video sobre '{prompt}' con 3 puntos principales:",
-                max_length=250,
-                num_return_sequences=1
-            )
-            return result[0]['generated_text']
-        except Exception as e:
-            logger.error(f"Error generando guion: {str(e)}")
-    
-    # Fallback si falla la generación
-    return f"1. Primer punto sobre {prompt}\n2. Segundo punto\n3. Tercer punto"
+# 3. Lista de voces disponibles
+VOICES = [v for v in edge_tts.list_voices() if 'es' in v['ShortName'] or 'en' in v['ShortName']]
+VOICE_NAMES = [f"{v['Name']} ({v['Gender']}, {v['LocaleName']})" for v in VOICES]
 
-def descargar_video(url, output_path):
-    """Descarga un video y lo guarda localmente"""
+def generar_guion_avanzado(prompt):
+    """Genera un guion largo y detallado usando IA"""
     try:
-        response = requests.get(url, stream=True, timeout=20)
-        response.raise_for_status()
-        with open(output_path, 'wb') as f:
-            for chunk in response.iter_content(chunk_size=1024*1024):  # 1MB chunks
-                if chunk:
-                    f.write(chunk)
-        return True
+        response = script_generator(
+            f"Escribe un guion detallado para un video de YouTube sobre '{prompt}' con introducción, 3 puntos principales y conclusión. Usa un estilo atractivo y profesional.",
+            max_length=1000,
+            num_beams=5,
+            temperature=0.7,
+            top_k=50,
+            top_p=0.95,
+            do_sample=True
+        )
+        return response[0]['generated_text']
     except Exception as e:
-        logger.error(f"Error descargando video: {str(e)}")
-        return False
+        logger.error(f"Error en generación de guion: {str(e)}")
+        # Fallback a guion predefinido
+        return f"""
+        ¡Hola a todos! Hoy exploraremos el fascinante tema de {prompt}. 
+        En este video cubriremos tres aspectos clave:
+        1. Primer aspecto importante sobre {prompt}
+        2. Segundo elemento crucial
+        3. Tercer punto que no te puedes perder
+        ¡Quedaos hasta el final para descubrir algo increíble!
+        """
+
+def obtener_embeddings(textos):
+    """Obtiene embeddings semánticos para los textos"""
+    inputs = tokenizer(textos, padding=True, truncation=True, return_tensors="pt", max_length=512)
+    with torch.no_grad():
+        outputs = embedding_model(**inputs)
+    embeddings = outputs.last_hidden_state.mean(dim=1).cpu().numpy()
+    return embeddings
 
-def crear_video(prompt, custom_script, voz_seleccionada, musica=None):
+def buscar_videos_semanticos(query, guion, num_videos=5):
+    """Busca videos usando análisis semántico"""
     try:
-        # 1. Generar o usar guion
-        guion = custom_script if custom_script else generar_guion(prompt)
-        logger.info(f"Guion: {guion[:100]}...")
+        # Dividir el guion en oraciones
+        oraciones = sent_tokenize(guion)
         
-        # 2. Generar voz
-        voz_archivo = "voz.mp3"
-        subprocess.run([
-            'edge-tts',
-            '--voice', voz_seleccionada,
-            '--text', guion,
-            '--write-media', voz_archivo
-        ], check=True)
-        
-        # 3. Buscar videos en Pexels
+        # Obtener embeddings para cada oración
+        embeddings_oraciones = obtener_embeddings(oraciones)
+        
+        # Embedding para la consulta general
+        embedding_query = obtener_embeddings([query])[0]
+        
+        # Calcular similitud entre consulta y cada oración
+        similitudes = cosine_similarity([embedding_query], embeddings_oraciones)[0]
+        
+        # Seleccionar las oraciones más relevantes
+        indices_relevantes = np.argsort(similitudes)[-3:]
+        oraciones_relevantes = [oraciones[i] for i in indices_relevantes]
+        
+        # Extraer palabras clave de las oraciones relevantes
+        vectorizer = TfidfVectorizer(stop_words=['el', 'la', 'los', 'las', 'de', 'en', 'y'])
+        tfidf = vectorizer.fit_transform(oraciones_relevantes)
+        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]
+        
+        # Realizar búsqueda en Pexels
         headers = {"Authorization": PEXELS_API_KEY}
         response = requests.get(
-            f"https://api.pexels.com/videos/search?query={prompt[:50]}&per_page=3",
+            f"https://api.pexels.com/videos/search?query={'+'.join(palabras_clave)}&per_page={num_videos}",
             headers=headers,
-            timeout=15
+            timeout=20
+        )
+        
+        videos = response.json().get('videos', [])
+        logger.info(f"Encontrados {len(videos)} videos para palabras clave: {palabras_clave}")
+        
+        # Seleccionar los mejores videos por 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 semántica: {str(e)}")
+        # Fallback a búsqueda simple
+        response = requests.get(
+            f"https://api.pexels.com/videos/search?query={query}&per_page={num_videos}",
+            headers={"Authorization": PEXELS_API_KEY},
+            timeout=10
         )
-        videos_data = response.json().get("videos", [])
+        return response.json().get('videos', [])[:num_videos]
+
+def crear_video_inteligente(prompt, custom_script, voz_index, musica=None):
+    try:
+        # 1. Generar o usar guion
+        guion = custom_script if custom_script else generar_guion_avanzado(prompt)
+        logger.info(f"Guion generado:\n{guion}")
+        
+        # 2. Seleccionar voz
+        voz_seleccionada = VOICES[voz_index]['ShortName']
+        
+        # 3. Generar archivo de voz
+        voz_archivo = "voz.mp3"
+        communicate = edge_tts.Communicate(guion, voz_seleccionada)
+        communicate.save(voz_archivo)
+        
+        # 4. Buscar videos usando análisis semántico
+        videos_data = buscar_videos_semanticos(prompt, guion, num_videos=5)
         
         if not videos_data:
-            raise Exception("No se encontraron videos en Pexels")
+            raise Exception("No se encontraron videos relevantes")
         
-        # 4. Descargar y preparar clips de video
+        # 5. Descargar y preparar videos
         clips = []
-        for i, video in enumerate(videos_data[:3]):
-            # Seleccionar la mejor calidad de video disponible
+        for video in videos_data:
+            # Seleccionar la mejor calidad de video
             video_files = sorted(
-                [vf for vf in video['video_files'] if vf.get('width')],
-                key=lambda x: x['width'],
+                video['video_files'],
+                key=lambda x: x.get('width', 0) * x.get('height', 0),
                 reverse=True
             )
-            
-            if not video_files:
-                continue
-                
             video_url = video_files[0]['link']
-            temp_video_path = f"temp_video_{i}.mp4"
             
-            if descargar_video(video_url, temp_video_path):
-                clip = VideoFileClip(temp_video_path)
-                
-                # Calcular duración proporcional
-                clip_duration = min(10, clip.duration)  # Máximo 10 segundos por clip
-                clips.append(clip.subclip(0, clip_duration))
-        
-        if not clips:
-            raise Exception("No se pudieron cargar videos válidos")
+            # 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)
         
-        # 5. Procesar audio
+        # 6. Procesar audio
         audio = AudioFileClip(voz_archivo)
         total_duration = audio.duration
         
         if musica:
             musica_clip = AudioFileClip(musica.name)
             if musica_clip.duration < total_duration:
-                # Crear loop si la música es más corta
-                looped_music = musica_clip.loop(duration=total_duration)
-            else:
-                looped_music = musica_clip.subclip(0, total_duration)
-                
-            audio = CompositeAudioClip([audio, looped_music.volumex(0.25)])
-        
-        # 6. Crear video final
+                musica_clip = musica_clip.loop(duration=total_duration)
+            audio = CompositeAudioClip([audio, musica_clip.volumex(0.25)])
+        
+        # 7. Crear video con sincronización inteligente
         # Calcular duración por clip
         clip_durations = [c.duration for c in clips]
         total_clip_duration = sum(clip_durations)
-        scale_factor = total_duration / total_clip_duration if total_clip_duration > 0 else 1
-        
-        # Ajustar velocidad de los clips para que coincidan con el audio
-        adjusted_clips = [c.fx(vfx.speedx, scale_factor) for c in clips]
-        final_clip = concatenate_videoclips(adjusted_clips, method="compose")
         
-        # Aplicar transición suave entre clips
-        final_clip = final_clip.fx(vfx.fadein, 0.5).fx(vfx.fadeout, 0.5)
+        # Ajustar clips para que coincidan con la duración del audio
+        if total_clip_duration < total_duration:
+            # Repetir la secuencia de videos si es necesario
+            repetitions = int(total_duration / total_clip_duration) + 1
+            extended_clips = clips * repetitions
+            final_clip = concatenate_videoclips(extended_clips).subclip(0, total_duration)
+        else:
+            # Ajustar velocidad para coincidir con la duración
+            speed_factor = total_clip_duration / total_duration
+            adjusted_clips = [clip.fx(vfx.speedx, speed_factor) for clip in clips]
+            final_clip = concatenate_videoclips(adjusted_clips)
         
-        # Ajustar duración exacta
-        final_clip = final_clip.set_duration(total_duration).set_audio(audio)
+        final_clip = final_clip.set_audio(audio)
         
-        # 7. Guardar video final
+        # 8. Guardar video final
         output_path = f"video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
         final_clip.write_videofile(
             output_path,
             codec="libx264",
             audio_codec="aac",
-            threads=2,
-            preset='fast',
+            threads=4,
+            preset='medium',
             fps=24
         )
         
@@ -158,69 +221,77 @@ def crear_video(prompt, custom_script, voz_seleccionada, musica=None):
         logger.error(f"ERROR: {str(e)}")
         return None
     finally:
-        # Limpieza de archivos temporales
+        # Limpieza
         if os.path.exists(voz_archivo):
             os.remove(voz_archivo)
-        for i in range(3):
-            if os.path.exists(f"temp_video_{i}.mp4"):
-                os.remove(f"temp_video_{i}.mp4")
 
-# Interfaz Gradio mejorada
-with gr.Blocks(theme=gr.themes.Soft(), title="Generador de Videos Profesional") as app:
-    gr.Markdown("# 🎬 GENERADOR DE VIDEOS AUTOMÁTICO")
+# Interfaz profesional
+with gr.Blocks(theme=gr.themes.Soft(), title="Generador de Videos con IA") as app:
+    gr.Markdown("# 🎬 GENERADOR AVANZADO DE VIDEOS CON IA")
     
     with gr.Row():
         with gr.Column(scale=1):
-            gr.Markdown("### Configuración del Video")
-            prompt = gr.Textbox(label="Tema principal", placeholder="Ej: 'Lugares misteriosos de España'")
+            gr.Markdown("### Configuración del Contenido")
+            prompt = gr.Textbox(label="Tema principal", placeholder="Ej: 'Los misterios del universo'")
             custom_script = gr.TextArea(
                 label="Guion personalizado (opcional)", 
-                placeholder="Pega aquí tu propio guion...",
-                lines=5
+                placeholder="O escribe tu propio guion aquí...",
+                lines=8
             )
             voz = gr.Dropdown(
-                label="Selecciona una voz",
-                choices=VOICES,
-                value="es-ES-ElviraNeural",
-                interactive=True
+                label="Selecciona una voz profesional",
+                choices=VOICE_NAMES,
+                value=VOICE_NAMES[0],
+                type="index"
             )
             musica = gr.File(
-                label="Música de fondo (opcional)", 
-                file_types=[".mp3", ".wav"],
+                label="Música de fondo profesional (opcional)", 
+                file_types=["audio"],
                 type="filepath"
             )
-            btn = gr.Button("🚀 GENERAR VIDEO", variant="primary", size="lg")
+            btn = gr.Button("🚀 Generar Video Profesional", variant="primary", size="lg")
             
         with gr.Column(scale=2):
             output = gr.Video(
                 label="Video Resultante", 
                 format="mp4",
                 interactive=False,
-                elem_id="video-player"
+                elem_id="video-output"
             )
             
-            gr.Examples(
-                examples=[
-                    ["Lugares históricos de Roma", "", "it-IT-ElsaNeural", None],
-                    ["Tecnologías del futuro", "", "en-US-JennyNeural", None],
-                    ["Playas paradisíacas del Caribe", "", "es-MX-DaliaNeural", None]
-                ],
-                inputs=[prompt, custom_script, voz, musica],
-                label="Ejemplos para probar"
-            )
+            with gr.Accordion("Detalles técnicos", open=False):
+                gr.Markdown("""
+                **Tecnologías utilizadas:**
+                - Generación de guiones: Meta MBART-large-50
+                - Búsqueda semántica: Sentence Transformers multilingüe
+                - Síntesis de voz: Microsoft Edge TTS
+                - Procesamiento de video: MoviePy
+                """)
+    
+    # Ejemplos profesionales
+    gr.Examples(
+        examples=[
+            ["Los secretos de la inteligencia artificial", "", 0, None],
+            ["Lugares históricos de Europa", "", 3, None],
+            ["Innovaciones tecnológicas del futuro", "", 5, None]
+        ],
+        inputs=[prompt, custom_script, voz, musica],
+        label="Ejemplos profesionales"
+    )
 
     btn.click(
-        fn=crear_video,
+        fn=crear_video_inteligente,
         inputs=[prompt, custom_script, voz, musica],
         outputs=output
     )
 
-# CSS para mejorar la visualización
+# CSS para mejor visualización
 app.css = """
-#video-player {
+#video-output {
+    border-radius: 12px;
+    box-shadow: 0 6px 16px rgba(0,0,0,0.15);
+    margin: 20px auto;
     max-width: 100%;
-    border-radius: 10px;
-    box-shadow: 0 4px 12px rgba(0,0,0,0.15);
 }
 """