Update app.py

app.py

@@ -1,235 +1,113 @@
-import os
-import re
-import requests
 import gradio as gr
-from moviepy.editor import *
+import asyncio
 import edge_tts
+import requests
 import tempfile
-import logging
+import os
 from datetime import datetime
-import numpy as np
-from sklearn.feature_extraction.text import TfidfVectorizer
-import nltk
-from nltk.tokenize import sent_tokenize
-import random
-from transformers import pipeline
-import torch
-import asyncio
-import nest_asyncio
-
-# Aplicar patch para event loop en entornos como Jupyter o Gradio
-nest_asyncio.apply()
-
-# Configuración inicial
-nltk.download('punkt', quiet=True)
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
-
-# Variables de configuración
-PEXELS_API_KEY = os.getenv("PEXELS_API_KEY")
-MODEL_NAME = "DeepESP/gpt2-spanish"  # Modelo en español
-
-# Función async para obtener voces de edge-tts
-async def get_voices():
-    try:
-        voices = await edge_tts.list_voices()
-        return voices
-    except Exception as e:
-        logger.error(f"Error obteniendo voces: {e}")
-        return []
-
-# Obtener voces sincrónicamente para inicializar
-VOICES = asyncio.get_event_loop().run_until_complete(get_voices())
-
-# Preparar lista segura de nombres de voces
-VOICE_NAMES = [
-    f"{v.get('Name', 'Desconocido')} ({v.get('Gender', 'Desconocido')}, {v.get('LocaleName', 'es-ES')})"
-    for v in VOICES
-]
-
-# Fallback si no se pudieron obtener voces
-if not VOICES:
-    VOICE_NAMES = ["Voz Predeterminada (Femenino, es-ES)"]
-    VOICES = [{'ShortName': 'es-ES-ElviraNeural'}]
-
-def generar_guion_profesional(prompt):
-    try:
-        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=1500,
-            temperature=0.7,
-            top_k=50,
-            top_p=0.95,
-            num_return_sequences=1,
-            truncation=True  # Para evitar warnings y límites
-        )
-        guion = response[0]['generated_text']
-        if len(guion.split()) < 100:
-            raise ValueError("Guion demasiado breve")
-        return guion
-    except Exception as e:
-        logger.error(f"Error generando guion: {str(e)}")
-        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"]
+from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip, CompositeAudioClip
+
+# Voz predeterminada (puedes cambiarla o cargar lista)
+VOCES = [{'ShortName': 'es-ES-ElviraNeural', 'Name': 'Elvira', 'Gender': 'Female'}]
+VOICE_NAMES = [f"{v['Name']} ({v['Gender']})" for v in VOCES]
+
+# Simula función para generar texto según prompt
+def generar_texto(prompt):
+    # Aquí deberías integrar tu generador real, por ahora solo repetimos prompt
+    return f"Este es un texto generado para el tema: {prompt}"
+
+# Simula función para buscar videos (debes conectar con Pexels u otra API)
+def buscar_videos(prompt):
+    # Retorna lista simulada con links a videos (debes poner tu API real)
+    return [
+        {
+            "video_files": [{"link": "https://filesamples.com/samples/video/mp4/sample_640x360.mp4"}],
+            "duration": 10
+        },
+        {
+            "video_files": [{"link": "https://filesamples.com/samples/video/mp4/sample_640x360.mp4"}],
+            "duration": 10
         }
-        categoria = "general"
-        for key in temas:
-            if key in prompt.lower():
-                categoria = key
-                break
-        puntos_clave = temas.get(categoria, ["aspectos importantes", "datos relevantes", "conclusiones"])
-        return f"""
-        ¡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 buscar_videos_avanzado(prompt, guion, num_videos=5):
-    try:
-        oraciones = sent_tokenize(guion)
-        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]
-        palabras_prompt = re.findall(r'\b\w{4,}\b', prompt.lower())
-        todas_palabras = list(set(palabras_clave + palabras_prompt))[:5]
-
-        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=15
-        )
-        videos = response.json().get('videos', [])
-        logger.info(f"Palabras clave usadas: {todas_palabras}")
-        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 de videos: {str(e)}")
-        response = requests.get(
-            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]
-
-async def crear_video_profesional(prompt, custom_script, voz_index, musica=None):
-    voz_archivo = None
-    try:
-        guion = custom_script if custom_script else generar_guion_profesional(prompt)
-        logger.info(f"Guion generado ({len(guion.split())} palabras)")
-
-        voz_seleccionada = VOICES[voz_index]['ShortName'] if VOICES else 'es-ES-ElviraNeural'
-
-        voz_archivo = "voz.mp3"
-        await edge_tts.Communicate(guion, voz_seleccionada).save(voz_archivo)
-        audio = AudioFileClip(voz_archivo)
-        duracion_total = audio.duration
+    ]
 
-        videos_data = buscar_videos_avanzado(prompt, guion)
-        if not videos_data:
-            raise Exception("No se encontraron videos relevantes")
+async def crear_video(prompt, voz_index, musica_path=None):
+    try:
+        texto = generar_texto(prompt)
+        voz_shortname = VOCES[voz_index]['ShortName']
+
+        # Generar audio TTS
+        archivo_audio = "audio.mp3"
+        await edge_tts.Communicate(texto, voz_shortname).save(archivo_audio)
+        audio_clip = AudioFileClip(archivo_audio)
+        duracion_audio = audio_clip.duration
+
+        # Cargar música si se pasa
+        if musica_path:
+            musica_clip = AudioFileClip(musica_path).volumex(0.2)  # Volumen bajo para música
+            musica_clip = musica_clip.subclip(0, duracion_audio)
+            audio_final = CompositeAudioClip([musica_clip, audio_clip])
+        else:
+            audio_final = audio_clip
+
+        # Descargar y preparar videos
+        videos = buscar_videos(prompt)
+        if not videos:
+            return None
 
         clips = []
-        for video in videos_data[:3]:
-            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']
+        for v in videos[:3]:
+            video_url = v['video_files'][0]['link']
             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()
-            clip = VideoFileClip(temp_video.name)
+            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4")
+            for chunk in response.iter_content(chunk_size=1024*1024):
+                temp_file.write(chunk)
+            temp_file.close()
+
+            clip = VideoFileClip(temp_file.name).subclip(0, min(duracion_audio/len(videos), v['duration']))
             clips.append(clip)
 
-        duracion_por_clip = duracion_total / len(clips)
+        video_final = concatenate_videoclips(clips)
+        video_final = video_final.set_audio(audio_final)
 
-        clips_procesados = []
-        for clip in clips:
-            if clip.duration < duracion_por_clip:
-                clip = clip.loop(duration=duracion_por_clip)
-            else:
-                clip = clip.subclip(0, duracion_por_clip)
-            clips_procesados.append(clip)
+        output_filename = f"video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
+        video_final.write_videofile(output_filename, codec="libx264", audio_codec="aac", fps=24)
 
-        video_final = concatenate_videoclips(clips_procesados)
+        # Limpieza
+        audio_clip.close()
+        if musica_path:
+            musica_clip.close()
+        for c in clips:
+            c.close()
+            os.remove(c.filename)
+        os.remove(archivo_audio)
 
-        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)])
+        return output_filename
 
-        video_final = video_final.set_audio(audio)
+    except Exception as e:
+        return f"Error: {e}"
 
-        output_path = f"video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
-        video_final.write_videofile(
-            output_path,
-            codec="libx264",
-            audio_codec="aac",
-            threads=2,
-            preset='fast',
-            fps=24
-        )
+def run_crear_video(prompt, voz_nombre, musica_file):
+    try:
+        voz_index = VOICE_NAMES.index(voz_nombre)
+    except ValueError:
+        voz_index = 0
 
-        return output_path
+    musica_path = musica_file.name if musica_file else None
+    return asyncio.run(crear_video(prompt, voz_index, musica_path))
 
-    except Exception as e:
-        logger.error(f"ERROR: {str(e)}")
-        return None
 
-    finally:
-        if voz_archivo and os.path.exists(voz_archivo):
-            os.remove(voz_archivo)
+with gr.Blocks(title="Generador de Video con TTS y Música de Fondo") as demo:
+    with gr.Row():
+        with gr.Column():
+            prompt = gr.Textbox(label="Tema del video", lines=2)
+            voz = gr.Dropdown(VOICE_NAMES, label="Voz", value=VOICE_NAMES[0])
+            musica = gr.File(label="Sube música de fondo (opcional, mp3/wav)", file_types=[".mp3", ".wav"])
+            btn = gr.Button("Generar Video")
+        with gr.Column():
+            salida = gr.Video(label="Video generado")
 
-# Interfaz Gradio
+    btn.click(run_crear_video, inputs=[prompt, voz, musica], outputs=salida)
 
-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 de la antigua Grecia'")
-            custom_script = gr.TextArea(
-                label="Guion personalizado (opcional)",
-                placeholder="Pega aquí tu propio guion completo...",
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)