Update aduc_orchestrator.py

aduc_orchestrator.py

@@ -1,13 +1,39 @@
 # aduc_orchestrator.py
 #
-# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
+# AducSdr: Uma implementação aberta e funcional da arquitetura ADUC-SDR
+# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
 #
-# Version: 2.2.0
+# Contato:
+# Carlos Rodrigues dos Santos
+# carlex22@gmail.com
+# Rua Eduardo Carlos Pereira, 4125, B1 Ap32, Curitiba, PR, Brazil, CEP 8102025
 #
-# This file contains the core ADUC (Automated Discovery and Orchestration of Complex tasks)
-# orchestrator, known as the "Maestro" (Γ). Its responsibility is to manage the high-level
-# creative workflow of film production. This version is updated to reflect the final
-# refactored project structure with `engineers` and `managers`.
+# Repositórios e Projetos Relacionados:
+# GitHub: https://github.com/carlex22/Aduc-sdr
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License...
+# PENDING PATENT NOTICE: Please see NOTICE.md.
+#
+# Version: 3.0.0
+#
+# This version adapts the Maestro to command the new unified "Turbo Intergalactic
+# Multiverse Engine": the Deformes7DEngine. The orchestrator is now a lean
+# command layer, delegating all complex production and post-production tasks
+# to its single, powerful Chief Engineer.
 
 import os
 import logging
@@ -16,18 +42,17 @@ from typing import List, Dict, Any, Generator, Tuple
 import gradio as gr
 from PIL import Image, ImageOps
 
-from engineers.deformes4D import Deformes4DEngine
+# O Orquestrador agora só precisa de dois engenheiros:
+# - O Pensador (2D) para a lógica criativa
+# - O Engenheiro-Chefe (7D) para toda a execução
 from engineers.deformes2D_thinker import deformes2d_thinker_singleton
-from engineers.deformes3D import deformes3d_engine_singleton
+from engineers.deformes7D import deformes7d_engine_singleton
 
-# The logger is configured in app.py; here we just get the instance.
 logger = logging.getLogger(__name__)
 
 class AducDirector:
     """
-    Represents the Scene Director, responsible for managing the production state.
-    Acts as the "score" for the orchestra, keeping track of all generated artifacts
-    (script, keyframes, etc.) during the creative process.
+    Representa o Diretor de Cena, gerenciando o estado da produção.
     """
     def __init__(self, workspace_dir: str):
         self.workspace_dir = workspace_dir
@@ -44,19 +69,21 @@ class AducDirector:
 
 class AducOrchestrator:
     """
-    Implements the Maestro (Γ), the central orchestration layer of the ADUC architecture.
-    It does not execute AI tasks directly but delegates each step of the creative
-    process (scriptwriting, art direction, cinematography) to the appropriate Specialists.
+    Implementa o Maestro (Γ), a camada de orquestração que comanda
+    o Engenheiro-Chefe Deformes7D.
     """
     def __init__(self, workspace_dir: str):
+        """
+        Inicializa o Maestro e seu Engenheiro-Chefe.
+        """
         self.director = AducDirector(workspace_dir)
-        self.editor = Deformes4DEngine(workspace_dir)
-        self.painter = deformes3d_engine_singleton
-        logger.info("ADUC Maestro is on the podium. Musicians (specialists) are ready.")
+        self.thinker = deformes2d_thinker_singleton
+        self.chief_engineer = deformes7d_engine_singleton
+        logger.info("ADUC Maestro is on the podium with the Chief Engineer (Deformes7D) ready.")
 
     def process_image_for_story(self, image_path: str, size: int, filename: str) -> str:
         """
-        Pre-processes a reference image, standardizing it for use by the Specialists.
+        Pré-processa uma imagem de referência, padronizando-a.
         """
         img = Image.open(image_path).convert("RGB")
         img_square = ImageOps.fit(img, (size, size), Image.Resampling.LANCZOS)
@@ -65,135 +92,87 @@ class AducOrchestrator:
         logger.info(f"Reference image processed and saved to: {processed_path}")
         return processed_path
 
-    # --- PRE-PRODUCTION TASKS ---
+    # --- TAREFAS DE PRÉ-PRODUÇÃO (Delegadas ao Pensador 2D) ---
 
     def task_generate_storyboard(self, prompt: str, num_keyframes: int, ref_image_paths: List[str],
                                  progress: gr.Progress) -> Tuple[List[str], str, Any]:
         """
-        Delegates the task of creating the storyboard to the Scriptwriter (deformes2D_thinker).
+        Delega a criação do storyboard para o Deformes2DThinker.
         """
-        logger.info(f"Act 1, Scene 1: Script. Instructing Scriptwriter to create {num_keyframes} scenes.")
-        progress(0.2, desc="Consulting AI Scriptwriter...")
+        logger.info(f"Act 1, Scene 1: Delegating storyboard creation to the Thinker.")
+        progress(0.2, desc="Consulting the Thinker for the script...")
 
-        storyboard = deformes2d_thinker_singleton.generate_storyboard(prompt, num_keyframes, ref_image_paths)
+        storyboard = self.thinker.generate_storyboard(prompt, num_keyframes, ref_image_paths)
 
-        logger.info(f"Scriptwriter returned the score: {storyboard}")
+        logger.info(f"The Thinker returned the script: {storyboard}")
         self.director.update_state("storyboard", storyboard)
         self.director.update_state("processed_ref_paths", ref_image_paths)
         return storyboard, ref_image_paths[0], gr.update(visible=True, open=True)
 
+    # A geração de keyframes agora é parte da produção principal, então esta tarefa é removida.
+    # A seleção de keyframes para o modo fotógrafo permanece.
     def task_select_keyframes(self, storyboard: List[str], base_ref_paths: List[str],
                               pool_ref_paths: List[str]) -> List[str]:
-        """
-        Delegates to the Photographer (deformes2D_thinker) the task of selecting keyframes.
-        """
-        logger.info(f"Act 1, Scene 2 (Photographer Mode): Instructing Photographer to select {len(storyboard)} keyframes.")
-        selected_paths = deformes2d_thinker_singleton.select_keyframes_from_pool(storyboard, base_ref_paths, pool_ref_paths)
-        logger.info(f"Photographer selected the following scenes: {[os.path.basename(p) for p in selected_paths]}")
+        logger.info(f"Act 1, Scene 2 (Photographer Mode): Delegating keyframe selection to the Thinker.")
+        selected_paths = self.thinker.select_keyframes_from_pool(storyboard, base_ref_paths, pool_ref_paths)
         self.director.update_state("keyframes", selected_paths)
         return selected_paths
 
-    def task_generate_keyframes(self, storyboard: List[str], initial_ref_path: str, global_prompt: str,
-                                keyframe_resolution: int, progress_callback_factory=None) -> List[str]:
-        """
-        Delegates to the Art Director (Deformes3DEngine) the task of generating keyframes.
-        """
-        logger.info("Act 1, Scene 2 (Art Director Mode): Delegating to Art Director.")
-        general_ref_paths = self.director.get_state("processed_ref_paths", [])
 
-        final_keyframes = self.painter.generate_keyframes_from_storyboard(
-            storyboard=storyboard,
-            initial_ref_path=initial_ref_path,
-            global_prompt=global_prompt,
-            keyframe_resolution=keyframe_resolution,
-            general_ref_paths=general_ref_paths,
-            progress_callback_factory=progress_callback_factory
-        )
-        self.director.update_state("keyframes", final_keyframes)
-        logger.info("Maestro: Art Director has completed keyframe generation.")
-        return final_keyframes
-
-    # --- PRODUCTION & POST-PRODUCTION TASKS ---
-
-    def task_produce_original_movie(self, keyframes: List[str], global_prompt: str, seconds_per_fragment: float,
-                                    trim_percent: int, handler_strength: float,
-                                    destination_convergence_strength: float,
-                                    guidance_scale: float, stg_scale: float, inference_steps: int,
-                                    video_resolution: int, use_continuity_director: bool,
-                                    progress: gr.Progress) -> Dict[str, Any]:
+    # --- TAREFA DE PRODUÇÃO UNIFICADA (Delegada ao Engenheiro-Chefe 7D) ---
+
+    def task_produce_full_movie(self, initial_ref_paths: List[str], global_prompt: str,
+                                video_resolution: int, seconds_per_fragment: float,
+                                # ... outros parâmetros do Deformes4D
+                                trim_percent: int, handler_strength: float, dest_strength: float,
+                                guidance_scale: float, stg_scale: float, inference_steps: int,
+                                progress: gr.Progress) -> Dict[str, Any]:
         """
-        Delegates the production of the original master video to the Deformes4DEngine.
+        Delega a produção completa do filme para o Deformes7DEngine.
         """
-        logger.info("Maestro: Delegating production of the original movie to Deformes4DEngine.")
+        logger.info("Maestro: All systems go. Engaging the Turbo Intergalactic Engine (Deformes7D)...")
         storyboard = self.director.get_state("storyboard", [])
-
-        result = self.editor.generate_original_movie(
-            keyframes=keyframes,
-            global_prompt=global_prompt,
+        if not storyboard:
+            raise gr.Error("Storyboard not generated. Please complete Step 1 first.")
+            
+        ltx_params = {
+            "guidance_scale": guidance_scale,
+            "stg_scale": stg_scale,
+            "num_inference_steps": inference_steps
+        }
+
+        # A chamada agora é para a função unificada do motor 7D
+        result = self.chief_engineer.generate_full_movie_interleaved(
+            initial_ref_paths=initial_ref_paths,
             storyboard=storyboard,
+            global_prompt=global_prompt,
+            video_resolution=video_resolution,
             seconds_per_fragment=seconds_per_fragment,
             trim_percent=trim_percent,
             handler_strength=handler_strength,
-            destination_convergence_strength=destination_convergence_strength,
-            video_resolution=video_resolution,
-            use_continuity_director=use_continuity_director,
-            guidance_scale=guidance_scale,
-            stg_scale=stg_scale,
-            num_inference_steps=inference_steps,
+            dest_strength=dest_strength,
+            ltx_params=ltx_params,
             progress=progress
         )
         
         self.director.update_state("final_video_path", result["final_path"])
-        self.director.update_state("latent_paths", result["latent_paths"])
-        logger.info("Maestro: Original movie production complete.")
+        self.director.update_state("all_keyframes", result["all_keyframes"])
+        logger.info("Maestro: Deformes7D has completed the main production run.")
         return result
 
-    def task_run_latent_upscaler(self, latent_paths: List[str], chunk_size: int, progress: gr.Progress) -> Generator[Dict[str, Any], None, None]:
-        """
-        Orchestrates the latent upscaling task.
-        """
-        logger.info(f"Maestro: Delegating latent upscaling task for {len(latent_paths)} fragments.")
-        for update in self.editor.upscale_latents_and_create_video(
-            latent_paths=latent_paths,
-            chunk_size=chunk_size,
-            progress=progress
-        ):
-            if "final_path" in update and update["final_path"]:
-                self.director.update_state("final_video_path", update["final_path"])
-                yield update
-                break
-        logger.info("Maestro: Latent upscaling complete.")
-    
+    # --- TAREFAS DE PÓS-PRODUÇÃO (Delegadas ao Engenheiro-Chefe 7D) ---
+
     def task_run_hd_mastering(self, source_video_path: str, model_version: str, steps: int, prompt: str, progress: gr.Progress) -> Generator[Dict[str, Any], None, None]:
-        """
-        Orchestrates the HD mastering task.
-        """
-        logger.info(f"Maestro: Delegating HD mastering task using SeedVR {model_version}.")
-        for update in self.editor.master_video_hd(
-            source_video_path=source_video_path,
-            model_version=model_version,
-            steps=steps,
-            prompt=prompt,
-            progress=progress
+        logger.info(f"Maestro: Delegating HD mastering to the Chief Engineer.")
+        for update in self.chief_engineer.master_video_hd(
+            source_video_path=source_video_path, model_version=model_version,
+            steps=steps, prompt=prompt, progress=progress
         ):
-            if "final_path" in update and update["final_path"]:
-                self.director.update_state("final_video_path", update["final_path"])
-                yield update
-                break
-        logger.info("Maestro: HD mastering complete.")
-
+            yield update
+    
     def task_run_audio_generation(self, source_video_path: str, audio_prompt: str, progress: gr.Progress) -> Generator[Dict[str, Any], None, None]:
-        """
-        Orchestrates the audio generation task.
-        """
-        logger.info(f"Maestro: Delegating audio generation task.")
-        for update in self.editor.generate_audio_for_final_video(
-            source_video_path=source_video_path,
-            audio_prompt=audio_prompt,
-            progress=progress
+        logger.info(f"Maestro: Delegating audio generation to the Chief Engineer.")
+        for update in self.chief_engineer.generate_audio(
+            source_video_path=source_video_path, audio_prompt=audio_prompt, progress=progress
         ):
-             if "final_path" in update and update["final_path"]:
-                self.director.update_state("final_video_path", update["final_path"])
-                yield update
-                break
-        logger.info("Maestro: Audio generation complete.")
+            yield update