create_course2.py

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)