Update app.py

app.py

@@ -6,8 +6,9 @@ Fixes:
 - Dataframes use type="array" to ensure list-of-lists I/O
 - Robust _apply_edits() to handle empty/short rows and parse errors
 - Safer student answer table parsing
-Enhancement:
+Enhancements:
 - Personalized Study Summary per student on Analysis & Homework tab
+- Profile-aware student simulation with targeted accuracy by subtopic category
 Run:
   pip install gradio openai
   python gradio_edu_app_fixed.py
@@ -15,6 +16,8 @@ Run:
 
 import json
 import uuid
+import re
+import random
 from typing import List, Dict, Any, Tuple
 import gradio as gr
 
@@ -65,7 +68,7 @@ def _call_openai_chat(
         return resp["choices"][0]["message"]["content"]
 
 
-# --- Prompt templates ------------------------------------------------------------
+# --- Prompt templates (ALL literal braces escaped) ------------------------------
 
 SUBTOPIC_PROMPT = """You are a curriculum designer.
 Extract at least {min_subtopics} clear, non-overlapping subtopics from the EDUCATIONAL TEXT below.
@@ -108,12 +111,19 @@ SUBTOPICS (the generator must cover these and label each item with the matching
 {selected_subtopics}
 """
 
+# policy-aware simulation prompt (subtopic-aware)
 SIMULATE_STUDENT_PROMPT = """You will roleplay as a student with this profile:
 ---
 {student_profile}
 ---
-Answer the following questions realistically based on your profile.
-For MCQ, answer ONLY the option key (A/B/C/D). For Short Answer, provide a 1–3 sentence response.
+
+**Policy (you MUST follow):**
+{policy_json}
+
+Guidelines:
+- Use the **subtopic** of each question to decide where to excel vs. struggle.
+- Hit the target accuracy ranges by category (strong/weak/neutral). If needed, deliberately pick a plausible but wrong choice. Never admit you’re doing this.
+- MCQ: answer ONLY the option key (A/B/C/D). Short Answer: 1–3 sentences; on weak areas, it’s ok to be vague, omit a key detail, or make a misconception.
 
 Return ONLY valid JSON:
 {{
@@ -123,7 +133,7 @@ Return ONLY valid JSON:
   ]
 }}
 
-QUESTIONS (with IDs):
+QUESTIONS (with IDs & subtopics):
 {questions_json}
 """
 
@@ -190,7 +200,7 @@ PERFORMANCE SUMMARY (Student 2):
 {perf_2_json}
 """
 
-# NEW: Personalized study summary prompt
+# Personalized study summary prompt
 STUDY_SUMMARY_PROMPT = """You are a learning coach. Using the performance summary and the proposed homework for ONE student, write a short **personalized home-study summary** they can follow on their own.
 
 Include, in order:
@@ -298,26 +308,163 @@ def generate_questions(
     return questions
 
 
+# --- Policy helpers to force visible divergence between students ----------------
+
+def _derive_policy(student_profile: str) -> Dict[str, Any]:
+    """Infer strong/weak areas and target accuracies from a free-form profile."""
+    p = student_profile.lower()
+    strong_terms, weak_terms = set(), set()
+
+    # Heuristics from profile
+    if re.search(r"strong in (definitions?|theor(?:y|ies)|concepts?)", p):
+        strong_terms |= {"definition", "definitions", "theory", "theories", "concept", "concepts", "term", "terms"}
+    if re.search(r"weak(?:er)? in (definitions?|theor(?:y|ies)|concepts?)", p):
+        weak_terms   |= {"definition", "definitions", "theory", "theories", "concept", "concepts", "term", "terms"}
+
+    if re.search(r"strong in (applications?|problem ?solving|calculations?)", p):
+        strong_terms |= {"application", "applications", "problem", "problems", "problem solving", "case", "cases", "calculation", "calculations", "practice"}
+    if re.search(r"weak(?:er)? in (applications?|problem ?solving|calculations?)", p):
+        weak_terms   |= {"application", "applications", "problem", "problems", "problem solving", "case", "cases", "calculation", "calculations", "practice"}
+
+    # Generic defaults if not mentioned
+    if not strong_terms and "theor" in p:
+        strong_terms |= {"definition","concept","theory","term"}
+    if not weak_terms and "careless" in p:
+        weak_terms |= {"definition","term"}  # careless → slips on definitional precision
+
+    # Accuracy targets
+    overall = 0.65  # baseline realism
+    if "anxious" in p:   overall -= 0.05
+    if "confident" in p: overall += 0.05
+
+    weak_acc    = 0.45
+    strong_acc  = 0.85
+    neutral_acc = overall
+
+    careless_rate = 0.15 if "careless" in p else 0.05
+    variance = 0.05  # small randomness
+
+    return {
+        "strong_terms": sorted(strong_terms),
+        "weak_terms": sorted(weak_terms),
+        "target_acc": {
+            "strong": strong_acc,
+            "weak": weak_acc,
+            "neutral": neutral_acc
+        },
+        "overall_target": overall,
+        "careless_rate": careless_rate,
+        "variance": variance
+    }
+
+def _classify_subtopic(name: str, policy: Dict[str, Any]) -> str:
+    s = (name or "").lower()
+    strong_hits = any(t in s for t in policy["strong_terms"])
+    weak_hits   = any(t in s for t in policy["weak_terms"])
+    if weak_hits and not strong_hits:
+        return "weak"
+    if strong_hits and not weak_hits:
+        return "strong"
+    return "neutral"
+
+def _wrong_option_letter(correct_key: str) -> str:
+    pool = ["A","B","C","D"]
+    pool = [x for x in pool if x != (correct_key or "").upper()]
+    return random.choice(pool) if pool else "A"
+
+def _enforce_profile_variation(
+    questions: List[Dict[str, Any]],
+    answers: List[Dict[str, Any]],
+    policy: Dict[str, Any]
+) -> List[Dict[str, Any]]:
+    """Post-process MCQ answers to meet target wrong-rate per category. Short answers untouched."""
+    # Indexing
+    q_by_id = {q["id"]: q for q in questions}
+    ans_by_id = {a["id"]: a["answer"] for a in answers}
+
+    # Collect MCQs per category
+    buckets = {"strong": [], "weak": [], "neutral": []}
+    for q in questions:
+        if q.get("question_type") != "MCQ":
+            continue
+        cat = _classify_subtopic(q.get("subtopic",""), policy)
+        buckets[cat].append(q["id"])
+
+    # For each category, compute current and target wrong counts
+    for cat, qids in buckets.items():
+        if not qids:
+            continue
+        target_acc = policy["target_acc"][cat]
+        # add small variance so runs don't look identical
+        target_acc += random.uniform(-policy["variance"], policy["variance"])
+        target_acc = max(0.2, min(0.95, target_acc))
+
+        total = len(qids)
+        desired_wrong = round(total * (1 - target_acc))
+
+        # Compute current wrongs
+        current_wrong = 0
+        correct_candidates = []  # qids currently correct → can flip to wrong if needed
+        for qid in qids:
+            q = q_by_id[qid]
+            stu = (ans_by_id.get(qid) or "").strip().upper()
+            correct = (q.get("correct_key") or "").strip().upper()
+            if stu and correct and stu == correct:
+                correct_candidates.append(qid)
+            else:
+                current_wrong += 1
+
+        need_more_wrong = max(0, desired_wrong - current_wrong)
+
+        # Flip some correct ones to wrong
+        if need_more_wrong > 0 and correct_candidates:
+            random.shuffle(correct_candidates)
+            for qid in correct_candidates[:need_more_wrong]:
+                correct = (q_by_id[qid].get("correct_key") or "").strip().upper()
+                ans_by_id[qid] = _wrong_option_letter(correct)
+
+        # Optional: sprinkle a few careless slips across all categories
+        if random.random() < policy["careless_rate"]:
+            for qid in random.sample(qids, k=max(0, min(1, len(qids)))):
+                correct = (q_by_id[qid].get("correct_key") or "").strip().upper()
+                if ans_by_id.get(qid, "").upper() == correct:
+                    ans_by_id[qid] = _wrong_option_letter(correct)
+
+    # Rebuild answers list
+    out = []
+    for a in answers:
+        qid = a["id"]
+        out.append({"id": qid, "answer": ans_by_id.get(qid, a["answer"])})
+    return out
+
+
 def simulate_student_answers(
     api_key: str,
     model: str,
     student_profile: str,
     questions: List[Dict[str, Any]],
 ) -> List[Dict[str, Any]]:
+    # Pack questions with subtopics so the model can bias performance
     qpack = [
         {
             "id": q["id"],
+            "subtopic": q["subtopic"],
             "question_type": q["question_type"],
             "question": q["question"],
             "options": q["options"],
         } for q in questions
     ]
+
+    # Derive an explicit policy from the free-text profile
+    policy = _derive_policy(student_profile)
+
     prompt = SIMULATE_STUDENT_PROMPT.format(
         student_profile=student_profile.strip(),
+        policy_json=json.dumps(policy, ensure_ascii=False, indent=2),
         questions_json=json.dumps(qpack, ensure_ascii=False, indent=2),
     )
     msg = [
-        {"role": "system", "content": "Return strictly valid JSON and keep answers realistic given the profile."},
+        {"role": "system", "content": "Return strictly valid JSON and keep answers realistic given the policy."},
         {"role": "user", "content": prompt},
     ]
     raw = _call_openai_chat(api_key, model, msg, temperature=0.8, max_tokens=3000)
@@ -326,14 +473,22 @@ def simulate_student_answers(
         answers = data.get("answers", [])
     except Exception:
         raise gr.Error("Failed to parse student answers JSON.")
+
+    # Normalize
     normalized = []
     for a in answers:
         qid = a.get("id")
         ans = (a.get("answer") or "").strip()
         if qid and ans:
             normalized.append({"id": qid, "answer": ans})
+
+    # Keep only answers for our questions
     q_ids = {q["id"] for q in questions}
     filtered = [a for a in normalized if a["id"] in q_ids]
+
+    # Enforce target variation to visibly differentiate students (MCQ-safe)
+    filtered = _enforce_profile_variation(questions, filtered, policy)
+
     return filtered
 
 
@@ -418,7 +573,7 @@ def prescribe_homework(
             "student_2": {"recap": "N/A", "weak_subtopics": [], "homework": []},
         }
 
-# NEW: personalized study summary helper
+# Personalized study summary helper
 def summarize_student(
     api_key: str,
     model: str,
@@ -440,7 +595,7 @@ def summarize_student(
 # --- Gradio UI ------------------------------------------------------------------
 
 with gr.Blocks(css="footer {visibility: hidden}") as demo:
-    gr.Markdown("# 🎓 Educational Text Tutor (Patched)\nDesign subtopics → generate questions → simulate students → analyze → prescribe homework")
+    gr.Markdown("# 🎓 Educational Tutor\nDesign subtopics → generate questions → simulate students → analyze → prescribe homework")
 
     # App-wide state
     st_api_key = gr.State("")
@@ -639,7 +794,7 @@ with gr.Blocks(css="footer {visibility: hidden}") as demo:
         hw1 = gr.JSON(label="Student 1 – Homework Plan")
         hw2 = gr.JSON(label="Student 2 – Homework Plan")
 
-        # NEW: Personalized study summaries
+        # Personalized study summaries
         gr.Markdown("### Student 1 – Personalized Study Summary")
         sum1_md = gr.Markdown()
         gr.Markdown("### Student 2 – Personalized Study Summary")
@@ -666,7 +821,7 @@ with gr.Blocks(css="footer {visibility: hidden}") as demo:
             s1_rx = rx_json.get("student_1", {})
             s2_rx = rx_json.get("student_2", {})
 
-            # NEW: generate summaries using performance + homework
+            # generate summaries using performance + homework
             s1_sum = summarize_student(api_key, model, by1, s1_rx)
             s2_sum = summarize_student(api_key, model, by2, s2_rx)
 
@@ -688,7 +843,8 @@ with gr.Blocks(css="footer {visibility: hidden}") as demo:
             ],
         )
 
-    gr.Markdown("— Built with ❤️ using Gradio + OpenAI —")
+    gr.Markdown("— Built using Gradio + OpenAI —")
 
 if __name__ == "__main__":
-    demo.launch()
+    # Set share=True to get a public link
+    demo.launch(share=True)