Update app.py

app.py

@@ -7,7 +7,6 @@ from datetime import datetime
 from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip, CompositeAudioClip
 import edge_tts
 import gradio as gr
-
 from transformers import GPT2Tokenizer, GPT2LMHeadModel
 import torch
 
@@ -17,77 +16,96 @@ logger = logging.getLogger(__name__)
 
 # --- 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"
+MODEL_NAME = "gpt2-small" # Puedes cambiar a "gpt2" si tienes más RAM/GPU.
 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
+    logger.info(f"Modelo GPT-2 '{MODEL_NAME}' cargado exitosamente.")
 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
+    logger.error(f"Error al cargar el modelo GPT-2 '{MODEL_NAME}': {e}")
+    # En un entorno de producción, podrías querer un fallback o salir aquí.
+    tokenizer = None
+    model = None
 
 # --- Funciones de Utilidad ---
 
-def generate_script(prompt, max_length=300):
+def generate_script(prompt, max_length=250): # Max_length ajustado ligeramente
     """
-    Genera un guion usando el modelo GPT-2 basado en un prompt dado.
-    Ajustamos truncation a True y añadimos un token de padding.
+    Genera un guion usando el modelo GPT-2.
     """
+    if not tokenizer or not model:
+        logger.error("Modelo GPT-2 no disponible para generar guion.")
+        return "Lo siento, el generador de guiones no está disponible en este momento."
+
     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
+    try:
+        inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512)
+        # Mover a GPU si está disponible
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+        model.to(device)
+
+        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,
+                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]}...")
+        return text
+    except Exception as e:
+        logger.error(f"Error durante la generación del guion: {e}")
+        return "No se pudo generar el guion. Intenta con otro prompt o un guion propio."
 
 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]}...")
+    logger.info(f"Generando audio TTS para: '{text[:100]}...'")
     try:
         communicate = edge_tts.Communicate(text, voice)
         await communicate.save(output_path)
-        logger.info(f"Audio guardado en {output_path}")
+        logger.info(f"Audio TTS guardado en {output_path}")
     except Exception as e:
         logger.error(f"Error al generar audio TTS: {e}")
-        raise # Volver a lanzar la excepción para que el llamador la maneje
+        raise # Relanzar la excepción para manejo en la función principal
 
 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}")
+    if not url: # Manejar URL vacía
+        return None
+    logger.info(f"Intentando descargar video de ejemplo desde: {url}")
+    tmp = None # Inicializar tmp para asegurar que exista en caso de error
     try:
         tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4")
-        response = requests.get(url, stream=True, timeout=10) # Añadir timeout
+        response = requests.get(url, stream=True, timeout=15) # Aumentar 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)
+
+        # Guardar el contenido en chunks
+        for chunk in response.iter_content(chunk_size=8192): # Chunk más pequeño
+            if chunk: # Filtrar chunks vacíos
+                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):
+        logger.error(f"Error de red/HTTP al descargar el video {url}: {e}")
+        if tmp and os.path.exists(tmp.name):
             os.remove(tmp.name)
-        return None # Retorna None si la descarga falla
+        return None
     except Exception as e:
         logger.error(f"Error inesperado al descargar video {url}: {e}")
-        if os.path.exists(tmp.name):
+        if tmp and os.path.exists(tmp.name):
             os.remove(tmp.name)
         return None
 
@@ -97,72 +115,89 @@ def loop_audio_to_length(audio_clip, target_duration):
     """
     if audio_clip.duration >= target_duration:
         return audio_clip.subclip(0, target_duration)
-    loops = int(target_duration // audio_clip.duration) + 1
+    
+    loops = int(target_duration / audio_clip.duration) + 1
     audios = [audio_clip] * loops
-    concatenated = concatenate_videoclips(audios) # No necesitas method="compose" para audio
+    concatenated = concatenate_videoclips(audios)
     return concatenated.subclip(0, target_duration)
 
 # --- Función Principal de Creación de Video ---
 
-def crear_video(prompt, musica_url=None):
+def crear_video(prompt_type, input_text, musica_url=None):
     """
-    Crea un video combinando un guion generado, voz TTS, clips de video y música de fondo.
+    Crea un video combinando un guion (generado o provisto), voz TTS, clips de video y música de fondo.
     """
-    logger.info(f"Iniciando creación de video para el prompt: '{prompt}'")
+    logger.info(f"Iniciando creación de video. Tipo de prompt: {prompt_type}")
+    guion = ""
+    if prompt_type == "Generar Guion con IA":
+        guion = generate_script(input_text)
+        if not guion or guion == "No se pudo generar el guion. Intenta con otro prompt o un guion propio.":
+            raise ValueError(guion) # Propagar el error para Gradio
+    else: # prompt_type == "Usar Mi Guion"
+        guion = input_text
+        if not guion.strip():
+            raise ValueError("Por favor, introduce tu guion.")
+
+    if not guion.strip():
+        raise ValueError("El guion está vacío. No se puede proceder.")
+
     temp_files = [] # Para llevar un registro de archivos temporales a limpiar
+    clips = [] # Lista para almacenar los objetos VideoFileClip
 
     try:
-        # 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")
+        # 1. Generar audio TTS
+        voz_archivo = os.path.join(tempfile.gettempdir(), f"voz_temp_{os.getpid()}.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.
+        # 2. Descargar videos de ejemplo (¡REEMPLAZA ESTAS URLs CON TUS FUENTES REALES!)
+        # Sugerencia: Busca videos de stock gratuitos o crea un sistema para buscar por palabras clave
         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"
+            "https://sample-videos.com/video123/mp4/720/big_buck_bunny_720p_1mb.mp4",
+            "https://test-videos.co.uk/vids/bigbuckbunny/mp4/720/big_buck_bunny_720p_1mb.mp4" # Otra URL de ejemplo
         ]
         
-        clips = []
-        video_download_success = False
-        for i, url in enumerate(video_urls):
+        valid_clip_found = False
+        for url in 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
+                    # Limitar duración del clip individual para que no sea excesivo
+                    clip = VideoFileClip(video_path).subclip(0, min(15, VideoFileClip(video_path).duration)) 
+                    if clip.duration > 1: # Asegurarse de que el clip tenga una duración mínima
+                        clips.append(clip)
+                        valid_clip_found = True
+                    else:
+                        logger.warning(f"Clip de video muy corto ({clip.duration:.2f}s) de {url}, omitiendo.")
+                        clip.close() # Cerrar clip si no se va a usar
                 except Exception as e:
-                    logger.warning(f"No se pudo cargar el clip de video {video_path}: {e}")
+                    logger.warning(f"No se pudo cargar o procesar el clip de video {video_path} de {url}: {e}")
             else:
                 logger.warning(f"No se pudo descargar el video de la URL: {url}")
         
-        if not video_download_success or not clips:
+        if not valid_clip_found 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.")
+            raise ValueError("No se encontraron clips de video válidos. Asegúrate de que las URLs sean correctas y accesibles.")
 
-        # 4. Concatenar videos
-        video_final = concatenate_videoclips(clips, method="compose")
-        
-        # 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)
+        # 3. Concatenar videos
+        video_base = concatenate_videoclips(clips, method="compose")
+        logger.info(f"Video base concatenado, duración: {video_base.duration:.2f}s")
+
+        # Asegurarse de que el video base sea al menos tan largo como el audio TTS
+        if video_base.duration < audio_tts.duration:
+            logger.info(f"Duración del video ({video_base.duration:.2f}s) es menor que la del audio TTS ({audio_tts.duration:.2f}s). Repitiendo video.")
+            num_repeats = int(audio_tts.duration / video_base.duration) + 1
+            repeated_clips = [video_base] * num_repeats
+            video_base = concatenate_videoclips(repeated_clips, method="compose") # No subclip aquí aún
 
+        # El video final tendrá la duración del audio combinado
+        final_video_duration = audio_tts.duration
 
-        # 5. Música de fondo en loop si está definida
+        # 4. 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)
@@ -170,35 +205,36 @@ def crear_video(prompt, musica_url=None):
                 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)
+                    # Loop música hasta la duración final del video
+                    musica_loop = loop_audio_to_length(musica_audio, final_video_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)])
+                    # Asegurarse de que el audio TTS tenga la duración correcta antes de mezclar
+                    mezcla_audio = CompositeAudioClip([musica_loop.volumex(0.3), audio_tts.set_duration(final_video_duration).volumex(1.0)])
+                    logger.info("Música de fondo añadida y mezclada.")
                 except Exception as e:
-                    logger.warning(f"No se pudo procesar la música de fondo: {e}. Se usará solo la voz.")
+                    logger.warning(f"No se pudo procesar la música de fondo de {musica_url}: {e}. Se usará solo la voz.")
             else:
-                logger.warning("No se pudo descargar la música. Se usará solo la voz.")
+                logger.warning(f"No se pudo descargar la música de {musica_url}. Se usará solo la voz.")
         
-        # 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)
+        # 5. Asignar audio al video y ajustar duración del video final
+        video_final = video_base.set_audio(mezcla_audio).subclip(0, final_video_duration)
+        logger.info(f"Video final configurado con audio. Duración final: {video_final.duration:.2f}s")
 
-
-        # 7. Guardar video final
+        # 6. 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
+        video_final.write_videofile(output_path, fps=24, threads=4, logger=None, preset="medium", codec="libx264")
 
         logger.info(f"Video generado exitosamente en: {output_path}")
         return output_path
 
     except Exception as e:
         logger.error(f"Error general en la creación del video: {e}", exc_info=True)
-        return None
+        raise e # Re-lanzar para que Gradio lo muestre
     finally:
-        # 8. Limpiar archivos temporales
+        # 7. Limpiar archivos temporales
         for f in temp_files:
             if os.path.exists(f):
                 try:
@@ -216,67 +252,105 @@ def crear_video(prompt, musica_url=None):
             musica_audio.close()
         if 'video_final' in locals() and video_final:
             video_final.close()
+        if 'video_base' in locals() and video_base:
+            video_base.close()
 
 
-def run_app(prompt, musica_url):
+def run_app(prompt_type, prompt_ia, prompt_manual, 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
+    input_text = ""
+    if prompt_type == "Generar Guion con IA":
+        input_text = prompt_ia
+        if not input_text.strip():
+            raise gr.Error("Por favor, introduce un tema para generar el guion.")
+    else: # Usar Mi Guion
+        input_text = prompt_manual
+        if not input_text.strip():
+            raise gr.Error("Por favor, introduce tu guion.")
+
+    logger.info(f"Solicitud recibida: Tipo='{prompt_type}', Input='{input_text[:50]}...', Música='{musica_url}'")
 
     try:
-        video_path = crear_video(prompt, musica_url if musica_url.strip() else None)
+        video_path = crear_video(prompt_type, input_text, musica_url if musica_url.strip() else None)
         if video_path:
             logger.info(f"Proceso completado. Video disponible en: {video_path}")
-            return video_path
+            return video_path, gr.update(value="¡Video generado exitosamente!")
         else:
-            gr.Error("Hubo un problema al generar el video. Revisa los logs para más detalles.")
-            return None
+            # Esto se manejará mejor por las excepciones lanzadas en crear_video
+            raise gr.Error("Hubo un problema desconocido al generar el video. Revisa los logs.")
+    except ValueError as ve:
+        logger.error(f"Error de validación: {ve}")
+        return None, gr.update(value=f"Error: {ve}", text_color="red")
     except Exception as e:
         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
+        return None, gr.update(value=f"Ocurrió un error grave: {e}. Por favor, inténtalo de nuevo.", text_color="red")
 
 # --- Interfaz de Gradio ---
 with gr.Blocks() as app:
     gr.Markdown("""
-    ### 🎬 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.
+    ### 🎬 Generador de Video Inteligente 🚀
+    Crea videos con guiones generados por IA o propios, voz automática 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")
     
-    boton = gr.Button("🚀 Generar Video")
-    
-    # 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)
+    with gr.Tab("Generar Video"):
+        with gr.Row():
+            prompt_type = gr.Radio(
+                ["Generar Guion con IA", "Usar Mi Guion"], 
+                label="Método de Guion", 
+                value="Generar Guion con IA"
+            )
+        
+        with gr.Column(visible=True) as ia_guion_column:
+            prompt_ia = gr.Textbox(
+                label="Tema para Generar Guion (con IA)", 
+                lines=2, 
+                placeholder="Ej: Las maravillas del universo y las estrellas."
+            )
+        
+        with gr.Column(visible=False) as manual_guion_column:
+            prompt_manual = gr.Textbox(
+                label="Introduce Tu Guion Propio", 
+                lines=5, 
+                placeholder="Ej: Hola a todos, hoy hablaremos de un tema fascinante..."
+            )
+        
+        musica_input = gr.Textbox(
+            label="URL de Música de Fondo (opcional, MP3 recomendado)", 
+            placeholder="Ej: https://www.soundhelix.com/examples/mp3/SoundHelix-Song-1.mp3"
+        )
+        
+        boton = gr.Button("✨ Generar Video")
+        
+        with gr.Column():
+            salida_video = gr.Video(label="Video Generado", interactive=False)
+            estado_mensaje = gr.Textbox(label="Estado del Proceso", interactive=False, value="")
+
+    # Lógica para mostrar/ocultar columnas según el tipo de prompt
+    prompt_type.change(
+        fn=lambda value: (gr.update(visible=value == "Generar Guion con IA"), 
+                          gr.update(visible=value == "Usar Mi Guion")),
+        inputs=prompt_type,
+        outputs=[ia_guion_column, manual_guion_column]
+    )
 
     # 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
+        fn=lambda: (None, gr.update(value="Iniciando generación... Por favor, espera, esto puede tardar un minuto o más.")),
+        outputs=[salida_video, estado_mensaje],
+        queue=False # Desactivar cola para feedback inmediato
     ).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
+        inputs=[prompt_type, prompt_ia, prompt_manual, musica_input],
+        outputs=[salida_video, estado_mensaje]
     )
-    # 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)
-
 
+    # Limpiar el mensaje de estado cuando el usuario cambia las entradas
+    prompt_ia.change(fn=lambda: gr.update(value=""), outputs=estado_mensaje, queue=False)
+    prompt_manual.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__":
-    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
+    logger.info("Iniciando aplicación Gradio para Hugging Face Spaces...")
+    app.launch(server_name="0.0.0.0", server_port=7860, share=False) # 'share=True' para un enlace público temporal (solo para pruebas)