Update app.py

app.py

@@ -118,11 +118,12 @@ GEMMA_REPO = "Lightricks/gemma-3-12b-it-qat-q4_0-unquantized"
 # Custom HQ Pipeline with LoRA Cache Support
 # =============================================================================
 
-class HQPipelineWithCachedLoRA(TI2VidTwoStagesHQPipeline):
+class HQPipelineWithCachedLoRA:
     """
-    TI2VidTwoStagesHQPipeline modified to:
-    1. NOT accept or pass distilled_lora to parent init (enables preloading)
-    2. Handle ALL LoRAs via cached state (distilled + 12 custom)
+    Custom HQ pipeline that:
+    1. Creates ModelLedgers WITHOUT LoRAs (enables preloading)
+    2. Handles ALL LoRAs via cached state (distilled + 12 custom)
+    3. Supports CFG/negative prompts and guidance parameters
     """
     
     def __init__(
@@ -130,23 +131,45 @@ class HQPipelineWithCachedLoRA(TI2VidTwoStagesHQPipeline):
         checkpoint_path: str,
         spatial_upsampler_path: str,
         gemma_root: str,
-        loras: tuple = (),
         quantization: QuantizationPolicy | None = None,
     ):
-        # Call parent WITHOUT distilled_lora parameters
-        # We create minimal stage ledgers (no LoRAs) for preloading
-        super().__init__(
+        from ltx_pipelines.utils import ModelLedger
+        from ltx_core.loader import LoraPathStrengthAndSDOps, LTXV_LORA_COMFY_RENAMING_MAP
+        from ltx_core.types import PipelineComponents
+        
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.dtype = torch.bfloat16
+        
+        # Create ModelLedgers WITHOUT LoRAs - this allows preloading
+        print("    Creating stage 1 ModelLedger (no LoRAs)...")
+        self.stage_1_model_ledger = ModelLedger(
+            dtype=self.dtype,
+            device=self.device,
             checkpoint_path=checkpoint_path,
-            distilled_lora=[],  # Empty - satisfies signature
-            distilled_lora_strength_stage_1=0.0,
-            distilled_lora_strength_stage_2=0.0,
+            gemma_root_path=gemma_root,
             spatial_upsampler_path=spatial_upsampler_path,
-            gemma_root=gemma_root,
-            loras=loras,
+            loras=(),  # NO LoRAs - preloading works
             quantization=quantization,
         )
         
-        # Storage for cached LoRA states for each stage
+        print("    Creating stage 2 ModelLedger (no LoRAs)...")
+        self.stage_2_model_ledger = ModelLedger(
+            dtype=self.dtype,
+            device=self.device,
+            checkpoint_path=checkpoint_path,
+            gemma_root_path=gemma_root,
+            spatial_upsampler_path=spatial_upsampler_path,
+            loras=(),  # NO LoRAs - preloading works
+            quantization=quantization,
+        )
+        
+        # Pipeline components (similar to parent)
+        self.pipeline_components = PipelineComponents(
+            dtype=self.dtype,
+            device=self.device,
+        )
+        
+        # Storage for cached LoRA states
         self._cached_state_stage1 = None
         self._cached_state_stage2 = None
     
@@ -172,7 +195,16 @@ class HQPipelineWithCachedLoRA(TI2VidTwoStagesHQPipeline):
         tiling_config: TilingConfig | None = None,
         enhance_prompt: bool = False,
     ):
-        # ... same as before ...
+        from ltx_pipelines.utils import assert_resolution, cleanup_memory, combined_image_conditionings, encode_prompts, res2s_audio_video_denoising_loop, multi_modal_guider_denoising_func, simple_denoising_func, denoise_audio_video
+        from ltx_core.tools import VideoLatentShape
+        from ltx_core.components.noisers import GaussianNoiser
+        from ltx_core.components.diffusion_steps import Res2sDiffusionStep
+        from ltx_core.components.schedulers import LTX2Scheduler
+        from ltx_core.types import VideoPixelShape
+        from ltx_core.model.upsampler import upsample_video
+        from ltx_core.model.video_vae import decode_video as vae_decode_video
+        from ltx_core.model.audio_vae import decode_audio as vae_decode_audio
+        
         assert_resolution(height=height, width=width, is_two_stage=True)
         
         device = self.device
@@ -180,6 +212,7 @@ class HQPipelineWithCachedLoRA(TI2VidTwoStagesHQPipeline):
         generator = torch.Generator(device=device).manual_seed(seed)
         noiser = GaussianNoiser(generator=generator)
         
+        # Apply cached LoRA state if available
         if self._cached_state_stage1 is not None:
             print("[LoRA] Applying cached state to stage 1 transformer...")
             t1 = self.stage_1_model_ledger.transformer()
@@ -283,6 +316,8 @@ class HQPipelineWithCachedLoRA(TI2VidTwoStagesHQPipeline):
         cleanup_memory()
         
         transformer = self.stage_2_model_ledger.transformer()
+        
+        from ltx_pipelines.utils.constants import STAGE_2_DISTILLED_SIGMA_VALUES
         distilled_sigmas = torch.tensor(STAGE_2_DISTILLED_SIGMA_VALUES, device=device)
         
         def second_stage_denoising_loop(sigmas, video_state, audio_state, stepper):