Upload 12 files

Dockerfile

@@ -0,0 +1,127 @@
+# =============================================================================
+# ADUC-SDR Video Suite — Dockerfile Otimizado
+# Preserva a estrutura de instalação original para alta performance.
+# CUDA 12.8 | PyTorch 2.8.0+cu128 | Ubuntu 22.04
+# =============================================================================
+FROM nvidia/cuda:12.8.0-devel-ubuntu22.04
+
+LABEL maintainer="Carlos Rodrigues dos Santos"
+LABEL description="ADUC-SDR: High-performance Diffusers stack for 8x NVIDIA L40S with LTX-Video and SeedVR"
+LABEL version="5.0.0"
+LABEL cuda_version="12.8.0"
+LABEL python_version="3.10"
+LABEL pytorch_version="2.8.0+cu128"
+LABEL gpu_optimized_for="8x_NVIDIA_L40S"
+
+# =============================================================================
+# 1. Variáveis de Ambiente e Configuração de Paths
+# =============================================================================
+ENV DEBIAN_FRONTEND=noninteractive TZ=UTC LANG=C.UTF-8 LC_ALL=C.UTF-8 \
+    PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1 \
+    PIP_NO_CACHE_DIR=0 PIP_DISABLE_PIP_VERSION_CHECK=1
+
+# --- Configurações de GPU e Computação ---
+ENV NVIDIA_VISIBLE_DEVICES=all \
+    TORCH_CUDA_ARCH_LIST="8.9" \
+    CUDA_DEVICE_ORDER=PCI_BUS_ID \
+    CUDA_DEVICE_MAX_CONNECTIONS=32
+
+# --- Configurações de Threads ---
+ENV OMP_NUM_THREADS=8 MKL_NUM_THREADS=8 MAX_JOBS=160
+
+# --- Configurações de Alocador de Memória e Caches de GPU ---
+ENV PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:512,garbage_collection_threshold:0.8 \
+    CUDA_LAUNCH_BLOCKING=0 CUDA_CACHE_MAXSIZE=2147483648 CUDA_CACHE_DISABLE=0
+
+# --- Paths da Aplicação e Dados Persistentes ---
+ENV APP_HOME=/app \
+    HF_HOME=/data/.cache/huggingface \
+    TORCH_HOME=/data/.cache/torch \
+    HF_DATASETS_CACHE=/data/.cache/datasets \
+    TRANSFORMERS_CACHE=/data/.cache/transformers \
+    DIFFUSERS_CACHE=/data/.cache/diffusers \
+    HF_HUB_ENABLE_HF_TRANSFER=1 \
+    TOKENIZERS_PARALLELISM=false
+
+WORKDIR $APP_HOME
+
+# =============================================================================
+# 2. Setup de Usuário e Sistema
+# =============================================================================
+# Cria usuário não-root e diretórios de dados/app.
+# As permissões finais serão aplicadas no final.
+RUN useradd -m -u 1000 -s /bin/bash appuser && \
+    mkdir -p /data $APP_HOME /app/output
+
+# --- Instalação de Pacotes de Sistema e Python ---
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential gosu tree cmake git git-lfs curl wget ffmpeg ninja-build \
+    python3.10 python3.10-dev python3.10-distutils python3-pip \
+    ca-certificates libglib2.0-0 libgl1 \
+ && apt-get clean && rm -rf /var/lib/apt/lists/*
+
+RUN ln -sf /usr/bin/python3.10 /usr/bin/python && \
+    python3 -m pip install --upgrade pip
+
+# =============================================================================
+# 3. Instalação da Toolchain de Machine Learning (Mantida 100% Original)
+# =============================================================================
+
+# --- PyTorch para CUDA 12.8 ---
+RUN pip install --index-url https://download.pytorch.org/whl/cu128 \
+    torch>=2.8.0+cu128 torchvision>=0.23.0+cu128 torchaudio>=2.8.0+cu128
+
+# --- Ferramentas de Compilação, Triton e FlashAttention ---
+RUN pip install packaging ninja cmake pybind11 scikit-build cython hf_transfer "numpy>=1.24.4"
+
+# --- Triton 3.x ---
+RUN pip uninstall -y triton || true && \
+    pip install -v --no-build-isolation triton==3.4.0
+
+# --- FlashAttention 2.8.x ---
+  
+# =============================================================================
+# 4. Instalação das Dependências da Aplicação
+# =============================================================================
+# Copia e instala requirements.txt primeiro para otimizar o cache de camadas do Docker.
+COPY --chown=appuser:appuser requirements.txt ./requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# --- Instalação de bitsandbytes e Wheels Customizados (Mantido 100% Original) ---
+RUN pip install --upgrade bitsandbytes
+
+# Instala wheels customizados (Apex, etc.)
+# Instala q8_kernels
+RUN pip install --no-cache-dir \
+   "https://huggingface.co/euIaxs22/Aduc-sdr/resolve/main/q8_kernels-0.0.5-cp310-cp310-linux_x86_64.whl"
+
+RUN echo "Installing custom wheels..." && \
+    pip install --no-cache-dir \
+      "https://huggingface.co/euIaxs22/Aduc-sdr/resolve/main/apex-0.1-cp310-cp310-linux_x86_64.whl" \
+      "https://huggingface.co/euIaxs22/Aduc-sdr/resolve/main/dropout_layer_norm-0.1-cp310-cp310-linux_x86_64.whl"
+      
+# =============================================================================
+# 5. Cópia do Código-Fonte e Configuração Final
+# =============================================================================
+# Copia o restante do código-fonte da aplicação por último.
+COPY --chown=appuser:appuser . .
+
+# Garante que todos os scripts de inicialização sejam executáveis
+# e que o usuário 'appuser' seja o dono de todos os arquivos.
+RUN chown -R appuser:appuser $APP_HOME /data && \
+    chmod +x /app/entrypoint.sh /app/start.sh /app/info.sh /app/builder.sh
+
+# =============================================================================
+# 6. Ponto de Entrada
+# =============================================================================
+# Expõe o diretório /data para ser montado como um volume persistente.
+VOLUME /data
+
+# Define o usuário padrão para a execução do contêiner.
+USER appuser
+
+# Define o script que será executado na inicialização do contêiner.
+ENTRYPOINT ["/app/entrypoint.sh"]
+
+# Define o comando padrão a ser executado pelo entrypoint.
+CMD ["/app/start.sh"]

LICENSE

@@ -0,0 +1,25 @@
+# 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
+# [email protected]
+# 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/>.

NOTICE.md

@@ -0,0 +1,76 @@
+# 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
+[email protected]
+Rua Eduardo Carlos Pereira, 4125, B1 Ap32, Curitiba, PR, Brazil, CEP 8102025

README.md

@@ -1,10 +1,212 @@
 ---
-title: Aduc
-emoji: ⚡
-colorFrom: blue
-colorTo: yellow
+title: Euia-AducSdr
+emoji: 🎥
+colorFrom: indigo
+colorTo: purple
 sdk: docker
-pinned: false
+app_file: app.py
+pinned: true
+license: agpl-3.0
+setup_file: setup.sh
+short_description: Uma implementação aberta e funcional da arquitetura ADUC-SDR
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+### 🇧🇷 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:** [email protected]
+- **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/)
+
+---

app.py

@@ -0,0 +1,194 @@
+
+# app_refactored_with_postprod.py (FINAL VERSION with LTX Refinement)
+
+import gradio as gr
+import os
+import sys
+import traceback
+from pathlib import Path
+import torch
+import numpy as np
+from PIL import Image
+
+# --- Import dos Serviços de Backend ---
+
+# Serviço LTX para geração de vídeo base e refinamento de textura
+from api.ltx_server_refactored import video_generation_service
+
+# Serviço SeedVR para upscaling de alta qualidade
+from api.seedvr_server import SeedVRServer
+
+# Inicializa o servidor SeedVR uma vez, se disponível
+seedvr_inference_server = SeedVRServer() if SeedVRServer else None
+
+# --- ESTADO DA SESSÃO ---
+def create_initial_state():
+    return {
+        "low_res_video": None,
+        "low_res_latents": None,
+        "refined_video_ltx": None,
+        "refined_latents_ltx": None,
+        "used_seed": None
+    }
+
+# --- FUNÇÕES WRAPPER PARA A UI ---
+
+def run_generate_low(prompt, neg_prompt, start_img, height, width, duration, cfg, seed, randomize_seed, progress=gr.Progress(track_tqdm=True)):
+    """Executa a primeira etapa: geração de um vídeo base em baixa resolução."""
+    print("UI: Chamando generate_low")
+    if True:
+        
+        conditioning_items = []
+        if start_img:
+            num_frames_estimate = int(duration * 24)
+            items_list = [[start_img, 0, 1.0]]
+            conditioning_items = video_generation_service._prepare_condition_items(items_list, height, width, num_frames_estimate)
+
+            
+        used_seed = None if randomize_seed else seed
+        
+        video_path, tensor_path, final_seed = video_generation_service.generate_low_resolution(
+            prompt=prompt, negative_prompt=neg_prompt,
+            height=height, width=width, duration_secs=duration,
+            guidance_scale=cfg, seed=used_seed,
+            conditioning_items=conditioning_items
+        )
+        
+        new_state = {
+            "low_res_video": video_path,
+            "low_res_latents": tensor_path,
+            "refined_video_ltx": None,
+            "refined_latents_ltx": None,
+            "used_seed": final_seed
+        }
+        
+        return video_path, new_state, gr.update(visible=True)
+    
+def run_ltx_refinement(state, prompt, neg_prompt, cfg, progress=gr.Progress(track_tqdm=True)):
+    """Executa o processo de refinamento e upscaling de textura com o pipeline LTX."""
+    print("UI: Chamando run_ltx_refinement (generate_upscale_denoise)")
+    
+    if True:
+        video_path, tensor_path = video_generation_service.generate_upscale_denoise(
+            latents_path=state["low_res_latents"],
+            prompt=prompt,
+            negative_prompt=neg_prompt,
+            guidance_scale=cfg,
+            seed=state["used_seed"]
+        )
+        
+        # Atualiza o estado com os novos artefatos refinados
+        state["refined_video_ltx"] = video_path
+        state["refined_latents_ltx"] = tensor_path
+        
+        return video_path, state
+    
+def run_seedvr_upscaling(state, seed, resolution, batch_size, fps, progress=gr.Progress(track_tqdm=True)):
+    """Executa o processo de upscaling com SeedVR."""
+            
+    video_path = state["low_res_video"]
+    print(f"▶️  Iniciando processo de upscaling SeedVR para o vídeo: {video_path}")
+    
+    if True:
+        def progress_wrapper(p, desc=""):
+            progress(p, desc=desc)
+        output_filepath = seedvr_inference_server.run_inference(
+            file_path=video_path, seed=seed, resolution=resolution,
+            batch_size=batch_size, fps=fps, progress=progress_wrapper
+        )
+        final_message = f"✅ Processo SeedVR concluído!\nVídeo salvo em: {output_filepath}"
+        return gr.update(value=output_filepath, interactive=True), gr.update(value=final_message, interactive=False)
+    
+# --- DEFINIÇÃO DA INTERFACE GRADIO ---
+with gr.Blocks() as demo:
+    gr.Markdown("# LTX Video - Geração e Pós-Produção por Etapas")
+    
+    app_state = gr.State(value=create_initial_state())
+
+    # --- ETAPA 1: Geração Base ---
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### Etapa 1: Configurações de Geração")
+            prompt_input = gr.Textbox(label="Prompt", value="A majestic dragon flying over a medieval castle", lines=3)
+            neg_prompt_input = gr.Textbox(visible=False, label="Negative Prompt", value="worst quality, blurry, low quality, jittery", lines=2)
+            start_image = gr.Image(label="Imagem de Início (Opcional)", type="filepath", sources=["upload", "clipboard"])
+            
+            with gr.Accordion("Parâmetros Avançados", open=False):
+                height_input = gr.Slider(label="Height", value=512, step=64, minimum=256, maximum=1024)
+                width_input = gr.Slider(label="Width", value=512, step=64, minimum=256, maximum=1024)
+                duration_input = gr.Slider(label="Duração (s)", value=8, step=0.5, minimum=1, maximum=16)
+                cfg_input = gr.Slider(label="Guidance Scale (CFG)", value=5.0, step=1, minimum=1, maximum=10.0)
+                seed_input = gr.Number(label="Seed", value=42, precision=0)
+                randomize_seed = gr.Checkbox(label="Randomize Seed", value=True)
+
+            generate_low_btn = gr.Button("1. Gerar Vídeo Base (Low-Res)", variant="primary")
+        
+        with gr.Column(scale=1):
+            gr.Markdown("### Vídeo Base Gerado")
+            low_res_video_output = gr.Video(label="O resultado da Etapa 1 aparecerá aqui", interactive=False)
+
+    # --- ETAPA 2: Pós-Produção (no rodapé, em abas) ---
+    with gr.Group(visible=False) as post_prod_group:
+        gr.Markdown("<hr style='margin-top: 20px; margin-bottom: 20px;'>")
+        gr.Markdown("## Etapa 2: Pós-Produção")
+        gr.Markdown("Use o vídeo gerado acima como entrada para as ferramentas abaixo. **O prompt e a CFG da Etapa 1 serão reutilizados.**")
+
+        with gr.Tabs():
+            # --- ABA LTX REFINEMENT (AGORA FUNCIONAL) ---
+            with gr.TabItem("🚀 Upscaler Textura (LTX)"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                         gr.Markdown("### Parâmetros de Refinamento")
+                         gr.Markdown("Esta etapa reutiliza o prompt, o prompt negativo e a CFG da Etapa 1 para manter a consistência.")
+                         ltx_refine_btn = gr.Button("Aplicar Refinamento de Textura LTX", variant="primary")
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Resultado do Refinamento")
+                        ltx_refined_video_output = gr.Video(label="Vídeo com Textura Refinada (LTX)", interactive=False)
+
+            # --- ABA SEEDVR UPSCALER ---
+            with gr.TabItem("✨ Upscaler SeedVR"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Parâmetros do SeedVR")
+                        seedvr_seed = gr.Slider(minimum=0, maximum=999999, value=42, step=1, label="Seed")
+                        seedvr_resolution = gr.Slider(minimum=720, maximum=1440, value=1072, step=8, label="Resolução Vertical (Altura)")
+                        seedvr_batch_size = gr.Slider(minimum=1, maximum=16, value=4, step=1, label="Batch Size por GPU")
+                        seedvr_fps_output = gr.Number(label="FPS de Saída (0 = original)", value=0)
+                        run_seedvr_button = gr.Button("Iniciar Upscaling SeedVR", variant="primary", interactive=(seedvr_inference_server is not None))
+                        if not seedvr_inference_server:
+                             gr.Markdown("<p style='color: red;'>Serviço SeedVR não disponível.</p>")
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Resultado do Upscaling")
+                        seedvr_video_output = gr.Video(label="Vídeo com Upscale SeedVR", interactive=False)
+                        seedvr_status_box = gr.Textbox(label="Status do Processamento", value="Aguardando...", lines=3, interactive=False)
+
+            # --- ABA MM-AUDIO ---
+            with gr.TabItem("🔊 Áudio (MM-Audio)"):
+                gr.Markdown("*(Funcionalidade futura para adicionar som aos vídeos)*")
+
+    # --- LÓGICA DE EVENTOS DA UI ---
+
+    # Botão da Etapa 1
+    generate_low_btn.click(
+        fn=run_generate_low,
+        inputs=[prompt_input, neg_prompt_input, start_image, height_input, width_input, duration_input, cfg_input, seed_input, randomize_seed],
+        outputs=[low_res_video_output, app_state, post_prod_group]
+    )
+
+    # Botão da Aba LTX Refinement
+    ltx_refine_btn.click(
+        fn=run_ltx_refinement,
+        inputs=[app_state, prompt_input, neg_prompt_input, cfg_input],
+        outputs=[ltx_refined_video_output, app_state]
+    )
+
+    # Botão da Aba SeedVR
+    run_seedvr_button.click(
+        fn=run_seedvr_upscaling,
+        inputs=[app_state, seedvr_seed, seedvr_resolution, seedvr_batch_size, seedvr_fps_output],
+        outputs=[seedvr_video_output, seedvr_status_box]
+    )
+
+if __name__ == "__main__":
+    demo.queue().launch(server_name="0.0.0.0", server_port=7860, debug=True, show_error=True)
+    

builder.sh

@@ -0,0 +1,346 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "🚀 Builder (FlashAttn LayerNorm extra + Apex + Q8) — runtime com GPU visível"
+
+# ===== Config e diretórios =====
+
+
+mkdir -p /app/wheels /app/cuda_cache /app/wheels/src
+chmod -R 777 /app/wheels || true
+export CUDA_CACHE_PATH="/app/cuda_cache"
+
+# Preserva licença NGC (se existir)
+if [ -f "/NGC-DL-CONTAINER-LICENSE" ]; then
+  cp -f /NGC-DL-CONTAINER-LICENSE /app/wheels/NGC-DL-CONTAINER-LICENSE || true
+fi
+
+# ===== Dependências mínimas =====
+python -m pip install -v -U pip build setuptools wheel hatchling hatch-vcs scikit-build-core cmake ninja packaging "huggingface_hub[hf_transfer]" || true
+
+# ===== Tags de ambiente (Python/CUDA/Torch) =====
+PY_TAG="$(python -c 'import sys; print(f"cp{sys.version_info[0]}{sys.version_info[1]}")' 2>/dev/null || echo cp310)"
+TORCH_VER="$(python - <<'PY'
+try:
+    import torch, re
+    v = torch.__version__
+    print(re.sub(r'\+.*$', '', v))
+except Exception:
+    print("unknown")
+PY
+)"
+CU_TAG="$(python - <<'PY'
+try:
+    import torch
+    cu = getattr(torch.version, "cuda", None)
+    print("cu"+cu.replace(".","")) if cu else print("")
+except Exception:
+    print("")
+PY
+)"
+echo "[env] PY_TAG=${PY_TAG} TORCH_VER=${TORCH_VER} CU_TAG=${CU_TAG}"
+
+# ============================================================================
+#                               CHECKERS
+# ============================================================================
+
+# Checa especificamente o módulo nativo requerido pelo layer_norm (sem checar 'flash-attn' geral)
+check_flash_layer_norm_bin () {
+python - <<'PY'
+import importlib
+ok = False
+# extensões conhecidas produzidas por csrc/layer_norm
+for name in [
+    "dropout_layer_norm",                 # nome do módulo nativo
+    "flash_attn.ops.layer_norm",          # wrapper python que usa o nativo
+    "flash_attn.ops.rms_norm",            # pode depender do mesmo backend em alguns empacotamentos
+]:
+    try:
+        importlib.import_module(name)
+        ok = True
+        break
+    except Exception:
+        pass
+raise SystemExit(0 if ok else 1)
+PY
+}
+
+check_apex () {
+python - <<'PY'
+try:
+    from apex.normalization import FusedLayerNorm
+    import importlib; importlib.import_module("fused_layer_norm_cuda")
+    ok = True
+except Exception:
+    ok = False
+raise SystemExit(0 if ok else 1)
+PY
+}
+
+check_q8 () {
+python - <<'PY'
+import importlib.util
+spec = importlib.util.find_spec("ltx_q8_kernels") or importlib.util.find_spec("q8_kernels")
+raise SystemExit(0 if spec else 1)
+PY
+}
+
+# ============================================================================
+#                         DOWNLOAD DO HUB (GENÉRICO)
+# ============================================================================
+
+# Instala uma wheel do HF por prefixo simples (ex.: apex-, q8_kernels-)
+install_from_hf_by_prefix () {
+  local PREFIX="$1"
+  echo "[hub] Procurando wheels '${PREFIX}-*.whl' em ${SELF_HF_REPO_ID} com tags ${PY_TAG}/${CU_TAG}"
+  python - "$PREFIX" "$PY_TAG" "$CU_TAG" <<'PY' || exit 0
+import os, sys
+from huggingface_hub import HfApi, hf_hub_download, HfFolder
+
+prefix, py_tag, cu_tag = sys.argv[1], sys.argv[2], sys.argv[3]
+repo = os.environ.get("SELF_HF_REPO_ID","euIaxs22/Aduc-sdr")
+api = HfApi(token=os.getenv("HF_TOKEN") or HfFolder.get_token())
+try:
+    files = api.list_repo_files(repo_id=repo, repo_type="model")
+except Exception:
+    raise SystemExit(0)
+
+def match(name: str) -> bool:
+    return name.endswith(".whl") and name.rsplit("/",1)[-1].startswith(prefix + "-") and (py_tag in name)
+
+cands = [f for f in files if match(f)]
+pref = [f for f in cands if cu_tag and cu_tag in f] or cands
+if not pref:
+    raise SystemExit(0)
+
+target = sorted(pref, reverse=True)[0]
+print(target)
+path = hf_hub_download(repo_id=repo, filename=target, repo_type="model", local_dir="/app/wheels")
+print(path)
+PY
+}
+
+# Instala wheels do submódulo layer_norm aceitando variantes de nome
+install_flash_layer_norm_from_hf () {
+  echo "[hub] Procurando wheels FlashAttention LayerNorm em ${SELF_HF_REPO_ID}"
+  python - "$PY_TAG" "$CU_TAG" <<'PY' || exit 0
+import os, sys, re
+from huggingface_hub import HfApi, hf_hub_download, HfFolder
+
+py_tag, cu_tag = sys.argv[1], sys.argv[2]
+repo = os.environ.get("SELF_HF_REPO_ID","euIaxs22/Aduc-sdr")
+api = HfApi(token=os.getenv("HF_TOKEN") or HfFolder.get_token())
+try:
+    files = api.list_repo_files(repo_id=repo, repo_type="model")
+except Exception:
+    raise SystemExit(0)
+
+pats = [
+    r"^flash[_-]?attn[_-]?.*layer[_-]?norm-.*\.whl$",
+    r"^dropout[_-]?layer[_-]?norm-.*\.whl$",
+]
+def ok(fn: str) -> bool:
+    name = fn.rsplit("/",1)[-1]
+    if py_tag not in name: return False
+    return any(re.search(p, name, flags=re.I) for p in pats)
+
+cands = [f for f in files if ok(f)]
+pref = [f for f in cands if cu_tag and cu_tag in f] or cands
+if not pref:
+    raise SystemExit(0)
+
+target = sorted(pref, reverse=True)[0]
+print(target)
+path = hf_hub_download(repo_id=repo, filename=target, repo_type="model", local_dir="/app/wheels")
+print(path)
+PY
+}
+
+# ============================================================================
+#                                BUILDERS
+# ============================================================================
+
+# Passo extra: SIEMPRE tenta instalar o submódulo layer_norm via wheel do HF;
+# se não houver wheel compatível, compila a partir de csrc/layer_norm e gera wheel.
+build_or_install_flash_layer_norm () {
+  echo "[flow] === FlashAttn LayerNorm (passo extra) ==="
+
+  # 1) Tentar instalar wheel do HF primeiro (evita recompilar)
+  HF_OUT="$(install_flash_layer_norm_from_hf || true)"
+  if [ -n "${HF_OUT:-}" ]; then
+    WHEEL_PATH="$(printf "%s\n" "${HF_OUT}" | tail -n1)"
+    echo "[hub] Baixado: ${WHEEL_PATH}"
+    python -m pip install -v -U --no-build-isolation --no-deps "${WHEEL_PATH}" || true
+    if check_flash_layer_norm_bin; then
+      echo "[flow] FlashAttn LayerNorm: OK via wheel do Hub"
+      return 0
+    fi
+    echo "[flow] Wheel do Hub não resolveu import; seguirá com build"
+  else
+    echo "[hub] Nenhuma wheel compatível encontrada para FlashAttn LayerNorm"
+  fi
+
+  # 2) Build from source do submódulo csrc/layer_norm -> wheel
+  local SRC="/app/wheels/src/flash-attn"
+  echo "[build] Preparando fonte FlashAttention (layer_norm) em ${SRC}"
+  if [ -d "$SRC/.git" ]; then
+    git -C "$SRC" fetch --all -p || true
+    git -C "$SRC" reset --hard origin/main || true
+    git -C "$SRC" clean -fdx || true
+  else
+    rm -rf "$SRC"
+    git clone --depth 1 https://github.com/Dao-AILab/flash-attention "$SRC"
+  fi
+
+  # Define CC alvo a partir da GPU ativa (reduz tempo/ruído de build)
+  export TORCH_CUDA_ARCH_LIST="$(python - <<'PY'
+import torch
+try:
+    cc = "%d.%d" % torch.cuda.get_device_capability(0)
+    print(cc)
+except Exception:
+    print("8.9")  # fallback p/ Ada (L40S) caso build sem GPU visível
+PY
+  )"
+  echo "[build] TORCH_CUDA_ARCH_LIST=${TORCH_CUDA_ARCH_LIST}"
+
+  pushd "$SRC/csrc/layer_norm" >/dev/null
+  export MAX_JOBS="${MAX_JOBS:-90}"
+  # Gera wheel reutilizável
+  python -m pip wheel -v --no-build-isolation --no-deps . -w /app/wheels || true
+  popd >/dev/null
+
+  # Instala a wheel gerada
+  local W="$(ls -t /app/wheels/*flash*attn*layer*norm*-*.whl 2>/dev/null | head -n1 || true)"
+  if [ -z "${W}" ]; then
+    W="$(ls -t /app/wheels/*dropout*layer*norm*-*.whl 2>/dev/null | head -n1 || true)"
+  fi
+  if [ -z "${W}" ]; then
+    # fallback para qualquer .whl recém gerado
+    W="$(ls -t /app/wheels/*.whl 2>/dev/null | head -n1 || true)"
+  fi
+
+  if [ -n "${W}" ]; then
+    python -m pip install -v -U --no-deps "${W}" || true
+    echo "[build] FlashAttn LayerNorm instalado da wheel: ${W}"
+  else
+    echo "[build] Nenhuma wheel gerada; instalando direto do source (último recurso)"
+    python -m pip install -v --no-build-isolation "$SRC/csrc/layer_norm" || true
+  fi
+
+  # Checagem final do binário
+  if check_flash_layer_norm_bin; then
+    echo "[flow] FlashAttn LayerNorm: import OK após build"
+    return 0
+  fi
+  echo "[flow] FlashAttn LayerNorm: falhou import após build"
+  return 1
+}
+
+build_apex () {
+  local SRC="/app/wheels/src/apex"
+  echo "[build] Preparando fonte Apex em ${SRC}"
+  if [ -d "$SRC/.git" ]; then
+    git -C "$SRC" fetch --all -p || true
+    git -C "$SRC" reset --hard HEAD || true
+    git -C "$SRC" clean -fdx || true
+  else
+    rm -rf "$SRC"
+    git clone --depth 1 https://github.com/NVIDIA/apex "$SRC"
+  fi
+  echo "[build] Compilando Apex -> wheel"
+  export APEX_CPP_EXT=1 APEX_CUDA_EXT=1 APEX_ALL_CONTRIB_EXT=0
+  python -m pip wheel -v --no-build-isolation --no-deps "$SRC" -w /app/wheels || true
+  local W="$(ls -t /app/wheels/apex-*.whl 2>/dev/null | head -n1 || true)"
+  if [ -n "${W}" ]; then
+    python -m pip install -v -U --no-deps "${W}" || true
+    echo "[build] Apex instalado da wheel recém-compilada: ${W}"
+  else
+    echo "[build] Nenhuma wheel Apex gerada; instalando do source"
+    python -m pip install -v --no-build-isolation "$SRC" || true
+  fi
+}
+
+Q8_REPO="${Q8_REPO:-https://github.com/Lightricks/LTX-Video-Q8-Kernels}"
+Q8_COMMIT="${Q8_COMMIT:-f3066edea210082799ca5a2bbf9ef0321c5dd8fc}"
+build_q8 () {
+  local SRC="/app/wheels/src/q8_kernels"
+  rm -rf "$SRC"
+  git clone --filter=blob:none "$Q8_REPO" "$SRC"
+  git -C "$SRC" checkout "$Q8_COMMIT"
+  git -C "$SRC" submodule update --init --recursive
+  echo "[build] Compilando Q8 Kernels -> wheel"
+  python -m pip wheel -v --no-build-isolation "$SRC" -w /app/wheels || true
+  local W="$(ls -t /app/wheels/q8_kernels-*.whl 2>/dev/null | head -n1 || true)"
+  if [ -n "${W}" ]; then
+    python -m pip install -v -U --no-deps "${W}" || true
+    echo "[build] Q8 instalado da wheel recém-compilada: ${W}"
+  else
+    echo "[build] Nenhuma wheel q8_kernels gerada; instalando do source"
+    python -m pip install -v --no-build-isolation "$SRC" || true
+  fi
+}
+
+# ============================================================================
+#                               EXECUÇÃO
+# ============================================================================
+
+# Passo adicional SEM depender de "flash-attn" já instalado: trata somente o layer_norm
+#build_q8 || true
+
+# Apex (mantido)
+# Tenta primeiro via wheel no HF e, se não houver, compila e instala em wheel
+#echo "[flow] === apex ==="
+#HF_OUT="$(install_from_hf_by_prefix "apex" || true)"
+#if [ -n "${HF_OUT:-}" ]; then
+#  WHEEL_PATH="$(printf "%s\n" "${HF_OUT}" | tail -n1)"
+#  echo "[hub] Baixado: ${WHEEL_PATH}"
+#  python -m pip install -v -U --no-build-isolation "${WHEEL_PATH}" || true
+#  if ! check_apex; then
+#    echo "[flow] apex: import falhou após wheel; compilando"
+#    #build_apex || true
+#  fi
+#else
+#  echo "[hub] Nenhuma wheel apex compatível; compilando"
+#  build_apex || true
+#fi
+
+ #Q8 (opcional)
+ echo "[flow] === q8_kernels ==="
+ HF_OUT="$(install_from_hf_by_prefix "q8_kernels" || true)"
+ if [ -n "${HF_OUT:-}" ]; then
+   WHEEL_PATH="$(printf "%s\n" "${HF_OUT}" | tail -n1)"
+   echo "[hub] Baixado: ${WHEEL_PATH}"
+   python -m pip install -v -U --no-build-isolation "${WHEEL_PATH}" || true
+   if ! check_q8; then
+     echo "[flow] q8_kernels: import falhou após wheel; compilando"
+     build_q8 || true
+   fi
+ else
+   echo "[hub] Nenhuma wheel q8_kernels compatível; compilando"
+   build_q8 || true
+ fi
+
+# Upload de wheels produzidas para o HF (cache cross-restarts)
+python - <<'PY'
+import os
+from huggingface_hub import HfApi, HfFolder
+
+repo = os.environ.get("SELF_HF_REPO_ID","euIaxs22/Aduc-sdr")
+token = os.getenv("HF_TOKEN") or HfFolder.get_token()
+if not token:
+    raise SystemExit("HF_TOKEN ausente; upload desabilitado")
+
+api = HfApi(token=token)
+api.upload_folder(
+    folder_path="/app/wheels",
+    repo_id=repo,
+    repo_type="model",
+    allow_patterns=["*.whl","NGC-DL-CONTAINER-LICENSE"],
+    ignore_patterns=["**/src/**","**/*.log","**/logs/**",".git/**"],
+)
+print("Upload concluído (wheels + licença).")
+PY
+
+chmod -R 777 /app/wheels || true
+echo "✅ Builder finalizado."

compose.yaml

@@ -0,0 +1,39 @@
+# compose.yaml (Versão com VINCIE)
+version: '3.8'
+
+services:
+  aduc-sdr-app:
+    build: .
+    environment:
+      ADUC_LOG_LEVEL: "DEBUG"
+    image: aduc-sdr-videosuite:latest
+    # (deploy, resources... mantidos como antes)
+    ports:
+      - "7860:7860" # Porta para a UI principal (LTX + SeedVR)
+      - "7861:7861" # Porta para a nova UI do VINCIE
+    volumes:
+      # O volume 'aduc_data' agora armazena tudo: cache, modelos e repos.
+      - aduc_data:/data
+      - ./output:/app/output
+    # O entrypoint cuidará do setup na inicialização.
+    # O CMD padrão iniciará a UI principal. Para VINCIE, usaremos um comando diferente.
+    
+  # Novo serviço para a interface do VINCIE
+  vince-ui:
+    image: aduc-sdr-videosuite:latest # Usa a mesma imagem já construída
+    command: python3 /app/app_vince.py # Sobrescreve o CMD padrão para iniciar a UI do VINCIE
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: all
+              capabilities: [gpu]
+    ports:
+      - "7861:7861"
+    volumes:
+      - aduc_data:/data
+      - ./output:/app/output
+
+volumes:
+  aduc_data:

entrypoint.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+set -e
+
+echo "🚀 ADUC-SDR Entrypoint: Configurando o ambiente de execução..."
+
+# --- Configuração de Performance (CPU & GPU) ---
+NUM_VCPUS=$(nproc)
+NUM_GPUS=$(nvidia-smi --query-gpu=count --format=csv,noheader | head -n 1 || echo 0)
+echo "   > Hardware: ${NUM_VCPUS} vCPUs, ${NUM_GPUS} GPUs"
+if [[ ${NUM_GPUS} -gt 0 ]]; then
+    VCPUS_PER_GPU=$((NUM_VCPUS / NUM_GPUS))
+    THREADS_PER_PROCESS=$((VCPUS_PER_GPU / 2))
+else
+    THREADS_PER_PROCESS=$((NUM_VCPUS / 2))
+fi
+MIN_THREADS=4; MAX_THREADS=16
+if [[ ${THREADS_PER_PROCESS} -lt ${MIN_THREADS} ]]; then THREADS_PER_PROCESS=${MIN_THREADS}; fi
+if [[ ${THREADS_PER_PROCESS} -gt ${MAX_THREADS} ]]; then THREADS_PER_PROCESS=${MAX_THREADS}; fi
+export OMP_NUM_THREADS=${OMP_NUM_THREADS:-${THREADS_PER_PROCESS}}
+export MKL_NUM_THREADS=${MKL_NUM_THREADS:-${THREADS_PER_PROCESS}}
+export MAX_JOBS=${MAX_JOBS:-${NUM_VCPUS}}
+export PYTORCH_CUDA_ALLOC_CONF=${PYTORCH_CUDA_ALLOC_CONF:-"max_split_size_mb:512"}
+export NVIDIA_TF32_OVERRIDE=${NVIDIA_TF32_OVERRIDE:-1}
+
+# --- Configuração de Depuração e Logging ---
+export ADUC_LOG_LEVEL=${ADUC_LOG_LEVEL:-"INFO"}
+export CUDA_LAUNCH_BLOCKING=${CUDA_LAUNCH_BLOCKING:-0}
+export PYTHONFAULTHANDLER=1
+export GRADIO_DEBUG=${GRADIO_DEBUG:-"False"}
+
+echo "   > Performance: OMP_NUM_THREADS=${OMP_NUM_THREADS}, MKL_NUM_THREADS=${MKL_NUM_THREADS}"
+echo "   > Depuração: ADUC_LOG_LEVEL=${ADUC_LOG_LEVEL}, CUDA_LAUNCH_BLOCKING=${CUDA_LAUNCH_BLOCKING}"
+echo ""
+echo ""
+
+#/bin/bash /app/info.sh
+
+# --- Setup de Dependências ---
+echo "   > Verificando dependências com setup.py..."
+python3 /app/setup.py
+
+echo "---------------------------------------------------------"
+echo "🔥 Ambiente configurado. Iniciando o comando principal: $@"
+exec "$@"

info.sh

@@ -0,0 +1,154 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+echo "================= RUNTIME CAPABILITIES ================="
+date
+
+echo
+if command -v nvidia-smi >/dev/null 2>&1; then
+  nvidia-smi
+else
+  echo "nvidia-smi: not available"
+fi
+echo
+
+echo "CUDA_HOME: ${CUDA_HOME:-/usr/local/cuda}"
+if command -v nvcc >/dev/null 2>&1; then
+  nvcc --version || true
+else
+  echo "nvcc: not available"
+fi
+echo
+
+echo "[PyTorch / CUDA backend]"
+python3 - <<'PY'
+import json, os, torch, inspect
+
+def to_bool(x):
+    try:
+        if callable(x):
+            try:
+                sig = inspect.signature(x)
+                if len(sig.parameters)==0:
+                    return bool(x())
+            except Exception:
+                pass
+            return True
+        return bool(x)
+    except Exception:
+        return None
+
+info = {
+    "torch": getattr(torch, "__version__", None),
+    "cuda_available": torch.cuda.is_available(),
+    "cuda_device_count": torch.cuda.device_count(),
+    "cuda_runtime_version": getattr(torch.version, "cuda", None),
+    "cudnn_version": torch.backends.cudnn.version() if torch.backends.cudnn.is_available() else None,
+    "tf32": (torch.backends.cuda.matmul.allow_tf32 if torch.cuda.is_available() else None),
+    "flash_sdp": (to_bool(getattr(torch.backends.cuda, "enable_flash_sdp", None)) if torch.cuda.is_available() else None),
+    "mem_efficient_sdp": (to_bool(getattr(torch.backends.cuda, "enable_mem_efficient_sdp", None)) if torch.cuda.is_available() else None),
+    "math_sdp": (to_bool(getattr(torch.backends.cuda, "enable_math_sdp", None)) if torch.cuda.is_available() else None),
+}
+print(json.dumps(info, indent=2))
+for i in range(min(torch.cuda.device_count(), 16)):
+    print(f"GPU {i}: {torch.cuda.get_device_name(i)}")
+PY
+echo
+
+echo "[Apex (FusedLayerNorm/RMSNorm)]"
+python3 - <<'PY'
+try:
+    from apex.normalization import FusedLayerNorm, FusedRMSNorm
+    import importlib; importlib.import_module("fused_layer_norm_cuda")
+    print("apex.normalization: OK")
+except Exception as e:
+    print("apex.normalization: FAIL ->", e)
+PY
+echo
+
+echo "[FlashAttention (CUDA/Triton/RMSNorm)]"
+python3 - <<'PY'
+import importlib
+mods = [
+    'flash_attn', 'flash_attn_2_cuda',
+    'flash_attn.ops.rms_norm', 'flash_attn.ops.layer_norm',
+    'flash_attn.layers.layer_norm'
+]
+for m in mods:
+    try:
+        importlib.import_module(m)
+        print(f"{m}: OK")
+    except Exception as e:
+        print(f"{m}: FAIL -> {e}")
+PY
+echo
+
+echo "[FlashAttention versão/details]"
+python3 - <<'PY'
+try:
+    import flash_attn
+    fa_ver = getattr(flash_attn, "__version__", None)
+    print(f"flash_attn: {fa_ver}")
+except Exception:
+    print("flash_attn: not importable.")
+try:
+    import torch
+    print(f"torch: {torch.__version__} | cuda: {getattr(torch.version, 'cuda', None)}")
+except Exception:
+    pass
+PY
+echo
+
+echo "[Triton]"
+python3 - <<'PY'
+try:
+    import triton
+    print("triton:", triton.__version__)
+    try:
+        import triton.ops as _; print("triton.ops: OK")
+    except Exception:
+        print("triton.ops: not present (ok on Triton>=3.x)")
+except Exception as e:
+    print("triton: FAIL ->", e)
+PY
+echo
+
+echo "[BitsAndBytes (Q8/Q4)]"
+python3 - <<'PY'
+try:
+    import bitsandbytes as bnb
+    print("bitsandbytes:", bnb.__version__)
+    try:
+        from bitsandbytes.triton import _custom_ops as _; print("bnb.triton._custom_ops: OK")
+    except Exception as e:
+        print("bnb.triton: partial ->", e)
+except Exception as e:
+    print("bitsandbytes: FAIL ->", e)
+PY
+echo
+
+echo "[Transformers / Diffusers / XFormers / EcoML]"
+python3 - <<'PY'
+def _v(m):
+    try:
+        mod = __import__(m)
+        print(f"{m}: {getattr(mod, '__version__', 'unknown')}")
+    except Exception as e:
+        print(f"{m}: FAIL -> {e}")
+for m in ("transformers", "diffusers", "xformers", "ecuml", "mlx", "ecobase"):
+    _v(m)
+PY
+echo
+
+echo "[Distribuído / NCCL Env]"
+env | grep -E '^(CUDA_VISIBLE_DEVICES|NCCL_|TORCH_|ENABLE_.*SDP|HF_HUB_.*|CUDA_|NV_.*NCCL.*|PYTORCH_CUDA_ALLOC_CONF)=' | sort
+echo
+
+echo "[Output dir/perms]"
+OUT="/app/outputs"
+echo "OUT dir: $OUT"
+mkdir -p "$OUT"
+ls -la "$OUT" || true
+
+echo "================= END CAPABILITIES ================="

requirements.txt

@@ -0,0 +1,60 @@
+accelerate
+transformers
+sentencepiece
+pillow
+numpy
+torchvision
+huggingface_hub
+spaces
+opencv-python
+imageio
+imageio-ffmpeg
+einops
+timm
+av
+#flash-attn-3@https://huggingface.co/alexnasa/flash-attn-3/resolve/main/128/flash_attn_3-3.0.0b1-cp39-abi3-linux_x86_64.whl
+git+https://github.com/huggingface/diffusers.git@main
+
+
+Common
+                # Configuration system.
+lpips>=0.1.4                    # LPIPS model for VAE training
+
+# Dataloading
+bson>=0.5.10                    # bson for Image dataloading
+tensorflow>=2.16.1              # Video dataloading
+opencv-python>=4.9.0.80         # OpenCV
+sentencepiece>=0.2.0            # For Text Encoder
+
+# Modeling
+rotary-embedding-torch>=0.5.3   # Rotary positional embedding
+transformers>=4.38.2            # Transformers
+torchvision>=0.19.0             # Torchvision
+tiktoken>=0.7.0                 # Tiktoken for generation
+transformers_stream_generator>=0.0.5 #LLM generation support
+
+# Metrics
+torchmetrics>=1.3.2             # Core module for metric
+pycocotools>=2.0.7              # COCO-related
+torch-fidelity>=0.3.0           # FID-related
+
+# Experiment Tracking
+moviepy>=1.0.3                  # WandB Logging Image & Video
+imageio>=2.34.0                 # WandB Logging Image & Video
+tabulate>=0.9.0                 # Logging Table
+deepdiff>=7.0.1                 # Find difference of config
+
+# Testing
+parameterized>=0.9.0            # Define multiple tests through decorators.
+
+# Notebook
+mediapy>=1.2.0                  # Notebook Visualization
+
+# DevOPs
+black >= 24             # Code formatting
+flake8 >= 7              # Code style
+isort >= 5               # Import sorting
+pre-commit>=3.7.0               # Pre-commit hooks
+expecttest>=0.2.1               # Pytorch dist tests
+hypothesis>=6.100.1             # Fix randomness
+av>=12.0.0

setup.py

@@ -0,0 +1,174 @@
+# setup.py
+#
+# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
+#
+# Versão 3.1.0 (Setup Unificado com LTX, SeedVR e VINCIE com Cache Robusto)
+# - Orquestra a instalação de todos os repositórios e modelos para a suíte ADUC-SDR.
+# - Usa snapshot_download para baixar dependências de forma eficiente e correta.
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+import yaml
+from huggingface_hub import hf_hub_download, snapshot_download
+
+# ==============================================================================
+# --- CONFIGURAÇÃO DE PATHS E CACHE ---
+# ==============================================================================
+# Assume que /data é um volume persistente montado no contêiner.
+DEPS_DIR = Path("/data")
+CACHE_DIR = DEPS_DIR / ".cache" / "huggingface"
+
+# --- Paths dos Módulos da Aplicação ---
+LTX_VIDEO_REPO_DIR = DEPS_DIR / "LTX-Video"
+SEEDVR_MODELS_DIR = DEPS_DIR / "models" / "SeedVR"
+VINCIE_REPO_DIR = DEPS_DIR / "VINCIE"
+VINCIE_CKPT_DIR = DEPS_DIR / "ckpt" / "VINCIE-3B"
+
+# --- Repositórios Git para Clonar ---
+REPOS_TO_CLONE = {
+    "LTX-Video": "https://huggingface.co/spaces/Lightricks/ltx-video-distilled",
+    "SeedVR": "https://github.com/numz/ComfyUI-SeedVR2_VideoUpscaler",
+    "VINCIE": "https://github.com/ByteDance-Seed/VINCIE",
+}
+
+# ==============================================================================
+# --- FUNÇÕES AUXILIARES ---
+# ==============================================================================
+
+def run_command(command, cwd=None):
+    """Executa um comando no terminal de forma segura e com logs claros."""
+    print(f"Executando: {' '.join(command)}")
+    try:
+        subprocess.run(
+            command, check=True, cwd=cwd,
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True,
+        )
+    except subprocess.CalledProcessError as e:
+        print(f"ERRO: O comando falhou com o código {e.returncode}\nStderr:\n{e.stderr.strip()}")
+        sys.exit(1)
+    except FileNotFoundError:
+        print(f"ERRO: Comando '{command[0]}' não encontrado. Verifique se o git está instalado.")
+        sys.exit(1)
+
+def _load_ltx_config():
+    """Carrega o arquivo de configuração YAML do LTX-Video."""
+    print("--- Carregando Configuração do LTX-Video ---")
+    config_file = LTX_VIDEO_REPO_DIR / "configs" / "ltxv-13b-0.9.8-distilled-fp8.yaml"
+    if not config_file.exists():
+        print(f"ERRO: Arquivo de configuração do LTX não encontrado em '{config_file}'")
+        return None
+    print(f"Configuração LTX encontrada: {config_file}")
+    with open(config_file, "r") as file:
+        return yaml.safe_load(file)
+
+def _ensure_hf_model(repo_id, filenames=None, allow_patterns=None, local_dir=None):
+    """Função genérica para baixar um ou mais arquivos (hf_hub_download) ou um snapshot (snapshot_download)."""
+    if not repo_id: return
+    
+    print(f"Verificando/Baixando modelo do repositório: '{repo_id}'...")
+    try:
+        if filenames: # Baixa arquivos específicos
+            for filename in filenames:
+                if not filename: continue
+                hf_hub_download(
+                    repo_id=repo_id, filename=filename, cache_dir=str(CACHE_DIR),
+                    local_dir=str(local_dir) if local_dir else None,
+                    #local_dir_use_symlinks=False, 
+                    token=os.getenv("HF_TOKEN"),
+                )
+        else: # Baixa um snapshot (partes de um repositório)
+            snapshot_download(
+                repo_id=repo_id, cache_dir=str(CACHE_DIR), 
+                local_dir=str(local_dir) if local_dir else None,
+                allow_patterns=allow_patterns, 
+                token=os.getenv("HF_TOKEN"),
+            )
+        print(f"-> Modelo '{repo_id}' está disponível.")
+    except Exception as e:
+        print(f"ERRO CRÍTICO ao baixar o modelo '{repo_id}': {e}")
+        sys.exit(1)
+
+# ==============================================================================
+# --- FUNÇÃO PRINCIPAL DE SETUP ---
+# ==============================================================================
+
+def main():
+    """Orquestra todo o processo de setup do ambiente."""
+    print("--- Iniciando Setup do Ambiente ADUC-SDR (LTX + SeedVR + VINCIE) ---")
+    DEPS_DIR.mkdir(exist_ok=True)
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    
+    # --- ETAPA 1: Clonar Repositórios ---
+    print("\n--- ETAPA 1: Verificando Repositórios Git ---")
+    for repo_name, repo_url in REPOS_TO_CLONE.items():
+        repo_path = DEPS_DIR / repo_name
+        if repo_path.is_dir():
+            print(f"Repositório '{repo_name}' já existe em '{repo_path}'. Pulando.")
+        else:
+            print(f"Clonando '{repo_name}' de {repo_url}...")
+            run_command(["git", "clone", "--depth", "1", repo_url, str(repo_path)])
+            print(f"-> '{repo_name}' clonado com sucesso.")
+
+    # --- ETAPA 2: Baixar Modelos LTX-Video e Dependências ---
+    print("\n--- ETAPA 2: Verificando Modelos LTX-Video e Dependências ---")
+    ltx_config = _load_ltx_config()
+    if not ltx_config:
+        print("ERRO: Não foi possível carregar a configuração do LTX-Video. Abortando.")
+        sys.exit(1)
+        
+    _ensure_hf_model(
+        repo_id="Lightricks/LTX-Video",
+        filenames=[
+            ltx_config.get("checkpoint_path"), 
+            ltx_config.get("spatial_upscaler_model_path") # <-- Adicione esta linha
+        ]
+    )
+    
+    _ensure_hf_model(
+        repo_id=ltx_config.get("text_encoder_model_name_or_path"),
+        allow_patterns=["*.json", "*.safetensors"]
+    )
+    
+    enhancer_repos = [
+        ltx_config.get("prompt_enhancer_image_caption_model_name_or_path"),
+        ltx_config.get("prompt_enhancer_llm_model_name_or_path"),
+    ]
+    for repo_id in filter(None, enhancer_repos):
+         _ensure_hf_model(repo_id=repo_id, allow_patterns=["*.json", "*.safetensors", "*.bin"])
+
+    # --- ETAPA 3: Baixar Modelos SeedVR ---
+    print("\n--- ETAPA 3: Verificando Modelos SeedVR ---")
+    SEEDVR_MODELS_DIR.mkdir(parents=True, exist_ok=True)
+    seedvr_files = {
+        "seedvr2_ema_7b_fp16.safetensors": "MonsterMMORPG/SeedVR2_SECourses",
+        "seedvr2_ema_7b_sharp_fp16.safetensors": "MonsterMMORPG/SeedVR2_SECourses",
+        "ema_vae_fp16.safetensors": "MonsterMMORPG/SeedVR2_SECourses",
+    }
+    for filename, repo_id in seedvr_files.items():
+        if not (SEEDVR_MODELS_DIR / filename).is_file():
+             _ensure_hf_model(repo_id=repo_id, filenames=[filename], local_dir=SEEDVR_MODELS_DIR)
+        else:
+            print(f"Arquivo SeedVR '{filename}' já existe. Pulando.")
+
+    # --- ETAPA 4: Baixar Modelos VINCIE ---
+    print("\n--- ETAPA 4: Verificando Modelos VINCIE ---")
+    VINCIE_CKPT_DIR.mkdir(parents=True, exist_ok=True)
+    _ensure_hf_model(repo_id="ByteDance-Seed/VINCIE-3B", local_dir=VINCIE_CKPT_DIR)
+    
+    # Cria o symlink de compatibilidade, se necessário
+    repo_ckpt_dir = VINCIE_REPO_DIR / "ckpt"
+    repo_ckpt_dir.mkdir(parents=True, exist_ok=True)
+    link = repo_ckpt_dir / "VINCIE-3B"
+    if not link.exists():
+        link.symlink_to(VINCIE_CKPT_DIR.resolve(), target_is_directory=True)
+        print(f"-> Symlink de compatibilidade VINCIE criado: '{link}' -> '{VINCIE_CKPT_DIR.resolve()}'")
+    else:
+        print(f"-> Symlink de compatibilidade VINCIE já existe.")
+
+    print("\n\n--- ✅ Setup Completo do Ambiente ADUC-SDR Concluído com Sucesso! ---")
+    print("Todos os repositórios e modelos foram verificados e estão prontos para uso.")
+
+if __name__ == "__main__":
+    main()

start.sh

@@ -0,0 +1,88 @@
+#!/bin/bash
+
+
+cp /app/LTX-Video/. /data/LTX-Video -rdfv
+
+tree -L 6 /data
+
+# ==============================================================================
+# GERENCIAMENTO DE LOGS NA INICIALIZAÇÃO
+# ==============================================================================
+mkdir /data/logs
+LOG_FILE="/data/logs/session.log"
+
+# Verifica se o arquivo de log da sessão anterior existe e não está vazio
+if [ -f "$LOG_FILE" ] && [ -s "$LOG_FILE" ]; then
+    echo "[STARTUP] Log da sessão anterior encontrado. Preparando para upload."
+
+    # Cria um nome de arquivo com timestamp para o upload
+    TODAY=$(date +%Y-%m-%d)
+    TIMESTAMP=$(date +%H-%M-%S)
+    UPLOAD_FILENAME="log-${TIMESTAMP}.txt"
+    export REPO_PATH="logs/${TODAY}/${UPLOAD_FILENAME}"
+
+    # Move o log antigo para um local temporário para evitar que a aplicação comece a escrever nele
+    TEMP_LOG_PATH="/data/previous_session.log"
+    mv "$LOG_FILE" "$TEMP_LOG_PATH"
+    
+    echo "[STARTUP] Fazendo upload de '$TEMP_LOG_PATH' para o repositório em '$REPO_PATH'..."
+
+    # Executa o script de upload do Python em segundo plano para não bloquear a inicialização
+    # O token HF_TOKEN deve estar definido como uma variável de ambiente no seu contêiner
+    python - <<'PY' &
+import os
+import time
+from huggingface_hub import HfApi, HfFolder
+
+# Adiciona uma pequena espera para garantir que a rede esteja pronta
+time.sleep(5)
+
+repo = os.environ.get("SELF_HF_REPO_ID", "eeuuia/Tmp")
+token = os.getenv("HF_TOKEN")
+log_to_upload = "/data/previous_session.log"
+repo_path = os.getenv("REPO_PATH",'logs/log.log')
+
+if not token:
+    print("[UPLOAD_SCRIPT] AVISO: HF_TOKEN ausente; upload do log desabilitado.")
+    # Limpa o arquivo temporário mesmo assim
+    if os.path.exists(log_to_upload):
+        os.remove(log_to_upload)
+    exit()
+
+if not repo_path:
+    print("[UPLOAD_SCRIPT] ERRO: REPO_PATH não definido.")
+    exit()
+
+try:
+    print(f"[UPLOAD_SCRIPT] Iniciando upload para {repo}...")
+    api = HfApi(token=token)
+    api.upload_file(
+        path_or_fileobj=log_to_upload,
+        path_in_repo=repo_path,
+        repo_id=repo,
+        repo_type="model",
+    )
+    print(f"[UPLOAD_SCRIPT] Upload de log concluído com sucesso para: {repo_path}")
+finally:
+    # Garante que o arquivo de log temporário seja sempre removido após a tentativa de upload
+    if os.path.exists(log_to_upload):
+        os.remove(log_to_upload)
+        print("[UPLOAD_SCRIPT] Arquivo de log temporário limpo.")
+PY
+    
+else
+    echo "[STARTUP] Nenhum log da sessão anterior encontrado. Iniciando com um log limpo."
+fi
+
+# ==============================================================================
+# INICIALIZAÇÃO DA APLICAÇÃO PRINCIPAL
+# ==============================================================================
+echo "[STARTUP] Iniciando a aplicação principal Gradio (app.py)..."
+
+# Executa o setup.py primeiro para garantir que as dependências estão prontas
+python /app/setup.py
+
+# Inicia a aplicação Gradio
+# O `exec` substitui o processo do shell pelo processo do python,
+# o que é uma boa prática para scripts de inicialização de contêineres.
+exec python /app/app.py