Update app.py

app.py

@@ -4,17 +4,12 @@ import requests
 import gradio as gr
 from moviepy.editor import *
 from datetime import datetime
-import tempfile
 import logging
-from transformers import pipeline
-import nltk
-from nltk.tokenize import sent_tokenize
-import numpy as np
-from sklearn.feature_extraction.text import TfidfVectorizer
 import re
+import torch
+from transformers import GPT2LMHeadModel, GPT2Tokenizer
 
 # Configuración inicial
-nltk.download('punkt', quiet=True)
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
@@ -23,77 +18,69 @@ PEXELS_API_KEY = os.getenv("PEXELS_API_KEY")
 # Lista de voces válidas
 VOICES = [
     "es-MX-DaliaNeural", "es-ES-ElviraNeural", "es-AR-ElenaNeural",
+    "es-MX-JorgeNeural", "es-ES-AlvaroNeural", "es-AR-TomasNeural",
     "en-US-JennyNeural", "fr-FR-DeniseNeural", "de-DE-KatjaNeural",
-    "it-IT-ElsaNeural", "pt-BR-FranciscaNeural", "ja-JP-NanamiNeural"
+    "it-IT-ElsaNeural", "pt-BR-FranciscaNeural", "ja-JP-NanamiNeural",
+    "en-GB-SoniaNeural", "es-CL-CatalinaNeural", "es-CO-GonzaloNeural"
 ]
 
-# Inicializar el generador de texto
+# Cargar modelo y tokenizador de GPT-2 en español
 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."
+    tokenizer = GPT2Tokenizer.from_pretrained("datificate/gpt2-small-spanish")
+    model = GPT2LMHeadModel.from_pretrained("datificate/gpt2-small-spanish")
+    logger.info("Modelo GPT-2 en español cargado correctamente")
+except Exception as e:
+    logger.error(f"Error cargando el modelo: {str(e)}")
+    model = None
+    tokenizer = None
 
-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()
+def generar_guion_largo(tema, custom_script=None):
+    """Genera un texto largo sobre el tema usando GPT-2"""
+    if custom_script:
+        return custom_script
+        
+    if model is None or tokenizer is None:
+        return f"Texto generado automáticamente sobre {tema}. " * 50
     
-    return [palabras[i] for i in indices]
+    try:
+        # Prompt directo como solicitaste
+        prompt = f"Escribe un texto largo y detallado sobre {tema}"
+        
+        inputs = tokenizer(prompt, return_tensors="pt", max_length=512, truncation=True)
+        
+        # Generar texto
+        outputs = model.generate(
+            inputs.input_ids,
+            max_length=800,
+            temperature=0.9,
+            top_k=50,
+            top_p=0.95,
+            num_return_sequences=1,
+            pad_token_id=tokenizer.eos_token_id
+        )
+        
+        guion = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        
+        # Limpiar texto
+        guion = re.sub(r'<.*?>', '', guion)
+        guion = re.sub(r'\n+', '\n', guion)
+        
+        logger.info(f"Guion generado: {len(guion)} caracteres")
+        return guion
+        
+    except Exception as e:
+        logger.error(f"Error generando guion: {str(e)}")
+        return f"Texto generado automáticamente sobre {tema}. " * 50
 
-def buscar_videos_pexels(palabras_clave, num_videos=3):
-    """Busca videos en Pexels usando palabras clave con enfoque en relevancia"""
+def buscar_videos_pexels(tema, num_videos=4):
+    """Busca videos en Pexels usando el tema directamente"""
     try:
         headers = {"Authorization": PEXELS_API_KEY}
-        query = "+".join(palabras_clave[:3])  # Usar las 3 palabras más relevantes
         
-        logger.info(f"Buscando videos con palabras clave: {query}")
+        logger.info(f"Buscando videos para: {tema}")
         
         response = requests.get(
-            f"https://api.pexels.com/videos/search?query={query}&per_page={num_videos}",
+            f"https://api.pexels.com/videos/search?query={tema}&per_page={num_videos}",
             headers=headers,
             timeout=15
         )
@@ -102,7 +89,7 @@ def buscar_videos_pexels(palabras_clave, num_videos=3):
         # Filtrar videos de alta calidad
         return sorted(
             videos,
-            key=lambda x: x.get('duration', 0),
+            key=lambda x: (x.get('width', 0) * x.get('height', 0), x.get('duration', 0)),
             reverse=True
         )[:num_videos]
     except Exception as e:
@@ -112,7 +99,7 @@ def buscar_videos_pexels(palabras_clave, num_videos=3):
 def descargar_video(url, output_path):
     """Descarga un video de manera eficiente"""
     try:
-        with requests.get(url, stream=True, timeout=25) as r:
+        with requests.get(url, stream=True, timeout=30) as r:
             r.raise_for_status()
             with open(output_path, 'wb') as f:
                 for chunk in r.iter_content(chunk_size=8192):
@@ -124,21 +111,10 @@ def descargar_video(url, output_path):
 
 def crear_video(prompt, custom_script, voz_seleccionada, musica=None):
     try:
-        # 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)}")
+        # 1. Generar guion largo
+        guion = generar_guion_largo(prompt, custom_script)
         
-        # 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...")
-        
-        # 4. Generar narración
+        # 2. Generar narración
         voz_archivo = "voz.mp3"
         subprocess.run([
             'edge-tts',
@@ -147,70 +123,100 @@ def crear_video(prompt, custom_script, voz_seleccionada, musica=None):
             '--write-media', voz_archivo
         ], check=True)
         
-        # 5. Procesar audio
+        # 3. Procesar audio principal
         audio = AudioFileClip(voz_archivo)
         duracion_total = audio.duration
         
-        # 6. Descargar y preparar videos
+        # 4. Buscar videos relevantes
+        videos_data = buscar_videos_pexels(prompt)
+        
+        if not videos_data:
+            logger.warning("No se encontraron videos. Usando videos genéricos...")
+            videos_data = buscar_videos_pexels("nature")
+        
+        # 5. 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)
+            try:
+                # Seleccionar la mejor calidad disponible
+                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"
                 
-                # Ajustar duración proporcional
-                duracion_clip = min(duracion_total / len(videos_data), clip.duration)
-                clips.append(clip.subclip(0, duracion_clip))
+                if descargar_video(video_url, temp_path):
+                    clip = VideoFileClip(temp_path)
+                    
+                    # Calcular duración proporcional para cada clip
+                    duracion_clip = duracion_total / len(videos_data)
+                    
+                    # Ajustar clip a la duración requerida
+                    if clip.duration < duracion_clip:
+                        clip = clip.loop(duration=duracion_clip)
+                    else:
+                        clip = clip.subclip(0, duracion_clip)
+                    
+                    clips.append(clip)
+            except Exception as e:
+                logger.error(f"Error procesando video {i}: {str(e)}")
         
-        # 7. Combinar videos
+        if not clips:
+            raise Exception("No se pudieron cargar videos válidos")
+        
+        # 6. Combinar videos
         video_final = concatenate_videoclips(clips)
         video_final = video_final.set_audio(audio)
         
-        # 8. Exportar
+        # 7. Exportar video final
         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",
-            threads=2
+            threads=4,
+            preset='fast'
         )
         
+        logger.info(f"Video generado exitosamente: {output_path}")
         return output_path
         
     except Exception as e:
         logger.error(f"ERROR: {str(e)}")
         return None
     finally:
-        # Limpieza
+        # Limpieza garantizada
         if os.path.exists(voz_archivo):
             os.remove(voz_archivo)
-        for i in range(3):
+        for i in range(5):
             temp_file = f"temp_video_{i}.mp4"
             if os.path.exists(temp_file):
                 os.remove(temp_file)
 
 # Interfaz simplificada y funcional
 with gr.Blocks(title="Generador de Videos") as app:
-    gr.Markdown("# 🎥 Generador Automático de Videos")
+    gr.Markdown("# 🎬 GENERADOR AUTOMÁTICO DE VIDEOS")
     
     with gr.Row():
-        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")
+        with gr.Column():
+            prompt = gr.Textbox(label="Tema del video", placeholder="Ej: 'La historia de la inteligencia artificial'")
+            custom_script = gr.TextArea(
+                label="Guion personalizado (opcional)", 
+                placeholder="Pega tu guion completo aquí...",
+                lines=5
+            )
+            voz = gr.Dropdown(label="Voz Narradora", choices=VOICES, value=VOICES[0])
+            musica = gr.File(label="Música de fondo (opcional)", file_types=["audio"])
+            btn = gr.Button("Generar Video", variant="primary")
+            
+        with gr.Column():
+            output = gr.Video(label="Video Resultado", format="mp4")
     
     btn.click(
         fn=crear_video,
-        inputs=[prompt, gr.Textbox(visible=False), voz, gr.File(visible=False)],
+        inputs=[prompt, custom_script, voz, musica],
         outputs=output
     )