add resource gen in course generation

.gitignore

@@ -18,4 +18,5 @@ course_creation.py
 topics.json
 new_analytics.json
 new_analytics2.json
-pre_class_analytics.py
+pre_class_analytics.py
+sample_files/

app.py

@@ -15,7 +15,7 @@ from werkzeug.security import generate_password_hash, check_password_hash
 import os
 from openai import OpenAI
 from dotenv import load_dotenv
-from create_course import create_course, courses_collection, generate_perplexity_response, PERPLEXITY_API_KEY
+from create_course2 import create_course, courses_collection, generate_perplexity_response, generate_session_resources, PERPLEXITY_API_KEY, validate_course_plan
 import json
 from bson import ObjectId
 client = OpenAI(api_key=os.getenv("OPENAI_KEY"))
@@ -653,14 +653,206 @@ def register_page():
                 st.success(f"Analyst registered successfully! Your username is: {username}")
 
 # Create Course feature
+# def create_course_form2(faculty_name, faculty_id):
+#     """Display enhanced form to create a new course with AI-generated content"""
+#     st.title("Create New Course")
+    
+#     if 'course_plan' not in st.session_state:
+#         st.session_state.course_plan = None
+#     if 'edit_mode' not in st.session_state:
+#         st.session_state.edit_mode = False
+
+#     # Initial Course Creation Form
+#     if not st.session_state.course_plan:
+#         with st.form("initial_course_form"):
+#             col1, col2 = st.columns(2)
+#             with col1:
+#                 course_name = st.text_input("Course Name", placeholder="e.g., Introduction to Computer Science")
+#                 faculty_info = st.text_input("Faculty", value=faculty_name, disabled=True)
+#             with col2:
+#                 duration_weeks = st.number_input("Duration (weeks)", min_value=1, max_value=16, value=12)
+#                 start_date = st.date_input("Start Date")
+            
+#             generate_button = st.form_submit_button("Generate Course Structure", use_container_width=True)
+            
+#             if generate_button and course_name:
+#                 with st.spinner("Generating course structure..."):
+#                     try:
+#                         course_plan = generate_perplexity_response(PERPLEXITY_API_KEY, course_name)
+#                         # print(course_plan)
+#                         st.session_state.course_plan = json.loads(course_plan)
+#                         st.session_state.start_date = start_date
+#                         st.session_state.duration_weeks = duration_weeks
+#                         st.rerun()
+#                     except Exception as e:
+#                         st.error(f"Error generating course structure: {e}")
+    
+#     # Display and Edit Generated Course Content
+#     if st.session_state.course_plan:
+#         with st.expander("Course Overview", expanded=True):
+#             if not st.session_state.edit_mode:
+#                 st.subheader(st.session_state.course_plan['course_title'])
+#                 st.write(st.session_state.course_plan['course_description'])
+#                 edit_button = st.button("Edit Course Details", use_container_width=True)
+#                 if edit_button:
+#                     st.session_state.edit_mode = True
+#                     st.rerun()
+#             else:
+#                 with st.form("edit_course_details"):
+#                     st.session_state.course_plan['course_title'] = st.text_input(
+#                         "Course Title", 
+#                         value=st.session_state.course_plan['course_title']
+#                     )
+#                     st.session_state.course_plan['course_description'] = st.text_area(
+#                         "Course Description", 
+#                         value=st.session_state.course_plan['course_description']
+#                     )
+#                     if st.form_submit_button("Save Course Details"):
+#                         st.session_state.edit_mode = False
+#                         st.rerun()
+        
+#         # Display Modules and Sessions
+#         st.subheader("Course Modules and Sessions")
+        
+#         start_date = st.session_state.start_date
+#         current_date = start_date
+        
+#         all_sessions = []
+#         for module_idx, module in enumerate(st.session_state.course_plan['modules']):
+#             with st.expander(f"📚 Module {module_idx + 1}: {module['module_title']}", expanded=True):
+#                 # Edit module title
+#                 new_module_title = st.text_input(
+#                     f"Module {module_idx + 1} Title",
+#                     value=module['module_title'],
+#                     key=f"module_{module_idx}"
+#                 )
+#                 module['module_title'] = new_module_title
+                
+#                 for sub_idx, sub_module in enumerate(module['sub_modules']):
+#                     st.markdown(f"### 📖 {sub_module['title']}")
+                    
+#                     # Create sessions for each topic
+#                     for topic_idx, topic in enumerate(sub_module['topics']):
+#                         session_key = f"session_{module_idx}_{sub_idx}_{topic_idx}"
+                        
+#                         with st.container():
+#                             col1, col2, col3 = st.columns([3, 2, 1])
+#                             with col1:
+#                                 new_topic = st.text_input(
+#                                     "Topic",
+#                                     value=topic,
+#                                     key=f"{session_key}_topic"
+#                                 )
+#                                 sub_module['topics'][topic_idx] = new_topic
+                            
+#                             with col2:
+#                                 session_date = st.date_input(
+#                                     "Session Date",
+#                                     value=current_date,
+#                                     key=f"{session_key}_date"
+#                                 )
+                            
+#                             with col3:
+#                                 session_status = st.selectbox(
+#                                     "Status",
+#                                     options=["upcoming", "in-progress", "completed"],
+#                                     key=f"{session_key}_status"
+#                                 )
+                            
+#                             # Create session object
+#                             session = {
+#                                 "session_id": str(ObjectId()),
+#                                 "title": new_topic,
+#                                 "date": datetime.combine(session_date, datetime.min.time()),
+#                                 "status": session_status,
+#                                 "module_name": module['module_title'],
+#                                 "created_at": datetime.utcnow(),
+#                                 "pre_class": {
+#                                     "resources": [],
+#                                     "completion_required": True
+#                                 },
+#                                 "in_class": {
+#                                     "quiz": [],
+#                                     "polls": []
+#                                 },
+#                                 "post_class": {
+#                                     "assignments": []
+#                                 }
+#                             }
+#                             all_sessions.append(session)
+#                             current_date = session_date + timedelta(days=7)
+        
+#         new_course_id = get_new_course_id()
+#         course_title = st.session_state.course_plan['course_title']
+#         # Final Save Button
+#         if st.button("Save Course", type="primary", use_container_width=True):
+#             try:
+#                 course_doc = {
+#                     "course_id": new_course_id,
+#                     "title": course_title,
+#                     "description": st.session_state.course_plan['course_description'],
+#                     "faculty": faculty_name,
+#                     "faculty_id": faculty_id,
+#                     "duration": f"{st.session_state.duration_weeks} weeks",
+#                     "start_date": datetime.combine(st.session_state.start_date, datetime.min.time()),
+#                     "created_at": datetime.utcnow(),
+#                     "sessions": all_sessions
+#                 }
+                
+#                 # Insert into database
+#                 courses_collection.insert_one(course_doc)
+                
+#                 st.success("Course successfully created!")
+
+#                 # Update faculty collection
+#                 faculty_collection.update_one(
+#                     {"_id": st.session_state.user_id},
+#                     {
+#                         "$push": {
+#                             "courses_taught": {
+#                                 "course_id": new_course_id,
+#                                 "title": course_title,
+#                             }
+#                         }
+#                     },
+#                 )
+
+#                 # Clear session state
+#                 st.session_state.course_plan = None
+#                 st.session_state.edit_mode = False
+                
+#                 # Optional: Add a button to view the created course
+#                 if st.button("View Course"):
+#                     # Add navigation logic here
+#                     pass
+                
+#             except Exception as e:
+#                 st.error(f"Error saving course: {e}")
+    
+
+def remove_json_backticks(json_string):
+    """Remove backticks and 'json' from the JSON object string"""
+    return json_string.replace("```json", "").replace("```", "").strip()
+
+
 def create_course_form(faculty_name, faculty_id):
-    """Display enhanced form to create a new course with AI-generated content"""
+    """Display enhanced form to create a new course with AI-generated content and resources"""
+    
     st.title("Create New Course")
     
     if 'course_plan' not in st.session_state:
         st.session_state.course_plan = None
     if 'edit_mode' not in st.session_state:
         st.session_state.edit_mode = False
+    if 'resources_map' not in st.session_state:
+        st.session_state.resources_map = {}
+    if 'start_date' not in st.session_state:
+        st.session_state.start_date = None
+    if 'duration_weeks' not in st.session_state:
+        st.session_state.duration_weeks = None
+    if 'sessions_per_week' not in st.session_state:
+        st.session_state.sessions_per_week = None
+    
 
     # Initial Course Creation Form
     if not st.session_state.course_plan:
@@ -669,6 +861,7 @@ def create_course_form(faculty_name, faculty_id):
             with col1:
                 course_name = st.text_input("Course Name", placeholder="e.g., Introduction to Computer Science")
                 faculty_info = st.text_input("Faculty", value=faculty_name, disabled=True)
+                sessions_per_week = st.number_input("Sessions Per Week", min_value=1, max_value=5, value=2)
             with col2:
                 duration_weeks = st.number_input("Duration (weeks)", min_value=1, max_value=16, value=12)
                 start_date = st.date_input("Start Date")
@@ -676,13 +869,51 @@ def create_course_form(faculty_name, faculty_id):
             generate_button = st.form_submit_button("Generate Course Structure", use_container_width=True)
             
             if generate_button and course_name:
-                with st.spinner("Generating course structure..."):
+                with st.spinner("Generating course structure and resources..."):
                     try:
-                        course_plan = generate_perplexity_response(PERPLEXITY_API_KEY, course_name)
-                        # print(course_plan)
-                        st.session_state.course_plan = json.loads(course_plan)
+                        # Generate course plan with resources
+                        course_plan = generate_perplexity_response(
+                            PERPLEXITY_API_KEY, 
+                            course_name, 
+                            duration_weeks,
+                            sessions_per_week
+                        )
+                        try:
+                            course_plan_json = json.loads(course_plan)
+                            validate_course_plan(course_plan_json)
+                            st.session_state.course_plan = course_plan_json
+                        except (json.JSONDecodeError, ValueError) as e:
+                            st.error(f"Error in course plan structure: {e}")
+                            return
                         st.session_state.start_date = start_date
                         st.session_state.duration_weeks = duration_weeks
+                        st.session_state.sessions_per_week = sessions_per_week
+                        
+                        # Generate resources for all sessions
+                        session_titles = []
+                        for module in st.session_state.course_plan['modules']:
+                            for sub_module in module['sub_modules']:
+                                for topic in sub_module['topics']:
+                                    # session_titles.append(topic['title'])
+                                    # session_titles.append(topic)
+                                    if isinstance(topic, dict):
+                                        session_titles.append(topic['title'])
+                                    else:
+                                        session_titles.append(topic)
+                        # In generate_session_resources function, add validation:
+                        if not session_titles:
+                            return json.dumps({"session_resources": []})
+                        resources_response = generate_session_resources(PERPLEXITY_API_KEY, session_titles)
+                        without_backticks = remove_json_backticks(resources_response)
+                        resources = json.loads(without_backticks)
+                        st.session_state.resources_map = {
+                            resource['session_title']: resource['resources']
+                            for resource in resources['session_resources']
+                        }
+                        # Add error handling for the resources map
+                        # if st.session_state.resources_map is None:
+                        #     st.session_state.resources_map = {}
+
                         st.rerun()
                     except Exception as e:
                         st.error(f"Error generating course structure: {e}")
@@ -693,6 +924,14 @@ def create_course_form(faculty_name, faculty_id):
             if not st.session_state.edit_mode:
                 st.subheader(st.session_state.course_plan['course_title'])
                 st.write(st.session_state.course_plan['course_description'])
+                col1, col2, col3 = st.columns(3)
+                with col1:
+                    st.write(f"**Start Date:** {st.session_state.start_date}")
+                with col2:
+                    st.write(f"**Duration (weeks):** {st.session_state.duration_weeks}")
+                with col3:
+                    st.write(f"**Sessions Per Week:** {st.session_state.sessions_per_week}")
+
                 edit_button = st.button("Edit Course Details", use_container_width=True)
                 if edit_button:
                     st.session_state.edit_mode = True
@@ -722,28 +961,45 @@ def create_course_form(faculty_name, faculty_id):
             with st.expander(f"📚 Module {module_idx + 1}: {module['module_title']}", expanded=True):
                 # Edit module title
                 new_module_title = st.text_input(
-                    f"Module {module_idx + 1} Title",
+                    f"Edit Module Title",
                     value=module['module_title'],
                     key=f"module_{module_idx}"
                 )
                 module['module_title'] = new_module_title
                 
                 for sub_idx, sub_module in enumerate(module['sub_modules']):
-                    st.markdown(f"### 📖 {sub_module['title']}")
-                    
-                    # Create sessions for each topic
+                    st.markdown("<br>", unsafe_allow_html=True)  # Add gap between sessions
+                    # st.markdown(f"### 📖 {sub_module['title']}")
+                    st.markdown(f'<h3 style="font-size: 1.25rem;">📖 Chapter {sub_idx + 1}: {sub_module["title"]}</h3>', unsafe_allow_html=True)
+                    # Possible fix: 
+                    # Inside the loop where topics are being processed:
+
                     for topic_idx, topic in enumerate(sub_module['topics']):
+                        st.markdown("<br>", unsafe_allow_html=True)  # Add gap between sessions
                         session_key = f"session_{module_idx}_{sub_idx}_{topic_idx}"
                         
+                        # Get topic title based on type
+                        if isinstance(topic, dict):
+                            current_topic_title = topic.get('title', '')
+                            current_topic_display = current_topic_title
+                        else:
+                            current_topic_title = str(topic)
+                            current_topic_display = current_topic_title
+
                         with st.container():
+                            # Session Details
                             col1, col2, col3 = st.columns([3, 2, 1])
                             with col1:
                                 new_topic = st.text_input(
-                                    "Topic",
-                                    value=topic,
+                                    f"Session {topic_idx + 1} Title",
+                                    value=current_topic_display,
                                     key=f"{session_key}_topic"
                                 )
-                                sub_module['topics'][topic_idx] = new_topic
+                                # Update the topic in the data structure
+                                if isinstance(topic, dict):
+                                    topic['title'] = new_topic
+                                else:
+                                    sub_module['topics'][topic_idx] = new_topic
                             
                             with col2:
                                 session_date = st.date_input(
@@ -759,6 +1015,59 @@ def create_course_form(faculty_name, faculty_id):
                                     key=f"{session_key}_status"
                                 )
                             
+                            # Display Resources
+                            if st.session_state.resources_map:
+                                # Try both the full topic title and the display title
+                                resources = None
+                                if isinstance(topic, dict) and topic.get('title') in st.session_state.resources_map:
+                                    resources = st.session_state.resources_map[topic['title']]
+                                elif current_topic_title in st.session_state.resources_map:
+                                    resources = st.session_state.resources_map[current_topic_title]
+                                
+                                if resources:
+                                    with st.container():
+                                        # st.markdown("#### 📚 Session Resources")
+                                        st.markdown(f'<h4 style="font-size: 1.25rem;">📚 Session Resources</h4>', unsafe_allow_html=True)
+                                        # Readings Tab
+                                        if resources.get('readings'):
+                                            st.markdown(f'<h5 style="font-size: 1.1rem; margin-top: 1rem;">📖 External Resources</h5>', unsafe_allow_html=True)
+                                            col1, col2 = st.columns(2)
+                                            for idx, reading in enumerate(resources['readings']):
+                                                with col1 if idx % 2 == 0 else col2:
+                                                    st.markdown(f"""
+                                                        - **{reading['title']}**
+                                                        - Type: {reading['type']}
+                                                        - Estimated reading time: {reading['estimated_read_time']}
+                                                        - [Access Resource]({reading['url']})
+                                                    """)
+                                        
+                                        # Books Tab and Additional Resources Tab side-by-side
+                                        col1, col2 = st.columns(2)
+                                        
+                                        with col1:
+                                            if resources.get('books'):
+                                                st.markdown(f'<h5 style="font-size: 1.1rem; margin-top: 1rem;">📚 Reference Books</h5>', unsafe_allow_html=True)
+                                                for book in resources['books']:
+                                                    with st.container():
+                                                        st.markdown(f"""
+                                                            - **{book['title']}**
+                                                            - Author: {book['author']}
+                                                            - ISBN: {book['isbn']}
+                                                            - Chapters: {book['chapters']}
+                                                        """)
+                                        
+                                        with col2:
+                                            if resources.get('additional_resources'):
+                                                st.markdown(f'<h5 style="font-size: 1.1rem; margin-top: 1rem;">🔗 Additional Study Resources</h5>', unsafe_allow_html=True)
+                                                for resource in resources['additional_resources']:
+                                                    with st.container():
+                                                        st.markdown(f"""
+                                                            - **{resource['title']}**
+                                                            - Type: {resource['type']}
+                                                            - Description: {resource['description']}
+                                                            - [Access Resource]({resource['url']})
+                                                        """)
+                            
                             # Create session object
                             session = {
                                 "session_id": str(ObjectId()),
@@ -777,58 +1086,64 @@ def create_course_form(faculty_name, faculty_id):
                                 },
                                 "post_class": {
                                     "assignments": []
-                                }
+                                },
+                                "external_resources": st.session_state.resources_map.get(current_topic_title, {})
                             }
                             all_sessions.append(session)
                             current_date = session_date + timedelta(days=7)
-        
+                        
+
         new_course_id = get_new_course_id()
         course_title = st.session_state.course_plan['course_title']
+
         # Final Save Button
-        if st.button("Save Course", type="primary", use_container_width=True):
-            try:
-                course_doc = {
-                    "course_id": new_course_id,
-                    "title": course_title,
-                    "description": st.session_state.course_plan['course_description'],
-                    "faculty": faculty_name,
-                    "faculty_id": faculty_id,
-                    "duration": f"{st.session_state.duration_weeks} weeks",
-                    "start_date": datetime.combine(st.session_state.start_date, datetime.min.time()),
-                    "created_at": datetime.utcnow(),
-                    "sessions": all_sessions
-                }
-                
-                # Insert into database
-                courses_collection.insert_one(course_doc)
-                
-                st.success("Course successfully created!")
+    if st.button("Save Course", type="primary", use_container_width=True):
+        try:
+            course_doc = {
+                "course_id": new_course_id,
+                "title": course_title,
+                "description": st.session_state.course_plan['course_description'],
+                "faculty": faculty_name,
+                "faculty_id": faculty_id,
+                "duration": f"{st.session_state.duration_weeks} weeks",
+                "sessions_per_week": st.session_state.sessions_per_week,
+                "start_date": datetime.combine(st.session_state.start_date, datetime.min.time()),
+                "created_at": datetime.utcnow(),
+                "sessions": all_sessions
+            }
+            
+            # Insert into database
+            courses_collection.insert_one(course_doc)
+            st.success("Course successfully created!")
 
-                # Update faculty collection
-                faculty_collection.update_one(
-                    {"_id": st.session_state.user_id},
-                    {
-                        "$push": {
-                            "courses_taught": {
-                                "course_id": new_course_id,
-                                "title": course_title,
-                            }
+            # Update faculty collection
+            faculty_collection.update_one(
+                {"_id": st.session_state.user_id},
+                {
+                    "$push": {
+                        "courses_taught": {
+                            "course_id": new_course_id,
+                            "title": course_title,
                         }
-                    },
-                )
+                    }
+                }
+            )
+
+            # Clear session state
+            st.session_state.course_plan = None
+            st.session_state.edit_mode = False
+            st.session_state.resources_map = {}
+            
+            # Optional: Add a button to view the created course
+            if st.button("View Course"):
+                # Add navigation logic here
+                pass
+            
+        except Exception as e:
+            st.error(f"Error saving course: {e}")
+
+
 
-                # Clear session state
-                st.session_state.course_plan = None
-                st.session_state.edit_mode = False
-                
-                # Optional: Add a button to view the created course
-                if st.button("View Course"):
-                    # Add navigation logic here
-                    pass
-                
-            except Exception as e:
-                st.error(f"Error saving course: {e}")
-    
 from research_assistant_dashboard import display_research_assistant_dashboard
 from goals2 import display_analyst_dashboard
 def enroll_in_course(course_id, course_title, student):

create_course2.py

@@ -0,0 +1,331 @@
+from datetime import datetime, timedelta
+import os
+from typing import Dict, List, Any
+from pymongo import MongoClient
+import requests
+import uuid
+import openai
+from openai import OpenAI
+import streamlit as st
+from bson import ObjectId
+from dotenv import load_dotenv
+import json
+
+load_dotenv()
+MONGODB_URI = os.getenv("MONGO_URI")
+PERPLEXITY_API_KEY = os.getenv("PERPLEXITY_KEY")
+OPENAI_API_KEY = os.getenv("OPENAI_KEY")
+
+client = MongoClient(MONGODB_URI)
+db = client['novascholar_db']
+courses_collection = db['courses']
+
+def generate_perplexity_response(api_key, course_name, duration_weeks, sessions_per_week):
+    headers = {
+        "accept": "application/json",
+        "content-type": "application/json",
+        "authorization": f"Bearer {api_key}"
+    }
+    
+    # Calculate sessions based on duration
+    total_sessions = duration_weeks * sessions_per_week  # Assuming 2 sessions per week
+    
+    prompt = f"""
+    You are an expert educational AI assistant specializing in curriculum design and instructional planning. Your task is to generate a comprehensive, academically rigorous course structure for the course {course_name} that fits exactly within {duration_weeks} weeks with {total_sessions} total sessions ({sessions_per_week} sessions per week).
+
+    Please generate a detailed course structure in JSON format following these specifications:
+
+    1. The course structure must be designed for exactly {duration_weeks} weeks with {total_sessions} total sessions
+    2. Each module should contain an appropriate number of sessions that sum up to exactly {total_sessions}
+    3. Each session should be designed for a 1-1.5-hour class duration
+    4. Follow standard academic practices and nomenclature
+    5. Ensure progressive complexity from foundational to advanced concepts
+    6. The course_title should exactly match the course name provided
+    7. Ensure that the property names are enclosed in double quotes (") and followed by a colon (:), and the values are enclosed in double quotes (").
+    8. **DO NOT INCLUDE THE WORD JSON IN THE OUTPUT STRING, DO NOT INCLUDE BACKTICKS (```) IN THE OUTPUT, AND DO NOT INCLUDE ANY OTHER TEXT, OTHER THAN THE ACTUAL JSON RESPONSE. START THE RESPONSE STRING WITH AN OPEN CURLY BRACE {{ AND END WITH A CLOSING CURLY BRACE }}.**
+
+    The JSON response should follow this structure:
+    {{
+        "course_title": "string",
+        "course_description": "string",
+        "total_duration_weeks": {duration_weeks},
+        "sessions_per_week": {sessions_per_week},
+        "total_sessions": {total_sessions},
+        "modules": [
+            {{
+                "module_title": "string",
+                "module_duration_sessions": number,
+                "sub_modules": [
+                    {{
+                        "title": "string",
+                        "topics": [
+                            {{
+                                "title": "string",
+                                "short_description": "string",
+                                "concise_learning_objectives": ["string"]
+                            }}
+                        ]
+                    }}
+                ]
+            }}
+        ]
+    }}
+
+    Ensure that:
+    1. The sum of all module_duration_sessions equals exactly {total_sessions}
+    2. Each topic has clear learning objectives
+    3. Topics build upon each other logically
+    4. Content is distributed evenly across the available sessions
+    5. **This Instruction is Strictly followed: **DO NOT INCLUDE THE WORD JSON IN THE OUTPUT STRING, DO NOT INCLUDE BACKTICKS (```) IN THE OUTPUT, AND DO NOT INCLUDE ANY OTHER TEXT, OTHER THAN THE ACTUAL JSON RESPONSE. START THE RESPONSE STRING WITH AN OPEN CURLY BRACE {{ AND END WITH A CLOSING CURLY BRACE }}.****
+
+    """
+
+    messages = [
+        {
+            "role": "system",
+            "content": (
+                "You are an expert educational AI assistant specializing in course design and curriculum planning. "
+                "Your task is to generate accurate, detailed, and structured educational content that precisely fits "
+                "the specified duration."
+            ),
+        },
+        {
+            "role": "user",
+            "content": prompt
+        },
+    ]
+    
+    try:
+        client = OpenAI(api_key=api_key, base_url="https://api.perplexity.ai")
+        response = client.chat.completions.create(
+            model="llama-3.1-sonar-small-128k-online",
+            messages=messages
+        )
+        content = response.choices[0].message.content
+        
+        # Validate session count
+        course_plan = json.loads(content)
+        total_planned_sessions = sum(
+            module.get('module_duration_sessions', 0) 
+            for module in course_plan.get('modules', [])
+        )
+        
+        if abs(total_planned_sessions - total_sessions) > 5:
+            raise ValueError(f"Generated plan has {total_planned_sessions} sessions, but {total_sessions} were requested")
+            
+        return content
+    except Exception as e:
+        st.error(f"Failed to fetch data from Perplexity API: {e}")
+        return ""
+
+def generate_session_resources(api_key, session_titles: List[str]):
+    """
+    Generate relevant resources for each session title separately
+    """
+    resources_prompt = f"""
+    You are an expert educational content curator. For each session title provided, suggest highly relevant and accurate learning resources.
+    Please provide resources for these sessions: {session_titles}
+
+    For each session, provide resources in this JSON format:
+    {{
+        "session_resources": [
+            {{
+                "session_title": "string",
+                "resources": {{
+                    "readings": [
+                        {{
+                            "title": "string",
+                            "url": "string",
+                            "type": "string",
+                            "estimated_read_time": "string"
+                        }}
+                    ],
+                    "books": [
+                        {{
+                            "title": "string",
+                            "author": "string",
+                            "isbn": "string",
+                            "chapters": "string"
+                        }}
+                    ],
+                    "additional_resources": [
+                        {{
+                            "title": "string",
+                            "url": "string",
+                            "type": "string",
+                            "description": "string"
+                        }}
+                    ]
+                }}
+            }}
+        ]
+    }}
+
+    Guidelines:
+    1. Ensure all URLs are real and currently active
+    2. Prioritize high-quality, authoritative sources
+    3. Include 1-2 resources of each type
+    5. For readings, include a mix of academic and practical resources. It can exceed to 3-4 readings 
+    6. Book references should be real, recently published works
+    7. Additional resources can include tools, documentation, or practice platforms
+    8. Ensure that the property names are enclosed in double quotes (") and followed by a colon (:), and the values are enclosed in double quotes (").
+    9. ***NOTE: **DO NOT INCLUDE THE WORD JSON IN THE OUTPUT STRING, DO NOT INCLUDE BACKTICKS (```) IN THE OUTPUT, AND DO NOT INCLUDE ANY OTHER TEXT, OTHER THAN THE ACTUAL JSON RESPONSE. START THE RESPONSE STRING WITH AN OPEN CURLY BRACE {{ AND END WITH A CLOSING CURLY BRACE }}.**
+    """
+
+    messages = [
+        {
+            "role": "system",
+            "content": "You are an expert educational content curator, focused on providing accurate and relevant learning resources.",
+        },
+        {
+            "role": "user",
+            "content": resources_prompt
+        },
+    ]
+
+    try:
+        client = OpenAI(api_key=api_key, base_url="https://api.perplexity.ai")
+        response = client.chat.completions.create(
+            model="llama-3.1-sonar-small-128k-online",
+            messages=messages
+        )
+        print("Response is: \n", response.choices[0].message.content)
+        # try:
+        #     return json.loads(response.choices[0].message.content)
+        # except json.JSONDecodeError as e:
+        #     st.error(f"Failed to decode JSON response: {e}")
+        #     return None
+        return response.choices[0].message.content
+    except Exception as e:
+        st.error(f"Failed to generate resources: {e}")
+        return None
+
+def validate_course_plan(course_plan):
+    required_fields = ['course_title', 'course_description', 'modules']
+    if not all(field in course_plan for field in required_fields):
+        raise ValueError("Invalid course plan structure")
+    
+    for module in course_plan['modules']:
+        if 'module_title' not in module or 'sub_modules' not in module:
+            raise ValueError("Invalid module structure")
+
+def create_session(title: str, date: datetime, module_name: str, resources: dict):
+    """Create a session document with pre-class, in-class, and post-class components."""
+    return {
+        "session_id": ObjectId(),
+        "title": title,
+        "date": date,
+        "status": "upcoming",
+        "created_at": datetime.utcnow(),
+        "module_name": module_name,
+        "pre_class": {
+            "resources": [],
+            "completion_required": True
+        },
+        "in_class": {
+            "quiz": [],
+            "polls": []
+        },
+        "post_class": {
+            "assignments": []
+        },
+        "external_resources": {
+            "readings": resources.get("readings", []),
+            "books": resources.get("books", []),
+            "additional_resources": resources.get("additional_resources", [])
+        }
+    }
+
+def create_course(course_name: str, start_date: datetime, duration_weeks: int, sessions_per_week: int):
+    # First generate a course plan using Perplexity API
+    # course_plan = generate_perplexity_response(PERPLEXITY_API_KEY, course_name, duration_weeks, sessions_per_week)
+    # course_plan_json = json.loads(course_plan)
+    
+    # print("Course Structure is: \n", course_plan_json);
+
+    # Earlier Code: 
+    # Generate sessions for each module with resources
+    # all_sessions = []
+    # current_date = start_date
+    
+    # for module in course_plan_json['modules']:
+    #     for sub_module in module['sub_modules']:
+    #         for topic in sub_module['topics']:
+    #             session = create_session(
+    #                 title=topic['title'],
+    #                 date=current_date,
+    #                 module_name=module['module_title'],
+    #                 resources=topic['resources']
+    #             )
+    #             all_sessions.append(session)
+    #             current_date += timedelta(days=3.5)  # Spacing sessions evenly across the week
+    
+    # return course_plan_json, all_sessions
+
+    # New Code:
+    # Extract all session titles
+    session_titles = []
+    # Load the course plan JSON
+    course_plan_json = {}
+    with open('sample_files/sample_course.json', 'r') as file:
+        course_plan_json = json.load(file)
+
+    for module in course_plan_json['modules']:
+        for sub_module in module['sub_modules']:
+            for topic in sub_module['topics']:
+                session_titles.append(topic['title'])
+    
+    # Generate resources for all sessions
+    session_resources = generate_session_resources(PERPLEXITY_API_KEY, session_titles)
+    # print("Session Resources are: \n", session_resources)
+    resources = json.loads(session_resources)
+    # print("Resources JSON is: \n", resources_json)
+    
+    # print("Session Resources are: \n", session_resources)
+
+    # Create a mapping of session titles to their resources
+    
+    # Import Resources JSON
+    # resources = {}
+    # with open('sample_files/sample_course_resources.json', 'r') as file:
+    #     resources = json.load(file)
+
+    resources_map = {
+        resource['session_title']: resource['resources']
+        for resource in resources['session_resources']
+    }
+    print("Resources Map is: \n", resources_map)
+    # print("Sample is: ", resources_map.get('Overview of ML Concepts, History, and Applications'));
+    # Generate sessions with their corresponding resources
+    all_sessions = []
+    current_date = start_date
+    
+    for module in course_plan_json['modules']:
+        for sub_module in module['sub_modules']:
+            for topic in sub_module['topics']:
+                session = create_session(
+                    title=topic['title'],
+                    date=current_date,
+                    module_name=module['module_title'],
+                    resources=resources_map.get(topic['title'], {})
+                )
+                all_sessions.append(session)
+                current_date += timedelta(days=3.5)
+    
+    print("All Sessions are: \n", all_sessions)
+
+def get_new_course_id():
+    """Generate a new course ID by incrementing the last course ID"""
+    last_course = courses_collection.find_one(sort=[("course_id", -1)])
+    if last_course:
+        last_course_id = int(last_course["course_id"][2:])
+        new_course_id = f"CS{last_course_id + 1}"
+    else:
+        new_course_id = "CS101"
+    return new_course_id
+
+# if __name__ == "__main__":
+#     course_name = "Introduction to Machine Learning"
+#     start_date = datetime(2022, 9, 1)
+#     duration_weeks = 4
+#     create_course(course_name, start_date, duration_weeks, 3)

pre_class_analytics4.py

@@ -0,0 +1,526 @@
+import pandas as pd
+import numpy as np
+from datetime import datetime
+from typing import List, Dict, Any, Tuple
+import spacy
+from collections import Counter, defaultdict
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+from textblob import TextBlob
+import networkx as nx
+from scipy import stats
+import logging
+import json
+from dataclasses import dataclass
+from enum import Enum
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class TopicDifficulty(Enum):
+    EASY = "easy"
+    MODERATE = "moderate"
+    DIFFICULT = "difficult"
+    VERY_DIFFICULT = "very_difficult"
+
+@dataclass
+class QuestionMetrics:
+    complexity_score: float
+    follow_up_count: int
+    clarification_count: int
+    time_spent: float
+    sentiment_score: float
+
+@dataclass
+class TopicInsights:
+    difficulty_level: TopicDifficulty
+    common_confusion_points: List[str]
+    question_patterns: List[str]
+    time_distribution: Dict[str, float]
+    engagement_metrics: Dict[str, float]
+    recommended_focus_areas: List[str]
+
+class PreClassAnalytics:
+    def __init__(self, nlp_model: str = "en_core_web_lg"):
+        """Initialize the analytics system with necessary components."""
+        self.nlp = spacy.load(nlp_model)
+        self.question_indicators = {
+            "what", "why", "how", "when", "where", "which", "who", 
+            "whose", "whom", "can", "could", "would", "will", "explain"
+        }
+        self.confusion_indicators = {
+            "confused", "don't understand", "unclear", "not clear",
+            "stuck", "difficult", "hard", "help", "explain again"
+        }
+        self.follow_up_indicators = {
+            "also", "another", "additionally", "furthermore", "moreover",
+            "besides", "related", "similarly", "again"
+        }
+        
+    def preprocess_chat_history(self, chat_history: List[Dict]) -> pd.DataFrame:
+        """Convert chat history to DataFrame with enhanced features."""
+        messages = []
+        for chat in chat_history:
+            user_id = chat['user_id']['$oid']
+            for msg in chat['messages']:
+                messages.append({
+                    'user_id': user_id,
+                    'timestamp': pd.to_datetime(msg['timestamp']['$date']),
+                    'prompt': msg['prompt'],
+                    'response': msg['response'],
+                    'is_question': any(q in msg['prompt'].lower() for q in self.question_indicators),
+                    'shows_confusion': any(c in msg['prompt'].lower() for c in self.confusion_indicators),
+                    'is_followup': any(f in msg['prompt'].lower() for f in self.follow_up_indicators)
+                })
+        
+        df = pd.DataFrame(messages)
+        df['sentiment'] = df['prompt'].apply(lambda x: TextBlob(x).sentiment.polarity)
+        return df
+
+    def extract_topic_hierarchies(self, df: pd.DataFrame) -> Dict[str, List[str]]:
+        """Extract hierarchical topic relationships from conversations."""
+        topic_hierarchy = defaultdict(list)
+        
+        for _, row in df.iterrows():
+            doc = self.nlp(row['prompt'])
+            
+            # Extract main topics and subtopics using noun chunks and dependencies
+            main_topics = []
+            subtopics = []
+            
+            for chunk in doc.noun_chunks:
+                if chunk.root.dep_ in ('nsubj', 'dobj'):
+                    main_topics.append(chunk.text.lower())
+                else:
+                    subtopics.append(chunk.text.lower())
+            
+            # Build hierarchy
+            for main_topic in main_topics:
+                topic_hierarchy[main_topic].extend(subtopics)
+        
+        # Clean and deduplicate
+        return {k: list(set(v)) for k, v in topic_hierarchy.items()}
+
+    def analyze_topic_difficulty(self, df: pd.DataFrame, topic: str) -> TopicDifficulty:
+        """Determine topic difficulty based on various metrics."""
+        topic_msgs = df[df['prompt'].str.contains(topic, case=False)]
+        
+        # Calculate difficulty indicators
+        confusion_rate = topic_msgs['shows_confusion'].mean()
+        question_rate = topic_msgs['is_question'].mean()
+        follow_up_rate = topic_msgs['is_followup'].mean()
+        avg_sentiment = topic_msgs['sentiment'].mean()
+        
+        # Calculate composite difficulty score
+        difficulty_score = (
+            confusion_rate * 0.4 +
+            question_rate * 0.3 +
+            follow_up_rate * 0.2 +
+            (1 - (avg_sentiment + 1) / 2) * 0.1
+        )
+        
+        # Map score to difficulty level
+        if difficulty_score < 0.3:
+            return TopicDifficulty.EASY
+        elif difficulty_score < 0.5:
+            return TopicDifficulty.MODERATE
+        elif difficulty_score < 0.7:
+            return TopicDifficulty.DIFFICULT
+        else:
+            return TopicDifficulty.VERY_DIFFICULT
+
+    def identify_confusion_patterns(self, df: pd.DataFrame, topic: str) -> List[str]:
+        """Identify common patterns in student confusion."""
+        confused_msgs = df[
+            (df['prompt'].str.contains(topic, case=False)) & 
+            (df['shows_confusion'])
+        ]['prompt']
+        
+        patterns = []
+        for msg in confused_msgs:
+            doc = self.nlp(msg)
+            
+            # Extract key phrases around confusion indicators
+            for sent in doc.sents:
+                for token in sent:
+                    if token.text.lower() in self.confusion_indicators:
+                        # Get context window around confusion indicator
+                        context = sent.text
+                        patterns.append(context)
+        
+        # Group similar patterns
+        if patterns:
+            vectorizer = TfidfVectorizer(ngram_range=(1, 3))
+            tfidf_matrix = vectorizer.fit_transform(patterns)
+            similarity_matrix = cosine_similarity(tfidf_matrix)
+            
+            # Cluster similar patterns
+            G = nx.Graph()
+            for i in range(len(patterns)):
+                for j in range(i + 1, len(patterns)):
+                    if similarity_matrix[i][j] > 0.5:  # Similarity threshold
+                        G.add_edge(i, j)
+            
+            # Extract representative patterns from each cluster
+            clusters = list(nx.connected_components(G))
+            return [patterns[min(cluster)] for cluster in clusters]
+        
+        return []
+
+    def analyze_question_patterns(self, df: pd.DataFrame, topic: str) -> List[str]:
+        """Analyze patterns in student questions about the topic."""
+        topic_questions = df[
+            (df['prompt'].str.contains(topic, case=False)) & 
+            (df['is_question'])
+        ]['prompt']
+        
+        question_types = defaultdict(list)
+        for question in topic_questions:
+            doc = self.nlp(question)
+            
+            # Categorize questions
+            if any(token.text.lower() in {"what", "define", "explain"} for token in doc):
+                question_types["conceptual"].append(question)
+            elif any(token.text.lower() in {"how", "steps", "process"} for token in doc):
+                question_types["procedural"].append(question)
+            elif any(token.text.lower() in {"why", "reason", "because"} for token in doc):
+                question_types["reasoning"].append(question)
+            else:
+                question_types["other"].append(question)
+        
+        # Extract patterns from each category
+        patterns = []
+        for category, questions in question_types.items():
+            if questions:
+                vectorizer = TfidfVectorizer(ngram_range=(1, 3))
+                tfidf_matrix = vectorizer.fit_transform(questions)
+                
+                # Get most representative questions
+                feature_array = np.mean(tfidf_matrix.toarray(), axis=0)
+                tfidf_sorting = np.argsort(feature_array)[::-1]
+                features = vectorizer.get_feature_names_out()
+                
+                patterns.append(f"{category}: {' '.join(features[tfidf_sorting[:3]])}")
+        
+        return patterns
+
+    def analyze_time_distribution(self, df: pd.DataFrame, topic: str) -> Dict[str, float]:
+        """Analyze time spent on different aspects of the topic."""
+        topic_msgs = df[df['prompt'].str.contains(topic, case=False)].copy()
+        if len(topic_msgs) < 2:
+            return {}
+        
+        topic_msgs['time_diff'] = topic_msgs['timestamp'].diff()
+        
+        # Calculate time distribution
+        distribution = {
+            'total_time': topic_msgs['time_diff'].sum().total_seconds() / 60,
+            'avg_time_per_message': topic_msgs['time_diff'].mean().total_seconds() / 60,
+            'max_time_gap': topic_msgs['time_diff'].max().total_seconds() / 60,
+            'time_spent_on_questions': topic_msgs[topic_msgs['is_question']]['time_diff'].sum().total_seconds() / 60,
+            'time_spent_on_confusion': topic_msgs[topic_msgs['shows_confusion']]['time_diff'].sum().total_seconds() / 60
+        }
+        
+        return distribution
+
+    def calculate_engagement_metrics(self, df: pd.DataFrame, topic: str) -> Dict[str, float]:
+        """Calculate student engagement metrics for the topic."""
+        topic_msgs = df[df['prompt'].str.contains(topic, case=False)]
+        
+        metrics = {
+            'message_count': len(topic_msgs),
+            'question_ratio': topic_msgs['is_question'].mean(),
+            'confusion_ratio': topic_msgs['shows_confusion'].mean(),
+            'follow_up_ratio': topic_msgs['is_followup'].mean(),
+            'avg_sentiment': topic_msgs['sentiment'].mean(),
+            'engagement_score': 0.0  # Will be calculated below
+        }
+        
+        # Calculate engagement score
+        metrics['engagement_score'] = (
+            metrics['message_count'] * 0.3 +
+            metrics['question_ratio'] * 0.25 +
+            metrics['follow_up_ratio'] * 0.25 +
+            (metrics['avg_sentiment'] + 1) / 2 * 0.2  # Normalize sentiment to 0-1
+        )
+        
+        return metrics
+
+    def generate_topic_insights(self, df: pd.DataFrame, topic: str) -> TopicInsights:
+        """Generate comprehensive insights for a topic."""
+        difficulty = self.analyze_topic_difficulty(df, topic)
+        confusion_points = self.identify_confusion_patterns(df, topic)
+        question_patterns = self.analyze_question_patterns(df, topic)
+        time_distribution = self.analyze_time_distribution(df, topic)
+        engagement_metrics = self.calculate_engagement_metrics(df, topic)
+        
+        # Generate recommended focus areas based on insights
+        focus_areas = []
+        
+        if difficulty in (TopicDifficulty.DIFFICULT, TopicDifficulty.VERY_DIFFICULT):
+            focus_areas.append("Fundamental concept reinforcement needed")
+        
+        if confusion_points:
+            focus_areas.append(f"Address common confusion around: {', '.join(confusion_points[:3])}")
+        
+        if engagement_metrics['confusion_ratio'] > 0.3:
+            focus_areas.append("Consider alternative teaching approaches")
+        
+        if time_distribution.get('time_spent_on_questions', 0) > time_distribution.get('total_time', 0) * 0.5:
+            focus_areas.append("More practical examples or demonstrations needed")
+        
+        return TopicInsights(
+            difficulty_level=difficulty,
+            common_confusion_points=confusion_points,
+            question_patterns=question_patterns,
+            time_distribution=time_distribution,
+            engagement_metrics=engagement_metrics,
+            recommended_focus_areas=focus_areas
+        )
+
+    def analyze_student_progress(self, df: pd.DataFrame) -> Dict[str, Any]:
+        """Analyze individual student progress and learning patterns."""
+        student_progress = {}
+        
+        for student_id in df['user_id'].unique():
+            student_msgs = df[df['user_id'] == student_id]
+            
+            # Calculate student-specific metrics
+            progress = {
+                'total_messages': len(student_msgs),
+                'questions_asked': student_msgs['is_question'].sum(),
+                'confusion_instances': student_msgs['shows_confusion'].sum(),
+                'avg_sentiment': student_msgs['sentiment'].mean(),
+                'topic_engagement': {},
+                'learning_pattern': self._identify_learning_pattern(student_msgs)
+            }
+            
+            # Analyze topic-specific engagement
+            topics = self.extract_topic_hierarchies(student_msgs)
+            for topic in topics:
+                topic_msgs = student_msgs[student_msgs['prompt'].str.contains(topic, case=False)]
+                progress['topic_engagement'][topic] = {
+                    'message_count': len(topic_msgs),
+                    'confusion_rate': topic_msgs['shows_confusion'].mean(),
+                    'sentiment_trend': stats.linregress(
+                        range(len(topic_msgs)),
+                        topic_msgs['sentiment']
+                    ).slope
+                }
+            
+            student_progress[student_id] = progress
+        
+        return student_progress
+
+    def _identify_learning_pattern(self, student_msgs: pd.DataFrame) -> str:
+        """Identify student's learning pattern based on their interaction style."""
+        # Calculate key metrics
+        question_ratio = student_msgs['is_question'].mean()
+        confusion_ratio = student_msgs['shows_confusion'].mean()
+        follow_up_ratio = student_msgs['is_followup'].mean()
+        sentiment_trend = stats.linregress(
+            range(len(student_msgs)),
+            student_msgs['sentiment']
+        ).slope
+        
+        # Identify pattern
+        if question_ratio > 0.6:
+            return "Inquisitive Learner"
+        elif confusion_ratio > 0.4:
+            return "Needs Additional Support"
+        elif follow_up_ratio > 0.5:
+            return "Deep Dive Learner"
+        elif sentiment_trend > 0:
+            return "Progressive Learner"
+        else:
+            return "Steady Learner"
+
+    def generate_comprehensive_report(self, chat_history: List[Dict]) -> Dict[str, Any]:
+        """Generate a comprehensive analytics report."""
+        # Preprocess chat history
+        df = self.preprocess_chat_history(chat_history)
+        
+        # Extract topics
+        topics = self.extract_topic_hierarchies(df)
+        
+        report = {
+            'topics': {},
+            'student_progress': self.analyze_student_progress(df),
+            'overall_metrics': {
+                'total_conversations': len(df),
+                'unique_students': df['user_id'].nunique(),
+                'avg_sentiment': df['sentiment'].mean(),
+                'most_discussed_topics': Counter(
+                    topic for topics_list in topics.values() 
+                    for topic in topics_list
+                ).most_common(5)
+            }
+        }
+        
+        # Generate topic-specific insights
+        for main_topic, subtopics in topics.items():
+            subtopic_insights = {}
+            for subtopic in subtopics:
+                subtopic_insights[subtopic] = {
+                    'insights': self.generate_topic_insights(df, subtopic),
+                    'related_topics': [t for t in subtopics if t != subtopic],
+                    'student_engagement': {
+                        student_id: self.calculate_engagement_metrics(
+                            df[df['user_id'] == student_id], 
+                            subtopic
+                        )
+                        for student_id in df['user_id'].unique()
+                    }
+                }
+            
+            report['topics'][main_topic] = {
+                'insights': self.generate_topic_insights(df, main_topic),
+                'subtopics': subtopic_insights,
+                'topic_relationships': {
+                    'hierarchy_depth': len(subtopics),
+                    'connection_strength': self._calculate_topic_connections(df, main_topic, subtopics),
+                    'progression_path': self._identify_topic_progression(df, main_topic, subtopics)
+                }
+            }
+        
+        # Add temporal analysis
+        report['temporal_analysis'] = {
+            'daily_engagement': df.groupby(df['timestamp'].dt.date).agg({
+                'user_id': 'count',
+                'is_question': 'sum',
+                'shows_confusion': 'sum',
+                'sentiment': 'mean'
+            }).to_dict(),
+            'peak_activity_hours': df.groupby(df['timestamp'].dt.hour)['user_id'].count().nlargest(3).to_dict(),
+            'learning_trends': self._analyze_learning_trends(df)
+        }
+        
+        # Add recommendations
+        report['recommendations'] = self._generate_recommendations(report)
+        
+        return report
+
+    def _calculate_topic_connections(self, df: pd.DataFrame, main_topic: str, subtopics: List[str]) -> Dict[str, float]:
+        """Calculate connection strength between topics based on co-occurrence."""
+        connections = {}
+        main_topic_msgs = df[df['prompt'].str.contains(main_topic, case=False)]
+        
+        for subtopic in subtopics:
+            cooccurrence = df[
+                df['prompt'].str.contains(main_topic, case=False) & 
+                df['prompt'].str.contains(subtopic, case=False)
+            ].shape[0]
+            
+            connection_strength = cooccurrence / len(main_topic_msgs) if len(main_topic_msgs) > 0 else 0
+            connections[subtopic] = connection_strength
+        
+        return connections
+
+    def _identify_topic_progression(self, df: pd.DataFrame, main_topic: str, subtopics: List[str]) -> List[str]:
+        """Identify optimal topic progression path based on student interactions."""
+        topic_difficulties = {}
+        
+        for subtopic in subtopics:
+            difficulty = self.analyze_topic_difficulty(df, subtopic)
+            topic_difficulties[subtopic] = difficulty.value
+        
+        # Sort subtopics by difficulty
+        return sorted(subtopics, key=lambda x: topic_difficulties[x])
+
+    def _analyze_learning_trends(self, df: pd.DataFrame) -> Dict[str, Any]:
+        """Analyze overall learning trends across the dataset."""
+        return {
+            'sentiment_trend': stats.linregress(
+                range(len(df)),
+                df['sentiment']
+            )._asdict(),
+            'confusion_trend': stats.linregress(
+                range(len(df)),
+                df['shows_confusion']
+            )._asdict(),
+            'engagement_progression': self._calculate_engagement_progression(df)
+        }
+
+    def _calculate_engagement_progression(self, df: pd.DataFrame) -> Dict[str, float]:
+        """Calculate how student engagement changes over time."""
+        df['week'] = df['timestamp'].dt.isocalendar().week
+        weekly_engagement = df.groupby('week').agg({
+            'is_question': 'mean',
+            'shows_confusion': 'mean',
+            'is_followup': 'mean',
+            'sentiment': 'mean'
+        })
+        
+        return {
+            'question_trend': stats.linregress(
+                range(len(weekly_engagement)),
+                weekly_engagement['is_question']
+            ).slope,
+            'confusion_trend': stats.linregress(
+                range(len(weekly_engagement)),
+                weekly_engagement['shows_confusion']
+            ).slope,
+            'follow_up_trend': stats.linregress(
+                range(len(weekly_engagement)),
+                weekly_engagement['is_followup']
+            ).slope,
+            'sentiment_trend': stats.linregress(
+                range(len(weekly_engagement)),
+                weekly_engagement['sentiment']
+            ).slope
+        }
+
+    def _generate_recommendations(self, report: Dict[str, Any]) -> List[str]:
+        """Generate actionable recommendations based on the analysis."""
+        recommendations = []
+        
+        # Analyze difficulty distribution
+        difficult_topics = [
+            topic for topic, data in report['topics'].items()
+            if data['insights'].difficulty_level in 
+            (TopicDifficulty.DIFFICULT, TopicDifficulty.VERY_DIFFICULT)
+        ]
+        
+        if difficult_topics:
+            recommendations.append(
+                f"Consider providing additional resources for challenging topics: {', '.join(difficult_topics)}"
+            )
+        
+        # Analyze student engagement
+        avg_engagement = np.mean([
+            progress['questions_asked'] / progress['total_messages']
+            for progress in report['student_progress'].values()
+        ])
+        
+        if avg_engagement < 0.3:
+            recommendations.append(
+                "Implement more interactive elements to increase student engagement"
+            )
+        
+        # Analyze temporal patterns
+        peak_hours = list(report['temporal_analysis']['peak_activity_hours'].keys())
+        recommendations.append(
+            f"Consider scheduling additional support during peak activity hours: {peak_hours}"
+        )
+        
+        # Analyze learning trends
+        sentiment_trend = report['temporal_analysis']['learning_trends']['sentiment_trend']
+        if sentiment_trend < 0:
+            recommendations.append(
+                "Review teaching approach to address declining student satisfaction"
+            )
+        
+        return recommendations
+
+if __name__ == "__main__":
+    # Load chat history data
+    with open("chat_history_corpus.json", "r", encoding="utf-8") as file:
+        chat_history = json.load(file)
+    
+    # Initialize analytics system
+    analytics = PreClassAnalytics()
+    
+    # Generate comprehensive report
+    report = analytics.generate_comprehensive_report(chat_history)
+    print(json.dumps(report, indent=2))

session_page.py

@@ -1288,11 +1288,41 @@ def get_preclass_analytics(session):
     # return refined_report
 
     # Use the 2nd analytice engine (using LLM): 
+    fallback_analytics = {
+        "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"
+                }
+            ],
+            "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": []
+            }
+    }
     analytics_generator = NovaScholarAnalytics()
     analytics2 = analytics_generator.generate_analytics(all_chat_histories, topics)
     # enriched_analytics = analytics_generator._enrich_analytics(analytics2)
     print("Analytics is: ", analytics2)
-    return analytics2
+    
+    if analytics2 == fallback_analytics:
+        return None
+    else:
+        return analytics2
     # print(json.dumps(analytics, indent=2))
 
 
@@ -1305,9 +1335,16 @@ def display_preclass_analytics2(session, course_id):
     # Initialize or get analytics data from session state
     if 'analytics_data' not in st.session_state:
         st.session_state.analytics_data = get_preclass_analytics(session)
+    if 'topic_indices'not in st.session_state:
+        st.session_state.topic_indices = None 
     
-    analytics = st.session_state.analytics_data
+    if st.session_state.analytics_data:
+        analytics = st.session_state.analytics_data
+    else:
+        st.info("No analytics data found for this session.")
+        return
     
+    print(analytics)
     # Enhanced CSS for better styling and interactivity
     st.markdown("""
         <style>
@@ -1497,133 +1534,133 @@ def display_preclass_analytics2(session, course_id):
     if 'topic_indices' not in st.session_state:
         st.session_state.topic_indices = list(range(len(analytics["topic_wise_insights"])))
 
+    if st.session_state.topic_indices: 
+        st.markdown('<div class="topic-list">', unsafe_allow_html=True)
+        for idx in st.session_state.topic_indices:
+            topic = analytics["topic_wise_insights"][idx]
+            topic_id = f"topic_{idx}"
+            
+            # Create clickable header
+            col1, col2 = st.columns([3, 1])
+            with col1:
+                if st.button(
+                    topic["topic"],
+                    key=f"topic_button_{idx}",
+                    use_container_width=True,
+                    type="secondary"
+                ):
+                    st.session_state.expanded_topic = topic_id if st.session_state.expanded_topic != topic_id else None
+            
+            with col2:
+                st.markdown(f"""
+                    <div style="text-align: right;">
+                        <span class="topic-struggling-rate">{topic["struggling_percentage"]*100:.1f}% Struggling</span>
+                    </div>
+                """, unsafe_allow_html=True)
+            
+            # Show content if topic is expanded
+            if st.session_state.expanded_topic == topic_id:
+                st.markdown(f"""
+                    <div class="topic-content">
+                        <div class="section-heading">Key Issues</div>
+                        <ul>
+                            {"".join([f"<li>{issue}</li>" for issue in topic["key_issues"]])}
+                        </ul>
+                        <div class="section-heading">Key Misconceptions</div>
+                        <ul>
+                            {"".join([f"<li>{misc}</li>" for misc in topic["key_misconceptions"]])}
+                        </ul>
+                    </div>
+                """, unsafe_allow_html=True)
+        st.markdown('</div>', unsafe_allow_html=True)
 
-    st.markdown('<div class="topic-list">', unsafe_allow_html=True)
-    for idx in st.session_state.topic_indices:
-        topic = analytics["topic_wise_insights"][idx]
-        topic_id = f"topic_{idx}"
-        
-        # Create clickable header
-        col1, col2 = st.columns([3, 1])
-        with col1:
-            if st.button(
-                topic["topic"],
-                key=f"topic_button_{idx}",
-                use_container_width=True,
-                type="secondary"
-            ):
-                st.session_state.expanded_topic = topic_id if st.session_state.expanded_topic != topic_id else None
-        
-        with col2:
-            st.markdown(f"""
-                <div style="text-align: right;">
-                    <span class="topic-struggling-rate">{topic["struggling_percentage"]*100:.1f}% Struggling</span>
-                </div>
-            """, unsafe_allow_html=True)
-        
-        # Show content if topic is expanded
-        if st.session_state.expanded_topic == topic_id:
+        # AI Recommendations Section
+        st.markdown('<h2 class="section-title">AI-Powered Recommendations</h2>', unsafe_allow_html=True)
+        st.markdown('<div class="recommendation-grid">', unsafe_allow_html=True)
+        for idx, rec in enumerate(analytics["ai_recommended_actions"]):
             st.markdown(f"""
-                <div class="topic-content">
-                    <div class="section-heading">Key Issues</div>
-                    <ul>
-                        {"".join([f"<li>{issue}</li>" for issue in topic["key_issues"]])}
-                    </ul>
-                    <div class="section-heading">Key Misconceptions</div>
-                    <ul>
-                        {"".join([f"<li>{misc}</li>" for misc in topic["key_misconceptions"]])}
-                    </ul>
+                <div class="recommendation-card">
+                    <h4>
+                        <span>Recommendation {idx + 1}</span>
+                        <span class="priority-badge">{rec["priority"]}</span>
+                    </h4>
+                    <p>{rec["action"]}</p>
+                    <p><span class="reason">Reason:</span>  {rec["reasoning"]}</p>
+                    <p><span class="reason">Expected Outcome:</span>  {rec["expected_outcome"]}</p>
                 </div>
             """, unsafe_allow_html=True)
-    st.markdown('</div>', unsafe_allow_html=True)
+        st.markdown('</div>', unsafe_allow_html=True)
 
-    # AI Recommendations Section
-    st.markdown('<h2 class="section-title">AI-Powered Recommendations</h2>', unsafe_allow_html=True)
-    st.markdown('<div class="recommendation-grid">', unsafe_allow_html=True)
-    for idx, rec in enumerate(analytics["ai_recommended_actions"]):
-        st.markdown(f"""
-            <div class="recommendation-card">
-                <h4>
-                    <span>Recommendation {idx + 1}</span>
-                    <span class="priority-badge">{rec["priority"]}</span>
-                </h4>
-                <p>{rec["action"]}</p>
-                <p><span class="reason">Reason:</span>  {rec["reasoning"]}</p>
-                <p><span class="reason">Expected Outcome:</span>  {rec["expected_outcome"]}</p>
-            </div>
-        """, unsafe_allow_html=True)
-    st.markdown('</div>', unsafe_allow_html=True)
-
-    # Student Analytics Section
-    st.markdown('<h2 class="section-title">Student Analytics</h2>', unsafe_allow_html=True)
-    
-    # Filters
-    with st.container():
-        # st.markdown('<div class="student-filters">', unsafe_allow_html=True)
-        col1, col2, col3 = st.columns(3)
-        with col1:
-            concept_understanding = st.selectbox(
-                "Filter by Understanding",
-                ["All", "Strong", "Moderate", "Needs Improvement"]
-            )
-        with col2:
-            participation_level = st.selectbox(
-                "Filter by Participation",
-                ["All", "High (>80%)", "Medium (50-80%)", "Low (<50%)"]
-            )
-        with col3:
-            struggling_topic = st.selectbox(
-                "Filter by Struggling Topic",
-                ["All"] + list(set([topic for student in analytics["student_analytics"] 
-                                  for topic in student["struggling_topics"]]))
-            )
-        # st.markdown('</div>', unsafe_allow_html=True)
-
-    # Display student metrics in a grid
-    st.markdown('<div class="analytics-grid">', unsafe_allow_html=True)
-    for student in analytics["student_analytics"]:
-        # Apply filters
-        if (concept_understanding != "All" and 
-            student["engagement_metrics"]["concept_understanding"].replace("_", " ").title() != concept_understanding):
-            continue
-            
-        participation = student["engagement_metrics"]["participation_level"] * 100
-        if participation_level != "All":
-            if participation_level == "High (>80%)" and participation <= 80:
-                continue
-            elif participation_level == "Medium (50-80%)" and (participation < 50 or participation > 80):
-                continue
-            elif participation_level == "Low (<50%)" and participation >= 50:
+        # Student Analytics Section
+        st.markdown('<h2 class="section-title">Student Analytics</h2>', unsafe_allow_html=True)
+        
+        # Filters
+        with st.container():
+            # st.markdown('<div class="student-filters">', unsafe_allow_html=True)
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                concept_understanding = st.selectbox(
+                    "Filter by Understanding",
+                    ["All", "Strong", "Moderate", "Needs Improvement"]
+                )
+            with col2:
+                participation_level = st.selectbox(
+                    "Filter by Participation",
+                    ["All", "High (>80%)", "Medium (50-80%)", "Low (<50%)"]
+                )
+            with col3:
+                struggling_topic = st.selectbox(
+                    "Filter by Struggling Topic",
+                    ["All"] + list(set([topic for student in analytics["student_analytics"] 
+                                    for topic in student["struggling_topics"]]))
+                )
+            # st.markdown('</div>', unsafe_allow_html=True)
+
+        # Display student metrics in a grid
+        st.markdown('<div class="analytics-grid">', unsafe_allow_html=True)
+        for student in analytics["student_analytics"]:
+            # Apply filters
+            if (concept_understanding != "All" and 
+                student["engagement_metrics"]["concept_understanding"].replace("_", " ").title() != concept_understanding):
                 continue
                 
-        if struggling_topic != "All" and struggling_topic not in student["struggling_topics"]:
-            continue
+            participation = student["engagement_metrics"]["participation_level"] * 100
+            if participation_level != "All":
+                if participation_level == "High (>80%)" and participation <= 80:
+                    continue
+                elif participation_level == "Medium (50-80%)" and (participation < 50 or participation > 80):
+                    continue
+                elif participation_level == "Low (<50%)" and participation >= 50:
+                    continue
+                    
+            if struggling_topic != "All" and struggling_topic not in student["struggling_topics"]:
+                continue
 
-        st.markdown(f"""
-            <div class="student-metrics-card">
-                <div class="header">
-                    <span class="student-id">Student {student["student_id"][-6:]}</span>
-                </div>
-                <div class="metrics-grid">
-                    <div class="metric-box">
-                        <div class="label">Participation</div>
-                        <div class="value">{student["engagement_metrics"]["participation_level"]*100:.1f}%</div>
-                    </div>
-                    <div class="metric-box">
-                        <div class="label">Understanding</div>
-                        <div class="value">{student["engagement_metrics"]["concept_understanding"].replace('_', ' ').title()}</div>
-                    </div>
-                    <div class="struggling-topics">
-                        <div class="label">Struggling Topics: </div>
-                        <div class="value">{", ".join(student["struggling_topics"]) if student["struggling_topics"] else "None"}</div>
+            st.markdown(f"""
+                <div class="student-metrics-card">
+                    <div class="header">
+                        <span class="student-id">Student {student["student_id"][-6:]}</span>
                     </div>
-                    <div class="recommendation-text">
-                        {student["personalized_recommendation"]}
+                    <div class="metrics-grid">
+                        <div class="metric-box">
+                            <div class="label">Participation</div>
+                            <div class="value">{student["engagement_metrics"]["participation_level"]*100:.1f}%</div>
+                        </div>
+                        <div class="metric-box">
+                            <div class="label">Understanding</div>
+                            <div class="value">{student["engagement_metrics"]["concept_understanding"].replace('_', ' ').title()}</div>
+                        </div>
+                        <div class="struggling-topics">
+                            <div class="label">Struggling Topics: </div>
+                            <div class="value">{", ".join(student["struggling_topics"]) if student["struggling_topics"] else "None"}</div>
+                        </div>
+                        <div class="recommendation-text">
+                            {student["personalized_recommendation"]}
+                        </div>
                     </div>
                 </div>
-            </div>
-        """, unsafe_allow_html=True)
-    st.markdown('</div>', unsafe_allow_html=True)
+            """, unsafe_allow_html=True)
+        st.markdown('</div>', unsafe_allow_html=True)
 
 def reset_analytics_state():
     """