Update app.py

app.py

@@ -2,261 +2,281 @@ import os
 import asyncio
 import logging
 import tempfile
-import time
-import shutil
-from datetime import datetime, timedelta
-from moviepy.config import change_settings
-
-# Configura ImageMagick antes de otros imports
-change_settings({"IMAGEMAGICK_BINARY": "/usr/bin/convert"})
-
-# Ahora importa los componentes de MoviePy
-from moviepy.editor import VideoFileClip, AudioFileClip, CompositeAudioClip, ColorClip, TextClip, CompositeVideoClip, concatenate_audioclips
+import requests
+from datetime import datetime
+from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip, CompositeAudioClip
 import edge_tts
 import gradio as gr
 
-# Configuración avanzada de logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.FileHandler("video_generator.log"),
-        logging.StreamHandler()
-    ]
-)
+from transformers import GPT2Tokenizer, GPT2LMHeadModel
+import torch
+
+# --- Configuración de Logging ---
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# Directorio temporal personalizado con limpieza automática
-TEMP_DIR = "temp_media"
-os.makedirs(TEMP_DIR, exist_ok=True)
+# --- Inicialización de Tokenizer y Modelo GPT-2 ---
+# Especificamos un modelo más pequeño para una generación más rápida y menos exigente en recursos
+# Puedes cambiarlo a "gpt2" si tienes suficiente RAM y GPU
+MODEL_NAME = "gpt2-small" # O "gpt2"
+try:
+    tokenizer = GPT2Tokenizer.from_pretrained(MODEL_NAME)
+    model = GPT2LMHeadModel.from_pretrained(MODEL_NAME).eval()
+    # Añadir un token de padding si el modelo no tiene uno (común en GPT-2)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+except Exception as e:
+    logger.error(f"Error al cargar el modelo GPT-2: {e}")
+    # Considerar una salida de emergencia o un mensaje al usuario si esto falla
 
-def clean_old_files():
-    """Elimina archivos temporales con más de 24 horas"""
-    now = time.time()
-    cutoff = now - (24 * 3600)
-    
-    for filename in os.listdir(TEMP_DIR):
-        file_path = os.path.join(TEMP_DIR, filename)
-        if os.path.isfile(file_path):
-            file_time = os.path.getmtime(file_path)
-            if file_time < cutoff:
-                try:
-                    os.remove(file_path)
-                    logger.info(f"Eliminado archivo antiguo: {filename}")
-                except Exception as e:
-                    logger.error(f"Error al eliminar {filename}: {e}")
+# --- Funciones de Utilidad ---
 
-async def text_to_speech(text, voice="es-ES-ElviraNeural"):
-    """Convierte texto a voz y guarda en archivo temporal"""
-    clean_old_files()
-    output_path = os.path.join(TEMP_DIR, f"tts_{datetime.now().strftime('%Y%m%d%H%M%S')}.mp3")
-    
+def generate_script(prompt, max_length=300):
+    """
+    Genera un guion usando el modelo GPT-2 basado en un prompt dado.
+    Ajustamos truncation a True y añadimos un token de padding.
+    """
+    logger.info("Generando guion con GPT-2...")
+    inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512) # Truncar para evitar errores
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_length=max_length,
+            do_sample=True,
+            top_p=0.95,
+            top_k=60,
+            temperature=0.9,
+            pad_token_id=tokenizer.pad_token_id, # Usar el token de padding
+            eos_token_id=tokenizer.eos_token_id
+        )
+    text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    logger.info(f"Guion generado (longitud: {len(text)} caracteres): {text[:200]}...") # Mostrar solo los primeros 200 chars
+    return text
+
+async def text_to_speech(text, voice="es-ES-ElviraNeural", output_path="voz.mp3"):
+    """
+    Convierte texto a voz usando Edge TTS.
+    """
+    logger.info(f"Generando audio TTS para: {text[:100]}...")
     try:
-        logger.info(f"Generando TTS para texto de {len(text)} caracteres")
         communicate = edge_tts.Communicate(text, voice)
         await communicate.save(output_path)
-        return output_path
+        logger.info(f"Audio guardado en {output_path}")
     except Exception as e:
-        logger.error(f"Error en TTS: {e}")
-        raise
+        logger.error(f"Error al generar audio TTS: {e}")
+        raise # Volver a lanzar la excepción para que el llamador la maneje
 
-def create_audio_loop(audio_path, target_duration):
-    """Crea un loop de audio hasta alcanzar la duración objetivo"""
+def download_video_sample(url):
+    """
+    Descarga un archivo de video desde una URL a un archivo temporal.
+    """
+    logger.info(f"Descargando video de ejemplo desde: {url}")
     try:
-        audio = AudioFileClip(audio_path)
-        if audio.duration >= target_duration:
-            return audio.subclip(0, target_duration)
-        
-        loops_needed = int(target_duration // audio.duration) + 1
-        clips = [audio] * loops_needed
-        looped_audio = concatenate_audioclips(clips).subclip(0, target_duration)
-        return looped_audio
+        tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4")
+        response = requests.get(url, stream=True, timeout=10) # Añadir timeout
+        response.raise_for_status() # Lanza un error para códigos de estado HTTP malos
+        for chunk in response.iter_content(chunk_size=1024 * 1024):
+            tmp.write(chunk)
+        tmp.close()
+        logger.info(f"Video descargado a: {tmp.name}")
+        return tmp.name
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Error al descargar el video {url}: {e}")
+        if os.path.exists(tmp.name):
+            os.remove(tmp.name)
+        return None # Retorna None si la descarga falla
     except Exception as e:
-        logger.error(f"Error al crear loop de audio: {e}")
-        raise
+        logger.error(f"Error inesperado al descargar video {url}: {e}")
+        if os.path.exists(tmp.name):
+            os.remove(tmp.name)
+        return None
+
+def loop_audio_to_length(audio_clip, target_duration):
+    """
+    Buclea un clip de audio hasta una duración objetivo.
+    """
+    if audio_clip.duration >= target_duration:
+        return audio_clip.subclip(0, target_duration)
+    loops = int(target_duration // audio_clip.duration) + 1
+    audios = [audio_clip] * loops
+    concatenated = concatenate_videoclips(audios) # No necesitas method="compose" para audio
+    return concatenated.subclip(0, target_duration)
+
+# --- Función Principal de Creación de Video ---
+
+def crear_video(prompt, musica_url=None):
+    """
+    Crea un video combinando un guion generado, voz TTS, clips de video y música de fondo.
+    """
+    logger.info(f"Iniciando creación de video para el prompt: '{prompt}'")
+    temp_files = [] # Para llevar un registro de archivos temporales a limpiar
 
-def create_video_with_text(text, duration, size=(1280, 720)):
-    """Crea un video simple con texto centrado"""
     try:
-        # Fondo del video
-        bg_clip = ColorClip(size, color=(30, 30, 30), duration=duration)
-        
-        # Configuración segura para TextClip
-        temp_txt = os.path.join(TEMP_DIR, f"temp_text_{datetime.now().strftime('%Y%m%d%H%M%S')}.txt")
-        with open(temp_txt, 'w', encoding='utf-8') as f:
-            f.write(text)
+        # 1. Generar guion
+        guion = generate_script(prompt, max_length=200) # Ajusta max_length si quieres guiones más largos
+
+        # 2. Generar audio TTS
+        voz_archivo = os.path.join(tempfile.gettempdir(), "voz_temp.mp3")
+        temp_files.append(voz_archivo)
+        asyncio.run(text_to_speech(guion, output_path=voz_archivo))
+        audio_tts = AudioFileClip(voz_archivo)
+
+        # 3. Descargar videos de ejemplo
+        # ¡IMPORTANTE! Aquí debes reemplazar estas URLs con URLs de videos reales y variados
+        # o implementar una lógica para buscar y descargar videos relevantes.
+        # Por ahora, usaré URLs de ejemplo distintas para simular variedad.
+        video_urls = [
+            "https://www.learningcontainer.com/wp-content/uploads/2020/05/sample-mp4-file.mp4",
+            "https://file-examples.com/storage/fe2c91b5c46522c0734a74a/2017/04/file_example_MP4_480_1_5MG.mp4",
+            "https://sample-videos.com/video123/mp4/720/big_buck_bunny_720p_1mb.mp4"
+        ]
         
-        # Texto con ajuste automático de tamaño
-        text_clip = TextClip(
-            txt=text,
-            fontsize=28,
-            color='white',
-            font='Arial-Bold',
-            size=(size[0]-100, size[1]-100),
-            method='caption',
-            align='center'
-        ).set_position('center').set_duration(duration)
+        clips = []
+        video_download_success = False
+        for i, url in enumerate(video_urls):
+            video_path = download_video_sample(url)
+            if video_path:
+                temp_files.append(video_path)
+                try:
+                    clip = VideoFileClip(video_path).subclip(0, min(10, VideoFileClip(video_path).duration)) # máximo 10 segundos o duración real
+                    clips.append(clip)
+                    video_download_success = True
+                except Exception as e:
+                    logger.warning(f"No se pudo cargar el clip de video {video_path}: {e}")
+            else:
+                logger.warning(f"No se pudo descargar el video de la URL: {url}")
         
-        video = CompositeVideoClip([bg_clip, text_clip])
+        if not video_download_success or not clips:
+            logger.error("No se pudieron obtener clips de video válidos. Abortando creación de video.")
+            raise ValueError("No hay clips de video disponibles para crear el video.")
+
+        # 4. Concatenar videos
+        video_final = concatenate_videoclips(clips, method="compose")
         
-        # Eliminar archivo temporal de texto
-        os.remove(temp_txt)
+        # Asegurarse de que el video sea al menos tan largo como el audio TTS si es posible
+        if video_final.duration < audio_tts.duration:
+            logger.info("Duración del video es menor que la del audio. Intentando extender el video.")
+            # Repetir el video si es necesario, o al menos el último clip
+            num_repeats = int(audio_tts.duration / video_final.duration) + 1
+            repeated_clips = [video_final] * num_repeats
+            video_final = concatenate_videoclips(repeated_clips, method="compose").subclip(0, audio_tts.duration)
+
+
+        # 5. Música de fondo en loop si está definida
+        mezcla_audio = audio_tts # Por defecto, solo la voz
+        if musica_url and musica_url.strip():
+            musica_path = download_video_sample(musica_url)
+            if musica_path:
+                temp_files.append(musica_path)
+                try:
+                    musica_audio = AudioFileClip(musica_path)
+                    # Loop música a duración del video final
+                    musica_loop = loop_audio_to_length(musica_audio, video_final.duration)
+                    # Mezclar audio TTS y música (TTS al 100%, música al 30%)
+                    mezcla_audio = CompositeAudioClip([musica_loop.volumex(0.3), audio_tts.set_duration(video_final.duration).volumex(1.0)])
+                except Exception as e:
+                    logger.warning(f"No se pudo procesar la música de fondo: {e}. Se usará solo la voz.")
+            else:
+                logger.warning("No se pudo descargar la música. Se usará solo la voz.")
         
-        return video
+        # 6. Asignar audio al video y ajustar duración del video a la duración del audio TTS
+        # Es crucial que el video tenga al menos la misma duración que el audio combinado.
+        video_final = video_final.set_audio(mezcla_audio).subclip(0, mezcla_audio.duration)
+
+
+        # 7. Guardar video final
+        output_dir = "generated_videos"
+        os.makedirs(output_dir, exist_ok=True)
+        output_path = os.path.join(output_dir, f"video_output_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4")
+        logger.info(f"Escribiendo video final a: {output_path}")
+        video_final.write_videofile(output_path, fps=24, threads=4, logger=None, preset="medium") # Mejorar preset para calidad
+
+        logger.info(f"Video generado exitosamente en: {output_path}")
+        return output_path
+
     except Exception as e:
-        logger.error(f"Error al crear video con texto: {e}")
-        if os.path.exists(temp_txt):
-            os.remove(temp_txt)
-        raise
+        logger.error(f"Error general en la creación del video: {e}", exc_info=True)
+        return None
+    finally:
+        # 8. Limpiar archivos temporales
+        for f in temp_files:
+            if os.path.exists(f):
+                try:
+                    os.remove(f)
+                    logger.info(f"Archivo temporal eliminado: {f}")
+                except Exception as e:
+                    logger.warning(f"No se pudo eliminar el archivo temporal {f}: {e}")
+        # Cerrar los clips de moviepy explícitamente para liberar recursos
+        for clip in clips:
+            if clip:
+                clip.close()
+        if 'audio_tts' in locals() and audio_tts:
+            audio_tts.close()
+        if 'musica_audio' in locals() and musica_audio:
+            musica_audio.close()
+        if 'video_final' in locals() and video_final:
+            video_final.close()
+
+
+def run_app(prompt, musica_url):
+    """
+    Función envoltorio para Gradio que maneja la ejecución y los errores.
+    """
+    logger.info(f"Solicitud recibida en run_app con prompt: '{prompt}', musica_url: '{musica_url}'")
+    if not prompt.strip():
+        gr.Warning("Por favor, introduce un tema para generar el guion.")
+        return None
 
-async def generate_video_content(text, background_music=None, use_tts=True):
-    """Función principal que genera el contenido del video"""
     try:
-        clean_old_files()
-        
-        # 1. Procesar audio principal
-        if use_tts:
-            voice_path = await text_to_speech(text)
-            main_audio = AudioFileClip(voice_path)
+        video_path = crear_video(prompt, musica_url if musica_url.strip() else None)
+        if video_path:
+            logger.info(f"Proceso completado. Video disponible en: {video_path}")
+            return video_path
         else:
-            # Si no usamos TTS, creamos un audio silencioso de la duración estimada
-            estimated_duration = max(5, len(text.split()) / 3)  # Estimación basada en palabras
-            main_audio = AudioFileClip(lambda t: 0, duration=estimated_duration)
-        
-        duration = main_audio.duration
-        
-        # 2. Procesar música de fondo
-        final_audio = main_audio
-        if background_music:
-            try:
-                bg_music_loop = create_audio_loop(background_music, duration).volumex(0.2)
-                final_audio = CompositeAudioClip([bg_music_loop, main_audio])
-            except Exception as e:
-                logger.error(f"Error al procesar música de fondo, continuando sin ella: {e}")
-        
-        # 3. Crear video
-        video_clip = create_video_with_text(text, duration)
-        video_clip = video_clip.set_audio(final_audio)
-        
-        # 4. Guardar resultado
-        output_path = os.path.join(TEMP_DIR, f"video_{datetime.now().strftime('%Y%m%d%H%M%S')}.mp4")
-        video_clip.write_videofile(
-            output_path,
-            fps=24,
-            threads=4,
-            codec='libx264',
-            audio_codec='aac',
-            preset='fast',
-            logger=None
-        )
-        
-        return output_path
+            gr.Error("Hubo un problema al generar el video. Revisa los logs para más detalles.")
+            return None
     except Exception as e:
-        logger.error(f"Error en generate_video_content: {e}")
-        raise
-    finally:
-        # Cerrar todos los clips para liberar recursos
-        if 'main_audio' in locals():
-            main_audio.close()
-        if 'bg_music_loop' in locals():
-            bg_music_loop.close()
-        if 'video_clip' in locals():
-            video_clip.close()
+        logger.error(f"Error inesperado al ejecutar la aplicación: {e}", exc_info=True)
+        gr.Error(f"Ocurrió un error: {e}. Por favor, inténtalo de nuevo.")
+        return None
 
-# Interfaz Gradio mejorada
-with gr.Blocks(title="Generador de Videos Avanzado", theme="soft") as app:
+# --- Interfaz de Gradio ---
+with gr.Blocks() as app:
     gr.Markdown("""
-    # 🎥 Generador de Videos Automático
-    Crea videos con voz sintetizada y música de fondo
+    ### 🎬 Generador de Video con IA
+    Introduce un tema, y la IA generará un guion, lo convertirá a voz, le añadirá videos de ejemplo y música de fondo.
     """)
+    with gr.Row():
+        prompt_input = gr.Textbox(label="Introduce el tema para generar el guion", lines=3, placeholder="Ej: Las maravillas de la inteligencia artificial y su futuro.")
+        musica_input = gr.Textbox(label="URL de Música de Fondo (opcional)", placeholder="Ej: https://www.soundhelix.com/examples/mp3/SoundHelix-Song-1.mp3")
     
-    with gr.Tab("Configuración Principal"):
-        with gr.Row():
-            with gr.Column():
-                text_input = gr.Textbox(
-                    label="Texto del Video",
-                    placeholder="Escribe aquí el contenido de tu video...",
-                    lines=5,
-                    max_lines=20
-                )
-                
-                with gr.Accordion("Opciones Avanzadas", open=False):
-                    use_tts = gr.Checkbox(
-                        label="Usar Texto a Voz (TTS)",
-                        value=True
-                    )
-                    voice_selector = gr.Dropdown(
-                        label="Voz TTS",
-                        choices=["es-ES-ElviraNeural", "es-MX-DaliaNeural", "es-US-AlonsoNeural"],
-                        value="es-ES-ElviraNeural",
-                        visible=True
-                    )
-                    
-                    bg_music = gr.Audio(
-                        label="Música de Fondo",
-                        type="filepath",
-                        sources=["upload"],
-                        format="mp3"
-                    )
-                
-                generate_btn = gr.Button("Generar Video", variant="primary")
-            
-            with gr.Column():
-                video_output = gr.Video(
-                    label="Video Resultante",
-                    format="mp4",
-                    interactive=False
-                )
-                status_output = gr.Textbox(
-                    label="Estado",
-                    interactive=False
-                )
+    boton = gr.Button("🚀 Generar Video")
     
-    # Lógica para mostrar/ocultar selector de voz
-    use_tts.change(
-        fn=lambda x: gr.Dropdown(visible=x),
-        inputs=use_tts,
-        outputs=voice_selector
-    )
-    
-    # Función principal de generación
-    def generate_video(text, use_tts, voice, bg_music):
-        try:
-            if not text.strip():
-                raise ValueError("Por favor ingresa un texto para el video")
-            
-            # Limpieza inicial
-            clean_old_files()
-            
-            # Generación del video
-            video_path = asyncio.run(
-                generate_video_content(
-                    text=text,
-                    use_tts=use_tts,
-                    background_music=bg_music
-                )
-            )
-            
-            return video_path, "✅ Video generado con éxito"
-        except Exception as e:
-            logger.error(f"Error en la generación: {str(e)}")
-            return None, f"❌ Error: {str(e)}"
-    
-    generate_btn.click(
-        fn=generate_video,
-        inputs=[text_input, use_tts, voice_selector, bg_music],
-        outputs=[video_output, status_output]
+    # Usamos gr.Column para organizar mejor la salida y mensajes
+    with gr.Column():
+        salida_video = gr.Video(label="Video Generado", interactive=False)
+        estado_mensaje = gr.Textbox(label="Estado", interactive=False, visible=True)
+
+    # Conectar el botón a la función run_app
+    # Añadimos un paso intermedio para actualizar el estado mientras se procesa
+    boton.click(
+        fn=lambda: gr.update(value="Generando video... Por favor, espera."), 
+        outputs=estado_mensaje, 
+        queue=False
+    ).then(
+        fn=run_app,
+        inputs=[prompt_input, musica_input],
+        outputs=salida_video
+    ).then(
+        fn=lambda: gr.update(value="¡Video generado exitosamente!"),
+        outputs=estado_mensaje,
+        queue=False
     )
+    # Resetear el mensaje de estado si el usuario cambia el prompt
+    prompt_input.change(fn=lambda: gr.update(value=""), outputs=estado_mensaje, queue=False)
+    musica_input.change(fn=lambda: gr.update(value=""), outputs=estado_mensaje, queue=False)
+
 
 if __name__ == "__main__":
-    # Limpieza inicial de archivos antiguos
-    clean_old_files()
-    
-    # Configuración del servidor
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        show_error=True,
-        share=False,
-        favicon_path=None
-    )
+    logger.info("Iniciando aplicación Gradio...")
+    app.launch(server_name="0.0.0.0", server_port=7860, share=False) # share=True si quieres un enlace público