Update api/ltx_server_refactored.py

api/ltx_server_refactored.py

@@ -225,7 +225,11 @@ class VideoService:
             conditioning_items.append(ConditioningItem(tensor, safe_frame, float(weight)))
         return conditioning_items
 
-    def generate_low(self, prompt, negative_prompt, height, width, duration, seed, conditioning_items=None):
+    def generate_low(
+        self, prompt, negative_prompt, 
+        height, width, duration, seed, 
+        conditioning_items=None
+    ):
         guidance_scale="4"
         used_seed = random.randint(0, 2**32 - 1) if seed is None else int(seed)
         seed_everething(used_seed)
@@ -251,12 +255,12 @@ class VideoService:
         try: 
             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)))
-                video_path = self._save_and_log_video(pixel_tensor, "low_res_video", FPS, temp_dir, results_dir, used_seed)
+                #pixel_tensor = vae_manager_singleton.decode(latents.clone(), decode_timestep=float(self.config.get("decode_timestep", 0.05)))
+                #video_path = self._save_and_log_video(pixel_tensor, "low_res_video", FPS, temp_dir, results_dir, used_seed)
                 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
+            return tensor_path
         
         except Exception as e:
             pass
@@ -333,36 +337,27 @@ class VideoService:
             torch.cuda.ipc_collect()
             self.finalize(keep_paths=[])
             
-
+     
     def generate_narrative_low(
         self, prompt: str, negative_prompt, 
         height, width, duration,
-        seed, initial_image_conditions=None, overlap_frames: int = 8,
+        seed, initial_image_conditions=None,
         ltx_configs_override: dict = None):
         
         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))
-        frames_per_chunk = max(9, total_actual_frames)
-        frames_per_chunk_last = max(9, total_actual_frames)
-        poda_latents_num = overlap_frames
-        
+
         latentes_chunk_video = []
         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):
+        for i, prompt in enumerate(prompt_list):
             print(f"\n--- Gerando Chunk Narrativo {i+1}/{num_chunks}: '{chunk_prompt}' ---")
 
             current_image_conditions = []
@@ -377,36 +372,29 @@ class VideoService:
                     current_image_conditions.append(cond_item_fraco)
             
             if ltx_configs_override is None: ltx_configs_override = {}
-            current_conditions = []
-            if current_image_conditions: current_conditions.extend(current_image_conditions)
-            if condition_item_latent_overlap: current_conditions.append(condition_item_latent_overlap)
-            ltx_configs_override["conditioning_items"] = current_conditions
             
-            num_frames_para_gerar = frames_per_chunk_last 
+            eco_current_conditions_list = []
+            if current_image_conditions: eco_current_conditions_list.extend(current_image_conditions)
+            if eco_latents_condition_overlap: eco_current_conditions_list.append(eco_latents_condition_overlap)
+            #ltx_configs_override["conditioning_items"] = current_conditions
             
-            latentes_bruto = self._generate_single_chunk_low(
-                prompt=chunk_prompt, negative_prompt=negative_prompt, height=height, width=width,
-                num_frames=num_frames_para_gerar, seed=used_seed,
-                ltx_configs_override=ltx_configs_override
+            latentes_chunk = self.generate_low(
+                prompt, negative_prompt, height, width, 
+                duration, seed, conditioning_items=eco_latents_condition_overlap
             )
-            
-            if latentes_bruto is None:
-                print(f"ERRO FATAL: A geração do chunk {i+1} falhou. Abortando.")
-                self.finalize(keep_paths=[])
-                return None, None, None
-
-            if i > 0:
-                latentes_bruto = latentes_bruto[:, :, poda_latents_num:, :, :]
-
-            latentes_podado = latentes_bruto.clone().detach()
+      
             if i < num_chunks - 1 and poda_latents_num > 0:
-                overlap_latents = latentes_bruto[:, :, -poda_latents_num:, :, :].clone()
+                overlap_latents = latentes_chunk[:, :, -poda_latents_num:, :, :].clone()
                 condition_item_latent_overlap = ConditioningItem(
                     media_item=overlap_latents, media_frame_number=0, conditioning_strength=1.0
                 )
-            latentes_chunk_video.append(latentes_podado)
 
-        final_latents_cpu = torch.cat(latentes_chunk_video, dim=2).cpu()
+            if i > 0:
+                latentes_chunk = latentes_chunk[:, :, poda_latents_num:, :, :].clone()
+            
+            latentes_chunk_video_list.append(latentes_chunk)
+
+        final_latents_cpu = torch.cat(latentes_chunk_video_list, dim=2).cpu()
         log_tensor_info(final_latents_cpu, "Tensor de Latentes Final Concatenado (CPU)")
         
         tensor_path = os.path.join(results_dir, f"latents_narrative_{used_seed}.pt")
@@ -596,7 +584,6 @@ class VideoService:
         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}...")
@@ -612,8 +599,6 @@ class VideoService:
         if torch.cuda.is_available():
             torch.cuda.empty_cache()
 
-    
-# Instanciação limpa, sem usar `self` fora da classe.
 print("Criando instância do VideoService...")
 video_generation_service = VideoService()
 print("Instância do VideoService pronta.")