elkay: lesson.py

phase/Student_view/lesson.py

@@ -1,14 +1,11 @@
+# phase/Student_view/lesson.py
 import streamlit as st
 from typing import List, Dict, Any, Optional, Tuple
 import re
 import datetime
 import os
 from utils import db as dbapi
-
-# Internal API client (already used across the app)
-# Uses BACKEND_URL/BACKEND_TOKEN env vars and has retry logic
-# See utils/api.py for details
-from utils import api as backend_api
+from utils import api as backend_api  # unified backend client
 
 USE_LOCAL_DB = os.getenv("DISABLE_DB", "1") != "1"
 
@@ -19,14 +16,14 @@ FALLBACK_TAG = "<!--fallback-->"
 # ---------------------------------------------
 _SS_DEFAULTS = {
     "level": "beginner",              # beginner | intermediate | advanced
-    "module_id": None,                 # int (1-based)
-    "topic_idx": 0,                    # 0-based within module
+    "module_id": None,                # int (1-based)
+    "topic_idx": 0,                   # 0-based within module
     "mode": "catalog",                # catalog | lesson | quiz | results
-    "topics_cache": {},                # {(level, module_id): [(title, text), ...]}
-    "quiz_data": None,                 # original quiz payload (list[dict])
-    "quiz_answers": {},                # q_index -> "A"|"B"|"C"|"D"
-    "quiz_result": None,               # backend result dict
-    "chatbot_feedback": None,          # str
+    "topics_cache": {},               # {(level, module_id): [(title, text), ...]}
+    "quiz_data": None,                # original quiz payload (list[dict])
+    "quiz_answers": {},               # q_index -> "A"|"B"|"C"|"D"
+    "quiz_result": None,              # backend result dict
+    "chatbot_feedback": None,         # str
 }
 
 def _ensure_state():
@@ -41,8 +38,6 @@ def _fetch_assigned_lesson(lesson_id: int) -> dict:
     """
     if USE_LOCAL_DB and hasattr(dbapi, "get_lesson"):
         return dbapi.get_lesson(lesson_id) or {}
-
-    # If your backend exposes GET /lessons/{id}
     try:
         return backend_api.get_lesson(lesson_id) or {}
     except Exception:
@@ -51,7 +46,6 @@ def _fetch_assigned_lesson(lesson_id: int) -> dict:
 # ---------------------------------------------
 # Content metadata (UI only)
 # ---------------------------------------------
-# These titles mirror the React version you shared, so the experience feels the same.
 MODULES_META: Dict[str, List[Dict[str, Any]]] = {
     "beginner": [
         {
@@ -171,45 +165,22 @@ def _topic_titles(level: str, module_id: int):
 @st.cache_data(show_spinner=False, ttl=300)
 def _fetch_topic_from_backend(level: str, module_id: int, topic_idx: int) -> Tuple[str, str]:
     """
-    Returns (ui_title, content). Tries backend first, never crashes the UI.
-    Backend expects folders like: /app/lessons/lesson_{module_id}/topic_{ordinal}.txt
+    Returns (ui_title, content). Calls the FastAPI /lesson endpoint via utils.api.fetch_lesson_content.
+    The backend expects files at /app/lessons/lesson_{module_id}/topic_{ordinal}.txt
     """
     plan = _topic_plan(level, module_id)
-    ui_title, backend_ordinal = plan[topic_idx]  # 1-based in original list
+    ui_title, backend_ordinal = plan[topic_idx]  # 1-based ordinal in original list
 
-    payload = {
-        "lesson": f"lesson_{module_id}",  # folder name
-        "module": str(module_id),         # kept for compatibility
-        "topic": str(backend_ordinal),    # 1-based ordinal mapping
-    }
-
-    data = {}
     try:
-        # Try your documented route, then a simpler alias
-        data = backend_api._try_candidates(
-            "POST",
-            [
-                ("/agents/lesson", {"json": payload}),
-                ("/lesson",        {"json": payload}),
-            ],
-        ) or {}
+        content = backend_api.fetch_lesson_content(
+            lesson=f"lesson_{module_id}",
+            module=str(module_id),
+            topic=str(backend_ordinal),
+        )
+        content = (content or "").strip()
     except Exception as e:
-        # Log once, keep the UI moving
         st.warning(f"Lesson fetch failed for lesson_{module_id}/topic_{backend_ordinal}: {e}")
-        data = {}
-
-    # Accept several possible shapes
-    content = ""
-    for k in ("lesson_content", "content", "text", "body"):
-        v = data.get(k)
-        if isinstance(v, str) and v.strip():
-            content = v.strip()
-            break
-        if isinstance(v, dict):
-            vv = v.get("content") or v.get("text") or v.get("body")
-            if isinstance(vv, str) and vv.strip():
-                content = vv.strip()
-                break
+        content = ""
 
     return ui_title, content
 
@@ -227,7 +198,7 @@ def _extract_takeaways(text: str, max_items: int = 5) -> List[str]:
         if items:
             return items
 
-    # Otherwise, harvest bullet-y looking lines
+    # Otherwise, bullet-ish lines
     bullets = [
         ln.strip(" •-*–\t")
         for ln in text.splitlines()
@@ -245,8 +216,8 @@ def _start_quiz(level: str, module_id: int) -> Optional[List[Dict[str, Any]]]:
     module_conf = next(m for m in MODULES_META[level] if m["id"] == module_id)
     try:
         quiz = backend_api.generate_quiz(
-            lesson_id=module_id,            # int id works; backend uses it for retrieval bucketing
-            level_slug=level,               # "beginner" | "intermediate" | "advanced"
+            lesson_id=module_id,
+            level_slug=level,
             lesson_title=module_conf["title"],
         )
         if isinstance(quiz, list) and quiz:
@@ -260,13 +231,17 @@ def _submit_quiz(level: str, module_id: int, original_quiz: List[Dict[str, Any]]
     """Submit answers and get score + tutor feedback."""
     user_answers = []
     for i, q in enumerate(original_quiz):
-        # Expect letters A-D; default to ""
         user_answers.append({
             "question": q.get("question", f"Q{i+1}"),
-            "answer": answers_map.get(i, ""),
+            "answer": answers_map.get(i, ""),  # "A".."D"
         })
+
+    # student_id is required by utils/api.submit_quiz
+    student_id = int(((st.session_state.get("user") or {}).get("user_id") or 0))
+
     try:
         result = backend_api.submit_quiz(
+            student_id=student_id,
             lesson_id=module_id,
             level_slug=level,
             user_answers=user_answers,
@@ -299,16 +274,17 @@ def _send_quiz_summary_to_chatbot(result: Dict[str, Any]):
     )
 
     try:
-        # Hit your FastAPI chatbot route (HF under the hood)
-        resp = backend_api.send_to_chatbot([
-            {"role": "system", "content": "You are a friendly financial tutor for Jamaican students."},
-            {"role": "user", "content": user_prompt}
-        ])
-        bot_reply = (resp or {}).get("reply", "").strip()
-    except Exception as e:
+        # Call FastAPI /chat via utils.api.chat_ai
+        bot_reply = (backend_api.chat_ai(
+            query=user_prompt,
+            lesson_id=module_id,
+            level_slug=level,
+            history=[]
+        ) or "").strip()
+    except Exception:
         bot_reply = f"(Chatbot unavailable) Based on your result: {feedback or 'Nice work!'}"
 
-    # Seed the Chatbot page's message list so the conversation is visible immediately
+    # Seed Chatbot page
     msgs = st.session_state.get("messages") or [{
         "id": "1",
         "text": "Hi! I'm your AI Financial Tutor. What would you like to learn today?",
@@ -318,8 +294,6 @@ def _send_quiz_summary_to_chatbot(result: Dict[str, Any]):
     msgs.append({"text": user_prompt, "sender": "user", "timestamp": datetime.datetime.now()})
     msgs.append({"text": bot_reply,   "sender": "assistant", "timestamp": datetime.datetime.now()})
     st.session_state.messages = msgs
-
-    # Jump straight to Chatbot page
     st.session_state.current_page = "Chatbot"
 
 def _fallback_text(title: str, module_id: int, topic_ordinal: int) -> str:
@@ -373,18 +347,41 @@ def _render_catalog():
                 for t, _ord in _topic_plan(level, mod["id"]):
                     st.write("• ", t)
             if st.button("Start Learning", key=f"start_{level}_{mod['id']}"):
-                # nuke stale topic cache for this module and any cached fetch failures
+                # clear topic cache and cached fetches for a fresh run
                 st.session_state.topics_cache.pop((level, mod["id"]), None)
                 try:
                     st.cache_data.clear()
                 except Exception:
                     pass
-
                 st.session_state.module_id = mod["id"]
                 st.session_state.topic_idx = 0
                 st.session_state.mode = "lesson"
                 st.rerun()
 
+def _get_topics(level: str, module_id: int) -> List[Tuple[str, str]]:
+    """
+    Build the six-topic plan from metadata titles, try backend for each,
+    and if content is missing, provide a short fallback paragraph.
+    """
+    cache_key = (level, module_id)
+    if cache_key in st.session_state.topics_cache:
+        return st.session_state.topics_cache[cache_key]
+
+    plan = _topic_plan(level, module_id)
+    out: List[Tuple[str, str]] = []
+
+    for idx in range(len(plan)):
+        title, content = _fetch_topic_from_backend(level, module_id, idx)
+        if not content:
+            content = _fallback_text(title, module_id, idx + 1)
+        out.append((title, content))
+
+    st.session_state.topics_cache[cache_key] = out
+    return out
+
+def _letter_for(i: int) -> str:
+    return chr(ord("A") + i)
+
 def _render_lesson():
     level = st.session_state.level
     module_id = st.session_state.module_id
@@ -401,7 +398,6 @@ def _render_lesson():
     topics = _get_topics(level, module_id)
 
     if not topics:
-        # build topics from metadata and use fallbacks so the page is never blank
         plan = _topic_plan(level, module_id)
         topics = [(title, _fallback_text(title, module_id, i + 1)) for i, (title, _) in enumerate(plan)]
         st.session_state.topics_cache[(level, module_id)] = topics
@@ -429,7 +425,6 @@ def _render_lesson():
     source_note = "Default" if FALLBACK_TAG in t_text else "Backend"
     st.caption(f"Source: {source_note}")
     if t_text:
-        # strip the marker and render HTML from backend files (e.g., <b>Money</b>)
         cleaned = t_text.replace(FALLBACK_TAG, "")
         st.markdown(cleaned, unsafe_allow_html=True)
 
@@ -455,7 +450,6 @@ def _render_lesson():
         is_last = st.session_state.topic_idx >= len(topics) - 1
 
         if is_last:
-            # NEW: auto-start quiz when learner reaches the last topic
             if not st.session_state.get("_auto_quiz_started", False):
                 st.session_state["_auto_quiz_started"] = True
                 with st.spinner("Generating quiz…"):
@@ -468,7 +462,6 @@ def _render_lesson():
                 else:
                     st.error("Quiz could not be generated. Please try again.")
             else:
-                # Fallback button if auto-start once failed
                 if st.button("Take Lesson Quiz →"):
                     with st.spinner("Generating quiz…"):
                         quiz = _start_quiz(level, module_id)
@@ -489,30 +482,6 @@ def _render_lesson():
             label = f"{i+1}. {tt}"
             st.button(label, key=f"jump_{i}", on_click=lambda j=i: st.session_state.update({"topic_idx": j}) or st.rerun())
 
-def _get_topics(level: str, module_id: int) -> List[Tuple[str, str]]:
-    """
-    Build the six-topic plan from metadata titles, try backend for each,
-    and if content is missing, provide a short fallback paragraph.
-    """
-    cache_key = (level, module_id)
-    if cache_key in st.session_state.topics_cache:
-        return st.session_state.topics_cache[cache_key]
-
-    plan = _topic_plan(level, module_id)   # six titles max
-    out: List[Tuple[str, str]] = []
-
-    for idx in range(len(plan)):
-        title, content = _fetch_topic_from_backend(level, module_id, idx)
-        if not content:
-            content = _fallback_text(title, module_id, idx + 1)
-        out.append((title, content))
-
-    st.session_state.topics_cache[cache_key] = out
-    return out
-
-def _letter_for(i: int) -> str:
-    return chr(ord("A") + i)
-
 def _render_quiz():
     quiz: List[Dict[str, Any]] = st.session_state.quiz_data or []
     if not quiz:
@@ -521,26 +490,24 @@ def _render_quiz():
 
     st.markdown("### Lesson Quiz")
 
-    # Render each question as a block (single page quiz)
+    # Render each question (single page)
     for q_idx, q in enumerate(quiz):
         st.markdown(f"**Q{q_idx+1}. {q.get('question','').strip()}**")
         opts = q.get("options") or []
-        # Build labels like "A. option"
-        labels = [f"{_letter_for(i)}. {opt}" for i, opt in enumerate(opts)]
 
         def _on_select():
             sel = st.session_state[f"ans_{q_idx}"]  # "A. option text"
             letter = sel.split(".", 1)[0] if isinstance(sel, str) else ""
-            st.session_state.quiz_answers[q_idx] = letter  # store "A".."D"
+            st.session_state.quiz_answers[q_idx] = letter
 
-        # Preselect previously chosen letter, if any
-        saved_letter = st.session_state.quiz_answers.get(q_idx)  # "A"
+        labels = [f"{_letter_for(i)}. {opt}" for i, opt in enumerate(opts)]
+        saved_letter = st.session_state.quiz_answers.get(q_idx)
         pre_idx = next((i for i, l in enumerate(labels) if saved_letter and l.startswith(f"{saved_letter}.")), None)
 
         st.radio(
             "",
             labels,
-            index=pre_idx,  # None means no default
+            index=pre_idx,
             key=f"ans_{q_idx}",
             on_change=_on_select,
         )
@@ -558,7 +525,6 @@ def _render_quiz():
         if result:
             st.session_state.quiz_result = result
             st.session_state.chatbot_feedback = result.get("feedback")
-            # NEW: immediately send to chatbot and navigate there
             _send_quiz_summary_to_chatbot(result)
             st.rerun()
 
@@ -618,7 +584,6 @@ def _render_assigned_lesson(lesson_id: int, assignment_id: Optional[int] = None)
     if not data or not data.get("lesson"):
         st.error("Lesson not found or not available.")
         if st.button("⬅ Back to Classes"):
-            # Clear the route and bounce back to the Teacher Link page
             st.session_state.lesson_route = None
             st.session_state.current_page = "Teacher Link"
             st.rerun()
@@ -631,7 +596,6 @@ def _render_assigned_lesson(lesson_id: int, assignment_id: Optional[int] = None)
     if L.get("description"):
         st.caption(L["description"])
 
-    # Track which section we’re on
     key = f"_dbsec_idx_{lesson_id}"
     if key not in st.session_state:
         st.session_state[key] = 0
@@ -670,9 +634,6 @@ def _render_assigned_lesson(lesson_id: int, assignment_id: Optional[int] = None)
             st.rerun()
     with col3:
         is_last = idx >= len(sections) - 1
-
-        # If your DB has a quiz section type, you can detect and branch here.
-        # For now we just advance or finish.
         if is_last:
             if st.button("Finish"):
                 st.success("Lesson complete.")
@@ -686,13 +647,11 @@ def _render_assigned_lesson(lesson_id: int, assignment_id: Optional[int] = None)
 
 def render():
     _ensure_state()
-    # If we were routed here from the Teacher Link, skip the catalog flow.
     route = st.session_state.get("lesson_route")
     if route and route.get("source") == "teacher":
         _render_assigned_lesson(int(route.get("lesson_id", 0)), route.get("assignment_id"))
         return
 
-    # Breadcrumb
     st.caption("Learning Path · " + st.session_state.level.capitalize())
 
     mode = st.session_state.mode
@@ -708,10 +667,9 @@ def render():
         st.session_state.mode = "catalog"
         _render_catalog()
 
-# Some parts of the app import pages and call a conventional `show()`
+# For pages that import and call `show_page()`
 show_page = render
 
 if __name__ == "__main__":
-    # Allow standalone run for local testing
     st.set_page_config(page_title="Lesson", page_icon="📘", layout="centered")
-    render()
+    render()