Update app.py

app.py

@@ -9,7 +9,7 @@ import gradio as gr
 import torch
 from transformers import GPT2Tokenizer, GPT2LMHeadModel
 from keybert import KeyBERT
-# Importación correcta
+# Importación correcta: Solo 'concatenate_videoclips'
 from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip, CompositeAudioClip, concatenate_audioclips, AudioClip
 import re
 import math
@@ -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")
+    # raise ValueError("API key de Pexels no configurada") # Descomentar para forzar fallo si no está
 
 # Inicialización de modelos
 MODEL_NAME = "datificate/gpt2-small-spanish"
@@ -66,14 +66,16 @@ async def get_available_voices():
     logger.info("Obteniendo lista de voces disponibles de Edge TTS...")
     try:
         voices = await edge_tts.VoicesManager.create()
-        # Filtrar solo voces en español si prefieres, o dejar todas
-        # es_voices = [voice.Name for voice in voices.Voices if voice.Locale.startswith('es-')]
-        # return es_voices if es_voices else [voice.Name for voice in voices.Voices]
-
-        # O simplemente retornar todas las voces
-        all_voices = [voice.Name for voice in voices.Voices]
-        logger.info(f"Encontradas {len(all_voices)} voces de Edge TTS.")
-        return all_voices
+        # 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)
@@ -157,46 +159,56 @@ 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)
@@ -374,11 +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, selected_voice, musica_file=None): # <-- AHORA RECIBE selected_voice
+# 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}") # <-- LOGUEAR la voz seleccionada
+    logger.info(f"Voz seleccionada para TTS: {selected_voice}")
 
     start_time = datetime.now()
     temp_dir_intermediate = None
@@ -409,31 +422,37 @@ 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
+        # 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")
 
-        # Ya no necesitamos reintentos/fallback aquí, la voz viene seleccionada
-        tts_success = asyncio.run(text_to_speech(guion, voz_path, voice=selected_voice))
-
-        # Si falla la generación con la voz seleccionada, intentar con una voz de respaldo
-        if not tts_success:
-             logger.warning(f"La generación de TTS falló con la voz seleccionada '{selected_voice}'. Intentando con voz de respaldo 'es-ES-ElviraNeural'.")
-             fallback_voice = "es-ES-ElviraNeural"
-             if selected_voice == fallback_voice: # Evitar reintentar con la misma voz fallida
-                  fallback_voice = "en-US-AriaNeural" # O alguna otra conocida
-                  logger.warning(f"La voz de respaldo era la misma que falló. Intentando otra voz de respaldo: {fallback_voice}")
-
-             tts_success = asyncio.run(text_to_speech(guion, voz_path, voice=fallback_voice))
-             if tts_success:
-                  logger.info(f"TTS exitoso con voz de respaldo: {fallback_voice}.")
-             else:
-                  logger.error(f"La generación de TTS falló también con la voz de respaldo.")
-
+        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]:
+
+        tts_success = False
+        tried_voices = []
+
+        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}...")
+            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
+            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
 
-        # Verificar si el archivo fue creado después de los intentos
+        # 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. 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)
@@ -869,10 +888,11 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None): # <-
 
 
 # run_app ahora recibe todos los inputs, incluyendo la voz seleccionada
-def run_app(prompt_type, prompt_ia, prompt_manual, musica_file, selected_voice): # <-- AHORA RECIBE selected_voice
+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")
 
+    # Elegir el texto de entrada basado en el prompt_type
     input_text = prompt_ia if prompt_type == "Generar Guion con IA" else prompt_manual
 
     output_video = None
@@ -883,9 +903,14 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_file, selected_voice):
         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 not selected_voice or selected_voice not in AVAILABLE_VOICES:
-        logger.warning(f"Voz seleccionada inválida o vacía: '{selected_voice}'. Usando voz por defecto: {DEFAULT_VOICE}.")
-        selected_voice = DEFAULT_VOICE # Usar voz por defecto si la seleccionada es inválida
+    # 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]}...'")
@@ -893,18 +918,18 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_file, selected_voice):
         logger.info(f"Archivo de música recibido: {musica_file}")
     else:
         logger.info("No se proporcionó archivo de música.")
-    logger.info(f"Voz seleccionada (validada): {selected_voice}") # Loguear la voz validada
+    logger.info(f"Voz final a usar: {selected_voice}") # Loguear la voz final que se usará
 
     try:
         logger.info("Llamando a crear_video...")
-        # Pasar la voz seleccionada a crear_video
-        video_path = crear_video(prompt_type, input_text, selected_voice, musica_file) # <-- PASAR selected_voice
+        # 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
 
         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")
-            output_video = video_path
-            output_file = video_path
+            output_video = video_path # Establecer valor del componente de video
+            output_file = video_path   # Establecer valor del componente de archivo para descarga
             status_msg = gr.update(value="✅ Video generado exitosamente.", interactive=False)
         else:
             logger.error(f"crear_video no retornó un path válido o el archivo no existe: {video_path}")
@@ -943,7 +968,7 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
                 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=""
                 )
@@ -963,15 +988,15 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
                 interactive=True,
                 value=None
             )
-            
-            # --- NUEVO COMPONENTE: Selección de Voz ---
+
+            # --- 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 NUEVO COMPONENTE ---
+            # --- FIN COMPONENTE ---
 
 
             generate_btn = gr.Button("✨ Generar Video", variant="primary")
@@ -985,7 +1010,7 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
             file_output = gr.File(
                 label="Descargar Archivo de Video",
                 interactive=False,
-                visible=False
+                visible=False # Ocultar inicialmente
             )
             status_output = gr.Textbox(
                 label="Estado",
@@ -1000,7 +1025,7 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
         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]
+        outputs=[ia_guion_column, manual_guion_column] # Apuntar a las Columnas
     )
 
     # Evento click del botón de generar video
@@ -1008,16 +1033,17 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
         # Acción 1 (síncrona): Resetear salidas y establecer estado
         lambda: (None, None, gr.update(value="⏳ Procesando... Esto puede tomar varios minutos.", interactive=False)),
         outputs=[video_output, file_output, status_output],
-        queue=True,
+        queue=True, # Usar la cola de Gradio
     ).then(
-        # Acción 2 (asíncrona): Llamar a la función principal de procesamiento
+        # Acción 2 (asíncrona): Llamar a la función principal
         run_app,
-        # PASAR TODOS LOS INPUTS DE LA INTERFAZ a run_app
-        inputs=[prompt_type, prompt_ia, prompt_manual, musica_input, voice_dropdown], # <-- AHORA PASAMOS voice_dropdown
+        # 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
         outputs=[video_output, file_output, status_output]
     ).then(
-        # Acción 3 (síncrona): Hacer visible el enlace de descarga si se retornó un archivo
+        # 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=[video_output, file_output, status_output],
         outputs=[file_output]
@@ -1027,15 +1053,13 @@ 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": 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.  **Selecciona la voz** para el guion.
+    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. El tiempo de espera puede variar. Verás el estado en el cuadro de texto.
-    7.  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.
-    8.  Si hay errores, revisa el log `video_generator_full.log` para más detalles.
+    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.
     """)
     gr.Markdown("---")
     gr.Markdown("Desarrollado por [Tu Nombre/Empresa/Alias - Opcional]")
@@ -1047,7 +1071,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)