Spaces:

FinEDProj
/

FInFront

Sleeping

FInFront / phase /Student_view /mini_quiz.py

lanna_lalala;-

miniquiz try

fdf0e7a about 1 year ago

8.78 kB

# phase/Student_view/mini_quiz.py
import datetime
from typing import List, Dict, Any, Optional
import streamlit as st

# Reuse the unified backend client
from utils import api as backend_api

# ---------------------------------------------
# Public quiz-state helpers
# ---------------------------------------------
QUIZ_SS_DEFAULTS = {
    "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
    "_auto_quiz_started": False, # helper to avoid double-start
}


def ensure_quiz_state():
    """Ensure quiz-related keys exist in st.session_state."""
    for k, v in QUIZ_SS_DEFAULTS.items():
        if k not in st.session_state:
            st.session_state[k] = v


# ---------------------------------------------
# Backend calls (isolated here)
# ---------------------------------------------

# --- in start_quiz() ---
def start_quiz(level: str, module_id: int, lesson_title: str) -> bool:
    ensure_quiz_state()
    try:
        resp = backend_api.generate_quiz(
            lesson_id=module_id,
            level_slug=level,
            lesson_title=lesson_title,
        )
    except Exception as e:
        st.error(f"Could not generate quiz: {e}")
        return False

    # Accept both the old (list) and new (dict with 'items') shapes
    items = resp.get("items") if isinstance(resp, dict) else resp
    if not isinstance(items, list) or not items:
        st.error("Quiz could not be generated. Please try again.")
        return False

    # Normalize: ensure id + answer_key are present
    normalized = []
    for i, q in enumerate(items, start=1):
        qid = q.get("id") or q.get("qid") or q.get("position") or f"q{i}"
        answer_key = q.get("answer_key") or q.get("answer")  # backend may send either
        normalized.append({
            "id": qid,
            "question": (q.get("question") or "").strip(),
            "options": q.get("options") or [],
            "answer_key": answer_key,  # keep for grading payload
        })

    st.session_state.quiz_data = normalized
    st.session_state.quiz_answers = {}
    st.session_state.mode = "quiz"
    return True


def submit_quiz(level: str, module_id: int, original_quiz: List[Dict[str, Any]], answers_map: Dict[int, str]) -> Optional[Dict[str, Any]]:
    """Submit answers and return the grading result dict."""
    # --- in submit_quiz() ---
    user_answers = []
    for q in original_quiz:
        qid = q.get("id") or q.get("question")  # fallback
        user_answers.append({"id": qid, "answer": answers_map.get(original_quiz.index(q), "")})


    # 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,
            original_quiz=original_quiz,
        )
        return result
    except Exception as e:
        st.error(f"Could not submit quiz: {e}")
        return None


def send_quiz_summary_to_chatbot(level: str, module_id: int, lesson_title: str, result: Dict[str, Any]):
    """Send a concise summary to the chatbot and navigate there."""
    score = result.get("score", {})
    correct = int(score.get("correct", 0))
    total = int(score.get("total", 0))
    feedback = (result.get("feedback") or st.session_state.get("chatbot_feedback") or "").strip()

    user_prompt = (
        f"I just finished the quiz for '{lesson_title}' (module {module_id}) "
        f"and scored {correct}/{total}. Please give me 2–3 targeted tips and 1 tiny action "
        f"to improve before the next lesson. If there were wrong answers, explain them simply.\n\n"
        f"Context from grader:\n{feedback}"
    )

    try:
        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 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?",
        "sender": "assistant",
        "timestamp": datetime.datetime.now(),
    }]
    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
    st.session_state.current_page = "Chatbot"


# ---------------------------------------------
# UI helpers
# ---------------------------------------------

def _letter_for(i: int) -> str:
    return chr(ord("A") + i)


def render_quiz(lesson_title: Optional[str] = None):
    """Render the quiz UI (single page). Expects st.session_state.level/module_id to be set."""
    ensure_quiz_state()

    quiz: List[Dict[str, Any]] = st.session_state.quiz_data or []
    if not quiz:
        # No staged quiz — bounce back to lesson
        st.session_state.mode = "lesson"
        st.rerun()

    st.markdown("### Lesson Quiz")

    # Render each question
    for q_idx, q in enumerate(quiz):
        st.markdown(f"**Q{q_idx+1}. {q.get('question','').strip()}**")
        opts = q.get("options") or []

        def _on_select():
            sel = st.session_state[f"ans_{q_idx}"]  # e.g. "A. option text"
            letter = sel.split(".", 1)[0] if isinstance(sel, str) else ""
            st.session_state.quiz_answers[q_idx] = letter

        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,
            key=f"ans_{q_idx}",
            on_change=_on_select,
        )
        st.divider()

    all_answered = len(st.session_state.quiz_answers) == len(quiz)
    if st.button("Submit Quiz", disabled=not all_answered):
        with st.spinner("Grading…"):
            result = submit_quiz(
                st.session_state.level,
                st.session_state.module_id,
                quiz,
                st.session_state.quiz_answers,
            )
        if result:
            st.session_state.quiz_result = result
            st.session_state.chatbot_feedback = result.get("feedback")
            # Keep current behavior: jump to Chatbot after grading
            send_quiz_summary_to_chatbot(
                st.session_state.level,
                st.session_state.module_id,
                lesson_title or "This Lesson",
                result,
            )
            st.rerun()


def render_results(planned_topics: Optional[List[str]] = None):
    """Optional results screen (not used by default flow which jumps to Chatbot)."""
    ensure_quiz_state()

    result = st.session_state.quiz_result or {}
    score = result.get("score", {})
    correct = score.get("correct", 0)
    total = score.get("total", 0)

    st.success(f"Quiz Complete! You scored {correct} / {total}.")

    wrong = result.get("wrong", [])
    if wrong:
        with st.expander("Review your answers"):
            for w in wrong:
                st.markdown(f"**{w.get('question','')}**")
                st.write(f"Your answer: {w.get('your_answer','')}")
                st.write(f"Correct answer: {w.get('correct_answer','')}")
                st.divider()

    fb = st.session_state.chatbot_feedback
    if fb:
        st.markdown("#### Tutor Explanation")
        st.write(fb)

    # Navigation controls
    planned_topics = planned_topics or []
    try:
        quiz_index = [t.strip().lower() for t in planned_topics].index("quiz")
    except ValueError:
        quiz_index = None

    c1, c2, c3 = st.columns([1, 1, 1])
    with c1:
        if st.button("Back to Modules"):
            st.session_state.mode = "catalog"
            st.session_state.module_id = None
            st.rerun()
    with c2:
        if st.button("Ask the Chatbot →"):
            st.session_state.current_page = "Chatbot"
            st.session_state.chatbot_prefill = fb
            st.rerun()
    with c3:
        if quiz_index is not None and quiz_index + 1 < len(planned_topics):
            if st.button("Continue Lesson →"):
                st.session_state.mode = "lesson"
                st.session_state.topic_idx = quiz_index + 1
                st.rerun()

	# phase/Student_view/mini_quiz.py
	import datetime
	from typing import List, Dict, Any, Optional
	import streamlit as st

	# Reuse the unified backend client
	from utils import api as backend_api

	# ---------------------------------------------
	# Public quiz-state helpers
	# ---------------------------------------------
	QUIZ_SS_DEFAULTS = {
	"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
	"_auto_quiz_started": False, # helper to avoid double-start
	}


	def ensure_quiz_state():
	"""Ensure quiz-related keys exist in st.session_state."""
	for k, v in QUIZ_SS_DEFAULTS.items():
	if k not in st.session_state:
	st.session_state[k] = v


	# ---------------------------------------------
	# Backend calls (isolated here)
	# ---------------------------------------------

	# --- in start_quiz() ---
	def start_quiz(level: str, module_id: int, lesson_title: str) -> bool:
	ensure_quiz_state()
	try:
	resp = backend_api.generate_quiz(
	lesson_id=module_id,
	level_slug=level,
	lesson_title=lesson_title,
	)
	except Exception as e:
	st.error(f"Could not generate quiz: {e}")
	return False

	# Accept both the old (list) and new (dict with 'items') shapes
	items = resp.get("items") if isinstance(resp, dict) else resp
	if not isinstance(items, list) or not items:
	st.error("Quiz could not be generated. Please try again.")
	return False

	# Normalize: ensure id + answer_key are present
	normalized = []
	for i, q in enumerate(items, start=1):
	qid = q.get("id") or q.get("qid") or q.get("position") or f"q{i}"
	answer_key = q.get("answer_key") or q.get("answer") # backend may send either
	normalized.append({
	"id": qid,
	"question": (q.get("question") or "").strip(),
	"options": q.get("options") or [],
	"answer_key": answer_key, # keep for grading payload
	})

	st.session_state.quiz_data = normalized
	st.session_state.quiz_answers = {}
	st.session_state.mode = "quiz"
	return True


	def submit_quiz(level: str, module_id: int, original_quiz: List[Dict[str, Any]], answers_map: Dict[int, str]) -> Optional[Dict[str, Any]]:
	"""Submit answers and return the grading result dict."""
	# --- in submit_quiz() ---
	user_answers = []
	for q in original_quiz:
	qid = q.get("id") or q.get("question") # fallback
	user_answers.append({"id": qid, "answer": answers_map.get(original_quiz.index(q), "")})


	# 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,
	original_quiz=original_quiz,
	)
	return result
	except Exception as e:
	st.error(f"Could not submit quiz: {e}")
	return None


	def send_quiz_summary_to_chatbot(level: str, module_id: int, lesson_title: str, result: Dict[str, Any]):
	"""Send a concise summary to the chatbot and navigate there."""
	score = result.get("score", {})
	correct = int(score.get("correct", 0))
	total = int(score.get("total", 0))
	feedback = (result.get("feedback") or st.session_state.get("chatbot_feedback") or "").strip()

	user_prompt = (
	f"I just finished the quiz for '{lesson_title}' (module {module_id}) "
	f"and scored {correct}/{total}. Please give me 2–3 targeted tips and 1 tiny action "
	f"to improve before the next lesson. If there were wrong answers, explain them simply.\n\n"
	f"Context from grader:\n{feedback}"
	)

	try:
	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 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?",
	"sender": "assistant",
	"timestamp": datetime.datetime.now(),
	}]
	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
	st.session_state.current_page = "Chatbot"


	# ---------------------------------------------
	# UI helpers
	# ---------------------------------------------

	def _letter_for(i: int) -> str:
	return chr(ord("A") + i)


	def render_quiz(lesson_title: Optional[str] = None):
	"""Render the quiz UI (single page). Expects st.session_state.level/module_id to be set."""
	ensure_quiz_state()

	quiz: List[Dict[str, Any]] = st.session_state.quiz_data or []
	if not quiz:
	# No staged quiz — bounce back to lesson
	st.session_state.mode = "lesson"
	st.rerun()

	st.markdown("### Lesson Quiz")

	# Render each question
	for q_idx, q in enumerate(quiz):
	st.markdown(f"Q{q_idx+1}. {q.get('question','').strip()}")
	opts = q.get("options") or []

	def _on_select():
	sel = st.session_state[f"ans_{q_idx}"] # e.g. "A. option text"
	letter = sel.split(".", 1)[0] if isinstance(sel, str) else ""
	st.session_state.quiz_answers[q_idx] = letter

	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,
	key=f"ans_{q_idx}",
	on_change=_on_select,
	)
	st.divider()

	all_answered = len(st.session_state.quiz_answers) == len(quiz)
	if st.button("Submit Quiz", disabled=not all_answered):
	with st.spinner("Grading…"):
	result = submit_quiz(
	st.session_state.level,
	st.session_state.module_id,
	quiz,
	st.session_state.quiz_answers,
	)
	if result:
	st.session_state.quiz_result = result
	st.session_state.chatbot_feedback = result.get("feedback")
	# Keep current behavior: jump to Chatbot after grading
	send_quiz_summary_to_chatbot(
	st.session_state.level,
	st.session_state.module_id,
	lesson_title or "This Lesson",
	result,
	)
	st.rerun()


	def render_results(planned_topics: Optional[List[str]] = None):
	"""Optional results screen (not used by default flow which jumps to Chatbot)."""
	ensure_quiz_state()

	result = st.session_state.quiz_result or {}
	score = result.get("score", {})
	correct = score.get("correct", 0)
	total = score.get("total", 0)

	st.success(f"Quiz Complete! You scored {correct} / {total}.")

	wrong = result.get("wrong", [])
	if wrong:
	with st.expander("Review your answers"):
	for w in wrong:
	st.markdown(f"{w.get('question','')}")
	st.write(f"Your answer: {w.get('your_answer','')}")
	st.write(f"Correct answer: {w.get('correct_answer','')}")
	st.divider()

	fb = st.session_state.chatbot_feedback
	if fb:
	st.markdown("#### Tutor Explanation")
	st.write(fb)

	# Navigation controls
	planned_topics = planned_topics or []
	try:
	quiz_index = [t.strip().lower() for t in planned_topics].index("quiz")
	except ValueError:
	quiz_index = None

	c1, c2, c3 = st.columns([1, 1, 1])
	with c1:
	if st.button("Back to Modules"):
	st.session_state.mode = "catalog"
	st.session_state.module_id = None
	st.rerun()
	with c2:
	if st.button("Ask the Chatbot →"):
	st.session_state.current_page = "Chatbot"
	st.session_state.chatbot_prefill = fb
	st.rerun()
	with c3:
	if quiz_index is not None and quiz_index + 1 < len(planned_topics):
	if st.button("Continue Lesson →"):
	st.session_state.mode = "lesson"
	st.session_state.topic_idx = quiz_index + 1
	st.rerun()