Update api/ltx_server_refactored.py

api/ltx_server_refactored.py

@@ -40,28 +40,22 @@ from tools.video_encode_tool import video_encode_tool_singleton
 DEPS_DIR = Path("/data")
 LTX_VIDEO_REPO_DIR = DEPS_DIR / "LTX-Video"
 
-# (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.)
 def run_setup():
     setup_script_path = "setup.py"
-    if not os.path.exists(setup_script_path):
-        print("[DEBUG] 'setup.py' não encontrado. Pulando clonagem de dependências.")
-        return
-    try:
-        print("[DEBUG] Executando setup.py para dependências...")
-        subprocess.run([sys.executable, setup_script_path], check=True)
-        print("[DEBUG] Setup concluído com sucesso.")
-    except subprocess.CalledProcessError as e:
-        print(f"[DEBUG] ERRO no setup.py (code {e.returncode}). Abortando.")
-        sys.exit(1)
+    print("[DEBUG] Executando setup.py para dependências...")
+    subprocess.run([sys.executable, setup_script_path], check=True)
+    print("[DEBUG] Setup concluído com sucesso.")
+    
 if not LTX_VIDEO_REPO_DIR.exists():
     print(f"[DEBUG] Repositório não encontrado em {LTX_VIDEO_REPO_DIR}. Rodando setup...")
     run_setup()
+    
 def add_deps_to_path():
     repo_path = str(LTX_VIDEO_REPO_DIR.resolve())
     if str(LTX_VIDEO_REPO_DIR.resolve()) not in sys.path:
         sys.path.insert(0, repo_path)
         print(f"[DEBUG] Repo adicionado ao sys.path: {repo_path}")
+        
 def calculate_padding(orig_h, orig_w, target_h, target_w):
     pad_h = target_h - orig_h
     pad_w = target_w - orig_w
@@ -70,6 +64,7 @@ def calculate_padding(orig_h, orig_w, target_h, target_w):
     pad_left = pad_w // 2
     pad_right = pad_w - pad_left
     return (pad_left, pad_right, pad_top, pad_bottom)
+    
 def log_tensor_info(tensor, name="Tensor"):
     if not isinstance(tensor, torch.Tensor):
         print(f"\n[INFO] '{name}' não é tensor.")
@@ -79,10 +74,7 @@ def log_tensor_info(tensor, name="Tensor"):
     print(f"  - Dtype: {tensor.dtype}")
     print(f"  - Device: {tensor.device}")
     if tensor.numel() > 0:
-        try:
-            print(f"  - Min: {tensor.min().item():.4f}  Max: {tensor.max().item():.4f}  Mean: {tensor.mean().item():.4f}")
-        except Exception:
-            pass
+        print(f"  - Min: {tensor.min().item():.4f}  Max: {tensor.max().item():.4f}  Mean: {tensor.mean().item():.4f}")
     print("------------------------------------------\n")
 
 add_deps_to_path()
@@ -200,19 +192,14 @@ class VideoService:
 
     @torch.no_grad()
     def _upsample_latents_internal(self, latents: torch.Tensor) -> torch.Tensor:
-        try:
-            if not self.latent_upsampler:
-                raise ValueError("Latent Upsampler não está carregado.")
-            latents_unnormalized = un_normalize_latents(latents, self.pipeline.vae, vae_per_channel_normalize=True)
-            upsampled_latents = self.latent_upsampler(latents_unnormalized)
-            return normalize_latents(upsampled_latents, self.pipeline.vae, vae_per_channel_normalize=True)
-        except Exception as e:
-            pass
-        finally:
-            torch.cuda.empty_cache()
-            torch.cuda.ipc_collect()
-            self.finalize(keep_paths=[])
-
+        latents_unnormalized = un_normalize_latents(latents, self.pipeline.vae, vae_per_channel_normalize=True)
+        upsampled_latents = self.latent_upsampler(latents_unnormalized)
+        torch.cuda.empty_cache()
+        torch.cuda.ipc_collect()
+        self.finalize(keep_paths=[])
+        return normalize_latents(upsampled_latents, self.pipeline.vae, vae_per_channel_normalize=True)
+        
+            
     def _prepare_conditioning_tensor(self, filepath, height, width, padding_values):
         tensor = load_image_to_tensor_with_resize_and_crop(filepath, height, width)
         tensor = torch.nn.functional.pad(tensor, padding_values)
@@ -266,7 +253,7 @@ class VideoService:
             "output_type": "latent", "conditioning_items": conditioning_items, "guidance_scale": float(guidance_scale),
             **(self.config.get("first_pass", {}))
         }
-        try: 
+        if True:
             with torch.autocast(device_type="cuda", dtype=self.runtime_autocast_dtype, enabled=self.device == 'cuda'):
                 latents = self.pipeline(**first_pass_kwargs).images
                 pixel_tensor = vae_manager_singleton.decode(latents.clone(), decode_timestep=float(self.config.get("decode_timestep", 0.05)))
@@ -274,15 +261,14 @@ class VideoService:
                 latents_cpu = latents.detach().to("cpu")
                 tensor_path = os.path.join(results_dir, f"latents_low_res_{used_seed}.pt")
                 torch.save(latents_cpu, tensor_path)
-            return video_path, tensor_path, used_seed
-        
-        except Exception as e:
-            pass
-        finally:
+            
             torch.cuda.empty_cache()
             torch.cuda.ipc_collect()
             self.finalize(keep_paths=[])
             
+            return video_path, tensor_path, used_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)