Update app.py

app.py

@@ -9,7 +9,7 @@ import gradio as gr
 import torch
 from transformers import GPT2Tokenizer, GPT2LMHeadModel
 from keybert import KeyBERT
-# CORRECCIÓN CRÍTICA DEFINITIVA: Eliminar 'concatenate_videoclip' (singular) de la importación
+# CORRECCIÓN CRÍTICA DEFINITIVA DEL TYPO DE IMPORTACIÓN
 from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip, CompositeAudioClip, concatenate_audioclips, AudioClip
 import re
 import math
@@ -102,24 +102,20 @@ def generate_script(prompt, max_length=150):
     logger.info(f"Generando guión | Prompt: '{prompt[:50]}...' | Longitud máxima: {max_length}")
     if not tokenizer or not model:
         logger.warning("Modelos GPT-2 no disponibles - Usando prompt original como guion.")
-        return prompt.strip() # Return original prompt clean
+        return prompt.strip()
 
-    # Frase de instrucción que se le da a la IA
     instruction_phrase_start = "Escribe un guion corto, interesante y coherente sobre:"
-    # Construir el prompt exacto que se le pasará a la IA
     ai_prompt = f"{instruction_phrase_start} {prompt}"
 
     try:
-        # Generar texto usando el prompt completo
         inputs = tokenizer(ai_prompt, return_tensors="pt", truncation=True, max_length=512)
-
         device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
         model.to(device)
         inputs = {k: v.to(device) for k, v in inputs.items()}
 
         outputs = model.generate(
             **inputs,
-            max_length=max_length + inputs[list(inputs.keys())[0]].size(1), # Longitud máxima incluyendo los tokens de entrada
+            max_length=max_length + inputs[list(inputs.keys())[0]].size(1),
             do_sample=True,
             top_p=0.9,
             top_k=40,
@@ -132,68 +128,55 @@ def generate_script(prompt, max_length=150):
 
         text = tokenizer.decode(outputs[0], skip_special_tokens=True)
 
-        # --- Limpiar la frase de instrucción inicial de la salida de la IA ---
         cleaned_text = text.strip()
-        # Intentar encontrar el inicio de la respuesta real después de la instrucción
-        # A veces la IA repite el prompt o la instrucción
         try:
-            # Buscar el final de la frase de instrucción literal en la salida
             instruction_end_idx = text.find(instruction_phrase)
             if instruction_end_idx != -1:
-                # Tomar el texto que viene *después* de la instrucción exacta
                 cleaned_text = text[instruction_end_idx + len(instruction_phrase):].strip()
                 logger.debug("Instrucción inicial encontrada y eliminada del guión generado.")
             else:
-                 # Si no se encuentra la frase exacta, buscar solo el inicio de la instrucción base
                  instruction_start_idx = text.find(instruction_phrase_start)
                  if instruction_start_idx != -1:
-                     # Tomar texto después de la frase base + prompt (heurística)
                      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:
-                          # Fallback: si la instrucción base está pero no el prompt después, tomar después de la instrucción base
                           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
+        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() # Fallback al texto original limpio
+             cleaned_text = re.sub(r'<[^>]+>', '', text).strip()
 
-        # Limpieza final de caracteres especiales y espacios
         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
         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()
 
-# CAMBIO: Voz por defecto a "es-ES-JuanNeural"
-async def text_to_speech(text, output_path, voice="es-ES-JuanNeural"):
+# Función TTS con voz especificada
+async def text_to_speech(text, output_path, voice): # voice is now a parameter
     logger.info(f"Convirtiendo texto a voz | Caracteres: {len(text)} | Voz: {voice} | Salida: {output_path}")
     if not text or not text.strip():
         logger.warning("Texto vacío para TTS")
@@ -211,7 +194,7 @@ async def text_to_speech(text, output_path, voice="es-ES-JuanNeural"):
             return False
 
     except Exception as e:
-        logger.error(f"Error en TTS: {str(e)}", exc_info=True)
+        logger.error(f"Error en TTS con voz '{voice}': {str(e)}", exc_info=True)
         return False
 
 def download_video_file(url, temp_dir):
@@ -397,26 +380,54 @@ 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
+        # 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")
-        # Usar voz de Juan
-        if not asyncio.run(text_to_speech(guion, voz_path, voice="es-ES-JuanNeural")):
-            logger.error("Fallo en generación de voz")
-            raise ValueError("Error generando voz a partir del guion.")
-        temp_intermediate_files.append(voz_path)
 
+        primary_voice = "es-ES-JuanNeural"
+        fallback_voice = "es-ES-ElviraNeural" # Otra voz en español
+        tts_success = False
+        retries = 3 # Número de intentos
+
+        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:
+                # Llamar a la función async text_to_speech
+                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 # Salir del bucle de reintentos si tiene éxito
+            except Exception as e:
+                 # La excepción ya se registra dentro de text_to_speech
+                 pass # Continuar al siguiente intento
+
+            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(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) # Añadir a la lista de limpieza si se creó
+
+        # Continuar cargando el archivo de audio generado
         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 (reader is None o duración <= 0).")
+            logger.critical("Clip de audio TTS inicial es inválido (reader is None o duración <= 0) *después* de crear AudioFileClip.")
             try: audio_tts_original.close()
             except: pass
             audio_tts_original = None
-            raise ValueError("Audio de voz generado es inválido.")
+            raise ValueError("Audio de voz generado es inválido después de procesamiento inicial.")
 
-        audio_tts = audio_tts_original # Usar el clip TTS válido original para la mezcla
-        audio_duration = audio_tts_original.duration # Usar duración original para la longitud del video
+        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:
@@ -590,7 +601,7 @@ def crear_video(prompt_type, input_text, musica_file=None):
             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 # Lista contiene duplicados del mismo objeto clip
+            repeated_clips_list = [final_video_base] * num_full_repeats
             if remaining_duration > 0:
                 try:
                     remaining_clip = final_video_base.subclip(0, remaining_duration)
@@ -628,7 +639,7 @@ def crear_video(prompt_type, input_text, musica_file=None):
                  finally:
                      if 'repeated_clips_list' in locals():
                          for clip in repeated_clips_list:
-                              if clip is not final_video_base: # No cerrar si es el clip final
+                              if clip is not final_video_base:
                                    try: clip.close()
                                    except: pass
 
@@ -686,7 +697,6 @@ def crear_video(prompt_type, input_text, musica_file=None):
                      except: pass
                      musica_audio_original = None
                 else:
-                     # Usar la duración correcta del video base para loopear la música
                      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")
 
@@ -775,21 +785,18 @@ def crear_video(prompt_type, input_text, musica_file=None):
     finally:
         logger.info("Iniciando limpieza de clips y archivos temporales intermedios...")
 
-        # Cerrar todos los clips de video fuente iniciales abiertos
         for clip in source_clips:
             try:
                 clip.close()
             except Exception as e:
                 logger.warning(f"Error cerrando clip de video fuente en finally: {str(e)}")
 
-        # Cerrar cualquier segmento de video que quede en la lista (debería estar vacía si tuvo éxito)
         for clip_segment in clips_to_concatenate:
              try:
                  clip_segment.close()
              except Exception as e:
                  logger.warning(f"Error cerrando segmento de video en finally: {str(e)}")
 
-        # Cerrar clips de audio en orden: música loopeada, música original (si es diferente), TTS original
         if musica_audio is not None: # musica_audio holds the potentially looped clip
             try:
                 musica_audio.close()
@@ -802,7 +809,6 @@ def crear_video(prompt_type, input_text, musica_file=None):
              except Exception as e:
                  logger.warning(f"Error cerrando musica_audio_original en finally: {str(e)}")
 
-        # audio_tts actualmente solo contiene audio_tts_original, pero se mantiene la estructura
         if audio_tts is not None and audio_tts is not audio_tts_original:
              try:
                  audio_tts.close()
@@ -815,26 +821,22 @@ def crear_video(prompt_type, input_text, musica_file=None):
              except Exception as e:
                  logger.warning(f"Error cerrando audio_tts_original en finally: {str(e)}")
 
-
-        # Cerrar clips de video en orden: video_final (debería cerrar sus componentes), luego video_base (si es diferente de video_final)
         if video_final is not None:
             try:
                 video_final.close()
             except Exception as e:
                 logger.warning(f"Error cerrando video_final en finally: {str(e)}")
-        elif video_base is not None and video_base is not video_final: # Asegurarse de que video_base no es el mismo objeto que video_final
+        elif video_base is not None and video_base is not video_final:
              try:
                  video_base.close()
              except Exception as e:
                  logger.warning(f"Error cerrando video_base en finally: {str(e)}")
 
-        # Limpiar archivos intermedios, pero NO el archivo de video final
         if temp_dir_intermediate and os.path.exists(temp_dir_intermediate):
              final_output_in_temp = os.path.join(temp_dir_intermediate, "final_video.mp4")
 
              for path in temp_intermediate_files:
                  try:
-                     # Verificar explícitamente que la ruta no sea la ruta de salida del video final antes de eliminar
                      if os.path.isfile(path) and path != final_output_in_temp:
                          logger.debug(f"Eliminando archivo temporal intermedio: {path}")
                          os.remove(path)
@@ -843,18 +845,19 @@ def crear_video(prompt_type, input_text, musica_file=None):
                  except Exception as e:
                      logger.warning(f"No se pudo eliminar archivo temporal intermedio {path}: {str(e)}")
 
-             # El directorio temporal *persistirá* porque contiene el archivo final
              logger.info(f"Directorio temporal intermedio {temp_dir_intermediate} persistirá para que Gradio lea el video final.")
 
 
+# CAMBIO CRÍTICO: run_app ahora toma 4 argumentos
 def run_app(prompt_type, prompt_ia, prompt_manual, musica_file):
     logger.info("="*80)
     logger.info("SOLICITUD RECIBIDA EN INTERFAZ")
 
+    # La lógica para elegir el texto de entrada YA ESTÁ AQUÍ
     input_text = prompt_ia if prompt_type == "Generar Guion con IA" else prompt_manual
 
     output_video = None
-    output_file = None # Inicializar a None
+    output_file = None
     status_msg = gr.update(value="⏳ Procesando...", interactive=False)
 
     if not input_text or not input_text.strip():
@@ -870,30 +873,27 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_file):
 
     try:
         logger.info("Llamando a crear_video...")
+        # Pasar el input_text elegido y el archivo de música
         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}")
             logger.info(f"Tamaño del archivo de video retornado: {os.path.getsize(video_path)} bytes")
-            output_video = video_path # Establecer valor del componente de video
-            output_file = video_path   # Establecer valor del componente de archivo para descarga
+            output_video = video_path
+            output_file = video_path
             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}")
-            # Dejar las salidas de video y archivo como None
             status_msg = gr.update(value="❌ Error: La generación del video falló o el archivo no se creó correctamente.", interactive=False)
 
     except ValueError as ve:
         logger.warning(f"Error de validación durante la creación del video: {str(ve)}")
-        # Dejar las salidas de video y archivo como None
         status_msg = gr.update(value=f"⚠️ Error de validación: {str(ve)}", interactive=False)
     except Exception as e:
         logger.critical(f"Error crítico durante la creación del video: {str(e)}", exc_info=True)
-        # Dejar las salidas de video y archivo como None
         status_msg = gr.update(value=f"❌ Error inesperado: {str(e)}", interactive=False)
     finally:
         logger.info("Fin del handler run_app.")
-        # Retornar las tres salidas
         return output_video, output_file, status_msg
 
 
@@ -914,23 +914,26 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
                 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, 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. Veremos la vida marina fascinante y los arrecifes de coral vibrantes. ¡Acompáñanos en esta aventura subacuática!",
-                    max_lines=10,
-                    value=""
-                )
+            # Estos inputs siempre se pasan a run_app, independientemente de cuál se use
+            prompt_ia = gr.Textbox(
+                label="Tema para IA",
+                lines=2,
+                placeholder="Ej: Un paisaje natural con montañas y ríos al amanecer...",
+                max_lines=4,
+                value="",
+                # Hacer visible/oculto por el evento change
+                visible=True
+            )
+
+            prompt_manual = gr.Textbox(
+                label="Tu Guion Completo",
+                lines=5,
+                placeholder="Ej: En este video exploraremos los misterios del océano...",
+                max_lines=10,
+                value="",
+                # Hacer visible/oculto por el evento change
+                visible=False # Oculto por defecto
+            )
 
             musica_input = gr.Audio(
                 label="Música de fondo (opcional)",
@@ -943,13 +946,12 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
 
         with gr.Column():
             video_output = gr.Video(
-                label="Previsualización del Video Generado", # Etiqueta cambiada
+                label="Previsualización del Video Generado",
                 interactive=False,
                 height=400
             )
-            # Añadir el componente File para la descarga
             file_output = gr.File(
-                label="Descargar Archivo de Video", # Etiqueta cambiada
+                label="Descargar Archivo de Video",
                 interactive=False,
                 visible=False # Ocultar inicialmente
             )
@@ -961,30 +963,33 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
                 value="Esperando entrada..."
             )
 
+    # Evento para mostrar/ocultar los campos de texto según el tipo de prompt
+    # Ahora usamos las Columnas 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]
+        outputs=[prompt_ia.parent, prompt_manual.parent] # Apuntar a las Columnas padre
     )
 
-    # Modificar el evento click para retornar 3 salidas
+    # Evento click del botón de generar video
     generate_btn.click(
-        # Acción 1: Resetear salidas y establecer estado a procesando
-        lambda: (None, None, gr.update(value="⏳ Procesando... Esto puede tomar 2-5 minutos o más para videos largos.", interactive=False)), # Mensaje de estado mejorado
+        # Acción 1 (síncrona): Resetear salidas y establecer estado a procesando
+        lambda: (None, None, gr.update(value="⏳ Procesando... Esto puede tomar 2-5 minutos o más para videos largos.", interactive=False)),
         outputs=[video_output, file_output, status_output],
-        queue=True, # Mantener la cola habilitada
+        queue=True, # Usar la cola de Gradio para tareas largas
     ).then(
-        # Acción 2: Llamar a la función principal de procesamiento
+        # Acción 2 (asíncrona): Llamar a la función principal de procesamiento
         run_app,
+        # CAMBIO CRÍTICO: Pasar los 4 argumentos definidos por run_app
         inputs=[prompt_type, prompt_ia, prompt_manual, musica_input],
-        outputs=[video_output, file_output, status_output] # Coincidir las 3 salidas
+        outputs=[video_output, file_output, status_output] # Coincidir las 3 salidas de run_app
     ).then(
-        # Acción 3: Hacer visible el enlace de descarga si se retornó un archivo
-        # Verificar si file_output tiene un valor
-        lambda video_path, file_path: gr.update(visible=file_path is not None), # Usar file_path para visibilidad
-        inputs=[video_output, file_output], # Ambas salidas como entrada
-        outputs=[file_output] # Actualizar visibilidad de file_output
+        # Acción 3 (síncrona): Hacer visible el enlace de descarga si se retornó un archivo
+        # Verificar si file_output tiene un valor (el path)
+        lambda video_path, file_path: gr.update(visible=file_path is not None),
+        inputs=[video_output, file_output], # Usar ambas salidas como entrada para esta función
+        outputs=[file_output] # Actualizar visibilidad del componente file_output
     )
 
 
@@ -1019,6 +1024,8 @@ if __name__ == "__main__":
 
     logger.info("Iniciando aplicación Gradio...")
     try:
+        # Gradio Queue maneja tareas largas, no es necesario un ajuste global de timeout aquí.
+        # El timeout se gestiona por solicitud o por el límite del worker de la cola.
         app.launch(server_name="0.0.0.0", server_port=7860, share=False)
     except Exception as e:
         logger.critical(f"No se pudo iniciar la app: {str(e)}", exc_info=True)