add question_bank in pre_class_quiz

gen_mcqs.py

@@ -225,7 +225,7 @@ GEMINI_KEY = os.getenv('GEMINI_KEY')
 # Configure APIs
 openai.api_key = OPENAI_KEY
 genai.configure(api_key=GEMINI_KEY)
-model = genai.GenerativeModel('gemini-pro')
+model = genai.GenerativeModel('gemini-1.5-flash')
 
 # Connect to MongoDB
 client = MongoClient(MONGO_URI)
@@ -306,6 +306,113 @@ def generate_mcqs(context, num_questions, session_title, session_description):
         print(f"Error generating MCQs: , error: {e}")
         return None
 
+def generate_pre_class_question_bank(context: str, session_title: str, session_description: str) -> List[Dict]:
+    """Generate a bank of 40 MCQ questions for pre-class quiz"""
+    try:
+        prompt = f"""
+        Based on the following content, generate 50 multiple choice questions for a question bank.
+        Format each question as a Python dictionary with this exact structure:
+        {{
+            "question": "Question text here",
+            "options": ["A) option1", "B) option2", "C) option3", "D) option4"],
+            "correct_option": "A) option1" or "B) option2" or "C) option3" or "D) option4",
+            "difficulty": "easy|medium|hard",
+            "topic": "specific topic from content"
+        }}
+        
+        Content:
+        {context}
+        
+        Session Title: {session_title}
+        Description: {session_description}
+        
+        Requirements:
+        1. Questions should cover all important concepts
+        2. Mix of easy (20%), medium (50%), and hard (30%) questions
+        3. Clear and unambiguous questions
+        4. Options should be plausible but only one correct answer
+        5. Include topic tags for categorization
+        6. **NUMBER OF QUESTIONS SHOULD BE GREATER THAN OR EQUAL TO 60**
+        
+        Return ONLY the JSON array of questions.
+        """
+        
+        response = model.generate_content(
+            prompt,
+            generation_config=genai.GenerationConfig(
+                # temperature=0.7,
+                response_mime_type="application/json"
+            )
+        )
+        response_text = response.text.strip()
+        modified_response_text = strip_code_markers(response_text)
+        question_bank = ast.literal_eval(modified_response_text)
+        print(question_bank)
+        # Validate question bank
+        if not isinstance(question_bank, list):
+            raise ValueError("Invalid question bank format or count")
+            
+        return question_bank
+        
+    except Exception as e:
+        print(f"Error generating question bank: {e}")
+        return None
+
+
+def save_pre_class_quiz_with_bank(
+    course_id: str, 
+    session_id: str, 
+    title: str, 
+    question_bank: List[Dict],
+    num_questions: int,
+    duration: int,
+    user_id: str
+) -> str:
+    """Save pre-class quiz with question bank to database"""
+    try:
+        quiz_data = {
+            "user_id": user_id,
+            "course_id": course_id,
+            "session_id": session_id,
+            "title": title,
+            "question_bank": question_bank,
+            "num_questions": num_questions,
+            "duration_minutes": duration,
+            "created_at": datetime.now(),
+            "status": "active",
+            "submissions": [],
+            "quiz_type": "pre_class"
+        }
+        result = quizzes_collection.insert_one(quiz_data)
+        return result.inserted_id
+    except Exception as e:
+        print(f"Error saving quiz with question bank: {e}")
+        return None
+
+def get_randomized_questions(quiz_id) -> List[Dict]:
+    """Get randomly selected questions from question bank based on quiz settings"""
+    try:
+        quiz = quizzes_collection.find_one({"_id": quiz_id})
+        if not quiz:
+            return None
+        
+        num_questions = quiz.get("num_questions", 0)
+        question_bank = quiz.get("question_bank", [])
+        
+        if not question_bank or num_questions <= 0:
+            return None
+            
+        # Randomly select questions
+        import random
+        selected_questions = random.sample(question_bank, num_questions)
+        
+        return selected_questions
+        
+    except Exception as e:
+        print(f"Error getting randomized questions: {e}")
+        return None
+
+
 def save_pre_class_quiz(course_id: str, session_id: str, title: str, questions: List[Dict], user_id: str, duration: int):
     """Save pre-class quiz to database"""
     try:

session_page.py

@@ -17,7 +17,7 @@ import plotly.express as px
 from dotenv import load_dotenv
 import os
 from pymongo import MongoClient
-from gen_mcqs import generate_mcqs, save_pre_class_quiz, save_quiz, quizzes_collection, get_student_quiz_score, submit_quiz_answers
+from gen_mcqs import generate_mcqs, generate_pre_class_question_bank, get_randomized_questions, save_pre_class_quiz, save_pre_class_quiz_with_bank, save_quiz, quizzes_collection, get_student_quiz_score, submit_quiz_answers
 from create_course import courses_collection
 # from pre_class_analytics import NovaScholarAnalytics
 from pre_class_analytics2 import NovaScholarAnalytics
@@ -831,56 +831,225 @@ def display_pre_class_quiz_tab(student_id, course_id, session_id):
                 st.success(f"Quiz completed! Score: {existing_score:.1f}%")
                 
                 # Show review
-                st.subheader("Quiz Review")
-                for i, question in enumerate(quiz["questions"]):
-                    st.markdown(f"**Q{i+1}:** {question['question']}")
-                    for opt in question["options"]:
-                        if opt.startswith(question["correct_option"]):
-                            st.markdown(f"✅ {opt}")
-                        else:
-                            st.markdown(f"- {opt}")
+                st.markdown("#### Quiz Review")
+                submission = next(
+                    (sub for sub in quiz["submissions"] if sub["student_id"] == student_id),
+                    None
+                )
+                # for i, question in enumerate(quiz["questions"]):
+                #     st.markdown(f"**Q{i+1}:** {question['question']}")
+                #     for opt in question["options"]:
+                #         if opt.startswith(question["correct_option"]):
+                #             st.markdown(f"✅ {opt}")
+                #         else:
+                #             st.markdown(f"- {opt}")
+                if submission:
+                    questions = submission.get("allocated_questions", [])
+                    answers = submission.get("answers", {})
+                    for i, question in enumerate(questions):
+                        st.markdown(f"**Q{i+1}:** {question['question']}")
+                        for opt in question["options"]:
+                            if opt == question["correct_option"]:
+                                st.markdown(f"✅ {opt}")
+                            elif opt == answers.get(str(i)):
+                                st.markdown(f"❌ {opt}")
+                            else:
+                                st.markdown(f"- {opt}")
 
             else:
-                # Check time remaining
-                start_time = quiz.get('start_time')
-                if not start_time:
+                # # Check time remaining
+                # start_time = quiz.get('start_time')
+                # if not start_time:
+                #     if st.button("Start Quiz", key=f"start_{quiz['_id']}"):
+                #         quizzes_collection.update_one(
+                #             {"_id": quiz["_id"]},
+                #             {"$set": {"start_time": datetime.now()}}
+                #         )
+                #         st.rerun()
+                # Start quiz flow
+                quiz_state = quizzes_collection.find_one({
+                    "_id": quiz["_id"],
+                    "student_states.student_id": student_id
+                })
+                if not quiz_state or "student_states" not in quiz_state:
+                    # Not started yet
                     if st.button("Start Quiz", key=f"start_{quiz['_id']}"):
-                        quizzes_collection.update_one(
-                            {"_id": quiz["_id"]},
-                            {"$set": {"start_time": datetime.now()}}
-                        )
-                        st.rerun()
+                        # Get random questions
+                        questions = get_randomized_questions(quiz["_id"])
+                        if questions:
+                            # Save allocated questions and start time
+                            result = quizzes_collection.update_one(
+                                {"_id": quiz["_id"]},
+                                {
+                                    "$push": {
+                                        "student_states": {
+                                            "student_id": student_id,
+                                            "allocated_questions": questions,
+                                            "start_time": datetime.now(),
+                                            "completed": False
+                                        }
+                                    }
+                                }
+                            )
+                            if result.modified_count > 0:
+                                st.rerun()
+                        else:
+                            st.error("Error getting quiz questions")
                 else:
-                    time_remaining = (start_time + timedelta(minutes=quiz['duration_minutes'])) - datetime.now()
-                    
-                    if time_remaining.total_seconds() > 0:
-                        st.info(f"Time remaining: {int(time_remaining.total_seconds() // 60)}:{int(time_remaining.total_seconds() % 60):02d}")
+                    # Quiz already started
+                    student_state = next(
+                        (state for state in quiz_state["student_states"] 
+                         if state["student_id"] == student_id),
+                        None
+                    )
+                    if student_state:
+                        start_time = student_state["start_time"]
+                        time_remaining = (start_time + timedelta(minutes=quiz['duration_minutes'])) - datetime.now()
                         
-                        # Display quiz form
-                        with st.form(f"pre_class_quiz_{quiz['_id']}"):
-                            student_answers = {}
-                            for i, question in enumerate(quiz["questions"]):
-                                st.markdown(f"**Q{i+1}:** {question['question']}")
-                                options = [opt for opt in question["options"]]
-                                student_answers[str(i)] = st.radio(
-                                    f"Select answer:",
-                                    options=options,
-                                    key=f"q_{quiz['_id']}_{i}"
-                                )
+                        if time_remaining.total_seconds() > 0:
+                            st.info(f"Time remaining: {int(time_remaining.total_seconds() // 60)}:{int(time_remaining.total_seconds() % 60):02d}")
+                            
+                            # Display questions
+                            questions = student_state["allocated_questions"]
+                            with st.form(f"pre_class_quiz_{quiz['_id']}"):
+                                student_answers = {}
+                                
+                                for i, question in enumerate(questions):
+                                    st.markdown(f"**Q{i+1}:** {question['question']}")
+                                    options = question["options"]
+                                    answer = st.radio(
+                                        "Select answer:",
+                                        options=options,
+                                        key=f"q_{quiz['_id']}_{i}"
+                                    )
+                                    if answer:
+                                        student_answers[str(i)] = answer
 
-                            if st.form_submit_button("Submit Quiz"):
-                                score = submit_quiz_answers(
-                                    quiz["_id"], 
-                                    student_id, 
-                                    student_answers
-                                )
-                                if score is not None:
-                                    st.success(f"Quiz submitted! Score: {score:.1f}%")
-                                    st.rerun()
-                                else:
-                                    st.error("Error submitting quiz")
-                    else:
-                        st.error("Quiz time expired")
+                                if st.form_submit_button("Submit Quiz"):
+                                    if len(student_answers) != len(questions):
+                                        st.error("Please answer all questions before submitting.")
+                                    else:
+                                        # Calculate score
+                                        correct_answers = 0
+                                        for i, question in enumerate(questions):
+                                            if student_answers.get(str(i)) == question["correct_option"]:
+                                                correct_answers += 1
+                                                
+                                        score = (correct_answers / len(questions)) * 100
+                                        
+                                        # Save submission
+                                        result = quizzes_collection.update_one(
+                                            {"_id": quiz["_id"]},
+                                            {
+                                                "$push": {
+                                                    "submissions": {
+                                                        "student_id": student_id,
+                                                        "allocated_questions": questions,
+                                                        "answers": student_answers,
+                                                        "score": score,
+                                                        "submitted_at": datetime.now()
+                                                    }
+                                                },
+                                                "$set": {
+                                                    "student_states.$[state].completed": True
+                                                }
+                                            },
+                                            array_filters=[
+                                                {"state.student_id": student_id}
+                                            ]
+                                        )
+                                        if result.modified_count > 0:
+                                            st.success(f"Quiz submitted! Score: {score:.1f}%")
+                                            st.rerun()
+                                        else:
+                                            st.error("Error submitting quiz")
+                        else:
+                            st.error("Quiz time expired")
+                # start_time = quiz.get("start_time")
+                # if not start_time:
+                #     if st.button("Start Quiz", key=f"start_{quiz['_id']}"):
+                #         # Get random questions when starting
+                #         questions = get_randomized_questions(quiz["_id"])
+                #         if questions:
+                #             # Save selected questions and start time
+                #             result = quizzes_collection.update_one(
+                #                 {"_id": quiz["_id"]},
+                #                 {
+                #                     "$set": {
+                #                         "start_time": datetime.now(),
+                #                         f"student_questions.{student_id}": questions
+                #                     }
+                #                 }
+                #             )
+                #             if result.modified_count > 0:
+                #                 st.rerun()
+                #         else:
+                #             st.error("Error getting quiz questions")
+                # else:
+                #     time_remaining = (start_time + timedelta(minutes=quiz['duration_minutes'])) - datetime.now()
+                    
+                #     # if time_remaining.total_seconds() > 0:
+                #     #     st.info(f"Time remaining: {int(time_remaining.total_seconds() // 60)}:{int(time_remaining.total_seconds() % 60):02d}")
+                        
+                #     #     # Display quiz form
+                #     #     with st.form(f"pre_class_quiz_{quiz['_id']}"):
+                #     #         student_answers = {}
+                #     #         for i, question in enumerate(quiz["questions"]):
+                #     #             st.markdown(f"**Q{i+1}:** {question['question']}")
+                #     #             options = [opt for opt in question["options"]]
+                #     #             student_answers[str(i)] = st.radio(
+                #     #                 f"Select answer:",
+                #     #                 options=options,
+                #     #                 key=f"q_{quiz['_id']}_{i}"
+                #     #             )
+
+                #     #         if st.form_submit_button("Submit Quiz"):
+                #     #             score = submit_quiz_answers(
+                #     #                 quiz["_id"], 
+                #     #                 student_id, 
+                #     #                 student_answers
+                #     #             )
+                #     #             if score is not None:
+                #     #                 st.success(f"Quiz submitted! Score: {score:.1f}%")
+                #     #                 st.rerun()
+                #     #             else:
+                #     #                 st.error("Error submitting quiz")
+                #     # else:
+                #     #     st.error("Quiz time expired")
+                #     if time_remaining.total_seconds() > 0:
+                #         st.info(f"Time remaining: {int(time_remaining.total_seconds() // 60)}:{int(time_remaining.total_seconds() % 60):02d}")
+                        
+                #         # Get student's randomized questions
+                #         student_questions = quiz.get("student_questions", {}).get(student_id)
+                        
+                #         if student_questions:
+                #             with st.form(f"pre_class_quiz_{quiz['_id']}"):
+                #                 student_answers = {}
+                                
+                #                 for i, question in enumerate(student_questions):
+                #                     st.markdown(f"**Q{i+1}:** {question['question']}")
+                #                     options = question["options"]
+                #                     student_answers[str(i)] = st.radio(
+                #                         "Select answer:",
+                #                         options=options,
+                #                         key=f"q_{quiz['_id']}_{i}"
+                #                     )
+                                    
+                #                 if st.form_submit_button("Submit Quiz"):
+                #                     score = submit_quiz_answers(
+                #                         quiz["_id"],
+                #                         student_id,
+                #                         student_answers,
+                #                         student_questions
+                #                     )
+                                    
+                #                     if score is not None:
+                #                         st.success(f"Quiz submitted! Score: {score:.1f}%")
+                #                         st.rerun()
+                #                     else:
+                #                         st.error("Error submitting quiz")
+                #     else:
+                #         st.error("Quiz time expired")
 
 
 def get_chat_context(session_id):
@@ -1389,13 +1558,76 @@ def upload_preclass_materials(session_id, course_id, student_id):
     with pre_class_quiz:
         if st.session_state.user_type == "faculty":
             st.subheader("Create Pre-class Quiz")
+            # with st.form("create_pre_class_quiz_form"):
+            #     quiz_title = st.text_input("Quiz Title")
+            #     num_questions = st.number_input(
+            #         "Number of Questions", 
+            #         min_value=1, 
+            #         max_value=20, 
+            #         value=5
+            #     )
+            #     duration = st.number_input(
+            #         "Quiz Duration (minutes)", 
+            #         min_value=5,
+            #         max_value=60,
+            #         value=15
+            #     )
+
+            #     # Generate quiz button
+            #     if st.form_submit_button("Generate Pre-class Quiz"):
+            #         if not quiz_title:
+            #             st.error("Please enter a quiz title")
+            #             return
+
+            #         # Get pre-class materials
+            #         materials = resources_collection.find({"session_id": session_id})
+            #         context = ""
+            #         for material in materials:
+            #             if 'text_content' in material:
+            #                 context += material['text_content'] + "\n"
+
+            #         if not context:
+            #             st.error("No pre-class materials found")
+            #             return
+
+            #         # Generate questions
+            #         questions = generate_mcqs(
+            #             context=context,
+            #             num_questions=num_questions,
+            #             session_title=session['title'],
+            #             session_description=session.get('description', '')
+            #         )
+
+            #         if questions:
+            #             # Preview questions
+            #             st.subheader("Preview Questions")
+            #             for i, q in enumerate(questions, 1):
+            #                 st.markdown(f"**Q{i}:** {q['question']}")
+            #                 for opt in q['options']:
+            #                     st.markdown(f"- {opt}")
+            #                 st.markdown(f"*Correct: {q['correct_option']}*")
+
+            #             # Save quiz
+            #             quiz_id = save_pre_class_quiz(
+            #                 course_id=course_id,
+            #                 session_id=session_id,
+            #                 title=quiz_title,
+            #                 questions=questions,
+            #                 user_id=st.session_state.user_id,
+            #                 duration=duration
+            #             )
+
+            #             if quiz_id:
+            #                 st.success("Pre-class quiz created successfully!")
+            #             else:
+            #                 st.error("Error saving quiz")
             with st.form("create_pre_class_quiz_form"):
                 quiz_title = st.text_input("Quiz Title")
                 num_questions = st.number_input(
-                    "Number of Questions", 
-                    min_value=1, 
-                    max_value=20, 
-                    value=5
+                    "Number of Questions per Student", 
+                    min_value=5,
+                    max_value=30,
+                    value=10
                 )
                 duration = st.number_input(
                     "Quiz Duration (minutes)", 
@@ -1404,54 +1636,111 @@ def upload_preclass_materials(session_id, course_id, student_id):
                     value=15
                 )
 
-                # Generate quiz button
-                if st.form_submit_button("Generate Pre-class Quiz"):
-                    if not quiz_title:
-                        st.error("Please enter a quiz title")
-                        return
-
-                    # Get pre-class materials
-                    materials = resources_collection.find({"session_id": session_id})
-                    context = ""
-                    for material in materials:
-                        if 'text_content' in material:
-                            context += material['text_content'] + "\n"
-
-                    if not context:
-                        st.error("No pre-class materials found")
-                        return
+                if st.form_submit_button("Generate Question Bank"):
+                    with st.spinner("Generating question bank..."):
+                        try:
+                            if not quiz_title:
+                                st.error("Please enter a quiz title")
+                                return
 
-                    # Generate questions
-                    questions = generate_mcqs(
-                        context=context,
-                        num_questions=num_questions,
-                        session_title=session['title'],
-                        session_description=session.get('description', '')
-                    )
+                            # Get pre-class materials
+                            materials = resources_collection.find({"session_id": session_id})
+                            context = ""
+                            for material in materials:
+                                if 'text_content' in material:
+                                    context += material['text_content'] + "\n"
 
-                    if questions:
-                        # Preview questions
-                        st.subheader("Preview Questions")
-                        for i, q in enumerate(questions, 1):
-                            st.markdown(f"**Q{i}:** {q['question']}")
-                            for opt in q['options']:
-                                st.markdown(f"- {opt}")
-                            st.markdown(f"*Correct: {q['correct_option']}*")
-
-                        # Save quiz
-                        quiz_id = save_pre_class_quiz(
-                            course_id=course_id,
-                            session_id=session_id,
-                            title=quiz_title,
-                            questions=questions,
-                            user_id=st.session_state.user_id,
-                            duration=duration
-                        )
+                            if not context:
+                                st.error("No pre-class materials found")
+                                return
 
-                        if quiz_id:
-                            st.success("Pre-class quiz created successfully!")
-                        else:
-                            st.error("Error saving quiz")
+                            # Generate question bank
+                            question_bank = generate_pre_class_question_bank(
+                                context=context,
+                                session_title=session['title'],
+                                session_description=session.get('description', '')
+                            )
+                            if question_bank:
+                                print(question_bank)
+                                # Preview question bank
+                                st.subheader("Question Bank Preview")
+                                
+                                # Show statistics
+                                difficulties = [q['difficulty'] for q in question_bank]
+                                st.write("Question Distribution:")
+                                st.write(f"- Easy: {difficulties.count('easy')}")
+                                st.write(f"- Medium: {difficulties.count('medium')}")
+                                st.write(f"- Hard: {difficulties.count('hard')}")
+                                
+                                # Show questions
+                                for i, q in enumerate(question_bank, 1):
+                                    with st.expander(f"Q{i}: {q['topic']} ({q['difficulty']})"):
+                                        st.markdown(f"**Question:** {q['question']}")
+                                        st.markdown("**Options:**")
+                                        for opt in q['options']:
+                                            if opt == q['correct_option']:
+                                                st.markdown(f"✅ {opt}")
+                                            else:
+                                                st.markdown(f"- {opt}")
+                                # Save quiz with question bank
+                                quiz_id = save_pre_class_quiz_with_bank(
+                                    course_id=course_id,
+                                    session_id=session_id,
+                                    title=quiz_title,
+                                    question_bank=question_bank,
+                                    num_questions=num_questions,
+                                    duration=duration,
+                                    user_id=st.session_state.user_id
+                                )
+                                if quiz_id:
+                                    st.success("Pre-class quiz created successfully!")
+                            else:
+                                st.error("Error generating question bank")
+                        except Exception as e:
+                            st.error("Error saving quiz", e)
+                # else:
+                #     st.error("Error generating question bank")
+            # question_banks = quizzes_collection.find({
+            #     "course_id": course_id,
+            #     "session_id": session_id,
+            #     "quiz_type": "pre_class"
+            # })
+            question_banks = list(quizzes_collection.find({
+                "course_id": course_id,
+                "session_id": session_id,
+                "quiz_type": "pre_class"
+            }))
+            if question_banks and len(question_banks) > 0: 
+                st.markdown("#### Existing Question Banks")
+                for bank in question_banks:
+                    try:
+                        faculty_member = faculty_collection.find_one({"_id": ObjectId(bank['user_id'])})
+                        faculty_name = faculty_member['full_name'] if faculty_member else "Unknown Faculty"
+                        
+                        with st.expander(f"📚 {bank.get('title', 'Untitled Quiz')}"):
+                            # Check if question bank exists
+                            if 'question_bank' in bank and bank['question_bank']:
+                                st.markdown(f"**Number of Questions:** {len(bank['question_bank'])}")
+                                st.markdown(f"**Created By:** {faculty_name}")
+                                st.markdown(f"**Created At:** {bank['created_at'].strftime('%Y-%m-%d %H:%M:%S')}")
+                                
+                                # Display questions
+                                for i, question in enumerate(bank['question_bank'], 1):
+                                    st.markdown(f"**Question {i}:** {question['question']}")
+                                    st.markdown("**Options:**")
+                                    for opt in question['options']:
+                                        if opt == question['correct_option']:
+                                            st.markdown(f"✅ {opt}")
+                                        else:
+                                            st.markdown(f"- {opt}")
+                                    st.markdown(f"**Difficulty:** {question['difficulty']}")
+                                    st.markdown(f"**Topic:** {question['topic']}")
+                            else:
+                                st.warning("This question bank appears to be empty")
+                    except Exception as e:
+                        st.error(f"Error displaying question bank: {str(e)}")
+            else:
+                st.info("No question banks yet for this session")
 
 def extract_external_content(url, content_type):
     """Extract content from external resources based on their type"""
@@ -3440,13 +3729,19 @@ def display_session_analytics(session, course_id):
 def display_quiz_tab(student_id, course_id, session_id):
     """Display quizzes for students"""
     st.header("Course Quizzes")
-    
-    # Get available quizzes for this session
+    # Get available quizzes for this session, excluding pre-class quizzes
     quizzes = quizzes_collection.find({
         "course_id": course_id,
         "session_id": session_id,
-        "status": "active"
+        "status": "active",
+        "quiz_type": {"$ne": "pre_class"}
     })
+    # Get available quizzes for this session
+    # quizzes = quizzes_collection.find({
+    #     "course_id": course_id,
+    #     "session_id": session_id,
+    #     "status": "active"
+    # })
     
     quizzes = list(quizzes)
     if not quizzes:
@@ -3570,7 +3865,8 @@ def display_session_content(student_id, course_id, session, username, user_type)
         with tabs[2]:
             display_post_class_content(session, student_id, course_id)
         with tabs[3]:
-            display_preclass_analytics2(session, course_id)
+            if st.button("Generate Pre-class Analytics") and not st.session_state.analytics_data:
+                display_preclass_analytics2(session, course_id)
         with tabs[4]:
             display_inclass_analytics(session, course_id)
         with tabs[5]: