Update app.py

app.py

@@ -11,21 +11,21 @@ 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!
+from pexels_api import API 
+
+# --- Importar KeyBERT para extracción de palabras clave ---
+from keybert import KeyBERT # Asegúrate de tener 'keybert' y 'sentence-transformers' en requirements.txt
 
 # --- 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)
+PEXELS_API_KEY = os.environ.get("PEXELS_API_KEY") 
+pexels_api = API(PEXELS_API_KEY) 
 
 # --- Inicialización de Tokenizer y Modelo GPT-2 ---
-MODEL_NAME = "gpt2-small"
+MODEL_NAME = "gpt2-small" 
 try:
     tokenizer = GPT2Tokenizer.from_pretrained(MODEL_NAME)
     model = GPT2LMHeadModel.from_pretrained(MODEL_NAME).eval()
@@ -37,9 +37,19 @@ except Exception as e:
     tokenizer = None
     model = None
 
+# --- Inicialización del modelo KeyBERT ---
+try:
+    # Se descarga la primera vez. 'multi-qa-MiniLM-L6-cos-v1' es un buen modelo multilingüe pequeño.
+    # Considera 'distiluse-base-multilingual-cased-v2' para mejor calidad multilingüe si hay suficiente RAM.
+    kw_model = KeyBERT('multi-qa-MiniLM-L6-cos-v1') 
+    logger.info("Modelo KeyBERT cargado exitosamente.")
+except Exception as e:
+    logger.error(f"Error al cargar el modelo KeyBERT: {e}. La búsqueda de videos será menos precisa.", exc_info=True)
+    kw_model = None
+
 # --- Funciones de Utilidad ---
 
-def generate_script(prompt, max_length=250):
+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."
@@ -79,31 +89,36 @@ async def text_to_speech(text, voice="es-ES-ElviraNeural", output_path="voz.mp3"
         logger.error(f"Error al generar audio TTS: {e}")
         raise
 
-def download_video_sample(url):
+def download_video_file(url, temp_dir): # Renombrada y mejorada para descargar a un dir temporal
     if not url:
         return None
-    logger.info(f"Intentando descargar video de: {url}")
-    tmp = None
+    
+    # Intentar obtener el nombre del archivo de la URL o generar uno
+    file_name = url.split('/')[-1].split('?')[0]
+    if not file_name.endswith('.mp4'): # Asegurar extensión correcta
+        file_name = f"video_temp_{os.getpid()}_{datetime.now().strftime('%f')}.mp4"
+    
+    output_path = os.path.join(temp_dir, file_name)
+    logger.info(f"Intentando descargar video de: {url} a {output_path}")
     try:
-        tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4")
-        response = requests.get(url, stream=True, timeout=20) # Aumentar timeout para videos más grandes
+        response = requests.get(url, stream=True, timeout=30) # Aumentar timeout por videos grandes
         response.raise_for_status()
 
-        for chunk in response.iter_content(chunk_size=8192):
-            if chunk:
-                tmp.write(chunk)
-        tmp.close()
-        logger.info(f"Video descargado a: {tmp.name}")
-        return tmp.name
+        with open(output_path, 'wb') as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                if chunk:
+                    f.write(chunk)
+        logger.info(f"Video descargado a: {output_path}")
+        return output_path
     except requests.exceptions.RequestException as e:
         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)
+        if os.path.exists(output_path):
+            os.remove(output_path)
         return None
     except Exception as e:
         logger.error(f"Error inesperado al descargar video {url}: {e}")
-        if tmp and os.path.exists(tmp.name):
-            os.remove(tmp.name)
+        if os.path.exists(output_path):
+            os.remove(output_path)
         return None
 
 def loop_audio_to_length(audio_clip, target_duration):
@@ -115,60 +130,105 @@ 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):
+# --- NUEVA LÓGICA: Extracción de palabras clave visuales del guion ---
+def extract_visual_keywords_from_script(script_text, max_keywords_per_segment=2):
     """
-    Busca videos en Pexels basados en una query y devuelve una lista de URLs de descarga.
+    Extrae palabras clave visuales de un script dividiéndolo en segmentos.
+    Retorna una lista de términos de búsqueda únicos.
     """
-    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 []
+    if not kw_model:
+        logger.warning("Modelo KeyBERT no disponible. La extracción de palabras clave será limitada.")
+        # Fallback si KeyBERT no carga: usar las primeras palabras del guion
+        return [script_text.split('.')[0].strip().replace(" ", "+")] if script_text.strip() else []
 
-    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("Extrayendo palabras clave visuales del guion.")
+    
+    # Dividir el guion en frases o párrafos para un mejor análisis contextual
+    # Puedes ajustar esto, por ejemplo, split('.') si prefieres por frases.
+    segments = [s.strip() for s in script_text.split('\n') if s.strip()]
+    if not segments: # Si no se puede dividir, usar el texto completo
+        segments = [script_text]
 
-        logger.info(f"Encontrados {len(video_urls)} URLs de video de Pexels para '{query}'.")
-        return video_urls
+    all_keywords = set() # Usar un set para evitar duplicados
+    
+    for segment in segments:
+        if not segment: continue
+        try:
+            # keyphrase_ngram_range=(1,2) busca palabras sueltas o frases de dos palabras
+            # top_n=max_keywords_per_segment es cuántas palabras clave por segmento
+            # use_mmr y diversity ayudan a obtener palabras clave más variadas.
+            keywords_with_scores = kw_model.extract_keywords(
+                segment,
+                keyphrase_ngram_range=(1, 2), 
+                stop_words='spanish', # ¡IMPORTANTE! Usar stop words en español
+                top_n=max_keywords_per_segment,
+                use_mmr=True, 
+                diversity=0.7 
+            )
+            for kw, score in keywords_with_scores:
+                # Convertir a formato de búsqueda de URL (espacios por +)
+                all_keywords.add(kw.replace(" ", "+"))
+        except Exception as e:
+            logger.warning(f"Error al extraer palabras clave de un segmento: {e}")
+            # En caso de error en un segmento, intentar con el segmento completo como palabra clave simple
+            all_keywords.add(segment.split(' ')[0].strip().replace(" ", "+"))
+
+    logger.info(f"Palabras clave visuales extraídas del guion: {list(all_keywords)}")
+    return list(all_keywords) # Devolver como lista para iterar
+
+# --- Búsqueda de videos en Pexels ---
+def search_pexels_videos(query_list, num_videos_per_query=5, min_duration_sec=7):
+    """
+    Busca videos en Pexels basados en una lista de queries y devuelve URLs de descarga.
+    """
+    if not PEXELS_API_KEY:
+        logger.error("ERROR: PEXELS_API_KEY no está configurada. No se pueden buscar videos en Pexels.")
+        raise ValueError("PEXELS_API_KEY no está configurada. Por favor, configúrala como un secreto en Hugging Face Spaces.")
 
-    except Exception as e:
-        logger.error(f"Error al buscar videos en Pexels para '{query}': {e}")
+    if not query_list:
+        logger.warning("Lista de queries para Pexels vacía. No se buscarán videos.")
         return []
 
+    all_video_urls = set() # Usar un set para evitar URLs duplicadas
+    
+    for query in query_list:
+        logger.info(f"Buscando {num_videos_per_query} videos en Pexels para la query: '{query}'")
+        try:
+            # Pedimos más de los que necesitamos por query por si algunos no cumplen duración
+            pexels_api.search_videos(query, per_page=num_videos_per_query * 2) 
+            videos = pexels_api.get_videos()
+
+            if not videos:
+                logger.info(f"No se encontraron videos en Pexels para la query: '{query}'")
+                continue
+
+            for video in videos:
+                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
+
+                best_quality_url = None
+                for file in video.get('video_files', []):
+                    if file.get('quality') in ['hd', 'sd', 'medium', 'large'] and file.get('link'):
+                        best_quality_url = file['link']
+                        break 
+                    elif file.get('link'):
+                        best_quality_url = file['link']
+
+                if best_quality_url:
+                    all_video_urls.add(best_quality_url)
+                else:
+                    logger.warning(f"No se encontró URL de descarga válida para el video Pexels ID: {video.get('id')}")
+
+        except Exception as e:
+            logger.error(f"Error al buscar videos en Pexels para '{query}': {e}", exc_info=True)
+            # No lanzamos la excepción aquí, para que otras queries puedan seguir funcionando
+            # Pero el error se registra.
+            
+    final_urls = list(all_video_urls)
+    logger.info(f"Total de {len(final_urls)} URLs de video únicas obtenidas de Pexels.")
+    return final_urls
+
 # --- Función Principal de Creación de Video ---
 
 def crear_video(prompt_type, input_text, musica_url=None):
@@ -177,8 +237,8 @@ def crear_video(prompt_type, input_text, musica_url=None):
     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)
-    else: # prompt_type == "Usar Mi Guion"
+            raise ValueError(guion) 
+    else: 
         guion = input_text
         if not guion.strip():
             raise ValueError("Por favor, introduce tu guion.")
@@ -186,8 +246,13 @@ 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 = []
-    clips = []
+    temp_files = [] 
+    downloaded_clip_paths = [] # Para los paths de los videos descargados
+    final_clips = [] # Para los objetos VideoFileClip ya procesados
+
+    # Directorio temporal para descargar videos
+    temp_video_dir = tempfile.mkdtemp()
+    temp_files.append(temp_video_dir) # Añadir el directorio temporal para su limpieza
 
     try:
         # 1. Generar audio TTS
@@ -196,61 +261,82 @@ 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. 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 pexels_video_urls:
-            video_path = download_video_sample(url)
+        # 2. Extracción de palabras clave y búsqueda masiva en Pexels
+        # Dividimos el guion en segmentos y extraemos palabras clave de cada uno
+        # Esto genera una lista de queries para Pexels, como ['misterios+china', 'muralla+china', ...]
+        search_queries_for_pexels = extract_visual_keywords_from_script(guion, max_keywords_per_segment=2)
+
+        # Si no se pudo extraer ninguna palabra clave útil, lanzar error.
+        if not search_queries_for_pexels:
+            raise ValueError("No se pudieron extraer palabras clave visuales del guion para buscar videos.")
+
+        # Buscar y obtener URLs de muchos videos de Pexels (e.g., 5 videos por cada palabra clave)
+        pexels_video_urls_found = search_pexels_videos(search_queries_for_pexels, num_videos_per_query=5, min_duration_sec=7) 
+
+        if not pexels_video_urls_found:
+            logger.error("Pexels no devolvió ningún video para las palabras clave extraídas.")
+            raise ValueError(f"Pexels no encontró videos adecuados para el guion. Intenta con otro tema o guion más descriptivo. Palabras clave usadas: {search_queries_for_pexels}")
+
+        # 3. Descargar todos los videos encontrados de Pexels
+        logger.info(f"Descargando {len(pexels_video_urls_found)} videos de Pexels...")
+        for url in pexels_video_urls_found:
+            video_path = download_video_file(url, temp_video_dir) # Descargar al directorio temporal
             if video_path:
-                temp_files.append(video_path)
-                try:
-                    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()
-                except Exception as e:
-                    logger.warning(f"No se pudo cargar o procesar el clip de video {video_path} de {url}: {e}")
+                downloaded_clip_paths.append(video_path)
             else:
-                logger.warning(f"No se pudo descargar el video de la URL: {url}")
+                logger.warning(f"No se pudo descargar video de Pexels: {url}")
         
-        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 de Pexels o fallback sean correctas y accesibles.")
+        if not downloaded_clip_paths:
+            logger.error("No se pudo descargar ningún video válido de Pexels.")
+            raise ValueError("No se pudo descargar ningún video válido de Pexels. Revisa la conexión o la calidad de las URLs.")
 
-        # 3. Concatenar videos
-        video_base = concatenate_videoclips(clips, method="compose")
+        # 4. Cargar y procesar los clips descargados
+        total_desired_video_duration = audio_tts.duration * 1.2 # Intentar tener 20% más de video que audio
+        current_video_clips_duration = 0
+        
+        for path in downloaded_clip_paths:
+            try:
+                clip = VideoFileClip(path)
+                # Opcional: Si quieres clips cortos y variados para transiciones rápidas
+                clip_duration = min(clip.duration, 10) # Limitar a un máximo de 10 segundos por clip
+                if clip_duration > 1: # Asegurar que el clip sea lo suficientemente largo
+                    final_clips.append(clip.subclip(0, clip_duration))
+                    current_video_clips_duration += clip_duration
+                    if current_video_clips_duration >= total_desired_video_duration:
+                        break # Ya tenemos suficiente metraje
+                else:
+                    logger.warning(f"Clip de video muy corto ({clip_duration:.2f}s) de {path}, omitiendo.")
+                    clip.close()
+            except Exception as e:
+                logger.warning(f"No se pudo cargar o procesar el clip de video {path}: {e}. Omitiendo.")
+                if 'clip' in locals() and clip: clip.close() # Asegurarse de cerrar si hay un error
+        
+        if not final_clips:
+            logger.error("No se pudo obtener ningún clip de video usable después de la descarga y procesamiento.")
+            raise ValueError("No se pudieron procesar los videos descargados de Pexels.")
+
+
+        # 5. Concatenar videos y ajustar duración
+        video_base = concatenate_videoclips(final_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
+        # Si es más corto, loopearlo.
         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")
-
+            video_base = concatenate_videoclips(repeated_clips, method="compose") 
+        
+        # El video final siempre tendrá la duración del audio TTS (o la mezcla de audio)
         final_video_duration = audio_tts.duration
 
-        # 4. Música de fondo en loop
+        # 6. Música de fondo en loop
         mezcla_audio = audio_tts
         if musica_url and musica_url.strip():
-            musica_path = download_video_sample(musica_url)
+            musica_path = download_video_file(musica_url, temp_video_dir) # Usar la misma función de descarga
             if musica_path:
-                temp_files.append(musica_path)
+                temp_files.append(musica_path) # Añadir el path del archivo de música a limpiar
                 try:
                     musica_audio = AudioFileClip(musica_path)
                     musica_loop = loop_audio_to_length(musica_audio, final_video_duration)
@@ -261,11 +347,11 @@ 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
+        # 7. 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")
 
-        # 6. Guardar video final
+        # 8. 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")
@@ -279,23 +365,34 @@ def crear_video(prompt_type, input_text, musica_url=None):
         logger.error(f"Error general en la creación del video: {e}", exc_info=True)
         raise e
     finally:
+        # 9. Limpiar archivos y directorios 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}")
-        for clip in clips:
-            if clip:
+                if os.path.isdir(f):
+                    try:
+                        import shutil
+                        shutil.rmtree(f)
+                        logger.info(f"Directorio temporal eliminado: {f}")
+                    except Exception as e:
+                        logger.warning(f"No se pudo eliminar el directorio temporal {f}: {e}")
+                else:
+                    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}")
+        
+        # Asegurarse de cerrar todos los objetos MoviePy VideoFileClip y AudioFileClip
+        for clip in final_clips: # Iterar sobre los clips finales que se usaron
+            if clip and not clip.is_playing: # Solo cerrar si no está ya cerrado
                 clip.close()
-        if 'audio_tts' in locals() and audio_tts:
+        if 'audio_tts' in locals() and audio_tts and not audio_tts.is_playing:
             audio_tts.close()
-        if 'musica_audio' in locals() and musica_audio:
+        if 'musica_audio' in locals() and musica_audio and not musica_audio.is_playing:
             musica_audio.close()
-        if 'video_final' in locals() and video_final:
+        if 'video_final' in locals() and video_final and not video_final.is_playing:
             video_final.close()
-        if 'video_base' in locals() and video_base:
+        if 'video_base' in locals() and video_base and not video_base.is_playing:
             video_base.close()
 
 
@@ -319,8 +416,8 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_url):
             return video_path, gr.update(value="¡Video generado exitosamente!")
         else:
             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}")
+    except ValueError as ve: 
+        logger.error(f"Error de validación o búsqueda de Pexels: {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)
@@ -330,7 +427,7 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_url):
 with gr.Blocks() as app:
     gr.Markdown("""
     ### 🎬 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.
+    Crea videos con guiones generados por IA o propios, voz automática y **videos de stock relevantes de Pexels (sin videos de ejemplo)**.
     """)
     
     with gr.Tab("Generar Video"):