Recalibrate GPU duration reservations, drop deprecated warnings

Live logs showed all three models finishing (warm) in 18-39s while
every call reserved a blanket 120s of ZeroGPU quota — the hard-coded
120s floor plus generous load_overhead guesses were never tuned
against real GPU timings. ZeroGPU's admission check gates on the
requested duration against remaining quota, so over-reserving causes
premature "quota exceeded" errors well before quota is actually
exhausted.

- Lower the global floor from 120s to 45s.
- Recalibrate each model's load_overhead to ~1.5-2x its measured warm
end-to-end time (TARO 120->35, MMAudio 30->35, HunyuanFoley 90->55,
with extra margin kept for HunyuanFoley's larger cold-disk-read risk).
- Drop the deprecated local_dir_use_symlinks kwarg from hf_hub_download
calls.
- Silence the harmless weight_norm FutureWarning from vendored
HunyuanVideo-Foley DAC VAE loading code.

app.py

@@ -20,9 +20,18 @@ import tempfile
 import random
 import threading
 import time
+import warnings
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 
+# HunyuanVideo-Foley's DAC VAE loads its weights via the pre-parametrization
+# torch.nn.utils.weight_norm API — harmless, but noisy on every model load.
+warnings.filterwarnings(
+    "ignore",
+    message="`torch.nn.utils.weight_norm` is deprecated",
+    category=FutureWarning,
+)
+
 import torch
 import numpy as np
 import torchaudio
@@ -121,22 +130,22 @@ def _dl_taro():
 def _dl_mmaudio():
     """Download MMAudio .pth files and return their local paths."""
     m = hf_hub_download(repo_id=CKPT_REPO_ID, filename="MMAudio/mmaudio_large_44k_v2.pth",
-                        cache_dir=CACHE_DIR, local_dir=str(MMAUDIO_WEIGHTS_DIR), local_dir_use_symlinks=False)
+                        cache_dir=CACHE_DIR, local_dir=str(MMAUDIO_WEIGHTS_DIR))
     v = hf_hub_download(repo_id=CKPT_REPO_ID, filename="MMAudio/v1-44.pth",
-                        cache_dir=CACHE_DIR, local_dir=str(MMAUDIO_EXT_DIR), local_dir_use_symlinks=False)
+                        cache_dir=CACHE_DIR, local_dir=str(MMAUDIO_EXT_DIR))
     s = hf_hub_download(repo_id=CKPT_REPO_ID, filename="MMAudio/synchformer_state_dict.pth",
-                        cache_dir=CACHE_DIR, local_dir=str(MMAUDIO_EXT_DIR), local_dir_use_symlinks=False)
+                        cache_dir=CACHE_DIR, local_dir=str(MMAUDIO_EXT_DIR))
     print("MMAudio checkpoints downloaded.")
     return m, v, s
 
 def _dl_hunyuan():
     """Download HunyuanVideoFoley .pth files."""
     hf_hub_download(repo_id=CKPT_REPO_ID, filename="HunyuanVideo-Foley/hunyuanvideo_foley.pth",
-                    cache_dir=CACHE_DIR, local_dir=str(HUNYUAN_MODEL_DIR), local_dir_use_symlinks=False)
+                    cache_dir=CACHE_DIR, local_dir=str(HUNYUAN_MODEL_DIR))
     hf_hub_download(repo_id=CKPT_REPO_ID, filename="HunyuanVideo-Foley/vae_128d_48k.pth",
-                    cache_dir=CACHE_DIR, local_dir=str(HUNYUAN_MODEL_DIR), local_dir_use_symlinks=False)
+                    cache_dir=CACHE_DIR, local_dir=str(HUNYUAN_MODEL_DIR))
     hf_hub_download(repo_id=CKPT_REPO_ID, filename="HunyuanVideo-Foley/synchformer_state_dict.pth",
-                    cache_dir=CACHE_DIR, local_dir=str(HUNYUAN_MODEL_DIR), local_dir_use_symlinks=False)
+                    cache_dir=CACHE_DIR, local_dir=str(HUNYUAN_MODEL_DIR))
     print("HunyuanVideoFoley checkpoints downloaded.")
 
 def _populate_hf_cache_from_mirror(orig_repo_id, mirror_subpath):
@@ -743,7 +752,8 @@ MODEL_CONFIGS = {
         "window_s":       TARO_MODEL_DUR,  # 8.192 s
         "sr":             TARO_SR,          # 16000 (output resampled to TARGET_SR)
         "secs_per_step":  0.025,  # measured 0.023 s/step on H200
-        "load_overhead":  120,    # CAVP+onset+MMDiT+VAE+vocoder load + feature extraction
+        "load_overhead":  35,     # CAVP+onset+MMDiT+VAE+vocoder load + feature extraction
+                                   # (measured ~18s warm end-to-end on RTX Pro 6000 Blackwell; ~2x margin)
         "tab_prefix":     "taro",
         "label":          "TARO",
         "regen_fn":       None,   # set after function definitions (avoids forward-ref)
@@ -752,7 +762,8 @@ MODEL_CONFIGS = {
         "window_s":       8.0,    # MMAudio's fixed generation window
         "sr":             48000,  # resampled from 44100 in post-processing
         "secs_per_step":  0.25,   # measured 0.230 s/step on H200
-        "load_overhead":  30,     # 15s warm + 15s model init
+        "load_overhead":  35,     # 15s warm + 15s model init
+                                   # (measured ~23s warm end-to-end on RTX Pro 6000 Blackwell; ~1.5x margin)
         "tab_prefix":     "mma",
         "label":          "MMAudio",
         "regen_fn":       None,
@@ -761,7 +772,10 @@ MODEL_CONFIGS = {
         "window_s":       15.0,   # HunyuanFoley max video duration
         "sr":             48000,
         "secs_per_step":  0.50,   # wall-time ~0.607s/step (incl. VAE decode + feature extraction)
-        "load_overhead":  90,     # cold disk: ~73s for 10 GB weights + ~8s aux models
+        "load_overhead":  55,     # SigLIP2 + Synchformer + CLAP + main model + DAC VAE load
+                                   # (measured ~39s warm end-to-end on RTX Pro 6000 Blackwell; extra
+                                   # margin kept vs. TARO/MMAudio for first-load cold-disk-cache risk
+                                   # on the ~10 GB XXL checkpoint)
         "tab_prefix":     "hf",
         "label":          "HunyuanFoley",
         "regen_fn":       None,
@@ -813,10 +827,12 @@ def _catch_oom(fn):
 
 
 def _clamp_duration(secs: float, label: str) -> int:
-    """Clamp a raw GPU-seconds estimate to [120, GPU_DURATION_CAP] and log it.
-    ZeroGPU Pro users get up to 300 s per call; 120 s floor covers cold-disk
-    model loads (e.g. HunyuanFoley XXL ~73 s on first access)."""
-    result = min(GPU_DURATION_CAP, max(120, int(secs)))
+    """Clamp a raw GPU-seconds estimate to [45, GPU_DURATION_CAP] and log it.
+    ZeroGPU Pro users get up to 300 s per call; 45 s floor covers per-call
+    scheduling/queue overhead without over-reserving quota on every warm
+    call (each model's own load_overhead in MODEL_CONFIGS covers its
+    model-load cost above this floor)."""
+    result = min(GPU_DURATION_CAP, max(45, int(secs)))
     print(f"[duration] {label}: {secs:.0f}s raw → {result}s reserved")
     return result