new

rubrics.py

@@ -98,14 +98,14 @@ def display_rubrics_tab(session, course_id):
                 
                 if rubric:
                     st.json(rubric)
-                    if st.button("Save Rubric"):
-                        rubric_data = {
-                            "course_id": course_id,
-                            "session_id": session['session_id'],
-                            "rubric": json.loads(rubric)
-                        }
-                        rubrics_collection.insert_one(rubric_data)
-                        st.success("Rubric saved successfully!")
+                    # if st.button("Save Rubric"):
+                    rubric_data = {
+                        "course_id": course_id,
+                        "session_id": session['session_id'],
+                        "rubric": json.loads(rubric)
+                    }
+                    rubrics_collection.insert_one(rubric_data)
+                    st.success("Rubric saved successfully!")
         else:
             st.error("No learning outcomes found for this session")
     else:

session_page.py

@@ -35,6 +35,9 @@ import streamlit.components.v1 as components
 from live_chat_feature import display_live_chat_interface 
 from code_playground import display_code_playground
 from urllib.parse import urlparse, parse_qs
+from bs4 import BeautifulSoup
+from rubrics import display_rubrics_tab
+from subjective_test_evaluation import evaluate_subjective_answers, display_evaluation_to_faculty
 
 # Load environment variables
 load_dotenv()
@@ -49,7 +52,7 @@ subjective_test_evaluation_collection = db["subjective_test_evaluation"]
 assignment_evaluation_collection = db["assignment_evaluation"]
 subjective_tests_collection = db["subjective_tests"]
 synoptic_store_collection = db["synoptic_store"]
-
+assignments_collection = db["assignments"]
 
 # for implementing Context Caching: 
 # PROJECT_ID = "novascholar-446709"
@@ -1188,8 +1191,7 @@ def display_post_class_content(session, student_id, course_id):
                                     course_id,
                                     session['session_id'],
                                     test_title,
-                                    questions,
-                                    synoptic
+                                    questions
                                 )
                                 if test_id:
                                     st.success("Subjective test saved successfully!")
@@ -1216,7 +1218,6 @@ 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!")
@@ -1278,267 +1279,136 @@ def display_post_class_content(session, student_id, course_id):
                     else:
                         st.error("Error saving quiz.")
 
-        st.subheader("Add Assignments")
-        # Add assignment form
+        st.subheader("Add Assignment")
         with st.form("add_assignment_form"):
             title = st.text_input("Assignment Title")
+            description = st.text_area("Assignment Description")
             due_date = st.date_input("Due Date")
             submit = st.form_submit_button("Add Assignment")
             
             if submit:
+                if not title or not description:
+                    st.error("Please fill in all required fields.")
+                    return
+                    
                 due_date = datetime.combine(due_date, datetime.min.time())
-                # Save the assignment to the database
                 assignment = {
-                    "id": ObjectId(),
+                    "_id": ObjectId(),
                     "title": title,
+                    "description": description,
                     "due_date": due_date,
-                    "status": "pending",
+                    "course_id": course_id,
+                    "session_id": session['session_id'],
+                    "faculty_id": faculty_id,
+                    "created_at": datetime.utcnow(),
+                    "status": "active",
                     "submissions": []
                 }
-                courses_collection2.update_one(
-                    {"course_id": course_id, "sessions.session_id": session['session_id']},
-                    {"$push": {"sessions.$.post_class.assignments": assignment}}
-                )
+                
+                assignments_collection.insert_one(assignment)
                 st.success("Assignment added successfully!")
-    else:
-        # Display assignments
-        session_data = courses_collection2.find_one(
-            {"course_id": course_id, "sessions.session_id": session['session_id']},
-            {"sessions.$": 1}
-        )
+                
+        st.subheader("Existing Assignments")
+        assignments = assignments_collection.find({
+            "session_id": session['session_id'],
+            "course_id": course_id
+        })
         
-        if session_data and "sessions" in session_data and len(session_data["sessions"]) > 0:
-            assignments = session_data["sessions"][0].get("post_class", {}).get("assignments", [])
-            for assignment in assignments:
-                title = assignment.get("title", "No Title")
-                due_date = assignment.get("due_date", "No Due Date")
-                status = assignment.get("status", "No Status")
-                assignment_id = assignment.get("id", "No ID")
-
-                with st.expander(f"Assignment: {title}", expanded=True):
-                    st.markdown(f"**Due Date:** {due_date}")
-                    st.markdown(f"**Status:** {status.replace('_', ' ').title()}")
+        for assignment in assignments:
+            with st.expander(f"📝 {assignment['title']}", expanded=True):
+                st.markdown(f"**Due Date:** {assignment['due_date'].strftime('%Y-%m-%d')}")
+                st.markdown(f"**Description:** {assignment['description']}")
+                
+                total_submissions = len(assignment.get('submissions', []))
+                total_students = students_collection.count_documents({
+                    "enrolled_courses": {
+                        "$elemMatch": {"course_id": course_id}
+                    }
+                })
+                
+                col1, col2, col3 = st.columns(3)
+                with col1:
+                    st.metric("Total Submissions", total_submissions)
+                with col2:
+                    submission_rate = (total_submissions / total_students * 100) if total_students > 0 else 0
+                    st.metric("Submission Rate", f"{submission_rate:.1f}%")
+                with col3:
+                    st.metric("Pending Submissions", total_students - total_submissions)
+                
+                # Display evaluation button and status
+                evaluation_status = st.empty()
+                eval_button = st.button("View/Generate Evaluations", key=f"eval_{assignment['_id']}")
+                
+                if eval_button:
+                    st.session_state.show_evaluations = True
+                    st.session_state.current_assignment = assignment['_id']
                     
-                    # Assignment details
-                    st.markdown("### Instructions")
-                    st.markdown("Complete the assignment according to the provided guidelines.")
+                    # Show evaluation interface in a new container instead of an expander
+                    evaluation_container = st.container()
+                    with evaluation_container:
+                        from assignment_evaluation import display_evaluation_to_faculty
+                        display_evaluation_to_faculty(session['session_id'], student_id, course_id)
                     
-                    # File submission
-                    st.markdown("### Submission")
+    else:  # Student view
+        assignments = assignments_collection.find({
+            "session_id": session['session_id'],
+            "course_id": course_id,
+            "status": "active"
+        })
+        
+        for assignment in assignments:
+            with st.expander(f"📝 {assignment['title']}", expanded=True):
+                st.markdown(f"**Due Date:** {assignment['due_date'].strftime('%Y-%m-%d')}")
+                st.markdown(f"**Description:** {assignment['description']}")
+                
+                existing_submission = next(
+                    (sub for sub in assignment.get('submissions', []) 
+                     if sub['student_id'] == str(student_id)),
+                    None
+                )
+                
+                if existing_submission:
+                    st.success("Assignment submitted!")
+                    st.markdown(f"**Submitted on:** {existing_submission['submitted_at'].strftime('%Y-%m-%d %H:%M')}")
+                    
+                    # Show evaluation status and feedback in the same container
+                    evaluation = assignment_evaluation_collection.find_one({
+                        "assignment_id": assignment['_id'],
+                        "student_id": str(student_id)
+                    })
+                    
+                    if evaluation:
+                        st.markdown("### Evaluation")
+                        st.markdown(evaluation['evaluation'])
+                    else:
+                        st.info("Evaluation pending. Check back later.")
+                else:
                     uploaded_file = st.file_uploader(
                         "Upload your work",
-                        type=['pdf', 'py', 'ipynb'],
-                        key=f"upload_{assignment['id']}"
+                        type=['pdf', 'doc', 'docx', 'txt', 'py', 'ipynb', 'ppt', 'pptx'],
+                        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']}"):
-                            # Extract text content from the file
+                        if st.button("Submit Assignment", key=f"submit_{assignment['_id']}"):
                             text_content = extract_text_from_file(uploaded_file)
                             
-                            # Call assignment_submit function
-                            success = assignment_submit(
-                                student_id=student_id,
-                                course_id=course_id,
-                                session_id=session['session_id'],
-                                assignment_id=assignment['id'],
-                                file_name=uploaded_file.name,
-                                file_content=uploaded_file,
-                                text_content=text_content,
-                                material_type="assignment"
+                            submission = {
+                                "student_id": str(student_id),
+                                "file_name": uploaded_file.name,
+                                "file_type": uploaded_file.type,
+                                "file_content": uploaded_file.getvalue(),
+                                "text_content": text_content,
+                                "submitted_at": datetime.utcnow()
+                            }
+                            
+                            assignments_collection.update_one(
+                                {"_id": assignment['_id']},
+                                {"$push": {"submissions": submission}}
                             )
                             
-                            if success:
-                                st.success("Assignment submitted successfully!")
-                            else:
-                                st.error("Error saving submission.")
-                    # 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.")
-        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.success("Assignment submitted successfully!")
+                            st.rerun()            
 
 def display_inclass_analytics(session, course_id):
     """Display in-class analytics for faculty"""
@@ -1653,9 +1523,6 @@ def display_inclass_analytics(session, course_id):
                 "courses": course_id,
                 "_id": {"$nin": respondents}
             }))
-            
-            
-
 
             if non_participants:
                 st.markdown("#### Students Who Haven't Participated")
@@ -2457,8 +2324,6 @@ def display_session_analytics(session, course_id):
 #             Uploaded on: {material['uploaded_at'].strftime('%Y-%m-%d %H:%M')}
 #         """)
 
-
-
 def display_quiz_tab(student_id, course_id, session_id):
     """Display quizzes for students"""
     st.header("Course Quizzes")
@@ -2520,69 +2385,6 @@ 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']}")
 
@@ -2644,7 +2446,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"
         ])
         with tabs[0]:
             upload_preclass_materials(session['session_id'], course_id)
@@ -2659,8 +2463,12 @@ 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.
@@ -2866,17 +2674,21 @@ def generate_synoptic(questions, context, session_title, num_questions):
         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"""
+def save_subjective_test(course_id, session_id, title, questions):
+    """Save subjective test to database with proper ID handling"""
     try:
-        # Format questions to include metadata
+        # Ensure proper string format for IDs
+        course_id = str(course_id)
+        session_id = str(session_id)
+        
+        # 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)
 
@@ -2885,157 +2697,48 @@ 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": []
         }
         
         result = subjective_tests_collection.insert_one(test_data)
-        return result.inserted_id
+        return str(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"""
+    """Display subjective tests and results 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,
@@ -3046,94 +2749,144 @@ def display_subjective_test_tab(student_id, course_id, session_id):
             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("---")
+        # Create tabs for Tests and Results
+        test_tab, results_tab = st.tabs(["Available Tests", "Test Results"])
+        
+        with test_tab:
+            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
+                    )
                     
-                    # Display analysis
-                    display_subjective_analysis(test['_id'], str(student_id), test.get('context', ''))
-                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 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
                                 )
-                                if success:
-                                    st.success("Test submitted successfully!")
-                                    st.rerun()
+                                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("Error submitting test. Please try again.")
-                            else:
-                                st.error("Please answer all questions before submitting.")
+                                    st.error("Please answer all questions before submitting.")
+        
+        with results_tab:
+            # Display results for completed tests
+            completed_tests = [
+                test for test in subjective_tests
+                if any(sub['student_id'] == str(student_id) for sub in test.get('submissions', []))
+            ]
+            
+            if not completed_tests:
+                st.info("You haven't completed any tests yet.")
+                return
+                
+            # Create a selectbox for choosing which test results to view
+            test_options = {
+                f"{test['title']} (Submitted: {next(sub['submitted_at'].strftime('%Y-%m-%d') for sub in test['submissions'] if sub['student_id'] == str(student_id))})"
+                : test['_id']
+                for test in completed_tests
+            }
+            
+            selected_test = st.selectbox(
+                "Select a test to view results:",
+                options=list(test_options.keys())
+            )
+            
+            if selected_test:
+                test_id = test_options[selected_test]
+                display_test_results(test_id, student_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.")
+        print(f"Error in display_subjective_test_tab: {str(e)}")
+        
+def display_test_results(test_id, student_id):
+    """
+    Display test results and analysis for a student
     
-
-
-def display_subjective_analysis(test_id, student_id, context):
-    """Display subjective test analysis to students and faculty"""
+    Args:
+        test_id: ObjectId or str of the test
+        student_id: str of the student ID
+    """
     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
-        )
+        # Fetch analysis from evaluation collection
+        analysis = subjective_test_evaluation_collection.find_one({
+            "test_id": test_id,
+            "student_id": str(student_id)
+        })
         
-        if not submission:
-            st.warning("No submission found for analysis.")
+        if not analysis:
+            st.info("Analysis will be available soon. Please check back later.")
             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
+        st.header("Test Analysis")
         
-        # 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')}")
+        # Display overall evaluation summary if available
+        if "overall_summary" in analysis:
+            with st.expander("Overall Performance Summary", expanded=True):
+                st.markdown(analysis["overall_summary"])
+                
+        # Display individual question evaluations
+        st.subheader("Question-wise Analysis")
+        for eval_item in analysis.get('evaluations', []):
+            with st.expander(f"Question {eval_item['question_number']}", expanded=True):
+                st.markdown("**Question:**")
+                st.markdown(eval_item['question'])
+                
+                st.markdown("**Your Answer:**")
+                st.markdown(eval_item['answer'])
+                
+                st.markdown("**Evaluation:**")
+                st.markdown(eval_item['evaluation'])
+                
+                # Extract and display score if available
+                if "Score:" in eval_item['evaluation']:
+                    score_line = next((line for line in eval_item['evaluation'].split('\n') if "Score:" in line), None)
+                    if score_line:
+                        score = score_line.split("Score:")[1].strip()
+                        st.metric("Score", score)
+                
+                # Display improvement points if available
+                if "Key Areas for Improvement" in eval_item['evaluation']:
+                    st.markdown("**Areas for Improvement:**")
+                    improvement_section = eval_item['evaluation'].split("Key Areas for Improvement")[1]
+                    points = [point.strip('- ').strip() for point in improvement_section.split('\n') if point.strip().startswith('-')]
+                    for point in points:
+                        if point:  # Only display non-empty points
+                            st.markdown(f"• {point}")
+                
+        # Display evaluation timestamp
+        if "evaluated_at" in analysis:
+            st.caption(f"Analysis generated on: {analysis['evaluated_at'].strftime('%Y-%m-%d %H:%M:%S UTC')}")
             
     except Exception as e:
-        st.error(f"Error displaying analysis: {e}")
+        st.error("An error occurred while loading the analysis. Please try again later.")
+        print(f"Error in display_test_results: {str(e)}")

subjective_test_evaluation.py

@@ -1,252 +1,247 @@
-import openai
-from pymongo import MongoClient
+import streamlit as st
 from datetime import datetime
+from pymongo import MongoClient
 import os
+from openai import OpenAI
 from dotenv import load_dotenv
-import re
-import streamlit as st
 from bson import ObjectId
 
 load_dotenv()
-MONGO_URI = os.getenv('MONGO_URI')
-OPENAI_API_KEY = os.getenv('OPENAI_KEY')
 
+# MongoDB setup
+MONGO_URI = os.getenv('MONGO_URI')
 client = MongoClient(MONGO_URI)
-db = client['novascholar_db']
-rubrics_collection = db['rubrics']
-resources_collection = db['resources']
-subjective_tests_collection = db['subjective_tests']
-subjective_test_analysis_collection = db['subjective_test_analysis']
-
-openai.api_key = OPENAI_API_KEY
-
-def evaluate_subjective_answers(test_id, student_id, course_id):
-    """Evaluate subjective test answers using OpenAI."""
+db = client["novascholar_db"]
+subjective_tests_collection = db["subjective_tests"]
+subjective_test_evaluation_collection = db["subjective_test_evaluation"]
+resources_collection = db["resources"]
+students_collection = db["students"]
+
+def evaluate_subjective_answers(session_id, student_id, test_id):
+    """
+    Generate evaluation and analysis for subjective test answers
+    """
     try:
-        # Get test and submission details
-        test_doc = subjective_tests_collection.find_one({
-            "_id": ObjectId(test_id),
-            "course_id": course_id
-        })
-        if not test_doc:
-            return {
-                "content_analysis": "Error: Test not found",
-                "analyzed_at": datetime.utcnow(),
-                "correctness_score": 0
-            }
+        # Fetch test and student submission
+        test = subjective_tests_collection.find_one({"_id": test_id})
+        if not test:
+            return None
 
+        # Find student's submission
         submission = next(
-            (sub for sub in test_doc.get('submissions', []) if sub['student_id'] == student_id),
+            (sub for sub in test.get('submissions', []) 
+             if sub['student_id'] == str(student_id)),
             None
         )
-
         if not submission:
-            return {
-                "content_analysis": "Error: Submission not found",
-                "analyzed_at": datetime.utcnow(),
-                "correctness_score": 0
-            }
-
-        # Rest of the evaluation logic remains the same
-        questions = test_doc.get('questions', [])
-        student_answers = submission.get('answers', [])
-
-        if not questions or not student_answers:
-            return {
-                "content_analysis": "Error: No questions or answers found",
-                "analyzed_at": datetime.utcnow(),
-                "correctness_score": 0
-            }
-
-        # Retrieve rubrics for the session
-        rubric_doc = rubrics_collection.find_one({
-            "session_id": test_doc['session_id'],
-            "course_id": course_id
-        })
-        
-        if not rubric_doc:
-            return {
-                "content_analysis": "Error: Rubric not found",
-                "analyzed_at": datetime.utcnow(),
-                "correctness_score": 0
-            }
-
-        rubric = rubric_doc.get('rubric', {})
-
-        # Retrieve pre-class materials
-        pre_class_materials = resources_collection.find({
-            "session_id": test_doc['session_id'],
-            "course_id": course_id
-        })
-        pre_class_content = "\n".join([material.get('text_content', '') for material in pre_class_materials])
-
-        # Analyze each question
-        all_analyses = []
-        total_score = 0
-
-        for i, (question, answer) in enumerate(zip(questions, student_answers), 1):
-            analysis_content = f"Question {i}: {question['question']}\nAnswer: {answer}\n\nRubric: {rubric}\n\nPre-class Materials: {pre_class_content}\n\n"
+            return None
+
+        # Fetch pre-class materials
+        pre_class_materials = resources_collection.find({"session_id": session_id})
+        pre_class_content = ""
+        for material in pre_class_materials:
+            if 'text_content' in material:
+                pre_class_content += material['text_content'] + "\n"
+
+        # Default rubric (can be customized later)
+        default_rubric = """
+        1. Content Understanding (1-4):
+           - Demonstrates comprehensive understanding of core concepts
+           - Accurately applies relevant theories and principles
+           - Provides specific examples and evidence
+           
+        2. Critical Analysis (1-4):
+           - Shows depth of analysis
+           - Makes meaningful connections
+           - Demonstrates original thinking
+           
+        3. Organization & Clarity (1-4):
+           - Clear structure and flow
+           - Well-developed arguments
+           - Effective use of examples
+        """
+
+        # Initialize OpenAI client
+        client = OpenAI(api_key=os.getenv('OPENAI_KEY'))
+
+        evaluations = []
+        for i, (question, answer) in enumerate(zip(test['questions'], submission['answers'])):
+            analysis_content = f"""
+            Question: {question['question']}
+            Student Answer: {answer}
+            """
 
             prompt_template = f"""As an educational assessor, evaluate this student's answer based on the provided rubric criteria and pre-class materials. Follow these assessment guidelines:
+            
+            1. Evaluation Process:
+            - Use each rubric criterion (scored 1-4) for internal assessment
+            - Compare response with pre-class materials
+            - Check alignment with all rubric requirements
+            - Calculate final score: sum of criteria scores converted to 10-point scale
 
-                1. Evaluation Process:
-                - Use each rubric criterion (scored 1-4) for internal assessment
-                - Compare response with pre-class materials
-                - Check alignment with all rubric requirements
-                - Calculate final score: sum of criteria scores converted to 10-point scale
+            Pre-class Materials:
+            {pre_class_content[:1000]}  # Truncate to avoid token limits
 
-                Pre-class Materials:
-                {pre_class_content}
+            Rubric Criteria:
+            {default_rubric}
 
-                Rubric Criteria:
-                {rubric}
+            Question and Answer:
+            {analysis_content}
 
-                Question and Answer:
-                {analysis_content}
+            Provide your assessment in the following format:
 
-                Provide your assessment in the following format:
+            **Score and Evidence**
+            - Score: [X]/10
+            - Evidence for deduction: [One-line reference to most significant gap or inaccuracy]
 
-                **Score and Evidence**
-                - Score: [X]/10
-                - Evidence for deduction: [One-line reference to most significant gap or inaccuracy]
-                **Key Areas for Improvement**
-                - [Concise improvement point 1]
-                - [Concise improvement point 2]
-                - [Concise improvement point 3]
+            **Key Areas for Improvement**
+            - [Concise improvement point 1]
+            - [Concise improvement point 2]
+            - [Concise improvement point 3]
             """
 
-            response = openai.Completion.create(
-                model="text-davinci-003",
-                prompt=prompt_template,
+            # Generate evaluation using OpenAI
+            response = client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[{"role": "user", "content": prompt_template}],
                 max_tokens=500,
-                temperature=0.7
+                temperature=0.4
             )
 
-            individual_analysis = response.choices[0].text.strip()
-
-            try:
-                score_match = re.search(r'Score: (\d+)', individual_analysis)
-                question_score = int(score_match.group(1)) if score_match else 0
-                total_score += question_score
-            except:
-                question_score = 0
-
-            formatted_analysis = f"\n\n## Question {i} Analysis\n\n{individual_analysis}"
-            all_analyses.append(formatted_analysis)
-
-        average_score = round(total_score / len(questions)) if questions else 0
-        combined_analysis = "\n".join(all_analyses)
-
-        return {
-            "content_analysis": combined_analysis,
-            "analyzed_at": datetime.utcnow(),
-            "correctness_score": average_score
+            evaluations.append({
+                "question_number": i + 1,
+                "question": question['question'],
+                "answer": answer,
+                "evaluation": response.choices[0].message.content
+            })
+
+        # Store evaluation in MongoDB
+        evaluation_doc = {
+            "test_id": test_id,
+            "student_id": student_id,
+            "session_id": session_id,
+            "evaluations": evaluations,
+            "evaluated_at": datetime.utcnow()
         }
+        
+        subjective_test_evaluation_collection.insert_one(evaluation_doc)
+        return evaluation_doc
 
     except Exception as e:
-        return {
-            "content_analysis": f"Error evaluating answers: {str(e)}",
-            "analyzed_at": datetime.utcnow(),
-            "correctness_score": 0
-        }
+        print(f"Error in evaluate_subjective_answers: {str(e)}")
+        return None
 
 def display_evaluation_to_faculty(session_id, student_id, course_id):
-    """Display submitted tests with improved error handling and debugging"""
-    st.subheader("Evaluate Subjective Tests")
-    
+    """
+    Display interface for faculty to generate and view evaluations
+    """
+    st.header("Evaluate Subjective Tests")
+
     try:
-        # Convert all IDs to strings for consistent comparison
-        session_id = str(session_id)
-        student_id = str(student_id)
-        course_id = str(course_id)
-        
-        print(f"Searching for tests with session_id: {session_id}, student_id: {student_id}, course_id: {course_id}")
-        
-        # Query for tests
-        query = {
-            "session_id": session_id,
-            "course_id": course_id,
-            "submissions": {
-                "$elemMatch": {
-                    "student_id": student_id
-                }
-            }
-        }
-        
-        # Log the query for debugging
-        print(f"MongoDB Query: {query}")
-        
-        # Fetch tests
-        tests = list(subjective_tests_collection.find(query))
-        print(f"Found {len(tests)} tests matching query")
-        
+        # Fetch available tests
+        tests = list(subjective_tests_collection.find({
+            "session_id": str(session_id),
+            "status": "active"
+        }))
+
         if not tests:
-            # Check if any tests exist for this session
-            all_session_tests = list(subjective_tests_collection.find({
-                "session_id": session_id,
-                "course_id": course_id
-            }))
-            
-            if all_session_tests:
-                print(f"Found {len(all_session_tests)} tests for this session, but no submissions from student {student_id}")
-                st.warning("No submitted tests found for this student, but tests exist for this session.")
-            else:
-                print("No tests found for this session at all")
-                st.info("No tests have been created for this session yet.")
+            st.info("No subjective tests found for this session.")
             return
 
-        # Display tests and handle evaluation
-        for test in tests:
-            with st.expander(f"Test: {test.get('title', 'Untitled Test')}", expanded=True):
-                # Find student submission
-                submission = next(
-                    (sub for sub in test.get('submissions', []) 
-                     if sub['student_id'] == student_id),
-                    None
-                )
-                
-                if submission:
-                    st.write("### Student's Answers")
-                    for i, (question, answer) in enumerate(zip(test['questions'], submission['answers'])):
-                        st.markdown(f"**Q{i+1}:** {question['question']}")
-                        st.markdown(f"**A{i+1}:** {answer}")
-                        st.markdown("---")
-                    
-                    # Generate/display analysis
-                    if st.button(f"Generate Analysis for {test.get('title')}"):
-                        with st.spinner("Analyzing responses..."):
-                            analysis = evaluate_subjective_answers(
-                                str(test['_id']),
-                                student_id,
-                                course_id
-                            )
-                            
-                            if analysis:
-                                st.markdown("### Analysis")
-                                st.markdown(analysis['content_analysis'])
-                                st.metric("Score", f"{analysis['correctness_score']}/10")
-                else:
-                    st.error("Submission data not found for this student")
-                    
-    except Exception as e:
-        st.error("An error occurred while loading the tests")
-        with st.expander("Error Details"):
-            st.write(f"Error: {str(e)}")
-            st.write(f"Session ID: {session_id}")
-            st.write(f"Student ID: {student_id}")
-            st.write(f"Course ID: {course_id}")
-
-def check_test_submission(session_id, student_id, course_id):
-    """Utility function to check test submission status"""
-    try:
-        query = {
-            "session_id": str(session_id),
-            "course_id": str(course_id),
-            "submissions.student_id": str(student_id)
+        # Select test
+        test_options = {
+            f"{test['title']} (Created: {test['created_at'].strftime('%Y-%m-%d %H:%M')})" if 'created_at' in test else test['title']: test['_id'] 
+            for test in tests
         }
         
-        test = subjective_tests_collection.find_one(query)
-        return bool(test)
+        if test_options:
+            selected_test = st.selectbox(
+                "Select Test to Evaluate",
+                options=list(test_options.keys())
+            )
+
+            if selected_test:
+                test_id = test_options[selected_test]
+                test = subjective_tests_collection.find_one({"_id": test_id})
+
+                if test:
+                    submissions = test.get('submissions', [])
+                    if not submissions:
+                        st.warning("No submissions found for this test.")
+                        return
+
+                    # Create a dropdown for student submissions
+                    student_options = {
+                        f"{students_collection.find_one({'_id': ObjectId(sub['student_id'])})['full_name']} (Submitted: {sub['submitted_at'].strftime('%Y-%m-%d %H:%M')})": sub['student_id']
+                        for sub in submissions
+                    }
+
+                    selected_student = st.selectbox(
+                        "Select Student Submission",
+                        options=list(student_options.keys())
+                    )
+
+                    if selected_student:
+                        student_id = student_options[selected_student]
+                        submission = next(sub for sub in submissions if sub['student_id'] == student_id)
+
+                        st.markdown(f"**Submission Date:** {submission.get('submitted_at', 'No submission date')}")
+                        st.markdown("---")
+
+                        # Display questions and answers
+                        st.subheader("Submission Details")
+                        for i, (question, answer) in enumerate(zip(test['questions'], submission['answers'])):
+                            st.markdown(f"**Question {i+1}:** {question['question']}")
+                            st.markdown(f"**Answer:** {answer}")
+                            st.markdown("---")
+
+                        # Check for existing evaluation
+                        existing_eval = subjective_test_evaluation_collection.find_one({
+                            "test_id": test_id,
+                            "student_id": student_id,
+                            "session_id": str(session_id)
+                        })
+
+                        if existing_eval:
+                            st.subheader("Evaluation Results")
+                            for eval_item in existing_eval['evaluations']:
+                                st.markdown(f"### Evaluation for Question {eval_item['question_number']}")
+                                st.markdown(eval_item['evaluation'])
+                                st.markdown("---")
+                            
+                            st.success("✓ Evaluation completed")
+                            if st.button("Regenerate Evaluation", key=f"regenerate_{student_id}_{test_id}"):
+                                with st.spinner("Regenerating evaluation..."):
+                                    evaluation = evaluate_subjective_answers(
+                                        str(session_id),
+                                        student_id,
+                                        test_id
+                                    )
+                                    if evaluation:
+                                        st.success("Evaluation regenerated successfully!")
+                                        st.rerun()
+                                    else:
+                                        st.error("Error regenerating evaluation.")
+                        else:
+                            st.subheader("Generate Evaluation")
+                            if st.button("Generate Evaluation", key=f"evaluate_{student_id}_{test_id}"):
+                                with st.spinner("Generating evaluation..."):
+                                    evaluation = evaluate_subjective_answers(
+                                        str(session_id),
+                                        student_id,
+                                        test_id
+                                    )
+                                    if evaluation:
+                                        st.success("Evaluation generated successfully!")
+                                        st.markdown("### Generated Evaluation")
+                                        for eval_item in evaluation['evaluations']:
+                                            st.markdown(f"#### Question {eval_item['question_number']}")
+                                            st.markdown(eval_item['evaluation'])
+                                            st.markdown("---")
+                                        st.rerun()
+                                    else:
+                                        st.error("Error generating evaluation.")
+
     except Exception as e:
-        print(f"Error checking submission: {e}")
-        return False
+        st.error(f"An error occurred while loading the evaluations: {str(e)}")
+        print(f"Error in display_evaluation_to_faculty: {str(e)}")