Update app.py

app.py

@@ -61,6 +61,36 @@ except Exception as e:
     logger.error(f"FALLA al cargar KeyBERT: {str(e)}", exc_info=True)
     kw_model = None
 
+# --- Obtener voces de Edge TTS al inicio ---
+async def get_available_voices():
+    logger.info("Obteniendo lista de voces disponibles de Edge TTS...")
+    try:
+        voices = await edge_tts.VoicesManager.create()
+        # Retornar solo voces en español si prefieres, o dejar todas
+        es_voices = [voice.Name for voice in voices.Voices if voice.Locale.startswith('es-')]
+        if es_voices:
+            logger.info(f"Encontradas {len(es_voices)} voces en español.")
+            return es_voices
+        else:
+            # Si no hay español, retornar todas las voces
+            all_voices = [voice.Name for voice in voices.Voices]
+            logger.warning(f"No se encontraron voces en español. Retornando {len(all_voices)} voces en todos los idiomas.")
+            return all_voices if all_voices else ["en-US-AriaNeural"] # Fallback si no hay ninguna
+
+    except Exception as e:
+        logger.error(f"Error obteniendo voces de Edge TTS: {str(e)}", exc_info=True)
+        # Retornar una lista de voces por defecto si falla la API de Edge TTS
+        logger.warning("No se pudieron obtener voces de Edge TTS. Usando lista de voces por defecto.")
+        return ["es-ES-JuanNeural", "es-ES-ElviraNeural", "en-US-AriaNeural"]
+
+# Obtener las voces al inicio del script (esto puede tardar un poco)
+logger.info("Inicializando lista de voces disponibles...")
+AVAILABLE_VOICES = asyncio.run(get_available_voices())
+# Establecer una voz por defecto inicial
+DEFAULT_VOICE = "es-ES-JuanNeural" if "es-ES-JuanNeural" in AVAILABLE_VOICES else (AVAILABLE_VOICES[0] if AVAILABLE_VOICES else "en-US-AriaNeural")
+logger.info(f"Voz por defecto seleccionada: {DEFAULT_VOICE}")
+
+
 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.")
@@ -129,53 +159,63 @@ def generate_script(prompt, max_length=150):
         text = tokenizer.decode(outputs[0], skip_special_tokens=True)
 
         cleaned_text = text.strip()
+        # Limpieza mejorada de la frase de instrucción
         try:
-            instruction_end_idx = text.find(instruction_phrase)
-            if instruction_end_idx != -1:
-                cleaned_text = text[instruction_end_idx + len(instruction_phrase):].strip()
-                logger.debug("Instrucción inicial encontrada y eliminada del guión generado.")
+            # Buscar el índice de inicio del prompt original dentro del texto generado
+            prompt_in_output_idx = text.lower().find(prompt.lower())
+            if prompt_in_output_idx != -1:
+                # Tomar todo el texto DESPUÉS del prompt original
+                cleaned_text = text[prompt_in_output_idx + len(prompt):].strip()
+                logger.debug("Texto limpiado tomando parte después del prompt original.")
             else:
+                 # Fallback si el prompt original no está exacto en la salida: buscar la frase de instrucción base
                  instruction_start_idx = text.find(instruction_phrase_start)
                  if instruction_start_idx != -1:
-                     prompt_in_output_idx = text.find(prompt, instruction_start_idx)
-                     if prompt_in_output_idx != -1:
-                          cleaned_text = text[prompt_in_output_idx + len(prompt):].strip()
-                          logger.debug("Instrucción base y prompt encontrados y eliminados del guión generado.")
-                     else:
-                          cleaned_text = text[instruction_start_idx + len(instruction_phrase_start):].strip()
-                          logger.debug("Instrucción base encontrada, eliminada del guión generado (sin prompt detectado).")
+                      # Tomar texto después de la frase base (puede incluir el prompt)
+                      cleaned_text = text[instruction_start_idx + len(instruction_phrase_start):].strip()
+                      logger.debug("Texto limpiado tomando parte después de la frase de instrucción base.")
+                 else:
+                      # Si ni la frase de instrucción ni el prompt se encuentran, usar el texto original
+                      logger.warning("No se pudo identificar el inicio del guión generado. Usando texto generado completo.")
+                      cleaned_text = text.strip() # Limpieza básica
+
 
         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()
+             cleaned_text = re.sub(r'<[^>]+>', '', text).strip() # Limpieza básica como fallback
 
-        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. Usando el texto generado original (sin limpieza heurística).")
-             cleaned_text = re.sub(r'<[^>]+>', '', text).strip()
+        # Asegurarse de que el texto resultante no sea solo la instrucción o vacío
+        if not cleaned_text or len(cleaned_text) < 10: # Umbral de longitud mínima
+             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() # Fallback al texto original limpio
 
+        # Limpieza final de caracteres especiales y espacios sobrantes
         cleaned_text = re.sub(r'<[^>]+>', '', cleaned_text).strip()
-        cleaned_text = cleaned_text.lstrip(':').strip()
-        cleaned_text = cleaned_text.lstrip('.').strip()
+        cleaned_text = cleaned_text.lstrip(':').strip() # Quitar posibles ':' al inicio
+        cleaned_text = cleaned_text.lstrip('.').strip() # Quitar posibles '.' al inicio
+
 
+        # Intentar obtener al menos una oración completa si es posible para un inicio más limpio
         sentences = cleaned_text.split('.')
         if sentences and sentences[0].strip():
             final_text = sentences[0].strip() + '.'
-            if len(sentences) > 1 and sentences[1].strip() and len(final_text.split()) < max_length * 0.7:
+            # 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.7: # Usar un 70% de max_length como umbral
                  final_text += " " + sentences[1].strip() + "."
-                 final_text = final_text.replace("..", ".")
+                 final_text = final_text.replace("..", ".") # Limpiar doble punto
 
             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()
+        return cleaned_text.strip() # Si no se puede formar una oración, devolver el texto limpio tal cual
 
     except Exception as e:
         logger.error(f"Error generando guion con GPT-2 (fuera del bloque de limpieza): {str(e)}", exc_info=True)
         logger.warning("Usando prompt original como guion debido al error de generación.")
         return prompt.strip()
 
-# Función TTS con voz especificada
+# Función TTS ahora recibe la voz a usar
 async def text_to_speech(text, output_path, voice):
     logger.info(f"Convirtiendo texto a voz | Caracteres: {len(text)} | Voz: {voice} | Salida: {output_path}")
     if not text or not text.strip():
@@ -346,10 +386,12 @@ def extract_visual_keywords_from_script(script_text):
     logger.info(f"Palabras clave finales: {top_keywords}")
     return top_keywords
 
-def crear_video(prompt_type, input_text, musica_file=None):
+# crear_video ahora recibe la voz seleccionada
+def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
     logger.info("="*80)
     logger.info(f"INICIANDO CREACIÓN DE VIDEO | Tipo: {prompt_type}")
     logger.debug(f"Input: '{input_text[:100]}...'")
+    logger.info(f"Voz seleccionada para TTS: {selected_voice}")
 
     start_time = datetime.now()
     temp_dir_intermediate = None
@@ -380,35 +422,39 @@ def crear_video(prompt_type, input_text, musica_file=None):
         logger.info(f"Directorio temporal intermedio creado: {temp_dir_intermediate}")
         temp_intermediate_files = []
 
-        # 2. Generar audio de voz con reintentos y voz de respaldo
+        # 2. Generar audio de voz usando la voz seleccionada, con reintentos si falla
         logger.info("Generando audio de voz...")
         voz_path = os.path.join(temp_dir_intermediate, "voz.mp3")
 
-        primary_voice = "es-ES-JuanNeural"
-        fallback_voice = "es-ES-ElviraNeural" # Otra voz en español
+        tts_voices_to_try = [selected_voice] # Intentar primero la voz seleccionada
+        # Añadir voces de respaldo si no están ya en la lista y son diferentes a la seleccionada
+        if "es-ES-JuanNeural" not in tts_voices_to_try: tts_voices_to_try.append("es-ES-JuanNeural")
+        if "es-ES-ElviraNeural" not in tts_voices_to_try: tts_voices_to_try.append("es-ES-ElviraNeural")
+        # Si la lista de voces disponibles es fiable, podrías usar un subconjunto ordenado para reintentos más amplios
+        # Ejemplo: for voice_id in [selected_voice] + sorted([v for v in AVAILABLE_VOICES if v.startswith('es-') and v != selected_voice]) + sorted([v for v in AVAILABLE_VOICES if not v.startswith('es-') and v != selected_voice]):
+
+
         tts_success = False
-        retries = 3
+        tried_voices = set() # Usar un set para rastrear voces intentadas de forma eficiente
+
+        for current_voice in tts_voices_to_try:
+            if current_voice in tried_voices: continue # Evitar intentar la misma voz dos veces
+            tried_voices.add(current_voice)
 
-        for attempt in range(retries):
-            current_voice = primary_voice if attempt == 0 else fallback_voice
-            if attempt > 0: logger.warning(f"Reintentando TTS ({attempt+1}/{retries})...")
-            logger.info(f"Intentando TTS con voz: {current_voice}")
+            logger.info(f"Intentando TTS con voz: {current_voice}...")
             try:
                 tts_success = asyncio.run(text_to_speech(guion, voz_path, voice=current_voice))
                 if tts_success:
-                    logger.info(f"TTS exitoso en intento {attempt + 1} con voz {current_voice}.")
-                    break
+                    logger.info(f"TTS exitoso con voz '{current_voice}'.")
+                    break # Salir del bucle de reintentos si tiene éxito
             except Exception as e:
-                 pass
-
-            if not tts_success and attempt == 0 and primary_voice != fallback_voice:
-                 logger.warning(f"Fallo con voz {primary_voice}, intentando voz de respaldo: {fallback_voice}")
-            elif not tts_success and attempt < retries - 1:
-                 logger.warning(f"Fallo con voz {current_voice}, reintentando...")
+                 logger.warning(f"Fallo al generar TTS con voz '{current_voice}': {str(e)}", exc_info=True)
+                 pass # Continuar al siguiente intento
 
 
+        # Verificar si el archivo fue creado después de todos los intentos
         if not tts_success or not os.path.exists(voz_path) or os.path.getsize(voz_path) <= 100:
-             logger.error(f"Fallo en la generación de voz después de {retries} intentos. Archivo de audio no creado o es muy pequeño.")
+             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)
@@ -843,8 +889,8 @@ def crear_video(prompt_type, input_text, musica_file=None):
              logger.info(f"Directorio temporal intermedio {temp_dir_intermediate} persistirá para que Gradio lea el video final.")
 
 
-# La función run_app ahora recibe todos los inputs de texto y el archivo de música
-def run_app(prompt_type, prompt_ia, prompt_manual, musica_file):
+# CAMBIO CRÍTICO: run_app ahora recibe TODOS los inputs que Gradio le pasa desde el evento click
+def run_app(prompt_type, prompt_ia, prompt_manual, musica_file, selected_voice): # <-- Recibe el valor del Dropdown
     logger.info("="*80)
     logger.info("SOLICITUD RECIBIDA EN INTERFAZ")
 
@@ -860,17 +906,27 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_file):
         # Retornar None para video y archivo, actualizar estado con mensaje de error
         return None, None, gr.update(value="⚠️ Por favor, ingresa texto para el guion o el tema.", interactive=False)
 
+    # Validar la voz seleccionada. Si no es válida, usar la por defecto.
+    # AVAILABLE_VOICES se obtiene al inicio.
+    if selected_voice not in AVAILABLE_VOICES:
+        logger.warning(f"Voz seleccionada inválida o no encontrada en la lista: '{selected_voice}'. Usando voz por defecto: {DEFAULT_VOICE}.")
+        selected_voice = DEFAULT_VOICE
+    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: {selected_voice}") # Loguear la voz final que se usará
 
     try:
         logger.info("Llamando a crear_video...")
-        # Pasar el input_text elegido y el archivo de música a crear_video
-        video_path = crear_video(prompt_type, input_text, musica_file)
+        # Pasar el input_text elegido, la voz seleccionada y el archivo de música a crear_video
+        video_path = crear_video(prompt_type, input_text, selected_voice, musica_file) # <-- PASAR selected_voice a crear_video
 
         if video_path and os.path.exists(video_path):
             logger.info(f"crear_video retornó path: {video_path}")
@@ -890,12 +946,11 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_file):
         status_msg = gr.update(value=f"❌ Error inesperado: {str(e)}", interactive=False)
     finally:
         logger.info("Fin del handler run_app.")
-        # Retornar las tres salidas esperadas por el evento click
         return output_video, output_file, status_msg
 
 
 # Interfaz de Gradio
-    with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="""
+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:
@@ -912,18 +967,16 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_file):
             )
 
             # Contenedores para los campos de texto para controlar la visibilidad
-            # visible=True/False está aquí en la COLUMNA
             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=""
-                    # visible=... <--- NO DEBE ESTAR AQUÍ
+                    # visible=... <-- ¡NO DEBE ESTAR AQUÍ!
                 )
 
-            # visible=True/False está aquí en la COLUMNA
             with gr.Column(visible=False) as manual_guion_column:
                 prompt_manual = gr.Textbox(
                     label="Tu Guion Completo",
@@ -931,7 +984,7 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_file):
                     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=""
-                    # visible=... <--- NO DEBE ESTAR AQUÍ
+                     # visible=... <-- ¡NO DEBE ESTAR AQUÍ!
                 )
 
             musica_input = gr.Audio(
@@ -939,7 +992,7 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_file):
                 type="filepath",
                 interactive=True,
                 value=None
-                # visible=... <--- NO DEBE ESTAR AQUÍ
+                 # visible=... <-- ¡NO DEBE ESTAR AQUÍ!
             )
 
             # --- COMPONENTE: Selección de Voz ---
@@ -948,7 +1001,7 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_file):
                 choices=AVAILABLE_VOICES,
                 value=DEFAULT_VOICE,
                 interactive=True
-                # visible=... <--- NO DEBE ESTAR AQUÍ
+                 # visible=... <-- ¡NO DEBE ESTAR AQUÍ!
             )
             # --- FIN COMPONENTE ---
 
@@ -960,12 +1013,13 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_file):
                 label="Previsualización del Video Generado",
                 interactive=False,
                 height=400
-                # visible=... <--- NO DEBE ESTAR AQUÍ
+                 # visible=... <-- ¡NO DEBE ESTAR AQUÍ!
             )
             file_output = gr.File(
                 label="Descargar Archivo de Video",
                 interactive=False,
-                visible=False # <-- ESTA BIEN AQUÍ porque su visibilidad se controla solo por el lambda posterior
+                visible=False # <-- ESTÁ BIEN AQUÍ porque su visibilidad se controla por el último then()
+                 # visible=... <-- ¡NO DEBE ESTAR AQUÍ si ya está visible=False arriba!
             )
             status_output = gr.Textbox(
                 label="Estado",
@@ -973,7 +1027,7 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_file):
                 show_label=False,
                 placeholder="Esperando acción...",
                 value="Esperando entrada..."
-                # visible=... <--- NO DEBE ESTAR AQUÍ
+                 # visible=... <-- ¡NO DEBE ESTAR AQUÍ!
             )
 
     # Evento para mostrar/ocultar los campos de texto según el tipo de prompt
@@ -981,8 +1035,7 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_file):
         lambda x: (gr.update(visible=x == "Generar Guion con IA"),
                    gr.update(visible=x == "Usar Mi Guion")),
         inputs=prompt_type,
-        # APUNTAR A LAS COLUMNAS, esto está correcto
-        outputs=[ia_guion_column, manual_guion_column]
+        outputs=[ia_guion_column, manual_guion_column] # Apuntar a las Columnas contenedoras
     )
 
     # Evento click del botón de generar video
@@ -994,29 +1047,31 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_file):
     ).then(
         # Acción 2 (asíncrona): Llamar a la función principal
         run_app,
-        # PASAR TODOS LOS INPUTS RELEVANTES a run_app
-        # Esto parece que ahora sí debería coincidir con la definición de run_app con 5 argumentos
-        inputs=[prompt_type, prompt_ia, prompt_manual, musica_input, voice_dropdown],
+        # PASAR TODOS LOS INPUTS DE LA INTERFAZ que run_app espera
+        inputs=[prompt_type, prompt_ia, prompt_manual, musica_input, voice_dropdown], # <-- Pasar los 5 inputs a run_app
         # run_app retornará los 3 outputs esperados
         outputs=[video_output, file_output, status_output]
     ).then(
         # Acción 3 (síncrona): Hacer visible el enlace de descarga
+        # Recibe las salidas de la Acción 2
         lambda video_path, file_path, status_msg: gr.update(visible=file_path is not None),
+        # Inputs para esta lambda son los outputs del .then() anterior
         inputs=[video_output, file_output, status_output],
+        # Actualizamos la visibilidad del componente file_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.
-    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.  La previsualización del video aparecerá arriba (puede fallar para archivos grandes), y un enlace **Descargar Archivo de Video** se mostrará si la generación fue exitosa.
-    7.  Si hay errores, revisa el log `video_generator_full.log` para más detalles.
+    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]")
@@ -1028,7 +1083,7 @@ 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 (como ColorClip) creados y cerrados exitosamente. FFmpeg parece accesible.")
+            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. A menudo indica problemas con FFmpeg/ImageMagick. Error: {e}", exc_info=True)