Update app.py

app.py

@@ -35,7 +35,7 @@ logger.info("="*80)
 PEXELS_API_KEY = os.environ.get("PEXELS_API_KEY")
 if not PEXELS_API_KEY:
     logger.critical("NO SE ENCONTRÓ PEXELS_API_KEY EN VARIABLES DE ENTORNO")
-    # raise ValueError("API key de Pexels no configurada") # Descomentar para forzar fallo si no está
+    # raise ValueError("API key de Pexels no configurada")
 
 # Inicialización de modelos
 MODEL_NAME = "datificate/gpt2-small-spanish"
@@ -61,36 +61,6 @@ except Exception as e:
     logger.error(f"FALLA al cargar KeyBERT: {str(e)}", exc_info=True)
     kw_model = None
 
-# --- NUEVA FUNCIÓN: Obtener voces de Edge TTS ---
-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
-        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.")
@@ -159,63 +129,53 @@ 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:
-            # 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.")
+            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.")
             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:
-                      # 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
-
+                     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).")
 
         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() # Limpieza básica como fallback
+             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
+        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()
 
-        # Limpieza final de caracteres especiales y espacios sobrantes
         cleaned_text = re.sub(r'<[^>]+>', '', cleaned_text).strip()
-        cleaned_text = cleaned_text.lstrip(':').strip() # Quitar posibles ':' al inicio
-        cleaned_text = cleaned_text.lstrip('.').strip() # Quitar posibles '.' al inicio
-
+        cleaned_text = cleaned_text.lstrip(':').strip()
+        cleaned_text = cleaned_text.lstrip('.').strip()
 
-        # 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() + '.'
-            # 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
+            if len(sentences) > 1 and sentences[1].strip() and len(final_text.split()) < max_length * 0.7:
                  final_text += " " + sentences[1].strip() + "."
-                 final_text = final_text.replace("..", ".") # Limpiar doble punto
+                 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() # Si no se puede formar una oración, devolver el texto limpio tal cual
+        return cleaned_text.strip()
 
     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 ahora recibe la voz a usar
+# Función TTS con voz especificada
 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():
@@ -386,12 +346,10 @@ def extract_visual_keywords_from_script(script_text):
     logger.info(f"Palabras clave finales: {top_keywords}")
     return top_keywords
 
-# crear_video ahora recibe la voz seleccionada
-def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
+def crear_video(prompt_type, input_text, musica_file=None):
     logger.info("="*80)
     logger.info(f"INICIANDO CREACIÓN DE VIDEO | Tipo: {prompt_type}")
     logger.debug(f"Input: '{input_text[:100]}...'")
-    logger.info(f"Voz seleccionada para TTS: {selected_voice}")
 
     start_time = datetime.now()
     temp_dir_intermediate = None
@@ -422,37 +380,35 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
         logger.info(f"Directorio temporal intermedio creado: {temp_dir_intermediate}")
         temp_intermediate_files = []
 
-        # 2. Generar audio de voz usando la voz seleccionada, con reintentos si falla
+        # 2. Generar audio de voz con reintentos y voz de respaldo
         logger.info("Generando audio de voz...")
         voz_path = os.path.join(temp_dir_intermediate, "voz.mp3")
 
-        tts_voices_to_try = [selected_voice] # Intentar primero la voz seleccionada
-        # Añadir voces de respaldo si 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 conocida y contiene otras voces españolas, añadirlas también
-        # Opcional: si AVAILABLE_VOICES es fiable, podrías usar un subconjunto ordenado para reintentos
-        # Ejemplo: for voice_id in [selected_voice] + [v for v in AVAILABLE_VOICES if v != selected_voice][:2]:
-
+        primary_voice = "es-ES-JuanNeural"
+        fallback_voice = "es-ES-ElviraNeural" # Otra voz en español
         tts_success = False
-        tried_voices = []
+        retries = 3
 
-        for current_voice in tts_voices_to_try:
-            if current_voice in tried_voices: continue # Evitar intentar la misma voz dos veces si está duplicada
-            tried_voices.append(current_voice)
-            logger.info(f"Intentando TTS con voz: {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}")
             try:
                 tts_success = asyncio.run(text_to_speech(guion, voz_path, voice=current_voice))
                 if tts_success:
-                    logger.info(f"TTS exitoso con voz '{current_voice}'.")
-                    break # Salir del bucle de reintentos si tiene éxito
+                    logger.info(f"TTS exitoso en intento {attempt + 1} con voz {current_voice}.")
+                    break
             except Exception as e:
-                 logger.warning(f"Fallo al generar TTS con voz '{current_voice}': {str(e)}", exc_info=True)
-                 pass # Continuar al siguiente intento
+                 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...")
+
 
-        # 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("Fallo en la generación de voz después de todos los intentos. Archivo de audio no creado o es muy pequeño.")
+             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.")
              raise ValueError("Error generando voz a partir del guion (fallo de TTS).")
 
         temp_intermediate_files.append(voz_path)
@@ -887,8 +843,8 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
              logger.info(f"Directorio temporal intermedio {temp_dir_intermediate} persistirá para que Gradio lea el video final.")
 
 
-# run_app ahora recibe todos los inputs, incluyendo la voz seleccionada
-def run_app(prompt_type, prompt_ia, prompt_manual, musica_file, selected_voice): # <-- Recibe el valor del Dropdown
+# 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):
     logger.info("="*80)
     logger.info("SOLICITUD RECIBIDA EN INTERFAZ")
 
@@ -901,29 +857,20 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_file, selected_voice):
 
     if not input_text or not input_text.strip():
         logger.warning("Texto de entrada vacío.")
+        # 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, la voz seleccionada y el archivo de música
-        video_path = crear_video(prompt_type, input_text, selected_voice, musica_file) # <-- PASAR selected_voice 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)
 
         if video_path and os.path.exists(video_path):
             logger.info(f"crear_video retornó path: {video_path}")
@@ -943,6 +890,7 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_file, selected_voice):
         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
 
 
@@ -964,6 +912,7 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
             )
 
             # Contenedores para los campos de texto para controlar la visibilidad
+            # Nombrados para que coincidan con los outputs del evento change
             with gr.Column(visible=True) as ia_guion_column:
                 prompt_ia = gr.Textbox(
                     label="Tema para IA",
@@ -989,16 +938,6 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
                 value=None
             )
 
-            # --- COMPONENTE: Selección de Voz ---
-            voice_dropdown = gr.Dropdown(
-                label="Seleccionar Voz para Guion",
-                choices=AVAILABLE_VOICES, # Usar la lista obtenida al inicio
-                value=DEFAULT_VOICE,      # Usar la voz por defecto calculada
-                interactive=True
-            )
-            # --- FIN COMPONENTE ---
-
-
             generate_btn = gr.Button("✨ Generar Video", variant="primary")
 
         with gr.Column():
@@ -1021,31 +960,37 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
             )
 
     # Evento para mostrar/ocultar los campos de texto según el tipo de prompt
+    # Apuntar a los componentes Column padre para controlar la visibilidad
     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] # Apuntar a las Columnas
+        # Pasar los componentes Column
+        outputs=[ia_guion_column, manual_guion_column]
     )
 
     # Evento click del botón de generar video
     generate_btn.click(
-        # Acción 1 (síncrona): Resetear salidas y establecer estado
+        # Acción 1 (síncrona): Resetear salidas y establecer estado a procesando
+        # Retorna None para los 3 outputs iniciales
         lambda: (None, None, gr.update(value="⏳ Procesando... Esto puede tomar varios minutos.", interactive=False)),
         outputs=[video_output, file_output, status_output],
-        queue=True, # Usar la cola de Gradio
+        queue=True, # Usar la cola de Gradio para tareas largas
     ).then(
-        # Acción 2 (asíncrona): Llamar a la función principal
+        # Acción 2 (asíncrona): Llamar a la función principal de procesamiento
         run_app,
-        # PASAR TODOS LOS INPUTS RELEVANTES
-        inputs=[prompt_type, prompt_ia, prompt_manual, musica_input, voice_dropdown], # <-- PASAR el dropdown de voz
-        # run_app retornará los 3 outputs esperados
+        # PASAR TODOS LOS INPUTS DE LA INTERFAZ que run_app espera
+        inputs=[prompt_type, prompt_ia, prompt_manual, musica_input],
+        # run_app retornará los 3 outputs esperados aquí
         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
+        # Acción 3 (síncrona): Hacer visible el enlace de descarga si se retornó un archivo
+        # Esta función recibe las salidas de la Acción 2 (video_path, file_path, status_msg)
+        # Solo necesitamos video_path o file_path para decidir si mostrar el enlace
         lambda video_path, file_path, status_msg: gr.update(visible=file_path is not None),
+        # Inputs son las salidas de la función .then() anterior
         inputs=[video_output, file_output, status_output],
+        # Actualizamos la visibilidad del componente file_output
         outputs=[file_output]
     )
 
@@ -1053,13 +998,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:** 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** si la generación fue exitosa.
-    8.  Revisa `video_generator_full.log` para detalles si hay errores.
+    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.
     """)
     gr.Markdown("---")
     gr.Markdown("Desarrollado por [Tu Nombre/Empresa/Alias - Opcional]")
@@ -1071,7 +1017,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 creados y cerrados exitosamente. FFmpeg parece accesible.")
+            logger.info("Clips base de MoviePy (como ColorClip) 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)