Upload 7 files

Dockerfile

@@ -0,0 +1,119 @@
+# =============================================================================
+# ADUC-SDR Video Suite — High-Perf Diffusers for 8× L40S (SM 8.9)
+# 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 & Development Partner"
+LABEL description="High-performance Diffusers stack with FA2/SDPA, 8×L40S"
+LABEL version="4.4.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"
+
+# ---------------- Core env & caches ----------------
+ENV DEBIAN_FRONTEND=noninteractive TZ=UTC LANG=C.UTF-8 LC_ALL=C.UTF-8 \
+    PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1 \
+    PIP_NO_CACHE_DIR=1 PIP_DISABLE_PIP_VERSION_CHECK=1
+
+# GPU/Compute
+ENV NVIDIA_VISIBLE_DEVICES=all
+ENV CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7
+ENV TORCH_CUDA_ARCH_LIST="8.9"
+ENV CUDA_DEVICE_ORDER=PCI_BUS_ID
+ENV CUDA_DEVICE_MAX_CONNECTIONS=32
+
+# Threads
+ENV OMP_NUM_THREADS=8 MKL_NUM_THREADS=8 MAX_JOBS=160
+
+# Alloc/caches
+ENV PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:512,garbage_collection_threshold:0.8
+ENV CUDA_LAUNCH_BLOCKING=0 CUDA_CACHE_MAXSIZE=2147483648 CUDA_CACHE_DISABLE=0
+
+# Hugging Face caches
+ENV APP_HOME=/app
+WORKDIR $APP_HOME
+
+
+ENV MODELS_DIR=/app/models
+RUN mkdir -p /home/user/.cache/models && ln -sf /home/user/.cache/models /app/models
+
+
+
+# ---------------- Sistema & Python ----------------
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential tree cmake git git-lfs curl wget ffmpeg ninja-build \
+    python3.10 python3.10-dev python3.10-distutils python3-pip \
+    && apt-get clean && rm -rf /var/lib/apt/lists/*
+
+RUN ln -sf /usr/bin/python3.10 /usr/bin/python3 && \
+    ln -sf /usr/bin/python3.10 /usr/bin/python && \
+    python3 -m pip install --upgrade pip
+
+
+# ---------------- PyTorch cu128 (pinado) ----------------
+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
+
+# ---------------- Toolchain, Triton, FA2 (sem bnb) ----------------
+RUN pip install packaging ninja cmake pybind11 scikit-build cython hf_transfer numpy==1.24.4
+
+# Triton 3.x (sem triton.ops)
+RUN pip uninstall -y triton || true && \
+    pip install -v --no-build-isolation triton==3.4.0
+
+# FlashAttention 2.8.x
+RUN pip install flash-attn==2.8.3 --no-build-isolation || \
+    pip install flash-attn==2.8.2 --no-build-isolation || \
+    pip install flash-attn==2.8.1 --no-build-isolation || \
+    pip install flash-attn==2.8.0.post2 --no-build-isolation
+
+# Diffusers/Transformers estáveis (sem dev)
+RUN pip install --no-cache-dir diffusers==0.31.0 transformers==4.44.2 accelerate==0.34.2 omegaconf==2.3.0
+
+# Opcional: seu fork de otimizações
+RUN pip install -U git+https://github.com/carlex22/diffusers-aduc-sdr
+
+# ---------------- Dependências da aplicação ----------------
+COPY requirements.txt ./requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+RUN pip install --upgrade bitsandbytes
+
+# Scripts e configs
+COPY info.sh ./app/info.sh
+COPY builder.sh ./app/builder.sh
+COPY start_seedvr.sh ./app/start_seedvr.sh
+
+# ---------------- Código e permissões ----------------
+COPY . .
+RUN useradd -m -u 1000 -s /bin/bash appuser && \
+    chown -R appuser:appuser /app && \
+    chmod 0755 /app/start_seedvr.sh /app/info.sh /app/builder.sh || true
+
+USER appuser
+
+# Declara volume persistente para HF Spaces
+VOLUME /data
+
+# Env vars para caches em /data
+ENV HF_HOME=/data/.cache/huggingface
+ENV TORCH_HOME=/data/.cache/torch
+ENV HF_DATASETS_CACHE=/data/.cache/datasets
+ENV TRANSFORMERS_CACHE=/data/.cache/transformers
+ENV DIFFUSERS_CACHE=/data/.cache/diffusers
+ENV HF_HUB_ENABLE_HF_TRANSFER=1
+ENV TOKENIZERS_PARALLELISM=false
+
+
+
+
+VOLUME ["/data/.cache/huggingface/hub", "/data/ckpt/VINCIE-3B" ]
+
+  
+
+
+# ---------------- Entry ----------------
+ENTRYPOINT ["/app/start.sh"]
+CMD [""]

README.md

@@ -1,10 +1,212 @@
 ---
-title: Tt2
-emoji: 🏆
-colorFrom: blue
-colorTo: pink
+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:** 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/)
+
+---

app.py

@@ -0,0 +1,212 @@
+from fastapi import FastAPI, UploadFile, File, Form, BackgroundTasks, HTTPException
+from fastapi.responses import HTMLResponse, FileResponse, JSONResponse
+from pathlib import Path
+import os, uuid, shutil, subprocess, time
+
+# -------------------- Configuração de diretórios --------------------
+def default_work_root() -> Path:
+    return Path("/data/work") if Path("/data").exists() else Path("/app/work")
+
+WORK_ROOT = Path(os.environ.get("WORK_ROOT", default_work_root()))
+JOBS_DIR = WORK_ROOT / "jobs"
+JOBS_DIR.mkdir(parents=True, exist_ok=True)
+
+# Caminhos/CLI
+SEEDVR_SCRIPT = os.environ.get("SEEDVR_SCRIPT", "projects/inference_seedvr2_3b.py")
+DEFAULT_PORT = os.environ.get("APP_PORT", "8000")
+API_BASE = os.environ.get("API_BASE", f"http://127.0.0.1:{DEFAULT_PORT}")
+
+# -------------------- App FastAPI --------------------
+app = FastAPI(title="SeedVR2-3B API + UI")
+
+# Estado simples em memória
+jobs = {}  # {job_id: {"status": str, "log": Path, "out": Path, "cmd": list}}
+
+# -------------------- Página HTML simples (raiz) --------------------
+INDEX_HTML = """
+<!doctype html>
+<html>
+  <head><meta charset="utf-8"><title>SeedVR UI</title></head>
+  <body>
+    <h2>SeedVR2-3B</h2>
+    <p>Use a UI em <a href="/ui">/ui</a> ou a documentação em <a href="/docs">/docs</a>.</p>
+  </body>
+</html>
+"""
+
+@app.get("/", response_class=HTMLResponse)
+async def index():
+    return INDEX_HTML
+
+# -------------------- Utilitários --------------------
+def visible_gpu_count() -> int:
+    try:
+        import torch
+        if torch.cuda.is_available():
+            return torch.cuda.device_count()
+    except Exception:
+        pass
+    # fallback por env
+    cuda = os.environ.get("CUDA_VISIBLE_DEVICES", "")
+    if not cuda:
+        return 0
+    return len([x for x in cuda.split(",") if x.strip() != ""])
+
+def effective_nproc(nproc: str) -> str:
+    ng = max(visible_gpu_count(), 1)
+    if nproc == "gpu":
+        return str(ng)
+    try:
+        n = int(nproc)
+        return str(max(1, min(n, ng)))
+    except Exception:
+        return "1"
+
+def build_torchrun_cmd(nproc: str, input_dir: Path, output_dir: Path,
+                       seed: int, res_h: int, res_w: int, sp_size: int):
+    nproc_arg = effective_nproc(nproc)
+    cmd = [
+        "torchrun",
+        "--standalone",
+        "--rdzv-backend=c10d",
+        "--rdzv-endpoint=localhost:0",
+        "--nnodes=1",
+        f"--nproc-per-node={nproc_arg}",
+        SEEDVR_SCRIPT,
+        "--video_path", str(input_dir),
+        "--output_dir", str(output_dir),
+        "--seed", str(seed),
+        "--res_h", str(res_h),
+        "--res_w", str(res_w),
+        "--sp_size", str(sp_size),
+    ]
+    return cmd
+
+def run_seedvr(job_id: str, input_dir: Path, output_dir: Path,
+               seed: int, res_h: int, res_w: int, sp_size: int, nproc: str):
+    log_path = output_dir / "run.log"
+    cmd = build_torchrun_cmd(nproc, input_dir, output_dir, seed, res_h, res_w, sp_size)
+    jobs[job_id]["cmd"] = cmd
+    output_dir.mkdir(parents=True, exist_ok=True)
+    with open(log_path, "a", buffering=1) as lf:
+        lf.write("CMD: " + " ".join(cmd) + "\n")
+        proc = subprocess.Popen(
+            cmd,
+            stdout=lf,
+            stderr=subprocess.STDOUT,
+            cwd=str(Path.cwd()),
+            env=os.environ.copy(),
+        )
+        jobs[job_id]["status"] = "running"
+        rc = proc.wait()
+        jobs[job_id]["status"] = "done" if rc == 0 else f"error:{rc}"
+
+# -------------------- Endpoints de job --------------------
+@app.post("/submit")
+async def submit(background_tasks: BackgroundTasks,
+                 file: UploadFile = File(...),
+                 seed: int = Form(42),
+                 res_h: int = Form(576),
+                 res_w: int = Form(1024),
+                 sp_size: int = Form(1),
+                 nproc: str = Form("1")):
+    if not file.filename:
+        raise HTTPException(status_code=400, detail="Arquivo ausente")
+    job_id = uuid.uuid4().hex
+    job_root = JOBS_DIR / job_id
+    in_dir = job_root / "inputs"
+    out_dir = job_root / "outputs"
+    in_dir.mkdir(parents=True, exist_ok=True)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    dst = in_dir / file.filename
+    with open(dst, "wb") as f:
+        shutil.copyfileobj(file.file, f)
+    jobs[job_id] = {"status": "queued", "log": out_dir / "run.log", "out": out_dir, "cmd": []}
+    background_tasks.add_task(run_seedvr, job_id, in_dir, out_dir, seed, res_h, res_w, sp_size, nproc)
+    return {"job_id": job_id, "status": "queued", "inputs": str(in_dir), "outputs": str(out_dir)}
+
+@app.get("/jobs/{job_id}/status")
+async def job_status(job_id: str):
+    if job_id not in jobs:
+        raise HTTPException(status_code=404, detail="Job não encontrado")
+    j = jobs[job_id]
+    resp = {"job_id": job_id, "status": j["status"], "cmd": j.get("cmd", [])}
+    log_path = j["log"]
+    if log_path.exists():
+        try:
+            with open(log_path, "r") as f:
+                lines = f.readlines()[-50:]
+            resp["log_tail"] = "".join(lines)
+        except Exception:
+            resp["log_tail"] = ""
+    return JSONResponse(resp)
+
+@app.get("/jobs/{job_id}/result")
+async def job_result(job_id: str):
+    if job_id not in jobs:
+        raise HTTPException(status_code=404, detail="Job não encontrado")
+    out_dir = jobs[job_id]["out"]
+    if not out_dir.exists():
+        raise HTTPException(status_code=404, detail="Output ausente")
+    files = [str(p.name) for p in sorted(out_dir.iterdir()) if p.is_file()]
+    return {"job_id": job_id, "files": files}
+
+@app.get("/jobs/{job_id}/download/{filename}")
+async def download_file(job_id: str, filename: str):
+    if job_id not in jobs:
+        raise HTTPException(status_code=404, detail="Job não encontrado")
+    file_path = jobs[job_id]["out"] / filename
+    if not file_path.exists():
+        raise HTTPException(status_code=404, detail="Arquivo não encontrado")
+    return FileResponse(str(file_path), filename=filename)
+
+# -------------------- UI Gradio (montada em /ui) --------------------
+import gradio as gr
+import requests
+
+def submit_and_follow(file, seed, res_h, res_w, sp_size, nproc, progress=gr.Progress()):
+    # 1) Submete
+    files = {"file": (os.path.basename(file.name), open(file.name, "rb"), "application/octet-stream")}
+    data = {"seed": int(seed), "res_h": int(res_h), "res_w": int(res_w), "sp_size": int(sp_size), "nproc": str(nproc)}
+    r = requests.post(f"{API_BASE}/submit", files=files, data=data, timeout=600)
+    r.raise_for_status()
+    job_id = r.json()["job_id"]
+    progress(0, desc=f"Job {job_id} criado")
+    log_text = f"Job {job_id} criado; acompanhando...\n"
+
+    # 2) Polling
+    pct = 0.05
+    while True:
+        s = requests.get(f"{API_BASE}/jobs/{job_id}/status", timeout=120).json()
+        if "log_tail" in s and s["log_tail"]:
+            log_text = f"Status: {s['status']}\n\n{s['log_tail']}"
+        else:
+            log_text = f"Status: {s['status']}"
+        progress(min(pct, 0.95), desc=s["status"])
+        yield log_text, job_id, []
+        if s["status"].startswith("error"):
+            return f"Erro: {s['status']}", job_id, []
+        if s["status"] == "done":
+            files_resp = requests.get(f"{API_BASE}/jobs/{job_id}/result", timeout=120).json()
+            return "Concluído", job_id, files_resp.get("files", [])
+        time.sleep(2)
+        pct = min(pct + 0.05, 0.95)
+
+with gr.Blocks(title="SeedVR2-3B UI") as ui:
+    gr.Markdown("### SeedVR2-3B — Processamento de vídeo/imagem")
+    with gr.Row():
+        in_file = gr.File(label="Vídeo/Imagem", file_types=["image", "video"])
+        with gr.Column():
+            seed = gr.Number(value=42, label="Seed", precision=0)
+            res_h = gr.Number(value=576, label="Altura", precision=0)
+            res_w = gr.Number(value=1024, label="Largura", precision=0)
+            sp_size = gr.Number(value=1, label="sp_size", precision=0)
+            nproc = gr.Dropdown(choices=["1","2","4","gpu"], value="1", label="nproc-per-node")
+            go = gr.Button("Iniciar")
+    out_log = gr.Markdown(label="Log/Status")
+    out_job = gr.Textbox(label="job_id")
+    out_files = gr.JSON(label="Arquivos gerados")
+    go.click(submit_and_follow, [in_file, seed, res_h, res_w, sp_size, nproc], [out_log, out_job, out_files], queue=True)
+
+# Monta o Gradio em /ui
+app = gr.mount_gradio_app(app, ui, path="/ui")

builder.sh

@@ -0,0 +1,351 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "🚀 Builder (FlashAttn LayerNorm extra + Apex + Q8) — runtime com GPU visível"
+
+# ===== Config e diretórios =====
+export SELF_HF_REPO_ID="${SELF_HF_REPO_ID:-euIaxs22/Aduc-sdr}"  # Repo no HF para wheels
+export HF_HOME="${HF_HOME:-/app/model_cache}"
+export HF_HUB_CACHE="${HF_HUB_CACHE:-$HF_HOME/hub}"
+export TORCH_HOME="${TORCH_HOME:-$HF_HOME/torch}"
+export HF_HUB_ENABLE_HF_TRANSFER="${HF_HUB_ENABLE_HF_TRANSFER:-1}"
+export PATH="$HOME/.local/bin:$PATH"
+
+mkdir -p /app/wheels /app/cuda_cache "$HF_HOME" "$TORCH_HOME" /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.git}"
+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_or_install_flash_layer_norm || 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."

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,50 @@
+gradio
+opencv-python-headless
+pillow>=10.4.0
+numpy==1.24.4
+
+safetensors>=0.4.5
+einops>=0.8.0
+pyyaml>=6.0.2
+omegaconf==2.3.0 
+mediapy
+librosa
+moviepy
+OmegaConf
+beartype
+sentencepiece
+gradio[oauth]
+mediapy
+fastapi
+uvicorn[standard]
+tiktoken
+transformers_stream_generator
+rotary-embedding-torch
+transformers
+accelerate
+safetensors
+einops
+decord
+huggingface_hub
+google-generativeai
+gradio
+tabulate
+pydantic
+soundfile
+requests
+hf_transfer
+timm
+ftfy
+easydict
+
+
+#vince
+bitsandbytes==0.45.0
+einop
+numpy
+rotary-embedding-torch
+safetensors
+sentencepiece
+torch
+torchvision
+transformers

start.sh

@@ -0,0 +1,97 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# =======================
+# SeedVR — start UI
+# =======================
+
+
+# 1) Builder (garante Apex/Flash e deps CUDA)
+echo "🛠️  Iniciando o builder.sh para compilar/instalar dependências CUDA..."
+if [ -f "/app/builder.sh" ]; then
+  /bin/bash /app/builder.sh
+  echo "✅ Builder finalizado."
+else
+  echo "⚠️  Aviso: builder.sh não encontrado. Pulando etapa de compilação de dependências."
+fi
+
+# Pastas e variáveis (podem ser sobrescritas via env)
+export SEEDVR_ROOT="${SEEDVR_ROOT:-/data/SeedVR}"
+export CKPTS_ROOT="${CKPTS_ROOT:-/data/ckpts/SeedVR2-3B}"
+export OUTPUT_ROOT="${OUTPUT_ROOT:-/app/outputs}"
+export INPUT_ROOT="${INPUT_ROOT:-/app/inputs}"
+
+# Transformers v5 recomenda HF_HOME
+export HF_HOME="${HF_HOME:-/data/.cache/huggingface}"
+export HF_TOKEN="${HF_TOKEN:-${HUGGINGFACE_TOKEN:-}}"
+
+# Repo/model identifiers
+export SEEDVR_GIT_URL="${SEEDVR_GIT_URL:-https://github.com/ByteDance-Seed/SeedVR.git}"
+export SEEDVR_REPO_ID="${SEEDVR_REPO_ID:-ByteDance-Seed/SeedVR2-3B}"
+
+# Multi-GPU / torchrun
+export NUM_GPUS="${NUM_GPUS:-8}"
+export NCCL_P2P_LEVEL="${NCCL_P2P_LEVEL:-NVL}"
+export NCCL_ASYNC_ERROR_HANDLING="${NCCL_ASYNC_ERROR_HANDLING:-1}"
+export OMP_NUM_THREADS="${OMP_NUM_THREADS:-8}"
+
+# Gradio
+export GRADIO_SERVER_NAME="${GRADIO_SERVER_NAME:-0.0.0.0}"
+export GRADIO_SERVER_PORT="${GRADIO_SERVER_PORT:-7860}"
+
+mkdir -p "$SEEDVR_ROOT" "$CKPTS_ROOT" "$OUTPUT_ROOT" "$INPUT_ROOT" "$HF_HOME"
+
+echo "[seedvr][start] checking environment..."
+command -v python >/dev/null || { echo "[seedvr][start] python not found"; exit 1; }
+command -v nvidia-smi >/dev/null && nvidia-smi || echo "[seedvr][start] warn: nvidia-smi not available"
+
+echo "[seedvr][start] cloning repo if missing: $SEEDVR_ROOT"
+if [ ! -d "$SEEDVR_ROOT/.git" ]; then
+  git clone "$SEEDVR_GIT_URL" "$SEEDVR_ROOT"
+else
+  echo "[seedvr][start] repo present"
+fi
+
+echo "[seedvr][start] downloading model (snapshot_download) into $CKPTS_ROOT"
+python - <<PY
+import os
+from pathlib import Path
+from huggingface_hub import snapshot_download
+
+repo_id = os.environ["SEEDVR_REPO_ID"]
+save_dir = os.environ["CKPTS_ROOT"]
+cache_dir = os.environ["HF_HOME"]
+token = os.environ.get("HF_TOKEN") or None
+
+Path(save_dir).mkdir(parents=True, exist_ok=True)
+snapshot_download(
+  repo_id=repo_id,
+  cache_dir=cache_dir,
+  local_dir=save_dir,
+  local_dir_use_symlinks=False,
+  resume_download=True,
+  allow_patterns=["*.json", "*.safetensors", "*.pth", "*.bin", "*.py", "*.md", "*.txt"],
+  token=token,
+)
+print("[seedvr][start] snapshot_download ok:", save_dir)
+PY
+
+
+export OUTPUT_ROOT=/app/outputs
+mkdir -p "$OUTPUT_ROOT" && chmod -R 777 "$OUTPUT_ROOT" || true
+
+
+echo "[seedvr][start] ensuring ckpt symlink SeedVR/ckpts/SeedVR2-3B -> $CKPTS_ROOT"
+mkdir -p "$SEEDVR_ROOT/ckpts"
+if [ -L "$SEEDVR_ROOT/ckpts/SeedVR2-3B" ]; then
+  target="$(readlink -f "$SEEDVR_ROOT/ckpts/SeedVR2-3B" || true)"
+  if [ "$target" != "$CKPTS_ROOT" ]; then
+    rm -f "$SEEDVR_ROOT/ckpts/SeedVR2-3B"
+  fi
+fi
+if [ ! -e "$SEEDVR_ROOT/ckpts/SeedVR2-3B" ]; then
+  ln -s "$CKPTS_ROOT" "$SEEDVR_ROOT/ckpts/SeedVR2-3B"
+fi
+
+echo "[seedvr][start] launching app_seedvr.py at ${GRADIO_SERVER_NAME}:${GRADIO_SERVER_PORT}"
+exec python app_seedvr.py