Update app.py

app.py

@@ -1,23 +1,147 @@
 import streamlit as st
 import google.generativeai as genai
 import os
+import re  # For improved parsing
 
 # Set up Streamlit page
-st.title("Multiple Choice Quiz Generator")
+st.title("Interactive Multiple Choice Quiz Generator")
 st.markdown("Powered by Gemini API")
 
-# **API Key Input from User**
+# API Key Input from User
 gemini_api_key = st.text_input("Enter your Gemini API Key:", type="password")
 
 if not gemini_api_key:
     st.warning("Please enter your Gemini API key to generate a quiz.")
-    st.stop()  # Stop execution if API key is missing
+    st.stop()
 else:
     genai.configure(api_key=gemini_api_key)
-    model = genai.GenerativeModel('gemini-pro') # Or 'gemini-pro-vision' if you need image input later
+    model = genai.GenerativeModel('gemini-pro')
 
-    # **Security Warning**
-    st.markdown("<font color='red'>**Warning:** Directly entering your API key in the app is less secure than using Streamlit Secrets or environment variables, especially if this app is shared or deployed publicly. For production or sensitive use, consider using Streamlit Secrets instead.</font>", unsafe_allow_html=True)
+    # Security Warning
+    st.markdown("<font color='red'>**Warning:** Directly entering your API key is less secure than using Streamlit Secrets or environment variables. For production, use Secrets.</font>", unsafe_allow_html=True)
+
+# Initialize session state for quiz data and progress
+if 'quiz_data' not in st.session_state:
+    st.session_state.quiz_data = None
+if 'current_question_index' not in st.session_state:
+    st.session_state.current_question_index = 0
+if 'user_answers' not in st.session_state:
+    st.session_state.user_answers = []
+if 'quiz_completed' not in st.session_state:
+    st.session_state.quiz_completed = False
+if 'score' not in st.session_state:
+    st.session_state.score = 0
+
+
+def parse_quiz_content(quiz_content):
+    """Parses the quiz content and answer key into a structured format."""
+    questions = []
+    answer_key_dict = {}
+
+    quiz_parts = quiz_content.split("Answer Key")
+    if len(quiz_parts) != 2:
+        st.warning("Could not reliably separate quiz questions and answer key. Parsing might be imperfect.")
+        return None, None
+
+    question_section = quiz_parts[0]
+    answer_key_section = quiz_parts[1]
+
+    # Parse questions and options using regex (more robust)
+    question_blocks = re.split(r'\n(?=\d+\.)', question_section.strip()) # Split by newline followed by number and dot
+    for block in question_blocks:
+        if not block.strip():
+            continue # Skip empty blocks
+        lines = block.strip().split('\n')
+        question_text = lines[0].strip()
+        options = {}
+        for line in lines[1:]:
+            line = line.strip()
+            if line.startswith('A.') or line.startswith('B.') or line.startswith('C.') or line.startswith('D.'):
+                option_letter = line[0]
+                option_text = line[2:].strip()
+                options[option_letter] = option_text
+        questions.append({'question': question_text, 'options': options})
+
+    # Parse answer key (assuming format like 1. A, 2. B, etc.)
+    answer_lines = answer_key_section.strip().split('\n')
+    for line in answer_lines:
+        line = line.strip()
+        match = re.match(r'(\d+)\.\s*([A-D])', line) # Regex to find question number and answer letter
+        if match:
+            question_num = int(match.group(1)) - 1 # Adjust to 0-based index
+            correct_answer = match.group(2)
+            answer_key_dict[question_num] = correct_answer
+
+    # Basic validation: Check if we parsed questions and answers and if counts match
+    if not questions or not answer_key_dict:
+        st.error("Error parsing quiz content. Please try again or check the generated format.")
+        return None, None
+    if len(questions) != len(answer_key_dict):
+        st.warning("Number of questions and answers in answer key do not match. Parsing might be incomplete.")
+
+
+    # Combine parsed questions and answer key into quiz_data
+    quiz_data_list = []
+    for i, q_data in enumerate(questions):
+        correct_answer = answer_key_dict.get(i)
+        if correct_answer:
+            quiz_data_list.append({
+                'question': q_data['question'],
+                'options': q_data['options'],
+                'correct_answer': correct_answer
+            })
+        else:
+            st.warning(f"Could not find correct answer for question {i+1} in the answer key.")
+            return None, None # Inconsistent data, better to stop
+
+    return quiz_data_list, answer_key_dict
+
+
+def display_question():
+    """Displays the current question and options for interactive quiz."""
+    if st.session_state.quiz_data is None:
+        st.error("Quiz data not loaded yet. Generate a quiz first.")
+        return
+
+    if st.session_state.current_question_index < len(st.session_state.quiz_data):
+        question_data = st.session_state.quiz_data[st.session_state.current_question_index]
+        question_number = st.session_state.current_question_index + 1
+        st.markdown(f"**Question {question_number}:** {question_data['question']}")
+
+        options_list = [f"{key}. {value}" for key, value in question_data['options'].items()]
+        user_choice = st.radio("Choose an answer:", options_list, key=f"q_{question_number}") # Unique key for radio buttons
+
+        if st.button("Submit Answer", key=f"submit_q_{question_number}"): # Unique key for submit button
+            selected_option_letter = user_choice.split('.')[0] # Extract A, B, C, or D
+            st.session_state.user_answers.append(selected_option_letter)
+
+            if st.session_state.current_question_index < len(st.session_state.quiz_data) - 1:
+                st.session_state.current_question_index += 1
+            else:
+                st.session_state.quiz_completed = True # Mark quiz as completed after last question
+            st.experimental_rerun() # Rerun to update UI
+
+
+def display_results():
+    """Displays the quiz results after completion."""
+    if st.session_state.quiz_completed:
+        st.markdown("### Quiz Results")
+        correct_count = 0
+        for i in range(len(st.session_state.quiz_data)):
+            user_answer = st.session_state.user_answers[i] if i < len(st.session_state.user_answers) else None # Handle if user didn't answer all
+            correct_answer = st.session_state.quiz_data[i]['correct_answer']
+            if user_answer == correct_answer:
+                correct_count += 1
+                result_text = f"**Question {i+1}:** ✅ Correct! (Your answer: {user_answer}, Correct answer: {correct_answer})"
+                color = "green"
+            else:
+                result_text = f"**Question {i+1}:** ❌ Incorrect. (Your answer: {user_answer if user_answer else 'Not answered'}, Correct answer: {correct_answer})"
+                color = "red"
+            st.markdown(f"<font color='{color}'>{result_text}</font>", unsafe_allow_html=True)
+
+        percentage_correct = (correct_count / len(st.session_state.quiz_data)) * 100
+        st.markdown(f"### Final Score: {correct_count} out of {len(st.session_state.quiz_data)} correct ({percentage_correct:.2f}%)")
+        st.session_state.score = correct_count # Store score in session state
 
 
 # User input for topic
@@ -27,7 +151,6 @@ if topic:
     if st.button("Generate Quiz"):
         with st.spinner(f"Generating quiz on '{topic}'..."):
             try:
-                # Construct the prompt for Gemini
                 prompt = f"""
                 Generate a multiple-choice quiz on the topic of "{topic}".
                 The quiz should have 5 questions.
@@ -35,29 +158,33 @@ if topic:
                 Clearly indicate the correct answer for each question at the end in a separate section called "Answer Key".
                 Format the quiz clearly for easy reading.
                 """
-
                 response = model.generate_content(prompt)
                 quiz_content = response.text
 
                 if quiz_content:
-                    st.markdown("### Quiz:")
-                    st.markdown(quiz_content)
-
-                    # Basic parsing to try and separate quiz and answer key (very basic, might need improvement)
-                    if "Answer Key" in quiz_content:
-                        parts = quiz_content.split("Answer Key")
-                        quiz_questions = parts[0]
-                        answer_key = "Answer Key" + parts[1] # Re-add "Answer Key" to the answer section
-                        st.markdown("### Answer Key:")
-                        st.markdown(answer_key)
+                    parsed_quiz_data, answer_key = parse_quiz_content(quiz_content)
+                    if parsed_quiz_data:
+                        st.session_state.quiz_data = parsed_quiz_data
+                        st.session_state.current_question_index = 0 # Reset to first question
+                        st.session_state.user_answers = [] # Clear previous answers
+                        st.session_state.quiz_completed = False # Reset completion status
+                        st.session_state.score = 0 # Reset score
+                        st.success(f"Quiz on '{topic}' generated successfully! Let's begin.")
                     else:
-                        st.warning("Could not clearly separate answer key. Answers may be embedded in the quiz text.")
-
+                        st.error("Failed to parse quiz content. Please try generating again.")
+                        st.session_state.quiz_data = None # Ensure quiz_data is reset in case of parsing failure
                 else:
                     st.error("Failed to generate quiz content. Please try again or check your API key.")
 
             except Exception as e:
                 st.error(f"An error occurred: {e}")
                 st.error("Please check your API key and network connection. If the problem persists, try a different topic or try again later.")
-else:
-    st.info("Please enter a topic to generate a quiz.")
+
+# Quiz Display Logic
+if st.session_state.quiz_data:
+    if not st.session_state.quiz_completed:
+        display_question()
+    else:
+        display_results()
+elif topic and not st.session_state.quiz_data and not st.session_state.quiz_completed: # Message if topic entered but quiz not generated yet
+    st.info("Click 'Generate Quiz' to start the quiz.")