Use direct ZeroGPU queue for synthesis

app.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import hashlib
+import json
 import os
 import shutil
 import time
@@ -11,7 +12,6 @@ from typing import Any
 import requests
 from fastapi import FastAPI, HTTPException, Query, Request
 from fastapi.responses import FileResponse, JSONResponse
-from gradio_client import Client
 
 ZERO_SPACE = os.getenv("ZERO_SPACE", "schroneko/irodori-tts-zerogpu")
 HF_TOKEN = os.getenv("HF_TOKEN", "")
@@ -53,16 +53,70 @@ def _seed_for_speaker(speaker: str) -> str:
     return str(value)
 
 
-def _zero_client(x_ip_token: str = "") -> Client:
-    headers: dict[str, str] = {}
+def _zero_space_base_url() -> str:
+    space = ZERO_SPACE.strip().rstrip("/")
+    if space.startswith("http://") or space.startswith("https://"):
+        return space
+    return f"https://{space.replace('/', '-')}.hf.space"
+
+
+def _zero_headers(x_ip_token: str = "") -> dict[str, str]:
+    headers = {"Content-Type": "application/json"}
     if HF_TOKEN:
         headers["Authorization"] = f"Bearer {HF_TOKEN}"
     if x_ip_token:
         headers["x-ip-token"] = x_ip_token
-    return Client(ZERO_SPACE, token=HF_TOKEN or None, headers=headers)
+    return headers
+
+
+def _raise_for_response(response: requests.Response) -> None:
+    if response.ok:
+        return
+    detail = response.text.strip()
+    raise RuntimeError(f"ZeroGPU request failed: {response.status_code} {detail}")
 
 
-def _copy_result_file(result: Any) -> Path:
+def _predict_zero_space(payload: dict[str, Any], x_ip_token: str = "") -> Any:
+    base_url = _zero_space_base_url()
+    response = requests.post(
+        f"{base_url}/gradio_api/call/v2/synthesize",
+        json=payload,
+        headers=_zero_headers(x_ip_token),
+        timeout=30,
+    )
+    _raise_for_response(response)
+    event_id = response.json().get("event_id")
+    if not event_id:
+        raise RuntimeError(f"ZeroGPU did not return event_id: {response.text}")
+
+    response = requests.get(
+        f"{base_url}/gradio_api/call/synthesize/{event_id}",
+        headers=_zero_headers(x_ip_token),
+        stream=True,
+        timeout=(10, 300),
+    )
+    _raise_for_response(response)
+
+    event_name = ""
+    for line in response.iter_lines(decode_unicode=True):
+        if not line:
+            continue
+        if line.startswith("event:"):
+            event_name = line.split(":", 1)[1].strip()
+            continue
+        if not line.startswith("data:"):
+            continue
+        data = line.split(":", 1)[1].strip()
+        if event_name == "error":
+            raise RuntimeError(data)
+        parsed = json.loads(data)
+        if event_name == "complete":
+            return parsed
+
+    raise RuntimeError("ZeroGPU stream ended before completion")
+
+
+def _copy_result_file(result: Any, x_ip_token: str = "") -> Path:
     source: str | None = None
     if isinstance(result, (list, tuple)) and result:
         source = result[0]
@@ -79,9 +133,8 @@ def _copy_result_file(result: Any) -> Path:
     output_path = OUTPUT_DIR / f"{int(time.time() * 1000)}_{uuid.uuid4().hex}.mp3"
     source_text = str(source)
     if source_text.startswith("http://") or source_text.startswith("https://"):
-        response = requests.get(source_text, timeout=60)
-        if not response.ok:
-            raise RuntimeError(f"Generated audio download failed: {response.status_code} {response.text.strip()}")
+        response = requests.get(source_text, headers=_zero_headers(x_ip_token), timeout=60)
+        _raise_for_response(response)
         output_path.write_bytes(response.content)
         return output_path
 
@@ -139,18 +192,20 @@ def synthesis(
     try:
         x_ip_token = request.headers.get("x-ip-token", "").strip()
         seed_value = str(seed).strip() or _seed_for_speaker(str(speaker))
-        result = _zero_client(x_ip_token).predict(
-            text=text,
-            speaker=str(speaker),
-            seconds=str(seconds),
-            duration_scale=float(duration_scale),
-            steps=int(steps),
-            seed=seed_value,
-            caption=str(caption).strip() or DEFAULT_CAPTION,
-            api_name="/synthesize",
+        result = _predict_zero_space(
+            {
+                "text": text,
+                "speaker": str(speaker),
+                "seconds": str(seconds),
+                "duration_scale": float(duration_scale),
+                "steps": int(steps),
+                "seed": seed_value,
+                "caption": str(caption).strip() or DEFAULT_CAPTION,
+            },
+            x_ip_token=x_ip_token,
         )
         metadata = _result_metadata(result)
-        output_path = _copy_result_file(result)
+        output_path = _copy_result_file(result, x_ip_token=x_ip_token)
     except Exception as exc:
         return JSONResponse(
             status_code=502,

requirements.txt

@@ -1,4 +1,3 @@
 fastapi>=0.115.0
 uvicorn[standard]>=0.30.0
-gradio_client>=2.5.0
 requests>=2.32.0