Update app.py

app.py

@@ -7,21 +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
-# 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
-# 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
+from collections import Counter
 
-# Configuración de logging MEJORADA
+# Logging configuration
 logging.basicConfig(
     level=logging.DEBUG,
     format='%(asctime)s - %(levelname)s - %(message)s',
@@ -32,52 +27,46 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 logger.info("="*80)
-logger.info("INICIO DE EJECUCIÓN - GENERADOR DE VIDEOS")
+logger.info("STARTING VIDEO GENERATOR EXECUTION")
 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
 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")
-    # 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
+    logger.critical("PEXELS_API_KEY environment variable not found.")
+    # logger.warning("Continuing without PEXELS_API_KEY. Video search will fail.")
+    # raise ValueError("Pexels API key not configured") # Uncomment to force fail if not set
+
+# Model Initialization
 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
+logger.info(f"Initializing GPT-2 model: {MODEL_NAME}")
+tokenizer = None
+model = None
 try:
-    # 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")
+    logger.info(f"GPT-2 model loaded | Vocab size: {len(tokenizer)}")
 except Exception as e:
-    logger.error(f"FALLA CRÍTICA al cargar GPT-2: {str(e)}", exc_info=True)
-    tokenizer = model = None # Asegurar que queden como None
+    logger.error(f"CRITICAL FAILURE loading GPT-2: {str(e)}", exc_info=True)
+    tokenizer = model = None
 
-logger.info("Cargando modelo KeyBERT...")
-kw_model = None # Inicializar a None por si falla
+logger.info("Loading KeyBERT model...")
+kw_model = None
 try:
     kw_model = KeyBERT('distilbert-base-multilingual-cased')
-    logger.info("KeyBERT inicializado correctamente")
+    logger.info("KeyBERT initialized successfully")
 except Exception as e:
-    logger.error(f"FALLA al cargar KeyBERT: {str(e)}", exc_info=True)
-    kw_model = None # Asegurar que quede como None
+    logger.error(f"FAILURE loading KeyBERT: {str(e)}", exc_info=True)
+    kw_model = 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.")
+        logger.warning("Cannot search Pexels: API Key not configured.")
         return []
 
-    logger.debug(f"Buscando en Pexels: '{query}' | Resultados: {per_page}")
+    logger.debug(f"Searching Pexels: '{query}' | Results per page: {per_page}")
     headers = {"Authorization": api_key}
     try:
         params = {
@@ -87,368 +76,301 @@ def buscar_videos_pexels(query, api_key, per_page=5):
             "size": "medium"
         }
         
-        logger.debug(f"Params: {params}")
         response = requests.get(
             "https://api.pexels.com/videos/search",
             headers=headers,
             params=params,
             timeout=20
         )
-        response.raise_for_status() # Lanza una excepción para códigos de estado de error HTTP
-
-        try:
-            data = response.json()
-            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 recibido | Status: {response.status_code} | Respuesta: {response.text[:200]}...")
-            return []
+        response.raise_for_status()
+        
+        data = response.json()
+        videos = data.get('videos', [])
+        logger.info(f"Pexels: Found {len(videos)} videos for '{query}'")
+        return videos
             
     except requests.exceptions.RequestException as e:
-        logger.error(f"Error de conexión Pexels para '{query}': {str(e)}")
+        logger.error(f"Pexels connection error for '{query}': {str(e)}")
+    except json.JSONDecodeError:
+        logger.error(f"Pexels: Invalid JSON received | Status: {response.status_code} | Response: {response.text[:200]}...")
     except Exception as e:
-        logger.error(f"Error inesperado Pexels para '{query}': {str(e)}", exc_info=True)
+        logger.error(f"Unexpected Pexels error for '{query}': {str(e)}", exc_info=True)
     
     return []
 
-# [FUNCIÓN GENERATE_SCRIPT ORIGINAL CON LOGS]
 def generate_script(prompt, max_length=150):
-    logger.info(f"Generando guión | Prompt: '{prompt[:50]}...' | Longitud máxima: {max_length}")
+    logger.info(f"Generating script | Prompt: '{prompt[:50]}...' | Max length: {max_length}")
     if not tokenizer or not model:
-        logger.warning("Modelos GPT-2 no disponibles - Usando prompt original como guion.")
+        logger.warning("GPT-2 models not available - Using original prompt as script.")
         return prompt
     
     try:
-        # 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.")
-
+        enhanced_prompt = f"Escribe un guion corto, interesante y coherente sobre: {prompt}"
         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, # Permite creatividad
+            do_sample=True,
             top_p=0.9,
             top_k=40,
             temperature=0.7,
-            repetition_penalty=1.2, # Reducido un poco para menos repetición agresiva
+            repetition_penalty=1.2,
             pad_token_id=tokenizer.pad_token_id,
             eos_token_id=tokenizer.eos_token_id,
-            no_repeat_ngram_size=3 # Ayuda a evitar repeticiones de frases cortas
+            no_repeat_ngram_size=3
         )
         
         text = tokenizer.decode(outputs[0], skip_special_tokens=True)
         
-        # Limpieza del texto
-        text = re.sub(r'<[^>]+>', '', text) # Elimina posibles tags HTML/XML si los hay
+        text = re.sub(r'<[^>]+>', '', text)
         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
+            if len(sentences) > 1 and sentences[1].strip() and len(final_text.split()) < max_length * 0.5:
                  final_text += " " + sentences[1].strip() + "."
-                 final_text = final_text.replace("..", ".") # Limpiar doble punto
+                 final_text = final_text.replace("..", ".")
 
-            logger.info(f"Guion generado (Truncado a 100 chars): '{final_text[:100]}...'")
-            return final_text.strip() # Asegurar que no haya espacios al inicio/fin
+            logger.info(f"Generated script (Truncated): '{final_text[:100]}...'")
+            return final_text.strip()
         
-        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
+        logger.info(f"Generated script (no full sentences detected): '{text[:100]}...'")
+        return text.strip()
+
     except Exception as e:
-        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
+        logger.error(f"Error generating script with GPT-2: {str(e)}", exc_info=True)
+        logger.warning("Using original prompt as script due to generation error.")
+        return prompt.strip()
 
-# [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} | Salida: {output_path}")
+    logger.info(f"Converting text to speech | Chars: {len(text)} | Voice: {voice} | Output: {output_path}")
     if not text or not text.strip():
-        logger.warning("Texto vacío para TTS")
+        logger.warning("Empty text for TTS")
         return False
         
     try:
         communicate = edge_tts.Communicate(text, voice)
         await communicate.save(output_path)
         
-        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")
+        if os.path.exists(output_path) and os.path.getsize(output_path) > 100:
+            logger.info(f"Audio saved successfully to: {output_path} | Size: {os.path.getsize(output_path)} bytes")
             return True
         else:
-            logger.error(f"TTS guardó un archivo pequeño o vacío en: {output_path}")
+            logger.error(f"TTS saved small or empty file to: {output_path}")
             return False
             
     except Exception as e:
-        logger.error(f"Error en TTS: {str(e)}", exc_info=True)
+        logger.error(f"Error in TTS: {str(e)}", exc_info=True)
         return False
 
-# [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 para descargar")
+        logger.warning("Video URL not provided for download")
         return None
     
     try:
-        logger.info(f"Descargando video desde: {url[:80]}...")
-        # Usar un nombre más robusto y asegurar que el directorio exista
+        logger.info(f"Downloading video from: {url[:80]}...")
         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)
         
-        # 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")
-
+            # total_size = int(r.headers.get('content-length', 0)) # Uncomment for progress logging
+            # downloaded_size = 0
             with open(output_path, 'wb') as f:
                 for chunk in r.iter_content(chunk_size=8192):
                     f.write(chunk)
-                    downloaded_size += len(chunk)
-                    # Opcional: loguear progreso si es muy lento
+                    # downloaded_size += len(chunk) # Uncomment for progress logging
 
-        # 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")
+        if os.path.exists(output_path) and os.path.getsize(output_path) > 1000:
+             logger.info(f"Video downloaded successfully: {output_path} | Size: {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")
+             logger.warning(f"Download seems incomplete or empty for {url[:80]}... File: {output_path} Size: {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
+                 os.remove(output_path)
              return None
 
     except requests.exceptions.RequestException as e:
-        logger.error(f"Error de descarga para {url[:80]}... : {str(e)}")
+        logger.error(f"Download error for {url[:80]}... : {str(e)}")
     except Exception as e:
-        logger.error(f"Error inesperado descargando {url[:80]}... : {str(e)}", exc_info=True)
+        logger.error(f"Unexpected error downloading {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")
+    logger.debug(f"Adjusting audio | Current duration: {audio_clip.duration:.2f}s | Target: {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
+        logger.warning("Audio clip has zero or negative duration, cannot loop.")
+        return AudioFileClip(filename="")
 
     if audio_clip.duration >= target_duration:
-        logger.debug("Clip de audio ya es más largo o igual al objetivo.")
+        logger.debug("Audio clip already longer or equal to target.")
         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")
+    logger.debug(f"Creating {loops} audio loops")
     
-    # 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")
+    logger.info("Extracting keywords from script")
     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
+        logger.warning("Empty script, cannot extract keywords.")
+        return ["naturaleza", "ciudad", "paisaje"]
 
-    # 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:
-            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
-            )
+            logger.debug("Attempting KeyBERT extraction...")
+            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)
             
-            # 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:
+                if formatted_keyword and formatted_keyword not in seen_keywords: # Ensure keyword is not empty
                     keywords_list.append(formatted_keyword)
                     seen_keywords.add(formatted_keyword)
-                if len(keywords_list) >= 5: # Limitar el número total de keywords
+                if len(keywords_list) >= 5:
                     break
 
             if keywords_list:
-                logger.debug(f"KeyBERT keywords extraídas: {keywords_list}")
+                logger.debug(f"KeyBERT extracted keywords: {keywords_list}")
                 return keywords_list
 
         except Exception as 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
+            logger.warning(f"KeyBERT failed: {str(e)}. Trying simple method.")
     
-    # Método simple de extracción si KeyBERT no está disponible o falló
-    logger.debug("Extrayendo keywords con método simple...")
+    logger.debug("Extracting keywords with simple method...")
     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"}
+    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", "porque", "aunque", "mientras", "siempre", "nunca", "jamás", "muy", "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", "quizá"}
 
-    # 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 valid_words:
-        logger.warning("No se encontraron palabras clave válidas con método simple. Usando palabras clave predeterminadas.")
+        logger.warning("No valid keywords found with simple method. Using default keywords.")
         return ["naturaleza", "ciudad", "paisaje"]
     
-    # 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.")
+         logger.warning("Simple method produced no keywords. Using default keywords.")
          return ["naturaleza", "ciudad", "paisaje"]
 
-    logger.info(f"Palabras clave finales: {top_keywords}")
+    logger.info(f"Final keywords: {top_keywords}")
     return top_keywords
 
-# [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.info(f"STARTING VIDEO CREATION | Type: {prompt_type}")
     logger.debug(f"Input: '{input_text[:100]}...'")
     
     start_time = datetime.now()
-    temp_dir_intermediate = None # Directorio para archivos temporales intermedios
-    output_video_path = None # Path para el video final fuera del directorio intermedio
-
+    temp_dir_intermediate = None
+    
     try:
-        # 1. Generar o usar guion
+        # 1. Generate or use script
         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
+            guion = input_text.strip()
 
-        logger.info(f"Guion final ({len(guion)} caracteres): '{guion[:100]}...'")
+        logger.info(f"Final script ({len(guion)} chars): '{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.")
+            logger.error("Resulting script is empty.")
+            raise ValueError("The script is empty.")
         
-        # 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
+        logger.info(f"Intermediate temporary directory created: {temp_dir_intermediate}")
+        temp_intermediate_files = []
 
-        # 2. Generar audio de voz
-        logger.info("Generando audio de voz...")
+        # 2. Generate voice audio
+        logger.info("Generating voice audio...")
         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 a partir del guion.")
-        temp_intermediate_files.append(voz_path) # Añadir para limpieza si la generación tuvo éxito
+            logger.error("Failed to generate voice audio.")
+            raise ValueError("Error generating voice audio.")
+        temp_intermediate_files.append(voz_path)
 
         audio_tts = AudioFileClip(voz_path)
         audio_duration = audio_tts.duration
-        logger.info(f"Duración audio voz: {audio_duration:.2f} segundos")
+        logger.info(f"Voice audio duration: {audio_duration:.2f} seconds")
 
         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
+             logger.warning(f"Voice audio duration ({audio_duration:.2f}s) is very short.")
 
-        # 3. Extraer palabras clave
-        logger.info("Extrayendo palabras clave...")
+        # 3. Extract keywords
+        logger.info("Extracting keywords...")
         try:
             keywords = extract_visual_keywords_from_script(guion)
-            logger.info(f"Palabras clave identificadas: {keywords}")
+            logger.info(f"Identified keywords: {keywords}")
         except Exception as e:
-            logger.error(f"Error extrayendo keywords: {str(e)}", exc_info=True)
-            keywords = ["naturaleza", "paisaje"] # Fallback si la extracción falla
+            logger.error(f"Error extracting keywords: {str(e)}", exc_info=True)
+            keywords = ["naturaleza", "paisaje"]
 
         if not keywords:
-             logger.warning("Lista de palabras clave vacía después de extracción y fallback.")
-             keywords = ["video", "background"] # Fallback final
+             keywords = ["video", "background"]
 
-        # 4. Buscar y descargar videos
-        logger.info("Buscando videos en Pexels...")
+        # 4. Search and download videos
+        logger.info("Searching videos on 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
+        total_desired_videos = 10
+        per_page_per_keyword = max(1, total_desired_videos // len(keywords))
 
         for keyword in keywords:
-            if len(videos_data) >= total_desired_videos: break # Dejar de buscar si ya tenemos suficientes
+            if len(videos_data) >= total_desired_videos: break
             try:
                 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}'. Total data: {len(videos_data)}")
+                    logger.info(f"Found {len(videos)} videos for '{keyword}'. Total data: {len(videos_data)}")
             except Exception as e:
-                logger.warning(f"Error buscando videos para '{keyword}': {str(e)}")
+                logger.warning(f"Error searching videos for '{keyword}': {str(e)}")
 
-        # 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
+        if len(videos_data) < total_desired_videos / 2:
+            logger.warning(f"Few videos found ({len(videos_data)}). Trying generic keywords.")
+            generic_keywords = ["nature", "city", "background", "abstract"]
             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) 
+                    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)}")
+                        logger.info(f"Found {len(videos)} videos for '{keyword}' (generic). Total data: {len(videos_data)}")
                  except Exception as e:
-                    logger.warning(f"Error buscando videos genéricos para '{keyword}': {str(e)}")
+                    logger.warning(f"Error searching generic videos for '{keyword}': {str(e)}")
 
 
         if not videos_data:
-            logger.error("No se encontraron videos en Pexels para ninguna palabra clave.")
-            raise ValueError("No se encontraron videos adecuados en Pexels.")
+            logger.error("No videos found on Pexels for any keyword.")
+            raise ValueError("No suitable videos found on Pexels.")
         
         video_paths = []
-        logger.info(f"Intentando descargar {len(videos_data)} videos encontrados...")
+        logger.info(f"Attempting to download {len(videos_data)} found videos...")
         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')}")
+                logger.debug(f"Skipping video without video files: {video.get('id')}")
                 continue
                 
             try:
-                # 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:
@@ -459,341 +381,287 @@ def crear_video(prompt_type, input_text, musica_file=None):
                     path = download_video_file(best_quality['link'], temp_dir_intermediate)
                     if path:
                         video_paths.append(path)
-                        temp_intermediate_files.append(path) # Añadir para limpieza
-                        logger.info(f"Video descargado OK desde {best_quality['link'][:50]}...")
+                        temp_intermediate_files.append(path)
+                        logger.info(f"Video downloaded OK from {best_quality['link'][:50]}...")
                     else:
-                         logger.warning(f"No se pudo descargar video desde {best_quality['link'][:50]}...")
+                         logger.warning(f"Could not download video from {best_quality['link'][:50]}...")
                 else:
-                    logger.warning(f"No se encontró enlace de descarga válido para video {video.get('id')}.")
+                    logger.warning(f"No valid download link found for video {video.get('id')}.")
 
             except Exception as e:
-                logger.warning(f"Error procesando/descargando video {video.get('id')}: {str(e)}")
+                logger.warning(f"Error processing/downloading video {video.get('id')}: {str(e)}")
 
-        logger.info(f"Descargados {len(video_paths)} archivos de video utilizables.")
+        logger.info(f"Downloaded {len(video_paths)} usable video files.")
         if not video_paths:
-            logger.error("No se pudo descargar ningún archivo de video utilizable.")
-            raise ValueError("No se pudo descargar ningún video utilizable de Pexels.")
+            logger.error("Could not download any usable video file.")
+            raise ValueError("Could not download any usable video from Pexels.")
         
-        # 5. Procesar y concatenar clips de video
-        logger.info("Procesando y concatenando videos descargados...")
+        # 5. Process and concatenate video clips
+        logger.info("Processing and concatenating downloaded videos...")
         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
+        min_clip_duration = 1.0
+        max_clip_segment = 8.0
 
-        for path in video_paths:
-            # 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: 
+        for i, path in enumerate(video_paths):
+            if current_duration >= audio_duration + max_clip_segment:
+                logger.debug(f"Video base sufficient ({current_duration:.1f}s >= {audio_duration:.1f}s + {max_clip_segment:.1f}s buffer). Stopping processing remaining source clips.")
                 break
 
+            clip = None
             try:
-                logger.debug(f"Abriendo clip: {path}")
+                logger.debug(f"[{i+1}/{len(video_paths)}] Opening clip: {path}")
                 clip = VideoFileClip(path)
-                
-                # Calcular duración útil: min(duración_restante_necesaria, duración_total_clip, segmento_máximo)
+
+                # Check clip validity after opening
+                if clip.reader is None or clip.duration is None or clip.duration <= 0:
+                    logger.warning(f"[{i+1}/{len(video_paths)}] Clip {path} seems invalid (reader is None or duration <= 0). Skipping.")
+                    continue
+
+                # Calculate how much to take from this clip
                 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
+                potential_use_duration = min(clip.duration, 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.")
+                     segment_duration = min(potential_use_duration, remaining_needed + min_clip_duration)
+                     segment_duration = max(min_clip_duration, segment_duration)
+                     segment_duration = min(segment_duration, clip.duration)
+
+                     if segment_duration >= min_clip_duration:
+                          try:
+                               sub = clip.subclip(0, segment_duration)
+                               clips.append(sub)
+                               current_duration += sub.duration 
+                               logger.debug(f"[{i+1}/{len(video_paths)}] Segment added: {sub.duration:.1f}s (total video: {current_duration:.1f}/{audio_duration:.1f}s)")
+                          except Exception as sub_e:
+                               logger.warning(f"[{i+1}/{len(video_paths)}] Error creating subclip from {path} ({segment_duration:.1f}s): {str(sub_e)}")
+                               continue
+                     else:
+                          logger.debug(f"[{i+1}/{len(video_paths)}] Clip {path} ({clip.duration:.1f}s) doesn't contribute sufficient segment ({segment_duration:.1f}s needed from it). Skipping.")
                 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() 
+                    logger.debug(f"[{i+1}/{len(video_paths)}] Video base duration already reached. Skipping clip.")
 
             except Exception as 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
+                logger.warning(f"[{i+1}/{len(video_paths)}] Error processing video {path}: {str(e)}", exc_info=True)
                 continue
 
+            finally:
+                if clip is not None:
+                    try:
+                        clip.close()
+                        logger.debug(f"[{i+1}/{len(video_paths)}] Clip {path} closed.")
+                    except Exception as close_e:
+                        logger.warning(f"[{i+1}/{len(video_paths)}] Error closing clip {path}: {str(close_e)}")
+
+
+        logger.info(f"Source clip processing finished. Obtained {len(clips)} valid clips.")
+
         if not clips:
-            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.error("No valid video clips available to create the sequence.")
+            raise ValueError("No valid video clips available to create the video.")
         
-        logger.info(f"Concatenando {len(clips)} clips de video.")
+        logger.info(f"Concatenating {len(clips)} video clips.")
         video_base = concatenate_videoclips(clips, method="compose")
-        logger.info(f"Duración base del video concatenado: {video_base.duration:.2f}s")
+        logger.info(f"Base video duration: {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 base ({video_base.duration:.2f}s) {num_repeats} veces para alcanzar {audio_duration:.2f}s.")
+            logger.info(f"Repeating base video ({video_base.duration:.2f}s) {num_repeats} times to reach {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")
+            logger.info(f"Adjusted base video duration: {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).")
+             logger.info(f"Trimming base video ({video_base.duration:.2f}s) to match audio duration ({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")
+             logger.info(f"Final base video duration: {video_base.duration:.2f}s")
 
 
-        # 6. Manejar música de fondo
-        logger.info("Procesando audio...")
-        final_audio = audio_tts # El audio base es la voz TTS
+        # 6. Handle background music
+        logger.info("Processing audio...")
+        final_audio = audio_tts
         
         if musica_file:
             try:
-                # 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_intermediate_files.append(music_path) # Añadir para limpieza
-                logger.info(f"Música de fondo copiada a: {music_path}")
+                temp_intermediate_files.append(music_path)
+                logger.info(f"Background music copied to: {music_path}")
                 
                 musica_audio = AudioFileClip(music_path)
-                logger.debug(f"Duración música original: {musica_audio.duration:.2f}s")
+                logger.debug(f"Original music duration: {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")
+                logger.debug(f"Music adjusted to video duration: {musica_audio.duration:.2f}s")
                 
-                # Mezclar voz y música. Ajusta los volúmenes según prefieras.
                 final_audio = CompositeAudioClip([
-                    musica_audio.volumex(0.2), # Volumen bajo para la música
-                    audio_tts.volumex(1.0)     # Volumen normal para la voz
+                    musica_audio.volumex(0.2),
+                    audio_tts.volumex(1.0)
                 ])
-                logger.info("Mezcla de audio completada (voz + música).")
+                logger.info("Audio mix completed (voice + music).")
             except Exception as 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
+                logger.warning(f"Error processing background music: {str(e)}", exc_info=True)
                 final_audio = audio_tts
-                logger.warning("Usando solo audio de voz debido a un error con la música.")
+                logger.warning("Using voice audio only due to music processing error.")
 
-        # 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...")
+
+
+        # 7. Create final video
+        logger.info("Rendering final video...")
         video_final = video_base.set_audio(final_audio)
         
-        # 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}")
+        logger.info(f"Writing final video to: {output_path}")
 
         video_final.write_videofile(
             output_path,
             fps=24,
-            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
+            threads=4,
+            codec="libx264",
+            audio_codec="aac",
+            preset="medium",
+            logger='bar' # Show MoviePy progress bar
         )
         
         total_time = (datetime.now() - start_time).total_seconds()
-        logger.info(f"PROCESO DE VIDEO FINALIZADO | Output: {output_path} | Tiempo total: {total_time:.2f}s")
+        logger.info(f"VIDEO PROCESS FINISHED | Output: {output_path} | Total time: {total_time:.2f}s")
         
-        # Cerrar clips para liberar recursos
-        video_base.close()
-        audio_tts.close()
-        if musica_file: musica_audio.close()
-        video_final.close()
+        # Close main clips
+        try:
+            video_base.close()
+            audio_tts.close()
+            if 'musica_audio' in locals() and musica_audio is not None: musica_audio.close()
+            video_final.close()
+        except Exception as e:
+            logger.warning(f"Error closing final clips: {str(e)}")
 
-        return output_path # Retornar el path del archivo generado
 
+        return output_path
+        
     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
-
+         logger.error(f"CONTROLLED ERROR in crear_video: {str(ve)}")
+         raise ve
     except Exception as 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:
-            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
-
+        logger.critical(f"CRITICAL UNHANDLED ERROR in crear_video: {str(e)}", exc_info=True)
+        raise e
     finally:
-        logger.info("Iniciando limpieza de archivos temporales intermedios...")
-        # Limpiar solo los archivos listados como temporales intermedios
+        logger.info("Starting cleanup of intermediate temporary files...")
         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}")
+                     if os.path.isfile(path) and path != final_output_in_temp:
+                         logger.debug(f"Deleting temporary file: {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)}")
+                     logger.warning(f"Could not delete temporary file {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.")
+             # IMPORTANT: DO NOT remove the temp_dir_intermediate itself.
+             # It contains the final video file needed by Gradio.
+             logger.info(f"Intermediate temporary directory {temp_dir_intermediate} will persist for Gradio to read the final video.")
 
 
-# [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")
+    logger.info("REQUEST RECEIVED IN INTERFACE")
     
     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
+        logger.warning("Empty input text.")
         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]}...'")
+    logger.info(f"Input Type: {prompt_type}")
+    logger.debug(f"Input Text: '{input_text[:100]}...'")
     if musica_file:
-        logger.info(f"Archivo de música recibido: {musica_file}")
+        logger.info(f"Music file received: {musica_file}")
     else:
-        logger.info("No se proporcionó archivo de música.")
+        logger.info("No music file provided.")
 
     try:
-        logger.info("Llamando a crear_video...")
+        logger.info("Calling crear_video...")
         video_path = crear_video(prompt_type, input_text, musica_file)
         
         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")
+            logger.info(f"crear_video returned path: {video_path}")
+            logger.info(f"Size of returned video file: {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}")
+            logger.error(f"crear_video did not return a valid path or file does not exist: {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 durante la creación del video: {str(ve)}")
+        logger.warning(f"Validation error during video creation: {str(ve)}")
         return None, gr.update(value=f"⚠️ Error de validación: {str(ve)}", interactive=False)
     except Exception as e:
-        logger.critical(f"Error crítico durante la creación del video: {str(e)}", exc_info=True)
+        logger.critical(f"Critical error during video creation: {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.")
+        logger.info("End of run_app handler.")
 
 
-# [INTERFAZ DE GRADIO ORIGINAL COMPLETA]
+# Gradio Interface
 with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="""
     .gradio-container {max-width: 800px; margin: auto;}
     h1 {text-align: center;}
     """) 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.")
+    gr.Markdown("# 🎬 Automatic AI Video Generator")
+    gr.Markdown("Generate short videos from a topic or script, using stock footage from Pexels and generated voice.")
     
     with gr.Row():
         with gr.Column():
             prompt_type = gr.Radio(
-                ["Generar Guion con IA", "Usar Mi Guion"],
-                label="Método de Entrada",
-                value="Generar Guion con IA" # Valor por defecto
+                ["Generar Guion con IA", "Usar Mi Guion"], 
+                label="Input Method",
+                value="Generar Guion con IA"
             )
             
             with gr.Column(visible=True) as ia_guion_column:
                 prompt_ia = gr.Textbox(
-                    label="Tema para IA", 
+                    label="Topic for AI", 
                     lines=2,
-                    placeholder="Ej: Un paisaje natural con montañas y ríos al amanecer, mostrando la belleza de la naturaleza...",
+                    placeholder="Ex: A natural landscape with mountains and rivers at sunrise, showing the beauty of nature...",
                     max_lines=4,
-                    value="" # Inicializar vacío
+                    value=""
                 )
             
             with gr.Column(visible=False) as manual_guion_column:
                 prompt_manual = gr.Textbox(
-                    label="Tu Guion Completo", 
+                    label="Your Full Script", 
                     lines=5,
-                    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!",
+                    placeholder="Ex: In this video, we will explore the mysteries of the ocean. We will see fascinating marine life and vibrant coral reefs. Join us on this underwater adventure!",
                     max_lines=10,
-                    value="" # Inicializar vacío
+                    value=""
                 )
             
             musica_input = gr.Audio(
-                label="Música de fondo (opcional)",
+                label="Background Music (optional)",
                 type="filepath",
                 interactive=True,
-                value=None # Inicializar vacío
+                value=None
             )
             
-            generate_btn = gr.Button("✨ Generar Video", variant="primary")
+            generate_btn = gr.Button("✨ Generate Video", variant="primary")
         
         with gr.Column():
             video_output = gr.Video(
-                label="Video Generado", 
-                interactive=False, # No interactivo para el usuario
-                height=400 # Altura fija
+                label="Generated Video", 
+                interactive=False,
+                height=400
             )
             status_output = gr.Textbox(
-                label="Estado", 
-                interactive=False, # Solo lectura
-                show_label=False, # No mostrar la etiqueta "Estado"
-                placeholder="Esperando acción...",
-                value="Esperando entrada..." # Estado inicial
+                label="Status", 
+                interactive=False,
+                show_label=False,
+                placeholder="Waiting for action...",
+                value="Waiting for input..."
             )
 
-    # 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")),
@@ -801,67 +669,41 @@ 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(
-        # 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)),
+        lambda: (None, gr.update(value="⏳ Processing... This can take 2-5 minutes depending on length and resources.", interactive=False)),
         outputs=[video_output, status_output],
-        queue=True, # Poner en cola si hay varias peticiones
-        # preprocess=False, # No pre-procesar para esta primera acción
+        queue=True,
     ).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]
     )
 
-    gr.Markdown("### Instrucciones:")
+    gr.Markdown("### Instructions:")
     gr.Markdown("""
-    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.
+    1.  **Pexels API Key:** Ensure you have set the `PEXELS_API_KEY` environment variable.
+    2.  **Select Input Method**:
+        -   "Generate Script with AI": Describe a topic (e.g., "The beauty of mountains"). AI will generate a short script.
+        -   "Use My Script": Write the full script for your video.
+    3.  **Upload Music** (optional): Select an audio file (MP3, WAV, etc.) for background music.
+    4.  **Click "✨ Generate Video"**.
+    5.  Wait for the video to process. Processing time may vary. Check the status box.
+    6.  If there are errors, check the `video_generator_full.log` file for details.
     """)
     gr.Markdown("---")
-    gr.Markdown("Desarrollado por [Tu Nombre/Empresa/Alias - Opcional]") # Añade tu nombre o un alias si quieres
+    gr.Markdown("Developed by [Your Name/Company/Alias - Optional]")
 
 if __name__ == "__main__":
-    # Verificar si FFmpeg está instalado (MoviePy lo requiere)
-    # Puedes añadir esta verificación aquí
-    logger.info("Verificando dependencias críticas...")
+    logger.info("Verifying critical dependencies...")
     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.")
-
+        from moviepy.editor import VideoFileClip
+        logger.info("MoviePy imported correctly. FFmpeg seems accessible.")
     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.critical(f"Failed to import MoviePy, often indicates FFmpeg issues. Ensure it is installed and in PATH. Error: {e}")
 
-    logger.info("Iniciando aplicación Gradio...")
+    logger.info("Starting Gradio app...")
     try:
-        # 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 # Relanzar la excepción para ver el traceback completo si falla al iniciar
+        logger.critical(f"Could not launch app: {str(e)}", exc_info=True)
+        raise