Update app.py

app.py

@@ -7,12 +7,16 @@ from datetime import datetime
 import edge_tts
 import gradio as gr
 import torch
+# Corregir typo: GPT2Tokenizer en lugar de GPTizer
 from transformers import GPT2Tokenizer, GPT2LMHeadModel
 from keybert import KeyBERT
-from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip, CompositeAudioClip
+# Importar concatenate_audioclips específicamente si no está en editor por defecto
+from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip, CompositeAudioClip, concatenate_audioclips
 import re
 import math
-from pydub import AudioSegment
+# Pydub ya no parece usarse directamente en las funciones principales,
+# pero se mantiene por si acaso o por si se usó en intentos previos.
+# from pydub import AudioSegment # Comentado porque no se usa en el flujo principal corregido
 from collections import Counter
 import shutil
 import json
@@ -32,36 +36,47 @@ logger.info("INICIO DE EJECUCIÓN - GENERADOR DE VIDEOS")
 logger.info("="*80)
 
 # Clave API de Pexels (configuración segura)
+# Asegúrate de que esta variable de entorno esté configurada en tu entorno.
 PEXELS_API_KEY = os.environ.get("PEXELS_API_KEY")
 if not PEXELS_API_KEY:
     logger.critical("NO SE ENCONTRÓ PEXELS_API_KEY EN VARIABLES DE ENTORNO")
-    raise ValueError("API key de Pexels no configurada")
+    # Permite que continúe en desarrollo/test pero registra el problema
+    # raise ValueError("API key de Pexels no configurada") # Descomentar para forzar fallo si no está
+    logger.warning("Continuando sin PEXELS_API_KEY. La búsqueda de videos fallará.")
 else:
     logger.info("API key de Pexels configurada correctamente")
 
 # Inicialización de modelos CON LOGS DETALLADOS
 MODEL_NAME = "datificate/gpt2-small-spanish"
 logger.info(f"Inicializando modelo GPT-2: {MODEL_NAME}")
+tokenizer = None # Inicializar a None por si falla
+model = None   # Inicializar a None por si falla
 try:
-    tokenizer = GPTizer.from_pretrained(MODEL_NAME)
+    # CORRECCIÓN: Usar GPT2Tokenizer
+    tokenizer = GPT2Tokenizer.from_pretrained(MODEL_NAME)
     model = GPT2LMHeadModel.from_pretrained(MODEL_NAME).eval()
     if tokenizer.pad_token is None:
         tokenizer.pad_token = tokenizer.eos_token
     logger.info(f"Modelo GPT-2 cargado | Vocabulario: {len(tokenizer)} tokens")
 except Exception as e:
     logger.error(f"FALLA CRÍTICA al cargar GPT-2: {str(e)}", exc_info=True)
-    tokenizer = model = None
+    tokenizer = model = None # Asegurar que queden como None
 
 logger.info("Cargando modelo KeyBERT...")
+kw_model = None # Inicializar a None por si falla
 try:
     kw_model = KeyBERT('distilbert-base-multilingual-cased')
     logger.info("KeyBERT inicializado correctamente")
 except Exception as e:
     logger.error(f"FALLA al cargar KeyBERT: {str(e)}", exc_info=True)
-    kw_model = None
+    kw_model = None # Asegurar que quede como None
 
 # [FUNCIÓN BUSCAR_VIDEOS_PEXELS ORIGINAL CON LOGS AÑADIDOS]
 def buscar_videos_pexels(query, api_key, per_page=5):
+    if not api_key:
+        logger.warning("No se puede buscar en Pexels: API Key no configurada.")
+        return []
+
     logger.debug(f"Buscando en Pexels: '{query}' | Resultados: {per_page}")
     headers = {"Authorization": api_key}
     try:
@@ -79,20 +94,21 @@ def buscar_videos_pexels(query, api_key, per_page=5):
             params=params,
             timeout=20
         )
-        response.raise_for_status()
-        
+        response.raise_for_status() # Lanza una excepción para códigos de estado de error HTTP
+
         try:
             data = response.json()
-            logger.info(f"Pexels: {len(data.get('videos', []))} videos encontrados")
-            return data.get('videos', [])
+            videos = data.get('videos', [])
+            logger.info(f"Pexels: {len(videos)} videos encontrados para '{query}'")
+            return videos
         except json.JSONDecodeError:
-            logger.error(f"Pexels: JSON inválido | Status: {response.status_code} | Respuesta: {response.text[:200]}...")
+            logger.error(f"Pexels: JSON inválido recibido | Status: {response.status_code} | Respuesta: {response.text[:200]}...")
             return []
             
     except requests.exceptions.RequestException as e:
-        logger.error(f"Error de conexión Pexels: {str(e)}")
+        logger.error(f"Error de conexión Pexels para '{query}': {str(e)}")
     except Exception as e:
-        logger.error(f"Error inesperado Pexels: {str(e)}", exc_info=True)
+        logger.error(f"Error inesperado Pexels para '{query}': {str(e)}", exc_info=True)
     
     return []
 
@@ -100,47 +116,83 @@ def buscar_videos_pexels(query, api_key, per_page=5):
 def generate_script(prompt, max_length=150):
     logger.info(f"Generando guión | Prompt: '{prompt[:50]}...' | Longitud máxima: {max_length}")
     if not tokenizer or not model:
-        logger.warning("Modelos no disponibles - Usando prompt original")
+        logger.warning("Modelos GPT-2 no disponibles - Usando prompt original como guion.")
         return prompt
     
     try:
-        enhanced_prompt = f"Escribe un guion corto y coherente sobre: {prompt}"
+        # Intenta mejorar el prompt para la IA si se detecta que es muy corto o no es una pregunta
+        # (Esto es una heurística simple, podrías mejorarlo)
+        if len(prompt.split()) < 5 or not re.search(r'[¿?.]', prompt):
+             enhanced_prompt = f"Escribe un guion corto, interesante y coherente sobre: {prompt}"
+        else:
+             enhanced_prompt = prompt # Si parece ya un guion o pregunta, úsalo directamente
+             logger.debug("Usando prompt original como base para la generación.")
+
         inputs = tokenizer(enhanced_prompt, return_tensors="pt", truncation=True, max_length=512)
         
         logger.debug("Generando texto con GPT-2...")
+        # Asegurar que el modelo esté en modo evaluación y en la CPU si no hay GPU
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        model.to(device)
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+
+
         outputs = model.generate(
             **inputs,
             max_length=max_length,
-            do_sample=True,
+            do_sample=True, # Permite creatividad
             top_p=0.9,
             top_k=40,
             temperature=0.7,
-            repetition_penalty=1.5,
+            repetition_penalty=1.2, # Reducido un poco para menos repetición agresiva
             pad_token_id=tokenizer.pad_token_id,
-            eos_token_id=tokenizer.eos_token_id
+            eos_token_id=tokenizer.eos_token_id,
+            no_repeat_ngram_size=3 # Ayuda a evitar repeticiones de frases cortas
         )
         
         text = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        text = re.sub(r'<[^>]+>', '', text)
+        
+        # Limpieza del texto
+        text = re.sub(r'<[^>]+>', '', text) # Elimina posibles tags HTML/XML si los hay
+        text = text.strip()
+        
+        # Intenta obtener al menos una oración completa si es posible
         sentences = text.split('.')
+        if sentences and sentences[0].strip():
+            final_text = sentences[0].strip() + '.'
+            # Añadir la segunda oración si existe y es razonable
+            if len(sentences) > 1 and sentences[1].strip() and len(final_text.split()) < max_length * 0.5: # Si la primera es corta y el guion no muy largo aún
+                 final_text += " " + sentences[1].strip() + "."
+                 final_text = final_text.replace("..", ".") # Limpiar doble punto
+
+            logger.info(f"Guion generado (Truncado a 100 chars): '{final_text[:100]}...'")
+            return final_text.strip() # Asegurar que no haya espacios al inicio/fin
         
-        if sentences:
-            final_text = sentences[0] + '.'
-            logger.info(f"Guion generado: '{final_text[:100]}...'")
-            return final_text
-        return text
+        logger.info(f"Guion generado (sin oraciones completas detectadas): '{text[:100]}...'")
+        return text.strip() # Si no se puede formar una oración, devolver el texto tal cual
     except Exception as e:
-        logger.error(f"Error generando guion: {str(e)}", exc_info=True)
-        return prompt
+        logger.error(f"Error generando guion con GPT-2: {str(e)}", exc_info=True)
+        logger.warning("Usando prompt original como guion debido al error de generación.")
+        return prompt.strip() # En caso de error, devolver el prompt original limpio
 
 # [FUNCIÓN TEXT_TO_SPEECH ORIGINAL CON LOGS]
 async def text_to_speech(text, output_path, voice="es-ES-ElviraNeural"):
-    logger.info(f"Convirtiendo texto a voz | Caracteres: {len(text)} | Voz: {voice}")
+    logger.info(f"Convirtiendo texto a voz | Caracteres: {len(text)} | Voz: {voice} | Salida: {output_path}")
+    if not text or not text.strip():
+        logger.warning("Texto vacío para TTS")
+        return False
+        
     try:
         communicate = edge_tts.Communicate(text, voice)
         await communicate.save(output_path)
-        logger.info(f"Audio guardado en: {output_path} | Tamaño: {os.path.getsize(output_path)} bytes")
-        return True
+        
+        if os.path.exists(output_path) and os.path.getsize(output_path) > 100: # Check for minimum size
+            logger.info(f"Audio guardado exitosamente en: {output_path} | Tamaño: {os.path.getsize(output_path)} bytes")
+            return True
+        else:
+            logger.error(f"TTS guardó un archivo pequeño o vacío en: {output_path}")
+            return False
+            
     except Exception as e:
         logger.error(f"Error en TTS: {str(e)}", exc_info=True)
         return False
@@ -148,279 +200,540 @@ async def text_to_speech(text, output_path, voice="es-ES-ElviraNeural"):
 # [FUNCIÓN DOWNLOAD_VIDEO_FILE ORIGINAL CON LOGS]
 def download_video_file(url, temp_dir):
     if not url:
-        logger.warning("URL de video no proporcionada")
+        logger.warning("URL de video no proporcionada para descargar")
         return None
     
     try:
-        logger.info(f"Descargando video desde: {url[:50]}...")
-        file_name = f"video_{datetime.now().strftime('%H%M%S%f')}.mp4"
+        logger.info(f"Descargando video desde: {url[:80]}...")
+        # Usar un nombre más robusto y asegurar que el directorio exista
+        os.makedirs(temp_dir, exist_ok=True)
+        file_name = f"video_dl_{datetime.now().strftime('%Y%m%d_%H%M%S_%f')}.mp4"
         output_path = os.path.join(temp_dir, file_name)
         
-        with requests.get(url, stream=True, timeout=30) as r:
+        # Aumentar timeout para descargas grandes
+        with requests.get(url, stream=True, timeout=60) as r: 
             r.raise_for_status()
+            total_size = int(r.headers.get('content-length', 0))
+            downloaded_size = 0
+            logger.debug(f"Tamaño esperado: {total_size} bytes")
+
             with open(output_path, 'wb') as f:
                 for chunk in r.iter_content(chunk_size=8192):
                     f.write(chunk)
-        
-        logger.info(f"Video descargado: {output_path} | Tamaño: {os.path.getsize(output_path)} bytes")
-        return output_path
+                    downloaded_size += len(chunk)
+                    # Opcional: loguear progreso si es muy lento
+
+        # Verificar si el archivo descargado tiene un tamaño razonable
+        if os.path.exists(output_path) and os.path.getsize(output_path) > 1000: # Mínimo 1KB
+             logger.info(f"Video descargado exitosamente: {output_path} | Tamaño: {os.path.getsize(output_path)} bytes")
+             return output_path
+        else:
+             logger.warning(f"Descarga parece incompleta o vacía para {url[:80]}... Archivo: {output_path} Tamaño: {os.path.getsize(output_path) if os.path.exists(output_path) else 'N/A'} bytes")
+             if os.path.exists(output_path):
+                 os.remove(output_path) # Eliminar archivo inválido
+             return None
+
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Error de descarga para {url[:80]}... : {str(e)}")
     except Exception as e:
-        logger.error(f"Error descargando video: {str(e)}", exc_info=True)
-        return None
+        logger.error(f"Error inesperado descargando {url[:80]}... : {str(e)}", exc_info=True)
+    
+    return None
 
 # [FUNCIÓN LOOP_AUDIO_TO_LENGTH ORIGINAL CON LOGS]
 def loop_audio_to_length(audio_clip, target_duration):
     logger.debug(f"Ajustando audio | Duración actual: {audio_clip.duration:.2f}s | Objetivo: {target_duration:.2f}s")
+    if audio_clip.duration <= 0:
+        logger.warning("Clip de audio de duración cero o negativa, no se puede ajustar.")
+        return AudioFileClip(filename="") # Devuelve clip de audio vacío
+
     if audio_clip.duration >= target_duration:
+        logger.debug("Clip de audio ya es más largo o igual al objetivo.")
         return audio_clip.subclip(0, target_duration)
     
+    # CORRECCIÓN: Usar concatenate_audioclips para audio
     loops = math.ceil(target_duration / audio_clip.duration)
     logger.debug(f"Creando {loops} loops de audio")
-    audios = [audio_clip] * loops
-    return concatenate_videoclips(audios).subclip(0, target_duration)
+    
+    # Crear una lista de clips de audio
+    audio_segments = [audio_clip] * loops
+    
+    # Concatenar los clips de audio
+    looped_audio = concatenate_audioclips(audio_segments)
+    
+    # Recortar al target_duration exacto
+    return looped_audio.subclip(0, target_duration)
 
 # [FUNCIÓN EXTRACT_VISUAL_KEYWORDS_FROM_SCRIPT ORIGINAL CON LOGS]
 def extract_visual_keywords_from_script(script_text):
     logger.info("Extrayendo palabras clave del guion")
-    clean_text = re.sub(r'[^\w\sáéíóúñ]', '', script_text.lower())
+    if not script_text or not script_text.strip():
+        logger.warning("Guion vacío, no se pueden extraer palabras clave.")
+        return ["naturaleza", "ciudad", "paisaje"] # Keywords por defecto
+
+    # Limpieza de texto más robusta, manteniendo espacios para keyphrases
+    clean_text = re.sub(r'[^\w\sáéíóúñÁÉÍÓÚÑ]', '', script_text)
     
+    keywords_list = []
+
     if kw_model:
         try:
-            keywords = kw_model.extract_keywords(
+            logger.debug("Intentando extraer keywords con KeyBERT...")
+            # Intentar con ngrams 1 y 2
+            keywords1 = kw_model.extract_keywords(
                 clean_text,
                 keyphrase_ngram_range=(1, 1),
                 stop_words='spanish',
+                top_n=5
+            )
+            keywords2 = kw_model.extract_keywords(
+                clean_text,
+                keyphrase_ngram_range=(2, 2),
+                stop_words='spanish',
                 top_n=3
             )
-            if keywords:
-                logger.debug(f"KeyBERT keywords: {keywords}")
-                return [kw[0].replace(" ", "+") for kw in keywords]
+            
+            # Combinar y priorizar palabras clave (ngram 1) y frases clave (ngram 2)
+            all_keywords = keywords1 + keywords2
+            # Ordenar por score descendente
+            all_keywords.sort(key=lambda item: item[1], reverse=True)
+            
+            # Tomar los top N únicos
+            seen_keywords = set()
+            for keyword, score in all_keywords:
+                # Convertir a minúsculas y reemplazar espacios por + para URL
+                formatted_keyword = keyword.lower().replace(" ", "+")
+                if formatted_keyword not in seen_keywords:
+                    keywords_list.append(formatted_keyword)
+                    seen_keywords.add(formatted_keyword)
+                if len(keywords_list) >= 5: # Limitar el número total de keywords
+                    break
+
+            if keywords_list:
+                logger.debug(f"KeyBERT keywords extraídas: {keywords_list}")
+                return keywords_list
+
         except Exception as e:
-            logger.warning(f"KeyBERT falló: {str(e)}")
+            logger.warning(f"KeyBERT falló durante la extracción: {str(e)}. Intentando método simple.")
+            # Continúa al método simple si KeyBERT falla
     
-    words = clean_text.split()
-    stop_words = {"el", "la", "los", "las", "de", "en", "y", "a", "que", "es", "un", "una", "con"}
-    keywords = [word for word in words if len(word) > 3 and word not in stop_words]
+    # Método simple de extracción si KeyBERT no está disponible o falló
+    logger.debug("Extrayendo keywords con método simple...")
+    words = clean_text.lower().split()
+    # Conjunto de stop words más amplio y eficiente
+    stop_words = {"el", "la", "los", "las", "de", "en", "y", "a", "que", "es", "un", "una", "con", "para", "del", "al", "por", "su", "sus", "se", "lo", "le", "me", "te", "nos", "os", "les", "mi", "tu", "nuestro", "vuestro", "este", "ese", "aquel", "esta", "esa", "aquella", "esto", "eso", "aquello", "mis", "tus", "nuestros", "vuestros", "estas", "esas", "aquellas", "si", "no", "más", "menos", "sin", "sobre", "bajo", "entre", "hasta", "desde", "durante", "mediante", "según", "versus", "via", "cada", "todo", "todos", "toda", "todas", "poco", "pocos", "poca", "pocas", "mucho", "muchos", "mucha", "muchas", "varios", "varias", "otro", "otros", "otra", "otras", "mismo", "misma", "mismos", "mismas", "tan", "tanto", "tanta", "tantos", "tantas", "tal", "tales", "cual", "cuales", "cuyo", "cuya", "cuyos", "cuyas", "quien", "quienes", "cuan", "cuanto", "cuanta", "cuantos", "cuantas", "como", "donde", "cuando", "que", "porque", "si", "aunque", "mientras", "cuando", "como", "donde", "siempre", "nunca", "jamás", "muy", "más", "menos", "tan", "tanto", "casi", "solo", "solamente", "incluso", "apenas", "quizás", "tal vez", "acaso", "claro", "cierto", "obvio", "evidentemente", "realmente", "simplemente", "generalmente", "especialmente", "principalmente", "posiblemente", "probablemente", "difícilmente", "fácilmente", "rápidamente", "lentamente", "bien", "mal", "mejor", "peor", "arriba", "abajo", "adelante", "atrás", "cerca", "lejos", "dentro", "fuera", "encima", "debajo", "frente", "detrás", "antes", "después", "luego", "pronto", "tarde", "todavía", "ya", "aun", "aún", "siempre", "nunca", "jamás", "quizá", "acaso", "tal vez"}
+
+    # Filtrar palabras, eliminar stop words y palabras cortas
+    valid_words = [word for word in words if len(word) > 3 and word not in stop_words]
     
-    if not keywords:
-        logger.warning("Usando palabras clave predeterminadas")
+    if not valid_words:
+        logger.warning("No se encontraron palabras clave válidas con método simple. Usando palabras clave predeterminadas.")
         return ["naturaleza", "ciudad", "paisaje"]
     
-    word_counts = Counter(keywords)
-    top_keywords = [word.replace(" ", "+") for word, _ in word_counts.most_common(3)]
+    # Contar frecuencia y tomar las más comunes
+    word_counts = Counter(valid_words)
+    # Tomar hasta 5 palabras clave más comunes
+    top_keywords = [word.replace(" ", "+") for word, _ in word_counts.most_common(5)]
+    
+    if not top_keywords:
+         logger.warning("El método simple no produjo keywords. Usando palabras clave predeterminadas.")
+         return ["naturaleza", "ciudad", "paisaje"]
+
     logger.info(f"Palabras clave finales: {top_keywords}")
     return top_keywords
 
-# [FUNCIÓN CREAR_VIDEO ORIGINAL CON LOGS]
+# [FUNCIÓN CREAR_VIDEO CORREGIDA]
 def crear_video(prompt_type, input_text, musica_file=None):
     logger.info("="*80)
     logger.info(f"INICIANDO CREACIÓN DE VIDEO | Tipo: {prompt_type}")
     logger.debug(f"Input: '{input_text[:100]}...'")
     
-    # 1. Generar o usar guion
     start_time = datetime.now()
-    if prompt_type == "Generar Guion con IA":
-        logger.info("Generando guion con IA...")
-        guion = generate_script(input_text)
-    else: 
-        logger.info("Usando guion proporcionado")
-        guion = input_text
-    
-    logger.info(f"Guion final ({len(guion)} caracteres): '{guion[:100]}...'")
-    
-    if not guion.strip():
-        logger.error("El guion está vacío")
-        raise ValueError("El guion está vacío")
-    
-    # Directorio temporal
-    temp_dir = tempfile.mkdtemp()
-    logger.info(f"Directorio temporal creado: {temp_dir}")
-    temp_files = []
-    
+    temp_dir_intermediate = None # Directorio para archivos temporales intermedios
+    output_video_path = None # Path para el video final fuera del directorio intermedio
+
     try:
+        # 1. Generar o usar guion
+        if prompt_type == "Generar Guion con IA":
+            logger.info("Generando guion con IA...")
+            guion = generate_script(input_text)
+        else:
+            logger.info("Usando guion proporcionado")
+            guion = input_text.strip() # Asegurar que el guion manual no tenga espacios al inicio/fin
+
+        logger.info(f"Guion final ({len(guion)} caracteres): '{guion[:100]}...'")
+        
+        if not guion.strip():
+            logger.error("El guion resultante está vacío o solo contiene espacios.")
+            raise ValueError("El guion está vacío.")
+        
+        # Crear directorio temporal para archivos intermedios (audio TTS, videos descargados)
+        temp_dir_intermediate = tempfile.mkdtemp(prefix="video_gen_intermediate_")
+        logger.info(f"Directorio temporal intermedio creado: {temp_dir_intermediate}")
+        temp_intermediate_files = [] # Lista para seguir los archivos que hay que limpiar
+
         # 2. Generar audio de voz
         logger.info("Generando audio de voz...")
-        voz_path = os.path.join(temp_dir, "voz.mp3")
+        voz_path = os.path.join(temp_dir_intermediate, "voz.mp3")
+        # No añadimos voz_path a temp_intermediate_files *antes* de la generación,
+        # solo si la generación es exitosa.
         if not asyncio.run(text_to_speech(guion, voz_path)):
-            logger.error("Fallo en generación de voz")
-            raise ValueError("Error generando voz")
-        temp_files.append(voz_path)
-        
+            logger.error("Fallo en generación de voz.")
+            raise ValueError("Error generando voz a partir del guion.")
+        temp_intermediate_files.append(voz_path) # Añadir para limpieza si la generación tuvo éxito
+
         audio_tts = AudioFileClip(voz_path)
         audio_duration = audio_tts.duration
         logger.info(f"Duración audio voz: {audio_duration:.2f} segundos")
-        
+
+        if audio_duration < 1.0:
+             logger.warning(f"Duración del audio de voz ({audio_duration:.2f}s) es muy corta. El video podría ser muy breve o fallar.")
+             # Podrías añadir un mínimo o generar un guion/voz alternativo
+
         # 3. Extraer palabras clave
         logger.info("Extrayendo palabras clave...")
         try:
             keywords = extract_visual_keywords_from_script(guion)
             logger.info(f"Palabras clave identificadas: {keywords}")
         except Exception as e:
-            logger.error(f"Error extrayendo keywords: {str(e)}")
-            keywords = ["naturaleza", "paisaje"]
-        
+            logger.error(f"Error extrayendo keywords: {str(e)}", exc_info=True)
+            keywords = ["naturaleza", "paisaje"] # Fallback si la extracción falla
+
+        if not keywords:
+             logger.warning("Lista de palabras clave vacía después de extracción y fallback.")
+             keywords = ["video", "background"] # Fallback final
+
         # 4. Buscar y descargar videos
         logger.info("Buscando videos en Pexels...")
         videos_data = []
+        # Buscar con todas las keywords, intentando obtener más resultados al principio
+        total_desired_videos = 10 # Intentar descargar hasta 10 videos en total
+        per_page_per_keyword = max(1, total_desired_videos // len(keywords)) # Distribuir la búsqueda
+
         for keyword in keywords:
+            if len(videos_data) >= total_desired_videos: break # Dejar de buscar si ya tenemos suficientes
             try:
-                videos = buscar_videos_pexels(keyword, PEXELS_API_KEY, per_page=3)
+                videos = buscar_videos_pexels(keyword, PEXELS_API_KEY, per_page=per_page_per_keyword)
                 if videos:
                     videos_data.extend(videos)
-                    logger.info(f"Encontrados {len(videos)} videos para '{keyword}'")
+                    logger.info(f"Encontrados {len(videos)} videos para '{keyword}'. Total data: {len(videos_data)}")
             except Exception as e:
                 logger.warning(f"Error buscando videos para '{keyword}': {str(e)}")
-        
-        if not videos_data:
-            logger.warning("No se encontraron videos - Usando palabras clave genéricas")
-            for keyword in ["naturaleza", "ciudad", "paisaje"]:
-                videos = buscar_videos_pexels(keyword, PEXELS_API_KEY, per_page=3)
-                if videos:
-                    videos_data.extend(videos)
-        
+
+        # Si no se encontraron suficientes videos con keywords específicas, intentar genéricas
+        if len(videos_data) < total_desired_videos / 2: # Si tenemos menos de la mitad de los deseados
+            logger.warning(f"Pocos videos encontrados ({len(videos_data)}). Intentando con palabras clave genéricas.")
+            generic_keywords = ["nature", "city", "background", "abstract"] # Palabras clave genéricas en inglés para Pexels
+            for keyword in generic_keywords:
+                 if len(videos_data) >= total_desired_videos: break
+                 try:
+                    # Buscar menos por cada genérica para no saturar
+                    videos = buscar_videos_pexels(keyword, PEXELS_API_KEY, per_page=2) 
+                    if videos:
+                        videos_data.extend(videos)
+                        logger.info(f"Encontrados {len(videos)} videos para '{keyword}' (genérico). Total data: {len(videos_data)}")
+                 except Exception as e:
+                    logger.warning(f"Error buscando videos genéricos para '{keyword}': {str(e)}")
+
+
         if not videos_data:
-            logger.error("No se encontraron videos para ninguna palabra clave")
-            raise ValueError("No se encontraron videos en Pexels para ninguna palabra clave")
+            logger.error("No se encontraron videos en Pexels para ninguna palabra clave.")
+            raise ValueError("No se encontraron videos adecuados en Pexels.")
         
         video_paths = []
+        logger.info(f"Intentando descargar {len(videos_data)} videos encontrados...")
         for video in videos_data:
             if 'video_files' not in video or not video['video_files']:
+                logger.debug(f"Saltando video sin archivos de video: {video.get('id')}")
                 continue
                 
             try:
-                best_quality = max(
-                    video['video_files'], 
-                    key=lambda x: x.get('width', 0) * x.get('height', 0)
-                )
-                
-                if 'link' in best_quality:
-                    path = download_video_file(best_quality['link'], temp_dir)
+                # Encontrar la mejor calidad disponible con un enlace de descarga
+                best_quality = None
+                for vf in sorted(video['video_files'], key=lambda x: x.get('width', 0) * x.get('height', 0), reverse=True):
+                    if 'link' in vf:
+                        best_quality = vf
+                        break
+
+                if best_quality and 'link' in best_quality:
+                    path = download_video_file(best_quality['link'], temp_dir_intermediate)
                     if path:
                         video_paths.append(path)
-                        temp_files.append(path)
-                        logger.info(f"Video descargado: {best_quality['link']}")
+                        temp_intermediate_files.append(path) # Añadir para limpieza
+                        logger.info(f"Video descargado OK desde {best_quality['link'][:50]}...")
+                    else:
+                         logger.warning(f"No se pudo descargar video desde {best_quality['link'][:50]}...")
+                else:
+                    logger.warning(f"No se encontró enlace de descarga válido para video {video.get('id')}.")
+
             except Exception as e:
-                logger.warning(f"Error procesando video: {str(e)}")
-        
+                logger.warning(f"Error procesando/descargando video {video.get('id')}: {str(e)}")
+
+        logger.info(f"Descargados {len(video_paths)} archivos de video utilizables.")
         if not video_paths:
-            logger.error("No se pudo descargar ningún video")
-            raise ValueError("No se pudo descargar ningún video")
+            logger.error("No se pudo descargar ningún archivo de video utilizable.")
+            raise ValueError("No se pudo descargar ningún video utilizable de Pexels.")
         
-        # 5. Procesar videos
-        logger.info("Procesando videos descargados...")
+        # 5. Procesar y concatenar clips de video
+        logger.info("Procesando y concatenando videos descargados...")
         clips = []
         current_duration = 0
-        
+        min_clip_duration = 1.0 # Duración mínima para un clip
+        max_clip_segment = 8.0 # Segmento máximo a tomar de un clip fuente
+
+        # Ordenar clips descargados por tamaño o duración si se desea, o usar el orden de descarga
+        # Por ahora, usamos el orden de descarga
+
         for path in video_paths:
-            if current_duration >= audio_duration:
+            # Dejar de añadir clips si ya tenemos suficiente duración o estamos cerca
+            # Añadimos un buffer para no cortar bruscamente el último clip
+            if current_duration >= audio_duration + max_clip_segment: 
                 break
-                
+
             try:
+                logger.debug(f"Abriendo clip: {path}")
                 clip = VideoFileClip(path)
-                usable_duration = min(clip.duration, 10)
                 
-                if usable_duration > 1:
-                    clips.append(clip.subclip(0, usable_duration))
-                    current_duration += usable_duration
-                    logger.debug(f"Clip añadido: {usable_duration:.1f}s (total: {current_duration:.1f}/{audio_duration:.1f}s)")
+                # Calcular duración útil: min(duración_restante_necesaria, duración_total_clip, segmento_máximo)
+                remaining_needed = audio_duration - current_duration
+                usable_duration = min(clip.duration, max_clip_segment)
+                
+                # Si necesitamos más duración, tomamos hasta el final del clip o el max_clip_segment
+                if remaining_needed > 0:
+                    usable_duration = min(usable_duration, remaining_needed + min_clip_duration) # Añadir un poco extra si el último clip nos deja justos
+                    usable_duration = max(min_clip_duration, usable_duration) # Asegurar duración mínima si es posible
+
+                if usable_duration > min_clip_duration:
+                    # Asegurar que no excedemos la duración del clip fuente
+                    segment_duration = min(usable_duration, clip.duration)
+                    if segment_duration > min_clip_duration:
+                         clips.append(clip.subclip(0, segment_duration))
+                         current_duration += segment_duration
+                         logger.debug(f"Clip añadido: {segment_duration:.1f}s (total video: {current_duration:.1f}/{audio_duration:.1f}s)")
+                    else:
+                         logger.debug(f"Clip {path} es demasiado corto ({clip.duration:.1f}s) para añadir un segmento útil.")
+                else:
+                    logger.debug(f"Clip {path} demasiado corto ({clip.duration:.1f}s) o no necesita más duración.")
+                
+                # Cerrar clip para liberar recursos
+                clip.close() 
+
             except Exception as e:
-                logger.warning(f"Error procesando video {path}: {str(e)}")
-        
+                logger.warning(f"Error procesando video clip {path}: {str(e)}", exc_info=True)
+                # Continuar con el siguiente clip si hay un error con este
+                continue
+
         if not clips:
-            logger.error("No hay clips válidos para crear el video")
-            raise ValueError("No hay clips válidos para crear el video")
+            logger.error("No hay clips de video válidos para crear la secuencia.")
+            raise ValueError("No hay clips de video válidos para crear el video.")
         
+        logger.info(f"Concatenando {len(clips)} clips de video.")
         video_base = concatenate_videoclips(clips, method="compose")
-        logger.info(f"Duración base del video: {video_base.duration:.2f}s")
+        logger.info(f"Duración base del video concatenado: {video_base.duration:.2f}s")
         
+        # Asegurar que el video base tenga al menos la duración del audio
         if video_base.duration < audio_duration:
+            # Calcular cuántas veces se necesita repetir el video base o parte de él
+            # Un método simple es repetir el video base completo
             num_repeats = math.ceil(audio_duration / video_base.duration)
-            logger.info(f"Repitiendo video {num_repeats} veces para ajustar duración")
-            video_base = concatenate_videoclips([video_base] * num_repeats).subclip(0, audio_duration)
-        
+            logger.info(f"Repitiendo video base ({video_base.duration:.2f}s) {num_repeats} veces para alcanzar {audio_duration:.2f}s.")
+            repeated_clips = [video_base] * num_repeats
+            video_base = concatenate_videoclips(repeated_clips, method="compose").subclip(0, audio_duration)
+            logger.info(f"Duración del video base ajustada: {video_base.duration:.2f}s")
+
+        # Si el video base es más largo que el audio (puede pasar si el último clip añadido fue largo)
+        # Recortarlo exactamente a la duración del audio
+        if video_base.duration > audio_duration:
+             logger.info(f"Recortando video base ({video_base.duration:.2f}s) a la duración del audio ({audio_duration:.2f}s).")
+             video_base = video_base.subclip(0, audio_duration)
+             logger.info(f"Duración final del video base: {video_base.duration:.2f}s")
+
+
         # 6. Manejar música de fondo
         logger.info("Procesando audio...")
-        final_audio = audio_tts
+        final_audio = audio_tts # El audio base es la voz TTS
         
         if musica_file:
             try:
-                music_path = os.path.join(temp_dir, "musica.mp3")
+                # Copiar archivo de música a un lugar temporal seguro
+                music_path = os.path.join(temp_dir_intermediate, "musica_bg.mp3")
                 shutil.copyfile(musica_file, music_path)
-                temp_files.append(music_path)
-                logger.info(f"Música copiada a: {music_path}")
+                temp_intermediate_files.append(music_path) # Añadir para limpieza
+                logger.info(f"Música de fondo copiada a: {music_path}")
                 
                 musica_audio = AudioFileClip(music_path)
                 logger.debug(f"Duración música original: {musica_audio.duration:.2f}s")
                 
-                if musica_audio.duration < audio_duration:
-                    musica_audio = loop_audio_to_length(musica_audio, audio_duration)
-                    logger.debug(f"Música looped: {musica_audio.duration:.2f}s")
+                # Ajustar duración de la música al video final (que ya tiene la duración del audio TTS)
+                musica_audio = loop_audio_to_length(musica_audio, video_base.duration)
+                logger.debug(f"Música ajustada a duración del video: {musica_audio.duration:.2f}s")
                 
+                # Mezclar voz y música. Ajusta los volúmenes según prefieras.
                 final_audio = CompositeAudioClip([
-                    musica_audio.volumex(0.3),
-                    audio_tts.volumex(1.0)
+                    musica_audio.volumex(0.2), # Volumen bajo para la música
+                    audio_tts.volumex(1.0)     # Volumen normal para la voz
                 ])
-                logger.info("Mezcla de audio completada")
+                logger.info("Mezcla de audio completada (voz + música).")
             except Exception as e:
-                logger.warning(f"Error procesando música: {str(e)}")
-        
+                logger.warning(f"Error procesando música de fondo: {str(e)}", exc_info=True)
+                # Si falla la música, simplemente usamos el audio TTS
+                final_audio = audio_tts
+                logger.warning("Usando solo audio de voz debido a un error con la música.")
+
+        # Asegurar que el audio final tenga exactamente la misma duración que el video base
+        if final_audio.duration > video_base.duration:
+             final_audio = final_audio.subclip(0, video_base.duration)
+        elif final_audio.duration < video_base.duration:
+             # Esto no debería pasar si loop_audio_to_length funciona, pero como seguridad
+             logger.warning("La duración del audio final es menor que la del video base. Intentando ajustar.")
+             # Podría re-ajustar o logear error más severo
+             # Para evitar errores en write_videofile, es mejor que el audio no sea más corto
+             # Si es más corto, moviepy suele extender el último frame de audio, lo cual es feo pero funciona.
+             # No intentaremos extenderlo aquí automáticamente para evitar complejidad, MoviePy lo manejará.
+             pass # MoviePy manejará la diferencia de duración
+
         # 7. Crear video final
         logger.info("Renderizando video final...")
         video_final = video_base.set_audio(final_audio)
-        output_path = os.path.join(temp_dir, "final_video.mp4")
         
+        # Gradio maneja directorios temporales para los outputs.
+        # Podemos escribir directamente en un archivo temporal dentro de la carpeta temporal de Gradio.
+        # Si no estamos en un entorno Gradio, podríamos usar un tempfile normal.
+        # Por simplicidad y compatibilidad con Gradio, devolveremos el path absoluto.
+        # El directorio temporal creado por tempfile.mkdtemp() EXISTIRÁ cuando la función retorne
+        # porque hemos eliminado la línea que lo borraba. Gradio debería poder leerlo.
+        # Si queremos un archivo temporal más "formal" de Gradio, necesitaríamos que Gradio
+        # nos pasara un path temporal. La forma actual de retornar el path debería funcionar
+        # ahora que no borramos el directorio.
+
+        # Asegurar que el directorio para el output existe si no es temp_dir_intermediate
+        # output_filename = f"final_video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
+        # # Si queremos que el archivo no esté en temp_dir_intermediate, podríamos usar otro temp_dir
+        # # o un path fijo para prueba. Para Gradio, devolver el path en temp_dir_intermediate
+        # # FUNCIONARÁ si temp_dir_intermediate NO SE BORRA.
+        # output_path = os.path.join(temp_dir_intermediate, output_filename)
+
+        # Dejar el nombre y path original dentro del temp_dir_intermediate,
+        # pero ASEGURARSE de que el rmtree del finally está COMENTADO/ELIMINADO.
+        output_filename = "final_video.mp4"
+        output_path = os.path.join(temp_dir_intermediate, output_filename)
+        logger.info(f"Escribiendo video final a: {output_path}")
+
         video_final.write_videofile(
             output_path,
             fps=24,
-            threads=4,
-            codec="libx264",
-            audio_codec="aac",
-            preset="medium",
-            logger=None
+            threads=4, # Usa un número razonable de hilos
+            codec="libx264", # Codec estándar compatible
+            audio_codec="aac", # Codec de audio estándar
+            preset="medium", # Balance entre velocidad y tamaño/calidad
+            # CORRECCIÓN: Mostrar log de MoviePy para debugging
+            logger='bar' # Muestra una barra de progreso y mensajes de FFmpeg
+            # logger='log' # Muestra mensajes detallados de FFmpeg
         )
         
         total_time = (datetime.now() - start_time).total_seconds()
-        logger.info(f"VIDEO FINALIZADO: {output_path} | Tiempo total: {total_time:.2f}s")
-        return output_path
+        logger.info(f"PROCESO DE VIDEO FINALIZADO | Output: {output_path} | Tiempo total: {total_time:.2f}s")
         
+        # Cerrar clips para liberar recursos
+        video_base.close()
+        audio_tts.close()
+        if musica_file: musica_audio.close()
+        video_final.close()
+
+        return output_path # Retornar el path del archivo generado
+
+    except ValueError as ve:
+         logger.error(f"ERROR CONTROLADO en crear_video: {str(ve)}")
+         # Asegurar que se cierran los clips abiertos antes de relanzar
+         # (Esto es mejor hacerlo en el finally, pero aquí es una capa extra)
+         try:
+             if 'video_base' in locals() and video_base is not None: video_base.close()
+             if 'audio_tts' in locals() and audio_tts is not None: audio_tts.close()
+             if 'musica_audio' in locals() and musica_audio is not None: musica_audio.close()
+             if 'video_final' in locals() and video_final is not None: video_final.close()
+         except: pass # Ignore errors during cleanup before re-raise
+         raise ve # Rellenar la excepción para que la atrape run_app
+
     except Exception as e:
-        logger.error(f"ERROR EN CREAR_VIDEO: {str(e)}", exc_info=True)
-        raise
-    finally:
-        logger.info("Limpiando archivos temporales...")
-        for path in temp_files:
-            try:
-                if os.path.isfile(path):
-                    os.remove(path)
-            except Exception as e:
-                logger.warning(f"No se pudo eliminar {path}: {str(e)}")
-        
+        logger.critical(f"ERROR CRÍTICO NO CONTROLADO en crear_video: {str(e)}", exc_info=True)
+        # Asegurar que se cierran los clips abiertos antes de relanzar
         try:
-            shutil.rmtree(temp_dir, ignore_errors=True)
-        except Exception as e:
-            logger.warning(f"No se pudo eliminar {temp_dir}: {str(e)}")
+            if 'video_base' in locals() and video_base is not None: video_base.close()
+            if 'audio_tts' in locals() and audio_tts is not None: audio_tts.close()
+            if 'musica_audio' in locals() and musica_audio is not None: musica_audio.close()
+            if 'video_final' in locals() and video_final is not None: video_final.close()
+        except: pass # Ignore errors during cleanup before re-raise
+        raise e # Rellenar la excepción
+
+    finally:
+        logger.info("Iniciando limpieza de archivos temporales intermedios...")
+        # Limpiar solo los archivos listados como temporales intermedios
+        if temp_dir_intermediate and os.path.exists(temp_dir_intermediate):
+             # Asegurarse de que el archivo de video final *no* sea borrado si está en esta lista por error
+             final_output_in_temp = os.path.join(temp_dir_intermediate, "final_video.mp4")
+             
+             for path in temp_intermediate_files:
+                 try:
+                     if os.path.isfile(path) and path != final_output_in_temp: # No borrar el archivo final
+                         logger.debug(f"Eliminando archivo temporal: {path}")
+                         os.remove(path)
+                     elif os.path.isdir(path): # Limpieza defensiva, aunque no deberíamos tener directorios aquí
+                         logger.warning(f"Intentando eliminar directorio listado como archivo temporal: {path}")
+                         shutil.rmtree(path, ignore_errors=True)
+                 except Exception as e:
+                     logger.warning(f"No se pudo eliminar archivo temporal {path}: {str(e)}")
+            
+             # CORRECCIÓN CRÍTICA: NO eliminar el directorio temporal completo con rmtree.
+             # Este directorio contiene el video final que Gradio necesita leer.
+             # El sistema operativo se encargará de limpiar los directorios temporales abandonados
+             # con el tiempo, o puedes implementar una limpieza más sofisticada si es necesario
+             # para archivos *muy* viejos, pero NO lo hagas inmediatamente después de crear el archivo.
+             # shutil.rmtree(temp_dir_intermediate, ignore_errors=True) # COMENTADO/ELIMINADO intencionadamente
+             logger.info(f"Directorio temporal intermedio {temp_dir_intermediate} persistirá para que Gradio lea el video final.")
+
 
 # [FUNCIÓN RUN_APP ORIGINAL CON LOGS]
 def run_app(prompt_type, prompt_ia, prompt_manual, musica_file):
     logger.info("="*80)
     logger.info("SOLICITUD RECIBIDA EN INTERFAZ")
-    input_text = prompt_ia if prompt_type == "Generar Guion con IA" else prompt_manual
     
-    if not input_text.strip():
-        logger.warning("Texto de entrada vacío")
-        return None, "Por favor ingresa texto"
+    input_text = prompt_ia if prompt_type == "Generar Guion con IA" else prompt_manual
     
+    if not input_text or not input_text.strip():
+        logger.warning("Texto de entrada vacío.")
+        # Asegurarse de devolver None para el video y un mensaje de error
+        return None, gr.update(value="⚠️ Por favor, ingresa texto para el guion o el tema.")
+
+    # Gradio actualiza la interfaz, no necesitamos un primer return para "Procesando..." aquí,
+    # el .then() encadenado en la interfaz ya maneja eso.
+    logger.info(f"Tipo de entrada: {prompt_type}")
+    logger.debug(f"Texto de entrada: '{input_text[:100]}...'")
+    if musica_file:
+        logger.info(f"Archivo de música recibido: {musica_file}")
+    else:
+        logger.info("No se proporcionó archivo de música.")
+
     try:
-        logger.info("Iniciando creación de video...")
+        logger.info("Llamando a crear_video...")
         video_path = crear_video(prompt_type, input_text, musica_file)
-        logger.info("Video creado exitosamente")
-        return video_path, "✅ Video generado exitosamente"
+        
+        if video_path and os.path.exists(video_path):
+            logger.info(f"Función crear_video retornó path: {video_path}")
+            logger.info(f"Tamaño del archivo de video retornado: {os.path.getsize(video_path)} bytes")
+            return video_path, gr.update(value="✅ Video generado exitosamente.", interactive=False)
+        else:
+            logger.error(f"crear_video no retornó un path válido o el archivo no existe: {video_path}")
+            return None, gr.update(value="❌ Error: La generación del video falló o el archivo no se creó correctamente.", interactive=False)
+
     except ValueError as ve:
-        logger.warning(f"Error de validación: {str(ve)}")
-        return None, f"⚠️ {ve}"
+        logger.warning(f"Error de validación durante la creación del video: {str(ve)}")
+        return None, gr.update(value=f"⚠️ Error de validación: {str(ve)}", interactive=False)
     except Exception as e:
-        logger.error(f"Error crítico: {str(e)}", exc_info=True)
-        return None, f"❌ Error: {str(e)}"
+        logger.critical(f"Error crítico durante la creación del video: {str(e)}", exc_info=True)
+        return None, gr.update(value=f"❌ Error inesperado: {str(e)}", interactive=False)
+    finally:
+        logger.info("Fin del handler run_app.")
+
 
 # [INTERFAZ DE GRADIO ORIGINAL COMPLETA]
 with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="""
@@ -429,35 +742,39 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
     """) as app:
     
     gr.Markdown("# 🎬 Generador Automático de Videos con IA")
+    gr.Markdown("Genera videos cortos a partir de un tema o guion, usando imágenes de archivo de Pexels y voz generada.")
     
     with gr.Row():
         with gr.Column():
             prompt_type = gr.Radio(
-                ["Generar Guion con IA", "Usar Mi Guion"], 
+                ["Generar Guion con IA", "Usar Mi Guion"],
                 label="Método de Entrada",
-                value="Generar Guion con IA"
+                value="Generar Guion con IA" # Valor por defecto
             )
             
             with gr.Column(visible=True) as ia_guion_column:
                 prompt_ia = gr.Textbox(
                     label="Tema para IA", 
                     lines=2,
-                    placeholder="Ej: Un paisaje natural con montañas y ríos...",
-                    max_lines=4
+                    placeholder="Ej: Un paisaje natural con montañas y ríos al amanecer, mostrando la belleza de la naturaleza...",
+                    max_lines=4,
+                    value="" # Inicializar vacío
                 )
             
             with gr.Column(visible=False) as manual_guion_column:
                 prompt_manual = gr.Textbox(
                     label="Tu Guion Completo", 
                     lines=5,
-                    placeholder="Ej: En este video exploraremos los misterios del océano...",
-                    max_lines=10
+                    placeholder="Ej: En este video exploraremos los misterios del océano. Veremos la vida marina fascinante y los arrecifes de coral vibrantes. ¡Acompáñanos en esta aventura subacuática!",
+                    max_lines=10,
+                    value="" # Inicializar vacío
                 )
             
             musica_input = gr.Audio(
                 label="Música de fondo (opcional)",
                 type="filepath",
-                interactive=True
+                interactive=True,
+                value=None # Inicializar vacío
             )
             
             generate_btn = gr.Button("✨ Generar Video", variant="primary")
@@ -465,16 +782,18 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
         with gr.Column():
             video_output = gr.Video(
                 label="Video Generado", 
-                interactive=False,
-                height=400
+                interactive=False, # No interactivo para el usuario
+                height=400 # Altura fija
             )
             status_output = gr.Textbox(
                 label="Estado", 
-                interactive=False,
-                show_label=False,
-                placeholder="Esperando acción..."
+                interactive=False, # Solo lectura
+                show_label=False, # No mostrar la etiqueta "Estado"
+                placeholder="Esperando acción...",
+                value="Esperando entrada..." # Estado inicial
             )
 
+    # Lógica para mostrar/ocultar campos de texto según el tipo de prompt
     prompt_type.change(
         lambda x: (gr.update(visible=x == "Generar Guion con IA"), 
                    gr.update(visible=x == "Usar Mi Guion")),
@@ -482,11 +801,17 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
         outputs=[ia_guion_column, manual_guion_column]
     )
 
+    # Lógica para el botón de generar video
+    # Primero, actualizar el estado a "Procesando..."
+    # Luego, llamar a la función run_app
     generate_btn.click(
-        lambda: (None, "⏳ Procesando... (esto puede tomar 2-5 minutos)"),
+        # La primera acción (sincrona) actualiza el estado y limpia el video anterior
+        lambda: (None, gr.update(value="⏳ Procesando... Esto puede tomar 2-5 minutos dependiendo de la longitud y recursos.", interactive=False)),
         outputs=[video_output, status_output],
-        queue=False
+        queue=True, # Poner en cola si hay varias peticiones
+        # preprocess=False, # No pre-procesar para esta primera acción
     ).then(
+        # La segunda acción (asincrona) ejecuta la función principal de generación
         run_app,
         inputs=[prompt_type, prompt_ia, prompt_manual, musica_input],
         outputs=[video_output, status_output]
@@ -494,18 +819,49 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
 
     gr.Markdown("### Instrucciones:")
     gr.Markdown("""
-    1. **Selecciona el tipo de entrada**: 
-        - "Generar Guion con IA": Describe un tema
-        - "Usar Mi Guion": Escribe tu guion completo
-    2. **Sube música** (opcional): Selecciona un archivo de audio
-    3. **Haz clic en Generar Video"
-    4. Espera a que se procese el video (puede tomar varios minutos)
+    1.  **Clave API de Pexels:** Asegúrate de haber configurado la variable de entorno `PEXELS_API_KEY` con tu clave.
+    2.  **Selecciona el tipo de entrada**:
+        -   "Generar Guion con IA": Describe brevemente un tema (ej. "La belleza de las montañas"). La IA generará un guion corto.
+        -   "Usar Mi Guion": Escribe el guion completo que quieres para el video.
+    3.  **Sube música** (opcional): Selecciona un archivo de audio (MP3, WAV, etc.) para usar como música de fondo.
+    4.  **Haz clic en "✨ Generar Video"**.
+    5.  Espera a que se procese el video. El tiempo de espera puede variar. Verás el estado en el cuadro de texto.
+    6.  Si hay errores, revisa el log `video_generator_full.log` para más detalles.
     """)
+    gr.Markdown("---")
+    gr.Markdown("Desarrollado por [Tu Nombre/Empresa/Alias - Opcional]") # Añade tu nombre o un alias si quieres
 
 if __name__ == "__main__":
+    # Verificar si FFmpeg está instalado (MoviePy lo requiere)
+    # Puedes añadir esta verificación aquí
+    logger.info("Verificando dependencias críticas...")
+    try:
+        # moviepy intenta encontrar ffmpeg, si falla, lanzar error
+        # from moviepy.config import get_setting
+        # ffmpeg_path = get_setting("FFMPEG_BINARY")
+        # if not os.path.exists(ffmpeg_path):
+        #      logger.critical(f"FFmpeg no encontrado en {ffmpeg_path}. Instálalo y/o configura la variable FFMPEG_BINARY.")
+        #      # raise RuntimeError("FFmpeg no está instalado o configurado correctamente.")
+        # else:
+        #     logger.info(f"FFmpeg encontrado en {ffmpeg_path}")
+        
+        # Una forma más simple es intentar importar algo que use FFmpeg
+        try:
+            from moviepy.editor import VideoFileClip
+            # No cargamos un archivo real, solo verificamos que el import no falle por FFmpeg
+            logger.info("MoviePy importado correctamente. FFmpeg parece accesible.")
+        except Exception as e:
+             logger.critical(f"Fallo al importar MoviePy, a menudo indica problemas con FFmpeg. Asegúrate de tenerlo instalado y en el PATH. Error: {e}")
+             # raise RuntimeError("MoviePy/FFmpeg dependency issue.")
+
+    except Exception as e:
+         logger.warning(f"No se pudo verificar FFmpeg automáticamente: {e}") # Esto no debería detener el script, solo advertir
+
     logger.info("Iniciando aplicación Gradio...")
     try:
-        app.launch(server_name="0.0.0.0", server_port=7860)
+        # Usa share=True para obtener un enlace público si lo necesitas para probar fuera de localhost
+        # No uses share=True en producción sin medidas de seguridad adecuadas
+        app.launch(server_name="0.0.0.0", server_port=7860, share=False)
     except Exception as e:
         logger.critical(f"No se pudo iniciar la app: {str(e)}", exc_info=True)
-        raise
+        raise # Relanzar la excepción para ver el traceback completo si falla al iniciar