Update app.py

app.py

@@ -1,38 +1,3 @@
-import streamlit as st
-import google.generativeai as genai
-import os
-import re  # For improved parsing
-
-# Set up Streamlit page
-st.title("Interactive Multiple Choice Quiz Generator")
-st.markdown("Powered by Gemini API")
-
-# 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()
-else:
-    genai.configure(api_key=gemini_api_key)
-    model = genai.GenerativeModel('gemini-pro')
-
-    # 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 = []
@@ -43,26 +8,40 @@ def parse_quiz_content(quiz_content):
         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]
+    question_section = quiz_parts[0].strip()  # Strip whitespace from question section
+    answer_key_section = quiz_parts[1].strip() # Strip whitespace from answer key section
+
+    # --- Improved Question Block Splitting ---
+    # Split question section by lines starting with a number followed by a dot and a space (e.g., "1. ")
+    question_blocks = re.split(r'\n(?=\d+\.\s)', question_section)
 
-    # 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():
+        block = block.strip() # Strip whitespace for each block
+        if not block:
             continue # Skip empty blocks
-        lines = block.strip().split('\n')
-        question_text = lines[0].strip()
+
+        # --- Improved Question and Options Parsing within each block ---
+        lines = block.split('\n')
+        question_text = lines[0].strip()  # First line is the question
+
         options = {}
-        for line in lines[1:]:
+        for line in lines[1:]: # Start from the second line to parse options
             line = line.strip()
-            if line.startswith('A.') or line.startswith('B.') or line.startswith('C.') or line.startswith('D.'):
+            if re.match(r'^[A-D]\)\s', line): # Match options starting with A), B), C), D) and a space
+                option_letter = line[0]
+                option_text = line[2:].strip() # Take text after the "letter) "
+                options[option_letter] = option_text
+            elif re.match(r'^[A-D]\.\s', line): # Also handle options starting with A., B., C., D. and a space (if Gemini uses this format sometimes)
                 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.)
+
+        if question_text: # Only append if we have a question text (to avoid empty questions from title etc.)
+            questions.append({'question': question_text, 'options': options})
+
+
+    # --- Answer Key Parsing (No significant change needed, but strip whitespace) ---
     answer_lines = answer_key_section.strip().split('\n')
     for line in answer_lines:
         line = line.strip()
@@ -72,15 +51,15 @@ def parse_quiz_content(quiz_content):
             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
+    # Basic validation (similar to before)
     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.")
+        st.warning(f"Number of questions parsed ({len(questions)}) does not match number of answers in answer key ({len(answer_key_dict)}). Parsing might be incomplete.")
 
 
-    # Combine parsed questions and answer key into quiz_data
+    # Combine parsed questions and answer key into quiz_data (similar to before)
     quiz_data_list = []
     for i, q_data in enumerate(questions):
         correct_answer = answer_key_dict.get(i)
@@ -94,108 +73,4 @@ def parse_quiz_content(quiz_content):
             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.rerun()
-
-
-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
-topic = st.text_input("Enter the topic for your quiz:")
-
-if topic:
-    if st.button("Generate Quiz"):
-        with st.spinner(f"Generating quiz on '{topic}'..."):
-            try:
-                prompt = f"""
-                Generate a multiple-choice quiz on the topic of "{topic}".
-                The quiz should have 5 questions.
-                For each question, provide four plausible options labeled A, B, C, and D.
-                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
-
-                # --- DEBUGGING PRINTS ---
-                st.write("### Raw Quiz Content from Gemini:")
-                st.code(quiz_content) # Display raw content in a code block for readability
-
-                parsed_quiz_data, answer_key = parse_quiz_content(quiz_content)
-
-                st.write("### Parsed Quiz Data:")
-                st.write(parsed_quiz_data) # Display the parsed data structure
-
-                # --- END DEBUGGING PRINTS ---
-
-
-                if quiz_content: # Check if quiz_content was generated successfully (outer if)
-                    if parsed_quiz_data: # Check if parsing was successful (inner if)
-                        st.session_state.quiz_data = parsed_quiz_data
-                        st.session_state.current_question_index = 0
-                        st.session_state.user_answers = []
-                        st.session_state.quiz_completed = False
-                        st.session_state.score = 0
-                        st.success(f"Quiz on '{topic}' generated successfully! Let's begin.")
-                    else: # else associated with inner if parsed_quiz_data
-                        st.error("Failed to parse quiz content. Please try generating again.")
-                        st.session_state.quiz_data = None
-                else: # else associated with outer if quiz_content
-                    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.")
-
-# 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.")
+    return quiz_data_list, answer_key_dict