Update app.py

app.py

@@ -15,6 +15,7 @@ import math
 import shutil
 import json
 from collections import Counter
+import time
 
 # Configuración de logging
 logging.basicConfig(
@@ -30,32 +31,28 @@ logger.info("="*80)
 logger.info("INICIO DE EJECUCIÓN - GENERADOR DE VIDEOS")
 logger.info("="*80)
 
-# Función para obtener voces disponibles dinámicamente
-async def get_available_voices():
-    try:
-        voices = await edge_tts.list_voices()
-        # Filtrar solo voces en español
-        es_voices = [v for v in voices if v['Locale'].startswith('es-')]
-        return {f"{v['ShortName']} - {v['Locale']} ({v['Gender']})": v['ShortName'] for v in es_voices}
-    except Exception as e:
-        logger.error(f"Error al obtener voces disponibles: {str(e)}")
-        return {}
-
-# Obtener las voces disponibles
-AVAILABLE_VOICES = asyncio.run(get_available_voices())
-if not AVAILABLE_VOICES:
-    logger.warning("No se pudieron obtener voces dinámicamente. Usando voces predefinidas.")
-    VOCES_PREDEFINIDAS = {
-        "es-ES-JuanNeural": "Juan (España) - Masculino",
-        "es-ES-ElviraNeural": "Elvira (España) - Femenino",
-        "es-MX-JorgeNeural": "Jorge (México) - Masculino",
-        "es-MX-DaliaNeural": "Dalia (México) - Femenino",
-    }
-    AVAILABLE_VOICES = {v: k for k, v in VOCES_PREDEFINIDAS.items()}
-
-# Establecer una voz por defecto
-DEFAULT_VOICE_ID = "es-ES-JuanNeural" if "es-ES-JuanNeural" in AVAILABLE_VOICES.values() else list(AVAILABLE_VOICES.values())[0]
-DEFAULT_VOICE_NAME = next((k for k, v in AVAILABLE_VOICES.items() if v == DEFAULT_VOICE_ID), list(AVAILABLE_VOICES.keys())[0])
+# CAMBIO: Lista estática de voces como en script 2
+VOICES = {
+    "Español": [
+        "es-ES-JuanNeural", "es-ES-ElviraNeural", "es-MX-JorgeNeural", "es-MX-DaliaNeural",
+        "es-AR-TomasNeural", "es-AR-ElenaNeural", "es-CO-GonzaloNeural", "es-CO-SalomeNeural",
+        "es-CL-LorenzoNeural", "es-CL-CatalinaNeural", "es-PE-AlexNeural", "es-PE-CamilaNeural",
+        "es-VE-PaolaNeural", "es-VE-SebastianNeural", "es-US-AlonsoNeural", "es-US-PalomaNeural"
+    ]
+}
+
+# CAMBIO: Función para obtener las voces en formato de dropdown como en script 2
+def get_voice_choices():
+    choices = []
+    for region, voice_list in VOICES.items():
+        for voice_id in voice_list:
+            choices.append((f"{voice_id} ({region})", voice_id))
+    return choices
+
+# CAMBIO: Usamos lista estática en lugar de edge_tts.list_voices()
+AVAILABLE_VOICES = get_voice_choices()
+DEFAULT_VOICE_ID = "es-ES-JuanNeural"
+DEFAULT_VOICE_NAME = next((name for name, vid in AVAILABLE_VOICES if vid == DEFAULT_VOICE_ID), DEFAULT_VOICE_ID)
 logger.info(f"Voz por defecto seleccionada: {DEFAULT_VOICE_NAME} ({DEFAULT_VOICE_ID})")
 
 # Clave API de Pexels
@@ -63,20 +60,27 @@ 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")
 
-# Inicialización de modelos
+# Inicialización de modelos con reintentos (como en script 1b)
 MODEL_NAME = "datificate/gpt2-small-spanish"
 logger.info(f"Inicializando modelo GPT-2: {MODEL_NAME}")
 tokenizer = None
 model = None
-try:
-    tokenizer = GPT2Tokenizer.from_pretrained(MODEL_NAME)
-    model = GPT2LMHeadModel.from_pretrained(MODEL_NAME).eval()
-    if tokenizer.pad_token is None:
-        tokenizer.pad_token = tokenizer.eos_token
-    logger.info(f"Modelo GPT-2 cargado | Vocabulario: {len(tokenizer)} tokens")
-except Exception as e:
-    logger.error(f"FALLA CRÍTICA al cargar GPT-2: {str(e)}", exc_info=True)
-    tokenizer = model = None
+MAX_RETRIES = 3
+for attempt in range(MAX_RETRIES):
+    try:
+        tokenizer = GPT2Tokenizer.from_pretrained(MODEL_NAME, timeout=60)
+        model = GPT2LMHeadModel.from_pretrained(MODEL_NAME, timeout=60).eval()
+        if tokenizer.pad_token is None:
+            tokenizer.pad_token = tokenizer.eos_token
+        logger.info(f"Modelo GPT-2 cargado | Vocabulario: {len(tokenizer)} tokens")
+        break
+    except Exception as e:
+        logger.warning(f"Intento {attempt + 1} falló al cargar GPT-2: {str(e)}")
+        if attempt < MAX_RETRIES - 1:
+            time.sleep(5)
+        else:
+            logger.error(f"FALLA CRÍTICA al cargar GPT-2 después de {MAX_RETRIES} intentos: {str(e)}")
+            tokenizer = model = None
 
 logger.info("Cargando modelo KeyBERT...")
 kw_model = None
@@ -94,35 +98,32 @@ def buscar_videos_pexels(query, api_key, per_page=5):
 
     logger.debug(f"Buscando en Pexels: '{query}' | Resultados: {per_page}")
     headers = {"Authorization": api_key}
-    try:
-        params = {
-            "query": query,
-            "per_page": per_page,
-            "orientation": "landscape",
-            "size": "medium"
-        }
-
-        response = requests.get(
-            "https://api.pexels.com/videos/search",
-            headers=headers,
-            params=params,
-            timeout=20
-        )
-        response.raise_for_status()
-
-        data = response.json()
-        videos = data.get('videos', [])
-        logger.info(f"Pexels: {len(videos)} videos encontrados para '{query}'")
-        return videos
-
-    except requests.exceptions.RequestException as e:
-        logger.error(f"Error de conexión Pexels para '{query}': {str(e)}")
-    except json.JSONDecodeError:
-        logger.error(f"Pexels: JSON inválido recibido | Status: {response.status_code} | Respuesta: {response.text[:200]}...")
-    except Exception as e:
-        logger.error(f"Error inesperado Pexels para '{query}': {str(e)}", exc_info=True)
-
-    return []
+    for attempt in range(MAX_RETRIES):
+        try:
+            params = {
+                "query": query,
+                "per_page": per_page,
+                "orientation": "landscape",
+                "size": "medium"
+            }
+            response = requests.get(
+                "https://api.pexels.com/videos/search",
+                headers=headers,
+                params=params,
+                timeout=60
+            )
+            response.raise_for_status()
+            data = response.json()
+            videos = data.get('videos', [])
+            logger.info(f"Pexels: {len(videos)} videos encontrados para '{query}'")
+            return videos
+        except requests.exceptions.RequestException as e:
+            logger.warning(f"Intento {attempt + 1} falló en Pexels: {str(e)}")
+            if attempt < MAX_RETRIES - 1:
+                time.sleep(5)
+            else:
+                logger.error(f"Error de conexión Pexels para '{query}' después de {MAX_RETRIES} intentos: {str(e)}")
+                return []
 
 def generate_script(prompt, max_length=150):
     logger.info(f"Generando guión | Prompt: '{prompt[:50]}...' | Longitud máxima: {max_length}")
@@ -230,31 +231,36 @@ def download_video_file(url, temp_dir):
         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
-        else:
-            logger.warning(f"Descarga parece incompleta o vacía para {url[:80]}... Archivo: {output_path} Tamaño: {os.path.getsize(output_path) if os.path.exists(output_path) else 'N/A'} bytes")
-            if os.path.exists(output_path):
-                os.remove(output_path)
-            return None
+        for attempt in range(MAX_RETRIES):
+            try:
+                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
+                else:
+                    logger.warning(f"Descarga parece incompleta o vacía para {url[:80]}...")
+                    if os.path.exists(output_path):
+                        os.remove(output_path)
+                    return None
+            except requests.exceptions.RequestException as e:
+                logger.warning(f"Intento {attempt + 1} falló al descargar video: {str(e)}")
+                if attempt < MAX_RETRIES - 1:
+                    time.sleep(5)
+                else:
+                    logger.error(f"Error descargando video después de {MAX_RETRIES} intentos: {str(e)}")
+                    return None
 
-    except requests.exceptions.RequestException as e:
-        logger.error(f"Error de descarga para {url[:80]}... : {str(e)}")
     except Exception as e:
-        logger.error(f"Error inesperado descargando {url[:80]}... : {str(e)}", exc_info=True)
-
-    return None
+        logger.error(f"Error inesperado descargando {url[:80]}...: {str(e)}", exc_info=True)
+        return None
 
 def loop_audio_to_length(audio_clip, target_duration):
     logger.debug(f"Ajustando audio | Duración actual: {audio_clip.duration:.2f}s | Objetivo: {target_duration:.2f}s")
-
     if audio_clip is None or audio_clip.duration is None or audio_clip.duration <= 0:
         logger.warning("Input audio clip is invalid (None or zero duration), cannot loop.")
         try:
@@ -276,7 +282,6 @@ def loop_audio_to_length(audio_clip, target_duration):
 
     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
@@ -292,9 +297,8 @@ def loop_audio_to_length(audio_clip, target_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: {strrance(e)}", exc_info=True)
+        logger.error(f"Error concatenating/subclipping audio clips for looping: {str(e)}", exc_info=True)
         try:
             if audio_clip.duration is not None and audio_clip.duration > 0:
                 logger.warning("Returning original audio clip (may be too short).")
@@ -303,7 +307,6 @@ def loop_audio_to_length(audio_clip, target_duration):
             pass
         logger.error("Fallback to original audio clip failed.")
         return AudioFileClip(filename="")
-
     finally:
         if looped_audio is not None and looped_audio is not final_looped_audio:
             try: looped_audio.close()
@@ -323,7 +326,6 @@ def extract_visual_keywords_from_script(script_text):
             logger.debug("Intentando extracción con KeyBERT...")
             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)
-
             all_keywords = keywords1 + keywords2
             all_keywords.sort(key=lambda item: item[1], reverse=True)
 
@@ -339,7 +341,6 @@ def extract_visual_keywords_from_script(script_text):
             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.")
 
@@ -348,14 +349,12 @@ def extract_visual_keywords_from_script(script_text):
     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 ["naturaleza", "ciudad", "paisaje"]
 
     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 ["naturaleza", "ciudad", "paisaje"]
@@ -369,13 +368,14 @@ 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}")
 
-    if selected_voice not in AVAILABLE_VOICES.values():
+    # CAMBIO: Validación simple de la voz como en script 2
+    voice_ids = [vid for _, vid in AVAILABLE_VOICES]
+    if selected_voice not in voice_ids:
         logger.warning(f"Voz seleccionada '{selected_voice}' no es válida. Usando voz por defecto: {DEFAULT_VOICE_ID}")
         selected_voice = DEFAULT_VOICE_ID
 
     start_time = datetime.now()
     temp_dir_intermediate = None
-
     audio_tts_original = None
     musica_audio_original = None
     audio_tts = None
@@ -384,6 +384,7 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
     video_final = None
     source_clips = []
     clips_to_concatenate = []
+    temp_intermediate_files = []
 
     try:
         if prompt_type == "Generar Guion con IA":
@@ -392,37 +393,23 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
             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}")
-        temp_intermediate_files = []
 
         logger.info("Generando audio de voz...")
         voz_path = os.path.join(temp_dir_intermediate, "voz.mp3")
-
-        tts_success = False
-        voices_to_try = [selected_voice, DEFAULT_VOICE_ID]
-
-        for voice in voices_to_try:
-            if not voice: continue
-            logger.info(f"Intentando TTS con voz: {voice}...")
-            tts_success = asyncio.run(text_to_speech(guion, voz_path, voice=voice))
-            if tts_success:
-                break
-            else:
-                logger.warning(f"Fallo al generar TTS con voz '{voice}'.")
-
+        # CAMBIO: Usamos la voz seleccionada directamente, sin fallbacks complejos
+        logger.info(f"Intentando TTS con voz: {selected_voice}...")
+        tts_success = asyncio.run(text_to_speech(guion, voz_path, voice=selected_voice))
         if not tts_success:
             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:
             logger.critical("Clip de audio TTS inicial es inválido.")
             try: audio_tts_original.close()
@@ -432,7 +419,6 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
         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.")
@@ -452,7 +438,6 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
         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
             try:
@@ -484,14 +469,12 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
             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:
@@ -509,30 +492,24 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
         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.")
                 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.")
                     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)
@@ -541,19 +518,16 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
                                 try: sub.close()
                                 except: pass
                                 continue
-
                             clips_to_concatenate.append(sub)
                             current_duration += sub.duration
                         except Exception as sub_e:
                             logger.warning(f"[{i+1}/{len(video_paths)}] Error creando subclip: {str(sub_e)}")
                             continue
-
             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.")
             raise ValueError("No hay segmentos de video válidos.")
@@ -563,11 +537,9 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=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")
-
             if concatenated_base is None or concatenated_base.duration is None or concatenated_base.duration <= 0:
                 logger.critical("Video base concatenado es inválido.")
                 raise ValueError("Fallo al crear video base válido.")
-
         except Exception as e:
             logger.critical(f"Error durante la concatenación inicial: {str(e)}", exc_info=True)
             raise ValueError("Fallo durante la concatenación de video inicial.")
@@ -579,12 +551,10 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
 
         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:
@@ -604,17 +574,13 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
                 try:
                     video_base_repeated = concatenate_videoclips(repeated_clips_list, method="chain")
                     logger.info(f"Duración del video base repetido: {video_base_repeated.duration:.2f}s")
-
                     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()
                         except: pass
-
                     final_video_base = video_base_repeated
-
                 except Exception as e:
                     logger.critical(f"Error durante la concatenación de repetición: {str(e)}", exc_info=True)
                     raise ValueError("Fallo durante la repetición de video.")
@@ -632,13 +598,10 @@ 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()
                     except: pass
-
                 final_video_base = trimmed_video_base
-
             except Exception as e:
                 logger.critical(f"Error durante el recorte: {str(e)}", exc_info=True)
                 raise ValueError("Fallo durante el recorte de video.")
@@ -652,11 +615,9 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
             raise ValueError("Video base final tiene tamaño inválido.")
 
         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:
@@ -664,9 +625,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.")
                     try: musica_audio_original.close()
@@ -675,19 +634,16 @@ 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.")
                         try: musica_audio_looped.close()
                         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.")
                         try: composite_audio.close()
@@ -697,7 +653,6 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
                         logger.info("Mezcla de audio completada (voz + música).")
                         final_audio = composite_audio
                         musica_audio = musica_audio_looped
-
             except Exception as e:
                 logger.warning(f"Error procesando música de fondo: {str(e)}", exc_info=True)
                 final_audio = audio_tts_original
@@ -723,7 +678,6 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
 
         logger.info("Renderizando video final...")
         video_final = video_base.set_audio(final_audio)
-
         if video_final is None or video_final.duration is None or video_final.duration <= 0:
             logger.critical("Clip de video final (con audio) es inválido.")
             raise ValueError("Clip de video final es inválido.")
@@ -731,9 +685,7 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
         output_filename = "final_video.mp4"
         output_path = os.path.join(temp_dir_intermediate, output_filename)
         logger.info(f"Escribiendo video final a: {output_path}")
-
         video_final.write_videofile(
-            output_path,
             fps=24,
             threads=4,
             codec="libx264",
@@ -744,9 +696,7 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
 
         total_time = (datetime.now() - start_time).total_seconds()
         logger.info(f"PROCESO DE VIDEO FINALIZADO | Output: {output_path} | Tiempo total: {total_time:.2f}s")
-
         return output_path
-
     except ValueError as ve:
         logger.error(f"ERROR CONTROLADO en crear_video: {str(ve)}")
         raise ve
@@ -808,33 +758,24 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
 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)
-
-    if selected_voice not in AVAILABLE_VOICES.values():
+    
+    # CAMBIO: Validación simple de la voz en run_app
+    voice_ids = [vid for _, vid in AVAILABLE_VOICES]
+    if selected_voice not in voice_ids:
         logger.warning(f"Voz seleccionada inválida: '{selected_voice}'. Usando voz por defecto: {DEFAULT_VOICE_ID}")
         selected_voice = DEFAULT_VOICE_ID
-
-    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}")
             output_video = video_path
@@ -842,23 +783,20 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_file, selected_voice):
             status_msg = gr.update(value="✅ Video generado exitosamente.", interactive=False)
         else:
             logger.error(f"crear_video no retornó un path válido: {video_path}")
-            status_msg = gr.update(value="❌ Error: La generación del video falló.", interactive=False)
-
+            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: {str(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: {str(e)}", exc_info=True)
+        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
+    return output_video, output_file, status_msg
 
+# Interfaz de Gradio
 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.")
 
@@ -869,41 +807,36 @@ 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",
                     lines=2,
-                    placeholder="Ej: Un paisaje natural con montañas y ríos al amanecer...",
+                    placeholder="Ej: Un paisaje natural con montañas y ríos al amanecer, mostrando la belleza de la naturaleza...",
                     max_lines=4,
                     value=""
                 )
-
             with gr.Column(visible=False) as manual_guion_column:
                 prompt_manual = gr.Textbox(
                     label="Tu Guion Completo",
                     lines=5,
-                    placeholder="Ej: En este video exploraremos los misterios del océano...",
+                    placeholder="Ej: En este video exploraremos los misterios del océano. Veremos la vida marina fascinante y los arrecifes de coral vibrantes. ¡Acompáñanos en esta aventura subacuática!",
                     max_lines=10,
                     value=""
                 )
-
             musica_input = gr.Audio(
                 label="Música de fondo (opcional)",
                 type="filepath",
                 interactive=True,
                 value=None
             )
-
+            # CAMBIO: Dropdown de voces simplificado
             voice_dropdown = gr.Dropdown(
                 label="Seleccionar Voz para Guion",
-                choices=list(AVAILABLE_VOICES.keys()),
-                value=DEFAULT_VOICE_NAME,
+                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",
@@ -929,7 +862,6 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
         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],
@@ -946,14 +878,14 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
 
     gr.Markdown("### Instrucciones:")
     gr.Markdown("""
-    1. **Clave API de Pexels:** Configura la variable de entorno `PEXELS_API_KEY`.
-    2. **Selecciona el tipo de entrada**: "Generar Guion con IA" o "Usar Mi Guion".
-    3. **Sube música** (opcional): Selecciona un archivo de audio (MP3, WAV, etc.).
-    4. **Selecciona la voz** deseada del desplegable.
-    5. **Haz clic en "✨ Generar Video"**.
-    6. Espera a que se procese el video. Verás el estado.
-    7. Descarga el video generado.
-    8. Revisa `video_generator_full.log` para detalles si hay errores.
+    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" o "Usar Mi Guion".
+    3.  **Sube música** (opcional): Selecciona un archivo de audio (MP3, WAV, etc.).
+    4.  **Selecciona la voz** deseada del desplegable.
+    5.  **Haz clic en "✨ Generar Video"**.
+    6.  Espera a que se procese el video. Verás el estado.
+    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]")
@@ -965,12 +897,11 @@ if __name__ == "__main__":
         try:
             temp_clip = ColorClip((100,100), color=(255,0,0), duration=0.1)
             temp_clip.close()
-            logger.info("Clips base de MoviePy creados y cerrados exitosamente.")
+            logger.info("Clips base de MoviePy creados y cerrados exitosamente. FFmpeg parece accesible.")
         except Exception as e:
-            logger.critical(f"Fallo al crear clip base de MoviePy: {e}", exc_info=True)
+            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: {e}", exc_info=True)
-
+        logger.critical(f"Fallo al importar MoviePy. Asegúrate de que está instalado. Error: {e}", exc_info=True)
     logger.info("Iniciando aplicación Gradio...")
     try:
         app.launch(server_name="0.0.0.0", server_port=7860, share=False)