Update app.py

app.py

@@ -1,157 +1,218 @@
 import os
-import subprocess
+import re
 import requests
 import gradio as gr
 from moviepy.editor import *
-from datetime import datetime
+import edge_tts
+import tempfile
 import logging
-import re
+from datetime import datetime
+import numpy as np
+from sklearn.feature_extraction.text import TfidfVectorizer
+import nltk
+from transformers import pipeline
 import torch
-from transformers import GPT2LMHeadModel, GPT2Tokenizer
+import asyncio
+import time
 
-# Configuración básica
-logging.basicConfig(level=logging.INFO)
+# Configuración inicial
+nltk.download('punkt', quiet=True)
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# Configuración de entorno (usa tu propia API key de Pexels)
-PEXELS_API_KEY = os.getenv("PEXELS_API_KEY") or "TU_API_KEY_AQUI"
-
-# Voces disponibles (Edge-TTS)
-VOICES = ["es-MX-DaliaNeural", "es-ES-ElviraNeural", "en-US-JennyNeural"]
+# Configuración de modelos
+PEXELS_API_KEY = os.getenv("PEXELS_API_KEY")
+MODEL_NAME = "DeepESP/gpt2-spanish"  # Modelo en español
 
-# Carga el modelo GPT-2 en español (ligero y rápido)
-tokenizer = GPT2Tokenizer.from_pretrained("datificate/gpt2-small-spanish")
-model = GPT2LMHeadModel.from_pretrained("datificate/gpt2-small-spanish")
+# 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_texto(tema):
-    """Genera un texto largo y natural sobre el tema (sin estructuras forzadas)."""
-    try:
-        prompt = f"Habla extensamente sobre {tema} en un tono natural y detallado:"
-        inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512)
-        
-        outputs = model.generate(
-            inputs.input_ids,
-            max_length=800,
-            do_sample=True,
-            temperature=0.7,
-            top_k=50,
-            pad_token_id=tokenizer.eos_token_id
-        )
-        
-        texto = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        return re.sub(r'\s+', ' ', texto).strip()
+def generar_guion_profesional(prompt):
+    """Genera guiones detallados"""
+    generator = pipeline(
+        "text-generation",
+        model=MODEL_NAME,
+        device=0 if torch.cuda.is_available() else -1
+    )
     
-    except Exception as e:
-        logger.error(f"Error generando texto: {e}")
-        return f"Contenido generado sobre {tema}."
+    response = generator(
+        f"Escribe un guion profesional para un video de YouTube sobre '{prompt}':",
+        max_length=600,
+        temperature=0.7,
+        num_return_sequences=1
+    )
+    
+    return response[0]['generated_text']
 
-def buscar_videos(tema):
-    """Busca videos en Pexels y devuelve los 3 más relevantes."""
-    try:
-        headers = {"Authorization": PEXELS_API_KEY}
-        response = requests.get(
-            f"https://api.pexels.com/videos/search?query={tema}&per_page=3",
-            headers=headers,
-            timeout=10
-        )
-        return response.json().get("videos", [])[:3]
-    except Exception as e:
-        logger.error(f"Error buscando videos: {e}")
-        return []
+def buscar_videos_avanzado(prompt, guion, num_videos=5):
+    """Búsqueda inteligente de videos usando análisis de contenido"""
+    # 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=10
+    )
+    
+    videos = response.json().get('videos', [])
+    
+    # Seleccionar videos de mejor calidad
+    return sorted(
+        videos,
+        key=lambda x: x.get('width', 0) * x.get('height', 0),
+        reverse=True
+    )[:num_videos]
 
-def crear_video(tema, voz_seleccionada):
-    """Genera el video final con voz y clips de video."""
+async def crear_video_profesional(prompt, custom_script, voz_index, musica=None):
     try:
-        # 1. Generar texto
-        texto = generar_texto(tema)
+        # 1. Generar o usar guion
+        guion = custom_script if custom_script else generar_guion_profesional(prompt)
         
-        # 2. Convertir texto a voz (Edge-TTS)
-        voz_archivo = "narracion.mp3"
-        subprocess.run([
-            'edge-tts',
-            '--voice', voz_seleccionada,
-            '--text', texto,
-            '--write-media', voz_archivo
-        ], check=True)
+        # 2. Seleccionar voz
+        voz_seleccionada = VOICES[voz_index]['ShortName']
         
-        # 3. Procesar audio
+        # 3. Generar voz
+        voz_archivo = "voz.mp3"
+        await edge_tts.Communicate(guion, voz_seleccionada).save(voz_archivo)
         audio = AudioFileClip(voz_archivo)
         duracion_total = audio.duration
         
-        # 4. Buscar y descargar videos
-        videos = buscar_videos(tema) or buscar_videos("nature")
+        # 4. Buscar videos relevantes
+        videos_data = buscar_videos_avanzado(prompt, guion)
+        
+        # 5. Descargar y preparar videos
         clips = []
+        for video in videos_data:
+            # 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)
         
-        for i, video in enumerate(videos[:3]):  # Máximo 3 videos
-            try:
-                mejor_calidad = max(video['video_files'], key=lambda x: x.get('width', 0))
-                url_video = mejor_calidad['link']
-                
-                # Descargar video temporal
-                temp_file = f"temp_video_{i}.mp4"
-                with requests.get(url_video, stream=True) as r:
-                    r.raise_for_status()
-                    with open(temp_file, 'wb') as f:
-                        for chunk in r.iter_content(chunk_size=8192):
-                            f.write(chunk)
-                
-                # Ajustar duración del clip
-                clip = VideoFileClip(temp_file)
-                duracion_clip = min(duracion_total / len(videos), clip.duration)
-                clips.append(clip.subclip(0, duracion_clip))
-                
-            except Exception as e:
-                logger.error(f"Error procesando video {i}: {e}")
+        # 6. Calcular duración por clip
+        duracion_por_clip = duracion_total / len(clips)
         
-        # 5. Combinar clips (o usar fondo negro si no hay videos)
-        if not clips:
-            video_final = ColorClip((1280, 720), (0, 0, 0), duration=duracion_total)
-        else:
-            video_final = concatenate_videoclips(clips, method="compose")
+        # 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 < 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)])
         
         video_final = video_final.set_audio(audio)
         
-        # 6. Exportar video
-        nombre_archivo = f"video_final_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
+        # 10. Exportar video
+        output_path = f"video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
         video_final.write_videofile(
-            nombre_archivo,
-            fps=24,
+            output_path,
             codec="libx264",
             audio_codec="aac",
-            threads=2,
-            preset='fast'
+            threads=4,
+            preset='ultrafast',
+            fps=24,
+            logger=None
         )
         
-        return nombre_archivo
-    
+        return output_path
+        
     except Exception as e:
-        logger.error(f"Error crítico: {e}")
+        logger.error(f"ERROR: {str(e)}")
         return None
-    
     finally:
         # Limpieza de archivos temporales
         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)
 
-# Interfaz de Gradio (sencilla y funcional)
-with gr.Blocks() as app:
-    gr.Markdown("# 🎬 Generador Automático de Videos")
-    
-    with gr.Row():
-        tema = gr.Textbox(label="Tema del video", placeholder="Ej: 'Historia de la inteligencia artificial'")
-        voz = gr.Dropdown(label="Voz", choices=VOICES, value=VOICES[0])
-        btn = gr.Button("Generar Video", variant="primary")
+# Función para ejecutar la tarea asíncrona con manejo de progreso
+def run_async_task(prompt, custom_script, voz_index, musica=None):
+    for i in range(5):
+        time.sleep(0.5)  # Simular progreso
     
-    salida = gr.Video(label="Resultado")
+    return asyncio.run(crear_video_profesional(prompt, custom_script, voz_index, musica))
+
+# Interfaz profesional
+with gr.Blocks(theme=gr.themes.Soft(), title="Generador de Videos") as app:
+    gr.Markdown("# 🎬 GENERADOR DE VIDEOS CON IA")
     
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### Configuración")
+            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=6
+            )
+            voz = gr.Dropdown(
+                label="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")
+            
+        with gr.Column(scale=2):
+            output = gr.Video(label="Video Resultante", format="mp4")
+            
+            gr.Examples(
+                examples=[
+                    ["Los secretos de las pirámides egipcias", "", 5, None],
+                    ["La inteligencia artificial en medicina", "", 3, None]
+                ],
+                inputs=[prompt, custom_script, voz, musica],
+                label="Ejemplos"
+            )
+
     btn.click(
-        fn=crear_video,
-        inputs=[tema, voz],
-        outputs=salida
+        fn=run_async_task,
+        inputs=[prompt, custom_script, voz, musica],
+        outputs=output
     )
 
 if __name__ == "__main__":