Update app.py

app.py

@@ -1,4 +1,27 @@
+python
 import os
+import subprocess
+import sys
+import importlib
+
+# Instalar dependencias faltantes
+required_packages = [
+    'moviepy',
+    'edge-tts',
+    'gradio',
+    'torch',
+    'transformers',
+    'keybert',
+    'requests'
+]
+
+for package in required_packages:
+    try:
+        importlib.import_module(package.replace('-', '_'))
+    except ImportError:
+        print(f"Instalando {package}...")
+        subprocess.check_call([sys.executable, "-m", "pip", "install", package])
+
 import asyncio
 import logging
 import tempfile
@@ -106,6 +129,7 @@ for text, voice_id in AVAILABLE_VOICES:
     if voice_id == DEFAULT_VOICE_ID:
         DEFAULT_VOICE_NAME = text
         break
+
 if DEFAULT_VOICE_ID not in [v[1] for v in AVAILABLE_VOICES]:
     DEFAULT_VOICE_ID = AVAILABLE_VOICES[0][1] if AVAILABLE_VOICES else "en-US-AriaNeural"
     DEFAULT_VOICE_NAME = AVAILABLE_VOICES[0][0] if AVAILABLE_VOICES else "Aria (United States) - Female"
@@ -118,6 +142,7 @@ if not PEXELS_API_KEY:
 
 MODEL_NAME = "datificate/gpt2-small-spanish"
 logger.info(f"Inicializando modelo GPT-2: {MODEL_NAME}")
+
 tokenizer = None
 model = None
 try:
@@ -176,13 +201,16 @@ def generate_script(prompt, max_length=150):
     if not tokenizer or not model:
         logger.warning("Modelos GPT-2 no disponibles - Usando prompt original como guion.")
         return prompt.strip()
+    
     instruction_phrase_start = "Escribe un guion corto, interesante y coherente sobre:"
     ai_prompt = f"{instruction_phrase_start} {prompt}"
+    
     try:
         inputs = tokenizer(ai_prompt, return_tensors="pt", truncation=True, max_length=512)
         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 + inputs[list(inputs.keys())[0]].size(1),
@@ -195,8 +223,10 @@ def generate_script(prompt, max_length=150):
             eos_token_id=tokenizer.eos_token_id,
             no_repeat_ngram_size=3
         )
+        
         text = tokenizer.decode(outputs[0], skip_special_tokens=True)
         cleaned_text = text.strip()
+        
         try:
             prompt_in_output_idx = text.lower().find(prompt.lower())
             if prompt_in_output_idx != -1:
@@ -213,12 +243,15 @@ def generate_script(prompt, max_length=150):
         except Exception as e:
             logger.warning(f"Error durante la limpieza heurística del guión de IA: {e}. Usando texto generado sin limpieza adicional.")
             cleaned_text = re.sub(r'<[^>]+>', '', text).strip()
+        
         if not cleaned_text or len(cleaned_text) < 10:
             logger.warning("El guión generado parece muy corto o vacío después de la limpieza heurística. Usando el texto generado original (sin limpieza adicional).")
             cleaned_text = re.sub(r'<[^>]+>', '', text).strip()
+        
         cleaned_text = re.sub(r'<[^>]+>', '', cleaned_text).strip()
         cleaned_text = cleaned_text.lstrip(':').strip()
         cleaned_text = cleaned_text.lstrip('.').strip()
+        
         sentences = cleaned_text.split('.')
         if sentences and sentences[0].strip():
             final_text = sentences[0].strip() + '.'
@@ -227,6 +260,7 @@ def generate_script(prompt, max_length=150):
                 final_text = final_text.replace("..", ".")
             logger.info(f"Guion generado final (Truncado a 100 chars): '{final_text[:100]}...'")
             return final_text.strip()
+        
         logger.info(f"Guion generado final (sin oraciones completas detectadas - Truncado): '{cleaned_text[:100]}...'")
         return cleaned_text.strip()
     except Exception as e:
@@ -261,11 +295,13 @@ def download_video_file(url, temp_dir):
         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=60) as r:
             r.raise_for_status()
             with open(output_path, 'wb') as f:
                 for chunk in r.iter_content(chunk_size=8192):
                     f.write(chunk)
+        
         if os.path.exists(output_path) and os.path.getsize(output_path) > 1000:
             logger.info(f"Video descargado exitosamente: {output_path} | Tamaño: {os.path.getsize(output_path)} bytes")
             return output_path
@@ -290,6 +326,7 @@ def loop_audio_to_length(audio_clip, target_duration):
         except Exception as e:
             logger.error(f"Could not create silence clip: {e}", exc_info=True)
             return AudioFileClip(filename="")
+    
     if audio_clip.duration >= target_duration:
         logger.debug("Audio clip already longer or equal to target. Trimming.")
         trimmed_clip = audio_clip.subclip(0, target_duration)
@@ -301,20 +338,24 @@ def loop_audio_to_length(audio_clip, target_duration):
                 pass
             return AudioFileClip(filename="")
         return trimmed_clip
+    
     loops = math.ceil(target_duration / audio_clip.duration)
     logger.debug(f"Creando {loops} loops de audio")
     audio_segments = [audio_clip] * loops
     looped_audio = None
     final_looped_audio = None
+    
     try:
         looped_audio = concatenate_audioclips(audio_segments)
         if looped_audio.duration is None or looped_audio.duration <= 0:
             logger.error("Concatenated audio clip is invalid (None or zero duration).")
             raise ValueError("Invalid concatenated audio.")
+        
         final_looped_audio = looped_audio.subclip(0, target_duration)
         if final_looped_audio.duration is None or final_looped_audio.duration <= 0:
             logger.error("Final subclipped audio clip is invalid (None or zero duration).")
             raise ValueError("Invalid final subclipped audio.")
+        
         return final_looped_audio
     except Exception as e:
         logger.error(f"Error concatenating/subclipping audio clips for looping: {str(e)}", exc_info=True)
@@ -338,8 +379,10 @@ def extract_visual_keywords_from_script(script_text):
     if not script_text or not script_text.strip():
         logger.warning("Guion vacío, no se pueden extraer palabras clave.")
         return ["naturaleza", "ciudad", "paisaje"]
+    
     clean_text = re.sub(r'[^\w\sáéíóúñÁÉÍÓÚÑ]', '', script_text)
     keywords_list = []
+    
     if kw_model:
         try:
             logger.debug("Intentando extracción con KeyBERT...")
@@ -347,6 +390,7 @@ def extract_visual_keywords_from_script(script_text):
             keywords2 = kw_model.extract_keywords(clean_text, keyphrase_ngram_range=(2, 2), stop_words='spanish', top_n=3)
             all_keywords = keywords1 + keywords2
             all_keywords.sort(key=lambda item: item[1], reverse=True)
+            
             seen_keywords = set()
             for keyword, score in all_keywords:
                 formatted_keyword = keyword.lower().replace(" ", "+")
@@ -355,25 +399,30 @@ def extract_visual_keywords_from_script(script_text):
                     seen_keywords.add(formatted_keyword)
                 if len(keywords_list) >= 5:
                     break
+            
             if keywords_list:
                 logger.debug(f"Palabras clave extraídas por KeyBERT: {keywords_list}")
                 return keywords_list
         except Exception as e:
             logger.warning(f"KeyBERT falló: {str(e)}. Intentando método simple.")
+    
     logger.debug("Extrayendo palabras clave con método simple...")
     words = clean_text.lower().split()
     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á"}
+    
     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.")
         return ["espiritual", "terror", "matrix", "arcontes", "galaxia", "creepy", "magia", "gangstalking","conspiracy",]
+    
     word_counts = Counter(valid_words)
     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 ["espiritual", "terror", "matrix", "arcontes", "galaxia", "creepy", "magia", "gangstalking","conspiracy",]
+    
     logger.info(f"Palabras clave finales: {top_keywords}")
     return top_keywords
 
@@ -383,6 +432,7 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
     logger.debug(f"Input: '{input_text[:100]}...'")
     logger.info(f"Voz seleccionada: {selected_voice}")
     start_time = datetime.now()
+    
     temp_dir_intermediate = None
     output_filename = None
     permanent_path = None
@@ -395,19 +445,24 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
     video_final = None
     source_clips = []
     clips_to_concatenate = []
+    
     try:
         if prompt_type == "Generar Guion con IA":
             guion = generate_script(input_text)
         else:
             guion = input_text.strip()
+        
         logger.info(f"Guion final ({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.")
+        
         temp_dir_intermediate = tempfile.mkdtemp(prefix="video_gen_intermediate_")
         logger.info(f"Directorio temporal intermedio creado: {temp_dir_intermediate}")
+        
         logger.info("Generando audio de voz...")
         voz_path = os.path.join(temp_dir_intermediate, "voz.mp3")
+        
         tts_voices_to_try = [selected_voice]
         fallback_juan = "es-ES-JuanNeural"
         fallback_elvira = "es-ES-ElviraNeural"
@@ -415,6 +470,7 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
             tts_voices_to_try.append(fallback_juan)
         if fallback_elvira and fallback_elvira != selected_voice and fallback_elvira not in tts_voices_to_try:
             tts_voices_to_try.append(fallback_elvira)
+        
         tts_success = False
         tried_voices = set()
         for current_voice in tts_voices_to_try:
@@ -430,9 +486,11 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
             except Exception as e:
                 logger.warning(f"Fallo al generar TTS con voz '{current_voice}': {str(e)}", exc_info=True)
                 pass
+        
         if not tts_success or not os.path.exists(voz_path) or os.path.getsize(voz_path) <= 100:
             logger.error("Fallo en la generación de voz después de todos los intentos. Archivo de audio no creado o es muy pequeño.")
             raise ValueError("Error generando voz a partir del guion (fallo de TTS).")
+        
         temp_intermediate_files.append(voz_path)
         audio_tts_original = AudioFileClip(voz_path)
         if audio_tts_original.reader is None or audio_tts_original.duration is None or audio_tts_original.duration <= 0:
@@ -450,12 +508,14 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
                 if voz_path in temp_intermediate_files:
                     temp_intermediate_files.remove(voz_path)
             raise ValueError("Audio de voz generado es inválido después de procesamiento inicial.")
+        
         audio_tts = audio_tts_original
         audio_duration = audio_tts_original.duration
         logger.info(f"Duración audio voz: {audio_duration:.2f} segundos")
         if audio_duration < 1.0:
             logger.error(f"Duración audio voz ({audio_duration:.2f}s) es muy corta.")
             raise ValueError("Generated voice audio is too short (min 1 second required).")
+        
         logger.info("Extrayendo palabras clave...")
         try:
             keywords = extract_visual_keywords_from_script(guion)
@@ -463,12 +523,15 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
         except Exception as e:
             logger.error(f"Error extrayendo keywords: {str(e)}", exc_info=True)
             keywords = ["naturaleza", "paisaje"]
+        
         if not keywords:
             keywords = ["video", "background"]
+        
         logger.info("Buscando videos en Pexels...")
         videos_data = []
         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
@@ -479,9 +542,11 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
                     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 len(videos_data) < total_desired_videos / 2:
             logger.warning(f"Pocos videos encontrados ({len(videos_data)}). Intentando con palabras clave genéricas.")
             generic_keywords = ["mystery", "alien", "ufo", "conspiracy", "paranormal", "supernatural", "horror", "fear", "suspense", "secret", "government", "cover_up", "simulation", "matrix", "apocalypse", "dystopian", "shadow", "occult", "unexplained", "creepy", "extraterrestrial", "abduction", "experiment", "secret_society", "illuminati", "new_world_order", "ancient_aliens", "ufo_sighting", "cryptid", "bigfoot", "loch_ness", "ghost", "haunting", "spirit", "demon", "possession", "exorcism", "witchcraft", "ritual", "cursed", "urban_legend", "myth", "legend", "folklore", "scary", "terror", "panic", "anxiety", "dread", "nightmare", "dark", "gloomy", "fog", "haunted", "cemetery", "asylum", "abandoned", "ruins", "underground", "tunnel", "bunker", "lab", "experiment", "government_secret", "mind_control", "brainwash", "propaganda", "surveillance", "spy", "whistleblower", "leak", "anonymous", "hack", "cyber", "virtual_reality", "ai", "artificial_intelligence", "robot", "cyborg", "apocalyptic", "post_apocalyptic", "zombie", "outbreak", "pandemic", "contagion", "biohazard", "radiation", "nuclear", "doomsday", "armageddon", "revelation", "prophecy", "symbolism", "hidden_meaning", "enigma", "puzzle", "code", "cipher", "mysterious", "unidentified", "anomaly", "glitch", "time_travel", "parallel_universe", "dimension", "portal"]
+            
             for keyword in generic_keywords:
                 if len(videos_data) >= total_desired_videos:
                     break
@@ -492,21 +557,26 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
                         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 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 = 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:
@@ -519,32 +589,40 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
                     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/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 archivo de video utilizable.")
             raise ValueError("No se pudo descargar ningún video utilizable de Pexels.")
+        
         logger.info("Procesando y concatenando videos descargados...")
         current_duration = 0
         min_clip_duration = 0.5
         max_clip_segment = 10.0
+        
         for i, path in enumerate(video_paths):
             if current_duration >= audio_duration + max_clip_segment:
                 logger.debug(f"Video base suficiente ({current_duration:.1f}s >= {audio_duration:.1f}s + {max_clip_segment:.1f}s buffer). Dejando de procesar clips fuente restantes.")
                 break
+            
             clip = None
             try:
                 logger.debug(f"[{i+1}/{len(video_paths)}] Abriendo clip: {path}")
                 clip = VideoFileClip(path)
                 source_clips.append(clip)
+                
                 if clip.reader is None or clip.duration is None or clip.duration <= 0:
                     logger.warning(f"[{i+1}/{len(video_paths)}] Clip fuente {path} parece inválido (reader is None o duración <= 0). Saltando.")
                     continue
+                
                 remaining_needed = audio_duration - current_duration
                 potential_use_duration = min(clip.duration, max_clip_segment)
+                
                 if remaining_needed > 0:
                     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)
@@ -555,6 +633,7 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
                                 except:
                                     pass
                                 continue
+                            
                             clips_to_concatenate.append(sub)
                             current_duration += sub.duration
                             logger.debug(f"[{i+1}/{len(video_paths)}] Segmento añadido: {sub.duration:.1f}s (total video: {current_duration:.1f}/{audio_duration:.1f}s)")
@@ -568,12 +647,15 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
             except Exception as e:
                 logger.warning(f"[{i+1}/{len(video_paths)}] Error procesando video {path}: {str(e)}", exc_info=True)
                 continue
+        
         logger.info(f"Procesamiento de clips fuente finalizado. Se obtuvieron {len(clips_to_concatenate)} segmentos válidos.")
         if not clips_to_concatenate:
             logger.error("No hay segmentos de video válidos disponibles para crear la secuencia.")
             raise ValueError("No hay segmentos de video válidos disponibles para crear el video.")
+        
         logger.info(f"Concatenando {len(clips_to_concatenate)} segmentos de video.")
         concatenated_base = None
+        
         try:
             concatenated_base = concatenate_videoclips(clips_to_concatenate, method="chain")
             logger.info(f"Duración video base después de concatenación inicial: {concatenated_base.duration:.2f}s")
@@ -590,12 +672,15 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
                 except:
                     pass
             clips_to_concatenate = []
+        
         video_base = concatenated_base
         final_video_base = video_base
+        
         if final_video_base.duration < audio_duration:
             logger.info(f"Video base ({final_video_base.duration:.2f}s) es más corto que el audio ({audio_duration:.2f}s). Repitiendo...")
             num_full_repeats = int(audio_duration // final_video_base.duration)
             remaining_duration = audio_duration % final_video_base.duration
+            
             repeated_clips_list = [final_video_base] * num_full_repeats
             if remaining_duration > 0:
                 try:
@@ -611,6 +696,7 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
                         logger.debug(f"Añadiendo segmento restante: {remaining_duration:.2f}s")
                 except Exception as e:
                     logger.warning(f"Error creando subclip para duración restante {remaining_duration:.2f}s: {str(e)}")
+            
             if repeated_clips_list:
                 logger.info(f"Concatenando {len(repeated_clips_list)} partes para repetición.")
                 video_base_repeated = None
@@ -620,6 +706,7 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
                     if video_base_repeated is None or video_base_repeated.duration is None or video_base_repeated.duration <= 0:
                         logger.critical("Video base repetido concatenado es inválido.")
                         raise ValueError("Fallo al crear video base repetido válido.")
+                    
                     if final_video_base is not video_base_repeated:
                         try:
                             final_video_base.close()
@@ -637,6 +724,7 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
                                     clip.close()
                                 except:
                                     pass
+        
         if final_video_base.duration > audio_duration:
             logger.info(f"Recortando video base ({final_video_base.duration:.2f}s) para que coincida con la duración del audio ({audio_duration:.2f}s).")
             trimmed_video_base = None
@@ -645,6 +733,7 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
                 if trimmed_video_base is None or trimmed_video_base.duration is None or trimmed_video_base.duration <= 0:
                     logger.critical("Video base recortado es inválido.")
                     raise ValueError("Fallo al crear video base recortado válido.")
+                
                 if final_video_base is not trimmed_video_base:
                     try:
                         final_video_base.close()
@@ -654,16 +743,21 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
             except Exception as e:
                 logger.critical(f"Error durante el recorte: {str(e)}", exc_info=True)
                 raise ValueError("Fallo durante el recorte de video.")
+        
         if final_video_base is None or final_video_base.duration is None or final_video_base.duration <= 0:
             logger.critical("Video base final es inválido antes de audio/escritura (None o duración cero).")
             raise ValueError("Video base final es inválido.")
+        
         if final_video_base.size is None or final_video_base.size[0] <= 0 or final_video_base.size[1] <= 0:
             logger.critical(f"Video base final tiene tamaño inválido: {final_video_base.size}. No se puede escribir video.")
             raise ValueError("Video base final tiene tamaño inválido antes de escribir.")
+        
         video_base = final_video_base
+        
         logger.info("Procesando audio...")
         final_audio = audio_tts_original
         musica_audio_looped = None
+        
         if musica_file:
             musica_audio_original = None
             try:
@@ -671,6 +765,7 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
                 shutil.copyfile(musica_file, music_path)
                 temp_intermediate_files.append(music_path)
                 logger.info(f"Música de fondo copiada a: {music_path}")
+                
                 musica_audio_original = AudioFileClip(music_path)
                 if musica_audio_original.reader is None or musica_audio_original.duration is None or musica_audio_original.duration <= 0:
                     logger.warning("Clip de música de fondo parece inválido o tiene duración cero. Saltando música.")
@@ -682,6 +777,7 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
                 else:
                     musica_audio_looped = loop_audio_to_length(musica_audio_original, video_base.duration)
                     logger.debug(f"Música ajustada a duración del video: {musica_audio_looped.duration:.2f}s")
+                    
                     if musica_audio_looped is None or musica_audio_looped.duration is None or musica_audio_looped.duration <= 0:
                         logger.warning("Clip de música de fondo loopeado es inválido. Saltando música.")
                         try:
@@ -689,11 +785,13 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
                         except:
                             pass
                         musica_audio_looped = None
+                
                 if musica_audio_looped:
                     composite_audio = CompositeAudioClip([
                         musica_audio_looped.volumex(0.2),
                         audio_tts_original.volumex(1.0)
                     ])
+                    
                     if composite_audio.duration is None or composite_audio.duration <= 0:
                         logger.warning("Clip de audio compuesto es inválido (None o duración cero). Usando solo audio de voz.")
                         try:
@@ -710,6 +808,7 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
                 final_audio = audio_tts_original
                 musica_audio = None
                 logger.warning("Usando solo audio de voz debido a un error con la música.")
+        
         if final_audio.duration is not None and abs(final_audio.duration - video_base.duration) > 0.2:
             logger.warning(f"Duración del audio final ({final_audio.duration:.2f}s) difiere significativamente del video base ({video_base.duration:.2f}s). Intentando recorte.")
             try:
@@ -731,10 +830,13 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
                         logger.warning("Audio final recortado para que coincida con la duración del video.")
             except Exception as e:
                 logger.warning(f"Error ajustando duración del audio final: {str(e)}")
+        
         video_final = video_base.set_audio(final_audio)
+        
         output_filename = f"video_{int(time.time())}.mp4"
         output_path = os.path.join(temp_dir_intermediate, output_filename)
         permanent_path = f"/tmp/{output_filename}"
+        
         video_final.write_videofile(
             output_path,
             fps=24,
@@ -748,21 +850,25 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
             ],
             logger='bar'
         )
+        
         try:
             shutil.copy(output_path, permanent_path)
             logger.info(f"Video guardado permanentemente en: {permanent_path}")
         except Exception as move_error:
             logger.error(f"Error moviendo archivo: {str(move_error)}. Usando path original.")
             permanent_path = output_path
+        
         try:
             video_final.close()
             if 'video_base' in locals() and video_base is not None and video_base is not video_final:
                 video_base.close()
         except Exception as close_error:
             logger.error(f"Error cerrando clips: {str(close_error)}")
+        
         total_time = (datetime.now() - start_time).total_seconds()
         logger.info(f"PROCESO DE VIDEO FINALIZADO | Output: {permanent_path} | Tiempo total: {total_time:.2f}s")
         return permanent_path
+    
     except ValueError as ve:
         logger.error(f"ERROR CONTROLADO en crear_video: {str(ve)}")
         raise ve
@@ -771,36 +877,43 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
         raise e
     finally:
         logger.info("Iniciando limpieza de clips y archivos temporales intermedios...")
+        
         for clip in source_clips:
             try:
                 clip.close()
             except Exception as e:
                 logger.warning(f"Error cerrando clip de video fuente en finally: {str(e)}")
+        
         for clip_segment in clips_to_concatenate:
             try:
                 clip_segment.close()
             except Exception as e:
                 logger.warning(f"Error cerrando segmento de video en finally: {str(e)}")
+        
         if musica_audio is not None:
             try:
                 musica_audio.close()
             except Exception as e:
                 logger.warning(f"Error cerrando musica_audio (procesada) en finally: {str(e)}")
+        
         if musica_audio_original is not None and musica_audio_original is not musica_audio:
             try:
                 musica_audio_original.close()
             except Exception as e:
                 logger.warning(f"Error cerrando musica_audio_original en finally: {str(e)}")
+        
         if audio_tts is not None and audio_tts is not audio_tts_original:
             try:
                 audio_tts.close()
             except Exception as e:
                 logger.warning(f"Error cerrando audio_tts (procesada) en finally: {str(e)}")
+        
         if audio_tts_original is not None:
             try:
                 audio_tts_original.close()
             except Exception as e:
                 logger.warning(f"Error cerrando audio_tts_original en finalmente: {str(e)}")
+        
         if video_final is not None:
             try:
                 video_final.close()
@@ -811,10 +924,12 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
                 video_base.close()
             except Exception as e:
                 logger.warning(f"Error cerrando video_base en finally: {str(e)}")
+        
         if temp_dir_intermediate and os.path.exists(temp_dir_intermediate):
             final_output_in_temp = None
             if output_filename:
                 final_output_in_temp = os.path.join(temp_dir_intermediate, output_filename)
+            
             for path in temp_intermediate_files:
                 try:
                     if os.path.isfile(path) and path != final_output_in_temp and path != permanent_path:
@@ -824,34 +939,43 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
                         logger.debug(f"Saltando eliminación del archivo de video final: {path}")
                 except Exception as e:
                     logger.warning(f"No se pudo eliminar archivo temporal intermedio {path}: {str(e)}")
+            
             logger.info(f"Directorio temporal intermedio {temp_dir_intermediate} persistirá para que Gradio lea el video final.")
 
 def run_app(prompt_type, prompt_ia, prompt_manual, musica_file, selected_voice):
     logger.info("="*80)
     logger.info("SOLICITUD RECIBIDA EN INTERFAZ")
+    
     input_text = prompt_ia if prompt_type == "Generar Guion con IA" else prompt_manual
     output_video = None
     output_file = None
     status_msg = gr.update(value="⏳ Procesando...", interactive=False)
+    
     if not input_text or not input_text.strip():
         logger.warning("Texto de entrada vacío.")
         return None, None, gr.update(value="⚠️ Por favor, ingresa texto para el guion o el tema.", interactive=False)
+    
     voice_ids_disponibles = [v[1] for v in AVAILABLE_VOICES]
     if selected_voice not in voice_ids_disponibles:
         logger.warning(f"Voz seleccionada inválida o no encontrada en la lista: '{selected_voice}'. Usando voz por defecto: {DEFAULT_VOICE_ID}.")
         selected_voice = DEFAULT_VOICE_ID
     else:
         logger.info(f"Voz seleccionada validada: {selected_voice}")
+    
     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.")
+    
     logger.info(f"Voz final a usar (ID): {selected_voice}")
+    
     try:
         logger.info("Llamando a crear_video...")
         video_path = crear_video(prompt_type, input_text, selected_voice, musica_file)
+        
         if video_path and os.path.exists(video_path):
             logger.info(f"crear_video retornó path: {video_path}")
             logger.info(f"Tamaño del archivo de video retornado: {os.path.getsize(video_path)} bytes")
@@ -861,12 +985,15 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_file, selected_voice):
         else:
             logger.error(f"crear_video no retornó un path válido o el archivo no existe: {video_path}")
             status_msg = 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)}")
         status_msg = 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)
         status_msg = gr.update(value=f"❌ Error inesperado: {str(e)}", interactive=False)
+    
     finally:
         logger.info("Fin del handler run_app.")
         return output_video, output_file, status_msg
@@ -875,8 +1002,10 @@ 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.")
+    
     with gr.Row():
         with gr.Column():
             prompt_type = gr.Radio(
@@ -884,6 +1013,7 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
                 label="Método de Entrada",
                 value="Generar Guion con IA"
             )
+            
             with gr.Column(visible=True) as ia_guion_column:
                 prompt_ia = gr.Textbox(
                     label="Tema para IA",
@@ -892,6 +1022,7 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
                     max_lines=4,
                     value=""
                 )
+            
             with gr.Column(visible=False) as manual_guion_column:
                 prompt_manual = gr.Textbox(
                     label="Tu Guion Completo",
@@ -900,30 +1031,36 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
                     max_lines=10,
                     value=""
                 )
+            
             musica_input = gr.Audio(
                 label="Música de fondo (opcional)",
                 type="filepath",
                 interactive=True,
                 value=None
             )
+            
             voice_dropdown = gr.Dropdown(
                 label="Seleccionar Voz para Guion",
                 choices=AVAILABLE_VOICES,
                 value=DEFAULT_VOICE_ID,
                 interactive=True
             )
+            
             generate_btn = gr.Button("✨ Generar Video", variant="primary")
+        
         with gr.Column():
             video_output = gr.Video(
                 label="Previsualización del Video Generado",
                 interactive=False,
                 height=400
             )
+            
             file_output = gr.File(
                 label="Descargar Archivo de Video",
                 interactive=False,
                 visible=False
             )
+            
             status_output = gr.Textbox(
                 label="Estado",
                 interactive=False,
@@ -931,12 +1068,14 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
                 placeholder="Esperando acción...",
                 value="Esperando entrada..."
             )
+    
     prompt_type.change(
         lambda x: (gr.update(visible=x == "Generar Guion con IA"),
                    gr.update(visible=x == "Usar Mi Guion")),
         inputs=prompt_type,
         outputs=[ia_guion_column, manual_guion_column]
     )
+    
     generate_btn.click(
         lambda: (None, None, gr.update(value="⏳ Procesando... Esto puede tomar varios minutos.", interactive=False)),
         outputs=[video_output, file_output, status_output],
@@ -950,6 +1089,7 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
         inputs=[video_output, file_output, status_output],
         outputs=[file_output]
     )
+    
     gr.Markdown("### Instrucciones:")
     gr.Markdown("""
     1.  **Clave API de Pexels:** Asegúrate de haber configurado la variable de entorno `PEXELS_API_KEY` con tu clave.
@@ -961,6 +1101,7 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
     7.  La previsualización aparecerá si es posible, y siempre un enlace **Descargar Archivo de Video** se mostrará si la generación fue exitosa.
     8.  Revisa `video_generator_full.log` para detalles si hay errores.
     """)
+    
     gr.Markdown("---")
     gr.Markdown("Desarrollado por [Tu Nombre/Empresa/Alias - Opcional]")
 
@@ -976,6 +1117,7 @@ if __name__ == "__main__":
             logger.critical(f"Fallo al crear clip base de MoviePy. A menudo indica problemas con FFmpeg/ImageMagick. Error: {e}", exc_info=True)
     except Exception as e:
         logger.critical(f"Fallo al importar MoviePy. Asegúrate de que está instalado. Error: {e}", exc_info=True)
+    
     os.environ['GRADIO_SERVER_TIMEOUT'] = '1200'
     logger.info("Iniciando aplicación Gradio...")
     try: