integrate new features

app.py

@@ -93,7 +93,7 @@ def login_user(username, password, user_type):
         # user = students_collection.find_one({"full_name": username}) or students_collection.find_one({"username": username})
         user = students_collection.find_one({"$or": [{"full_name": username}, {"username": username}]})
     elif user_type == "faculty":
-        user = faculty_collection.find_one({"full_name": username})
+        user = faculty_collection.find_one({"$or": [{"full_name": username}, {"username": username}]})
     elif user_type == "research_assistant":
         user = research_assistants_collection.find_one({"full_name": username})
     elif user_type == "analyst":

live_chat_feature.py

@@ -0,0 +1,530 @@
+import streamlit as st
+from pymongo import MongoClient
+from datetime import datetime, timedelta
+from dotenv import load_dotenv
+import os
+import google.generativeai as genai 
+from file_upload_vectorize import resources_collection, vectors_collection
+# Load environment variables
+load_dotenv()
+MONGO_URI = os.getenv("MONGO_URI")
+client = MongoClient(MONGO_URI)
+db = client["novascholar_db"]
+live_chat_sessions_collection = db["live_chat_sessions"]
+
+# Initialize AI model
+genai.configure(api_key=os.getenv("GEMINI_KEY"))
+model = genai.GenerativeModel("gemini-1.5-flash")
+
+
+def display_live_chat_interface(session, user_id, course_id):
+    """Main interface for live chat sessions - handles both faculty and student views"""
+    st.markdown("<div style='margin-top: 20px;'></div>", unsafe_allow_html=True)
+    st.subheader("Live Class Chat Session")
+    
+    # Initialize session states
+    if 'chat_active' not in st.session_state:
+        st.session_state.chat_active = False
+    if 'chat_end_time' not in st.session_state:
+        st.session_state.chat_end_time = None
+    if 'messages' not in st.session_state:
+        st.session_state.messages = []
+
+    # Faculty View
+    if st.session_state.user_type == "faculty":
+        display_faculty_controls(session, user_id, course_id)
+    # Student View
+    else:
+        display_student_view(session, user_id, course_id)
+
+def create_timer_html(end_time):
+    """Create a simplified but reliable timer component"""
+    end_timestamp = int(end_time.timestamp() * 1000)  # Convert to milliseconds
+    current_timestamp = int(datetime.utcnow().timestamp() * 1000)
+    
+    return f"""
+        <div id="timer-container">
+            <style>
+                .timer-box {{
+                    background: #f0f2f6;
+                    border-radius: 8px;
+                    padding: 15px;
+                    text-align: center;
+                    margin: 10px 0;
+                }}
+                .timer-display {{
+                    font-size: 24px;
+                    font-weight: bold;
+                    color: #0066cc;
+                    margin-bottom: 10px;
+                }}
+                .progress-bar {{
+                    width: 100%;
+                    height: 8px;
+                    background: #e0e0e0;
+                    border-radius: 4px;
+                    overflow: hidden;
+                }}
+                .progress {{
+                    height: 100%;
+                    background: #00aa00;
+                    transition: width 1s linear;
+                }}
+            </style>
+            
+            <div class="timer-box">
+                <div id="timer" class="timer-display">Calculating...</div>
+                <div class="progress-bar">
+                    <div id="progress" class="progress"></div>
+                </div>
+            </div>
+
+            <script>
+                function updateTimer() {{
+                    const endTime = {end_timestamp};
+                    const startTime = {current_timestamp};
+                    const now = new Date().getTime();
+                    const totalDuration = endTime - startTime;
+                    const timeLeft = endTime - now;
+                    
+                    const timer = document.getElementById('timer');
+                    const progress = document.getElementById('progress');
+                    
+                    if (timeLeft <= 0) {{
+                        timer.innerHTML = 'Session Ended';
+                        timer.style.color = '#ff4444';
+                        progress.style.width = '100%';
+                        progress.style.background = '#ff4444';
+                        return;
+                    }}
+                    
+                    const minutes = Math.floor(timeLeft / (1000 * 60));
+                    const seconds = Math.floor((timeLeft % (1000 * 60)) / 1000);
+                    const progressWidth = ((totalDuration - timeLeft) / totalDuration) * 100;
+                    
+                    timer.innerHTML = `${{minutes}}:${{seconds < 10 ? '0' : ''}}${{seconds}}`;
+                    progress.style.width = `${{progressWidth}}%`;
+                    
+                    if (minutes < 5) {{
+                        progress.style.background = '#ffa500';
+                    }}
+                }}
+                
+                const timerInterval = setInterval(updateTimer, 1000);
+                updateTimer();
+            </script>
+        </div>
+    """
+
+# def display_timer(end_time):
+#     """Display a simple countdown timer"""
+#     if not isinstance(end_time, datetime):
+#         return
+        
+#     # Calculate remaining time
+#     remaining_time = end_time - datetime.utcnow()
+    
+#     if remaining_time.total_seconds() <= 0:
+#         st.session_state.chat_active = False
+#         st.session_state.chat_end_time = None
+#         return
+    
+#     # Convert to minutes and seconds
+#     total_seconds = int(remaining_time.total_seconds())
+#     minutes = total_seconds // 60
+#     seconds = total_seconds % 60
+    
+#     # Create a progress value between 0 and 100
+#     original_duration = st.session_state.get('original_duration', 15) * 60  # default 15 minutes in seconds
+#     progress = ((original_duration - total_seconds) / original_duration)
+    
+#     # Display timer using columns for better layout
+#     col1, col2 = st.columns([1, 28])
+    
+#     with col1:
+#         st.markdown("### ⏱️")
+#     with col2:
+#         # Display time remaining
+#         st.markdown(f"### {minutes:02d}:{seconds:02d}")
+    
+#     # Display progress bar
+#     if minutes < 5:
+#         color = "orange"
+#     else:
+#         color = "blue"
+    
+#     st.progress(progress, text="Session Progress")
+
+def display_timer(end_time):
+    """Display a simple countdown timer"""
+    if not isinstance(end_time, datetime):
+        return
+        
+    # Calculate remaining time
+    remaining_time = end_time - datetime.utcnow()
+    
+    if remaining_time.total_seconds() <= 0:
+        st.session_state.chat_active = False
+        st.session_state.chat_end_time = None
+        return
+    
+    # Convert to minutes and seconds
+    total_seconds = int(remaining_time.total_seconds())
+    minutes = total_seconds // 60
+    seconds = total_seconds % 60
+    
+    # Create a progress value between 0 and 100
+    original_duration = st.session_state.get('original_duration', 15) * 60  # default 15 minutes in seconds
+    progress = ((original_duration - total_seconds) / original_duration)
+    
+    # Custom CSS for timer layout
+    st.markdown("""
+        <style>
+        .timer-container {{
+            margin: 1rem 0;
+        }}
+        .timer-row {{
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            gap: 1rem;
+            margin-bottom: 0.15rem;
+        }}
+        .timer-icon {{
+            font-size: 1.5rem;
+        }}
+        .timer-text {{
+            font-size: 1.2rem;
+            font-weight: bold;
+        }}
+        .timer-progress-label {{
+            font-size: 1.1rem;
+            font-weight: semi-bold;
+        }}
+        .stProgress {{
+            margin-bottom: 0.25rem;
+        }}
+        .stChatInputContainer {{
+            margin-top: 1rem;
+        }}
+        </style>
+        
+        <div class="timer-container">
+            <div class="timer-row">
+                <div class="progress-text"><span class="timer-progress-label">Session Progress</span></div>
+                <div class="timer-progress">
+                <span class="timer-icon">⏱️</span>
+                <span class="timer-text">{:02d}:{:02d}</span>
+                </div>
+            </div>
+        </div>
+    """.format(minutes, seconds), unsafe_allow_html=True)
+    
+    # Display progress bar
+    color = "orange" if minutes < 5 else "blue"
+    st.progress(progress)
+
+def display_faculty_controls(session, faculty_id, course_id):
+    """Display faculty controls for managing chat sessions"""
+    
+    # Show scheduled sessions
+    st.markdown("<div style='margin-top: 20px;'></div>", unsafe_allow_html=True)
+    st.markdown("##### 📅 Scheduled Chat Sessions")
+    scheduled_sessions = list(live_chat_sessions_collection.find({
+        "session_id": session['session_id'],
+        "status": "scheduled"
+    }))
+
+    # Schedule new session
+    with st.expander("➕ Schedule New Chat Session"):
+        col1, col2, col3 = st.columns([2, 2, 1])
+        with col1:
+            session_date = st.date_input("📅 Date", min_value=datetime.now().date())
+        with col2:
+            session_time = st.time_input("🕒 Time", value=datetime.now().time())
+        with col3:
+            duration = st.selectbox(
+                "⏱️ Duration (mins)",
+                options=[5, 10, 15, 20, 30, 45, 60],
+                index=2
+            )
+        
+        if st.button("📋 Schedule Session"):
+            session_datetime = datetime.combine(session_date, session_time)
+            if session_datetime < datetime.now():
+                st.error("❌ Cannot schedule sessions in the past!")
+            else:
+                live_chat_sessions_collection.insert_one({
+                    "session_id": session['session_id'],
+                    "course_id": course_id,
+                    "faculty_id": faculty_id,
+                    "start_time": session_datetime,
+                    "duration": duration,
+                    "status": "scheduled",
+                    "chats": []
+                })
+                st.success("✅ Chat session scheduled successfully!")
+                st.rerun()
+
+
+    
+    if scheduled_sessions:
+        for scheduled in scheduled_sessions:
+            with st.expander(f"📌 Scheduled: {scheduled['start_time'].strftime('%I:%M %p')}"):
+                st.write(f"⏱️ Duration: {scheduled['duration']} minutes")
+                if st.button("❌ Cancel Session", key=f"cancel_{scheduled['_id']}", type="secondary"):
+                    live_chat_sessions_collection.delete_one({"_id": scheduled['_id']})
+                    st.rerun()
+    
+    # Start immediate session
+    if not st.session_state.get('chat_active', False):
+        st.markdown("<div style='margin-top: 20px;'></div>", unsafe_allow_html=True)
+        st.markdown("##### 🎯 Start Immediate Session")
+        col1, col2 = st.columns([3, 1])
+        with col1:
+            immediate_duration = st.selectbox(
+                "⏱️ Select duration (minutes)",
+                options=[5, 10, 15, 20, 30, 45, 60],
+                index=2
+            )
+        with col2:
+            st.markdown("<div style='margin-top: 26px;'>", unsafe_allow_html=True)
+            if st.button("▶️ Start", use_container_width=True):
+                st.session_state.chat_active = True
+                st.session_state.chat_end_time = datetime.utcnow() + timedelta(minutes=immediate_duration)
+                st.session_state.original_duration = immediate_duration  # Store original duration
+                live_chat_sessions_collection.insert_one({
+                    "session_id": session['session_id'],
+                    "course_id": course_id,
+                    "faculty_id": faculty_id,
+                    "start_time": datetime.utcnow(),
+                    "duration": immediate_duration,
+                    "status": "active",
+                    "chats": []
+                })
+                st.rerun()
+            st.markdown("</div>", unsafe_allow_html=True)
+    else:
+        # Show timer for active session
+        if hasattr(st.session_state, 'chat_end_time'):
+            display_timer(st.session_state.chat_end_time)
+            
+            if st.button("⏹️ End Session", type="secondary"):
+                st.session_state.chat_active = False
+                st.session_state.chat_end_time = None
+                live_chat_sessions_collection.update_one(
+                    {"session_id": session['session_id'], "status": "active"},
+                    {"$set": {"status": "completed", "end_time": datetime.utcnow()}}
+                )
+                st.rerun()
+
+def get_session_context(session, session_id, course_id):
+    """Retrieve session context for AI model"""
+    # Get session data
+    session = live_chat_sessions_collection.find_one({"session_id": session_id})
+    if not session:
+        st.error("Session not found")
+        return
+    
+    # Get pre-class materials
+    context = ""
+    materials = resources_collection.find({"session_id": session_id})
+    for material in materials:
+        resource_id = material['_id']
+        vector_data = vectors_collection.find_one({"resource_id": resource_id})
+        if vector_data and 'text' in vector_data:
+            context += vector_data['text'] + "\n"
+    
+    courses_collection = db["courses"]
+    course = courses_collection.find_one({"_id": course_id})
+    session = courses_collection.find_one({"sessions.session_id": session_id})
+    if course:
+        context += f"Course: {course['course_name']}\n"
+    if session:
+        context += f"Session: {session['title']}\n"
+        if 'session_learning_outcomes' in session:
+            context += f"Session Learning Outcomes: {', '.join(session['session_learning_outcomes'])}\n"
+    return context
+
+def display_student_view(session, student_id, course_id):
+    """Display student interface for chat sessions"""
+    
+    # Show upcoming scheduled sessions
+    st.markdown("<div style='margin-top: 20px;'></div>", unsafe_allow_html=True)
+    st.markdown("##### 📅 Upcoming Chat Sessions")
+    upcoming_sessions = list(live_chat_sessions_collection.find({
+        "session_id": session['session_id'],
+        "status": "scheduled",
+        "start_time": {"$gt": datetime.utcnow()} 
+    }).sort("start_time", 1))
+    
+    if upcoming_sessions:
+        for upcoming in upcoming_sessions:
+            with st.expander(f"📌 {upcoming['start_time'].strftime('%I:%M %p')}"):
+                st.write(f"⏱️ Duration: {upcoming['duration']} minutes")
+                time_until = upcoming['start_time'] - datetime.utcnow()
+                st.write(f"🕒 Starts in: {time_until.seconds // 3600}h {(time_until.seconds % 3600) // 60}m")
+    else:
+        st.info("📝 No upcoming chat sessions scheduled")
+    
+    # Check for active session
+    active_session = live_chat_sessions_collection.find_one({
+        "session_id": session['session_id'],
+        "status": "active"
+    })
+    
+    # if active_session:
+    #     st.session_state.chat_active = True
+    #     st.session_state.chat_end_time = active_session['start_time'] + timedelta(minutes=active_session['duration'])
+    if active_session and not st.session_state.get('chat_active', False):
+        st.session_state.chat_active = True
+        st.session_state.chat_end_time = active_session['start_time'] + timedelta(minutes=active_session['duration'])
+        st.session_state.original_duration = active_session['duration']
+    
+    if st.session_state.get('chat_active', False):
+        st.markdown("<div style='margin-top: 20px;'></div>", unsafe_allow_html=True)
+        st.markdown("##### 🔴 Live Chat Section")
+
+        if hasattr(st.session_state, 'chat_end_time'):
+            reamining_time = st.session_state.chat_end_time - datetime.utcnow()
+            if reamining_time.total_seconds() > 0:
+                display_timer(st.session_state.chat_end_time)
+                active_session = live_chat_sessions_collection.find_one({
+                    "session_id": session['session_id'],
+                    "status": "active"
+                })
+                if active_session:
+                    faculty_id = active_session['faculty_id']
+                    display_chat_interface(session, student_id, course_id, faculty_id)
+                else:
+                    st.error("❌ No active session found.")
+                    st.session_state.chat_active = False
+                    st.session_state.chat_end_time = None
+            else:
+                st.session_state.chat_active = False
+                st.session_state.chat_end_time = None
+                live_chat_sessions_collection.update_one(
+                    {"session_id": session['session_id'], "status": "active"},
+                    {"$set": {"status": "completed", "end_time": datetime.utcnow()}}
+                )
+                st.rerun()
+
+def display_chat_interface(session, user_id, course_id, faculty_id):
+    """Display the actual chat interface with messages"""
+    # Display chat messages
+    # Initialize 'messages' in session_state if it doesn't exist
+    if 'messages' not in st.session_state:
+        st.session_state.messages = []
+    
+    # Chat input
+    if prompt := st.chat_input("Ask Questions about the Session"):
+        # Get session context
+        context = ""
+        context = get_session_context(session, session['session_id'], course_id)
+        
+        st.session_state.messages.append({"role": "user", "content": prompt})
+        
+        # Display user message
+        with st.chat_message("user"):
+            st.markdown(prompt)
+        
+        try:
+            # Generate AI response
+            context_prompt = f"""
+            You are an intelligent teaching assistant participating in a live class discussion.
+            
+            Session Context:
+            {context}
+
+            Current Question by the Student: {prompt}
+
+            Instructions:
+            1. Provide clear, concise responses that relate to the session's key concepts and learning outcomes
+            2. Encourage critical thinking and discussion
+            3. Keep responses focused and relevant to the current topic
+            4. If students seem confused, provide clarifying examples
+            
+            Please provide an appropriate response for this live classroom discussion.
+            """
+            
+            response = model.generate_content(context_prompt)
+            assistant_response = response.text
+            
+            # Display assistant response
+            with st.chat_message("assistant"):
+                st.markdown(assistant_response)
+            
+            # Save chat message
+            chat_message = {
+                "session_id": session['session_id'],
+                "timestamp": datetime.utcnow(),
+                "user_id": user_id,
+                "user_type": st.session_state.user_type,
+                "message": prompt,
+                "response": assistant_response
+            }
+            st.session_state.messages.append(chat_message)
+            # chat_messages_collection.insert_one(chat_message)
+            # Update database
+            try:
+                current_session = live_chat_sessions_collection.find_one({"session_id": session['session_id'], "status": "active"})
+                live_chat_sessions_collection.update_one(
+                    {
+                        "session_id": session['session_id'],
+                        "course_id": course_id,
+                        "faculty_id": faculty_id,
+                        "start_time": current_session['start_time'],
+                        "duration": current_session['duration'],
+                        "status": current_session['status'],
+                        "chats.user_id": user_id
+                    },
+                    {
+                        "$push": {
+                            "chats.$.messages": {
+                                "prompt": prompt,
+                                "response": assistant_response,
+                                "timestamp": datetime.utcnow()
+                            }
+                        }
+                    }
+                )
+
+                # If no existing chat object for the user, create a new one
+                if live_chat_sessions_collection.find_one({
+                    "session_id": session['session_id'],
+                    "course_id": course_id,
+                    "faculty_id": faculty_id,
+                    "start_time": current_session['start_time'],
+                    "duration": current_session['duration'],
+                    "status": current_session['status'],
+                    "chats.user_id": user_id
+                }) is None:
+                    live_chat_sessions_collection.update_one(
+                        {
+                            "session_id": session['session_id'],
+                            "course_id": course_id,
+                            "faculty_id": faculty_id,
+                            "start_time": current_session['start_time'],
+                            "duration": current_session['duration'],
+                            "status": current_session['status']
+                        },
+                        {
+                            "$push": {
+                                "chats": {
+                                    "user_id": user_id,
+                                    "messages": [
+                                        {
+                                            "prompt": prompt,
+                                            "response": assistant_response,
+                                            "timestamp": datetime.utcnow()
+                                        }
+                                    ]
+                                }
+                            }
+                        },
+                        upsert=True
+                    )
+            except Exception as db_error:
+                st.error(f"Error saving chat history: {str(db_error)}")
+        except Exception as e:
+            st.error(f"Error processing message: {str(e)}")

pre_class_analytics3.py

@@ -0,0 +1,499 @@
+from datetime import datetime
+import json
+from bson import ObjectId
+import typing_extensions as typing
+import google.generativeai as genai
+from typing import List, Dict, Any
+import numpy as np
+from collections import defaultdict
+
+from dotenv import load_dotenv
+import os
+import pymongo
+from pymongo import MongoClient
+
+load_dotenv()
+GEMINI_API_KEY = os.getenv("GEMINI_KEY")
+
+class NovaScholarAnalytics:
+    def __init__(self, model_name: str = "gemini-1.5-flash"):
+        genai.configure(api_key=GEMINI_API_KEY)
+        self.model = genai.GenerativeModel(model_name)
+    
+    def _preprocess_chat_histories(self, chat_histories: List[Dict]) -> List[Dict]:
+        # Code 2: 
+        """Preprocess chat histories to focus on relevant information."""
+        processed = []
+        
+        for chat in chat_histories:
+            # Convert ObjectId to string if it's an ObjectId
+            user_id = str(chat["user_id"]["$oid"]) if isinstance(chat["user_id"], dict) and "$oid" in chat["user_id"] else str(chat["user_id"])
+            
+            try:
+                processed_chat = {
+                    "user_id": user_id,
+                    "messages": [
+                        {
+                            "prompt": msg["prompt"],
+                            "response": msg["response"]
+                        }
+                        for msg in chat["messages"]
+                    ]
+                }
+                processed.append(processed_chat)
+                print(f"Successfully processed chat for user: {user_id}")
+            except Exception as e:
+                print(f"Error processing chat for user: {user_id}")
+                print(f"Error details: {str(e)}")
+                continue
+                
+        return processed
+    
+    def _create_analytics_prompt(self, chat_histories: List[Dict], all_topics: List[str]) -> str:
+        """Creates a structured prompt for Gemini to analyze chat histories."""
+        return f"""Analyze the provided student chat histories for a university course and generate concise, actionable analytics WITH EVIDENCE.
+
+        Context:
+        - Chat histories: {json.dumps(chat_histories, indent=2)}
+        - These are pre-class interactions between students and an AI tutor
+        - Topics covered: {', '.join(all_topics)}
+
+        Your task is to provide analytics with supporting evidence from the chat histories.
+
+        Output Format (strictly follow this JSON structure):
+        {{
+        "topic_wise_insights": [
+            {{
+            "topic": "<string>",
+            "struggling_percentage": <number between 0 and 1>,
+            "evidence": {{
+                "calculation": "Explain how struggling_percentage was calculated",
+                "supporting_messages": [
+                    {{
+                        "user_id": "<string>",
+                        "message": "<string>",
+                        "reasoning": "Why this message indicates struggling"
+                    }}
+                ]
+            }},
+            "key_issues": ["<string>"],
+            "key_misconceptions": ["<string>"],
+            "evidence_for_issues": [
+                {{
+                    "issue": "<string>",
+                    "supporting_messages": [
+                        {{
+                            "user_id": "<string>",
+                            "message": "<string>"
+                        }}
+                    ]
+                }}
+            ]
+            }}
+        ],
+        "ai_recommended_actions": [
+            {{
+            "action": "<string>",
+            "priority": "high|medium|low",
+            "reasoning": "<string>",
+            "evidence": {{
+                "supporting_messages": [
+                    {{
+                        "user_id": "<string>",
+                        "message": "<string>",
+                        "relevance": "Why this message supports the recommendation"
+                    }}
+                ],
+                "pattern_description": "Description of the pattern observed in chat histories"
+            }},
+            "expected_outcome": "<string>"
+            }}
+        ],
+        "student_analytics": [
+            {{
+            "student_id": "<string>",
+            "engagement_metrics": {{
+                "participation_level": <number between 0 and 1>,
+                "concept_understanding": "strong|moderate|needs_improvement",
+                "question_quality": "advanced|intermediate|basic"
+            }},
+            "evidence": {{
+                "participation_calculation": "Explain how participation_level was calculated",
+                "understanding_evidence": [
+                    {{
+                        "message": "<string>",
+                        "analysis": "Why this indicates their understanding level"
+                    }}
+                ],
+                "question_quality_evidence": [
+                    {{
+                        "question": "<string>",
+                        "analysis": "Why this question is classified at this level"
+                    }}
+                ]
+            }},
+            "struggling_topics": ["<string>"],
+            "personalized_recommendation": "<string>"
+            }}
+        ]
+        }}
+
+        Guidelines for Analysis:
+        1. For every insight, recommendation, or metric, provide specific evidence from the chat histories
+        2. Explain calculations (e.g., how struggling_percentage was derived)
+        3. Include relevant message excerpts that support each conclusion
+        4. For recommendations, show the pattern of student interactions that led to that recommendation
+        5. When analyzing question quality or understanding, provide reasoning for the classification
+        
+        The response must adhere strictly to the above JSON structure, with all fields populated appropriately."""
+
+    def _validate_analytics_with_evidence(self, initial_analytics: Dict) -> Dict:
+        """Validate the initial analytics by checking evidence."""
+        validation_prompt = f"""Review and validate the following analytics based on the provided evidence.
+        
+        Analytics to validate: {json.dumps(initial_analytics, indent=2)}
+        
+        For each section:
+        1. Verify if the evidence supports the conclusions
+        2. Check if calculations (percentages, metrics) are justified by the data
+        3. Validate if recommendations are supported by patterns in the chat history
+        
+        Return a JSON with the same structure, but only include insights/recommendations that have strong supporting evidence.
+        For any removed items, include them in a separate "insufficient_evidence" section with explanation."""
+        
+        try:
+            validation_response = self.model.generate_content(
+                validation_prompt,
+                generation_config=genai.GenerationConfig(
+                    response_mime_type="application/json",
+                    temperature=0.1
+                )
+            )
+            
+            validated_analytics = json.loads(validation_response.text)
+            return validated_analytics
+            
+        except Exception as e:
+            print(f"Error in validation: {str(e)}")
+            return initial_analytics
+
+    def _enrich_analytics(self, analytics: Dict) -> Dict:
+        """Add derived insights and metrics to the validated analytics."""
+        try:
+            # Calculate class distribution
+            total_students = len(analytics.get("student_insights", []))
+            performance_distribution = defaultdict(int)
+            
+            for student in analytics.get("student_insights", []):
+                metrics = student.get("engagement_metrics", {})
+                understanding = metrics.get("concept_understanding", "moderate")
+                
+                if understanding == "strong":
+                    performance_distribution["high_performers"] += 1
+                elif understanding == "needs_improvement":
+                    performance_distribution["at_risk"] += 1
+                else:
+                    performance_distribution["average_performers"] += 1
+            
+            # Convert to percentages
+            class_distribution = {
+                level: count/total_students if total_students > 0 else 0
+                for level, count in performance_distribution.items()
+            }
+            
+            # Calculate overall engagement
+            engagement_sum = sum(
+                student.get("engagement_metrics", {}).get("participation_level", 0)
+                for student in analytics.get("student_insights", [])
+            )
+            overall_engagement = engagement_sum / total_students if total_students > 0 else 0
+            
+            # Identify critical topics (those with high struggling percentage)
+            critical_topics = [
+                topic["topic"]
+                for topic in analytics.get("topic_wise_insights", [])
+                if topic.get("struggling_percentage", 0) > 0.7  # 70% threshold
+            ]
+            
+            # Identify students needing intervention
+            immediate_attention = []
+            monitoring_required = []
+            
+            for student in analytics.get("student_insights", []):
+                student_id = student.get("student_id")
+                metrics = student.get("engagement_metrics", {})
+                
+                # Check for immediate attention needed
+                if (metrics.get("concept_understanding") == "needs_improvement" or
+                    metrics.get("participation_level", 0) < 0.3 or  # Less than 30% participation
+                    len(student.get("struggling_topics", [])) > 2):  # Struggling with more than 2 topics
+                    immediate_attention.append(student_id)
+                # Check for monitoring
+                elif (metrics.get("concept_understanding") == "moderate" or
+                    metrics.get("participation_level", 0) < 0.5):  # Less than 50% participation
+                    monitoring_required.append(student_id)
+            
+            # Add enriched data to analytics
+            analytics["course_health"] = {
+                "overall_engagement": overall_engagement,
+                "critical_topics": critical_topics,
+                "class_distribution": class_distribution
+            }
+            
+            analytics["intervention_metrics"] = {
+                "immediate_attention_needed": immediate_attention,
+                "monitoring_required": monitoring_required
+            }
+            
+            # Add evidence for enriched metrics
+            analytics["course_health"]["evidence"] = {
+                "engagement_calculation": f"Calculated from average participation level of {total_students} students",
+                "critical_topics_criteria": "Topics where over 70% of students are struggling",
+                "distribution_calculation": "Based on concept understanding levels from student metrics"
+            }
+            
+            analytics["intervention_metrics"]["evidence"] = {
+                "immediate_attention_criteria": "Students with low understanding, participation < 30%, or >2 struggling topics",
+                "monitoring_criteria": "Students with moderate understanding or participation < 50%"
+            }
+            
+            return analytics
+            
+        except Exception as e:
+            print(f"Error enriching analytics: {str(e)}")
+            return analytics  # Return original analytics if enrichment fails
+
+    def generate_analytics(self, chat_histories: List[Dict], all_topics: List[str]) -> Dict:
+        """Main method to generate analytics with evidence-based validation."""
+        try:
+            if not chat_histories or not all_topics:
+                print("Missing required input data")
+                return self._fallback_analytics()
+
+            try:
+                processed_histories = self._preprocess_chat_histories(chat_histories)
+                print("Successfully preprocessed chat histories")
+            except Exception as preprocess_error:
+                print(f"Error in preprocessing: {str(preprocess_error)}")
+                return self._fallback_analytics()
+            
+            try:
+                prompt = self._create_analytics_prompt(processed_histories, all_topics)
+                print("Successfully created prompt")
+                print("Prompt preview:", prompt[:200] + "...") # Print first 200 chars
+            except Exception as prompt_error:
+                print(f"Error in prompt creation: {str(prompt_error)}")
+                return self._fallback_analytics()
+            
+            # Generate initial analytics with evidence
+            # prompt = self._create_analytics_prompt(chat_histories, all_topics)
+            response = self.model.generate_content(
+                prompt,
+                generation_config=genai.GenerationConfig(
+                    response_mime_type="application/json",
+                    temperature=0.15
+                )
+            )
+            print(response.text)
+            
+            if not response.text:
+                print("Empty response from Gemini")
+                return self._fallback_analytics()
+            
+            # Parse initial analytics
+            # initial_analytics = self._process_gemini_response(response.text)
+            initial_analytics2 = json.loads(response.text)
+            print("Initial analytics:", initial_analytics2)
+            # print("Initial analytics type:", type(initial_analytics2))
+            # print("Moving to validation...")
+            
+            # Validate analytics using evidence
+            validated_analytics = self._validate_analytics_with_evidence(initial_analytics2)
+            
+            # # Enrich with additional metrics
+            final_analytics = self._enrich_analytics(validated_analytics)
+            
+            return final_analytics
+            
+        except Exception as e:
+            print(f"Error generating analytics: {str(e)}")
+            return self._fallback_analytics()
+
+    def _fallback_analytics(self) -> Dict:
+        """Provide fallback analytics with explanation."""
+        return {
+            "topic_insights": [],
+            "student_insights": [],
+            "recommended_actions": [
+                {
+                    "action": "Review analytics generation process",
+                    "priority": "high",
+                    "target_group": "system_administrators",
+                    "reasoning": "Analytics generation failed",
+                    "expected_impact": "Restore analytics functionality",
+                    "evidence": {
+                        "error": "Analytics generation failed to complete"
+                    }
+                }
+            ],
+            "course_health": {
+                "overall_engagement": 0,
+                "critical_topics": [],
+                "class_distribution": {
+                    "high_performers": 0,
+                    "average_performers": 0,
+                    "at_risk": 0
+                }
+            },
+            "intervention_metrics": {
+                "immediate_attention_needed": [],
+                "monitoring_required": []
+            }
+        }
+    def _process_gemini_response(self, response: str) -> Dict:
+        print("Entered here")
+        try:
+            analytics = json.loads(response, object_hook=json_serializer)
+            if not isinstance(analytics, dict):
+                raise ValueError("Invalid response format")
+            return analytics
+        except Exception as e:
+            print(f"Error processing Gemini response: {str(e)}")
+            return self._fallback_analytics()
+
+load_dotenv()
+MONGODB_URI = os.getenv("MONGO_URI")
+from file_upload_vectorize import model
+import streamlit as st
+
+def extract_topics_from_materials(session_id):
+    """Extract topics from pre-class materials"""
+    materials = resources_collection.find({"session_id": session_id})
+    texts = ""
+    if materials:
+        for material in materials:
+            if 'text_content' in material:
+                text = material['text_content']
+                texts += text + "\n"
+            else:
+                st.warning("No text content found in the material.")
+                return
+    else:
+        st.error("No pre-class materials found for this session.")
+        return
+
+    if texts:
+        context_prompt = f"""
+        Task: Extract Comprehensive Topics in a List Format
+        You are tasked with analyzing the provided text content and extracting a detailed, flat list of topics.
+
+        Instructions:
+        Identify All Topics: Extract a comprehensive list of all topics, subtopics, and indirect topics present in the provided text content. This list should include:
+
+        Overarching themes
+        Main topics
+        Subtopics and their sub-subtopics
+        Indirectly related topics
+        Flat List Format: Provide a flat list where each item is a topic. Ensure topics at all levels (overarching, main, sub, sub-sub, indirect) are represented as individual entries in the list.
+
+        Be Exhaustive: Ensure the response captures every topic, subtopic, and indirectly related concept comprehensively.
+
+        Output Requirements:
+        Use this structure:
+        {{
+            "topics": [
+                "Topic 1",
+                "Topic 2",
+                "Topic 3",
+                ...
+            ]
+        }}
+        Do Not Include: Do not include backticks, hierarchical structures, or the word 'json' in your response.
+
+        Content to Analyze:
+        {texts}
+        """
+        try:
+            # response = model.generate_content(context_prompt, generation_config=genai.GenerationConfig(response_mime_type="application/json", response_schema=list[Topics]))
+            response = model.generate_content(context_prompt, generation_config=genai.GenerationConfig(temperature=0.3))
+            if not response or not response.text:
+                st.error("Error extracting topics from materials.")
+                return
+            
+            topics = response.text
+            return topics
+        except Exception as e:
+            st.error(f"Error extracting topics: {str(e)}")
+            return None
+    else:
+        st.error("No text content found in the pre-class materials.")
+        return None
+
+
+def get_chat_history(user_id, session_id):
+    query = {
+        "user_id": ObjectId(user_id),
+        "session_id": session_id,
+        "timestamp": {"$lte": datetime.utcnow()}
+    }
+    result = chat_history_collection.find(query)
+    return list(result)
+
+def json_serializer(obj):
+    if isinstance(obj, ObjectId):
+        return str(obj)
+    raise TypeError(f"Type {type(obj)} not serializable")
+
+if __name__ == "__main__":
+    client = MongoClient(MONGODB_URI)
+    db = client["novascholar_db"]
+    chat_history_collection = db["chat_history"]
+    resources_collection = db["resources"]
+    session_id = "S104"
+    # Connect to MongoDB
+    user_ids = chat_history_collection.distinct("user_id", {"session_id": session_id})
+    # Debug print 2: Check user_ids
+    print("Found user_ids:", user_ids)
+    
+    all_chat_histories = []
+    for user_id in user_ids:
+        result = get_chat_history(user_id, session_id)
+        # Debug print 3: Check each chat history result
+        print(f"Chat history for user {user_id}:", "Found" if result else "Not found")
+        if result:
+            for record in result:
+                chat_history = {
+                    "user_id": record["user_id"],  # Convert ObjectId to string
+                    "session_id": record["session_id"],
+                    "messages": record["messages"]
+                }
+                all_chat_histories.append(chat_history)
+
+    print(all_chat_histories)
+
+    # Export all chat histories to a JSON file
+    # Path: sample_files/chat_histories.json
+    # with open("sample_files/all_chat_histories3.json", "w") as file:
+    #     json.dump(all_chat_histories, file, indent=2)
+
+    # Debug print 4: Check chat histories
+    print("Total chat histories collected:", len(all_chat_histories))
+
+    # Extract topics with debug print
+    # topics = extract_topics_from_materials(session_id)
+    # # Export extracted topics to a JSON file
+    # with open("sample_files/extracted_topics.json", "w") as file:
+    #     json.dump(topics, file, indent=2)
+
+    # Load extracted topics from JSON file
+    with open("sample_files/extracted_topics.json", "r") as file:
+        topics = json.load(file)
+    # Debug print 5: Check topics
+    print("Extracted topics:", topics)
+    
+    # Generate analytics
+
+    analytics_generator = NovaScholarAnalytics()
+    analytics = analytics_generator.generate_analytics(all_chat_histories, topics)
+    # Debug print 6: Check generated analytics
+    print("Generated Analytics:", analytics)

session_page.py

@@ -30,6 +30,8 @@ import numpy as np
 import re
 from analytics import derive_analytics, create_embeddings, cosine_similarity
 from bs4 import BeautifulSoup
+import streamlit.components.v1 as components
+from live_chat_feature import display_live_chat_interface 
 
 load_dotenv()
 MONGO_URI = os.getenv('MONGO_URI')
@@ -39,6 +41,9 @@ client = MongoClient(MONGO_URI)
 db = client["novascholar_db"]
 polls_collection = db["polls"]
 subjective_tests_collection = db["subjective_tests"]
+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"]
 
 def get_current_user():
@@ -132,66 +137,6 @@ def get_current_user():
     # user = get_current_user()
     
 def display_preclass_content(session, student_id, course_id):
-    # """Display pre-class materials for a session"""
-    # st.subheader("Pre-class Materials")
-    # print("Session ID is: ", session['session_id'])
-    # # Display pre-class materials
-    # materials = resources_collection.find({"session_id": session['session_id']})
-    # for material in materials:
-    #     with st.expander(f"{material['file_name']} ({material['material_type'].upper()})"):
-    #         file_type = material.get('file_type', 'unknown')
-    #         if file_type == 'application/pdf':
-    #             st.markdown(f"📑 [Open PDF Document]({material['file_name']})")
-    #             if st.button("View PDF", key=f"view_pdf_{material['_id']}"):
-    #                 st.text_area("PDF Content", material['text_content'], height=300)
-    #             if st.button("Download PDF", key=f"download_pdf_{material['_id']}"):
-    #                 st.download_button(
-    #                     label="Download PDF",
-    #                     data=material['file_content'],
-    #                     file_name=material['file_name'],
-    #                     mime='application/pdf'
-    #                 )
-    #             if st.button("Mark PDF as Read", key=f"pdf_{material['_id']}"):
-    #                 create_notification("PDF marked as read!", "success")
-    #         elif file_type == 'text/plain':
-    #             st.markdown(f"📄 [Open Text Document]({material['file_name']})")
-    #             if st.button("View Text", key=f"view_text_{material['_id']}"):
-    #                 st.text_area("Text Content", material['text_content'], height=300)
-    #             if st.button("Download Text", key=f"download_text_{material['_id']}"):
-    #                 st.download_button(
-    #                     label="Download Text",
-    #                     data=material['file_content'],
-    #                     file_name=material['file_name'],
-    #                     mime='text/plain'
-    #                 )
-    #             if st.button("Mark Text as Read", key=f"text_{material['_id']}"):
-    #                 create_notification("Text marked as read!", "success")
-    #         elif file_type == 'application/vnd.openxmlformats-officedocument.wordprocessingml.document':
-    #             st.markdown(f"📄 [Open Word Document]({material['file_name']})")
-    #             if st.button("View Word", key=f"view_word_{material['_id']}"):
-    #                 st.text_area("Word Content", material['text_content'], height=300)
-    #             if st.button("Download Word", key=f"download_word_{material['_id']}"):
-    #                 st.download_button(
-    #                     label="Download Word",
-    #                     data=material['file_content'],
-    #                     file_name=material['file_name'],
-    #                     mime='application/vnd.openxmlformats-officedocument.wordprocessingml.document'
-    #                 )
-    #             if st.button("Mark Word as Read", key=f"word_{material['_id']}"):
-    #                 create_notification("Word document marked as read!", "success")
-    #         elif file_type == 'application/vnd.openxmlformats-officedocument.presentationml.presentation':
-    #             st.markdown(f"📊 [Open PowerPoint Presentation]({material['file_name']})")
-    #             if st.button("View PowerPoint", key=f"view_pptx_{material['_id']}"):
-    #                 st.text_area("PowerPoint Content", material['text_content'], height=300)
-    #             if st.button("Download PowerPoint", key=f"download_pptx_{material['_id']}"):
-    #                 st.download_button(
-    #                     label="Download PowerPoint",
-    #                     data=material['file_content'],
-    #                     file_name=material['file_name'],
-    #                     mime='application/vnd.openxmlformats-officedocument.presentationml.presentation'
-    #                 )
-    #             if st.button("Mark PowerPoint as Read", key=f"pptx_{material['_id']}"):
-    #                 create_notification("PowerPoint presentation marked as read!", "success")
     """Display pre-class materials for a session including external resources"""
     st.subheader("Pre-class Materials")
     print("Session ID is: ", session['session_id'])
@@ -203,7 +148,7 @@ def display_preclass_content(session, student_id, course_id):
         file_type = material.get('file_type', 'unknown')
         
         # Handle external resources
-        if file_type == 'external':
+        if file_type == 'external' or file_type == 'video':
             with st.expander(f"📌 {material['file_name']}"):
                 st.markdown(f"Source: [{material['source_url']}]({material['source_url']})")
                 
@@ -596,6 +541,247 @@ def display_preclass_content(session, student_id, course_id):
                                 # except Exception as db_error:
                                 #     st.error(f"Error saving submission: {str(db_error)}")
 
+import requests
+
+def fetch_youtube_video_title(video_url):
+    """Fetch the title of a YouTube video using the YouTube Data API"""
+    api_key = os.getenv("YOUTUBE_API_KEY")
+    video_id = extract_youtube_id(video_url)
+    if not video_id:
+        return None
+    
+    url = f"https://www.googleapis.com/youtube/v3/videos?id={video_id}&key={api_key}&part=snippet"
+    response = requests.get(url)
+    if response.status_code == 200:
+        data = response.json()
+        if "items" in data and len(data["items"]) > 0:
+            return data["items"][0]["snippet"]["title"]
+    return None
+
+def upload_video_source(course_id, session_id, video_url):
+    """Upload video source and its transcript to the database"""
+    # Fetch video title
+    video_title = fetch_youtube_video_title(video_url)
+    if not video_title:
+        st.error("Could not fetch the video title from the provided YouTube URL.")
+        return
+    # print("Video Title: ", video_title)
+    # Extract transcript from YouTube video
+    transcript = extract_youtube_transcript(video_url)
+    
+    if not transcript:
+        st.error("Could not extract transcript from the provided YouTube URL.")
+        return
+
+    # Create resource document
+    resource_data = {
+        "_id": ObjectId(),
+        "course_id": course_id,
+        "session_id": session_id,
+        "file_name": video_title,
+        "file_type": "video",
+        "text_content": transcript,
+        "material_type": "video",
+        "source_url": video_url,
+        "uploaded_at": datetime.utcnow()
+    }    
+    # Check if resource already exists
+    existing_resource = resources_collection.find_one({
+        "session_id": session_id,
+        "source_url": video_url
+    })
+    
+    if existing_resource:
+        st.warning("This video resource already exists.")
+        return existing_resource["_id"]
+    
+    # Insert new resource
+    resources_collection.insert_one(resource_data)
+    resource_id = resource_data["_id"]
+
+    # Update course document
+    courses_collection.update_one(
+        {
+            "course_id": course_id,
+            "sessions.session_id": session_id
+        },
+        {
+            "$push": {"sessions.$.pre_class.resources": resource_id}
+        }
+    )
+    # Create vector store for the transcript
+    create_vector_store(transcript, resource_id)
+    
+    # st.success("Video source uploaded successfully!")
+    return resource_id
+
+def upload_preclass_materials(session_id, course_id):
+    """Upload pre-class materials and manage external resources for a session"""
+    st.subheader("Pre-class Materials Management")
+    
+    # Create tabs for different functionalities
+    upload_tab, external_tab = st.tabs(["Upload Materials", "External Resources"])
+    
+    with upload_tab:
+        # Original file upload functionality
+        uploaded_file = st.file_uploader("Upload Material", type=['txt', 'pdf', 'docx'])
+        if uploaded_file is not None:
+            with st.spinner("Processing document..."):
+                file_name = uploaded_file.name
+                file_content = extract_text_from_file(uploaded_file)
+                if file_content:
+                    material_type = st.selectbox("Select Material Type", ["pdf", "docx", "txt"])
+                    if st.button("Upload Material"):
+                        upload_resource(course_id, session_id, file_name, uploaded_file, material_type)
+                        st.success("Material uploaded successfully!")
+    
+    with external_tab:
+        # Fetch and display external resources
+        session_data = courses_collection.find_one(
+            {"course_id": course_id, "sessions.session_id": session_id},
+            {"sessions.$": 1}
+        )
+        
+        if session_data and session_data.get('sessions'):
+            session = session_data['sessions'][0]
+            external = session.get('external_resources', {})
+            
+            # Display web articles
+            if 'readings' in external:
+                st.subheader("Web Articles and Videos")
+                for reading in external['readings']:
+                    col1, col2 = st.columns([3, 1])
+                    with col1:
+                        st.markdown(f"**{reading['title']}**")
+                        st.markdown(f"Type: {reading['type']} | Est. time: {reading['estimated_read_time']}")
+                        st.markdown(f"URL: [{reading['url']}]({reading['url']})")
+                    with col2:
+                        if st.button("Extract Content", key=f"extract_{reading['url']}"):
+                            with st.spinner("Extracting content..."):
+                                content = extract_external_content(reading['url'], reading['type'])
+                                if content:
+                                    resource_id = upload_external_resource(
+                                        course_id,
+                                        session_id,
+                                        reading['title'],
+                                        content,
+                                        reading['type'].lower(),
+                                        reading['url']
+                                    )
+                                    st.success("Content extracted and stored successfully!")
+            
+            # Display books
+            if 'books' in external:
+                st.subheader("Recommended Books")
+                for book in external['books']:
+                    st.markdown(f"""
+                    **{book['title']}** by {book['author']}
+                    - ISBN: {book['isbn']}
+                    - Chapters: {book['chapters']}
+                    """)
+            
+            # Display additional resources
+            if 'additional_resources' in external:
+                st.subheader("Additional Resources")
+                for resource in external['additional_resources']:
+                    st.markdown(f"""
+                    **{resource['title']}** ({resource['type']})
+                    - {resource['description']}
+                    - URL: [{resource['url']}]({resource['url']})
+                    """)
+
+def extract_external_content(url, content_type):
+    """Extract content from external resources based on their type"""
+    try:
+        if content_type.lower() == 'video' and 'youtube.com' in url:
+            return extract_youtube_transcript(url)
+        else:
+            return extract_web_article(url)
+    except Exception as e:
+        st.error(f"Error extracting content: {str(e)}")
+        return None
+
+def extract_youtube_transcript(url):
+    """Extract transcript from YouTube videos"""
+    try:
+        # Extract video ID from URL
+        video_id = url.split('v=')[1].split('&')[0]
+        
+        # Get transcript
+        transcript = YouTubeTranscriptApi.get_transcript(video_id)
+        # Combine transcript text
+        full_text = ' '.join([entry['text'] for entry in transcript])
+        return full_text
+    except Exception as e:
+        st.error(f"Could not extract YouTube transcript: {str(e)}")
+        return None
+
+def extract_web_article(url):
+    """Extract text content from web articles"""
+    try:
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+        }
+        response = requests.get(url, headers=headers)
+        response.raise_for_status()
+        
+        soup = BeautifulSoup(response.text, 'html.parser')
+        
+        # Remove unwanted tags
+        for tag in soup(['script', 'style', 'nav', 'footer', 'header']):
+            tag.decompose()
+        
+        # Extract text from paragraphs
+        paragraphs = soup.find_all('p')
+        text_content = ' '.join([p.get_text().strip() for p in paragraphs])
+        
+        return text_content
+    except Exception as e:
+        st.error(f"Could not extract web article content: {str(e)}")
+        return None
+
+def upload_external_resource(course_id, session_id, title, content, content_type, source_url):
+    """Upload extracted external resource content to the database"""
+    resource_data = {
+        "_id": ObjectId(),
+        "course_id": course_id,
+        "session_id": session_id,
+        "file_name": f"{title} ({content_type})",
+        "file_type": "external",
+        "text_content": content,
+        "material_type": content_type,
+        "source_url": source_url,
+        "uploaded_at": datetime.utcnow()
+    }
+    
+    # Check if resource already exists
+    existing_resource = resources_collection.find_one({
+        "session_id": session_id,
+        "source_url": source_url
+    })
+    
+    if existing_resource:
+        return existing_resource["_id"]
+    
+    # Insert new resource
+    resources_collection.insert_one(resource_data)
+    resource_id = resource_data["_id"]
+    
+    # Update course document
+    courses_collection.update_one(
+        {
+            "course_id": course_id,
+            "sessions.session_id": session_id
+        },
+        {
+            "$push": {"sessions.$.pre_class.resources": resource_id}
+        }
+    )
+    
+    if content:
+        create_vector_store(content, resource_id)
+    
+    return resource_id
 
 def extract_youtube_id(url):
     """Extract YouTube video ID from URL"""
@@ -611,8 +797,75 @@ def extract_youtube_id(url):
             return None
     return None
 
+def display_live_presentation(session, user_type, course_id):
+    st.markdown("### Live Presentation")
+    
+    # Get active presentation
+    session_data = courses_collection.find_one(
+        {"course_id": course_id, "sessions.session_id": session['session_id']},
+        {"sessions.$": 1}
+    )
+    active_presentation = session_data["sessions"][0].get("in_class", {}).get("active_presentation")
+    
+    # Faculty Interface
+    if user_type == 'faculty':
+        if not active_presentation:
+            st.markdown("""
+                <style>
+                    .url-container {
+                        background-color: #f8f9fa;
+                        padding: 20px;
+                        border-radius: 10px;
+                        margin: 10px 0;
+                    }
+                    .button-container {
+                        display: flex;
+                        justify-content: space-between;
+                        margin-top: 10px;
+                    }
+                </style>
+            """, unsafe_allow_html=True)
+            
+            # URL input section
+            with st.container():
+                ppt_url = st.text_input("🔗 Enter Google Slides Presentation URL", 
+                                      placeholder="https://docs.google.com/presentation/...")
+                
+                if ppt_url:
+                    if st.button("▶️ Activate Presentation", 
+                               use_container_width=True):
+                        courses_collection.update_one(
+                            {"course_id": course_id, "sessions.session_id": session['session_id']},
+                            {"$set": {"sessions.$.in_class.active_presentation": ppt_url}}
+                        )
+                        st.success("✅ Presentation activated successfully!")
+                        st.rerun()
+        else:
+            # Display active presentation
+            st.markdown("#### 🎯 Active Presentation")
+            components.iframe(active_presentation, height=800)
+            
+            # Deactivate button
+            st.markdown("<div style='margin-top: 20px;'></div>", unsafe_allow_html=True)
+            if st.button("⏹️ Deactivate Presentation", 
+                        type="secondary",
+                        use_container_width=True):
+                courses_collection.update_one(
+                    {"course_id": course_id, "sessions.session_id": session['session_id']},
+                    {"$unset": {"sessions.$.in_class.active_presentation": ""}}
+                )
+                st.success("✅ Presentation deactivated successfully!")
+                st.rerun()
+    
+    # Student Interface
+    else:
+        if active_presentation:
+            st.markdown("#### 🎯 Active Presentation")
+            components.iframe(active_presentation, height=800)
+        else:
+            st.info("📝 No active presentations at this time.")
 
-def display_in_class_content(session, user_type):
+def display_in_class_content(session, user_type, course_id, user_id):
     # """Display in-class activities and interactions"""
     """Display in-class activities and interactions"""
     st.header("In-class Activities")
@@ -625,6 +878,11 @@ def display_in_class_content(session, user_type):
         live_polls.display_faculty_interface(session['session_id'])
     else:
         live_polls.display_student_interface(session['session_id'])
+    
+    display_live_chat_interface(session, user_id, course_id=course_id)
+
+    # Live Presentation Feature
+    display_live_presentation(session, user_type, course_id)
 
 def generate_random_assignment_id():
     """Generate a random integer ID for assignments"""
@@ -1412,7 +1670,7 @@ def convert_json_to_dict(json_str):
 # with open(r'topics.json', 'r') as file:
 #     topics = json.load(file)
 
-def get_preclass_analytics(session):
+def get_preclass_analytics(session, course_id):
     # Earlier Code:
     # """Get all user_ids from chat_history collection where session_id matches"""
     # user_ids = chat_history_collection.distinct("user_id", {"session_id": session['session_id']})
@@ -1534,11 +1792,16 @@ def get_preclass_analytics(session):
         print("Fallback analytics returned")  # Debug print 8
         return None
     else:
+        try:
+            courses_collection.update_one(
+                {"course_id": course_id, "sessions.session_id": session['session_id']},
+                {"$set": {"sessions.$.pre_class.analytics": analytics2}}
+            )
+        except Exception as e:
+            print("Error storing analytics:", str(e)) 
         return analytics2
 
 
-
-
 # Load Analytics from a JSON file
 # analytics = []
 # with open(r'new_analytics2.json', 'r') as file:
@@ -1559,7 +1822,7 @@ def display_preclass_analytics2(session, course_id):
     # Initialize or get analytics data from session state
     if 'analytics_data' not in st.session_state:
         # Add debug prints
-        analytics_data = get_preclass_analytics(session)
+        analytics_data = get_preclass_analytics(session, course)
         if analytics_data is None:
             st.info("Fetching new analytics data...")
         if analytics_data is None:
@@ -1962,173 +2225,7 @@ def display_session_analytics(session, course_id):
 #             Uploaded on: {material['uploaded_at'].strftime('%Y-%m-%d %H:%M')}
 #         """)
 
-def upload_preclass_materials(session_id, course_id):
-    """Upload pre-class materials and manage external resources for a session"""
-    st.subheader("Pre-class Materials Management")
-    
-    # Create tabs for different functionalities
-    upload_tab, external_tab = st.tabs(["Upload Materials", "External Resources"])
-    
-    with upload_tab:
-        # Original file upload functionality
-        uploaded_file = st.file_uploader("Upload Material", type=['txt', 'pdf', 'docx'])
-        if uploaded_file is not None:
-            with st.spinner("Processing document..."):
-                file_name = uploaded_file.name
-                file_content = extract_text_from_file(uploaded_file)
-                if file_content:
-                    material_type = st.selectbox("Select Material Type", ["pdf", "docx", "txt"])
-                    if st.button("Upload Material"):
-                        upload_resource(course_id, session_id, file_name, uploaded_file, material_type)
-                        st.success("Material uploaded successfully!")
-    
-    with external_tab:
-        # Fetch and display external resources
-        session_data = courses_collection.find_one(
-            {"course_id": course_id, "sessions.session_id": session_id},
-            {"sessions.$": 1}
-        )
-        
-        if session_data and session_data.get('sessions'):
-            session = session_data['sessions'][0]
-            external = session.get('external_resources', {})
-            
-            # Display web articles
-            if 'readings' in external:
-                st.subheader("Web Articles and Videos")
-                for reading in external['readings']:
-                    col1, col2 = st.columns([3, 1])
-                    with col1:
-                        st.markdown(f"**{reading['title']}**")
-                        st.markdown(f"Type: {reading['type']} | Est. time: {reading['estimated_read_time']}")
-                        st.markdown(f"URL: [{reading['url']}]({reading['url']})")
-                    with col2:
-                        if st.button("Extract Content", key=f"extract_{reading['url']}"):
-                            with st.spinner("Extracting content..."):
-                                content = extract_external_content(reading['url'], reading['type'])
-                                if content:
-                                    resource_id = upload_external_resource(
-                                        course_id,
-                                        session_id,
-                                        reading['title'],
-                                        content,
-                                        reading['type'].lower(),
-                                        reading['url']
-                                    )
-                                    st.success("Content extracted and stored successfully!")
-            
-            # Display books
-            if 'books' in external:
-                st.subheader("Recommended Books")
-                for book in external['books']:
-                    st.markdown(f"""
-                    **{book['title']}** by {book['author']}
-                    - ISBN: {book['isbn']}
-                    - Chapters: {book['chapters']}
-                    """)
-            
-            # Display additional resources
-            if 'additional_resources' in external:
-                st.subheader("Additional Resources")
-                for resource in external['additional_resources']:
-                    st.markdown(f"""
-                    **{resource['title']}** ({resource['type']})
-                    - {resource['description']}
-                    - URL: [{resource['url']}]({resource['url']})
-                    """)
-
-def extract_external_content(url, content_type):
-    """Extract content from external resources based on their type"""
-    try:
-        if content_type.lower() == 'video' and 'youtube.com' in url:
-            return extract_youtube_transcript(url)
-        else:
-            return extract_web_article(url)
-    except Exception as e:
-        st.error(f"Error extracting content: {str(e)}")
-        return None
-
-def extract_youtube_transcript(url):
-    """Extract transcript from YouTube videos"""
-    try:
-        # Extract video ID from URL
-        video_id = url.split('v=')[1].split('&')[0]
-        
-        # Get transcript
-        transcript = YouTubeTranscriptApi.get_transcript(video_id)
-        # Combine transcript text
-        full_text = ' '.join([entry['text'] for entry in transcript])
-        return full_text
-    except Exception as e:
-        st.error(f"Could not extract YouTube transcript: {str(e)}")
-        return None
-
-def extract_web_article(url):
-    """Extract text content from web articles"""
-    try:
-        headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
-        }
-        response = requests.get(url, headers=headers)
-        response.raise_for_status()
-        
-        soup = BeautifulSoup(response.text, 'html.parser')
-        
-        # Remove unwanted tags
-        for tag in soup(['script', 'style', 'nav', 'footer', 'header']):
-            tag.decompose()
-        
-        # Extract text from paragraphs
-        paragraphs = soup.find_all('p')
-        text_content = ' '.join([p.get_text().strip() for p in paragraphs])
-        
-        return text_content
-    except Exception as e:
-        st.error(f"Could not extract web article content: {str(e)}")
-        return None
 
-def upload_external_resource(course_id, session_id, title, content, content_type, source_url):
-    """Upload extracted external resource content to the database"""
-    resource_data = {
-        "_id": ObjectId(),
-        "course_id": course_id,
-        "session_id": session_id,
-        "file_name": f"{title} ({content_type})",
-        "file_type": "external",
-        "text_content": content,
-        "material_type": content_type,
-        "source_url": source_url,
-        "uploaded_at": datetime.utcnow()
-    }
-    
-    # Check if resource already exists
-    existing_resource = resources_collection.find_one({
-        "session_id": session_id,
-        "source_url": source_url
-    })
-    
-    if existing_resource:
-        return existing_resource["_id"]
-    
-    # Insert new resource
-    resources_collection.insert_one(resource_data)
-    resource_id = resource_data["_id"]
-    
-    # Update course document
-    courses_collection.update_one(
-        {
-            "course_id": course_id,
-            "sessions.session_id": session_id
-        },
-        {
-            "$push": {"sessions.$.pre_class.resources": resource_id}
-        }
-    )
-    
-    if content:
-        create_vector_store(content, resource_id)
-    
-    return resource_id
 
 def display_quiz_tab(student_id, course_id, session_id):
     """Display quizzes for students"""
@@ -2763,6 +2860,8 @@ def display_subjective_test_tab(student_id, course_id, session_id):
         print(f"Error in display_subjective_test_tab: {str(e)}", flush=True)
         st.error("An error occurred while loading the tests. Please try again later.")
     
+
+
 def display_subjective_analysis(test_id, student_id, context):
     """Display subjective test analysis to students and faculty"""
     try: