Minimal baseline to confirm RUNNING state

app.py

@@ -7,27 +7,20 @@ import torch
 import torchaudio
 import gradio as gr
 import spaces
-from fastapi.responses import JSONResponse
-from einops import rearrange
-from huggingface_hub import login
-from stable_audio_3 import StableAudioModel
 
-# Hugging Face Spaces should use UTF-8; explicitly configure streams so model
-# libraries cannot inherit a platform-specific charmap encoding.
 for _stream in (sys.stdout, sys.stderr):
     if hasattr(_stream, "reconfigure"):
         _stream.reconfigure(encoding="utf-8", errors="backslashreplace")
 
-# Authenticate with gated model when HF_TOKEN secret is present
+from fastapi.responses import JSONResponse
+from einops import rearrange
+from huggingface_hub import login
+from stable_audio_3 import StableAudioModel
+
 hf_token = os.environ.get("HF_TOKEN")
 if hf_token:
     login(token=hf_token)
 
-
-# ZeroGPU Spaces refuse to start if no @spaces.GPU function is ever called, but
-# every call into a GPU function burns quota. So call this exactly ONCE at boot
-# with the smallest budget (1s), and keep all real generation on CPU below
-# (NOT decorated). That way quota is only touched here, never per request.
 try:
     @spaces.GPU(duration=1)
     def _gpu_startup_touch():
@@ -52,10 +45,6 @@ def _get_ram_bytes():
     return None
 
 
-# ---------------------------------------------------------------------------
-# API metadata
-# ---------------------------------------------------------------------------
-
 API_RESOURCES = {
     "audio_generation": {
         "name": "Audio generation",
@@ -78,11 +67,11 @@ API_SPECS = {
     "name": "Respite API",
     "version": "1.0.0",
     "description": "General-purpose AI API server with audio generation capabilities.",
-    "base_path": "/respite",
+    "base_path": "/api",
     "authentication": "none",
     "content_types": ["application/json", "audio/wav"],
-    "resources_endpoint": "/respite/resources",
-    "specs_endpoint": "/respite/specs",
+    "resources_endpoint": "/api/resources",
+    "specs_endpoint": "/api/specs",
     "limits": {
         "max_concurrent_requests": 1,
         "max_queue_size": 4,
@@ -104,15 +93,10 @@ def _get_runtime_specs():
     }
 
 
-# ---------------------------------------------------------------------------
-# Model cache
-# ---------------------------------------------------------------------------
-
 MODEL_CACHE = {}
 
 
 def load_model(model_name):
-    """Load model on demand and cache it."""
     if model_name not in MODEL_CACHE:
         _log(f"Loading {model_name} model...")
         model = StableAudioModel.from_pretrained(model_name, device="cpu")
@@ -121,31 +105,18 @@ def load_model(model_name):
     return MODEL_CACHE[model_name]
 
 
-# Model loading is lazy: startup must remain healthy even when a model download
-# or initialization fails. The first generation request loads the selected model.
-
-
 def generate_audio(prompt, duration, steps, cfg_scale, seed, model_name):
     _log(
         f"Generating with {model_name}: prompt='{prompt}', "
         f"duration={duration}s, steps={steps}, cfg={cfg_scale}, seed={seed}"
     )
-
     model = load_model(model_name)
-
     audio = model.generate(
-        prompt=prompt,
-        duration=duration,
-        steps=steps,
-        cfg_scale=cfg_scale,
-        seed=seed,
-        batch_size=1,
+        prompt=prompt, duration=duration, steps=steps,
+        cfg_scale=cfg_scale, seed=seed, batch_size=1,
     )
-
-    # Post-process: (batch, channels, samples) -> stereo waveform
     audio = rearrange(audio, "b d n -> d (b n)")
     audio = audio.to(torch.float32).clamp(-1, 1).mul(32767).to(torch.int16).cpu()
-
     output_path = os.path.join(
         tempfile.gettempdir(),
         f"stable_audio_{seed}_{hash(prompt) & 0xFFFFFFFF:08x}.wav",
@@ -155,10 +126,6 @@ def generate_audio(prompt, duration, steps, cfg_scale, seed, model_name):
     return output_path
 
 
-# ---------------------------------------------------------------------------
-# Gradio UI
-# ---------------------------------------------------------------------------
-
 with gr.Blocks(title="Respite API") as demo:
     gr.Markdown("# Respite API - Music & SFX Generation")
     gr.Markdown(
@@ -170,23 +137,16 @@ with gr.Blocks(title="Respite API") as demo:
         with gr.Column():
             model_name = gr.Dropdown(
                 choices=["small-music", "small-sfx"],
-                value="small-music",
-                label="Model",
+                value="small-music", label="Model",
             )
             prompt = gr.Textbox(
                 label="Prompt",
                 placeholder="Describe the music or sound effect you want to generate...",
                 lines=2,
             )
-            duration = gr.Slider(
-                minimum=1, maximum=120, value=30, step=1, label="Duration (seconds)"
-            )
-            steps = gr.Slider(
-                minimum=1, maximum=50, value=8, step=1, label="Steps"
-            )
-            cfg_scale = gr.Slider(
-                minimum=0.0, maximum=10.0, value=1.0, step=0.1, label="CFG Scale"
-            )
+            duration = gr.Slider(minimum=1, maximum=120, value=30, step=1, label="Duration (seconds)")
+            steps = gr.Slider(minimum=1, maximum=50, value=8, step=1, label="Steps")
+            cfg_scale = gr.Slider(minimum=0.0, maximum=10.0, value=1.0, step=0.1, label="CFG Scale")
             seed = gr.Number(value=-1, label="Seed (-1 for random)")
             btn = gr.Button("Generate", variant="primary")
 
@@ -200,43 +160,5 @@ with gr.Blocks(title="Respite API") as demo:
     )
 
 
-# ---------------------------------------------------------------------------
-# API discovery endpoints
-#
-# Use /respite/ prefix instead of /api/ to avoid collision with Gradio's
-# internal /api proxy which intercepts all /api/* requests in the
-# sdk:gradio Spaces runtime.
-# ---------------------------------------------------------------------------
-
+# This is the only thing that matters for the HF Gradio runner.
 demo.queue(max_size=4, default_concurrency_limit=1)
-
-# These decorators run at import time. demo.app is the FastAPI instance
-# underlying the Gradio Blocks. Routes registered here will be served
-# alongside the Gradio UI once the server starts.
-# NOTE: demo.app is created lazily by Gradio, so we use a startup hook
-# to register routes after the server is ready.
-import threading
-
-def _register_routes():
-    # Wait for demo.app to be available (created during launch)
-    import time
-    for _ in range(30):
-        if hasattr(demo, "app") and demo.app is not None:
-            break
-        time.sleep(1)
-
-    if not hasattr(demo, "app") or demo.app is None:
-        _log("Warning: demo.app not available, API routes not registered")
-        return
-
-    @demo.app.get("/respite/resources")
-    def resources():
-        return JSONResponse({"resources": API_RESOURCES})
-
-    @demo.app.get("/respite/specs")
-    def specs():
-        return JSONResponse({**API_SPECS, "runtime": _get_runtime_specs()})
-
-    _log("API routes registered at /respite/resources and /respite/specs")
-
-threading.Thread(target=_register_routes, daemon=True).start()