second commit

README.md

@@ -6,6 +6,9 @@ colorTo: blue
 sdk: gradio
 app_file: app.py
 pinned: false
+startup_duration_timeout: 600
+hardware:
+  accelerator: zero-gpu
 models:
   - Lightricks/LTX-Video-0.9.5
 ---
@@ -74,8 +77,10 @@ browser, on any device, forever (as long as the Space stays public/free).
 (Data from the official [ZeroGPU docs](https://huggingface.co/docs/hub/en/spaces-zerogpu),
 Aug 2026. Free accounts can host up to 2 ZeroGPU Spaces.)
 
-- One short clip (~5s, 30 steps) consumes roughly **1–2 minutes** of that quota,
-  so a free account realistically gets **~3–5 videos per day**.
+- ZeroGPU bills each request by its **reserved duration** (x1.5 on current
+  hardware), not the exact seconds used. The app reserves just enough for one
+  clip, so a free account realistically gets **~2–4 videos per day** (short,
+  low-resolution clips cost less and stretch it further).
 - Queue priority is based on remaining quota — use your quota early in the day.
 - There is **no unlimited free tier anywhere** for video generation. GPUs are
   expensive; that's physics, not a scam.

app.py

@@ -10,6 +10,9 @@ import tempfile
 
 import gradio as gr
 import spaces
+import torch
+from diffusers import LTXImageToVideoPipeline, LTXPipeline
+from diffusers.utils import export_to_video
 
 # The 2B LTX-Video checkpoint (0.9.5): much lighter than the 13B main repo
 # (~15GB bf16 vs ~38GB), so it fits the 48GB ZeroGPU slice comfortably.
@@ -30,35 +33,37 @@ RESOLUTIONS = {
 
 FPS = 24
 
-# Pipelines are loaded lazily on the first generation (the model files are
-# prefetched at build time via the `models:` key in README.md, so this only
-# loads them into GPU memory once). Keeps the Space from OOM-ing at startup.
-_text_pipe = None
-_image_pipe = None
-
-
-def _load_pipes():
-    """Load the text-to-video and image-to-video pipelines once, then reuse."""
-    global _text_pipe, _image_pipe
-
-    import torch
-    from diffusers import LTXImageToVideoPipeline, LTXPipeline
-
-    if _text_pipe is None:
-        _text_pipe = LTXPipeline.from_pretrained(MODEL_ID, torch_dtype=torch.bfloat16)
-        _text_pipe.to("cuda")
-        _text_pipe.vae.enable_slicing()
-        _text_pipe.vae.enable_tiling()
-
-    if _image_pipe is None:
-        _image_pipe = LTXImageToVideoPipeline.from_pretrained(
-            MODEL_ID, torch_dtype=torch.bfloat16
-        )
-        _image_pipe.to("cuda")
-        _image_pipe.vae.enable_slicing()
-        _image_pipe.vae.enable_tiling()
-
-    return _text_pipe, _image_pipe
+# ---------------------------------------------------------------------------
+# Load the model ONCE at startup (module level).
+#
+# ZeroGPU rule: place models on cuda at module level so loading happens OUTSIDE
+# the quota-charged generation call. A lazy first load inside @spaces.GPU would
+# need a huge reservation (240s -> 360s billed after ZeroGPU's 1.5x factor),
+# which exceeds the 300s free daily quota and gets rejected with
+# "duration is larger than the maximum allowed". Preloading keeps every call
+# small, so the free quota buys ~2-4 videos per day.
+# The model files are prefetched at build time via the `models:` key in
+# README.md, so this reads from local disk and takes under a minute.
+# ---------------------------------------------------------------------------
+print("Loading LTX-Video model (once, at startup)...")
+_text_pipe = LTXPipeline.from_pretrained(MODEL_ID, torch_dtype=torch.bfloat16)
+_text_pipe.to("cuda")
+_text_pipe.vae.enable_slicing()
+_text_pipe.vae.enable_tiling()
+
+# The image-to-video pipeline reuses the same components, so it adds
+# almost no extra memory.
+_image_pipe = LTXImageToVideoPipeline.from_pretrained(
+    MODEL_ID,
+    transformer=_text_pipe.transformer,
+    vae=_text_pipe.vae,
+    text_encoder=_text_pipe.text_encoder,
+    tokenizer=_text_pipe.tokenizer,
+    scheduler=_text_pipe.scheduler,
+    torch_dtype=torch.bfloat16,
+)
+_image_pipe.to("cuda")
+print("Model ready.")
 
 
 def _get_duration(
@@ -66,12 +71,17 @@ def _get_duration(
 ):
     """Return the GPU runtime budget for this call (seconds).
 
-    ZeroGPU charges quota based on this reservation, so keep it tight.
-    The first call also loads the model into GPU memory, so give it more room.
+    The model is already loaded, so this only needs to cover generation.
+    ZeroGPU bills the reservation (x1.5 on current hardware) against the daily
+    quota, so keep it tight: shorter durations = more videos per day.
     """
-    if _text_pipe is None:
-        return 240  # first call: model load + generation
-    return max(45, int(num_steps * 1.5) + 15)
+    width, height = RESOLUTIONS[resolution]
+    pixel_scale = (width * height) / (512 * 704)
+    step_scale = num_steps / 30.0
+    estimate = num_frames * 0.25 * pixel_scale * step_scale
+    total = int((estimate + 15) * 1.2)  # + VAE decode/export overhead, 20% margin
+    total = max(45, total)
+    return min(total, 120)
 
 
 @spaces.GPU(duration=_get_duration)
@@ -87,9 +97,6 @@ def generate_video(
     guidance,
 ):
     """Generate a video from a text prompt (or an image + prompt)."""
-    import torch
-    from diffusers.utils import export_to_video
-
     if not prompt or not prompt.strip():
         raise gr.Error("Please write a prompt first.")
 
@@ -101,7 +108,7 @@ def generate_video(
         seed = random.randint(0, 2**31 - 1)
     generator = torch.Generator(device="cuda").manual_seed(seed)
 
-    text_pipe, image_pipe = _load_pipes()
+    text_pipe, image_pipe = _text_pipe, _image_pipe
 
     # Timestep-aware VAE settings recommended for LTX-Video 0.9.1+.
     decode_kwargs = {"decode_timestep": 0.05, "decode_noise_scale": 0.025}