Update app.py

app.py

@@ -1,31 +1,21 @@
-import os, io, json, time, tarfile, subprocess, urllib.request
+import os, io, json
 from pathlib import Path
 
 import gradio as gr
 import spaces
-import httpx
 import edge_tts
-from huggingface_hub import hf_hub_download
-
-# ===== 0. CONFIG (override in Space Settings → Variables and secrets) =====
-LLAMA_TAG  = os.environ.get("LLAMA_TAG", "")            # pin e.g. "b8407"; "" = latest
-MODEL_REPO = os.environ.get("MODEL_REPO", "Abiray/MiniCPM5-1B-GGUF")
-MODEL_FILE = os.environ.get("MODEL_FILE", "minicpm5-1b-Q6_K.gguf")
-CTX_SIZE   = int(os.environ.get("CTX_SIZE", "8192"))
-PARALLEL   = int(os.environ.get("PARALLEL", "2"))
-LLAMA_PORT = int(os.environ.get("LLAMA_PORT", "8080"))  # internal only
-API_KEY    = os.environ.get("LLAMA_API_KEY", "")        # SET THIS as a Space secret!
-SYSTEM_PROMPT = os.environ.get("SYSTEM_PROMPT", "You are a helpful AI assistant.")
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import Response, StreamingResponse, JSONResponse
 
-# ===== 1. HOLD THE ZEROGPU HARDWARE (~5s of quota, once, at boot) =====
+# ===== 1. ZEROGPU CPU/RAM MAXIMIZER =====
 @spaces.GPU(duration=5)
 def _hold_zerogpu():
-    print("[zerogpu] host claimed; GPU slice released, CPU+RAM stay ours.")
+    print("[zerogpu] claimed host; GPU slice released, CPU+RAM stay ours.")
     return True
 
 _hold_zerogpu()
 
-# ===== 2. READ THE "DYNAMIC" CPU/RAM WE ACTUALLY GOT (cgroup truth) =====
 def effective_cpus() -> int:
     try:
         quota, period = Path("/sys/fs/cgroup/cpu.max").read_text().split()[:2]
@@ -50,130 +40,8 @@ def memory_limit_gb():
 CORES = effective_cpus()
 print(f"[resources] effective cores: {CORES} | RAM limit: {memory_limit_gb() or '?'} GB")
 
-# ===== 3. FETCH PREBUILT llama.cpp =====
-FALLBACK_TAG = "b8407"
-
-def resolve_tag() -> str:
-    if LLAMA_TAG:
-        return LLAMA_TAG
-    try:
-        req = urllib.request.Request(
-            "https://api.github.com/repos/ggml-org/llama.cpp/releases/latest",
-            headers={"User-Agent": "hf-space"})
-        with urllib.request.urlopen(req, timeout=10) as r:
-            return json.load(r)["tag_name"]
-    except Exception as e:
-        print(f"[llama.cpp] latest-tag lookup failed ({e}); pinned fallback {FALLBACK_TAG}")
-        return FALLBACK_TAG
-
-def ensure_llama_server() -> Path:
-    tag = resolve_tag()
-    root = Path.home() / ".cache" / "llamacpp" / tag
-    server = root / "build" / "bin" / "llama-server"
-    if not server.exists():
-        url = (f"https://github.com/ggml-org/llama.cpp/releases/download/"
-               f"{tag}/llama-{tag}-bin-ubuntu-x64.tar.gz")
-        print(f"[llama.cpp] downloading {url}")
-        req = urllib.request.Request(url, headers={"User-Agent": "hf-space"})
-        with urllib.request.urlopen(req, timeout=180) as r:
-            blob = r.read()
-        root.mkdir(parents=True, exist_ok=True)
-        with tarfile.open(fileobj=io.BytesIO(blob), mode="r:gz") as t:
-            t.extractall(root)
-        for f in (root / "build" / "bin").iterdir():
-            f.chmod(0o755)
-    return server
-
-# ===== 4. MODEL =====
-print(f"[model] downloading {MODEL_REPO}/{MODEL_FILE}")
-model_path = hf_hub_download(repo_id=MODEL_REPO, filename=MODEL_FILE)
-
-# ===== 5. LAUNCH llama-server =====
-server_bin = ensure_llama_server()
-UPSTREAM = f"http://127.0.0.1:{LLAMA_PORT}"
-
-env = os.environ.copy()
-env["LD_LIBRARY_PATH"] = f"{server_bin.parent}:{env.get('LD_LIBRARY_PATH', '')}"
-env.setdefault("HF_HUB_ENABLE_HF_TRANSFER", "1")
-
-cmd = [
-    str(server_bin), "-m", model_path,
-    "--host", "127.0.0.1", "--port", str(LLAMA_PORT),
-    "-t", str(CORES), "-tb", str(CORES),
-    "-c", str(CTX_SIZE),
-    "-np", str(PARALLEL),
-    "-fa",
-    "--cache-reuse", "256",
-]
-if API_KEY:
-    cmd += ["--api-key", API_KEY]
-
-proc = subprocess.Popen(cmd, env=env)
-
-def wait_ready(timeout=600):
-    t0 = time.time()
-    while time.time() - t0 < timeout:
-        if proc.poll() is not None:
-            raise RuntimeError(f"llama-server died early (code {proc.returncode})")
-        try:
-            if httpx.get(f"{UPSTREAM}/health", timeout=2).status_code == 200:
-                print("[llama.cpp] server ready")
-                return
-        except Exception:
-            pass
-        time.sleep(1)
-    raise TimeoutError("llama-server not ready in time")
-
-wait_ready()
-
-# ===== 6. GRADIO UI =====
-from openai import OpenAI
-oai = OpenAI(base_url=f"{UPSTREAM}/v1", api_key=API_KEY or "not-needed")
-
-def _normalize(history):
-    msgs = [{"role": "system", "content": SYSTEM_PROMPT}]
-    for item in history:
-        if isinstance(item, dict):
-            msgs.append({"role": item["role"], "content": item["content"]})
-        else:
-            user, bot = item
-            msgs.append({"role": "user", "content": user})
-            if bot:
-                msgs.append({"role": "assistant", "content": bot})
-    return msgs
-
-def chat(message, history):
-    stream = oai.chat.completions.create(
-        model="local",
-        messages=_normalize(history) + [{"role": "user", "content": message}],
-        stream=True, temperature=0.7, max_tokens=1024,
-    )
-    out = ""
-    for chunk in stream:
-        delta = chunk.choices[0].delta.content
-        if delta:
-            out += delta
-            yield out
-
-with gr.Blocks() as demo:
-    gr.Markdown(
-        f"# ⚡ llama.cpp + Edge-TTS API on ZeroGPU's CPU\n"
-        f"`{MODEL_REPO}` · {CORES} threads · ctx {CTX_SIZE}\n\n"
-        f"**Endpoints Available:**\n"
-        f"- `POST /v1/chat/completions` (LLM Chat)\n"
-        f"- `GET/POST /tts` (Microsoft Edge Text-to-Speech Stream)\n"
-        f"- `GET /tts/voices` (List Edge TTS Voices)"
-    )
-    gr.ChatInterface(fn=chat, examples=["Who are you?", "Tell me a fast joke."])
-
-demo = demo.queue()
-
-# ===== 7. FASTAPI PROXY & EDGE-TTS ENDPOINTS =====
-from fastapi import FastAPI, Request
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import Response, StreamingResponse, JSONResponse
-
-app = FastAPI(title="llama-cpp-edgetts-proxy")
+# ===== 2. FASTAPI SERVER & CORS SETUP =====
+app = FastAPI(title="Edge-TTS-Server")
 app.add_middleware(
     CORSMiddleware, 
     allow_origins=["*"], 
@@ -181,9 +49,8 @@ app.add_middleware(
     allow_methods=["*"], 
     allow_headers=["*"]
 )
-_http = httpx.AsyncClient(timeout=httpx.Timeout(None))
 
-# Helper functions to normalize speed and pitch for EdgeTTS
+# ===== 3. PARAMETER NORMALIZERS =====
 def format_rate(rate_input):
     if rate_input is None:
         return "+0%"
@@ -209,15 +76,17 @@ def format_pitch(pitch_input):
     except ValueError:
         return "+0Hz"
 
-# --- Edge-TTS Stream Endpoint ---
+# ===== 4. EXTERNAL STREAMING ENDPOINTS =====
+
+# --- Direct Audio Stream (GET & POST) ---
 @app.api_route("/tts", methods=["GET", "POST"])
 async def tts_stream(request: Request):
     """
-    Query or JSON Parameters:
-    - text: text to read
-    - voice: e.g., 'en-US-AriaNeural' or 'en-US-ChristopherNeural'
-    - speed / rate: e.g. 1.2 or '+20%'
-    - pitch: e.g. '+0Hz' or '+5%'
+    Accepts:
+    - text (string, required)
+    - voice (string, default: en-US-AriaNeural)
+    - speed / rate (float or string, e.g. 1.2 or '+20%')
+    - pitch (string or int, e.g. '+5Hz' or '+10%')
     """
     if request.method == "POST":
         try:
@@ -262,7 +131,6 @@ async def openai_speech(request: Request):
     text = data.get("input", "")
     voice = data.get("voice", "en-US-AriaNeural")
     speed = data.get("speed", 1.0)
-    
     rate = format_rate(speed)
 
     async def generate_audio():
@@ -279,37 +147,56 @@ async def list_voices():
     voices = await edge_tts.list_voices()
     return JSONResponse(voices)
 
-# --- Proxy LLM Chat Completions ---
-@app.api_route("/v1/{path:path}", methods=["GET", "POST"])
-async def v1_proxy(path: str, request: Request):
-    body = await request.body()
-    headers = {k: request.headers[k] for k in ("authorization", "content-type")
-               if k in request.headers}
-    wants_stream = False
-    if body:
-        try:
-            wants_stream = bool(json.loads(body).get("stream"))
-        except Exception:
-            pass
-
-    url = f"{UPSTREAM}/v1/{path}"
-    if request.method == "POST" and wants_stream:
-        req = _http.build_request("POST", url, content=body, headers=headers)
-        resp = await _http.send(req, stream=True)
-        async def gen():
-            try:
-                async for chunk in resp.aiter_raw():
-                    yield chunk
-            finally:
-                await resp.aclose()
-        return StreamingResponse(gen(), status_code=resp.status_code,
-                                 media_type="text/event-stream")
+# ===== 5. GRADIO TEST INTERFACE =====
+async def gradio_tts(text, voice, speed, pitch):
+    if not text:
+        return None
+    rate_str = format_rate(speed)
+    pitch_str = format_pitch(pitch)
+    communicate = edge_tts.Communicate(text=text, voice=voice, rate=rate_str, pitch=pitch_str)
+    
+    buf = io.BytesIO()
+    async for chunk in communicate.stream():
+        if chunk["type"] == "audio":
+            buf.write(chunk["data"])
+    buf.seek(0)
+    return buf.getvalue()
+
+DEFAULT_VOICES = [
+    "en-US-AriaNeural",
+    "en-US-ChristopherNeural",
+    "en-US-GuyNeural",
+    "en-US-JennyNeural",
+    "en-GB-SoniaNeural",
+    "en-GB-RyanNeural",
+    "es-ES-AlvaroNeural",
+    "fr-FR-DeniseNeural",
+    "de-DE-KatjaNeural",
+    "zh-CN-XiaoxiaoNeural"
+]
 
-    resp = await _http.request(request.method, url, content=body or None, headers=headers)
-    return Response(content=resp.content, status_code=resp.status_code,
-                    media_type=resp.headers.get("content-type", "application/json"))
+with gr.Blocks(title="High-Speed Edge-TTS API") as demo:
+    gr.Markdown(
+        f"# ⚡ High-Speed Edge-TTS Server\n"
+        f"Running on ZeroGPU Max-CPU ({CORES} Cores Allocated)\n\n"
+        f"**External API Endpoints:**\n"
+        f"- `GET / POST /tts?text=...&voice=...&speed=1.0&pitch=+0Hz`\n"
+        f"- `POST /v1/audio/speech` (OpenAI Compatible)\n"
+        f"- `GET /tts/voices` (List All Available Edge-TTS Voices)"
+    )
+    with gr.Row():
+        with gr.Column():
+            text_input = gr.Textbox(label="Text", value="Hello! This is a real-time streaming test of Edge TTS.", lines=3)
+            voice_dropdown = gr.Dropdown(choices=DEFAULT_VOICES, value="en-US-AriaNeural", label="Voice")
+            speed_slider = gr.Slider(minimum=0.5, maximum=2.0, value=1.0, step=0.1, label="Speed / Rate")
+            pitch_input = gr.Textbox(value="+0Hz", label="Pitch (e.g. +0Hz, +5Hz, -5Hz)")
+            btn = gr.Button("Generate Speech", variant="primary")
+        with gr.Column():
+            audio_output = gr.Audio(label="Audio Output", autoplay=True)
+
+    btn.click(fn=gradio_tts, inputs=[text_input, voice_dropdown, speed_slider, pitch_input], outputs=audio_output)
 
-# Mount Gradio UI
+demo = demo.queue()
 app = gr.mount_gradio_app(app, demo, path="/")
 
 if __name__ == "__main__":