feat: Implement self-contained specialist managers

aduc_framework/engineers/deformes3D.py

@@ -183,11 +183,4 @@ class Deformes3DEngine:
         Image.fromarray(image_np).save(path)
 
 # --- Singleton Instantiation ---
-try:
-    with open("config.yaml", 'r') as f:
-        config = yaml.safe_load(f)
-    WORKSPACE_DIR = config['application']['workspace_dir']
-    deformes3d_engine_singleton = Deformes3DEngine(workspace_dir=WORKSPACE_DIR)
-except Exception as e:
-    logger.error(f"Could not initialize Deformes3DEngine: {e}", exc_info=True)
-    deformes3d_engine_singleton = None
+deformes3d_engine_singleton = Deformes3DEngine()

aduc_framework/engineers/deformes7D.py

@@ -299,18 +299,4 @@ class Deformes7DEngine:
             logger.error(f"Audio generation failed: {e}", exc_info=True)
             raise gr.Error(f"Audio generation failed. Details: {e}")
 
-# --- Singleton Instantiation ---
-try:
-    config_path = Path(__file__).resolve().parent.parent / "config.yaml"
-    with open(config_path, 'r') as f:
-        config = yaml.safe_load(f)
-    WORKSPACE_DIR = config['application']['workspace_dir']
-    deformes7d_engine_singleton = Deformes7DEngine(workspace_dir=WORKSPACE_DIR)
-# <--- INÍCIO DA CORREÇÃO --->
-except Exception as e:
-    # Loga o erro como CRÍTICO, pois a aplicação não pode funcionar sem este motor.
-    logger.critical(f"CRITICAL: Failed to initialize the Deformes7DEngine singleton from {config_path}: {e}", exc_info=True)
-    # Relança a exceção para parar a aplicação imediatamente.
-    # Isso evita o erro 'NoneType' mais tarde e fornece um ponto claro de falha.
-    raise
-# <--- FIM DA CORREÇÃO --->
+deformes7d_engine_singleton = Deformes7DEngine()

aduc_framework/orchestrator.py

@@ -2,22 +2,27 @@
 #
 # Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
 #
-# Versão 3.0.0 (Framework Core)
+# Versão 3.1.0 (Framework Core com Inicialização Centralizada)
 #
 # Esta versão representa a camada de orquestração do Aduc Framework.
 # Ela é agnóstica a qualquer interface (UI ou API) e opera com
 # tipos de dados bem definidos (Pydantic) e um estado de geração central.
+# Agora, é responsável por inicializar os singletons dos engenheiros.
 
 import logging
 from typing import List, Dict, Any, Tuple, Callable, Optional
-
 from PIL import Image, ImageOps
 import os
 
 # Importa componentes internos do framework
 from .director import AducDirector
 from .types import GenerationState, PreProductionParams, ProductionParams
-from .engineers import deformes2d_thinker_singleton, deformes3d_engine_singleton, Deformes4DEngine
+from .engineers import (
+    deformes2d_thinker_singleton,
+    deformes3d_engine_singleton,
+    deformes7d_engine_singleton,
+    Deformes4DEngine
+)
 
 logger = logging.getLogger(__name__)
 
@@ -38,9 +43,16 @@ class AducOrchestrator:
             workspace_dir (str): O diretório raiz para salvar todos os artefatos gerados.
         """
         self.director = AducDirector(workspace_dir)
-        # O Deformes4D é instanciado aqui pois não é um singleton complexo
-        self.editor = Deformes4DEngine(workspace_dir)
+        self.editor = Deformes4DEngine() # Instancia o editor
+        self.editor.initialize(workspace_dir) # E o inicializa
+
+        # Inicializa os singletons globais com a configuração necessária
         self.painter = deformes3d_engine_singleton
+        self.painter.initialize(workspace_dir)
+
+        self.unified_painter = deformes7d_engine_singleton
+        self.unified_painter.initialize(workspace_dir)
+
         logger.info("ADUC Maestro (Framework Core) está no pódio. Engenheiros especialistas prontos.")
 
     def get_current_state(self) -> GenerationState:
@@ -69,22 +81,11 @@ class AducOrchestrator:
     def task_pre_production(self, params: PreProductionParams, progress_callback: ProgressCallback = None) -> Tuple[List[str], List[str], GenerationState]:
         """
         Executa o fluxo completo de pré-produção: storyboard e geração de keyframes.
-
-        Args:
-            params (PreProductionParams): Objeto Pydantic com todos os parâmetros da UI/API.
-            progress_callback (callable, optional): Uma função que aceita (fração, descrição) para reportar progresso.
-
-        Returns:
-            Tuple[List[str], List[str], GenerationState]: Uma tupla contendo a lista de atos do storyboard,
-                                                          a lista de caminhos dos keyframes gerados, e o estado
-                                                          de geração completo e atualizado.
         """
         logger.info("Maestro: Iniciando tarefa de Pré-Produção.")
         
-        # 1. Atualiza o estado com os parâmetros recebidos
         self.director.update_parameters("pre_producao", params)
         
-        # 2. Gera o storyboard
         if progress_callback: progress_callback(0.1, "Gerando storyboard...")
         
         storyboard_list = deformes2d_thinker_singleton.generate_storyboard(
@@ -94,17 +95,14 @@ class AducOrchestrator:
         )
         self.director.update_pre_production_state(params.prompt, params.ref_paths, storyboard_list)
         
-        # 3. Gera os keyframes
         if progress_callback: progress_callback(0.2, "Iniciando geração de keyframes...")
 
-        # O engenheiro agora recebe o estado completo e o callback genérico
         keyframes_detailed_data = self.painter.generate_keyframes_from_storyboard(
             generation_state=self.director.get_full_state_as_dict(),
             progress_callback=progress_callback
         )
         self.director.update_keyframes_state(keyframes_detailed_data)
         
-        # 4. Prepara o retorno
         final_keyframe_paths = [kf["caminho_pixel"] for kf in keyframes_detailed_data]
         final_state = self.director.get_full_state()
 
@@ -115,32 +113,18 @@ class AducOrchestrator:
     def task_produce_original_movie(self, params: ProductionParams, progress_callback: ProgressCallback = None) -> Tuple[str, List[str], GenerationState]:
         """
         Executa o fluxo de produção do vídeo principal.
-
-        Args:
-            params (ProductionParams): Objeto Pydantic com todos os parâmetros de produção.
-            progress_callback (callable, optional): Função para reportar progresso.
-
-        Returns:
-            Tuple[str, List[str], GenerationState]: Uma tupla contendo o caminho do vídeo final,
-                                                    a lista de caminhos dos latentes dos fragmentos,
-                                                    e o estado de geração completo e atualizado.
         """
         logger.info("Maestro: Iniciando tarefa de Produção do Filme Original.")
 
-        # 1. Atualiza o estado com os novos parâmetros
         self.director.update_parameters("producao", params)
 
-        # 2. Delega a produção para o Deformes4DEngine
-        # O editor agora recebe o estado completo, que já contém os parâmetros que acabamos de salvar.
         result_data = self.editor.generate_original_movie(
             full_generation_state=self.director.get_full_state_as_dict(),
             progress_callback=progress_callback
         )
         
-        # 3. Atualiza o estado com os resultados da produção
         self.director.update_video_state(result_data["video_data"])
 
-        # 4. Prepara o retorno
         final_video_path = result_data["final_path"]
         latent_paths = result_data["latent_paths"]
         final_state = self.director.get_full_state()
@@ -148,15 +132,22 @@ class AducOrchestrator:
         logger.info("Maestro: Tarefa de Produção do Filme Original concluída.")
         return final_video_path, latent_paths, final_state
 
-    # --- TAREFAS DE PÓS-PRODUÇÃO (Exemplos) ---
-    # (A serem refatoradas no futuro para seguir o mesmo padrão)
+    # --- TAREFAS DE PÓS-PRODUÇÃO (Exemplos para futura refatoração) ---
     
     def task_run_hd_mastering(self, source_video_path: str, hd_params: Dict[str, Any], progress_callback: ProgressCallback = None) -> str:
-        # Placeholder para futura refatoração
         logger.info(f"Maestro: Delegando tarefa de masterização HD.")
-        return ""
+        # Lógica futura:
+        # self.director.update_parameters("pos_producao", {"hd_mastering": hd_params})
+        # final_path = self.editor.master_video_hd(...)
+        # self.director.update_pos_production_results(...)
+        # return final_path
+        return "" # Placeholder
         
     def task_run_audio_generation(self, source_video_path: str, audio_params: Dict[str, Any], progress_callback: ProgressCallback = None) -> str:
-        # Placeholder para futura refatoração
         logger.info(f"Maestro: Delegando tarefa de geração de áudio.")
-        return ""
+        # Lógica futura:
+        # self.director.update_parameters("pos_producao", {"audio_generation": audio_params})
+        # final_path = self.editor.generate_audio_for_final_video(...)
+        # self.director.update_pos_production_results(...)
+        # return final_path
+        return "" # Placeholder