Update api/ltx_server_refactored.py

api/ltx_server_refactored.py

@@ -303,17 +303,17 @@ class VideoService:
             self.finalize(keep_paths=[])
             
     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)
-        results_dir = "/app/output"; os.makedirs(results_dir, exist_ok=True)
-        latents_low = torch.load(latents_path).to(self.device)
         try:
+            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)
+            results_dir = "/app/output"; os.makedirs(results_dir, exist_ok=True)
+            latents_low = torch.load(latents_path).to(self.device)
             with torch.autocast(device_type="cuda", dtype=self.runtime_autocast_dtype, enabled=self.device == 'cuda'):
                 upsampled_latents = self._upsample_latents_internal(latents_low)
                 upsampled_latents = adain_filter_latent(latents=upsampled_latents, reference_latents=latents_low)
                 del latents_low; torch.cuda.empty_cache()
-            
+                
                 # --- LÓGICA DE DIVISÃO SIMPLES COM OVERLAP ---
                 total_frames = upsampled_latents.shape[2]
                 # Garante que mid_point seja pelo menos 1 para evitar um segundo chunk vazio se houver poucos frames
@@ -321,42 +321,42 @@ class VideoService:
                 chunk1 = upsampled_latents[:, :, :mid_point, :, :]
                 # O segundo chunk começa um frame antes para criar o overlap
                 chunk2 = upsampled_latents[:, :, mid_point - 1:, :, :]
-            
+                
                 final_latents_list = []
                 for i, chunk in enumerate([chunk1, chunk2]):
-                   if chunk.shape[2] <= 1: continue # Pula chunks inválidos ou vazios
-                      second_pass_height = chunk.shape[3] * self.pipeline.vae_scale_factor
-                      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),
-                         "output_type": "latent", "generator": torch.Generator(device=self.device).manual_seed(used_seed),
-                          **(self.config.get("second_pass", {}))
-                      }
-                      refined_chunk = self.pipeline(**second_pass_kwargs).images
-                      # Remove o overlap do primeiro chunk refinado antes de juntar
+                    if chunk.shape[2] <= 1: continue # Pula chunks inválidos ou vazios
+                    second_pass_height = chunk.shape[3] * self.pipeline.vae_scale_factor
+                    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),
+                        "output_type": "latent", "generator": torch.Generator(device=self.device).manual_seed(used_seed),
+                        **(self.config.get("second_pass", {}))
+                    }
+                    refined_chunk = self.pipeline(**second_pass_kwargs).images
+                    # Remove o overlap do primeiro chunk refinado antes de juntar
                     if i == 0:
                         final_latents_list.append(refined_chunk[:, :, :-1, :, :])
                     else:
                         final_latents_list.append(refined_chunk)
-
+    
                 final_latents = torch.cat(final_latents_list, dim=2)
                 log_tensor_info(final_latents, "Latentes Upscaled/Refinados Finais")
-
-            latents_cpu = final_latents.detach().to("cpu")
-            tensor_path = os.path.join(results_dir, f"latents_refined_{used_seed}.pt")
-            torch.save(latents_cpu, tensor_path)
-            pixel_tensor = vae_manager_singleton.decode(final_latents, decode_timestep=float(self.config.get("decode_timestep", 0.05)))
-            video_path = self._save_and_log_video(pixel_tensor, "refined_video", 24.0, temp_dir, results_dir, used_seed)
-            return video_path, tensor_path
-        except Exception as e:
+    
+                latents_cpu = final_latents.detach().to("cpu")
+                tensor_path = os.path.join(results_dir, f"latents_refined_{used_seed}.pt")
+                torch.save(latents_cpu, tensor_path)
+                pixel_tensor = vae_manager_singleton.decode(final_latents, decode_timestep=float(self.config.get("decode_timestep", 0.05)))
+                video_path = self._save_and_log_video(pixel_tensor, "refined_video", 24.0, temp_dir, results_dir, used_seed)
+            return video_path, tensor_path        except Exception as e:
+        except Exception as e:   
             pass
         finally:
             torch.cuda.empty_cache()
             torch.cuda.ipc_collect()
             self.finalize(keep_paths=[])
 
-def encode_mp4(self, latents_path: str, fps: int = 24):
+    def encode_mp4(self, latents_path: str, fps: int = 24):
         latents = torch.load(latents_path)
         seed = random.randint(0, 99999)
         temp_dir = tempfile.mkdtemp(prefix="ltxv_enc_"); self._register_tmp_dir(temp_dir)