add session outline feature

.gitignore

@@ -19,4 +19,5 @@ topics.json
 new_analytics.json
 new_analytics2.json
 pre_class_analytics.py
-sample_files/
+sample_files/
+sample_script.py

live_chat_feature.py

@@ -20,7 +20,7 @@ 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")
+    st.markdown("#### Live Class Chat Session")
     
     # Initialize session states
     if 'chat_active' not in st.session_state:

live_polls.py

@@ -11,7 +11,7 @@ class LivePollFeature:
     
     def display_faculty_interface(self, session_id):
         """Display the faculty interface for managing polls"""
-        st.subheader("Live Polls Management")
+        st.markdown("#### Live Polls Management")
         
         # Create new poll
         with st.expander("Create New Poll", expanded=False):

rubrics.py

@@ -1,3 +1,4 @@
+from datetime import datetime
 import streamlit as st
 from pymongo import MongoClient
 from openai import OpenAI
@@ -5,10 +6,14 @@ from bson import ObjectId
 import json
 from dotenv import load_dotenv
 import os
+import google.generativeai as genai
 
 load_dotenv()
 MONGO_URI = os.getenv('MONGO_URI')
 OPENAI_API_KEY = os.getenv('OPENAI_KEY')
+GEMINI_API_KEY = os.getenv('GEMINI_KEY')
+genai.configure(api_key=GEMINI_API_KEY)
+model = genai.GenerativeModel("gemini-1.5-flash")
 
 client = MongoClient(MONGO_URI)
 db = client['novascholar_db']
@@ -17,12 +22,18 @@ rubrics_collection = db['rubrics']
 resources_collection = db['resources']
 courses_collection = db['courses']
 
-def generate_rubrics(api_key, session_title, outcome_description, taxonomy, pre_class_material):
+def generate_rubrics(session_title, outcomes, pre_class_material):
+    # Format outcomes for prompt
+    outcomes_text = "\n".join([
+        f"Outcome {i+1}:\n- Description: {outcome.get('outcome_description')}\n- Taxonomy Level: {outcome.get('bloom_taxanomy_level')}"
+        for i, outcome in enumerate(outcomes)
+    ])
+    
     prompt = f"""
-    You are an expert educational AI assistant specializing in instructional design. Generate a detailed rubric for the session titled "{session_title}". The rubric should be aligned with Bloom's Taxonomy level "{taxonomy}" and use numerical scoring levels (4,3,2,1) instead of descriptive levels. Use the following context:
+    You are an expert educational AI assistant specializing in instructional design. Generate a detailed rubric for the session titled "{session_title}". The rubric should cover multiple learning outcomes and use numerical scoring levels (4,3,2,1). Use the following context:
 
-    Session Outcome Description:
-    {outcome_description}
+    Session Outcomes Description:
+    {outcomes_text}
 
     Pre-class Material:
     {pre_class_material}
@@ -49,12 +60,13 @@ def generate_rubrics(api_key, session_title, outcome_description, taxonomy, pre_
     ]
 
     try:
-        client = OpenAI(api_key=api_key)
-        response = client.chat.completions.create(
-            model="gpt-4-0125-preview",
-            messages=messages
+        response = model.generate_content(
+            prompt,
+            generation_config=genai.GenerationConfig(
+                response_mime_type="application/json"
+            )
         )
-        return response.choices[0].message.content
+        return response.text
     except Exception as e:
         st.error(f"Failed to generate rubrics: {e}")
         return None
@@ -73,15 +85,24 @@ def display_rubrics_tab(session, course_id):
         
         # Extract session learning outcomes
         if 'session_learning_outcomes' in session_data and len(session_data['session_learning_outcomes']) > 0:
-            outcome = session_data['session_learning_outcomes'][0]
-            outcome_description = outcome.get('outcome_description', '')
-            taxonomy_level = outcome.get('bloom_taxonomy_level', '')
+            outcomes = session_data['session_learning_outcomes']
+            # outcome_description = outcome.get('outcome_description', None)
+            # taxonomy_level = outcome.get('bloom_taxonomy_level', None)
             
             # Display fetched information
             st.markdown("### Session Information")
             st.markdown(f"**Session Title:** {session['title']}")
-            st.markdown(f"**Learning Outcome:** {outcome_description}")
-            st.markdown(f"**Taxonomy Level:** {taxonomy_level}")
+            # st.markdown(f"**Learning Outcome:** {outcome_description}")
+            # if taxonomy_level:
+            #     st.markdown(f"**Taxonomy Level:** {taxonomy_level}")
+            # Display all learning outcomes
+            st.markdown("### Learning Outcomes:")
+            for i, outcome in enumerate(outcomes, 1):
+                st.markdown(f"""
+                **Outcome {i}:**
+                - Description: {outcome.get('outcome_description')}
+                - Taxonomy Level: {outcome.get('bloom_taxanomy_level')}
+                """)
 
             # Fetch pre-class material
             pre_class_material_docs = resources_collection.find({"session_id": session['session_id']})
@@ -89,10 +110,8 @@ def display_rubrics_tab(session, course_id):
 
             if st.button("Generate Rubric"):
                 rubric = generate_rubrics(
-                    OPENAI_API_KEY,
                     session['title'],
-                    outcome_description,
-                    taxonomy_level,
+                    outcomes,
                     pre_class_material
                 )
                 
@@ -102,10 +121,39 @@ def display_rubrics_tab(session, course_id):
                     rubric_data = {
                         "course_id": course_id,
                         "session_id": session['session_id'],
-                        "rubric": json.loads(rubric)
+                        "rubric": json.loads(rubric),
+                        "outcomes": outcomes,
+                        "created_at": datetime.now()
                     }
-                    rubrics_collection.insert_one(rubric_data)
-                    st.success("Rubric saved successfully!")
+                    # rubrics_collection.insert_one(rubric_data)
+                    # st.success("Rubric saved successfully!")
+                    # Check for existing rubric and update or insert
+                    existing_rubric = rubrics_collection.find_one({
+                        "session_id": session['session_id']
+                    })
+                    
+                    if existing_rubric:
+                        rubrics_collection.update_one(
+                            {"_id": existing_rubric["_id"]},
+                            {"$set": rubric_data}
+                        )
+                        st.success("Rubric updated successfully!")
+                    else:
+                        rubrics_collection.insert_one(rubric_data)
+                        st.success("Rubric saved successfully!")
+
+            # Display existing rubric if available
+            existing_rubric = rubrics_collection.find_one({
+                "session_id": session['session_id']
+            })
+            
+            if existing_rubric:
+                with st.expander("View Existing Rubric"):
+                    st.json(existing_rubric['rubric'])
+                    st.caption(f"Last updated: {existing_rubric['created_at'].strftime('%Y-%m-%d %H:%M:%S')}")
+                    
+                    if st.button("Generate New Rubric", key="new_rubric"):
+                        st.rerun()
         else:
             st.error("No learning outcomes found for this session")
     else:

session_page.py

@@ -1126,7 +1126,7 @@ def extract_youtube_id(url):
     return None
 
 def display_live_presentation(session, user_type, course_id):
-    st.markdown("### Live Presentation")
+    st.markdown("#### Live Presentation")
     
     # Get active presentation
     session_data = courses_collection.find_one(
@@ -1193,11 +1193,349 @@ def display_live_presentation(session, user_type, course_id):
         else:
             st.info("📝 No active presentations at this time.")
 
+
+def generate_session_outline(session_id, course_id):
+    """
+    Generate a comprehensive session outline based on pre-class materials, learning outcomes, and analytics.
+    """
+    try:
+        # Fetch session details
+        session_data = courses_collection.find_one(
+            {"course_id": course_id, "sessions.session_id": session_id},
+            {"sessions.$": 1}
+        )
+        
+        if not session_data or 'sessions' not in session_data:
+            st.error("Session data not found")
+            return None
+            
+        session = session_data['sessions'][0]
+        
+        # Fetch pre-class materials
+        materials = resources_collection.find({"session_id": session_id})
+        materials_context = ""
+        for material in materials:
+            if 'text_content' in material:
+                materials_context += f"\nMaterial: {material['file_name']}\n{material['text_content']}\n"
+        
+        # Get learning outcomes
+        learning_outcomes = session.get('session_learning_outcomes', [])
+        outcomes_text = "\n".join([
+            f"Outcome {i+1}: {outcome.get('outcome_description', '')}" 
+            for i, outcome in enumerate(learning_outcomes)
+        ])
+        
+        # Get analytics
+        analytics = session.get('pre_class', {}).get('analytics', {})
+        
+        # Craft the prompt for Gemini
+        prompt = f"""
+        As an expert educational planner, create a detailed session outline based on the following context:
+
+        SESSION INFORMATION:
+        Title: {session.get('title', '')}
+        Duration: 70 minutes
+
+        LEARNING OUTCOMES:
+        {outcomes_text}
+
+        PRE-CLASS MATERIALS SUMMARY:
+        {materials_context}
+
+        ANALYTICS INSIGHTS:
+        Struggling Topics: {[topic['topic'] for topic in analytics.get('topic_wise_insights', [])]}
+        Key Issues: {[topic.get('key_issues', []) for topic in analytics.get('topic_wise_insights', [])]}
+        Student Understanding: {analytics.get('course_health', {}).get('overall_engagement', 'N/A')}
+
+        Based on this context, create a detailed session outline that includes:
+
+        1. Opening (8-10 minutes):
+           - How to start the session
+           - Initial engagement activities
+           - Connection to pre-class materials
+
+        2. Main Activities (50 minutes):
+           - Sequence of learning activities
+           - Teaching strategies for struggling topics
+           - Interactive elements and discussions
+           - Time allocation for each activity
+
+        3. Closing (10-12 minutes):
+           - Assessment strategies
+           - Summary activities
+           - Preview of next session
+
+        4. Additional Considerations:
+           - Student engagement strategies
+           - Addressing identified misconceptions
+           - Integration of technology/tools
+           - Backup activities if needed
+
+        Format the response as a JSON object with these exact keys:
+        {{
+            "opening_activities": [{{
+                "activity": "string",
+                "duration": "string",
+                "purpose": "string",
+                "materials_needed": ["string"]
+            }}],
+            "main_activities": [{{
+                "activity": "string",
+                "duration": "string",
+                "learning_outcome_addressed": "string",
+                "teaching_strategy": "string",
+                "materials_needed": ["string"]
+            }}],
+            "closing_activities": [{{
+                "activity": "string",
+                "duration": "string",
+                "purpose": "string"
+            }}],
+            "contingency_plans": [{{
+                "scenario": "string",
+                "alternative_activity": "string"
+            }}]
+        }}
+        """
+        GEMINI_API_KEY = os.getenv("GEMINI_KEY")
+        genai.configure(api_key=GEMINI_API_KEY)
+        model = genai.GenerativeModel("gemini-1.5-flash")
+
+        # Generate response using Gemini
+        response = model.generate_content(
+            prompt,
+            generation_config=genai.GenerationConfig(
+                temperature=0.3,
+                response_mime_type="application/json"
+            )
+        )
+
+        if not response or not response.text:
+            st.error("No response received from Gemini")
+            return None
+
+        # Parse and validate the response
+        try:
+            outline = json.loads(response.text)
+            return outline
+        except json.JSONDecodeError as e:
+            st.error(f"Error parsing response: {str(e)}")
+            return None
+
+    except Exception as e:
+        st.error(f"Error generating session outline: {str(e)}")
+        return None
+
+def display_session_outline(session, outline, course_id):
+    """Display the generated session outline in a structured format"""
+    if not outline:
+        return
+
+    # Initialize session state for storing outline if not exists
+    if 'session_outline' not in st.session_state:
+        st.session_state.session_outline = None
+    
+    # Store the outline in session state
+    st.session_state.session_outline = outline
+
+    # Main Display
+    st.markdown("""
+    <style>
+    .session-section {
+        border-radius: 8px;
+        background-color: #f8f9fa;
+        margin: 15px 0;
+    }
+    .activity-item {
+        padding: 15px;
+        border-left: 4px solid #3b82f6;
+        margin: 10px 0;
+        background-color: white;
+        border-radius: 4px;
+    }
+    .section-title {
+        color: #1e3a8a;
+        font-size: 1.2rem;
+        font-weight: 600;
+        margin-bottom: 15px;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+
+    # st.markdown("### 📋 Session Outline")
+
+    # # Opening Activities
+    # st.markdown("#### 🎯 Opening Activities")
+    # for activity in outline["opening_activities"]:
+    #     with st.expander(f"{activity['activity']} ({activity['duration']})"):
+    #         st.markdown(f"**Purpose:** {activity['purpose']}")
+    #         st.markdown("**Materials Needed:**")
+    #         for material in activity["materials_needed"]:
+    #             st.markdown(f"- {material}")
+    st.markdown("#### 📋 Session Outline")
+    with st.expander("View Session Outline"):
+        # Opening Activities Section
+        # st.markdown('<div class="session-section">', unsafe_allow_html=True)
+        st.markdown("<div style='margin-top: 10px;'></div>", unsafe_allow_html=True)
+        st.markdown("###### 🎯 Opening Activities (8-10 minutes)")
+        for activity in outline["opening_activities"]:
+            st.markdown(f"""
+            <div class="activity-item">
+                <h6>{activity['activity']} ({activity['duration']})</h6>
+                <p><strong>Purpose:</strong> {activity['purpose']}</p>
+            </div>
+            """, unsafe_allow_html=True)
+        # st.markdown('</div>', unsafe_allow_html=True)
+
+        # Main Activities
+        # st.markdown("#### 📚 Main Activities")
+        # for activity in outline["main_activities"]:
+        #     with st.expander(f"{activity['activity']} ({activity['duration']})"):
+        #         st.markdown(f"**Learning Outcome:** {activity['learning_outcome_addressed']}")
+        #         st.markdown(f"**Teaching Strategy:** {activity['teaching_strategy']}")
+        #         st.markdown("**Materials Needed:**")
+        #         for material in activity["materials_needed"]:
+        #             st.markdown(f"- {material}")
+        # Main Activities Section
+        # st.markdown('<div class="session-section">', unsafe_allow_html=True)
+        st.markdown("<div style='margin-top: 10px;'></div>", unsafe_allow_html=True)
+        st.markdown("###### 📚 Main Activities (50 minutes)")
+        for activity in outline["main_activities"]:
+            st.markdown(f"""
+            <div class="activity-item">
+                <h6>{activity['activity']} ({activity['duration']})</h6>
+                <p><strong>Learning Outcome:</strong> {activity['learning_outcome_addressed']}</p>
+                <p><strong>Teaching Strategy:</strong> {activity['teaching_strategy']}</p>
+            </div>
+            """, unsafe_allow_html=True)
+        # st.markdown('</div>', unsafe_allow_html=True)
+
+        # Closing Activities
+        # st.markdown("#### 🎬 Closing Activities")
+        # for activity in outline["closing_activities"]:
+        #     with st.expander(f"{activity['activity']} ({activity['duration']})"):
+        #         st.markdown(f"**Purpose:** {activity['purpose']}")
+        # st.markdown('<div class="session-section">', unsafe_allow_html=True)
+        st.markdown("<div style='margin-top: 10px;'></div>", unsafe_allow_html=True)
+        st.markdown("###### 🎬 Closing Activities (10-12 minutes)")
+        for activity in outline["closing_activities"]:
+            st.markdown(f"""
+            <div class="activity-item">
+                <h6>{activity['activity']} ({activity['duration']})</h6>
+                <p><strong>Purpose:</strong> {activity['purpose']}</p>
+            </div>
+            """, unsafe_allow_html=True)
+        # st.markdown('</div>', unsafe_allow_html=True)
+
+        # Contingency Plans
+        # st.markdown("#### 🔄 Contingency Plans")
+        # for plan in outline["contingency_plans"]:
+        #     with st.expander(f"If: {plan['scenario']}"):
+        #         st.markdown(f"**Alternative Activity:** {plan['alternative_activity']}")
+        # st.markdown('<div class="session-section">', unsafe_allow_html=True)
+        st.markdown("<div style='margin-top: 10px;'></div>", unsafe_allow_html=True)
+        st.markdown("###### 🔄 Contingency Plans")
+        for plan in outline["contingency_plans"]:
+            st.markdown(f"""
+            <div class="activity-item">
+                <p><strong>If:</strong> {plan['scenario']}</p>
+                <p><strong>Alternative Activity:</strong> {plan['alternative_activity']}</p>
+            </div>
+            """, unsafe_allow_html=True)
+        # st.markdown('</div>', unsafe_allow_html=True)
+
+        # Add save/download options
+        if st.button("💾 Save Outline"):
+            try:
+                courses_collection.update_one(
+                    {"course_id": course_id, "sessions.session_id": session['session_id']},
+                    {"$set": {"sessions.$.session_outline": st.session_state.session_outline}}
+                )
+                st.success("Outline saved successfully!")
+            except Exception as e:
+                st.error(f"Error saving outline: {str(e)}")
+
+        # Download option
+        if st.download_button(
+            "📥 Download Outline",
+            data=json.dumps(st.session_state.session_outline, indent=2),
+            file_name="session_outline.json",
+            mime="application/json"
+        ):
+            st.success("Outline downloaded successfully!")
+
+
 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")
+    st.markdown("### In-class Activities")
     
+    # Check if session outline exists in the database
+    # session_data = courses_collection.find_one(
+    #     {"course_id": course_id, "sessions.session_id": session['session_id']},
+    #     {"sessions.$": 1}
+    # )
+    # # Initialize session state for storing outline if not exists
+    # if 'session_outline' not in st.session_state:
+    #     if session_data and session_data.get('sessions'):
+    #         session_outline = session_data['sessions'][0].get('session_outline')
+    #         if session_outline:
+    #             st.session_state.session_outline = session_outline
+    #             display_session_outline(session, session_outline, course_id)
+    #         else: 
+    #             st.session_state.session_outline = None
+
+    # Initialize session state for outline
+    if 'session_outline' not in st.session_state:
+        st.session_state.session_outline = None
+
+    # Check if session outline exists in the database
+    try:
+        # Debug log
+        # st.write("Fetching session outline from database...")
+        
+        session_data = courses_collection.find_one(
+            {
+                "course_id": course_id,
+                "sessions.session_id": session['session_id']
+            },
+            {"sessions.$": 1}
+        )
+
+        if session_data and session_data.get('sessions'):
+            current_session = session_data['sessions'][0]
+            stored_outline = current_session.get('session_outline')
+            
+            if stored_outline:
+                # st.write("Found existing session outline")
+                st.session_state.session_outline = stored_outline
+            else:
+                st.write("No existing session outline found")
+                st.session_state.session_outline = None
+        
+    except Exception as e:
+        st.error(f"Error fetching session outline: {e}")
+        st.session_state.session_outline = None
+
+    if user_type == 'faculty':
+        # st.markdown("<div style='margin-top: 10px;'></div>", unsafe_allow_html=True)
+        if not st.session_state.session_outline: 
+            st.markdown("#### Session Outline")
+            if st.button("Generate a Session Outline"):
+                with st.spinner("Generating session outline..."):
+                    outline = generate_session_outline(session['session_id'], course_id)
+                    if outline:
+                        display_session_outline(session, outline, course_id)
+                        st.rerun()
+                        print("Session outline is: ", outline)
+                        # Save outline to database
+                        # courses_collection.update_one(
+                        #     {"course_id": course_id, "sessions.session_id": session['session_id']},
+                        #     {"$set": {"sessions.$.session_outline": outline}}
+                        # )
+        else:
+            display_session_outline(session, st.session_state.session_outline, course_id)
+
     # Initialize Live Polls feature
     live_polls = LivePollFeature()
     
@@ -1212,6 +1550,25 @@ def display_in_class_content(session, user_type, course_id, user_id):
     # Live Presentation Feature
     display_live_presentation(session, user_type, course_id)
 
+def get_current_context(session):
+    """Get current context from session outline and materials"""
+    context = ""
+    
+    # Get context from session outline
+    if st.session_state.session_outline:
+        outline = st.session_state.session_outline
+        current_activities = outline.get("main_activities", [])
+        for activity in current_activities:
+            context += f"{activity['activity']} - {activity['learning_outcome_addressed']}\n"
+    
+    # Get context from materials
+    materials = resources_collection.find({"session_id": session['session_id']})
+    for material in materials:
+        if 'text_content' in material:
+            context += material['text_content'] + "\n"
+    
+    return context
+
 def generate_random_assignment_id():
     """Generate a random integer ID for assignments"""
     return random.randint(100000, 999999)