Update app.py

app.py

@@ -764,6 +764,7 @@ def crear_video(prompt_type, input_text, 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:
@@ -836,37 +837,43 @@ def crear_video(prompt_type, input_text, musica_file=None):
                      logger.warning(f"No se pudo eliminar archivo temporal intermedio {path}: {str(e)}")
 
              logger.info(f"Directorio temporal intermedio {temp_dir_intermediate} persistirá para que Gradio lea el video final.")
-        
+
 def run_app(prompt_type, prompt_ia, prompt_manual, musica_file):
     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 = gr.update(value=None, visible=False)
     status_msg = gr.update(value="⏳ Procesando...", interactive=False)
+
     if not input_text or not input_text.strip():
         logger.warning("Texto de entrada vacío.")
         status_msg = gr.update(value="⚠️ Por favor, ingresa texto para el guion o el tema.", interactive=False)
         return output_video, output_file, status_msg
+
     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.")
+
     try:
         logger.info("Llamando 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}")
             logger.info(f"Tamaño del archivo de video retornado: {os.path.getsize(video_path)} bytes")
             output_video = video_path
             output_file = gr.update(value=video_path, visible=True)
             status_msg = gr.update(value="✅ Video generado exitosamente.", interactive=False)
-            print(f"\n\nLINK DE DESCARGA DIRECTO: file://{video_path}\n\n")
         else:
             logger.error(f"crear_video no retornó un path válido o el archivo no existe: {video_path}")
             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)}")
         status_msg = gr.update(value=f"⚠️ Error de validación: {str(ve)}", interactive=False)
@@ -877,403 +884,14 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_file):
         logger.info("Fin del handler run_app.")
         return output_video, output_file, status_msg
 
-def schedule_directory_deletion(directory_path, delay_hours=3):
-    import threading
-    import time
-    import shutil
-    def delete_directory():
-        time.sleep(delay_hours * 3600)
-        try:
-            if os.path.exists(directory_path):
-                shutil.rmtree(directory_path)
-                logger.info(f"Directorio temporal autoeliminado: {directory_path}")
-        except Exception as e:
-            logger.warning(f"No se pudo eliminar directorio {directory_path}: {str(e)}")
-    thread = threading.Thread(target=delete_directory)
-    thread.daemon = True
-    thread.start()
-
-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]}...'")
-    start_time = datetime.now()
-    temp_dir_intermediate = None
-    audio_tts_original = None
-    musica_audio_original = None
-    audio_tts = None
-    musica_audio = None
-    video_base = None
-    video_final = None
-    source_clips = []
-    clips_to_concatenate = []
-    try:
-        if prompt_type == "Generar Guion con IA":
-            guion = generate_script(input_text)
-        else:
-            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.")
-        guion = guion.replace("na hora", "A la hora")
-        temp_dir_intermediate = tempfile.mkdtemp(prefix="video_gen_intermediate_")
-        logger.info(f"Directorio temporal intermedio creado: {temp_dir_intermediate}")
-        logger.info("Generando audio de voz...")
-        voz_path = os.path.join(temp_dir_intermediate, "voz.mp3")
-        tts_success = text_to_speech(guion, voz_path)
-        if not tts_success or not os.path.exists(voz_path) or os.path.getsize(voz_path) <= 1000:
-            logger.error(f"Fallo en la generación de voz. Archivo de audio no creado o es muy pequeño: {voz_path}")
-            raise ValueError("Error generando voz a partir del guion (fallo de TTS).")
-        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) *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 después de procesamiento inicial.")
-        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 (min 1 second required).")
-        logger.info("Extrayendo palabras clave...")
-        try:
-            keywords = extract_visual_keywords_from_script(guion)
-            logger.info(f"Palabras clave identificadas: {keywords}")
-        except Exception as e:
-            logger.error(f"Error extrayendo keywords: {str(e)}", exc_info=True)
-            keywords = ["naturaleza", "paisaje"]
-        if not keywords:
-             keywords = ["video", "background"]
-        logger.info("Buscando videos en Pexels...")
-        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:
-                videos = buscar_videos_pexels(keyword, PEXELS_API_KEY, per_page=per_page_per_keyword)
-                if videos:
-                    videos_data.extend(videos)
-                    logger.info(f"Encontrados {len(videos)} videos para '{keyword}'. Total data: {len(videos_data)}")
-            except Exception as e:
-                logger.warning(f"Error buscando videos para '{keyword}': {str(e)}")
-        if len(videos_data) < total_desired_videos / 2:
-            logger.warning(f"Pocos videos encontrados ({len(videos_data)}). Intentando con palabras clave genéricas.")
-            generic_keywords = ["nature", "city", "background", "abstract"]
-            for keyword in generic_keywords:
-                 if len(videos_data) >= total_desired_videos: break
-                 try:
-                    videos = buscar_videos_pexels(keyword, PEXELS_API_KEY, per_page=2)
-                    if videos:
-                        videos_data.extend(videos)
-                        logger.info(f"Encontrados {len(videos)} videos para '{keyword}' (genérico). Total data: {len(videos_data)}")
-                 except Exception as e:
-                    logger.warning(f"Error buscando videos genéricos para '{keyword}': {str(e)}")
-        if not videos_data:
-            logger.error("No se encontraron videos en Pexels para ninguna palabra clave.")
-            raise ValueError("No se encontraron videos adecuados en Pexels.")
-        video_paths = []
-        logger.info(f"Intentando descargar {len(videos_data)} videos encontrados...")
-        for video in videos_data:
-            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:
-                        video_paths.append(path)
-                        logger.info(f"Video descargado OK desde {best_quality['link'][:50]}...")
-                    else:
-                         logger.warning(f"No se pudo descargar video desde {best_quality['link'][:50]}...")
-                else:
-                    logger.warning(f"No se encontró enlace de descarga válido para video {video.get('id')}.")
-            except Exception as e:
-                logger.warning(f"Error procesando/descargando video {video.get('id')}: {str(e)}")
-        logger.info(f"Descargados {len(video_paths)} archivos de video utilizables.")
-        if not video_paths:
-            logger.error("No se pudo descargar ningún archivo de video utilizable.")
-            raise ValueError("No se pudo descargar ningún video utilizable de Pexels.")
-        logger.info("Procesando y concatenando videos descargados...")
-        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 ({current_duration:.1f}s >= {audio_duration:.1f}s + {max_clip_segment:.1f}s buffer). Dejando de procesar clips fuente restantes.")
-                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 (reader is None o duración <= 0). Saltando.")
-                    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)
-                               if sub.reader is None or sub.duration is None or sub.duration <= 0:
-                                    logger.warning(f"[{i+1}/{len(video_paths)}] Subclip generado de {path} es inválido. Saltando.")
-                                    try: sub.close()
-                                    except: pass
-                                    continue
-                               clips_to_concatenate.append(sub)
-                               current_duration += sub.duration
-                               logger.debug(f"[{i+1}/{len(video_paths)}] Segmento añadido: {sub.duration:.1f}s (total video: {current_duration:.1f}/{audio_duration:.1f}s)")
-                          except Exception as sub_e:
-                               logger.warning(f"[{i+1}/{len(video_paths)}] Error creando subclip de {path} ({segment_duration:.1f}s): {str(sub_e)}")
-                               continue
-                     else:
-                          logger.debug(f"[{i+1}/{len(video_paths)}] Clip {path} ({clip.duration:.1f}s) no contribuye un segmento suficiente ({segment_duration:.1f}s necesario). Saltando.")
-                else:
-                    logger.debug(f"[{i+1}/{len(video_paths)}] Duración de video base ya alcanzada. Saltando clip.")
-            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 para crear la secuencia.")
-            raise ValueError("No hay segmentos de video válidos disponibles para crear el video.")
-        logger.info(f"Concatenando {len(clips_to_concatenate)} segmentos de video.")
-        concatenated_base = 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 después de la primera concatenación (None o duración cero).")
-                 raise ValueError("Fallo al crear video base válido a partir de segmentos.")
-        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.")
-        finally:
-             for clip_segment in clips_to_concatenate:
-                  try: clip_segment.close()
-                  except: pass
-             clips_to_concatenate = []
-        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:
-                    remaining_clip = final_video_base.subclip(0, remaining_duration)
-                    if remaining_clip is None or remaining_clip.duration is None or remaining_clip.duration <= 0:
-                        logger.warning(f"Subclip generado para duración restante {remaining_duration:.2f}s es inválido. Saltando.")
-                        try: remaining_clip.close()
-                        except: pass
-                    else:
-                         repeated_clips_list.append(remaining_clip)
-                         logger.debug(f"Añadiendo segmento restante: {remaining_duration:.2f}s")
-                except Exception as e:
-                     logger.warning(f"Error creando subclip para duración restante {remaining_duration:.2f}s: {str(e)}")
-            if repeated_clips_list:
-                 logger.info(f"Concatenando {len(repeated_clips_list)} partes para repetición.")
-                 video_base_repeated = 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.")
-                 finally:
-                     for clip in repeated_clips_list:
-                              if clip is not final_video_base:
-                                   try: clip.close()
-                                   except: pass
-        if final_video_base.duration > audio_duration:
-             logger.info(f"Recortando video base ({final_video_base.duration:.2f}s) para que coincida con la duración del audio ({audio_duration:.2f}s).")
-             trimmed_video_base = None
-             try:
-                trimmed_video_base = final_video_base.subclip(0, audio_duration)
-                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.")
-        if final_video_base is None or final_video_base.duration is None or final_video_base.duration <= 0:
-             logger.critical("Video base final es inválido antes de audio/escritura (None o duración cero).")
-             raise ValueError("Video base final es inválido.")
-        if final_video_base.size is None or final_video_base.size[0] <= 0 or final_video_base.size[1] <= 0:
-             logger.critical(f"Video base final tiene tamaño inválido: {final_video_base.size}. No se puede escribir video.")
-             raise ValueError("Video base final tiene tamaño inválido antes de escribir.")
-        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:
-                music_path = os.path.join(temp_dir_intermediate, "musica_bg.mp3")
-                shutil.copyfile(musica_file, 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 o tiene duración cero. Saltando música.")
-                     try: musica_audio_original.close()
-                     except: pass
-                     musica_audio_original = 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. Saltando música.")
-                          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 (None o duración cero). Usando solo audio de voz.")
-                        try: composite_audio.close()
-                        except: pass
-                        final_audio = audio_tts_original
-                    else:
-                         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
-                musica_audio = None
-                logger.warning("Usando solo audio de voz debido a un error con la música.")
-        if final_audio.duration is not None and abs(final_audio.duration - video_base.duration) > 0.2:
-            logger.warning(f"Duración del audio final ({final_audio.duration:.2f}s) difiere significativamente del video base ({video_base.duration:.2f}s). Intentando recorte.")
-            try:
-                 if final_audio.duration > video_base.duration:
-                      trimmed_final_audio = final_audio.subclip(0, video_base.duration)
-                      if trimmed_final_audio is None or trimmed_final_audio.duration <= 0:
-                           logger.warning("Audio final recortado es inválido. Usando audio final original.")
-                           try: trimmed_final_audio.close()
-                           except: pass
-                      else:
-                           if final_audio is not trimmed_final_audio:
-                               try: final_audio.close()
-                               except: pass
-                           final_audio = trimmed_final_audio
-                           logger.warning("Audio final recortado para que coincida con la duración del video.")
-            except Exception as e:
-                 logger.warning(f"Error ajustando duración del audio final: {str(e)}")
-        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 antes de escribir (None o duración cero).")
-             raise ValueError("Clip de video final es inválido antes de escribir.")
-        output_filename = "final_video.mp4"
-        output_path = os.path.join(temp_dir_intermediate, output_filename)
-        logger.info(f"Escribiendo video final a: {output_path}")
-        if not output_path or not isinstance(output_path, str):
-            logger.critical(f"output_path no es válido: {output_path}")
-            raise ValueError("El nombre del archivo de salida no es válido.")
-        try:
-            video_final.write_videofile(
-                filename=output_path,
-                fps=24,
-                threads=4,
-                codec="libx264",
-                audio_codec="aac",
-                preset="medium",
-                logger='bar',
-                bitrate="2000k",
-                ffmpeg_params=['-vf', 'scale=1280:720']
-            )
-        except Exception as e:
-            logger.critical(f"Error al escribir el video final: {str(e)}", exc_info=True)
-            raise ValueError(f"Fallo al escribir el video final: {str(e)}")
-        total_time = (datetime.now() - start_time).total_seconds()
-        logger.info(f"PROCESO DE VIDEO FINALIZADO | Output: {output_path} | Tiempo total: {total_time:.2f}s")
-        schedule_directory_deletion(temp_dir_intermediate)
-        return output_path
-    except ValueError as ve:
-         logger.error(f"ERROR CONTROLADO en crear_video: {str(ve)}")
-         raise ve
-    except Exception as e:
-        logger.critical(f"ERROR CRÍTICO NO CONTROLADO en crear_video: {str(e)}", exc_info=True)
-        raise e
-    finally:
-        logger.info("Iniciando limpieza de clips y archivos temporales intermedios...")
-        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)}")
-        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)}")
-        if musica_audio is not None:
-            try:
-                musica_audio.close()
-            except Exception as e:
-                logger.warning(f"Error cerrando musica_audio (procesada) en finally: {str(e)}")
-        if musica_audio_original is not None and musica_audio_original is not musica_audio:
-             try:
-                 musica_audio_original.close()
-             except Exception as e:
-                 logger.warning(f"Error cerrando musica_audio_original en finally: {str(e)}")
-        if audio_tts is not None and audio_tts is not audio_tts_original:
-             try:
-                 audio_tts.close()
-             except Exception as e:
-                 logger.warning(f"Error cerrando audio_tts (procesada) en finally: {str(e)}")
-        if audio_tts_original is not None:
-             try:
-                 audio_tts_original.close()
-             except Exception as e:
-                 logger.warning(f"Error cerrando audio_tts_original en finally: {str(e)}")
-        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:
-             try:
-                 video_base.close()
-             except Exception as e:
-                 logger.warning(f"Error cerrando video_base en finally: {str(e)}")
-        if temp_dir_intermediate and os.path.exists(temp_dir_intermediate):
-            schedule_directory_deletion(temp_dir_intermediate)
-            logger.info(f"Directorio temporal {temp_dir_intermediate} programado para eliminación en 3 horas.")
-
 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.")
+
     with gr.Row():
         with gr.Column():
             prompt_type = gr.Radio(
@@ -1281,6 +899,7 @@ 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",
@@ -1289,6 +908,7 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
                     max_lines=4,
                     value=""
                 )
+
             with gr.Column(visible=False) as manual_guion_column:
                 prompt_manual = gr.Textbox(
                     label="Tu Guion Completo",
@@ -1297,13 +917,16 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
                     max_lines=10,
                     value=""
                 )
+
             musica_input = gr.Audio(
                 label="Música de fondo (opcional)",
                 type="filepath",
                 interactive=True,
                 value=None
             )
+
             generate_btn = gr.Button("✨ Generar Video", variant="primary")
+
         with gr.Column():
             video_output = gr.Video(
                 label="Previsualización del Video Generado",
@@ -1322,12 +945,14 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
                 placeholder="Esperando acción...",
                 value="Esperando entrada..."
             )
+
     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]
     )
+
     generate_btn.click(
         lambda: (None, None, gr.update(value="⏳ Procesando... Esto puede tomar varios minutos.", interactive=False)),
         outputs=[video_output, file_output, status_output],
@@ -1337,9 +962,11 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
         inputs=[prompt_type, prompt_ia, prompt_manual, musica_input],
         outputs=[video_output, file_output, status_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.
+    
     """)
     gr.Markdown("---")
     gr.Markdown("Desarrollado por [Tu Nombre/Empresa/Alias - Opcional]")
@@ -1354,22 +981,13 @@ if __name__ == "__main__":
             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)
+
     except Exception as e:
          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.queue(
-            max_size=1,
-            api_open=False
-        ).launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            share=False,
-            prevent_thread_lock=True,
-            show_error=True,
-            max_threads=1,
-            timeout=10800  # 3 horas en segundos
-        )
+        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)
         raise