Upload 17 files

.env.example

@@ -0,0 +1,2 @@
+OPENAI_API_KEY=your_openai_api_key
+DATABASE_URL=your_postgres_database_url

.gitignore

@@ -0,0 +1,13 @@
+# Virtual environments
+.venv/
+venv/
+
+.myenv/
+myenv/
+
+# Python cache files
+__pycache__/
+*.pyc
+
+# Environment variables
+.env

Install-Instructions.txt

@@ -0,0 +1,8 @@
+Setup Database
+---------------
+After create DB, get the connection string and update:
+a. Database\DatabaseSetup.py
+    line 6: url = "post..."
+b. then run the file via "visual studio code", so the tables are created.
+c. update the db con string in 'database_functions.py'
+    line 12: url = "postgr..."

app.py

@@ -0,0 +1,255 @@
+# app.py
+import gradio as gr
+import asyncio
+import os
+import thinkingframes
+import soundfile as sf
+import numpy as np
+import logging
+from openai import OpenAI
+from dotenv import load_dotenv
+from policy import user_acceptance_policy
+from styles import theme
+from thinkingframes import generate_prompt, strategy_options
+from utils import get_image_html, collect_student_info
+from database_functions import add_submission
+from tab_teachers_dashboard import create_teachers_dashboard_tab
+from config import CLASS_OPTIONS
+from concurrent.futures import ThreadPoolExecutor
+
+# Load CSS from external file
+with open('styles.css', 'r') as file:
+    css = file.read()
+
+# For maintaining user session (to keep track of userID)
+user_state = gr.State(value="")
+
+load_dotenv()
+
+client = OpenAI()
+image_path = "picturePerformance.jpg"
+img_html = get_image_html(image_path)
+
+# Create a thread pool executor
+executor = ThreadPoolExecutor()
+
+def transcribe_audio(audio_path):
+    with open(audio_path, "rb") as audio_file:
+        transcript = client.audio.transcriptions.create(file=audio_file, model="whisper-1", language="en")
+    return transcript.text
+
+async def generate_feedback(user_id, question_choice, strategy_choice, message, feedback_level):
+    current_question_index = thinkingframes.questions.index(question_choice)
+    strategy, explanation = thinkingframes.strategy_options[strategy_choice]
+
+    conversation = [{
+        "role": "system",
+        "content": f"You are an expert Primary 6 English Language Teacher in a Singapore Primary school, "
+                   f"directly guiding a Primary 6 student in Singapore in their oral responses. "
+                   f"Format the feedback in Markdown so that it can be easily read. "
+                   f"Address the student directly in the second person in your feedback. "
+                   f"The student is answering the question: '{thinkingframes.questions[current_question_index]}'. "
+                   f"For Question 1, consider the picture description: '{thinkingframes.description}'. "
+                   f"For Questions 2 and 3, the picture is not relevant, so the student should not refer to it in their response. "
+                   f"Analyze the student's response using the following step-by-step approach: "
+                   f"1. Evaluate the response against the {strategy} thinking frame. "
+                   f"2. Assess how well the student's response addresses each component of the {strategy} thinking frame: "
+                   f"   - Assign emoticon scores based on how well the student comprehensively covered each component: "
+                   f"     - 😊😊😊 (three smiling faces) for a good coverage "
+                   f"     - 😊😊 (two smiling faces) for an average coverage "
+                   f"     - 😊 (one smiling face) for a poor coverage "
+                   f"   - Provide a clear, direct, and concise explanation of how well the answer addresses each component. "
+                   f"   - Identify specific areas for improvement in students responses, and provide targeted suggestions for improvement. "
+                   f"3. Identify overall strengths and areas for improvement in the student's response using the {strategy} to format and provide targeted areas for improvement. "
+                   f"4. Provide specific feedback on grammar, vocabulary, and sentence structure. "
+                   f"   Suggest age-appropriate enhancements that are one level higher than the student's current response. "
+                   f"5. Conclude with follow-up questions for reflection. "
+                   f"If the student's response deviates from the question, provide clear and concise feedback to help them refocus and try again. "
+                   f"Ensure that the vocabulary and sentence structure recommendations are achievable for Primary 6 students in Singapore. "
+                   f"Example Feedback Structure for Each Component: "
+                   f"Component: [Component Name] "
+                   f"Score: [Smiling emoticons] "
+                   f"Explanation: [Clear, direct, and concise explanation of how well the answer addresses the component. Identify specific areas for improvement, and provide targeted suggestions for improvement.] "
+                   f"{thinkingframes.generate_prompt(feedback_level)}"
+    }, {
+        "role": "user",
+        "content": message
+    }]
+
+    response = client.chat.completions.create(
+        model='gpt-4o-2024-05-13',
+        messages=conversation,
+        temperature=0.6,
+        max_tokens=1000,
+        stream=True
+    )
+
+    chat_history = []  # Initialize chat history outside the loop
+    full_feedback = ""  # Accumulate the entire feedback message
+    try:
+        for chunk in response:
+            if chunk.choices[0].delta and chunk.choices[0].delta.content:
+                feedback_chunk = chunk.choices[0].delta.content
+                full_feedback += feedback_chunk  # Accumulate the feedback
+                await asyncio.sleep(0)
+
+        # Append the complete feedback to the chat history
+        chat_history.append(("Oral Coach  ⚡ ϞϞ(๑⚈ ․̫ ⚈๑)∩ ⚡", full_feedback))
+        yield chat_history  # Yield the chat history only once
+
+    except Exception as e:
+        logging.error(f"An error occurred during feedback generation: {str(e)}")
+
+    questionNo = current_question_index + 1
+    # Save complete feedback after streaming
+    add_submission(user_id, message, full_feedback, int(0), "", questionNo)
+
+async def generate_audio_feedback(feedback_buffer):
+    try:
+        response = client.audio.speech.create(
+            model="tts-1",
+            voice="alloy",
+            input=feedback_buffer,
+            response_format="wav"
+        )
+
+        audio_data = np.frombuffer(response.read(), dtype=np.int16)
+        sample_rate = 24000  # Default sample rate for OpenAI's WAV output
+
+        return (sample_rate, audio_data)
+
+    except Exception as e:
+        logging.error(f"An error occurred during speech generation: {str(e)}")
+        return None  # Return None in case of an error
+
+async def predict(question_choice, strategy_choice, feedback_level, audio):
+    current_audio_output = None  # Initialize current_audio_output to None
+    final_feedback = ""  # Store only the assistant's feedback
+
+    if audio is None:
+        yield [("Oral Coach  ⚡ ϞϞ(๑⚈ ․̫ ⚈๑)∩ ⚡", "No audio data received. Please try again.")], current_audio_output
+        return
+    
+    sample_rate, audio_data = audio
+
+    if audio_data is None or len(audio_data) == 0:
+        yield [("Oral Coach  ⚡ ϞϞ(๑⚈ ․̫ ⚈๑)∩ ⚡", "No audio data received. Please try again.")], current_audio_output
+        return
+
+    audio_path = "audio.wav"
+    if not isinstance(audio_data, np.ndarray):
+        raise ValueError("audio_data must be a numpy array")
+    sf.write(audio_path, audio_data, sample_rate)
+
+    chat_history = [("Oral Coach  ⚡ ϞϞ(๑⚈ ․̫ ⚈๑)∩ ⚡", "Transcribing your audio, please listen to your oral response while waiting ...")]
+    yield chat_history, current_audio_output
+
+    try:
+        transcription_future = executor.submit(transcribe_audio, audio_path)
+        student_response = await asyncio.wrap_future(transcription_future)
+
+        if not student_response.strip():
+            yield [("Oral Coach  ⚡ ϞϞ(๑⚈ ․̫ ⚈๑)∩ ⚡", "Transcription failed. Please try again or seek assistance.")], current_audio_output
+            return
+
+        chat_history.append(("Student", student_response))  # Add student's transcript
+        yield chat_history, current_audio_output
+
+        chat_history.append(("Oral Coach  ⚡ ϞϞ(๑⚈ ․̫ ⚈๑)∩ ⚡", "Transcription complete. Generating feedback. Please continue listening to your oral response while waiting ..."))
+        yield chat_history, current_audio_output
+
+        moderation_response = client.moderations.create(input=student_response)
+        flagged = any(result.flagged for result in moderation_response.results)
+        if flagged:
+            moderated_message = "The message has been flagged. Please see your teacher to clarify."
+            questionNo = thinkingframes.questions.index(question_choice) + 1
+            add_submission(int(user_state.value), moderated_message, "", int(0), "", questionNo)
+            yield chat_history, current_audio_output
+            return
+
+        async for chat_update in generate_feedback(int(user_state.value), question_choice, strategy_choice, student_response, feedback_level):
+                # Append the assistant's feedback to the existing chat_history
+                chat_history.extend(chat_update)  
+                final_feedback = chat_history[-1][1]  # Update final_feedback with the latest chunk
+                yield chat_history, current_audio_output # Yield audio output
+
+        feedback_buffer = final_feedback  # Use final_feedback for TTS
+        audio_task = asyncio.create_task(generate_audio_feedback(feedback_buffer))
+        current_audio_output = await audio_task  # Store audio output
+        yield chat_history, current_audio_output  # Yield audio output
+
+    except Exception as e:
+        logging.error(f"An error occurred: {str(e)}", exc_info=True)
+        yield [("Oral Coach  ⚡ ϞϞ(๑⚈ ․̫ ⚈๑)∩ ⚡", "An error occurred. Please try again or seek assistance.")], current_audio_output
+
+with gr.Blocks(title="Oral Coach  ⚡ ϞϞ(๑⚈ ․̫ ⚈๑)∩ ⚡", theme=theme, css=css) as app:
+    with gr.Tab("Oral Coach  ⚡ ϞϞ(๑⚈ ․̫ ⚈๑)∩ ⚡"):
+        gr.Markdown("## Student Information")
+        class_name = gr.Dropdown(label="Class", choices=CLASS_OPTIONS)
+        index_no = gr.Dropdown(label="Index No", choices=[f"{i:02}" for i in range(1, 46)])
+
+        policy_text = gr.Markdown(user_acceptance_policy)
+        policy_checkbox = gr.Checkbox(label="I have read and agree to the Things to Note When using the Oral Coach  ⚡ ϞϞ(๑⚈ ․̫ ⚈๑)∩ ⚡", value=False)
+
+        submit_info_btn = gr.Button("Submit Info")
+        info_output = gr.Text()
+  
+        with gr.Column(visible=False) as oral_coach_content:
+            gr.Markdown("## English Language Oral Coach  ⚡ ϞϞ(๑⚈ ․̫ ⚈๑)∩ ⚡")
+            gr.Markdown(img_html)  # Display the image
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### Step 1: Choose a Question")
+                    question_choice = gr.Radio(thinkingframes.questions, label="Questions", value=thinkingframes.questions[0])
+                    gr.Markdown("### Step 2: Choose a Thinking Frame")
+                    strategy_choice = gr.Dropdown(list(strategy_options.keys()), label="Thinking Frame", value=list(strategy_options.keys())[0])
+                    gr.Markdown("### Step 3: Choose Feedback Level")
+                    feedback_level = gr.Radio(["Brief Feedback", "Moderate Feedback", "Comprehensive Feedback"], label="Feedback Level")
+                    feedback_level.value = "Brief Feedback"
+
+                with gr.Column(scale=1):
+                    gr.Markdown("### Step 4: Record Your Answer")
+                    audio_input = gr.Audio(type="numpy", sources=["microphone"], label="Record")
+                    submit_answer_btn = gr.Button("Submit Oral Response")
+
+                    gr.Markdown("### Step 5: Review your personalised feedback")
+                    feedback_output = gr.Chatbot(
+                        label="Feedback",
+                        scale=4,
+                        height=700,
+                        show_label=True
+                    )
+                    #audio
+            #submit_answer_here        
+                    audio_output = gr.Audio(type="numpy", label="Audio Playback", format="wav", autoplay="True")
+
+            submit_answer_btn.click(
+                predict,
+                inputs=[question_choice, strategy_choice, feedback_level, audio_input],
+                outputs=[feedback_output, audio_output],
+                api_name="predict"
+            )
+
+        def toggle_oral_coach_visibility(class_name, index_no, policy_checked):
+            if not policy_checked:
+                return "Please agree to the Things to Note When using the Oral Coach  ⚡ ϞϞ(๑⚈ ․̫ ⚈๑)∩ ⚡ before submitting.", gr.update(visible=False)
+            validation_passed, message, userid = collect_student_info(class_name, index_no)
+            if not validation_passed:
+                return message, gr.update(visible=False)
+            user_state.value = userid
+            return message, gr.update(visible=True)
+
+        submit_info_btn.click(
+            toggle_oral_coach_visibility,
+            inputs=[class_name, index_no, policy_checkbox],
+            outputs=[info_output, oral_coach_content]
+        )
+
+    # Define other tabs like Teacher's Dashboard
+    create_teachers_dashboard_tab()
+
+app.queue(max_size=20).launch(
+    debug=True,
+    server_port=int(os.environ.get("PORT", 10000)),
+    favicon_path="favicon.ico"
+)

config.py

@@ -0,0 +1,2 @@
+# In constants.py or config.py
+CLASS_OPTIONS = ["Demo","Testing Only", "Teacher"]

database_functions.py

@@ -0,0 +1,238 @@
+# database_functions.py
+import psycopg2
+import random
+import string
+from urllib.parse import urlparse
+from datetime import datetime
+import json
+from dotenv import load_dotenv
+import os
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Get the database URL from the environment variables
+url = os.getenv("DATABASE_URL")
+if not url:
+    raise ValueError("DATABASE_URL is not set in the environment variables")
+
+parsed_url = urlparse(url)
+
+# Extract connection parameters
+db_config = {
+    'user': parsed_url.username,
+    'password': parsed_url.password,
+    'host': parsed_url.hostname,
+    'port': parsed_url.port,
+    'database': parsed_url.path.lstrip('/')
+}
+
+# Since we define password in schema, we will just generate password
+def generate_password():
+    characters = string.ascii_letters + string.digits + string.punctuation
+    password = ''.join(random.choice(characters) for _ in range(8))
+    return password
+
+# add student method (privacy with only class & indexNo)
+def add_user_privacy(class_name, index_no):
+    connection = psycopg2.connect(**db_config)
+    cursor = connection.cursor() 
+    password = generate_password()
+    dbMsg = ""
+
+    try:
+        # Check if user with the same email already exists
+        cursor.execute("SELECT id FROM oc_students WHERE class = %s and index_no = %s", (class_name,index_no))
+        existing_user = cursor.fetchone()
+        if existing_user:
+            user_id = existing_user[0]
+            dbMsg = "User already exists"
+        else:
+            # If user doesn't exist, insert a new user
+            cursor.execute("INSERT INTO oc_students (index_no, class, hashPassword) VALUES (%s, %s, %s) RETURNING id",
+                       (index_no, class_name, password))
+            user_id = cursor.fetchone()[0]  # Fetch the ID of the newly inserted user
+            connection.commit()  # without this, data is not persist on db!
+            dbMsg = "User Created"
+        return user_id, dbMsg
+
+    except psycopg2.Error as e:
+        return "Error adding user:" +  str(e)
+
+def add_submission(userid, transcribed_text, ai_responses, scores, feedback, questionNo):
+    connection = psycopg2.connect(**db_config)
+    cursor = connection.cursor() 
+    dbMsg = ""
+    
+    try:
+        current_datetime = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+        cursor.execute("INSERT INTO oc_submissions (userid, datetime, Transcribed_text, AI_conversation_responses, Scores, Feedback, questionNo) "
+                       "VALUES (%s, %s, %s, %s, %s, %s, %s)",
+                       (userid, current_datetime, transcribed_text, ai_responses, scores, feedback, questionNo))
+        connection.commit()
+        dbMsg = "Submission added"
+
+    except psycopg2.Error as e:
+        print("Error adding submission:", e)
+
+    finally:
+        if connection:
+            cursor.close()
+            connection.close()
+            print("PostgreSQL connection is closed")
+
+def get_submissions_by_date_and_class(from_date, to_date, class_name, display_ai_feedback):
+    # Connect to the database
+    conn = psycopg2.connect(**db_config)
+    cursor = conn.cursor()
+
+    try:
+        print(f"From Date: {from_date}")
+        print(f"To Date: {to_date}")
+        print(f"Class Name: {class_name}")
+
+        # Swap from_date and to_date if from_date is later than to_date
+        if from_date > to_date:
+            from_date, to_date = to_date, from_date
+
+        query = """
+            SELECT s.index_no, s.class, sub.datetime, sub.questionNo, sub.transcribed_text,
+                   CASE WHEN %s THEN sub.ai_conversation_responses ELSE NULL END AS ai_conversation_responses,
+                   sub.userid
+            FROM oc_students AS s
+            JOIN oc_submissions AS sub ON s.id = sub.userid
+            WHERE TO_DATE(sub.datetime::text, 'YYYY-MM-DD') BETWEEN TO_DATE(%s, 'YYYY-MM-DD') AND TO_DATE(%s, 'YYYY-MM-DD')
+            AND s.class = %s
+            ORDER BY sub.userid, sub.questionNo, sub.datetime DESC
+        """
+        cursor.execute(query, (display_ai_feedback, from_date, to_date, class_name))
+
+        results = cursor.fetchall()
+
+        if results:
+            return generate_report_as_json(results, display_ai_feedback)
+        else:
+            return [{"Email": "No data found for the selected date range and class", "Name": "", "Class": "", "Datetime": "", "Transcribed Text": "", "AI Conversation Responses": ""}]
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return [{"Email": "Error occurred while fetching data", "Name": "", "Class": "", "Datetime": "", "Transcribed Text": "", "AI Conversation Responses": ""}]
+    finally:
+        cursor.close()
+        conn.close()
+
+def generate_report_as_json(results, display_ai_feedback):
+    user_ids_info = []  # To store tuples of (UserID, Name, Class)
+    user_question_map = {}  # To map UserID to answered questions
+
+    if results:
+        for result in results:
+            user_id = result[6]  # Assuming UserID is at index 6
+
+            # Storing tuples of (UserID, Name, Class)
+            user_info = (user_id, result[0], result[1])  # (UserID, Name, Class)
+            if user_info not in user_ids_info:
+                user_ids_info.append(user_info)
+
+            # Creating a map of UserIDs to answered questions
+            question = result[3]  # Assuming Question number is at index 3
+            details = {
+                "Datetime": result[2].strftime("%Y-%m-%d %H:%M:%S") if result[2] else "",
+                "Question": question,
+                "Student Response": result[4],
+                "AI Feedback": result[5] if display_ai_feedback else "Not displayed"
+            }
+            if user_id in user_question_map:
+                user_question_map[user_id].append(details)
+            else:
+                user_question_map[user_id] = [details]
+
+    report_data = []
+
+    for user_info in user_ids_info:
+        user_id, name, class_ = user_info
+
+        user_dict = {
+            "Index No": name,
+            "Class": class_,
+            "Questions": []
+        }
+
+        question_numbers = [1, 2, 3]  # List of required question numbers
+
+        if user_id in user_question_map:
+            user_questions = user_question_map[user_id]
+
+            for question_details in user_questions:
+                question_data = {
+                    "Question": question_details["Question"],
+                    "Datetime": question_details["Datetime"],
+                    "Student Response": question_details["Student Response"],
+                    "AI Feedback": question_details["AI Feedback"]
+                }
+                user_dict["Questions"].append(question_data)
+
+                # Remove answered question number from the (fixed list)
+                if question_data["Question"] in question_numbers:
+                    question_numbers.remove(question_data["Question"])
+
+        # Add NA entries for unanswered questions
+        for missing_question in question_numbers:
+            missing_question_data = {
+                "Question": missing_question,
+                "Datetime": "NA",
+                "Student Response": "NA",
+                "AI Feedback": "NA" if display_ai_feedback else "Not displayed"
+            }
+            user_dict["Questions"].append(missing_question_data)
+
+        # Sort the user's questions by question number before appending to report
+        user_dict["Questions"] = sorted(user_dict["Questions"], key=lambda x: x['Question'])
+
+        report_data.append(user_dict)
+
+    return json.dumps(report_data, indent=4)
+
+def getUniqueSubmitDate():
+    # Connect to the database
+    conn = psycopg2.connect(**db_config)
+    cursor = conn.cursor()
+
+    try:
+        # Fetch all submissions on the provided date
+        cursor.execute("""
+                SELECT DISTINCT DATE(datetime) AS unique_date
+                FROM public.oc_submissions
+                ORDER BY unique_date desc
+                LIMIT 14;
+                """)
+        dates = [str(row[0]) for row in cursor.fetchall()] 
+        return dates
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return [{"Error": "Error occurred while fetching data"}]
+    finally:
+        cursor.close()
+        conn.close()
+
+def getUniqueClass():
+    # Connect to the database
+    conn = psycopg2.connect(**db_config)
+    cursor = conn.cursor()
+
+    try:
+        # Fetch all submissions on the provided date
+        cursor.execute("""
+                SELECT DISTINCT s.class
+                FROM oc_students AS s
+                JOIN oc_submissions AS sub ON s.id = sub.userid
+                ORDER BY s.class
+                """)
+        listClass = [str(row[0]) for row in cursor.fetchall()] 
+        return listClass
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return [{"Error": "Error occurred while fetching data"}]
+    finally:
+        cursor.close()
+        conn.close()

policy.py

@@ -0,0 +1,33 @@
+# policy.py
+
+user_acceptance_policy = """**Oral Coach App🎤✨**
+
+This application uses a Large Language Model to generate responses for educational purposes.
+
+**Things to Note When using the Oral Coach**
+
+Before practising with this AI-powered Oral Coach, please review these guidelines:
+
+1. **Practising with an AI Coach:**
+   - You'll be practising speaking with an AI Oral Coach, which is a computer program that helps you learn. It is not a real person.
+
+2. **Feedback Might Not Be Perfect:**
+   - The feedback you get from the AI Oral Coach is usually helpful, but it might not always be right. If you are not sure about something, ask your teacher or parents.
+
+3. **Use Your Own Ideas Too:**
+   - If the AI coach gives you ideas, remember to add your own too. It is great to be creative and use your own thoughts!
+
+4. **Keep Personal Info Private:**
+   - Don't share your personal details like your NRIC, full name, address, or any passwords with the AI Oral Coach. This keeps you safe!
+
+5. **Be Kind and Positive:**
+   - When using the AI Oral Coach, remember to use nice words and be positive. No inappropriate language.
+
+6. **For Learning:**
+   - The Oral Coach is designed for improving speaking skills and enhancing learning. It should not enable illegal or unethical activities.
+
+7. **When in Doubt, Ask:**
+   - If something seems confusing or you're not sure what to do, always ask your teacher for help.
+
+*Large Language Models (LLMs) are a type of AI trained on large datasets to understand language and generate text.
+"""

styles.css

@@ -0,0 +1,28 @@
+/* style.css */
+/* Overwrite the background color */
+.gradio-container {
+    display: flex;
+    flex-direction: column;
+    flex-grow: 1;
+    background: hsl(39deg 57.28% 92.99%);
+}
+
+/* Define your light mode default text color */
+:root {
+    --custom-text-color-light: #0b0f19; /* Dark color for text in light mode */
+}
+
+/* Apply the light mode text color */
+.gradio-container .string.svelte-1kspdo {
+    color: var(--custom-text-color-light) !important;
+}
+
+/* Dark mode specific styles */
+.dark .gradio-container .string.svelte-1kspdo {
+    color: #f9fafb !important; /* Light color for text in dark mode */
+}
+
+/* Hide the footer */
+footer {
+    display: none !important;
+}

styles.py

@@ -0,0 +1,8 @@
+import gradio as gr
+
+# Set the theme to 'xiaobaiyuan/theme_brief'
+theme = 'xiaobaiyuan/theme_brief'
+
+with gr.Blocks(theme=theme) as demo:
+    # Your existing components and layout
+    ...

tab_how_oc_works.py

@@ -0,0 +1,20 @@
+# tab_how_oc_works.py
+import gradio as gr
+
+def overview_video_component():
+    return gr.HTML("""
+        <div style="position: relative; padding-bottom: 56.25%; height: 0;">
+            <iframe src="https://www.loom.com/embed/0b1ae013725f41f6ba1c89eec9c65567?sid=eac1f57a-e314-4fab-a399-f82e29de927b"
+            frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen
+            style="position: absolute; top: 0; left: 0; width: 100%; height: 100%;"></iframe>
+        </div>
+        """)
+
+def how_oral_coach_works_tab():
+    with gr.Tab("How Oral Coach Works"):
+        gr.Markdown("## How Oral Coach Works")
+        gr.Markdown("""
+        This tool is designed to enhance students' oral language skills. Here's how it works:
+        **Watch the Overview Video Below**:
+        """)
+        overview_video_component()

tab_teachers_dashboard.py

@@ -0,0 +1,49 @@
+import gradio as gr
+from database_functions import getUniqueSubmitDate, getUniqueClass
+from teachers_dashboard import show_dashboard, updateReportByDateAndClass, chat_with_json_output
+
+def create_teachers_dashboard_tab():
+    with gr.Tab("Teacher's Dashboard") as teacher_dash_tab:
+        with gr.Column() as login_dash:
+            password_input = gr.Textbox(label="Enter Password", type="password")
+            btn_login_dash = gr.Button("Submit")
+            dashboard_content = gr.HTML()
+
+        with gr.Column(visible=False) as teacher_dash:
+            gr.Markdown("## Teacher Dash (unlocked)")
+            with gr.Tab("Select Date Range and Class"):
+                date_choices = getUniqueSubmitDate()
+                ddl_start_date = gr.Dropdown(choices=date_choices, label="Start Date")
+                ddl_end_date = gr.Dropdown(choices=date_choices, label="End Date")
+                class_choices = getUniqueClass()
+                ddl_class = gr.Dropdown(choices=class_choices, label="Select a class")
+                display_ai_feedback = gr.Checkbox(label="Display AI Feedback", value=True)
+                btn_show_report_date_range_class = gr.Button("Display Submissions")
+                submission_report = gr.JSON(label="Submissions for Selected Date Range and Class")
+
+            gr.Markdown("You can use the following example queries to analyze the student responses:")
+            query_input = gr.Textbox(label="Teacher's Query")
+            additional_inputs_accordion = gr.Accordion(label="Example Queries", open=True)
+            with additional_inputs_accordion:
+                gr.Examples(examples=[
+                    ["General Analysis: Summarize overall performance and identify patterns"],
+                    ["Specific Analysis: Identify common misconceptions and suggest interventions"],
+                    ["Specific Analysis: Analyze the effectiveness of strategies used"],
+                    ["Specific Analysis: Compare performance of different student groups"],
+                    ["Specific Analysis: Track individual student progress over time"],
+                    ["Completion Rate Analysis: Breakdown of questions attempted and insights"]
+                ], inputs=[query_input])
+
+            chat_interface = gr.Chatbot(label="Overall Analysis on Students Responses")
+            chat_button = gr.Button("Chat")
+
+            chat_button.click(
+                chat_with_json_output,
+                inputs=[query_input, submission_report, chat_interface],
+                outputs=chat_interface
+            )
+
+        btn_login_dash.click(show_dashboard, inputs=[password_input], outputs=[dashboard_content, teacher_dash, login_dash, ddl_start_date, ddl_class])
+        btn_show_report_date_range_class.click(updateReportByDateAndClass, inputs=[ddl_start_date, ddl_end_date, ddl_class, display_ai_feedback], outputs=[submission_report, chat_interface])
+
+    return teacher_dash_tab

teachers_dashboard.py

@@ -0,0 +1,109 @@
+#teachers_dashboard.py
+import gradio as gr
+import thinkingframes
+from dotenv import load_dotenv
+from openai import OpenAI
+from database_functions import get_submissions_by_date_and_class, getUniqueSubmitDate, getUniqueClass
+
+load_dotenv()
+client = OpenAI()
+
+def validate_password(password):
+    correct_password = "Happyteacher2024"
+    return password == correct_password
+
+def show_dashboard(password):
+    if validate_password(password):
+        date_choices = getUniqueSubmitDate()
+        class_choices = getUniqueClass()
+        return "<p>Dashboard content goes here</p>", gr.update(visible=True), gr.update(visible=False), gr.Dropdown(choices=date_choices, label="Select a date"), gr.Dropdown(choices=class_choices, label="Select a class")
+    return "<p>Incorrect password</p>", gr.update(visible=False), gr.update(visible=False), gr.Dropdown(choices='', label="Select a date"), gr.Dropdown(choices='', label="Select a class")
+
+def updateReportByDateAndClass(start_date, end_date, class_name, display_ai_feedback):
+    json_output = get_submissions_by_date_and_class(start_date, end_date, class_name, display_ai_feedback)
+    chat_history = []
+    return json_output, chat_history
+
+def chat_with_json_output(query, json_output, chat_history):
+    questions = thinkingframes.questions
+    strategies = [strategy[0] for strategy in thinkingframes.strategy_options.values()]
+    picture_description = thinkingframes.description
+
+    history_openai_format = [
+        {"role": "system", "content": f"Here is the JSON output of the student responses and AI interactions:\n{json_output}"},
+        {"role": "user", "content": f"Selected Analysis Prompt: {query}"}
+    ]
+    for human, assistant in chat_history:
+        history_openai_format.append({"role": "user", "content": human})
+        history_openai_format.append({"role": "assistant", "content": assistant})
+    
+    system_prompt = f"""
+    You are an English Language Teacher analyzing student responses to oral questions. The questions and strategies used are:
+
+    Questions:
+    1. {questions[0]}
+    2. {questions[1]}
+    3. {questions[2]}
+
+    Strategies:
+    1. {strategies[0]}
+    2. {strategies[1]}
+    3. {strategies[2]}
+
+    Picture Description (relevant only for Question 1):
+    {picture_description}
+
+    Based on the provided JSON output and the selected analysis prompt, please perform the following:
+
+    General Analysis:
+    - If the selected prompt is "General Analysis: Summarize overall performance and identify patterns":
+      - Summarize the overall performance of students for each question, considering the relevant strategies and picture description.
+      - Identify notable patterns and trends in student responses and AI feedback.
+      - Highlight exemplary responses or feedback that demonstrate effective use of strategies or insightful interpretations.
+
+    Specific Analysis:
+    - If the selected prompt is "Specific Analysis: Identify common misconceptions and suggest interventions":
+      - Identify common misconceptions or errors in student responses.
+      - Suggest targeted interventions to address these misconceptions and improve student understanding.
+
+    - If the selected prompt is "Specific Analysis: Analyze the effectiveness of strategies used":
+      - Analyze the effectiveness of each strategy used by students.
+      - Provide recommendations for improving the use of strategies and enhancing student performance.
+
+    - If the selected prompt is "Specific Analysis: Compare performance of different student groups":
+      - Compare the performance of different student groups (e.g., high performers vs. struggling students).
+      - Offer insights and recommendations based on the identified differences and patterns.
+
+    - If the selected prompt is "Specific Analysis: Track individual student progress over time":
+      - Track the progress of individual students over time, if data is available.
+      - Highlight areas where students have shown improvement or require additional support.
+
+    Completion Rate Analysis:
+    - If the selected prompt is "Completion Rate Analysis: Breakdown of questions attempted and insights":
+      - Identify the students who have attempted all three questions, two questions, only Question 1, or no questions at all.
+      - Calculate the percentage of students in each category.
+      - Provide insights on the potential reasons for the completion rates (e.g., difficulty level, student engagement, etc.).
+      - Offer recommendations for improving completion rates, such as providing additional support or incentives.
+
+    Please provide the analysis in a clear and organized format, using bullet points, tables, or paragraphs as appropriate. Include specific examples and data-driven insights to support your recommendations. Focus on actionable feedback that can directly impact student learning and engagement.
+    """
+
+    history_openai_format.append({"role": "user", "content": system_prompt})
+    history_openai_format.append({"role": "user", "content": query})
+
+    response = client.chat.completions.create(
+        model='gpt-4o-2024-05-13',
+        messages=history_openai_format,
+        temperature=0.2,
+        max_tokens=1000,
+        stream=True
+    )
+
+    partial_message = ""
+    for chunk in response:
+        if chunk.choices[0].delta.content is not None:
+            partial_message += chunk.choices[0].delta.content
+            yield chat_history + [("Assistant", partial_message)]
+
+    chat_history.append(("Assistant", partial_message))
+    return chat_history

thinkingframes.py

@@ -0,0 +1,86 @@
+# thinkingframes.py
+
+description = (
+    "In this photograph, we see a group of young girls dressed in shiny, glittery costumes being helped by adults. "
+    "It looks like they are preparing for a performance or a dance recital. Each girl has her hair neatly done, and some "
+    "are getting decorative hairpieces attached. They are all standing indoors, as we can see windows with light coming "
+    "through in the background, which creates a calm and focused atmosphere.\n\n"
+    "The adults, possibly parents or teachers, are attentively making sure that the girls look their best. The girls seem "
+    "to be patient and maybe a bit nervous as they get ready. One girl in the front is closing her eyes and has a serious "
+    "expression on her face, which might mean she is concentrating or thinking about the upcoming event.\n\n"
+    "The way everyone is dressed and the care being taken with their appearance suggests that this is an important and "
+    "special occasion. It's a busy scene with everyone doing something to prepare, and it captures a moment of quiet "
+    "intensity before a performance where everyone wants to do well."
+)
+
+strategy_options = {
+    "PEEL": ("PEEL strategy (Point, Evidence, Experience(s), Link back to the question)", 
+        "Structure your feedback using the PEEL strategy. Begin with a Point, provide Evidence to support it, specifically referencing possible details from the photograph: '{description}'. Share an Experience or example, and finally Link back to the question."),
+
+    "5W1H": ("5W1H thinking frame (Who, What, Where, When, Why, How)", 
+        "Structure your feedback using the 5W1H thinking frame. Address Who the user is talking about, What they are discussing, Where it's happening, When it's occurring, Why they feel that way, and How they express it."),
+
+    "OREO": ("OREO thinking frame (Opening Statement, Reasons, Elaborate, Opinion)", 
+        "Structure your feedback using the OREO thinking frame. Begin with an Opening Statement about the user's response, provide Reasons for your feedback, Elaborate on those reasons, and conclude with an Opinion on their overall response."),
+
+    "SEP": ("SEP strategy - State, Elaborate, Personal experiences",
+        "Structure your feedback using the SEP strategy. Begin with a State (S), where you state your point and answer to the question posed. Next, Elaborate (E) on your statement, justifying and explaining the reasons for your choice of answer specifically referencing possible details from the photograph: '{description}'. S. Use examples from various areas of your life such as Self, Home, School, Community, and Nation to enrich your elaboration. Lastly, share Personal experiences (P) from your own life or others' experiences to support your answer."),
+
+    "OREOS": ("OREOS thinking frame (Opinion, Reasons, Elaborate, Own Experiences, Suggestion)",
+        "Structure your feedback using the OREO thinking frame. Begin with an Opening Statement about the user's response, provide Reasons for your feedback, Elaborate on those reasons, and conclude with an Opinion on their overall response, and make a Suggestion."),
+    
+    "TREES": ("TREES strategy (Thought, Reasons, Elaboration, Experiences, Summary or Suggestions)",
+        "Begin your feedback with a Thought that directly addresses the question. "
+        "Follow with Reasons that are relevant and logical to support this thought. "
+        "Elaborate on your reasons using the 5Ws1H method: Who, What, Where, When, Why, and How, to provide a comprehensive explanation. "
+        "Incorporate personal Experiences that are pertinent and provide insight into the topic to make your response more engaging. "
+        "Conclude with a Summary that encapsulates your main points succinctly, or offer Suggestions that provide depth and forward-thinking perspectives."),
+
+    "TREES+": ("TREES+ strategy - Thought, Reasons, Elaboration, Experiences, Summary or Suggestions",
+        "Begin your feedback with a Thought that directly addresses the question. "
+        "Follow with Reasons to support this thought, making sure they are relevant and logical. "
+        "Then, Elaborate on your reasons with examples or explanations that further clarify your point. "
+        "Incorporate personal Experiences that are pertinent to the topic to make your response more engaging. "
+        "Conclude with a Summary that encapsulates your main points succinctly, or provide Suggestions that offer insight or recommendations. "
+        "Ask yourself: Does my Thought align with the question? Are my Reasons strong and supportive of my Thought? "
+        "How can I Elaborate on my reasons more effectively? What Experiences can I share that will resonate with my main points? "
+        "How can I tie all my points together in a Summary, or what Suggestions can I make for future consideration?")
+}
+
+questions = [
+    "1. How do you think the people in the photograph might be feeling? Why?",
+    "2. Would you like to perform on stage? Why or why not?",
+    "3. What are some ways to build confidence in children?",
+]
+
+
+# Function to generate the feedback prompt based on feedback level
+def generate_prompt(feedback_level):
+    if feedback_level == "Brief Feedback":
+        return (f"Provide concise feedback Strictly following a 40 word limit. "
+                f"Conclude with one relevant Socratic question for reflect on their response and label them as Follow Up Question:.")
+    elif feedback_level == "Moderate Feedback":
+        return (f"Provide clear, constructive, concise feedback strictly in a 70 word limit. "
+                f"Include two relevant Socratic questions for the student to reflect on their response and label them as Follow Up Questions:")
+    elif feedback_level == "Comprehensive Feedback":
+        # No additional prompting for comprehensive feedback
+        return "Strictly provide feedback of around 300 words limit, including a full suggested response based on the student's response structured using the relevant thinking frame."
+    else:
+        raise ValueError(f"Invalid feedback level: {feedback_level}")
+
+
+# Update the generate_system_message function to include feedback_level and strategy_choice
+def generate_system_message(current_question_index, feedback_level):
+    feedback_structure = generate_prompt(feedback_level)
+    
+    system_message = f"""
+    As your English Oral Coach, I'll guide you through answering the question: '{questions[current_question_index]}'.
+
+    {feedback_structure}
+
+    I'll help you reflect on your response, suggesting areas to elaborate and clarify. Remember, our goal is to enhance your critical thinking and independence.
+
+    Please ensure your response is in English and language and tone is age appropriate for Singapore students in Primary 5.
+    """
+    
+    return system_message

utils.py

@@ -0,0 +1,23 @@
+#utils.py
+import base64
+from database_functions import add_user_privacy  # Make sure this is correctly implemented
+
+def get_image_html(image_path):
+    with open(image_path, "rb") as img_file:
+        base64_image = base64.b64encode(img_file.read()).decode('utf-8')
+    return f'<img src="data:image/jpg;base64,{base64_image}" alt="SBC6" width="450" style="display: block; margin: auto;"/>'
+
+def collect_student_info(class_name, index_no):
+    # Validate inputs
+    if not class_name or not index_no:
+        return False, "Please select your class and index number.", None
+    
+    try:
+        # Call the updated add_user function with class_name and index_no
+        userid, dbMsg = add_user_privacy(class_name, index_no)
+        return True, dbMsg, userid
+    except Exception as e:
+        # Log the exception and handle it appropriately
+        print(f"An error occurred: {e}")
+        return False, "An error occurred while adding user to the database.", None
+