Update app.py

app.py

@@ -1,120 +1,136 @@
 import os
 import re
 import requests
-import numpy as np
 import gradio as gr
-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 sklearn.metrics.pairwise import cosine_similarity
+from datetime import datetime
+import numpy as np
 from sklearn.feature_extraction.text import TfidfVectorizer
-from nltk.tokenize import sent_tokenize
 import nltk
+from nltk.tokenize import sent_tokenize
+import random
+from transformers import pipeline
+import torch
 
-# Descargar recursos para NLTK
+# Configuración inicial
 nltk.download('punkt')
-
-# Configuración avanzada
 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")
-HF_TOKEN = os.getenv("HF_TOKEN")  # Para modelos privados
-
-# 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
-)
-
-# 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")
+MODEL_NAME = "DeepESP/gpt2-spanish"  # Modelo en español más ligero
 
-# 3. Lista de voces disponibles
-VOICES = [v for v in edge_tts.list_voices() if 'es' in v['ShortName'] or 'en' in v['ShortName']]
+# Lista de voces disponibles
+VOICES = asyncio.run(edge_tts.list_voices())
 VOICE_NAMES = [f"{v['Name']} ({v['Gender']}, {v['LocaleName']})" for v in VOICES]
 
-def generar_guion_avanzado(prompt):
-    """Genera un guion largo y detallado usando IA"""
+def generar_guion_profesional(prompt):
+    """Genera guiones detallados con sistema de 3 niveles"""
     try:
-        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.",
+        # 1. Intento con modelo principal
+        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}'. "
+            "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,
-            num_beams=5,
             temperature=0.7,
             top_k=50,
             top_p=0.95,
-            do_sample=True
+            num_return_sequences=1
         )
-        return response[0]['generated_text']
+        
+        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
+        
     except Exception as e:
-        logger.error(f"Error en generación de guion: {str(e)}")
-        # Fallback a guion predefinido
+        logger.error(f"Error generando guion: {str(e)}")
+        
+        # 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! 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!
+        ¡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!
         """
 
-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 buscar_videos_semanticos(query, guion, num_videos=5):
-    """Busca videos usando análisis semántico"""
+def buscar_videos_avanzado(prompt, guion, num_videos=5):
+    """Búsqueda inteligente de videos usando análisis de contenido"""
     try:
         # Dividir el guion en oraciones
         oraciones = sent_tokenize(guion)
         
-        # 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)
+        # 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]
         
-        # Realizar búsqueda en Pexels
+        # 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(palabras_clave)}&per_page={num_videos}",
+            f"https://api.pexels.com/videos/search?query={'+'.join(todas_palabras)}&per_page={num_videos}",
             headers=headers,
-            timeout=20
+            timeout=15
         )
         
         videos = response.json().get('videos', [])
-        logger.info(f"Encontrados {len(videos)} videos para palabras clave: {palabras_clave}")
+        logger.info(f"Palabras clave usadas: {todas_palabras}")
         
-        # Seleccionar los mejores videos por calidad
+        # Seleccionar videos de mejor calidad
         videos_ordenados = sorted(
             videos,
             key=lambda x: x.get('width', 0) * x.get('height', 0),
@@ -124,31 +140,32 @@ def buscar_videos_semanticos(query, guion, num_videos=5):
         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
+        logger.error(f"Error en búsqueda de videos: {str(e)}")
+        # Búsqueda simple de respaldo
         response = requests.get(
-            f"https://api.pexels.com/videos/search?query={query}&per_page={num_videos}",
+            f"https://api.pexels.com/videos/search?query={prompt}&per_page={num_videos}",
             headers={"Authorization": PEXELS_API_KEY},
             timeout=10
         )
         return response.json().get('videos', [])[:num_videos]
 
-def crear_video_inteligente(prompt, custom_script, voz_index, musica=None):
+def crear_video_profesional(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}")
+        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']
         
-        # 3. Generar archivo de voz
+        # 3. Generar voz
         voz_archivo = "voz.mp3"
-        communicate = edge_tts.Communicate(guion, voz_seleccionada)
-        communicate.save(voz_archivo)
+        asyncio.run(edge_tts.Communicate(guion, voz_seleccionada).save(voz_archivo))
+        audio = AudioFileClip(voz_archivo)
+        duracion_total = audio.duration
         
-        # 4. Buscar videos usando análisis semántico
-        videos_data = buscar_videos_semanticos(prompt, guion, num_videos=5)
+        # 4. Buscar videos relevantes
+        videos_data = buscar_videos_avanzado(prompt, guion)
         
         if not videos_data:
             raise Exception("No se encontraron videos relevantes")
@@ -175,43 +192,42 @@ def crear_video_inteligente(prompt, custom_script, voz_index, musica=None):
             clip = VideoFileClip(temp_video.name)
             clips.append(clip)
         
-        # 6. Procesar audio
-        audio = AudioFileClip(voz_archivo)
-        total_duration = audio.duration
+        # 6. Calcular duración por clip
+        duracion_por_clip = duracion_total / len(clips)
+        
+        # 7. Procesar clips de video
+        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
         if musica:
             musica_clip = AudioFileClip(musica.name)
-            if musica_clip.duration < total_duration:
-                musica_clip = musica_clip.loop(duration=total_duration)
+            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)])
         
-        # 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)
-        
-        # 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)
-        
-        final_clip = final_clip.set_audio(audio)
+        video_final = video_final.set_audio(audio)
         
-        # 8. Guardar video final
+        # 10. Exportar video
         output_path = f"video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
-        final_clip.write_videofile(
+        video_final.write_videofile(
             output_path,
             codec="libx264",
             audio_codec="aac",
-            threads=4,
-            preset='medium',
+            threads=2,
+            preset='fast',
             fps=24
         )
         
@@ -221,79 +237,57 @@ def crear_video_inteligente(prompt, custom_script, voz_index, musica=None):
         logger.error(f"ERROR: {str(e)}")
         return None
     finally:
-        # Limpieza
+        # Limpieza de archivos temporales
         if os.path.exists(voz_archivo):
             os.remove(voz_archivo)
 
 # 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.Blocks(theme=gr.themes.Soft(), title="Generador de Videos Profesional") as app:
+    gr.Markdown("# 🎬 GENERADOR DE VIDEOS CON IA")
     
     with gr.Row():
         with gr.Column(scale=1):
             gr.Markdown("### Configuración del Contenido")
-            prompt = gr.Textbox(label="Tema principal", placeholder="Ej: 'Los misterios del universo'")
+            prompt = gr.Textbox(label="Tema principal", placeholder="Ej: 'Los misterios de la antigua Grecia'")
             custom_script = gr.TextArea(
                 label="Guion personalizado (opcional)", 
-                placeholder="O escribe tu propio guion aquí...",
+                placeholder="Pega aquí tu propio guion completo...",
                 lines=8
             )
             voz = gr.Dropdown(
-                label="Selecciona una voz profesional",
+                label="Selecciona una voz",
                 choices=VOICE_NAMES,
                 value=VOICE_NAMES[0],
                 type="index"
             )
             musica = gr.File(
-                label="Música de fondo profesional (opcional)", 
-                file_types=["audio"],
-                type="filepath"
+                label="Música de fondo (opcional)", 
+                file_types=["audio"]
             )
-            btn = gr.Button("🚀 Generar Video Profesional", variant="primary", size="lg")
+            btn = gr.Button("🚀 Generar Video", variant="primary", size="lg")
             
         with gr.Column(scale=2):
             output = gr.Video(
                 label="Video Resultante", 
                 format="mp4",
-                interactive=False,
-                elem_id="video-output"
+                interactive=False
             )
             
-            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"
-    )
+            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"
+            )
 
     btn.click(
-        fn=crear_video_inteligente,
+        fn=crear_video_profesional,
         inputs=[prompt, custom_script, voz, musica],
         outputs=output
     )
 
-# CSS para mejor visualización
-app.css = """
-#video-output {
-    border-radius: 12px;
-    box-shadow: 0 6px 16px rgba(0,0,0,0.15);
-    margin: 20px auto;
-    max-width: 100%;
-}
-"""
-
 if __name__ == "__main__":
     app.launch(server_name="0.0.0.0", server_port=7860)