Added app [Not required, just for reference], llm handler and streamlit_app files, requirements is yet to be added

Streamlit_app.py

@@ -0,0 +1,194 @@
+import streamlit as st
+import json
+from openai_llm import LessonPlanGenerator
+
+# Page configuration
+st.set_page_config(
+    page_title="Lesson Plan Generator",
+   # page_icon="📚",
+    layout="wide"
+)
+
+# Custom CSS with corrected container styling
+st.markdown("""
+    <style>
+    /* Main container */
+    .main-container {
+        background-color: white;
+        border-radius: 8px;
+        padding: 25px;
+        margin: 20px 0;
+        box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+    }
+
+    /* Section styling */
+    .section {
+        margin: 15px 0;
+        padding: 10px 0;
+        border-bottom: 1px solid #eee;
+    }
+
+    /* Header styling */
+    .section-header {
+        color: #1a237e;
+        font-size: 18px;
+        font-weight: 600;
+        margin-bottom: 10px;
+    }
+
+    /* Content styling */
+    .section-content {
+        color: #333;
+        margin-left: 20px;
+    }
+
+    /* List item styling */
+    .list-item {
+        margin: 5px 0;
+        color: #333;
+    }
+
+    /* Nested content */
+    .nested-content {
+        margin-left: 20px;
+        padding-left: 10px;
+        border-left: 2px solid #e8eaf6;
+    }
+    </style>
+""", unsafe_allow_html=True)
+
+
+# Initialize generator
+@st.cache_resource
+def get_generator():
+    return LessonPlanGenerator()
+
+
+generator = get_generator()
+
+# Header
+st.title("WizLab Lesson Plan Generator")
+st.markdown("We help you generate lesson plans tailored to your needs.")
+
+# Input section
+st.header("📝 Input Your Requirements")
+
+# Create two columns for input fields
+col1, col2 = st.columns(2)
+
+with col1:
+    topic = st.text_input("Topic", placeholder="e.g., Introduction to Photosynthesis")
+
+    age_group_options = ["Elementary (6-11)", "Middle School (12-14)",
+                         "High School (15-18)", "Adult Learners", "Other"]
+    age_group_selection = st.selectbox("Target Age Group", age_group_options)
+    if age_group_selection == "Other":
+        age_group = st.text_input("Specify Age Group")
+    else:
+        age_group = age_group_selection
+
+with col2:
+    duration_options = ["30 minutes", "45 minutes", "60 minutes", "90 minutes", "Other"]
+    duration_selection = st.selectbox("Lesson Duration", duration_options)
+    if duration_selection == "Other":
+        duration = st.text_input("Specify Duration")
+    else:
+        duration = duration_selection
+
+    proficiency_options = ["Beginner", "Intermediate", "Advanced", "Other"]
+    proficiency_selection = st.selectbox("Proficiency Level", proficiency_options)
+    if proficiency_selection == "Other":
+        proficiency = st.text_input("Specify Proficiency Level")
+    else:
+        proficiency = proficiency_selection
+
+tech_options = ["Interactive Whiteboard", "Computers/Laptops",
+                "Mobile Devices", "Internet Access", "None", "Other"]
+tech_selection = st.multiselect("Technology Requirements", tech_options)
+
+if "Other" in tech_selection:
+    other_tech = st.text_input("Specify Other Technology Requirements")
+    tech_usage = [tech for tech in tech_selection if tech != "Other"] + [other_tech]
+else:
+    tech_usage = tech_selection
+
+
+def format_content(data):
+    html_content = '<div class="main-container">'
+
+    def process_value(value, level=0):
+        if isinstance(value, dict):
+            return process_dict(value, level)
+        elif isinstance(value, list):
+            return process_list(value, level)
+        else:
+            return f'<div class="section-content">{value}</div>'
+
+    def process_dict(d, level):
+        content = ""
+        for key, value in d.items():
+            formatted_key = key.replace("_", " ").title()
+            content += f'<div class="section">'
+            content += f'<div class="section-header">{formatted_key}</div>'
+            content += process_value(value, level + 1)
+            content += '</div>'
+        return content
+
+    def process_list(lst, level):
+        content = '<div class="section-content">'
+        for item in lst:
+            if isinstance(item, dict):
+                content += process_dict(item, level + 1)
+            else:
+                content += f'<div class="list-item">• {item}</div>'
+        content += '</div>'
+        return content
+
+    html_content += process_dict(data, 0)
+    html_content += '</div>'
+    return html_content
+
+
+# Generate button
+if st.button("Generate Lesson Plan", type="primary"):
+    if not topic:
+        st.error("Please enter a topic for the lesson plan.")
+    else:
+        with st.spinner("Generating your lesson plan..."):
+            detailed_prompt = f"""
+            Create a lesson plan for teaching '{topic}' to {age_group} students.
+            Duration: {duration}
+            Proficiency Level: {proficiency}
+            Technology Requirements: {', '.join(tech_usage) if tech_usage else 'None'}
+            """
+
+            try:
+                result = generator.generate_lesson_plan(detailed_prompt)
+                st.success("Lesson plan generated successfully!")
+
+                # Create tabs for different views
+                tab1, tab2 = st.tabs(["Formatted View", "Raw JSON"])
+
+                with tab1:
+                    if isinstance(result, dict):
+                        # Display formatted content in white container
+                        st.markdown(format_content(result), unsafe_allow_html=True)
+                    else:
+                        st.error("Invalid response format")
+
+                with tab2:
+                    st.json(result)
+
+                # Download button
+                st.download_button(
+                    label="Download Lesson Plan",
+                    data=json.dumps(result, indent=2),
+                    file_name="lesson_plan.json",
+                    mime="application/json"
+                )
+
+            except Exception as e:
+                st.error(f"An error occurred: {str(e)}")
+
+# Footer
+st.markdown("---")

app.py

@@ -0,0 +1,30 @@
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+from openai_llm import LessonPlanGenerator
+
+app = Flask(__name__)
+CORS(app)
+
+# Initialize the lesson plan generator
+lesson_generator = LessonPlanGenerator()
+
+
+@app.route('/generate-lesson-plan', methods=['POST'])
+def generate_lesson_plan():
+    try:
+        data = request.get_json()
+
+        if not data or 'topic' not in data:
+            return jsonify({"error": "No topic provided"}), 400
+
+        topic = data['topic']
+        lesson_plan = lesson_generator.generate_lesson_plan(topic)
+
+        return jsonify(lesson_plan)
+
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+if __name__ == '__main__':
+    app.run(debug=True)

openai_llm.py

@@ -0,0 +1,59 @@
+import os
+from openai import OpenAI
+from dotenv import load_dotenv
+
+load_dotenv()
+class LessonPlanGenerator:
+    def __init__(self):
+        # Load environment variables
+
+
+        # Initialize OpenAI client
+        self.client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
+
+        # System prompt for lesson plan generation
+
+
+    def generate_lesson_plan(self, topic):
+        system_prompt = """
+                You are an advanced lesson plan generator. When provided with an input text prompt that requests a lesson plan on a specific topic, along with parameters such as learner age, proficiency level, duration, and tech usage, follow these steps:
+                1.	Extract Input Parameters:
+                • Identify the topic, target learner group (age and proficiency), lesson duration, and any technology requirements.
+                2.	Determine the Appropriate Framework:
+                • For young learners with clear sequential activities, select an activity-based framework such as PPP (Presentation, Practice, Production) or one of the ESA variants (Straight Arrow, Boomerang, or Patchwork).
+                • For adult learners or contexts that require diagnostic assessment followed by targeted instruction, consider the TTT (Test, Teach, Test) framework.
+                • For high school learners or lessons focused on collaborative tasks and discussion, consider using the TBL (Task-Based Learning) framework.
+                • For lessons that require comprehensive, backward-designed planning with a focus on understanding, essential questions, and transfer of learning, use the UbD (Understanding by Design) framework. In this case, structure the lesson plan into three stages: Stage 1 – Desired Results, Stage 2 – Assessment Evidence, and Stage 3 – Learning Plan.
+                3.	Generate a JSON Structure:
+                • Your output should be a well-formed JSON object containing sections for:
+                - Objectives and learning outcomes
+                - Essential questions (if using UbD)
+                - Detailed activities and timings
+                - Assessment strategies
+                - Materials and resources
+                - Any other relevant details based on the chosen framework
+                4.	Ensure Adaptability:
+                While the examples provided (PPP, ESA, TTT, TBL, and UbD) serve as guidance, 
+                you are not restricted to these frameworks. If another lesson plan structure or innovative approach better aligns with the input parameters,
+                feel free to choose and implement that structure. 
+                5. Ensure that your output is organized 
+                in a clear JSON format with sections for objectives, assessments, learning activities, and resources.
+               
+                """
+        try:
+            response = self.client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": f"Create a lesson plan for: {topic}"}
+                ],
+                response_format={"type": "json_object"}  # This ensures JSON output
+            )
+
+            # If you want to strictly parse the response
+            import json
+            return json.loads(response.choices[0].message.content, strict=True)
+
+        except Exception as e:
+            return {"error": str(e)}
+