Restore real app (Blocks + mount + uvicorn 7860); space now public

app.py

@@ -1,138 +1,57 @@
-import spaces  # MUST be first
+"""
+HF Playground — code-driven model playground.
+Enter any HuggingFace model ID in a code template and run.
+"""
+import spaces  # MUST be first — signals ZeroGPU infrastructure
+
+import sys
+import asyncio
 
-import os
 import gradio as gr
 
+from api import build_fastapi_app
+from ui import build_app, theme, CSS
 
+# ZeroGPU startup probe. The runtime scans Gradio's *registered event handlers*
+# for a @spaces.GPU-marked function and refuses to start if none is found, so this
+# probe is wired to demo.load() below. The real work (run_custom_code) stays
+# undecorated so it runs in-process — models are CPU-bound and the sandbox needs
+# threads + queues that would break inside a forked ZeroGPU worker.
 @spaces.GPU(duration=10)
 def _gpu_probe():
     return None
 
 
-with gr.Blocks(title="DIAG") as demo:
-    gr.Markdown("DIAG MODE")
-    demo.load(fn=_gpu_probe)
-
-
-def _fmt_ino():
-    ino = {}
-    for pid in os.listdir("/proc"):
-        if not pid.isdigit():
-            continue
-        try:
-            for fd in os.listdir(f"/proc/{pid}/fd"):
-                try:
-                    t = os.readlink(f"/proc/{pid}/fd/{fd}")
-                except OSError:
-                    continue
-                if t.startswith("socket:["):
-                    ino[t[8:-1]] = pid
-        except OSError:
-            continue
-    return ino
-
-
-def _procinfo(pid):
-    try:
-        with open(f"/proc/{pid}/comm") as f:
-            comm = f.read().strip()
-    except OSError:
-        return None
-    try:
-        with open(f"/proc/{pid}/cmdline") as f:
-            cmd = f.read().replace("\x00", " ").strip()[:200]
-    except OSError:
-        cmd = ""
-    try:
-        with open(f"/proc/{pid}/stat") as f:
-            ppid = f.read().split()[3]
-    except OSError:
-        ppid = "?"
-    return f"{pid}:{comm}(pp={ppid})|{cmd}"
-
-
-def _dump_env(pid):
-    try:
-        with open(f"/proc/{pid}/environ") as f:
-            env = f.read().replace("\x00", "\n")
-    except OSError:
-        return
-    picks = {}
-    for line in env.splitlines():
-        k, _, v = line.partition("=")
-        if k in (
-            "GRADIO_SSR_MODE", "PORT", "GRADIO_SERVER_PORT", "GRADIO_SERVER_NAME",
-            "SPACES_ZERO_GPU", "SPACES_ZERO_DEVICE_API_URL", "ZEROGPU_V2",
-            "GRADIO_NODE_PATH", "GRADIO_OFFICIAL_EXAMPLE", "SSH_CONNECTION",
-        ):
-            picks[k] = v
-    print(f"DIAGENV{pid} " + " ".join(f"{k}={v}" for k, v in picks.items()))
-
-
-def _dump_env_diff():
+# Python 3.10 asyncio cleanup fix: suppress "Invalid file descriptor: -1" on shutdown
+if sys.version_info >= (3, 10) and sys.platform == 'linux':
     try:
-        e1 = open("/proc/1/environ").read().replace("\x00", "\n").splitlines()
-        e2 = open("/proc/224/environ").read().replace("\x00", "\n").splitlines()
-        d1, d2 = dict(l.split("=", 1) for l in e1 if "=" in l), dict(l.split("=", 1) for l in e2 if "=" in l)
-        only1 = sorted(set(d1) - set(d2))
-        only2 = sorted(set(d2) - set(d1))
-        print("DIAGDIFF only1=" + ",".join(only1) if only1 else "DIAGDIFF only1=none")
-        print("DIAGDIFF only2=" + ",".join(only2) if only2 else "DIAGDIFF only2=none")
-    except OSError:
+        _cls = asyncio.selector_events.BaseSelectorEventLoop
+        _orig = _cls._close_self_pipe
+        def _safe_close_self_pipe(self):
+            try:
+                _orig(self)
+            except ValueError:
+                pass
+        _cls._close_self_pipe = _safe_close_self_pipe
+    except Exception:
         pass
 
 
-def _listeners():
-    ino = _fmt_ino()
-    import socket as sk
-    out = []
-    for proto in ("/proc/net/tcp", "/proc/net/tcp6"):
-        try:
-            with open(proto) as f:
-                next(f)
-                for line in f:
-                    p = line.split()
-                    if len(p) < 10 or p[3] != "0A":
-                        continue
-                    ip_hex, port_hex = p[1].split(":")
-                    af = sk.AF_INET6 if proto.endswith("6") else sk.AF_INET
-                    ip = sk.inet_ntop(af, bytes.fromhex(ip_hex))
-                    port = int(port_hex, 16)
-                    out.append((ip, port, ino.get(p[9], "?")))
-        except OSError:
-            continue
-    return out
-
-
-def _dump():
-    print("DIAGENV " + " ".join(
-        f"{k}={os.environ.get(k)}" for k in (
-            "GRADIO_SSR_MODE", "PORT", "GRADIO_SERVER_PORT",
-            "GRADIO_SERVER_NAME", "GRADIO_NODE_PATH", "SPACES_ZERO_GPU",
-            "SPACES_ZERO_DEVICE_API_URL", "ZEROGPU_V2",
-            "GRADIO_NUM_WORKERS", "NODE_PATH", "HOME",
-        )
-    ))
-    print("DIAGPROC " + " | ".join(x for x in (
-        _procinfo(p) for p in ("1", "2", "224", "239", "7860")
-    ) if x))
-    _dump_env("1")
-    _dump_env("224")
-    print("DIAGL " + " | ".join(f"{ip}:{port}={owner}" for ip, port, owner in _listeners()))
-
+with gr.Blocks(title="HF Model Playground") as demo:
+    build_app()
+    demo.load(fn=_gpu_probe, trigger_mode="once")
 
-demo.launch(server_name="0.0.0.0", prevent_thread_lock=True)
+# ZeroGPU client registration happens on the first Blocks.launch() call
+# (spaces.zero wraps gr.Blocks.launch to send the startup report to the device
+# API). Launch once on a throwaway port to trigger that registration, then
+# immediately close it. The real server starts below via uvicorn on 7860 and
+# serves both the Gradio UI and the OpenAI-compatible /v1 routes.
+demo.launch(prevent_thread_lock=True, server_name=None, server_port=8000, quiet=True)
+demo.close()
 
-_dump()
-_dump_env_diff()
+fastapi_app = build_fastapi_app()
+app = gr.mount_gradio_app(fastapi_app, demo, path="/", theme=theme, css=CSS)
 
-import time
-time.sleep(20)
-print("DIAGL2 " + " | ".join(
-    f"{ip}:{port}={owner}" for ip, port, owner in _listeners()
-))
-if os.path.exists("/proc/224"):
-    print("DIAG224 alive after 20s")
-else:
-    print("DIAG224 EXITED")
-time.sleep(3600)
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)