Update Dockerfile

Dockerfile

@@ -1,308 +1,201 @@
-# aduc_framework/managers/wan_manager.py
-# WanManager v1.5.3 (Correção final de dispositivo para `device_map="auto"`)
-
-import os
-import platform
-import shutil
-import subprocess
-import tempfile
-import random
-from typing import List, Any, Optional, Tuple
-
-import numpy as np
-import torch
-from PIL import Image
-import imageio.v2 as imageio
-from moviepy.editor import VideoFileClip, concatenate_videoclips
-
-torch.backends.cuda.matmul.allow_tf32 = True
-
-try:
-    from torch.nn.attention import sdpa_kernel, SDPBackend
-    _SDPA_NEW = True
-except ImportError:
-    _SDPA_NEW = False
-
-from diffusers import FlowMatchEulerDiscreteScheduler
-from diffusers.pipelines.wan.pipeline_wan_i2v import WanImageToVideoPipeline
-from diffusers.models.transformers.transformer_wan import WanTransformer3DModel
-from diffusers.utils.export_utils import export_to_video
-from aduc_framework.utils.callbacks import DenoiseStepLogger
-
-class WanManager:
-    """
-    Gerenciador de produção v1.5.3:
-    - CORREÇÃO: Remove o gerenciamento manual de dispositivos na preparação de tensores
-      para ser totalmente compatível com a automação do `accelerate` e `device_map="auto"`.
-      Resolve os erros "Cannot copy out of meta tensor".
-    - Mantém o `yield` para atualizações em tempo real, os modos I2V e V2V,
-      e toda a lógica de validação robusta.
-    """
-    MODEL_ID = "Wan-AI/Wan2.2-I2V-A14B-Diffusers"
-    TRANSFORMER_ID = "cbensimon/Wan2.2-I2V-A14B-bf16-Diffusers"
-    MIN_FRAMES_MODEL = 8
-    MAX_FRAMES_MODEL = 81
-    default_negative_prompt = (
-        "bright, overexposed, static, blurry details, text, subtitles, watermark, style, "
-        "artwork, painting, still image, gray scale, worst quality, low quality, jpeg artifacts, "
-        "ugly, deformed, disfigured, missing fingers, extra fingers, poorly drawn hands, "
-        "poorly drawn face, malformed limbs, fused fingers, messy background, three legs, "
-        "too many people, walking backwards."
-    )
+# =============================================================================
+# DOCKERFILE - ADUC-SDR: AI Video Suite v4.1.0
+# Base: CUDA 12.8.0 | PyTorch 2.8.0+cu128
+# Otimizado para Hugging Face Spaces com 8x NVIDIA L40S GPUs
+# =============================================================================
+
+# Base CUDA 12.8.0
+FROM nvidia/cuda:12.8.0-devel-ubuntu22.04
+
+# =============================================================================
+# METADADOS
+# =============================================================================
+LABEL maintainer="Carlos Rodrigues dos Santos & Development Partner"
+LABEL description="ADUC-SDR: Production-Ready Multi-GPU AI Video Generation Suite with Wan2.2, SeedVR, LTX, MMAudio"
+LABEL version="4.1.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"
+
+# Otimizações específicas do sistema
+ENV OMP_NUM_THREADS=8
+ENV MKL_NUM_THREADS=8
+ENV CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7
+ENV CUDA_DEVICE_MAX_CONNECTIONS=32
+
+# Cache e Memory Management
+# Unificar PYTORCH_CUDA_ALLOC_CONF em uma linha
+ENV PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:512,garbage_collection_threshold:0.8
+ENV CUDA_MODULE_LOADING=LAZY
+ENV CUDA_DEVICE_MAX_CONNECTIONS=32
+ENV CUDA_DEVICE_ORDER=PCI_BUS_ID
+
+
+
+# Constantes de Performance para Build
+ENV CUDA_CACHE_MAXSIZE=2147483648
+ENV CUDA_CACHE_DISABLE=0
+ENV TORCH_HOME=/app/.cache/torch
+ENV HF_HOME=/app/.cache/huggingface
+ENV HF_DATASETS_CACHE=/app/.cache/datasets
+
+# Constantes de Memory Management
+ENV PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:512,garbage_collection_threshold:0.8
+ENV CUDA_LAUNCH_BLOCKING=0
+ENV CUDA_DEVICE_ORDER=PCI_BUS_ID
+
+# Constantes de Model Loading
+ENV TRANSFORMERS_CACHE=/app/.cache/transformers
+ENV DIFFUSERS_CACHE=/app/.cache/diffusers
+ENV MODEL_CACHE_STRATEGY=aggressive
+
+
+# Melhorias de cache/download
+ENV HF_HOME=/app/.cache/huggingface
+ENV TRANSFORMERS_CACHE=/app/.cache/transformers
+ENV DIFFUSERS_CACHE=/app/.cache/diffusers
+ENV HF_DATASETS_CACHE=/app/.cache/datasets
+ENV HF_HUB_ENABLE_HF_TRANSFER=1
+ENV TOKENIZERS_PARALLELISM=false
+
+
+
+# =============================================================================
+# VARIÁVEIS DE AMBIENTE GLOBAIS
+# =============================================================================
+ENV DEBIAN_FRONTEND=noninteractive
+ENV TZ=UTC
+ENV LANG=C.UTF-8
+ENV LC_ALL=C.UTF-8
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PIP_NO_CACHE_DIR=1
+ENV PIP_DISABLE_PIP_VERSION_CHECK=1
+
+# Otimizações de CUDA e Build
+ENV NVIDIA_VISIBLE_DEVICES=all
+ENV NVIDIA_DRIVER_CAPABILITIES=compute,utility
+ENV TORCH_CUDA_ARCH_LIST="8.9"
+ENV MAX_JOBS=90
+
+# Caminhos da Aplicação
+ENV APP_HOME=/app
+WORKDIR $APP_HOME
+
+# =============================================================================
+# PACOTES DO SISTEMA E PYTHON 3.10
+# =============================================================================
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+    build-essential 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
+
+# =============================================================================
+# INSTALAÇÃO DE BIBLIOTECAS DE ALTA PERFORMANCE
+# =============================================================================
+
+# 1. Instala PyTorch 2.8.0 e ferramentas de build
+RUN pip -v install \
+    torch>=2.8.0+cu128 \
+    torchvision \
+    torchaudio \
+    --index-url https://download.pytorch.org/whl/cu128 
     
-    def __init__(self) -> None:
-        self._print_env_banner()
-        print("Loading models into memory...")
-        n_gpus = torch.cuda.device_count()
-        max_memory = {i: "43GiB" for i in range(n_gpus)}
-        max_memory["cpu"] = "120GiB"
-        transformer = WanTransformer3DModel.from_pretrained(
-            self.TRANSFORMER_ID, subfolder="transformer", torch_dtype=torch.bfloat16,
-            device_map="auto", max_memory=max_memory
-        )
-        transformer_2 = WanTransformer3DModel.from_pretrained(
-            self.TRANSFORMER_ID, subfolder="transformer_2", torch_dtype=torch.bfloat16,
-            device_map="auto", max_memory=max_memory
-        )
-        self.pipe = WanImageToVideoPipeline.from_pretrained(
-            self.MODEL_ID, transformer=transformer, transformer_2=transformer_2, torch_dtype=torch.bfloat16
-        )
-        self.pipe.scheduler = FlowMatchEulerDiscreteScheduler.from_config(self.pipe.scheduler.config, shift=32.0)
-
-        print("Applying 8-step Lightning LoRA...")
-        try:
-            self.pipe.load_lora_weights("Kijai/WanVideo_comfy", weight_name="Lightx2v/lightx2v_I2V_14B_480p_cfg_step_distill_rank128_bf16.safetensors", adapter_name="lightx2v")
-            self.pipe.load_lora_weights("Kijai/WanVideo_comfy", weight_name="Lightx2v/lightx2v_I2V_14B_480p_cfg_step_distill_rank128_bf16.safetensors", adapter_name="lightx2v_2", load_into_transformer_2=True)
-            self.pipe.set_adapters(["lightx2v", "lightx2v_2"], adapter_weights=[1.0, 1.0])
-            print("Fusing LoRA weights into the main model...")
-            self.pipe.fuse_lora(adapter_names=["lightx2v"], lora_scale=3.0, components=["transformer"])
-            self.pipe.fuse_lora(adapter_names=["lightx2v_2"], lora_scale=1.0, components=["transformer_2"])
-            self.pipe.unload_lora_weights()
-            print("Lightning LoRA successfully fused.")
-        except Exception as e:
-            print(f"[WanManager] AVISO: Falha ao fundir LoRA Lightning: {e}")
-        print("All models loaded. Service is ready.")
-
-    def _print_env_banner(self) -> None:
-        def _safe_get(fn, default="n/a"):
-            try: return fn()
-            except Exception: return default
-
-        torch_ver = getattr(torch, "__version__", "unknown")
-        cuda_rt = getattr(torch.version, "cuda", "unknown")
-        cudnn_ver = _safe_get(lambda: torch.backends.cudnn.version())
-        cuda_ok = torch.cuda.is_available()
-        n_gpu = torch.cuda.device_count() if cuda_ok else 0
-        devs, total_vram, caps = [], [], []
-        if cuda_ok:
-            for i in range(n_gpu):
-                props = torch.cuda.get_device_properties(i)
-                devs.append(f"cuda:{i} {props.name}")
-                total_vram.append(f"{props.total_memory/1024**3:.1f}GiB")
-                caps.append(f"{props.major}.{props.minor}")
-        
-        try: bf16_supported = torch.cuda.is_bf16_supported()
-        except: bf16_supported = False
-        
-        tf32_allowed = torch.backends.cuda.matmul.allow_tf32
-        sdpa_api = "torch.nn.attention (2.1+)" if _SDPA_NEW else "torch.backends.cuda (2.0)" if not _SDPA_NEW and hasattr(torch.backends.cuda, 'sdp_kernel') else "unavailable"
-        
-        try:
-            import xformers
-            xformers_ok = True
-        except ImportError:
-            xformers_ok = False
-
-        alloc_conf = os.environ.get("PYTORCH_CUDA_ALLOC_CONF", "unset")
-        visible = os.environ.get("CUDA_VISIBLE_DEVICES", "unset")
-        python_ver = platform.python_version()
-        nvcc = shutil.which("nvcc")
-        nvcc_ver = "n/a"
-        if nvcc:
-            try: nvcc_ver = subprocess.check_output([nvcc, "--version"], text=True).strip().splitlines()[-1]
-            except Exception: nvcc_ver = "n/a"
-
-        banner_lines = [
-            "================== WAN MANAGER • ENV ==================",
-            f"Python              : {python_ver}", f"PyTorch             : {torch_ver}",
-            f"CUDA (torch)        : {cuda_rt}", f"cuDNN               : {cudnn_ver}",
-            f"CUDA available      : {cuda_ok}", f"GPU count           : {n_gpu}",
-            f"GPUs                : {', '.join(devs) if devs else 'n/a'}",
-            f"GPU VRAM            : {', '.join(total_vram) if total_vram else 'n/a'}",
-            f"Compute Capability  : {', '.join(caps) if caps else 'n/a'}",
-            f"BF16 supported      : {bf16_supported}", f"TF32 allowed        : {tf32_allowed}",
-            f"SDPA API            : {sdpa_api}", f"xFormers available  : {xformers_ok}",
-            f"CUDA_VISIBLE_DEVICES: {visible}", f"PYTORCH_CUDA_ALLOC_CONF: {alloc_conf}",
-            f"nvcc                : {nvcc_ver}",
-            "=======================================================",
-        ]
-        print("\n".join(banner_lines))
-
-    def resize_and_crop_to_match(self, target: Image.Image, ref_w: int, ref_h: int) -> Image.Image:
-        tw, th = target.size
-        s = max(ref_w / tw, ref_h / th)
-        nw, nh = int(tw * s), int(th * s)
-        resized = target.resize((nw, nh), Image.Resampling.LANCZOS)
-        left, top = (nw - ref_w) // 2, (nh - ref_h) // 2
-        return resized.crop((left, top, left + ref_w, top + ref_h))
-
-    def _preprocess_causal_video(self, video_path: str, target_fps: int, target_w: int, target_h: int) -> str:
-        print(f"[WanManager] Pré-processando vídeo: conformando para {target_w}x{target_h} @ {target_fps}fps...")
-        clip = VideoFileClip(video_path)
-        conformed_clip = clip.resize(height=target_h) if (clip.w / clip.h) < (target_w / target_h) else clip.resize(width=target_w)
-        conformed_clip = conformed_clip.crop(x_center=conformed_clip.w/2, y_center=conformed_clip.h/2, width=target_w, height=target_h)
-        conformed_clip = conformed_clip.set_fps(target_fps)
-        with tempfile.NamedTemporaryFile(suffix="_conformed.mp4", delete=False) as tmp:
-            conformed_video_path = tmp.name
-        conformed_clip.write_videofile(conformed_video_path, codec="libx264", audio=False, logger=None, threads=os.cpu_count() or 1)
-        clip.close()
-        print(f"[WanManager] Vídeo conformado salvo em: {conformed_video_path}")
-        return conformed_video_path
-
-    def generate_video(
-        self,
-        convergent_img: Image.Image,
-        causal_video_path: Optional[str] = None,
-        causal_img: Optional[Image.Image] = None,
-        handler_img: Optional[Image.Image] = None,
-        total_frames: Optional[int] = 33,
-        handler_frame: Optional[int] = 17,
-        handler_weight: float = 1.0,
-        causal_weight: float = 1.0,
-        fps: Optional[int] = 16,
-        resolution: Optional[str] = "480x832",
-        prompt: str = "",
-        negative_prompt: Optional[str] = None,
-        steps: int = 8,
-        guidance_scale: float = 1.0,
-        guidance_scale_2: float = 1.0,
-        seed: int = 42,
-        randomize_seed: bool = True,
-    ):
-        final_handler_img, final_causal_img = handler_img, causal_img
-        final_total_frames, final_fps, final_resolution = total_frames, fps, resolution
-        final_handler_frame, final_causal_weight, final_handler_weight = handler_frame, causal_weight, handler_weight
-        conformed_video_path = None
-
-        if causal_video_path and os.path.exists(causal_video_path):
-            print(f"[WanManager] INFO: Modo 'Causal Video' ativado com o arquivo: {causal_video_path}")
-            target_h, target_w = [int(x) for x in resolution.split('x')]
-            conformed_video_path = self._preprocess_causal_video(causal_video_path, fps, target_w, target_h)
-            reader = imageio.get_reader(conformed_video_path)
-            video_frame_count = reader.count_frames()
-            if video_frame_count < 25:
-                reader.close()
-                raise ValueError(f"O vídeo conformado deve ter pelo menos 25 frames. Tem apenas {video_frame_count}.")
-            print("[WanManager] INFO: Extraindo frames de controle do vídeo conformado...")
-            causal_img_from_video_np = reader.get_data(video_frame_count - 25)
-            final_causal_img = Image.fromarray(causal_img_from_video_np)
-            handler_img_from_video_np = reader.get_data(video_frame_count - 1)
-            final_handler_img = Image.fromarray(handler_img_from_video_np)
-            reader.close()
-            final_total_frames, final_fps, final_resolution = video_frame_count, fps, resolution
-            final_handler_frame, final_handler_weight, final_causal_weight = 24, 1.0, causal_weight
-        else:
-            print("[WanManager] INFO: Modo 'Image to Video' padrão ativado.")
-            if convergent_img is None or causal_img is None:
-                raise ValueError("A imagem convergente (inicial) e a imagem causal (final) são obrigatórias no modo I2V.")
-
-        target_h, target_w = [int(x) for x in final_resolution.split('x')]
-        
-        processed_convergent = self.resize_and_crop_to_match(convergent_img, target_w, target_h)
-        processed_causal = self.resize_and_crop_to_match(final_causal_img, target_w, target_h)
-        processed_handler = self.resize_and_crop_to_match(final_handler_img, target_w, target_h) if final_handler_img else None
-
-        clamped_frames = int(np.clip(final_total_frames, self.MIN_FRAMES_MODEL, self.MAX_FRAMES_MODEL))
-        sf_t = getattr(self.pipe, "vae_scale_factor_temporal", 4)
-        num_frames = ((clamped_frames - 1) // sf_t * sf_t) + 1
-        
-        print(f"[WanManager] INFO: Total de frames final para a pipeline é {num_frames}.")
-
-        current_seed = random.randint(0, np.iinfo(np.int32).max) if randomize_seed else int(seed)
-        
-        corrected_handler_index = None
-        if processed_handler is not None and final_handler_frame is not None:
-            min_safe_frame, max_safe_frame = 9, num_frames - 9
-            if causal_video_path:
-                 corrected_handler_index = max(min_safe_frame, min(final_handler_frame, max_safe_frame))
-            else:
-                block_index = round(final_handler_frame / 8)
-                aligned_frame = block_index * 8 + 1
-                corrected_handler_index = max(min_safe_frame, min(aligned_frame, max_safe_frame))
-            print(f"[WanManager] INFO: Handler Frame final validado para {corrected_handler_index}.")
-
-        print("[WanManager] Preparando tensores e timesteps para a geração...")
-        
-        transformer_dtype = self.pipe.transformer.dtype
-        generator = torch.Generator(device="cpu").manual_seed(current_seed)
-        
-        prompt_embeds, negative_prompt_embeds = self.pipe.encode_prompt(prompt=prompt, negative_prompt=negative_prompt or self.default_negative_prompt)
-        prompt_embeds = prompt_embeds.to(transformer_dtype)
-        if negative_prompt_embeds is not None:
-            negative_prompt_embeds = negative_prompt_embeds.to(transformer_dtype)
-            
-        image_processed = self.pipe.video_processor.preprocess(processed_convergent, height=target_h, width=target_w)
-        causal_img_processed = self.pipe.video_processor.preprocess(processed_causal, height=target_h, width=target_w)
-        handler_img_processed = self.pipe.video_processor.preprocess(processed_handler, height=target_h, width=target_w) if processed_handler else None
-
-        latents_outputs = self.pipe.prepare_latents(
-            image=image_processed, batch_size=1, num_channels_latents=self.pipe.vae.config.z_dim,
-            height=target_h, width=target_w, num_frames=num_frames, dtype=torch.float32, generator=generator,
-            causal_img=causal_img_processed, handler_img=handler_img_processed,
-            handler_frame_index=corrected_handler_index, handler_weight=final_handler_weight, causal_weight=final_causal_weight
-        )
-        latents, condition = latents_outputs
-        
-        self.pipe.scheduler.set_timesteps(steps, device=latents.device)
-        timesteps = self.pipe.scheduler.timesteps
-        
-        denoise_logger = DenoiseStepLogger(self.pipe)
-        denoising_step_videos = []
-
-        with torch.no_grad():
-            for i, t in enumerate(timesteps):
-                print(f"[WanManager] Executando passo de denoising {i+1}/{steps}...")
-                latent_model_input = torch.cat([latents, condition], dim=1).to(transformer_dtype)
-                
-                noise_pred_uncond = self.pipe.transformer(latent_model_input, t, encoder_hidden_states=negative_prompt_embeds).sample
-                noise_pred_text = self.pipe.transformer(latent_model_input, t, encoder_hidden_states=prompt_embeds).sample
-                
-                noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
-                latents = self.pipe.scheduler.step(noise_pred, t, latents).prev_sample
-
-                video_frames_np = denoise_logger.decode_latents_to_video_tensor(latents)
-                with tempfile.NamedTemporaryFile(suffix=f"_step_{i+1}.mp4", delete=False) as tmp:
-                    step_video_path = tmp.name
-                export_to_video(video_frames_np[0], step_video_path, fps=final_fps)
-                denoising_step_videos.append(step_video_path)
-                
-                yield None, None, denoising_step_videos
-        
-        print("[WanManager] Denoising completo. Processando o vídeo final...")
-        final_video_frames_np = denoise_logger.decode_latents_to_video_tensor(latents)
-
-        with tempfile.NamedTemporaryFile(suffix="_generated_clip.mp4", delete=False) as tmp:
-            generated_clip_path = tmp.name
-        export_to_video(final_video_frames_np[0], generated_clip_path, fps=final_fps)
-        
-        final_video_path = generated_clip_path
-        if conformed_video_path:
-            print("[WanManager] INFO: Modo Causal Video: iniciando concatenação final...")
-            input_clip = VideoFileClip(conformed_video_path)
-            generated_clip = VideoFileClip(generated_clip_path)
-            duration_to_cut = 25 / input_clip.fps
-            if input_clip.duration > duration_to_cut:
-                prefix_clip = input_clip.subclip(0, input_clip.duration - duration_to_cut)
-                final_clip = concatenate_videoclips([prefix_clip, generated_clip])
-            else:
-                final_clip = generated_clip
-            with tempfile.NamedTemporaryFile(suffix="_final.mp4", delete=False) as tmp:
-                final_video_path = tmp.name
-            final_clip.write_videofile(final_video_path, codec="libx264", audio=False, logger=None, threads=os.cpu_count() or 1)
-            input_clip.close()
-            generated_clip.close()
-            os.remove(conformed_video_path)
-            os.remove(generated_clip_path)
-            print(f"[WanManager] INFO: Vídeo final concatenado salvo em: {final_video_path}")
-        
-        yield final_video_path, current_seed, denoising_step_videos
+RUN pip install  \
+    packaging \
+    ninja \
+    cmake \
+    pybind11 \
+    scikit-build \
+    cython \
+    hf_transfer \
+    numpy==1.24.4 
+
+
+# =============================================================================
+# CLONAGEM E INSTALAÇÃO DOS REPOSITÓRIOS DA APLICAÇÃO
+# =============================================================================
+
+RUN git clone https://github.com/Wan-Video/Wan2.2.git && \
+    #cd Wan2.2 && pip install -v -r requirements.txt && pip install -v -r requirements_s2v.txt && cd .. && \
+    echo "Copiando 'wan' para /app/wan..." && \
+    cp -r Wan2.2/wan /app/wan 
+    
+# VINCIE
+RUN git clone https://github.com/bytedance-seed/VINCIE.git && \
+    #cd VINCIE && pip install -v -r requirements.txt && cd .. && \  
+    #echo "Copiando módulos do SeedVR para /app/..." && \
+    #cp /VINCIE/generate.py /app/VINCIE/ 2>/dev/null || echo "vincie_service.py não encontrado"
+    #cp -r VINCIE /app/VINCIE && \
+    #cp -r VINCIE/projects /app/projects && \
+    #cp -r VINCIE/data /app/data && \
+    cp -r VINCIE/configs/. /app/configs/
+    
+
+# SeedVR
+RUN git clone https://github.com/bytedance-seed/SeedVR.git && \
+    #cd SeedVR && pip install -v -r requirements.txt && cd .. && \
+    #echo "Copiando módulos do SeedVR para /app/..." && \
+    #cp -r SeedVR/common /app/common && \
+    #cp -r SeedVR/projects /app/projects && \
+    #cp -r SeedVR/data /app/data && \
+    cp -r SeedVR/configs_3b /app/configs_3b 
+    
+
+# MMAudio
+#RUN git clone https://github.com/hkchengrex/MMAudio.git && \
+#    cd MMAudio && pip install -v -e . && cd .. && \
+#    echo "Copiando 'mmaudio' para /app/mmaudio..." && \
+#    cp -r MMAudio/mmaudio /app/mmaudio 
+
+# LTX-Video
+RUN git clone https://github.com/Lightricks/LTX-Video.git && \
+    #cd LTX-Video && pip install -v -e .[inference] && cd .. && \
+    echo "Copiando 'ltx_video' para /app/ltx_video..." && \
+    cp -r LTX-Video/ltx_video /app/ltx_video 
+
+# opcionais 
+RUN pip uninstall -y bitsandbytes triton && \
+    pip install -v  bitsandbytes --index-url https://pypi.org/simple/ && \
+    pip install -v  triton
+    
+# =============================================================================
+# INSTALAÇÃO DO RESTANTE DAS DEPENDÊNCIAS
+# =============================================================================
+COPY requirements.txt .
+
+# Instala os pacotes restantes do requirements.txt
+# A linha do flash-attention no arquivo será ignorada se já estiver instalado, mas é bom limpá-la.
+RUN pip install -r requirements.txt
+
+
+# PyTorch cu128 (fixar versões consistentes do mesmo canal)
+RUN pip install --index-url https://download.pytorch.org/whl/cu128 \
+    torch==2.8.0+cu128 torchvision>=0.19.0+cu128 torchaudio>=2.8.0+cu128
+    
+
+
+# =============================================================================
+# COPIA O CÓDIGO DA APLICAÇÃO E CONFIGURA PERMISSÕES
+# =============================================================================
+COPY . .
+
+RUN useradd -m -u 1000 -s /bash appuser && \
+    chown -R appuser:appuser $APP_HOME && \
+    mkdir -p /app && chown -R appuser:appuser /app
+
+USER appuser
+
+# =============================================================================
+# PONTO DE ENTRADA
+# =============================================================================
+RUN chmod +x ./start.sh
+
+ENTRYPOINT ["./start.sh"]
+CMD ["gradio"]