Spaces:

Percy3822
/

Brain

Paused

App Files Files Community

Percy3822 commited on Sep 3, 2025

Commit

f772dc7

verified ·

1 Parent(s): 79b1fb2

Update app.py

Browse files

Files changed (1) hide show

app.py +213 -326

app.py CHANGED Viewed

@@ -1,27 +1,25 @@
-# app.py
-# Brain: hub UI + proxy to Python_ai / TTS / STT
-# NOTE: If WhatsApp changes _name_ to name, restore the double underscores.
-import os
-import json
-from typing import Optional, Dict, Any
-from fastapi import FastAPI, UploadFile, File, Form, Request
-from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
 import httpx
-# -----------------------------------------------------------------------------
-# Config (env overrides allowed)
-# -----------------------------------------------------------------------------
-PYTHON_AI_URL = os.getenv("PYTHON_AI_URL", "https://Percy3822-Python-ai.hf.space")
-TTS_URL       = os.getenv("TTS_URL",       "https://Percy3822-ActualTTS.hf.space")
-STT_URL       = os.getenv("STT_URL",       "https://Percy3822-ActualSTT.hf.space")
-TIMEOUT_S     = float(os.getenv("UPSTREAM_TIMEOUT_S", "60"))
-app = FastAPI(title="Brain", version="0.4")
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -29,318 +27,207 @@ app.add_middleware(
     allow_headers=["*"],
 )
-# -----------------------------------------------------------------------------
-# Models
-# -----------------------------------------------------------------------------
-class CodeHelpPayload(BaseModel):
-    utterance: str
-    telemetry: Dict[str, Any]
-    memory: Dict[str, Any]
-    response_mode: Optional[str] = "patch"
-class TTSPayload(BaseModel):
-    text: str
-# -----------------------------------------------------------------------------
-# Helpers
-# -----------------------------------------------------------------------------
-def _make_abs_url(url_or_path: Optional[str]) -> Optional[str]:
-    """Ensure a TTS path or hostname becomes a full https URL."""
-    if not url_or_path:
-        return None
-    s = url_or_path.strip()
-    if s.startswith("http://") or s.startswith("https://"):
-        return s
-    # Accept outputs like "percy3822-actualtts.hf.space/file/xxx.wav" or "/file/xxx.wav"
-    s = s.lstrip("/")
-    if s.startswith("file/"):
-        # file path without host -> attach TTS host
-        return f"{TTS_URL.rstrip('/')}/{s}"
-    # likely host/path without scheme
-    return "https://" + s
-async def _post_json(url: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-    async with httpx.AsyncClient(timeout=TIMEOUT_S) as client:
-        r = await client.post(url, json=payload)
-        r.raise_for_status()
-        return r.json()
-async def _post_multipart(url: str, files: Dict[str, Any], params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-    async with httpx.AsyncClient(timeout=TIMEOUT_S) as client:
-        r = await client.post(url, files=files, params=params or {})
-        r.raise_for_status()
-        return r.json()
-# -----------------------------------------------------------------------------
-# UI
-# -----------------------------------------------------------------------------
-INDEX_HTML = """<!doctype html>
-<html lang="en">
-<head>
-<meta charset="utf-8" />
-<meta name="viewport" content="width=device-width, initial-scale=1" />
-<title>Brain – Control Panel</title>
-<style>
-  :root { color-scheme: light dark; }
-  body { font-family: system-ui, -apple-system, Segoe UI, Roboto, sans-serif; margin: 24px; line-height: 1.4; }
-  h1 { margin: 0 0 8px; }
-  .grid { display: grid; gap: 16px; grid-template-columns: repeat(auto-fit, minmax(320px, 1fr)); }
-  .card { border: 1px solid #8883; border-radius: 12px; padding: 16px; }
-  textarea, input[type="text"] { width: 100%; box-sizing: border-box; padding: 8px; border-radius: 8px; border: 1px solid #8885; }
-  button { padding: 8px 12px; border-radius: 8px; border: 1px solid #4444; cursor: pointer; }
-  .row { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; }
-  .muted { opacity: .8; font-size: .9em; }
-  .mono { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; white-space: pre-wrap; }
-  audio { width: 100%; margin-top: 8px; }
-  .ok { color: #15803d; }
-  .err { color: #b91c1c; }
-</style>
-</head>
-<body>
-  <h1>🧠 Brain – Control Panel</h1>
-  <p class="muted">Test each feature from Brain. If WhatsApp changed <code>_name</code> to <code>_name</code> in files, fix before deploying.</p>
-  <div class="grid">
-    <div class="card">
-      <h2>TTS → Play & Download</h2>
-      <textarea id="ttsText" rows="3" placeholder="Type text to speak...">Brain speaking through ActualTTS on CPU.</textarea>
-      <div class="row" style="margin-top:8px;">
-        <button id="ttsBtn">Speak</button>
-        <span id="ttsStatus" class="muted"></span>
-      </div>
-      <div id="ttsOut" style="margin-top:10px;"></div>
-    </div>
-    <div class="card">
-      <h2>STT → Transcribe File</h2>
-      <input type="file" id="sttFile" accept="audio/*" />
-      <div class="row" style="margin-top:8px;">
-        <button id="sttBtn">Transcribe</button>
-        <span id="sttStatus" class="muted"></span>
-      </div>
-      <div id="sttOut" style="margin-top:10px;"></div>
-    </div>
-    <div class="card">
-      <h2>Code Help (dummy patch)</h2>
-      <textarea id="codeViewport" rows="5">def foo():
-    return bar
-result = foo()
-print(reslt)
-</textarea>
-      <div class="row" style="margin-top:8px;">
-        <button id="codeBtn">Ask Python_ai via Brain</button>
-        <span id="codeStatus" class="muted"></span>
-      </div>
-      <div id="codeOut" class="mono" style="margin-top:10px;"></div>
-    </div>
-  </div>
-<script>
-const byId = (x) => document.getElementById(x);
-// TTS
-byId('ttsBtn').onclick = async () => {
-  const text = byId('ttsText').value.trim();
-  byId('ttsStatus').textContent = 'Calling /speak...';
-  byId('ttsOut').innerHTML = '';
-  try {
-    const r = await fetch('/speak', {
-      method: 'POST',
-      headers: {'Content-Type':'application/json'},
-      body: JSON.stringify({text})
-    });
-    const j = await r.json();
-    if (!r.ok) throw new Error(j.detail || JSON.stringify(j));
-    const url = j.audio_url;
-    const a = document.createElement('audio');
-    a.controls = true;
-    a.src = url;
-    const dl = document.createElement('a');
-    dl.href = url;
-    dl.download = (url.split('/').pop() || 'tts.wav');
-    dl.textContent = 'Download audio';
-    byId('ttsOut').appendChild(a);
-    byId('ttsOut').appendChild(document.createElement('br'));
-    byId('ttsOut').appendChild(dl);
-    byId('ttsStatus').textContent = 'Done.';
-    byId('ttsStatus').className = 'ok';
-  } catch (e) {
-    byId('ttsStatus').textContent = String(e);
-    byId('ttsStatus').className = 'err';
-  }
-};
-// STT
-byId('sttBtn').onclick = async () => {
-  const f = byId('sttFile').files[0];
-  if (!f) {
-    byId('sttStatus').textContent = 'Pick an audio file first.';
-    byId('sttStatus').className = 'err';
-    return;
-  }
-  byId('sttStatus').textContent = 'Uploading to /transcribe...';
-  byId('sttOut').innerHTML = '';
-  try {
-    const form = new FormData();
-    form.append('file', f, f.name);
-    const r = await fetch('/transcribe', { method: 'POST', body: form });
-    const j = await r.json();
-    if (!r.ok) throw new Error(j.detail || JSON.stringify(j));
-    const pre = document.createElement('pre');
-    pre.className = 'mono';
-    pre.textContent = JSON.stringify(j, null, 2);
-    byId('sttOut').appendChild(pre);
-    byId('sttStatus').textContent = 'Done.';
-    byId('sttStatus').className = 'ok';
-  } catch (e) {
-    byId('sttStatus').textContent = String(e);
-    byId('sttStatus').className = 'err';
-  }
-};
-// Code Help
-byId('codeBtn').onclick = async () => {
-  const viewportText = byId('codeViewport').value;
-  byId('codeStatus').textContent = 'Calling /code_help...';
-  byId('codeOut').textContent = '';
-  try {
-    const payload = {
-      utterance: "please fix the error and make it run",
-      telemetry: {
-        file: "main.py",
-        lang: "python",
-        cursor: { l: 88, c: 12 },
-        viewport: { start: 72, end: 110, text: viewportText },
-        diag: [{ l: 90, sev: "error", msg: "NameError: reslt is not defined" }],
-        term: "Traceback... NameError: reslt"
-      },
-      memory: { short: [], sess: ["Prefer list comprehensions."], proj: [] },
-      response_mode: "patch"
-    };
-    const r = await fetch('/code_help', {
-      method: 'POST',
-      headers: {'Content-Type':'application/json'},
-      body: JSON.stringify(payload)
-    });
-    const j = await r.json();
-    if (!r.ok) throw new Error(j.detail || JSON.stringify(j));
-    byId('codeOut').textContent = JSON.stringify(j, null, 2);
-    byId('codeStatus').textContent = 'Done.';
-    byId('codeStatus').className = 'ok';
-  } catch (e) {
-    byId('codeStatus').textContent = String(e);
-    byId('codeStatus').className = 'err';
-  }
-};
-</script>
-</body>
-</html>
-"""
-# -----------------------------------------------------------------------------
-# Routes
-# -----------------------------------------------------------------------------
-@app.get("/", response_class=HTMLResponse)
-async def index():
-    return HTMLResponse(INDEX_HTML)
-@app.get("/health")
-async def health():
-    return {"ok": True, "services": {"python_ai": PYTHON_AI_URL, "tts": TTS_URL, "stt": STT_URL}}
 @app.post("/warmup")
 async def warmup():
-    notes = {}
-    # ping python_ai
-    try:
-        # Intentionally minimal/invalid to confirm it's up (expect 200 or 4xx)
-        payload = {
-            "utterance": "ping",
-            "telemetry": {"file":"x.py","lang":"python","cursor":{"l":1,"c":1},
-                          "viewport":{"start":1,"end":1,"text":"print(reslt)\\n"},
-                          "diag":[], "term":""},
-            "memory": {"short":[], "sess":[], "proj":[]},
-            "response_mode": "patch"
-        }
-        async with httpx.AsyncClient(timeout=TIMEOUT_S) as client:
-            r = await client.post(f"{PYTHON_AI_URL}/code_help", json=payload)
-            notes["python_ai"] = "ok" if r.status_code == 200 else f"ok(ping-{r.status_code})"
-    except Exception as e:
-        notes["python_ai"] = f"err: {e}"
-    # ping TTS
-    try:
-        async with httpx.AsyncClient(timeout=TIMEOUT_S) as client:
-            r = await client.post(f"{TTS_URL}/speak", json={"text": "warmup"})
-            notes["tts"] = "ok" if r.status_code == 200 else f"status {r.status_code}"
-    except Exception as e:
-        notes["tts"] = f"err: {e}"
-    # ping STT
-    try:
-        async with httpx.AsyncClient(timeout=TIMEOUT_S) as client:
-            r = await client.get(f"{STT_URL}/openapi.json")
-            notes["stt"] = "ok" if r.status_code == 200 else f"status {r.status_code}"
-    except Exception as e:
-        notes["stt"] = f"err: {e}"
-    return {"ok": True, "notes": notes}
-@app.post("/code_help")
-async def code_help(body: CodeHelpPayload):
-    try:
-        data = await _post_json(f"{PYTHON_AI_URL}/code_help", json.loads(body.model_dump_json()))
-        return JSONResponse(data)
-    except httpx.HTTPStatusError as e:
-        return JSONResponse({"detail": str(e), "upstream": e.response.text}, status_code=502)
-    except Exception as e:
-        return JSONResponse({"detail": str(e)}, status_code=502)
 @app.post("/speak")
-async def speak(body: TTSPayload):
-    try:
-        # Call TTS space
-        async with httpx.AsyncClient(timeout=TIMEOUT_S) as client:
-            r = await client.post(f"{TTS_URL}/speak", json={"text": body.text})
-            r.raise_for_status()
-            j = r.json()
-        # Normalize keys: handle audio_path | audio_url | path
-        raw = j.get("audio_path") or j.get("audio_url") or j.get("path")
-        audio_url = _make_abs_url(raw)
-        # Force fully-qualified https:// if scheme missing (extra guard)
-        if audio_url and not audio_url.startswith("http"):
-            audio_url = "https://" + audio_url.lstrip("/")
-        if not audio_url:
-            return JSONResponse({"detail": f"Upstream returned no audio path: {j}"}, status_code=502)
-        return {"audio_url": audio_url}
-    except httpx.HTTPStatusError as e:
-        return JSONResponse({"detail": f"TTS upstream error: {str(e)}", "upstream": e.response.text}, status_code=502)
-    except Exception as e:
-        return JSONResponse({"detail": f"TTS error: {str(e)}"}, status_code=502)
 @app.post("/transcribe")
 async def transcribe(file: UploadFile = File(...), beam_size: int = 1, vad_filter: bool = True):
-    try:
-        files = {"file": (file.filename, await file.read(), file.content_type or "application/octet-stream")}
-        params = {"beam_size": beam_size, "vad_filter": str(vad_filter).lower()}
-        data = await _post_multipart(f"{STT_URL}/transcribe", files=files, params=params)
-        return JSONResponse(data)
-    except httpx.HTTPStatusError as e:
-        return JSONResponse({"detail": f"STT upstream error: {str(e)}", "upstream": e.response.text}, status_code=502)
-    except Exception as e:
-        return JSONResponse({"detail": f"STT error: {str(e)}"}, status_code=502)
-# -----------------------------------------------------------------------------
-# Entrypoint
-# -----------------------------------------------------------------------------
-if __name__ == "__main__":  # restore to __main_ if WhatsApp changed it
-    import uvicorn
-    uvicorn.run("app:app", host="0.0.0.0", port=int(os.getenv("PORT", "7860")), reload=False)

+# app.py — Brain (Milestone 1: streaming + bus + telemetry)
+import asyncio, json, os, time, uuid
+from datetime import datetime, timezone
+from typing import AsyncGenerator, Dict, List, Optional
 import httpx
+from fastapi import FastAPI, Form, UploadFile, File, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse, JSONResponse
+APP_START = time.time()
+# ---- Config -----------------------------------------------------------------
+ACTUAL_TTS = os.getenv("ACTUAL_TTS_URL", "https://Percy3822-ActualTTS.hf.space")
+ACTUAL_STT = os.getenv("ACTUAL_STT_URL", "https://Percy3822-ActualSTT.hf.space")
+PY_AI      = os.getenv("PYTHON_AI_URL",   "https://Percy3822-Python-ai.hf.space")
+FILES_DIR  = os.getenv("FILES_DIR", "/home/user/files")
+LOG_DIR    = os.path.join(FILES_DIR, "logs")
+os.makedirs(LOG_DIR, exist_ok=True)
+# ---- App --------------------------------------------------------------------
+app = FastAPI(title="Brain Streaming")
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
     allow_headers=["*"],
 )
+# ---- Simple pub/sub for SSE -------------------------------------------------
+class Bus:
+    def __init__(self):
+        self.subs: List[asyncio.Queue] = []
+    def sub(self) -> asyncio.Queue:
+        q = asyncio.Queue()
+        self.subs.append(q)
+        return q
+    async def pub(self, event: Dict):
+        # Ensure an iso timestamp and monotonic ms
+        event.setdefault("ts_iso", datetime.now(timezone.utc).isoformat())
+        event.setdefault("ts_ms", int(time.time() * 1000))
+        # log to jsonl
+        with open(os.path.join(LOG_DIR, "events.jsonl"), "a", encoding="utf-8") as f:
+            f.write(json.dumps(event, ensure_ascii=False) + "\n")
+        # fan out
+        for q in list(self.subs):
+            try:
+                q.put_nowait(event)
+            except asyncio.QueueFull:
+                pass
+BUS = Bus()
+def _sse_encode(ev: Dict) -> bytes:
+    return f"data: {json.dumps(ev, ensure_ascii=False)}\n\n".encode("utf-8")
+async def _sse_stream(q: asyncio.Queue) -> AsyncGenerator[bytes, None]:
+    # Heartbeat to keep connections alive
+    try:
+        while True:
+            try:
+                ev = await asyncio.wait_for(q.get(), timeout=15)
+                yield _sse_encode(ev)
+            except asyncio.TimeoutError:
+                yield b": hb\n\n"
+    except asyncio.CancelledError:
+        return
+@app.get("/events")
+async def events():
+    q = BUS.sub()
+    return StreamingResponse(_sse_stream(q), media_type="text/event-stream")
+# ---- Health + warmup --------------------------------------------------------
 @app.post("/warmup")
 async def warmup():
+    out = {}
+    async with httpx.AsyncClient(timeout=15) as client:
+        try:
+            r = await client.get(f"{ACTUAL_TTS}/health")
+            out["tts"] = ("ok" if r.status_code == 200 else f"status {r.status_code}")
+        except Exception as e:
+            out["tts"] = f"err: {e!r}"
+        try:
+            r = await client.get(f"{ACTUAL_STT}/health")
+            out["stt"] = ("ok" if r.status_code == 200 else f"status {r.status_code}")
+        except Exception as e:
+            out["stt"] = f"err: {e!r}"
+        try:
+            r = await client.post(f"{PY_AI}/code_help", json={"utterance":"ping"})
+            out["python_ai"] = "ok" if r.status_code in (200,422) else f"status {r.status_code}"
+        except Exception as e:
+            out["python_ai"] = f"err: {e!r}"
+    return {"ok": True, "notes": out}
+@app.get("/health")
+async def health():
+    up = time.time() - APP_START
+    return {"ok": True, "uptime_sec": round(up,2)}
+# ---- Telemetry intake -------------------------------------------------------
+@app.post("/telemetry")
+async def telemetry(payload: Dict):
+    # payload example: { kind, cpu, mem, active_app, net, meter, etc. }
+    await BUS.pub({"type":"telemetry", "payload":payload})
+    return {"ok": True}
+# ---- Streaming NLM (demo) ---------------------------------------------------
+@app.post("/stream/nlm")
+async def stream_nlm(body: Dict):
+    """
+    Body:
+      { "id": "...(optional)", "prompt": "text to answer", "answer": "(optional: if you want me to stream this string)" }
+    For now we stream the provided 'answer' (or a canned one) token-by-token to let you wire the UI.
+    """
+    req_id = body.get("id") or str(uuid.uuid4())
+    prompt = body.get("prompt", "")
+    answer = body.get("answer") or f"Ok! I received your prompt: {prompt[:100]}"
+    async def gen():
+        start = time.time()
+        await BUS.pub({"type":"nlm_start", "id":req_id, "prompt":prompt})
+        buf = []
+        for token in answer.split(" "):
+            buf.append(token)
+            chunk = " ".join(buf)
+            ev = {"type":"nlm_token", "id":req_id, "delta":token, "text":chunk}
+            yield _sse_encode(ev)
+            await asyncio.sleep(0.03)  # tiny delay so UI shows a stream
+        dur = time.time() - start
+        await BUS.pub({"type":"nlm_done", "id":req_id, "duration_ms":int(dur*1000)})
+        yield _sse_encode({"type":"nlm_done", "id":req_id})
+    return StreamingResponse(gen(), media_type="text/event-stream")
+# ---- Streaming TTS orchestration (status stream) ----------------------------
+@app.post("/stream/tts")
+async def stream_tts(body: Dict):
+    """
+    Body: { "text": "...", "voice": "en_US-amy-medium", "description": "optional" }
+    Streams status events; ends with {type: "tts_audio", audio_url: "..."} when ready.
+    """
+    req_id = str(uuid.uuid4())
+    text = body.get("text","").strip()
+    voice = body.get("voice")
+    desc  = body.get("description")
+    async def gen():
+        start = time.time()
+        yield _sse_encode({"type":"tts_status","id":req_id,"phase":"queued"})
+        await BUS.pub({"type":"tts_start","id":req_id,"text":text,"voice":voice})
+        try:
+            async with httpx.AsyncClient(timeout=120) as client:
+                yield _sse_encode({"type":"tts_status","id":req_id,"phase":"synthesizing"})
+                r = await client.post(f"{ACTUAL_TTS}/speak", json={"text":text, **({"voice":voice} if voice else {}), **({"description":desc} if desc else {})})
+                r.raise_for_status()
+                data = r.json()
+                if not data.get("ok"):
+                    raise RuntimeError(data.get("error") or "TTS failed")
+                audio_url = data.get("audio_url")
+                yield _sse_encode({"type":"tts_audio","id":req_id,"audio_url":audio_url})
+                dur = time.time() - start
+                await BUS.pub({"type":"tts_done","id":req_id,"audio_url":audio_url,"duration_ms":int(dur*1000)})
+                yield _sse_encode({"type":"tts_done","id":req_id})
+        except Exception as e:
+            err = {"type":"error","scope":"tts","id":req_id,"msg":repr(e)}
+            await BUS.pub(err)
+            yield _sse_encode(err)
+    return StreamingResponse(gen(), media_type="text/event-stream")
+# ---- Streaming STT orchestration (status stream) ----------------------------
+@app.post("/stream/stt")
+async def stream_stt(file: UploadFile = File(...), beam_size: int = 1, vad_filter: bool = True):
+    """
+    Uploads one file, streams status, ends with text result.
+    """
+    req_id = str(uuid.uuid4())
+    async def gen():
+        start = time.time()
+        yield _sse_encode({"type":"stt_status","id":req_id,"phase":"received","filename":file.filename})
+        await BUS.pub({"type":"stt_start","id":req_id,"filename":file.filename})
+        try:
+            # forward to ActualSTT
+            files = {"file": (file.filename, await file.read(), file.content_type or "audio/wav")}
+            params = {"beam_size":beam_size, "vad_filter":"true" if vad_filter else "false"}
+            async with httpx.AsyncClient(timeout=120) as client:
+                yield _sse_encode({"type":"stt_status","id":req_id,"phase":"processing"})
+                r = await client.post(f"{ACTUAL_STT}/transcribe", params=params, files=files)
+                r.raise_for_status()
+                data = r.json()
+                text = data.get("text","")
+                lang = data.get("language","")
+                dur_a = data.get("duration",0)
+                yield _sse_encode({"type":"stt_text","id":req_id,"text":text,"language":lang,"audio_duration":dur_a})
+                dur = time.time() - start
+                await BUS.pub({"type":"stt_done","id":req_id,"text":text,"duration_ms":int(dur*1000)})
+                yield _sse_encode({"type":"stt_done","id":req_id})
+        except Exception as e:
+            err = {"type":"error","scope":"stt","id":req_id,"msg":repr(e)}
+            await BUS.pub(err)
+            yield _sse_encode(err)
+    return StreamingResponse(gen(), media_type="text/event-stream")
+# ---- Existing compatibility endpoints (non-stream) --------------------------
 @app.post("/speak")
+async def speak(body: Dict):
+    text = body.get("text","")
+    voice = body.get("voice")
+    desc  = body.get("description")
+    async with httpx.AsyncClient(timeout=120) as client:
+        r = await client.post(f"{ACTUAL_TTS}/speak", json={"text":text, **({"voice":voice} if voice else {}), **({"description":desc} if desc else {})})
+        return JSONResponse(r.json(), status_code=r.status_code)
 @app.post("/transcribe")
 async def transcribe(file: UploadFile = File(...), beam_size: int = 1, vad_filter: bool = True):
+    files = {"file": (file.filename, await file.read(), file.content_type or "audio/wav")}
+    params = {"beam_size":beam_size, "vad_filter":"true" if vad_filter else "false"}
+    async with httpx.AsyncClient(timeout=120) as client:
+        r = await client.post(f"{ACTUAL_STT}/transcribe", params=params, files=files)
+        return JSONResponse(r.json(), status_code=r.status_code)
+# (Optional) passthrough to python_ai/code_help so your tests still work
+@app.post("/code_help")
+async def code_help(body: Dict):
+    async with httpx.AsyncClient(timeout=60) as client:
+        r = await client.post(f"{PY_AI}/code_help", json=body)
+        return JSONResponse(r.json(), status_code=r.status_code)