elkay: api.py

utils/api.py

@@ -1,21 +1,19 @@
-import os, json, requests
+import os, json, requests, logging
 from urllib3.util.retry import Retry
 from requests.adapters import HTTPAdapter
 
 # ---- Setup ----
 BACKEND = (os.getenv("BACKEND_URL") or "").strip().rstrip("/")
 if not BACKEND:
-    # Fail fast at import; Streamlit will surface this in the sidebar on first run
     raise RuntimeError("BACKEND_URL is not set in Space secrets.")
 
-# Accept either BACKEND_TOKEN or HF_TOKEN
 TOKEN = (os.getenv("BACKEND_TOKEN") or os.getenv("HF_TOKEN") or "").strip()
 
-DEFAULT_TIMEOUT = int(os.getenv("BACKEND_TIMEOUT", "30"))
+# Increased timeout for potential late-night latency
+DEFAULT_TIMEOUT = int(os.getenv("BACKEND_TIMEOUT", "60"))
 
 _session = requests.Session()
 
-# Light retry for transient network/server blips
 retry = Retry(
     total=3,
     connect=3,
@@ -27,7 +25,6 @@ retry = Retry(
 _session.mount("https://", HTTPAdapter(max_retries=retry))
 _session.mount("http://", HTTPAdapter(max_retries=retry))
 
-# Default headers
 _session.headers.update({
     "Accept": "application/json, */*;q=0.1",
     "User-Agent": "FinEdu-Frontend/1.0 (+spaces)",
@@ -35,11 +32,14 @@ _session.headers.update({
 if TOKEN:
     _session.headers["Authorization"] = f"Bearer {TOKEN}"
 
+# Setup logging for debugging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
 def _json_or_raise(resp: requests.Response):
     ctype = resp.headers.get("content-type", "")
     if "application/json" in ctype:
         return resp.json()
-    # Try to parse anyway; show a helpful error if not JSON
     try:
         return resp.json()
     except Exception:
@@ -61,7 +61,6 @@ def _req(method: str, path: str, **kw):
         except Exception:
             pass
         status = getattr(r, "status_code", "?")
-        # Give nicer hints for common auth misconfigs
         if status in (401, 403):
             raise RuntimeError(
                 f"{method} {path} failed [{status}] – auth rejected. "
@@ -74,11 +73,9 @@ def _req(method: str, path: str, **kw):
 
 # ---- Health ----
 def health():
-    # Prefer /health but allow root fallback if you change the backend later
     try:
         return _json_or_raise(_req("GET", "/health"))
     except Exception:
-        # best-effort fallback
         try:
             _req("GET", "/")
             return {"ok": True}
@@ -89,18 +86,11 @@ def health():
 API_PREFIX_ENV = (os.getenv("BACKEND_API_PREFIX") or "").strip().rstrip("/")
 
 def _prefixes():
-    """Try only the configured prefix (if any) and the bare root."""
     if API_PREFIX_ENV:
         return ["/" + API_PREFIX_ENV.strip("/"), ""]
     return [""]
 
 def _try_candidates(method: str, candidates: list[tuple[str, dict]]):
-    """
-    candidates: list of (path, request_kwargs) where path starts with "/" and
-    kwargs may include {'params':..., 'json':...}.
-    Tries multiple prefixes (e.g., "", "/api", "/v1") and returns JSON for first 2xx.
-    Auth errors (401/403) are raised immediately.
-    """
     tried = []
     for pref in _prefixes():
         for path, kw in candidates:
@@ -109,14 +99,12 @@ def _try_candidates(method: str, candidates: list[tuple[str, dict]]):
             try:
                 r = _session.request(method, url, timeout=DEFAULT_TIMEOUT, **kw)
             except requests.RequestException as e:
-                # transient error: keep trying others
                 continue
             if r.status_code in (401, 403):
                 snippet = (r.text or "")[:200]
                 raise RuntimeError(f"{method} {path} auth failed [{r.status_code}]: {snippet}")
             if 200 <= r.status_code < 300:
                 return _json_or_raise(r)
-            # 404/405/etc.: try next candidate
     raise RuntimeError("No matching endpoint for this operation. Tried:\n- " + "\n- ".join(tried))
 
 # -- Helpers for student_db.py
@@ -126,19 +114,16 @@ def list_assignments_for_student(student_id: int):
     return _req("GET", f"/students/{student_id}/assignments").json()
 def student_quiz_average(student_id: int):
     d = _req("GET", f"/students/{student_id}/quiz_avg").json()
-    # Normalize common shapes: {"avg": 82}, {"score_pct": "82"}, "82", 82
     if isinstance(d, dict):
         for k in ("avg", "average", "score_pct", "score", "value"):
             if k in d:
                 v = d[k]
                 break
         else:
-            # fallback: first numeric-ish value
             v = next((vv for vv in d.values() if isinstance(vv, (int, float, str))), 0)
     else:
         v = d
     try:
-        # handle strings like "82" or "82%"
         return int(round(float(str(v).strip().rstrip("%"))))
     except Exception:
         return 0
@@ -149,7 +134,6 @@ def recent_lessons_for_student(student_id: int, limit: int = 5):
 def create_class(teacher_id: int, name: str):
     return _try_candidates("POST", [
         (f"/teachers/{teacher_id}/classes", {"json": {"name": name}}),
-        # fallbacks if you ever rename:
         ("/classes", {"json": {"teacher_id": teacher_id, "name": name}}),
     ])
 
@@ -164,9 +148,8 @@ def list_classes_by_teacher(teacher_id: int):
 def class_student_metrics(class_id: int):
     return _try_candidates("GET", [
         (f"/classes/{class_id}/students/metrics", {}),
-        # tolerant fallbacks:
         (f"/classes/{class_id}/student_metrics", {}),
-        (f"/classes/{class_id}/students", {}),   # older shape (list of students)
+        (f"/classes/{class_id}/students", {}),
     ])
 
 def class_weekly_activity(class_id: int):
@@ -190,14 +173,12 @@ def class_recent_activity(class_id: int, limit=6, days=30):
 def list_students_in_class(class_id: int):
     return _json_or_raise(_req("GET", f"/classes/{class_id}/students"))
 
-# Optional if you want to compute levels server-side
 def level_from_xp(xp: int):
     return _json_or_raise(_req("GET", "/levels/from_xp", params={"xp": xp}))["level"]
 
 # -- teacherlink.py helpers
 def join_class_by_code(student_id: int, code: str):
     d = _json_or_raise(_req("POST", f"/students/{student_id}/classes/join", json={"code": code}))
-    # backend may return {"class_id": ...} or full class object; both are fine
     return d.get("class_id", d)
 
 def list_classes_for_student(student_id: int):
@@ -213,7 +194,6 @@ def student_class_progress(student_id: int, class_id: int):
     return _json_or_raise(_req("GET", f"/classes/{class_id}/students/{student_id}/progress"))
 
 def leave_class(student_id: int, class_id: int):
-    # could also be DELETE /classes/{class_id}/students/{student_id}
     _json_or_raise(_req("POST", f"/classes/{class_id}/leave", json={"student_id": student_id}))
     return True
 
@@ -221,12 +201,9 @@ def student_assignments_for_class(student_id: int, class_id: int):
     return _json_or_raise(_req("GET", f"/classes/{class_id}/students/{student_id}/assignments"))
 
 # ---------- TEACHERS / CLASSES / CONTENT (BACKEND ROUTES THAT EXIST) ----------
-
-# Classes
 def create_class(teacher_id: int, name: str):
     return _try_candidates("POST", [
         (f"/teachers/{teacher_id}/classes", {"json": {"name": name}}),
-        # fallbacks if you ever rename:
         ("/classes", {"json": {"teacher_id": teacher_id, "name": name}}),
     ])
 
@@ -236,7 +213,6 @@ def list_classes_by_teacher(teacher_id: int):
     ])
 
 def list_students_in_class(class_id: int):
-    # exact route in backend
     return _json_or_raise(_req("GET", f"/classes/{class_id}/students"))
 
 def class_content_counts(class_id: int):
@@ -257,9 +233,8 @@ def teacher_tiles(teacher_id: int):
 def class_student_metrics(class_id: int):
     return _try_candidates("GET", [
         (f"/classes/{class_id}/students/metrics", {}),
-        # tolerant fallbacks:
         (f"/classes/{class_id}/student_metrics", {}),
-        (f"/classes/{class_id}/students", {}),   # older shape (list of students)
+        (f"/classes/{class_id}/students", {}),
     ])
 
 def class_weekly_activity(class_id: int):
@@ -295,7 +270,6 @@ def create_lesson(teacher_id: int, title: str, description: str,
     }
     d = _try_candidates("POST", [
         (f"/teachers/{teacher_id}/lessons", {"json": payload}),
-        # fallback if you later add a flat /lessons route:
         ("/lessons", {"json": {"teacher_id": teacher_id, **payload}}),
     ])
     return d.get("lesson_id", d.get("id", d))
@@ -352,11 +326,11 @@ def submit_quiz(*, lesson_id: int | None, level_slug: str | None,
     payload = {
         "lesson_id": int(lesson_id) if lesson_id is not None else None,
         "level_slug": level_slug,
-        "user_answers": user_answers,     # [{"question":"...", "answer":"A"}...]
-        "original_quiz": original_quiz,   # [{"question","options","answer_key"}...]
+        "user_answers": user_answers,
+        "original_quiz": original_quiz,
     }
     return _try_candidates("POST", [
-        ("/quiz/submit", {"json": payload}),  # Updated to match backend
+        ("/quiz/submit", {"json": payload}),
     ])
 
 def update_quiz(quiz_id: int,
@@ -392,10 +366,6 @@ def assign_to_class(lesson_id: int | None, quiz_id: int | None, class_id: int, t
 
 # ---------- LLM-based quiz generation (backend uses GEN_MODEL) ----------
 def generate_quiz_from_text(content: str, n_questions: int = 5, subject: str = "finance", level: str = "beginner"):
-    """
-    Backend should read GEN_MODEL from env and use your chosen model (llama-3.1-8b-instruct).
-    Return shape: {"items":[{"question":...,"options":[...],"answer_key":"A"}]}
-    """
     return _req("POST", "/quiz/generate", json={
         "content": content, "n_questions": n_questions, "subject": subject, "level": level
     }).json()
@@ -406,17 +376,18 @@ def generate_quiz(*, lesson_id: int | None, level_slug: str | None, lesson_title
         "level_slug": level_slug,
         "lesson_title": lesson_title,
     }
-
+    logger.debug(f"Generating quiz with POST method and payload: {payload}")
     try:
-        resp = _try_candidates("POST", [
-            ("/quiz/auto", {"json": payload}),
-        ])
+        resp = _req("POST", "/quiz/auto", json=payload)
+        logger.debug(f"Raw response from /quiz/auto: {resp.text}")
+        result = _json_or_raise(resp)
     except RuntimeError as e:
-        raise RuntimeError(f"Failed to generate quiz: {str(e)}")
+        logger.error(f"Quiz generation failed: {str(e)}")
+        return []  # Return empty list to prevent app crash
 
-    if isinstance(resp, dict):
-        return resp.get("items") or resp.get("quiz") or []
-    return resp if isinstance(resp, list) else []
+    if isinstance(result, dict):
+        return result.get("items") or result.get("quiz") or []
+    return result if isinstance(result, list) else []
 
 # ---- Legacy agent endpoints (keep) ----
 def start_agent(student_id: int, lesson_id: int, level_slug: str):