Upload app.py with huggingface_hub

app.py

@@ -0,0 +1,274 @@
+"""
+SimonLM Cloud — Hugging Face Space (ZeroGPU).
+
+- Wheel llama-cpp-python CUDA (GPU gratuit via ZeroGPU)
+- Interface Gradio (chat) + API OpenAI-compatible (/v1/chat/completions,
+  /v1/models) pour que SimonLM local puisse router ses questions SIMPLE
+  vers ce GPU au lieu de charger le 0.6B sur la machine.
+- Le modèle est chargé une seule fois (cache global) et l'inférence passe par
+  @spaces.GPU pour utiliser le GPU réel.
+
+RÈGLE ZeroGPU : la fonction bindée aux événements Gradio (respond) DOIT être
+décorée @spaces.GPU — le scan de démarrage ne détecte que les handlers
+Gradio décorés. L'API utilise sa propre fonction décorée (même worker GPU).
+
+Réglages via variables d'environnement : MODEL_REPO, MODEL_FILE, N_CTX,
+N_THREADS, MAX_TOKENS, N_GPU_LAYERS.
+"""
+import ctypes
+import glob
+import os
+import site
+import time
+import uuid
+
+# --- Pré-chargement des libs CUDA (libcudart, libcublas) requises par llama-cpp-python ---
+# L'image ZeroGPU embarque PyTorch + CUDA ; on localise et on charge les .so
+# avant l'import de llama_cpp pour que ctypes les trouve.
+def _preload_cuda_libs():
+    dirs = []
+    # torch/lib (présent dans l'image ZeroGPU)
+    try:
+        import torch
+        dirs.append(os.path.join(os.path.dirname(torch.__file__), "lib"))
+    except Exception:
+        pass
+    # packages nvidia installés par pip (nvidia-cuda-runtime-cu12, nvidia-cublas-cu12)
+    for sp in site.getsitepackages():
+        dirs.extend(glob.glob(os.path.join(sp, "nvidia", "*", "lib")))
+    loaded = []
+    for d in dirs:
+        for so in sorted(glob.glob(os.path.join(d, "libcudart.so*")) +
+                         glob.glob(os.path.join(d, "libcublas*.so*")) +
+                         glob.glob(os.path.join(d, "libcuda.so*"))):
+            try:
+                ctypes.CDLL(so)
+                loaded.append(os.path.basename(so))
+            except Exception:
+                pass
+    return loaded
+
+_preload_cuda_libs()
+
+from typing import List
+
+from fastapi.responses import JSONResponse, StreamingResponse
+from pydantic import BaseModel
+import gradio as gr
+from gradio.routes import App
+import spaces
+
+MODEL_REPO = os.getenv("MODEL_REPO", "unsloth/Qwen3-0.6B-GGUF")
+MODEL_FILE = os.getenv("MODEL_FILE", "Qwen3-0.6B-Q4_K_M.gguf")
+N_CTX = int(os.getenv("N_CTX", "8192"))
+N_THREADS = int(os.getenv("N_THREADS", "4"))
+MAX_TOKENS = int(os.getenv("MAX_TOKENS", "512"))
+N_GPU_LAYERS = int(os.getenv("N_GPU_LAYERS", "-1"))  # -1 = tout sur GPU
+API_MODEL_ID = os.getenv("API_MODEL_ID", "simonlm-0.6b")
+
+_llm = None
+
+
+def _get_llm():
+    """Charge le modèle une seule fois (cache global, dans le worker GPU)."""
+    global _llm
+    if _llm is None:
+        from llama_cpp import Llama
+
+        print(f"[SimonLM] Chargement de {MODEL_REPO}/{MODEL_FILE} "
+              f"(n_ctx={N_CTX}, gpu_layers={N_GPU_LAYERS})…", flush=True)
+        _llm = Llama.from_pretrained(
+            repo_id=MODEL_REPO,
+            filename=MODEL_FILE,
+            n_ctx=N_CTX,
+            n_threads=N_THREADS,
+            n_gpu_layers=N_GPU_LAYERS,
+            verbose=False,
+        )
+        print("[SimonLM] Modèle prêt (GPU)", flush=True)
+    return _llm
+
+
+def _infer(messages: list, max_tokens: int, temperature: float, top_p: float) -> str:
+    """Inférence GPU brute (à appeler DANS une fonction @spaces.GPU)."""
+    llm = _get_llm()
+    out = llm.create_chat_completion(
+        messages=messages,
+        max_tokens=max_tokens,
+        temperature=temperature,
+        top_p=top_p,
+    )
+    return out["choices"][0]["message"].get("content", "")
+
+
+def _split_think(text: str):
+    """Sépare le bloc <think> Qwen3 : (reasoning, content)."""
+    if "<think>" in text and "</think>" in text:
+        reasoning, content = text.split("</think>", 1)
+        reasoning = reasoning.replace("<think>", "").strip()
+        return reasoning, content.lstrip("\n")
+    return "", text
+
+
+# ── Interface Gradio (chat humain) ────────────────────────────────────────────
+# ⚠️ DÉCORÉ @spaces.GPU : le scan ZeroGPU ne détecte QUE les handlers Gradio
+# décorés. respond est bindé à ChatInterface → c'est lui qui doit l'être.
+
+_history: list = []
+
+
+@spaces.GPU(duration=120)
+def respond(message: str, chat_history):
+    global _history
+    _history.append({"role": "user", "content": message})
+    if len(_history) > 12:
+        del _history[:2]
+    try:
+        raw = _infer(list(_history), max_tokens=MAX_TOKENS, temperature=0.7, top_p=0.9)
+        _, content = _split_think(raw)
+        reply = content
+    except Exception as e:  # noqa: BLE001 — jamais planter l'interface
+        reply = f"⚠️ Erreur : {e}"
+    _history.append({"role": "assistant", "content": reply})
+    return reply
+
+
+demo = gr.ChatInterface(
+    fn=respond,
+    title="🤖 SimonLM Cloud",
+    description=f"Assistant IA — modèle {MODEL_FILE} sur ZeroGPU (GPU gratuit HF Spaces).",
+)
+
+
+# ── API OpenAI-compatible ─────────────────────────────────────────────────────
+# App = sous-classe FastAPI de Gradio → on y ajoute nos routes /v1/* puis on la
+# passe à demo.launch(_app=...) : Gradio s'y monte et le scan ZeroGPU s'exécute.
+app = App(title="SimonLM Cloud API")
+
+
+class ChatMessage(BaseModel):
+    role: str
+    content: str
+
+
+class ChatRequest(BaseModel):
+    model: str = API_MODEL_ID
+    messages: List[ChatMessage]
+    temperature: float = 0.7
+    top_p: float = 0.9
+    max_tokens: int = MAX_TOKENS
+    stream: bool = False
+
+
+@spaces.GPU(duration=120)
+def _api_infer(messages: list, max_tokens: int, temperature: float, top_p: float) -> str:
+    return _infer(messages, max_tokens, temperature, top_p)
+
+
+@app.get("/v1/models")
+def list_models():
+    return JSONResponse({
+        "object": "list",
+        "data": [{
+            "id": API_MODEL_ID,
+            "object": "model",
+            "owned_by": "simonlm",
+        }],
+    })
+
+
+def _sse_chunks(content: str, model: str):
+    """Découpe la réponse en fragments SSE (ressenti streaming)."""
+    import json as _json
+    frags = []
+    for part in content.split(" "):
+        frags.append(part + " " if part else " ")
+    buf = ""
+    for f in frags:
+        buf += f
+        if len(buf) >= 15:
+            chunk = {
+                "id": f"chatcmpl-{uuid.uuid4().hex[:12]}",
+                "object": "chat.completion.chunk",
+                "created": int(time.time()),
+                "model": model,
+                "choices": [{
+                    "index": 0,
+                    "delta": {"content": buf},
+                    "finish_reason": None,
+                }],
+            }
+            yield f"data: {_json.dumps(chunk)}\n\n"
+            buf = ""
+    if buf:
+        chunk = {
+            "id": f"chatcmpl-{uuid.uuid4().hex[:12]}",
+            "object": "chat.completion.chunk",
+            "created": int(time.time()),
+            "model": model,
+            "choices": [{
+                "index": 0,
+                "delta": {"content": buf},
+                "finish_reason": None,
+            }],
+        }
+        yield f"data: {_json.dumps(chunk)}\n\n"
+    done = {
+        "id": f"chatcmpl-{uuid.uuid4().hex[:12]}",
+        "object": "chat.completion.chunk",
+        "created": int(time.time()),
+        "model": model,
+        "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}],
+    }
+    yield f"data: {_json.dumps(done)}\n\n"
+    yield "data: [DONE]\n\n"
+
+
+@app.post("/v1/chat/completions")
+def chat_completions(req: ChatRequest):
+    raw_messages = [{"role": m.role, "content": m.content} for m in req.messages]
+    try:
+        raw = _api_infer(
+            raw_messages,
+            max_tokens=min(req.max_tokens, MAX_TOKENS),
+            temperature=req.temperature,
+            top_p=req.top_p,
+        )
+    except Exception as e:  # noqa: BLE001 — erreur propre côté client
+        return JSONResponse({
+            "error": {"message": f"Inférence GPU en échec : {e}", "type": "server_error"},
+        }, status_code=500)
+
+    reasoning, content = _split_think(raw)
+    msg = {"role": "assistant", "content": content}
+    if reasoning:
+        msg["reasoning_content"] = reasoning
+
+    if req.stream:
+        return StreamingResponse(
+            _sse_chunks(content, req.model),
+            media_type="text/event-stream",
+        )
+
+    return JSONResponse({
+        "id": f"chatcmpl-{uuid.uuid4().hex[:12]}",
+        "object": "chat.completion",
+        "created": int(time.time()),
+        "model": req.model,
+        "choices": [{
+            "index": 0,
+            "message": msg,
+            "finish_reason": "stop",
+        }],
+        "usage": {
+            "prompt_tokens": 0,
+            "completion_tokens": 0,
+            "total_tokens": 0,
+        },
+    })
+
+
+# Lancement via demo.launch(_app=...) : le scan ZeroGPU s'exécute au launch()
+# (gr.Blocks.launch est patché par le runtime) ET nos routes /v1/* sont montées
+# sur la même app FastAPI que Gradio.
+demo.launch(_app=app)