Restore working create_app monkey-patch with staticmethod

app.py

@@ -25,23 +25,21 @@ hf_token = os.environ.get("HF_TOKEN")
 if hf_token:
     login(token=hf_token)
 
-
 @spaces.GPU(duration=1)
 def _gpu_startup_touch():
     return "ok"
 
-
 try:
     _gpu_startup_touch()
 except Exception as e:
     print(f"Warning: ZeroGPU touch failed: {e}", flush=True)
 
 
-def _log(message):
-    print(message.encode("ascii", "backslashreplace").decode("ascii"), flush=True)
+def _log(msg):
+    print(msg.encode("ascii", "backslashreplace").decode("ascii"), flush=True)
 
 
-def _read_cgroup_file(path):
+def _read_cgroup(path):
     try:
         with open(path, "r", encoding="utf-8") as f:
             return f.read().strip()
@@ -50,63 +48,40 @@ def _read_cgroup_file(path):
 
 
 def _parse_cpu_count():
-    cpu_max = _read_cgroup_file("/sys/fs/cgroup/cpu.max")
-    if cpu_max:
-        parts = cpu_max.split()
-        if len(parts) == 2 and parts[0] != "max":
+    v = _read_cgroup("/sys/fs/cgroup/cpu.max")
+    if v:
+        p = v.split()
+        if len(p) == 2 and p[0] != "max":
             try:
-                quota, period = int(parts[0]), int(parts[1])
-                if period > 0:
-                    return quota // period
-            except ValueError:
-                pass
-    quota = _read_cgroup_file("/sys/fs/cgroup/cpu/cpu.cfs_quota_us")
-    period = _read_cgroup_file("/sys/fs/cgroup/cpu/cpu.cfs_period_us")
-    if quota and period:
-        try:
-            q, p = int(quota), int(period)
-            if q > 0 and p > 0:
-                return q // p
-        except ValueError:
-            pass
-    cpuset = _read_cgroup_file("/sys/fs/cgroup/cpuset.cpus")
-    if cpuset:
-        count = 0
-        for part in cpuset.split(","):
+                q, per = int(p[0]), int(p[1])
+                if per > 0: return q // per
+            except: pass
+    v = _read_cgroup("/sys/fs/cgroup/cpuset.cpus")
+    if v:
+        c = 0
+        for part in v.split(","):
             if "-" in part:
-                start, end = part.split("-", 1)
-                count += int(end) - int(start) + 1
+                s, e = part.split("-", 1)
+                c += int(e) - int(s) + 1
             else:
-                count += 1
-        if count > 0:
-            return count
+                c += 1
+        if c > 0: return c
     return os.cpu_count()
 
 
-def _parse_ram_bytes():
-    mem_max = _read_cgroup_file("/sys/fs/cgroup/memory.max")
-    if mem_max and mem_max != "max":
+def _parse_ram():
+    v = _read_cgroup("/sys/fs/cgroup/memory.max")
+    if v and v != "max":
         try:
-            val = int(mem_max)
-            if val < 2**62:
-                return val
-        except ValueError:
-            pass
-    mem_limit = _read_cgroup_file("/sys/fs/cgroup/memory/memory.limit_in_bytes")
-    if mem_limit:
-        try:
-            val = int(mem_limit)
-            if val < 2**62:
-                return val
-        except ValueError:
-            pass
+            val = int(v)
+            if val < 2**62: return val
+        except: pass
     try:
-        with open("/proc/meminfo", "r", encoding="utf-8") as meminfo:
-            for line in meminfo:
+        with open("/proc/meminfo", "r", encoding="utf-8") as f:
+            for line in f:
                 if line.startswith("MemTotal:"):
                     return int(line.split()[1]) * 1024
-    except (FileNotFoundError, OSError, ValueError):
-        pass
+    except: pass
     return None
 
 
@@ -136,8 +111,8 @@ API_RESOURCES = {
         "endpoint": "/respite/search",
         "method": "GET",
         "input": {
-            "q": "string (search query)",
-            "backend": "string: 'text' (default), 'news', or 'images'",
+            "q": "string",
+            "backend": "'text', 'news', or 'images'",
             "max_results": "integer (1-50, default 10)",
             "extract_top": "integer (0-5, default 0)",
             "region": "string (default 'wt-wt')",
@@ -165,28 +140,24 @@ API_SPECS = {
 
 def _get_runtime_specs():
     storage = shutil.disk_usage(os.getcwd())
-    hardware = os.environ.get("SPACE_HARDWARE", "zero-a10g")
-    is_zerogpu = "zero" in hardware.lower()
+    hw = os.environ.get("SPACE_HARDWARE", "zero-a10g")
+    is_zgpu = "zero" in hw.lower()
     return {
         "platform": platform.platform(),
         "python_version": platform.python_version(),
         "cpu_cores": _parse_cpu_count(),
         "host_cpu_cores": os.cpu_count(),
-        "ram_bytes": _parse_ram_bytes(),
+        "ram_bytes": _parse_ram(),
         "storage_total_bytes": storage.total,
         "storage_used_bytes": storage.used,
         "storage_free_bytes": storage.free,
-        "hardware": hardware,
-        "gpu": {
-            "type": "NVIDIA RTX Pro 6000 Blackwell",
-            "vram_bytes": 48 * 1024**3 if is_zerogpu else None,
-            "shared_zero_gpu": is_zerogpu,
-        } if is_zerogpu else None,
+        "hardware": hw,
+        "gpu": {"type": "NVIDIA RTX Pro 6000 Blackwell", "vram_bytes": 48*1024**3, "shared_zero_gpu": True} if is_zgpu else None,
     }
 
 
 # ---------------------------------------------------------------------------
-# Web search (DuckDuckGo)
+# Web search
 # ---------------------------------------------------------------------------
 
 try:
@@ -197,28 +168,23 @@ try:
         max_results = max(1, min(50, max_results))
         with DDGS() as ddgs:
             if backend == "news":
-                hits = list(ddgs.news(query, max_results=max_results, region=region))
-                results = [{"title": r.get("title", ""), "url": r.get("url", ""), "content": r.get("body", ""), "source": r.get("source", ""), "date": r.get("date", "")} for r in hits]
+                results = [{"title": r.get("title",""), "url": r.get("url",""), "content": r.get("body",""), "source": r.get("source",""), "date": r.get("date","")} for r in ddgs.news(query, max_results=max_results, region=region)]
             elif backend == "images":
-                hits = list(ddgs.images(query, max_results=max_results, region=region))
-                results = [{"title": r.get("title", ""), "url": r.get("image", ""), "source": r.get("source", ""), "thumbnail": r.get("thumbnail", ""), "width": r.get("width"), "height": r.get("height")} for r in hits]
+                results = [{"title": r.get("title",""), "url": r.get("image",""), "source": r.get("source","")} for r in ddgs.images(query, max_results=max_results, region=region)]
             else:
-                hits = list(ddgs.text(query, max_results=max_results, region=region))
-                results = [{"title": r.get("title", ""), "url": r.get("href", ""), "content": r.get("body", "")} for r in hits]
+                results = [{"title": r.get("title",""), "url": r.get("href",""), "content": r.get("body","")} for r in ddgs.text(query, max_results=max_results, region=region)]
         if extract_top > 0 and results and backend != "images":
-            urls_to_extract = [r["url"] for r in results[:extract_top] if r.get("url")]
             with DDGS() as ddgs:
-                for url in urls_to_extract:
+                for url in [r["url"] for r in results[:extract_top] if r.get("url")]:
                     try:
-                        extracted = ddgs.extract(url)
-                        page_content = extracted.get("content", "")
-                        if page_content:
+                        ex = ddgs.extract(url)
+                        ct = ex.get("content","")
+                        if ct:
                             for r in results:
                                 if r["url"] == url:
-                                    r["extracted_content"] = page_content[:8000]
+                                    r["extracted_content"] = ct[:8000]
                                     break
-                    except Exception:
-                        pass
+                    except: pass
         return {"query": query, "backend": backend, "results": results, "total_results": len(results)}
 
 except ImportError:
@@ -227,99 +193,81 @@ except ImportError:
 
 
 # ---------------------------------------------------------------------------
-# CPU LLM benchmark
+# Benchmark
 # ---------------------------------------------------------------------------
 
-_BENCHMARK_MODELS = [
+_BENCH_MODELS = [
     {"name": "Gemma 4 E4B", "repo": "unsloth/gemma-4-E4B-it-GGUF", "file": "gemma-4-E4B-it-Q4_K_M.gguf", "size_gb": 2.5},
     {"name": "Qwen3 8B", "repo": "Qwen/Qwen3-8B-GGUF", "file": "Qwen3-8B-Q4_K_M.gguf", "size_gb": 5.0},
     {"name": "Qwen3.8 27B", "repo": "unsloth/Qwen3.8-27B-GGUF", "file": "Qwen3.8-27B-Q4_0.gguf", "size_gb": 16.0},
 ]
-_BENCHMARK_CACHE = os.path.join(tempfile.gettempdir(), "llm_benchmark")
-_BENCHMARK_RESULTS = []
-_LLAMA_CPP_BIN = None
+_BENCH_CACHE = os.path.join(tempfile.gettempdir(), "llm_bench")
+_BENCH_RESULTS = []
 
 
-def _ensure_llama_cpp():
-    global _LLAMA_CPP_BIN
-    if _LLAMA_CPP_BIN and os.path.isfile(_LLAMA_CPP_BIN):
-        return _LLAMA_CPP_BIN
+def _ensure_llama():
+    d = os.path.join(_BENCH_CACHE, "bin")
+    cli = os.path.join(d, "llama-cli")
+    if os.path.isfile(cli): return cli
     import subprocess
-    os.makedirs(_BENCHMARK_CACHE, exist_ok=True)
-    bin_dir = os.path.join(_BENCHMARK_CACHE, "llama_bin")
-    llama_cli = os.path.join(bin_dir, "llama-cli")
-    if os.path.isfile(llama_cli):
-        _LLAMA_CPP_BIN = llama_cli
-        return llama_cli
-    _log("Benchmark: building llama.cpp from source...")
-    src_dir = os.path.join(_BENCHMARK_CACHE, "llama_src")
-    if os.path.isdir(src_dir):
-        shutil.rmtree(src_dir, ignore_errors=True)
-    subprocess.check_call(["git", "clone", "--depth=1", "https://github.com/ggml-org/llama.cpp.git", src_dir], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-    n_threads = _parse_cpu_count() or 8
-    build_dir = os.path.join(_BENCHMARK_CACHE, "llama_build")
-    os.makedirs(build_dir, exist_ok=True)
-    os.makedirs(bin_dir, exist_ok=True)
-    subprocess.check_call(["cmake", "-S", src_dir, "-B", build_dir, "-DLLAMA_NATIVE=ON", "-DBUILD_SHARED_LIBS=OFF"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-    subprocess.check_call(["cmake", "--build", build_dir, "-j", str(n_threads), "--target", "llama-cli"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-    import glob as _glob
-    candidates = _glob.glob(os.path.join(build_dir, "**", "llama-cli"), recursive=True)
-    if candidates:
-        shutil.copy2(candidates[0], llama_cli)
-        os.chmod(llama_cli, 0o755)
-    else:
-        raise RuntimeError("llama-cli not found after build")
-    _LLAMA_CPP_BIN = llama_cli
-    return llama_cli
-
-
-def _run_benchmark(model_filter=None):
-    global _BENCHMARK_RESULTS
-    if _BENCHMARK_RESULTS and not model_filter:
-        return _BENCHMARK_RESULTS
+    os.makedirs(d, exist_ok=True)
+    src = os.path.join(_BENCH_CACHE, "src")
+    if os.path.isdir(src): shutil.rmtree(src, ignore_errors=True)
+    _log("Building llama.cpp...")
+    subprocess.check_call(["git","clone","--depth=1","https://github.com/ggml-org/llama.cpp.git",src], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    bd = os.path.join(_BENCH_CACHE, "build")
+    os.makedirs(bd, exist_ok=True)
+    nt = _parse_cpu_count() or 8
+    subprocess.check_call(["cmake","-S",src,"-B",bd,"-DLLAMA_NATIVE=ON","-DBUILD_SHARED_LIBS=OFF"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    subprocess.check_call(["cmake","--build",bd,"-j",str(nt),"--target","llama-cli"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    import glob as _g
+    cands = _g.glob(os.path.join(bd,"**","llama-cli"), recursive=True)
+    if cands: shutil.copy2(cands[0], cli); os.chmod(cli, 0o755)
+    else: raise RuntimeError("llama-cli not found")
+    return cli
+
+
+def _run_bench(model_filter=None):
+    global _BENCH_RESULTS
+    if _BENCH_RESULTS and not model_filter: return _BENCH_RESULTS
     import subprocess, re
     from huggingface_hub import hf_hub_download
-    os.makedirs(_BENCHMARK_CACHE, exist_ok=True)
-    llama_cli = _ensure_llama_cpp()
-    n_threads = _parse_cpu_count() or 8
-    prompt = "Explain recursion in programming in 3 sentences."
-    models = [m for m in _BENCHMARK_MODELS if m["name"] == model_filter] if model_filter else _BENCHMARK_MODELS
-    if model_filter and not models:
-        raise ValueError(f"Unknown model. Available: {[m['name'] for m in _BENCHMARK_MODELS]}")
+    os.makedirs(_BENCH_CACHE, exist_ok=True)
+    cli = _ensure_llama()
+    nt = _parse_cpu_count() or 8
+    prompt = "Explain recursion in 3 sentences."
+    models = [m for m in _BENCH_MODELS if m["name"]==model_filter] if model_filter else _BENCH_MODELS
     results = []
-    for model_info in models:
-        result = {"name": model_info["name"], "status": "error"}
+    for mi in models:
+        r = {"name": mi["name"], "status": "error"}
         try:
-            model_path = hf_hub_download(repo_id=model_info["repo"], filename=model_info["file"], cache_dir=_BENCHMARK_CACHE)
+            mp = hf_hub_download(repo_id=mi["repo"], filename=mi["file"], cache_dir=_BENCH_CACHE)
             env = os.environ.copy()
-            env["LD_LIBRARY_PATH"] = os.path.dirname(llama_cli)
-            n_predict = 128 if model_info["size_gb"] <= 6 else 256
-            timeout_sec = 300 if model_info["size_gb"] <= 6 else 600
-            cmd = [llama_cli, "-m", model_path, "-t", str(n_threads), "-c", "2048", "-n", str(n_predict), "--temp", "0.7", "--top-p", "0.9", "-p", prompt, "--no-display-prompt", "--log-disable"]
+            env["LD_LIBRARY_PATH"] = os.path.dirname(cli)
+            np = 128 if mi["size_gb"]<=6 else 256
+            to = 300 if mi["size_gb"]<=6 else 600
             t0 = time.time()
-            proc = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout_sec, env=env)
-            wall_time = time.time() - t0
-            prompt_tps = gen_tps = 0.0
-            prompt_tok = gen_tok = 0
-            for line in proc.stderr.splitlines():
-                tps_m = re.search(r"(\d+\.?\d*) tokens per second", line)
-                tok_m = re.search(r"/ (\d+) tokens", line)
+            p = subprocess.run([cli,"-m",mp,"-t",str(nt),"-c","2048","-n",str(np),"--temp","0.7","--top-p","0.9","-p",prompt,"--no-display-prompt","--log-disable"], capture_output=True, text=True, timeout=to, env=env)
+            wt = time.time()-t0
+            pt=gt=0.0; ptk=gtk=0
+            for line in p.stderr.splitlines():
+                tm = re.search(r"(\d+\.?\d*) tokens per second", line)
+                km = re.search(r"/ (\d+) tokens", line)
                 if "prompt eval" in line.lower():
-                    if tps_m: prompt_tps = float(tps_m.group(1))
-                    if tok_m: prompt_tok = int(tok_m.group(1))
+                    if tm: pt=float(tm.group(1))
+                    if km: ptk=int(km.group(1))
                 elif "eval time" in line.lower() and "prompt" not in line.lower():
-                    if tps_m: gen_tps = float(tps_m.group(1))
-                    if tok_m: gen_tok = int(tok_m.group(1))
-            result.update({"status": "success", "total_time_sec": round(wall_time, 2), "prompt_tokens": prompt_tok, "completion_tokens": gen_tok, "prompt_tokens_per_sec": round(prompt_tps, 1), "generation_tokens_per_sec": round(gen_tps, 1), "output": proc.stdout.strip()[:500]})
+                    if tm: gt=float(tm.group(1))
+                    if km: gtk=int(km.group(1))
+            r.update({"status":"success","total_time_sec":round(wt,2),"prompt_tokens":ptk,"completion_tokens":gtk,"prompt_tokens_per_sec":round(pt,1),"generation_tokens_per_sec":round(gt,1),"output":p.stdout.strip()[:500]})
         except Exception as e:
-            result["error"] = str(e)
-        results.append(result)
-        import glob as _glob
-        for f in _glob.glob(os.path.join(_BENCHMARK_CACHE, "**", "*.gguf"), recursive=True):
+            r["error"] = str(e)
+        results.append(r)
+        import glob as _g
+        for f in _g.glob(os.path.join(_BENCH_CACHE,"**","*.gguf"), recursive=True):
             try: os.unlink(f)
             except: pass
-    if not model_filter:
-        _BENCHMARK_RESULTS = results
+    if not model_filter: _BENCH_RESULTS = results
     return results
 
 
@@ -329,22 +277,19 @@ def _run_benchmark(model_filter=None):
 
 MODEL_CACHE = {}
 
-
-def load_model(model_name):
-    if model_name not in MODEL_CACHE:
-        model = StableAudioModel.from_pretrained(model_name, device="cpu")
-        MODEL_CACHE[model_name] = model
-    return MODEL_CACHE[model_name]
-
+def load_model(name):
+    if name not in MODEL_CACHE:
+        MODEL_CACHE[name] = StableAudioModel.from_pretrained(name, device="cpu")
+    return MODEL_CACHE[name]
 
 def generate_audio(prompt, duration, steps, cfg_scale, seed, model_name):
     model = load_model(model_name)
     audio = model.generate(prompt=prompt, duration=duration, steps=steps, cfg_scale=cfg_scale, seed=seed, batch_size=1)
     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")
-    torchaudio.save(output_path, audio, 44100)
-    return output_path
+    out = os.path.join(tempfile.gettempdir(), f"stable_audio_{seed}_{hash(prompt)&0xFFFFFFFF:08x}.wav")
+    torchaudio.save(out, audio, 44100)
+    return out
 
 
 # ---------------------------------------------------------------------------
@@ -355,12 +300,12 @@ with gr.Blocks(title="Respite API") as demo:
     gr.Markdown("# Respite API")
     with gr.Row():
         with gr.Column():
-            model_name = gr.Dropdown(choices=["small-music", "small-sfx"], value="small-music", label="Model")
+            model_name = gr.Dropdown(choices=["small-music","small-sfx"], value="small-music", label="Model")
             prompt = gr.Textbox(label="Prompt", placeholder="Describe the audio...", lines=2)
-            duration = gr.Slider(minimum=1, maximum=120, value=30, step=1, label="Duration (seconds)")
+            duration = gr.Slider(minimum=1, maximum=120, value=30, step=1, label="Duration")
             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)")
+            seed = gr.Number(value=-1, label="Seed (-1=random)")
             btn = gr.Button("Generate", variant="primary")
         with gr.Column():
             audio_output = gr.Audio(label="Generated Audio", type="filepath")
@@ -368,72 +313,48 @@ with gr.Blocks(title="Respite API") as demo:
 
 
 # ---------------------------------------------------------------------------
-# After Gradio is launched, inject routes into the running server.
-#
-# Strategy: Gradio blocks while the server runs, so we start a thread that
-# waits for the server to be ready, then adds our routes to it.
+# Monkey-patch: intercept Gradio App creation to inject routes
 # ---------------------------------------------------------------------------
 
-def _inject_routes():
-    """Wait for Gradio server to start, then add API routes."""
-    for attempt in range(60):
-        time.sleep(2)
-        # demo.server is set after launch() starts uvicorn
-        server = getattr(demo, "server", None)
-        if server is None:
-            continue
-        app = getattr(server, "app", None)
-        if app is None:
-            continue
-        _log(f"Injecting routes (attempt {attempt+1})...")
+from gradio.routes import App as GradioApp
+
+_orig_create_app = GradioApp.create_app
+
+
+def _patched_create_app(blocks, **kwargs):
+    fa_app = _orig_create_app(blocks, **kwargs)
+
+    @fa_app.get("/respite/resources")
+    def _r(): return JSONResponse({"resources": API_RESOURCES})
+
+    @fa_app.get("/respite/specs")
+    def _s(): return JSONResponse({**API_SPECS, "runtime": _get_runtime_specs()})
+
+    @fa_app.get("/respite/search")
+    def _q(q: str="", backend: str="text", max_results: int=10, extract_top: int=0, region: str="wt-wt"):
+        if not q: return JSONResponse({"error":"Missing 'q'"}, status_code=400)
+        try: return JSONResponse(_search_web(q, backend=backend, max_results=max_results, extract_top=extract_top, region=region))
+        except Exception as e: return JSONResponse({"error": str(e)}, status_code=502)
+
+    @fa_app.get("/respite/benchmark")
+    def _b(force: bool=False, model: str=""):
         try:
-            # Add all API routes
-            from fastapi import Request as _Req
-
-            @app.get("/respite/resources")
-            async def _resources():
-                return JSONResponse({"resources": API_RESOURCES})
-
-            @app.get("/respite/specs")
-            async def _specs():
-                return JSONResponse({**API_SPECS, "runtime": _get_runtime_specs()})
-
-            @app.get("/respite/search")
-            async def _search(q: str = "", backend: str = "text", max_results: int = 10, extract_top: int = 0, region: str = "wt-wt"):
-                if not q:
-                    return JSONResponse({"error": "Missing 'q' parameter"}, status_code=400)
-                try:
-                    return JSONResponse(_search_web(q, backend=backend, max_results=max_results, extract_top=extract_top, region=region))
-                except Exception as e:
-                    return JSONResponse({"error": str(e)}, status_code=502)
-
-            @app.get("/respite/benchmark")
-            async def _benchmark(force: bool = False, model: str = ""):
-                try:
-                    global _BENCHMARK_RESULTS
-                    if force:
-                        _BENCHMARK_RESULTS = []
-                    results = _run_benchmark(model_filter=model.strip() or None)
-                    return JSONResponse({"status": "complete", "models": results, "system": {"cpu_cores": _parse_cpu_count(), "ram_bytes": _parse_ram_bytes(), "threads": _parse_cpu_count() or 8}})
-                except Exception as e:
-                    return JSONResponse({"error": str(e)}, status_code=500)
-
-            _log("Routes injected into running server!")
-            return
-        except Exception as e:
-            _log(f"Route injection failed: {e}")
-    _log("WARNING: Could not inject routes after 120s")
+            global _BENCH_RESULTS
+            if force: _BENCH_RESULTS = []
+            results = _run_bench(model_filter=model.strip() or None)
+            return JSONResponse({"status":"complete","models":results,"system":{"cpu_cores":_parse_cpu_count(),"ram_bytes":_parse_ram(),"threads":_parse_cpu_count() or 8}})
+        except Exception as e: return JSONResponse({"error": str(e)}, status_code=500)
+
+    _log("Routes injected via create_app monkey-patch")
+    return fa_app
 
 
-# Start route injection in background
-_inject_thread = threading.Thread(target=_inject_routes, daemon=True)
-_inject_thread.start()
+GradioApp.create_app = _patched_create_app
 
 # Disable file watcher
 import gradio.utils as _gr_utils
 if hasattr(_gr_utils, "watchfn_spaces"):
     _gr_utils.watchfn_spaces = lambda *a, **kw: None
 
-_log("Starting Gradio server...")
 demo.queue(max_size=4, default_concurrency_limit=1)
-demo.launch()
+demo.launch(ssr_mode=False)