Update app.py

app.py

@@ -10,13 +10,22 @@ import gradio as gr
 from transformers import GPT2Tokenizer, GPT2LMHeadModel
 import torch
 
+# --- Importar la librería de Pexels ---
+from pexels_api import API # ¡Asegúrate de instalarla: pip install pexels-api!
+
 # --- Configuración de Logging ---
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
+# --- Clave API de Pexels ---
+# IMPORTANTE: No uses tu clave API directamente aquí en un repositorio público.
+# Lo ideal es cargarla desde una variable de entorno o un archivo de configuración SEGURO.
+# Para Hugging Face Spaces, puedes añadirla como un "Secret" llamado PEXELS_API_KEY.
+PEXELS_API_KEY = os.environ.get("PEXELS_API_KEY", "TU_CLAVE_API_PEXELS_AQUI") # Reemplaza "TU_CLAVE_API_PEXELS_AQUI" con tu clave si pruebas localmente sin variables de entorno
+pexels_api = API(PEXELS_API_KEY)
+
 # --- 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
-MODEL_NAME = "gpt2-small" # Puedes cambiar a "gpt2" si tienes más RAM/GPU.
+MODEL_NAME = "gpt2-small"
 try:
     tokenizer = GPT2Tokenizer.from_pretrained(MODEL_NAME)
     model = GPT2LMHeadModel.from_pretrained(MODEL_NAME).eval()
@@ -25,16 +34,12 @@ try:
     logger.info(f"Modelo GPT-2 '{MODEL_NAME}' cargado exitosamente.")
 except Exception as e:
     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=250): # Max_length ajustado ligeramente
-    """
-    Genera un guion usando el modelo GPT-2.
-    """
+def generate_script(prompt, max_length=250):
     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."
@@ -42,7 +47,6 @@ def generate_script(prompt, max_length=250): # Max_length ajustado ligeramente
     logger.info("Generando guion con GPT-2...")
     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)
@@ -66,9 +70,6 @@ def generate_script(prompt, max_length=250): # Max_length ajustado ligeramente
         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]}...'")
     try:
         communicate = edge_tts.Communicate(text, voice)
@@ -76,24 +77,20 @@ async def text_to_speech(text, voice="es-ES-ElviraNeural", output_path="voz.mp3"
         logger.info(f"Audio TTS guardado en {output_path}")
     except Exception as e:
         logger.error(f"Error al generar audio TTS: {e}")
-        raise # Relanzar la excepción para manejo en la función principal
+        raise
 
 def download_video_sample(url):
-    """
-    Descarga un archivo de video desde una URL a un archivo temporal.
-    """
-    if not url: # Manejar URL vacía
+    if not url:
         return None
-    logger.info(f"Intentando descargar video de ejemplo desde: {url}")
-    tmp = None # Inicializar tmp para asegurar que exista en caso de error
+    logger.info(f"Intentando descargar video de: {url}")
+    tmp = None
     try:
         tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4")
-        response = requests.get(url, stream=True, timeout=15) # Aumentar timeout
-        response.raise_for_status() # Lanza un error para códigos de estado HTTP malos
+        response = requests.get(url, stream=True, timeout=20) # Aumentar timeout para videos más grandes
+        response.raise_for_status()
 
-        # 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
+        for chunk in response.iter_content(chunk_size=8192):
+            if chunk:
                 tmp.write(chunk)
         tmp.close()
         logger.info(f"Video descargado a: {tmp.name}")
@@ -110,9 +107,6 @@ def download_video_sample(url):
         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)
     
@@ -121,18 +115,69 @@ def loop_audio_to_length(audio_clip, target_duration):
     concatenated = concatenate_videoclips(audios)
     return concatenated.subclip(0, target_duration)
 
+# --- NUEVA FUNCIÓN: Búsqueda de videos en Pexels ---
+def search_pexels_videos(query, num_videos=3, min_duration_sec=5):
+    """
+    Busca videos en Pexels basados en una query y devuelve una lista de URLs de descarga.
+    """
+    if not PEXELS_API_KEY or PEXELS_API_KEY == "TU_CLAVE_API_PEXELS_AQUI":
+        logger.warning("PEXELS_API_KEY no configurada. No se buscarán videos en Pexels.")
+        return []
+
+    logger.info(f"Buscando {num_videos} videos en Pexels para la query: '{query}'")
+    video_urls = []
+    try:
+        # Pexels API para videos: search_videos(query, orientation, size, per_page, page)
+        # La API de Pexels no permite filtrar directamente por duración mínima.
+        # Tendremos que filtrar después de obtener los resultados.
+        pexels_api.search_videos(query, per_page=num_videos * 3) # Pedimos más por si algunos no cumplen duración
+        videos = pexels_api.get_videos()
+
+        if not videos:
+            logger.warning(f"No se encontraron videos en Pexels para la query: '{query}'")
+            return []
+
+        for video in videos:
+            # Pexels devuelve diferentes archivos de video (quality). Buscamos la más adecuada (p.ej., medium o large).
+            # También verificamos la duración si está disponible en los metadatos de Pexels.
+            if video.get('duration') and video['duration'] < min_duration_sec:
+                logger.info(f"Saltando video {video['id']} de Pexels por duración ({video['duration']}s < {min_duration_sec}s).")
+                continue
+
+            # Buscar la URL de descarga del video de mayor calidad disponible o una calidad aceptable.
+            # Los archivos vienen en una lista 'video_files'.
+            best_quality_url = None
+            for file in video.get('video_files', []):
+                # Preferir calidades como 'hd', 'sd', 'medium', 'large'
+                if file.get('quality') in ['hd', 'sd', 'medium', 'large'] and file.get('link'):
+                    best_quality_url = file['link']
+                    break # Tomar el primero que cumpla
+                elif file.get('link'): # Si no hay calidad específica, tomar cualquier enlace válido
+                    best_quality_url = file['link']
+
+            if best_quality_url:
+                video_urls.append(best_quality_url)
+                if len(video_urls) >= num_videos:
+                    break # Suficientes videos
+            else:
+                logger.warning(f"No se encontró URL de descarga válida para el video Pexels ID: {video.get('id')}")
+
+        logger.info(f"Encontrados {len(video_urls)} URLs de video de Pexels para '{query}'.")
+        return video_urls
+
+    except Exception as e:
+        logger.error(f"Error al buscar videos en Pexels para '{query}': {e}")
+        return []
+
 # --- Función Principal de Creación de Video ---
 
 def crear_video(prompt_type, input_text, musica_url=None):
-    """
-    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. 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
+            raise ValueError(guion)
     else: # prompt_type == "Usar Mi Guion"
         guion = input_text
         if not guion.strip():
@@ -141,8 +186,8 @@ def crear_video(prompt_type, input_text, musica_url=None):
     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
+    temp_files = []
+    clips = []
 
     try:
         # 1. Generar audio TTS
@@ -151,29 +196,34 @@ def crear_video(prompt_type, input_text, musica_url=None):
         asyncio.run(text_to_speech(guion, output_path=voz_archivo))
         audio_tts = AudioFileClip(voz_archivo)
 
-        # 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://test-videos.co.uk/vids/bigbuckbunny/mp4/720/big_buck_bunny_720p_1mb.mp4" # Otra URL de ejemplo
-        ]
-        
+        # 2. Búsqueda y descarga de videos con Pexels
+        # Usamos el guion o el prompt inicial para la búsqueda en Pexels
+        search_query = input_text if prompt_type == "Generar Guion con IA" else guion.split('.')[0] # Usar primera frase del guion
+        pexels_video_urls = search_pexels_videos(search_query, num_videos=4, min_duration_sec=7) # Pedimos 4, min 7s
+
+        # Si Pexels no devuelve nada o falla, podemos tener unas URLs de fallback
+        if not pexels_video_urls:
+            logger.warning("Pexels no devolvió videos. Usando videos de ejemplo de fallback.")
+            pexels_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://test-videos.co.uk/vids/bigbuckbunny/mp4/720/big_buck_bunny_720p_1mb.mp4"
+            ]
+
         valid_clip_found = False
-        for url in video_urls:
+        for url in pexels_video_urls:
             video_path = download_video_sample(url)
             if video_path:
                 temp_files.append(video_path)
                 try:
-                    # 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
+                    clip = VideoFileClip(video_path).subclip(0, min(15, VideoFileClip(video_path).duration))
+                    if clip.duration > 1:
                         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
+                        clip.close()
                 except Exception as e:
                     logger.warning(f"No se pudo cargar o procesar el clip de video {video_path} de {url}: {e}")
             else:
@@ -181,34 +231,29 @@ def crear_video(prompt_type, input_text, musica_url=None):
         
         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 se encontraron clips de video válidos. Asegúrate de que las URLs sean correctas y accesibles.")
+            raise ValueError("No se encontraron clips de video válidos. Asegúrate de que las URLs de Pexels o fallback sean correctas y accesibles.")
 
         # 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
+            video_base = concatenate_videoclips(repeated_clips, method="compose")
 
-        # El video final tendrá la duración del audio combinado
         final_video_duration = audio_tts.duration
 
-        # 4. Música de fondo en loop si está definida
-        mezcla_audio = audio_tts # Por defecto, solo la voz
+        # 4. Música de fondo en loop
+        mezcla_audio = audio_tts
         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 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%)
-                    # 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:
@@ -216,7 +261,7 @@ def crear_video(prompt_type, input_text, musica_url=None):
             else:
                 logger.warning(f"No se pudo descargar la música de {musica_url}. Se usará solo la voz.")
         
-        # 5. Asignar audio al video y ajustar duración del video final
+        # 5. Asignar audio al video y ajustar duración
         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")
 
@@ -232,9 +277,8 @@ def crear_video(prompt_type, input_text, musica_url=None):
 
     except Exception as e:
         logger.error(f"Error general en la creaci��n del video: {e}", exc_info=True)
-        raise e # Re-lanzar para que Gradio lo muestre
+        raise e
     finally:
-        # 7. Limpiar archivos temporales
         for f in temp_files:
             if os.path.exists(f):
                 try:
@@ -242,7 +286,6 @@ def crear_video(prompt_type, input_text, musica_url=None):
                     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()
@@ -257,15 +300,12 @@ def crear_video(prompt_type, input_text, musica_url=None):
 
 
 def run_app(prompt_type, prompt_ia, prompt_manual, musica_url):
-    """
-    Función envoltorio para Gradio que maneja la ejecución y los errores.
-    """
     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
+    else:
         input_text = prompt_manual
         if not input_text.strip():
             raise gr.Error("Por favor, introduce tu guion.")
@@ -278,7 +318,6 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_url):
             logger.info(f"Proceso completado. Video disponible en: {video_path}")
             return video_path, gr.update(value="¡Video generado exitosamente!")
         else:
-            # 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}")
@@ -290,8 +329,8 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_url):
 # --- Interfaz de Gradio ---
 with gr.Blocks() as app:
     gr.Markdown("""
-    ### 🎬 Generador de Video Inteligente 🚀
-    Crea videos con guiones generados por IA o propios, voz automática y música de fondo.
+    ### 🎬 Generador de Video Inteligente con Pexels 🚀
+    Crea videos con guiones generados por IA o propios, voz automática y videos de stock relevantes de Pexels.
     """)
     
     with gr.Tab("Generar Video"):
@@ -327,7 +366,6 @@ with gr.Blocks() as app:
             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")),
@@ -335,22 +373,20 @@ with gr.Blocks() as app:
         outputs=[ia_guion_column, manual_guion_column]
     )
 
-    # Conectar el botón a la función run_app
     boton.click(
-        fn=lambda: (None, gr.update(value="Iniciando generación... Por favor, espera, esto puede tardar un minuto o más.")),
+        fn=lambda: (None, gr.update(value="Iniciando generación... Esto puede tardar varios minutos (descarga de videos).")),
         outputs=[salida_video, estado_mensaje],
-        queue=False # Desactivar cola para feedback inmediato
+        queue=False
     ).then(
         fn=run_app,
         inputs=[prompt_type, prompt_ia, prompt_manual, musica_input],
         outputs=[salida_video, estado_mensaje]
     )
 
-    # 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 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)
+    app.launch(server_name="0.0.0.0", server_port=7860, share=False)