Update app.py

app.py

@@ -1,35 +1,54 @@
 # FILE: app.py
 # DESCRIPTION: Final Gradio web interface for the ADUC-SDR Video Suite.
-# Features a unified workflow, advanced LTX controls, and a clean, modular structure.
+# Features a unified LTX workflow, advanced controls, integrated SeedVR upscaling,
+# and detailed debug logging.
 
 import gradio as gr
 import traceback
 import sys
+import os
+import logging
 
 # ==============================================================================
-# --- IMPORTAÇÃO DOS SERVIÇOS DE BACKEND ---
+# --- IMPORTAÇÃO DOS SERVIÇOS DE BACKEND E UTILS ---
 # ==============================================================================
 
 try:
-    # A UI depende do VideoService para todas as operações LTX.
+    # Serviço principal para geração LTX
     from api.ltx_server_refactored_complete import video_generation_service
     
-    # A importação do SeedVR permanece opcional.
-    # from api.seedvr_server import SeedVRServer
-    # seedvr_inference_server = SeedVRServer()
-    seedvr_inference_server = None # Desativado para este exemplo
-    print("Backend services imported successfully.")
+    # Nosso decorador de logging para depuração
+    from api.utils.debug_utils import log_function_io
+
+    # Serviço especialista para upscaling de resolução (SeedVR)
+    from api.seedvr_server import SeedVRServer
+    seedvr_inference_server = SeedVRServer()
+    
+    logging.info("All backend services (LTX, SeedVR) and debug utils imported successfully.")
+
 except ImportError as e:
-    print(f"FATAL ERROR: Could not import backend services. Details: {e}", file=sys.stderr)
-    sys.exit(1)
+    # Define um fallback para o decorador para que a UI não quebre se o utilitário não for encontrado
+    def log_function_io(func):
+        return func
+    logging.warning(f"Could not import a module, debug logger might be disabled. SeedVR might be unavailable. Details: {e}")
+    # Se o serviço LTX principal falhar, é um erro fatal
+    if 'video_generation_service' not in locals():
+        logging.critical(f"FATAL: Main LTX service failed to import.", exc_info=True)
+        sys.exit(1)
+    # Se apenas o SeedVR falhar, a aplicação pode continuar com ele desativado
+    if 'seedvr_inference_server' not in locals():
+        seedvr_inference_server = None
+        logging.warning("SeedVR server could not be initialized. The SeedVR upscaling tab will be disabled.")
+
 except Exception as e:
-    print(f"FATAL ERROR: An unexpected error occurred during backend initialization. Details: {e}", file=sys.stderr)
+    logging.critical(f"FATAL ERROR: An unexpected error occurred during backend initialization. Details: {e}", exc_info=True)
     sys.exit(1)
 
 # ==============================================================================
 # --- FUNÇÕES WRAPPER (PONTE ENTRE UI E BACKEND) ---
 # ==============================================================================
 
+@log_function_io
 def run_generate_base_video(
     generation_mode: str, prompt: str, neg_prompt: str, start_img: str, 
     height: int, width: int, duration: float,
@@ -37,12 +56,9 @@ def run_generate_base_video(
     fp_num_inference_steps: int, fp_skip_initial_steps: int, fp_skip_final_steps: int,
     progress=gr.Progress(track_tqdm=True)
 ) -> tuple:
-    """
-    Wrapper que coleta todos os dados da UI, os empacota e chama a função de geração
-    unificada do backend.
-    """
+    """Wrapper para a geração do vídeo base LTX."""
     try:
-        print(f"[UI] Request received. Selected mode: {generation_mode}")
+        logging.info(f"[UI] Request received. Selected mode: {generation_mode}")
         
         initial_conditions = []
         if start_img:
@@ -52,7 +68,6 @@ def run_generate_base_video(
                 items_list, height, width, num_frames_estimate
             )
 
-        # Agrupa todas as configurações LTX em um único dicionário para o backend
         ltx_configs = {
             "guidance_preset": fp_guidance_preset,
             "guidance_scale_list": fp_guidance_scale_list,
@@ -63,43 +78,70 @@ def run_generate_base_video(
         }
 
         video_path, tensor_path, final_seed = video_generation_service.generate_low_resolution(
-            prompt=prompt,
-            negative_prompt=neg_prompt,
+            prompt=prompt, negative_prompt=neg_prompt,
             height=height, width=width, duration=duration,
-            initial_conditions=initial_conditions,
-            ltx_configs_override=ltx_configs
+            initial_conditions=initial_conditions, ltx_configs_override=ltx_configs
         )
         
-        if not video_path:
-            raise RuntimeError("Backend failed to return a valid video path.")
+        if not video_path: raise RuntimeError("Backend failed to return a valid video path.")
 
         new_state = {"low_res_video": video_path, "low_res_latents": tensor_path, "used_seed": final_seed}
-        
-        print(f"[UI] Base video generation successful. Seed used: {final_seed}, Path: {video_path}")
+        logging.info(f"[UI] Base video generation successful. Seed used: {final_seed}, Path: {video_path}")
         return video_path, new_state, gr.update(visible=True)
         
     except Exception as e:
         error_message = f"❌ An error occurred during base generation:\n{e}"
-        print(f"{error_message}\nDetails: {traceback.format_exc()}", file=sys.stderr)
+        logging.error(f"{error_message}\nDetails: {traceback.format_exc()}", exc_info=True)
         raise gr.Error(error_message)
 
-
+@log_function_io
 def run_ltx_refinement(state: dict, prompt: str, neg_prompt: str, progress=gr.Progress(track_tqdm=True)) -> tuple:
-    """Wrapper para chamar a função de refinamento/upscale do LTX."""
+    """Wrapper para o refinamento de textura LTX."""
     if not state or not state.get("low_res_latents"):
         raise gr.Error("Error: Please generate a base video in Step 1 before refining.")
-    # (A lógica desta função permanece a mesma)
-    # ...
-    return None, state
+    
+    try:
+        logging.info(f"[UI] Requesting LTX refinement for latents: {state.get('low_res_latents')}")
+        video_path, tensor_path = video_generation_service.generate_upscale_denoise(
+            latents_path=state["low_res_latents"],
+            prompt=prompt,
+            negative_prompt=neg_prompt,
+            seed=state["used_seed"]
+        )
+        state["refined_video_ltx"] = video_path
+        state["refined_latents_ltx"] = tensor_path
+        logging.info(f"[UI] LTX refinement successful. Path: {video_path}")
+        return video_path, state
+    except Exception as e:
+        error_message = f"❌ An error occurred during LTX Refinement:\n{e}"
+        logging.error(f"{error_message}\nDetails: {traceback.format_exc()}", exc_info=True)
+        raise gr.Error(error_message)
 
 
-def run_seedvr_upscaling(state: dict, resolution: int, batch_size: int, fps: int, progress=gr.Progress(track_tqdm=True)) -> tuple:
-    """Wrapper para chamar o serviço de upscale do SeedVR."""
+@log_function_io
+def run_seedvr_upscaling(state: dict, seed: int, resolution: int, batch_size: int, fps: int, progress=gr.Progress(track_tqdm=True)) -> tuple:
+    """Wrapper para o upscale de resolução SeedVR."""
     if not state or not state.get("low_res_video"):
         raise gr.Error("Error: Please generate a base video in Step 1 before upscaling.")
-    # (A lógica desta função permanece a mesma)
-    # ...
-    return None, "Not implemented."
+    if not seedvr_inference_server:
+        raise gr.Error("Error: The SeedVR upscaling server is not available.")
+    
+    try:
+        logging.info(f"[UI] Requesting SeedVR upscaling for video: {state.get('low_res_video')}")
+        def progress_wrapper(p, desc=""): progress(p, desc=desc)
+        
+        output_filepath = seedvr_inference_server.run_inference(
+            file_path=state["low_res_video"], seed=int(seed), resolution=int(resolution),
+            batch_size=int(batch_size), fps=float(fps), progress=progress_wrapper
+        )
+        
+        status_message = f"✅ Upscaling complete!\nSaved to: {output_filepath}"
+        logging.info(f"[UI] SeedVR upscaling successful. Path: {output_filepath}")
+        return gr.update(value=output_filepath), gr.update(value=status_message)
+    except Exception as e:
+        error_message = f"❌ An error occurred during SeedVR Upscaling:\n{e}"
+        logging.error(f"{error_message}\nDetails: {traceback.format_exc()}", exc_info=True)
+        return None, gr.update(value=error_message)
 
 # ==============================================================================
 # --- CONSTRUÇÃO DA INTERFACE GRADIO ---
@@ -112,7 +154,7 @@ def build_ui():
         app_state = gr.State(value={"low_res_video": None, "low_res_latents": None, "used_seed": None})
         ui_components = {}
 
-        gr.Markdown("# ADUC-SDR Video Suite - LTX Workflow", elem_id="main-title")
+        gr.Markdown("# ADUC-SDR Video Suite - LTX & SeedVR Workflow", elem_id="main-title")
         
         with gr.Row():
             with gr.Column(scale=1):
@@ -120,6 +162,7 @@ def build_ui():
             with gr.Column(scale=1):
                 gr.Markdown("### Etapa 1: Vídeo Base Gerado")
                 ui_components['low_res_video_output'] = gr.Video(label="O resultado aparecerá aqui", interactive=False)
+                ui_components['used_seed_display'] = gr.Textbox(label="Seed Utilizada", interactive=False)
         
         _build_postprod_controls(ui_components)
         _register_event_handlers(app_state, ui_components)
@@ -129,13 +172,7 @@ def build_ui():
 def _build_generation_controls(ui: dict):
     """Constrói os componentes da UI para a Etapa 1: Geração."""
     gr.Markdown("### Configurações de Geração")
-    
-    ui['generation_mode'] = gr.Radio(
-        label="Modo de Geração", 
-        choices=["Simples (Prompt Único)", "Narrativa (Múltiplos Prompts)"],
-        value="Narrativa (Múltiplos Prompts)", 
-        info="Simples para uma ação contínua, Narrativa para uma sequência (uma cena por linha)."
-    )
+    ui['generation_mode'] = gr.Radio(label="Modo de Geração", choices=["Simples (Prompt Único)", "Narrativa (Múltiplos Prompts)"], value="Narrativa (Múltiplos Prompts)", info="Simples para uma ação contínua, Narrativa para uma sequência (uma cena por linha).")
     ui['prompt'] = gr.Textbox(label="Prompt(s)", value="Um leão majestoso caminha pela savana\nEle sobe em uma grande pedra e olha o horizonte", lines=4)
     ui['neg_prompt'] = gr.Textbox(label="Negative Prompt", value="blurry, low quality, bad anatomy, deformed", lines=2)
     ui['start_image'] = gr.Image(label="Imagem de Início (Opcional)", type="filepath", sources=["upload"])
@@ -149,18 +186,13 @@ def _build_generation_controls(ui: dict):
     with gr.Accordion("Opções Avançadas LTX", open=False):
         gr.Markdown("#### Configurações de Passos de Inferência (First Pass)")
         gr.Markdown("*Deixe o valor padrão (ex: 20) ou 0 para usar a configuração do `config.yaml`.*")
-        
         ui['fp_num_inference_steps'] = gr.Slider(label="Número de Passos", minimum=0, maximum=100, step=1, value=20, info="Padrão LTX: 20.")
         ui['fp_skip_initial_steps'] = gr.Slider(label="Pular Passos Iniciais", minimum=0, maximum=100, step=1, value=0)
         ui['fp_skip_final_steps'] = gr.Slider(label="Pular Passos Finais", minimum=0, maximum=100, step=1, value=0)
 
         with gr.Tabs():
             with gr.TabItem("Configurações de Guiagem (First Pass)"):
-                ui['fp_guidance_preset'] = gr.Dropdown(
-                    label="Preset de Guiagem",
-                    choices=["Padrão (Recomendado)", "Agressivo", "Suave", "Customizado"],
-                    value="Padrão (Recomendado)", info="Controla o comportamento da guiagem durante a difusão."
-                )
+                ui['fp_guidance_preset'] = gr.Dropdown(label="Preset de Guiagem", choices=["Padrão (Recomendado)", "Agressivo", "Suave", "Customizado"], value="Padrão (Recomendado)", info="Controla o comportamento da guiagem durante a difusão.")
                 with gr.Group(visible=False) as ui['custom_guidance_group']:
                     gr.Markdown("⚠️ Edite as listas em formato JSON. Ex: `[1.0, 2.5, 3.0]`")
                     ui['fp_guidance_scale_list'] = gr.Textbox(label="Lista de Guidance Scale", value="[1, 1, 6, 8, 6, 1, 1]")
@@ -182,8 +214,20 @@ def _build_postprod_controls(ui: dict):
                         ui['ltx_refined_video_output'] = gr.Video(label="Vídeo com Textura Refinada", interactive=False)
             
             with gr.TabItem("✨ Upscaler de Resolução (SeedVR)"):
-                # (A UI do SeedVR permanece a mesma, desativada se o servidor não estiver disponível)
-                pass
+                is_seedvr_available = seedvr_inference_server is not None
+                if not is_seedvr_available:
+                    gr.Markdown("🔴 **AVISO: O serviço SeedVR não está disponível. A aba de upscale de resolução está desativada.**")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        ui['seedvr_seed'] = gr.Slider(minimum=0, maximum=999999, value=42, step=1, label="Seed")
+                        ui['seedvr_resolution'] = gr.Slider(minimum=720, maximum=2160, value=1080, step=8, label="Resolução Vertical Alvo")
+                        ui['seedvr_batch_size'] = gr.Slider(minimum=1, maximum=16, value=4, step=1, label="Batch Size por GPU")
+                        ui['seedvr_fps'] = gr.Number(label="FPS de Saída (0 = original)", value=0)
+                        ui['run_seedvr_btn'] = gr.Button("2. Iniciar Upscaling SeedVR", variant="primary", interactive=is_seedvr_available)
+                    with gr.Column(scale=1):
+                        ui['seedvr_video_output'] = gr.Video(label="Vídeo com Upscale SeedVR", interactive=False)
+                        ui['seedvr_status_box'] = gr.Textbox(label="Status do SeedVR", value="Aguardando...", lines=3, interactive=False)
 
 def _register_event_handlers(app_state: gr.State, ui: dict):
     """Registra todos os manipuladores de eventos do Gradio."""
@@ -193,6 +237,9 @@ def _register_event_handlers(app_state: gr.State, ui: dict):
     
     ui['fp_guidance_preset'].change(fn=toggle_custom_guidance, inputs=ui['fp_guidance_preset'], outputs=ui['custom_guidance_group'])
 
+    def update_seed_display(state):
+        return state.get("used_seed", "N/A")
+
     gen_inputs = [
         ui['generation_mode'], ui['prompt'], ui['neg_prompt'], ui['start_image'],
         ui['height'], ui['width'], ui['duration'],
@@ -200,19 +247,30 @@ def _register_event_handlers(app_state: gr.State, ui: dict):
         ui['fp_num_inference_steps'], ui['fp_skip_initial_steps'], ui['fp_skip_final_steps'],
     ]
     gen_outputs = [ui['low_res_video_output'], app_state, ui['post_prod_group']]
-    ui['generate_low_btn'].click(fn=run_generate_base_video, inputs=gen_inputs, outputs=gen_outputs)
+    
+    (
+        ui['generate_low_btn']
+        .click(fn=run_generate_base_video, inputs=gen_inputs, outputs=gen_outputs)
+        .then(fn=update_seed_display, inputs=[app_state], outputs=[ui['used_seed_display']])
+    )
 
     refine_inputs = [app_state, ui['prompt'], ui['neg_prompt']]
     refine_outputs = [ui['ltx_refined_video_output'], app_state]
     ui['ltx_refine_btn'].click(fn=run_ltx_refinement, inputs=refine_inputs, outputs=refine_outputs)
     
-    # (Handlers para o SeedVR, se ativados)
+    if 'run_seedvr_btn' in ui:
+        seedvr_inputs = [app_state, ui['seedvr_seed'], ui['seedvr_resolution'], ui['seedvr_batch_size'], ui['seedvr_fps']]
+        seedvr_outputs = [ui['seedvr_video_output'], ui['seedvr_status_box']]
+        ui['run_seedvr_btn'].click(fn=run_seedvr_upscaling, inputs=seedvr_inputs, outputs=seedvr_outputs)
 
 # ==============================================================================
 # --- PONTO DE ENTRADA DA APLICAÇÃO ---
 # ==============================================================================
 
 if __name__ == "__main__":
+    log_level = os.environ.get("ADUC_LOG_LEVEL", "INFO").upper()
+    logging.basicConfig(level=log_level, format='[%(levelname)s] [%(name)s] %(message)s')
+    
     print("Building Gradio UI...")
     gradio_app = build_ui()
     print("Launching Gradio app...")
@@ -220,4 +278,4 @@ if __name__ == "__main__":
         server_name=os.getenv("GRADIO_SERVER_NAME", "0.0.0.0"), 
         server_port=int(os.getenv("GRADIO_SERVER_PORT", "7860")),
         show_error=True
-    )
+    )