Upload app.py with huggingface_hub

app.py

@@ -5,6 +5,7 @@ install `requirements.txt` (torch + diffusers + transformers + gradio + spaces)
 and call:
   - `app.py:infer`         — single image → motion (AnimateDiff MotionLoRA)
   - `app.py:infer_txt2img` — prompt → 512×512 sprite (SD 1.5)
+  - `app.py:infer_ltx_i2v` — reference portrait → portrait video (LTX-Video I2V)
 
 `@spaces.GPU` allocates an A10G only for the duration of the call (ZeroGPU
 model), so the Space is free for the maintainer and shared fairly across users.
@@ -28,6 +29,7 @@ from studio.backends.animatediff import AnimateDiffAdapter, MOTION_LORA_MAP
 
 _adapter: AnimateDiffAdapter | None = None
 _sd_pipe = None
+_ltx_pipe = None
 
 
 def _get_adapter() -> AnimateDiffAdapter:
@@ -41,18 +43,9 @@ def _get_adapter() -> AnimateDiffAdapter:
 PIXEL_ART_LORA_REPO = "artificialguybr/pixelartredmond-1-5v-pixel-art-loras-for-sd-1-5"
 PIXEL_ART_LORA_WEIGHT_FILE = "PixelArtRedmond15V-PixelArt-PIXARFK.safetensors"
 PIXEL_ART_LORA_ADAPTER = "pixart"
-# Trigger words: "pixel art, PixArFK" should appear in the prompt for the LoRA
-# to engage. The probe + UI include them by default.
 
 
 def _get_sd_pipe():
-    """Lazily load SD 1.5 txt2img pipeline + PixelArtRedmond LoRA (runs inside
-    @spaces.GPU context).
-
-    Cached at module scope so warm calls skip re-loading. Cold start is ~30-60s
-    including weight downloads on first call ever (cached in persistent storage
-    for subsequent cold starts). LoRA weight is set per-call via set_adapters().
-    """
     global _sd_pipe
     if _sd_pipe is not None:
         return _sd_pipe
@@ -81,6 +74,29 @@ def _get_sd_pipe():
     return pipe
 
 
+def _get_ltx_pipe():
+    """Lazily load LTX-Video I2V pipeline (bfloat16, CUDA).
+
+    Model: Lightricks/LTX-Video (~8 GB, cached in persistent storage after first call).
+    Supports portrait aspect ratios (height > width) with both dims divisible by 32.
+    Frame counts must be of the form 8k+1 (9, 17, 25, 49, 97, 121 ...).
+    """
+    global _ltx_pipe
+    if _ltx_pipe is not None:
+        return _ltx_pipe
+    import torch
+    from diffusers import LTXImageToVideoPipeline
+    pipe = LTXImageToVideoPipeline.from_pretrained(
+        "Lightricks/LTX-Video",
+        torch_dtype=torch.bfloat16,
+    )
+    pipe = pipe.to("cuda")
+    pipe.set_progress_bar_config(disable=True)
+    print("LTX-Video I2V pipeline loaded", flush=True)
+    _ltx_pipe = pipe
+    return pipe
+
+
 @spaces.GPU(duration=90)
 def infer(
     image: np.ndarray,
@@ -126,15 +142,7 @@ def infer_txt2img(
     seed: int,
     lora_weight: float,
 ) -> str:
-    """Generate a single sprite from a text prompt. Returns path to a PNG.
-
-    Defaults tuned for pixel-art sprites: 512×512, 25 steps, guidance 7.5,
-    LoRA strength 0.9. Caller downscales to target res (256×256 is the Dicer
-    sprite size).
-
-    Prompt must include "pixel art, PixArFK" to engage the LoRA. The UI
-    pre-populates these tokens; the probe always includes them.
-    """
+    """Generate a single sprite from a text prompt. Returns path to a PNG."""
     import torch
 
     pipe = _get_sd_pipe()
@@ -158,11 +166,66 @@ def infer_txt2img(
     return f.name
 
 
+@spaces.GPU(duration=150)
+def infer_ltx_i2v(
+    image: np.ndarray,
+    prompt: str,
+    negative_prompt: str,
+    height: int,
+    width: int,
+    num_frames: int,
+    num_inference_steps: int,
+    guidance_scale: float,
+    seed: int,
+) -> str:
+    """LTX-Video image-to-video: reference portrait → portrait video clip.
+
+    Constraints enforced here (not in UI) so programmatic callers are safe:
+      - height and width are rounded up to nearest multiple of 32
+      - num_frames is rounded up to nearest 8k+1 value
+
+    Returns path to an mp4 file at 24fps.
+    """
+    import torch
+    import imageio.v3 as iio
+
+    # Enforce divisibility constraints
+    h = int(height)
+    w = int(width)
+    h = ((h + 31) // 32) * 32
+    w = ((w + 31) // 32) * 32
+    nf = int(num_frames)
+    if (nf - 1) % 8 != 0:
+        nf = ((nf // 8) * 8) + 1
+
+    pipe = _get_ltx_pipe()
+    pil_img = PILImage.fromarray(image.astype(np.uint8))
+    gen = torch.Generator(device="cuda").manual_seed(int(seed))
+
+    result = pipe(
+        image=pil_img,
+        prompt=prompt,
+        negative_prompt=negative_prompt,
+        height=h,
+        width=w,
+        num_frames=nf,
+        num_inference_steps=int(num_inference_steps),
+        guidance_scale=float(guidance_scale),
+        generator=gen,
+    )
+    frames_pil = result.frames[0]
+    frames_np = np.stack([np.array(f) for f in frames_pil], axis=0)
+
+    out = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
+    iio.imwrite(out.name, frames_np, fps=24)
+    return out.name
+
+
 with gr.Blocks(title="Venture-Studio") as demo:
     gr.Markdown(
         "# Venture-Studio · Pixel-Cursor Animation\n"
-        "Single image → 24fps animation, or text prompt → sprite, via PixelCursor.\n"
-        "Running on Hugging Face ZeroGPU (free A10G)."
+        "Single image → 24fps animation, text prompt → sprite, or portrait → locked video.\n"
+        "Running on Hugging Face ZeroGPU."
     )
     with gr.Tabs():
         with gr.Tab("Motion"):
@@ -229,6 +292,57 @@ with gr.Blocks(title="Venture-Studio") as demo:
                 api_name="infer_txt2img",
             )
 
+        with gr.Tab("Hologram (LTX I2V)"):
+            gr.Markdown(
+                "### LTX-Video Image-to-Video\n"
+                "Reference portrait image → locked-head portrait video clip. "
+                "Height must exceed width (portrait). Both dims rounded to nearest 32. "
+                "Frames rounded to nearest 8k+1 (9 17 25 49 97 121...)."
+            )
+            with gr.Row():
+                with gr.Column():
+                    ltx_image = gr.Image(label="Reference portrait", type="numpy", height=384)
+                    ltx_prompt = gr.Textbox(
+                        value=(
+                            "East-Asian man, 30s, dark navy suit, subtle lapel pin, "
+                            "neutral-formal expression, studio lighting, soft rim light, "
+                            "portrait frame, subject upper two-thirds of frame. "
+                            "Speaking naturally, lips 60-70% open, visible lip movement. "
+                            "Head absolutely still, zero lateral or vertical drift. "
+                            "Single continuous shot, no cuts. Photorealistic, cinematic."
+                        ),
+                        lines=4, label="prompt",
+                    )
+                    ltx_neg = gr.Textbox(
+                        value=(
+                            "head movement, swaying, bobbing, nodding, camera shake, "
+                            "zoom, pan, closed mouth, jump cut, cartoon, deformed, blurry"
+                        ),
+                        lines=2, label="negative_prompt",
+                    )
+                    with gr.Accordion("Advanced", open=False):
+                        ltx_height = gr.Slider(256, 768, value=576, step=32,
+                                               label="height (portrait: height > width, div-32)")
+                        ltx_width = gr.Slider(256, 768, value=320, step=32,
+                                              label="width (div-32)")
+                        ltx_frames = gr.Slider(9, 121, value=121, step=8,
+                                               label="num_frames (8k+1: 9 17 25 49 97 121)")
+                        ltx_steps = gr.Slider(10, 50, value=25, step=1, label="num_inference_steps")
+                        ltx_guidance = gr.Slider(1.0, 10.0, value=3.0, step=0.5, label="guidance_scale")
+                        ltx_seed = gr.Number(value=42, precision=0, label="seed")
+                    ltx_run = gr.Button("Generate", variant="primary")
+                with gr.Column():
+                    ltx_out = gr.Video(label="Output", autoplay=True, loop=True)
+
+            ltx_run.click(
+                infer_ltx_i2v,
+                inputs=[ltx_image, ltx_prompt, ltx_neg,
+                        ltx_height, ltx_width, ltx_frames,
+                        ltx_steps, ltx_guidance, ltx_seed],
+                outputs=ltx_out,
+                api_name="infer_ltx_i2v",
+            )
+
 
 if __name__ == "__main__":
     demo.launch()