File size: 4,810 Bytes
37d8158 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 |
# aduc_framework/director.py
#
# Copyright (C) August 4, 2025 Carlos Rodrigues dos Santos
#
# Versão 3.0.0 (Framework State Manager)
#
# Este arquivo contém a classe AducDirector. Sua única responsabilidade
# é gerenciar o objeto de estado da geração (GenerationState). Ele atua
# como o "score" da orquestra ou o "script" do filme, mantendo um registro
# preciso de todos os parâmetros e artefatos gerados.
import logging
import os
from typing import List, Dict, Any
# Importa os modelos de dados Pydantic que ele irá gerenciar
from .types import GenerationState, PreProductionParams, ProductionParams, Ato, MediaRef, KeyframeData, VideoData
logger = logging.getLogger(__name__)
class AducDirector:
"""
Representa o Diretor de Cena, responsável por gerenciar o estado da produção.
Atua como a fonte única da verdade para todos os dados relacionados a uma
única tarefa de geração de vídeo.
"""
def __init__(self, workspace_dir: str):
"""
Inicializa o Diretor.
Args:
workspace_dir (str): O diretório onde os artefatos são salvos.
O Diretor usa isso para referenciar caminhos se necessário.
"""
self.workspace_dir = workspace_dir
self.state: GenerationState = self._initialize_state()
os.makedirs(self.workspace_dir, exist_ok=True)
logger.info(f"AducDirector inicializado. O estado de geração foi criado.")
def _initialize_state(self) -> GenerationState:
"""
Cria uma instância vazia e válida do modelo GenerationState.
"""
return GenerationState()
def get_full_state(self) -> GenerationState:
"""
Retorna o objeto de estado Pydantic completo.
Returns:
GenerationState: O estado atual da geração.
"""
return self.state
def get_full_state_as_dict(self) -> Dict[str, Any]:
"""
Retorna o estado completo serializado como um dicionário Python.
Útil para passar para bibliotecas que não suportam Pydantic diretamente.
Returns:
Dict[str, Any]: O estado atual como um dicionário.
"""
return self.state.model_dump()
def update_parameters(self, stage: str, params: Any):
"""
Atualiza o nó de parâmetros no estado de geração.
Args:
stage (str): O estágio da produção ('pre_producao', 'producao', etc.).
params (BaseModel): O objeto Pydantic contendo os parâmetros para aquele estágio.
"""
if hasattr(self.state.parametros_geracao, stage):
setattr(self.state.parametros_geracao, stage, params)
logger.info(f"Parâmetros do estágio '{stage}' atualizados no estado.")
else:
logger.warning(f"Tentativa de atualizar parâmetros para um estágio desconhecido: '{stage}'")
def update_pre_production_state(self, prompt: str, ref_paths: List[str], storyboard: List[str]):
"""
Popula as seções iniciais do estado após a geração do storyboard.
Args:
prompt (str): O prompt geral.
ref_paths (List[str]): Lista de caminhos para as mídias de referência.
storyboard (List[str]): Lista de resumos dos atos.
"""
self.state.Promt_geral = prompt
self.state.midias_referencia = [MediaRef(id=i, caminho=path) for i, path in enumerate(ref_paths)]
self.state.Atos = [Ato(id=i, resumo_ato=ato) for i, ato in enumerate(storyboard)]
logger.info("Estado de pré-produção (prompt, referências, atos) atualizado.")
def update_keyframes_state(self, keyframes_data: List[Dict[str, Any]]):
"""
Atualiza a lista de keyframes no estado.
Args:
keyframes_data (List[Dict[str, Any]]): Uma lista de dicionários, cada um
representando os dados de um keyframe.
"""
# Converte os dicionários em modelos Pydantic KeyframeData
self.state.Keyframe_atos = [KeyframeData(**data) for data in keyframes_data]
logger.info(f"{len(keyframes_data)} keyframes adicionados ao estado.")
def update_video_state(self, video_data_dict: Dict[str, Any]):
"""
Atualiza a lista de vídeos gerados no estado.
Args:
video_data_dict (Dict[str, Any]): Um dicionário representando os dados do vídeo gerado.
"""
# Converte o dicionário em um modelo Pydantic VideoData
video_model = VideoData(**video_data_dict)
# Atualmente, substituímos a lista, mas poderíamos adicionar a ela no futuro.
self.state.videos_atos = [video_model]
logger.info("Dados da produção de vídeo atualizados no estado.") |