Spaces:

proti0070
/

Tgconfig

Running

App Files Files Community

proti0070 commited on Mar 5

Commit

b976823

verified ·

1 Parent(s): 837a21e

Update app.py

Browse files

Files changed (1) hide show

app.py +0 -276

app.py CHANGED Viewed

@@ -243,282 +243,6 @@ async def delete_model(request: Request):
         return resp.json() if resp.content else {"status": "ok"}
-# ─────────────────────────────────────────────
-# POST /shell — plain text, no SSE, no "event: line" prefix
-# curl -N /shell -d '{"cmd":"apt update"}'
-# ─────────────────────────────────────────────
-def _sanitize_cmd(cmd: str) -> str:
-    """
-    Auto-fix apt/apt-get commands so they never hang waiting for input:
-      - prefix with sudo (non-root user on HF Spaces)
-      - inject -y (auto yes)
-      - inject -o flags to suppress dpkg config prompts
-      - set DEBIAN_FRONTEND=noninteractive inline
-    """
-    s = cmd.strip()
-    is_apt = s.startswith("apt ") or s.startswith("apt-get ") \
-             or s == "apt" or s == "apt-get"
-    if is_apt:
-        # inject -y if not already present
-        if " -y" not in s and " --yes" not in s:
-            s = s.replace("apt-get ", "apt-get -y ", 1)
-            s = s.replace("apt ", "apt -y ", 1)
-        # inject dpkg options to suppress config file prompts
-        dpkg_opts = '-o Dpkg::Options::="--force-confdef" -o Dpkg::Options::="--force-confold"'
-        s = f'DEBIAN_FRONTEND=noninteractive sudo {s} {dpkg_opts}'
-    elif not s.startswith("sudo "):
-        # for other privileged commands let user decide, but keep env clean
-        pass
-    return s
-@app.post("/shell")
-async def shell_post(request: Request):
-import asyncio
-import httpx
-import json
-import os
-import uuid
-from datetime import datetime
-from fastapi import FastAPI, Request
-from fastapi.responses import StreamingResponse, HTMLResponse, JSONResponse, PlainTextResponse
-app = FastAPI(title="Ollama HF Space Server")
-OLLAMA_PORT     = os.environ.get("OLLAMA_PORT", "11434")
-OLLAMA_BASE_URL = f"http://localhost:{OLLAMA_PORT}"
-DEFAULT_MODEL   = os.environ.get("DEFAULT_MODEL", "hydra-ai")
-sessions: dict = {}
-MAX_SESSIONS = 100
-MAX_MESSAGES = 50
-def get_or_create_session(conv_id: str, model: str) -> dict:
-    if conv_id not in sessions:
-        if len(sessions) >= MAX_SESSIONS:
-            oldest = next(iter(sessions))
-            del sessions[oldest]
-        sessions[conv_id] = {
-            "model": model,
-            "created_at": datetime.utcnow().isoformat(),
-            "messages": []
-        }
-    return sessions[conv_id]
-@app.get("/", response_class=HTMLResponse)
-async def root():
-    return """<!DOCTYPE html>
-<html><head><title>Ollama HF Space</title>
-<style>body{font-family:monospace;background:#0d0d0d;color:#00ff88;padding:20px}
-.ep{background:#111;border:1px solid #00ff88;padding:10px;margin:8px 0;border-radius:4px}
-a{color:#00ffcc}code{background:#1a1a1a;padding:2px 6px}</style></head>
-<body>
-<h1>🦙 Ollama HF Space</h1>
-<div class="ep"><b>GET  /web</b> — <a href="/web">Full Web Control Panel</a></div>
-<div class="ep"><b>POST /api/chat</b> — Chat, streams plain text content only</div>
-<div class="ep"><b>POST /api/chat/new</b> — Create new conversation</div>
-<div class="ep"><b>GET  /api/chat/history?conv_id=...</b> — Get history</div>
-<div class="ep"><b>DEL  /api/chat/history?conv_id=...</b> — Clear history</div>
-<div class="ep"><b>GET  /api/sessions</b> — List sessions</div>
-<div class="ep"><b>POST /shell</b> — Plain text shell stream (no event: prefixes)</div>
-<div class="ep"><b>GET  /api/tags</b> — List models</div>
-<div class="ep"><b>POST /api/pull</b> — Pull model</div>
-</body></html>"""
-@app.post("/api/chat/new")
-async def new_conversation(request: Request):
-    body    = await request.json()
-    model   = body.get("model", DEFAULT_MODEL)
-    conv_id = str(uuid.uuid4())[:8]
-    get_or_create_session(conv_id, model)
-    return {"conv_id": conv_id, "model": model, "created_at": sessions[conv_id]["created_at"]}
-@app.get("/api/chat/history")
-async def get_history(conv_id: str):
-    if conv_id not in sessions:
-        return JSONResponse({"error": "conversation not found"}, status_code=404)
-    s = sessions[conv_id]
-    return {"conv_id": conv_id, "model": s["model"], "created_at": s["created_at"],
-            "message_count": len(s["messages"]), "messages": s["messages"]}
-@app.delete("/api/chat/history")
-async def clear_history(conv_id: str):
-    if conv_id not in sessions:
-        return JSONResponse({"error": "conversation not found"}, status_code=404)
-    sessions[conv_id]["messages"] = []
-    return {"conv_id": conv_id, "status": "cleared"}
-@app.get("/api/sessions")
-async def list_sessions():
-    return {"total": len(sessions), "sessions": [
-        {"conv_id": cid, "model": s["model"], "created_at": s["created_at"],
-         "message_count": len(s["messages"])}
-        for cid, s in sessions.items()
-    ]}
-# ─────────────────────────────────────────────
-# POST /api/chat
-# stream=true  → streams ONLY the text content, no JSON wrapper
-# stream=false → returns full JSON with conv_id
-#
-# With session:    {"conv_id": "a3f9c1b2", "message": "Hello"}
-# Without session: {"messages": [...], "model": "...", "stream": true}
-# Auto session:    {"message": "Hello", "model": "tinyllama"}
-# ─────────────────────────────────────────────
-@app.post("/api/chat")
-async def chat(request: Request):
-    body = await request.json()
-    # ── Session-based mode ──
-    if "message" in body:
-        user_msg = body["message"]
-        model    = body.get("model", DEFAULT_MODEL)
-        conv_id  = body.get("conv_id") or str(uuid.uuid4())[:8]
-        stream   = body.get("stream", True)
-        session = get_or_create_session(conv_id, model)
-        session["model"] = model
-        session["messages"].append({"role": "user", "content": user_msg})
-        if len(session["messages"]) > MAX_MESSAGES:
-            session["messages"] = session["messages"][-MAX_MESSAGES:]
-        ollama_body = {"model": model, "messages": session["messages"], "stream": True}
-        full_response = []
-        async def stream_content_only():
-            # Streams ONLY the text tokens — no JSON, no metadata
-            async with httpx.AsyncClient(timeout=300) as client:
-                async with client.stream("POST", f"{OLLAMA_BASE_URL}/api/chat", json=ollama_body) as r:
-                    async for line in r.aiter_lines():
-                        if not line.strip():
-                            continue
-                        try:
-                            d = json.loads(line)
-                            token = d.get("message", {}).get("content", "")
-                            if token:
-                                full_response.append(token)
-                                yield token          # ← just the raw text
-                        except Exception:
-                            pass
-            # save to session after stream ends
-            session["messages"].append({"role": "assistant", "content": "".join(full_response)})
-        if stream:
-            return StreamingResponse(
-                stream_content_only(),
-                media_type="text/plain",
-                headers={
-                    "X-Conv-Id": conv_id,
-                    "Cache-Control": "no-cache",
-                    "X-Accel-Buffering": "no",
-                },
-            )
-        else:
-            # collect full response then return JSON
-            async with httpx.AsyncClient(timeout=300) as client:
-                resp = await client.post(f"{OLLAMA_BASE_URL}/api/chat", json={**ollama_body, "stream": False})
-                data = resp.json()
-                assistant_text = data.get("message", {}).get("content", "")
-                if assistant_text:
-                    session["messages"].append({"role": "assistant", "content": assistant_text})
-                return {"conv_id": conv_id, "model": model, "content": assistant_text}
-    # ── Raw passthrough mode (old style) ──
-    else:
-        if "model" not in body:
-            body["model"] = DEFAULT_MODEL
-        stream = body.get("stream", True)
-        async def stream_content_raw():
-            # Also streams only content text for raw mode
-            async with httpx.AsyncClient(timeout=300) as client:
-                async with client.stream("POST", f"{OLLAMA_BASE_URL}/api/chat", json={**body, "stream": True}) as r:
-                    async for line in r.aiter_lines():
-                        if not line.strip():
-                            continue
-                        try:
-                            d = json.loads(line)
-                            token = d.get("message", {}).get("content", "")
-                            if token:
-                                yield token
-                        except Exception:
-                            pass
-        if stream:
-            return StreamingResponse(
-                stream_content_raw(),
-                media_type="text/plain",
-                headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
-            )
-        else:
-            async with httpx.AsyncClient(timeout=300) as client:
-                resp = await client.post(f"{OLLAMA_BASE_URL}/api/chat", json={**body, "stream": False})
-                data = resp.json()
-                return {"content": data.get("message", {}).get("content", ""), "model": body["model"]}
-@app.post("/api/generate")
-async def generate(request: Request):
-    body = await request.json()
-    if "model" not in body:
-        body["model"] = DEFAULT_MODEL
-    async def stream_content():
-        async with httpx.AsyncClient(timeout=300) as client:
-            async with client.stream("POST", f"{OLLAMA_BASE_URL}/api/generate", json={**body, "stream": True}) as r:
-                async for line in r.aiter_lines():
-                    if not line.strip():
-                        continue
-                    try:
-                        d = json.loads(line)
-                        token = d.get("response", "")
-                        if token:
-                            yield token
-                    except Exception:
-                        pass
-    return StreamingResponse(
-        stream_content(),
-        media_type="text/plain",
-        headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
-    )
-@app.get("/api/tags")
-async def list_models():
-    async with httpx.AsyncClient(timeout=10) as client:
-        resp = await client.get(f"{OLLAMA_BASE_URL}/api/tags")
-        return resp.json()
-@app.post("/api/pull")
-async def pull_model(request: Request):
-    body = await request.json()
-    async def stream_pull():
-        async with httpx.AsyncClient(timeout=600) as client:
-            async with client.stream("POST", f"{OLLAMA_BASE_URL}/api/pull", json=body) as r:
-                async for chunk in r.aiter_bytes():
-                    yield chunk
-    return StreamingResponse(stream_pull(), media_type="application/x-ndjson")
-@app.delete("/api/delete")
-async def delete_model(request: Request):
-    body = await request.json()
-    async with httpx.AsyncClient(timeout=60) as client:
-        resp = await client.delete(f"{OLLAMA_BASE_URL}/api/delete", json=body)
-        return resp.json() if resp.content else {"status": "ok"}
 # ─────────────────────────────────────────────
 # POST /shell — plain text, no SSE, no "event: line" prefix
 # curl -N /shell -d '{"cmd":"apt update"}'

         return resp.json() if resp.content else {"status": "ok"}
 # ─────────────────────────────────────────────
 # POST /shell — plain text, no SSE, no "event: line" prefix
 # curl -N /shell -d '{"cmd":"apt update"}'