try 3

dashboards/teacher_db.py

@@ -1,12 +1,16 @@
 # dashboards/teacher_db.py
-import streamlit as st
 import os
-import plotly.express as px
-import plotly.graph_objects as go
-import csv
 import io
+import csv
 import datetime
+import streamlit as st
+import plotly.graph_objects as go
+
 from utils import db as dbapi
+import utils.api as api  # backend Space client
+
+# If DISABLE_DB=1 (default), don't call MySQL at all
+USE_LOCAL_DB = os.getenv("DISABLE_DB", "1") != "1"
 
 def load_css(file_name):
     try:
@@ -24,6 +28,87 @@ def tile(icon, label, value):
     </div>
     """
 
+def _level_from_xp(xp: int) -> int:
+    """
+    Prefer backend/db helper if available, else simple fallback (every 500 XP = +1 level).
+    """
+    try:
+        if USE_LOCAL_DB and hasattr(dbapi, "level_from_xp"):
+            return int(dbapi.level_from_xp(xp))
+        if hasattr(api, "level_from_xp"):  # if you add the endpoint
+            return int(api.level_from_xp(int(xp)))
+    except Exception:
+        pass
+    xp = int(xp or 0)
+    return 1 + (xp // 500)
+
+def _safe_get_tiles(teacher_id: int) -> dict:
+    if USE_LOCAL_DB and hasattr(dbapi, "teacher_tiles"):
+        return dbapi.teacher_tiles(teacher_id)
+    try:
+        return api.teacher_tiles(teacher_id)
+    except Exception:
+        return {
+            "total_students": 0, "class_avg": 0.0,
+            "lessons_created": 0, "active_students": 0
+        }
+
+def _safe_list_classes(teacher_id: int) -> list:
+    if USE_LOCAL_DB and hasattr(dbapi, "list_classes_by_teacher"):
+        return dbapi.list_classes_by_teacher(teacher_id)
+    try:
+        return api.list_classes_by_teacher(teacher_id)
+    except Exception:
+        return []
+
+def _safe_create_class(teacher_id: int, name: str) -> dict:
+    if USE_LOCAL_DB and hasattr(dbapi, "create_class"):
+        return dbapi.create_class(teacher_id, name)
+    return api.create_class(teacher_id, name)
+
+def _safe_class_student_metrics(class_id: int) -> list:
+    if USE_LOCAL_DB and hasattr(dbapi, "class_student_metrics"):
+        return dbapi.class_student_metrics(class_id)
+    try:
+        return api.class_student_metrics(class_id)
+    except Exception:
+        return []
+
+def _safe_weekly_activity(class_id: int) -> list:
+    if USE_LOCAL_DB and hasattr(dbapi, "class_weekly_activity"):
+        return dbapi.class_weekly_activity(class_id)
+    try:
+        return api.class_weekly_activity(class_id)
+    except Exception:
+        return []
+
+def _safe_progress_overview(class_id: int) -> dict:
+    if USE_LOCAL_DB and hasattr(dbapi, "class_progress_overview"):
+        return dbapi.class_progress_overview(class_id)
+    try:
+        return api.class_progress_overview(class_id)
+    except Exception:
+        return {
+            "overall_progress": 0.0, "quiz_performance": 0.0,
+            "lessons_completed": 0, "class_xp": 0
+        }
+
+def _safe_recent_activity(class_id: int, limit=6, days=30) -> list:
+    if USE_LOCAL_DB and hasattr(dbapi, "class_recent_activity"):
+        return dbapi.class_recent_activity(class_id, limit=limit, days=days)
+    try:
+        return api.class_recent_activity(class_id, limit=limit, days=days)
+    except Exception:
+        return []
+
+def _safe_list_students(class_id: int) -> list:
+    if USE_LOCAL_DB and hasattr(dbapi, "list_students_in_class"):
+        return dbapi.list_students_in_class(class_id)
+    try:
+        return api.list_students_in_class(class_id)
+    except Exception:
+        return []
+
 def show_teacher_dashboard():
     css_path = os.path.join("assets", "styles.css")
     load_css(css_path)

phase/Student_view/teacherlink.py

@@ -2,6 +2,9 @@
 import os
 import streamlit as st
 from utils import db as dbapi
+import utils.api as api  # <-- backend Space client
+
+USE_LOCAL_DB = os.getenv("DISABLE_DB", "1") != "1"  # DB only when DISABLE_DB=0
 
 def load_css(file_name: str):
     try:
@@ -18,6 +21,57 @@ def _progress_0_1(v):
     # accept 0..1 or 0..100
     return max(0.0, min(1.0, f if f <= 1.0 else f / 100.0))
 
+# --- Small wrappers to switch between DB and Backend ---
+
+def _join_class_by_code(student_id: int, code: str):
+    if USE_LOCAL_DB and hasattr(dbapi, "join_class_by_code"):
+        return dbapi.join_class_by_code(student_id, code)
+    return api.join_class_by_code(student_id, code)
+
+def _list_classes_for_student(student_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "list_classes_for_student"):
+        return dbapi.list_classes_for_student(student_id)
+    try:
+        return api.list_classes_for_student(student_id)
+    except Exception:
+        return []
+
+def _class_content_counts(class_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "class_content_counts"):
+        return dbapi.class_content_counts(class_id)
+    try:
+        return api.class_content_counts(class_id)
+    except Exception:
+        return {"lessons": 0, "quizzes": 0}
+
+def _student_class_progress(student_id: int, class_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "student_class_progress"):
+        return dbapi.student_class_progress(student_id, class_id)
+    try:
+        return api.student_class_progress(student_id, class_id)
+    except Exception:
+        return {
+            "overall_progress": 0,
+            "lessons_completed": 0,
+            "total_assigned_lessons": 0,
+            "avg_score": 0,
+        }
+
+def _leave_class(student_id: int, class_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "leave_class"):
+        return dbapi.leave_class(student_id, class_id)
+    return api.leave_class(student_id, class_id)
+
+def _student_assignments_for_class(student_id: int, class_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "student_assignments_for_class"):
+        return dbapi.student_assignments_for_class(student_id, class_id)
+    try:
+        return api.student_assignments_for_class(student_id, class_id)
+    except Exception:
+        return []
+
+# --- UI ---
+
 def show_code():
     load_css(os.path.join("assets", "styles.css"))
 
@@ -33,7 +87,7 @@ def show_code():
     st.caption("Enter class code from your teacher")
 
     raw = st.text_input(
-        label="Class Code", 
+        label="Class Code",
         placeholder="e.g. FIN5A2024",
         key="class_code_input",
         label_visibility="collapsed"
@@ -65,16 +119,18 @@ def show_code():
             st.error("Enter a class code.")
         else:
             try:
-                class_id = dbapi.join_class_by_code(student_id, code)
+                _join_class_by_code(student_id, code)
                 st.success("🎉 Joined the class!")
                 st.rerun()
             except ValueError as e:
                 st.error(str(e))
+            except Exception as e:
+                st.error(f"Could not join class: {e}")
 
     st.markdown("---")
     st.markdown("## Your Classes")
 
-    classes = dbapi.list_classes_for_student(student_id)
+    classes = _list_classes_for_student(student_id)
     if not classes:
         st.info("You haven’t joined any classes yet. Ask your teacher for a class code.")
         return
@@ -82,36 +138,44 @@ def show_code():
     # one card per class
     for c in classes:
         class_id = c["class_id"]
-        counts   = dbapi.class_content_counts(class_id)      # lessons/quizzes count
-        prog     = dbapi.student_class_progress(student_id, class_id)
+        counts   = _class_content_counts(class_id)             # lessons/quizzes count
+        prog     = _student_class_progress(student_id, class_id)
 
-        st.markdown(f"### {c['name']}")
-        st.caption(f"Teacher: {c['teacher_name']} • Code: {c['code']} • Joined: {str(c['joined_at'])[:10]}")
+        st.markdown(f"### {c.get('name', 'Untitled Class')}")
+        st.caption(
+            f"Teacher: {c.get('teacher_name','—')} • "
+            f"Code: {c.get('code','—')} • "
+            f"Joined: {str(c.get('joined_at',''))[:10] if c.get('joined_at') else '—'}"
+        )
 
-        st.progress(_progress_0_1(prog["overall_progress"]))
+        st.progress(_progress_0_1(prog.get("overall_progress", 0)))
+        avg_pct = int(round(100 * _progress_0_1(prog.get("avg_score", 0))))
         st.caption(
-            f"{prog['lessons_completed']}/{prog['total_assigned_lessons']} lessons completed • "
-            f"Avg quiz: {int(round(100 * (prog['avg_score'] or 0)))}%"
+            f"{prog.get('lessons_completed', 0)}/{prog.get('total_assigned_lessons', 0)} lessons completed • "
+            f"Avg quiz: {avg_pct}%"
         )
 
         # top metrics
         m1, m2, m3, m4 = st.columns(4)
         m1.metric("Lessons", counts.get("lessons", 0))
         m2.metric("Quizzes", counts.get("quizzes", 0))
-        m3.metric("Overall", f"{int(round(100*_progress_0_1(prog['overall_progress'])))}%")
-        m4.metric("Avg Quiz", f"{int(round(100*(prog['avg_score'] or 0)))}%")
+        m3.metric("Overall", f"{int(round(100 * _progress_0_1(prog.get('overall_progress', 0))))}%")
+        m4.metric("Avg Quiz", f"{avg_pct}%")
 
         # Leave class
-        leave_col, _ = st.columns([1,3])
+        leave_col, _ = st.columns([1, 3])
         with leave_col:
             if st.button("🚪 Leave Class", key=f"leave_{class_id}"):
-                dbapi.leave_class(student_id, class_id)
-                st.toast("Left class.", icon="👋")
-                st.rerun()
+                try:
+                    _leave_class(student_id, class_id)
+                    st.toast("Left class.", icon="👋")
+                    st.rerun()
+                except Exception as e:
+                    st.error(f"Could not leave class: {e}")
 
         # Assignments for THIS class with THIS student's progress
         st.markdown("#### Teacher Lessons & Quizzes")
-        rows = dbapi.student_assignments_for_class(student_id, class_id)
+        rows = _student_assignments_for_class(student_id, class_id)
         if not rows:
             st.info("No assignments yet.")
         else:
@@ -119,23 +183,29 @@ def show_code():
 
             with lessons_tab:
                 for r in rows:
-                    if r["lesson_id"] is None:
+                    if r.get("lesson_id") is None:
                         continue
 
                     status = r.get("status") or "not_started"
                     pos = r.get("current_pos") or 0
-                    pct = 1.0 if status == "completed" else min(0.95, float(pos or 0) * 0.1)
-
-                    st.subheader(r["title"])
-                    st.caption(f"{r['subject']} • {r['level']} • Due: {str(r['due_at'])[:10] if r.get('due_at') else '—'}")
+                    # if backend returns explicit progress % or 0..1, keep it sane:
+                    pct = r.get("progress")
+                    if pct is None:
+                        # fallback: estimate from position
+                        pct = 1.0 if status == "completed" else min(0.95, float(pos or 0) * 0.1)
+
+                    st.subheader(r.get("title", "Untitled"))
+                    due = r.get("due_at")
+                    due_txt = f"Due: {str(due)[:10]}" if due else "—"
+                    st.caption(f"{r.get('subject','General')} • {r.get('level','Beginner')} • {due_txt}")
                     st.progress(_progress_0_1(pct))
 
                     c1, c2 = st.columns(2)
                     with c1:
-                        #  pass lesson & assignment to the Lessons page
-                        if st.button("▶️ Start Lesson", key=f"start_lesson_{r['assignment_id']}"):
-                            st.session_state.selected_lesson = r["lesson_id"]
-                            st.session_state.selected_assignment = r["assignment_id"]
+                        # pass lesson & assignment to the Lessons page
+                        if st.button("▶️ Start Lesson", key=f"start_lesson_{r.get('assignment_id')}"):
+                            st.session_state.selected_lesson = r.get("lesson_id")
+                            st.session_state.selected_assignment = r.get("assignment_id")
                             st.session_state.current_page = "Lessons"
                             st.rerun()
                     with c2:
@@ -144,21 +214,26 @@ def show_code():
             with quizzes_tab:
                 any_quiz = False
                 for r in rows:
-                    if not r.get("quiz_id"):
+                    quiz_id = r.get("quiz_id")
+                    if not quiz_id:
                         continue
                     any_quiz = True
 
-                    st.subheader(r["title"])
+                    st.subheader(r.get("title", "Untitled"))
                     score, total = r.get("score"), r.get("total")
                     if score is not None and total:
-                        st.caption(f"Last score: {int(round(100*float(score)/float(total)))}%")
+                        try:
+                            pct = int(round(100 * float(score) / float(total)))
+                            st.caption(f"Last score: {pct}%")
+                        except Exception:
+                            st.caption("Last score: —")
                     else:
                         st.caption("No submission yet")
 
-                    #  pass quiz & assignment to the Quiz page
-                    if st.button("📝 Start Quiz", key=f"start_quiz_{class_id}_{r['quiz_id']}"):
-                        st.session_state.selected_quiz = r["quiz_id"]            # numeric quiz_id from DB
-                        st.session_state.current_assignment = r["assignment_id"] # you’ll need this when submitting
+                    # pass quiz & assignment to the Quiz page
+                    if st.button("📝 Start Quiz", key=f"start_quiz_{class_id}_{quiz_id}"):
+                        st.session_state.selected_quiz = quiz_id
+                        st.session_state.current_assignment = r.get("assignment_id")
                         st.session_state.current_page = "Quiz"
                         st.rerun()
 

phase/Teacher_view/classmanage.py

@@ -1,10 +1,13 @@
 # phase/Teacher_view/classmanage.py
-
+import os
 import streamlit as st
-import random
-import string
-from datetime import datetime
+
 from utils import db as dbapi
+import utils.api as api  # backend Space client
+
+# When DISABLE_DB=1 (default), skip direct MySQL and use backend APIs
+USE_LOCAL_DB = os.getenv("DISABLE_DB", "1") != "1"
+
 
 def _metric_card(label: str, value: str, caption: str = ""):
     st.markdown(
@@ -18,6 +21,23 @@ def _metric_card(label: str, value: str, caption: str = ""):
         unsafe_allow_html=True,
     )
 
+
+def _prefer_db(db_name: str, api_func, default, *args, **kwargs):
+    """
+    Try local DB function if enabled & present; else call backend API; else return default.
+    """
+    if USE_LOCAL_DB and hasattr(dbapi, db_name):
+        try:
+            return getattr(dbapi, db_name)(*args, **kwargs)
+        except Exception as e:
+            st.warning(f"DB call {db_name} failed; falling back to backend. ({e})")
+    try:
+        return api_func(*args, **kwargs)
+    except Exception as e:
+        st.error(f"Backend call failed: {e}")
+        return default
+
+
 def show_page():
     user = st.session_state.user
     teacher_id = user["user_id"]
@@ -30,29 +50,45 @@ def show_page():
         new_name = st.text_input("Classroom Name", key="new_classroom_name")
         if st.button("Create Classroom"):
             name = new_name.strip()
-            if name:
-                out = dbapi.create_class(teacher_id, name)
-                st.session_state.selected_class_id = out["class_id"]
-                st.success(f'Classroom "{name}" created with code: {out["code"]}')
-                st.rerun()
-            else:
+            if not name:
                 st.error("Enter a real name, not whitespace.")
+            else:
+                # positional args first, then keywords (we only use positional here)
+                out = _prefer_db(
+                    "create_class",
+                    lambda tid, n: api.create_class(tid, n),
+                    None,
+                    teacher_id,
+                    name,
+                )
+                if out:
+                    st.session_state.selected_class_id = out.get("class_id")
+                    st.success(f'Classroom "{name}" created with code: {out.get("code","—")}')
+                    st.rerun()
+                else:
+                    st.error("Could not create classroom (no response).")
 
     # -------- Load classes for this teacher --------
-    classes = dbapi.list_classes_by_teacher(teacher_id)
+    classes = _prefer_db(
+        "list_classes_by_teacher",
+        lambda tid: api.list_classes_by_teacher(tid),
+        [],
+        teacher_id,  # positional
+    )
+
     if not classes:
         st.info("No classrooms yet. Create one above, then share the code.")
         return
 
-    # Picker like your mock header bar
+    # Picker
     st.subheader("Your Classrooms")
-    options = {f"{c['name']} (Code: {c.get('code','')})": c for c in classes}
+    options = {f"{c.get('name','(unnamed)')} (Code: {c.get('code','')})": c for c in classes}
     selected_label = st.selectbox("Select a classroom", list(options.keys()))
     selected = options[selected_label]
     class_id = selected["class_id"]
 
     st.markdown("---")
-    st.header(selected["name"])
+    st.header(selected.get("name", "Classroom"))
 
     # -------- Code stripe --------
     st.subheader("Class Code")
@@ -70,14 +106,18 @@ def show_page():
 
     # ============== Students tab ==============
     with tab_students:
-        # search input
         q = st.text_input("Search students by name or email", "")
-        roster = dbapi.list_students_in_class(class_id)
+        roster = _prefer_db(
+            "list_students_in_class",
+            lambda cid: api.list_students_in_class(cid),
+            [],
+            class_id,  # positional
+        )
 
         # simple filter
         if q.strip():
             ql = q.lower()
-            roster = [r for r in roster if ql in r["name"].lower() or ql in r["email"].lower()]
+            roster = [r for r in roster if ql in (r.get("name","").lower()) or ql in (r.get("email","").lower())]
 
         st.caption(f"{len(roster)} Students Found")
 
@@ -85,41 +125,65 @@ def show_page():
             st.info("No students in this class yet.")
         else:
             for s in roster:
-                st.subheader(f"👤 {s['name']}")
-                st.caption(s["email"])
+                st.subheader(f"👤 {s.get('name','(unknown)')}")
+                st.caption(s.get("email","—"))
                 joined = s.get("joined_at") or s.get("created_at")
-                st.caption(f"📅 Joined: {str(joined)[:10]}")
-                st.progress(0.0)  # placeholder bar to match your style
+                st.caption(f"📅 Joined: {str(joined)[:10] if joined else '—'}")
+                st.progress(0.0)  # placeholder bar
                 cols = st.columns(3)
-                cols[0].metric("⭐ Level", s["level_slug"].capitalize())
-                cols[1].metric("📊 Avg Score", "—")    # can be filled per-student later
-                cols[2].metric("🔥 Streak", "—")       # from streaks table if you want
+                level_slug = (s.get("level_slug") or s.get("level") or "beginner")
+                try:
+                    level_label = level_slug.capitalize() if isinstance(level_slug, str) else str(level_slug)
+                except Exception:
+                    level_label = "—"
+                cols[0].metric("⭐ Level", level_label)
+                cols[1].metric("📊 Avg Score", "—")
+                cols[2].metric("🔥 Streak", "—")
                 st.markdown("---")
 
     # ============== Content tab ==============
     with tab_content:
-        counts = dbapi.class_content_counts(class_id)
+        counts = _prefer_db(
+            "class_content_counts",
+            lambda cid: api.class_content_counts(cid),
+            {"lessons": 0, "quizzes": 0},
+            class_id,  # positional
+        )
         left, right = st.columns(2)
         with left:
-            _metric_card("📖 Custom Lessons", str(counts["lessons"]), "Lessons created for this classroom")
+            _metric_card("📖 Custom Lessons", str(counts.get("lessons", 0)), "Lessons created for this classroom")
         with right:
-            _metric_card("🏆 Custom Quizzes", str(counts["quizzes"]), "Quizzes created for this classroom")
-
-        # Optional list so teachers know what those numbers are
-        assigs = dbapi.list_class_assignments(class_id)
+            _metric_card("🏆 Custom Quizzes", str(counts.get("quizzes", 0)), "Quizzes created for this classroom")
+
+        assigs = _prefer_db(
+            "list_class_assignments",
+            lambda cid: api.list_class_assignments(cid),
+            [],
+            class_id,  # positional
+        )
         if assigs:
             st.markdown("#### Assigned items")
             for a in assigs:
-                has_quiz = " + Quiz" if a["quiz_id"] else ""
-                st.markdown(f"- **{a['title']}** · {a['subject']} · {a['level']}{has_quiz}")
+                has_quiz = " + Quiz" if a.get("quiz_id") else ""
+                st.markdown(f"- **{a.get('title','Untitled')}** · {a.get('subject','—')} · {a.get('level','—')}{has_quiz}")
 
     # ============== Analytics tab ==============
     with tab_analytics:
-        stats = dbapi.class_analytics(class_id)
+        stats = _prefer_db(
+            "class_analytics",
+            lambda cid: api.class_analytics(cid),
+            {"class_avg": 0.0, "total_xp": 0, "lessons_completed": 0},
+            class_id,  # positional
+        )
+
+        class_avg_pct = round(float(stats.get("class_avg", 0)) * 100) if stats.get("class_avg") is not None else 0
+        total_xp = stats.get("total_xp", 0)
+        lessons_completed = stats.get("lessons_completed", 0)
+
         g1, g2, g3 = st.columns(3)
         with g1:
-            _metric_card("📊 Class Average", f"{round(stats['class_avg']*100)}%", "Average quiz performance")
+            _metric_card("📊 Class Average", f"{class_avg_pct}%", "Average quiz performance")
         with g2:
-            _metric_card("🪙 Total XP", f"{stats['total_xp']}", "Combined XP earned")
+            _metric_card("🪙 Total XP", f"{total_xp}", "Combined XP earned")
         with g3:
-            _metric_card("📘 Lessons Completed", f"{stats['lessons_completed']}", "Total lessons completed")
+            _metric_card("📘 Lessons Completed", f"{lessons_completed}", "Total lessons completed")

phase/Teacher_view/contentmanage.py

@@ -1,8 +1,13 @@
 # phase/Teacher_view/contentmanage.py
 import json
-import streamlit as st
+import os
 from datetime import datetime
+import streamlit as st
 from utils import db as dbapi
+import utils.api as api  # backend Space client
+
+# Switch automatically: if DISABLE_DB=1 (default), use backend API; else use local DB
+USE_LOCAL_DB = os.getenv("DISABLE_DB", "1") != "1"
 
 # ---------- small UI helpers ----------
 def _pill(text):
@@ -16,36 +21,28 @@ def _progress(val: float):
     </div>
     """
 
+def _fmt_date(v):
+    if isinstance(v, datetime):
+        return v.strftime("%Y-%m-%d")
+    try:
+        s = str(v)
+        return s[:10]
+    except Exception:
+        return ""
 
-# ---------- OpenAI quiz generator ----------
-def _generate_quiz_from_text(content: str, n_questions: int = 5):
+# ---------- Quiz generator via backend LLM (llama 3.1 8B) ----------
+def _generate_quiz_from_text(content: str, n_questions: int = 5, subject: str = "finance", level: str = "beginner"):
     """
-    Returns a list of dicts like:
-      {"question": "...", "options": ["A","B","C","D"], "answer_key": "B", "points": 1}
-    Uses OPENAI_API_KEY from your env.
+    Calls your backend, which uses GEN_MODEL (llama-3.1-8b-instruct).
+    Returns a normalized list like:
+      [{"question":"...","options":["A","B","C","D"],"answer_key":"B","points":1}, ...]
     """
-    system = (
-        "You are a Jamaican primary school financial literacy teacher. "
-        "Write clear multiple-choice questions (A-D) about the provided lesson content. "
-        "Keep language simple and age-appropriate. Only one correct answer per question."
-    )
-    user = (
-        f"Create {n_questions} MCQs strictly in this JSON format:\n"
-        "{\n"
-        '  \"items\":[\n'
-        '    {\"question\":\"...\", \"options\":[\"A\",\"B\",\"C\",\"D\"], \"answer_key\":\"A\"}\n'
-        "  ]\n"
-        "}\n\n"
-        "Lesson content:\n"
-        f"{content}"
-    )
-
     def _normalize(items):
         out = []
         for it in (items or [])[:n_questions]:
             q = str(it.get("question", "")).strip()
             opts = it.get("options", [])
-            if not q or not isinstance(opts, list) or len(opts) < 2:
+            if not q or not isinstance(opts, list):
                 continue
             while len(opts) < 4:
                 opts.append("Option")
@@ -57,53 +54,108 @@ def _generate_quiz_from_text(content: str, n_questions: int = 5):
         return out
 
     try:
-        from openai import OpenAI
-        client = OpenAI()
-
-        # 1) Preferred path: Responses API
-        try:
-            resp = client.responses.create(
-                model="gpt-4o-mini",
-                temperature=0.2,
-                response_format={"type": "json_object"},
-                input=[
-                    {"role": "system", "content": [{"type": "text", "text": system}]},
-                    {"role": "user",   "content": [{"type": "text", "text": user}]},
-                ],
-            )
-            raw = getattr(resp, "output_text", "") or ""
-            data = json.loads(raw)
-            return _normalize(data.get("items", []))
-
-        # 2) Fallback: Chat Completions
-        except Exception:
-            resp = client.chat.completions.create(
-                model="gpt-4o-mini",
-                temperature=0.2,
-                messages=[{"role":"system","content":system},{"role":"user","content":user}],
-                response_format={"type": "json_object"},
-            )
-            raw = resp.choices[0].message.content.strip()
-            data = json.loads(raw)
-            return _normalize(data.get("items", []))
-
+        resp = api.generate_quiz_from_text(content, n_questions=n_questions, subject=subject, level=level)
+        items = resp.get("items", resp)  # allow backend to return either shape
+        return _normalize(items)
     except Exception as e:
         with st.expander("Quiz generation error details"):
             st.code(str(e))
-        st.warning("Quiz generation failed. Check API key and your openai package version.")
+        st.warning("Quiz generation failed via backend. Check the /quiz/generate endpoint and GEN_MODEL.")
         return []
 
+# ---------- Thin wrappers that choose DB or Backend ----------
+def _list_classes_by_teacher(teacher_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "list_classes_by_teacher"):
+        return dbapi.list_classes_by_teacher(teacher_id)
+    try:
+        return api.list_classes_by_teacher(teacher_id)
+    except Exception:
+        return []
+
+def _list_all_students_for_teacher(teacher_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "list_all_students_for_teacher"):
+        return dbapi.list_all_students_for_teacher(teacher_id)
+    try:
+        return api.list_all_students_for_teacher(teacher_id)
+    except Exception:
+        return []
+
+def _list_lessons_by_teacher(teacher_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "list_lessons_by_teacher"):
+        return dbapi.list_lessons_by_teacher(teacher_id)
+    try:
+        return api.list_lessons_by_teacher(teacher_id)
+    except Exception:
+        return []
+
+def _list_quizzes_by_teacher(teacher_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "list_quizzes_by_teacher"):
+        return dbapi.list_quizzes_by_teacher(teacher_id)
+    try:
+        return api.list_quizzes_by_teacher(teacher_id)
+    except Exception:
+        return []
+
+def _create_lesson(teacher_id: int, title: str, description: str, subject: str, level: str, sections: list[dict]):
+    if USE_LOCAL_DB and hasattr(dbapi, "create_lesson"):
+        return dbapi.create_lesson(teacher_id, title, description, subject, level, sections)
+    return api.create_lesson(teacher_id, title, description, subject, level, sections)
+
+def _update_lesson(lesson_id: int, teacher_id: int, title: str, description: str, subject: str, level: str, sections: list[dict]):
+    if USE_LOCAL_DB and hasattr(dbapi, "update_lesson"):
+        return dbapi.update_lesson(lesson_id, teacher_id, title, description, subject, level, sections)
+    return api.update_lesson(lesson_id, teacher_id, title, description, subject, level, sections)
+
+def _delete_lesson(lesson_id: int, teacher_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "delete_lesson"):
+        return dbapi.delete_lesson(lesson_id, teacher_id)
+    return api.delete_lesson(lesson_id, teacher_id)
+
+def _get_lesson(lesson_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "get_lesson"):
+        return dbapi.get_lesson(lesson_id)
+    return api.get_lesson(lesson_id)
+
+def _create_quiz(lesson_id: int, title: str, items: list[dict], settings: dict):
+    if USE_LOCAL_DB and hasattr(dbapi, "create_quiz"):
+        return dbapi.create_quiz(lesson_id, title, items, settings)
+    return api.create_quiz(lesson_id, title, items, settings)
+
+def _update_quiz(quiz_id: int, teacher_id: int, title: str, items: list[dict], settings: dict):
+    if USE_LOCAL_DB and hasattr(dbapi, "update_quiz"):
+        return dbapi.update_quiz(quiz_id, teacher_id, title, items, settings)
+    return api.update_quiz(quiz_id, teacher_id, title, items, settings)
+
+def _delete_quiz(quiz_id: int, teacher_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "delete_quiz"):
+        return dbapi.delete_quiz(quiz_id, teacher_id)
+    return api.delete_quiz(quiz_id, teacher_id)
+
+def _list_assigned_students_for_lesson(lesson_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "list_assigned_students_for_lesson"):
+        return dbapi.list_assigned_students_for_lesson(lesson_id)
+    return api.list_assigned_students_for_lesson(lesson_id)
+
+def _list_assigned_students_for_quiz(quiz_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "list_assigned_students_for_quiz"):
+        return dbapi.list_assigned_students_for_quiz(quiz_id)
+    return api.list_assigned_students_for_quiz(quiz_id)
+
+def _assign_to_class(lesson_id: int | None, quiz_id: int | None, class_id: int, teacher_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "assign_to_class"):
+        return dbapi.assign_to_class(lesson_id, quiz_id, class_id, teacher_id)
+    return api.assign_to_class(lesson_id, quiz_id, class_id, teacher_id)
+
 # ---------- Create panels ----------
 def _create_lesson_panel(teacher_id: int):
     st.markdown("### ✍️ Create New Lesson")
 
-    classes = dbapi.list_classes_by_teacher(teacher_id)
+    classes = _list_classes_by_teacher(teacher_id)
     class_opts = {f"{c['name']} (code {c['code']})": c["class_id"] for c in classes} if classes else {}
 
     if "cl_topic_count" not in st.session_state:
         st.session_state.cl_topic_count = 2  # start with two topics
 
-    # UI-manipulation buttons OUTSIDE the form
     cols_btn = st.columns([1,1,6])
     with cols_btn[0]:
         if st.button("➕ Add topic", type="secondary"):
@@ -144,16 +196,13 @@ def _create_lesson_panel(teacher_id: int):
 
         st.markdown("#### Auto-generate a quiz from this lesson (optional)")
         gen_quiz = st.checkbox("Generate a quiz from content", value=False)
-        q_count = st.slider("", 3, 10, 5)  # label empty because already described
-        
-        # ONLY keep the main submit button inside the form
-        submitted = st.form_submit_button("Create lesson", type="primary")
+        q_count = st.slider("", 3, 10, 5)
 
+        submitted = st.form_submit_button("Create lesson", type="primary")
 
     if not submitted:
         return
 
-    # build sections payload for DB
     sections = []
     for t, b in topic_rows:
         if (t or b):
@@ -169,41 +218,47 @@ def _create_lesson_panel(teacher_id: int):
         st.error("Please add a title and at least one topic.")
         return
 
-    # create lesson
-    lesson_id = dbapi.create_lesson(teacher_id, title, description, subject, level, sections)
-    st.success(f"✅ Lesson created (ID {lesson_id}).")
+    # create lesson (DB or backend)
+    try:
+        lesson_id = _create_lesson(teacher_id, title, description, subject, level, sections)
+        st.success(f"✅ Lesson created (ID {lesson_id}).")
+    except Exception as e:
+        st.error(f"Failed to create lesson: {e}")
+        return
 
     # assign to chosen classes (lesson only for now)
     for label in assign_classes:
-        dbapi.assign_to_class(lesson_id, None, class_opts[label], teacher_id)
+        try:
+            _assign_to_class(lesson_id, None, class_opts[label], teacher_id)
+        except Exception as e:
+            st.warning(f"Could not assign to {label}: {e}")
 
-    # auto-generate quiz
+    # auto-generate quiz via backend LLM
     if gen_quiz:
         text = "\n\n".join([s["title"] + "\n" + (s["content"] or "") for s in sections])
-        with st.spinner("Generating quiz..."):
-            items = _generate_quiz_from_text(text, n_questions=q_count)
+        with st.spinner("Generating quiz from lesson content..."):
+            items = _generate_quiz_from_text(text, n_questions=q_count, subject=subject, level=level)
         if items:
-            qid = dbapi.create_quiz(lesson_id, f"{title} - Quiz", items, {})
-            st.success(f"🧠 Quiz generated and saved (ID {qid}).")
-            for label in assign_classes:
-                dbapi.assign_to_class(lesson_id, qid, class_opts[label], teacher_id)
+            try:
+                qid = _create_quiz(lesson_id, f"{title} - Quiz", items, {})
+                st.success(f"🧠 Quiz generated and saved (ID {qid}).")
+                for label in assign_classes:
+                    _assign_to_class(lesson_id, qid, class_opts[label], teacher_id)
+            except Exception as e:
+                st.warning(f"Lesson saved, but failed to save quiz: {e}")
 
     st.session_state.show_create_lesson = False
     st.rerun()
 
-
-
 def _create_quiz_panel(teacher_id: int):
     st.markdown("### 🏆 Create New Quiz")
 
-    # teacher lessons to link
-    lessons = dbapi.list_lessons_by_teacher(teacher_id)
+    lessons = _list_lessons_by_teacher(teacher_id)
     lesson_map = {f"{L['title']} (#{L['lesson_id']})": L["lesson_id"] for L in lessons}
     if not lesson_map:
         st.info("Create a lesson first, then link a quiz to it.")
         return
 
-    # dynamic questions
     if "cq_q_count" not in st.session_state:
         st.session_state.cq_q_count = 5
 
@@ -244,7 +299,6 @@ def _create_quiz_panel(teacher_id: int):
         st.error("Please add a quiz title.")
         return
 
-    # sanitize items
     cleaned = []
     for it in items:
         q = (it["question"] or "").strip()
@@ -259,17 +313,23 @@ def _create_quiz_panel(teacher_id: int):
         st.error("Add at least one valid question.")
         return
 
-    qid = dbapi.create_quiz(lesson_map[lesson_label], title, cleaned, {})
-    st.success(f"✅ Quiz created (ID {qid}).")
-
-    st.session_state.show_create_quiz = False
-    st.rerun()
-
+    try:
+        qid = _create_quiz(lesson_map[lesson_label], title, cleaned, {})
+        st.success(f"✅ Quiz created (ID {qid}).")
+        st.session_state.show_create_quiz = False
+        st.rerun()
+    except Exception as e:
+        st.error(f"Failed to create quiz: {e}")
 
 def _edit_lesson_panel(teacher_id: int, lesson_id: int):
-    data = dbapi.get_lesson(lesson_id)
-    L = data["lesson"]
-    secs = data["sections"] or []
+    try:
+        data = _get_lesson(lesson_id)
+    except Exception as e:
+        st.error(f"Could not load lesson #{lesson_id}: {e}")
+        return
+
+    L = data.get("lesson", {})
+    secs = data.get("sections", []) or []
 
     key_cnt = f"el_cnt_{lesson_id}"
     if key_cnt not in st.session_state:
@@ -277,7 +337,6 @@ def _edit_lesson_panel(teacher_id: int, lesson_id: int):
 
     st.markdown("### ✏️ Edit Lesson")
 
-    #Move UI-manipulation buttons 
     tools = st.columns([1,1,8])
     with tools[0]:
         if st.button("➕ Add section", key=f"el_add_{lesson_id}", use_container_width=True):
@@ -289,17 +348,16 @@ def _edit_lesson_panel(teacher_id: int, lesson_id: int):
             st.session_state[key_cnt] = max(1, st.session_state[key_cnt] - 1)
             st.rerun()
 
-    #  The form only has fields + a single submit (Save)
     with st.form(f"edit_lesson_form_{lesson_id}", clear_on_submit=False):
         c1, c2 = st.columns([2,1])
-        title = c1.text_input("Title", value=L["title"])
+        title = c1.text_input("Title", value=L.get("title") or "")
         level = c2.selectbox(
             "Level",
             ["beginner","intermediate","advanced"],
-            index=["beginner","intermediate","advanced"].index(L["level"])
+            index=["beginner","intermediate","advanced"].index(L.get("level") or "beginner")
         )
         description = st.text_area("Short description", value=L.get("description") or "")
-        subject = st.selectbox("Subject", ["numeracy","finance"], index=(0 if L["subject"]=="numeracy" else 1))
+        subject = st.selectbox("Subject", ["numeracy","finance"], index=(0 if (L.get("subject")=="numeracy") else 1))
 
         st.markdown("#### Sections")
         edited_sections = []
@@ -313,7 +371,6 @@ def _edit_lesson_panel(teacher_id: int, lesson_id: int):
 
         save = st.form_submit_button("💾 Save changes", type="primary", use_container_width=True)
 
-    # Cancel is a normal button outside the form
     actions = st.columns([8,2])
     with actions[1]:
         cancel_clicked = st.button("✖ Cancel", key=f"el_cancel_{lesson_id}", type="secondary", use_container_width=True)
@@ -326,29 +383,37 @@ def _edit_lesson_panel(teacher_id: int, lesson_id: int):
     if not save:
         return
 
-    # validation + persist
     if not title or not any((s["title"] or s["content"]).strip() for s in edited_sections):
         st.error("Title and at least one non-empty section are required.")
         return
 
-    ok = dbapi.update_lesson(lesson_id, teacher_id, title, description, subject, level, edited_sections)
+    ok = False
+    try:
+        ok = _update_lesson(lesson_id, teacher_id, title, description, subject, level, edited_sections)
+    except Exception as e:
+        st.error(f"Update failed: {e}")
+
     if ok:
         st.success("✅ Lesson updated.")
         st.session_state.show_edit_lesson = False
         st.session_state.edit_lesson_id = None
         st.rerun()
     else:
-        st.error("Could not update this lesson. Check ownership or DB errors.")
-
+        st.error("Could not update this lesson. Check ownership or backend errors.")
 
 def _edit_quiz_panel(teacher_id: int, quiz_id: int):
-    data = dbapi.get_quiz(quiz_id)  # {'quiz': {...}, 'items': [...]}
-    if not data or not data.get("quiz"):
-        st.error("Quiz not found.")
+    # Load quiz
+    try:
+        data = (dbapi.get_quiz(quiz_id) if (USE_LOCAL_DB and hasattr(dbapi, "get_quiz")) else api._req("GET", f"/quizzes/{quiz_id}").json())
+    except Exception as e:
+        st.error(f"Quiz not found: {e}")
         return
 
-    Q = data["quiz"]
+    Q = data.get("quiz")
     raw_items = data.get("items", [])
+    if not Q:
+        st.error("Quiz not found.")
+        return
 
     def _dec(x):
         if isinstance(x, str):
@@ -358,7 +423,6 @@ def _edit_quiz_panel(teacher_id: int, quiz_id: int):
                 return x
         return x
 
-    # Normalize into simple dicts that the form can bind to
     items = []
     for it in raw_items:
         opts = _dec(it.get("options")) or []
@@ -427,7 +491,6 @@ def _edit_quiz_panel(teacher_id: int, quiz_id: int):
     if not save:
         return
 
-    # sanitize
     cleaned = []
     for it in edited:
         q = (it["question"] or "").strip()
@@ -439,7 +502,7 @@ def _edit_quiz_panel(teacher_id: int, quiz_id: int):
         cleaned.append({
             "question": q,
             "options": opts[:4],
-            "answer_key": it["answer_key"],  # single letter
+            "answer_key": it["answer_key"],
             "points": 1
         })
 
@@ -447,15 +510,19 @@ def _edit_quiz_panel(teacher_id: int, quiz_id: int):
         st.error("Title and at least one valid question are required.")
         return
 
-    ok = dbapi.update_quiz(quiz_id, teacher_id, title, cleaned, settings={})
+    ok = False
+    try:
+        ok = _update_quiz(quiz_id, teacher_id, title, cleaned, settings={})
+    except Exception as e:
+        st.error(f"Save failed: {e}")
+
     if ok:
         st.success("✅ Quiz updated.")
         st.session_state.show_edit_quiz = False
         st.session_state.edit_quiz_id = None
         st.rerun()
     else:
-        st.error("Could not update this quiz. Check ownership or DB errors.")
-
+        st.error("Could not update this quiz. Check ownership or backend errors.")
 
 # ---------- Main page ----------
 def show_page():
@@ -466,17 +533,17 @@ def show_page():
     st.caption("Create and manage custom lessons and quizzes")
 
     # preload lists
-    lessons = dbapi.list_lessons_by_teacher(teacher_id)
-    quizzes = dbapi.list_quizzes_by_teacher(teacher_id)
+    lessons = _list_lessons_by_teacher(teacher_id)
+    quizzes = _list_quizzes_by_teacher(teacher_id)
 
-    # top action bar (no popovers)
+    # top action bar
     a1, a2, _sp = st.columns([3,3,4])
     if a1.button("➕ Create Lesson", use_container_width=True):
         st.session_state.show_create_lesson = True
     if a2.button("🏆 Create Quiz", use_container_width=True):
         st.session_state.show_create_quiz = True
 
-    # big inline create panels
+    # create panels
     if st.session_state.get("show_create_lesson"):
         with st.container(border=True):
             _create_lesson_panel(teacher_id)
@@ -487,18 +554,17 @@ def show_page():
             _create_quiz_panel(teacher_id)
         st.markdown("---")
 
-    # ----- Inline lesson edit panel, when triggered -----
+    # inline editors
     if st.session_state.get("show_edit_lesson") and st.session_state.get("edit_lesson_id"):
         with st.container(border=True):
             _edit_lesson_panel(teacher_id, st.session_state.edit_lesson_id)
         st.markdown("---")
-    # ----- Inline quiz edit panel, when triggered -----
+
     if st.session_state.get("show_edit_quiz") and st.session_state.get("edit_quiz_id"):
         with st.container(border=True):
             _edit_quiz_panel(teacher_id, st.session_state.edit_quiz_id)
         st.markdown("---")
 
-
     # Tabs
     tab1, tab2 = st.tabs([f"Custom Lessons ({len(lessons)})", f"Custom Quizzes ({len(quizzes)})"])
 
@@ -507,14 +573,13 @@ def show_page():
         if not lessons:
             st.info("No lessons yet. Use **Create Lesson** above.")
         else:
-            # all students across teacher's classes (optional “assign to students” inline UI you already had)
-            all_students = dbapi.list_all_students_for_teacher(teacher_id)
+            all_students = _list_all_students_for_teacher(teacher_id)
             student_options = {f"{s['name']} · {s['email']}": s["user_id"] for s in all_students}
 
             for L in lessons:
-                assignees = dbapi.list_assigned_students_for_lesson(L["lesson_id"])
-                assignee_names = [a["name"] for a in assignees]
-                created = L["created_at"].strftime("%Y-%m-%d") if isinstance(L["created_at"], datetime) else str(L["created_at"])[:10]
+                assignees = _list_assigned_students_for_lesson(L["lesson_id"])
+                assignee_names = [a.get("name") for a in assignees]
+                created = _fmt_date(L.get("created_at"))
                 count = len(assignees)
 
                 with st.container(border=True):
@@ -523,8 +588,8 @@ def show_page():
                         st.markdown(f"### {L['title']}")
                         st.caption(L.get("description") or "")
                         st.markdown(
-                            _pill(L["level"].capitalize()) +
-                            _pill(L["subject"]) +
+                            _pill((L.get("level") or "beginner").capitalize()) +
+                            _pill(L.get("subject","finance")) +
                             _pill(f"{count} student{'s' if count != 1 else ''} assigned") +
                             _pill(f"Created {created}"),
                             unsafe_allow_html=True
@@ -538,13 +603,13 @@ def show_page():
                                 st.rerun()
                         with b2:
                             if st.button("Delete", key=f"del_{L['lesson_id']}"):
-                                ok, msg = dbapi.delete_lesson(L["lesson_id"], teacher_id)
+                                ok, msg = _delete_lesson(L["lesson_id"], teacher_id)
                                 if ok: st.success("Lesson deleted"); st.rerun()
-                                else:  st.error(msg)
+                                else:  st.error(msg or "Delete failed")
 
                     st.markdown("**Assigned Students:**")
                     if assignee_names:
-                        st.markdown(" ".join(_pill(n) for n in assignee_names), unsafe_allow_html=True)
+                        st.markdown(" ".join(_pill(n) for n in assignee_names if n), unsafe_allow_html=True)
                     else:
                         st.caption("No students assigned yet.")
 
@@ -554,15 +619,15 @@ def show_page():
             st.info("No quizzes yet. Use **Create Quiz** above.")
         else:
             for Q in quizzes:
-                assignees = dbapi.list_assigned_students_for_quiz(Q["quiz_id"])
-                created = Q["created_at"].strftime("%Y-%m-%d") if isinstance(Q["created_at"], datetime) else str(Q["created_at"])[:10]
+                assignees = _list_assigned_students_for_quiz(Q["quiz_id"])
+                created = _fmt_date(Q.get("created_at"))
                 num_qs = int(Q.get("num_items", 0))
 
                 with st.container(border=True):
                     c1, c2 = st.columns([8,3])
                     with c1:
                         st.markdown(f"### {Q['title']}")
-                        st.caption(f"Lesson: {Q['lesson_title']}")
+                        st.caption(f"Lesson: {Q.get('lesson_title','')}")
                         st.markdown(
                             _pill(f"{num_qs} question{'s' if num_qs != 1 else ''}") +
                             _pill(f"{len(assignees)} students assigned") +
@@ -578,25 +643,30 @@ def show_page():
                                 st.rerun()
                         with b2:
                             if st.button("Delete", key=f"delq_{Q['quiz_id']}"):
-                                ok, msg = dbapi.delete_quiz(Q["quiz_id"], teacher_id)
+                                ok, msg = _delete_quiz(Q["quiz_id"], teacher_id)
                                 if ok: st.success("Quiz deleted"); st.rerun()
-                                else:  st.error(msg)
+                                else:  st.error(msg or "Delete failed")
 
                     st.markdown("**Assigned Students:**")
                     if assignees:
-                        st.markdown(" ".join(_pill(a['name']) for a in assignees), unsafe_allow_html=True)
+                        st.markdown(" ".join(_pill(a.get('name')) for a in assignees if a.get('name')), unsafe_allow_html=True)
                     else:
                         st.caption("No students assigned yet.")
 
                     with st.expander("View questions", expanded=False):
-                        data = dbapi.get_quiz(Q["quiz_id"])  # {'quiz': {...}, 'items': [...]}
+                        # Load items on demand to avoid heavy initial load
+                        try:
+                            data = (dbapi.get_quiz(Q["quiz_id"]) if (USE_LOCAL_DB and hasattr(dbapi, "get_quiz"))
+                                    else api._req("GET", f"/quizzes/{Q['quiz_id']}").json())
+                        except Exception as e:
+                            st.info(f"Could not fetch items: {e}")
+                            data = None
                         items = data.get("items", []) if data else []
                         if not items:
                             st.info("No items found for this quiz.")
                         else:
                             labels = ["A","B","C","D"]
                             for i, it in enumerate(items, start=1):
-                                # Handle JSON columns that may come back as strings
                                 opts = it.get("options")
                                 if isinstance(opts, str):
                                     try:
@@ -615,4 +685,4 @@ def show_page():
                                     st.write(f"{labels[j]}) {opt}")
                                 ans_text = answer if isinstance(answer, str) else ",".join(answer or [])
                                 st.caption(f"Answer: {ans_text}")
-                                st.markdown("---")
+                                st.markdown("---")

phase/Teacher_view/studentlist.py

@@ -1,36 +1,55 @@
 # phase/Teacher_view/studentlist.py
+import os
 import streamlit as st
 from utils import db as dbapi
+import utils.api as api  # backend Space client
+
+# Use local DB only when DISABLE_DB != "1"
+USE_LOCAL_DB = os.getenv("DISABLE_DB", "1") != "1"
 
 # ---------- tiny helpers ----------
 def _avatar(name: str) -> str:
-    
     return "🧑‍🎓" if hash(name) % 2 else "👩‍🎓"
 
+def _avg_pct_from_row(r) -> int:
+    """
+    Accepts either:
+      - r['avg_pct'] in [0, 100]
+      - r['avg_score'] in [0, 1] or [0, 100]
+    Returns an int 0..100.
+    """
+    v = r.get("avg_pct", r.get("avg_score", 0)) or 0
+    try:
+        f = float(v)
+        if f <= 1.0:  # treat as 0..1
+            f *= 100.0
+        return max(0, min(100, int(round(f))))
+    except Exception:
+        return 0
+
+def _level_from_xp(total_xp: int) -> int:
+    try:
+        xp = int(total_xp or 0)
+    except Exception:
+        xp = 0
+    return 1 + xp // 500
+
 def _report_text(r, level, avg_pct):
     return (
         "STUDENT PROGRESS REPORT\n"
         "======================\n"
-        f"Student: {r['name']}\n"
-        f"Email: {r['email']}\n"
-        f"Joined: {str(r['joined_at'])[:10]}\n\n"
+        f"Student: {r.get('name','')}\n"
+        f"Email: {r.get('email','')}\n"
+        f"Joined: {str(r.get('joined_at',''))[:10]}\n\n"
         "PROGRESS OVERVIEW\n"
         "-----------------\n"
-        f"Lessons Completed: {int(r['lessons_completed'] or 0)}/{int(r['total_assigned_lessons'] or 0)}\n"
+        f"Lessons Completed: {int(r.get('lessons_completed') or 0)}/{int(r.get('total_assigned_lessons') or 0)}\n"
         f"Average Quiz Score: {avg_pct}%\n"
-        f"Total XP: {int(r['total_xp'] or 0)}\n"
+        f"Total XP: {int(r.get('total_xp') or 0)}\n"
         f"Current Level: {level}\n"
-        f"Study Streak: {int(r['streak_days'] or 0)} days\n"
+        f"Study Streak: {int(r.get('streak_days') or 0)} days\n"
     )
 
-def _level_from_xp(total_xp: int) -> int:
-    try:
-        xp = int(total_xp or 0)
-    except Exception:
-        xp = 0
-    return 1 + xp // 500
-
-
 ROW_CSS = """
 <style>
 .sm-chip{display:inline-block;padding:4px 10px;border-radius:999px;background:#eef7f1;color:#0b8f5d;font-weight:600;font-size:.80rem;margin-left:8px}
@@ -46,16 +65,56 @@ ROW_CSS = """
 </style>
 """
 
+# ---------- data access (DB or Backend) ----------
+@st.cache_data(show_spinner=False, ttl=30)
+def _list_classes_by_teacher(teacher_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "list_classes_by_teacher"):
+        return dbapi.list_classes_by_teacher(teacher_id) or []
+    try:
+        return api.list_classes_by_teacher(teacher_id) or []
+    except Exception:
+        return []
+
+@st.cache_data(show_spinner=False, ttl=30)
+def _get_class(class_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "get_class"):
+        return dbapi.get_class(class_id) or {}
+    try:
+        return api.get_class(class_id) or {}
+    except Exception:
+        return {}
+
+@st.cache_data(show_spinner=False, ttl=30)
+def _class_student_metrics(class_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "class_student_metrics"):
+        return dbapi.class_student_metrics(class_id) or []
+    try:
+        return api.class_student_metrics(class_id) or []
+    except Exception:
+        return []
+
+@st.cache_data(show_spinner=False, ttl=30)
+def _list_assignments_for_student(student_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "list_assignments_for_student"):
+        return dbapi.list_assignments_for_student(student_id) or []
+    try:
+        return api.list_assignments_for_student(student_id) or []
+    except Exception:
+        return []
+
 # ---------- page ----------
 def show_page():
     st.title("🎓 Student Management")
     st.caption("Monitor and manage your students' progress")
     st.markdown(ROW_CSS, unsafe_allow_html=True)
 
-    teacher = st.session_state.user
+    teacher = st.session_state.get("user")
+    if not teacher:
+        st.error("Please log in.")
+        return
     teacher_id = teacher["user_id"]
 
-    classes = dbapi.list_classes_by_teacher(teacher_id)
+    classes = _list_classes_by_teacher(teacher_id)
     if not classes:
         st.info("No classes yet. Create one in Classroom Management.")
         return
@@ -65,14 +124,18 @@ def show_page():
         "Choose a class",
         list(range(len(classes))),
         index=0,
-        format_func=lambda i: f"{classes[i]['name']}"
+        format_func=lambda i: f"{classes[i].get('name','(unnamed)')}"
     )
     selected = classes[idx]
-    class_id = selected["class_id"]
-    code_row = dbapi.get_class(class_id)
+    class_id = selected.get("class_id") or selected.get("id")  # be tolerant to backend naming
+    if class_id is None:
+        st.error("Selected class is missing an ID.")
+        return
+
+    code_row = _get_class(class_id)
 
     # get students before drawing chips
-    rows = dbapi.class_student_metrics(class_id)
+    rows = _class_student_metrics(class_id)
 
     # code + student chip row
     chip1, chip2 = st.columns([1, 1])
@@ -86,7 +149,7 @@ def show_page():
             f'<div class="sm-chip">👥 {len(rows)} Students</div>',
             unsafe_allow_html=True
         )
-        
+
     st.markdown("---")
 
     # search line
@@ -96,19 +159,23 @@ def show_page():
     ).strip().lower()
 
     if query:
-        rows = [r for r in rows if query in r["name"].lower() or query in r["email"].lower()]
+        rows = [
+            r for r in rows
+            if query in (r.get("name","").lower()) or query in (r.get("email","").lower())
+        ]
 
     # student rows
     for r in rows:
-        name = r["name"]
-        email = r["email"]
-        joined = str(r["joined_at"])[:10]
-        total_xp = int(r["total_xp"] or 0)
+        name = r.get("name", "Unknown")
+        email = r.get("email", "")
+        joined = str(r.get("joined_at", ""))[:10]
+        total_xp = int(r.get("total_xp") or 0)
         level = _level_from_xp(total_xp)
-        lessons_completed = int(r["lessons_completed"] or 0)
-        total_assigned = int(r["total_assigned_lessons"] or 0)
-        avg_pct = round((r["avg_score"] or 0) * 100)
-        streak = int(r["streak_days"] or 0)
+        lessons_completed = int(r.get("lessons_completed") or 0)
+        total_assigned = int(r.get("total_assigned_lessons") or 0)
+        avg_pct = _avg_pct_from_row(r)
+        streak = int(r.get("streak_days") or 0)
+        student_id = r.get("student_id") or r.get("id")
 
         with st.container():
             st.markdown('<div class="sm-row">', unsafe_allow_html=True)
@@ -140,12 +207,17 @@ def show_page():
             d1, d2, spacer = st.columns([2, 1.3, 5])
             with d1:
                 with st.popover("👁️ View Details"):
-                    # list the student's assignments
-                    items = dbapi.list_assignments_for_student(r["student_id"])
+                    if student_id is not None:
+                        items = _list_assignments_for_student(int(student_id))
+                    else:
+                        items = []
                     if items:
                         for it in items[:25]:
-                            tag = " + Quiz" if it["quiz_id"] else ""
-                            st.markdown(f"- **{it['title']}** · {it['subject']} · {it['level']}{tag} · Status: {it['status']}")
+                            tag = " + Quiz" if it.get("quiz_id") else ""
+                            st.markdown(
+                                f"- **{it.get('title','Untitled')}** · {it.get('subject','General')} · "
+                                f"{it.get('level','')} {tag} · Status: {it.get('status','unknown')}"
+                            )
                     else:
                         st.info("No assignments yet.")
             with d2:
@@ -153,9 +225,9 @@ def show_page():
                 st.download_button(
                     "⬇️ Export",
                     data=rep,
-                    file_name=f"{name.replace(' ','_')}_report.txt",
+                    file_name=f"{str(name).replace(' ','_')}_report.txt",
                     mime="text/plain",
-                    key=f"dl_{r['student_id']}"
+                    key=f"dl_{student_id or name}"
                 )
 
-            st.markdown('</div>', unsafe_allow_html=True)  
+            st.markdown('</div>', unsafe_allow_html=True)

utils/api.py

@@ -87,6 +87,8 @@ def health():
             return {"ok": False}
         
 #---helpers
+
+#--helpers for student_db.py
 def user_stats(student_id: int):
     return _req("GET", f"/students/{student_id}/stats").json()
 def list_assignments_for_student(student_id: int):
@@ -96,6 +98,167 @@ def student_quiz_average(student_id: int):
 def recent_lessons_for_student(student_id: int, limit: int = 5):
     return _req("GET", f"/students/{student_id}/recent", params={"limit": limit}).json()
 
+# --- Teacher endpoints (backend Space) ---
+def create_class(teacher_id: int, name: str):
+    return _json_or_raise(_req("POST", f"/teachers/{teacher_id}/classes",
+                               json={"name": name}))
+
+def teacher_tiles(teacher_id: int):
+    return _json_or_raise(_req("GET", f"/teachers/{teacher_id}/tiles"))
+
+def list_classes_by_teacher(teacher_id: int):
+    return _json_or_raise(_req("GET", f"/teachers/{teacher_id}/classes"))
+
+def class_student_metrics(class_id: int):
+    return _json_or_raise(_req("GET", f"/classes/{class_id}/student_metrics"))
+
+def class_weekly_activity(class_id: int):
+    return _json_or_raise(_req("GET", f"/classes/{class_id}/weekly_activity"))
+
+def class_progress_overview(class_id: int):
+    return _json_or_raise(_req("GET", f"/classes/{class_id}/progress_overview"))
+
+def class_recent_activity(class_id: int, limit=6, days=30):
+    return _json_or_raise(_req("GET", f"/classes/{class_id}/recent_activity",
+                               params={"limit": limit, "days": days}))
+
+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):
+    return _json_or_raise(_req("GET", f"/students/{student_id}/classes"))
+
+def class_content_counts(class_id: int):
+    return _json_or_raise(_req("GET", f"/classes/{class_id}/counts"))
+
+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
+
+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"))
+
+
+# ---- Classes / Teacher endpoints ----
+def create_class(teacher_id: int, name: str):
+    return _req("POST", f"/teachers/{teacher_id}/classes", json={"name": name}).json()
+
+def list_classes_by_teacher(teacher_id: int):
+    return _req("GET", f"/teachers/{teacher_id}/classes").json()
+
+def list_students_in_class(class_id: int):
+    return _req("GET", f"/classes/{class_id}/students").json()
+
+def class_content_counts(class_id: int):
+    return _req("GET", f"/classes/{class_id}/content_counts").json()
+
+def list_class_assignments(class_id: int):
+    return _req("GET", f"/classes/{class_id}/assignments").json()
+
+def class_analytics(class_id: int):
+    return _req("GET", f"/classes/{class_id}/analytics").json()
+
+#--contentmanage.py helpers
+
+# ---------- Teacher/content management endpoints (backend Space) ----------
+def list_classes_by_teacher(teacher_id: int):
+    return _req("GET", f"/teachers/{teacher_id}/classes").json()
+
+def list_all_students_for_teacher(teacher_id: int):
+    return _req("GET", f"/teachers/{teacher_id}/students").json()
+
+def list_lessons_by_teacher(teacher_id: int):
+    return _req("GET", f"/teachers/{teacher_id}/lessons").json()
+
+def list_quizzes_by_teacher(teacher_id: int):
+    return _req("GET", f"/teachers/{teacher_id}/quizzes").json()
+
+def create_lesson(teacher_id: int, title: str, description: str, subject: str, level: str, sections: list[dict]):
+    d = _req("POST", "/lessons", json={
+        "teacher_id": teacher_id, "title": title, "description": description,
+        "subject": subject, "level": level, "sections": sections
+    }).json()
+    return d["lesson_id"]
+
+def update_lesson(lesson_id: int, teacher_id: int, title: str, description: str, subject: str, level: str, sections: list[dict]):
+    d = _req("PUT", f"/lessons/{lesson_id}", json={
+        "teacher_id": teacher_id, "title": title, "description": description,
+        "subject": subject, "level": level, "sections": sections
+    }).json()
+    return bool(d.get("ok", True))
+
+def delete_lesson(lesson_id: int, teacher_id: int):
+    d = _req("DELETE", f"/lessons/{lesson_id}", json={"teacher_id": teacher_id}).json()
+    return bool(d.get("ok", True)), d.get("message", "")
+
+def get_lesson(lesson_id: int):
+    return _req("GET", f"/lessons/{lesson_id}").json()  # {"lesson":{...}, "sections":[...]}
+
+def create_quiz(lesson_id: int, title: str, items: list[dict], settings: dict):
+    d = _req("POST", "/quizzes", json={"lesson_id": lesson_id, "title": title, "items": items, "settings": settings}).json()
+    return d["quiz_id"]
+
+def update_quiz(quiz_id: int, teacher_id: int, title: str, items: list[dict], settings: dict):
+    d = _req("PUT", f"/quizzes/{quiz_id}", json={"teacher_id": teacher_id, "title": title, "items": items, "settings": settings}).json()
+    return bool(d.get("ok", True))
+
+def delete_quiz(quiz_id: int, teacher_id: int):
+    d = _req("DELETE", f"/quizzes/{quiz_id}", json={"teacher_id": teacher_id}).json()
+    return bool(d.get("ok", True)), d.get("message", "")
+
+def list_assigned_students_for_lesson(lesson_id: int):
+    return _req("GET", f"/lessons/{lesson_id}/assignees").json()
+
+def list_assigned_students_for_quiz(quiz_id: int):
+    return _req("GET", f"/quizzes/{quiz_id}/assignees").json()
+
+def assign_to_class(lesson_id: int | None, quiz_id: int | None, class_id: int, teacher_id: int):
+    d = _req("POST", "/assignments", json={
+        "lesson_id": lesson_id, "quiz_id": quiz_id, "class_id": class_id, "teacher_id": teacher_id
+    }).json()
+    return bool(d.get("ok", True))
+
+# ---------- 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()
+
+#-- studentlist helpers
+
+def list_classes_by_teacher(teacher_id: int):
+    return _req("GET", f"/teachers/{teacher_id}/classes").json()
+
+def get_class(class_id: int):
+    return _req("GET", f"/classes/{class_id}").json()
+
+def class_student_metrics(class_id: int):
+    # expected to return list of rows with fields used in the UI
+    return _req("GET", f"/classes/{class_id}/students").json()
+
+def list_assignments_for_student(student_id: int):
+    return _req("GET", f"/students/{student_id}/assignments").json()
+
+
+
 
 # ---- Legacy agent endpoints (keep) ----
 def start_agent(student_id: int, lesson_id: int, level_slug: str):