Declare @spaces.GPU functions so ZeroGPU will start the Space

ZeroGPU refuses to start a Space with no decorated function - 'No @spaces.GPU
function detected during startup' - which is why hardware.current stayed None
from the first build. Move the model calls into decorated functions, since
that is the only window in which a device is actually attached, and default
to cuda when the spaces package is importable.

app.py

@@ -36,9 +36,21 @@ SAMPLE_RATE = 16000
 CHUNK_LENGTH_S = float(os.environ.get("CHUNK_LENGTH_S", "30"))
 STRIDE_LENGTH_S = float(os.environ.get("STRIDE_LENGTH_S", "5"))
 MT_BATCH = int(os.environ.get("MT_BATCH", "16"))
-# "cpu" rather than the old -1: transformers 5 takes a device string. Set
-# ASR_DEVICE=cuda:0 if this ever runs on real GPU hardware.
-DEVICE = os.environ.get("ASR_DEVICE", "cpu")
+# ZeroGPU hands out a GPU only inside @spaces.GPU functions, and refuses to
+# start a Space that declares none ("No @spaces.GPU function detected during
+# startup"). Importing spaces also tells us we are on that hardware, so the
+# device default follows it.
+try:
+    import spaces
+    _GPU = spaces.GPU(duration=int(os.environ.get("GPU_DURATION", "120")))
+    _ON_ZEROGPU = True
+except Exception:                             # local runs, or a plain CPU host
+    _ON_ZEROGPU = False
+
+    def _GPU(fn):
+        return fn
+
+DEVICE = os.environ.get("ASR_DEVICE", "cuda" if _ON_ZEROGPU else "cpu")
 
 # Gradio owns the process on a Gradio-SDK Space, but it is a FastAPI app
 # underneath — so the REST routes below are the real interface and the little UI
@@ -160,6 +172,20 @@ def _words_from_chunks(chunks, audio_secs: float):
     return words
 
 
+@_GPU
+def _asr_run(audio, gen):
+    """Decoding, on the GPU when ZeroGPU has granted one."""
+    pipe = _load("asr")
+    try:
+        return pipe(audio.copy(), return_timestamps="word", generate_kwargs=gen), True
+    except Exception as e:
+        # Word timings need alignment_heads in the generation config. Fine-tunes
+        # frequently drop them; phrase-level timings still make usable cues.
+        print(f"word timestamps unavailable ({type(e).__name__}: {e}) — phrase level",
+              flush=True)
+        return pipe(audio.copy(), return_timestamps=True, generate_kwargs=gen), False
+
+
 @app.post("/asr")
 async def asr(request: Request, x_service_token: str = Header(default=None)):
     _auth(x_service_token)
@@ -169,7 +195,6 @@ async def asr(request: Request, x_service_token: str = Header(default=None)):
 
     audio = _decode(raw)
     audio_secs = len(audio) / float(SAMPLE_RATE)
-    pipe = _load("asr")
 
     # language/task are forced because a fine-tune sometimes ships a generation
     # config still defaulting to English transcription, which silently produces
@@ -177,16 +202,7 @@ async def asr(request: Request, x_service_token: str = Header(default=None)):
     gen = {"language": "ha", "task": "transcribe"}
 
     t0 = time.time()
-    word_level = True
-    try:
-        out = pipe(audio.copy(), return_timestamps="word", generate_kwargs=gen)
-    except Exception as e:
-        # Word timings need alignment_heads in the generation config. Fine-tunes
-        # frequently drop them; phrase-level timings still make usable cues.
-        print(f"word timestamps unavailable ({type(e).__name__}: {e}) — phrase level",
-              flush=True)
-        word_level = False
-        out = pipe(audio.copy(), return_timestamps=True, generate_kwargs=gen)
+    out, word_level = _asr_run(audio, gen)
 
     words = _words_from_chunks(out.get("chunks"), audio_secs)
     print(f"asr {audio_secs:.1f}s audio -> {len(words)} words in {time.time() - t0:.1f}s "
@@ -205,6 +221,11 @@ class TranslateIn(BaseModel):
     texts: list[str]
 
 
+@_GPU
+def _mt_run(texts):
+    return _load("mt")(texts, batch_size=MT_BATCH, truncation=True)
+
+
 @app.post("/translate")
 def translate(body: TranslateIn, x_service_token: str = Header(default=None)):
     _auth(x_service_token)
@@ -212,13 +233,12 @@ def translate(body: TranslateIn, x_service_token: str = Header(default=None)):
     if not texts:
         return {"translations": []}
 
-    pipe = _load("mt")
     # Blank inputs are held out and reinserted: MarianMT will happily emit a
     # hallucinated sentence for an empty string.
     idx = [i for i, t in enumerate(texts) if (t or "").strip()]
     out = [""] * len(texts)
     if idx:
-        res = pipe([texts[i] for i in idx], batch_size=MT_BATCH, truncation=True)
+        res = _mt_run([texts[i] for i in idx])
         for i, r in zip(idx, res):
             out[i] = (r.get("translation_text") or "").strip()
     return {"translations": out}