Update app.py

app.py

@@ -1,36 +1,41 @@
 # FILE: app.py
 # DESCRIPTION: Final Gradio web interface for the ADUC-SDR Video Suite.
-# Features dimension sliders locked to multiples of 8, a unified LTX workflow,
-# advanced controls, integrated SeedVR upscaling, and detailed debug logging.
+# This version is refactored to use the central LtxAducOrchestrator, simplifying the UI logic
+# and making it a pure client of the backend services.
 
 import gradio as gr
 import traceback
 import sys
 import os
 import logging
+from PIL import Image
 
 # ==============================================================================
 # --- IMPORTAÇÃO DOS SERVIÇOS DE BACKEND E UTILS ---
 # ==============================================================================
 
 try:
-    # Serviço principal para geração LTX
-    from api.ltx.ltx_aduc_pipeline import ltx_aduc_pipeline
+    # --- MUDANÇA PRINCIPAL: Importamos apenas o ORQUESTRADOR ---
+    # O orquestrador é agora nosso único ponto de entrada para a geração de vídeo.
+    from api.ltx_aduc_orchestrator import ltx_aduc_orchestrator
+    
+    # O SeedVR (upscaler de resolução) ainda é um serviço separado que pode ser chamado após a geração.
+    from api.seedvr.seed_aduc_pipeline import seed_aduc_pipeline
     
     # Nosso decorador de logging para depuração
     from utils.debug_utils import log_function_io
-
-    # Serviço especialista para upscaling de resolução (SeedVR)
-    from api.seedvr.seed_aduc_pipeline import seed_aduc_pipeline 
     
-    logging.info("All backend services (LTX, SeedVR) and debug utils imported successfully.")
+    logging.info("All backend services (Orchestrator, SeedVR) and debug utils imported successfully.")
 
 except ImportError as e:
+    # Lógica de falha para o decorador de log
     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}")
-    if 'ltx_aduc_pipeline' not in locals():
-        logging.critical(f"FATAL: Main LTX service failed to import.", exc_info=True)
+    logging.warning(f"Could not import a module. Debug logger might be disabled. Details: {e}")
+    # Verifica se o orquestrador, que é CRÍTICO, falhou ao importar.
+    if 'ltx_aduc_orchestrator' not in locals() or ltx_aduc_orchestrator is None:
+        logging.critical(f"FATAL: Main Orchestrator service failed to import or initialize.", exc_info=True)
         sys.exit(1)
+    # SeedVR é opcional, então apenas avisamos se ele falhar.
     if 'seed_aduc_pipeline' not in locals():
         seed_aduc_pipeline = None
         logging.warning("SeedVR server could not be initialized. The SeedVR upscaling tab will be disabled.")
@@ -43,77 +48,58 @@ except Exception as e:
 # ==============================================================================
 
 @log_function_io
-def run_generate_base_video(
-    generation_mode: str, prompt: str, neg_prompt: str, start_img: str, 
+def run_orchestrated_generation(
+    prompt: str, start_img_path: str, 
     height: int, width: int, duration: float,
     fp_guidance_preset: str, fp_guidance_scale_list: str, fp_stg_scale_list: str,
-    fp_num_inference_steps: int, fp_skip_initial_steps: int, fp_skip_final_steps: int,
+    fp_num_inference_steps: int,
     progress=gr.Progress(track_tqdm=True)
 ) -> tuple:
-    """Wrapper para a geração do vídeo base LTX."""
+    """
+    Função wrapper simplificada que coleta dados da UI e chama o orquestrador principal.
+    """
     try:
-        logging.info(f"[UI] Request received. Selected mode: {generation_mode}")
+        logging.info("[UI] Request received. Submitting job to the main orchestrator...")
         
-        initial_conditions = []
-        if start_img:
-            num_frames_estimate = int(duration * 24)
-            items_list = [[start_img, 0, 1.0]]
-            initial_conditions = ltx_aduc_pipeline.prepare_condition_items(
-                items_list, height, width, num_frames_estimate
-            )
-
+        # Monta o dicionário de configurações avançadas LTX a partir da UI
         ltx_configs = {
             "guidance_preset": fp_guidance_preset,
             "guidance_scale_list": fp_guidance_scale_list,
             "stg_scale_list": fp_stg_scale_list,
-            "num_inference_steps": fp_num_inference_steps,
-            "skip_initial_inference_steps": fp_skip_initial_steps,
-            "skip_final_inference_steps": fp_skip_final_steps,
+            "num_inference_steps": fp_num_inference_steps
         }
 
-        video_path, tensor_path, final_seed = ltx_aduc_pipeline.generate_low_resolution(
-            prompt=prompt, negative_prompt=neg_prompt,
-            height=height, width=width, duration=duration,
-            initial_conditions=initial_conditions, ltx_configs_override=ltx_configs
+        # Carrega a imagem inicial para um objeto PIL, que é o que o orquestrador espera.
+        initial_image_pil = Image.open(start_img_path).convert("RGB") if start_img_path else None
+
+        # --- CHAMADA ÚNICA E LIMPA PARA O ORQUESTRADOR ---
+        video_path = ltx_aduc_orchestrator(
+            prompt=prompt,
+            initial_image=initial_image_pil,
+            height=height,
+            width=width,
+            duration_in_seconds=duration,
+            ltx_configs=ltx_configs
         )
         
-        if not video_path: raise RuntimeError("Backend failed to return a valid video path.")
+        if not video_path:
+            raise RuntimeError("Orchestrator failed to return a valid video path. Check backend logs for details.")
 
-        new_state = {"low_res_video": video_path, "low_res_latents": tensor_path, "used_seed": final_seed}
-        logging.info(f"[UI] Base video generation successful. Seed used: {final_seed}, Path: {video_path}")
+        logging.info(f"[UI] Orchestrator job successful. Video path: {video_path}")
+        
+        # O estado agora pode ser mais simples, apenas guardando o caminho do vídeo gerado para o próximo passo (SeedVR).
+        new_state = {"low_res_video": 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}"
+        error_message = f"❌ An error occurred during the orchestrated generation:\n{e}"
         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 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.")
-    
-    try:
-        logging.info(f"[UI] Requesting LTX refinement for latents: {state.get('low_res_latents')}")
-        video_path, tensor_path = ltx_aduc_pipeline.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)
 
 @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."""
+    """Wrapper para o upscale de resolução SeedVR. Esta função permanece a mesma."""
     if not state or not state.get("low_res_video"):
         raise gr.Error("Error: Please generate a base video in Step 1 before upscaling.")
     if not seed_aduc_pipeline:
@@ -143,15 +129,14 @@ def run_seedvr_upscaling(state: dict, seed: int, resolution: int, batch_size: in
 def build_ui():
     """Constrói a interface completa do Gradio."""
     with gr.Blocks(theme=gr.themes.Soft(primary_hue="indigo")) as demo:
-        app_state = gr.State(value={"low_res_video": None, "low_res_latents": None, "used_seed": None})
+        app_state = gr.State(value={"low_res_video": None})
         ui_components = {}
-        gr.Markdown("# ADUC-SDR Video Suite - LTX & SeedVR Workflow", elem_id="main-title")
+        gr.Markdown("# ADUC-SDR Video Suite - Orchestrated Workflow", elem_id="main-title")
         with gr.Row():
             with gr.Column(scale=1): _build_generation_controls(ui_components)
             with gr.Column(scale=1):
-                gr.Markdown("### Etapa 1: Vídeo Base Gerado")
+                gr.Markdown("### Etapa 1: Vídeo Base Gerado pelo Orquestrador")
                 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)
     return demo
@@ -159,46 +144,33 @@ 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['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['prompt'] = gr.Textbox(label="Prompt(s) de Geração", 
+                              info="Escreva sua história. Cada nova linha será tratada como uma nova cena.",
+                              value="Um leão majestoso caminha pela savana\nEle sobe em uma grande pedra e olha o horizonte", 
+                              lines=4)
     ui['start_image'] = gr.Image(label="Imagem de Início (Opcional)", type="filepath", sources=["upload"])
     
     with gr.Accordion("Parâmetros Principais", open=True):
         ui['duration'] = gr.Slider(label="Duração Total (s)", value=4, step=1, minimum=1, maximum=30)
         with gr.Row():
-            ui['height'] = gr.Slider(label="Height", value=432, step=8, minimum=256, maximum=1024)
-            ui['width'] = gr.Slider(label="Width", value=768, step=8, minimum=256, maximum=1024)
+            ui['height'] = gr.Slider(label="Altura", value=432, step=8, minimum=256, maximum=1024)
+            ui['width'] = gr.Slider(label="Largura", value=768, step=8, minimum=256, maximum=1024)
 
     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.")
-                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]")
-                    ui['fp_stg_scale_list'] = gr.Textbox(label="Lista de STG Scale (Movimento)", value="[0, 0, 4, 4, 4, 2, 1]")
+        ui['fp_num_inference_steps'] = gr.Slider(label="Número de Passos", minimum=1, maximum=100, step=1, value=20)
+        ui['fp_guidance_preset'] = gr.Dropdown(label="Preset de Guiagem", choices=["Padrão (Recomendado)", "Customizado"], value="Padrão (Recomendado)")
+        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]")
+            ui['fp_stg_scale_list'] = gr.Textbox(label="Lista de STG Scale (Movimento)", value="[0, 0, 4, 4, 4, 2, 1]")
     
-    ui['generate_low_btn'] = gr.Button("1. Gerar Vídeo Base", variant="primary")
+    ui['generate_low_btn'] = gr.Button("1. Gerar Vídeo via Orquestrador", variant="primary")
 
 def _build_postprod_controls(ui: dict):
-    """Constrói os componentes da UI para a Etapa 2: Pós-Produção."""
+    """Constrói os componentes da UI para a Etapa 2: Pós-Produção (Upscaling)."""
     with gr.Group(visible=False) as ui['post_prod_group']:
         gr.Markdown("--- \n## Etapa 2: Pós-Produção")
         with gr.Tabs():
-            with gr.TabItem("🚀 Upscaler de Textura (LTX)"):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                         gr.Markdown("Usa o prompt e a semente originais para refinar o vídeo, adicionando detalhes e texturas de alta qualidade.")
-                         ui['ltx_refine_btn'] = gr.Button("2. Aplicar Refinamento LTX", variant="primary")
-                    with gr.Column(scale=1):
-                        ui['ltx_refined_video_output'] = gr.Video(label="Vídeo com Textura Refinada", interactive=False)
-            
             with gr.TabItem("✨ Upscaler de Resolução (SeedVR)"):
                 is_seedvr_available = seed_aduc_pipeline is not None
                 if not is_seedvr_available:
@@ -221,23 +193,15 @@ 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['prompt'], ui['start_image'],
         ui['height'], ui['width'], ui['duration'],
         ui['fp_guidance_preset'], ui['fp_guidance_scale_list'], ui['fp_stg_scale_list'],
-        ui['fp_num_inference_steps'], ui['fp_skip_initial_steps'], ui['fp_skip_final_steps'],
+        ui['fp_num_inference_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)
-     .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)
+    ui['generate_low_btn'].click(fn=run_orchestrated_generation, inputs=gen_inputs, outputs=gen_outputs)
     
     if 'run_seedvr_btn' in ui and ui['run_seedvr_btn'].interactive:
         seedvr_inputs = [app_state, ui['seedvr_seed'], ui['seedvr_resolution'], ui['seedvr_batch_size'], ui['seedvr_fps']]