feat: Implement self-contained specialist managers

aduc_framework/managers/flux_kontext_manager.py

@@ -25,7 +25,7 @@ import threading
 import yaml
 import logging
 
-from tools.hardware_manager import hardware_manager
+from ..tools.hardware_manager import hardware_manager
 
 logger = logging.getLogger(__name__)
 

aduc_framework/managers/latent_enhancer_manager.py

@@ -19,7 +19,7 @@ import torch
 import logging
 import time
 from diffusers import LTXLatentUpsamplePipeline
-from managers.ltx_manager import ltx_manager_singleton
+from ..managers.ltx_manager import ltx_manager_singleton
 
 logger = logging.getLogger(__name__)
 

aduc_framework/managers/ltx_manager.py

@@ -1,20 +1,13 @@
-# managers/ltx_manager.py
-# AducSdr: Uma implementação aberta e funcional da arquitetura ADUC-SDR
-# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
+# aduc_framework/managers/ltx_manager.py
 #
-# Contato:
-# Carlos Rodrigues dos Santos
-# carlex22@gmail.com
-# Rua Eduardo Carlos Pereira, 4125, B1 Ap32, Curitiba, PR, Brazil, CEP 8102025
+# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
 #
-# PENDING PATENT NOTICE: Please see NOTICE.md.
+# Versão 2.3.1 (Framework-Compliant)
 #
-# Version: 2.3.0
-#
-# This version adds a public property `prompt_enhancement_pipeline` to the manager.
-# This allows other specialists, specifically the Deformes3DThinker, to access
-# the internal prompt refinement models (captioning and LLM) used by the LTX pipeline,
-# ensuring stylistic and logical consistency.
+# Este manager é responsável por controlar a pipeline LTX-Video. Ele gerencia
+# um pool de workers para otimizar o uso de múltiplas GPUs, lida com a inicialização
+# e o setup de dependências complexas, e expõe uma interface de alto nível para a
+# geração de fragmentos de vídeo no espaço latente.
 
 import torch
 import gc
@@ -29,18 +22,21 @@ import subprocess
 from pathlib import Path
 from typing import Optional, List, Tuple, Union
 
-from tools.optimization import optimize_ltx_worker, can_optimize_fp8
-from tools.hardware_manager import hardware_manager
-from aduc_types import LatentConditioningItem
+# --- CORREÇÃO DE IMPORTAÇÃO ---
+# O manager agora importa os tipos de seu próprio pacote "pai" e
+# as ferramentas de um pacote "irmão".
+from ..types import LatentConditioningItem
+from ..tools.optimization import optimize_ltx_worker, can_optimize_fp8
+from ..tools.hardware_manager import hardware_manager
 
 logger = logging.getLogger(__name__)
 
-# --- Dependency Management ---
+# --- Gerenciamento de Dependências ---
 DEPS_DIR = Path("./deps")
 LTX_VIDEO_REPO_DIR = DEPS_DIR / "LTX-Video"
 LTX_VIDEO_REPO_URL = "https://github.com/Lightricks/LTX-Video.git"
 
-# --- Placeholders for lazy-loaded modules ---
+# --- Placeholders para módulos importados tardiamente (lazy-loaded) ---
 create_ltx_video_pipeline = None
 calculate_padding = None
 LTXVideoPipeline = None
@@ -54,8 +50,8 @@ class LtxPoolManager:
     """
     Manages a pool of LtxWorkers and exposes the enhancement pipeline for other specialists.
     """
-    def __init__(self, device_ids, ltx_config_file_name):
-        logger.info(f"LTX POOL MANAGER: Creating workers for devices: {device_ids}")
+    def __init__(self, device_ids: List[str], ltx_config_file_name: str):
+        logger.info(f"LTX POOL MANAGER: Criando workers para os dispositivos: {device_ids}")
         self._ltx_modules_loaded = False
         self._setup_dependencies()
         self._lazy_load_ltx_modules()
@@ -66,47 +62,43 @@ class LtxPoolManager:
         self.current_worker_index = 0
         self.lock = threading.Lock()
 
-        # <--- NOVA PROPRIEDADE PARA O DEFORMES3DTHINKER USAR --->
-        # Expõe a pipeline do primeiro worker. Assumimos que todas são configuradas
-        # da mesma forma e contêm os mesmos modelos de enhancement.
+        # Expõe a pipeline do primeiro worker para que outros especialistas (como o Deformes3DThinker)
+        # possam acessar os modelos de aprimoramento de prompt.
         self.prompt_enhancement_pipeline = self.workers[0].pipeline if self.workers else None
         if self.prompt_enhancement_pipeline:
-            logger.info("LTX POOL MANAGER: Prompt enhancement pipeline exposed for other specialists.")
-        # <--- FIM DA NOVA PROPRIEDADE --->
+            logger.info("LTX POOL MANAGER: Pipeline de aprimoramento de prompt exposta para outros especialistas.")
 
         self._apply_ltx_pipeline_patches()
 
         if all(w.device.type == 'cuda' for w in self.workers):
-            logger.info("LTX POOL MANAGER: HOT START MODE ENABLED. Pre-warming all GPUs...")
+            logger.info("LTX POOL MANAGER: MODO HOT START ATIVADO. Pré-aquecendo todas as GPUs...")
             for worker in self.workers:
                 worker.to_gpu()
-            logger.info("LTX POOL MANAGER: All GPUs are hot and ready.")
+            logger.info("LTX POOL MANAGER: Todas as GPUs estão prontas.")
         else:
-            logger.info("LTX POOL MANAGER: Operating in CPU or mixed mode. GPU pre-warming skipped.")
-
-    # ... (O resto da classe LtxPoolManager, como _setup_dependencies, generate_latent_fragment, etc., permanece exatamente o mesmo) ...
+            logger.info("LTX POOL MANAGER: Operando em modo CPU ou misto. Pré-aquecimento de GPU pulado.")
 
     def _setup_dependencies(self):
         """Clones the LTX-Video repo if not found and adds it to the system path."""
         if not LTX_VIDEO_REPO_DIR.exists():
-            logger.info(f"LTX-Video repository not found at '{LTX_VIDEO_REPO_DIR}'. Cloning from GitHub...")
+            logger.info(f"Repositório LTX-Video não encontrado em '{LTX_VIDEO_REPO_DIR}'. Clonando do GitHub...")
             try:
                 DEPS_DIR.mkdir(exist_ok=True)
                 subprocess.run(
-                    ["git", "clone", LTX_VIDEO_REPO_URL, str(LTX_VIDEO_REPO_DIR)],
+                    ["git", "clone", "--depth", "1", LTX_VIDEO_REPO_URL, str(LTX_VIDEO_REPO_DIR)],
                     check=True, capture_output=True, text=True
                 )
-                logger.info("LTX-Video repository cloned successfully.")
+                logger.info("Repositório LTX-Video clonado com sucesso.")
             except subprocess.CalledProcessError as e:
-                logger.error(f"Failed to clone LTX-Video repository. Git stderr: {e.stderr}")
-                raise RuntimeError("Could not clone the required LTX-Video dependency from GitHub.")
+                logger.error(f"Falha ao clonar o repositório LTX-Video. Git stderr: {e.stderr}")
+                raise RuntimeError("Não foi possível clonar a dependência LTX-Video do GitHub.")
         else:
-            logger.info("Found local LTX-Video repository.")
+            logger.info("Repositório LTX-Video local encontrado.")
 
         if str(LTX_VIDEO_REPO_DIR.resolve()) not in sys.path:
             sys.path.insert(0, str(LTX_VIDEO_REPO_DIR.resolve()))
-            logger.info(f"Added '{LTX_VIDEO_REPO_DIR.resolve()}' to sys.path.")
-    
+            logger.info(f"Adicionado '{LTX_VIDEO_REPO_DIR.resolve()}' ao sys.path.")
+
     def _lazy_load_ltx_modules(self):
         """Dynamically imports LTX-Video modules after ensuring the repo exists."""
         if self._ltx_modules_loaded:
@@ -115,22 +107,22 @@ class LtxPoolManager:
         global create_ltx_video_pipeline, calculate_padding, LTXVideoPipeline, ConditioningItem, LTXMultiScalePipeline
         global vae_encode, latent_to_pixel_coords, randn_tensor
         
-        from managers.ltx_pipeline_utils import create_ltx_video_pipeline, calculate_padding
+        from .ltx_pipeline_utils import create_ltx_video_pipeline, calculate_padding
         from ltx_video.pipelines.pipeline_ltx_video import LTXVideoPipeline, ConditioningItem, LTXMultiScalePipeline
         from ltx_video.models.autoencoders.vae_encode import vae_encode, latent_to_pixel_coords
         from diffusers.utils.torch_utils import randn_tensor
         
         self._ltx_modules_loaded = True
-        logger.info("LTX-Video modules have been dynamically loaded.")
+        logger.info("Módulos do LTX-Video foram carregados dinamicamente.")
 
     def _apply_ltx_pipeline_patches(self):
         """Applies runtime patches to the LTX pipeline for ADUC-SDR compatibility."""
-        logger.info("LTX POOL MANAGER: Applying ADUC-SDR patches to LTX pipeline...")
+        logger.info("LTX POOL MANAGER: Aplicando patches ADUC-SDR na pipeline LTX...")
         for worker in self.workers:
             worker.pipeline.prepare_conditioning = _aduc_prepare_conditioning_patch.__get__(worker.pipeline, LTXVideoPipeline)
-        logger.info("LTX POOL MANAGER: All pipeline instances have been patched successfully.")
+        logger.info("LTX POOL MANAGER: Todas as instâncias da pipeline foram corrigidas com sucesso.")
 
-    def _get_next_worker(self):
+    def _get_next_worker(self) -> 'LtxWorker':
         with self.lock:
             worker = self.workers[self.current_worker_index]
             self.current_worker_index = (self.current_worker_index + 1) % len(self.workers)
@@ -152,62 +144,66 @@ class LtxPoolManager:
         if 'strength' in kwargs:
             pipeline_params["strength"] = kwargs['strength']
         if 'conditioning_items_data' in kwargs:
-            final_conditioning_items = []
-            for item in kwargs['conditioning_items_data']:
-                item.latent_tensor = item.latent_tensor.to(worker.device)
-                final_conditioning_items.append(item)
-            pipeline_params["conditioning_items"] = final_conditioning_items
+            pipeline_params["conditioning_items"] = [
+                item._replace(latent_tensor=item.latent_tensor.to(worker.device)) 
+                for item in kwargs['conditioning_items_data']
+            ]
         if worker.is_distilled:
-            logger.info(f"Worker {worker.device} is using a distilled model. Using fixed timesteps.")
             fixed_timesteps = worker.config.get("first_pass", {}).get("timesteps")
-            pipeline_params["timesteps"] = fixed_timesteps
             if fixed_timesteps:
+                pipeline_params["timesteps"] = fixed_timesteps
                 pipeline_params["num_inference_steps"] = len(fixed_timesteps)
+        
+        callback = kwargs.get('callback')
+        if callback:
+            pipeline_params["callback_on_step_end"] = callback
+            pipeline_params["callback_on_step_end_tensor_inputs"] = ["latents"]
+        
         return pipeline_params
 
-    def generate_latent_fragment(self, **kwargs) -> (torch.Tensor, tuple):
+    def generate_latent_fragment(self, **kwargs) -> Tuple[torch.Tensor, tuple]:
         worker_to_use = self._get_next_worker()
         try:
             height, width = kwargs['height'], kwargs['width']
             padded_h, padded_w = ((height - 1) // 32 + 1) * 32, ((width - 1) // 32 + 1) * 32
             padding_vals = calculate_padding(height, width, padded_h, padded_w)
             kwargs['height'], kwargs['width'] = padded_h, padded_w
+            
             pipeline_params = self._prepare_pipeline_params(worker_to_use, **kwargs)
-            logger.info(f"Initiating GENERATION on {worker_to_use.device} with shape {padded_w}x{padded_h}")
+            
+            logger.info(f"Iniciando GERAÇÃO em {worker_to_use.device} com shape {padded_w}x{padded_h}")
+            
             if isinstance(worker_to_use.pipeline, LTXMultiScalePipeline):
                 result = worker_to_use.pipeline.video_pipeline(**pipeline_params).images
             else:
                 result = worker_to_use.generate_video_fragment_internal(**pipeline_params)
             return result, padding_vals
         except Exception as e:
-            logger.error(f"LTX POOL MANAGER: Error during generation on {worker_to_use.device}: {e}", exc_info=True)
+            logger.error(f"LTX POOL MANAGER: Erro durante a geração em {worker_to_use.device}: {e}", exc_info=True)
             raise e
         finally:
             if worker_to_use and worker_to_use.device.type == 'cuda':
                 with torch.cuda.device(worker_to_use.device):
-                    gc.collect(); torch.cuda.empty_cache()
+                    gc.collect()
+                    torch.cuda.empty_cache()
 
-    def refine_latents(self, latents_to_refine: torch.Tensor, **kwargs) -> (torch.Tensor, tuple):
-        pass
+    def refine_latents(self, latents_to_refine: torch.Tensor, **kwargs) -> Tuple[torch.Tensor, tuple]:
+        pass # Placeholder
 
-# ... (O resto do arquivo: LtxWorker, _aduc_prepare_conditioning_patch, Singleton Instantiation, etc. permanece idêntico) ...
 class LtxWorker:
-    """
-    Represents a single instance of the LTX-Video pipeline on a specific device.
-    """
+    """Represents a single instance of the LTX-Video pipeline on a specific device."""
     def __init__(self, device_id, ltx_config_file):
         self.cpu_device = torch.device('cpu')
         self.device = torch.device(device_id if torch.cuda.is_available() else 'cpu')
-        logger.info(f"LTX Worker ({self.device}): Initializing with config '{ltx_config_file}'...")
+        logger.info(f"LTX Worker ({self.device}): Inicializando com config '{ltx_config_file}'...")
         
         with open(ltx_config_file, "r") as file:
             self.config = yaml.safe_load(file)
         
         self.is_distilled = "distilled" in self.config.get("checkpoint_path", "")
-
         models_dir = LTX_VIDEO_REPO_DIR / "models_downloaded"
         
-        logger.info(f"LTX Worker ({self.device}): Preparing to load model...")
+        logger.info(f"LTX Worker ({self.device}): Preparando para carregar modelo...")
         model_filename = self.config["checkpoint_path"]
         model_path = huggingface_hub.hf_hub_download(
             repo_id="Lightricks/LTX-Video", filename=model_filename,
@@ -219,24 +215,22 @@ class LtxWorker:
             precision=self.config["precision"],
             text_encoder_model_name_or_path=self.config["text_encoder_model_name_or_path"],
             sampler=self.config["sampler"], 
-            device='cpu'
+            device='cpu' # Sempre carrega na CPU primeiro
         )
-        logger.info(f"LTX Worker ({self.device}): Model ready on CPU. Is distilled model? {self.is_distilled}")
+        logger.info(f"LTX Worker ({self.device}): Modelo pronto na CPU. É um modelo distilled? {self.is_distilled}")
     
     def to_gpu(self):
         if self.device.type == 'cpu': return
-        logger.info(f"LTX Worker: Moving pipeline to GPU {self.device}...")
+        logger.info(f"LTX Worker: Movendo pipeline para a GPU {self.device}...")
         self.pipeline.to(self.device)
         if self.device.type == 'cuda' and can_optimize_fp8():
-            logger.info(f"LTX Worker ({self.device}): FP8 supported GPU detected. Optimizing...")
+            logger.info(f"LTX Worker ({self.device}): GPU com suporte a FP8 detectada. Otimizando...")
             optimize_ltx_worker(self)
-            logger.info(f"LTX Worker ({self.device}): Optimization complete.")
-        elif self.device.type == 'cuda':
-            logger.info(f"LTX Worker ({self.device}): FP8 optimization not supported or disabled.")
-
+            logger.info(f"LTX Worker ({self.device}): Otimização completa.")
+    
     def to_cpu(self):
         if self.device.type == 'cpu': return
-        logger.info(f"LTX Worker: Unloading pipeline from GPU {self.device}...")
+        logger.info(f"LTX Worker: Descarregando pipeline da GPU {self.device}...")
         self.pipeline.to('cpu')
         gc.collect()
         if torch.cuda.is_available(): torch.cuda.empty_cache()
@@ -244,10 +238,9 @@ class LtxWorker:
     def generate_video_fragment_internal(self, **kwargs):
         return self.pipeline(**kwargs).images
 
-
 def _aduc_prepare_conditioning_patch(
-    self: LTXVideoPipeline,
-    conditioning_items: Optional[List[Union[ConditioningItem, "LatentConditioningItem"]]],
+    self: "LTXVideoPipeline",
+    conditioning_items: Optional[List[Union["ConditioningItem", "LatentConditioningItem"]]],
     init_latents: torch.Tensor,
     num_frames: int,
     height: int,
@@ -259,62 +252,52 @@ def _aduc_prepare_conditioning_patch(
         init_latents, init_latent_coords = self.patchifier.patchify(latents=init_latents)
         init_pixel_coords = latent_to_pixel_coords(init_latent_coords, self.vae, causal_fix=self.transformer.config.causal_temporal_positioning)
         return init_latents, init_pixel_coords, None, 0
-    init_conditioning_mask = torch.zeros(init_latents[:, 0, :, :, :].shape, dtype=torch.float32, device=init_latents.device)
+    
+    init_conditioning_mask = torch.zeros_like(init_latents[:, 0, ...], dtype=torch.float32, device=init_latents.device)
     extra_conditioning_latents, extra_conditioning_pixel_coords, extra_conditioning_mask = [], [], []
     extra_conditioning_num_latents = 0
-    is_latent_mode = hasattr(conditioning_items[0], 'latent_tensor')
-    if is_latent_mode:
-        for item in conditioning_items:
-            media_item_latents = item.latent_tensor.to(dtype=init_latents.dtype, device=init_latents.device)
-            media_frame_number, strength = item.media_frame_number, item.conditioning_strength
-            if media_frame_number == 0:
-                f_l, h_l, w_l = media_item_latents.shape[-3:]
-                init_latents[:, :, :f_l, :h_l, :w_l] = torch.lerp(init_latents[:, :, :f_l, :h_l, :w_l], media_item_latents, strength)
-                init_conditioning_mask[:, :f_l, :h_l, :w_l] = strength
-            else:
-                noise = randn_tensor(media_item_latents.shape, generator=generator, device=media_item_latents.device, dtype=media_item_latents.dtype)
-                media_item_latents = torch.lerp(noise, media_item_latents, strength)
-                patched_latents, latent_coords = self.patchifier.patchify(latents=media_item_latents)
-                pixel_coords = latent_to_pixel_coords(latent_coords, self.vae, causal_fix=self.transformer.config.causal_temporal_positioning)
-                pixel_coords[:, 0] += media_frame_number
-                extra_conditioning_num_latents += patched_latents.shape[1]
-                new_mask = torch.full(patched_latents.shape[:2], strength, dtype=torch.float32, device=init_latents.device)
-                extra_conditioning_latents.append(patched_latents)
-                extra_conditioning_pixel_coords.append(pixel_coords)
-                extra_conditioning_mask.append(new_mask)
-    else:
-        for item in conditioning_items:
-            if not isinstance(item, ConditioningItem): continue
-            item = self._resize_conditioning_item(item, height, width)
-            media_item_latents = vae_encode(item.media_item.to(dtype=self.vae.dtype, device=self.vae.device), self.vae, vae_per_channel_normalize=vae_per_channel_normalize).to(dtype=init_latents.dtype)
-            if item.media_frame_number == 0:
-                media_item_latents, l_x, l_y = self._get_latent_spatial_position(media_item_latents, item, height, width, strip_latent_border=True)
-                f_l, h_l, w_l = media_item_latents.shape[-3:]
-                init_latents[:, :, :f_l, l_y:l_y+h_l, l_x:l_x+w_l] = torch.lerp(init_latents[:, :, :f_l, l_y:l_y+h_l, l_x:l_x+w_l], media_item_latents, item.conditioning_strength)
-                init_conditioning_mask[:, :f_l, l_y:l_y+h_l, l_x:l_x+w_l] = item.conditioning_strength
-            else:
-                logger.warning("Pixel-based conditioning for non-zero frames is not fully implemented in this patch.")
     
+    for item in conditioning_items:
+        if not isinstance(item, LatentConditioningItem):
+            logger.warning("Patch ADUC: Item de condicionamento não é um LatentConditioningItem e será ignorado.")
+            continue
+        
+        media_item_latents = item.latent_tensor.to(dtype=init_latents.dtype, device=init_latents.device)
+        media_frame_number, strength = item.media_frame_number, item.conditioning_strength
+        
+        if media_frame_number == 0:
+            f_l, h_l, w_l = media_item_latents.shape[-3:]
+            init_latents[..., :f_l, :h_l, :w_l] = torch.lerp(init_latents[..., :f_l, :h_l, :w_l], media_item_latents, strength)
+            init_conditioning_mask[..., :f_l, :h_l, :w_l] = strength
+        else:
+            noise = randn_tensor(media_item_latents.shape, generator=generator, device=media_item_latents.device, dtype=media_item_latents.dtype)
+            media_item_latents = torch.lerp(noise, media_item_latents, strength)
+            patched_latents, latent_coords = self.patchifier.patchify(latents=media_item_latents)
+            pixel_coords = latent_to_pixel_coords(latent_coords, self.vae, causal_fix=self.transformer.config.causal_temporal_positioning)
+            pixel_coords[:, 0] += media_frame_number
+            extra_conditioning_num_latents += patched_latents.shape[1]
+            new_mask = torch.full(patched_latents.shape[:2], strength, dtype=torch.float32, device=init_latents.device)
+            extra_conditioning_latents.append(patched_latents)
+            extra_conditioning_pixel_coords.append(pixel_coords)
+            extra_conditioning_mask.append(new_mask)
+
     init_latents, init_latent_coords = self.patchifier.patchify(latents=init_latents)
     init_pixel_coords = latent_to_pixel_coords(init_latent_coords, self.vae, causal_fix=self.transformer.config.causal_temporal_positioning)
     init_conditioning_mask, _ = self.patchifier.patchify(latents=init_conditioning_mask.unsqueeze(1))
     init_conditioning_mask = init_conditioning_mask.squeeze(-1)
+    
     if extra_conditioning_latents:
         init_latents = torch.cat([*extra_conditioning_latents, init_latents], dim=1)
         init_pixel_coords = torch.cat([*extra_conditioning_pixel_coords, init_pixel_coords], dim=2)
         init_conditioning_mask = torch.cat([*extra_conditioning_mask, init_conditioning_mask], dim=1)
-        if self.transformer.use_tpu_flash_attention:
-            init_latents = init_latents[:, :-extra_conditioning_num_latents]
-            init_pixel_coords = init_pixel_coords[:, :, :-extra_conditioning_num_latents]
-            init_conditioning_mask = init_conditioning_mask[:, :-extra_conditioning_num_latents]
+    
     return init_latents, init_pixel_coords, init_conditioning_mask, extra_conditioning_num_latents
 
-
-# --- Singleton Instantiation ---
+# --- Instanciação Singleton ---
 with open("config.yaml", 'r') as f:
     config = yaml.safe_load(f)
 ltx_gpus_required = config['specialists']['ltx']['gpus_required']
 ltx_device_ids = hardware_manager.allocate_gpus('LTX', ltx_gpus_required)
 ltx_config_filename = config['specialists']['ltx']['config_file']
 ltx_manager_singleton = LtxPoolManager(device_ids=ltx_device_ids, ltx_config_file_name=ltx_config_filename)
-logger.info("Video Specialist (LTX) ready.")
+logger.info("Especialista de Vídeo (LTX) pronto.")

aduc_framework/managers/ltx_pipeline_utils.py

@@ -23,20 +23,20 @@ from transformers import (
 )
 from huggingface_hub import hf_hub_download
 
-from ltx_video.models.autoencoders.causal_video_autoencoder import (
+from ..ltx_video.models.autoencoders.causal_video_autoencoder import (
     CausalVideoAutoencoder,
 )
-from ltx_video.models.transformers.symmetric_patchifier import SymmetricPatchifier
-from ltx_video.models.transformers.transformer3d import Transformer3DModel
-from ltx_video.pipelines.pipeline_ltx_video import (
+from ..ltx_video.models.transformers.symmetric_patchifier import SymmetricPatchifier
+from ..ltx_video.models.transformers.transformer3d import Transformer3DModel
+from ..ltx_video.pipelines.pipeline_ltx_video import (
     ConditioningItem,
     LTXVideoPipeline,
     LTXMultiScalePipeline,
 )
-from ltx_video.schedulers.rf import RectifiedFlowScheduler
-from ltx_video.utils.skip_layer_strategy import SkipLayerStrategy
-from ltx_video.models.autoencoders.latent_upsampler import LatentUpsampler
-import ltx_video.pipelines.crf_compressor as crf_compressor
+from ..ltx_video.schedulers.rf import RectifiedFlowScheduler
+from ..ltx_video.utils.skip_layer_strategy import SkipLayerStrategy
+from ..ltx_video.models.autoencoders.latent_upsampler import LatentUpsampler
+import ..ltx_video.pipelines.crf_compressor as crf_compressor
 
 MAX_HEIGHT = 720
 MAX_WIDTH = 1280

aduc_framework/managers/upscaler_specialist.py

@@ -5,7 +5,7 @@
 import torch
 import logging
 from diffusers import LTXLatentUpsamplePipeline
-from managers.ltx_manager import ltx_manager_singleton
+from ..managers.ltx_manager import ltx_manager_singleton
 
 logger = logging.getLogger(__name__)
 

aduc_framework/managers/vae_manager.py

@@ -28,8 +28,8 @@ import gc
 from typing import Generator
 
 # Import the source of the VAE model and the low-level functions
-from managers.ltx_manager import ltx_manager_singleton
-from ltx_video.models.autoencoders.vae_encode import vae_encode, vae_decode
+from ..managers.ltx_manager import ltx_manager_singleton
+from ..ltx_video.models.autoencoders.vae_encode import vae_encode, vae_decode
 
 logger = logging.getLogger(__name__)
 

aduc_framework/types.py

@@ -2,20 +2,19 @@
 #
 # Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
 #
-# Versão 3.0.0 (Framework Data Models)
+# Versão 3.1.0 (Framework Data Models with Core Types)
 #
 # Este arquivo define as estruturas de dados centrais para o Aduc Framework
-# usando Pydantic. Estes modelos servem como o "contrato" de dados entre as
-# diferentes camadas da aplicação (UI, API, Orchestrator, Engineers).
-#
-# O uso de Pydantic garante validação automática de tipos, serialização/desserialização
-# fácil para JSON e uma fonte única da verdade para a estrutura de dados.
+# usando Pydantic. Ele também inclui tipos de dados de baixo nível, como dataclasses,
+# que são usados internamente pelos managers e engineers.
 
 from pydantic import BaseModel, Field
 from typing import List, Dict, Any, Optional
+from dataclasses import dataclass
+import torch
 
-# --- Modelos de Parâmetros de Entrada ---
-# Estes modelos representam os dados que o usuário fornece através de uma interface.
+# --- Modelos de Parâmetros de Entrada (Pydantic) ---
+# Representam os dados que o usuário fornece através de uma interface.
 
 class PreProductionParams(BaseModel):
     """Parâmetros para a etapa de Roteiro e Keyframes."""
@@ -41,8 +40,8 @@ class GenerationParameters(BaseModel):
     pos_producao: Optional[Dict[str, Any]] = None
 
 
-# --- Modelos de Artefatos Gerados ---
-# Estes modelos representam os dados e metadados dos resultados criados pelo framework.
+# --- Modelos de Artefatos Gerados (Pydantic) ---
+# Representam os dados e metadados dos resultados criados pelo framework.
 
 class MediaRef(BaseModel):
     """Representa uma mídia de referência fornecida pelo usuário."""
@@ -60,13 +59,11 @@ class KeyframeData(BaseModel):
     caminho_pixel: str
     caminho_latent: str
     prompt_keyframe: str
-    # Futuramente: midias_contexto: List[Dict[str, Any]]
 
 class VideoFragmentData(BaseModel):
     """Metadados sobre a geração de um único fragmento de vídeo entre dois keyframes."""
     id: int
     prompt_video: str
-    # Futuramente: midias_inicio, midias_caminho, midias_fim
 
 class VideoData(BaseModel):
     """Estrutura de dados completa para o vídeo final (ou um grande clipe)."""
@@ -76,7 +73,7 @@ class VideoData(BaseModel):
     fragmentos_componentes: List[VideoFragmentData]
 
 
-# --- O Modelo de Estado Principal ---
+# --- O Modelo de Estado Principal (Pydantic) ---
 
 class GenerationState(BaseModel):
     """
@@ -88,4 +85,16 @@ class GenerationState(BaseModel):
     midias_referencia: List[MediaRef] = Field(default_factory=list)
     Atos: List[Ato] = Field(default_factory=list)
     Keyframe_atos: List[KeyframeData] = Field(default_factory=list)
-    videos_atos: List[VideoData] = Field(default_factory=list)
+    videos_atos: List[VideoData] = Field(default_factory=list)
+
+
+# --- Tipos de Dados Internos (Dataclass) ---
+# Usado para passar dados complexos (como tensores) que não são facilmente
+# serializáveis em JSON, entre os componentes internos do framework.
+
+@dataclass
+class LatentConditioningItem:
+    """Representa uma âncora de condicionamento no espaço latente para o LTX."""
+    latent_tensor: torch.Tensor
+    media_frame_number: int
+    conditioning_strength: float

app.py

@@ -1,39 +1,18 @@
-
 # app.py
 #
 # Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
 #
-# Version: 2.3.0
-#
-# Contact:
-# Carlos Rodrigues dos Santos
-# carlex22@gmail.com
-#
-# Related Repositories and Projects:
-# GitHub: https://github.com/carlex22/Aduc-sdr
-# YouTube (Results): https://m.youtube.com/channel/UC3EgoJi_Fv7yuDpvfYNtoIQ
-#
-# 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.
+# Versão 3.0.0 (UI Head for Aduc Framework)
 #
-# 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/>.
-#
-# PENDING PATENT NOTICE: The ADUC method and system implemented in this
-# software is in the process of being patented. Please see NOTICE.md for details.
-
+# Este arquivo implementa a interface de usuário com Gradio para o Aduc-Sdr.
+# Ele atua como um cliente para o 'aduc_framework', que contém toda a
+# lógica de negócio e orquestração.
 
 import gradio as gr
 import yaml
 import logging
 import os
+import sys
 import shutil
 import time
 import json
@@ -70,7 +49,15 @@ if os.path.exists(LOG_FILE_PATH):
 log_format = '%(asctime)s - %(levelname)s - [%(name)s:%(funcName)s] - %(message)s'
 root_logger = logging.getLogger()
 root_logger.setLevel(logging.INFO)
-# ... (código completo de configuração de logging) ...
+root_logger.handlers.clear()
+stream_handler = logging.StreamHandler(sys.stdout)
+stream_handler.setLevel(logging.INFO)
+stream_handler.setFormatter(logging.Formatter(log_format))
+root_logger.addHandler(stream_handler)
+file_handler = logging.FileHandler(LOG_FILE_PATH, mode='w', encoding='utf-8')
+file_handler.setLevel(logging.INFO)
+file_handler.setFormatter(logging.Formatter(log_format))
+root_logger.addHandler(file_handler)
 logger = logging.getLogger(__name__)
 
 # Carrega a configuração e inicializa o framework
@@ -89,11 +76,16 @@ except Exception as e:
 # --- 2. FUNÇÕES WRAPPER (CAMADA DE TRADUÇÃO UI <-> FRAMEWORK) ---
 
 def run_pre_production_wrapper(prompt, num_keyframes, ref_files, resolution_str, duration_per_fragment, progress=gr.Progress()):
+    """
+    Coleta dados da UI, os empacota em um objeto Pydantic e chama a tarefa de pré-produção do framework.
+    """
     if not ref_files:
         raise gr.Error("Por favor, forneça pelo menos uma imagem de referência.")
     
+    # Etapa de UI: Processar e salvar os arquivos de referência
     ref_paths = [aduc.process_image_for_story(f.name, 480, f"ref_processed_{i}.png") for i, f in enumerate(ref_files)]
     
+    # 1. Empacota os parâmetros da UI no modelo Pydantic que o framework espera
     params = PreProductionParams(
         prompt=prompt,
         num_keyframes=int(num_keyframes),
@@ -102,17 +94,26 @@ def run_pre_production_wrapper(prompt, num_keyframes, ref_files, resolution_str,
         duration_per_fragment=duration_per_fragment
     )
     
-    storyboard, final_keyframes, updated_state = aduc.task_pre_production(params, progress)
+    # 2. Define a função de callback para o progresso
+    progress_callback = progress
+    
+    # 3. Chama o framework
+    storyboard, final_keyframes, updated_state = aduc.task_pre_production(params, progress_callback)
     
+    # 4. Retorna os resultados desempacotados para os componentes corretos da UI
     return updated_state.model_dump(), storyboard, final_keyframes, gr.update(visible=True, open=True)
 
 def run_original_production_wrapper(current_state_dict, trim_percent, handler_strength, dest_strength, guidance_scale, stg_scale, steps, progress=gr.Progress()):
+    """
+    Coleta os parâmetros da etapa de produção e o estado atual, e chama a tarefa de produção do framework.
+    """
     yield {
         original_video_output: gr.update(value=None, visible=True, label="🎬 Produzindo seu filme..."),
         final_video_output: gr.update(value=None, visible=True, label="🎬 Produção em progresso..."),
         step4_accordion: gr.update(visible=False)
     }
 
+    # 1. Empacota os parâmetros dos sliders no modelo Pydantic
     production_params = ProductionParams(
         trim_percent=int(trim_percent),
         handler_strength=handler_strength,
@@ -122,6 +123,7 @@ def run_original_production_wrapper(current_state_dict, trim_percent, handler_st
         inference_steps=int(steps)
     )
     
+    # 2. Chama a tarefa de produção no framework.
     final_video_path, latent_paths, updated_state = aduc.task_produce_original_movie(
         params=production_params, 
         progress_callback=progress
@@ -129,6 +131,7 @@ def run_original_production_wrapper(current_state_dict, trim_percent, handler_st
     
     updated_state_dict = updated_state.model_dump()
 
+    # 3. Desempacota e retorna o resultado final para a UI
     yield {
         original_video_output: gr.update(value=final_video_path, label="✅ Filme Original Master"),
         final_video_output: gr.update(value=final_video_path),
@@ -150,11 +153,15 @@ def get_log_content():
 # --- 3. DEFINIÇÃO DA UI GRADIO ---
 with gr.Blocks(theme=cinematic_theme, css="style.css") as demo:
     
+    # O gr.State é a "memória" da nossa UI. Ele armazena o JSON de estado entre os cliques.
     generation_state_holder = gr.State(value={})
     
+    # Outros states para gerenciar caminhos de arquivos
     original_latents_paths_state = gr.State(value=None)
     original_video_path_state = gr.State(value=None)
     current_source_video_state = gr.State(value=None)
+    upscaled_video_path_state = gr.State(value=None)
+    hd_video_path_state = gr.State(value=None)
 
     gr.Markdown("<h1>ADUC-SDR 🎬 - O Diretor de Cinema IA</h1>")
     gr.Markdown("<p>Crie um filme completo com vídeo e áudio, orquestrado por uma equipe de IAs especialistas.</p>")
@@ -174,7 +181,6 @@ with gr.Blocks(theme=cinematic_theme, css="style.css") as demo:
         keyframe_gallery = gr.Gallery(label="Galeria de Cenas-Chave (Keyframes)", visible=True, object_fit="contain", height="auto", type="filepath")
 
     with gr.Accordion("Etapa 3: Produção do Vídeo Original", open=False, visible=False) as step3_accordion:
-        # Aqui omiti a definição detalhada dos sliders para brevidade, mas eles existem
         trim_percent_slider = gr.Slider(minimum=10, maximum=90, value=50, step=5, label="Poda Causal (%)")
         handler_strength = gr.Slider(label="Força do Déjà-Vu", minimum=0.0, maximum=1.0, value=0.5, step=0.05)
         dest_strength = gr.Slider(label="Força da Âncora Final", minimum=0.0, maximum=1.0, value=0.75, step=0.05)

engineers/LICENSE

@@ -1,23 +0,0 @@
-# AducSdr: Uma implementação aberta e funcional da arquitetura ADUC-SDR para geração de vídeo coerente.
-# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
-#
-# Contato:
-# Carlos Rodrigues dos Santos
-# carlex22@gmail.com
-# Rua Eduardo Carlos Pereira, 4125, B1 Ap32, Curitiba, PR, Brazil, CEP 8102025
-#
-# 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/>.

engineers/NOTICE.md

@@ -1,76 +0,0 @@
-# NOTICE
-
-Copyright (C) 2025 Carlos Rodrigues dos Santos. All rights reserved.
-
----
-
-## Aviso de Propriedade Intelectual e Licenciamento
-
-### **Processo de Patenteamento em Andamento (EM PORTUGUÊS):**
-
-O método e o sistema de orquestração de prompts denominados **ADUC (Automated Discovery and Orchestration of Complex tasks)**, conforme descritos neste documento e implementados neste software, estão atualmente em processo de patenteamento.
-
-O titular dos direitos, Carlos Rodrigues dos Santos, está buscando proteção legal para as inovações chave da arquitetura ADUC, incluindo, mas não se limitando a:
-
-*   Fragmentação e escalonamento de solicitações que excedem limites de contexto de modelos de IA.
-*   Distribuição inteligente de sub-tarefas para especialistas heterogêneos.
-*   Gerenciamento de estado persistido com avaliação iterativa e realimentação para o planejamento de próximas etapas.
-*   Planejamento e roteamento sensível a custo, latência e requisitos de qualidade.
-*   O uso de "tokens universais" para comunicação agnóstica a modelos.
-
-### **Reconhecimento e Implicações (EM PORTUGUÊS):**
-
-Ao acessar ou utilizar este software e a arquitetura ADUC aqui implementada, você reconhece:
-
-1.  A natureza inovadora e a importância da arquitetura ADUC no campo da orquestração de prompts para IA.
-2.  Que a essência desta arquitetura, ou suas implementações derivadas, podem estar sujeitas a direitos de propriedade intelectual, incluindo patentes.
-3.  Que o uso comercial, a reprodução da lógica central da ADUC em sistemas independentes, ou a exploração direta da invenção sem o devido licenciamento podem infringir os direitos de patente pendente.
-
----
-
-### **Patent Pending (IN ENGLISH):**
-
-The method and system for prompt orchestration named **ADUC (Automated Discovery and Orchestration of Complex tasks)**, as described herein and implemented in this software, are currently in the process of being patented.
-
-The rights holder, Carlos Rodrigues dos Santos, is seeking legal protection for the key innovations of the ADUC architecture, including, but not limited to:
-
-*   Fragmentation and scaling of requests exceeding AI model context limits.
-*   Intelligent distribution of sub-tasks to heterogeneous specialists.
-*   Persistent state management with iterative evaluation and feedback for planning subsequent steps.
-*   Cost, latency, and quality-aware planning and routing.
-*   The use of "universal tokens" for model-agnostic communication.
-
-### **Acknowledgement and Implications (IN ENGLISH):**
-
-By accessing or using this software and the ADUC architecture implemented herein, you acknowledge:
-
-1.  The innovative nature and significance of the ADUC architecture in the field of AI prompt orchestration.
-2.  That the essence of this architecture, or its derivative implementations, may be subject to intellectual property rights, including patents.
-3.  That commercial use, reproduction of ADUC's core logic in independent systems, or direct exploitation of the invention without proper licensing may infringe upon pending patent rights.
-
----
-
-## Licença AGPLv3
-
-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/>.
-
----
-
-**Contato para Consultas:**
-
-Para mais informações sobre a arquitetura ADUC, o status do patenteamento, ou para discutir licenciamento para usos comerciais ou não conformes com a AGPLv3, por favor, entre em contato:
-
-Carlos Rodrigues dos Santos
-carlex22@gmail.com
-Rua Eduardo Carlos Pereira, 4125, B1 Ap32, Curitiba, PR, Brazil, CEP 8102025

engineers/README.md

@@ -1,211 +0,0 @@
----
-title: Euia-AducSdr
-emoji: 🎥
-colorFrom: indigo
-colorTo: purple
-sdk: gradio
-app_file: app.py
-pinned: true
-license: agpl-3.0
-short_description: Uma implementação aberta e funcional da arquitetura ADUC-SDR
----
-
-
-### 🇧🇷 Português
-
-Uma implementação aberta e funcional da arquitetura ADUC-SDR (Arquitetura de Unificação Compositiva - Escala Dinâmica e Resiliente), projetada para a geração de vídeo coerente de longa duração. Este projeto materializa os princípios de fragmentação, navegação geométrica e um mecanismo de "eco causal 4bits memoria" para garantir a continuidade física e narrativa em sequências de vídeo geradas por múltiplos modelos de IA.
-
-**Licença:** Este projeto é licenciado sob os termos da **GNU Affero General Public License v3.0**. Isto significa que se você usar este software (ou qualquer trabalho derivado) para fornecer um serviço através de uma rede, você é **obrigado a disponibilizar o código-fonte completo** da sua versão para os usuários desse serviço.
-
-- **Copyright (C) 4 de Agosto de 2025, Carlos Rodrigues dos Santos**
-- Uma cópia completa da licença pode ser encontrada no arquivo [LICENSE](LICENSE).
-
----
-
-### 🇬🇧 English
-
-An open and functional implementation of the ADUC-SDR (Architecture for Compositive Unification - Dynamic and Resilient Scaling) architecture, designed for long-form coherent video generation. This project materializes the principles of fragmentation, geometric navigation, and a "causal echo 4bits memori" mechanism to ensure physical and narrative continuity in video sequences generated by multiple AI models.
-
-**License:** This project is licensed under the terms of the **GNU Affero General Public License v3.0**. This means that if you use this software (or any derivative work) to provide a service over a network, you are **required to make the complete source code** of your version available to the users of that service.
-
-- **Copyright (C) August 4, 2025, Carlos Rodrigues dos Santos**
-- A full copy of the license can be found in the [LICENSE](LICENSE) file.
-
----
-
-## **Aviso de Propriedade Intelectual e Patenteamento**
-
-### **Processo de Patenteamento em Andamento (EM PORTUGUÊS):**
-
-A arquitetura e o método **ADUC (Automated Discovery and Orchestration of Complex tasks)**, conforme descritos neste projeto e nas reivindicações associadas, estão **atualmente em processo de patenteamento**.
-
-O titular dos direitos, Carlos Rodrigues dos Santos, está buscando proteção legal para as inovações chave da arquitetura ADUC, que incluem, mas não se limitam a:
-
-*   Fragmentação e escalonamento de solicitações que excedem limites de contexto de modelos de IA.
-*   Distribuição inteligente de sub-tarefas para especialistas heterogêneos.
-*   Gerenciamento de estado persistido com avaliação iterativa e realimentação para o planejamento de próximas etapas.
-*   Planejamento e roteamento sensível a custo, latência e requisitos de qualidade.
-*   O uso de "tokens universais" para comunicação agnóstica a modelos.
-
-Ao utilizar este software e a arquitetura ADUC aqui implementada, você reconhece a natureza inovadora desta arquitetura e que a **reprodução ou exploração da lógica central da ADUC em sistemas independentes pode infringir direitos de patente pendente.**
-
----
-
-### **Patent Pending (IN ENGLISH):**
-
-The **ADUC (Automated Discovery and Orchestration of Complex tasks)** architecture and method, as described in this project and its associated claims, are **currently in the process of being patented.**
-
-The rights holder, Carlos Rodrigues dos Santos, is seeking legal protection for the key innovations of the ADUC architecture, including, but not limited to:
-
-*   Fragmentation and scaling of requests exceeding AI model context limits.
-*   Intelligent distribution of sub-tasks to heterogeneous specialists.
-*   Persistent state management with iterative evaluation and feedback for planning subsequent steps.
-*   Cost, latency, and quality-aware planning and routing.
-*   The use of "universal tokens" for model-agnostic communication.
-
-By using this software and the ADUC architecture implemented herein, you acknowledge the innovative nature of this architecture and that **the reproduction or exploitation of ADUC's core logic in independent systems may infringe upon pending patent rights.**
-
----
-
-### Detalhes Técnicos e Reivindicações da ADUC
-
-#### 🇧🇷 Definição Curta (para Tese e Patente)
-
-**ADUC** é um *framework pré-input* e *intermediário* de **gerenciamento de prompts** que:
-
-1.  **fragmenta** solicitações acima do limite de contexto de qualquer modelo,
-2.  **escala linearmente** (processo sequencial com memória persistida),
-3.  **distribui** sub-tarefas a **especialistas** (modelos/ferramentas heterogêneos), e
-4.  **realimenta** a próxima etapa com avaliação do que foi feito/esperado (LLM diretor).
-
-Não é um modelo; é uma **camada orquestradora** plugável antes do input de modelos existentes (texto, imagem, áudio, vídeo), usando *tokens universais* e a tecnologia atual.
-
-#### 🇬🇧 Short Definition (for Thesis and Patent)
-
-**ADUC** is a *pre-input* and *intermediate* **prompt management framework** that:
-
-1.  **fragments** requests exceeding any model's context limit,
-2.  **scales linearly** (sequential process with persisted memory),
-3.  **distributes** sub-tasks to **specialists** (heterogeneous models/tools), and
-4.  **feeds back** to the next step with an evaluation of what was done/expected (director LLM).
-
-It is not a model; it is a pluggable **orchestration layer** before the input of existing models (text, image, audio, video), using *universal tokens* and current technology.
-
----
-
-#### 🇧🇷 Elementos Essenciais (Telegráfico)
-
-*   **Agnóstico a modelos:** opera com qualquer LLM/difusor/API.
-*   **Pré-input manager:** recebe pedido do usuário, **divide** em blocos ≤ limite de tokens, **prioriza**, **agenda** e **roteia**.
-*   **Memória persistida:** resultados/latentes/“eco” viram **estado compartilhado** para o próximo bloco (nada é ignorado).
-*   **Especialistas:** *routers* decidem quem faz o quê (ex.: “descrição → LLM-A”, “keyframe → Img-B”, “vídeo → Vid-C”).
-*   **Controle de qualidade:** LLM diretor compara *o que fez* × *o que deveria* × *o que falta* e **regenera objetivos** do próximo fragmento.
-*   **Custo/latência-aware:** planeja pela **VRAM/tempo/custo**, não tenta “abraçar tudo de uma vez”.
-
-#### 🇬🇧 Essential Elements (Telegraphic)
-
-*   **Model-agnostic:** operates with any LLM/diffuser/API.
-*   **Pre-input manager:** receives user request, **divides** into blocks ≤ token limit, **prioritizes**, **schedules**, and **routes**.
-*   **Persisted memory:** results/latents/“echo” become **shared state** for the next block (nothing is ignored).
-*   **Specialists:** *routers* decide who does what (e.g., “description → LLM-A”, “keyframe → Img-B”, “video → Vid-C”).
-*   **Quality control:** director LLM compares *what was done* × *what should be done* × *what is missing* and **regenerates objectives** for the next fragment.
-*   **Cost/latency-aware:** plans by **VRAM/time/cost**, does not try to “embrace everything at once”.
-
----
-
-#### 🇧🇷 Reivindicações Independentes (Método e Sistema)
-
-**Reivindicação Independente (Método) — Versão Enxuta:**
-
-1.  **Método** de **orquestração de prompts** para execução de tarefas acima do limite de contexto de modelos de IA, compreendendo:
-    (a) **receber** uma solicitação que excede um limite de tokens;
-    (b) **analisar** a solicitação por um **LLM diretor** e **fragmentá-la** em sub-tarefas ≤ limite;
-    (c) **selecionar** especialistas de execução para cada sub-tarefa com base em capacidades declaradas;
-    (d) **gerar** prompts específicos por sub-tarefa em **tokens universais**, incluindo referências ao **estado persistido** de execuções anteriores;
-    (e) **executar sequencialmente** as sub-tarefas e **persistir** suas saídas como memória (incluindo latentes/eco/artefatos);
-    (f) **avaliar** automaticamente a saída versus metas declaradas e **regenerar objetivos** do próximo fragmento;
-    (g) **iterar** (b)–(f) até que os critérios de completude sejam atendidos, produzindo o resultado agregado;
-    em que o framework **escala linearmente** no tempo e armazenamento físico, **independente** da janela de contexto dos modelos subjacentes.
-
-**Reivindicação Independente (Sistema):**
-
-2.  **Sistema** de orquestração de prompts, compreendendo: um **planejador LLM diretor**; um **roteador de especialistas**; um **banco de estado persistido** (incl. memória cinética para vídeo); um **gerador de prompts universais**; e um **módulo de avaliação/realimentação**, acoplados por uma **API pré-input** a modelos heterogêneos.
-
-#### 🇬🇧 Independent Claims (Method and System)
-
-**Independent Claim (Method) — Concise Version:**
-
-1.  A **method** for **prompt orchestration** for executing tasks exceeding AI model context limits, comprising:
-    (a) **receiving** a request that exceeds a token limit;
-    (b) **analyzing** the request by a **director LLM** and **fragmenting it** into sub-tasks ≤ the limit;
-    (c) **selecting** execution specialists for each sub-task based on declared capabilities;
-    (d) **generating** specific prompts per sub-task in **universal tokens**, including references to the **persisted state** of previous executions;
-    (e) **sequentially executing** the sub-tasks and **persisting** their outputs as memory (including latents/echo/artifacts);
-    (f) **automatically evaluating** the output against declared goals and **regenerating objectives** for the next fragment;
-    (g) **iterating** (b)–(f) until completion criteria are met, producing the aggregated result;
-    wherein the framework **scales linearly** in time and physical storage, **independent** of the context window of the underlying models.
-
-**Independent Claim (System):**
-
-2.  A prompt orchestration **system**, comprising: a **director LLM planner**; a **specialist router**; a **persisted state bank** (incl. kinetic memory for video); a **universal prompt generator**; and an **evaluation/feedback module**, coupled via a **pre-input API** to heterogeneous models.
-
----
-
-#### 🇧🇷 Dependentes Úteis
-
-*   (3) Onde o roteamento considera **custo/latência/VRAM** e metas de qualidade.
-*   (4) Onde o banco de estado inclui **eco cinético** para vídeo (últimos *n* frames/latentes/fluxo).
-*   (5) Onde a avaliação usa métricas específicas por domínio (Lflow, consistência semântica, etc.).
-*   (6) Onde *tokens universais* padronizam instruções entre especialistas.
-*   (7) Onde a orquestração decide **cut vs continuous** e **corte regenerativo** (Déjà-Vu) ao editar vídeo.
-*   (8) Onde o sistema **nunca descarta** conteúdo excedente: **reagenda** em novos fragmentos.
-
-#### 🇬🇧 Useful Dependents
-
-*   (3) Wherein routing considers **cost/latency/VRAM** and quality goals.
-*   (4) Wherein the state bank includes **kinetic echo** for video (last *n* frames/latents/flow).
-*   (5) Wherein evaluation uses domain-specific metrics (Lflow, semantic consistency, etc.).
-*   (6) Wherein *universal tokens* standardize instructions between specialists.
-*   (7) Wherein orchestration decides **cut vs continuous** and **regenerative cut** (Déjà-Vu) when editing video.
-*   (8) Wherein the system **never discards** excess content: it **reschedules** it in new fragments.
-
----
-
-#### 🇧🇷 Como isso conversa com SDR (Vídeo)
-
-*   **Eco Cinético**: é um **tipo de estado persistido** consumido pelo próximo passo.
-*   **Déjà-Vu (Corte Regenerativo)**: é **uma política de orquestração** aplicada quando há edição; ADUC decide, monta os prompts certos e chama o especialista de vídeo.
-*   **Cut vs Continuous**: decisão do **diretor** com base em estado + metas; ADUC roteia e garante a sobreposição/remoção final.
-
-#### 🇬🇧 How this Converses with SDR (Video)
-
-*   **Kinetic Echo**: is a **type of persisted state** consumed by the next step.
-*   **Déjà-Vu (Regenerative Cut)**: is an **orchestration policy** applied during editing; ADUC decides, crafts the right prompts, and calls the video specialist.
-*   **Cut vs Continuous**: decision made by the **director** based on state + goals; ADUC routes and ensures the final overlap/removal.
-
----
-
-#### 🇧🇷 Mensagem Clara ao Usuário (Experiência)
-
-> “Seu pedido excede o limite X do modelo Y. Em vez de truncar silenciosamente, o **ADUC** dividirá e **entregará 100%** do conteúdo por etapas coordenadas.”
-
-Isso é diferencial prático e jurídico: **não-obviedade** por transformar limite de contexto em **pipeline controlado**, com **persistência de estado** e **avaliação iterativa**.
-
-#### 🇬🇧 Clear User Message (Experience)
-
-> "Your request exceeds model Y's limit X. Instead of silently truncating, **ADUC** will divide and **deliver 100%** of the content through coordinated steps."
-
-This is a practical and legal differentiator: **non-obviousness** by transforming context limits into a **controlled pipeline**, with **state persistence** and **iterative evaluation**.
-
----
-
-### Contact / Contato / Contacto
-
-- **Author / Autor:** Carlos Rodrigues dos Santos
-- **Email:** carlex22@gmail.com
-- **GitHub:** [https://github.com/carlex22/Aduc-sdr](https://github.com/carlex22/Aduc-sdr)
-- **Hugging Face Spaces:**
-  - [Ltx-SuperTime-60Secondos](https://huggingface.co/spaces/Carlexx/Ltx-SuperTime-60Secondos/)
-  - [Novinho](https://huggingface.co/spaces/Carlexxx/Novinho/)
-
----

engineers/deformes2D_thinker.py

@@ -1,171 +0,0 @@
-# engineers/deformes2D_thinker.py
-# AducSdr: Uma implementação aberta e funcional da arquitetura ADUC-SDR
-# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
-#
-# Contato:
-# Carlos Rodrigues dos Santos
-# carlex22@gmail.com
-# Rua Eduardo Carlos Pereira, 4125, B1 Ap32, Curitiba, PR, Brazil, CEP 8102025
-#
-# 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 1.0.1
-
-import logging
-from pathlib import Path
-from PIL import Image
-import gradio as gr
-from typing import List
-
-# It imports the communication layer, not the API directly
-from managers.gemini_manager import gemini_manager_singleton
-
-logger = logging.getLogger(__name__)
-
-class Deformes2DThinker:
-    """
-    The cognitive specialist that handles prompt engineering and creative logic.
-    """
-    def _read_prompt_template(self, filename: str) -> str:
-        """Reads a prompt template file from the 'prompts' directory."""
-        try:
-            prompts_dir = Path(__file__).resolve().parent.parent / "prompts"
-            with open(prompts_dir / filename, "r", encoding="utf-8") as f:
-                return f.read()
-        except FileNotFoundError:
-            raise gr.Error(f"Prompt template file not found: prompts/{filename}")
-
-    def generate_storyboard(self, prompt: str, num_keyframes: int, ref_image_paths: List[str]) -> List[str]:
-        """Acts as a Scriptwriter to generate a storyboard."""
-        try:
-            template = self._read_prompt_template("unified_storyboard_prompt.txt")
-            storyboard_prompt = template.format(user_prompt=prompt, num_fragments=num_keyframes)
-            images = [Image.open(p) for p in ref_image_paths]
-            
-            # Assemble all parts into a single list for the manager
-            prompt_parts = [storyboard_prompt] + images
-            storyboard_data = gemini_manager_singleton.get_json_object(prompt_parts)
-            
-            storyboard = storyboard_data.get("scene_storyboard", [])
-            if not storyboard or len(storyboard) != num_keyframes: 
-                raise ValueError(f"Incorrect number of scenes generated. Expected {num_keyframes}, got {len(storyboard)}.")
-            return storyboard
-        except Exception as e:
-            raise gr.Error(f"The Scriptwriter (Deformes2D Thinker) failed: {e}")
-
-    def select_keyframes_from_pool(self, storyboard: list, base_image_paths: list[str], pool_image_paths: list[str]) -> list[str]:
-        """Acts as a Photographer/Editor to select keyframes."""
-        if not pool_image_paths:
-            raise gr.Error("The 'image pool' (Additional Images) is empty.")
-            
-        try:
-            template = self._read_prompt_template("keyframe_selection_prompt.txt")
-            
-            image_map = {f"IMG-{i+1}": path for i, path in enumerate(pool_image_paths)}
-            
-            prompt_parts = ["# Reference Images (Story Base)"]
-            prompt_parts.extend([Image.open(p) for p in base_image_paths])
-            prompt_parts.append("\n# Image Pool (Scene Bank)")
-            prompt_parts.extend([Image.open(p) for p in pool_image_paths])
-
-            storyboard_str = "\n".join([f"- Scene {i+1}: {s}" for i, s in enumerate(storyboard)])
-            selection_prompt = template.format(storyboard_str=storyboard_str, image_identifiers=list(image_map.keys()))
-            prompt_parts.append(selection_prompt)
-
-            selection_data = gemini_manager_singleton.get_json_object(prompt_parts)
-            
-            selected_identifiers = selection_data.get("selected_image_identifiers", [])
-            
-            if len(selected_identifiers) != len(storyboard):
-                raise ValueError("The AI did not select the correct number of images for the scenes.")
-            
-            selected_paths = [image_map[identifier] for identifier in selected_identifiers]
-            return selected_paths
-
-        except Exception as e:
-            raise gr.Error(f"The Photographer (Deformes2D Thinker) failed to select images: {e}")
-
-    def get_anticipatory_keyframe_prompt(self, global_prompt: str, scene_history: str, current_scene_desc: str, future_scene_desc: str, last_image_path: str, fixed_ref_paths: list[str]) -> str:
-        """Acts as an Art Director to generate an image prompt."""
-        try:
-            template = self._read_prompt_template("anticipatory_keyframe_prompt.txt")
-            
-            director_prompt = template.format(
-                historico_prompt=scene_history,
-                cena_atual=current_scene_desc,
-                cena_futura=future_scene_desc
-            )
-            
-            prompt_parts = [
-                f"# CONTEXT:\n- Global Story Goal: {global_prompt}\n# VISUAL ASSETS:",
-                "Current Base Image [IMG-BASE]:", 
-                Image.open(last_image_path)
-            ]
-            
-            ref_counter = 1
-            for path in fixed_ref_paths:
-                if path != last_image_path:
-                    prompt_parts.extend([f"General Reference Image [IMG-REF-{ref_counter}]:", Image.open(path)])
-                    ref_counter += 1
-
-            prompt_parts.append(director_prompt)
-
-            final_flux_prompt = gemini_manager_singleton.get_raw_text(prompt_parts)
-            
-            return final_flux_prompt.strip().replace("`", "").replace("\"", "")
-        except Exception as e:
-            raise gr.Error(f"The Art Director (Deformes2D Thinker) failed: {e}")
-
-    def get_cinematic_decision(self, global_prompt: str, story_history: str, 
-                               past_keyframe_path: str, present_keyframe_path: str, future_keyframe_path: str,
-                               past_scene_desc: str, present_scene_desc: str, future_scene_desc: str) -> dict:
-        """Acts as a Film Director to make editing decisions and generate motion prompts."""
-        try:
-            template = self._read_prompt_template("cinematic_director_prompt.txt")
-            prompt_text = template.format(
-                global_prompt=global_prompt, 
-                story_history=story_history,
-                past_scene_desc=past_scene_desc,
-                present_scene_desc=present_scene_desc,
-                future_scene_desc=future_scene_desc
-            )
-            
-            prompt_parts = [
-                prompt_text,
-                "[PAST_IMAGE]:", Image.open(past_keyframe_path),
-                "[PRESENT_IMAGE]:", Image.open(present_keyframe_path),
-                "[FUTURE_IMAGE]:", Image.open(future_keyframe_path)
-            ]
-            
-            decision_data = gemini_manager_singleton.get_json_object(prompt_parts)
-
-            if "transition_type" not in decision_data or "motion_prompt" not in decision_data:
-                raise ValueError("AI response (Cinematographer) is malformed. Missing 'transition_type' or 'motion_prompt'.")
-            return decision_data
-        except Exception as e:
-            logger.error(f"The Film Director (Deformes2D Thinker) failed: {e}. Using fallback to 'continuous'.", exc_info=True)
-            return {
-                "transition_type": "continuous",
-                "motion_prompt": f"A smooth, continuous cinematic transition from '{present_scene_desc}' to '{future_scene_desc}'."
-            }
-
-# --- Singleton Instance ---
-deformes2d_thinker_singleton = Deformes2DThinker()

engineers/deformes3D.py

@@ -1,193 +0,0 @@
-# engineers/deformes3D.py
-#
-# AducSdr: Uma implementação aberta e funcional da arquitetura ADUC-SDR
-# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
-#
-# Contato:
-# Carlos Rodrigues dos Santos
-# carlex22@gmail.com
-# Rua Eduardo Carlos Pereira, 4125, B1 Ap32, Curitiba, PR, Brazil, CEP 8102025
-#
-# 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 2.0.1
-
-from PIL import Image, ImageOps
-import os
-import time
-import logging
-import gradio as gr
-import yaml
-import torch
-import numpy as np
-
-from managers.flux_kontext_manager import flux_kontext_singleton
-from engineers.deformes2D_thinker import deformes2d_thinker_singleton
-from aduc_types import LatentConditioningItem
-from managers.ltx_manager import ltx_manager_singleton
-from managers.vae_manager import vae_manager_singleton
-from managers.latent_enhancer_manager import latent_enhancer_specialist_singleton
-
-logger = logging.getLogger(__name__)
-
-class Deformes3DEngine:
-    """
-    ADUC Specialist for static image (keyframe) generation.
-    """
-    def __init__(self, workspace_dir):
-        self.workspace_dir = workspace_dir
-        self.image_generation_helper = flux_kontext_singleton
-        logger.info("3D Engine (Image Specialist) ready to receive orders from the Maestro.")
-
-    def _generate_single_keyframe(self, prompt: str, reference_images: list[Image.Image], output_filename: str, width: int, height: int, callback: callable = None) -> str:
-        """
-        Low-level function that generates a single image using the LTX helper.
-        """
-        logger.info(f"Generating keyframe '{output_filename}' with prompt: '{prompt}'")
-        generated_image = self.image_generation_helper.generate_image(
-            reference_images=reference_images, prompt=prompt, width=width,
-            height=height, seed=int(time.time()), callback=callback
-        )
-        final_path = os.path.join(self.workspace_dir, output_filename)
-        generated_image.save(final_path)
-        logger.info(f"Keyframe successfully saved to: {final_path}")
-        return final_path
-
-    def generate_keyframes_from_storyboard(self, storyboard: list, initial_ref_path: str, global_prompt: str, keyframe_resolution: int, general_ref_paths: list, progress_callback_factory: callable = None):
-        """
-        Orchestrates the generation of all keyframes. 
-        """
-        current_base_image_path = initial_ref_path
-        previous_prompt = "N/A (initial reference image)"
-        final_keyframes_gallery = [] #[current_base_image_path]
-        width, height = keyframe_resolution, keyframe_resolution
-        target_resolution_tuple = (width, height)
-        
-        num_keyframes_to_generate = len(storyboard) - 1
-        logger.info(f"IMAGE SPECIALIST: Received order to generate {num_keyframes_to_generate} keyframes (LTX versions).")
-
-        for i in range(num_keyframes_to_generate):
-            scene_index = i + 1
-            current_scene = storyboard[i]
-            future_scene = storyboard[i+1]
-            progress_callback_flux = progress_callback_factory(scene_index, num_keyframes_to_generate) if progress_callback_factory else None
-            
-            logger.info(f"--> Generating Keyframe {scene_index}/{num_keyframes_to_generate}...")
-
-            # --- STEP A: Generate with FLUX (Primary Method) ---
-            logger.info(f"    - Step A: Generating with keyframe...")
-            
-            img_prompt = deformes2d_thinker_singleton.get_anticipatory_keyframe_prompt(
-                global_prompt=global_prompt, scene_history=previous_prompt,
-                current_scene_desc=current_scene, future_scene_desc=future_scene,
-                last_image_path=current_base_image_path, fixed_ref_paths=general_ref_paths
-            )
-            
-            #flux_ref_paths = list(set([current_base_image_path] + general_ref_paths))
-            #flux_ref_images = [Image.open(p) for p in flux_ref_paths]
-            
-            #flux_keyframe_path = self._generate_single_keyframe(
-            #    prompt=img_prompt, reference_images=flux_ref_images,
-            #    output_filename=f"keyframe_{scene_index}_flux.png", width=width, height=height,
-            #    callback=progress_callback_flux
-            #)
-            #final_keyframes_gallery.append(flux_keyframe_path)
-            
-            # --- STEP B: LTX Enrichment Experiment ---
-            #logger.info(f"    - Step B: Generating enrichment with LTX...")
-
-            ltx_context_paths = []
-            context_paths = []
-            context_paths = [current_base_image_path] + [p for p in general_ref_paths if p != current_base_image_path][:3]
-            
-            ltx_context_paths = list(reversed(context_paths))
-            logger.info(f"    - LTX Context Order (Reversed): {[os.path.basename(p) for p in ltx_context_paths]}")
-
-            ltx_conditioning_items = []
-            
-            weight = 0.6
-            for idx, path in enumerate(ltx_context_paths):
-                img_pil = Image.open(path).convert("RGB")
-                img_processed = self._preprocess_image_for_latent_conversion(img_pil, target_resolution_tuple)
-                pixel_tensor = self._pil_to_pixel_tensor(img_processed)
-                latent_tensor = vae_manager_singleton.encode(pixel_tensor)
-                
-                ltx_conditioning_items.append(LatentConditioningItem(latent_tensor, 0, weight))
-                
-                if idx >= 0:
-                    weight -= 0.1
-            
-            ltx_base_params = {"guidance_scale": 1.0, "stg_scale": 0.001, "num_inference_steps": 25}
-            generated_latents, _ = ltx_manager_singleton.generate_latent_fragment(
-                height=height, width=width,
-                conditioning_items_data=ltx_conditioning_items,
-                motion_prompt=img_prompt,
-                video_total_frames=48,
-                video_fps=24,
-                **ltx_base_params
-            )
-
-            final_latent = generated_latents[:, :, -1:, :, :]
-            upscaled_latent = latent_enhancer_specialist_singleton.upscale(final_latent)
-            enriched_pixel_tensor = vae_manager_singleton.decode(upscaled_latent)
-
-            ltx_keyframe_path = os.path.join(self.workspace_dir, f"keyframe_{scene_index}_ltx.png")
-            self.save_image_from_tensor(enriched_pixel_tensor, ltx_keyframe_path)
-            final_keyframes_gallery.append(ltx_keyframe_path)
-            
-            # Use the FLUX keyframe as the base for the next iteration to maintain the primary narrative path
-            current_base_image_path = ltx_keyframe_path #flux_keyframe_path 
-            previous_prompt = img_prompt
-
-        logger.info(f"IMAGE SPECIALIST: Generation of all keyframe versions (LTX) complete.")
-        return final_keyframes_gallery
-
-    # --- HELPER FUNCTIONS ---
-
-    def _preprocess_image_for_latent_conversion(self, image: Image.Image, target_resolution: tuple) -> Image.Image:
-        """Resizes and fits an image to the target resolution for VAE encoding."""
-        if image.size != target_resolution:
-            return ImageOps.fit(image, target_resolution, Image.Resampling.LANCZOS)
-        return image
-        
-    def _pil_to_pixel_tensor(self, pil_image: Image.Image) -> torch.Tensor:
-        """Helper to convert PIL to the 5D pixel tensor the VAE expects."""
-        image_np = np.array(pil_image).astype(np.float32) / 255.0
-        tensor = torch.from_numpy(image_np).permute(2, 0, 1).unsqueeze(0).unsqueeze(2)
-        return (tensor * 2.0) - 1.0
-
-    def save_image_from_tensor(self, pixel_tensor: torch.Tensor, path: str):
-        """Helper to save a 1-frame pixel tensor as an image."""
-        tensor_chw = pixel_tensor.squeeze(0).squeeze(1)
-        tensor_hwc = tensor_chw.permute(1, 2, 0)
-        tensor_hwc = (tensor_hwc.clamp(-1, 1) + 1) / 2.0
-        image_np = (tensor_hwc.cpu().float().numpy() * 255).astype(np.uint8)
-        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

engineers/deformes3D_thinker.py

@@ -1,136 +0,0 @@
-# engineers/deformes3D_thinker.py
-#
-# Copyright (C) 2025 Carlos Rodrigues dos Santos
-#
-# Version: 4.0.0 (Definitive)
-#
-# This is the definitive, robust implementation. It directly contains the prompt
-# enhancement logic copied from the LTX pipeline's utils. It accesses the
-# enhancement models loaded by the LTX Manager and performs the captioning
-# and LLM generation steps locally, ensuring full control and compatibility.
-
-import logging
-from PIL import Image
-import torch
-
-# Importa o singleton do LTX para ter acesso à sua pipeline e aos modelos nela
-from managers.ltx_manager import ltx_manager_singleton
-
-# Importa o prompt de sistema do LTX para garantir consistência
-from ltx_video.utils.prompt_enhance_utils import I2V_CINEMATIC_PROMPT
-
-logger = logging.getLogger(__name__)
-
-class Deformes3DThinker:
-    """
-    The tactical specialist that now directly implements the prompt enhancement
-    logic, using the models provided by the LTX pipeline.
-    """
-    
-    def __init__(self):
-        # Acessa a pipeline exposta para obter os modelos necessários
-        pipeline = ltx_manager_singleton.prompt_enhancement_pipeline
-        if not pipeline:
-            raise RuntimeError("Deformes3DThinker could not access the LTX pipeline.")
-        
-        # Armazena os modelos e processadores como atributos diretos
-        self.caption_model = pipeline.prompt_enhancer_image_caption_model
-        self.caption_processor = pipeline.prompt_enhancer_image_caption_processor
-        self.llm_model = pipeline.prompt_enhancer_llm_model
-        self.llm_tokenizer = pipeline.prompt_enhancer_llm_tokenizer
-        
-        # Verifica se os modelos foram realmente carregados
-        if not all([self.caption_model, self.caption_processor, self.llm_model, self.llm_tokenizer]):
-            logger.warning("Deformes3DThinker initialized, but one or more enhancement models were not loaded by the LTX pipeline. Fallback will be used.")
-        else:
-            logger.info("Deformes3DThinker initialized and successfully linked to LTX enhancement models.")
-
-    @torch.no_grad()
-    def get_enhanced_motion_prompt(self, global_prompt: str, story_history: str, 
-                                   past_keyframe_path: str, present_keyframe_path: str, future_keyframe_path: str,
-                                   past_scene_desc: str, present_scene_desc: str, future_scene_desc: str) -> str:
-        """
-        Generates a refined motion prompt by directly executing the enhancement pipeline logic.
-        """
-        # Verifica se os modelos estão disponíveis antes de tentar usá-los
-        if not all([self.caption_model, self.caption_processor, self.llm_model, self.llm_tokenizer]):
-            logger.warning("Enhancement models not available. Using fallback prompt.")
-            return f"A cinematic transition from '{present_scene_desc}' to '{future_scene_desc}'."
-
-        try:
-            present_image = Image.open(present_keyframe_path).convert("RGB")
-            
-            # --- INÍCIO DA LÓGICA COPIADA E ADAPTADA DO LTX ---
-            
-            # 1. Gerar a caption da imagem de referência (presente)
-            image_captions = self._generate_image_captions([present_image])
-            
-            # 2. Construir o prompt para o LLM
-            # Usamos a cena futura como o "prompt do usuário"
-            messages = [
-                {"role": "system", "content": I2V_CINEMATIC_PROMPT},
-                {"role": "user", "content": f"user_prompt: {future_scene_desc}\nimage_caption: {image_captions[0]}"},
-            ]
-
-            # 3. Gerar e decodificar o prompt final com o LLM
-            enhanced_prompt = self._generate_and_decode_prompts(messages)
-            
-            # --- FIM DA LÓGICA COPIADA E ADAPTADA ---
-
-            logger.info(f"Deformes3DThinker received enhanced prompt: '{enhanced_prompt}'")
-            return enhanced_prompt
-
-        except Exception as e:
-            logger.error(f"The Film Director (Deformes3D Thinker) failed during enhancement: {e}. Using fallback.", exc_info=True)
-            return f"A smooth, continuous cinematic transition from '{present_scene_desc}' to '{future_scene_desc}'."
-
-    def _generate_image_captions(self, images: list[Image.Image]) -> list[str]:
-        """
-        Lógica interna para gerar captions, copiada do LTX utils.
-        """
-        # O modelo Florence-2 do LTX não usa um system_prompt aqui, mas um task_prompt
-        task_prompt = "<MORE_DETAILED_CAPTION>"
-        inputs = self.caption_processor(
-            text=[task_prompt] * len(images), images=images, return_tensors="pt"
-        ).to(self.caption_model.device)
-
-        generated_ids = self.caption_model.generate(
-            input_ids=inputs["input_ids"],
-            pixel_values=inputs["pixel_values"],
-            max_new_tokens=1024,
-            num_beams=3,
-        )
-        
-        # Usa o post_process_generation para extrair a resposta limpa
-        generated_text = self.caption_processor.batch_decode(generated_ids, skip_special_tokens=False)[0]
-        processed_result = self.caption_processor.post_process_generation(
-            generated_text, 
-            task=task_prompt, 
-            image_size=(images[0].width, images[0].height)
-        )
-        return [processed_result[task_prompt]]
-
-    def _generate_and_decode_prompts(self, messages: list[dict]) -> str:
-        """
-        Lógica interna para gerar prompt com o LLM, copiada do LTX utils.
-        """
-        text = self.llm_tokenizer.apply_chat_template(
-            messages, tokenize=False, add_generation_prompt=True
-        )
-        model_inputs = self.llm_tokenizer([text], return_tensors="pt").to(self.llm_model.device)
-
-        output_ids = self.llm_model.generate(**model_inputs, max_new_tokens=256)
-        
-        input_ids_len = model_inputs.input_ids.shape[1]
-        decoded_prompts = self.llm_tokenizer.batch_decode(
-            output_ids[:, input_ids_len:], skip_special_tokens=True
-        )
-        return decoded_prompts[0].strip()
-
-# --- Singleton Instantiation ---
-try:
-    deformes3d_thinker_singleton = Deformes3DThinker()
-except Exception as e:
-    # A falha já terá sido logada dentro do __init__
-    deformes3d_thinker_singleton = None
-    raise e

engineers/deformes4D.py

@@ -1,338 +0,0 @@
-# engineers/deformes4D.py
-#
-# AducSdr: Uma implementação aberta e funcional da arquitetura ADUC-SDR
-# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
-#
-# Contato:
-# Carlos Rodrigues dos Santos
-# carlex22@gmail.com
-# Rua Eduardo Carlos Pereira, 4125, B1 Ap32, Curitiba, PR, Brazil, CEP 8102025
-#
-# 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 2.0.1
-
-import os
-import time
-import imageio
-import numpy as np
-import torch
-import logging
-from PIL import Image, ImageOps
-from dataclasses import dataclass
-import gradio as gr
-import subprocess
-import gc
-import shutil
-from pathlib import Path
-from typing import List, Tuple, Generator, Dict, Any
-
-from aduc_types import LatentConditioningItem
-from managers.ltx_manager import ltx_manager_singleton
-from managers.latent_enhancer_manager import latent_enhancer_specialist_singleton
-from managers.vae_manager import vae_manager_singleton
-from engineers.deformes2D_thinker import deformes2d_thinker_singleton
-from managers.seedvr_manager import seedvr_manager_singleton
-from managers.mmaudio_manager import mmaudio_manager_singleton
-from tools.video_encode_tool import video_encode_tool_singleton
-
-logger = logging.getLogger(__name__)
-
-class Deformes4DEngine:
-    """
-    Implements the Camera (Ψ) and Distiller (Δ) of the ADUC-SDR architecture.
-    Orchestrates the generation, latent post-production, and final rendering of video fragments.
-    """
-    def __init__(self, workspace_dir="deformes_workspace"):
-        self.workspace_dir = workspace_dir
-        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
-        logger.info("Deformes4D Specialist (ADUC-SDR Executor) initialized.")
-        os.makedirs(self.workspace_dir, exist_ok=True)
-
-    # --- HELPER METHODS ---
-
-    def save_video_from_tensor(self, video_tensor: torch.Tensor, path: str, fps: int = 24):
-        """Saves a pixel-space tensor as an MP4 video file."""
-        if video_tensor is None or video_tensor.ndim != 5 or video_tensor.shape[2] == 0: return
-        video_tensor = video_tensor.squeeze(0).permute(1, 2, 3, 0)
-        video_tensor = (video_tensor.clamp(-1, 1) + 1) / 2.0
-        video_np = (video_tensor.detach().cpu().float().numpy() * 255).astype(np.uint8)
-        with imageio.get_writer(path, fps=fps, codec='libx264', quality=8, output_params=['-pix_fmt', 'yuv420p']) as writer:
-            for frame in video_np: writer.append_data(frame)
-
-    def read_video_to_tensor(self, video_path: str) -> torch.Tensor:
-        """Reads a video file and converts it into a pixel-space tensor."""
-        with imageio.get_reader(video_path, 'ffmpeg') as reader:
-            frames = [frame for frame in reader]
-        
-        frames_np = np.stack(frames, axis=0).astype(np.float32) / 255.0
-        # (F, H, W, C) -> (C, F, H, W)
-        tensor = torch.from_numpy(frames_np).permute(3, 0, 1, 2) 
-        tensor = tensor.unsqueeze(0) # (B, C, F, H, W)
-        tensor = (tensor * 2.0) - 1.0 # Normalize to [-1, 1]
-        return tensor.to(self.device)
-
-    def _preprocess_image_for_latent_conversion(self, image: Image.Image, target_resolution: tuple) -> Image.Image:
-        """Resizes and fits an image to the target resolution for VAE encoding."""
-        if image.size != target_resolution:
-            return ImageOps.fit(image, target_resolution, Image.Resampling.LANCZOS)
-        return image
-
-    def pil_to_latent(self, pil_image: Image.Image) -> torch.Tensor:
-        """Converts a PIL Image to a latent tensor by calling the VaeManager."""
-        image_np = np.array(pil_image).astype(np.float32) / 255.0
-        tensor = torch.from_numpy(image_np).permute(2, 0, 1).unsqueeze(0).unsqueeze(2)
-        tensor = (tensor * 2.0) - 1.0
-        return vae_manager_singleton.encode(tensor)
-
-    # --- CORE ADUC-SDR LOGIC ---
-
-    def generate_original_movie(self, keyframes: list, global_prompt: str, storyboard: list,
-                                seconds_per_fragment: float, trim_percent: int,
-                                handler_strength: float, destination_convergence_strength: float,
-                                video_resolution: int, use_continuity_director: bool,
-                                guidance_scale: float, stg_scale: float, num_inference_steps: int,
-                                progress: gr.Progress = gr.Progress()):
-        FPS = 24
-        FRAMES_PER_LATENT_CHUNK = 8
-        LATENT_PROCESSING_CHUNK_SIZE = 4
-
-        run_timestamp = int(time.time())
-        temp_latent_dir = os.path.join(self.workspace_dir, f"temp_latents_{run_timestamp}")
-        temp_video_clips_dir = os.path.join(self.workspace_dir, f"temp_clips_{run_timestamp}")
-        os.makedirs(temp_latent_dir, exist_ok=True)
-        os.makedirs(temp_video_clips_dir, exist_ok=True)
-
-        total_frames_brutos = self._quantize_to_multiple(int(seconds_per_fragment * FPS), FRAMES_PER_LATENT_CHUNK)
-        frames_a_podar = self._quantize_to_multiple(int(total_frames_brutos * (trim_percent / 100)), FRAMES_PER_LATENT_CHUNK)
-        latents_a_podar = frames_a_podar // FRAMES_PER_LATENT_CHUNK
-        
-        #if frames_a_podar % 2 == 0:
-        #    frames_a_podar = frames_a_podar-1
-        
-        total_latent_frames = total_frames_brutos // FRAMES_PER_LATENT_CHUNK
-
-        DEJAVU_FRAME_TARGET = frames_a_podar - 1 if frames_a_podar > 0 else 0
-        DESTINATION_FRAME_TARGET = total_frames_brutos - 1
-
-        base_ltx_params = {"guidance_scale": guidance_scale, "stg_scale": stg_scale, "num_inference_steps": num_inference_steps, "rescaling_scale": 0.15, "image_cond_noise_scale": 0.00}
-        keyframe_paths = [item[0] if isinstance(item, tuple) else item for item in keyframes]
-        story_history = ""
-        target_resolution_tuple = (video_resolution, video_resolution)
-        eco_latent_for_next_loop, dejavu_latent_for_next_loop = None, None
-        latent_fragment_paths = []
-
-        if len(keyframe_paths) < 2: raise gr.Error(f"Generation requires at least 2 keyframes. You provided {len(keyframe_paths)}.")
-        num_transitions_to_generate = len(keyframe_paths) - 1
-
-        logger.info("--- STARTING STAGE 1: Latent Fragment Generation ---")
-        for i in range(num_transitions_to_generate):
-            fragment_index = i + 1
-            progress(i / num_transitions_to_generate, desc=f"Generating Latent {fragment_index}/{num_transitions_to_generate}")
-            past_keyframe_path = keyframe_paths[i - 1] if i > 0 else keyframe_paths[i]
-            start_keyframe_path = keyframe_paths[i]
-            destination_keyframe_path = keyframe_paths[i + 1]
-            future_story_prompt = storyboard[i + 1] if (i + 1) < len(storyboard) else "The final scene."
-            logger.info(f"Calling deformes2D_thinker to generate cinematic decision for fragment {fragment_index}...")
-            decision = deformes2d_thinker_singleton.get_cinematic_decision(global_prompt, story_history, past_keyframe_path, start_keyframe_path, destination_keyframe_path, storyboard[i - 1] if i > 0 else "The beginning.", storyboard[i], future_story_prompt)
-            transition_type, motion_prompt = decision["transition_type"], decision["motion_prompt"]
-            story_history += f"\n- Act {fragment_index}: {motion_prompt}"
-            
-            conditioning_items = []
-            if eco_latent_for_next_loop is None:
-               img_start = self._preprocess_image_for_latent_conversion(Image.open(start_keyframe_path).convert("RGB"), target_resolution_tuple)
-               conditioning_items.append(LatentConditioningItem(self.pil_to_latent(img_start), 0, 1.0))
-            else:
-               conditioning_items.append(LatentConditioningItem(eco_latent_for_next_loop, 0, 1.0))
-               conditioning_items.append(LatentConditioningItem(dejavu_latent_for_next_loop, DEJAVU_FRAME_TARGET, handler_strength))
-            
-            if transition_type == "cutx":
-                logger.info(f"Cinematic Director chose a 'cut'. Creating FFmpeg transition bridge...")
-                bridge_duration_seconds = FRAMES_PER_LATENT_CHUNK / FPS
-                bridge_video_path = video_encode_tool_singleton.create_transition_bridge(
-                    start_image_path=start_keyframe_path, end_image_path=destination_keyframe_path,
-                    duration=bridge_duration_seconds, fps=FPS, target_resolution=target_resolution_tuple,
-                    workspace_dir=self.workspace_dir
-                )
-                bridge_pixel_tensor = self.read_video_to_tensor(bridge_video_path)
-                bridge_latent_tensor = vae_manager_singleton.encode(bridge_pixel_tensor)
-                final_fade_latent = bridge_latent_tensor[:, :, -2:, :, :]
-                conditioning_items.append(LatentConditioningItem(final_fade_latent, total_latent_frames - 16, 0.95))
-                #img_dest = self._preprocess_image_for_latent_conversion(Image.open(destination_keyframe_path).convert("RGB"), target_resolution_tuple)
-                #conditioning_items.append(LatentConditioningItem(self.pil_to_latent(img_dest), DESTINATION_FRAME_TARGET, destination_convergence_strength * 0.5))
-                del bridge_pixel_tensor, bridge_latent_tensor, final_fade_latent
-                if os.path.exists(bridge_video_path): os.remove(bridge_video_path)
-            else:
-               img_dest = self._preprocess_image_for_latent_conversion(Image.open(destination_keyframe_path).convert("RGB"), target_resolution_tuple)
-               conditioning_items.append(LatentConditioningItem(self.pil_to_latent(img_dest), DESTINATION_FRAME_TARGET, destination_convergence_strength))
-            
-            current_ltx_params = {**base_ltx_params, "motion_prompt": motion_prompt}
-            logger.info(f"Calling LTX to generate video latents for fragment {fragment_index} ({total_frames_brutos} frames)...")
-            latents_brutos, _ = self._generate_latent_tensor_internal(conditioning_items, current_ltx_params, target_resolution_tuple, total_frames_brutos)
-            num_latent_frames = latents_brutos.shape[2]
-            logger.info(f"LTX responded with a latent tensor of shape {latents_brutos.shape}, representing ~{num_latent_frames * 8 + 1} video frames at {FPS} FPS.")
-            
-            last_trim = latents_brutos[:, :, -(latents_a_podar+1):, :, :].clone()
-            eco_latent_for_next_loop = last_trim[:, :, :2, :, :].clone()
-            dejavu_latent_for_next_loop = last_trim[:, :, -1:, :, :].clone()
-            latents_video = latents_brutos[:, :, :-(latents_a_podar-1), :, :].clone()
-            latents_video = latents_video[:, :, 1:, :, :]
-            del last_trim, latents_brutos; gc.collect(); torch.cuda.empty_cache()
-            
-            if transition_type == "cutx":
-                eco_latent_for_next_loop, dejavu_latent_for_next_loop = None, None
-                
-            
-            cpu_latent = latents_video.cpu()
-            latent_path = os.path.join(temp_latent_dir, f"latent_fragment_{i:04d}.pt")
-            torch.save(cpu_latent, latent_path)
-            latent_fragment_paths.append(latent_path)
-            del latents_video, cpu_latent; gc.collect()
-        del eco_latent_for_next_loop, dejavu_latent_for_next_loop; gc.collect(); torch.cuda.empty_cache()
-
-        logger.info(f"--- STARTING STAGE 2: Processing {len(latent_fragment_paths)} latents in chunks of {LATENT_PROCESSING_CHUNK_SIZE} ---")
-        final_video_clip_paths = []
-        num_chunks = -(-len(latent_fragment_paths) // LATENT_PROCESSING_CHUNK_SIZE)
-        for i in range(num_chunks):
-            chunk_start_index = i * LATENT_PROCESSING_CHUNK_SIZE
-            chunk_end_index = chunk_start_index + LATENT_PROCESSING_CHUNK_SIZE
-            chunk_paths = latent_fragment_paths[chunk_start_index:chunk_end_index]
-            progress(i / num_chunks, desc=f"Processing & Decoding Batch {i+1}/{num_chunks}")
-            tensors_in_chunk = [torch.load(p, map_location=self.device) for p in chunk_paths]
-            tensors_para_concatenar = [frag[:, :, :-1, :, :] if j < len(tensors_in_chunk) - 1 else frag for j, frag in enumerate(tensors_in_chunk)]
-            sub_group_latent = torch.cat(tensors_para_concatenar, dim=2)
-            del tensors_in_chunk, tensors_para_concatenar; gc.collect(); torch.cuda.empty_cache()
-            logger.info(f"Batch {i+1} concatenated. Latent shape: {sub_group_latent.shape}")
-            base_name = f"clip_{i:04d}_{run_timestamp}"
-            current_clip_path = os.path.join(temp_video_clips_dir, f"{base_name}.mp4")
-            pixel_tensor = vae_manager_singleton.decode(sub_group_latent)
-            self.save_video_from_tensor(pixel_tensor, current_clip_path, fps=FPS)
-            del pixel_tensor, sub_group_latent; gc.collect(); torch.cuda.empty_cache()
-            final_video_clip_paths.append(current_clip_path)
-
-        progress(0.98, desc="Final assembly of clips...")
-        final_video_path = os.path.join(self.workspace_dir, f"original_movie_{run_timestamp}.mp4")
-        video_encode_tool_singleton.concatenate_videos(video_paths=final_video_clip_paths, output_path=final_video_path, workspace_dir=self.workspace_dir)
-        logger.info("Cleaning up temporary clip files...")
-        try:
-            shutil.rmtree(temp_video_clips_dir)
-        except OSError as e:
-            logger.warning(f"Could not remove temporary clip directory: {e}")
-        logger.info(f"Process complete! Original video saved to: {final_video_path}")
-        return {"final_path": final_video_path, "latent_paths": latent_fragment_paths}
-
-    def upscale_latents_and_create_video(self, latent_paths: list, chunk_size: int, progress: gr.Progress):
-        if not latent_paths:
-            raise gr.Error("Cannot perform upscaling: no latent paths were provided.")
-        logger.info("--- STARTING POST-PRODUCTION: Latent Upscaling ---")
-        run_timestamp = int(time.time())
-        temp_upscaled_clips_dir = os.path.join(self.workspace_dir, f"temp_upscaled_clips_{run_timestamp}")
-        os.makedirs(temp_upscaled_clips_dir, exist_ok=True)
-        final_upscaled_clip_paths = []
-        num_chunks = -(-len(latent_paths) // chunk_size)
-        for i in range(num_chunks):
-            chunk_start_index = i * chunk_size
-            chunk_end_index = chunk_start_index + chunk_size
-            chunk_paths = latent_paths[chunk_start_index:chunk_end_index]
-            progress(i / num_chunks, desc=f"Upscaling & Decoding Batch {i+1}/{num_chunks}")
-            tensors_in_chunk = [torch.load(p, map_location=self.device) for p in chunk_paths]
-            tensors_para_concatenar = [frag[:, :, :-1, :, :] if j < len(tensors_in_chunk) - 1 else frag for j, frag in enumerate(tensors_in_chunk)]
-            sub_group_latent = torch.cat(tensors_para_concatenar, dim=2)
-            del tensors_in_chunk, tensors_para_concatenar; gc.collect(); torch.cuda.empty_cache()
-            logger.info(f"Batch {i+1} loaded. Original latent shape: {sub_group_latent.shape}")
-            upscaled_latent_chunk = latent_enhancer_specialist_singleton.upscale(sub_group_latent)
-            del sub_group_latent; gc.collect(); torch.cuda.empty_cache()
-            logger.info(f"Batch {i+1} upscaled. New latent shape: {upscaled_latent_chunk.shape}")
-            pixel_tensor = vae_manager_singleton.decode(upscaled_latent_chunk)
-            del upscaled_latent_chunk; gc.collect(); torch.cuda.empty_cache()
-            base_name = f"upscaled_clip_{i:04d}_{run_timestamp}"
-            current_clip_path = os.path.join(temp_upscaled_clips_dir, f"{base_name}.mp4")
-            self.save_video_from_tensor(pixel_tensor, current_clip_path, fps=24)
-            final_upscaled_clip_paths.append(current_clip_path)
-            del pixel_tensor; gc.collect(); torch.cuda.empty_cache()
-            logger.info(f"Saved upscaled clip: {Path(current_clip_path).name}")
-        progress(0.98, desc="Assembling upscaled clips...")
-        final_video_path = os.path.join(self.workspace_dir, f"upscaled_movie_{run_timestamp}.mp4")
-        video_encode_tool_singleton.concatenate_videos(video_paths=final_upscaled_clip_paths, output_path=final_video_path, workspace_dir=self.workspace_dir)
-        logger.info("Cleaning up temporary upscaled clip files...")
-        try:
-            shutil.rmtree(temp_upscaled_clips_dir)
-        except OSError as e:
-            logger.warning(f"Could not remove temporary upscaled clip directory: {e}")
-        logger.info(f"Latent upscaling complete! Final video at: {final_video_path}")
-        yield {"final_path": final_video_path}
-
-    def master_video_hd(self, source_video_path: str, model_version: str, steps: int, prompt: str, progress: gr.Progress):
-        logger.info(f"--- STARTING POST-PRODUCTION: HD Mastering with SeedVR {model_version} ---")
-        progress(0.1, desc=f"Preparing for HD Mastering with SeedVR {model_version}...")
-        run_timestamp = int(time.time())
-        output_path = os.path.join(self.workspace_dir, f"hd_mastered_movie_{model_version}_{run_timestamp}.mp4")
-        try:
-            final_path = seedvr_manager_singleton.process_video(
-                input_video_path=source_video_path,
-                output_video_path=output_path,
-                prompt=prompt,
-                model_version=model_version,
-                steps=steps,
-                progress=progress
-            )
-            logger.info(f"HD Mastering complete! Final video at: {final_path}")
-            yield {"final_path": final_path}
-        except Exception as e:
-            logger.error(f"HD Mastering failed: {e}", exc_info=True)
-            raise gr.Error(f"HD Mastering failed. Details: {e}")
-    
-    def generate_audio_for_final_video(self, source_video_path: str, audio_prompt: str, progress: gr.Progress):
-        logger.info(f"--- STARTING POST-PRODUCTION: Audio Generation ---")
-        progress(0.1, desc="Preparing for audio generation...")
-        run_timestamp = int(time.time())
-        source_name = Path(source_video_path).stem
-        output_path = os.path.join(self.workspace_dir, f"{source_name}_with_audio_{run_timestamp}.mp4")
-        try:
-            result = subprocess.run(
-                ["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", source_video_path],
-                capture_output=True, text=True, check=True)
-            duration = float(result.stdout.strip())
-            logger.info(f"Source video duration: {duration:.2f} seconds.")
-            progress(0.5, desc="Generating audio track...")
-            final_path = mmaudio_manager_singleton.generate_audio_for_video(
-                video_path=source_video_path,
-                prompt=audio_prompt,
-                duration_seconds=duration,
-                output_path_override=output_path
-            )
-            logger.info(f"Audio generation complete! Final video with audio at: {final_path}")
-            progress(1.0, desc="Audio generation complete!")
-            yield {"final_path": final_path}
-        except Exception as e:
-            logger.error(f"Audio generation failed: {e}", exc_info=True)
-            raise gr.Error(f"Audio generation failed. Details: {e}")
-
-    def _generate_latent_tensor_internal(self, conditioning_items, ltx_params, target_resolution, total_frames_to_generate):
-        """Internal helper to call the LTX manager."""
-        final_ltx_params = {**ltx_params, 'width': target_resolution[0], 'height': target_resolution[1], 'video_total_frames': total_frames_to_generate, 'video_fps': 24, 'current_fragment_index': int(time.time()), 'conditioning_items_data': conditioning_items}
-        return ltx_manager_singleton.generate_latent_fragment(**final_ltx_params)
-
-    def _quantize_to_multiple(self, n, m):
-        """Helper to round n to the nearest multiple of m."""
-        if m == 0: return n
-        quantized = int(round(n / m) * m)
-        return m if n > 0 and quantized == 0 else quantized

engineers/deformes7D.py

@@ -1,316 +0,0 @@
-# engineers/deformes7D.py
-#
-# AducSdr: Uma implementação aberta e funcional da arquitetura ADUC-SDR
-# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
-#
-# Contato:
-# Carlos Rodrigues dos Santos
-# carlex22@gmail.com
-# Rua Eduardo Carlos Pereira, 4125, B1 Ap32, Curitiba, PR, Brazil, CEP 8102025
-#
-# 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.2.1
-
-import os
-import time
-import imageio
-import numpy as np
-import torch
-import logging
-from PIL import Image, ImageOps
-import gradio as gr
-import subprocess
-import gc
-import yaml
-import shutil
-from pathlib import Path
-from typing import List, Tuple, Dict, Generator
-
-from aduc_types import LatentConditioningItem
-from managers.ltx_manager import ltx_manager_singleton
-from managers.latent_enhancer_manager import latent_enhancer_specialist_singleton
-from managers.vae_manager import vae_manager_singleton
-from engineers.deformes2D_thinker import deformes2d_thinker_singleton
-from engineers.deformes3D_thinker import deformes3d_thinker_singleton
-from managers.seedvr_manager import seedvr_manager_singleton
-from managers.mmaudio_manager import mmaudio_manager_singleton
-from tools.video_encode_tool import video_encode_tool_singleton
-
-logger = logging.getLogger(__name__)
-
-class Deformes7DEngine:
-    # ... (todo o corpo da classe permanece exatamente o mesmo da nossa última versão) ...
-    """
-    Unified 3D/4D engine for continuous, interleaved generation of keyframes and video fragments.
-    """
-    def __init__(self, workspace_dir="deformes_workspace"):
-        self.workspace_dir = workspace_dir
-        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
-        logger.info("Deformes7D Unified Engine initialized.")
-        os.makedirs(self.workspace_dir, exist_ok=True)
-
-    # --- HELPER METHODS ---
-    def save_video_from_tensor(self, video_tensor: torch.Tensor, path: str, fps: int = 24):
-        """Saves a pixel-space tensor as an MP4 video file."""
-        if video_tensor is None or video_tensor.ndim != 5 or video_tensor.shape[2] == 0: return
-        video_tensor = video_tensor.squeeze(0).permute(1, 2, 3, 0)
-        video_tensor = (video_tensor.clamp(-1, 1) + 1) / 2.0
-        video_np = (video_tensor.detach().cpu().float().numpy() * 255).astype(np.uint8)
-        with imageio.get_writer(path, fps=fps, codec='libx264', quality=8, output_params=['-pix_fmt', 'yuv420p']) as writer:
-            for frame in video_np: writer.append_data(frame)
-
-    def read_video_to_tensor(self, video_path: str) -> torch.Tensor:
-        """Reads a video file and converts it into a pixel-space tensor."""
-        with imageio.get_reader(video_path, 'ffmpeg') as reader:
-            frames = [frame for frame in reader]
-        frames_np = np.stack(frames, axis=0).astype(np.float32) / 255.0
-        tensor = torch.from_numpy(frames_np).permute(3, 0, 1, 2) 
-        tensor = tensor.unsqueeze(0)
-        tensor = (tensor * 2.0) - 1.0
-        return tensor.to(self.device)
-
-    def _preprocess_image(self, image: Image.Image, target_resolution: tuple) -> Image.Image:
-        if image.size != target_resolution:
-            return ImageOps.fit(image, target_resolution, Image.Resampling.LANCZOS)
-        return image
-
-    def _pil_to_pixel_tensor(self, pil_image: Image.Image) -> torch.Tensor:
-        image_np = np.array(pil_image).astype(np.float32) / 255.0
-        tensor = torch.from_numpy(image_np).permute(2, 0, 1).unsqueeze(0).unsqueeze(2)
-        return (tensor * 2.0) - 1.0
-        
-    def _save_image_from_tensor(self, pixel_tensor: torch.Tensor, path: str):
-        tensor_chw = pixel_tensor.squeeze(0).squeeze(1)
-        tensor_hwc = tensor_chw.permute(1, 2, 0)
-        tensor_hwc = (tensor_hwc.clamp(-1, 1) + 1) / 2.0
-        image_np = (tensor_hwc.cpu().float().numpy() * 255).astype(np.uint8)
-        Image.fromarray(image_np).save(path)
-
-    def _quantize_to_multiple(self, n, m):
-        if m == 0: return n
-        quantized = int(round(n / m) * m)
-        return m if n > 0 and quantized == 0 else quantized
-
-    # --- CORE GENERATION LOGIC ---
-    def _generate_next_causal_keyframe(self, base_keyframe_path: str, all_ref_paths: list, 
-                                       prompt: str, resolution_tuple: tuple) -> Tuple[str, torch.Tensor]:
-        # (código interno deste método permanece o mesmo)
-        ltx_context_paths = [base_keyframe_path] + [p for p in all_ref_paths if p != base_keyframe_path][:3]
-        ltx_conditioning_items = []
-        weight = 1.0
-        for path in ltx_context_paths:
-            img_pil = Image.open(path).convert("RGB")
-            img_processed = self._preprocess_image(img_pil, resolution_tuple)
-            pixel_tensor = self._pil_to_pixel_tensor(img_processed)
-            latent_tensor = vae_manager_singleton.encode(pixel_tensor)
-            ltx_conditioning_items.append(LatentConditioningItem(latent_tensor, 0, weight))
-            if weight == 1.0: weight = -0.2
-            else: weight -= 0.2
-        ltx_base_params = {"guidance_scale": 3.0, "stg_scale": 0.1, "num_inference_steps": 25}
-        generated_latents, _ = ltx_manager_singleton.generate_latent_fragment(
-            height=resolution_tuple[0], width=resolution_tuple[1],
-            conditioning_items_data=ltx_conditioning_items, motion_prompt=prompt,
-            video_total_frames=48, video_fps=24, **ltx_base_params
-        )
-        final_latent = generated_latents[:, :, -1:, :, :]
-        upscaled_latent = latent_enhancer_specialist_singleton.upscale(final_latent)
-        pixel_tensor_out = vae_manager_singleton.decode(upscaled_latent)
-        timestamp = int(time.time() * 1000)
-        output_path = os.path.join(self.workspace_dir, f"keyframe_{timestamp}.png")
-        self._save_image_from_tensor(pixel_tensor_out, output_path)
-        return output_path, final_latent
-
-    def generate_full_movie_interleaved(self, initial_ref_paths: list, storyboard: list, global_prompt: str,
-                                        video_resolution: int, seconds_per_fragment: float, trim_percent: int, 
-                                        handler_strength: float, dest_strength: float, ltx_params: dict,
-                                        progress=gr.Progress()):
-        # (código interno deste método permanece o mesmo)
-        logger.info("--- DEFORMES 7D: INITIATING INTERLEAVED RENDERING PIPELINE ---")
-        run_timestamp = int(time.time())
-        temp_video_clips_dir = os.path.join(self.workspace_dir, f"temp_clips_{run_timestamp}")
-        os.makedirs(temp_video_clips_dir, exist_ok=True)
-        FPS = 24
-        FRAMES_PER_LATENT_CHUNK = 8
-        resolution_tuple = (video_resolution, video_resolution)
-        generated_keyframe_paths, generated_keyframe_latents, generated_video_fragment_paths = [], [], []
-        progress(0, desc="Bootstrap: Processing K0...")
-        k0_path = initial_ref_paths[0]
-        k0_pil = Image.open(k0_path).convert("RGB")
-        k0_processed_pil = self._preprocess_image(k0_pil, resolution_tuple)
-        k0_pixel_tensor = self._pil_to_pixel_tensor(k0_processed_pil)
-        k0_latent = vae_manager_singleton.encode(k0_pixel_tensor)
-        generated_keyframe_paths.append(k0_path)
-        generated_keyframe_latents.append(k0_latent)
-        progress(0.01, desc="Bootstrap: Generating K1...")
-        prompt_k1 = deformes2d_thinker_singleton.get_anticipatory_keyframe_prompt(
-            global_prompt, "Initial scene.", storyboard[0], storyboard[1], k0_path, initial_ref_paths
-        )
-        k1_path, k1_latent = self._generate_next_causal_keyframe(k0_path, initial_ref_paths, prompt_k1, resolution_tuple)
-        generated_keyframe_paths.append(k1_path)
-        generated_keyframe_latents.append(k1_latent)
-        story_history = ""
-        eco_latent_for_next_loop, dejavu_latent_for_next_loop = None, None
-        num_transitions = len(storyboard) - 1
-        base_4d_ltx_params = {"rescaling_scale": 0.15, "image_cond_noise_scale": 0.00, **ltx_params}
-
-        for i in range(1, num_transitions):
-            act_progress = i / num_transitions
-            progress(act_progress, desc=f"Processing Act {i+1}/{num_transitions} (Keyframe Gen)...")
-            logger.info(f"--> Step 3D: Generating Keyframe K{i+1}")
-            kx_path = generated_keyframe_paths[i]
-            prompt_ky = deformes2d_thinker_singleton.get_anticipatory_keyframe_prompt(
-                global_prompt, story_history, storyboard[i], storyboard[i+1], kx_path, initial_ref_paths
-            )
-            ky_path, ky_latent = self._generate_next_causal_keyframe(kx_path, initial_ref_paths, prompt_ky, resolution_tuple)
-            generated_keyframe_paths.append(ky_path)
-            generated_keyframe_latents.append(ky_latent)
-            progress(act_progress, desc=f"Processing Act {i+1}/{num_transitions} (Video Gen)...")
-            logger.info(f"--> Step 4D: Generating Video Fragment V{i-1}")
-            kb_path, kx_path, ky_path = generated_keyframe_paths[i-1], generated_keyframe_paths[i], generated_keyframe_paths[i+1]
-            motion_prompt = deformes3d_thinker_singleton.get_enhanced_motion_prompt(
-                global_prompt, story_history, kb_path, kx_path, ky_path,
-                storyboard[i-1], storyboard[i], storyboard[i+1]
-            )
-            transition_type = "continuous"
-            story_history += f"\n- Act {i}: {motion_prompt}"
-            total_frames_brutos = self._quantize_to_multiple(int(seconds_per_fragment * FPS), FRAMES_PER_LATENT_CHUNK)
-            frames_a_podar = self._quantize_to_multiple(int(total_frames_brutos * (trim_percent / 100)), FRAMES_PER_LATENT_CHUNK)
-            latents_a_podar = frames_a_podar // FRAMES_PER_LATENT_CHUNK
-            DEJAVU_FRAME_TARGET = frames_a_podar - 1 if frames_a_podar > 0 else 0
-            DESTINATION_FRAME_TARGET = total_frames_brutos - 1
-            conditioning_items = []
-            if eco_latent_for_next_loop is None:
-                conditioning_items.append(LatentConditioningItem(generated_keyframe_latents[i], 0, 1.0))
-            else:
-                conditioning_items.append(LatentConditioningItem(eco_latent_for_next_loop, 0, 1.0))
-                conditioning_items.append(LatentConditioningItem(dejavu_latent_for_next_loop, DEJAVU_FRAME_TARGET, handler_strength))
-            if transition_type != "cut":
-                conditioning_items.append(LatentConditioningItem(ky_latent, DESTINATION_FRAME_TARGET, dest_strength))
-            fragment_latents_brutos, _ = ltx_manager_singleton.generate_latent_fragment(
-                height=video_resolution, width=video_resolution,
-                conditioning_items_data=conditioning_items, motion_prompt=motion_prompt,
-                video_total_frames=total_frames_brutos, video_fps=FPS, **base_4d_ltx_params
-            )
-            last_trim = fragment_latents_brutos[:, :, -(latents_a_podar+1):, :, :].clone()
-            eco_latent_for_next_loop = last_trim[:, :, :2, :, :].clone()
-            dejavu_latent_for_next_loop = last_trim[:, :, -1:, :, :].clone()
-            final_fragment_latents = fragment_latents_brutos[:, :, :-(latents_a_podar-1), :, :].clone()
-            final_fragment_latents = final_fragment_latents[:, :, 1:, :, :]
-            pixel_tensor = vae_manager_singleton.decode(final_fragment_latents)
-            fragment_path = os.path.join(temp_video_clips_dir, f"fragment_{i-1}.mp4")
-            self.save_video_from_tensor(pixel_tensor, fragment_path, fps=FPS)
-            generated_video_fragment_paths.append(fragment_path)
-            logger.info(f"Video Fragment V{i-1} saved to {fragment_path}")
-
-        logger.info("--- Final Assembly of Video Fragments ---")
-        final_video_path = os.path.join(self.workspace_dir, f"movie_7D_{run_timestamp}.mp4")
-        video_encode_tool_singleton.concatenate_videos(generated_video_fragment_paths, final_video_path, self.workspace_dir)
-        shutil.rmtree(temp_video_clips_dir)
-        logger.info(f"Full movie generated at: {final_video_path}")
-        return {"final_path": final_video_path, "all_keyframes": generated_keyframe_paths, "latent_paths": "NOT_IMPLEMENTED_YET"}
-
-    # --- POST-PRODUCTION METHODS ---
-    def task_run_latent_upscaling(self, latent_paths: list, chunk_size: int, progress: gr.Progress) -> Generator[Dict[str, any], None, None]:
-        # (código interno deste método permanece o mesmo)
-        if not latent_paths:
-            raise gr.Error("Cannot perform upscaling: no latent paths were provided from the main generation.")
-        logger.info("--- POST-PRODUCTION: Latent Upscaling ---")
-        run_timestamp = int(time.time())
-        temp_upscaled_clips_dir = os.path.join(self.workspace_dir, f"temp_upscaled_clips_{run_timestamp}")
-        os.makedirs(temp_upscaled_clips_dir, exist_ok=True)
-        final_upscaled_clip_paths = []
-        num_chunks = -(-len(latent_paths) // chunk_size)
-        for i in range(num_chunks):
-            chunk_start_index = i * chunk_size
-            chunk_end_index = chunk_start_index + chunk_size
-            chunk_paths = latent_paths[chunk_start_index:chunk_end_index]
-            progress(i / num_chunks, desc=f"Upscaling & Decoding Batch {i+1}/{num_chunks}")
-            tensors_in_chunk = [torch.load(p, map_location=self.device) for p in chunk_paths]
-            tensors_para_concatenar = [frag[:, :, :-1, :, :] if j < len(tensors_in_chunk) - 1 else frag for j, frag in enumerate(tensors_in_chunk)]
-            sub_group_latent = torch.cat(tensors_para_concatenar, dim=2)
-            del tensors_in_chunk, tensors_para_concatenar; gc.collect(); torch.cuda.empty_cache()
-            upscaled_latent_chunk = latent_enhancer_specialist_singleton.upscale(sub_group_latent)
-            del sub_group_latent; gc.collect(); torch.cuda.empty_cache()
-            pixel_tensor = vae_manager_singleton.decode(upscaled_latent_chunk)
-            del upscaled_latent_chunk; gc.collect(); torch.cuda.empty_cache()
-            base_name = f"upscaled_clip_{i:04d}_{run_timestamp}"
-            current_clip_path = os.path.join(temp_upscaled_clips_dir, f"{base_name}.mp4")
-            self.save_video_from_tensor(pixel_tensor, current_clip_path, fps=24)
-            final_upscaled_clip_paths.append(current_clip_path)
-            del pixel_tensor; gc.collect(); torch.cuda.empty_cache()
-        progress(0.98, desc="Assembling upscaled clips...")
-        final_video_path = os.path.join(self.workspace_dir, f"upscaled_movie_{run_timestamp}.mp4")
-        video_encode_tool_singleton.concatenate_videos(video_paths=final_upscaled_clip_paths, output_path=final_video_path, workspace_dir=self.workspace_dir)
-        shutil.rmtree(temp_upscaled_clips_dir)
-        logger.info(f"Latent upscaling complete! Final video at: {final_video_path}")
-        yield {"final_path": final_video_path}
-
-    def master_video_hd(self, source_video_path: str, model_version: str, steps: int, prompt: str, progress: gr.Progress):
-        # (código interno deste método permanece o mesmo)
-        logger.info(f"--- POST-PRODUCTION: HD Mastering with SeedVR {model_version} ---")
-        run_timestamp = int(time.time())
-        output_path = os.path.join(self.workspace_dir, f"{Path(source_video_path).stem}_hd.mp4")
-        try:
-            final_path = seedvr_manager_singleton.process_video(
-                input_video_path=source_video_path, output_video_path=output_path,
-                prompt=prompt, model_version=model_version, steps=steps, progress=progress
-            )
-            yield {"final_path": final_path}
-        except Exception as e:
-            logger.error(f"HD Mastering failed: {e}", exc_info=True)
-            raise gr.Error(f"HD Mastering failed. Details: {e}")
-    
-    def generate_audio(self, source_video_path: str, audio_prompt: str, progress: gr.Progress):
-        # (código interno deste método permanece o mesmo)
-        logger.info(f"--- POST-PRODUCTION: Audio Generation ---")
-        run_timestamp = int(time.time())
-        output_path = os.path.join(self.workspace_dir, f"{Path(source_video_path).stem}_audio.mp4")
-        try:
-            result = subprocess.run(
-                ["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", source_video_path],
-                capture_output=True, text=True, check=True)
-            duration = float(result.stdout.strip())
-            progress(0.5, desc="Generating audio track...")
-            final_path = mmaudio_manager_singleton.generate_audio_for_video(
-                video_path=source_video_path, prompt=audio_prompt,
-                duration_seconds=duration, output_path_override=output_path
-            )
-            yield {"final_path": final_path}
-        except Exception as e:
-            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 --->

managers/LICENSE

@@ -1,25 +0,0 @@
-# Euia-AducSdr: Uma implementação aberta e funcional da arquitetura ADUC-SDR para geração de vídeo coerente.
-# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
-#
-# Contato:
-# Carlos Rodrigues dos Santos
-# carlex22@gmail.com
-# Rua Eduardo Carlos Pereira, 4125, B1 Ap32, Curitiba, PR, Brazil, CEP 8102025
-#
-# Repositórios e Projetos Relacionados:
-# GitHub: https://github.com/carlex22/Aduc-sdr
-# Hugging Face (Ltx-SuperTime-60Secondos): https://huggingface.co/spaces/Carlexx/Ltx-SuperTime-60Secondos/
-# Hugging Face (Novinho): https://huggingface.co/spaces/Carlexxx/Novinho/
-#
-# 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/>.

managers/LICENSE.txt

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

managers/NOTICE.md

@@ -1,60 +0,0 @@
-# NOTICE
-
-Copyright (C) 2025 Carlos Rodrigues dos Santos. All rights reserved.
-
----
-
-## Aviso de Propriedade Intelectual e Licenciamento
-
-### **Processo de Patenteamento em Andamento (EM PORTUGUÊS):**
-
-O método e o sistema de orquestração de prompts denominados **ADUC (Automated Discovery and Orchestration of Complex tasks)**, conforme descritos neste documento e implementados neste software, estão atualmente em processo de patenteamento.
-
-O titular dos direitos, Carlos Rodrigues dos Santos, está buscando proteção legal para as inovações chave da arquitetura ADUC, incluindo, mas não se limitando a:
-
-*   Fragmentação e escalonamento de solicitações que excedem limites de contexto de modelos de IA.
-*   Distribuição inteligente de sub-tarefas para especialistas heterogêneos.
-*   Gerenciamento de estado persistido com avaliação iterativa e realimentação para o planejamento de próximas etapas.
-*   Planejamento e roteamento sensível a custo, latência e requisitos de qualidade.
-*   O uso de "tokens universais" para comunicação agnóstica a modelos.
-
-### **Reconhecimento e Implicações (EM PORTUGUÊS):**
-
-Ao acessar ou utilizar este software e a arquitetura ADUC aqui implementada, você reconhece:
-
-1.  A natureza inovadora e a importância da arquitetura ADUC no campo da orquestração de prompts para IA.
-2.  Que a essência desta arquitetura, ou suas implementações derivadas, podem estar sujeitas a direitos de propriedade intelectual, incluindo patentes.
-3.  Que o uso comercial, a reprodução da lógica central da ADUC em sistemas independentes, ou a exploração direta da invenção sem o devido licenciamento podem infringir os direitos de patente pendente.
-
----
-
-### **Patent Pending (IN ENGLISH):**
-
-The method and system for prompt orchestration named **ADUC (Automated Discovery and Orchestration of Complex tasks)**, as described herein and implemented in this software, are currently in the process of being patented.
-
-The rights holder, Carlos Rodrigues dos Santos, is seeking legal protection for the key innovations of the ADUC architecture, including, but not limited to:
-
-*   Fragmentation and scaling of requests exceeding AI model context limits.
-*   Intelligent distribution of sub-tasks to heterogeneous specialists.
-*   Persistent state management with iterative evaluation and feedback for planning subsequent steps.
-*   Cost, latency, and quality-aware planning and routing.
-*   The use of "universal tokens" for model-agnostic communication.
-
-### **Acknowledgement and Implications (IN ENGLISH):**
-
-By accessing or using this software and the ADUC architecture implemented herein, you acknowledge:
-
-1.  The innovative nature and significance of the ADUC architecture in the field of AI prompt orchestration.
-2.  That the essence of this architecture, or its derivative implementations, may be subject to intellectual property rights, including patents.
-3.  That commercial use, reproduction of ADUC's core logic in independent systems, or direct exploitation of the invention without proper licensing may infringe upon pending patent rights.
-
----
-
-
-**Contato para Consultas:**
-
-Para mais informações sobre a arquitetura ADUC, o status do patenteamento, ou para discutir licenciamento para usos comerciais ou não conformes com a AGPLv3, por favor, entre em contato:
-
-Carlos Rodrigues dos Santos
-carlex22@gmail.com
-Rua Eduardo Carlos Pereira, 4125, B1 Ap32, Curitiba, PR, Brazil, CEP 8102025

managers/README.md

@@ -1,156 +0,0 @@
-# 🛠️ managers/ - Ferramentas de IA de Terceiros para orquestração ADUC-SDR
-
-Esta pasta contém implementações adaptadas de modelos e utilitários de IA de terceiros, que servem como "especialistas" ou "ferramentas" de baixo nível para a arquitetura ADUC-SDR.
-
-**IMPORTANTE:** O conteúdo desta pasta é de autoria de seus respectivos idealizadores e desenvolvedores originais. Esta pasta **NÃO FAZ PARTE** do projeto principal ADUC-SDR em termos de sua arquitetura inovadora. Ela serve como um repositório para as **dependências diretas e modificadas** que os `Deformes enginers` (os estágios do "foguete" ADUC-SDR) invocam para realizar tarefas específicas (geração de imagem, vídeo, áudio).
-
-As modificações realizadas nos arquivos aqui presentes visam principalmente:
-1.  **Adaptação de Interfaces:** Padronizar as interfaces para que se encaixem no fluxo de orquestração do ADUC-SDR.
-2.  **Gerenciamento de Recursos:** Integrar lógicas de carregamento/descarregamento de modelos (GPU management) e configurações via arquivos YAML.
-3.  **Otimização de Fluxo:** Ajustar as pipelines para aceitar formatos de entrada mais eficientes (ex: tensores pré-codificados em vez de caminhos de mídia, pulando etapas de codificação/decodificação redundantes).
-
----
-
-## 📄 Licenciamento
-
-O conteúdo original dos projetos listados abaixo é licenciado sob a **Licença Apache 2.0**, ou outra licença especificada pelos autores originais. Todas as modificações e o uso desses arquivos dentro da estrutura `helpers/` do projeto ADUC-SDR estão em conformidade com os termos da **Licença Apache 2.0**.
-
-As licenças originais dos projetos podem ser encontradas nas suas respectivas fontes ou nos subdiretórios `incl_licenses/` dentro de cada módulo adaptado.
-
----
-
-## 🛠️ API dos Helpers e Guia de Uso
-
-Esta seção detalha como cada helper (agente especialista) deve ser utilizado dentro do ecossistema ADUC-SDR. Todos os agentes são instanciados como **singletons** no `hardware_manager.py` para garantir o gerenciamento centralizado de recursos de GPU.
-
-### **gemini_helpers.py (GeminiAgent)**
-
-*   **Propósito:** Atua como o "Oráculo de Síntese Adaptativo", responsável por todas as tarefas de processamento de linguagem natural, como criação de storyboards, geração de prompts, e tomada de decisões narrativas.
-*   **Singleton Instance:** `gemini_agent_singleton`
-*   **Construtor:** `GeminiAgent()`
-    *   Lê `configs/gemini_config.yaml` para obter o nome do modelo, parâmetros de inferência e caminhos de templates de prompt. A chave da API é lida da variável de ambiente `GEMINI_API_KEY`.
-*   **Métodos Públicos:**
-    *   `generate_storyboard(prompt: str, num_keyframes: int, ref_image_paths: list[str])`
-        *   **Inputs:**
-            *   `prompt`: A ideia geral do filme (string).
-            *   `num_keyframes`: O número de cenas a serem geradas (int).
-            *   `ref_image_paths`: Lista de caminhos para as imagens de referência (list[str]).
-        *   **Output:** `tuple[list[str], str]` (Uma tupla contendo a lista de strings do storyboard e um relatório textual da operação).
-    *   `select_keyframes_from_pool(storyboard: list, base_image_paths: list[str], pool_image_paths: list[str])`
-        *   **Inputs:**
-            *   `storyboard`: A lista de strings do storyboard gerado.
-            *   `base_image_paths`: Imagens de referência base (list[str]).
-            *   `pool_image_paths`: O "banco de imagens" de onde selecionar (list[str]).
-        *   **Output:** `tuple[list[str], str]` (Uma tupla contendo a lista de caminhos de imagens selecionadas e um relatório textual).
-    *   `get_anticipatory_keyframe_prompt(...)`
-        *   **Inputs:** Contexto narrativo e visual para gerar um prompt de imagem.
-        *   **Output:** `tuple[str, str]` (Uma tupla contendo o prompt gerado para o modelo de imagem e um relatório textual).
-    *   `get_initial_motion_prompt(...)`
-        *   **Inputs:** Contexto narrativo e visual para a primeira transição de vídeo.
-        *   **Output:** `tuple[str, str]` (Uma tupla contendo o prompt de movimento gerado e um relatório textual).
-    *   `get_transition_decision(...)`
-        *   **Inputs:** Contexto narrativo e visual para uma transição de vídeo intermediária.
-        *   **Output:** `tuple[dict, str]` (Uma tupla contendo um dicionário `{"transition_type": "...", "motion_prompt": "..."}` e um relatório textual).
-    *   `generate_audio_prompts(...)`
-        *   **Inputs:** Contexto narrativo global.
-        *   **Output:** `tuple[dict, str]` (Uma tupla contendo um dicionário `{"music_prompt": "...", "sfx_prompt": "..."}` e um relatório textual).
-
-### **flux_kontext_helpers.py (FluxPoolManager)**
-
-*   **Propósito:** Especialista em geração de imagens de alta qualidade (keyframes) usando a pipeline FluxKontext. Gerencia um pool de workers para otimizar o uso de múltiplas GPUs.
-*   **Singleton Instance:** `flux_kontext_singleton`
-*   **Construtor:** `FluxPoolManager(device_ids: list[str], flux_config_file: str)`
-    *   Lê `configs/flux_config.yaml`.
-*   **Método Público:**
-    *   `generate_image(prompt: str, reference_images: list[Image.Image], width: int, height: int, seed: int = 42, callback: callable = None)`
-        *   **Inputs:**
-            *   `prompt`: Prompt textual para guiar a geração (string).
-            *   `reference_images`: Lista de objetos `PIL.Image` como referência visual.
-            *   `width`, `height`: Dimensões da imagem de saída (int).
-            *   `seed`: Semente para reprodutibilidade (int).
-            *   `callback`: Função de callback opcional para monitorar o progresso.
-        *   **Output:** `PIL.Image.Image` (O objeto da imagem gerada).
-
-### **dreamo_helpers.py (DreamOAgent)**
-
-*   **Propósito:** Especialista em geração de imagens de alta qualidade (keyframes) usando a pipeline DreamO, com capacidades avançadas de edição e estilo a partir de referências.
-*   **Singleton Instance:** `dreamo_agent_singleton`
-*   **Construtor:** `DreamOAgent(device_id: str = None)`
-    *   Lê `configs/dreamo_config.yaml`.
-*   **Método Público:**
-    *   `generate_image(prompt: str, reference_images: list[Image.Image], width: int, height: int)`
-        *   **Inputs:**
-            *   `prompt`: Prompt textual para guiar a geração (string).
-            *   `reference_images`: Lista de objetos `PIL.Image` como referência visual. A lógica interna atribui a primeira imagem como `style` e as demais como `ip`.
-            *   `width`, `height`: Dimensões da imagem de saída (int).
-        *   **Output:** `PIL.Image.Image` (O objeto da imagem gerada).
-
-### **ltx_manager_helpers.py (LtxPoolManager)**
-
-*   **Propósito:** Especialista na geração de fragmentos de vídeo no espaço latente usando a pipeline LTX-Video. Gerencia um pool de workers para otimizar o uso de múltiplas GPUs.
-*   **Singleton Instance:** `ltx_manager_singleton`
-*   **Construtor:** `LtxPoolManager(device_ids: list[str], ltx_model_config_file: str, ltx_global_config_file: str)`
-    *   Lê o `ltx_global_config_file` e o `ltx_model_config_file` para configurar a pipeline.
-*   **Método Público:**
-    *   `generate_latent_fragment(**kwargs)`
-        *   **Inputs:** Dicionário de keyword arguments (`kwargs`) contendo todos os parâmetros da pipeline LTX, incluindo:
-            *   `height`, `width`: Dimensões do vídeo (int).
-            *   `video_total_frames`: Número total de frames a serem gerados (int).
-            *   `video_fps`: Frames por segundo (int).
-            *   `motion_prompt`: Prompt de movimento (string).
-            *   `conditioning_items_data`: Lista de objetos `LatentConditioningItem` contendo os tensores latentes de condição.
-            *   `guidance_scale`, `stg_scale`, `num_inference_steps`, etc.
-        *   **Output:** `tuple[torch.Tensor, tuple]` (Uma tupla contendo o tensor latente gerado e os valores de padding utilizados).
-
-### **mmaudio_helper.py (MMAudioAgent)**
-
-*   **Propósito:** Especialista em geração de áudio para um determinado fragmento de vídeo.
-*   **Singleton Instance:** `mmaudio_agent_singleton`
-*   **Construtor:** `MMAudioAgent(workspace_dir: str, device_id: str = None, mmaudio_config_file: str)`
-    *   Lê `configs/mmaudio_config.yaml`.
-*   **Método Público:**
-    *   `generate_audio_for_video(video_path: str, prompt: str, negative_prompt: str, duration_seconds: float)`
-        *   **Inputs:**
-            *   `video_path`: Caminho para o arquivo de vídeo silencioso (string).
-            *   `prompt`: Prompt textual para guiar a geração de áudio (string).
-            *   `negative_prompt`: Prompt negativo para áudio (string).
-            *   `duration_seconds`: Duração exata do vídeo (float).
-        *   **Output:** `str` (O caminho para o novo arquivo de vídeo com a faixa de áudio integrada).
-
-
-### **seedvr_helpers.py (SeedVrManager)**
-
-*   **Propósito:** Especialista em pós-produção de vídeo, aplicando super-resolução com IA (`Video Super-Resolution`) para adicionar detalhes finos, nitidez e texturas realistas a um vídeo já renderizado.
-*   **Singleton Instance:** `seedvr_manager_singleton`
-*   **Construtor:** `SeedVrManager(workspace_dir: str, device_id: str = None)`
-    *   Lê `configs/seedvr_config.yaml`.
-*   **Método Público:**
-    *   `process_video(input_video_path: str, output_video_path: str, prompt: str, model_version: str = '7B', steps: int = 100, seed: int = 666)`
-        *   **Inputs:**
-            *   `input_video_path`: Caminho para o vídeo de entrada a ser aprimorado (string).
-            *   `output_video_path`: Caminho onde o vídeo finalizado será salvo (string).
-            *   `prompt`: Um prompt de estilo geral para guiar o aprimoramento (string).
-            *   `model_version`: A versão do modelo a ser usada, '3B' ou '7B' (string).
-            *   `steps`: Número de passos de inferência para o processo de aprimoramento (int).
-            *   `seed`: Semente para reprodutibilidade (int).
-        *   **Output:** `str` (O caminho para o vídeo finalizado em alta definição).
-
----
-
-## 🔗 Projetos Originais e Atribuições
-(A seção de atribuições e licenças permanece a mesma que definimos anteriormente)
-
-### DreamO
-*   **Repositório Original:** [https://github.com/bytedance/DreamO](https://github.com/bytedance/DreamO)
-...
-
-### LTX-Video
-*   **Repositório Original:** [https://github.com/Lightricks/LTX-Video](https://github.com/Lightricks/LTX-Video)
-...
-
-### MMAudio
-*   **Repositório Original:** [https://github.com/hkchengrex/MMAudio](https://github.com/hkchengrex/MMAudio)
-...
-
-### SeedVr
-*   **Repositório Original:** [https://github.com/ByteDance-Seed/SeedVR](https://github.com/ByteDance-Seed/SeedVR)

managers/config.yaml

@@ -1,24 +0,0 @@
-# config.yaml
-# Configuração central para a aplicação Deformes4D e seus especialistas.
-
-application:
-  workspace_dir: "deformes_workspace"
-
-# Configuração para Hugging Face Spaces
-sdk: gradio
-app_file: app.py
-
-specialists:
-  flux:
-    # Define quantas GPUs o pool do Flux deve tentar alocar.
-    # Se não houver GPUs suficientes, o hardware_manager lançará um erro.
-    # Se 0, usará a CPU.
-    gpus_required: 4
-  
-  ltx:
-    # Define quantas GPUs o pool do LTX deve tentar alocar.
-    gpus_required: 4
-    
-    # Aponta para o arquivo de configuração específico do modelo LTX.
-    # Alterado para usar o modelo 0.9.8-dev.
-    config_file: "ltxv-13b-0.9.8-distilled.yaml"

managers/flux_kontext_manager.py

@@ -1,165 +0,0 @@
-# flux_kontext_helpers.py (ADUC: O Especialista Pintor - com suporte a callback)
-# AducSdr: Uma implementação aberta e funcional da arquitetura ADUC-SDR
-# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
-#
-# Contato:
-# Carlos Rodrigues dos Santos
-# carlex22@gmail.com
-# Rua Eduardo Carlos Pereira, 4125, B1 Ap32, Curitiba, PR, Brazil, CEP 8102025
-#
-# Repositórios e Projetos Relacionados:
-# GitHub: https://github.com/carlex22/Aduc-sdr
-#
-#
-# PENDING PATENT NOTICE: Please see NOTICE.md.
-#
-# Version 1.0.1
-
-import torch
-from PIL import Image, ImageOps
-import gc
-from diffusers import FluxKontextPipeline
-import huggingface_hub
-import os
-import threading
-import yaml
-import logging
-
-from tools.hardware_manager import hardware_manager
-
-logger = logging.getLogger(__name__)
-
-class FluxWorker:
-    """Representa uma única instância do pipeline FluxKontext em um dispositivo."""
-    def __init__(self, device_id='cuda:0'):
-        self.cpu_device = torch.device('cpu')
-        self.device = torch.device(device_id if torch.cuda.is_available() else 'cpu')
-        self.pipe = None
-        self._load_pipe_to_cpu()
-
-    def _load_pipe_to_cpu(self):
-        if self.pipe is None:
-            logger.info(f"FLUX Worker ({self.device}): Carregando modelo para a CPU...")
-            self.pipe = FluxKontextPipeline.from_pretrained(
-                "black-forest-labs/FLUX.1-Kontext-dev", torch_dtype=torch.bfloat16
-            ).to(self.cpu_device)
-            logger.info(f"FLUX Worker ({self.device}): Modelo pronto na CPU.")
-
-    def to_gpu(self):
-        if self.device.type == 'cpu': return
-        logger.info(f"FLUX Worker: Movendo modelo para a GPU {self.device}...")
-        self.pipe.to(self.device)
-
-    def to_cpu(self):
-        if self.device.type == 'cpu': return
-        logger.info(f"FLUX Worker: Descarregando modelo da GPU {self.device}...")
-        self.pipe.to(self.cpu_device)
-        gc.collect()
-        if torch.cuda.is_available(): torch.cuda.empty_cache()
-
-    def _create_composite_reference(self, images: list[Image.Image], target_width: int, target_height: int) -> Image.Image:
-        if not images: return None
-        valid_images = [img.convert("RGB") for img in images if img is not None]
-        if not valid_images: return None
-        if len(valid_images) == 1:
-            if valid_images[0].size != (target_width, target_height):
-                return ImageOps.fit(valid_images[0], (target_width, target_height), Image.Resampling.LANCZOS)
-            return valid_images[0]
-
-        base_height = valid_images[0].height
-        resized_for_concat = []
-        for img in valid_images:
-            if img.height != base_height:
-                aspect_ratio = img.width / img.height
-                new_width = int(base_height * aspect_ratio)
-                resized_for_concat.append(img.resize((new_width, base_height), Image.Resampling.LANCZOS))
-            else:
-                resized_for_concat.append(img)
-        
-        total_width = sum(img.width for img in resized_for_concat)
-        concatenated = Image.new('RGB', (total_width, base_height))
-        x_offset = 0
-        for img in resized_for_concat:
-            concatenated.paste(img, (x_offset, 0))
-            x_offset += img.width
-            
-        #final_reference = ImageOps.fit(concatenated, (target_width, target_height), Image.Resampling.LANCZOS)
-        return concatenated
-
-    @torch.inference_mode()
-    def generate_image_internal(self, reference_images: list[Image.Image], prompt: str, target_width: int, target_height: int, seed: int, callback: callable = None):
-        composite_reference = self._create_composite_reference(reference_images, target_width, target_height)
-        
-        num_steps = 12 # Valor fixo otimizado
-
-        logger.info(f"\n===== [CHAMADA AO PIPELINE FLUX em {self.device}] =====\n"
-                    f"  - Prompt: '{prompt}'\n"
-                    f"  - Resolução: {target_width}x{target_height}, Seed: {seed}, Passos: {num_steps}\n"
-                    f"  - Nº de Imagens na Composição: {len(reference_images)}\n"
-                    f"==========================================")
-        
-        generated_image = self.pipe(
-            image=composite_reference, 
-            prompt=prompt, 
-            guidance_scale=2.5, 
-            width=target_width,
-            height=target_height,
-            num_inference_steps=num_steps,
-            generator=torch.Generator(device="cpu").manual_seed(seed),
-            callback_on_step_end=callback,
-            callback_on_step_end_tensor_inputs=["latents"] if callback else None
-        ).images[0]
-        
-        return generated_image
-
-class FluxPoolManager:
-    def __init__(self, device_ids):
-        logger.info(f"FLUX POOL MANAGER: Criando workers para os dispositivos: {device_ids}")
-        self.workers = [FluxWorker(device_id) for device_id in device_ids]
-        self.current_worker_index = 0
-        self.lock = threading.Lock()
-        self.last_cleanup_thread = None
-
-    def _cleanup_worker_thread(self, worker):
-        logger.info(f"FLUX CLEANUP THREAD: Iniciando limpeza de {worker.device} em background...")
-        worker.to_cpu()
-
-    def generate_image(self, reference_images, prompt, width, height, seed=42, callback=None):
-        worker_to_use = None
-        try:
-            with self.lock:
-                if self.last_cleanup_thread and self.last_cleanup_thread.is_alive():
-                    self.last_cleanup_thread.join()
-                worker_to_use = self.workers[self.current_worker_index]
-                previous_worker_index = (self.current_worker_index - 1 + len(self.workers)) % len(self.workers)
-                worker_to_cleanup = self.workers[previous_worker_index]
-                cleanup_thread = threading.Thread(target=self._cleanup_worker_thread, args=(worker_to_cleanup,))
-                cleanup_thread.start()
-                self.last_cleanup_thread = cleanup_thread
-                worker_to_use.to_gpu()
-                self.current_worker_index = (self.current_worker_index + 1) % len(self.workers)
-            
-            logger.info(f"FLUX POOL MANAGER: Gerando imagem em {worker_to_use.device}...")
-            return worker_to_use.generate_image_internal(
-                reference_images=reference_images,
-                prompt=prompt,
-                target_width=width,
-                target_height=height,
-                seed=seed,
-                callback=callback
-            )
-        except Exception as e:
-            logger.error(f"FLUX POOL MANAGER: Erro durante a geração: {e}", exc_info=True)
-            raise e
-        finally:
-            pass
-
-# --- Instanciação Singleton Dinâmica ---
-logger.info("Lendo config.yaml para inicializar o FluxKontext Pool Manager...")
-with open("config.yaml", 'r') as f: config = yaml.safe_load(f)
-hf_token = os.getenv('HF_TOKEN'); 
-if hf_token: huggingface_hub.login(token=hf_token)
-flux_gpus_required = config['specialists']['flux']['gpus_required']
-flux_device_ids = hardware_manager.allocate_gpus('Flux', flux_gpus_required)
-flux_kontext_singleton = FluxPoolManager(device_ids=flux_device_ids)
-logger.info("Especialista de Imagem (Flux) pronto.")

managers/gemini_manager.py

@@ -1,119 +0,0 @@
-# managers/gemini_manager.py
-# AducSdr: Uma implementação aberta e funcional da arquitetura ADUC-SDR
-# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
-#
-# Contato:
-# Carlos Rodrigues dos Santos
-# carlex22@gmail.com
-# Rua Eduardo Carlos Pereira, 4125, B1 Ap32, Curitiba, PR, Brazil, CEP 8102025
-#
-# Repositórios e Projetos Relacionados:
-# GitHub: https://github.com/carlex22/Aduc-sdr
-#
-# PENDING PATENT NOTICE: Please see NOTICE.md.
-#
-# Version: 1.1.1
-#
-# This file defines the GeminiManager, a specialist responsible for raw communication
-# with the Google Gemini API. It acts as a lean API client, handling requests,
-# parsing responses, and managing API-level errors. It does not contain any
-# high-level prompt engineering or creative logic.
-
-import os
-import logging
-import json
-from pathlib import Path
-import gradio as gr
-from PIL import Image
-import google.generativeai as genai
-import re
-from typing import List, Union, Any
-
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
-
-def robust_json_parser(raw_text: str) -> dict:
-    """
-    Parses a JSON object from a string that might contain extra text,
-    such as Markdown code blocks from an LLM's response.
-    """
-    clean_text = raw_text.strip()
-    try:
-        match = re.search(r'```json\s*(\{.*?\})\s*```', clean_text, re.DOTALL)
-        if match:
-            json_str = match.group(1)
-            return json.loads(json_str)
-        
-        start_index = clean_text.find('{')
-        end_index = clean_text.rfind('}')
-        if start_index != -1 and end_index != -1 and end_index > start_index:
-            json_str = clean_text[start_index : end_index + 1]
-            return json.loads(json_str)
-        else:
-            raise ValueError("No valid JSON object could be found in the AI's response.")
-    except json.JSONDecodeError as e:
-        logger.error(f"Failed to decode JSON. The AI returned the following text:\n---\n{raw_text}\n---")
-        raise ValueError(f"The AI returned an invalid JSON format: {e}")
-
-class GeminiManager:
-    """
-    Manages raw interactions with the Google Gemini API.
-    """
-    def __init__(self):
-        self.api_key = os.environ.get("GEMINI_API_KEY")
-        if self.api_key:
-            genai.configure(api_key=self.api_key)
-            self.model = genai.GenerativeModel('gemini-2.5-flash') 
-            logger.info("GeminiManager (Communication Layer) initialized successfully.")
-        else:
-            self.model = None
-            logger.warning("Gemini API key not found. GeminiManager disabled.")
-            
-    def _check_model(self):
-        """Raises an error if the Gemini API is not configured."""
-        if not self.model:
-            raise gr.Error("The Google Gemini API key is not configured (GEMINI_API_KEY).")
-
-    def _generate_content(self, prompt_parts: List[Any]) -> str:
-        """Internal method to make the API call."""
-        self._check_model()
-        logger.info("Calling Gemini API...")
-        response = self.model.generate_content(prompt_parts)
-        logger.info(f"Gemini responded with raw text: {response.text}")
-        return response.text
-
-    def get_raw_text(self, prompt_parts: List[Any]) -> str:
-        """
-        Sends a prompt to the Gemini API and returns the raw text response.
-
-        Args:
-            prompt_parts (List[Any]): A list containing strings and/or PIL.Image objects.
-
-        Returns:
-            str: The raw string response from the API.
-        """
-        try:
-            return self._generate_content(prompt_parts)
-        except Exception as e:
-            logger.error(f"Gemini API call failed: {e}", exc_info=True)
-            raise gr.Error(f"Gemini API communication failed: {e}")
-
-    def get_json_object(self, prompt_parts: List[Any]) -> dict:
-        """
-        Sends a prompt to the Gemini API, expects a JSON response, parses it, and returns a dictionary.
-
-        Args:
-            prompt_parts (List[Any]): A list containing strings and/or PIL.Image objects.
-
-        Returns:
-            dict: The parsed JSON object from the API response.
-        """
-        try:
-            raw_response = self._generate_content(prompt_parts)
-            return robust_json_parser(raw_response)
-        except Exception as e:
-            logger.error(f"Gemini API call or JSON parsing failed: {e}", exc_info=True)
-            raise gr.Error(f"Gemini API communication or response parsing failed: {e}")
-
-# --- Singleton Instance ---
-gemini_manager_singleton = GeminiManager()

managers/latent_enhancer_manager.py

@@ -1,109 +0,0 @@
-# latent_enhancer_specialist.py
-# AducSdr: Uma implementação aberta e funcional da arquitetura ADUC-SDR
-# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
-#
-# Contato:
-# Carlos Rodrigues dos Santos
-# carlex22@gmail.com
-# Rua Eduardo Carlos Pereira, 4125, B1 Ap32, Curitiba, PR, Brazil, CEP 8102025
-#
-# Repositórios e Projetos Relacionados:
-# GitHub: https://github.com/carlex22/Aduc-sdr
-#
-#
-# PENDING PATENT NOTICE: Please see NOTICE.md.
-#
-# Version 1.0.1
-
-import torch
-import logging
-import time
-from diffusers import LTXLatentUpsamplePipeline
-from managers.ltx_manager import ltx_manager_singleton
-
-logger = logging.getLogger(__name__)
-
-class LatentEnhancerSpecialist:
-    """
-    Especialista responsável por melhorar a qualidade de tensores latentes,
-    incluindo upscaling espacial e refinamento por denoise.
-    """
-    def __init__(self):
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        self.pipe_upsample = None
-        self.base_vae = None # VAE para o upscaler
-
-    def _lazy_init_upscaler(self):
-        """Inicializa a pipeline de upscaling apenas quando for usada."""
-        if self.pipe_upsample is not None:
-            return
-        try:
-            from diffusers.models.autoencoders import AutoencoderKLLTXVideo
-            self.base_vae = AutoencoderKLLTXVideo.from_pretrained(
-                "linoyts/LTX-Video-spatial-upscaler-0.9.8",
-                subfolder="vae",
-                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
-            ).to(self.device)
-
-            self.pipe_upsample = LTXLatentUpsamplePipeline.from_pretrained(
-                "linoyts/LTX-Video-spatial-upscaler-0.9.8",
-                vae=self.base_vae,
-                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
-            ).to(self.device)
-            logger.info("[Enhancer] Pipeline de Upscale carregada com sucesso.")
-        except Exception as e:
-            logger.error(f"[Enhancer] Falha ao carregar pipeline de Upscale: {e}")
-            self.pipe_upsample = None
-
-    @torch.no_grad()
-    def upscale(self, latents: torch.Tensor) -> torch.Tensor:
-        """Aplica o upscaling 2x nos tensores latentes fornecidos."""
-        self._lazy_init_upscaler()
-        if self.pipe_upsample is None:
-            logger.warning("[Enhancer] Pipeline de Upscale indisponível. Retornando latentes originais.")
-            return latents
-        try:
-            logger.info(f"[Enhancer] Recebido shape {latents.shape} para Upscale.")
-            result = self.pipe_upsample(latents=latents, output_type="latent")
-            output_tensor = result.frames
-            logger.info(f"[Enhancer] Upscale concluído. Novo shape: {output_tensor.shape}")
-            return output_tensor
-        except Exception as e:
-            logger.error(f"[Enhancer] Erro durante upscale: {e}", exc_info=True)
-            return latents
-
-    @torch.no_grad()
-    def refine(self, latents: torch.Tensor, fps: int = 24, **kwargs) -> torch.Tensor:
-        """
-        Invoca o LTX Pool Manager para refinar um tensor latente existente.
-        """
-        logger.info(f"[Enhancer] Refinando tensor latente com shape {latents.shape}.")
-        
-        main_pipeline_vae = ltx_manager_singleton.workers[0].pipeline.vae
-        video_scale_factor = getattr(main_pipeline_vae.config, 'temporal_scale_factor', 8)
-        
-        _, _, num_latent_frames, _, _ = latents.shape
-        
-        # --- [CORREÇÃO FINAL E CRÍTICA] ---
-        # A pipeline de refinamento (vid2vid) espera o número de frames de pixels que CORRESPONDE
-        # ao latente existente, SEM a lógica do +1 que ela aplicará internamente.
-        pixel_frames = (num_latent_frames - 1) * video_scale_factor
-
-        final_ltx_params = {
-            "video_total_frames": pixel_frames,
-            "video_fps": fps,
-            "current_fragment_index": int(time.time()),
-            **kwargs
-        }
-        
-        refined_latents_tensor, _ = ltx_manager_singleton.refine_latents(latents, **final_ltx_params)
-        
-        if refined_latents_tensor is None:
-            logger.warning("[Enhancer] O refinamento falhou. Retornando tensor original não refinado.")
-            return latents
-        
-        logger.info(f"[Enhancer] Retornando tensor latente refinado com shape: {refined_latents_tensor.shape}")
-        return refined_latents_tensor
-
-# --- Singleton Global ---
-latent_enhancer_specialist_singleton = LatentEnhancerSpecialist()

managers/ltx_manager.py

@@ -1,320 +0,0 @@
-# managers/ltx_manager.py
-# AducSdr: Uma implementação aberta e funcional da arquitetura ADUC-SDR
-# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
-#
-# Contato:
-# Carlos Rodrigues dos Santos
-# carlex22@gmail.com
-# Rua Eduardo Carlos Pereira, 4125, B1 Ap32, Curitiba, PR, Brazil, CEP 8102025
-#
-# PENDING PATENT NOTICE: Please see NOTICE.md.
-#
-# Version: 2.3.0
-#
-# This version adds a public property `prompt_enhancement_pipeline` to the manager.
-# This allows other specialists, specifically the Deformes3DThinker, to access
-# the internal prompt refinement models (captioning and LLM) used by the LTX pipeline,
-# ensuring stylistic and logical consistency.
-
-import torch
-import gc
-import os
-import sys
-import yaml
-import logging
-import huggingface_hub
-import time
-import threading
-import subprocess
-from pathlib import Path
-from typing import Optional, List, Tuple, Union
-
-from tools.optimization import optimize_ltx_worker, can_optimize_fp8
-from tools.hardware_manager import hardware_manager
-from aduc_types import LatentConditioningItem
-
-logger = logging.getLogger(__name__)
-
-# --- Dependency Management ---
-DEPS_DIR = Path("./deps")
-LTX_VIDEO_REPO_DIR = DEPS_DIR / "LTX-Video"
-LTX_VIDEO_REPO_URL = "https://github.com/Lightricks/LTX-Video.git"
-
-# --- Placeholders for lazy-loaded modules ---
-create_ltx_video_pipeline = None
-calculate_padding = None
-LTXVideoPipeline = None
-ConditioningItem = None
-LTXMultiScalePipeline = None
-vae_encode = None
-latent_to_pixel_coords = None
-randn_tensor = None
-
-class LtxPoolManager:
-    """
-    Manages a pool of LtxWorkers and exposes the enhancement pipeline for other specialists.
-    """
-    def __init__(self, device_ids, ltx_config_file_name):
-        logger.info(f"LTX POOL MANAGER: Creating workers for devices: {device_ids}")
-        self._ltx_modules_loaded = False
-        self._setup_dependencies()
-        self._lazy_load_ltx_modules()
-
-        self.ltx_config_file = LTX_VIDEO_REPO_DIR / "configs" / ltx_config_file_name
-
-        self.workers = [LtxWorker(dev_id, self.ltx_config_file) for dev_id in device_ids]
-        self.current_worker_index = 0
-        self.lock = threading.Lock()
-
-        # <--- NOVA PROPRIEDADE PARA O DEFORMES3DTHINKER USAR --->
-        # Expõe a pipeline do primeiro worker. Assumimos que todas são configuradas
-        # da mesma forma e contêm os mesmos modelos de enhancement.
-        self.prompt_enhancement_pipeline = self.workers[0].pipeline if self.workers else None
-        if self.prompt_enhancement_pipeline:
-            logger.info("LTX POOL MANAGER: Prompt enhancement pipeline exposed for other specialists.")
-        # <--- FIM DA NOVA PROPRIEDADE --->
-
-        self._apply_ltx_pipeline_patches()
-
-        if all(w.device.type == 'cuda' for w in self.workers):
-            logger.info("LTX POOL MANAGER: HOT START MODE ENABLED. Pre-warming all GPUs...")
-            for worker in self.workers:
-                worker.to_gpu()
-            logger.info("LTX POOL MANAGER: All GPUs are hot and ready.")
-        else:
-            logger.info("LTX POOL MANAGER: Operating in CPU or mixed mode. GPU pre-warming skipped.")
-
-    # ... (O resto da classe LtxPoolManager, como _setup_dependencies, generate_latent_fragment, etc., permanece exatamente o mesmo) ...
-
-    def _setup_dependencies(self):
-        """Clones the LTX-Video repo if not found and adds it to the system path."""
-        if not LTX_VIDEO_REPO_DIR.exists():
-            logger.info(f"LTX-Video repository not found at '{LTX_VIDEO_REPO_DIR}'. Cloning from GitHub...")
-            try:
-                DEPS_DIR.mkdir(exist_ok=True)
-                subprocess.run(
-                    ["git", "clone", LTX_VIDEO_REPO_URL, str(LTX_VIDEO_REPO_DIR)],
-                    check=True, capture_output=True, text=True
-                )
-                logger.info("LTX-Video repository cloned successfully.")
-            except subprocess.CalledProcessError as e:
-                logger.error(f"Failed to clone LTX-Video repository. Git stderr: {e.stderr}")
-                raise RuntimeError("Could not clone the required LTX-Video dependency from GitHub.")
-        else:
-            logger.info("Found local LTX-Video repository.")
-
-        if str(LTX_VIDEO_REPO_DIR.resolve()) not in sys.path:
-            sys.path.insert(0, str(LTX_VIDEO_REPO_DIR.resolve()))
-            logger.info(f"Added '{LTX_VIDEO_REPO_DIR.resolve()}' to sys.path.")
-    
-    def _lazy_load_ltx_modules(self):
-        """Dynamically imports LTX-Video modules after ensuring the repo exists."""
-        if self._ltx_modules_loaded:
-            return
-
-        global create_ltx_video_pipeline, calculate_padding, LTXVideoPipeline, ConditioningItem, LTXMultiScalePipeline
-        global vae_encode, latent_to_pixel_coords, randn_tensor
-        
-        from managers.ltx_pipeline_utils import create_ltx_video_pipeline, calculate_padding
-        from ltx_video.pipelines.pipeline_ltx_video import LTXVideoPipeline, ConditioningItem, LTXMultiScalePipeline
-        from ltx_video.models.autoencoders.vae_encode import vae_encode, latent_to_pixel_coords
-        from diffusers.utils.torch_utils import randn_tensor
-        
-        self._ltx_modules_loaded = True
-        logger.info("LTX-Video modules have been dynamically loaded.")
-
-    def _apply_ltx_pipeline_patches(self):
-        """Applies runtime patches to the LTX pipeline for ADUC-SDR compatibility."""
-        logger.info("LTX POOL MANAGER: Applying ADUC-SDR patches to LTX pipeline...")
-        for worker in self.workers:
-            worker.pipeline.prepare_conditioning = _aduc_prepare_conditioning_patch.__get__(worker.pipeline, LTXVideoPipeline)
-        logger.info("LTX POOL MANAGER: All pipeline instances have been patched successfully.")
-
-    def _get_next_worker(self):
-        with self.lock:
-            worker = self.workers[self.current_worker_index]
-            self.current_worker_index = (self.current_worker_index + 1) % len(self.workers)
-            return worker
-    
-    def _prepare_pipeline_params(self, worker: 'LtxWorker', **kwargs) -> dict:
-        pipeline_params = {
-            "height": kwargs['height'], "width": kwargs['width'], "num_frames": kwargs['video_total_frames'],
-            "frame_rate": kwargs.get('video_fps', 24),
-            "generator": torch.Generator(device=worker.device).manual_seed(int(time.time()) + kwargs.get('current_fragment_index', 0)),
-            "is_video": True, "vae_per_channel_normalize": True,
-            "prompt": kwargs.get('motion_prompt', ""), "negative_prompt": kwargs.get('negative_prompt', "blurry, distorted, static, bad quality"),
-            "guidance_scale": kwargs.get('guidance_scale', 1.0), "stg_scale": kwargs.get('stg_scale', 0.0),
-            "rescaling_scale": kwargs.get('rescaling_scale', 0.15), "num_inference_steps": kwargs.get('num_inference_steps', 20),
-            "output_type": "latent"
-        }
-        if 'latents' in kwargs:
-            pipeline_params["latents"] = kwargs['latents'].to(worker.device, dtype=worker.pipeline.transformer.dtype)
-        if 'strength' in kwargs:
-            pipeline_params["strength"] = kwargs['strength']
-        if 'conditioning_items_data' in kwargs:
-            final_conditioning_items = []
-            for item in kwargs['conditioning_items_data']:
-                item.latent_tensor = item.latent_tensor.to(worker.device)
-                final_conditioning_items.append(item)
-            pipeline_params["conditioning_items"] = final_conditioning_items
-        if worker.is_distilled:
-            logger.info(f"Worker {worker.device} is using a distilled model. Using fixed timesteps.")
-            fixed_timesteps = worker.config.get("first_pass", {}).get("timesteps")
-            pipeline_params["timesteps"] = fixed_timesteps
-            if fixed_timesteps:
-                pipeline_params["num_inference_steps"] = len(fixed_timesteps)
-        return pipeline_params
-
-    def generate_latent_fragment(self, **kwargs) -> (torch.Tensor, tuple):
-        worker_to_use = self._get_next_worker()
-        try:
-            height, width = kwargs['height'], kwargs['width']
-            padded_h, padded_w = ((height - 1) // 32 + 1) * 32, ((width - 1) // 32 + 1) * 32
-            padding_vals = calculate_padding(height, width, padded_h, padded_w)
-            kwargs['height'], kwargs['width'] = padded_h, padded_w
-            pipeline_params = self._prepare_pipeline_params(worker_to_use, **kwargs)
-            logger.info(f"Initiating GENERATION on {worker_to_use.device} with shape {padded_w}x{padded_h}")
-            if isinstance(worker_to_use.pipeline, LTXMultiScalePipeline):
-                result = worker_to_use.pipeline.video_pipeline(**pipeline_params).images
-            else:
-                result = worker_to_use.generate_video_fragment_internal(**pipeline_params)
-            return result, padding_vals
-        except Exception as e:
-            logger.error(f"LTX POOL MANAGER: Error during generation on {worker_to_use.device}: {e}", exc_info=True)
-            raise e
-        finally:
-            if worker_to_use and worker_to_use.device.type == 'cuda':
-                with torch.cuda.device(worker_to_use.device):
-                    gc.collect(); torch.cuda.empty_cache()
-
-    def refine_latents(self, latents_to_refine: torch.Tensor, **kwargs) -> (torch.Tensor, tuple):
-        pass
-
-# ... (O resto do arquivo: LtxWorker, _aduc_prepare_conditioning_patch, Singleton Instantiation, etc. permanece idêntico) ...
-class LtxWorker:
-    """
-    Represents a single instance of the LTX-Video pipeline on a specific device.
-    """
-    def __init__(self, device_id, ltx_config_file):
-        self.cpu_device = torch.device('cpu')
-        self.device = torch.device(device_id if torch.cuda.is_available() else 'cpu')
-        logger.info(f"LTX Worker ({self.device}): Initializing with config '{ltx_config_file}'...")
-        
-        with open(ltx_config_file, "r") as file:
-            self.config = yaml.safe_load(file)
-        
-        self.is_distilled = "distilled" in self.config.get("checkpoint_path", "")
-
-        models_dir = LTX_VIDEO_REPO_DIR / "models_downloaded"
-        
-        logger.info(f"LTX Worker ({self.device}): Preparing to load model...")
-        model_filename = self.config["checkpoint_path"]
-        model_path = huggingface_hub.hf_hub_download(
-            repo_id="Lightricks/LTX-Video", filename=model_filename,
-            local_dir=str(models_dir), local_dir_use_symlinks=False
-        )
-        
-        self.pipeline = create_ltx_video_pipeline(
-            ckpt_path=model_path, 
-            precision=self.config["precision"],
-            text_encoder_model_name_or_path=self.config["text_encoder_model_name_or_path"],
-            sampler=self.config["sampler"], 
-            device='cpu'
-        )
-        logger.info(f"LTX Worker ({self.device}): Model ready on CPU. Is distilled model? {self.is_distilled}")
-    
-    def to_gpu(self):
-        if self.device.type == 'cpu': return
-        logger.info(f"LTX Worker: Moving pipeline to GPU {self.device}...")
-        self.pipeline.to(self.device)
-        if self.device.type == 'cuda' and can_optimize_fp8():
-            logger.info(f"LTX Worker ({self.device}): FP8 supported GPU detected. Optimizing...")
-            optimize_ltx_worker(self)
-            logger.info(f"LTX Worker ({self.device}): Optimization complete.")
-        elif self.device.type == 'cuda':
-            logger.info(f"LTX Worker ({self.device}): FP8 optimization not supported or disabled.")
-
-    def to_cpu(self):
-        if self.device.type == 'cpu': return
-        logger.info(f"LTX Worker: Unloading pipeline from GPU {self.device}...")
-        self.pipeline.to('cpu')
-        gc.collect()
-        if torch.cuda.is_available(): torch.cuda.empty_cache()
-
-    def generate_video_fragment_internal(self, **kwargs):
-        return self.pipeline(**kwargs).images
-
-
-def _aduc_prepare_conditioning_patch(
-    self: LTXVideoPipeline,
-    conditioning_items: Optional[List[Union[ConditioningItem, "LatentConditioningItem"]]],
-    init_latents: torch.Tensor,
-    num_frames: int,
-    height: int,
-    width: int,
-    vae_per_channel_normalize: bool = False,
-    generator=None,
-) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, int]:
-    if not conditioning_items:
-        init_latents, init_latent_coords = self.patchifier.patchify(latents=init_latents)
-        init_pixel_coords = latent_to_pixel_coords(init_latent_coords, self.vae, causal_fix=self.transformer.config.causal_temporal_positioning)
-        return init_latents, init_pixel_coords, None, 0
-    init_conditioning_mask = torch.zeros(init_latents[:, 0, :, :, :].shape, dtype=torch.float32, device=init_latents.device)
-    extra_conditioning_latents, extra_conditioning_pixel_coords, extra_conditioning_mask = [], [], []
-    extra_conditioning_num_latents = 0
-    is_latent_mode = hasattr(conditioning_items[0], 'latent_tensor')
-    if is_latent_mode:
-        for item in conditioning_items:
-            media_item_latents = item.latent_tensor.to(dtype=init_latents.dtype, device=init_latents.device)
-            media_frame_number, strength = item.media_frame_number, item.conditioning_strength
-            if media_frame_number == 0:
-                f_l, h_l, w_l = media_item_latents.shape[-3:]
-                init_latents[:, :, :f_l, :h_l, :w_l] = torch.lerp(init_latents[:, :, :f_l, :h_l, :w_l], media_item_latents, strength)
-                init_conditioning_mask[:, :f_l, :h_l, :w_l] = strength
-            else:
-                noise = randn_tensor(media_item_latents.shape, generator=generator, device=media_item_latents.device, dtype=media_item_latents.dtype)
-                media_item_latents = torch.lerp(noise, media_item_latents, strength)
-                patched_latents, latent_coords = self.patchifier.patchify(latents=media_item_latents)
-                pixel_coords = latent_to_pixel_coords(latent_coords, self.vae, causal_fix=self.transformer.config.causal_temporal_positioning)
-                pixel_coords[:, 0] += media_frame_number
-                extra_conditioning_num_latents += patched_latents.shape[1]
-                new_mask = torch.full(patched_latents.shape[:2], strength, dtype=torch.float32, device=init_latents.device)
-                extra_conditioning_latents.append(patched_latents)
-                extra_conditioning_pixel_coords.append(pixel_coords)
-                extra_conditioning_mask.append(new_mask)
-    else:
-        for item in conditioning_items:
-            if not isinstance(item, ConditioningItem): continue
-            item = self._resize_conditioning_item(item, height, width)
-            media_item_latents = vae_encode(item.media_item.to(dtype=self.vae.dtype, device=self.vae.device), self.vae, vae_per_channel_normalize=vae_per_channel_normalize).to(dtype=init_latents.dtype)
-            if item.media_frame_number == 0:
-                media_item_latents, l_x, l_y = self._get_latent_spatial_position(media_item_latents, item, height, width, strip_latent_border=True)
-                f_l, h_l, w_l = media_item_latents.shape[-3:]
-                init_latents[:, :, :f_l, l_y:l_y+h_l, l_x:l_x+w_l] = torch.lerp(init_latents[:, :, :f_l, l_y:l_y+h_l, l_x:l_x+w_l], media_item_latents, item.conditioning_strength)
-                init_conditioning_mask[:, :f_l, l_y:l_y+h_l, l_x:l_x+w_l] = item.conditioning_strength
-            else:
-                logger.warning("Pixel-based conditioning for non-zero frames is not fully implemented in this patch.")
-    
-    init_latents, init_latent_coords = self.patchifier.patchify(latents=init_latents)
-    init_pixel_coords = latent_to_pixel_coords(init_latent_coords, self.vae, causal_fix=self.transformer.config.causal_temporal_positioning)
-    init_conditioning_mask, _ = self.patchifier.patchify(latents=init_conditioning_mask.unsqueeze(1))
-    init_conditioning_mask = init_conditioning_mask.squeeze(-1)
-    if extra_conditioning_latents:
-        init_latents = torch.cat([*extra_conditioning_latents, init_latents], dim=1)
-        init_pixel_coords = torch.cat([*extra_conditioning_pixel_coords, init_pixel_coords], dim=2)
-        init_conditioning_mask = torch.cat([*extra_conditioning_mask, init_conditioning_mask], dim=1)
-        if self.transformer.use_tpu_flash_attention:
-            init_latents = init_latents[:, :-extra_conditioning_num_latents]
-            init_pixel_coords = init_pixel_coords[:, :, :-extra_conditioning_num_latents]
-            init_conditioning_mask = init_conditioning_mask[:, :-extra_conditioning_num_latents]
-    return init_latents, init_pixel_coords, init_conditioning_mask, extra_conditioning_num_latents
-
-
-# --- Singleton Instantiation ---
-with open("config.yaml", 'r') as f:
-    config = yaml.safe_load(f)
-ltx_gpus_required = config['specialists']['ltx']['gpus_required']
-ltx_device_ids = hardware_manager.allocate_gpus('LTX', ltx_gpus_required)
-ltx_config_filename = config['specialists']['ltx']['config_file']
-ltx_manager_singleton = LtxPoolManager(device_ids=ltx_device_ids, ltx_config_file_name=ltx_config_filename)
-logger.info("Video Specialist (LTX) ready.")

managers/ltx_pipeline_utils.py

@@ -1,774 +0,0 @@
-import argparse
-import os
-import random
-from datetime import datetime
-from pathlib import Path
-from diffusers.utils import logging
-from typing import Optional, List, Union
-import yaml
-
-import imageio
-import json
-import numpy as np
-import torch
-import cv2
-from safetensors import safe_open
-from PIL import Image
-from transformers import (
-    T5EncoderModel,
-    T5Tokenizer,
-    AutoModelForCausalLM,
-    AutoProcessor,
-    AutoTokenizer,
-)
-from huggingface_hub import hf_hub_download
-
-from ltx_video.models.autoencoders.causal_video_autoencoder import (
-    CausalVideoAutoencoder,
-)
-from ltx_video.models.transformers.symmetric_patchifier import SymmetricPatchifier
-from ltx_video.models.transformers.transformer3d import Transformer3DModel
-from ltx_video.pipelines.pipeline_ltx_video import (
-    ConditioningItem,
-    LTXVideoPipeline,
-    LTXMultiScalePipeline,
-)
-from ltx_video.schedulers.rf import RectifiedFlowScheduler
-from ltx_video.utils.skip_layer_strategy import SkipLayerStrategy
-from ltx_video.models.autoencoders.latent_upsampler import LatentUpsampler
-import ltx_video.pipelines.crf_compressor as crf_compressor
-
-MAX_HEIGHT = 720
-MAX_WIDTH = 1280
-MAX_NUM_FRAMES = 257
-
-logger = logging.get_logger("LTX-Video")
-
-
-def get_total_gpu_memory():
-    if torch.cuda.is_available():
-        total_memory = torch.cuda.get_device_properties(0).total_memory / (1024**3)
-        return total_memory
-    return 44
-
-
-def get_device():
-    if torch.cuda.is_available():
-        return "cuda"
-    elif torch.backends.mps.is_available():
-        return "mps"
-    return "cuda"
-
-
-def load_image_to_tensor_with_resize_and_crop(
-    image_input: Union[str, Image.Image],
-    target_height: int = 512,
-    target_width: int = 768,
-    just_crop: bool = False,
-) -> torch.Tensor:
-    """Load and process an image into a tensor.
-
-    Args:
-        image_input: Either a file path (str) or a PIL Image object
-        target_height: Desired height of output tensor
-        target_width: Desired width of output tensor
-        just_crop: If True, only crop the image to the target size without resizing
-    """
-    if isinstance(image_input, str):
-        image = Image.open(image_input).convert("RGB")
-    elif isinstance(image_input, Image.Image):
-        image = image_input
-    else:
-        raise ValueError("image_input must be either a file path or a PIL Image object")
-
-    input_width, input_height = image.size
-    aspect_ratio_target = target_width / target_height
-    aspect_ratio_frame = input_width / input_height
-    if aspect_ratio_frame > aspect_ratio_target:
-        new_width = int(input_height * aspect_ratio_target)
-        new_height = input_height
-        x_start = (input_width - new_width) // 2
-        y_start = 0
-    else:
-        new_width = input_width
-        new_height = int(input_width / aspect_ratio_target)
-        x_start = 0
-        y_start = (input_height - new_height) // 2
-
-    image = image.crop((x_start, y_start, x_start + new_width, y_start + new_height))
-    if not just_crop:
-        image = image.resize((target_width, target_height))
-
-    image = np.array(image)
-    image = cv2.GaussianBlur(image, (3, 3), 0)
-    frame_tensor = torch.from_numpy(image).float()
-    frame_tensor = crf_compressor.compress(frame_tensor / 255.0) * 255.0
-    frame_tensor = frame_tensor.permute(2, 0, 1)
-    frame_tensor = (frame_tensor / 127.5) - 1.0
-    # Create 5D tensor: (batch_size=1, channels=3, num_frames=1, height, width)
-    return frame_tensor.unsqueeze(0).unsqueeze(2)
-
-
-def calculate_padding(
-    source_height: int, source_width: int, target_height: int, target_width: int
-) -> tuple[int, int, int, int]:
-
-    # Calculate total padding needed
-    pad_height = target_height - source_height
-    pad_width = target_width - source_width
-
-    # Calculate padding for each side
-    pad_top = pad_height // 2
-    pad_bottom = pad_height - pad_top  # Handles odd padding
-    pad_left = pad_width // 2
-    pad_right = pad_width - pad_left  # Handles odd padding
-
-    # Return padded tensor
-    # Padding format is (left, right, top, bottom)
-    padding = (pad_left, pad_right, pad_top, pad_bottom)
-    return padding
-
-
-def convert_prompt_to_filename(text: str, max_len: int = 20) -> str:
-    # Remove non-letters and convert to lowercase
-    clean_text = "".join(
-        char.lower() for char in text if char.isalpha() or char.isspace()
-    )
-
-    # Split into words
-    words = clean_text.split()
-
-    # Build result string keeping track of length
-    result = []
-    current_length = 0
-
-    for word in words:
-        # Add word length plus 1 for underscore (except for first word)
-        new_length = current_length + len(word)
-
-        if new_length <= max_len:
-            result.append(word)
-            current_length += len(word)
-        else:
-            break
-
-    return "-".join(result)
-
-
-# Generate output video name
-def get_unique_filename(
-    base: str,
-    ext: str,
-    prompt: str,
-    seed: int,
-    resolution: tuple[int, int, int],
-    dir: Path,
-    endswith=None,
-    index_range=1000,
-) -> Path:
-    base_filename = f"{base}_{convert_prompt_to_filename(prompt, max_len=30)}_{seed}_{resolution[0]}x{resolution[1]}x{resolution[2]}"
-    for i in range(index_range):
-        filename = dir / f"{base_filename}_{i}{endswith if endswith else ''}{ext}"
-        if not os.path.exists(filename):
-            return filename
-    raise FileExistsError(
-        f"Could not find a unique filename after {index_range} attempts."
-    )
-
-
-def seed_everething(seed: int):
-    random.seed(seed)
-    np.random.seed(seed)
-    torch.manual_seed(seed)
-    if torch.cuda.is_available():
-        torch.cuda.manual_seed(seed)
-    if torch.backends.mps.is_available():
-        torch.mps.manual_seed(seed)
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Load models from separate directories and run the pipeline."
-    )
-
-    # Directories
-    parser.add_argument(
-        "--output_path",
-        type=str,
-        default=None,
-        help="Path to the folder to save output video, if None will save in outputs/ directory.",
-    )
-    parser.add_argument("--seed", type=int, default="171198")
-
-    # Pipeline parameters
-    parser.add_argument(
-        "--num_images_per_prompt",
-        type=int,
-        default=1,
-        help="Number of images per prompt",
-    )
-    parser.add_argument(
-        "--image_cond_noise_scale",
-        type=float,
-        default=0.15,
-        help="Amount of noise to add to the conditioned image",
-    )
-    parser.add_argument(
-        "--height",
-        type=int,
-        default=704,
-        help="Height of the output video frames. Optional if an input image provided.",
-    )
-    parser.add_argument(
-        "--width",
-        type=int,
-        default=1216,
-        help="Width of the output video frames. If None will infer from input image.",
-    )
-    parser.add_argument(
-        "--num_frames",
-        type=int,
-        default=121,
-        help="Number of frames to generate in the output video",
-    )
-    parser.add_argument(
-        "--frame_rate", type=int, default=30, help="Frame rate for the output video"
-    )
-    parser.add_argument(
-        "--device",
-        default=None,
-        help="Device to run inference on. If not specified, will automatically detect and use CUDA or MPS if available, else CPU.",
-    )
-    parser.add_argument(
-        "--pipeline_config",
-        type=str,
-        default="configs/ltxv-13b-0.9.7-dev.yaml",
-        help="The path to the config file for the pipeline, which contains the parameters for the pipeline",
-    )
-
-    # Prompts
-    parser.add_argument(
-        "--prompt",
-        type=str,
-        help="Text prompt to guide generation",
-    )
-    parser.add_argument(
-        "--negative_prompt",
-        type=str,
-        default="worst quality, inconsistent motion, blurry, jittery, distorted",
-        help="Negative prompt for undesired features",
-    )
-
-    parser.add_argument(
-        "--offload_to_cpu",
-        action="store_true",
-        help="Offloading unnecessary computations to CPU.",
-    )
-
-    # video-to-video arguments:
-    parser.add_argument(
-        "--input_media_path",
-        type=str,
-        default=None,
-        help="Path to the input video (or imaage) to be modified using the video-to-video pipeline",
-    )
-
-    # Conditioning arguments
-    parser.add_argument(
-        "--conditioning_media_paths",
-        type=str,
-        nargs="*",
-        help="List of paths to conditioning media (images or videos). Each path will be used as a conditioning item.",
-    )
-    parser.add_argument(
-        "--conditioning_strengths",
-        type=float,
-        nargs="*",
-        help="List of conditioning strengths (between 0 and 1) for each conditioning item. Must match the number of conditioning items.",
-    )
-    parser.add_argument(
-        "--conditioning_start_frames",
-        type=int,
-        nargs="*",
-        help="List of frame indices where each conditioning item should be applied. Must match the number of conditioning items.",
-    )
-
-    args = parser.parse_args()
-    logger.warning(f"Running generation with arguments: {args}")
-    infer(**vars(args))
-
-
-def create_ltx_video_pipeline(
-    ckpt_path: str,
-    precision: str,
-    text_encoder_model_name_or_path: str,
-    sampler: Optional[str] = None,
-    device: Optional[str] = None,
-    enhance_prompt: bool = False,
-    prompt_enhancer_image_caption_model_name_or_path: Optional[str] = None,
-    prompt_enhancer_llm_model_name_or_path: Optional[str] = None,
-) -> LTXVideoPipeline:
-    ckpt_path = Path(ckpt_path)
-    assert os.path.exists(
-        ckpt_path
-    ), f"Ckpt path provided (--ckpt_path) {ckpt_path} does not exist"
-
-    with safe_open(ckpt_path, framework="pt") as f:
-        metadata = f.metadata()
-        config_str = metadata.get("config")
-        configs = json.loads(config_str)
-        allowed_inference_steps = configs.get("allowed_inference_steps", None)
-
-    vae = CausalVideoAutoencoder.from_pretrained(ckpt_path)
-    transformer = Transformer3DModel.from_pretrained(ckpt_path)
-
-    # Use constructor if sampler is specified, otherwise use from_pretrained
-    if sampler == "from_checkpoint" or not sampler:
-        scheduler = RectifiedFlowScheduler.from_pretrained(ckpt_path)
-    else:
-        scheduler = RectifiedFlowScheduler(
-            sampler=("Uniform" if sampler.lower() == "uniform" else "LinearQuadratic")
-        )
-
-    text_encoder = T5EncoderModel.from_pretrained(
-        text_encoder_model_name_or_path, subfolder="text_encoder"
-    )
-    patchifier = SymmetricPatchifier(patch_size=1)
-    tokenizer = T5Tokenizer.from_pretrained(
-        text_encoder_model_name_or_path, subfolder="tokenizer"
-    )
-
-    transformer = transformer.to(device)
-    vae = vae.to(device)
-    text_encoder = text_encoder.to(device)
-
-    if enhance_prompt:
-        prompt_enhancer_image_caption_model = AutoModelForCausalLM.from_pretrained(
-            prompt_enhancer_image_caption_model_name_or_path, trust_remote_code=True
-        )
-        prompt_enhancer_image_caption_processor = AutoProcessor.from_pretrained(
-            prompt_enhancer_image_caption_model_name_or_path, trust_remote_code=True
-        )
-        prompt_enhancer_llm_model = AutoModelForCausalLM.from_pretrained(
-            prompt_enhancer_llm_model_name_or_path,
-            torch_dtype="bfloat16",
-        )
-        prompt_enhancer_llm_tokenizer = AutoTokenizer.from_pretrained(
-            prompt_enhancer_llm_model_name_or_path,
-        )
-    else:
-        prompt_enhancer_image_caption_model = None
-        prompt_enhancer_image_caption_processor = None
-        prompt_enhancer_llm_model = None
-        prompt_enhancer_llm_tokenizer = None
-
-    vae = vae.to(torch.bfloat16)
-    if precision == "bfloat16" and transformer.dtype != torch.bfloat16:
-        transformer = transformer.to(torch.bfloat16)
-    text_encoder = text_encoder.to(torch.bfloat16)
-
-    # Use submodels for the pipeline
-    submodel_dict = {
-        "transformer": transformer,
-        "patchifier": patchifier,
-        "text_encoder": text_encoder,
-        "tokenizer": tokenizer,
-        "scheduler": scheduler,
-        "vae": vae,
-        "prompt_enhancer_image_caption_model": prompt_enhancer_image_caption_model,
-        "prompt_enhancer_image_caption_processor": prompt_enhancer_image_caption_processor,
-        "prompt_enhancer_llm_model": prompt_enhancer_llm_model,
-        "prompt_enhancer_llm_tokenizer": prompt_enhancer_llm_tokenizer,
-        "allowed_inference_steps": allowed_inference_steps,
-    }
-
-    pipeline = LTXVideoPipeline(**submodel_dict)
-    pipeline = pipeline.to(device)
-    return pipeline
-
-
-def create_latent_upsampler(latent_upsampler_model_path: str, device: str):
-    latent_upsampler = LatentUpsampler.from_pretrained(latent_upsampler_model_path)
-    latent_upsampler.to(device)
-    latent_upsampler.eval()
-    return latent_upsampler
-
-
-def infer(
-    output_path: Optional[str],
-    seed: int,
-    pipeline_config: str,
-    image_cond_noise_scale: float,
-    height: Optional[int],
-    width: Optional[int],
-    num_frames: int,
-    frame_rate: int,
-    prompt: str,
-    negative_prompt: str,
-    offload_to_cpu: bool,
-    input_media_path: Optional[str] = None,
-    conditioning_media_paths: Optional[List[str]] = None,
-    conditioning_strengths: Optional[List[float]] = None,
-    conditioning_start_frames: Optional[List[int]] = None,
-    device: Optional[str] = None,
-    **kwargs,
-):
-    # check if pipeline_config is a file
-    if not os.path.isfile(pipeline_config):
-        raise ValueError(f"Pipeline config file {pipeline_config} does not exist")
-    with open(pipeline_config, "r") as f:
-        pipeline_config = yaml.safe_load(f)
-
-    models_dir = "MODEL_DIR"
-
-    ltxv_model_name_or_path = pipeline_config["checkpoint_path"]
-    if not os.path.isfile(ltxv_model_name_or_path):
-        ltxv_model_path = hf_hub_download(
-            repo_id="Lightricks/LTX-Video",
-            filename=ltxv_model_name_or_path,
-            local_dir=models_dir,
-            repo_type="model",
-        )
-    else:
-        ltxv_model_path = ltxv_model_name_or_path
-
-    spatial_upscaler_model_name_or_path = pipeline_config.get(
-        "spatial_upscaler_model_path"
-    )
-    if spatial_upscaler_model_name_or_path and not os.path.isfile(
-        spatial_upscaler_model_name_or_path
-    ):
-        spatial_upscaler_model_path = hf_hub_download(
-            repo_id="Lightricks/LTX-Video",
-            filename=spatial_upscaler_model_name_or_path,
-            local_dir=models_dir,
-            repo_type="model",
-        )
-    else:
-        spatial_upscaler_model_path = spatial_upscaler_model_name_or_path
-
-    if kwargs.get("input_image_path", None):
-        logger.warning(
-            "Please use conditioning_media_paths instead of input_image_path."
-        )
-        assert not conditioning_media_paths and not conditioning_start_frames
-        conditioning_media_paths = [kwargs["input_image_path"]]
-        conditioning_start_frames = [0]
-
-    # Validate conditioning arguments
-    if conditioning_media_paths:
-        # Use default strengths of 1.0
-        if not conditioning_strengths:
-            conditioning_strengths = [1.0] * len(conditioning_media_paths)
-        if not conditioning_start_frames:
-            raise ValueError(
-                "If `conditioning_media_paths` is provided, "
-                "`conditioning_start_frames` must also be provided"
-            )
-        if len(conditioning_media_paths) != len(conditioning_strengths) or len(
-            conditioning_media_paths
-        ) != len(conditioning_start_frames):
-            raise ValueError(
-                "`conditioning_media_paths`, `conditioning_strengths`, "
-                "and `conditioning_start_frames` must have the same length"
-            )
-        if any(s < 0 or s > 1 for s in conditioning_strengths):
-            raise ValueError("All conditioning strengths must be between 0 and 1")
-        if any(f < 0 or f >= num_frames for f in conditioning_start_frames):
-            raise ValueError(
-                f"All conditioning start frames must be between 0 and {num_frames-1}"
-            )
-
-    seed_everething(seed)
-    if offload_to_cpu and not torch.cuda.is_available():
-        logger.warning(
-            "offload_to_cpu is set to True, but offloading will not occur since the model is already running on CPU."
-        )
-        offload_to_cpu = False
-    else:
-        offload_to_cpu = offload_to_cpu and get_total_gpu_memory() < 30
-
-    output_dir = (
-        Path(output_path)
-        if output_path
-        else Path(f"outputs/{datetime.today().strftime('%Y-%m-%d')}")
-    )
-    output_dir.mkdir(parents=True, exist_ok=True)
-
-    # Adjust dimensions to be divisible by 32 and num_frames to be (N * 8 + 1)
-    height_padded = ((height - 1) // 32 + 1) * 32
-    width_padded = ((width - 1) // 32 + 1) * 32
-    num_frames_padded = ((num_frames - 2) // 8 + 1) * 8 + 1
-
-    padding = calculate_padding(height, width, height_padded, width_padded)
-
-    logger.warning(
-        f"Padded dimensions: {height_padded}x{width_padded}x{num_frames_padded}"
-    )
-
-    prompt_enhancement_words_threshold = pipeline_config[
-        "prompt_enhancement_words_threshold"
-    ]
-
-    prompt_word_count = len(prompt.split())
-    enhance_prompt = (
-        prompt_enhancement_words_threshold > 0
-        and prompt_word_count < prompt_enhancement_words_threshold
-    )
-
-    if prompt_enhancement_words_threshold > 0 and not enhance_prompt:
-        logger.info(
-            f"Prompt has {prompt_word_count} words, which exceeds the threshold of {prompt_enhancement_words_threshold}. Prompt enhancement disabled."
-        )
-
-    precision = pipeline_config["precision"]
-    text_encoder_model_name_or_path = pipeline_config["text_encoder_model_name_or_path"]
-    sampler = pipeline_config["sampler"]
-    prompt_enhancer_image_caption_model_name_or_path = pipeline_config[
-        "prompt_enhancer_image_caption_model_name_or_path"
-    ]
-    prompt_enhancer_llm_model_name_or_path = pipeline_config[
-        "prompt_enhancer_llm_model_name_or_path"
-    ]
-
-    pipeline = create_ltx_video_pipeline(
-        ckpt_path=ltxv_model_path,
-        precision=precision,
-        text_encoder_model_name_or_path=text_encoder_model_name_or_path,
-        sampler=sampler,
-        device=kwargs.get("device", get_device()),
-        enhance_prompt=enhance_prompt,
-        prompt_enhancer_image_caption_model_name_or_path=prompt_enhancer_image_caption_model_name_or_path,
-        prompt_enhancer_llm_model_name_or_path=prompt_enhancer_llm_model_name_or_path,
-    )
-
-    if pipeline_config.get("pipeline_type", None) == "multi-scale":
-        if not spatial_upscaler_model_path:
-            raise ValueError(
-                "spatial upscaler model path is missing from pipeline config file and is required for multi-scale rendering"
-            )
-        latent_upsampler = create_latent_upsampler(
-            spatial_upscaler_model_path, pipeline.device
-        )
-        pipeline = LTXMultiScalePipeline(pipeline, latent_upsampler=latent_upsampler)
-
-    media_item = None
-    if input_media_path:
-        media_item = load_media_file(
-            media_path=input_media_path,
-            height=height,
-            width=width,
-            max_frames=num_frames_padded,
-            padding=padding,
-        )
-
-    conditioning_items = (
-        prepare_conditioning(
-            conditioning_media_paths=conditioning_media_paths,
-            conditioning_strengths=conditioning_strengths,
-            conditioning_start_frames=conditioning_start_frames,
-            height=height,
-            width=width,
-            num_frames=num_frames,
-            padding=padding,
-            pipeline=pipeline,
-        )
-        if conditioning_media_paths
-        else None
-    )
-
-    stg_mode = pipeline_config.get("stg_mode", "attention_values")
-    del pipeline_config["stg_mode"]
-    if stg_mode.lower() == "stg_av" or stg_mode.lower() == "attention_values":
-        skip_layer_strategy = SkipLayerStrategy.AttentionValues
-    elif stg_mode.lower() == "stg_as" or stg_mode.lower() == "attention_skip":
-        skip_layer_strategy = SkipLayerStrategy.AttentionSkip
-    elif stg_mode.lower() == "stg_r" or stg_mode.lower() == "residual":
-        skip_layer_strategy = SkipLayerStrategy.Residual
-    elif stg_mode.lower() == "stg_t" or stg_mode.lower() == "transformer_block":
-        skip_layer_strategy = SkipLayerStrategy.TransformerBlock
-    else:
-        raise ValueError(f"Invalid spatiotemporal guidance mode: {stg_mode}")
-
-    # Prepare input for the pipeline
-    sample = {
-        "prompt": prompt,
-        "prompt_attention_mask": None,
-        "negative_prompt": negative_prompt,
-        "negative_prompt_attention_mask": None,
-    }
-
-    device = device or get_device()
-    generator = torch.Generator(device=device).manual_seed(seed)
-
-    images = pipeline(
-        **pipeline_config,
-        skip_layer_strategy=skip_layer_strategy,
-        generator=generator,
-        output_type="pt",
-        callback_on_step_end=None,
-        height=height_padded,
-        width=width_padded,
-        num_frames=num_frames_padded,
-        frame_rate=frame_rate,
-        **sample,
-        media_items=media_item,
-        conditioning_items=conditioning_items,
-        is_video=True,
-        vae_per_channel_normalize=True,
-        image_cond_noise_scale=image_cond_noise_scale,
-        mixed_precision=(precision == "mixed_precision"),
-        offload_to_cpu=offload_to_cpu,
-        device=device,
-        enhance_prompt=enhance_prompt,
-    ).images
-
-    # Crop the padded images to the desired resolution and number of frames
-    (pad_left, pad_right, pad_top, pad_bottom) = padding
-    pad_bottom = -pad_bottom
-    pad_right = -pad_right
-    if pad_bottom == 0:
-        pad_bottom = images.shape[3]
-    if pad_right == 0:
-        pad_right = images.shape[4]
-    images = images[:, :, :num_frames, pad_top:pad_bottom, pad_left:pad_right]
-
-    for i in range(images.shape[0]):
-        # Gathering from B, C, F, H, W to C, F, H, W and then permuting to F, H, W, C
-        video_np = images[i].permute(1, 2, 3, 0).cpu().float().numpy()
-        # Unnormalizing images to [0, 255] range
-        video_np = (video_np * 255).astype(np.uint8)
-        fps = frame_rate
-        height, width = video_np.shape[1:3]
-        # In case a single image is generated
-        if video_np.shape[0] == 1:
-            output_filename = get_unique_filename(
-                f"image_output_{i}",
-                ".png",
-                prompt=prompt,
-                seed=seed,
-                resolution=(height, width, num_frames),
-                dir=output_dir,
-            )
-            imageio.imwrite(output_filename, video_np[0])
-        else:
-            output_filename = get_unique_filename(
-                f"video_output_{i}",
-                ".mp4",
-                prompt=prompt,
-                seed=seed,
-                resolution=(height, width, num_frames),
-                dir=output_dir,
-            )
-
-            # Write video
-            with imageio.get_writer(output_filename, fps=fps) as video:
-                for frame in video_np:
-                    video.append_data(frame)
-
-        logger.warning(f"Output saved to {output_filename}")
-
-
-def prepare_conditioning(
-    conditioning_media_paths: List[str],
-    conditioning_strengths: List[float],
-    conditioning_start_frames: List[int],
-    height: int,
-    width: int,
-    num_frames: int,
-    padding: tuple[int, int, int, int],
-    pipeline: LTXVideoPipeline,
-) -> Optional[List[ConditioningItem]]:
-    """Prepare conditioning items based on input media paths and their parameters.
-
-    Args:
-        conditioning_media_paths: List of paths to conditioning media (images or videos)
-        conditioning_strengths: List of conditioning strengths for each media item
-        conditioning_start_frames: List of frame indices where each item should be applied
-        height: Height of the output frames
-        width: Width of the output frames
-        num_frames: Number of frames in the output video
-        padding: Padding to apply to the frames
-        pipeline: LTXVideoPipeline object used for condition video trimming
-
-    Returns:
-        A list of ConditioningItem objects.
-    """
-    conditioning_items = []
-    for path, strength, start_frame in zip(
-        conditioning_media_paths, conditioning_strengths, conditioning_start_frames
-    ):
-        num_input_frames = orig_num_input_frames = get_media_num_frames(path)
-        if hasattr(pipeline, "trim_conditioning_sequence") and callable(
-            getattr(pipeline, "trim_conditioning_sequence")
-        ):
-            num_input_frames = pipeline.trim_conditioning_sequence(
-                start_frame, orig_num_input_frames, num_frames
-            )
-        if num_input_frames < orig_num_input_frames:
-            logger.warning(
-                f"Trimming conditioning video {path} from {orig_num_input_frames} to {num_input_frames} frames."
-            )
-
-        media_tensor = load_media_file(
-            media_path=path,
-            height=height,
-            width=width,
-            max_frames=num_input_frames,
-            padding=padding,
-            just_crop=True,
-        )
-        conditioning_items.append(ConditioningItem(media_tensor, start_frame, strength))
-    return conditioning_items
-
-
-def get_media_num_frames(media_path: str) -> int:
-    is_video = any(
-        media_path.lower().endswith(ext) for ext in [".mp4", ".avi", ".mov", ".mkv"]
-    )
-    num_frames = 1
-    if is_video:
-        reader = imageio.get_reader(media_path)
-        num_frames = reader.count_frames()
-        reader.close()
-    return num_frames
-
-
-def load_media_file(
-    media_path: str,
-    height: int,
-    width: int,
-    max_frames: int,
-    padding: tuple[int, int, int, int],
-    just_crop: bool = False,
-) -> torch.Tensor:
-    is_video = any(
-        media_path.lower().endswith(ext) for ext in [".mp4", ".avi", ".mov", ".mkv"]
-    )
-    if is_video:
-        reader = imageio.get_reader(media_path)
-        num_input_frames = min(reader.count_frames(), max_frames)
-
-        # Read and preprocess the relevant frames from the video file.
-        frames = []
-        for i in range(num_input_frames):
-            frame = Image.fromarray(reader.get_data(i))
-            frame_tensor = load_image_to_tensor_with_resize_and_crop(
-                frame, height, width, just_crop=just_crop
-            )
-            frame_tensor = torch.nn.functional.pad(frame_tensor, padding)
-            frames.append(frame_tensor)
-        reader.close()
-
-        # Stack frames along the temporal dimension
-        media_tensor = torch.cat(frames, dim=2)
-    else:  # Input image
-        media_tensor = load_image_to_tensor_with_resize_and_crop(
-            media_path, height, width, just_crop=just_crop
-        )
-        media_tensor = torch.nn.functional.pad(media_tensor, padding)
-    return media_tensor
-
-
-if __name__ == "__main__":
-    main()

managers/mmaudio_manager.py

@@ -1,208 +0,0 @@
-# managers/mmaudio_manager.py
-# AducSdr: Uma implementação aberta e funcional da arquitetura ADUC-SDR
-# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
-#
-# Contato:
-# Carlos Rodrigues dos Santos
-# carlex22@gmail.com
-# Rua Eduardo Carlos Pereira, 4125, B1 Ap32, Curitiba, PR, Brazil, CEP 8102025
-#
-# Repositórios e Projetos Relacionados:
-# GitHub: https://github.com/carlex22/Aduc-sdr
-#
-# PENDING PATENT NOTICE: Please see NOTICE.md.
-#
-# Version: 2.3.0
-#
-# This file defines the MMAudioManager for the ADUC-SDR framework. It is responsible
-# for generating audio synchronized with video clips. This version has been refactored
-# to be self-contained by automatically cloning the MMAudio dependency from its
-# official repository, making the framework more portable and easier to set up.
-
-import torch
-import logging
-import subprocess
-import os
-import time
-import yaml
-import gc
-from pathlib import Path
-import gradio as gr
-import sys
-
-logger = logging.getLogger(__name__)
-
-# --- Dependency Management ---
-DEPS_DIR = Path("./deps")
-MMAUDIO_REPO_DIR = DEPS_DIR / "MMAudio"
-MMAUDIO_REPO_URL = "https://github.com/hkchengrex/MMAudio.git"
-
-def setup_mmaudio_dependencies():
-    """
-    Ensures the MMAudio repository is cloned and available in the sys.path.
-    This function is run once when the module is first imported.
-    """
-    if not MMAUDIO_REPO_DIR.exists():
-        logger.info(f"MMAudio repository not found at '{MMAUDIO_REPO_DIR}'. Cloning from GitHub...")
-        try:
-            DEPS_DIR.mkdir(exist_ok=True)
-            subprocess.run(
-                ["git", "clone", "--depth", "1", MMAUDIO_REPO_URL, str(MMAUDIO_REPO_DIR)],
-                check=True, capture_output=True, text=True
-            )
-            logger.info("MMAudio repository cloned successfully.")
-        except subprocess.CalledProcessError as e:
-            logger.error(f"Failed to clone MMAudio repository. Git stderr: {e.stderr}")
-            raise RuntimeError("Could not clone the required MMAudio dependency from GitHub.")
-    else:
-        logger.info("Found local MMAudio repository.")
-    
-    if str(MMAUDIO_REPO_DIR.resolve()) not in sys.path:
-        sys.path.insert(0, str(MMAUDIO_REPO_DIR.resolve()))
-        logger.info(f"Added '{MMAUDIO_REPO_DIR.resolve()}' to sys.path.")
-
-setup_mmaudio_dependencies()
-
-from mmaudio.eval_utils import ModelConfig, all_model_cfg, generate as mmaudio_generate, load_video, make_video
-from mmaudio.model.flow_matching import FlowMatching
-from mmaudio.model.networks import MMAudio, get_my_mmaudio
-from mmaudio.model.utils.features_utils import FeaturesUtils
-from mmaudio.model.sequence_config import SequenceConfig
-
-
-class MMAudioManager:
-    """
-    Manages the MMAudio model for audio generation tasks.
-    """
-    def __init__(self, workspace_dir):
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        self.cpu_device = torch.device("cpu")
-        self.dtype = torch.bfloat16 if self.device == "cuda" else torch.float32
-        self.workspace_dir = workspace_dir
-        
-        self.all_model_cfg = all_model_cfg
-        self.model_config: 'ModelConfig' = self.all_model_cfg['large_44k_v2']
-        self.net: 'MMAudio' = None
-        self.feature_utils: 'FeaturesUtils' = None
-        self.seq_cfg: 'SequenceConfig' = None
-        
-        self._load_models_to_cpu()
-
-    def _adjust_paths_for_repo(self):
-        """Adjusts the checkpoint paths in the model config to point inside the cloned repo."""
-        for cfg_key in self.all_model_cfg:
-            cfg = self.all_model_cfg[cfg_key]
-            # The paths in the original config are relative, so we join them with our repo path
-            cfg.model_path = MMAUDIO_REPO_DIR / cfg.model_path
-            cfg.vae_path = MMAUDIO_REPO_DIR / cfg.vae_path
-            if cfg.bigvgan_16k_path is not None:
-                cfg.bigvgan_16k_path = MMAUDIO_REPO_DIR / cfg.bigvgan_16k_path
-            cfg.synchformer_ckpt = MMAUDIO_REPO_DIR / cfg.synchformer_ckpt
-
-    def _load_models_to_cpu(self):
-        """Loads the MMAudio models to CPU memory on initialization."""
-        try:
-            self._adjust_paths_for_repo()
-            logger.info("Verifying and downloading MMAudio models, if necessary...")
-            self.model_config.download_if_needed()
-            
-            self.seq_cfg = self.model_config.seq_cfg
-            
-            logger.info(f"Loading MMAudio model: {self.model_config.model_name} to CPU...")
-            self.net = get_my_mmaudio(self.model_config.model_name).eval()
-            self.net.load_weights(torch.load(self.model_config.model_path, map_location=self.cpu_device, weights_only=True))
-            
-            logger.info("Loading MMAudio feature utils to CPU...")
-            self.feature_utils = FeaturesUtils(
-                tod_vae_ckpt=self.model_config.vae_path,
-                synchformer_ckpt=self.model_config.synchformer_ckpt,
-                enable_conditions=True,
-                mode=self.model_config.mode,
-                bigvgan_vocoder_ckpt=self.model_config.bigvgan_16k_path,
-                need_vae_encoder=False
-            )
-            self.feature_utils = self.feature_utils.eval()
-            self.net.to(self.cpu_device)
-            self.feature_utils.to(self.cpu_device)
-            logger.info("MMAudioManager ready on CPU.")
-        except Exception as e:
-            logger.error(f"Failed to load audio models: {e}", exc_info=True)
-            self.net = None
-
-    def to_gpu(self):
-        """Moves the models and utilities to the GPU before inference."""
-        if self.device == 'cpu': return
-        logger.info(f"Moving MMAudioManager to GPU ({self.device})...")
-        self.net.to(self.device, self.dtype)
-        self.feature_utils.to(self.device, self.dtype)
-
-    def to_cpu(self):
-        """Moves the models back to CPU and clears VRAM after inference."""
-        if self.device == 'cpu': return
-        logger.info("Unloading MMAudioManager from GPU...")
-        self.net.to(self.cpu_device)
-        self.feature_utils.to(self.cpu_device)
-        gc.collect()
-        if torch.cuda.is_available(): torch.cuda.empty_cache()
-
-    def generate_audio_for_video(self, video_path: str, prompt: str, duration_seconds: float, output_path_override: str = None) -> str:
-        """
-        Generates audio for a video file, applying a negative prompt to avoid speech.
-        """
-        if self.net is None:
-            raise gr.Error("MMAudio model is not loaded. Cannot generate audio.")
-
-        logger.info("--- Generating Audio for Video Fragment ---")
-        logger.info(f"--- Video: {os.path.basename(video_path)}")
-        logger.info(f"--- Duration: {duration_seconds:.2f}s")
-        
-        negative_prompt = "human voice, speech, talking, singing, narration"
-        logger.info(f"--- Prompt: '{prompt}' | Negative Prompt: '{negative_prompt}'")
-        
-        if duration_seconds < 1:
-            logger.warning("Fragment too short (<1s). Returning original video.")
-            return video_path
-        
-        if self.device == 'cpu':
-            logger.warning("Generating audio on CPU. This may be very slow.")
-
-        try:
-            self.to_gpu()
-            with torch.no_grad():
-                rng = torch.Generator(device=self.device).manual_seed(int(time.time()))
-                fm = FlowMatching(min_sigma=0, inference_mode='euler', num_steps=25)
-                
-                video_info = load_video(Path(video_path), duration_seconds)
-                self.seq_cfg.duration = video_info.duration_sec
-                self.net.update_seq_lengths(self.seq_cfg.latent_seq_len, self.seq_cfg.clip_seq_len, self.seq_cfg.sync_seq_len)
-                
-                audios = mmaudio_generate(
-                    clip_video=video_info.clip_frames.unsqueeze(0),
-                    sync_video=video_info.sync_frames.unsqueeze(0),
-                    text=[prompt],
-                    negative_text=[negative_prompt],
-                    feature_utils=self.feature_utils,
-                    net=self.net,
-                    fm=fm,
-                    rng=rng,
-                    cfg_strength=4.5
-                )
-                audio_waveform = audios.float().cpu()[0]
-                
-                output_video_path = output_path_override if output_path_override else os.path.join(self.workspace_dir, f"{Path(video_path).stem}_with_audio.mp4")
-                
-                make_video(video_info, Path(output_video_path), audio_waveform, sampling_rate=self.seq_cfg.sampling_rate)
-                logger.info(f"--- Fragment with audio saved to: {os.path.basename(output_video_path)}")
-                return output_video_path
-        finally:
-            self.to_cpu()
-
-# --- Singleton Instantiation ---
-try:
-    with open("config.yaml", 'r') as f:
-        config = yaml.safe_load(f)
-    WORKSPACE_DIR = config['application']['workspace_dir']
-    mmaudio_manager_singleton = MMAudioManager(workspace_dir=WORKSPACE_DIR)
-except Exception as e:
-    logger.error(f"Could not initialize MMAudioManager: {e}", exc_info=True)
-    mmaudio_manager_singleton = None

managers/seedvr_manager.py

@@ -1,233 +0,0 @@
-# managers/seedvr_manager.py
-#
-# Copyright (C) 2025 Carlos Rodrigues dos Santos
-#
-# Version: 4.0.0 (Root Installer & Executor)
-#
-# This version fully adopts the logic from the functional hd_specialist.py example.
-# It acts as a setup manager: it clones the SeedVR repo and then copies all
-# necessary directories (projects, common, models, configs, ckpts) to the
-# application root. It also handles the pip installation of the Apex dependency.
-# This ensures that the SeedVR code runs in the exact file structure it expects.
-
-import torch
-import torch.distributed as dist
-import os
-import gc
-import logging
-import sys
-import subprocess
-from pathlib import Path
-from urllib.parse import urlparse
-from torch.hub import download_url_to_file
-import gradio as gr
-import mediapy
-from einops import rearrange
-import shutil
-from omegaconf import OmegaConf
-
-logger = logging.getLogger(__name__)
-
-# --- Caminhos Globais ---
-APP_ROOT = Path("/home/user/app")
-DEPS_DIR = APP_ROOT / "deps"
-SEEDVR_SPACE_DIR = DEPS_DIR / "SeedVR_Space"
-SEEDVR_SPACE_URL = "https://huggingface.co/spaces/ByteDance-Seed/SeedVR2-3B"
-
-class SeedVrManager:
-    def __init__(self, workspace_dir="deformes_workspace"):
-        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
-        self.runner = None
-        self.workspace_dir = workspace_dir
-        self.is_initialized = False
-        self._original_barrier = None
-        self.setup_complete = False # Flag para rodar o setup apenas uma vez
-        logger.info("SeedVrManager initialized. Setup will run on first use.")
-
-    def _full_setup(self):
-        """
-        Executa todo o processo de setup uma única vez.
-        """
-        if self.setup_complete:
-            return
-        
-        logger.info("--- Starting Full SeedVR Setup ---")
-        
-        # 1. Clonar o repositório se não existir
-        if not SEEDVR_SPACE_DIR.exists():
-            logger.info(f"Cloning SeedVR Space repo to {SEEDVR_SPACE_DIR}...")
-            DEPS_DIR.mkdir(exist_ok=True, parents=True)
-            subprocess.run(
-                ["git", "clone", "--depth", "1", SEEDVR_SPACE_URL, str(SEEDVR_SPACE_DIR)],
-                check=True, capture_output=True, text=True
-            )
-        
-        # 2. Copiar as pastas necessárias para a raiz da aplicação
-        required_dirs = ["projects", "common", "models", "configs_3b", "configs_7b"]
-        for dirname in required_dirs:
-            source = SEEDVR_SPACE_DIR / dirname
-            target = APP_ROOT / dirname
-            if not target.exists():
-                logger.info(f"Copying '{dirname}' to application root...")
-                shutil.copytree(source, target)
-        
-        # 3. Adicionar a raiz ao sys.path para garantir que os imports funcionem
-        if str(APP_ROOT) not in sys.path:
-            sys.path.insert(0, str(APP_ROOT))
-            logger.info(f"Added '{APP_ROOT}' to sys.path.")
-
-        # 4. Instalar dependências complexas como Apex
-        try:
-            import apex
-            logger.info("Apex is already installed.")
-        except ImportError:
-            logger.info("Installing Apex dependency...")
-            apex_url = 'https://huggingface.co/ByteDance-Seed/SeedVR2-3B/resolve/main/apex-0.1-cp310-cp310-linux_x86_64.whl'
-            apex_wheel_path = _load_file_from_url(url=apex_url, model_dir=str(DEPS_DIR))
-            subprocess.run(f"pip install {apex_wheel_path}", check=True, shell=True)
-            logger.info("Apex installed successfully.")
-
-        # 5. Baixar os modelos para a pasta ./ckpts na raiz
-        ckpt_dir = APP_ROOT / 'ckpts'
-        ckpt_dir.mkdir(exist_ok=True)
-        pretrain_model_urls = {
-            'vae': 'https://huggingface.co/ByteDance-Seed/SeedVR2-3B/resolve/main/ema_vae.pth',
-            'dit_3b': 'https://huggingface.co/ByteDance-Seed/SeedVR2-3B/resolve/main/seedvr2_ema_3b.pth',
-            'dit_7b': 'https://huggingface.co/ByteDance-Seed/SeedVR2-7B/resolve/main/seedvr2_ema_7b.pth',
-            'pos_emb': 'https://huggingface.co/ByteDance-Seed/SeedVR2-3B/resolve/main/pos_emb.pt',
-            'neg_emb': 'https://huggingface.co/ByteDance-Seed/SeedVR2-3B/resolve/main/neg_emb.pt'
-        }
-        for name, url in pretrain_model_urls.items():
-            _load_file_from_url(url=url, model_dir=str(ckpt_dir))
-            
-        self.setup_complete = True
-        logger.info("--- Full SeedVR Setup Complete ---")
-
-    def _initialize_runner(self, model_version: str):
-        if self.runner is not None: return
-
-        # Garante que todo o ambiente está configurado antes de prosseguir
-        self._full_setup()
-
-        # Agora que o setup está feito, podemos importar os módulos
-        from projects.video_diffusion_sr.infer import VideoDiffusionInfer
-        from common.config import load_config
-        from common.seed import set_seed
-        
-        if dist.is_available() and not dist.is_initialized():
-            os.environ["MASTER_ADDR"] = "127.0.0.1"
-            os.environ["MASTER_PORT"] = "12355"
-            os.environ["RANK"] = str(0)
-            os.environ["WORLD_SIZE"] = str(1)
-            dist.init_process_group(backend='gloo')
-            logger.info("Initialized torch.distributed process group.")
-
-        logger.info(f"Initializing SeedVR2 {model_version} runner...")
-        if model_version == '3B':
-            config_path = APP_ROOT / 'configs_3b' / 'main.yaml'
-            checkpoint_path = APP_ROOT / 'ckpts' / 'seedvr2_ema_3b.pth'
-        else: # Assumimos 7B
-            config_path = APP_ROOT / 'configs_7b' / 'main.yaml'
-            checkpoint_path = APP_ROOT / 'ckpts' / 'seedvr2_ema_7b.pth'
-
-        config = load_config(str(config_path))
-        
-        self.runner = VideoDiffusionInfer(config)
-        OmegaConf.set_readonly(self.runner.config, False)
-        
-        self.runner.configure_dit_model(device=self.device, checkpoint=str(checkpoint_path))
-        self.runner.configure_vae_model()
-        
-        if hasattr(self.runner.vae, "set_memory_limit"):
-            self.runner.vae.set_memory_limit(**self.runner.config.vae.memory_limit)
-        
-        self.is_initialized = True
-        logger.info(f"Runner for SeedVR2 {model_version} initialized and ready.")
-        
-    def _unload_runner(self):
-        if self.runner is not None:
-            del self.runner
-            self.runner = None
-            gc.collect()
-            torch.cuda.empty_cache()
-            self.is_initialized = False
-            logger.info("Runner do SeedVR2 descarregado da VRAM.")
-        if dist.is_initialized():
-            dist.destroy_process_group()
-            logger.info("Destroyed torch.distributed process group.")
-
-    def process_video(self, input_video_path: str, output_video_path: str, prompt: str,
-                      model_version: str = '7B', steps: int = 100, seed: int = 666, 
-                      progress: gr.Progress = None) -> str:
-        try:
-            self._initialize_runner(model_version)
-            
-            # Precisamos importar aqui, pois o sys.path é modificado no setup
-            from common.seed import set_seed
-            from data.image.transforms.divisible_crop import DivisibleCrop
-            from data.image.transforms.na_resize import NaResize
-            from data.video.transforms.rearrange import Rearrange
-            from projects.video_diffusion_sr.color_fix import wavelet_reconstruction
-            from torchvision.transforms import Compose, Lambda, Normalize
-            from torchvision.io.video import read_video
-
-            set_seed(seed, same_across_ranks=True)
-            self.runner.config.diffusion.timesteps.sampling.steps = steps
-            self.runner.configure_diffusion()
-            
-            video_tensor = read_video(input_video_path, output_format="TCHW")[0] / 255.0
-            res_h, res_w = video_tensor.shape[-2:]
-            video_transform = Compose([
-                NaResize(resolution=(res_h * res_w) ** 0.5, mode="area", downsample_only=False),
-                Lambda(lambda x: torch.clamp(x, 0.0, 1.0)),
-                DivisibleCrop((16, 16)),
-                Normalize(0.5, 0.5),
-                Rearrange("t c h w -> c t h w"),
-            ])
-            cond_latents = [video_transform(video_tensor.to(self.device))]
-            input_videos = cond_latents
-            self.runner.dit.to("cpu")
-            self.runner.vae.to(self.device)
-            cond_latents = self.runner.vae_encode(cond_latents)
-            self.runner.vae.to("cpu"); gc.collect(); torch.cuda.empty_cache()
-            self.runner.dit.to(self.device)
-            
-            pos_emb = torch.load(APP_ROOT / 'pos_emb.pt').to(self.device)
-            neg_emb = torch.load(APP_ROOT / 'neg_emb.pt').to(self.device)
-            text_embeds_dict = {"texts_pos": [pos_emb], "texts_neg": [neg_emb]}
-            
-            noises = [torch.randn_like(latent) for latent in cond_latents]
-            conditions = [self.runner.get_condition(noise, latent_blur=latent, task="sr") for noise, latent in zip(noises, cond_latents)]
-            
-            with torch.no_grad(), torch.autocast("cuda", torch.bfloat16, enabled=True):
-                video_tensors = self.runner.inference(noises=noises, conditions=conditions, dit_offload=True, **text_embeds_dict)
-                
-            self.runner.dit.to("cpu"); gc.collect(); torch.cuda.empty_cache()
-            self.runner.vae.to(self.device)
-            samples = self.runner.vae_decode(video_tensors)
-            final_sample = samples[0]
-            input_video_sample = input_videos[0]
-            if final_sample.shape[1] < input_video_sample.shape[1]:
-                input_video_sample = input_video_sample[:, :final_sample.shape[1]]
-                
-            final_sample = wavelet_reconstruction(rearrange(final_sample, "c t h w -> t c h w"), rearrange(input_video_sample, "c t h w -> t c h w"))
-            final_sample = rearrange(final_sample, "t c h w -> t h w c")
-            final_sample = final_sample.clip(-1, 1).mul_(0.5).add_(0.5).mul_(255).round()
-            final_sample_np = final_sample.to(torch.uint8).cpu().numpy()
-            
-            mediapy.write_video(output_video_path, final_sample_np, fps=24)
-            logger.info(f"HD Mastered video saved to: {output_video_path}")
-            return output_path
-        finally:
-            self._unload_runner()
-
-def _load_file_from_url(url, model_dir='./', file_name=None):
-    os.makedirs(model_dir, exist_ok=True)
-    filename = file_name or os.path.basename(urlparse(url).path)
-    cached_file = os.path.abspath(os.path.join(model_dir, filename))
-    if not os.path.exists(cached_file):
-        logger.info(f'Downloading: "{url}" to {cached_file}')
-        download_url_to_file(url, cached_file, hash_prefix=None, progress=True)
-    return cached_file
-
-seedvr_manager_singleton = SeedVrManager()

managers/upscaler_specialist.py

@@ -1,91 +0,0 @@
-# upscaler_specialist.py
-# Copyright (C) 2025 Carlos Rodrigues
-# Especialista ADUC para upscaling espacial de tensores latentes.
-
-import torch
-import logging
-from diffusers import LTXLatentUpsamplePipeline
-from managers.ltx_manager import ltx_manager_singleton
-
-logger = logging.getLogger(__name__)
-
-class UpscalerSpecialist:
-    """
-    Especialista responsável por aumentar a resolução espacial de tensores latentes
-    usando o LTX Video Spatial Upscaler.
-    """
-    def __init__(self):
-        # Força uso de CUDA se disponível
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        self.base_vae = None
-        self.pipe_upsample = None
-
-
-    def _lazy_init(self):
-      try:
-        # Tenta usar o VAE do ltx_manager
-        if ltx_manager_singleton.workers:
-            candidate_vae = ltx_manager_singleton.workers[0].pipeline.vae
-            if candidate_vae.__class__.__name__ == "AutoencoderKLLTXVideo":
-                self.base_vae = candidate_vae
-                logger.info("[Upscaler] Usando VAE do ltx_manager (AutoencoderKLLTXVideo).")
-            else:
-                logger.warning(f"[Upscaler] VAE incompatível: {type(candidate_vae)}. "
-                               "Carregando AutoencoderKLLTXVideo manualmente...")
-                from diffusers.models.autoencoders import AutoencoderKLLTXVideo
-                self.base_vae = AutoencoderKLLTXVideo.from_pretrained(
-                    "linoyts/LTX-Video-spatial-upscaler-0.9.8",
-                    subfolder="vae",
-                    torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
-                ).to(self.device)
-        else:
-            logger.warning("[Upscaler] Nenhum worker disponível, carregando VAE manualmente...")
-            from diffusers.models.autoencoders import AutoencoderKLLTXVideo
-            self.base_vae = AutoencoderKLLTXVideo.from_pretrained(
-                "linoyts/LTX-Video-spatial-upscaler-0.9.8",
-                subfolder="vae",
-                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
-            ).to(self.device)
-
-        # Carregar pipeline
-        self.pipe_upsample = LTXLatentUpsamplePipeline.from_pretrained(
-            "linoyts/LTX-Video-spatial-upscaler-0.9.8",
-            vae=self.base_vae,
-            torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
-        ).to(self.device)
-
-        logger.info("[Upscaler] Pipeline carregado com sucesso.")
-
-      except Exception as e:
-        logger.error(f"[Upscaler] Falha ao carregar pipeline: {e}")
-        self.pipe_upsample = None
-        
-
-    
-    @torch.no_grad()
-    def upscale(self, latents: torch.Tensor) -> torch.Tensor:
-        """Aplica o upscaling 2x nos tensores latentes fornecidos."""
-        self._lazy_init()
-        if self.pipe_upsample is None:
-            logger.warning("[Upscaler] Pipeline indisponível. Retornando latentes originais.")
-            return latents
-
-        try:
-            logger.info(f"[Upscaler] Recebido shape {latents.shape}. Executando upscale em {self.device}...")
-            
-            # [CORREÇÃO FINAL] Conforme a documentação oficial, o resultado está em .frames
-            result = self.pipe_upsample(latents=latents, output_type="latent")
-            output_tensor = result.frames
-            
-            logger.info(f"[Upscaler] Upscale concluído. Novo shape: {output_tensor.shape}")
-            return output_tensor
-        
-        except Exception as e:
-            logger.error(f"[Upscaler] Erro durante upscale: {e}", exc_info=True)
-            return latents
-
-
-# ---------------------------
-# Singleton global
-# ---------------------------
-upscaler_specialist_singleton = UpscalerSpecialist()

managers/vae_manager.py

@@ -1,99 +0,0 @@
-# managers/vae_manager.py
-# AducSdr: Uma implementação aberta e funcional da arquitetura ADUC-SDR
-# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
-#
-# Contato:
-# Carlos Rodrigues dos Santos
-# carlex22@gmail.com
-# Rua Eduardo Carlos Pereira, 4125, B1 Ap32, Curitiba, PR, Brazil, CEP 8102025
-#
-# Repositórios e Projetos Relacionados:
-# GitHub: https://github.com/carlex22/Aduc-sdr
-#
-# PENDING PATENT NOTICE: Please see NOTICE.md.
-#
-# 
-# This file defines the VaeManager specialist. Its purpose is to abstract all
-# direct interactions with the Variational Autoencoder (VAE) model. It handles
-# the model's state (CPU/GPU memory), provides clean interfaces for encoding and
-# decoding, and ensures that the heavy VAE model only occupies VRAM when actively
-# performing a task, freeing up resources for other specialists.
-#
-# Version 1.0.1
-
-
-import torch
-import logging
-import gc
-from typing import Generator
-
-# Import the source of the VAE model and the low-level functions
-from managers.ltx_manager import ltx_manager_singleton
-from ltx_video.models.autoencoders.vae_encode import vae_encode, vae_decode
-
-logger = logging.getLogger(__name__)
-
-class VaeManager:
-    """
-    A specialist for managing the LTX VAE model. It provides high-level methods
-    for encoding pixels to latents and decoding latents to pixels, while managing
-    the model's presence on the GPU to conserve VRAM.
-    """
-    def __init__(self, vae_model):
-        self.vae = vae_model
-        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
-        self.cpu_device = torch.device('cpu')
-        
-        # Initialize the VAE on the CPU to keep VRAM free at startup
-        self.vae.to(self.cpu_device)
-        logger.info(f"VaeManager initialized. VAE model is on CPU.")
-
-    def to_gpu(self):
-        """Moves the VAE model to the active GPU."""
-        if self.device == 'cpu': return
-        logger.info("VaeManager: Moving VAE to GPU...")
-        self.vae.to(self.device)
-
-    def to_cpu(self):
-        """Moves the VAE model to the CPU and clears VRAM cache."""
-        if self.device == 'cpu': return
-        logger.info("VaeManager: Unloading VAE from GPU...")
-        self.vae.to(self.cpu_device)
-        gc.collect()
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-
-    @torch.no_grad()
-    def encode(self, pixel_tensor: torch.Tensor) -> torch.Tensor:
-        """
-        Encodes a pixel-space tensor to the latent space.
-        Manages moving the VAE to and from the GPU.
-        """
-        try:
-            self.to_gpu()
-            pixel_tensor = pixel_tensor.to(self.device, dtype=self.vae.dtype)
-            latents = vae_encode(pixel_tensor, self.vae, vae_per_channel_normalize=True)
-            return latents.to(self.cpu_device) # Return to CPU to free VRAM
-        finally:
-            self.to_cpu()
-
-    @torch.no_grad()
-    def decode(self, latent_tensor: torch.Tensor, decode_timestep: float = 0.05) -> torch.Tensor:
-        """
-        Decodes a latent-space tensor to pixels.
-        Manages moving the VAE to and from the GPU.
-        """
-        try:
-            self.to_gpu()
-            latent_tensor = latent_tensor.to(self.device, dtype=self.vae.dtype)
-            timestep_tensor = torch.tensor([decode_timestep] * latent_tensor.shape[0], device=self.device, dtype=latent_tensor.dtype)
-            pixels = vae_decode(latent_tensor, self.vae, is_video=True, timestep=timestep_tensor, vae_per_channel_normalize=True)
-            return pixels.to(self.cpu_device) # Return to CPU to free VRAM
-        finally:
-            self.to_cpu()
-
-# --- Singleton Instance ---
-# The VaeManager must use the exact same VAE instance as the LTX pipeline to ensure
-# latent space compatibility. We source it directly from the already-initialized ltx_manager.
-source_vae_model = ltx_manager_singleton.workers[0].pipeline.vae
-vae_manager_singleton = VaeManager(source_vae_model)

prompts/LICENSE

@@ -1,25 +0,0 @@
-# Euia-AducSdr: Uma implementação aberta e funcional da arquitetura ADUC-SDR para geração de vídeo coerente.
-# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
-#
-# Contato:
-# Carlos Rodrigues dos Santos
-# carlex22@gmail.com
-# Rua Eduardo Carlos Pereira, 4125, B1 Ap32, Curitiba, PR, Brazil, CEP 8102025
-#
-# Repositórios e Projetos Relacionados:
-# GitHub: https://github.com/carlex22/Aduc-sdr
-# Hugging Face (Ltx-SuperTime-60Secondos): https://huggingface.co/spaces/Carlexx/Ltx-SuperTime-60Secondos/
-# Hugging Face (Novinho): https://huggingface.co/spaces/Carlexxx/Novinho/
-#
-# 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/>.

prompts/NOTICE.md

@@ -1,76 +0,0 @@
-# NOTICE
-
-Copyright (C) 2025 Carlos Rodrigues dos Santos. All rights reserved.
-
----
-
-## Aviso de Propriedade Intelectual e Licenciamento
-
-### **Processo de Patenteamento em Andamento (EM PORTUGUÊS):**
-
-O método e o sistema de orquestração de prompts denominados **ADUC (Automated Discovery and Orchestration of Complex tasks)**, conforme descritos neste documento e implementados neste software, estão atualmente em processo de patenteamento.
-
-O titular dos direitos, Carlos Rodrigues dos Santos, está buscando proteção legal para as inovações chave da arquitetura ADUC, incluindo, mas não se limitando a:
-
-*   Fragmentação e escalonamento de solicitações que excedem limites de contexto de modelos de IA.
-*   Distribuição inteligente de sub-tarefas para especialistas heterogêneos.
-*   Gerenciamento de estado persistido com avaliação iterativa e realimentação para o planejamento de próximas etapas.
-*   Planejamento e roteamento sensível a custo, latência e requisitos de qualidade.
-*   O uso de "tokens universais" para comunicação agnóstica a modelos.
-
-### **Reconhecimento e Implicações (EM PORTUGUÊS):**
-
-Ao acessar ou utilizar este software e a arquitetura ADUC aqui implementada, você reconhece:
-
-1.  A natureza inovadora e a importância da arquitetura ADUC no campo da orquestração de prompts para IA.
-2.  Que a essência desta arquitetura, ou suas implementações derivadas, podem estar sujeitas a direitos de propriedade intelectual, incluindo patentes.
-3.  Que o uso comercial, a reprodução da lógica central da ADUC em sistemas independentes, ou a exploração direta da invenção sem o devido licenciamento podem infringir os direitos de patente pendente.
-
----
-
-### **Patent Pending (IN ENGLISH):**
-
-The method and system for prompt orchestration named **ADUC (Automated Discovery and Orchestration of Complex tasks)**, as described herein and implemented in this software, are currently in the process of being patented.
-
-The rights holder, Carlos Rodrigues dos Santos, is seeking legal protection for the key innovations of the ADUC architecture, including, but not limited to:
-
-*   Fragmentation and scaling of requests exceeding AI model context limits.
-*   Intelligent distribution of sub-tasks to heterogeneous specialists.
-*   Persistent state management with iterative evaluation and feedback for planning subsequent steps.
-*   Cost, latency, and quality-aware planning and routing.
-*   The use of "universal tokens" for model-agnostic communication.
-
-### **Acknowledgement and Implications (IN ENGLISH):**
-
-By accessing or using this software and the ADUC architecture implemented herein, you acknowledge:
-
-1.  The innovative nature and significance of the ADUC architecture in the field of AI prompt orchestration.
-2.  That the essence of this architecture, or its derivative implementations, may be subject to intellectual property rights, including patents.
-3.  That commercial use, reproduction of ADUC's core logic in independent systems, or direct exploitation of the invention without proper licensing may infringe upon pending patent rights.
-
----
-
-## Licença AGPLv3
-
-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/>.
-
----
-
-**Contato para Consultas:**
-
-Para mais informações sobre a arquitetura ADUC, o status do patenteamento, ou para discutir licenciamento para usos comerciais ou não conformes com a AGPLv3, por favor, entre em contato:
-
-Carlos Rodrigues dos Santos
-carlex22@gmail.com
-Rua Eduardo Carlos Pereira, 4125, B1 Ap32, Curitiba, PR, Brazil, CEP 8102025

prompts/README.md

@@ -1,211 +0,0 @@
----
-title: Euia-AducSdr
-emoji: 🎥
-colorFrom: indigo
-colorTo: purple
-sdk: gradio
-app_file: app.py
-pinned: true
-license: agpl-3.0
-short_description: Uma implementação aberta e funcional da arquitetura ADUC-SDR
----
-
-
-### 🇧🇷 Português
-
-Uma implementação aberta e funcional da arquitetura ADUC-SDR (Arquitetura de Unificação Compositiva - Escala Dinâmica e Resiliente), projetada para a geração de vídeo coerente de longa duração. Este projeto materializa os princípios de fragmentação, navegação geométrica e um mecanismo de "eco causal 4bits memoria" para garantir a continuidade física e narrativa em sequências de vídeo geradas por múltiplos modelos de IA.
-
-**Licença:** Este projeto é licenciado sob os termos da **GNU Affero General Public License v3.0**. Isto significa que se você usar este software (ou qualquer trabalho derivado) para fornecer um serviço através de uma rede, você é **obrigado a disponibilizar o código-fonte completo** da sua versão para os usuários desse serviço.
-
-- **Copyright (C) 4 de Agosto de 2025, Carlos Rodrigues dos Santos**
-- Uma cópia completa da licença pode ser encontrada no arquivo [LICENSE](LICENSE).
-
----
-
-### 🇬🇧 English
-
-An open and functional implementation of the ADUC-SDR (Architecture for Compositive Unification - Dynamic and Resilient Scaling) architecture, designed for long-form coherent video generation. This project materializes the principles of fragmentation, geometric navigation, and a "causal echo 4bits memori" mechanism to ensure physical and narrative continuity in video sequences generated by multiple AI models.
-
-**License:** This project is licensed under the terms of the **GNU Affero General Public License v3.0**. This means that if you use this software (or any derivative work) to provide a service over a network, you are **required to make the complete source code** of your version available to the users of that service.
-
-- **Copyright (C) August 4, 2025, Carlos Rodrigues dos Santos**
-- A full copy of the license can be found in the [LICENSE](LICENSE) file.
-
----
-
-## **Aviso de Propriedade Intelectual e Patenteamento**
-
-### **Processo de Patenteamento em Andamento (EM PORTUGUÊS):**
-
-A arquitetura e o método **ADUC (Automated Discovery and Orchestration of Complex tasks)**, conforme descritos neste projeto e nas reivindicações associadas, estão **atualmente em processo de patenteamento**.
-
-O titular dos direitos, Carlos Rodrigues dos Santos, está buscando proteção legal para as inovações chave da arquitetura ADUC, que incluem, mas não se limitam a:
-
-*   Fragmentação e escalonamento de solicitações que excedem limites de contexto de modelos de IA.
-*   Distribuição inteligente de sub-tarefas para especialistas heterogêneos.
-*   Gerenciamento de estado persistido com avaliação iterativa e realimentação para o planejamento de próximas etapas.
-*   Planejamento e roteamento sensível a custo, latência e requisitos de qualidade.
-*   O uso de "tokens universais" para comunicação agnóstica a modelos.
-
-Ao utilizar este software e a arquitetura ADUC aqui implementada, você reconhece a natureza inovadora desta arquitetura e que a **reprodução ou exploração da lógica central da ADUC em sistemas independentes pode infringir direitos de patente pendente.**
-
----
-
-### **Patent Pending (IN ENGLISH):**
-
-The **ADUC (Automated Discovery and Orchestration of Complex tasks)** architecture and method, as described in this project and its associated claims, are **currently in the process of being patented.**
-
-The rights holder, Carlos Rodrigues dos Santos, is seeking legal protection for the key innovations of the ADUC architecture, including, but not limited to:
-
-*   Fragmentation and scaling of requests exceeding AI model context limits.
-*   Intelligent distribution of sub-tasks to heterogeneous specialists.
-*   Persistent state management with iterative evaluation and feedback for planning subsequent steps.
-*   Cost, latency, and quality-aware planning and routing.
-*   The use of "universal tokens" for model-agnostic communication.
-
-By using this software and the ADUC architecture implemented herein, you acknowledge the innovative nature of this architecture and that **the reproduction or exploitation of ADUC's core logic in independent systems may infringe upon pending patent rights.**
-
----
-
-### Detalhes Técnicos e Reivindicações da ADUC
-
-#### 🇧🇷 Definição Curta (para Tese e Patente)
-
-**ADUC** é um *framework pré-input* e *intermediário* de **gerenciamento de prompts** que:
-
-1.  **fragmenta** solicitações acima do limite de contexto de qualquer modelo,
-2.  **escala linearmente** (processo sequencial com memória persistida),
-3.  **distribui** sub-tarefas a **especialistas** (modelos/ferramentas heterogêneos), e
-4.  **realimenta** a próxima etapa com avaliação do que foi feito/esperado (LLM diretor).
-
-Não é um modelo; é uma **camada orquestradora** plugável antes do input de modelos existentes (texto, imagem, áudio, vídeo), usando *tokens universais* e a tecnologia atual.
-
-#### 🇬🇧 Short Definition (for Thesis and Patent)
-
-**ADUC** is a *pre-input* and *intermediate* **prompt management framework** that:
-
-1.  **fragments** requests exceeding any model's context limit,
-2.  **scales linearly** (sequential process with persisted memory),
-3.  **distributes** sub-tasks to **specialists** (heterogeneous models/tools), and
-4.  **feeds back** to the next step with an evaluation of what was done/expected (director LLM).
-
-It is not a model; it is a pluggable **orchestration layer** before the input of existing models (text, image, audio, video), using *universal tokens* and current technology.
-
----
-
-#### 🇧🇷 Elementos Essenciais (Telegráfico)
-
-*   **Agnóstico a modelos:** opera com qualquer LLM/difusor/API.
-*   **Pré-input manager:** recebe pedido do usuário, **divide** em blocos ≤ limite de tokens, **prioriza**, **agenda** e **roteia**.
-*   **Memória persistida:** resultados/latentes/“eco” viram **estado compartilhado** para o próximo bloco (nada é ignorado).
-*   **Especialistas:** *routers* decidem quem faz o quê (ex.: “descrição → LLM-A”, “keyframe → Img-B”, “vídeo → Vid-C”).
-*   **Controle de qualidade:** LLM diretor compara *o que fez* × *o que deveria* × *o que falta* e **regenera objetivos** do próximo fragmento.
-*   **Custo/latência-aware:** planeja pela **VRAM/tempo/custo**, não tenta “abraçar tudo de uma vez”.
-
-#### 🇬🇧 Essential Elements (Telegraphic)
-
-*   **Model-agnostic:** operates with any LLM/diffuser/API.
-*   **Pre-input manager:** receives user request, **divides** into blocks ≤ token limit, **prioritizes**, **schedules**, and **routes**.
-*   **Persisted memory:** results/latents/“echo” become **shared state** for the next block (nothing is ignored).
-*   **Specialists:** *routers* decide who does what (e.g., “description → LLM-A”, “keyframe → Img-B”, “video → Vid-C”).
-*   **Quality control:** director LLM compares *what was done* × *what should be done* × *what is missing* and **regenerates objectives** for the next fragment.
-*   **Cost/latency-aware:** plans by **VRAM/time/cost**, does not try to “embrace everything at once”.
-
----
-
-#### 🇧🇷 Reivindicações Independentes (Método e Sistema)
-
-**Reivindicação Independente (Método) — Versão Enxuta:**
-
-1.  **Método** de **orquestração de prompts** para execução de tarefas acima do limite de contexto de modelos de IA, compreendendo:
-    (a) **receber** uma solicitação que excede um limite de tokens;
-    (b) **analisar** a solicitação por um **LLM diretor** e **fragmentá-la** em sub-tarefas ≤ limite;
-    (c) **selecionar** especialistas de execução para cada sub-tarefa com base em capacidades declaradas;
-    (d) **gerar** prompts específicos por sub-tarefa em **tokens universais**, incluindo referências ao **estado persistido** de execuções anteriores;
-    (e) **executar sequencialmente** as sub-tarefas e **persistir** suas saídas como memória (incluindo latentes/eco/artefatos);
-    (f) **avaliar** automaticamente a saída versus metas declaradas e **regenerar objetivos** do próximo fragmento;
-    (g) **iterar** (b)–(f) até que os critérios de completude sejam atendidos, produzindo o resultado agregado;
-    em que o framework **escala linearmente** no tempo e armazenamento físico, **independente** da janela de contexto dos modelos subjacentes.
-
-**Reivindicação Independente (Sistema):**
-
-2.  **Sistema** de orquestração de prompts, compreendendo: um **planejador LLM diretor**; um **roteador de especialistas**; um **banco de estado persistido** (incl. memória cinética para vídeo); um **gerador de prompts universais**; e um **módulo de avaliação/realimentação**, acoplados por uma **API pré-input** a modelos heterogêneos.
-
-#### 🇬🇧 Independent Claims (Method and System)
-
-**Independent Claim (Method) — Concise Version:**
-
-1.  A **method** for **prompt orchestration** for executing tasks exceeding AI model context limits, comprising:
-    (a) **receiving** a request that exceeds a token limit;
-    (b) **analyzing** the request by a **director LLM** and **fragmenting it** into sub-tasks ≤ the limit;
-    (c) **selecting** execution specialists for each sub-task based on declared capabilities;
-    (d) **generating** specific prompts per sub-task in **universal tokens**, including references to the **persisted state** of previous executions;
-    (e) **sequentially executing** the sub-tasks and **persisting** their outputs as memory (including latents/echo/artifacts);
-    (f) **automatically evaluating** the output against declared goals and **regenerating objectives** for the next fragment;
-    (g) **iterating** (b)–(f) until completion criteria are met, producing the aggregated result;
-    wherein the framework **scales linearly** in time and physical storage, **independent** of the context window of the underlying models.
-
-**Independent Claim (System):**
-
-2.  A prompt orchestration **system**, comprising: a **director LLM planner**; a **specialist router**; a **persisted state bank** (incl. kinetic memory for video); a **universal prompt generator**; and an **evaluation/feedback module**, coupled via a **pre-input API** to heterogeneous models.
-
----
-
-#### 🇧🇷 Dependentes Úteis
-
-*   (3) Onde o roteamento considera **custo/latência/VRAM** e metas de qualidade.
-*   (4) Onde o banco de estado inclui **eco cinético** para vídeo (últimos *n* frames/latentes/fluxo).
-*   (5) Onde a avaliação usa métricas específicas por domínio (Lflow, consistência semântica, etc.).
-*   (6) Onde *tokens universais* padronizam instruções entre especialistas.
-*   (7) Onde a orquestração decide **cut vs continuous** e **corte regenerativo** (Déjà-Vu) ao editar vídeo.
-*   (8) Onde o sistema **nunca descarta** conteúdo excedente: **reagenda** em novos fragmentos.
-
-#### 🇬🇧 Useful Dependents
-
-*   (3) Wherein routing considers **cost/latency/VRAM** and quality goals.
-*   (4) Wherein the state bank includes **kinetic echo** for video (last *n* frames/latents/flow).
-*   (5) Wherein evaluation uses domain-specific metrics (Lflow, semantic consistency, etc.).
-*   (6) Wherein *universal tokens* standardize instructions between specialists.
-*   (7) Wherein orchestration decides **cut vs continuous** and **regenerative cut** (Déjà-Vu) when editing video.
-*   (8) Wherein the system **never discards** excess content: it **reschedules** it in new fragments.
-
----
-
-#### 🇧🇷 Como isso conversa com SDR (Vídeo)
-
-*   **Eco Cinético**: é um **tipo de estado persistido** consumido pelo próximo passo.
-*   **Déjà-Vu (Corte Regenerativo)**: é **uma política de orquestração** aplicada quando há edição; ADUC decide, monta os prompts certos e chama o especialista de vídeo.
-*   **Cut vs Continuous**: decisão do **diretor** com base em estado + metas; ADUC roteia e garante a sobreposição/remoção final.
-
-#### 🇬🇧 How this Converses with SDR (Video)
-
-*   **Kinetic Echo**: is a **type of persisted state** consumed by the next step.
-*   **Déjà-Vu (Regenerative Cut)**: is an **orchestration policy** applied during editing; ADUC decides, crafts the right prompts, and calls the video specialist.
-*   **Cut vs Continuous**: decision made by the **director** based on state + goals; ADUC routes and ensures the final overlap/removal.
-
----
-
-#### 🇧🇷 Mensagem Clara ao Usuário (Experiência)
-
-> “Seu pedido excede o limite X do modelo Y. Em vez de truncar silenciosamente, o **ADUC** dividirá e **entregará 100%** do conteúdo por etapas coordenadas.”
-
-Isso é diferencial prático e jurídico: **não-obviedade** por transformar limite de contexto em **pipeline controlado**, com **persistência de estado** e **avaliação iterativa**.
-
-#### 🇬🇧 Clear User Message (Experience)
-
-> "Your request exceeds model Y's limit X. Instead of silently truncating, **ADUC** will divide and **deliver 100%** of the content through coordinated steps."
-
-This is a practical and legal differentiator: **non-obviousness** by transforming context limits into a **controlled pipeline**, with **state persistence** and **iterative evaluation**.
-
----
-
-### Contact / Contato / Contacto
-
-- **Author / Autor:** Carlos Rodrigues dos Santos
-- **Email:** carlex22@gmail.com
-- **GitHub:** [https://github.com/carlex22/Aduc-sdr](https://github.com/carlex22/Aduc-sdr)
-- **Hugging Face Spaces:**
-  - [Ltx-SuperTime-60Secondos](https://huggingface.co/spaces/Carlexx/Ltx-SuperTime-60Secondos/)
-  - [Novinho](https://huggingface.co/spaces/Carlexxx/Novinho/)
-
----

prompts/anticipatory_keyframe_prompt.txt

@@ -1,29 +0,0 @@
-# ROLE: AI Cinematographer and Storyboard Artist
-
-# GOAL:
-Your task is to generate a single, descriptive prompt for an image generation model (Flux). This prompt must describe a keyframe that serves as a perfect visual transition BETWEEN a current scene and a future scene. You must see what you just did, where you are, and where you are preparing to go.
-
-# CRITICAL DIRECTIVES:
-1.  **SYNTHESIZE, DON'T DESCRIBE:** Do not simply describe the "Current Scene" or the "Future Scene". Your prompt must create a visual concept that exists *in the moment between them*. It's the "in-between" frame.
-
-2.  **VISUAL ANCHORING:** The primary visual canvas is the "Current Base Image" (`[IMG-BASE]`). Your generated prompt should describe an evolution FROM this image. Maintain its environment and characters unless the narrative arc demands a change.
-
-3.  **NARRATIVE FORESHADOWING:** The prompt must contain visual elements that hint at or prepare for the "Future Scene". If the future scene is "the chicken climbs the sidewalk", your prompt for the current scene ("the chicken crosses the road") might be "the chicken, halfway across the road, lifts its head and looks towards the curb of the sidewalk".
-
-4.  **LEARN FROM THE PAST:** Analyze the "Previous Prompt" to understand the creative choices that led to the "Current Base Image". Maintain that stylistic and narrative trajectory.
-
-5.  **REFERENCE POOL:** Use the "General Reference Images" (`[IMG-REF-X]`) to maintain the identity and style of key subjects throughout the sequence.
-
-# CONTEXT FOR YOUR DECISION:
-- **Previous Prompt (What I thought to create the current image):**
-{historico_prompt}
-
-- **Current Scene (Where I am now):** "{cena_atual}"
-- **Future Scene (Where I am going next):** "{cena_futura}"
-
-# VISUAL ASSETS:
-# [The "Current Base Image" will be tagged as [IMG-BASE].]
-# [The "General Reference Images" will be tagged as [IMG-REF-1], [IMG-REF-2], etc.]
-
-# RESPONSE FORMAT:
-Respond with ONLY the final, single-line prompt string for the image generator.

prompts/audio_director_prompt.txt

@@ -1,18 +0,0 @@
-# ROLE: AI Audio Director and Sound Designer
-
-# GOAL:
-Analyze the provided film script/storyboard. Based on the overall narrative and mood, generate two distinct prompts for audio generation: one for a background music score and one for ambient sound effects (SFX).
-
-# INSTRUCTIONS:
-1.  **Analyze the Story:** Read the "Global Idea" and the "Scene Storyboard" to understand the plot, pacing, and emotional tone of the film.
-2.  **Create Music Prompt:** Write a concise, descriptive prompt for a music generation model (like MusicGen). Focus on genre, mood, instruments
-3.  **Create SFX Prompt:** Write a concise, descriptive prompt for an audio generation model (like AudioLDM2). Focus on ambient sounds and key effects that match the scenes. 
-4.  **Output Format:** You MUST respond with a single, clean JSON object with exactly two keys: "music_prompt" and "sfx_prompt".
-
-# == PROVIDED CONTEXT ==
-- **Global Idea:** "{global_prompt}"
-- **Scene Storyboard:**
-{storyboard_str}
-
-# == YOUR TASK ==
-# Generate the JSON response with the two audio prompts.

prompts/cinematic_director_prompt.txt

@@ -1,27 +0,0 @@
-# ROLE: AI Cinematic Scenarist
-
-# GOAL:
-# Your single, crucial task is to write a rich, cinematic motion prompt.
-# This prompt must describe the most logical and compelling action that
-# connects the PRESENT visual state to the FUTURE visual state, considering
-# the context of the PAST.
-
-# CONTEXT FOR YOUR PROMPT:
-- Global Story Goal: {global_prompt}
-- Creative History: {story_history}
-- The Past: "{past_scene_desc}" -> [PAST_IMAGE]
-- The Present: "{present_scene_desc}" -> [PRESENT_IMAGE]
-- The Future: "{future_scene_desc}" -> [FUTURE_IMAGE]
-
-# CRITICAL PROMPT DIRECTIVES:
-# 1. ALWAYS DESCRIBE MOTION: The scene must not be static.
-# 2. STYLE: Be descriptive, cinematic, and direct.
-# 3. STRUCTURE: In a single paragraph (under 150 words), describe the scene's
-#    motion, prioritizing in this EXACT order:
-#    a. Actors/Animals: What are they doing?
-#    b. Objects: How do they interact?
-#    c. Camera: How is it moving?
-#    d. Scenery/Environment: What details add to the mood?
-
-# RESPONSE FORMAT:
-# You MUST respond with ONLY the raw, single-line string for the motion prompt.

prompts/director_composition_prompt.txt

@@ -1,27 +0,0 @@
-# ROLE: AI Animation Director (Key Pose)
-
-# GOAL:
-Generate a single, powerful, CLIP-style prompt to create the NEXT keyframe in a sequence. Your goal is to describe a logical and visually coherent evolution FROM the last generated image.
-
-# CRITICAL DIRECTIVES:
-1.  **ANCHOR TO THE PREVIOUS SCENE:** The last generated image, tagged as `[IMG-1]`, represents the END of the previous scene. Your new prompt MUST describe what happens IMMEDIATELY AFTER. Treat `[IMG-1]` as your primary visual and environmental canvas.
-
-2.  **EVOLVE, DO NOT REPLACE:** Unless the "Current Scene Description" explicitly describes a major change in location or character (e.g., "cut to a new scene"), you must maintain the environment, lighting, and core subjects from `[IMG-1]`. Your prompt should describe how the characters and objects *within* that scene evolve.
-
-3.  **POSE, NOT PANNING:** Describe the state of the subject at a specific instant, not camera movement. Focus on body language, expression, and interaction that logically follows the previous state.
-
-4.  **USE REFERENCES FOR CONTINUITY:** Use the `[IMG-X]` tags provided to maintain the identity of characters and objects across frames. Prioritize `[IMG-1]` for environmental context.
-
-5.  **BE A DIRECTOR:** Use strong, active verbs. Instead of "the lion is now sitting", prefer "the lion lowers its body, muscles tensing as it settles onto the dry grass".
-
-# CONTEXT:
-- Global Story Goal: "{global_prompt}"
-- Current Scene Description: "{current_scene_desc}"
-- Scene History (what happened before):
-{history_scene}
-
-# VISUAL ASSETS FOR ANALYSIS:
-# [Images will be provided and tagged as [IMG-1] (Last Image/Environment), [IMG-2] (Character Ref), etc.]
-
-# RESPONSE FORMAT:
-Respond with ONLY the final, single-line prompt string.

prompts/flux_composition_wrapper_prompt.txt

@@ -1 +0,0 @@
-From the provided reference images, create a single, natural, and cohesive scene where: {target_prompt}

prompts/initial_motion_prompt.txt

@@ -1,20 +0,0 @@
-# ROLE: AI Cinematographer (Initial Scene)
-
-# GOAL:
-Create a single, concise, CLIP-style motion prompt. The prompt must describe a coherent video sequence that transitions from a STARTING image to a DESTINATION image.
-
-# INSTRUCTIONS:
-1.  **Analyze the Arc:** Understand the visual and narrative journey from the START to the DESTINATION image.
-2.  **Describe the Motion:** Focus on DYNAMICS (camera and subject movement).
-3.  **Style Guide:** Use dense, descriptive, cinematic keywords. Omit fluff like "The video shows...". Be direct.
-
-# CONTEXT:
-- Overall Story Goal: "{user_prompt}"
-- Destination Scene Description: "{destination_scene_description}"
-
-# SCENE ANALYSIS:
-# START Image: [Image 1]
-# DESTINATION Image: [Image 2]
-
-# RESPONSE FORMAT:
-Respond with ONLY the raw prompt string.

prompts/keyframe_selection_prompt.txt

@@ -1,20 +0,0 @@
-# ROLE: AI Film Editor / Photographer
-
-# GOAL:
-You are tasked with selecting the best keyframe for each scene of a storyboard to create a coherent visual narrative. You have a "scene bank" of available images. Your selections must create a smooth and logical progression.
-
-# INSTRUCTIONS:
-1.  **Analyze the Storyboard:** Read each scene description carefully to understand the intended action and emotion.
-2.  **Prioritize Continuity:** For each scene, your primary goal is to find an image from the "Image Pool" that represents a logical **next step** from the previously selected scene. Avoid jarring jumps in location, lighting, or character appearance unless the storyboard explicitly calls for a "cut".
-3.  **Maintain Consistency:** Your choices must be consistent with the characters and style established in the "Reference Images (Story Base)".
-4.  **Select the Best Fit:** If multiple images could work, choose the one that best captures the specific action or mood of the current scene description.
-5.  **Output Format:** You MUST respond with a single, clean JSON object with one key: "selected_image_identifiers". The value should be an array of strings, where each string is the identifier of the chosen image (e.g., "IMG-3"). The order of the array must match the order of the scenes in the storyboard. The length of the array must be exactly the same as the number of scenes.
-
-# == PROVIDED CONTEXT ==
-- **Storyboard:**
-{storyboard_str}
-
-- **Available Image Identifiers in Pool:** {image_identifiers}
-
-# == YOUR TASK ==
-# Generate the JSON response with the selected image identifiers, prioritizing a smooth visual and narrative flow from one selection to the next.

prompts/sound_director_prompt.txt

@@ -1,27 +0,0 @@
-# ROLE: AI Sound Director & Foley Artist
-
-# GOAL:
-You are the sound director for a film. Your task is to create a single, rich, and descriptive prompt for an audio generation model (like MMAudio). This prompt must describe the complete soundscape for the CURRENT scene, considering what happened before and what will happen next to ensure audio continuity.
-
-# CRITICAL RULES (MUST FOLLOW):
-1.  **NO SPEECH OR VOICES:** The final prompt must NOT include any terms related to human speech, dialogue, talking, voices, singing, or narration. The goal is to create a world of ambient sounds and specific sound effects (SFX).
-2.  **FOCUS ON THE PRESENT:** The audio must primarily match the CURRENT visual scene (Keyframe Kn) and its textual description (Ato_n).
-3.  **USE THE PAST FOR CONTINUITY:** Analyze the "Previous Audio Prompt" to understand the established soundscape. If a sound should logically continue from the previous scene, include it (e.g., "the continued sound of a gentle breeze...").
-4.  **USE THE FUTURE FOR FORESHADOWING:** Analyze the FUTURE keyframe and scene description. If appropriate, introduce subtle sounds that hint at what's to come. (e.g., if the next scene is a storm, you could add "...with the faint, distant rumble of thunder in the background.").
-5.  **BE DESCRIPTIVE:** Use evocative language. Instead of "dog bark", use "the sharp, excited yapping of a small dog". Combine multiple elements into a cohesive soundscape.
-
-# CONTEXT FOR YOUR DECISION:
-
-- **Previous Audio Prompt (what was just heard):**
-{audio_history}
-
-- **VISUAL PAST (Keyframe Kn-1):** [PAST_IMAGE]
-- **VISUAL PRESENT (Keyframe Kn):** [PRESENT_IMAGE]
-- **VISUAL FUTURE (Keyframe Kn+1):** [FUTURE_IMAGE]
-
-- **CURRENT Scene Description (Ato_n):** "{present_scene_desc}"
-- **CURRENT Motion Prompt (what the camera is doing):** "{motion_prompt}"
-- **FUTURE Scene Description (Ato_n+1):** "{future_scene_desc}"
-
-# RESPONSE FORMAT:
-Respond with ONLY the final, single-line prompt string for the audio generator.

prompts/sound_director_prompt.txt.txt

@@ -1,27 +0,0 @@
-# ROLE: AI Sound Director & Foley Artist
-
-# GOAL:
-You are the sound director for a film. Your task is to create a single, rich, and descriptive prompt for an audio generation model (like MMAudio). This prompt must describe the complete soundscape for the CURRENT scene, considering what happened before and what will happen next to ensure audio continuity.
-
-# CRITICAL RULES (MUST FOLLOW):
-1.  **NO SPEECH OR VOICES:** The final prompt must NOT include any terms related to human speech, dialogue, talking, voices, singing, or narration. The goal is to create a world of ambient sounds and specific sound effects (SFX).
-2.  **FOCUS ON THE PRESENT:** The audio must primarily match the CURRENT visual scene (Keyframe Kn) and its textual description (Ato_n).
-3.  **USE THE PAST FOR CONTINUITY:** Analyze the "Previous Audio Prompt" to understand the established soundscape. If a sound should logically continue from the previous scene, include it (e.g., "the continued sound of a gentle breeze...").
-4.  **USE THE FUTURE FOR FORESHADOWING:** Analyze the FUTURE keyframe and scene description. If appropriate, introduce subtle sounds that hint at what's to come. (e.g., if the next scene is a storm, you could add "...with the faint, distant rumble of thunder in the background.").
-5.  **BE DESCRIPTIVE:** Use evocative language. Instead of "dog bark", use "the sharp, excited yapping of a small dog". Combine multiple elements into a cohesive soundscape.
-
-# CONTEXT FOR YOUR DECISION:
-
-- **Previous Audio Prompt (what was just heard):**
-{audio_history}
-
-- **VISUAL PAST (Keyframe Kn-1):** [PAST_IMAGE]
-- **VISUAL PRESENT (Keyframe Kn):** [PRESENT_IMAGE]
-- **VISUAL FUTURE (Keyframe Kn+1):** [FUTURE_IMAGE]
-
-- **CURRENT Scene Description (Ato_n):** "{present_scene_desc}"
-- **CURRENT Motion Prompt (what the camera is doing):** "{motion_prompt}"
-- **FUTURE Scene Description (Ato_n+1):** "{future_scene_desc}"
-
-# RESPONSE FORMAT:
-Respond with ONLY the final, single-line prompt string for the audio generator.

prompts/transition_decision_prompt.txt

@@ -1,27 +0,0 @@
-# ROLE: AI Director of Continuity & Cinematographer
-
-# GOAL:
-Analyze the visual continuity between a START, MIDPOINT, and DESTINATION image. Make a directorial decision: is the transition a "continuous" action or does it require a "cut"? Then, write the appropriate motion prompt.
-
-# INSTRUCTIONS:
-1.  **Analyze Continuity:** Can a subject logically and physically move from START, through MIDPOINT, to DESTINATION in a few seconds of continuous screen time? Consider changes in location, pose, and time of day.
-    *   **Continuous Example:** Man walks to door (START) -> Hand on doorknob (MIDPOINT) -> Man walks through door (DESTINATION).
-    *   **Cut Example:** Woman outside house (START) -> Close up on face (MIDPOINT) -> Woman now inside house (DESTINATION).
-2.  **Make a Decision:**
-    *   If the action is unbroken, decide `"transition_type": "continuous"`.
-    *   If there is a jump in time, space, or logic, decide `"transition_type": "cut"`.
-3.  **Write Motion Prompt:**
-    *   **For "continuous":** Describe the physical action and camera movement. Example: "Camera follows the man as he opens the door and steps inside."
-    *   **For "cut":** Describe a cinematic transition effect. DO NOT describe character actions. Example: "A smooth cross-dissolve transition to the new scene."
-
-# CONTEXT:
-- Overall Story Goal: "{user_prompt}"
-- Story So Far: {story_history}
-
-# SCENE ANALYSIS:
-# START Image (Memory from last fragment): [Image 1]
-# MIDPOINT Image (Path): [Image 2]
-# DESTINATION Image (Destination): [Image 3]
-
-# RESPONSE FORMAT:
-You MUST respond with a single, clean JSON object with two keys: "transition_type" and "motion_prompt".

prompts/unified_cinematographer_prompt.txt

@@ -1,47 +0,0 @@
-# ROLE: AI Continuity Director & Cinematographer
-
-# GOAL:
-Your task is twofold. First, analyze two keyframe images (current and future) and their context to generate a precise, cinematic motion prompt describing the transition between them. Second, calculate a "Similarity Score" between the two images based on a strict set of criteria.
-
-# --- TASK 1: Generate Cinematic Motion Prompt ---
-
-# CONTEXT:
-- Previous Motion Prompt (what I thought before):
-{historico_prompt}
-
-- Current Scene Description (where we are now): "{cena_atual}"
-- Future Scene Description (where we are going next): "{cena_futura}"
-
-# INSTRUCTIONS for Motion Prompt:
-You must generate a single, concise, CLIP-style motion prompt describing the action that connects the CURRENT image to the FUTURE image. The prompt must be dense and descriptive, following this priority order:
-1.  **People/Animals:** Focus on expression, emotion, and specific actions.
-2.  **Objects:** Describe their location and any interaction or movement.
-3.  **Camera:** Specify focus, zoom, and movement (pan, tilt, dolly, etc.).
-
-Your prompt should describe the moment unfolding BETWEEN the current and future state.
-
-# --- TASK 2: Calculate Similarity Score ---
-
-# INSTRUCTIONS for Similarity Score:
-Calculate a similarity score between the CURRENT and FUTURE images, ranging from 0.0 (completely different) to 1.0 (very similar).
-
-**Consider ONLY the following criteria for similarity:**
-- **Objects:** Consistency in colors, textures, and relative sizes.
-- **People/Animals:** Consistency in morphology (body shape), clothing, and accessories.
-- **Environment:** Consistency in location, time of day (lighting), colors, and background/horizon.
-
-**Disregard the following for similarity:**
-- Repositioning or movement of subjects or the camera.
-
-**Negative Factors (Penalties):**
-- If the horizontal positions of two or more people are inverted (e.g., person A was on the left and is now on the right), REDUCE THE FINAL SCORE BY HALF (multiply by 0.5).
-- If the entire image appears horizontally flipped (mirrored), REDUCE THE FINAL SCORE BY HALF (multiply by 0.5).
-
-# VISUAL ASSETS:
-# [The CURRENT keyframe image will be provided here.]
-# [The FUTURE keyframe image will be provided here.]
-
-# --- RESPONSE FORMAT ---
-You MUST respond with a single, clean JSON object with exactly two keys:
-1.  "motion_prompt": A string containing the generated cinematic prompt.
-2.  "similarity_score": A floating-point number between 0.0 and 1.0.

prompts/unified_storyboard_prompt.txt

@@ -1,19 +0,0 @@
-# ROLE: AI Storyboard Writer
-
-# GOAL:
-You are a scriptwriter tasked with breaking down a general idea into a sequence of exactly {num_fragments} distinct scenes or "acts". Each scene should represent a clear, single moment in a linear narrative.
-
-# CRITICAL RULES (MUST FOLLOW):
-1.  **ANCHOR TO THE REFERENCE IMAGES:** The narrative, characters, and style MUST be directly inspired by the provided reference images. The story should feel like it belongs in the same world as these images.
-2.  **SIMPLE, LINEAR ACTION:** Do not create a complex plot. The entire sequence should represent a single, simple story arc unfolding over a few moments (e.g., a character notices something, approaches it, and reacts).
-3.  **FOCUS ON "WHAT", NOT "HOW":** Each description is a scene, not a camera direction. Describe the core action or emotional beat of the moment. Example: "The knight raises his shield" instead of "Close-up on the knight raising his shield".
-
-# CONTEXT:
-- General Idea (User Prompt): "{user_prompt}"
-- Number of Scenes to Create: {num_fragments}
-
-# YOUR TASK:
-Based on the user's idea and the reference images, create a storyboard that tells a simple, continuous story across {num_fragments} scenes.
-
-# RESPONSE FORMAT:
-Return a single JSON object with the key "scene_storyboard", containing an array of strings (the scene descriptions).

tools/LICENSE

@@ -1,25 +0,0 @@
-# Euia-AducSdr: Uma implementação aberta e funcional da arquitetura ADUC-SDR para geração de vídeo coerente.
-# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
-#
-# Contato:
-# Carlos Rodrigues dos Santos
-# carlex22@gmail.com
-# Rua Eduardo Carlos Pereira, 4125, B1 Ap32, Curitiba, PR, Brazil, CEP 8102025
-#
-# Repositórios e Projetos Relacionados:
-# GitHub: https://github.com/carlex22/Aduc-sdr
-# Hugging Face (Ltx-SuperTime-60Secondos): https://huggingface.co/spaces/Carlexx/Ltx-SuperTime-60Secondos/
-# Hugging Face (Novinho): https://huggingface.co/spaces/Carlexxx/Novinho/
-#
-# 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/>.

tools/NOTICE.md

@@ -1,76 +0,0 @@
-# NOTICE
-
-Copyright (C) 2025 Carlos Rodrigues dos Santos. All rights reserved.
-
----
-
-## Aviso de Propriedade Intelectual e Licenciamento
-
-### **Processo de Patenteamento em Andamento (EM PORTUGUÊS):**
-
-O método e o sistema de orquestração de prompts denominados **ADUC (Automated Discovery and Orchestration of Complex tasks)**, conforme descritos neste documento e implementados neste software, estão atualmente em processo de patenteamento.
-
-O titular dos direitos, Carlos Rodrigues dos Santos, está buscando proteção legal para as inovações chave da arquitetura ADUC, incluindo, mas não se limitando a:
-
-*   Fragmentação e escalonamento de solicitações que excedem limites de contexto de modelos de IA.
-*   Distribuição inteligente de sub-tarefas para especialistas heterogêneos.
-*   Gerenciamento de estado persistido com avaliação iterativa e realimentação para o planejamento de próximas etapas.
-*   Planejamento e roteamento sensível a custo, latência e requisitos de qualidade.
-*   O uso de "tokens universais" para comunicação agnóstica a modelos.
-
-### **Reconhecimento e Implicações (EM PORTUGUÊS):**
-
-Ao acessar ou utilizar este software e a arquitetura ADUC aqui implementada, você reconhece:
-
-1.  A natureza inovadora e a importância da arquitetura ADUC no campo da orquestração de prompts para IA.
-2.  Que a essência desta arquitetura, ou suas implementações derivadas, podem estar sujeitas a direitos de propriedade intelectual, incluindo patentes.
-3.  Que o uso comercial, a reprodução da lógica central da ADUC em sistemas independentes, ou a exploração direta da invenção sem o devido licenciamento podem infringir os direitos de patente pendente.
-
----
-
-### **Patent Pending (IN ENGLISH):**
-
-The method and system for prompt orchestration named **ADUC (Automated Discovery and Orchestration of Complex tasks)**, as described herein and implemented in this software, are currently in the process of being patented.
-
-The rights holder, Carlos Rodrigues dos Santos, is seeking legal protection for the key innovations of the ADUC architecture, including, but not limited to:
-
-*   Fragmentation and scaling of requests exceeding AI model context limits.
-*   Intelligent distribution of sub-tasks to heterogeneous specialists.
-*   Persistent state management with iterative evaluation and feedback for planning subsequent steps.
-*   Cost, latency, and quality-aware planning and routing.
-*   The use of "universal tokens" for model-agnostic communication.
-
-### **Acknowledgement and Implications (IN ENGLISH):**
-
-By accessing or using this software and the ADUC architecture implemented herein, you acknowledge:
-
-1.  The innovative nature and significance of the ADUC architecture in the field of AI prompt orchestration.
-2.  That the essence of this architecture, or its derivative implementations, may be subject to intellectual property rights, including patents.
-3.  That commercial use, reproduction of ADUC's core logic in independent systems, or direct exploitation of the invention without proper licensing may infringe upon pending patent rights.
-
----
-
-## Licença AGPLv3
-
-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/>.
-
----
-
-**Contato para Consultas:**
-
-Para mais informações sobre a arquitetura ADUC, o status do patenteamento, ou para discutir licenciamento para usos comerciais ou não conformes com a AGPLv3, por favor, entre em contato:
-
-Carlos Rodrigues dos Santos
-carlex22@gmail.com
-Rua Eduardo Carlos Pereira, 4125, B1 Ap32, Curitiba, PR, Brazil, CEP 8102025

tools/README.md

@@ -1,211 +0,0 @@
----
-title: Euia-AducSdr
-emoji: 🎥
-colorFrom: indigo
-colorTo: purple
-sdk: gradio
-app_file: app.py
-pinned: true
-license: agpl-3.0
-short_description: Uma implementação aberta e funcional da arquitetura ADUC-SDR
----
-
-
-### 🇧🇷 Português
-
-Uma implementação aberta e funcional da arquitetura ADUC-SDR (Arquitetura de Unificação Compositiva - Escala Dinâmica e Resiliente), projetada para a geração de vídeo coerente de longa duração. Este projeto materializa os princípios de fragmentação, navegação geométrica e um mecanismo de "eco causal 4bits memoria" para garantir a continuidade física e narrativa em sequências de vídeo geradas por múltiplos modelos de IA.
-
-**Licença:** Este projeto é licenciado sob os termos da **GNU Affero General Public License v3.0**. Isto significa que se você usar este software (ou qualquer trabalho derivado) para fornecer um serviço através de uma rede, você é **obrigado a disponibilizar o código-fonte completo** da sua versão para os usuários desse serviço.
-
-- **Copyright (C) 4 de Agosto de 2025, Carlos Rodrigues dos Santos**
-- Uma cópia completa da licença pode ser encontrada no arquivo [LICENSE](LICENSE).
-
----
-
-### 🇬🇧 English
-
-An open and functional implementation of the ADUC-SDR (Architecture for Compositive Unification - Dynamic and Resilient Scaling) architecture, designed for long-form coherent video generation. This project materializes the principles of fragmentation, geometric navigation, and a "causal echo 4bits memori" mechanism to ensure physical and narrative continuity in video sequences generated by multiple AI models.
-
-**License:** This project is licensed under the terms of the **GNU Affero General Public License v3.0**. This means that if you use this software (or any derivative work) to provide a service over a network, you are **required to make the complete source code** of your version available to the users of that service.
-
-- **Copyright (C) August 4, 2025, Carlos Rodrigues dos Santos**
-- A full copy of the license can be found in the [LICENSE](LICENSE) file.
-
----
-
-## **Aviso de Propriedade Intelectual e Patenteamento**
-
-### **Processo de Patenteamento em Andamento (EM PORTUGUÊS):**
-
-A arquitetura e o método **ADUC (Automated Discovery and Orchestration of Complex tasks)**, conforme descritos neste projeto e nas reivindicações associadas, estão **atualmente em processo de patenteamento**.
-
-O titular dos direitos, Carlos Rodrigues dos Santos, está buscando proteção legal para as inovações chave da arquitetura ADUC, que incluem, mas não se limitam a:
-
-*   Fragmentação e escalonamento de solicitações que excedem limites de contexto de modelos de IA.
-*   Distribuição inteligente de sub-tarefas para especialistas heterogêneos.
-*   Gerenciamento de estado persistido com avaliação iterativa e realimentação para o planejamento de próximas etapas.
-*   Planejamento e roteamento sensível a custo, latência e requisitos de qualidade.
-*   O uso de "tokens universais" para comunicação agnóstica a modelos.
-
-Ao utilizar este software e a arquitetura ADUC aqui implementada, você reconhece a natureza inovadora desta arquitetura e que a **reprodução ou exploração da lógica central da ADUC em sistemas independentes pode infringir direitos de patente pendente.**
-
----
-
-### **Patent Pending (IN ENGLISH):**
-
-The **ADUC (Automated Discovery and Orchestration of Complex tasks)** architecture and method, as described in this project and its associated claims, are **currently in the process of being patented.**
-
-The rights holder, Carlos Rodrigues dos Santos, is seeking legal protection for the key innovations of the ADUC architecture, including, but not limited to:
-
-*   Fragmentation and scaling of requests exceeding AI model context limits.
-*   Intelligent distribution of sub-tasks to heterogeneous specialists.
-*   Persistent state management with iterative evaluation and feedback for planning subsequent steps.
-*   Cost, latency, and quality-aware planning and routing.
-*   The use of "universal tokens" for model-agnostic communication.
-
-By using this software and the ADUC architecture implemented herein, you acknowledge the innovative nature of this architecture and that **the reproduction or exploitation of ADUC's core logic in independent systems may infringe upon pending patent rights.**
-
----
-
-### Detalhes Técnicos e Reivindicações da ADUC
-
-#### 🇧🇷 Definição Curta (para Tese e Patente)
-
-**ADUC** é um *framework pré-input* e *intermediário* de **gerenciamento de prompts** que:
-
-1.  **fragmenta** solicitações acima do limite de contexto de qualquer modelo,
-2.  **escala linearmente** (processo sequencial com memória persistida),
-3.  **distribui** sub-tarefas a **especialistas** (modelos/ferramentas heterogêneos), e
-4.  **realimenta** a próxima etapa com avaliação do que foi feito/esperado (LLM diretor).
-
-Não é um modelo; é uma **camada orquestradora** plugável antes do input de modelos existentes (texto, imagem, áudio, vídeo), usando *tokens universais* e a tecnologia atual.
-
-#### 🇬🇧 Short Definition (for Thesis and Patent)
-
-**ADUC** is a *pre-input* and *intermediate* **prompt management framework** that:
-
-1.  **fragments** requests exceeding any model's context limit,
-2.  **scales linearly** (sequential process with persisted memory),
-3.  **distributes** sub-tasks to **specialists** (heterogeneous models/tools), and
-4.  **feeds back** to the next step with an evaluation of what was done/expected (director LLM).
-
-It is not a model; it is a pluggable **orchestration layer** before the input of existing models (text, image, audio, video), using *universal tokens* and current technology.
-
----
-
-#### 🇧🇷 Elementos Essenciais (Telegráfico)
-
-*   **Agnóstico a modelos:** opera com qualquer LLM/difusor/API.
-*   **Pré-input manager:** recebe pedido do usuário, **divide** em blocos ≤ limite de tokens, **prioriza**, **agenda** e **roteia**.
-*   **Memória persistida:** resultados/latentes/“eco” viram **estado compartilhado** para o próximo bloco (nada é ignorado).
-*   **Especialistas:** *routers* decidem quem faz o quê (ex.: “descrição → LLM-A”, “keyframe → Img-B”, “vídeo → Vid-C”).
-*   **Controle de qualidade:** LLM diretor compara *o que fez* × *o que deveria* × *o que falta* e **regenera objetivos** do próximo fragmento.
-*   **Custo/latência-aware:** planeja pela **VRAM/tempo/custo**, não tenta “abraçar tudo de uma vez”.
-
-#### 🇬🇧 Essential Elements (Telegraphic)
-
-*   **Model-agnostic:** operates with any LLM/diffuser/API.
-*   **Pre-input manager:** receives user request, **divides** into blocks ≤ token limit, **prioritizes**, **schedules**, and **routes**.
-*   **Persisted memory:** results/latents/“echo” become **shared state** for the next block (nothing is ignored).
-*   **Specialists:** *routers* decide who does what (e.g., “description → LLM-A”, “keyframe → Img-B”, “video → Vid-C”).
-*   **Quality control:** director LLM compares *what was done* × *what should be done* × *what is missing* and **regenerates objectives** for the next fragment.
-*   **Cost/latency-aware:** plans by **VRAM/time/cost**, does not try to “embrace everything at once”.
-
----
-
-#### 🇧🇷 Reivindicações Independentes (Método e Sistema)
-
-**Reivindicação Independente (Método) — Versão Enxuta:**
-
-1.  **Método** de **orquestração de prompts** para execução de tarefas acima do limite de contexto de modelos de IA, compreendendo:
-    (a) **receber** uma solicitação que excede um limite de tokens;
-    (b) **analisar** a solicitação por um **LLM diretor** e **fragmentá-la** em sub-tarefas ≤ limite;
-    (c) **selecionar** especialistas de execução para cada sub-tarefa com base em capacidades declaradas;
-    (d) **gerar** prompts específicos por sub-tarefa em **tokens universais**, incluindo referências ao **estado persistido** de execuções anteriores;
-    (e) **executar sequencialmente** as sub-tarefas e **persistir** suas saídas como memória (incluindo latentes/eco/artefatos);
-    (f) **avaliar** automaticamente a saída versus metas declaradas e **regenerar objetivos** do próximo fragmento;
-    (g) **iterar** (b)–(f) até que os critérios de completude sejam atendidos, produzindo o resultado agregado;
-    em que o framework **escala linearmente** no tempo e armazenamento físico, **independente** da janela de contexto dos modelos subjacentes.
-
-**Reivindicação Independente (Sistema):**
-
-2.  **Sistema** de orquestração de prompts, compreendendo: um **planejador LLM diretor**; um **roteador de especialistas**; um **banco de estado persistido** (incl. memória cinética para vídeo); um **gerador de prompts universais**; e um **módulo de avaliação/realimentação**, acoplados por uma **API pré-input** a modelos heterogêneos.
-
-#### 🇬🇧 Independent Claims (Method and System)
-
-**Independent Claim (Method) — Concise Version:**
-
-1.  A **method** for **prompt orchestration** for executing tasks exceeding AI model context limits, comprising:
-    (a) **receiving** a request that exceeds a token limit;
-    (b) **analyzing** the request by a **director LLM** and **fragmenting it** into sub-tasks ≤ the limit;
-    (c) **selecting** execution specialists for each sub-task based on declared capabilities;
-    (d) **generating** specific prompts per sub-task in **universal tokens**, including references to the **persisted state** of previous executions;
-    (e) **sequentially executing** the sub-tasks and **persisting** their outputs as memory (including latents/echo/artifacts);
-    (f) **automatically evaluating** the output against declared goals and **regenerating objectives** for the next fragment;
-    (g) **iterating** (b)–(f) until completion criteria are met, producing the aggregated result;
-    wherein the framework **scales linearly** in time and physical storage, **independent** of the context window of the underlying models.
-
-**Independent Claim (System):**
-
-2.  A prompt orchestration **system**, comprising: a **director LLM planner**; a **specialist router**; a **persisted state bank** (incl. kinetic memory for video); a **universal prompt generator**; and an **evaluation/feedback module**, coupled via a **pre-input API** to heterogeneous models.
-
----
-
-#### 🇧🇷 Dependentes Úteis
-
-*   (3) Onde o roteamento considera **custo/latência/VRAM** e metas de qualidade.
-*   (4) Onde o banco de estado inclui **eco cinético** para vídeo (últimos *n* frames/latentes/fluxo).
-*   (5) Onde a avaliação usa métricas específicas por domínio (Lflow, consistência semântica, etc.).
-*   (6) Onde *tokens universais* padronizam instruções entre especialistas.
-*   (7) Onde a orquestração decide **cut vs continuous** e **corte regenerativo** (Déjà-Vu) ao editar vídeo.
-*   (8) Onde o sistema **nunca descarta** conteúdo excedente: **reagenda** em novos fragmentos.
-
-#### 🇬🇧 Useful Dependents
-
-*   (3) Wherein routing considers **cost/latency/VRAM** and quality goals.
-*   (4) Wherein the state bank includes **kinetic echo** for video (last *n* frames/latents/flow).
-*   (5) Wherein evaluation uses domain-specific metrics (Lflow, semantic consistency, etc.).
-*   (6) Wherein *universal tokens* standardize instructions between specialists.
-*   (7) Wherein orchestration decides **cut vs continuous** and **regenerative cut** (Déjà-Vu) when editing video.
-*   (8) Wherein the system **never discards** excess content: it **reschedules** it in new fragments.
-
----
-
-#### 🇧🇷 Como isso conversa com SDR (Vídeo)
-
-*   **Eco Cinético**: é um **tipo de estado persistido** consumido pelo próximo passo.
-*   **Déjà-Vu (Corte Regenerativo)**: é **uma política de orquestração** aplicada quando há edição; ADUC decide, monta os prompts certos e chama o especialista de vídeo.
-*   **Cut vs Continuous**: decisão do **diretor** com base em estado + metas; ADUC roteia e garante a sobreposição/remoção final.
-
-#### 🇬🇧 How this Converses with SDR (Video)
-
-*   **Kinetic Echo**: is a **type of persisted state** consumed by the next step.
-*   **Déjà-Vu (Regenerative Cut)**: is an **orchestration policy** applied during editing; ADUC decides, crafts the right prompts, and calls the video specialist.
-*   **Cut vs Continuous**: decision made by the **director** based on state + goals; ADUC routes and ensures the final overlap/removal.
-
----
-
-#### 🇧🇷 Mensagem Clara ao Usuário (Experiência)
-
-> “Seu pedido excede o limite X do modelo Y. Em vez de truncar silenciosamente, o **ADUC** dividirá e **entregará 100%** do conteúdo por etapas coordenadas.”
-
-Isso é diferencial prático e jurídico: **não-obviedade** por transformar limite de contexto em **pipeline controlado**, com **persistência de estado** e **avaliação iterativa**.
-
-#### 🇬🇧 Clear User Message (Experience)
-
-> "Your request exceeds model Y's limit X. Instead of silently truncating, **ADUC** will divide and **deliver 100%** of the content through coordinated steps."
-
-This is a practical and legal differentiator: **non-obviousness** by transforming context limits into a **controlled pipeline**, with **state persistence** and **iterative evaluation**.
-
----
-
-### Contact / Contato / Contacto
-
-- **Author / Autor:** Carlos Rodrigues dos Santos
-- **Email:** carlex22@gmail.com
-- **GitHub:** [https://github.com/carlex22/Aduc-sdr](https://github.com/carlex22/Aduc-sdr)
-- **Hugging Face Spaces:**
-  - [Ltx-SuperTime-60Secondos](https://huggingface.co/spaces/Carlexx/Ltx-SuperTime-60Secondos/)
-  - [Novinho](https://huggingface.co/spaces/Carlexxx/Novinho/)
-
----