Spaces:
Paused
Paused
File size: 7,054 Bytes
6f76256 c8d9009 61657d1 520c7b3 6f76256 c8d9009 6f76256 450c3f0 6f76256 c8d9009 6f76256 450c3f0 6f76256 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 | """Run allow-listed public Gradio Spaces server-side with the signed-in user's OAuth token
(user's own ZeroGPU / Space quota). Streams status + data as SSE. Result files are kept in a
short-lived tmp store (/api/tmp/<id>/<name>) – never the token. Anonymous users get 401 → frontend
falls back to the anonymous browser client."""
import asyncio, json, os, secrets, shutil, tempfile, time, threading, mimetypes
from pathlib import Path
from fastapi import APIRouter, Request, HTTPException, UploadFile
from fastapi.responses import StreamingResponse, FileResponse
from gradio_client import Client, handle_file
ALLOW = { # space -> allowed endpoints (Module API backends)
"huggingface-projects/llama-3.2-3B-Instruct": {"/generate"},
"black-forest-labs/FLUX.1-schnell": {"/infer"},
"black-forest-labs/FLUX.1-Kontext-Dev": {"/infer"},
"ACE-Step/ACE-Step": {"/__call__"},
"declare-lab/TangoFlux": {"/predict"},
"abidlabs/music-separation": {"/inference"},
"Lightricks/ltx-video-distilled": {"/text_to_video"},
"multimodalart/MoDA-fast-talking-head": {"/generate_motion"},
"pragnakalp/Wav2lip-ZeroGPU": {"/run_infrence"},
"Qwen/Qwen3-TTS": {"/generate_voice_design", "/generate_voice_clone"},
}
PATH_ARGS = {("Lightricks/ltx-video-distilled", "/text_to_video"): {"input_image_filepath", "input_video_filepath"}} # str-typed filepath args: upload to the Space, pass its server path
TMP: dict[str, tuple[str, float]] = {}
TMPDIR = Path(tempfile.gettempdir()) / "studius-tmp"; TMPDIR.mkdir(exist_ok=True)
CLIENTS: dict[tuple, tuple[Client, float]] = {}
router = APIRouter()
def tmp_put(src: str) -> str:
now = time.time()
for k, (p, e) in list(TMP.items()):
if e < now: TMP.pop(k, None); shutil.rmtree(Path(p).parent, ignore_errors=True)
i = secrets.token_urlsafe(18); d = TMPDIR / i; d.mkdir()
dst = d / Path(src).name; shutil.copy(src, dst); TMP[i] = (str(dst), now + 3600)
return f"/api/tmp/{i}/{dst.name}"
def tmp_path(url: str):
try: _, _, _, i, _ = url.split("/", 4)
except ValueError: return None
v = TMP.get(i)
if not v and i and "/" not in i and ".." not in i: # survive process restarts: re-index from disk (< 1 h old)
d = TMPDIR / i
if d.is_dir():
fs = [f for f in d.iterdir() if f.is_file()]
if fs and fs[0].stat().st_mtime + 3600 > time.time(): TMP[i] = v = (str(fs[0]), fs[0].stat().st_mtime + 3600)
return v[0] if v and v[1] > time.time() else None
def client(space, token):
k = (space, token); c = CLIENTS.get(k)
if c and c[1] > time.time(): return c[0]
for kk, (_, e) in list(CLIENTS.items()):
if e < time.time(): CLIENTS.pop(kk, None)
cl = Client(space, hf_token=token, verbose=False, download_files=str(TMPDIR / "dl")); CLIENTS[k] = (cl, time.time() + 900); return cl
def conv(x): # gradio outputs → JSON (files → tmp URLs)
if isinstance(x, (list, tuple)): return [conv(v) for v in x]
if isinstance(x, dict):
if x.get("path") and os.path.exists(str(x["path"])): return {"url": tmp_put(x["path"])}
return {k: conv(v) for k, v in x.items()}
if isinstance(x, str) and x.startswith(str(Path(tempfile.gettempdir()))) and os.path.isfile(x): return {"url": tmp_put(x)}
return x
def make_router(session):
@router.post("/api/run")
async def run(req: Request):
s = session(req)
if not s: raise HTTPException(401, "not signed in")
form = await req.form(); space = form.get("space"); ep = form.get("ep")
if ep not in ALLOW.get(space, ()): raise HTTPException(400, "space/endpoint not allowed")
args = json.loads(form.get("args") or "{}"); tmpd = tempfile.mkdtemp(dir=TMPDIR)
for k, v in list(args.items()): # {"__file__": "f0"} placeholders → uploaded parts
if isinstance(v, dict) and "__file__" in v:
up: UploadFile = form.get(v["__file__"]); p = Path(tmpd) / Path(up.filename or "in.bin").name
p.write_bytes(await up.read()); args[k] = handle_file(str(p))
elif isinstance(v, dict) and "__tmp__" in v:
p = tmp_path(v["__tmp__"]);
if not p: raise HTTPException(400, "tmp file expired")
args[k] = handle_file(p)
timeout = min(float(form.get("timeout") or 240), 600); tok = s["token"]
for k in PATH_ARGS.get((space, ep), ()):
v = args.get(k)
if isinstance(v, dict) and v.get("path"): # handle_file() result -> upload to the Space's /gradio_api/upload
c = client(space, tok); base = c.src.rstrip("/")
import httpx as _hx
with open(v["path"], "rb") as fh:
r = _hx.post(f"{base}/gradio_api/upload", files={"files": (Path(v["path"]).name, fh)}, headers={"Authorization": f"Bearer {tok}"}, timeout=120)
if r.status_code != 200: raise HTTPException(502, f"upload to space failed: HTTP {r.status_code}")
args[k] = r.json()[0]
q: asyncio.Queue = asyncio.Queue(); loop = asyncio.get_running_loop()
def worker():
emit = lambda e: loop.call_soon_threadsafe(q.put_nowait, e)
try:
job = client(space, tok).submit(**args, api_name=ep); t0 = time.time(); seen = 0; last = None
while not job.done():
if time.time() - t0 > timeout: job.cancel(); raise TimeoutError(f"Zeitüberschreitung nach {int(timeout)} s")
st = job.status(); outs = job.outputs()
for o in outs[seen:]: emit({"type": "data", "data": conv(o)})
seen = len(outs)
sd = {"type": "status", "stage": {"PROCESSING": "generating", "ITERATING": "generating"}.get(st.code.name, "pending"), "position": st.rank, "queue_size": st.queue_size, "eta": st.eta}
if sd != last: emit(sd); last = sd
time.sleep(0.25)
res = job.result(); emit({"type": "data", "data": conv(res)}); emit({"type": "done"})
except Exception as e:
emit({"type": "error", "message": str(e).split("\n")[0][:400]})
finally:
shutil.rmtree(tmpd, ignore_errors=True); emit(None)
threading.Thread(target=worker, daemon=True).start()
async def gen():
while True:
e = await q.get()
if e is None: break
yield f"data: {json.dumps(e)}\n\n"
if await req.is_disconnected(): break
return StreamingResponse(gen(), media_type="text/event-stream", headers={"Cache-Control": "no-store", "X-Accel-Buffering": "no"})
@router.get("/api/tmp/{i}/{name}")
def tmp_file(i: str, name: str):
p = tmp_path(f"/api/tmp/{i}/{name}")
if not p or Path(p).name != name: raise HTTPException(404)
return FileResponse(p, media_type=mimetypes.guess_type(name)[0] or "application/octet-stream", headers={"Cache-Control": "private, max-age=3600"})
return router
|