Update session_page.py

session_page.py

@@ -18,10 +18,9 @@ import os
 from pymongo import MongoClient
 from gen_mcqs import generate_mcqs, save_quiz, quizzes_collection, get_student_quiz_score, submit_quiz_answers
 from create_course import courses_collection
-# from pre_class_analytics import NovaScholarAnalytics
+import traceback
 from pre_class_analytics2 import NovaScholarAnalytics
 import openai
-from openai import OpenAI
 import google.generativeai as genai
 from goals2 import GoalAnalyzer
 from openai import OpenAI
@@ -30,6 +29,8 @@ import numpy as np
 import re
 from analytics import derive_analytics, create_embeddings, cosine_similarity
 from bs4 import BeautifulSoup
+from rubrics import display_rubrics_tab
+from subjective_test_evaluation import evaluate_subjective_answers, display_evaluation_to_faculty
 
 load_dotenv()
 MONGO_URI = os.getenv('MONGO_URI')
@@ -40,6 +41,7 @@ db = client["novascholar_db"]
 polls_collection = db["polls"]
 subjective_tests_collection = db["subjective_tests"]
 synoptic_store_collection = db["synoptic_store"]
+subjective_test_analysis_collection = db['subjective_test_analysis']
 
 def get_current_user():
     if 'current_user' not in st.session_state:
@@ -132,66 +134,6 @@ def get_current_user():
     # 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")
-    # print("Session ID is: ", session['session_id'])
-    # # 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['_id']}"):
-    #                 st.text_area("PDF Content", material['text_content'], height=300)
-    #             if st.button("Download PDF", key=f"download_pdf_{material['_id']}"):
-    #                 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['_id']}"):
-    #                 create_notification("PDF marked as read!", "success")
-    #         elif file_type == 'text/plain':
-    #             st.markdown(f"📄 [Open Text Document]({material['file_name']})")
-    #             if st.button("View Text", key=f"view_text_{material['_id']}"):
-    #                 st.text_area("Text Content", material['text_content'], height=300)
-    #             if st.button("Download Text", key=f"download_text_{material['_id']}"):
-    #                 st.download_button(
-    #                     label="Download Text",
-    #                     data=material['file_content'],
-    #                     file_name=material['file_name'],
-    #                     mime='text/plain'
-    #                 )
-    #             if st.button("Mark Text as Read", key=f"text_{material['_id']}"):
-    #                 create_notification("Text marked as read!", "success")
-    #         elif file_type == 'application/vnd.openxmlformats-officedocument.wordprocessingml.document':
-    #             st.markdown(f"📄 [Open Word Document]({material['file_name']})")
-    #             if st.button("View Word", key=f"view_word_{material['_id']}"):
-    #                 st.text_area("Word Content", material['text_content'], height=300)
-    #             if st.button("Download Word", key=f"download_word_{material['_id']}"):
-    #                 st.download_button(
-    #                     label="Download Word",
-    #                     data=material['file_content'],
-    #                     file_name=material['file_name'],
-    #                     mime='application/vnd.openxmlformats-officedocument.wordprocessingml.document'
-    #                 )
-    #             if st.button("Mark Word as Read", key=f"word_{material['_id']}"):
-    #                 create_notification("Word document marked as read!", "success")
-    #         elif file_type == 'application/vnd.openxmlformats-officedocument.presentationml.presentation':
-    #             st.markdown(f"📊 [Open PowerPoint Presentation]({material['file_name']})")
-    #             if st.button("View PowerPoint", key=f"view_pptx_{material['_id']}"):
-    #                 st.text_area("PowerPoint Content", material['text_content'], height=300)
-    #             if st.button("Download PowerPoint", key=f"download_pptx_{material['_id']}"):
-    #                 st.download_button(
-    #                     label="Download PowerPoint",
-    #                     data=material['file_content'],
-    #                     file_name=material['file_name'],
-    #                     mime='application/vnd.openxmlformats-officedocument.presentationml.presentation'
-    #                 )
-    #             if st.button("Mark PowerPoint as Read", key=f"pptx_{material['_id']}"):
-    #                 create_notification("PowerPoint presentation marked as read!", "success")
     """Display pre-class materials for a session including external resources"""
     st.subheader("Pre-class Materials")
     print("Session ID is: ", session['session_id'])
@@ -672,41 +614,29 @@ def display_post_class_content(session, student_id, course_id):
                     )
                     
                     if questions:
-                        synoptic = generate_synoptic(
-                            questions,
-                            context if context else None,
-                            session['title'],
-                            num_subjective_questions
-                        )
-                        
-                        if synoptic:
-                            # Store in session state
-                            st.session_state.generated_questions = questions
-                            st.session_state.generated_synoptic = synoptic
-                            st.session_state.test_title = test_title
+                        # Store in session state
+                        st.session_state.generated_questions = questions
+                        st.session_state.test_title = test_title
                             
                             # Display preview
-                            st.subheader("Preview Subjective Questions and Synoptic")
-                            for i, (q, s) in enumerate(zip(questions, synoptic), 1):
-                                st.markdown(f"**Question {i}:** {q['question']}")
-                                with st.expander(f"View Synoptic {i}"):
-                                    st.markdown(s)
+                        st.subheader("Preview Subjective Questions and Synoptic")
+                        for i, q in enumerate(questions, 1):
+                            st.markdown(f"**Question {i}:** {q['question']}")
+                            # with st.expander(f"View Synoptic {i}"):
+                            #     st.markdown(s)
                             
-                            # Save button outside the form
-                            if st.button("Save Test"):
-                                test_id = save_subjective_test(
-                                    course_id,
-                                    session['session_id'],
-                                    test_title,
-                                    questions,
-                                    synoptic
-                                )
-                                if test_id:
-                                    st.success("Subjective test saved successfully!")
-                                else:
-                                    st.error("Error saving subjective test.")
-                        else:
-                            st.error("Error generating synoptic answers. Please try again.")
+                        # Save button outside the form
+                        if st.button("Save Test"):
+                            test_id = save_subjective_test(
+                                course_id,
+                                session['session_id'],
+                                test_title,
+                                questions
+                            )
+                            if test_id:
+                                st.success("Subjective test saved successfully!")
+                            else:
+                                st.error("Error saving subjective test.")
                     else:
                         st.error("Error generating questions. Please try again.")
                 except Exception as e:
@@ -714,11 +644,9 @@ def display_post_class_content(session, student_id, course_id):
 
         # Display previously generated test if it exists in session state
         elif hasattr(st.session_state, 'generated_questions') and hasattr(st.session_state, 'generated_synoptic'):
-            st.subheader("Preview Subjective Questions and Synoptic")
-            for i, (q, s) in enumerate(zip(st.session_state.generated_questions, st.session_state.generated_synoptic), 1):
-                st.markdown(f"**Question {i}:** {q['question']}")
-                with st.expander(f"View Synoptic {i}"):
-                    st.markdown(s)
+            st.subheader("Preview Subjective Questions")
+            for i, q in enumerate(st.session_state.generated_questions, 1):
+                st.markdown(f"**Questison {i}:** {q['question']}")
             
             if st.button("Save Test"):
                 test_id = save_subjective_test(
@@ -726,13 +654,11 @@ def display_post_class_content(session, student_id, course_id):
                     session['session_id'],
                     st.session_state.test_title,
                     st.session_state.generated_questions,
-                    st.session_state.generated_synoptic
                 )
                 if test_id:
                     st.success("Subjective test saved successfully!")
                     # Clear session state after successful save
                     del st.session_state.generated_questions
-                    del st.session_state.generated_synoptic
                     del st.session_state.test_title
                 else:
                     st.error("Error saving subjective test.")
@@ -869,186 +795,7 @@ def display_post_class_content(session, student_id, course_id):
                         st.markdown("### Feedback")
                         st.info("Feedback will be provided here once the assignment is graded.")
         else:
-            st.warning("No assignments found for this session.")            
-                
-# def display_preclass_analytics(session, course_id):
-#     """Display pre-class analytics for faculty based on chat interaction metrics"""
-#     st.subheader("Pre-class Analytics")
-    
-#     # Get all enrolled students
-#     # enrolled_students = list(students_collection.find({"enrolled_courses": session['course_id']}))
-#     enrolled_students = list(students_collection.find({
-#         "enrolled_courses.course_id": course_id
-#     }))
-#     # total_students = len(enrolled_students)
-    
-#     total_students = students_collection.count_documents({
-#         "enrolled_courses": {
-#             "$elemMatch": {"course_id": course_id}
-#         }
-#     })
-
-
-#     if total_students == 0:
-#         st.warning("No students enrolled in this course.")
-#         return
-    
-#     # Get chat history for all students in this session
-#     chat_data = list(chat_history_collection.find({
-#         "session_id": session['session_id']
-#     }))
-    
-#     # Create a DataFrame to store student completion data
-#     completion_data = []
-#     incomplete_students = []
-    
-#     for student in enrolled_students:
-#         student_id = student['_id']
-#         student_name = student.get('full_name', 'Unknown')
-#         student_sid = student.get('SID', 'Unknown')
-        
-#         # Find student's chat history
-#         student_chat = next((chat for chat in chat_data if chat['user_id'] == student_id), None)
-        
-#         if student_chat:
-#             messages = student_chat.get('messages', [])
-#             message_count = len(messages)
-#             status = "Completed" if message_count >= 20 else "Incomplete"
-
-#             # Format chat history for display
-#             chat_history = []
-#             for msg in messages:
-#                 timestamp_str = msg.get('timestamp', '')
-#                 if isinstance(timestamp_str, str):
-#                     timestamp = datetime.fromisoformat(timestamp_str)
-#                 else:
-#                     timestamp = timestamp_str
-#                 # timestamp = msg.get('timestamp', '').strftime("%Y-%m-%d %H:%M:%S")
-#                 chat_history.append({
-#                     # 'timestamp': timestamp,
-#                     'timestamp': timestamp.strftime("%Y-%m-%d %H:%M:%S"),
-#                     'prompt': msg.get('prompt'),
-#                     'response': msg.get('response')
-#                 })
-            
-#             message_count = len(student_chat.get('messages', []))
-#             status = "Completed" if message_count >= 20 else "Incomplete"
-#             if status == "Incomplete":
-#                 incomplete_students.append({
-#                     'name': student_name,
-#                     'sid': student_sid,
-#                     'message_count': message_count
-#                 })
-#         else:
-#             message_count = 0
-#             status = "Not Started"
-#             chat_history = []
-#             incomplete_students.append({
-#                 'name': student_name,
-#                 'sid': student_sid,
-#                 'message_count': 0
-#             })
-            
-#         completion_data.append({
-#             'Student Name': student_name,
-#             'SID': student_sid,
-#             'Messages': message_count,
-#             'Status': status,
-#             'Chat History': chat_history
-#         })
-    
-#     # Create DataFrame
-#     df = pd.DataFrame(completion_data)
-    
-#     # Display summary metrics
-#     col1, col2, col3 = st.columns(3)
-    
-#     completed_count = len(df[df['Status'] == 'Completed'])
-#     incomplete_count = len(df[df['Status'] == 'Incomplete'])
-#     not_started_count = len(df[df['Status'] == 'Not Started'])
-    
-#     with col1:
-#         st.metric("Completed", completed_count)
-#     with col2:
-#         st.metric("Incomplete", incomplete_count)
-#     with col3:
-#         st.metric("Not Started", not_started_count)
-    
-#     # Display completion rate progress bar
-#     completion_rate = (completed_count / total_students) * 100
-#     st.markdown("### Overall Completion Rate")
-#     st.progress(completion_rate / 100)
-#     st.markdown(f"**{completion_rate:.1f}%** of students have completed pre-class materials")
-
-#     # Create tabs for different views
-#     tab1, tab2 = st.tabs(["Student Overview", "Detailed Chat History"])
-    
-#     with tab1:
-#         # Display completion summary table
-#         st.markdown("### Student Completion Details")
-#         summary_df = df[['Student Name', 'SID', 'Messages', 'Status']].copy()
-#         st.dataframe(
-#             summary_df.style.apply(lambda x: ['background-color: #90EE90' if v == 'Completed' 
-#                                             else 'background-color: #FFB6C1' if v == 'Incomplete'
-#                                             else 'background-color: #FFE4B5' 
-#                                             for v in x],
-#                                  subset=['Status'])
-#         )
-        
-#     with tab2:
-#         # Display detailed chat history
-#         st.markdown("### Student Chat Histories")
-        
-#         # Add student selector
-#         selected_student = st.selectbox(
-#             "Select a student to view chat history:",
-#             options=df['Student Name'].tolist()
-#         )
-        
-#         # Get selected student's data
-#         student_data = df[df['Student Name'] == selected_student].iloc[0]
-#         print(student_data)
-#         chat_history = student_data['Chat History']
-#         # Refresh chat history when a new student is selected
-#         if 'selected_student' not in st.session_state or st.session_state.selected_student != selected_student:
-#             st.session_state.selected_student = selected_student
-#             st.session_state.selected_student_chat_history = chat_history
-#         else:
-#             chat_history = st.session_state.selected_student_chat_history
-#         # Display student info and chat statistics
-#         st.markdown(f"**Student ID:** {student_data['SID']}")
-#         st.markdown(f"**Status:** {student_data['Status']}")
-#         st.markdown(f"**Total Messages:** {student_data['Messages']}")
-        
-#         # Display chat history in a table
-#         if chat_history:
-#             chat_df = pd.DataFrame(chat_history)
-#             st.dataframe(
-#                 chat_df.style.apply(lambda x: ['background-color: #E8F0FE' if v == 'response' else 'background-color: #FFFFFF' for v in x], subset=['prompt']), use_container_width=True
-#             )
-#         else:
-#             st.info("No chat history available for this student.")
-    
-#     # Display students who haven't completed
-#     if incomplete_students:
-#         st.markdown("### Students Requiring Follow-up")
-#         incomplete_df = pd.DataFrame(incomplete_students)
-#         st.markdown(f"**{len(incomplete_students)} students** need to complete the pre-class materials:")
-        
-#         # Create a styled table for incomplete students
-#         st.table(
-#             incomplete_df.style.apply(lambda x: ['background-color: #FFFFFF' 
-#                                                for _ in range(len(x))]))
-        
-#         # Export option for incomplete students list
-#         csv = incomplete_df.to_csv(index=False).encode('utf-8')
-#         st.download_button(
-#             "Download Follow-up List",
-#             csv,
-#             "incomplete_students.csv",
-#             "text/csv",
-#             key='download-csv'
-#         )
+            st.warning("No assignments found for this session.")                            
 
 def display_inclass_analytics(session, course_id):
     """Display in-class analytics for faculty"""
@@ -1164,9 +911,6 @@ def display_inclass_analytics(session, course_id):
                 "_id": {"$nin": respondents}
             }))
             
-            
-
-
             if non_participants:
                 st.markdown("#### Students Who Haven't Participated")
                 non_participant_data = [{
@@ -1205,24 +949,23 @@ def display_inclass_analytics(session, course_id):
 def display_postclass_analytics(session, course_id):
     """Display post-class analytics for faculty"""
     st.subheader("Post-class Analytics")
-    
+
     # Get all assignments for this session
     session_data = courses_collection2.find_one(
         {"sessions.session_id": session['session_id']},
         {"sessions.$": 1}
     )
-    
+
     if not session_data or 'sessions' not in session_data:
         st.warning("No assignments found for this session.")
         return
-    
+
     assignments = session_data['sessions'][0].get('post_class', {}).get('assignments', [])
-    
+
     for assignment in assignments:
         with st.expander(f"📝 Assignment: {assignment.get('title', 'Untitled')}"):
             # Get submission analytics
             submissions = assignment.get('submissions', [])
-            # total_students = students_collection.count_documents({"courses": session['course_id']})
             total_students = students_collection.count_documents({
                 "enrolled_courses": {
                     "$elemMatch": {"course_id": course_id}
@@ -1231,7 +974,7 @@ def display_postclass_analytics(session, course_id):
             # Calculate submission metrics
             submitted_count = len(submissions)
             submission_rate = (submitted_count / total_students) * 100 if total_students > 0 else 0
-            
+
             # Display metrics
             col1, col2, col3 = st.columns(3)
             with col1:
@@ -1240,43 +983,25 @@ def display_postclass_analytics(session, course_id):
                 st.metric("Submission Rate", f"{submission_rate:.1f}%")
             with col3:
                 st.metric("Pending Submissions", total_students - submitted_count)
-            
+
             # Display submission timeline
             if submissions:
                 submission_dates = [sub.get('submitted_at') for sub in submissions if 'submitted_at' in sub]
                 if submission_dates:
                     df = pd.DataFrame(submission_dates, columns=['Submission Date'])
-                    fig = px.histogram(df, x='Submission Date', 
-                                     title='Submission Timeline',
-                                     labels={'Submission Date': 'Date', 'count': 'Number of Submissions'})
+                    fig = px.histogram(df, x='Submission Date',
+                                       title='Submission Timeline',
+                                       labels={'Submission Date': 'Date', 'count': 'Number of Submissions'})
                     st.plotly_chart(fig)
-            
-            # Display submission status breakdown
-            status_counts = {
-                'pending': total_students - submitted_count,
-                'submitted': submitted_count,
-                'late': len([sub for sub in submissions if sub.get('is_late', False)])
-            }
-            
-            st.markdown("### Submission Status Breakdown")
-            status_df = pd.DataFrame(list(status_counts.items()), 
-                                   columns=['Status', 'Count'])
-            st.bar_chart(status_df.set_index('Status'))
-            
-            # List of students who haven't submitted
-            if status_counts['pending'] > 0:
-                st.markdown("### Students with Pending Submissions")
-                # submitted_ids = [sub.get('student_id') for sub in submissions]
-                submitted_ids = [ObjectId(sub.get('student_id')) for sub in submissions]
-                print(submitted_ids)
-                pending_students = students_collection.find({
-                    "enrolled_courses.course_id": course_id,
-                    "_id": {"$nin": submitted_ids}
-                })
-                print(pending_students)
-                for student in pending_students:
-                    st.markdown(f"- {student.get('full_name', 'Unknown Student')} (SID: {student.get('SID', 'Unknown SID')})")
 
+            # Display subjective test analysis
+            st.subheader("Subjective Test Analysis")
+            for submission in submissions:
+                if 'analysis' in submission:
+                    st.markdown(f"**Student ID:** {submission['student_id']}")
+                    st.markdown(submission['analysis']['content_analysis'])
+                    st.markdown("---")
+    
 def get_chat_history(user_id, session_id):
     query = {
         "user_id": ObjectId(user_id),
@@ -1933,34 +1658,6 @@ def display_session_analytics(session, course_id):
 
     # Display Post-class Analytics
     display_postclass_analytics(session, course_id)
-    
-# 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 upload_preclass_materials(session_id, course_id):
     """Upload pre-class materials and manage external resources for a session"""
@@ -2191,75 +1888,11 @@ def display_quiz_tab(student_id, course_id, session_id):
                         else:
                             st.error("Error submitting quiz. Please try again.")
 
-def display_subjective_test_tab(student_id, course_id, session_id):
-    """Display subjective tests for students"""
-    st.header("Subjective Tests")
-    
-    try:
-        subjective_tests = list(subjective_tests_collection.find({
-            "course_id": course_id,
-            "session_id": session_id,
-            "status": "active"
-        }))
-
-        if not subjective_tests:
-            st.info("No subjective tests available for this session.")
-            return
-
-        for test in subjective_tests:
-            with st.expander(f"📝 {test['title']}", expanded=True):
-                # Check for existing submission
-                existing_submission = next(
-                    (sub for sub in test.get('submissions', []) 
-                     if sub['student_id'] == str(student_id)), 
-                    None
-                )
-                
-                if existing_submission:
-                    st.success("Test completed! Your answers have been submitted.")
-                    st.subheader("Your Answers")
-                    for i, ans in enumerate(existing_submission['answers']):
-                        st.markdown(f"**Question {i+1}:** {test['questions'][i]['question']}")
-                        st.markdown(f"**Your Answer:** {ans}")
-                        st.markdown("---")
-                else:
-                    st.write("Please write your answers:")
-                    with st.form(key=f"subjective_test_form_{test['_id']}"):
-                        student_answers = []
-                        for i, question in enumerate(test['questions']):
-                            st.markdown(f"**Question {i+1}:** {question['question']}")
-                            answer = st.text_area(
-                                "Your answer:",
-                                key=f"q_{test['_id']}_{i}",
-                                height=200
-                            )
-                            student_answers.append(answer)
-
-                        if st.form_submit_button("Submit Test"):
-                            if all(answer.strip() for answer in student_answers):
-                                success = submit_subjective_test(
-                                    test['_id'],
-                                    str(student_id),
-                                    student_answers
-                                )
-                                if success:
-                                    st.success("Test submitted successfully!")
-                                    st.rerun()
-                                else:
-                                    st.error("Error submitting test. Please try again.")
-                            else:
-                                st.error("Please answer all questions before submitting.")
-                                
-    except Exception as e:
-        st.error(f"An error occurred while loading the tests. Please try again later.")
-        print(f"Error in display_subjective_test_tab: {str(e)}", flush=True)
-
 def display_session_content(student_id, course_id, session, username, user_type):
     st.title(f"{session['title']}")
 
     # Check if the date is a string or a datetime object
     if isinstance(session['date'], str):
-        # Convert date string to datetime object
         session_date = datetime.fromisoformat(session['date'])
     else:
         session_date = session['date']
@@ -2269,10 +1902,7 @@ def display_session_content(student_id, course_id, session, username, user_type)
     st.markdown(f"**Date:** {format_datetime(session_date)}")
     st.markdown(f"**Course Name:** {course_name}")
 
-    # Find the course_id of the session in 
-
     if user_type == 'student':
-        # Create all tabs at once for students
         tabs = st.tabs([
             "Pre-class Work",
             "In-class Work", 
@@ -2292,18 +1922,14 @@ def display_session_content(student_id, course_id, session, username, user_type)
             with tabs[3]:
                 display_quiz_tab(student_id, course_id, session['session_id'])
             with tabs[4]:
-                display_subjective_test_tab(student_id, course_id, session['session_id'])
+                display_subjective_test_tab(student_id, course_id, session['session_id'])  # Added this line
             with tabs[5]:
-                st.subheader("Group Work")
-                st.info("Group work content will be available soon.")
+                #display_group_work_tab(session, student_id)
+                st.info("End term content will be available soon.")
             with tabs[6]:
                 st.subheader("End Terms")
                 st.info("End term content will be available soon.")
-        else:
-            st.error("Error creating tabs. Please try again.")
-    
     else:  # faculty user
-        # Create all tabs at once for faculty
         tabs = st.tabs([
             "Pre-class Work",
             "In-class Work",
@@ -2311,7 +1937,9 @@ def display_session_content(student_id, course_id, session, username, user_type)
             "Pre-class Analytics",
             "In-class Analytics",
             "Post-class Analytics",
-            "End Terms"
+            "Rubrics",
+            "End Terms",
+            "Evaluate Subjective Tests"  # New tab for evaluation
         ])
         with tabs[0]:
             upload_preclass_materials(session['session_id'], course_id)
@@ -2326,9 +1954,13 @@ def display_session_content(student_id, course_id, session, username, user_type)
         with tabs[5]:
             display_postclass_analytics(session, course_id)
         with tabs[6]:
+            display_rubrics_tab(session, course_id)
+        with tabs[7]:
             st.subheader("End Terms")
             st.info("End term content will be available soon.")
-
+        with tabs[8]:  # New tab for evaluation
+            display_evaluation_to_faculty(session['session_id'], student_id, course_id)
+            
 def parse_model_response(response_text):
     """Enhanced parser for model responses with better error handling.
     
@@ -2426,124 +2058,21 @@ def generate_questions(context, num_questions, session_title, session_descriptio
         print(f"Error generating questions: {str(e)}")
         return None
 
-def generate_synoptic(questions, context, session_title, num_questions):
-    """Generate synoptic answers for the questions with improved error handling and response validation.
-    
-    Args:
-        questions (list): List of question dictionaries
-        context (str): Additional context for answer generation
-        session_title (str): Title of the session
-        num_questions (int): Expected number of questions
-        
-    Returns:
-        list: List of synoptic answers or None if generation fails
-    """
+def save_subjective_test(course_id, session_id, title, questions):
+    """Save subjective test to database with proper ID handling"""
     try:
-        # First, let's validate our input
-        if not questions or not isinstance(questions, list):
-            raise ValueError("Questions must be provided as a non-empty list")
-            
-        # Format questions for better prompt clarity
-        formatted_questions = "\n".join(
-            f"{i+1}. {q['question']}" 
-            for i, q in enumerate(questions)
-        )
+        # Ensure proper string format for IDs
+        # course_id = course_id
+        # session_id = session_id
         
-        # Construct a more structured prompt
-        prompt = f"""You are a subject matter expert creating detailed model answers for {num_questions} questions about {session_title}.
-
-        Here are the questions:
-        {formatted_questions}
-        {f'Additional context: {context}' if context else ''}
-
-        Please provide {num_questions} comprehensive answers following this JSON format:
-        {{
-            "answers": [
-                {{
-                    "answer": "Your detailed answer for question 1...",
-                    "key_points": ["Point 1", "Point 2", "Point 3"]
-                }},
-                {{
-                    "answer": "Your detailed answer for question 2...",
-                    "key_points": ["Point 1", "Point 2", "Point 3"]
-                }}
-            ]
-        }}
-
-        Requirements for each answer:
-        1. Minimum 150 words
-        2. Include specific examples and evidence
-        3. Reference key concepts and terminology
-        4. Demonstrate critical analysis
-        5. Structure with clear introduction, body, and conclusion
-
-        IMPORTANT: Return ONLY the JSON object with the answers array. No additional text.
-        """
-
-        # Generate response
-        response = model.generate_content(prompt)
-        
-        # Parse and validate the response
-        parsed_response = parse_model_response(response.text)
-        
-        # Additional validation of parsed response
-        if not isinstance(parsed_response, (dict, list)):
-            raise ValueError("Response must be a dictionary or list")
-            
-        # Handle both possible valid response formats
-        if isinstance(parsed_response, dict):
-            answers = parsed_response.get('answers', [])
-        else:  # If it's a list
-            answers = parsed_response
-        
-        # Validate answer count
-        if len(answers) != num_questions:
-            raise ValueError(f"Expected {num_questions} answers, got {len(answers)}")
-        
-        # Extract just the answer texts for consistency with existing code
-        final_answers = []
-        for ans in answers:
-            if isinstance(ans, dict):
-                answer_text = ans.get('answer', '')
-                key_points = ans.get('key_points', [])
-                formatted_answer = f"{answer_text}\n\nKey Points:\n" + "\n".join(f"• {point}" for point in key_points)
-                final_answers.append(formatted_answer)
-            else:
-                final_answers.append(str(ans))
-        
-        # Final validation of the answers
-        for i, answer in enumerate(final_answers):
-            if not answer or len(answer.split()) < 50:  # Basic length check
-                raise ValueError(f"Answer {i+1} is too short or empty")
-        
-        # Save the synoptic to the synoptic_store collection
-        synoptic_data = {
-            "session_title": session_title,
-            "questions": questions,
-            "synoptic": final_answers,
-            "created_at": datetime.utcnow()
-        }
-        synoptic_store_collection.insert_one(synoptic_data)
-        
-        return final_answers
-
-    except Exception as e:
-        # Log the error for debugging
-        print(f"Error in generate_synoptic: {str(e)}")
-        print(f"Response text: {response.text if 'response' in locals() else 'No response generated'}")
-        return None
-
-def save_subjective_test(course_id, session_id, title, questions, synoptic):
-    """Save subjective test to database"""
-    try:
-        # Format questions to include metadata
+        # Format questions
         formatted_questions = []
         for q in questions:
             formatted_question = {
                 "question": q["question"],
-                "expected_points": q.get("expected_points", []),
-                "difficulty_level": q.get("difficulty_level", "medium"),
-                "suggested_time": q.get("suggested_time", "5 minutes")
+                "expected_points": [],
+                "difficulty_level": "medium",
+                "suggested_time": "5 minutes"
             }
             formatted_questions.append(formatted_question)
 
@@ -2552,7 +2081,6 @@ def save_subjective_test(course_id, session_id, title, questions, synoptic):
             "session_id": session_id,
             "title": title,
             "questions": formatted_questions,
-            "synoptic": synoptic,
             "created_at": datetime.utcnow(),
             "status": "active",
             "submissions": []
@@ -2561,148 +2089,40 @@ def save_subjective_test(course_id, session_id, title, questions, synoptic):
         result = subjective_tests_collection.insert_one(test_data)
         return result.inserted_id
     except Exception as e:
-        print(f"Error saving subjective test: {e}")
+        print(f"Error saving test: {e}")
         return None
 
-def submit_subjective_test(test_id, student_id, student_answers):
-    """Submit subjective test answers and trigger analysis"""
+def submit_subjective_test(test_id, student_id, answers):
+    """Submit test answers with proper ID handling"""
     try:
-        submission_data = {
+        # Ensure IDs are strings
+        test_id = str(test_id)
+        student_id = str(student_id)
+        
+        # Create submission document
+        submission = {
             "student_id": student_id,
-            "answers": student_answers,
-            "submitted_at": datetime.utcnow()
+            "answers": answers,
+            "submitted_at": datetime.utcnow(),
+            "status": "submitted"
         }
         
+        # Update test document with new submission
         result = subjective_tests_collection.update_one(
-            {"_id": test_id},
-            {
-                "$push": {
-                    "submissions": submission_data
-                }
-            }
+            {"_id": ObjectId(test_id)},
+            {"$push": {"submissions": submission}}
         )
         
-        if result.modified_count > 0:
-            try:
-                # Trigger grading and analysis
-                analysis = analyze_subjective_answers(test_id, student_id)
-                if analysis:
-                    # Update the submission with the analysis and score
-                    subjective_tests_collection.update_one(
-                        {"_id": test_id, "submissions.student_id": student_id},
-                        {
-                            "$set": {
-                                "submissions.$.analysis": analysis,
-                                "submissions.$.score": analysis.get('correctness_score')
-                            }
-                        }
-                    )
-                    return True
-                else:
-                    print("Error: Analysis failed")
-                    return False
-            except Exception as e:
-                print(f"Warning: Grading failed but submission was saved: {e}")
-                return True  # We still return True since the submission itself was successful
-            
-        print("Error: No document was modified")
-        return False
-        
+        return result.modified_count > 0
     except Exception as e:
-        print(f"Error submitting subjective test: {str(e)}")
+        print(f"Error submitting test: {e}")
         return False
 
-def analyze_subjective_answers(test_id, student_id):
-    """Analyze subjective test answers for correctness and improvements"""
-    try:
-        # Get test and submission details
-        test_doc = subjective_tests_collection.find_one({"_id": test_id})
-        if not test_doc:
-            print(f"Test document not found for test_id: {test_id}")
-            return None
-            
-        submission = next(
-            (sub for sub in test_doc.get('submissions', []) if sub['student_id'] == student_id),
-            None
-        )
-        
-        if not submission:
-            print(f"No submission found for student_id: {student_id}")
-            return None
-        
-        # Get questions and answers
-        questions = test_doc.get('questions', [])
-        student_answers = submission.get('answers', [])
-        
-        if not questions or not student_answers:
-            print("No questions or answers found")
-            return None
-            
-        # Retrieve the synoptic from the synoptic_store collection
-        synoptic_doc = synoptic_store_collection.find_one({"session_title": test_doc.get('title')})
-        synoptic = synoptic_doc.get('synoptic', '') if synoptic_doc else ''
-        
-        # Analyze each question separately
-        all_analyses = []
-        total_score = 0
-        
-        for i, (question, answer) in enumerate(zip(questions, student_answers), 1):
-            # Format content for individual question
-            analysis_content = f"Question {i}: {question['question']}\nAnswer: {answer}\n\n"
-            
-            # Get analysis for this question
-            individual_analysis = derive_analytics(
-                goal="Analyze and Grade",
-                reference_text=analysis_content,
-                openai_api_key=OPENAI_API_KEY,
-                context=test_doc.get('context', ''),
-                synoptic=synoptic[i-1] if isinstance(synoptic, list) else synoptic
-            )
-            
-            if individual_analysis:
-                # Extract score for this question
-                try:
-                    score_match = re.search(r'(\d+)(?:/10)?', individual_analysis)
-                    if score_match:
-                        question_score = int(score_match.group(1))
-                        if 1 <= question_score <= 10:
-                            total_score += question_score
-                except:
-                    question_score = 0
-                
-                # Format individual analysis
-                formatted_analysis = f"\n\n## Question {i} Analysis\n\n{individual_analysis}"
-                all_analyses.append(formatted_analysis)
-        
-        if not all_analyses:
-            print("Error: No analyses generated")
-            return None
-            
-        # Calculate average score
-        average_score = round(total_score / len(questions)) if questions else 0
-        
-        # Combine all analyses
-        combined_analysis = "\n".join(all_analyses)
-        
-        # Format final results
-        analysis_results = {
-            "content_analysis": combined_analysis,
-            "analyzed_at": datetime.utcnow(),
-            "correctness_score": average_score
-        }
-        
-        return analysis_results
-        
-    except Exception as e:
-        print(f"Error in analyze_subjective_answers: {str(e)}")
-        return None
-
 def display_subjective_test_tab(student_id, course_id, session_id):
     """Display subjective tests for students"""
     st.header("Subjective Tests")
-    
+
     try:
-        # Query for active tests
         subjective_tests = list(subjective_tests_collection.find({
             "course_id": course_id,
             "session_id": session_id,
@@ -2721,7 +2141,7 @@ def display_subjective_test_tab(student_id, course_id, session_id):
                      if sub['student_id'] == str(student_id)), 
                     None
                 )
-                
+
                 if existing_submission:
                     st.success("Test completed! Your answers have been submitted.")
                     st.subheader("Your Answers")
@@ -2729,9 +2149,19 @@ def display_subjective_test_tab(student_id, course_id, session_id):
                         st.markdown(f"**Question {i+1}:** {test['questions'][i]['question']}")
                         st.markdown(f"**Your Answer:** {ans}")
                         st.markdown("---")
-                    
+
                     # Display analysis
-                    display_subjective_analysis(test['_id'], str(student_id), test.get('context', ''))
+                    analysis = subjective_test_analysis_collection.find_one({
+                        "test_id": test['_id'],
+                        "student_id": str(student_id)
+                    })
+                    if analysis:
+                        st.subheader("Answer Analysis")
+                        st.markdown("### Evidence-Based Feedback")
+                        st.markdown(analysis.get('content_analysis', 'No analysis available'))
+                        analyzed_at = analysis.get('analyzed_at')
+                        if analyzed_at:
+                            st.caption(f"Analysis performed at: {analyzed_at.strftime('%Y-%m-%d %H:%M:%S UTC')}")
                 else:
                     st.write("Please write your answers:")
                     with st.form(key=f"subjective_test_form_{test['_id']}"):
@@ -2762,43 +2192,27 @@ def display_subjective_test_tab(student_id, course_id, session_id):
     except Exception as e:
         print(f"Error in display_subjective_test_tab: {str(e)}", flush=True)
         st.error("An error occurred while loading the tests. Please try again later.")
-    
-def display_subjective_analysis(test_id, student_id, context):
-    """Display subjective test analysis to students and faculty"""
-    try:
-        test_doc = subjective_tests_collection.find_one({"_id": test_id})
-        submission = next(
-            (sub for sub in test_doc.get('submissions', []) if sub['student_id'] == student_id),
-            None
-        )
         
-        if not submission:
-            st.warning("No submission found for analysis.")
-            return
-            
-        # Get or generate analysis
-        analysis = submission.get('analysis')
-        if not analysis:
-            analysis = analyze_subjective_answers(test_id, student_id, context)
-            if not analysis:
-                st.error("Could not generate analysis.")
-                return
-        
-        # Display analysis results
-        st.subheader("Answer Analysis")
-        
-        # Content analysis
-        st.markdown("### Evidence-Based Feedback")
-        st.markdown(analysis.get('content_analysis', 'No analysis available'))
-        
-        # Improvement suggestions
-        # st.markdown("### Suggested Improvements")
-        # st.markdown(analysis.get('suggested_improvements', 'No suggestions available'))
-        
-        # Analysis timestamp
-        analyzed_at = analysis.get('analyzed_at')
-        if analyzed_at:
-            st.caption(f"Analysis performed at: {analyzed_at.strftime('%Y-%m-%d %H:%M:%S UTC')}")
-            
-    except Exception as e:
-        st.error(f"Error displaying analysis: {e}")
+def review_and_edit_analysis(test_id, student_id):
+    """Allow faculty to review and edit the generated analysis before storing it"""
+    analysis = st.session_state.get('llm_analysis')
+    if not analysis:
+        st.error("No analysis available for review.")
+        return
+
+    st.header("Review and Edit Analysis")
+    content_analysis = st.text_area("Content Analysis", value=analysis['content_analysis'], height=300)
+    correctness_score = st.number_input("Correctness Score", value=analysis['correctness_score'], min_value=0, max_value=10)
+
+    if st.button("Save Analysis"):
+        # Store the edited analysis in MongoDB
+        analysis_results = {
+            "test_id": test_id,
+            "student_id": student_id,
+            "content_analysis": content_analysis,
+            "analyzed_at": datetime.utcnow(),
+            "correctness_score": correctness_score
+        }
+        subjective_test_analysis_collection.insert_one(analysis_results)
+        st.success("Analysis saved successfully!")
+        del st.session_state['llm_analysis']  # Clear the temporary analysis