Update api/ltx_server_refactored.py

api/ltx_server_refactored.py

@@ -232,7 +232,7 @@ class VideoService:
         t0 = time.perf_counter()
         print("[INFO] Inicializando VideoService...")
         self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        self.config = self._load_config("ltxv-13b-0.9.8-dev-fp8.yaml")
+        self.config = self._load_config("ltxv-13b-0.9.8-distilled-fp8.yaml")
 
         self.pipeline, self.latent_upsampler = self._load_models_from_hub()
         self._move_models_to_device()
@@ -653,82 +653,6 @@ class VideoService:
         print("============ [SUCCESS] ETAPA 2 Concluída com Sucesso =============")
         print("======================================================================\n")
         return video_path_out, latents_path_out
-    
-    def refine_texture_only1(
-        self,
-        latents_path: str,
-        prompt: str,
-        negative_prompt: str,
-        guidance_scale: float,
-        seed: Optional[int] = None,
-        conditioning_items: Optional[List[ConditioningItem]] = None
-    ) -> Tuple[str, str]:
-        """
-        ETAPA 2: Refina a textura dos latentes existentes SEM alterar sua resolução
-        e SEM dividi-los em pedaços. O tensor inteiro é processado de uma só vez para
-        garantir máxima consistência temporal.
-        """
-        print("[INFO] Iniciando ETAPA 2: Refinamento de Textura...")
-    
-        # --- Configuração de Seed e Diretórios ---
-        used_seed = random.randint(0, 2**32 - 1) if seed is None else int(seed)
-        #seed_everything(used_seed)
-        print(f"  - Usando Seed (consistente com Etapa 1): {used_seed}")
-    
-        temp_dir = tempfile.mkdtemp(prefix="ltxv_refine_single_")
-        self._register_tmp_dir(temp_dir)
-        
-        # --- Carregamento dos Latentes ---
-        latents_to_refine = torch.load(latents_path).to(self.device)
-        print(f"  - Shape dos latentes de entrada: {latents_to_refine.shape}")
-        
-        if conditioning_items:
-            print(f"  - Usando {len(conditioning_items)} item(ns) de condicionamento para o refinamento.")
-    
-        # --- Execução da Pipeline ---
-        with torch.autocast(device_type=self.device.split(':')[0], dtype=self.runtime_autocast_dtype, enabled=(self.device == 'cuda')):
-            
-            # As dimensões são as mesmas do tensor de entrada
-            refine_height = latents_to_refine.shape[3] * self.pipeline.vae_scale_factor
-            refine_width = latents_to_refine.shape[4] * self.pipeline.vae_scale_factor
-            
-            second_pass_kwargs = {
-                "prompt": prompt,
-                "negative_prompt": negative_prompt,
-                "height": refine_height,
-                "width": refine_width,
-                "frame_rate": int(DEFAULT_FPS),
-                "num_frames": latents_to_refine.shape[2],
-                "latents": latents_to_refine,  # O tensor completo é passado aqui
-                "guidance_scale": float(guidance_scale),
-                "output_type": "latent",
-                "generator": torch.Generator(device=self.device).manual_seed(used_seed),
-                "conditioning_items": conditioning_items,
-                **(self.config.get("second_pass", {}))
-            }
-            
-            print("  - Enviando tensor completo para a pipeline de refinamento...")
-            final_latents = self.pipeline(**second_pass_kwargs).images
-            print(f"  - Latentes refinados com shape: {final_latents.shape}")
-    
-            # Decodifica os latentes refinados para pixels
-            pixel_tensor = vae_manager_singleton.decode(final_latents, decode_timestep=float(self.config.get("decode_timestep", 0.05)))
-            
-            # Salva os artefatos de saída
-            video_path_out = self._save_video_from_tensor(pixel_tensor, "refined_video_single_pass", used_seed, temp_dir)
-            latents_path_out = self._save_latents_to_disk(final_latents, "latents_refined_single_pass", used_seed)
-            
-        # --- Limpeza ---
-        # Libera os tensores da memória da GPU antes de finalizar.
-        del latents_to_refine
-        if 'final_latents' in locals():
-            del final_latents
-        if 'pixel_tensor' in locals():
-            del pixel_tensor
-        self._finalize()
-        
-        print("[SUCCESS] ETAPA 2 Concluída.")
-        return video_path_out, latents_path_out
 
         
     def encode_latents_to_mp4(self, latents_path: str, fps: int = int(DEFAULT_FPS)) -> str: