Initial Commit

.gitignore

@@ -0,0 +1,3 @@
+# Ignore .env file
+.env
+__pycache__/

db.py

@@ -0,0 +1,535 @@
+# Setup for MongoDB
+from pymongo import MongoClient
+from datetime import datetime
+from werkzeug.security import generate_password_hash
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+MONGO_URI = os.getenv('MONGO_URI')
+
+client = MongoClient(MONGO_URI)
+try:
+    client.admin.command('ping')
+    print("MongoDB connection successful")
+except Exception as e:
+    print(f"MongoDB connection failed: {e}")
+
+db = client['novascholar_db']
+
+# Define the course schema
+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", "status", "created_at"],
+                "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": "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",
+                                                "required": ["student_id", "file_url", "submitted_at"],
+                                                "properties": {
+                                                    "student_id": {
+                                                        "bsonType": "string",
+                                                        "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"
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+# Create the collection with the schema
+# db.create_collection("courses_collection2", validator={"$jsonSchema": course_schema})
+
+# sample_course = {
+#     "course_id": "CS101",
+#     "title": "Introduction to Computer Science",
+#     "description": "This course covers the basics of computer science and programming.",
+#     "faculty": "Dr. John Doe",
+#     "faculty_id": "F101",
+#     "duration": "10 weeks",
+#     "created_at": datetime.utcnow(),
+#     "sessions": [
+#         {
+#             "session_id": "S101",
+#             "title": "Introduction to Programming Fundamentals",
+#             "date": datetime.utcnow() - timedelta(days=7),
+#             "status": "completed",
+#             "created_at": datetime.utcnow() - timedelta(days=7),
+#             "pre_class": {
+#                 "resources": [
+#                     {
+#                         "type": "pdf",
+#                         "title": "Introduction to Python Basics",
+#                         "url": "/assets/python_basics.pdf",
+#                         "vector": [0.1, 0.2, 0.3]  # Example vector
+#                     }
+#                 ],
+#                 "completion_required": True
+#             },
+#             "in_class": {
+#                 "topics": ["Variables", "Data Types", "Basic Operations"],
+#                 "quiz": {
+#                     "title": "Python Basics Quiz",
+#                     "questions": 5,
+#                     "duration": 15
+#                 },
+#                 "polls": [
+#                     {
+#                         "question": "How comfortable are you with Python syntax?",
+#                         "options": ["Very", "Somewhat", "Not at all"],
+#                         "responses": {"Very": 10, "Somewhat": 5, "Not at all": 2}
+#                     }
+#                 ]
+#             },
+#             "post_class": {
+#                 "assignments": [
+#                     {
+#                         "id": 1,
+#                         "title": "Basic Python Programs",
+#                         "due_date": datetime.utcnow() + timedelta(days=2),
+#                         "status": "pending",
+#                         "submissions": []
+#                     }
+#                 ]
+#             }
+#         },
+#         {
+#             "session_id": "S102",
+#             "title": "Control Flow and Functions",
+#             "date": datetime.utcnow() - timedelta(days=3),
+#             "status": "completed",
+#             "created_at": datetime.utcnow() - timedelta(days=3),
+#             "pre_class": {
+#                 "resources": [
+#                     {
+#                         "type": "pdf",
+#                         "title": "Control Flow in Python",
+#                         "url": "/assets/control_flow.pdf",
+#                         "vector": [0.4, 0.5, 0.6]  # Example vector
+#                     }
+#                 ],
+#                 "completion_required": True
+#             },
+#             "in_class": {
+#                 "topics": ["If-else statements", "Loops", "Function definitions"],
+#                 "quiz": {
+#                     "title": "Control Flow Quiz",
+#                     "questions": 8,
+#                     "duration": 20
+#                 },
+#                 "polls": [
+#                     {
+#                         "question": "Which loop type do you find more intuitive?",
+#                         "options": ["For loops", "While loops", "Both"],
+#                         "responses": {"For loops": 12, "While loops": 8, "Both": 10}
+#                     }
+#                 ]
+#             },
+#             "post_class": {
+#                 "assignments": [
+#                     {
+#                         "id": 2,
+#                         "title": "Function Implementation Exercise",
+#                         "due_date": datetime.utcnow() + timedelta(days=4),
+#                         "status": "pending",
+#                         "submissions": []
+#                     }
+#                 ]
+#             }
+#         }
+#     ]
+# }
+courses_collection2 = db['courses_collection2']
+
+# courses_collection2.insert_one(sample_course)
+#  print("Sample course inserted successfully!")
+
+
+# sessions_collection.insert_one(session_data)
+# sessions_collection.delete_one({"session_id": "S101"})
+
+# course_id = "C101"
+# sessions = sessions_collection.find({"course_id": course_id})
+# for session in sessions:
+#     print(session)
+
+
+# Define the users schema
+users_schema = {
+    "bsonType": "object",
+    "required": ["user_id", "username", "password", "role", "created_at"],
+    "properties": {
+        "user_id": {
+            "bsonType": "string",
+            "description": "Unique identifier for the user"
+        },
+        "username": {
+            "bsonType": "string",
+            "description": "Name of the User"
+        },
+        "password": {
+            "bsonType": "string",
+            "description": "Password of the user"
+        },
+        "role": {
+            "bsonType": "string",
+            "description": "Type of user (e.g., student, faculty)"
+        },
+        "created_at": {
+            "bsonType": "date",
+            "description": "Date when the user was created"
+        }
+    }
+}
+# Create the collection with the schema
+# db.create_collection("users", validator={"$jsonSchema": users_schema})
+users_collection = db['users']
+
+# sample_user = {
+#     "user_id": "U103",
+#     "username": "Yash Desai",
+#     "password": generate_password_hash("yash"),
+#     "role": "Faculty",
+#     "created_at": datetime.utcnow()
+# }
+# users_collection.insert_one(sample_user)
+# print("Sample user inserted successfully!")
+
+# Defining the Student Collection
+student_schema = {
+    "bsonType": "object",
+    "required": ["SID", "full_name", "password", "enrolled_courses", "created_at"],
+    "properties": {
+        "SID": {
+            "bsonType": "string",
+            "description": "Unique identifier for the student"
+        },
+        "full_name": {
+            "bsonType": "string",
+            "description": "Full name of the student"
+        },
+        "password": {
+            "bsonType": "string",
+            "description": "Hashed password of the student"
+        },
+        "enrolled_courses": {
+            "bsonType": "array",
+            "description": "List of courses the student is enrolled in",
+            "items": {
+                "bsonType": "object",
+                "required": ["course_id", "title"],
+                "properties": {
+                    "course_id": {
+                        "bsonType": "string",
+                        "description": "Unique identifier for the course"
+                    },
+                    "title": {
+                        "bsonType": "string",
+                        "description": "Title of the course"
+                    }
+                }
+            }
+        },
+        "created_at": {
+            "bsonType": "date",
+            "description": "Date when the student was created"
+        }
+    }
+}
+# Defining the Faculty Collection
+faculty_schema = {
+    "bsonType": "object",
+    "required": ["TID", "full_name", "password", "courses_taught", "created_at"],
+    "properties": {
+        "TID": {
+            "bsonType": "string",
+            "description": "Unique identifier for the faculty"
+        },
+        "full_name": {
+            "bsonType": "string",
+            "description": "Full name of the faculty"
+        },
+        "password": {
+            "bsonType": "string",
+            "description": "Hashed password of the faculty"
+        },
+        "courses_taught": {
+            "bsonType": "array",
+            "description": "List of courses the faculty is teaching",
+            "items": {
+                "bsonType": "object",
+                "required": ["course_id", "title"],
+                "properties": {
+                    "course_id": {
+                        "bsonType": "string",
+                        "description": "Unique identifier for the course"
+                    },
+                    "title": {
+                        "bsonType": "string",
+                        "description": "Title of the course"
+                    }
+                }
+            }
+        },
+        "created_at": {
+            "bsonType": "date",
+            "description": "Date when the faculty was created"
+        }
+    }
+}
+# Creating the Collections
+# db.create_collection("students", validator={"$jsonSchema": student_schema})
+# db.create_collection("faculty", validator={"$jsonSchema": faculty_schema})
+
+students_collection = db['students']
+faculty_collection = db['faculty']
+
+# Inserting Sample Student Data
+# sample_student = {
+#     "SID": "S102",
+#     "full_name": "Omkar Surve",
+#     "password": generate_password_hash("omkar"),
+#     "enrolled_courses": [
+#         {"course_id": "CS101", "title": "Introduction to Computer Science"}
+#     ],
+#     "created_at": datetime.utcnow()
+# }
+# # students_collection.insert_one(sample_student)
+# print("Sample student inserted successfully!")
+
+# Inserting Sample Faculty Data
+# sample_faculty = {
+#     "TID": "F101",
+#     "full_name": "Dr. John Doe",
+#     "password": generate_password_hash("john"),
+#     "courses_taught": [
+#         {"course_id": "CS101", "title": "Introduction to Computer Science"}
+#     ],
+#     "created_at": datetime.utcnow()
+# }
+# faculty_collection.insert_one(sample_faculty)
+# print("Sample faculty inserted successfully!")
+
+# Defining the Vector Collection Schema
+vector_schema = {
+    "bsonType": "object",
+    "required": ["resource_id", "vector"],
+    "properties": {
+        "resource_id": {
+            "bsonType": "objectId",
+            "description": "Unique identifier for the resource"
+        },
+        "vector": {
+            "bsonType": "array",
+            "description": "Vector representation of the resource",
+            "items": {
+                "bsonType": "double"
+            }
+        },
+        "text": {
+            "bsonType": "string",
+            "description": "Text content of the resource"
+        },
+        "created_at": {
+            "bsonType": "date",
+            "description": "Date when the vector was created"
+        }
+    }
+}
+# Creating the Vector Collection
+# db.create_collection("vectors", validator={"$jsonSchema": vector_schema})
+vectors_collection = db['vectors']

file_upload_vectorize.py

@@ -0,0 +1,105 @@
+from pymongo import MongoClient
+from datetime import datetime
+import openai
+import google.generativeai as genai
+import streamlit as st
+from db import courses_collection2, faculty_collection, students_collection, vectors_collection
+from PIL import Image
+import PyPDF2, docx, io
+from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Document
+from bson import ObjectId
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+MONGO_URI = os.getenv('MONGO_URI')
+OPENAI_KEY = os.getenv('OPENAI_KEY')
+GEMINI_KEY = os.getenv('GEMINI_KEY')
+
+
+client = MongoClient(MONGO_URI)
+db = client['novascholar_db']
+resources_collection = db['resources']
+
+# Configure APIs
+openai.api_key = OPENAI_KEY
+genai.configure(api_key=GEMINI_KEY)
+model = genai.GenerativeModel('gemini-pro')
+
+def upload_resource(course_id, session_id, file_name, file_content, material_type):
+    # material_data = {
+    #     "session_id": session_id,
+    #     "course_id": course_id,
+    #     "file_name": file_name,
+    #     "file_content": file_content,
+    #     "material_type": material_type,
+    #     "uploaded_at": datetime.utcnow()
+    # }
+    # return resources_collection.insert_one(material_data)
+    resource_id = ObjectId()
+    
+    # Extract text content from the file
+    text_content = extract_text_from_file(file_content)
+    
+    # Read the file content
+    file_content.seek(0)  # Reset the file pointer to the beginning
+    original_file_content = file_content.read()
+    
+
+    resource_data = {
+        "resource_id": resource_id,
+        "course_id": course_id,
+        "session_id": session_id,
+        "file_name": file_name,
+        "file_type": file_content.type,
+        "text_content": text_content,
+        "file_content": original_file_content,  # Store the original file content
+        "material_type": material_type,
+        "uploaded_at": datetime.utcnow()
+    }
+    
+    resources_collection.insert_one(resource_data)
+    return resource_id
+
+def extract_text_from_file(uploaded_file):
+    text = ""
+    file_type = uploaded_file.type
+    
+    try:
+        if file_type == "text/plain":
+            text = uploaded_file.getvalue().decode("utf-8")
+        elif file_type == "application/pdf":
+            pdf_reader = PyPDF2.PdfReader(io.BytesIO(uploaded_file.getvalue()))
+            for page in pdf_reader.pages:
+                text += page.extract_text() + "\n"
+        elif file_type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
+            doc = docx.Document(io.BytesIO(uploaded_file.getvalue()))
+            for para in doc.paragraphs:
+                text += para.text + "\n"
+        return text
+    except Exception as e:
+        st.error(f"Error processing file: {str(e)}")
+        return None
+
+def get_embedding(text):
+    response = openai.embeddings.create(
+        model="text-embedding-ada-002",
+        input=text
+    )
+    return response.data[0].embedding
+
+def create_vector_store(text, resource_id):
+    resource_object_id = ObjectId(resource_id)
+    document = Document(text=text)
+    embedding = get_embedding(text)
+    
+    vector_data = {
+        "resource_id": resource_object_id,
+        "vector": embedding,
+        "text": text,
+        "created_at": datetime.utcnow()
+    }
+    
+    vectors_collection.insert_one(vector_data)
+    
+    return VectorStoreIndex.from_documents([document])

main.py

@@ -0,0 +1,134 @@
+import streamlit as st
+import datetime
+from pathlib import Path
+from utils.sample_data import SAMPLE_COURSES, SAMPLE_SESSIONS
+from session_page import display_session_content
+from db import courses_collection2, faculty_collection, students_collection
+from werkzeug.security import generate_password_hash, check_password_hash
+import hashlib
+
+def init_session_state():
+    """Initialize session state variables"""
+    if 'authenticated' not in st.session_state:
+        st.session_state.authenticated = False
+    if 'user_type' not in st.session_state:
+        st.session_state.user_type = None
+    if 'username' not in st.session_state:
+        st.session_state.username = None
+    if 'selected_course' not in st.session_state:
+        st.session_state.selected_course = None
+
+def login_user(username, password, user_type):
+    """Login user based on credentials"""
+    if user_type == "student":
+        user = students_collection.find_one({"full_name": username})
+    else:
+        user = faculty_collection.find_one({"full_name": username})
+    
+    if user and check_password_hash(user['password'], password):
+        st.session_state.authenticated = True
+        st.session_state.user_type = user_type
+        st.session_state.username = username
+        return True
+    return False
+
+
+def login_form():
+    """Display login form"""
+    st.title("Welcome to NOVAScholar")
+    
+    with st.form("login_form"):
+        user_type = st.selectbox("Select User Type", ["student", "faculty"])
+        username = st.text_input("Username")
+        password = st.text_input("Password", type="password")
+        submit = st.form_submit_button("Login")
+        
+        if submit:
+            if login_user(username, password, user_type):
+                st.success("Login successful!")
+                st.rerun()
+            else:
+                st.error("Invalid credentials!")
+
+def get_courses(username, user_type):
+    if user_type == "student":
+        student = students_collection.find_one({"full_name": username})
+        if student:
+            enrolled_course_ids = [course['course_id'] for course in student.get('enrolled_courses', [])]
+            courses = courses_collection2.find({"course_id": {"$in": enrolled_course_ids}})
+            # course_titles = [course['title'] for course in courses]
+            print(courses)
+            return list(courses)
+    elif user_type == "faculty":
+        faculty = faculty_collection.find_one({"full_name": username})
+        if faculty:
+            course_ids = [course['course_id'] for course in faculty.get('courses_taught', [])]
+            courses = courses_collection2.find({"course_id": {"$in": course_ids}})
+            return list(courses)
+    else: 
+        return []
+
+def get_course_ids():
+    """Get course IDs for sample courses"""
+    return [course['course_id'] for course in SAMPLE_COURSES]
+
+def get_sessions(course_id):
+    """Get sessions for a given course ID"""
+    course = courses_collection2.find_one({"course_id": course_id})
+    if course:
+        return course.get('sessions', [])
+    return []
+
+def main_dashboard():
+    # st.title(f"Welcome, {st.session_state.username}")
+    selected_course_id = None
+    with st.sidebar:
+        st.title("Courses")
+
+        # Course selection
+        enrolled_courses = get_courses(st.session_state.username, st.session_state.user_type)
+        course_titles = [course['title'] for course in enrolled_courses]
+        course_ids = [course['course_id'] for course in enrolled_courses]
+
+        selected_course = st.selectbox("Select Course", course_titles)
+        selected_course_id = course_ids[course_titles.index(selected_course)]
+        print(selected_course_id)
+
+        st.session_state.selected_course = selected_course
+        st.session_state.selected_course_id = selected_course_id
+
+        # Display course sessions
+        sessions = get_sessions(selected_course_id)
+        print(sessions)
+
+        st.title("Sessions")
+        for i, session in enumerate(sessions, start=1):
+            if st.button(f"Session {i}", key=f"session_{i}", use_container_width=True):
+                st.session_state.selected_session = session
+
+        if st.button("Logout", use_container_width=True):
+            for key in st.session_state.keys():
+                del st.session_state[key]
+            st.rerun()
+
+    # Main content
+    if 'selected_session' in st.session_state:
+        display_session_content(selected_course_id, st.session_state.selected_session, st.session_state.username)
+
+
+def main():
+    st.set_page_config(
+        page_title="NOVAScholar",
+        page_icon="📚",
+        layout="wide"
+    )
+    init_session_state()
+
+    if not st.session_state.authenticated:
+        login_form()
+    else:
+        main_dashboard()
+
+if __name__ == "__main__":
+    main()
+

session_page.py

@@ -0,0 +1,270 @@
+import streamlit as st
+from datetime import datetime
+from utils.sample_data import SAMPLE_CHAT_HISTORY, SAMPLE_STUDENT_PROGRESS
+from utils.helpers import display_progress_bar, create_notification, format_datetime
+from utils.sample_data import SAMPLE_SESSIONS, SAMPLE_COURSES
+from file_upload_vectorize import upload_resource, extract_text_from_file, create_vector_store, resources_collection
+from db import courses_collection2
+def display_preclass_content(session, username):
+    """Display pre-class materials for a session"""
+    st.subheader("Pre-class Materials")
+    
+    # Display progress bar
+    # progress = SAMPLE_STUDENT_PROGRESS.get(st.session_state.username, {}).get(session['session_id'], {}).get('pre_class', 0)
+    # display_progress_bar(progress, 100, "Pre-class completion")
+
+    # for resource in session['pre_class']['resources']:
+    #     with st.expander(f"{resource['title']} ({resource['type'].upper()})"):
+    #         if resource['type'] == 'pdf':
+    #             st.markdown(f"📑 [Open PDF Document]({resource['url']})")
+    #             if st.button("Mark PDF as Read", key=f"pdf_{resource['title']}"):
+    #                 create_notification("PDF marked as read!", "success")
+                    
+    #         elif resource['type'] == 'video':
+    #             st.markdown(f"🎥 Video Duration: {resource['duration']}")
+    #             col1, col2 = st.columns([3, 1])
+    #             with col1:
+    #                 st.video("https://example.com/placeholder.mp4")
+    #             with col2:
+    #                 if st.button("Mark Video Complete", key=f"video_{resource['title']}"):
+    #                     create_notification("Video marked as complete!", "success")
+                        
+    #         elif resource['type'] == 'reading':
+    #             st.markdown(f"📖 Reading Assignment: Pages {resource['pages']}")
+    #             if st.button("Mark Reading Complete", key=f"reading_{resource['title']}"):
+    #                 create_notification("Reading marked as complete!", "success")
+            
+    #         st.markdown("---")
+    #         st.markdown("**Notes:**")
+    #         notes = st.text_area("Add your notes here", key=f"notes_{resource['title']}")
+    #         if st.button("Save Notes", key=f"save_notes_{resource['title']}"):
+    #             create_notification("Notes saved successfully!", "success")
+
+    # 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()})"):
+        #     if material['material_type'] == 'pdf':
+        #         # st.markdown(f"📑 [Open PDF Document]({material['url']})")
+        #         if st.button("Mark PDF as Read", key=f"pdf_{material['file_name']}"):
+        #             create_notification("PDF marked as read!", "success")
+        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")
+
+def display_in_class_content(session):
+    """Display in-class activities and interactions"""
+    st.header("In-class Activities")
+    
+    # Topics covered
+    with st.expander("Topics Covered", expanded=True):
+        for topic in session['in_class']['topics']:
+            st.markdown(f"- {topic}")
+    
+    # Live Quiz section
+    st.subheader("Session Quiz")
+    quiz = session['in_class']['quiz']
+    with st.expander(f"Quiz: {quiz['title']}"):
+        st.markdown(f"- Number of questions: {quiz['questions']}")
+        st.markdown(f"- Time allowed: {quiz['duration']} minutes")
+        if session['status'] == 'in_progress':
+            if st.button("Start Quiz"):
+                create_notification("Quiz will begin shortly!", "info")
+        else:
+            st.info("Quiz not available at this time")
+    
+    # Live Polls
+    st.subheader("Interactive Polls")
+    for idx, poll in enumerate(session['in_class']['polls']):
+        with st.expander(f"Poll {idx + 1}: {poll['question']}"):
+            selected_option = st.radio(
+                "Your response:",
+                options=poll['options'],
+                key=f"poll_{session['session_id']}_{idx}"
+            )
+            if st.button("Submit Response", key=f"submit_poll_{idx}"):
+                create_notification("Poll response recorded!", "success")
+    
+    # Chat Interface
+    st.subheader("Class Discussion")
+    chat_container = st.container()
+    with chat_container:
+        # Display existing messages
+        messages = SAMPLE_CHAT_HISTORY.get(session['session_id'], [])
+        for msg in messages:
+            with st.chat_message(msg['user']):
+                st.write(msg['message'])
+        
+        # New message input
+        if session['status'] == 'in_progress':
+            if prompt := st.chat_input("Ask a question..."):
+                if len(messages) < 20:
+                    with st.chat_message("user"):
+                        st.write(prompt)
+                    with st.chat_message("assistant"):
+                        st.write("This is a sample response to your question.")
+                else:
+                    create_notification("Message limit (20) reached for this session.", "warning")
+
+def display_post_class_content(session):
+    """Display post-class assignments and submissions"""
+    st.header("Post-class Work")
+    
+    # Display assignments
+    for assignment in session['post_class']['assignments']:
+        with st.expander(f"Assignment: {assignment['title']}", expanded=True):
+            st.markdown(f"**Due Date:** {format_datetime(assignment['due_date'])}")
+            st.markdown(f"**Status:** {assignment['status'].replace('_', ' ').title()}")
+            
+            # Assignment details
+            st.markdown("### Instructions")
+            st.markdown("Complete the assignment according to the provided guidelines.")
+            
+            # File submission
+            st.markdown("### Submission")
+            uploaded_file = st.file_uploader(
+                "Upload your work",
+                type=['pdf', 'py', 'ipynb'],
+                key=f"upload_{assignment['id']}"
+            )
+            
+            if uploaded_file is not None:
+                st.success("File uploaded successfully!")
+                if st.button("Submit Assignment", key=f"submit_{assignment['id']}"):
+                    create_notification("Assignment submitted successfully!", "success")
+            
+            # Feedback section (if assignment is completed)
+            if assignment['status'] == 'completed':
+                st.markdown("### Feedback")
+                st.info("Feedback will be provided here once the assignment is graded.")
+
+def display_preclass_analytics(session):
+    """Display pre-class analytics for faculty"""
+    st.subheader("Pre-class Analytics")
+    
+    # Display pre-class resource completion rates
+    for resource in session['pre_class']['resources']:
+        progress = SAMPLE_STUDENT_PROGRESS.get(resource['title'], 0)
+        display_progress_bar(progress, 100, resource['title'])
+
+def display_inclass_analytics(session):
+    """Display in-class analytics for faculty"""
+    st.subheader("In-class Analytics")
+    
+    # Display chat usage metrics
+    chat_messages = SAMPLE_CHAT_HISTORY.get(session['session_id'], [])
+    st.metric("Total Chat Messages", len(chat_messages))
+    
+    # Display live quiz/poll results
+    # for poll in session['in_class']['polls']:
+    #     st.subheader(poll['question'])
+    #     for option, count in poll['responses'].items():
+    #         st.metric(option, count)
+    for poll in session.get('in_class', {}).get('polls', []):
+        st.text(poll.get('question', 'No question available'))
+        responses = poll.get('responses', {})
+        if responses:
+            for option, count in responses.items():
+                st.metric(option, count)
+        else:
+            st.warning("No responses available for this poll")
+
+def display_postclass_analytics(session):
+    """Display post-class analytics for faculty"""
+    st.subheader("Post-class Analytics")
+    
+    # Display assignment completion rates
+    for assignment in session['post_class']['assignments']:
+        progress = SAMPLE_STUDENT_PROGRESS.get(assignment['id'], 0)
+        display_progress_bar(progress, 100, assignment['title'])
+
+
+def upload_preclass_materials(session_id, course_id):
+    """Upload pre-class materials for a session"""
+    st.subheader("Upload Pre-class Materials")
+    
+    # File upload section
+    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_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!")
+                    
+    # Display existing materials
+    materials = resources_collection.find({"course_id": course_id, "session_id": session_id})
+    for material in materials:
+        st.markdown(f"""
+        * **{material['file_name']}** ({material['material_type']})  
+            Uploaded on: {material['uploaded_at'].strftime('%Y-%m-%d %H:%M')}
+        """)
+
+
+
+
+def display_session_content(course_id, session, username):
+    st.title(f"Session {session['session_id']}: {session['title']}")
+    st.markdown(f"**Date:** {format_datetime(session['date'])}")
+    st.markdown(f"**Status:** {session['status'].replace('_', ' ').title()}")
+    
+    # Find the course_id of the session in 
+
+    if st.session_state.user_type == 'student':
+        tabs = (["Pre-class Work", "In-class Work", "Post-class Work"])
+    else:
+        tabs = (["Pre-class Analytics", "In-class Analytics", "Post-class Analytics"])
+
+    # Create tabs for different sections
+    # pre_class_tab, in_class_tab, post_class_tab, faculty_tab = st.tabs([
+    #     "Pre-class Work",
+    #     "In-class Work",
+    #     "Post-class Work",
+    #     "Faculty Analytics"
+    # ])
+
+    if st.session_state.user_type == 'student':
+        pre_class_tab, in_class_tab, post_class_tab = st.tabs(["Pre-class Work", "In-class Work", "Post-class Work"])
+    else:
+        pre_class_work, in_class_work, post_class_work, preclass_analytics, inclass_analytics, postclass_analytics = st.tabs(["Pre-class Work", "In-class Work", "Post-class Work", "Pre-class Analytics", "In-class Analytics", "Post-class Analytics"])
+
+    # Display pre-class materials
+    if st.session_state.user_type == 'student':
+        with pre_class_tab:
+            display_preclass_content(session, username)
+        
+        with in_class_tab:
+            display_in_class_content(session)
+        
+        # Post-class Content
+        with post_class_tab:
+            display_post_class_content(session)
+
+    if st.session_state.user_type == 'faculty':
+        with pre_class_work:
+            upload_preclass_materials(session['session_id'], course_id)
+        with preclass_analytics:
+            display_preclass_analytics(session)
+        with inclass_analytics:
+            display_inclass_analytics(session)
+        with postclass_analytics:
+            display_postclass_analytics(session)

utils/helpers.py

@@ -0,0 +1,83 @@
+from datetime import datetime, timedelta
+import streamlit as st
+
+def format_datetime(dt):
+    """Format datetime for display"""
+    return dt.strftime("%Y-%m-%d %H:%M")
+
+def get_session_progress(username, course_id, session_id):
+    """
+    Get user's progress for a specific session
+    Returns dict with pre_class, in_class, and post_class completion status
+    """
+    # Demo implementation - replace with actual database queries
+    return {
+        'pre_class': {
+            'completed': True,
+            'last_access': datetime.now() - timedelta(days=1),
+            'resources_viewed': 3,
+            'total_resources': 3
+        },
+        'in_class': {
+            'completed': False,
+            'attendance': True,
+            'quiz_completed': False,
+            'questions_asked': 5
+        },
+        'post_class': {
+            'completed': False,
+            'assignments_submitted': 1,
+            'total_assignments': 2,
+            'grade': None
+        }
+    }
+
+def get_course_sessions(course_id):
+    """Get all sessions for a course"""
+    # Demo implementation - replace with database query
+    return [
+        {
+            'id': 1,
+            'title': 'Introduction to Programming Concepts',
+            'date': datetime.now() + timedelta(days=i),
+            'status': 'completed' if i < 0 else 'upcoming'
+        }
+        for i in range(-2, 5)
+    ]
+
+def display_progress_bar(completed, total, text=""):
+    """Display a progress bar with text"""
+    progress = completed / total if total > 0 else 0
+    st.progress(progress)
+    st.text(f"{text}: {completed}/{total} ({progress*100:.1f}%)")
+
+def create_notification(message, type="info"):
+    """Create a notification message"""
+    if type == "success":
+        st.success(message)
+    elif type == "error":
+        st.error(message)
+    elif type == "warning":
+        st.warning(message)
+    else:
+        st.info(message)
+
+class SessionManager:
+    """Manage session state and navigation"""
+    @staticmethod
+    def get_current_session():
+        """Get current session information"""
+        if 'current_session' not in st.session_state:
+            st.session_state.current_session = 1
+        return st.session_state.current_session
+    
+    @staticmethod
+    def set_current_session(session_id):
+        """Set current session"""
+        st.session_state.current_session = session_id
+    
+    @staticmethod
+    def clear_session():
+        """Clear session state"""
+        for key in list(st.session_state.keys()):
+            del st.session_state[key]

utils/sample_data.py

@@ -0,0 +1,226 @@
+from datetime import datetime, timedelta
+
+SAMPLE_COURSES = [
+    {
+        'course_id': 'CS101',
+        'title': 'Introduction to Computer Science',
+        'description': 'This course covers the basics of computer science and programming.',
+        'instructor': 'Dr. John Doe',
+        'duration': '10 weeks'
+    },
+    {
+        'course_id': 'CS102',
+        'title': 'Data Structures and Algorithms',
+        'description': 'This course introduces data structures and algorithms for efficient data processing.',
+        'instructor': 'Dr. Jane Smith',
+        'duration': '12 weeks'
+    },
+    {
+        'course_id': 'CS103',
+        'title': 'Advanced Python Programming',
+        'description': 'This course covers advanced topics in Python programming, including file handling and exception management.',
+        'instructor': 'Dr. Emily Johnson',
+        'duration': '8 weeks'
+    }
+]
+
+SAMPLE_SESSIONS = [
+    {
+        'id': 1,
+        'course_id': 'CS101',
+        'title': 'Introduction to Programming Fundamentals',
+        'date': datetime.now() - timedelta(days=7),
+        'status': 'completed',
+        'pre_class': {
+            'resources': [
+                {'type': 'pdf', 'title': 'Introduction to Python Basics', 'url': '/assets/python_basics.pdf'},
+                {'type': 'video', 'title': 'Programming Fundamentals', 'duration': '15:00'},
+                {'type': 'reading', 'title': 'Chapter 1: Getting Started', 'pages': '1-15'}
+            ],
+            'completion_required': True
+        },
+        'in_class': {
+            'topics': ['Variables', 'Data Types', 'Basic Operations'],
+            'quiz': {
+                'title': 'Python Basics Quiz',
+                'questions': 5,
+                'duration': 15
+            },
+            'polls': [
+                {'question': 'How comfortable are you with Python syntax?', 'options': ['Very', 'Somewhat', 'Not at all']}
+            ]
+        },
+        'post_class': {
+            'assignments': [
+                {
+                    'id': 1,
+                    'title': 'Basic Python Programs',
+                    'due_date': datetime.now() + timedelta(days=2),
+                    'status': 'pending'
+                }
+            ]
+        }
+    },
+    {
+        'id': 2,
+        'course_id': 'CS101',
+        'title': 'Control Flow and Functions',
+        'date': datetime.now() - timedelta(days=3),
+        'status': 'completed',
+        'pre_class': {
+            'resources': [
+                {'type': 'pdf', 'title': 'Control Flow in Python', 'url': '/assets/control_flow.pdf'},
+                {'type': 'video', 'title': 'Functions and Methods', 'duration': '20:00'}
+            ],
+            'completion_required': True
+        },
+        'in_class': {
+            'topics': ['If-else statements', 'Loops', 'Function definitions'],
+            'quiz': {
+                'title': 'Control Flow Quiz',
+                'questions': 8,
+                'duration': 20
+            },
+            'polls': [
+                {'question': 'Which loop type do you find more intuitive?', 'options': ['For loops', 'While loops', 'Both']}
+            ]
+        },
+        'post_class': {
+            'assignments': [
+                {
+                    'id': 2,
+                    'title': 'Function Implementation Exercise',
+                    'due_date': datetime.now() + timedelta(days=4),
+                    'status': 'pending'
+                }
+            ]
+        }
+    },
+    {
+        'id': 3,
+        'course_id': 'CS102',
+        'title': 'Data Structures',
+        'date': datetime.now(),
+        'status': 'in_progress',
+        'pre_class': {
+            'resources': [
+                {'type': 'pdf', 'title': 'Python Data Structures', 'url': '/assets/data_structures.pdf'},
+                {'type': 'video', 'title': 'Lists and Dictionaries', 'duration': '25:00'}
+            ],
+            'completion_required': True
+        },
+        'in_class': {
+            'topics': ['Lists', 'Tuples', 'Dictionaries', 'Sets'],
+            'quiz': {
+                'title': 'Data Structures Quiz',
+                'questions': 10,
+                'duration': 25
+            },
+            'polls': [
+                {'question': 'Which data structure do you use most often?', 'options': ['Lists', 'Dictionaries', 'Sets', 'Tuples']}
+            ]
+        },
+        'post_class': {
+            'assignments': [
+                {
+                    'id': 3,
+                    'title': 'Data Structure Implementation',
+                    'due_date': datetime.now() + timedelta(days=7),
+                    'status': 'not_started'
+                }
+            ]
+        }
+    },
+    {
+        'id': 4,
+        'course_id': 'CS101',
+        'title': 'Object-Oriented Programming',
+        'date': datetime.now() + timedelta(days=4),
+        'status': 'upcoming',
+        'pre_class': {
+            'resources': [
+                {'type': 'pdf', 'title': 'OOP Concepts', 'url': '/assets/oop_concepts.pdf'},
+                {'type': 'video', 'title': 'Classes and Objects', 'duration': '30:00'}
+            ],
+            'completion_required': True
+        },
+        'in_class': {
+            'topics': ['Classes', 'Objects', 'Inheritance', 'Polymorphism'],
+            'quiz': {
+                'title': 'OOP Concepts Quiz',
+                'questions': 12,
+                'duration': 30
+            },
+            'polls': [
+                {'question': 'Have you used OOP before?', 'options': ['Yes', 'No', 'Not sure'], 'responses': {'For loops': 12, 'While loops': 8, 'Both': 10}}
+            ]
+        },
+        'post_class': {
+            'assignments': [
+                {
+                    'id': 4,
+                    'title': 'Class Implementation Project',
+                    'due_date': datetime.now() + timedelta(days=11),
+                    'status': 'not_started'
+                }
+            ]
+        }
+    },
+    {
+        'id': 5,
+        'course_id': 'CS103',
+        'title': 'File Handling and Exception Management',
+        'date': datetime.now() + timedelta(days=7),
+        'status': 'upcoming',
+        'pre_class': {
+            'resources': [
+                {'type': 'pdf', 'title': 'File Operations in Python', 'url': '/assets/file_ops.pdf'},
+                {'type': 'video', 'title': 'Exception Handling', 'duration': '20:00'}
+            ],
+            'completion_required': True
+        },
+        'in_class': {
+            'topics': ['File Operations', 'Exception Handling', 'Context Managers'],
+            'quiz': {
+                'title': 'File Operations Quiz',
+                'questions': 8,
+                'duration': 20
+            },
+            'polls': [
+                {'question': 'How often do you handle exceptions in your code?', 
+                 'options': ['Always', 'Sometimes', 'Rarely', 'Never'],
+                 'responses': {'Very': 10, 'Somewhat': 15, 'Not at all': 5} 
+                }
+            ]
+        },
+        'post_class': {
+            'assignments': [
+                {
+                    'id': 5,
+                    'title': 'File Processing Application',
+                    'due_date': datetime.now() + timedelta(days=14),
+                    'status': 'not_started'
+                }
+            ]
+        }
+    }
+]
+
+# Chatbot message history
+SAMPLE_CHAT_HISTORY = {
+    1: [
+        {'user': 'student1', 'message': 'What is the difference between list and tuple?', 'timestamp': datetime.now()},
+        {'user': 'chatbot', 'message': 'Lists are mutable (can be modified) while tuples are immutable (cannot be modified after creation).', 'timestamp': datetime.now()}
+    ]
+}
+
+# Student progress data
+SAMPLE_STUDENT_PROGRESS = {
+    'user1': {
+        1: {'pre_class': 50, 'in_class': 80, 'post_class': 90},
+        2: {'pre_class': 100, 'in_class': 75, 'post_class': 85},
+        3: {'pre_class': 50, 'in_class': 0, 'post_class': 0},
+        4: {'pre_class': 0, 'in_class': 0, 'post_class': 0},
+        5: {'pre_class': 0, 'in_class': 0, 'post_class': 0}
+    }
+}