Upload 8 files

.gitattributes

@@ -71,3 +71,7 @@ squatting_sonic.png filter=lfs diff=lfs merge=lfs -text
 tower_takes_off.png filter=lfs diff=lfs merge=lfs -text
 ugly_sonic.jpeg filter=lfs diff=lfs merge=lfs -text
 bird.webp filter=lfs diff=lfs merge=lfs -text
+astronaut.jpg filter=lfs diff=lfs merge=lfs -text
+cat_selfie.JPG filter=lfs diff=lfs merge=lfs -text
+kill_bill.jpeg filter=lfs diff=lfs merge=lfs -text
+wednesday.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,13 @@
+---
+title: LTX-2 Video Fast
+emoji: 🎥💨
+colorFrom: yellow
+colorTo: indigo
+sdk: gradio
+sdk_version: 6.2.0
+app_file: app.py
+pinned: false
+short_description: Fast high quality video with audio generation
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,299 +1,322 @@
-# PyTorch 2.8 (temporary hack)
-import os
-os.system('pip install --upgrade --pre --extra-index-url https://download.pytorch.org/whl/nightly/cu126 "torch<2.9" spaces')
+import sys
+from pathlib import Path
 
-# Actual demo code
-try:
-    import spaces
-except:
-    class spaces():
-        def GPU(*args, **kwargs):
-            def decorator(function):
-                return lambda *dummy_args, **dummy_kwargs: function(*dummy_args, **dummy_kwargs)
-            return decorator
+# Add packages to Python path
+current_dir = Path(__file__).parent
+sys.path.insert(0, str(current_dir / "packages" / "ltx-pipelines" / "src"))
+sys.path.insert(0, str(current_dir / "packages" / "ltx-core" / "src"))
 
+import spaces
 import gradio as gr
+from gradio_client import Client, handle_file
 import numpy as np
-import torch
 import random
-import os
-from datetime import datetime
-
-from PIL import Image
-import tempfile
-import zipfile
-import shutil
+import torch
+from typing import Optional
 from pathlib import Path
+from huggingface_hub import hf_hub_download
+from gradio_client import Client
+from ltx_pipelines.distilled import DistilledPipeline
+from ltx_core.tiling import TilingConfig
+from ltx_core.loader.primitives import LoraPathStrengthAndSDOps
+from ltx_core.loader.sd_ops import LTXV_LORA_COMFY_RENAMING_MAP
+from ltx_pipelines.constants import (
+    DEFAULT_SEED,
+    DEFAULT_HEIGHT,
+    DEFAULT_WIDTH,
+    DEFAULT_NUM_FRAMES,
+    DEFAULT_FRAME_RATE,
+    DEFAULT_LORA_STRENGTH,
+)
 
-from diffusers import FluxKontextPipeline
-from diffusers.utils import load_image
+MAX_SEED = np.iinfo(np.int32).max
+# Default prompt from docstring example
+DEFAULT_PROMPT = "An astronaut hatches from a fragile egg on the surface of the Moon, the shell cracking and peeling apart in gentle low-gravity motion. Fine lunar dust lifts and drifts outward with each movement, floating in slow arcs before settling back onto the ground. The astronaut pushes free in a deliberate, weightless motion, small fragments of the egg tumbling and spinning through the air. In the background, the deep darkness of space subtly shifts as stars glide with the camera's movement, emphasizing vast depth and scale. The camera performs a smooth, cinematic slow push-in, with natural parallax between the foreground dust, the astronaut, and the distant starfield. Ultra-realistic detail, physically accurate low-gravity motion, cinematic lighting, and a breath-taking, movie-like shot."
 
-from optimization import optimize_pipeline_
+# HuggingFace Hub defaults
+DEFAULT_REPO_ID = "Lightricks/LTX-2"
+DEFAULT_CHECKPOINT_FILENAME = "ltx-2-19b-dev-fp8.safetensors"
+DEFAULT_DISTILLED_LORA_FILENAME = "ltx-2-19b-distilled-lora-384.safetensors"
+DEFAULT_SPATIAL_UPSAMPLER_FILENAME = "ltx-2-spatial-upscaler-x2-1.0.safetensors"
 
-MAX_SEED = np.iinfo(np.int32).max
+# Text encoder space URL
+TEXT_ENCODER_SPACE = "linoyts/gemma-text-encoder"
 
-pipe = FluxKontextPipeline.from_pretrained("yuvraj108c/FLUX.1-Kontext-dev", torch_dtype=torch.bfloat16).to("cuda")
-optimize_pipeline_(pipe, image=Image.new("RGB", (512, 512)), prompt='prompt')
-
-input_image_debug_value = [None]
-prompt_debug_value = [None]
-number_debug_value = [None]
-def save_on_path(img: Image, filename: str, format_: str = None) -> Path:
-    """
-    Save `img` in a unique temporary folder under the given `filename`
-    and return its absolute path.
-    """
-    # 1) unique temporary folder
-    tmp_dir = Path(tempfile.mkdtemp(prefix="pil_tmp_"))
-    
-    # 2) full path of the future file
-    file_path = tmp_dir / filename
-    
-    # 3) save
-    img.save(file_path, format=format_ or img.format)
-    
-    return file_path
+def get_hub_or_local_checkpoint(repo_id: Optional[str] = None, filename: Optional[str] = None):
+    """Download from HuggingFace Hub or use local checkpoint."""
+    if repo_id is None and filename is None:
+        raise ValueError("Please supply at least one of `repo_id` or `filename`")
+
+    if repo_id is not None:
+        if filename is None:
+            raise ValueError("If repo_id is specified, filename must also be specified.")
+        print(f"Downloading {filename} from {repo_id}...")
+        ckpt_path = hf_hub_download(repo_id=repo_id, filename=filename)
+        print(f"Downloaded to {ckpt_path}")
+    else:
+        ckpt_path = filename
+
+    return ckpt_path
+
+
+# Initialize pipeline at startup
+print("=" * 80)
+print("Loading LTX-2 Distilled pipeline...")
+print("=" * 80)
+
+checkpoint_path = get_hub_or_local_checkpoint(DEFAULT_REPO_ID, DEFAULT_CHECKPOINT_FILENAME)
+distilled_lora_path = get_hub_or_local_checkpoint(DEFAULT_REPO_ID, DEFAULT_DISTILLED_LORA_FILENAME)
+spatial_upsampler_path = get_hub_or_local_checkpoint(DEFAULT_REPO_ID, DEFAULT_SPATIAL_UPSAMPLER_FILENAME)
+
+print(f"Initializing pipeline with:")
+print(f"  checkpoint_path={checkpoint_path}")
+print(f"  distilled_lora_path={distilled_lora_path}")
+print(f"  spatial_upsampler_path={spatial_upsampler_path}")
+print(f"  text_encoder_space={TEXT_ENCODER_SPACE}")
 
-@spaces.GPU(duration=40)
-def infer(
+# Load distilled LoRA as a regular LoRA
+loras = [
+    LoraPathStrengthAndSDOps(
+        path=distilled_lora_path,
+        strength=DEFAULT_LORA_STRENGTH,
+        sd_ops=LTXV_LORA_COMFY_RENAMING_MAP,
+    )
+]
+
+# Initialize pipeline WITHOUT text encoder (gemma_root=None)
+# Text encoding will be done by external space
+pipeline = DistilledPipeline(
+    checkpoint_path=checkpoint_path,
+    spatial_upsampler_path=spatial_upsampler_path,
+    gemma_root=None,  # No text encoder in this space
+    loras=loras,
+    fp8transformer=True,
+    local_files_only=False,
+)
+
+# Initialize text encoder client
+print(f"Connecting to text encoder space: {TEXT_ENCODER_SPACE}")
+try:
+    text_encoder_client = Client(TEXT_ENCODER_SPACE)
+    print("✓ Text encoder client connected!")
+except Exception as e:
+    print(f"⚠ Warning: Could not connect to text encoder space: {e}")
+    text_encoder_client = None
+
+print("=" * 80)
+print("Pipeline fully loaded and ready!")
+print("=" * 80)
+
+@spaces.GPU(duration=300)
+def generate_video(
     input_image,
-    prompt,
-    seed = 42,
-    randomize_seed = False,
-    guidance_scale = 2.5,
-    steps = 28,
-    width = -1,
-    height = -1,
+    prompt: str,
+    duration: float,
+    enhance_prompt: bool = True,
+    seed: int = 42,
+    randomize_seed: bool = True,
+    height: int = DEFAULT_HEIGHT,
+    width: int = DEFAULT_WIDTH,
     progress=gr.Progress(track_tqdm=True)
 ):
-    """
-    Perform image editing using the FLUX.1 Kontext pipeline.
-    
-    This function takes an input image and a text prompt to generate a modified version
-    of the image based on the provided instructions. It uses the FLUX.1 Kontext model
-    for contextual image editing tasks.
-    
-    Args:
-        input_image (PIL.Image.Image): The input image to be edited. Will be converted
-            to RGB format if not already in that format.
-        prompt (str): Text description of the desired edit to apply to the image.
-            Examples: "Remove glasses", "Add a hat", "Change background to beach".
-        seed (int, optional): Random seed for reproducible generation. Defaults to 42.
-            Must be between 0 and MAX_SEED (2^31 - 1).
-        randomize_seed (bool, optional): If True, generates a random seed instead of
-            using the provided seed value. Defaults to False.
-        guidance_scale (float, optional): Controls how closely the model follows the
-            prompt. Higher values mean stronger adherence to the prompt but may reduce
-            image quality. Range: 1.0-10.0. Defaults to 2.5.
-        steps (int, optional): Controls how many steps to run the diffusion model for.
-            Range: 1-30. Defaults to 28.
-        progress (gr.Progress, optional): Gradio progress tracker for monitoring
-            generation progress. Defaults to gr.Progress(track_tqdm=True).
-    
-    Returns:
-        tuple: A 3-tuple containing:
-            - PIL.Image.Image: The generated/edited image
-            - int: The seed value used for generation (useful when randomize_seed=True)
-            - gr.update: Gradio update object to make the reuse button visible
-    
-    Example:
-        >>> edited_image, used_seed, button_update = infer(
-        ...     input_image=my_image,
-        ...     prompt="Add sunglasses",
-        ...     seed=123,
-        ...     randomize_seed=False,
-        ...     guidance_scale=2.5
-        ... )
-    """
-    if randomize_seed:
-        seed = random.randint(0, MAX_SEED)
-    
-    if input_image:
-        input_image = input_image.convert("RGB")
-        image = pipe(
-            image=input_image, 
-            prompt=prompt,
-            guidance_scale=guidance_scale,
-            width = input_image.size[0] if width == -1 else width,
-            height = input_image.size[1] if height == -1 else height,
-            num_inference_steps=steps,
-            generator=torch.Generator().manual_seed(seed),
-        ).images[0]
-    else:
-        image = pipe(
-            prompt=prompt,
-            guidance_scale=guidance_scale,
-            num_inference_steps=steps,
-            generator=torch.Generator().manual_seed(seed),
-        ).images[0]
-    
-    image_filename = datetime.now().strftime("%Y-%m-%d_%H-%M-%S.%f") + '.webp'
-    path = save_on_path(image, image_filename, format_="WEBP")
-    return path, gr.update(value=path, visible=True), seed, gr.update(visible=True)
-
-def infer_example(input_image, prompt):
-    number=1
-    if input_image_debug_value[0] is not None or prompt_debug_value[0] is not None or number_debug_value[0] is not None:
-        input_image=input_image_debug_value[0]
-        prompt=prompt_debug_value[0]
-        number=number_debug_value[0]
-        #input_image_debug_value[0]=prompt_debug_value[0]=prompt_debug_value[0]=None
-    gallery = []
+    """Generate a video based on the given parameters."""
     try:
-        for i in range(number):
-            print("Generating #" + str(i + 1) + " image...")
-            seed = random.randint(0, MAX_SEED)
-            image, download_button, seed, _ = infer(input_image, prompt, seed, True)
-            gallery.append(image)
-    except:
-        print("Error")
-    zip_path = export_images_to_zip(gallery)
-    return gallery, seed, zip_path
-
-def export_images_to_zip(gallery) -> str:
-    """
-    Bundle compiled_transformer_1 and compiled_transformer_2 into a zip file and return the file path.
-    """
-
-    tmp_zip = tempfile.NamedTemporaryFile(suffix=".zip", delete=False)
-    tmp_zip.close()
-
-    with zipfile.ZipFile(tmp_zip.name, "w", compression=zipfile.ZIP_DEFLATED) as zf:
-        for i in range(len(gallery)):
-            image_path = gallery[i]
-            zf.write(image_path, arcname=os.path.basename(image_path))
-
-    print(str(len(gallery)) + " images zipped")
-    return tmp_zip.name
-
-css="""
-#col-container {
-    margin: 0 auto;
-    max-width: 960px;
-}
-"""
-
-with gr.Blocks(css=css) as demo:
+        # Randomize seed if checkbox is enabled
+        current_seed = random.randint(0, MAX_SEED) if randomize_seed else int(seed)
+
+        # Calculate num_frames from duration (using fixed 24 fps)
+        frame_rate = 24.0
+        num_frames = int(duration * frame_rate) + 1  # +1 to ensure we meet the duration
+
+        # Create output directory if it doesn't exist
+        output_dir = Path("outputs")
+        output_dir.mkdir(exist_ok=True)
+        output_path = output_dir / f"video_{current_seed}.mp4"
+
+        # Handle image input
+        images = []
+        temp_image_path = None  # Initialize to None
+        
+        if input_image is not None:
+            # Save uploaded image temporarily
+            temp_image_path = output_dir / f"temp_input_{current_seed}.jpg"
+            if hasattr(input_image, 'save'):
+                input_image.save(temp_image_path)
+            else:
+                # If it's a file path already
+                temp_image_path = Path(input_image)
+            # Format: (image_path, frame_idx, strength)
+            images = [(str(temp_image_path), 0, 1.0)]
+        
+        # Get embeddings from text encoder space
+        print(f"Encoding prompt: {prompt}")
+        
+        if text_encoder_client is None:
+            raise RuntimeError(
+                f"Text encoder client not connected. Please ensure the text encoder space "
+                f"({TEXT_ENCODER_SPACE}) is running and accessible."
+            )
+        
+        try:
+            # Prepare image for upload if it exists
+            image_input = None
+            if temp_image_path is not None:
+                image_input = handle_file(str(temp_image_path))
+            
+            result = text_encoder_client.predict(
+                prompt=prompt,
+                enhance_prompt=enhance_prompt,
+                input_image=image_input,
+                seed=current_seed,
+                negative_prompt="",
+                api_name="/encode_prompt"
+            )
+            embedding_path = result[0]  # Path to .pt file
+            print(f"Embeddings received from: {embedding_path}")
     
-    with gr.Column(elem_id="col-container"):
-        gr.Markdown(f"""# FLUX.1 Kontext [dev]
-Image editing and manipulation model guidance-distilled from FLUX.1 Kontext [pro], [[blog]](https://bfl.ai/announcements/flux-1-kontext-dev) [[model]](https://huggingface.co/black-forest-labs/FLUX.1-Kontext-dev)
-        """)
-        with gr.Row():
-            with gr.Column():
-                input_image = gr.Image(label="Upload the image for editing", type="pil")
-                with gr.Row():
-                    prompt = gr.Text(
-                        label="Prompt",
-                        show_label=False,
-                        max_lines=1,
-                        placeholder="Enter your prompt for editing (e.g., 'Remove glasses', 'Add a hat')",
-                        container=False,
+            # Load embeddings
+            embeddings = torch.load(embedding_path)
+            video_context = embeddings['video_context']
+            audio_context = embeddings['audio_context']
+            print("✓ Embeddings loaded successfully")
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to get embeddings from text encoder space: {e}\n"
+                f"Please ensure {TEXT_ENCODER_SPACE} is running properly."
+            )
+
+        # Run inference - progress automatically tracks tqdm from pipeline
+        pipeline(
+            prompt=prompt,
+            output_path=str(output_path),
+            seed=current_seed,
+            height=height,
+            width=width,
+            num_frames=num_frames,
+            frame_rate=frame_rate,
+            images=images,
+            tiling_config=TilingConfig.default(),
+            video_context=video_context,
+            audio_context=audio_context,
+        )
+
+        return str(output_path), current_seed
+
+    except Exception as e:
+        import traceback
+        error_msg = f"Error: {str(e)}\n{traceback.format_exc()}"
+        print(error_msg)
+        return None
+
+
+# Create Gradio interface
+with gr.Blocks(title="LTX-2 Video Distilled 🎥🔈") as demo:
+    gr.Markdown("# LTX-2 Distilled 🎥🔈: The First Open Source Audio-Video Model")
+    gr.Markdown("Fast, state-of-the-art video & audio generation with [Lightricks LTX-2 TI2V model](https://huggingface.co/Lightricks/LTX-2) and [distillation LoRA](https://huggingface.co/Lightricks/LTX-2/blob/main/ltx-2-19b-distilled-lora-384.safetensors) for accelerated inference. Read more: [[model]](https://huggingface.co/Lightricks/LTX-2), [[code]](https://github.com/Lightricks/LTX-2)")
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(
+                label="Input Image (Optional)",
+                type="pil"
+            )
+
+            prompt = gr.Textbox(
+                label="Prompt",
+                info="for best results - make it as elaborate as possible",
+                value="Make this image come alive with cinematic motion, smooth animation",
+                lines=3,
+                placeholder="Describe the motion and animation you want..."
+            )
+            with gr.Row():
+                duration = gr.Slider(
+                    label="Duration (seconds)",
+                    minimum=1.0,
+                    maximum=10.0,
+                    value=3.0,
+                    step=0.1
+                )
+                enhance_prompt = gr.Checkbox(
+                        label="Enhance Prompt",
+                        value=True
                     )
-                    run_button = gr.Button(value="🚀 Edit", variant = "primary", scale=0)
-                with gr.Accordion("Advanced Settings", open=False):
-                    
-                    seed = gr.Slider(
-                        label="Seed",
-                        minimum=0,
-                        maximum=MAX_SEED,
-                        step=1,
-                        value=0,
+
+            generate_btn = gr.Button("Generate Video", variant="primary", size="lg")
+
+            with gr.Accordion("Advanced Settings", open=False):
+                seed = gr.Slider(
+                    label="Seed",
+                    minimum=0,
+                    maximum=MAX_SEED,
+                    value=DEFAULT_SEED,
+                    step=1
+                )
+
+                randomize_seed = gr.Checkbox(
+                    label="Randomize Seed",
+                    value=True
+                )
+
+                with gr.Row():
+                    width = gr.Number(
+                        label="Width",
+                        value=DEFAULT_WIDTH,
+                        precision=0
                     )
-                    
-                    randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
-                    
-                    guidance_scale = gr.Slider(
-                        label="Guidance Scale",
-                        minimum=1,
-                        maximum=10,
-                        step=0.1,
-                        value=2.5,
-                    )       
-                    
-                    steps = gr.Slider(
-                        label="Steps",
-                        minimum=1,
-                        maximum=30,
-                        value=30,
-                        step=1
-                    )      
-                    
-                    width = gr.Slider(
-                        label="Output width",
-                        info="-1 = original width",
-                        minimum=-1,
-                        maximum=1024,
-                        value=-1,
-                        step=1
-                    )   
-                    
-                    height = gr.Slider(
-                        label="Output height",
-                        info="-1 = original height",
-                        minimum=-1,
-                        maximum=1024,
-                        value=-1,
-                        step=1
+                    height = gr.Number(
+                        label="Height",
+                        value=DEFAULT_HEIGHT,
+                        precision=0
                     )
-                    
-            with gr.Column():
-                result = gr.Image(label="Result", show_label=False, interactive=False)
-                download_button = gr.DownloadButton(elem_id="download_btn", visible=False)
-                reuse_button = gr.Button("Reuse this image", visible=False)
-    
-    with gr.Row(visible=False):
-        download_button = gr.DownloadButton(elem_id="download_btn", interactive = True)
-        result_gallery = gr.Gallery(interactive = False, elem_id = "gallery1")
-        gr.Examples(
-            examples=[
-                ["monster.png", "Make this monster ride a skateboard on the beach"]
-            ],
-            inputs=[input_image, prompt],
-            outputs=[result_gallery, seed, download_button],
-            fn=infer_example,
-            run_on_click=True,
-            cache_examples=True,
-            cache_mode='lazy'
-        )
-        prompt_debug=gr.Textbox()
-        input_image_debug=gr.Image(type="pil")
-        number_debug=gr.Slider(minimum=1, maximum=50, step=1, value=50)
 
-    gr.Examples(
-        label = "Examples from demo",
-        examples=[
-            ["flowers.png", "turn the flowers into sunflowers"],
-            ["monster.png", "make this monster ride a skateboard on the beach"],
-            ["cat.png", "make this cat happy"]
+        with gr.Column():
+            output_video = gr.Video(label="Generated Video", autoplay=True)
+
+    generate_btn.click(
+        fn=generate_video,
+        inputs=[
+            input_image,
+            prompt,
+            duration,
+            enhance_prompt,
+            seed,
+            randomize_seed,
+            height,
+            width,
         ],
-        inputs=[input_image, prompt],
-        outputs=[result, download_button, seed],
-        fn=infer
+        outputs=[output_video,seed]
     )
 
-    def handle_field_debug_change(input_image_debug_data, prompt_debug_data, number_debug_data):
-        prompt_debug_value[0] = prompt_debug_data
-        input_image_debug_value[0] = input_image_debug_data
-        number_debug_value[0] = number_debug_data
-        return []
-
-    inputs_debug=[input_image_debug, prompt_debug, number_debug]
-
-    input_image_debug.upload(fn=handle_field_debug_change, inputs=inputs_debug, outputs=[])
-    prompt_debug.change(fn=handle_field_debug_change, inputs=inputs_debug, outputs=[])
-    number_debug.change(fn=handle_field_debug_change, inputs=inputs_debug, outputs=[])
+    # Add example
+    gr.Examples(
+        examples=[
+            [
+                "kill_bill.jpeg",
+                "A low, subsonic drone pulses as Uma Thurman's character, Beatrix Kiddo, holds her razor-sharp katana blade steady in the cinematic lighting. A faint electrical hum fills the silence. Suddenly, accompanied by a deep metallic groan, the polished steel begins to soften and distort, like heated metal starting to lose its structural integrity. Discordant strings swell as the blade's perfect edge slowly warps and droops, molten steel beginning to flow downward in silvery rivulets while maintaining its metallic sheen—each drip producing a wet, viscous stretching sound. The transformation starts subtly at first—a slight bend in the blade—then accelerates as the metal becomes increasingly fluid, the groaning intensifying. The camera holds steady on her face as her piercing eyes gradually narrow, not with lethal focus, but with confusion and growing alarm as she watches her weapon dissolve before her eyes. She whispers under her breath, voice flat with disbelief: 'Wait, what?' Her heartbeat rises in the mix—thump... thump-thump—as her breathing quickens slightly while she witnesses this impossible transformation. Sharp violin stabs punctuate each breath. The melting intensifies, the katana's perfect form becoming increasingly abstract, dripping like liquid mercury from her grip. Molten droplets fall to the ground with soft, bell-like pings. Unintelligible whispers fade in and out as her expression shifts from calm readiness to bewilderment and concern, her heartbeat now pounding like a war drum, as her legendary instrument of vengeance literally liquefies in her hands, leaving her defenseless and disoriented. All sound cuts to silence—then a single devastating bass drop as the final droplet falls, leaving only her unsteady breathing in the dark.",
+                5.0,
+            ],
+            [
+                "wednesday.png",
+                "A cinematic close-up of Wednesday Addams frozen mid-dance on a dark, blue-lit ballroom floor as students move indistinctly behind her, their footsteps and muffled music reduced to a distant, underwater thrum; the audio foregrounds her steady breathing and the faint rustle of fabric as she slowly raises one arm, never breaking eye contact with the camera, then after a deliberately long silence she speaks in a flat, dry, perfectly controlled voice, “I don’t dance… I vibe code,” each word crisp and unemotional, followed by an abrupt cutoff of her voice as the background sound swells slightly, reinforcing the deadpan humor, with precise lip sync, minimal facial movement, stark gothic lighting, and cinematic realism.",
+                5.0,
+            ],
+            [
+                "astronaut.jpg",
+                "An astronaut hatches from a fragile egg on the surface of the Moon, the shell cracking and peeling apart in gentle low-gravity motion. Fine lunar dust lifts and drifts outward with each movement, floating in slow arcs before settling back onto the ground. The astronaut pushes free in a deliberate, weightless motion, small fragments of the egg tumbling and spinning through the air. In the background, the deep darkness of space subtly shifts as stars glide with the camera's movement, emphasizing vast depth and scale. The camera performs a smooth, cinematic slow push-in, with natural parallax between the foreground dust, the astronaut, and the distant starfield. Ultra-realistic detail, physically accurate low-gravity motion, cinematic lighting, and a breath-taking, movie-like shot.",
+                3.0,
+            ]
             
-    gr.on(
-        triggers=[run_button.click, prompt.submit],
-        fn = infer,
-        inputs = [input_image, prompt, seed, randomize_seed, guidance_scale, steps, width, height],
-        outputs = [result, download_button, seed, reuse_button]
-    )
-    reuse_button.click(
-        fn = lambda image: image,
-        inputs = [result],
-        outputs = [input_image]
+        ],
+        fn=generate_video,
+        inputs=[input_image, prompt, duration],
+        outputs = [output_video, seed],
+        label="Example",
+        cache_examples=True,
+        cache_mode="lazy",
     )
 
-demo.launch(mcp_server=True)
+
+css = '''
+.gradio-container .contain{max-width: 1200px !important; margin: 0 auto !important}
+'''
+if __name__ == "__main__":
+    demo.launch(theme=gr.themes.Citrus(), css=css)

ltx2_two_stage.py

@@ -0,0 +1,84 @@
+"""
+python ltx2_two_stage.py \
+  --image "astronaut.jpg" 0 1.0 \
+  --prompt="An astronaut hatches from a fragile egg on the surface of the Moon, the shell cracking and peeling apart in gentle low-gravity motion. Fine lunar dust lifts and drifts outward with each movement, floating in slow arcs before settling back onto the ground. The astronaut pushes free in a deliberate, weightless motion, small fragments of the egg tumbling and spinning through the air. In the background, the deep darkness of space subtly shifts as stars glide with the camera's movement, emphasizing vast depth and scale. The camera performs a smooth, cinematic slow push-in, with natural parallax between the foreground dust, the astronaut, and the distant starfield. Ultra-realistic detail, physically accurate low-gravity motion, cinematic lighting, and a breath-taking, movie-like shot." \
+  --output_path="t2v_2.mp4" \
+  --gemma_root="google/gemma-3-12b-it-qat-q4_0-unquantized" \
+  --checkpoint_path="rc1/ltx-2-19b-dev-rc1.safetensors" \
+  --distilled_lora_path "rc1/ltx-2-19b-distilled-lora-384-rc1.safetensors" \
+  --spatial_upsampler_path "rc1/ltx-2-spatial-upscaler-x2-1.0-rc1.safetensors"
+
+"""
+
+from huggingface_hub import hf_hub_download
+from typing import Optional
+from ltx_pipelines import utils
+from ltx_pipelines.constants import DEFAULT_LORA_STRENGTH
+from ltx_core.loader.primitives import LoraPathStrengthAndSDOps
+from ltx_core.loader.sd_ops import LTXV_LORA_COMFY_RENAMING_MAP
+from ltx_pipelines.ti2vid_two_stages import TI2VidTwoStagesPipeline
+from ltx_core.tiling import TilingConfig
+
+
+def get_hub_or_local_checkpoint(repo_id: Optional[str] = None, filename: Optional[str] = None):
+    if repo_id is None and filename is None:
+        raise ValueError("Please supply at least one of `repo_id` or `filename`")
+
+    if repo_id is not None:
+        if filename is None:
+            raise ValueError("If repo_id is specified, filename must also be specified.")
+        ckpt_path = hf_hub_download(repo_id=repo_id, filename=filename)
+    else:
+        ckpt_path = filename
+
+    return ckpt_path
+
+
+def default_2_stage_arg_parser_mod():
+    parser = utils.default_2_stage_arg_parser()
+    parser.add_argument("--local_files_only", action="store_true")
+    parser.add_argument("--checkpoint_id", type=str, default="diffusers-internal-dev/new-ltx-model")
+    return parser
+
+
+def main() -> None:
+    parser = default_2_stage_arg_parser_mod()
+    args = parser.parse_args()
+    
+    checkpoint_path = get_hub_or_local_checkpoint(args.checkpoint_id, args.checkpoint_path)
+    distilled_lora_path = get_hub_or_local_checkpoint(args.checkpoint_id, args.distilled_lora_path)
+    spatial_upsampler_path = get_hub_or_local_checkpoint(args.checkpoint_id, args.spatial_upsampler_path)
+
+    lora_strengths = (args.lora_strength + [DEFAULT_LORA_STRENGTH] * len(args.lora))[: len(args.lora)]
+    loras = [
+        LoraPathStrengthAndSDOps(lora, strength, LTXV_LORA_COMFY_RENAMING_MAP)
+        for lora, strength in zip(args.lora, lora_strengths, strict=True)
+    ]
+    pipeline = TI2VidTwoStagesPipeline(
+        checkpoint_path=checkpoint_path,
+        distilled_lora_path=distilled_lora_path,
+        distilled_lora_strength=args.distilled_lora_strength,
+        spatial_upsampler_path=spatial_upsampler_path,
+        gemma_root=args.gemma_root,
+        loras=loras,
+        fp8transformer=args.enable_fp8,
+        local_files_only=args.local_files_only
+    )
+    pipeline(
+        prompt=args.prompt,
+        negative_prompt=args.negative_prompt,
+        output_path=args.output_path,
+        seed=args.seed,
+        height=args.height,
+        width=args.width,
+        num_frames=args.num_frames,
+        frame_rate=args.frame_rate,
+        num_inference_steps=args.num_inference_steps,
+        cfg_guidance_scale=args.cfg_guidance_scale,
+        images=args.images,
+        tiling_config=TilingConfig.default(),
+    )
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -1,5 +1,12 @@
+einops
+numpy
+torchaudio
 transformers
-git+https://github.com/huggingface/diffusers.git
-accelerate
 safetensors
-sentencepiece
+accelerate
+flashpack==0.1.2
+scikit-image>=0.25.2
+av
+tqdm
+pillow
+scipy>=1.14