updating

phase/Student_view/lesson.py

@@ -119,9 +119,37 @@ MODULES_META: Dict[str, List[Dict[str, Any]]] = {
 
 # Helper to read topic titles regardless of whether metadata uses `topics` or `topic_labels`
 
-def _topic_titles(level: str, module_id: int) -> List[str]:
+def _topic_plan(level: str, module_id: int):
+    """
+    Returns a list of (title, backend_ordinal) after filtering:
+    - drop any 'Play:' topic
+    - drop 'Quiz'
+    - keep first five + the Summary (6 total)
+    backend_ordinal is the 1-based index in the original metadata (so backend files line up).
+    """
     mod = next(m for m in MODULES_META[level] if m["id"] == module_id)
-    return (mod.get("topics") or mod.get("topic_labels") or [])
+    raw = (mod.get("topics") or mod.get("topic_labels") or [])
+    plan = []
+    for i, t in enumerate(raw, start=1):
+        tl = t.strip().lower()
+        if tl == "quiz" or tl.startswith("play:"):
+            continue
+        plan.append((t, i))
+
+    # Ensure at most 6 topics: first five + Summary if present
+    if len(plan) > 6:
+        # Prefer keeping a 'Summary' entry last if it exists
+        summary_pos = next((idx for idx, (title, _) in enumerate(plan)
+                            if title.strip().lower().startswith("summary")), None)
+        if summary_pos is not None:
+            plan = plan[:5] + [plan[summary_pos]]
+        else:
+            plan = plan[:6]
+    return plan
+
+def _topic_titles(level: str, module_id: int):
+    return [t for (t, _) in _topic_plan(level, module_id)]
+
 
 # ---------------------------------------------
 # Backend integrations
@@ -132,10 +160,12 @@ def _fetch_topic_from_backend(level: str, module_id: int, topic_idx: int) -> Tup
     Calls the backend to read the topic text from the lessons folder.
     Returns (title, content). Title uses the configured UI label as a fallback.
     """
-    # Human-friendly strings for the backend schema
+    plan = _topic_plan(level, module_id)
+    title, backend_ordinal = plan[topic_idx]  # 1-based ordinal in original list
+    # this keeps your filesystem mapping correct: topic_{backend_ordinal}.txt
     lesson_label = MODULES_META[level][[m["id"] for m in MODULES_META[level]].index(module_id)]["title"]
-    module_label = str(module_id)  # backend extracts digits from this string
-    topic_label = str(topic_idx + 1)
+    module_label = str(module_id)
+    topic_label = str(backend_ordinal)
 
     payload = {"lesson": lesson_label, "module": module_label, "topic": topic_label}
 
@@ -232,13 +262,13 @@ def _render_catalog():
     st.header("Financial Education")
     st.caption("Build your financial knowledge with structured paths for every skill level.")
 
-    level = st.segmented_control(
-        "Level",
-        options=["beginner", "intermediate", "advanced"],
-        default=st.session_state.level,
-        format_func=lambda s: s.capitalize(),
-        key="level",
-    )
+    # level = st.segmented_control(
+    #     "Level",
+    #     options=["beginner", "intermediate", "advanced"],
+    #     default=st.session_state.level,
+    #     format_func=lambda s: s.capitalize(),
+    #     key="level",
+    # )
 
     cols = st.columns(3)
     for i, mod in enumerate(MODULES_META[level]):
@@ -248,7 +278,7 @@ def _render_catalog():
                 st.caption(mod["description"])
             st.caption(f"Duration: {mod.get('duration','—')} · Difficulty: {mod.get('difficulty','—')}")
             with st.expander("Topics include"):
-                for t in (mod.get("topics") or [])[:3]:
+                for t, _ord in _topic_plan(level, mod["id"]):
                     st.write("• ", t)
             if st.button("Start Learning", key=f"start_{level}_{mod['id']}"):
                 st.session_state.module_id = mod["id"]
@@ -259,18 +289,14 @@ def _render_catalog():
 
 
 def _get_topics(level: str, module_id: int) -> List[Tuple[str, str]]:
-    """Load and cache all available topics for a module by probing sequentially."""
     cache_key = (level, module_id)
     if cache_key in st.session_state.topics_cache:
         return st.session_state.topics_cache[cache_key]
 
-    # Probe up to N topics — stop on first 2 consecutive misses to keep it snappy
-    out: List[Tuple[str, str]] = []
+    plan = _topic_plan(level, module_id)
+    out = []
     misses = 0
-    # Prefer the UI labels count; probe a little beyond in case backend has more
-    planned = len(_topic_titles(level, module_id)) + 2
-    N = max(3, planned)
-    for idx in range(N):
+    for idx in range(len(plan)):  # exactly the filtered six
         title, text = _fetch_topic_from_backend(level, module_id, idx)
         if text and not text.startswith("(Failed"):
             out.append((title, text))
@@ -279,11 +305,12 @@ def _get_topics(level: str, module_id: int) -> List[Tuple[str, str]]:
             misses += 1
             if misses >= 2:
                 break
-    # Cache
+
     st.session_state.topics_cache[cache_key] = out
     return out
 
 
+
 def _render_lesson():
     level = st.session_state.level
     module_id = st.session_state.module_id