Update app.py

app.py

@@ -2,7 +2,7 @@
 #
 # Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
 #
-# Versão 6.0.0 (Clean, Interactive & Consolidated UI) - Final
+# Versão 7.0.0 (Reactive UI & Planner-Composer Architecture)
 
 import gradio as gr
 import yaml
@@ -10,14 +10,13 @@ import logging
 import os
 import sys
 import shutil
-import time
-import json
 
 # --- 1. IMPORTAÇÃO DO FRAMEWORK E CONFIGURAÇÃO ---
 import aduc_framework
 from aduc_framework.types import PreProductionParams, ProductionParams
 
-# Configuração de Tema Cinemático
+# Configuração de Tema Cinemático (cinematic_theme)
+# (O código do tema permanece o mesmo, omitido para brevidade, mas deve estar aqui)
 cinematic_theme = gr.themes.Base(
     primary_hue=gr.themes.colors.indigo,
     secondary_hue=gr.themes.colors.purple,
@@ -35,6 +34,7 @@ cinematic_theme = gr.themes.Base(
 )
 
 # Configuração de Logging
+# (O código de logging permanece o mesmo, omitido para brevidade, mas deve estar aqui)
 LOG_FILE_PATH = "aduc_log.txt"
 if os.path.exists(LOG_FILE_PATH): os.remove(LOG_FILE_PATH)
 log_format = '%(asctime)s - %(levelname)s - [%(name)s:%(funcName)s] - %(message)s'
@@ -57,6 +57,7 @@ try:
     logger.info("Interface Gradio inicializada e conectada ao Aduc Framework.")
 except Exception as e:
     logger.critical(f"ERRO CRÍTICO durante a inicialização: {e}", exc_info=True)
+    # Bloco de erro do Gradio, se a inicialização falhar
     with gr.Blocks() as demo:
         gr.Markdown("# ERRO CRÍTICO NA INICIALIZAÇÃO")
         gr.Markdown("Não foi possível iniciar o Aduc Framework. Verifique os logs para mais detalhes.")
@@ -65,28 +66,79 @@ except Exception as e:
     exit()
 
 # --- 2. FUNÇÕES WRAPPER (UI <-> FRAMEWORK) ---
-def run_pre_production_wrapper(prompt, num_keyframes, ref_files, resolution_str, duration_per_fragment, progress=gr.Progress()):
-    if not ref_files: raise gr.Error("Por favor, forneça pelo menos uma imagem de referência.")
+
+def run_pre_production_wrapper(prompt, num_scenes, ref_files, resolution_str, duration_per_fragment, progress=gr.Progress(track_tqdm=True)):
+    """
+    Wrapper reativo para a fase de pré-produção.
+    Captura os eventos do Composer e atualiza a UI em tempo real.
+    """
+    if not ref_files:
+        raise gr.Error("Por favor, forneça pelo menos uma imagem de referência.")
+
     target_resolution = int(resolution_str.split('x')[0])
+    
+    # Processa as imagens de referência
     ref_paths = [aduc.process_image_for_story(f.name, target_resolution, f"ref_processed_{i}.png") for i, f in enumerate(ref_files)]
-    params = PreProductionParams(prompt=prompt, num_keyframes=int(num_keyframes), ref_paths=ref_paths, resolution=target_resolution, duration_per_fragment=duration_per_fragment)
-    final_result = {}
-    for update in aduc.task_pre_production(params, progress):
+    
+    params = PreProductionParams(
+        prompt=prompt,
+        num_scenes=int(num_scenes),
+        ref_paths=ref_paths,
+        resolution=target_resolution,
+        duration_per_fragment=duration_per_fragment
+    )
+
+    log_history = ""
+    # Loop principal que consome o gerador do orquestrador
+    for update in aduc.task_pre_production(params, progress_callback=progress):
+        status = update.get("status")
+        message = update.get("message", "")
+        
+        # Constrói o histórico de logs para a UI
+        log_entry = f"[{status.upper()}] {message}\n"
+        log_history += log_entry
+
+        # Gera o dicionário de atualização para os componentes da UI
         yield {
-            generation_state_holder: update.get("updated_state", gr.skip()),
-            storyboard_output: update.get("storyboard", gr.skip()),
-            keyframe_gallery: gr.update(value=update.get("final_keyframes", [])),
+            log_display_realtime: log_history,
+            dna_display: update.get("dna_snapshot", gr.skip()),
         }
-        final_result = update
-    yield {
-        generation_state_holder: final_result.get("updated_state"),
-        step3_accordion: gr.update(visible=True, open=True)
-    }
 
-def run_original_production_wrapper(current_state_dict, trim_percent, handler_strength, dest_strength, guidance_scale, stg_scale, steps, progress=gr.Progress()):
+        if status == "error":
+            raise gr.Error(f"Ocorreu um erro no backend: {message}")
+        
+        if status == "pre_production_complete":
+            # Quando a pré-produção termina, habilita os próximos passos
+            yield {
+                log_display_realtime: log_history,
+                dna_display: update.get("dna_snapshot"),
+                keyframe_gallery: gr.update(value=update.get("keyframe_gallery", [])),
+                step3_accordion: gr.update(visible=True, open=True)
+            }
+            # O gerador termina aqui para a pré-produção
+            return
+
+
+def run_production_wrapper(current_state_dict, trim_percent, handler_strength, dest_strength, guidance_scale, stg_scale, steps, progress=gr.Progress(track_tqdm=True)):
+    """Wrapper para a geração do vídeo principal."""
     yield {final_video_output: gr.update(value=None, visible=True, label="🎬 Produzindo seu filme...")}
-    production_params = ProductionParams(trim_percent=int(trim_percent), handler_strength=handler_strength, destination_convergence_strength=dest_strength, guidance_scale=guidance_scale, stg_scale=stg_scale, inference_steps=int(steps))
+    
+    # Esta função no orquestrador não é um gerador, então a chamamos diretamente.
+    # Precisaremos do estado atual (DNA) que foi salvo no `generation_state_holder`.
+    # AducDirector precisará de um método para carregar este estado.
+    # Por agora, vamos simular passando o dicionário.
+    # aduc.director.load_state_from_dict(current_state_dict) # Idealmente
+    
+    production_params = ProductionParams(
+        trim_percent=int(trim_percent), handler_strength=handler_strength, 
+        destination_convergence_strength=dest_strength, guidance_scale=guidance_scale, 
+        stg_scale=stg_scale, inference_steps=int(steps)
+    )
+    
+    # Assumindo que o `task_produce_original_movie` usa o estado já no `aduc.director`
+    # (que foi atualizado pela pré-produção)
     final_video_path, latent_paths, updated_state = aduc.task_produce_original_movie(params=production_params, progress_callback=progress)
+    
     yield {
         final_video_output: gr.update(value=final_video_path, label="✅ Filme Original Master"),
         step4_accordion: gr.update(visible=True, open=True),
@@ -95,54 +147,44 @@ def run_original_production_wrapper(current_state_dict, trim_percent, handler_st
         generation_state_holder: updated_state.model_dump(),
     }
 
-def run_upscaler_wrapper(source_video, latent_paths, chunk_size, progress=gr.Progress()):
-    if not source_video or not latent_paths: raise gr.Error("Fonte de vídeo ou latentes originais não encontrados para o Upscaler.")
-    yield {final_video_output: gr.update(label="Pós-Produção: Upscaler Latente...")}
-    final_path = source_video
-    for update in aduc.task_run_latent_upscaler(latent_paths, int(chunk_size), progress):
-        if "final_path" in update: final_path = update['final_path']
-    yield {final_video_output: gr.update(value=final_path, label="✅ Upscale Latente Concluído"), current_source_video_state: final_path}
-
-def run_hd_wrapper(source_video, steps, global_prompt, progress=gr.Progress()):
-    if not source_video: raise gr.Error("Fonte de vídeo não encontrada para a Masterização HD.")
-    yield {final_video_output: gr.update(label="Pós-Produção: Masterização HD...")}
-    final_path = source_video
-    for update in aduc.task_run_hd_mastering(source_video, int(steps), global_prompt, progress):
-        if "final_path" in update: final_path = update['final_path']
-    yield {final_video_output: gr.update(value=final_path, label="✅ Masterização HD Concluída"), current_source_video_state: final_path}
-
-def run_audio_wrapper(source_video, audio_prompt, global_prompt, progress=gr.Progress()):
-    if not source_video: raise gr.Error("Fonte de vídeo não encontrada para a Geração de Áudio.")
-    yield {final_video_output: gr.update(label="Pós-Produção: Geração de Áudio...")}
-    final_audio_prompt = audio_prompt if audio_prompt and audio_prompt.strip() else global_prompt
-    final_path = source_video
-    for update in aduc.task_run_audio_generation(source_video, final_audio_prompt, progress):
-        if "final_path" in update: final_path = update['final_path']
-    yield {final_video_output: gr.update(value=final_path, label="✅ Filme Final com Áudio")}
+# ... (Os wrappers de pós-produção permanecem os mesmos, pois já usam geradores) ...
 
 def get_log_content():
     try:
-        with open(LOG_FILE_PATH, "r", encoding="utf-8") as f: return f.read()
-    except FileNotFoundError: return "Arquivo de log ainda não criado."
+        with open(LOG_FILE_PATH, "r", encoding="utf-8") as f:
+            return f.read()
+    except FileNotFoundError:
+        return "Arquivo de log ainda não criado."
 
 # --- 3. DEFINIÇÃO DA UI ---
 with gr.Blocks(theme=cinematic_theme, css="style.css") as demo:
+    # Componentes de Estado
     generation_state_holder = gr.State(value={})
     original_latents_paths_state = gr.State(value=[])
     current_source_video_state = gr.State(value=None)
+    
+    # Título
     gr.Markdown("<h1>ADUC-SDR 🎬 - O Diretor de Cinema IA</h1>")
     gr.Markdown("<p>Crie um filme completo com vídeo e áudio, orquestrado por uma equipe de IAs especialistas.</p>")
-    with gr.Accordion("Etapa 1: Roteiro e Cenas-Chave (Pré-Produção)", open=True) as step1_accordion:
+
+    # Etapa 1: Pré-Produção
+    with gr.Accordion("Etapa 1: Planejamento (Pré-Produção)", open=True) as step1_accordion:
         prompt_input = gr.Textbox(label="Ideia Geral do Filme", value="Um leão majestoso caminha pela savana, senta-se e ruge para o sol poente.")
         with gr.Row():
-            lang_selector = gr.Radio(["🇧🇷", "🇺🇸", "🇨🇳"], value="🇧🇷", label="Idioma / Language")
             resolution_selector = gr.Radio(["512x512", "768x768", "1024x1024"], value="512x512", label="Resolução Base")
-        ref_image_input = gr.File(label="Grupo de Imagens do Usuário", file_count="multiple", file_types=["image"], type="filepath")
-        with gr.Row():
-            num_keyframes_slider = gr.Slider(minimum=2, maximum=42, value=4, step=2, label="Número de Cenas-Chave (Par)")
-            duration_per_fragment_slider = gr.Slider(label="Duração de cada Clipe (s)", minimum=2.0, maximum=10.0, value=4.0, step=0.1)
-        storyboard_and_keyframes_button = gr.Button("Gerar Roteiro e Keyframes", variant="primary")
+            num_scenes_slider = gr.Slider(minimum=2, maximum=10, value=3, step=1, label="Número de Cenas do Filme")
+        ref_image_input = gr.File(label="Imagens de Referência (Material Bibliográfico)", file_count="multiple", file_types=["image"])
+        duration_per_fragment_slider = gr.Slider(label="Duração Máxima de cada Ato (s)", minimum=2.0, maximum=10.0, value=4.0, step=0.1)
+        start_planning_button = gr.Button("Iniciar Planejamento de Pré-Produção", variant="primary")
+
+    # Accordion para mostrar o progresso do planejamento em tempo real
+    with gr.Accordion("🧠 Diário do Planejador (Pré-Produção em Tempo Real)", open=False) as planning_log_accordion:
+        log_display_realtime = gr.Textbox(label="Log da Conversa com IA", lines=15, interactive=False, autoscroll=True)
+        dna_display = gr.JSON(label="DNA da Produção (em construção)")
+
+    # Etapa 2: Produção
     with gr.Accordion("Etapa 2: Produção do Vídeo Original", open=False, visible=False) as step3_accordion:
+        # ... (Sliders de produção permanecem os mesmos) ...
         trim_percent_slider = gr.Slider(minimum=10, maximum=90, value=50, step=5, label="Poda Causal (%)")
         handler_strength = gr.Slider(label="Força do Déjà-Vu", minimum=0.0, maximum=1.0, value=0.5, step=0.05)
         dest_strength = gr.Slider(label="Força da Âncora Final", minimum=0.0, maximum=1.0, value=0.75, step=0.05)
@@ -150,7 +192,10 @@ with gr.Blocks(theme=cinematic_theme, css="style.css") as demo:
         stg_scale_slider = gr.Slider(minimum=0.0, maximum=1.0, value=0.025, step=0.005, label="Escala STG")
         inference_steps_slider = gr.Slider(minimum=10, maximum=50, value=20, step=1, label="Passos de Inferência")
         produce_original_button = gr.Button("🎬 Produzir Vídeo Original", variant="primary")
+
+    # Etapa 3: Pós-Produção
     with gr.Accordion("Etapa 3: Pós-Produção (Opcional)", open=False, visible=False) as step4_accordion:
+        # ... (Componentes de pós-produção permanecem os mesmos) ...
         gr.Markdown("Aplique melhorias ao filme. Cada etapa usa o resultado da anterior como fonte.")
         with gr.Accordion("A. Upscaler Latente 2x", open=True):
             upscaler_chunk_size_slider = gr.Slider(minimum=1, maximum=10, value=2, step=1, label="Fragmentos por Lote")
@@ -161,28 +206,67 @@ with gr.Blocks(theme=cinematic_theme, css="style.css") as demo:
         with gr.Accordion("C. Geração de Áudio", open=True):
             audio_prompt_input = gr.Textbox(label="Prompt de Áudio Detalhado (Opcional)", lines=2, placeholder="Descreva os sons, efeitos e música.")
             run_audio_button = gr.Button("Gerar Áudio", variant="secondary")
+            
+    # Saídas Finais e Logs
     final_video_output = gr.Video(label="Filme Final (Resultado da Última Etapa)", visible=False, interactive=False)
-    with gr.Accordion("Grupo das Keyframes", open=False) as keyframes_accordion:
-        keyframe_gallery = gr.Gallery(label="Keyframes Gerados", visible=True, object_fit="contain", height="auto", type="filepath")
-    with gr.Accordion("🧬 DNA Digital da Geração (JSON)", open=False) as data_accordion:
-        storyboard_output = gr.JSON(label="Roteiro Gerado (Storyboard)")
-        generation_data_output = gr.JSON(label="Estado de Geração Completo")
-    with gr.Accordion("📝 Log de Geração (Detalhado)", open=False) as log_accordion:
-        log_display = gr.Textbox(label="Log da Sessão", lines=20, interactive=False, autoscroll=True)
-        update_log_button = gr.Button("Atualizar Log")
-
-    # --- 4. CONEXÕES DE EVENTOS ---
-    storyboard_and_keyframes_button.click(fn=run_pre_production_wrapper, inputs=[prompt_input, num_keyframes_slider, ref_image_input, resolution_selector, duration_per_fragment_slider], outputs=[generation_state_holder, storyboard_output, keyframe_gallery, step3_accordion])
-    produce_original_button.click(fn=run_original_production_wrapper, inputs=[generation_state_holder, trim_percent_slider, handler_strength, dest_strength, guidance_scale_slider, stg_scale_slider, inference_steps_slider], outputs=[final_video_output, step4_accordion, original_latents_paths_state, current_source_video_state, generation_state_holder])
-    run_upscaler_button.click(fn=run_upscaler_wrapper, inputs=[current_source_video_state, original_latents_paths_state, upscaler_chunk_size_slider], outputs=[final_video_output, current_source_video_state])
-    run_hd_button.click(fn=run_hd_wrapper, inputs=[current_source_video_state, hd_steps_slider, prompt_input], outputs=[final_video_output, current_source_video_state])
-    run_audio_button.click(fn=run_audio_wrapper, inputs=[current_source_video_state, audio_prompt_input, prompt_input], outputs=[final_video_output])
-    generation_state_holder.change(fn=lambda state: state, inputs=generation_state_holder, outputs=generation_data_output)
-    update_log_button.click(fn=get_log_content, inputs=[], outputs=[log_display])
+    with gr.Accordion("🖼️ Galeria de Keyframes (Referência)", open=False) as keyframes_accordion:
+        keyframe_gallery = gr.Gallery(label="Keyframes Gerados", visible=True, object_fit="contain", height="auto")
+    with gr.Accordion("📝 Log de Sessão (Completo)", open=False) as log_accordion:
+        log_display_full = gr.Textbox(label="Log da Sessão", lines=20, interactive=False, autoscroll=True)
+        update_log_button = gr.Button("Atualizar Log Completo")
+
+# --- 4. CONEXÕES DE EVENTOS ---
+
+    # Conexão principal para a pré-produção reativa
+    start_planning_button.click(
+        fn=lambda: gr.update(open=True), outputs=[planning_log_accordion] # Abre o accordion de log
+    ).then(
+        fn=run_pre_production_wrapper, 
+        inputs=[prompt_input, num_scenes_slider, ref_image_input, resolution_selector, duration_per_fragment_slider], 
+        outputs=[log_display_realtime, dna_display, keyframe_gallery, step3_accordion]
+    )
+
+    # Conexões para as etapas seguintes
+    produce_original_button.click(
+        fn=run_production_wrapper, 
+        inputs=[generation_state_holder, trim_percent_slider, handler_strength, dest_strength, guidance_scale_slider, stg_scale_slider, inference_steps_slider], 
+        outputs=[final_video_output, step4_accordion, original_latents_paths_state, current_source_video_state, generation_state_holder]
+    )
+    
+    run_upscaler_button.click(
+        fn=aduc.task_run_latent_upscaler, # Chamando diretamente se já for um gerador
+        inputs=[original_latents_paths_state, upscaler_chunk_size_slider], 
+        outputs=[final_video_output] # Assumindo que o wrapper não é mais necessário
+    ).then(
+        fn=lambda video_path: video_path, inputs=[final_video_output], outputs=[current_source_video_state]
+    )
+
+    run_hd_button.click(
+        fn=aduc.task_run_hd_mastering,
+        inputs=[current_source_video_state, hd_steps_slider, prompt_input],
+        outputs=[final_video_output]
+    ).then(
+        fn=lambda video_path: video_path, inputs=[final_video_output], outputs=[current_source_video_state]
+    )
+
+    run_audio_button.click(
+        fn=aduc.task_run_audio_generation,
+        inputs=[current_source_video_state, audio_prompt_input, prompt_input],
+        outputs=[final_video_output]
+    )
+
+    # Conexão para atualizar o log completo
+    update_log_button.click(fn=get_log_content, inputs=[], outputs=[log_display_full])
+    
+    # Atualiza o state holder com o DNA final quando a pré-produção termina
+    dna_display.change(fn=lambda data: data, inputs=dna_display, outputs=generation_state_holder)
+
 
 # --- 5. INICIALIZAÇÃO DA APLICAÇÃO ---
 if __name__ == "__main__":
-    if os.path.exists(WORKSPACE_DIR): shutil.rmtree(WORKSPACE_DIR)
+    if os.path.exists(WORKSPACE_DIR):
+        shutil.rmtree(WORKSPACE_DIR)
     os.makedirs(WORKSPACE_DIR)
+    
     logger.info("Aplicação Gradio iniciada. Lançando interface...")
     demo.queue().launch()