add quiz in pre-class

chatbot.py

@@ -7,6 +7,7 @@ import os
 from datetime import datetime
 from bson import ObjectId
 from file_upload_vectorize import model
+from gen_mcqs import generate_mcqs, quizzes_collection
 
 load_dotenv()
 MONGO_URI = os.getenv('MONGO_URI')
@@ -49,3 +50,18 @@ def give_chat_response(user_id, session_id, question, title, description, contex
     insert_chat_message(user_id, session_id, "assistant", assistant_response)
     
     return assistant_response
+
+def create_quiz_by_context(user_id, session_id, context, length, session_title, session_description):
+    """Create a quiz based on the context provided"""
+    quiz = generate_mcqs(context, length, session_title, session_description)
+    if not quiz:
+        return "No quiz generated";
+    
+    # Save the quiz
+    quizzes_collection.insert_one({
+        "user_id": ObjectId(user_id),
+        "session_id": ObjectId(session_id),
+        "questions": quiz,
+        "timestamp": datetime.utcnow()
+    })
+    return "Quiz created successfully"

course_creation.py

@@ -0,0 +1,108 @@
+import pandas as pd
+import json
+import os
+from datetime import datetime
+import openai
+from openai import OpenAI
+import streamlit as st
+from llama_index.core import VectorStoreIndex, Document
+from llama_index.core.vector_stores import SimpleVectorStore
+from llama_index.core.storage.storage_context import StorageContext
+from llama_index.embeddings.openai import OpenAIEmbedding
+from pymongo import MongoClient
+import numpy as np
+from numpy.linalg import norm
+import PyPDF2
+from io import BytesIO
+import base64
+
+MONGO_URI = os.getenv('MONGO_URI')
+PERPLEXITY_KEY = os.getenv('PERPLEXITY_KEY')
+
+# Connect to MongoDB
+client = MongoClient(MONGO_URI)
+db = client['novascholar_db']
+
+# Function to fetch data from Perplexity API
+def fetch_perplexity_data(api_key, topic):
+    headers = {
+        "accept": "application/json",
+        "content-type": "application/json",
+        "authorization": f"Bearer {api_key}"
+    }
+    messages = [
+        {
+            "role": "system",
+            "content": (
+                "You are a expert providing official information about the given topic. Provide only verified information with atleast 3 working reference links for citations."
+            ),
+        },
+        {
+            "role": "user",
+            "content": topic
+        },
+    ]
+    
+    try:
+        client = OpenAI(api_key=api_key, base_url="https://api.perplexity.ai")
+        response = client.chat.completions.create(
+            model="llama-3.1-sonar-small-128k-online",
+            messages=messages,
+        )
+        content = response.choices[0].message.content
+        return content
+    except Exception as e:
+        st.error(f"Failed to fetch data from Perplexity API: {e}")
+        return ""
+    
+def structure_data(api_key, generated_text, columns):
+    prompt = f"You are given a large amount of data that can be structured into a table with many rows. Structure the following data into a JSON format with columns: {columns}. Data: {generated_text}. Ensure that you only output the data in JSON format without any other text at all, not even backtics `` and the word JSON. Do not include any other information in the output."
+    messages = [
+        {
+            "role": "system",
+            "content": "You are an AI that structures data into JSON format for converting unstructured text data into tables. Ensure that you have atlest as many rows in the output as much mentioned in the input text. Return the data in such a way that it is a list of dictionaried that can be converted to a pandas dataframe directly."
+        },  
+        {
+            "role": "user",
+            "content": prompt
+        },
+    ]
+    
+    try:
+        client = OpenAI(api_key=api_key)
+        response = client.chat.completions.create(
+            model="gpt-4o",
+            messages=messages,
+            temperature=0.1,
+        )
+        json_content = response.choices[0].message.content
+        return json.loads(json_content)
+    except Exception as e:
+        st.error(f"Failed to structure data using GPT-4o Mini: {e}")
+        return []
+
+def generate_theme_title(api_key, text):
+    prompt = f"Provide a 2-3 word title that captures the main theme of the following text: {text} Return only the 2 3 word string and nothing else. Do not include any other information in the output."
+    messages = [
+        {
+            "role": "system",
+            "content": "You are an AI that generates concise titles for text content."
+        },
+        {
+            "role": "user",
+            "content": prompt
+        },
+    ]
+    
+    try:
+        client = OpenAI(api_key=api_key)
+        response = client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=messages,
+            temperature=0.1,
+        )
+        theme_title = response.choices[0].message.content.strip()
+        return theme_title
+    except Exception as e:
+        st.error(f"Failed to generate theme title using GPT-4o Mini: {e}")
+        return "Unnamed Theme"

file_upload_vectorize.py

@@ -70,12 +70,14 @@ def assignment_submit(student_id, course_id, session_id, assignment_id,  file_na
         "student_id": student_id,
         "course_id": course_id,
         "session_id": session_id,
+        "assignment_id": assignment_id,
         "file_name": file_name,
         "file_type": file_content.type,
         "file_content": original_file_content,  # Store the original file content
         "text_content": text_content,
         "material_type": material_type,
-        "uploaded_at": datetime.utcnow()
+        "submitted_at": datetime.utcnow(),
+        "file_url": "sample_url"
     }
     try:
         courses_collection2.update_one(

gen_mcqs.py

@@ -1,3 +1,4 @@
+import ast
 from pymongo import MongoClient
 from datetime import datetime
 import openai
@@ -23,6 +24,17 @@ client = MongoClient(MONGO_URI)
 db = client['novascholar_db']
 quizzes_collection = db["quizzes"]
 
+def strip_code_markers(response_text):
+    """Strip off the markers ``` and python from a LLM model's response"""
+    if response_text.startswith("```python"):
+        response_text = response_text[len("```python"):].strip()
+    if response_text.startswith("```"):
+        response_text = response_text[len("```"):].strip()
+    if response_text.endswith("```"):
+        response_text = response_text[:-len("```")].strip()
+    return response_text
+
+
 # New function to generate MCQs using Gemini
 def generate_mcqs(context, num_questions, session_title, session_description):
     """Generate MCQs either from context or session details"""
@@ -58,29 +70,46 @@ def generate_mcqs(context, num_questions, session_title, session_description):
             }}
             
             Generate challenging but clear questions.
-            Return only the Python list of dictionaries.
+            Return only the Python list of dictionaries without any additional formatting or markers
+            Do not write any other text, do not start the response with (```python), do not end the response with backticks(```)
+            A Sample response should look like this: Response Text: [
+                {
+                    "question": "Which of the following is NOT a valid data type in C++?",
+                    "options": ["int", "double", "boolean", "char"],
+                    "correct_option": "C"
+                }
+            ] (Notice that there are no backticks(```) around the response and no (```python)) 
+            .
             """
         
         response = model.generate_content(prompt)
+        response_text = response.text.strip()
+        print("Response Text:", response_text)
+        modified_response_text = strip_code_markers(response_text)
+        print("Response Text Modified to:", modified_response_text)
         # Extract and parse the response to get the list of MCQs
-        mcqs = eval(response.text)  # Be careful with eval, consider using ast.literal_eval for production
+        mcqs = ast.literal_eval(modified_response_text)  # Be careful with eval, consider using ast.literal_eval for production
         print(mcqs)
+        if not mcqs:
+            raise ValueError("No questions generated")
         return mcqs
     except Exception as e:
-        print(f"Error generating MCQs: {e}")
+        print(f"Error generating MCQs: , error: {e}")
         return None
 
 # New function to save quiz to database
-def save_quiz(course_id, session_id, title, questions):
+def save_quiz(course_id, session_id, title, questions, user_id):
     """Save quiz to database"""
     try:
         quiz_data = {
+            "user_id": user_id,
             "course_id": course_id,
             "session_id": session_id,
             "title": title,
             "questions": questions,
             "created_at": datetime.utcnow(),
-            "status": "active"
+            "status": "active",
+            "submissions": []
         }
         result = quizzes_collection.insert_one(quiz_data)
         return result.inserted_id
@@ -102,36 +131,76 @@ def get_student_quiz_score(quiz_id, student_id):
         return quiz['submissions'][0].get('score')
     return None
 
-def submit_quiz_answers(quiz_id, student_id, student_answers):
-    """Submit and score student's quiz answers"""
-    quiz = quizzes_collection.find_one({"_id": quiz_id})
-    if not quiz:
-        return None
+# def submit_quiz_answers(quiz_id, student_id, student_answers):
+#     """Submit and score student's quiz answers"""
+#     quiz = quizzes_collection.find_one({"_id": quiz_id})
+#     if not quiz:
+#         return None
     
-    # Calculate score
-    correct_answers = 0
-    total_questions = len(quiz['questions'])
+#     # Calculate score
+#     correct_answers = 0
+#     total_questions = len(quiz['questions'])
     
-    for q_idx, question in enumerate(quiz['questions']):
-        if student_answers.get(str(q_idx)) == question['correct_option']:
-            correct_answers += 1
+#     for q_idx, question in enumerate(quiz['questions']):
+#         if student_answers.get(str(q_idx)) == question['correct_option']:
+#             correct_answers += 1
     
-    score = (correct_answers / total_questions) * 100
+#     score = (correct_answers / total_questions) * 100
     
-    # Store submission
-    submission_data = {
-        "student_id": student_id,
-        "answers": student_answers,
-        "score": score,
-        "submitted_at": datetime.utcnow()
-    }
+#     # Store submission
+#     submission_data = {
+#         "student_id": student_id,
+#         "answers": student_answers,
+#         "score": score,
+#         "submitted_at": datetime.utcnow()
+#     }
     
-    # Update quiz with submission
-    quizzes_collection.update_one(
-        {"_id": quiz_id},
-        {
-            "$push": {"submissions": submission_data}
-        }
-    )
+#     # Update quiz with submission
+#     quizzes_collection.update_one(
+#         {"_id": quiz_id},
+#         {
+#             "$push": {"submissions": submission_data}
+#         }
+#     )
     
-    return score
+#     return score
+def submit_quiz_answers(quiz_id, student_id, student_answers):
+    """Submit and score student's quiz answers"""
+    try:
+        quiz = quizzes_collection.find_one({"_id": quiz_id})
+        if not quiz:
+            return None
+        
+        # Calculate score
+        correct_answers = 0
+        total_questions = len(quiz['questions'])
+        
+        for q_idx, question in enumerate(quiz['questions']):
+            student_answer = student_answers.get(str(q_idx))
+            if student_answer:  # Only check if answer was provided
+                # Extract the option letter (A, B, C, D) from the full answer string
+                answer_letter = student_answer.split(')')[0].strip()
+                if answer_letter == question['correct_option']:
+                    correct_answers += 1
+        
+        score = (correct_answers / total_questions) * 100
+        
+        # Store submission
+        submission_data = {
+            "student_id": student_id,
+            "answers": student_answers,
+            "score": score,
+            "submitted_at": datetime.utcnow()
+        }
+        
+        # Update quiz with submission
+        result = quizzes_collection.update_one(
+            {"_id": quiz_id},
+            {"$push": {"submissions": submission_data}}
+        )
+        
+        return score if result.modified_count > 0 else None
+        
+    except Exception as e:
+        print(f"Error submitting quiz: {e}")
+        return None

main.py

@@ -101,8 +101,9 @@ def login_form():
     st.title("Welcome to NOVAScholar")
 
     with st.form("login_form"):
+        
         user_type = st.selectbox(
-            "Select User Type", ["student", "faculty", "research_assistant", "analyst"]
+            "Please select your Role", ["student", "faculty", "research_assistant", "analyst"]
         )
         username = st.text_input("Username")
         password = st.text_input("Password", type="password")
@@ -184,6 +185,11 @@ def create_session_form(course_id):
     """Display form to create a new session and perform the creation operation"""
     st.title("Create New Session")
 
+    if 'session_time' not in st.session_state:
+        st.session_state.session_time = datetime.now().time()
+    if 'show_create_session_form' not in st.session_state:
+        st.session_state.show_create_session_form = False
+
     with st.form("create_session_form"):
         session_title = st.text_input("Session Title")
         session_date = st.date_input("Session Date", date.today(), key="session_date")
@@ -191,9 +197,6 @@ def create_session_form(course_id):
             "Session Time", st.session_state.session_time, key="session_time"
         )
 
-        if "show_create_session_form" not in st.session_state:
-            st.session_state.show_create_session_form = False
-
         new_session_id = None
         # Generate new session ID
         course = courses_collection2.find_one({"course_id": course_id})

modify_schema.py

@@ -0,0 +1,222 @@
+from db import courses_collection2
+from dotenv import load_dotenv
+import os
+from pymongo import MongoClient
+from datetime import datetime
+
+
+
+load_dotenv()
+MONGO_URI = os.getenv("MONGO_URI")
+
+client = MongoClient(MONGO_URI)
+db = client["novascholar_db"]
+
+# Define the updated course schema
+updated_course_schema = {
+    "bsonType": "object",
+    "required": [
+        "course_id",
+        "title",
+        "description",
+        "faculty",
+        "faculty_id",
+        "duration",
+        "created_at",
+    ],
+    "properties": {
+        "course_id": {
+            "bsonType": "string",
+            "description": "Unique identifier for the course",
+        },
+        "title": {"bsonType": "string", "description": "Title of the course"},
+        "description": {
+            "bsonType": "string",
+            "description": "Description of the course",
+        },
+        "faculty": {"bsonType": "string", "description": "Name of the faculty"},
+        "duration": {"bsonType": "string", "description": "Duration of the course"},
+        "created_at": {
+            "bsonType": "date",
+            "description": "Date when the course was created",
+        },
+        "sessions": {
+            "bsonType": "array",
+            "description": "List of sessions associated with the course",
+            "items": {
+                "bsonType": "object",
+                "required": ["session_id", "title", "date"],
+                "properties": {
+                    "session_id": {
+                        "bsonType": "string",
+                        "description": "Unique identifier for the session",
+                    },
+                    "title": {
+                        "bsonType": "string",
+                        "description": "Title of the session",
+                    },
+                    "date": {"bsonType": "date", "description": "Date of the session"},
+                    "status": {
+                        "bsonType": "string",
+                        "description": "Status of the session (e.g., completed, upcoming)",
+                    },
+                    "created_at": {
+                        "bsonType": "date",
+                        "description": "Date when the session was created",
+                    },
+                    "pre_class": {
+                        "bsonType": "object",
+                        "description": "Pre-class segment data",
+                        "properties": {
+                            "resources": {
+                                "bsonType": "array",
+                                "description": "List of pre-class resources",
+                                "items": {
+                                    "bsonType": "object",
+                                    "required": ["type", "title", "url"],
+                                    "properties": {
+                                        "type": {
+                                            "bsonType": "string",
+                                            "description": "Type of resource (e.g., pdf, video)",
+                                        },
+                                        "title": {
+                                            "bsonType": "string",
+                                            "description": "Title of the resource",
+                                        },
+                                        "url": {
+                                            "bsonType": "string",
+                                            "description": "URL of the resource",
+                                        },
+                                        "vector": {
+                                            "bsonType": "array",
+                                            "description": "Vector representation of the resource",
+                                            "items": {"bsonType": "double"},
+                                        },
+                                    },
+                                },
+                            },
+                            "completion_required": {
+                                "bsonType": "bool",
+                                "description": "Indicates if completion of pre-class resources is required",
+                            },
+                        },
+                    },
+                    "in_class": {
+                        "bsonType": "object",
+                        "description": "In-class segment data",
+                        "properties": {
+                            "topics": {
+                                "bsonType": "array",
+                                "description": "List of topics covered in the session",
+                                "items": {"bsonType": "string"},
+                            },
+                            "quiz": {
+                                "bsonType": "object",
+                                "description": "Quiz data",
+                                "properties": {
+                                    "title": {
+                                        "bsonType": "string",
+                                        "description": "Title of the quiz",
+                                    },
+                                    "questions": {
+                                        "bsonType": "int",
+                                        "description": "Number of questions in the quiz",
+                                    },
+                                    "duration": {
+                                        "bsonType": "int",
+                                        "description": "Duration of the quiz in minutes",
+                                    },
+                                },
+                            },
+                            "polls": {
+                                "bsonType": "array",
+                                "description": "List of polls conducted during the session",
+                                "items": {
+                                    "bsonType": "object",
+                                    "required": ["question", "options"],
+                                    "properties": {
+                                        "question": {
+                                            "bsonType": "string",
+                                            "description": "Poll question",
+                                        },
+                                        "options": {
+                                            "bsonType": "array",
+                                            "description": "List of poll options",
+                                            "items": {"bsonType": "string"},
+                                        },
+                                        "responses": {
+                                            "bsonType": "object",
+                                            "description": "Responses to the poll",
+                                            "additionalProperties": {"bsonType": "int"},
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    "post_class": {
+                        "bsonType": "object",
+                        "description": "Post-class segment data",
+                        "properties": {
+                            "assignments": {
+                                "bsonType": "array",
+                                "description": "List of assignments",
+                                "items": {
+                                    "bsonType": "object",
+                                    "required": ["id", "title", "due_date", "status"],
+                                    "properties": {
+                                        "id": {
+                                            "bsonType": ["objectId", "int"],
+                                            "description": "Assignment ID",
+                                        },
+                                        "title": {
+                                            "bsonType": "string",
+                                            "description": "Title of the assignment",
+                                        },
+                                        "due_date": {
+                                            "bsonType": "date",
+                                            "description": "Due date of the assignment",
+                                        },
+                                        "status": {
+                                            "bsonType": "string",
+                                            "description": "Status of the assignment (e.g., pending, completed)",
+                                        },
+                                        "submissions": {
+                                            "bsonType": "array",
+                                            "description": "List of submissions",
+                                            "items": {
+                                                "bsonType": "object",
+                                                "properties": {
+                                                    "student_id": {
+                                                        "bsonType": "objectId",
+                                                        "description": "ID of the student who submitted the assignment",
+                                                    },
+                                                    "file_url": {
+                                                        "bsonType": "string",
+                                                        "description": "URL of the submitted file",
+                                                    },
+                                                    "submitted_at": {
+                                                        "bsonType": "date",
+                                                        "description": "Date when the assignment was submitted",
+                                                    },
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            }
+                        },
+                    },
+                },
+            },
+        },
+    },
+}
+
+# Update the schema using the collMod command
+db.command({
+    "collMod": "courses_collection2",
+    "validator": {"$jsonSchema": updated_course_schema}
+})
+
+print("Schema updated successfully!")

session_page.py

@@ -1,3 +1,4 @@
+import random
 import streamlit as st
 from datetime import datetime
 from utils.helpers import display_progress_bar, create_notification, format_datetime
@@ -24,7 +25,7 @@ def get_current_user():
         return None
     return students_collection.find_one({"_id": st.session_state.user_id})
 
-def display_preclass_content(session, student_id, course_id):
+# def display_preclass_content(session, student_id, course_id):
     """Display pre-class materials for a session"""
     
     # Initialize 'messages' in session_state if it doesn't exist
@@ -101,13 +102,308 @@ def display_preclass_content(session, student_id, course_id):
         with st.chat_message("assistant"):
             st.markdown(response)
     
-    st.subheader("Your Chat History")
-    for message in st.session_state.messages:
-        content = message.get("content", "")  # Default to an empty string if "content" is not present
-        role = message.get("role", "user")  # Default to "user" if "role" is not present
-        with st.chat_message(role):
-            st.markdown(content)
-    user = get_current_user()
+    # st.subheader("Your Chat History")
+    # for message in st.session_state.messages:
+    #     content = message.get("content", "")  # Default to an empty string if "content" is not present
+    #     role = message.get("role", "user")  # Default to "user" if "role" is not present
+    #     with st.chat_message(role):
+    #         st.markdown(content)
+    # user = get_current_user()
+    
+def display_preclass_content(session, student_id, course_id):
+    """Display pre-class materials for a session"""
+    st.subheader("Pre-class Materials")
+
+    # Display pre-class materials
+    materials = resources_collection.find({"session_id": session['session_id']})
+    for material in materials:
+        with st.expander(f"{material['file_name']} ({material['material_type'].upper()})"):
+            file_type = material.get('file_type', 'unknown')
+            if file_type == 'application/pdf':
+                st.markdown(f"📑 [Open PDF Document]({material['file_name']})")
+                if st.button("View PDF", key=f"view_pdf_{material['file_name']}"):
+                    st.text_area("PDF Content", material['text_content'], height=300)
+                if st.button("Download PDF", key=f"download_pdf_{material['file_name']}"):
+                    st.download_button(
+                        label="Download PDF",
+                        data=material['file_content'],
+                        file_name=material['file_name'],
+                        mime='application/pdf'
+                    )
+                if st.button("Mark PDF as Read", key=f"pdf_{material['file_name']}"):
+                    create_notification("PDF marked as read!", "success")
+
+    # Chat input
+    # Add a check, if materials are available, only then show the chat input
+    if(st.session_state.user_type == "student"):
+        if materials:
+            if prompt := st.chat_input("Ask a question about Pre-class Materials"):
+                if len(st.session_state.messages) >= 20:
+                    st.warning("Message limit (20) reached for this session.")
+                    return
+
+                st.session_state.messages.append({"role": "user", "content": prompt})
+
+                # Display User Message
+                with st.chat_message("user"):
+                    st.markdown(prompt)
+
+                # Get document context
+                context = ""
+                materials = resources_collection.find({"session_id": session['session_id']})
+                context = ""
+                vector_data = None
+
+                context = ""
+                for material in materials:
+                    resource_id = material['_id']
+                    vector_data = vectors_collection.find_one({"resource_id": resource_id})
+                    if vector_data and 'text' in vector_data:
+                        context += vector_data['text'] + "\n"
+
+                if not vector_data:
+                    st.error("No Pre-class materials found for this session.")
+                    return
+
+                try:
+                    # Generate response using Gemini
+                    context_prompt = f"""
+                    Based on the following context, answer the user's question:
+                    
+                    Context:
+                    {context}
+                    
+                    Question: {prompt}
+                    
+                    Please provide a clear and concise answer based only on the information provided in the context.
+                    """
+
+                    response = model.generate_content(context_prompt)
+                    if not response or not response.text:
+                        st.error("No response received from the model")
+                        return
+
+                    assistant_response = response.text
+                    # Display Assistant Response
+                    with st.chat_message("assistant"):
+                        st.markdown(assistant_response)
+
+                    # Build the message
+                    new_message = {
+                        "prompt": prompt,
+                        "response": assistant_response,
+                        "timestamp": datetime.utcnow()
+                    }
+                    st.session_state.messages.append(new_message)
+
+                    # Update database
+                    try:
+                        chat_history_collection.update_one(
+                            {
+                                "user_id": student_id,
+                                "session_id": session['session_id']
+                            },
+                            {
+                                "$push": {"messages": new_message},
+                                "$setOnInsert": {
+                                    "user_id": student_id,
+                                    "session_id": session['session_id'],
+                                    "timestamp": datetime.utcnow()
+                                }
+                            },
+                            upsert=True
+                        )
+                    except Exception as db_error:
+                        st.error(f"Error saving chat history: {str(db_error)}")
+                except Exception as e:
+                    st.error(f"Error generating response: {str(e)}")
+
+    else:
+        st.subheader("Upload Pre-class Material")
+        # File upload section for students
+        uploaded_file = st.file_uploader("Upload Material", type=['txt', 'pdf', 'docx'])
+        if uploaded_file is not None:
+            with st.spinner("Processing document..."):
+                file_name = uploaded_file.name
+                file_content = extract_text_from_file(uploaded_file)
+                if file_content:
+                    material_type = st.selectbox("Select Material Type", ["pdf", "docx", "txt"])
+                    if st.button("Upload Material"):
+                        upload_resource(course_id, session['session_id'], file_name, uploaded_file, material_type)
+
+                        # Search for the newly uploaded resource's _id in resources_collection
+                        resource_id = resources_collection.find_one({"file_name": file_name})["_id"]
+                        create_vector_store(file_content, resource_id)
+                        st.success("Material uploaded successfully!")
+
+    # st.subheader("Your Chat History")
+    if st.button("View Chat History"):
+        # Initialize chat messages from database
+        if 'messages' not in st.session_state or not st.session_state.messages:
+            existing_chat = chat_history_collection.find_one({
+                "user_id": student_id,
+                "session_id": session['session_id']
+            })
+            if existing_chat and 'messages' in existing_chat:
+                st.session_state.messages = existing_chat['messages']
+            else:
+                st.session_state.messages = []
+
+        # Display existing chat history
+        try:
+            for message in st.session_state.messages:
+                if 'prompt' in message and 'response' in message:
+                    with st.chat_message("user"):
+                        st.markdown(message["prompt"])
+                    with st.chat_message("assistant"):
+                        st.markdown(message["response"])
+        except Exception as e:
+            st.error(f"Error displaying chat history: {str(e)}")
+            st.session_state.messages = []
+    
+    if st.session_state.user_type == 'student':
+        st.subheader("Create a Practice Quiz")
+        questions = []
+        quiz_id = ""
+        with st.form("create_quiz_form"):
+            num_questions = st.number_input("Number of Questions", min_value=1, max_value=20, value=2)
+            submit_quiz = st.form_submit_button("Generate Quiz")
+            if submit_quiz:
+                # Get pre-class materials from resources_collection
+                materials = resources_collection.find({"session_id": session['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 for this session.")
+                    return
+
+                # Generate MCQs from context
+                questions = generate_mcqs(context, num_questions, session['title'], session.get('description', ''))
+                if questions:
+                    quiz_id = save_quiz(course_id, session['session_id'], "Practice Quiz", questions, student_id)
+                    if quiz_id:
+                            st.success("Quiz saved successfully!")
+                            st.session_state.show_quizzes = True
+                    else:
+                            st.error("Error saving quiz.")
+                else:
+                    st.error("Error generating questions.")
+
+        # if st.button("Attempt Practice Quizzes "):
+            # quizzes = list(quizzes_collection.find({"course_id": course_id, "session_id": session['session_id'], "user_id": student_id}))
+            
+            
+        if getattr(st.session_state, 'show_quizzes', False):
+            # quiz = quizzes_collection.find_one({"course_id": course_id, "session_id": session['session_id'], "user_id": student_id})
+            quiz = quizzes_collection.find_one(
+                {"course_id": course_id, "session_id": session['session_id'], "user_id": student_id},
+                sort=[("created_at", -1)]
+            )
+            if not quiz:
+                st.info("No practice quizzes created.")
+            else:
+                    with st.expander(f"📝 Practice Quiz", expanded=False):
+                        # Check if student has already taken this quiz
+                        existing_score = get_student_quiz_score(quiz['_id'], student_id)
+                        
+                        if existing_score is not None:
+                            st.success(f"Quiz completed! Your score: {existing_score:.1f}%")
+                            
+                            # Display correct answers after submission
+                            st.subheader("Quiz Review")
+                            for i, question in enumerate(quiz['questions']):
+                                st.markdown(f"**Question {i+1}:** {question['question']}")
+                                for opt in question['options']:
+                                    if opt.startswith(question['correct_option']):
+                                        st.markdown(f"✅ {opt}")
+                                    else:
+                                        st.markdown(f"- {opt}")
+                            
+                        else:
+                             # Initialize quiz state for this specific quiz
+                            quiz_key = f"quiz_{quiz['_id']}_student_{student_id}"
+                            if quiz_key not in st.session_state:
+                                st.session_state[quiz_key] = {
+                                    'submitted': False,
+                                    'score': None,
+                                    'answers': {}
+                                }
+
+                            # If quiz was just submitted, show the results
+                            if st.session_state[quiz_key]['submitted']:
+                                st.success(f"Quiz submitted successfully! Your score: {st.session_state[quiz_key]['score']:.1f}%")
+                                # Reset the quiz state
+                                st.session_state[quiz_key]['submitted'] = False
+
+
+                            # Display quiz questions
+                            st.write("Please select your answers:")
+                            
+                            # Create a form for quiz submission
+                            form_key = f"quiz_form_{quiz['_id']}_student_{student_id}"
+                            with st.form(key=form_key):
+                                student_answers = {}
+                                
+                                for i, question in enumerate(quiz['questions']):
+                                    st.markdown(f"**Question {i+1}:** {question['question']}")
+                                    options = [opt for opt in question['options']]
+                                    # student_answers[str(i)] = st.radio(
+                                    #     f"Select answer for question {i+1}:",
+                                    #     options=options,
+                                    #     key=f"q_{i}",
+                                    #     index=None
+                                    # ) 
+                                    answer = st.radio(
+                                        f"Select answer for question {i+1}:",
+                                        options=options,
+                                        key=f"{quiz['_id']}_{i}",  # Simplify the radio button key
+                                        index=None
+                                    )
+                                    if answer:  # Only add to answers if a selection was made
+                                        student_answers[str(i)] = answer                               
+
+                                # Submit button
+                                # submitted =  st.form_submit_button("Submit Quiz")
+                                print("Before the submit button")
+                                submit_button = st.form_submit_button("Submit Quiz")
+                                print("After the submit button")
+                            if submit_button and student_answers:
+                                print("Clicked the button")
+                                print(student_answers)
+                                correct_answers = 0
+                                for i, question in enumerate(quiz['questions']):
+                                    if student_answers[str(i)] == question['correct_option']:
+                                        correct_answers += 1
+                                score = (correct_answers / len(quiz['questions'])) * 100
+                                
+                                if score is not None:
+                                    st.success(f"Quiz submitted successfully! Your score: {score:.1f}%")
+                                    st.session_state[quiz_key]['submitted'] = True
+                                    st.session_state[quiz_key]['score'] = score
+                                    st.session_state[quiz_key]['answers'] = student_answers
+                                    # This will trigger a rerun, but now we'll handle it properly
+                                    st.rerun()
+                        
+                                else:
+                                    st.error("Error submitting quiz. Please try again.")
+                                # correct_answers = 0
+                                # for i, question in enumerate(quiz['questions']):
+                                #     if student_answers[str(i)] == question['correct_option']:
+                                #         correct_answers += 1
+                                # score = (correct_answers / len(quiz['questions'])) * 100
+                                # print(score)
+                                # try:
+                                #     quizzes_collection.update_one(
+                                #         {"_id": quiz['_id']},
+                                #         {"$push": {"submissions": {"student_id": student_id, "score": score}}}
+                                #     )
+                                #     st.success(f"Quiz submitted successfully! Your score: {score:.1f}%")
+                                # except Exception as db_error:
+                                #     st.error(f"Error saving submission: {str(db_error)}")
+
 
 def display_in_class_content(session, user_type):
     # """Display in-class activities and interactions"""
@@ -123,6 +419,10 @@ def display_in_class_content(session, user_type):
     else:
         live_polls.display_student_interface(session['session_id'])
 
+def generate_random_assignment_id():
+    """Generate a random integer ID for assignments"""
+    return random.randint(100000, 999999)
+
 def display_post_class_content(session, student_id, course_id):
     """Display post-class assignments and submissions"""
     st.header("Post-class Work")
@@ -178,17 +478,22 @@ def display_post_class_content(session, student_id, course_id):
                         st.success("Quiz saved successfully!")
                     else:
                         st.error("Error saving quiz.")
+                else:
+                    st.error("Error generating questions.")
 
         st.subheader("Add Assignments")
         # Add assignment form
         with st.form("add_assignment_form"):
             title = st.text_input("Assignment Title")
             due_date = st.date_input("Due Date")
+            due_date = datetime.strptime(due_date.strftime('%Y-%m-%d'), '%Y-%m-%d')
             submit = st.form_submit_button("Add Assignment")
             
             if submit:
                 due_date = datetime.combine(due_date, datetime.min.time())
                 # Save the assignment to the database
+                assignment_id = ObjectId()
+                print("Assignment ID: ", assignment_id)
                 assignment = {
                     "id": ObjectId(),
                     "title": title,