Spaces:

Aduc-sdr
/

Adduccccv

Runtime error

App Files Files Community

Aduc-sdr commited on Sep 6, 2025

Commit

e3d97f4

verified ·

1 Parent(s): 844d8b0

Delete engineers

Browse files

Files changed (9) hide show

engineers/LICENSE +0 -23
engineers/NOTICE.md +0 -76
engineers/README.md +0 -211
engineers/__init__.py +0 -0
engineers/deformes2D_thinker.py +0 -171
engineers/deformes3D.py +0 -194
engineers/deformes3D_thinker.py +0 -136
engineers/deformes4D.py +0 -338
engineers/deformes7D.py +0 -316

engineers/LICENSE DELETED Viewed

@@ -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 DELETED Viewed

@@ -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 DELETED Viewed

@@ -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/__init__.py DELETED Viewed

File without changes

engineers/deformes2D_thinker.py DELETED Viewed

@@ -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 DELETED Viewed

@@ -1,194 +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(
-                callback_on_step_end=progress_callback_flux
-                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 DELETED Viewed

@@ -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 DELETED Viewed

@@ -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 DELETED Viewed

@@ -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 --->