init Commit

app.py

@@ -0,0 +1,23 @@
+import gradio as gr
+from dotenv import load_dotenv
+
+from mcq import mcq_generation
+from lesson_plan import lesson_plan
+from worksheet import worksheet_generation
+from content import content_generation
+
+load_dotenv()
+
+with gr.Blocks() as app:
+    gr.Markdown("# API Demo")
+    with gr.Tabs():
+        with gr.TabItem("MCQ Generation"):
+            mcq_generation()
+        with gr.TabItem("Lesson Plan Generation"):
+            lesson_plan()
+        with gr.TabItem("Worksheet Generation"):
+            worksheet_generation()
+        with gr.TabItem("Content Generation"):
+            content_generation()
+
+app.launch()

content.py

@@ -0,0 +1,106 @@
+import requests
+import gradio as gr
+
+from helper import generate_access_token
+
+def generate_content(grade, subject, topics, learning_outcomes, notes, stories, activities, group_dicussion, extras):
+    
+    data = {
+        "institution_id": "inst789",
+        "teacher_id": "teacher456",
+        "grade": grade,
+        "subject": subject,
+        "topics": topics.split(", "),
+        "learning_outcomes": learning_outcomes.split(", "),
+        "content_type": {
+            "notes": notes,
+            "stories": stories,
+            "activities": activities,
+            "group_dicussion": group_dicussion
+        },
+        "extras": extras.split(", ")
+    }
+
+    access_token = generate_access_token()
+
+    if access_token is None:
+        return {"Error": "Failed to generate access token"}
+
+    response = requests.post("http://20.193.151.200:8080/k12/generate/content", 
+                             headers={
+                                 "accept": "application/json",
+                                 "content-type": "application/json",
+                                 "Authorization": f"{access_token}"},
+                             json=data)
+    
+    if(str(response.status_code)[0] != '2'):
+        return {"Error": f"{response.status_code}"}
+
+    return response.json()
+
+def get_content_generation(request_id):
+    
+    access_token = generate_access_token()
+
+    if access_token is None:
+        return {"Error": "Failed to generate access token"}
+
+    url = f"http://20.193.151.200:8080/k12/generate/content/{request_id}"
+    headers = {"accept": "application/json",
+               "Authorization": access_token}
+    
+    response = requests.get(url, headers=headers)
+    
+    if str(response.status_code)[0] == "2":
+        return response.json()
+    else:
+        return {"Error" : f"{response.status_code}"}
+
+def post_interface():
+    
+    with gr.Blocks() as post_page:    
+        grade = gr.Textbox(label="Grade", value="8")
+        subject = gr.Textbox(label="Subject", value="Science")
+
+        topics = gr.Textbox(label="Topics (comma-separated)", value="Plant and Animal Cells, Reproduction in Humans and Animals")
+        learning_outcomes = gr.Textbox(label="Learning Outcomes (comma-separated)")
+        
+        notes = gr.Radio(label="Notes", choices=["Yes", "No"], value="No")
+        stories = gr.Radio(label="Stories", choices=["Yes", "No"], value="No")
+        activities = gr.Radio(label="Activities", choices=["Yes", "No"], value="No")
+        group_dicussion = gr.Radio(label="Group Discussion", choices=["Yes", "No"], value="No")
+        
+        extras = gr.Textbox(label="Extras  (comma-separated)")
+        
+        submit_button = gr.Button("Invoke Request")
+        output = gr.JSON(label="Content Generation ID")
+
+        submit_button.click(
+            fn=generate_content, 
+            inputs=[grade, subject, topics, learning_outcomes, notes, stories, activities, group_dicussion, extras], 
+            outputs=output,
+        )
+
+    return post_page
+
+def get_interface():
+    with gr.Blocks() as get_page:
+
+        interface = gr.Interface(
+            fn=get_content_generation, 
+            inputs=gr.Textbox(label="Enter Request ID"), 
+            outputs="json",
+        )
+        
+    return get_page
+
+def content_generation():
+    gr.Markdown("# Content Generation")
+    with gr.Blocks() as content_generation:
+        with gr.Tabs():
+            with gr.TabItem("POST"):
+                post_interface()
+            with gr.TabItem("GET"):
+                get_interface()
+
+    return content_generation

helper.py

@@ -0,0 +1,25 @@
+import os
+import requests
+
+def generate_access_token():
+
+    url = "http://20.193.151.200:8080/token"
+    headers = {
+        "accept": "application/json",
+        "Content-Type": "application/x-www-form-urlencoded"
+    }
+    data = {
+        "grant_type": "",
+        "username": os.getenv("TOKEN_USERNAME"),
+        "password": os.getenv("TOKEN_PASSWORD"),
+        "scope": "",
+        "client_id": "",
+        "client_secret": ""
+    }
+
+    response = requests.post(url, headers=headers, data=data)
+    
+    if(response.status_code != 200):
+        return None
+    
+    return response.json()["access_token"]

lesson_plan.py

@@ -0,0 +1,97 @@
+import requests
+import gradio as gr
+
+from helper import generate_access_token
+
+def generate_lesson_plan(board, grade, subject, topics, duration, learning_outcomes, curriculum_framework):
+
+    data = {
+        "board": board,
+        "curriculum_framework": curriculum_framework,
+        "duration": duration,
+        "grade": grade,
+        "institution_id": "inst789",
+        "learning_outcomes": learning_outcomes.split(", "),
+        "subject": subject,
+        "teacher_id": "teacher456",
+        "topics": topics.split(", ")
+    }
+
+    access_token = generate_access_token()
+
+    if access_token is None:
+        return {"Error": "Failed to generate access token"}
+
+    response = requests.post("http://20.193.151.200:8080/v1/k12/generate/lesson-plan", 
+                             headers={
+                                 "accept": "application/json",
+                                 "content-type": "application/json",
+                                 "Authorization": f"{access_token}"},
+                             json=data)
+    
+    if(str(response.status_code)[0] != '2'):
+        return {"Error": f"{response.status_code}"}
+
+    return response.json()
+
+def get_lesson_plan(request_id):
+    
+    access_token = generate_access_token()
+
+    if access_token is None:
+        return {"Error": "Failed to generate access token"}
+
+    url = f"http://20.193.151.200:8080/v1/k12/generate/lesson-plan/{request_id}"
+    headers = {"accept": "application/json",
+               "Authorization": access_token}
+    
+    response = requests.get(url, headers=headers)
+    
+    if response.status_code == 200:
+        return response.json()
+    else:
+        return {"Error" : f"{response.status_code}"}
+
+def post_interface():
+
+    with gr.Blocks() as post_page:
+        
+        board = gr.Textbox(label="Board", value="NCERT")
+        grade = gr.Textbox(label="Grade", value="8")
+        subject = gr.Textbox(label="Subject", value="Science")
+        topics = gr.Textbox(label="Topics (comma-separated)", value="Plant and Animal Cells, Reproduction in Humans and Animals")
+        
+        duration = gr.Number(label="Duration (minutes)", value=45)
+        learning_outcomes = gr.Textbox(label="Learning Outcomes (comma-separated)")
+        curriculum_framework = gr.Textbox(label="Curriculum Framework", value="ncf2023")
+
+        output = gr.JSON(label="Lesson Plan ID")
+        submit_button = gr.Button("Invoke Request")
+
+        submit_button.click(
+            generate_lesson_plan,
+            inputs=[board, grade, subject, topics, duration, learning_outcomes, curriculum_framework],
+            outputs=output
+        )
+
+def get_interface():
+    with gr.Blocks() as get_page:
+
+        interface = gr.Interface(
+            fn=get_lesson_plan, 
+            inputs=gr.Textbox(label="Enter Request ID"), 
+            outputs="json",
+        )
+        
+    return get_page
+
+def lesson_plan():
+    gr.Markdown("# Lesson Plan Generation")
+    with gr.Blocks() as lesson_plan:
+        with gr.Tabs():
+            with gr.TabItem("POST"):
+                post_interface()
+            with gr.TabItem("GET"):
+                get_interface()
+
+    return lesson_plan

mcq.py

@@ -0,0 +1,147 @@
+import requests
+import gradio as gr
+
+from helper import generate_access_token
+
+def generate_mcq_questions(grade, subject, topics, number_of_questions, multiple_answer, single_answer,
+                           easy, medium, hard, remember, understand, apply, analyze, evaluate, create,
+                           hint, curricular_goal, competency, lo, lob, difficulty_level, bloom_taxonomy,
+                           solution_sheet):
+        
+    data = {
+        "institution_id": "string",
+        "teacher_id": "string",
+        "board": "NCERT",
+        "grade": grade,
+        "subject": subject,
+        "topics": topics.split(", "),
+        "number_of_questions": number_of_questions,
+        "question_type_distribution_percentage": {
+            "multiple_answer": multiple_answer,
+            "single_answer": single_answer,
+        },
+        "difficulty_distribution_percentage": {
+            "easy": easy,
+            "medium": medium,
+            "hard": hard
+        },
+        "blooms_taxonomy_distribution_percentage": {
+            "Remember": remember,
+            "Understand": understand,
+            "Apply": apply,
+            "Analyze": analyze,
+            "Evaluate": evaluate,
+            "Create": create
+        },
+        "question_tagging_options": {
+            "Hint": hint,
+            "Curricular_Goal": curricular_goal,
+            "Competency": competency,
+            "LO": lo,
+            "LOB": lob,
+            "Difficulty_level": difficulty_level,
+            "Bloom_Taxonomy": bloom_taxonomy
+        },
+        "solution_sheet": solution_sheet
+    }
+
+    access_token = generate_access_token()
+
+    if access_token is None:
+        return {"Error": "Failed to generate access token"}
+
+    response = requests.post("http://20.193.151.200:8080/v1/k12/generate/mcqs", 
+                             headers={
+                                 "accept": "application/json",
+                                 "content-type": "application/json",
+                                 "Authorization": f"{access_token}"},
+                             json=data)
+    
+    if(str(response.status_code)[0] != '2'):
+        return {"Error": f"{response.status_code}"}
+
+    return response.json()
+
+def get_mcq_questions(request_id):
+
+    access_token = generate_access_token()
+
+    if access_token is None:
+        return {"Error": "Failed to generate access token"}
+
+    url = f"http://20.193.151.200:8080/v1/k12/generate/mcqs/{request_id}"
+    headers = {"accept": "application/json",
+               "Authorization": access_token}
+    
+    response = requests.get(url, headers=headers)
+    
+    if response.status_code == 200:
+        return response.json()
+    else:
+        return {"Error" : f"{response.status_code}"}
+
+def post_interface():
+
+    with gr.Blocks() as post_page:
+        grade = gr.Textbox(label="Grade", value="6")
+        subject = gr.Textbox(label="Subject", value="Science")
+        topics = gr.Textbox(label="Topics (comma-separated)", value="Light")
+        number_of_questions = gr.Number(label="Number of Questions", value=20)
+        
+        multiple_answer = gr.Slider(label="Multiple Answer Questions (%)", minimum=0, maximum=100, value=100)
+        single_answer = gr.Slider(label="Single Answer Questions (%)", minimum=0, maximum=100, value=0)
+        
+        easy = gr.Slider(label="Easy Questions (%)", minimum=0, maximum=100, value=0)
+        medium = gr.Slider(label="Medium Questions (%)", minimum=0, maximum=100, value=0)
+        hard = gr.Slider(label="Hard Questions (%)", minimum=0, maximum=100, value=0)
+        
+        remember = gr.Slider(label="Remember (%)", minimum=0, maximum=100, value=0)
+        understand = gr.Slider(label="Understand (%)", minimum=0, maximum=100, value=0)
+        apply = gr.Slider(label="Apply (%)", minimum=0, maximum=100, value=0)
+        analyze = gr.Slider(label="Analyze (%)", minimum=0, maximum=100, value=0)
+        evaluate = gr.Slider(label="Evaluate (%)", minimum=0, maximum=100, value=0)
+        create = gr.Slider(label="Create (%)", minimum=0, maximum=100, value=0)
+        
+        hint = gr.Radio(label="Hint", choices=["Yes", "No"], value="No")
+        curricular_goal = gr.Radio(label="Curricular Goal", choices=["Yes", "No"], value="No")
+        competency = gr.Radio(label="Competency", choices=["Yes", "No"], value="No")
+        lo = gr.Radio(label="LO", choices=["Yes", "No"], value="No")
+        lob = gr.Radio(label="LOB", choices=["Yes", "No"], value="No")
+        difficulty_level = gr.Radio(label="Difficulty Level", choices=["Yes", "No"], value="No")
+        bloom_taxonomy = gr.Radio(label="Bloom Taxonomy", choices=["Yes", "No"], value="No")
+        
+        solution_sheet = gr.Radio(label="Solution Sheet", choices=["Yes", "No"], value="Yes")
+        
+        submit_button = gr.Button("Invoke Request")
+        
+        submit_button.click(generate_mcq_questions, 
+                            inputs= [grade, subject, topics, number_of_questions, multiple_answer, single_answer,
+                            easy, medium, hard, remember, understand, apply, analyze, evaluate, create,
+                            hint, curricular_goal, competency, lo, lob, difficulty_level, bloom_taxonomy,
+                            solution_sheet],
+                            outputs=gr.JSON())
+        
+    return post_page
+
+def get_interface():
+
+    with gr.Blocks() as get_page:
+
+        interface = gr.Interface(
+            fn=get_mcq_questions, 
+            inputs=gr.Textbox(label="Enter Request ID"), 
+            outputs="json",
+        )
+        
+    return get_page
+
+def mcq_generation():
+    gr.Markdown("# MCQ Generation")
+    with gr.Blocks() as mcq_generation:
+        with gr.Tabs():
+            with gr.TabItem("POST"):
+                post_interface()
+            with gr.TabItem("GET"):
+                get_interface()
+
+    return mcq_generation

worksheet.py

@@ -0,0 +1,195 @@
+import requests
+import gradio as gr
+
+from helper import generate_access_token
+
+def yes_no(value, array):
+    if value in array:
+        return "Yes"
+    else:
+        return "No"
+
+def generate_worksheet(grade, subject, topics, learning_objectives, question_tagging_options, 
+                       number_of_questions, easy, medium, hard, remember, understand, apply, analyze, 
+                       evaluate, create, mcq_single_answer, mcq_multiple_answer, true_false, fill_in_the_blanks, 
+                       match_the_column, very_short_answer, short_answer, long_answer, solution_sheet, format, extras):
+    
+    data = {
+        "institution_id": "inst789",
+        "teacher_id": "teacher456",
+        "grade": grade,
+        "subject": subject,
+        "topics": topics.split(", "),
+        "learning_objectives": learning_objectives.split(", "),
+        "question_tagging_options": {
+            "Hint": yes_no("Hint", question_tagging_options),
+            "Curricular_Goal": yes_no("Curricular Goal", question_tagging_options),
+            "Competency": yes_no("Competency", question_tagging_options),
+            "LO": yes_no("LO", question_tagging_options),
+            "LOB": yes_no("LOB", question_tagging_options),
+            "Difficulty_level": yes_no("Difficulty Level", question_tagging_options),
+            "Bloom_Taxonomy": yes_no("Bloom Taxonomy", question_tagging_options)
+        },
+        "number_of_questions": number_of_questions,
+        "difficulty_distribution_percentage": {
+            "easy": easy,
+            "medium": medium,
+            "hard": hard
+        },
+        "blooms_taxonomy_distribution_percentage": {
+            "Remember": remember,
+            "Understand": understand,
+            "Apply": apply,
+            "Analyze": analyze,
+            "Evaluate": evaluate,
+            "Create": create
+        },
+        "question_type_distribution_absolute": {
+            "MCQ_single_answer": mcq_single_answer,
+            "MCQ_Multiple_answer": mcq_multiple_answer,
+            "True_False": true_false,
+            "Fill_in_the_blanks": fill_in_the_blanks,
+            "Match_the_column": match_the_column,
+            "Very_Short_answer": very_short_answer,
+            "Short_answer": short_answer,
+            "Long_answer": long_answer
+        },
+        "solution_sheet": solution_sheet,
+        "format": format,
+        "extras": extras.split(", ")
+    }
+
+    access_token = generate_access_token()
+
+    if access_token is None:
+        return {"Error": "Failed to generate access token"}
+
+    response = requests.post("http://20.193.151.200:8080/k12/generate/worksheet", 
+                             headers={
+                                 "accept": "application/json",
+                                 "content-type": "application/json",
+                                 "Authorization": f"{access_token}"},
+                             json=data)
+
+    if(str(response.status_code)[0] != '2'):
+        return {"Error": f"{response.status_code}"}
+
+    return response.json()
+
+def get_worksheet(request_id):
+
+    access_token = generate_access_token()
+
+    if access_token is None:
+        return {"Error": "Failed to generate access token"}
+
+    url = f"http://20.193.151.200:8080/k12/generate/worksheet/{request_id}"
+    headers = {"accept": "application/json",
+               "Authorization": access_token}
+    
+    response = requests.get(url, headers=headers)
+    
+    if str(response.status_code)[0] == '2':
+        return response.json()
+    else:
+        return {"Error" : f"{response.status_code}"}
+
+def post_interface():
+
+    with gr.Blocks() as post_page:
+  
+        grade = gr.Textbox(label="Grade", value="8")
+        subject = gr.Textbox(label="Subject", value="Science")
+        topics = gr.Textbox(label="Topics (comma-separated)")
+        learning_objectives = gr.Textbox(label="Learning Objectives (comma-separated)")
+        question_tagging_options = gr.CheckboxGroup(["Hint", "Curricular Goal", "Competency", "LO", "LOB", "Difficulty Level", "Bloom Taxonomy"], label="Question Tagging Options")
+        number_of_questions = gr.Number(label="Number of Questions", value=10)
+        
+        gr.Markdown("## Difficulty Distribution (easy, medium, hard)")
+        # Difficulty Distribution (easy, medium, hard)
+        with gr.Row():
+            with gr.Column():
+                easy = gr.Number(label="Easy", minimum=0, maximum=100, value=0)
+            with gr.Column():
+                medium = gr.Number(label="Medium", minimum=0, maximum=100, value=0)
+            with gr.Column():
+                hard = gr.Number(label="Hard", minimum=0, maximum=100, value=0)
+
+        gr.Markdown("## Bloom Taxonomy Distribution (Remember, Understand, Apply, Analyze, Evaluate, Create)")
+        # Bloom Taxonomy Distribution (Remember, Understand, Apply, Analyze, Evaluate, Create)
+        with gr.Row():
+            with gr.Column():
+                remember = gr.Number(minimum=0, maximum=100, step=1, label="Remember", value=0)
+            with gr.Column():
+                understand = gr.Number(minimum=0, maximum=100, step=1, label="Understand", value=0)
+            with gr.Column():
+                apply = gr.Number(minimum=0, maximum=100, step=1, label="Apply", value=0)
+        with gr.Row():    
+            with gr.Column():  
+                analyze = gr.Number(minimum=0, maximum=100, step=1, label="Analyze", value=0)
+            with gr.Column():
+                evaluate = gr.Number(minimum=0, maximum=100, step=1, label="Evaluate", value=0)
+            with gr.Column():
+                create = gr.Number(minimum=0, maximum=100, step=1, label="Create", value=0)
+
+        gr.Markdown("## Question Type Distribution (MCQ Single, MCQ Multiple, True/False, Fill in the Blanks, Match the Column, Very Short, Short, Long)")
+        with gr.Row():
+            with gr.Column():
+                mcq_single_answer = gr.Number(minimum=0, maximum=100, step=1, label="MCQ Single Answer", value=0)
+            with gr.Column():
+                mcq_multiple_answer = gr.Number(minimum=0, maximum=100, step=1, label="MCQ Multiple Answer", value=0)
+            with gr.Column():
+                true_false = gr.Number(minimum=0, maximum=100, step=1, label="True/False", value=0)
+        with gr.Row():
+            with gr.Column():
+                fill_in_the_blanks = gr.Number(minimum=0, maximum=100, step=1, label="Fill in the Blanks", value=0)
+            with gr.Column():
+                match_the_column = gr.Number(minimum=0, maximum=100, step=1, label="Match the Column", value=0)
+            with gr.Column():
+                very_short_answer = gr.Number(minimum=0, maximum=100, step=1, label="Very Short Answer", value=0)
+        with gr.Row():
+            with gr.Column():
+                short_answer = gr.Number(minimum=0, maximum=100, step=1, label="Short Answer", value=0)
+            with gr.Column():
+                long_answer = gr.Number(minimum=0, maximum=100, step=1, label="Long Answer", value=0)
+
+        solution_sheet = gr.Radio(label="Solution Sheet", choices=["Yes", "No"], value="Yes")       
+        format = gr.Textbox(label="Format", value="JSON")
+        extras = gr.Textbox(label="Extras (comma-separated)")
+
+        submit_button = gr.Button("Invoke Request")
+
+        output = gr.JSON(label="Request Data")
+
+        submit_button.click(
+            generate_worksheet,
+            inputs=[grade, subject, topics, learning_objectives, question_tagging_options, 
+                    number_of_questions, easy, medium, hard, remember, understand, apply, analyze, 
+                    evaluate, create, mcq_single_answer, mcq_multiple_answer, true_false, fill_in_the_blanks, 
+                    match_the_column, very_short_answer, short_answer, long_answer, solution_sheet, format, extras],
+            outputs=output
+        )
+
+    return post_page
+
+def get_interface():
+    with gr.Blocks() as get_page:
+
+        interface = gr.Interface(
+            fn=get_worksheet, 
+            inputs=gr.Textbox(label="Enter Request ID"), 
+            outputs="json",
+        )
+        
+    return get_page
+
+def worksheet_generation():
+    gr.Markdown("# Worksheet Generation")
+    with gr.Blocks() as worksheet_generation:
+        with gr.Tabs():
+            with gr.TabItem("POST"):
+                post_interface()
+            with gr.TabItem("GET"):
+                get_interface()
+
+    return worksheet_generation