feat: switch to Docker SDK with custom FastAPI frontend at /

Dockerfile

@@ -0,0 +1,17 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y git curl && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+RUN useradd -m -u 1000 user && chown -R user /app
+USER user
+
+EXPOSE 7860
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]

README.md

@@ -1,12 +1,9 @@
 ---
 title: PaperProf
-emoji: 😻 cat
+emoji: 📄
 colorFrom: purple
 colorTo: blue
-sdk: gradio
-sdk_version: 6.16.0
-python_version: '3.12'
-app_file: app.py
+sdk: docker
 pinned: false
 ---
 

app.py

@@ -236,86 +236,5 @@ with gr.Blocks(title="PaperProf") as demo:
         outputs=[feedback_box, correct_state, total_state, score_box],
     )
 
-# ---------------------------------------------------------------------------
-# Custom frontend & stateless API — mounted on Gradio's internal FastAPI app
-# (demo.app is the FastAPI instance created when the Blocks context exits)
-# ---------------------------------------------------------------------------
-
-import os as _os
-import pathlib as _pathlib
-import tempfile as _tempfile
-from fastapi import File as _File, HTTPException as _HTTPException, UploadFile as _UploadFile
-from fastapi.responses import HTMLResponse as _HTMLResponse
-from pydantic import BaseModel as _BaseModel
-
-
-@demo.app.get("/paperprof-ui", response_class=_HTMLResponse)
-async def _serve_ui():
-    return (_pathlib.Path(__file__).parent / "ui" / "index.html").read_text(encoding="utf-8")
-
-
-@demo.app.post("/api/load")
-async def _api_load(file: _UploadFile = _File(...)):
-    if not (file.filename or "").lower().endswith(".pdf"):
-        raise _HTTPException(400, "Only PDF files are supported.")
-    content = await file.read()
-    with _tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as tmp:
-        tmp.write(content)
-        tmp_path = tmp.name
-    try:
-        text = extract_text(tmp_path)
-        chunks = chunk_text(text)
-        if not chunks:
-            raise _HTTPException(400, "No text found in PDF (scanned or too short?).")
-        return {"chunks": chunks, "count": len(chunks)}
-    except _HTTPException:
-        raise
-    except ValueError as exc:
-        raise _HTTPException(400, str(exc))
-    except Exception as exc:
-        raise _HTTPException(500, f"Unexpected error: {exc}")
-    finally:
-        _os.unlink(tmp_path)
-
-
-class _QuestionReq(_BaseModel):
-    chunk: str
-    language: str = "English"
-    difficulty: str = "Normal"
-
-
-@spaces.GPU(duration=60)
-def _api_gen_question(chunk: str, language: str, difficulty: str) -> str:
-    return generate_question(chunk, language=language, difficulty=difficulty)
-
-
-@demo.app.post("/api/question")
-def _api_question(req: _QuestionReq):
-    try:
-        return {"question": _api_gen_question(req.chunk, req.language, req.difficulty)}
-    except Exception as exc:
-        raise _HTTPException(500, str(exc))
-
-
-class _EvalReq(_BaseModel):
-    question: str
-    chunk: str
-    answer: str
-    language: str = "English"
-
-
-@spaces.GPU(duration=120)
-def _api_eval_answer(question: str, chunk: str, answer: str, language: str) -> str:
-    return evaluate_answer(question, chunk, answer, language=language)
-
-
-@demo.app.post("/api/evaluate")
-def _api_evaluate(req: _EvalReq):
-    try:
-        return {"feedback": _api_eval_answer(req.question, req.chunk, req.answer, req.language)}
-    except Exception as exc:
-        raise _HTTPException(500, str(exc))
-
-
 if __name__ == "__main__":
     pass

main.py

@@ -0,0 +1,128 @@
+"""
+main.py — FastAPI entry point for PaperProf (Docker / HuggingFace Spaces).
+
+Routes:
+  GET  /           → custom HTML frontend
+  POST /api/load   → parse PDF, return chunks (CPU)
+  POST /api/question → generate question from chunk (GPU via @spaces.GPU)
+  POST /api/evaluate → evaluate student answer (GPU via @spaces.GPU)
+  *    /gradio/*   → Gradio interface as fallback
+"""
+
+import os
+import pathlib
+import tempfile
+
+import gradio as gr
+from fastapi import FastAPI, File, HTTPException, Request, UploadFile
+from fastapi.responses import HTMLResponse
+
+from app import demo
+from core.parser import extract_text
+from core.chunker import chunk_text
+from core.questioner import generate_question
+from core.evaluator import evaluate_answer
+
+try:
+    import spaces
+except ImportError:
+    class spaces:  # noqa: N801 — local dev fallback
+        @staticmethod
+        def GPU(duration=60):
+            def wrap(fn): return fn
+            return wrap
+
+# ─────────────────────────────────────────────────────────────────────────────
+# FastAPI app
+# ─────────────────────────────────────────────────────────────────────────────
+
+fastapi_app = FastAPI(title="PaperProf", docs_url=None, redoc_url=None)
+
+
+@fastapi_app.get("/", response_class=HTMLResponse)
+async def root():
+    return pathlib.Path("ui/index.html").read_text(encoding="utf-8")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# /api/load — parse uploaded PDF into text chunks (no GPU needed)
+# ─────────────────────────────────────────────────────────────────────────────
+
+@fastapi_app.post("/api/load")
+async def api_load(file: UploadFile = File(...)):
+    if not (file.filename or "").lower().endswith(".pdf"):
+        raise HTTPException(400, "Only PDF files are supported.")
+    content = await file.read()
+    with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as tmp:
+        tmp.write(content)
+        tmp_path = tmp.name
+    try:
+        text = extract_text(tmp_path)
+        chunks = chunk_text(text)
+        if not chunks:
+            raise HTTPException(400, "No text found in PDF (scanned or too short?).")
+        return {"chunks": chunks, "count": len(chunks)}
+    except HTTPException:
+        raise
+    except ValueError as exc:
+        raise HTTPException(400, str(exc))
+    except Exception as exc:
+        raise HTTPException(500, f"Unexpected error: {exc}")
+    finally:
+        os.unlink(tmp_path)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# /api/question — generate a study question from a chunk (GPU)
+# ─────────────────────────────────────────────────────────────────────────────
+
+@spaces.GPU(duration=60)
+def _gen_question(chunk: str, language: str, difficulty: str) -> str:
+    return generate_question(chunk, language, difficulty)
+
+
+@fastapi_app.post("/api/question")
+async def api_question(request: Request):
+    body = await request.json()
+    chunk      = body.get("chunk", "")
+    language   = body.get("language", "English")
+    difficulty = body.get("difficulty", "Normal")
+    if not chunk:
+        raise HTTPException(400, "chunk is required.")
+    try:
+        question = _gen_question(chunk, language, difficulty)
+        return {"question": question}
+    except Exception as exc:
+        raise HTTPException(500, str(exc))
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# /api/evaluate — evaluate student answer against source chunk (GPU)
+# ─────────────────────────────────────────────────────────────────────────────
+
+@spaces.GPU(duration=120)
+def _eval_answer(question: str, chunk: str, answer: str, language: str) -> str:
+    return evaluate_answer(question, chunk, answer, language)
+
+
+@fastapi_app.post("/api/evaluate")
+async def api_evaluate(request: Request):
+    body = await request.json()
+    question = body.get("question", "")
+    chunk    = body.get("chunk", "")
+    answer   = body.get("answer", "")
+    language = body.get("language", "English")
+    if not (question and chunk and answer):
+        raise HTTPException(400, "question, chunk, and answer are required.")
+    try:
+        feedback = _eval_answer(question, chunk, answer, language)
+        return {"feedback": feedback}
+    except Exception as exc:
+        raise HTTPException(500, str(exc))
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Mount Gradio at /gradio as fallback and export the combined ASGI app
+# ─────────────────────────────────────────────────────────────────────────────
+
+app = gr.mount_gradio_app(fastapi_app, demo, path="/gradio")

requirements.txt

@@ -5,6 +5,7 @@ gradio>=4.36.0
 fastapi>=0.100.0
 uvicorn>=0.23.0
 python-multipart>=0.0.6
+spaces>=0.50.0
 
 # PDF extraction
 PyMuPDF>=1.24.0