Update aduc_framework/orchestrator.py

aduc_framework/orchestrator.py

@@ -2,11 +2,11 @@
 #
 # Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
 #
-# Version: 4.1.0 (Multi-Pool with Forced SeedVR 3B)
+# Versão 5.0.0 (Conductor for Autonomous Director)
 #
-# Esta versão do orquestrador opera com uma arquitetura de múltiplos pools de
-# especialistas e simplifica a tarefa de masterização HD, fixando o uso do
-# modelo SeedVR 3B e removendo a necessidade de selecionar a versão do modelo.
+# Esta versão do orquestrador está alinhada com a arquitetura do Diretor Autônomo.
+# Ele delega a complexa tarefa de geração de keyframes ao Deformes3DEngine (`painter`),
+# que agora gerencia seu próprio ciclo de avaliação, correção e improviso.
 
 import logging
 from typing import List, Dict, Any, Tuple, Callable, Optional, Generator
@@ -19,14 +19,14 @@ import time
 import gc
 import torch
 
-# Componentes internos do framework
+# --- Componentes Internos do Framework ---
 from .director import AducDirector
 from .types import GenerationState, PreProductionParams, ProductionParams
 
 # Engenheiros de alto nível que definem a lógica do fluxo
 from .engineers import deformes2d_thinker_singleton, deformes3d_engine_singleton, Deformes4DEngine
 
-# Managers (Pools) de especialistas que executam as tarefas em hardware dedicado
+# Managers (Pools) de especialistas que executam tarefas de pós-produção
 from .managers.latent_enhancer_manager import latent_enhancer_specialist_singleton
 from .managers.seedvr_manager import seedvr_manager_singleton
 from .managers.mmaudio_manager import mmaudio_manager_singleton
@@ -36,7 +36,6 @@ from .managers.vae_manager import vae_manager_singleton
 from .tools.video_encode_tool import video_encode_tool_singleton
 
 logger = logging.getLogger(__name__)
-
 ProgressCallback = Optional[Callable[[float, str], None]]
 
 class AducOrchestrator:
@@ -55,11 +54,11 @@ class AducOrchestrator:
         logger.info("ADUC Maestro (Framework Core) pronto para reger a orquestra de especialistas.")
 
     def get_current_state(self) -> GenerationState:
-        """Retorna o estado de geração atual."""
+        """Retorna o estado de geração atual, útil para APIs."""
         return self.director.get_full_state()
 
     def process_image_for_story(self, image_path: str, size: int, filename: str) -> str:
-        """Processa uma imagem de referência para o formato quadrado padrão."""
+        """Processa e padroniza uma imagem de referência para o formato quadrado."""
         img = Image.open(image_path).convert("RGB")
         img_square = ImageOps.fit(img, (size, size), Image.Resampling.LANCZOS)
         processed_path = os.path.join(self.director.workspace_dir, filename)
@@ -69,16 +68,26 @@ class AducOrchestrator:
 
     # --- ETAPA 1: PRÉ-PRODUÇÃO ---
     def task_pre_production(self, params: PreProductionParams, progress_callback: ProgressCallback = None) -> Tuple[List[str], List[str], GenerationState]:
-        """Orquestra a criação do storyboard e dos keyframes visuais."""
+        """Orquestra a criação do storyboard e a geração autônoma de keyframes."""
         logger.info("Maestro: Iniciando tarefa de Pré-Produção.")
         self.director.update_parameters("pre_producao", params)
         
-        if progress_callback: progress_callback(0.1, "Gerando storyboard...")
-        storyboard_list = deformes2d_thinker_singleton.generate_storyboard(prompt=params.prompt, num_keyframes=params.num_keyframes, ref_image_paths=params.ref_paths)
+        # Passo 1A: Gerar o roteiro inicial (storyboard)
+        if progress_callback: progress_callback(0.1, "Gerando roteiro inicial...")
+        storyboard_list = deformes2d_thinker_singleton.generate_storyboard(
+            prompt=params.prompt, num_keyframes=params.num_keyframes, ref_image_paths=params.ref_paths
+        )
         self.director.update_pre_production_state(params.prompt, params.ref_paths, storyboard_list)
         
-        if progress_callback: progress_callback(0.2, "Iniciando geração de keyframes...")
-        keyframes_detailed_data = self.painter.generate_keyframes_from_storyboard(generation_state=self.director.get_full_state_as_dict(), progress_callback=progress_callback)
+        # Passo 1B: Entregar produção ao Diretor Autônomo para gerar os keyframes
+        if progress_callback: progress_callback(0.2, "Entregando produção ao Diretor Autônomo...")
+        
+        # CORREÇÃO APLICADA: Chamamos o método correto e renomeado `generate_keyframes`.
+        keyframes_detailed_data = self.painter.generate_keyframes(
+            generation_state=self.director.get_full_state_as_dict(), 
+            progress_callback=progress_callback
+        )
+        
         self.director.update_keyframes_state(keyframes_detailed_data)
         
         final_keyframe_paths = [kf["caminho_pixel"] for kf in keyframes_detailed_data]
@@ -92,7 +101,10 @@ class AducOrchestrator:
         logger.info("Maestro: Iniciando tarefa de Produção do Filme Original.")
         self.director.update_parameters("producao", params)
         
-        result_data = self.editor.generate_original_movie(full_generation_state=self.director.get_full_state_as_dict(), progress_callback=progress_callback)
+        result_data = self.editor.generate_original_movie(
+            full_generation_state=self.director.get_full_state_as_dict(), 
+            progress_callback=progress_callback
+        )
         self.director.update_video_state(result_data["video_data"])
         
         final_video_path = result_data["final_path"]
@@ -105,7 +117,6 @@ class AducOrchestrator:
 
     def task_run_latent_upscaler(self, latent_paths: List[str], chunk_size: int, progress_callback: ProgressCallback = None) -> Generator[Dict[str, Any], None, None]:
         """Aplica upscale 2x nos latentes e os decodifica para um novo vídeo."""
-        if not self.director.workspace_dir: raise RuntimeError("Orchestrator não inicializado.")
         if not latent_paths: raise ValueError("Nenhum caminho de latente fornecido para o upscale.")
         
         logger.info("--- ORQUESTRADOR: Tarefa de Upscaling de Latentes ---")
@@ -127,7 +138,7 @@ class AducOrchestrator:
             pixel_tensor = vae_manager_singleton.decode(upscaled_latent_chunk)
 
             current_clip_path = os.path.join(temp_dir, f"upscaled_clip_{i:04d}.mp4")
-            self.editor.save_video_from_tensor(pixel_tensor, current_clip_path, fps=24)
+            video_encode_tool_singleton.save_video_from_tensor(pixel_tensor, current_clip_path)
             final_upscaled_clip_paths.append(current_clip_path)
             
             del tensors_in_chunk, sub_group_latent, upscaled_latent_chunk, pixel_tensor
@@ -142,12 +153,11 @@ class AducOrchestrator:
         yield {"final_path": final_video_path}
 
     def task_run_hd_mastering(self, source_video_path: str, steps: int, prompt: str, progress_callback: ProgressCallback = None) -> Generator[Dict[str, Any], None, None]:
-        """Aplica masterização em HD usando o pool de GPUs do SeedVR com o modelo 3B."""
-        if not self.director.workspace_dir: raise RuntimeError("Orchestrator não inicializado.")
-        logger.info(f"--- ORQUESTRADOR: Tarefa de Masterização HD com SeedVR 3B ---")
+        """Aplica masterização em HD usando o pool de GPUs do SeedVR."""
+        logger.info(f"--- ORQUESTRADOR: Tarefa de Masterização HD com SeedVR ---")
         
         run_timestamp = int(time.time())
-        output_path = os.path.join(self.director.workspace_dir, f"hd_mastered_movie_3B_{run_timestamp}.mp4")
+        output_path = os.path.join(self.director.workspace_dir, f"hd_mastered_movie_{run_timestamp}.mp4")
         
         final_path = seedvr_manager_singleton.process_video(
             input_video_path=source_video_path,
@@ -160,7 +170,6 @@ class AducOrchestrator:
 
     def task_run_audio_generation(self, source_video_path: str, audio_prompt: str, progress_callback: ProgressCallback = None) -> Generator[Dict[str, Any], None, None]:
         """Gera e adiciona áudio ao vídeo usando o pool de GPUs do MMAudio."""
-        if not self.director.workspace_dir: raise RuntimeError("Orchestrator não inicializado.")
         logger.info(f"--- ORQUESTRADOR: Tarefa de Geração de Áudio ---")
 
         if progress_callback: progress_callback(0.1, "Preparando para geração de áudio...")