Run inline on Space instead of via FastAPI

Drop the HTTP client to /generate and load AudioProcessor in-process
so the Space works as a single Gradio app: download checkpoints,
clone the seed-vc and ComfyUI-MelBandRoFormer source trees, pin every
checkpoint env var (incl. GEMMA_QUANTIZE=nf4) before importing
audio_core, then call processor.startup() at module load. _run_job
monkey-patches _download_reference so file:// uploads from the Voice
Cloning tab get copied to a throwaway temp path. Whisper Validation
defaults off pending cuBLAS/cuDNN preload; ship the nvidia-cu12 wheels
in requirements so the libs are at least installed.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

app.py

@@ -2,32 +2,162 @@
 # https://scenema.ai
 # SPDX-License-Identifier: MIT
 
-"""Gradio web UI for Scenema Audio.
+"""Gradio web UI for Scenema Audio (ZeroGPU, single-process)."""
 
-Thin HTTP client that talks to the FastAPI server at /generate.
-Mount into the FastAPI app via gr.mount_gradio_app() or run standalone.
-
-Usage (standalone):
-    python app.py
-
-Usage (mounted, via ENABLE_GRADIO=1):
-    ENABLE_GRADIO=1 python -m server
-    # UI available at http://localhost:8000/ui
-"""
-
-import base64
+import asyncio
 import io
-import json
+import logging
 import os
-import urllib.request
+import shutil
+import sys
+import tempfile
+import uuid
+from pathlib import Path
 from xml.sax.saxutils import escape
-import spaces
 
-import gradio as gr
-import numpy as np
-import soundfile as sf
+os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
+
+# ── Model paths ───────────────────────────────────────────────
+# These env vars must be set before audio_core is imported — vocal_separator
+# and seedvc capture MELBAND_*/SEEDVC_PATH at module import time.
+
+_APP_DIR = Path(__file__).parent.resolve()
+MODEL_DIR = (_APP_DIR / "models").resolve()
+MODEL_DIR.mkdir(parents=True, exist_ok=True)
+os.environ["MODEL_DIR"] = str(MODEL_DIR)
+
+os.environ.setdefault(
+    "AUDIO_CKPT", str(MODEL_DIR / "scenema-audio-transformer-int8.safetensors")
+)
+os.environ.setdefault(
+    "PIPELINE_CKPT", str(MODEL_DIR / "scenema-audio-pipeline.safetensors")
+)
+os.environ.setdefault(
+    "VAE_ENCODER_CKPT", str(MODEL_DIR / "scenema-audio-vae-encoder.safetensors")
+)
+os.environ.setdefault("GEMMA_ROOT", str(MODEL_DIR / "gemma-3-12b-it"))
+os.environ.setdefault(
+    "MELBAND_MODEL_PATH", str(MODEL_DIR / "MelBandRoformer_fp16.safetensors")
+)
+os.environ.setdefault("SEEDVC_PATH", str(_APP_DIR / "seed-vc"))
+os.environ.setdefault("MELBAND_NODE_PATH", str(_APP_DIR / "melband_roformer_node"))
+os.environ.setdefault("HF_HUB_CACHE", str(MODEL_DIR / "hf_cache"))
+os.environ.setdefault("GEMMA_QUANTIZE", "nf4")
+
+sys.path.insert(0, str(_APP_DIR / "src"))
+
+import gradio as gr  # noqa: E402
+import numpy as np  # noqa: E402
+import soundfile as sf  # noqa: E402
+import spaces  # noqa: E402
+from huggingface_hub import hf_hub_download, snapshot_download  # noqa: E402
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(name)s %(levelname)s %(message)s",
+)
+logger = logging.getLogger("scenema-space")
+
+
+# ── Repo + weight bootstrap ───────────────────────────────────
+
+HF_REPO = "ScenemaAI/scenema-audio"
+GEMMA_REPO = "google/gemma-3-12b-it"
+SEEDVC_REPO = "Plachta/Seed-VC"
+BIGVGAN_REPO = "nvidia/bigvgan_v2_22khz_80band_256x"
+WHISPER_REPO = "openai/whisper-small"
+
+
+def _ensure_seedvc_repo():
+    """Clone seed-vc + ComfyUI-MelBandRoFormer source if missing."""
+    seedvc = Path(os.environ["SEEDVC_PATH"])
+    if not (seedvc / "modules").exists():
+        logger.info("Cloning seed-vc source...")
+        os.system(
+            f"git clone --depth 1 https://github.com/Plachtaa/seed-vc.git {seedvc}"
+        )
 
-# API_URL = os.environ.get("SCENEMA_API_URL", "http://localhost:8000")
+    melband_node = Path(os.environ["MELBAND_NODE_PATH"])
+    if not melband_node.exists():
+        logger.info("Cloning ComfyUI-MelBandRoFormer source...")
+        os.system(
+            f"git clone --depth 1 https://github.com/kijai/ComfyUI-MelBandRoFormer {melband_node}"
+        )
+
+
+def _download_all():
+    token = os.environ.get("HF_TOKEN")
+
+    audio_ckpt = Path(os.environ["AUDIO_CKPT"])
+    if not audio_ckpt.exists():
+        logger.info("Downloading audio transformer INT8 (~4.9 GB)...")
+        hf_hub_download(
+            HF_REPO, "scenema-audio-transformer-int8.safetensors",
+            local_dir=str(audio_ckpt.parent), token=token,
+        )
+
+    pipeline_ckpt = Path(os.environ["PIPELINE_CKPT"])
+    if not pipeline_ckpt.exists():
+        logger.info("Downloading pipeline checkpoint (~6.7 GB)...")
+        hf_hub_download(
+            HF_REPO, "scenema-audio-pipeline.safetensors",
+            local_dir=str(pipeline_ckpt.parent), token=token,
+        )
+
+    vae = Path(os.environ["VAE_ENCODER_CKPT"])
+    if not vae.exists():
+        logger.info("Downloading VAE encoder (~42 MB)...")
+        hf_hub_download(
+            HF_REPO, "scenema-audio-vae-encoder.safetensors",
+            local_dir=str(vae.parent), token=token,
+        )
+
+    melband = Path(os.environ["MELBAND_MODEL_PATH"])
+    if not melband.exists():
+        logger.info("Downloading MelBandRoFormer (~436 MB)...")
+        hf_hub_download(
+            "Kijai/MelBandRoFormer_comfy", "MelBandRoformer_fp16.safetensors",
+            local_dir=str(melband.parent), token=token,
+        )
+
+    gemma = Path(os.environ["GEMMA_ROOT"])
+    if not gemma.exists() or not any(gemma.glob("*.safetensors")):
+        logger.info("Downloading Gemma 3 12B IT (~24 GB, gated)...")
+        snapshot_download(
+            GEMMA_REPO, local_dir=str(gemma),
+            ignore_patterns=["*.gguf"], token=token,
+        )
+
+    seedvc_path = Path(os.environ["SEEDVC_PATH"])
+    seedvc_ckpts = seedvc_path / "checkpoints"
+    if not seedvc_ckpts.exists() or not any(seedvc_ckpts.glob("*.pth")):
+        logger.info("Downloading SeedVC checkpoints (~1.6 GB)...")
+        seedvc_ckpts.mkdir(parents=True, exist_ok=True)
+        hf_cache = seedvc_ckpts / "hf_cache"
+        hf_cache.mkdir(parents=True, exist_ok=True)
+        os.environ["HF_HUB_CACHE"] = str(hf_cache)
+        hf_hub_download(
+            SEEDVC_REPO,
+            "DiT_seed_v2_uvit_whisper_small_wavenet_bigvgan_pruned.pth",
+            local_dir=str(seedvc_ckpts), token=token,
+        )
+        hf_hub_download(
+            SEEDVC_REPO,
+            "config_dit_mel_seed_uvit_whisper_small_wavenet.yml",
+            local_dir=str(seedvc_ckpts), token=token,
+        )
+        snapshot_download(BIGVGAN_REPO, local_dir=str(hf_cache / "bigvgan"))
+        snapshot_download(WHISPER_REPO, local_dir=str(hf_cache / "whisper-small"))
+
+
+_ensure_seedvc_repo()
+_download_all()
+
+from audio_core.processor import AudioProcessor  # noqa: E402
+from common.handlers.base import ProcessJob  # noqa: E402
+
+processor = AudioProcessor()
+processor.startup()
 
 
 # ── Helpers ────────────────────────────────────────────────────
@@ -97,30 +227,43 @@ def _build_xml(
     return f"<speak {attrs}>\n{text.strip()}\n</speak>"
 
 
-def _call_api(payload: dict) -> tuple:
-    """POST to /generate, return (sample_rate, np_array), metadata_str."""
-    data = json.dumps(payload).encode()
-    req = urllib.request.Request(
-        f"{API_URL}/generate",
-        data=data,
-        headers={"Content-Type": "application/json"},
-    )
-    try:
-        with urllib.request.urlopen(req, timeout=600) as resp:
-            result = json.loads(resp.read())
-    except urllib.error.URLError as e:
-        raise gr.Error(
-            f"Cannot reach API at {API_URL}/generate. "
-            f"Is the server running? ({e})"
-        )
-
-    if result.get("status") != "succeeded":
-        raise gr.Error(result.get("error", "Generation failed"))
-
-    wav_bytes = base64.b64decode(result["audio"])
-    audio_data, sample_rate = sf.read(io.BytesIO(wav_bytes))
+def _run_job(payload: dict) -> tuple:
+    """Run a generation job inline against the global processor.
 
-    meta = result.get("metadata", {})
+    Returns ((sample_rate, np_array), metadata_dict).
+    """
+    async def _go():
+        # Voice Cloning passes the upload as file://… — httpx can't fetch
+        # that, and the processor unlinks the path it gets back. Copy the
+        # user's file to a throwaway temp file so cleanup is harmless.
+        original = processor._download_reference
+
+        async def patched(url):
+            if url.startswith("file://"):
+                src = url[len("file://"):]
+                suffix = Path(src).suffix or ".wav"
+                tmp = tempfile.NamedTemporaryFile(suffix=suffix, delete=False)
+                tmp.close()
+                shutil.copyfile(src, tmp.name)
+                return tmp.name
+            return await original(url)
+
+        processor._download_reference = patched
+        try:
+            job = ProcessJob(job_id=str(uuid.uuid4()), input=payload)
+            return await processor.process(job)
+        finally:
+            processor._download_reference = original
+
+    result = asyncio.run(_go())
+
+    if not result.success:
+        raise gr.Error(result.error or "Generation failed")
+
+    output = result.output
+    audio_data, sample_rate = sf.read(io.BytesIO(output.data))
+
+    meta = output.metadata or {}
     meta_display = {
         "duration": f"{meta.get('duration_s', 0):.1f}s",
         "processing_time": f"{meta.get('processing_ms', 0) / 1000:.1f}s",
@@ -163,7 +306,7 @@ def generate(
         "validate": validate,
         "skip_vc": skip_vc,
     }
-    audio, meta = _call_api(payload)
+    audio, meta = _run_job(payload)
     return audio, meta, prompt
 
 
@@ -188,7 +331,7 @@ def voice_design(
         "mode": "voice_design",
         "seed": seed,
     }
-    audio, meta = _call_api(payload)
+    audio, meta = _run_job(payload)
     return audio, meta, prompt
 
 
@@ -236,7 +379,7 @@ def voice_clone(
         "background_sfx": background_sfx,
         "validate": validate,
     }
-    audio, meta = _call_api(payload)
+    audio, meta = _run_job(payload)
     return audio, meta, prompt
 
 
@@ -264,7 +407,7 @@ def generate_raw(
         "validate": validate,
         "skip_vc": skip_vc,
     }
-    audio, meta = _call_api(payload)
+    audio, meta = _run_job(payload)
     return audio, meta
 
 
@@ -488,7 +631,8 @@ def create_demo() -> gr.Blocks:
                             )
                             gen_validate = gr.Checkbox(
                                 label="Whisper Validation",
-                                value=True,
+                                value=False,
+                                interactive=True
                             )
                             gen_skip_vc = gr.Checkbox(
                                 label="Skip Voice Conversion",
@@ -678,7 +822,8 @@ def create_demo() -> gr.Blocks:
                             )
                             vc_validate = gr.Checkbox(
                                 label="Whisper Validation",
-                                value=True,
+                                value=False,
+                                interactive=True,
                             )
                         vc_btn = gr.Button("Generate with Voice Cloning", variant="primary")
 
@@ -756,7 +901,8 @@ def create_demo() -> gr.Blocks:
                             )
                             raw_validate = gr.Checkbox(
                                 label="Whisper Validation",
-                                value=True,
+                                value=False,
+                                interactive=True,
                             )
                             raw_skip_vc = gr.Checkbox(
                                 label="Skip VC",

requirements.txt

@@ -27,3 +27,5 @@ bitsandbytes==0.49.2
 kokoro==0.9.4
 faster-whisper==1.2.1
 ctranslate2==4.7.1
+nvidia-cublas-cu12
+nvidia-cudnn-cu12