Merge branch 'main' of https://huggingface.co/spaces/SPJIMR-Internship/SPJIMR_FlipClassroom_RCopilot_ResearchInternship

gen_mcqs.py

@@ -1,3 +1,210 @@
+# import ast
+# from pymongo import MongoClient
+# from datetime import datetime
+# import openai
+# import google.generativeai as genai
+# from google.generativeai import GenerativeModel
+# from dotenv import load_dotenv
+# import os
+# from file_upload_vectorize import resources_collection, vectors_collection, courses_collection2, faculty_collection
+
+# # Load environment variables
+# load_dotenv()
+# MONGO_URI = os.getenv('MONGO_URI')
+# OPENAI_KEY = os.getenv('OPENAI_KEY')
+# GEMINI_KEY = os.getenv('GEMINI_KEY')
+
+# # Configure APIs
+# openai.api_key = OPENAI_KEY
+# genai.configure(api_key=GEMINI_KEY)
+# model = genai.GenerativeModel('gemini-pro')
+
+# # Connect to MongoDB
+# client = MongoClient(MONGO_URI)
+# db = client['novascholar_db']
+# quizzes_collection = db["quizzes"]
+
+# def strip_code_markers(response_text):
+#     """Strip off the markers ``` and python from a LLM model's response"""
+#     if response_text.startswith("```python"):
+#         response_text = response_text[len("```python"):].strip()
+#     if response_text.startswith("```"):
+#         response_text = response_text[len("```"):].strip()
+#     if response_text.endswith("```"):
+#         response_text = response_text[:-len("```")].strip()
+#     return response_text
+
+
+# # New function to generate MCQs using Gemini
+# def generate_mcqs(context, num_questions, session_title, session_description):
+#     """Generate MCQs either from context or session details"""
+#     try:
+#         # Initialize Gemini model
+#         if context:
+#             prompt = f"""
+#             Based on the following content, generate {num_questions} multiple choice questions.
+#             Format each question as a Python dictionary with the following structure:
+#             {{
+#                 "question": "Question text here",
+#                 "options": ["A) option1", "B) option2", "C) option3", "D) option4"],
+#                 "correct_option": "A) option1" or "B) option2" or "C) option3" or "D) option4"
+#             }}
+            
+#             Content:
+#             {context}
+            
+#             Generate challenging but clear questions that test understanding of key concepts.
+#             Return only the Python list of dictionaries.
+#             """
+#         else:
+#             prompt = f"""
+#             Generate {num_questions} multiple choice questions about the topic:
+#             Title: {session_title}
+#             Description: {session_description}
+            
+#             Format each question as a Python dictionary with the following structure:
+#             {{
+#                 "question": "Question text here",
+#                 "options": ["A) option1", "B) option2", "C) option3", "D) option4"],
+#                 "correct_option": "A" or "B" or "C" or "D"
+#             }}
+            
+#             Generate challenging but clear questions.
+#             Return only the Python list of dictionaries without any additional formatting or markers
+#             Do not write any other text, do not start the response with (```python), do not end the response with backticks(```)
+#             A Sample response should look like this: Response Text: [
+#                 {
+#                     "question": "Which of the following is NOT a valid data type in C++?",
+#                     "options": ["int", "double", "boolean", "char"],
+#                     "correct_option": "C"
+#                 }
+#             ] (Notice that there are no backticks(```) around the response and no (```python)) 
+#             .
+#             """
+        
+#         response = model.generate_content(prompt)
+#         response_text = response.text.strip()
+#         print("Response Text:", response_text)
+#         modified_response_text = strip_code_markers(response_text)
+#         print("Response Text Modified to:", modified_response_text)
+#         # Extract and parse the response to get the list of MCQs
+#         mcqs = ast.literal_eval(modified_response_text)  # Be careful with eval, consider using ast.literal_eval for production
+#         print(mcqs)
+#         if not mcqs:
+#             raise ValueError("No questions generated")
+#         return mcqs
+#     except Exception as e:
+#         print(f"Error generating MCQs: , error: {e}")
+#         return None
+
+# # New function to save quiz to database
+# def save_quiz(course_id, session_id, title, questions, user_id):
+#     """Save quiz to database"""
+#     try:
+#         quiz_data = {
+#             "user_id": user_id,
+#             "course_id": course_id,
+#             "session_id": session_id,
+#             "title": title,
+#             "questions": questions,
+#             "created_at": datetime.utcnow(),
+#             "status": "active",
+#             "submissions": []
+#         }
+#         result = quizzes_collection.insert_one(quiz_data)
+#         return result.inserted_id
+#     except Exception as e:
+#         print(f"Error saving quiz: {e}")
+#         return None
+    
+
+# def get_student_quiz_score(quiz_id, student_id):
+#     """Get student's score for a specific quiz"""
+#     quiz = quizzes_collection.find_one(
+#         {
+#             "_id": quiz_id,
+#             "submissions.student_id": student_id
+#         },
+#         {"submissions.$": 1}
+#     )
+#     if quiz and quiz.get('submissions'):
+#         return quiz['submissions'][0].get('score')
+#     return None
+
+# # def submit_quiz_answers(quiz_id, student_id, student_answers):
+# #     """Submit and score student's quiz answers"""
+# #     quiz = quizzes_collection.find_one({"_id": quiz_id})
+# #     if not quiz:
+# #         return None
+    
+# #     # Calculate score
+# #     correct_answers = 0
+# #     total_questions = len(quiz['questions'])
+    
+# #     for q_idx, question in enumerate(quiz['questions']):
+# #         if student_answers.get(str(q_idx)) == question['correct_option']:
+# #             correct_answers += 1
+    
+# #     score = (correct_answers / total_questions) * 100
+    
+# #     # Store submission
+# #     submission_data = {
+# #         "student_id": student_id,
+# #         "answers": student_answers,
+# #         "score": score,
+# #         "submitted_at": datetime.utcnow()
+# #     }
+    
+# #     # Update quiz with submission
+# #     quizzes_collection.update_one(
+# #         {"_id": quiz_id},
+# #         {
+# #             "$push": {"submissions": submission_data}
+# #         }
+# #     )
+    
+# #     return score
+# def submit_quiz_answers(quiz_id, student_id, student_answers):
+#     """Submit and score student's quiz answers"""
+#     try:
+#         quiz = quizzes_collection.find_one({"_id": quiz_id})
+#         if not quiz:
+#             return None
+        
+#         # Calculate score
+#         correct_answers = 0
+#         total_questions = len(quiz['questions'])
+        
+#         for q_idx, question in enumerate(quiz['questions']):
+#             student_answer = student_answers.get(str(q_idx))
+#             if student_answer:  # Only check if answer was provided
+#                 # Extract the option letter (A, B, C, D) from the full answer string
+#                 answer_letter = student_answer.split(')')[0].strip()
+#                 if answer_letter == question['correct_option']:
+#                     correct_answers += 1
+        
+#         score = (correct_answers / total_questions) * 100
+        
+#         # Store submission
+#         submission_data = {
+#             "student_id": student_id,
+#             "answers": student_answers,
+#             "score": score,
+#             "submitted_at": datetime.utcnow()
+#         }
+        
+#         # Update quiz with submission
+#         result = quizzes_collection.update_one(
+#             {"_id": quiz_id},
+#             {"$push": {"submissions": submission_data}}
+#         )
+        
+#         return score if result.modified_count > 0 else None
+        
+#     except Exception as e:
+#         print(f"Error submitting quiz: {e}")
+#         return None
+
 import ast
 from pymongo import MongoClient
 from datetime import datetime
@@ -23,6 +230,7 @@ model = genai.GenerativeModel('gemini-pro')
 client = MongoClient(MONGO_URI)
 db = client['novascholar_db']
 quizzes_collection = db["quizzes"]
+surprise_quizzes_collection = db["surprise_quizzes"]
 
 def strip_code_markers(response_text):
     """Strip off the markers ``` and python from a LLM model's response"""
@@ -117,6 +325,26 @@ def save_quiz(course_id, session_id, title, questions, user_id):
         print(f"Error saving quiz: {e}")
         return None
     
+def save_surprise_quiz(course_id, session_id, title, questions, user_id, no_minutes):
+    """Save quiz to database"""
+    try:
+        quiz_data = {
+            "user_id": user_id,
+            "course_id": course_id,
+            "session_id": session_id,
+            "title": title,
+            "questions": questions,
+            "created_at": datetime.now(),
+            "status": "active",
+            "submissions": [],
+            "no_minutes": no_minutes
+        }
+        result = surprise_quizzes_collection.insert_one(quiz_data)
+        return result.inserted_id
+    except Exception as e:
+        print(f"Error saving quiz: {e}")
+        return None
+    
 
 def get_student_quiz_score(quiz_id, student_id):
     """Get student's score for a specific quiz"""
@@ -131,6 +359,19 @@ def get_student_quiz_score(quiz_id, student_id):
         return quiz['submissions'][0].get('score')
     return None
 
+def get_student_surprise_quiz_score(quiz_id, student_id):
+    """Get student's score for a specific quiz"""
+    quiz = surprise_quizzes_collection.find_one(
+        {
+            "_id": quiz_id,
+            "submissions.student_id": student_id
+        },
+        {"submissions.$": 1}
+    )
+    if quiz and quiz.get('submissions'):
+        return quiz['submissions'][0].get('score')
+    return None
+
 # def submit_quiz_answers(quiz_id, student_id, student_answers):
 #     """Submit and score student's quiz answers"""
 #     quiz = quizzes_collection.find_one({"_id": quiz_id})
@@ -201,6 +442,47 @@ def submit_quiz_answers(quiz_id, student_id, student_answers):
         
         return score if result.modified_count > 0 else None
         
+    except Exception as e:
+        print(f"Error submitting quiz: {e}")
+        return None
+    
+def submit_surprise_quiz_answers(quiz_id, student_id, student_answers):
+    """Submit and score student's quiz answers"""
+    try:
+        quiz = surprise_quizzes_collection.find_one({"_id": quiz_id})
+        if not quiz:
+            return None
+        
+        # Calculate score
+        correct_answers = 0
+        total_questions = len(quiz['questions'])
+        
+        for q_idx, question in enumerate(quiz['questions']):
+            student_answer = student_answers.get(str(q_idx))
+            if student_answer:  # Only check if answer was provided
+                # Extract the option letter (A, B, C, D) from the full answer string
+                answer_letter = student_answer.split(')')[0].strip()
+                if answer_letter == question['correct_option']:
+                    correct_answers += 1
+        
+        score = (correct_answers / total_questions) * 100
+        
+        # Store submission
+        submission_data = {
+            "student_id": student_id,
+            "answers": student_answers,
+            "score": score,
+            "submitted_at": datetime.utcnow()
+        }
+        
+        # Update quiz with submission
+        result = surprise_quizzes_collection.update_one(
+            {"_id": quiz_id},
+            {"$push": {"submissions": submission_data}}
+        )
+        
+        return score if result.modified_count > 0 else None
+        
     except Exception as e:
         print(f"Error submitting quiz: {e}")
         return None

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:

subjective_test_evaluation.py

@@ -1,252 +1,798 @@
-import openai
-from pymongo import MongoClient
-from datetime import datetime
-import os
-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')
-
-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."""
-    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
-            }
-
-        submission = next(
-            (sub for sub in test_doc.get('submissions', []) if sub['student_id'] == 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"
-
-            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
-
-                Pre-class Materials:
-                {pre_class_content}
-
-                Rubric Criteria:
-                {rubric}
-
-                Question and Answer:
-                {analysis_content}
-
-                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]
-                **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,
-                max_tokens=500,
-                temperature=0.7
-            )
-
-            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
-        }
-
-    except Exception as e:
-        return {
-            "content_analysis": f"Error evaluating answers: {str(e)}",
-            "analyzed_at": datetime.utcnow(),
-            "correctness_score": 0
-        }
-
-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")
-    
-    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")
-        
-        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.")
-            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)
-        }
-        
-        test = subjective_tests_collection.find_one(query)
-        return bool(test)
-    except Exception as e:
-        print(f"Error checking submission: {e}")
-        return False
+# import streamlit as st
+# from datetime import datetime
+# from pymongo import MongoClient
+# import os
+# from openai import OpenAI
+# from dotenv import load_dotenv
+# from bson import ObjectId
+
+# load_dotenv()
+
+# # MongoDB setup
+# MONGO_URI = os.getenv('MONGO_URI')
+# client = MongoClient(MONGO_URI)
+# 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:
+#         # 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.get('submissions', []) 
+#              if sub['student_id'] == str(student_id)),
+#             None
+#         )
+#         if not submission:
+#             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
+
+#             Pre-class Materials:
+#             {pre_class_content[:1000]}  # Truncate to avoid token limits
+
+#             Rubric Criteria:
+#             {default_rubric}
+
+#             Question and Answer:
+#             {analysis_content}
+
+#             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]
+
+#             **Key Areas for Improvement**
+#             - [Concise improvement point 1]
+#             - [Concise improvement point 2]
+#             - [Concise improvement point 3]
+#             """
+
+#             # Generate evaluation using OpenAI
+#             response = client.chat.completions.create(
+#                 model="gpt-4o-mini",
+#                 messages=[{"role": "user", "content": prompt_template}],
+#                 max_tokens=500,
+#                 temperature=0.4
+#             )
+
+#             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:
+#         print(f"Error in evaluate_subjective_answers: {str(e)}")
+#         return None
+
+# def display_evaluation_to_faculty(session_id, student_id, course_id):
+#     """
+#     Display interface for faculty to generate and view evaluations
+#     """
+#     st.header("Evaluate Subjective Tests")
+
+#     try:
+#         # Fetch available tests
+#         tests = list(subjective_tests_collection.find({
+#             "session_id": str(session_id),
+#             "status": "active"
+#         }))
+
+#         if not tests:
+#             st.info("No subjective tests found for this session.")
+#             return
+
+#         # 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
+#         }
+        
+#         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:
+#         st.error(f"An error occurred while loading the evaluations: {str(e)}")
+#         print(f"Error in display_evaluation_to_faculty: {str(e)}")
+
+import streamlit as st
+from datetime import datetime
+from pymongo import MongoClient
+import os
+from openai import OpenAI
+from dotenv import load_dotenv
+from bson import ObjectId
+
+load_dotenv()
+
+# MongoDB setup
+MONGO_URI = os.getenv("MONGO_URI")
+client = MongoClient(MONGO_URI)
+db = client["novascholar_db"]
+subjective_tests_collection = db["subjective_tests"]
+subjective_test_evaluation_collection = db["subjective_test_evaluation"]
+pre_subjective_tests_collection = db["pre_subjective_tests"]
+resources_collection = db["resources"]
+students_collection = db["students"]
+pre_subjective_test_evaluation_collection = db["pre_subjective_test_evaluation"]
+
+
+def evaluate_subjective_answers(session_id, student_id, test_id):
+    """
+    Generate evaluation and analysis for subjective test answers
+    """
+    try:
+        # 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.get("submissions", [])
+                if sub["student_id"] == str(student_id)
+            ),
+            None,
+        )
+        if not submission:
+            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
+
+            Pre-class Materials:
+            {pre_class_content[:1000]}  # Truncate to avoid token limits
+
+            Rubric Criteria:
+            {default_rubric}
+
+            Question and Answer:
+            {analysis_content}
+
+            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]
+
+            **Key Areas for Improvement**
+            - [Concise improvement point 1]
+            - [Concise improvement point 2]
+            - [Concise improvement point 3]
+            """
+
+            # Generate evaluation using OpenAI
+            response = client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[{"role": "user", "content": prompt_template}],
+                max_tokens=500,
+                temperature=0.4,
+            )
+
+            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:
+        print(f"Error in evaluate_subjective_answers: {str(e)}")
+        return None
+
+
+def pre_evaluate_subjective_answers(session_id, student_id, test_id):
+    """
+    Generate evaluation and analysis for subjective test answers
+    """
+    try:
+        # Fetch test and student submission
+        test = pre_subjective_tests_collection.find_one({"_id": test_id})
+        if not test:
+            return None
+
+        # Find student's submission
+        submission = next(
+            (
+                sub
+                for sub in test.get("submissions", [])
+                if sub["student_id"] == str(student_id)
+            ),
+            None,
+        )
+        if not submission:
+            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
+
+            Pre-class Materials:
+            {pre_class_content[:1000]}  # Truncate to avoid token limits
+
+            Rubric Criteria:
+            {default_rubric}
+
+            Question and Answer:
+            {analysis_content}
+
+            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]
+
+            **Key Areas for Improvement**
+            - [Concise improvement point 1]
+            - [Concise improvement point 2]
+            - [Concise improvement point 3]
+            """
+
+            # Generate evaluation using OpenAI
+            response = client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[{"role": "user", "content": prompt_template}],
+                max_tokens=500,
+                temperature=0.4,
+            )
+
+            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(),
+        }
+
+        pre_subjective_test_evaluation_collection.insert_one(evaluation_doc)
+        return evaluation_doc
+
+    except Exception as e:
+        print(f"Error in evaluate_subjective_answers: {str(e)}")
+        return None
+
+
+def display_evaluation_to_faculty(session_id, student_id, course_id):
+    """
+    Display interface for faculty to generate and view evaluations
+    """
+    st.header("Evaluate Subjective Tests")
+
+    try:
+        # Fetch available tests
+        print("session_id", session_id, "student_id", student_id, "course_id", course_id)
+        tests = list(
+            subjective_tests_collection.find(
+                {"session_id": str(session_id), "status": "active"}
+            )
+        )
+
+        print("tests" ,tests)
+        if not tests:
+            st.info("No subjective tests found for this session.")
+            return
+
+        # 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
+        }
+
+        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:
+        st.error(f"An error occurred while loading the evaluations: {str(e)}")
+        print(f"Error in display_evaluation_to_faculty: {str(e)}")
+        return None
+
+
+def pre_display_evaluation_to_faculty(session_id, student_id, course_id):
+    """
+    Display interface for faculty to generate and view evaluations
+    """
+    st.header("Evaluate Pre Subjective Tests")
+
+    try:
+        # Fetch available tests
+        tests = list(
+            pre_subjective_tests_collection.find(
+                {"session_id": str(session_id), "status": "active"}
+            )
+        )
+
+        if not tests:
+            st.info("No subjective tests found for this session.")
+            return
+
+        # 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
+        }
+
+        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 = pre_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 = (
+                            pre_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 = pre_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"pre_evaluate_{student_id}_{test_id}",
+                            ):
+                                with st.spinner("Generating evaluation..."):
+                                    print("session_id", session_id, "student_id", student_id, "test_id", test_id)
+                                    evaluation = pre_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:
+        st.error(f"An error occurred while loading the evaluations: {str(e)}")
+        print(f"Error in display_evaluation_to_faculty: {str(e)}")