Omkar update 1

assignment_evaluation.py

@@ -0,0 +1,261 @@
+# assignment_evaluation.py
+
+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"]
+assignments_collection = db["assignments"]
+assignment_evaluation_collection = db["assignment_evaluation"]
+resources_collection = db["resources"]
+students_collection = db["students"]
+
+def evaluate_assignment(session_id, student_id, assignment_id):
+    """
+    Generate evaluation and analysis for submitted assignments
+    """
+    try:
+        # Fetch assignment and student submission
+        assignment = assignments_collection.find_one({"_id": assignment_id})
+        if not assignment:
+            return None
+
+        # Find student's submission
+        submission = next(
+            (sub for sub in assignment.get('submissions', []) 
+             if sub['student_id'] == str(student_id)),
+            None
+        )
+        if not submission:
+            return None
+
+        # Default rubric for assignment evaluation
+        default_rubric = """
+        1. Understanding & Implementation (1-4):
+           - Demonstrates understanding of assignment requirements
+           - Implements required components correctly
+           - Shows attention to detail
+           
+        2. Quality & Completeness (1-4):
+           - Work is complete and thorough
+           - Meets all assignment objectives
+           - Shows evidence of effort and care
+           
+        3. Presentation & Organization (1-4):
+           - Clear and professional presentation
+           - Well-structured and organized
+           - Follows required format and guidelines
+        """
+
+        # Initialize OpenAI client
+        client = OpenAI(api_key=os.getenv('OPENAI_KEY'))
+
+        # Create evaluation prompt
+        prompt_template = f"""As an assignment evaluator, assess this student's submission based on the provided rubric criteria. Follow these guidelines:
+
+        1. Evaluation Process:
+        - Use each rubric criterion (scored 1-4)
+        - Evaluate completeness and quality
+        - Check alignment with assignment requirements
+        - Calculate final score: sum of criteria scores converted to 10-point scale
+
+        Assignment Title: {assignment['title']}
+        Due Date: {assignment['due_date']}
+        
+        Submission Content:
+        {submission.get('text_content', 'No text content available')}
+
+        Rubric Criteria:
+        {default_rubric}
+
+        Provide your assessment in the following format:
+
+        **Overall Score and Summary**
+        - Score: [X]/10
+        - Overall Assessment: [2-3 sentence summary]
+
+        **Strengths**
+        - [Key strength 1]
+        - [Key strength 2]
+        - [Key strength 3]
+
+        **Areas for Improvement**
+        - [Improvement point 1]
+        - [Improvement point 2]
+        - [Improvement point 3]
+
+        **Specific Recommendations**
+        [2-3 sentences with actionable feedback]
+        """
+
+        # Generate evaluation using OpenAI
+        response = client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[{"role": "user", "content": prompt_template}],
+            max_tokens=1000,
+            temperature=0.4
+        )
+
+        # Store evaluation in MongoDB
+        evaluation_doc = {
+            "assignment_id": assignment_id,
+            "student_id": student_id,
+            "session_id": session_id,
+            "evaluation": response.choices[0].message.content,
+            "evaluated_at": datetime.utcnow()
+        }
+        
+        assignment_evaluation_collection.insert_one(evaluation_doc)
+        return evaluation_doc
+
+    except Exception as e:
+        print(f"Error in evaluate_assignment: {str(e)}")
+        return None
+
+def display_evaluation_to_faculty(session_id, student_id, course_id):
+    """
+    Display interface for faculty to generate and view assignment evaluations
+    """
+    st.header("Evaluate Assignments")
+
+    try:
+        # Fetch available assignments
+        assignments = list(assignments_collection.find({
+            "session_id": str(session_id),
+            "course_id": course_id
+        }))
+
+        if not assignments:
+            st.info("No assignments found for this session.")
+            return
+
+        # Select assignment
+        assignment_options = {
+            f"{assignment['title']} (Due: {assignment['due_date'].strftime('%Y-%m-%d')})" if 'due_date' in assignment else assignment['title']: assignment['_id'] 
+            for assignment in assignments
+        }
+        
+        if assignment_options:
+            selected_assignment = st.selectbox(
+                "Select Assignment to Evaluate",
+                options=list(assignment_options.keys())
+            )
+
+            if selected_assignment:
+                assignment_id = assignment_options[selected_assignment]
+                assignment = assignments_collection.find_one({"_id": assignment_id})
+
+                if assignment:
+                    submissions = assignment.get('submissions', [])
+                    if not submissions:
+                        st.warning("No submissions found for this assignment.")
+                        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)
+
+                        # Display submission details
+                        st.subheader("Submission Details")
+                        st.markdown(f"**Submitted:** {submission['submitted_at'].strftime('%Y-%m-%d %H:%M')}")
+                        st.markdown(f"**File Name:** {submission['file_name']}")
+                        
+                        # Add download button for submitted file
+                        if 'file_content' in submission:
+                            st.download_button(
+                                label="Download Submission",
+                                data=submission['file_content'],
+                                file_name=submission['file_name'],
+                                mime=submission['file_type']
+                            )
+
+                        # Check for existing evaluation
+                        existing_eval = assignment_evaluation_collection.find_one({
+                            "assignment_id": assignment_id,
+                            "student_id": student_id,
+                            "session_id": str(session_id)
+                        })
+
+                        if existing_eval:
+                            st.subheader("Evaluation Results")
+                            st.markdown(existing_eval['evaluation'])
+                            st.success("✓ Evaluation completed")
+                            
+                            if st.button("Regenerate Evaluation"):
+                                with st.spinner("Regenerating evaluation..."):
+                                    evaluation = evaluate_assignment(
+                                        str(session_id),
+                                        student_id,
+                                        assignment_id
+                                    )
+                                    if evaluation:
+                                        st.success("Evaluation regenerated successfully!")
+                                        st.rerun()
+                                    else:
+                                        st.error("Error regenerating evaluation.")
+                        else:
+                            if st.button("Generate Evaluation"):
+                                with st.spinner("Generating evaluation..."):
+                                    evaluation = evaluate_assignment(
+                                        str(session_id),
+                                        student_id,
+                                        assignment_id
+                                    )
+                                    if evaluation:
+                                        st.success("Evaluation generated successfully!")
+                                        st.markdown("### Generated Evaluation")
+                                        st.markdown(evaluation['evaluation'])
+                                        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)}")
+
+def display_assignment_results(assignment_id, student_id):
+    """
+    Display assignment results and analysis for a student
+    """
+    try:
+        # Fetch analysis from evaluation collection
+        analysis = assignment_evaluation_collection.find_one({
+            "assignment_id": assignment_id,
+            "student_id": str(student_id)
+        })
+        
+        if not analysis:
+            st.info("Evaluation will be available soon. Please check back later.")
+            return
+            
+        st.header("Assignment Evaluation")
+        
+        # Display evaluation content
+        st.markdown(analysis["evaluation"])
+        
+        # Display evaluation timestamp
+        st.caption(f"Evaluation generated on: {analysis['evaluated_at'].strftime('%Y-%m-%d %H:%M:%S UTC')}")
+            
+    except Exception as e:
+        st.error("An error occurred while loading the evaluation. Please try again later.")
+        print(f"Error in display_assignment_results: {str(e)}")