Update api/ltx_server_refactored.py

api/ltx_server_refactored.py

@@ -1,8 +1,17 @@
 # ltx_server_refactored.py — VideoService (Modular Version with Simple Overlap Chunking)
-# Em api/ltx_server_refactored.py
 
+# --- 0. WARNINGS E AMBIENTE ---
 import warnings
+warnings.filterwarnings("ignore", category=UserWarning)
+warnings.filterwarnings("ignore", category=FutureWarning)
+warnings.filterwarnings("ignore", message=".*")
 from huggingface_hub import logging
+logging.set_verbosity_error()
+logging.set_verbosity_warning()
+logging.set_verbosity_info()
+logging.set_verbosity_debug()
+LTXV_DEBUG=1
+LTXV_FRAME_LOG_EVERY=8
 import os, subprocess, shlex, tempfile
 import torch
 import json
@@ -24,23 +33,12 @@ import shutil
 import contextlib
 import time
 import traceback
-from api.gpu_manager import gpu_manager
 from einops import rearrange
 import torch.nn.functional as F
 from managers.vae_manager import vae_manager_singleton
 from tools.video_encode_tool import video_encode_tool_singleton
-
 DEPS_DIR = Path("/data")
 LTX_VIDEO_REPO_DIR = DEPS_DIR / "LTX-Video"
-logging.set_verbosity_error()
-logging.set_verbosity_warning()
-logging.set_verbosity_info()
-logging.set_verbosity_debug()
-LTXV_DEBUG=1
-LTXV_FRAME_LOG_EVERY=8
-warnings.filterwarnings("ignore", category=UserWarning)
-warnings.filterwarnings("ignore", category=FutureWarning)
-warnings.filterwarnings("ignore", message=".*")
 
 # (Todas as funções de setup, helpers e inicialização da classe permanecem inalteradas)
 # ... (run_setup, add_deps_to_path, _query_gpu_processes_via_nvml, etc.)
@@ -100,6 +98,24 @@ from api.ltx.inference import (
 )
 
 class VideoService:
+    def __init__(self):
+        t0 = time.perf_counter()
+        print("[DEBUG] Inicializando VideoService...")
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.config = self._load_config()
+        self.pipeline, self.latent_upsampler = self._load_models()
+        self.pipeline.to(self.device)
+        if self.latent_upsampler:
+            self.latent_upsampler.to(self.device)
+        self._apply_precision_policy()
+        vae_manager_singleton.attach_pipeline(
+            self.pipeline,
+            device=self.device,
+            autocast_dtype=self.runtime_autocast_dtype
+        )
+        self._tmp_dirs = set()
+        print(f"[DEBUG] VideoService pronto. boot_time={time.perf_counter()-t0:.3f}s")
+
     def _load_config(self):
         base = LTX_VIDEO_REPO_DIR / "configs"
         config_path = base / "ltxv-13b-0.9.8-distilled-fp8.yaml"
@@ -119,6 +135,10 @@ class VideoService:
                     pass
         except Exception as e:
             print(f"[DEBUG] Finalize: limpeza GPU falhou: {e}")
+        try:
+            self._log_gpu_memory("Após finalize")
+        except Exception as e:
+            print(f"[DEBUG] Log GPU pós-finalize falhou: {e}")
             
     def _load_models(self):
         t0 = time.perf_counter()
@@ -200,11 +220,11 @@ class VideoService:
 
             
     def _save_and_log_video(self, pixel_tensor, base_filename, fps, temp_dir, results_dir, used_seed, progress_callback=None):
-        output_path = os.path.join(temp_dir, f"{base_filename}_.mp4")
+        output_path = os.path.join(temp_dir, f"{base_filename}_{used_seed}.mp4")
         video_encode_tool_singleton.save_video_from_tensor(
             pixel_tensor, output_path, fps=fps, progress_callback=progress_callback
         )
-        final_path = os.path.join(results_dir, f"{base_filename}_.mp4")
+        final_path = os.path.join(results_dir, f"{base_filename}_{used_seed}.mp4")
         shutil.move(output_path, final_path)
         print(f"[DEBUG] Vídeo salvo em: {final_path}")
         return final_path
@@ -243,8 +263,7 @@ class VideoService:
         first_pass_kwargs = {
             "prompt": prompt, "negative_prompt": negative_prompt, "height": downscaled_height, "width": downscaled_width,
             "num_frames": actual_num_frames, "frame_rate": int(FPS), "generator": torch.Generator(device=self.device).manual_seed(used_seed),
-            "output_type": "latent", "conditioning_items": conditioning_items, 
-            #"guidance_scale": float(guidance_scale),
+            "output_type": "latent", "conditioning_items": conditioning_items, "guidance_scale": float(guidance_scale),
             **(self.config.get("first_pass", {}))
         }
         try: 
@@ -258,283 +277,13 @@ class VideoService:
             return video_path, tensor_path, used_seed
         
         except Exception as e:
-            print(f"[DEBUG] falhou: {e}")
-        finally:
-            torch.cuda.empty_cache()
-            torch.cuda.ipc_collect()
-            self.finalize(keep_paths=[])
-
-    # ==============================================================================
-    # --- FUNÇÃO #1: GERADOR DE CHUNK ÚNICO (AUXILIAR INTERNA) ---
-    # ==============================================================================
-    def _generate_single_chunk_low(
-        self, prompt, negative_prompt, 
-        height, width, num_frames, guidance_scale, 
-        seed, initial_latent_condition=None, image_conditions=None, 
-        ltx_configs_override=None):
-        """
-        [NÓ DE GERAÇÃO]
-        Gera um ÚNICO chunk de latentes brutos. Esta é a unidade de trabalho fundamental.
-        """
-        print("\n" + "-"*20 + " INÍCIO: _generate_single_chunk_low " + "-"*20)
-
-        used_seed = random.randint(0, 2**32 - 1) if seed is None else int(seed)
-        seed_everething(used_seed)
-        
-        # --- NÓ 1.1: SETUP DE PARÂMETROS ---
-        height_padded = ((height - 1) // 8 + 1) * 8
-        width_padded = ((width - 1) // 8 + 1) * 8
-        generator = torch.Generator(device=self.device).manual_seed(seed)
-        
-        downscale_factor = self.config.get("downscale_factor", 0.6666666)
-        vae_scale_factor = self.pipeline.vae_scale_factor
-        
-        x_width = int(width_padded * downscale_factor)
-        downscaled_width = x_width - (x_width % vae_scale_factor)
-        x_height = int(height_padded * downscale_factor)
-        downscaled_height = x_height - (x_height % vae_scale_factor)
-        
-        # --- NÓ 1.2: MONTAGEM DE CONDIÇÕES E OVERRIDES ---
-        all_conditions = []
-        if image_conditions: all_conditions.extend(image_conditions)
-        if initial_latent_condition: all_conditions.append(initial_latent_condition)
-
-        first_pass_config = self.config.get("first_pass", {}).copy()
-
-        if ltx_configs_override:
-            print("[DEBUG] Sobrepondo configurações do LTX com valores da UI...")
-            preset = ltx_configs_override.get("guidance_preset")
-            if preset == "Customizado":
-                try:
-                    first_pass_config["guidance_scale"] = json.loads(ltx_configs_override["guidance_scale_list"])
-                    first_pass_config["stg_scale"] = json.loads(ltx_configs_override["stg_scale_list"])
-                    #first_pass_config["guidance_timesteps"] = json.loads(ltx_configs_override["timesteps_list"])
-                except Exception as e:
-                    print(f"  > ERRO ao parsear valores customizados: {e}. Usando Padrão como fallback.")
-            elif preset == "Agressivo":
-                first_pass_config["guidance_scale"] = [1, 2, 8, 12, 8, 2, 1]
-                first_pass_config["stg_scale"] = [0, 0, 5, 6, 5, 3, 2]
-            elif preset == "Suave":
-                first_pass_config["guidance_scale"] = [1, 1, 4, 5, 4, 1, 1]
-                first_pass_config["stg_scale"] = [0, 0, 2, 2, 2, 1, 0]
-                                        
-        first_pass_kwargs = {
-            "prompt": prompt, "negative_prompt": negative_prompt, "height": downscaled_height, "width": downscaled_width,
-            "num_frames": num_frames, "frame_rate": 24, "generator": generator, "output_type": "latent",
-            "conditioning_items": all_conditions if all_conditions else None,
-            **first_pass_config
-        }
-
-        results_dir = "/app/output"; os.makedirs(results_dir, exist_ok=True)
-    
-        
-        # --- NÓ 1.3: CHAMADA AO PIPELINE ---
-        try: 
-            with torch.autocast(device_type="cuda", dtype=self.runtime_autocast_dtype, enabled=self.device.type == 'cuda'):
-                latents_bruto = self.pipeline(**first_pass_kwargs).images
-                latents_cpu_bruto = latents_bruto.detach().to("cpu")
-                tensor_path_cpu = os.path.join(results_dir, f"latents_low_res.pt")
-                torch.save(latents_cpu_bruto, tensor_path_cpu)
-                log_tensor_info(latents_bruto, f"Latente Bruto Gerado para: '{prompt[:40]}...'")
-        
-            print("-" * 20 + " FIM: _generate_single_chunk_low " + "-"*20)
-            return tensor_path_cpu
-        except Exception as e:
-            print("-" * 20 + f" ERRO: _generate_single_chunk_low {e} " + "-"*20)
-        finally:
-            torch.cuda.empty_cache()
-            torch.cuda.ipc_collect()
-            self.finalize(keep_paths=[])
-
-    # ==============================================================================
-    # --- FUNÇÃO #2: ORQUESTRADOR NARRATIVO (MÚLTIPLOS PROMPTS) ---
-    # ==============================================================================
-    def generate_narrative_low(
-        self, prompt: str, negative_prompt, 
-        height, width, duration, guidance_scale, 
-        seed, initial_image_conditions=None, overlap_frames: int = 8,
-        ltx_configs_override: dict = None):
-        """
-        [ORQUESTRADOR NARRATIVO]
-        Gera um vídeo em múltiplos chunks sequenciais a partir de um prompt com várias linhas.
-        """
-        print("\n" + "="*80)
-        print("======           INICIANDO GERAÇÃO NARRATIVA EM CHUNKS (LOW-RES)           ======")
-        print("="*80)
-        
-        
-        used_seed = random.randint(0, 2**32 - 1) if seed is None else int(seed)
-        seed_everething(used_seed)
-        FPS = 24.0
-
-        prompt_list = [p.strip() for p in prompt.splitlines() if p.strip()]
-        num_chunks = len(prompt_list)
-        if num_chunks == 0: raise ValueError("O prompt está vazio ou não contém linhas válidas.")
-        
-        total_actual_frames = max(9, int(round((round(duration * FPS) - 1) / 8.0) * 8 + 1))
-
-        if num_chunks > 1:
-            total_blocks = (total_actual_frames - 1) // 8
-            blocks_per_chunk = total_blocks // num_chunks
-            blocks_last_chunk = total_blocks - (blocks_per_chunk * (num_chunks - 1))
-            frames_per_chunk = blocks_per_chunk * 8 + 1
-            frames_per_chunk_last = blocks_last_chunk * 8 + 1
-        else:
-            frames_per_chunk = total_actual_frames
-            frames_per_chunk_last = total_actual_frames
-        
-        frames_per_chunk = max(9, frames_per_chunk)
-        frames_per_chunk_last = max(9, frames_per_chunk_last)
-        
-        poda_latents_num = overlap_frames // self.pipeline.video_scale_factor if self.pipeline.video_scale_factor > 0 else 0
-        
-        latentes_chunk_video = []
-        lista_patch_latentes_chunk = []
-        condition_item_latent_overlap = None
-        temp_dir = tempfile.mkdtemp(prefix="ltxv_narrative_"); self._register_tmp_dir(temp_dir)
-        results_dir = "/app/output"; os.makedirs(results_dir, exist_ok=True)
-        
-        for i, chunk_prompt in enumerate(prompt_list):
-            print(f"\n--- Gerando Chunk Narrativo {i+1}/{num_chunks}: '{chunk_prompt}' ---")
-
-            current_image_conditions = []
-            if initial_image_conditions:
-                cond_item_original = initial_image_conditions[0]
-                if i == 0:
-                    current_image_conditions.append(cond_item_original)
-                else:
-                    cond_item_fraco = ConditioningItem(
-                        media_item=cond_item_original.media_item, media_frame_number=0, conditioning_strength=0.1
-                    )
-                    current_image_conditions.append(cond_item_fraco)
-
-
-            poda_latents_num = 8
-            
-            if i > 0 and poda_latents_num > 0:
-                frames_per_chunk += poda_latents_num
-            else:
-                frames_per_chunk = frames_per_chunk
-           
-            if i == num_chunks - 1:
-                frames_per_chunk = frames_per_chunk_last+poda_latents_num
-
-            frames_per_chunk = ((frames_per_chunk//8)*8)+1
-            
-            latent_path = self._generate_single_chunk_low(
-                prompt=chunk_prompt, negative_prompt=negative_prompt, height=height, width=width,
-                num_frames=frames_per_chunk, guidance_scale=guidance_scale, seed=used_seed + i,
-                initial_latent_condition=condition_item_latent_overlap, image_conditions=current_image_conditions,
-                ltx_configs_override=ltx_configs_override
-            )
-        
-            latentes_bruto = torch.load(latent_path).to("cpu")
-
-            #poda inicio overlap
-            if i > 0 and poda_latents_num > 0:
-                 latentes_bruto = latentes_bruto[:, :, poda_latents_num:, :, :]
-
-
-            # cria estado overlap para proximo
-            if i < num_chunks - 1 and poda_latents_num > 0:
-                overlap_latents = latentes_bruto[:, :, -poda_latents_num:, :, :].clone()
-                overlap_latents = overlap_latents.detach().to(self.device)
-                condition_item_latent_overlap = ConditioningItem(
-                    media_item=overlap_latents, media_frame_number=0, conditioning_strength=1.0
-                )
-
-            #adiciona a lista
-            tensor_path_podado = os.path.join(results_dir, f"latents_poda{i}_res.pt")
-            torch.save(latentes_bruto, tensor_path_podado)
-            lista_patch_latentes_chunk.append(tensor_path_podado)
-
-        print("\n--- Finalizando Narrativa: Concatenando chunks ---")
-        
-        # Carrega cada tensor do disco
-        lista_tensores = [torch.load(caminho) for caminho in lista_patch_latentes_chunk]
-        
-        # Concatena ao longo da dimensão de frames (dim=2)
-        final_latents = torch.cat(lista_tensores, dim=2).to(self.device)
-        log_tensor_info(final_latents, "Tensor de Latentes Final Concatenado")
-        
-        try: 
-            with torch.autocast(device_type="cuda", dtype=self.runtime_autocast_dtype, enabled=self.device.type == 'cuda'):
-                pixel_tensor = vae_manager_singleton.decode(final_latents, decode_timestep=float(self.config.get("decode_timestep", 0.05)))
-                pixel_tensor_cpu = pixel_tensor.detach().to("cpu")
-                video_path = self._save_and_log_video(pixel_tensor_cpu, "narrative_video", FPS, temp_dir, results_dir, used_seed)
-                final_latents_cpu = final_latents.detach().to("cpu")
-                final_latents_patch = os.path.join(results_dir, f"latents_low_fim.pt")
-                torch.save(final_latents_cpu, final_latents_patch)
-            return video_path, final_latents_patch, used_seed
-        
-        except Exception as e:
-            print(f"[DEBUG] falhou: {e}")
+            pass
         finally:
             torch.cuda.empty_cache()
             torch.cuda.ipc_collect()
             self.finalize(keep_paths=[])
             
-    # ==============================================================================
-    # --- FUNÇÃO #3: ORQUESTRADOR SIMPLES (PROMPT ÚNICO) ---
-    # ==============================================================================
-    def generate_single_low(
-        self, prompt: str, negative_prompt, 
-        height, width, duration, guidance_scale, 
-        seed, initial_image_conditions=None,
-        ltx_configs_override: dict = None):
-        """
-        [ORQUESTRADOR SIMPLES]
-        Gera um vídeo completo em um único chunk. Ideal para prompts simples e curtos.
-        """
-        print("\n" + "="*80)
-        print("======             INICIANDO GERAÇÃO SIMPLES EM CHUNK ÚNICO (LOW-RES)             ======")
-        print("="*80)
-
-        used_seed = random.randint(0, 2**32 - 1) if seed is None else int(seed)
-        seed_everething(used_seed)
-        FPS = 24.0
-
-        total_actual_frames = max(9, int(round((round(duration * FPS) - 1) / 8.0) * 8 + 1))
-        
-        temp_dir = tempfile.mkdtemp(prefix="ltxv_single_"); self._register_tmp_dir(temp_dir)
-        results_dir = "/app/output"; os.makedirs(results_dir, exist_ok=True)
-
-        # Chama a função de geração de chunk único para fazer todo o trabalho
-        latent_path = self._generate_single_chunk_low(
-            prompt=prompt, negative_prompt=negative_prompt, height=height, width=width,
-            num_frames=total_actual_frames, guidance_scale=guidance_scale, seed=used_seed,
-            image_conditions=initial_image_conditions, 
-            ltx_configs_override=ltx_configs_override
-        )
-
-        final_latents = torch.load(latent_path).to(self.device)
-        print("\n--- Finalizando Geração Simples: Salvando e decodificando ---")
-        log_tensor_info(final_latents, "Tensor de Latentes Final")
-
-        try: 
-            with torch.autocast(device_type="cuda", dtype=self.runtime_autocast_dtype, enabled=self.device.type == 'cuda'):
-                pixel_tensor = vae_manager_singleton.decode(final_latents.clone(), decode_timestep=float(self.config.get("decode_timestep", 0.05)))
-                video_path = self._save_and_log_video(pixel_tensor, "single_video", FPS, temp_dir, results_dir, used_seed)
-                latents_cpu = final_latents.detach().to("cpu")
-                tensor_path = os.path.join(results_dir, f"latents_single.pt")
-                torch.save(latents_cpu, tensor_path)
-            return video_path, tensor_path, used_seed
-        except Exception as e:
-            print(f"[DEBUG] falhou: {e}")
-        finally:
-            torch.cuda.empty_cache()
-            torch.cuda.ipc_collect()
-            self.finalize(keep_paths=[])
-        
-
-        
-    # ==============================================================================
-    # --- FUNÇÃO #4: ORQUESTRADOR  (Upscaler + texturas hd) ---
-    # ==============================================================================
-    def generate_upscale_denoise(
-        self, latents_path, prompt, negative_prompt, 
-        guidance_scale, seed,
-    ):
+    def generate_upscale_denoise(self, latents_path, prompt, negative_prompt, guidance_scale, seed):
             used_seed = random.randint(0, 2**32 - 1) if seed is None else int(seed)
             seed_everething(used_seed)
             temp_dir = tempfile.mkdtemp(prefix="ltxv_up_"); self._register_tmp_dir(temp_dir)
@@ -560,8 +309,7 @@ class VideoService:
                     second_pass_width = chunk.shape[4] * self.pipeline.vae_scale_factor
                     second_pass_kwargs = {
                         "prompt": prompt, "negative_prompt": negative_prompt, "height": second_pass_height, "width": second_pass_width,
-                        "num_frames": chunk.shape[2], "latents": chunk, 
-                        #"guidance_scale": float(guidance_scale),
+                        "num_frames": chunk.shape[2], "latents": chunk, "guidance_scale": float(guidance_scale),
                         "output_type": "latent", "generator": torch.Generator(device=self.device).manual_seed(used_seed),
                         **(self.config.get("second_pass", {}))
                     }
@@ -582,6 +330,8 @@ class VideoService:
             video_path = self._save_and_log_video(pixel_tensor, "refined_video", 24.0, temp_dir, results_dir, used_seed)
             return video_path, tensor_path    
 
+            
+
     def encode_mp4(self, latents_path: str, fps: int = 24):
         latents = torch.load(latents_path)
         seed = random.randint(0, 99999)
@@ -609,51 +359,9 @@ class VideoService:
         final_pixel_tensor = torch.cat(pixel_chunks_to_concat, dim=2)
         final_video_path = self._save_and_log_video(final_pixel_tensor, f"final_concatenated_{seed}", fps, temp_dir, results_dir, seed)
         return final_video_path
-
-    def __init__(self):
-        t0 = time.perf_counter()
-        print("[DEBUG] Inicializando VideoService...")
-        
-        # 1. Obter o dispositivo alvo a partir do gerenciador
-        #    Não definimos `self.device` ainda, apenas guardamos o alvo.
-        target_device = gpu_manager.get_ltx_device()
-        print(f"[DEBUG] LTX foi alocado para o dispositivo: {target_device}")
-
-        # 2. Carregar a configuração e os modelos (na CPU, como a função _load_models faz)
-        self.config = self._load_config()
-        self.pipeline, self.latent_upsampler = self._load_models()
-
-        # 3. Mover os modelos para o dispositivo alvo e definir `self.device`
-        self.move_to_device(target_device) # Usando a função que já criamos!
-
-        # 4. Configurar o resto dos componentes com o dispositivo correto
-        self._apply_precision_policy()
-        vae_manager_singleton.attach_pipeline(
-            self.pipeline,
-            device=self.device, # Agora `self.device` está correto
-            autocast_dtype=self.runtime_autocast_dtype
-        )
-        self._tmp_dirs = set()
-        print(f"[DEBUG] VideoService pronto. boot_time={time.perf_counter()-t0:.3f}s")
-    
-    # A função move_to_device que criamos antes é essencial aqui
-    def move_to_device(self, device):
-        """Move os modelos do pipeline para o dispositivo especificado."""
-        print(f"[LTX] Movendo modelos para {device}...")
-        self.device = torch.device(device) # Garante que é um objeto torch.device
-        self.pipeline.to(self.device)
-        if self.latent_upsampler:
-            self.latent_upsampler.to(self.device)
-        print(f"[LTX] Modelos agora estão em {self.device}.")
         
-    def move_to_cpu(self):
-        """Move os modelos para a CPU para liberar VRAM."""
-        self.move_to_device(torch.device("cpu"))
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
 
-    
-# Instanciação limpa, sem usar `self` fora da classe.
-print("Criando instância do VideoService...")
+# --- INSTANCIAÇÃO DO SERVIÇO ---
+print("Criando instância do VideoService. O carregamento do modelo começará agora...")
 video_generation_service = VideoService()
-print("Instância do VideoService pronta.")
+print("Instância do VideoService pronta para uso.")