Update aduc_orchestrator.py

aduc_orchestrator.py

@@ -127,16 +127,6 @@ class AducOrchestrator:
                                  progress: gr.Progress) -> Tuple[List[str], str, Any]:
         """
         Delega ao Roteirista (Gemini) a tarefa de criar o roteiro (storyboard).
-
-        Args:
-            prompt (str): A ideia geral do filme fornecida pelo usuário.
-            num_keyframes (int): O número de cenas a serem criadas.
-            ref_image_paths (List[str]): Caminhos para as imagens de referência.
-            progress (gr.Progress): Objeto do Gradio para reportar progresso.
-
-        Returns:
-            Tuple[List[str], str, Any]: O storyboard, o caminho da primeira imagem de referência,
-                                        e um update para a UI do Gradio.
         """
         logger.info(f"Ato 1, Cena 1: Roteiro. Instruindo o Roteirista (Gemini) a criar {num_keyframes} cenas a partir de: '{prompt}'")
         progress(0.2, desc="Consultando Roteirista IA (Gemini)...")
@@ -147,8 +137,6 @@ class AducOrchestrator:
         self.director.update_state("storyboard", storyboard)
         self.director.update_state("processed_ref_paths", ref_image_paths)
         
-        # Retorna o storyboard, a primeira imagem como referência inicial, e um comando
-        # para tornar o próximo acordeão da UI visível.
         return storyboard, ref_image_paths[0], gr.update(visible=True, open=True)
 
     def task_select_keyframes(self, storyboard: List[str], base_ref_paths: List[str], 
@@ -156,14 +144,6 @@ class AducOrchestrator:
         """
         Delega ao Editor/Fotógrafo (Gemini) a tarefa de selecionar as melhores imagens
         de um "banco de cenas" para corresponder ao roteiro (Modo Fotógrafo).
-
-        Args:
-            storyboard (List[str]): O roteiro gerado.
-            base_ref_paths (List[str]): Imagens de referência principais.
-            pool_ref_paths (List[str]): O conjunto de imagens para seleção.
-
-        Returns:
-            List[str]: Uma lista ordenada de caminhos de imagem selecionados como keyframes.
         """
         logger.info(f"Ato 1, Cena 2 (Modo Fotógrafo): Instruindo o Editor (Gemini) a selecionar {len(storyboard)} keyframes.")
         
@@ -178,16 +158,6 @@ class AducOrchestrator:
         """
         Delega ao Diretor de Arte (ImageSpecialist) a tarefa de gerar os keyframes
         visuais a partir do roteiro (Modo Diretor de Arte).
-
-        Args:
-            storyboard (List[str]): O roteiro gerado.
-            initial_ref_path (str): A imagem inicial que serve como base para o primeiro keyframe.
-            global_prompt (str): O prompt geral do filme.
-            keyframe_resolution (int): A resolução (em pixels) para os keyframes gerados.
-            progress_callback_factory (callable, optional): Uma função para criar callbacks de progresso.
-
-        Returns:
-            List[str]: Uma lista de caminhos para os keyframes gerados e salvos.
         """
         logger.info("Ato 1, Cena 2 (Modo Diretor de Arte): Delegando ao Especialista de Imagem.")
         
@@ -208,24 +178,16 @@ class AducOrchestrator:
     
     def task_produce_final_movie_with_feedback(self, keyframes: List[str], global_prompt: str, seconds_per_fragment: float, 
                                                trim_percent: int, handler_strength: float, 
-                                               destination_convergence_strength: float, video_resolution: int, 
-                                               use_continuity_director: bool, progress: gr.Progress) -> Generator[Dict[str, Any], None, None]:
+                                               destination_convergence_strength: float, 
+                                               use_upscaler: bool, use_refiner: bool, use_hd: bool, use_audio: bool,
+                                               video_resolution: int, use_continuity_director: bool, 
+                                               progress: gr.Progress) -> Generator[Dict[str, Any], None, None]:
         """
-        Delega ao Editor/Cineasta (Deformes4DEngine) a produção final do filme,
-        gerando e retornando feedback sobre cada fragmento criado.
-
-        Args:
-            (Vários): Parâmetros de controle para a geração de vídeo.
-            progress (gr.Progress): Objeto do Gradio para reportar progresso.
-
-        Yields:
-            Generator[Dict[str, Any], None, None]: Dicionários contendo o caminho para
-                                                   cada fragmento gerado ou o caminho final do filme.
+        Delega ao Editor/Cineasta (Deformes4DEngine) a produção final do filme.
         """
         logger.info("Maestro: Delegando a produção do filme completo ao Deformes4DEngine.")
         storyboard = self.director.get_state("storyboard", [])
 
-        # O gerador do Deformes4DEngine retorna atualizações de progresso.
         for update in self.editor.generate_full_movie(
             keyframes=keyframes, 
             global_prompt=global_prompt, 
@@ -234,13 +196,15 @@ class AducOrchestrator:
             trim_percent=trim_percent,
             handler_strength=handler_strength, 
             destination_convergence_strength=destination_convergence_strength,
+            use_upscaler=use_upscaler,
+            use_refiner=use_refiner,
+            use_hd=use_hd,
+            use_audio=use_audio,
             video_resolution=video_resolution, 
             use_continuity_director=use_continuity_director, 
             progress=progress
         ):
-            if "fragment_path" in update and update["fragment_path"]:
-                yield {"fragment_path": update["fragment_path"]}
-            elif "final_path" in update and update["final_path"]:
+            if "final_path" in update and update["final_path"]:
                 final_movie_path = update["final_path"]
                 self.director.update_state("final_video_path", final_movie_path)
                 yield {"final_path": final_movie_path}