wip update

demo.py

@@ -4,6 +4,7 @@ import json
 import gradio as gr
 import requests
 import firebase_admin
+from itertools import chain
 from firebase_admin import db, credentials
 
 def clamp(x, minimum, maximum):
@@ -13,463 +14,391 @@ def clamp(x, minimum, maximum):
 # API calls
 #################################################################################################################################################
 
+
+
 # read secret api key
 API_KEY = os.environ['ApiKey']
 FIREBASE_API_KEY = os.environ['FirebaseSecret']
 FIREBASE_URL = os.environ['FirebaseURL']
+SETUP_MODEL = os.environ['SETUP_MODEL']
+
+
+# creds = credentials.Certificate(json.loads(FIREBASE_API_KEY))
+# firebase_app = firebase_admin.initialize_app(creds, {'databaseURL': FIREBASE_URL})
+# firebase_data_ref = db.reference("data")
+# firebase_current_ref = None
 
-creds = credentials.Certificate(json.loads(FIREBASE_API_KEY))
-firebase_app = firebase_admin.initialize_app(creds, {'databaseURL': FIREBASE_URL})
-firebase_data_ref = db.reference("data")
-firebase_current_ref = None
+BASE_URL = "https://skapi.polyglot-edu.com/"
 
+##################################################################
+# Data Layer
+##################################################################
 
-base_url = "https://skapi.polyglot-edu.com/"
 levels = ["Primary School", "Middle School", "High School", "College", "Academy"]
 languages = ["English", "Italian", "French", "German", "Spanish"]
-categories = ["Factual Knowledge", "Understanding of Concepts", "Application of Skills", "Analysys And Evaluation"]
-
-def get_level_mapping(level):
-    if level is None:
-        raise gr.Error("Please select a level.")
-
-    return levels.index(level)
-
-def get_category_mapping(category):
-    if category is None:
-        raise gr.Error("Please select a level.")
-
-    return categories.index(category)
-
-def generate_fill_gaps(original_text, level, number_of_words, number_of_gaps, number_of_distractors, temperature, language):
-    """
-    Generate a fill-gaps question from a given text.
-
-
-    Parameters
-    ----------
-    original_text : str
-        The original text from which to generate the fill-gaps question.
-    number_of_words : int
-        The number of words of the generated text.
-    number_of_gaps : int
-        The number of gaps to generate.
-    number_of_distractors : int
-        The number of distractors to generate for each gap.
-    temperature : float
-        The temperature for the generation.
-    language : str
-        The language of the generated text.
-
-    Returns
-    -------
-    str
-        The fill-gaps question.
-    """
-
-    match number_of_words:
-        case "≈ 150 Words":
-            number_of_words = 150
-        case "≈ 250 Words":
-            number_of_words = 250
-        case "≈ 350 Words":
-            number_of_words = 350
-
-    input_json = {
-        "text": original_text,
-        "level": get_level_mapping(level),
-        "n_o_w": int(number_of_words),
-        "n_o_g": int(number_of_gaps),
-        "n_o_d": int(number_of_distractors),
-        "temperature": int(temperature) * 0.2,
-        "language": language
-    }
+type_of_exercise = ["Open Question", "Short Answer Question", "True or False", "Fill in the Blanks", "Single Choice", "Multiple Choice", "Debate", "Essay", "Brainstorming", "Knoledge Exposition"]
 
-    print(input_json)
-
-    output = ""
-    try:
-        response = requests.post(
-            base_url + "FillTheGaps/generateexercise",
-            headers={"ApiKey": API_KEY},
-            json=input_json,
-            timeout=20
-        )
-
-        if response.status_code != 200:
-            output = f"API call failed with status code {response.status_code} and message '{response.text}'"
-            raise Exception(f"API call failed with status code {response.status_code} and message '{response.text}'")
-        
-        output = response.text
-        return output
-    finally:
-        global firebase_current_ref
-        firebase_current_ref = firebase_data_ref.push({
-            "type": "fill_the_gaps",
-            **input_json,
-            "output": output,
-            "datetime": str(datetime.datetime.now()),
-            "like": 0,
-            "comment_text": "",
-            "flagged": False,
-        })
-
-def generate_open_question(original_text, level, temperature, language, question_type, question_category):
-    """
-    Generate an open question from a given text.
-
-
-    Parameters
-    ----------
-    original_text : str
-        The original text from which to generate the open question.
-    temperature : float
-        The temperature for the generation.
-    language : str
-        The language of the generated text.
-    question_type : str
-        The type of the question.
-    question_category : str
-        The category of the question.
-
-    Returns
-    -------
-    str
-        The open question.
-    """
-
-    input_json = {
-        "text": original_text,
-        "level": get_level_mapping(level),
-        "temperature": int(temperature) * 0.2,
-        "language": language,
-        "type": question_type,
-        "category": get_category_mapping(question_category),
-    }
+def generation_to_dict(experiment, skip=False):
+    info = {
+        # experiment info
+        **experiment,
 
-    print(input_json)
-
-    output = ""
-    try:
-        response = requests.post(
-            base_url + "QuestionExercise/generateexercise",
-            headers={"ApiKey": API_KEY},
-            json=input_json,
-            timeout=20
-        )
-
-        if response.status_code != 200:
-            output = f"API call failed with status code {response.status_code} and message '{response.text}'"
-            raise Exception(f"API call failed with status code {response.status_code} and message '{response.text}'")
-        
-        output = response.text
-        return output
-    finally:
-        global firebase_current_ref
-        firebase_current_ref = firebase_data_ref.push({
-            "type": "open_question",
-            **input_json,
-            "output": output,
-            "datetime": str(datetime.datetime.now()),
-            "like": 0,
-            "comment_text": "",
-            "flagged": False,
-        })
-
-def generate_multiplechoice(original_text, level, number_of_easy_distractors, number_of_distractors, temperature, language, question_category, correct_answers, exercise_type):
-    """
-    Generate a multiple-choice question from a given text.
-
-
-    Parameters
-    ----------
-    original_text : str
-        The original text from which to generate the multiple-choice question.
-    number_of_easy_distractors : int
-        The number of easy distractors to generate for each option.
-    number_of_distractors : int
-        The number of distractors to generate for each option.
-    temperature : float
-        The temperature for the generation.
-    language : str
-        The language of the generated text.
-    question_category : str
-        The category of the question.
-    correct_answers : int
-        The number of correct answers.
-    exercise_type : bool
-        The type of the exercise (theory or practice).
-
-    Returns
-    -------
-    str
-        The multiple-choice question.
-    """
-    
-    input_json = {
-        "text": original_text,
-        "type": bool(exercise_type),
-        "level": get_level_mapping(level),
-        "category": get_category_mapping(question_category),
-        "n_o_ca": int(correct_answers),
-        "n_o_d": int(number_of_distractors),
-        "nedd": int(number_of_easy_distractors),
-        "temperature": int(temperature) * 0.2,
-        "language": language
+        # chosen image set info
+        "corrupted_filename": experiment["corrupted"]["name"],
+        "options": [img["name"] for img in experiment["options"]],
     }
 
-    print(input_json)
-
-    output = ""
-    try:
-        response = requests.post(
-            base_url + "QuizExercise/generateexercise",
-            headers={"ApiKey": API_KEY},
-            json=input_json,
-            timeout=20
-        )
-
-        if response.status_code != 200:
-            output = f"API call failed with status code {response.status_code} and message '{response.text}'"
-            raise Exception(f"API call failed with status code {response.status_code} and message '{response.text}'")
-        
-        output = response.text
-        return output
-    finally:
-        global firebase_current_ref
-        firebase_current_ref = firebase_data_ref.push({
-            "type": "open_question",
-            **input_json,
-            "output": output,
-            "datetime": str(datetime.datetime.now()),
-            "like": 0,
-            "comment_text": "",
-            "flagged": False,
-        })
-
-def like():
-    global firebase_current_ref
-    if firebase_current_ref is not None:
-        firebase_current_ref.update({"like": 1})
-        gr.Info("Generated text liked.")
-    else:
-        gr.Warning("No generated text to vote.")
-
-def neutral_like():
-    global firebase_current_ref
-    if firebase_current_ref is not None:
-        firebase_current_ref.update({"like": 0})
-        gr.Info("Generated text preference removed.")
-    else:
-        gr.Warning("No generated text to vote.")
-
-def dislike():
-    global firebase_current_ref
-    if firebase_current_ref is not None:
-        firebase_current_ref.update({"like": -1})
-        gr.Info("Generated text disliked.")
-    else:
-        gr.Warning("No generated text to vote.")
-
-def comment(comment_text):
-    global firebase_current_ref
-    if firebase_current_ref is not None:
-        firebase_current_ref.update({"comment": comment_text})
-        gr.Info("Comment added.")
+    if skip:
+        info = {
+            **info,
+            # selected image info
+            "selected_image": "None",
+            "selected_algo": "None",
+        }
     else:
-        raise gr.Error("No generated text to comment.")
-
-def flag(flag_btn):
-    global firebase_current_ref
-    if firebase_current_ref is not None:
-        firebase_current_ref.update({"flagged": not firebase_current_ref.get()["flagged"]})
-        if firebase_current_ref.get()["flagged"]:
-            gr.Info("Generated text flagged.")
-            value = "⚠️  Unflag"
-        else:
-            gr.Info("Generated text unflagged.")
-            value = "⚠️  Flag"
-        return gr.Button(value=value)
-    else:
-        gr.Warning("No generated text to flag.")
-
-    return flag_btn
-
+        info = {
+            **info,
+            # selected image info
+            "selected_image": experiment["options"][experiment["selected_image"]]["name"],
+            "selected_algo": experiment["options"][experiment["selected_image"]]["algo"],
+        }
+    
+    return info
+
+def generate_new_experiment():
+    pass
+    # wanted_corruptions = ["spatter", "impulse_noise", "speckle_noise", "gaussian_noise", "pixelate", "jpeg_compression", "elastic_transform"]
+    # corruption = random.choice([f for f in list(Path(f"./images/{DATASET}").glob("*/*")) if f.is_dir() and f.name in wanted_corruptions])
+    # image_id = random.choice(list(corruption.glob("*")))
+    # imgs_to_sample = (NUMBER_OF_IMAGES_PER_ROW * NUMBER_OF_ROWS) // 2
+
+    # corrupted_image = {"name": str(random.choice(list(image_id.glob("*corrupted*"))))}
+    # sdedit_images = [
+    #     {"name": str(img), "algo": "SDEdit"}
+    #     for img in random.sample(list((image_id / "sde").glob(f"*")), imgs_to_sample)
+    # ]
+    # odedit_images = [
+    #     {"name": str(img), "algo": "ODEdit"}
+    #     for img in random.sample(list((image_id / "ode").glob(f"*")), imgs_to_sample)
+    # ]
+    # total_images = sdedit_images + odedit_images
+    # random.shuffle(total_images)
+
+    # return Experiment(
+    #     DATASET,
+    #     corruption.name,
+    #     image_id.name,
+    #     corrupted_image,
+    #     total_images,
+    # )
+
+def save(experiment, corrupted_component, *img_components, mode):
+    if mode == "save" and (experiment is None or experiment["selected_image"] is None):
+        gr.Warning("You must select an image before submitting")
+        return [experiment, corrupted_component, *img_components]
+    if mode == "skip":
+        experiment["selected_image"] = None
+
+    dict_to_save = {
+        **generation_to_dict(experiment, skip=(mode=="skip")),
+        "timestamp": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+    }
+    # firebase_data_ref.push(dict_to_save)
+
+    print("=====================")
+    print(dict_to_save)
+    print("=====================")
+
+    gr.Info("Your choice has been saved to Firebase")
+    return next()
+
+def analyze_resource(url):
+    response = requests.post(
+        BASE_URL + "Analyser/analyseMaterial",
+        headers={"ApiKey": API_KEY, "SetupModel": str(SETUP_MODEL)},
+        json={
+            "material": url
+        },
+        timeout=20
+    )
+
+    if response.status_code != 200:
+        raise gr.Error(f"Failed to analyze resource: {response.text}")
+    
+    return response.json()
+
+def generate_learning_objective(topic, context, level):
+    response = requests.post(
+        BASE_URL + "LOGenerator/generatelearningobjective",
+        headers={"ApiKey": API_KEY, "SetupModel": str(SETUP_MODEL)},
+        json={
+            "topic": topic,
+            "context": context,
+            "level": levels.index(level)
+        },
+        timeout=20
+    )
+
+    print(topic, context, level)
+
+    if response.status_code != 200:
+        raise gr.Error(f"Failed to generate learning objective: {response.text}")
+    
+    return response.json()
+
+def generate_exercise(state):
+    def find_key(d, item):
+        for key, value in d.items():
+            if item in value:
+                return key
+        return None
+
+    step3 = requests.post(
+        BASE_URL + "Exercises/GenerateExercise",
+        headers={"ApiKey": API_KEY, "SetupModel": str(SETUP_MODEL)},
+        json={
+            # filled in with the data from the previous steps
+            "macroSubject": state['MacroSubject'],
+            "title": state['Title'],
+            "level": state['level'],
+            "learningObjective": state['learningObjective'],
+            "bloomLevel": find_key(state["learningObjectiveList"], state['learningObjective']),
+            "language": state['Language'],
+            "material": state['material_url'],
+            "assignmentType": [topic['Type'] for topic in state['MainTopics'] if topic['Topic'] == state['topic']][0],
+            "topic": state['topic'],
+            "temperature": 0,
+            
+            # to be filled in manually
+            "correctAnswersNumber": 0,
+            "distractorsNumber": 0,
+            "easilyDiscardableDistractorsNumber": 0,
+            "typeOfExercise": 0
+        },
+        timeout=20
+    )
+
+##################################################################
+# UI Layer
+##################################################################
+
+def format_output(output, exercise_type):
+    if type_of_exercise[exercise_type] in ["Open Question", "Short Answer Question"]:
+        return f"<div class='markdown-body'><h3>{output['Assignment']}</h3><p>{output['Solutions'][0]}</p></div>"
+    
+    return f"<div class='markdown-body'><h3>Ouput (unknown type)</h3><p>{output['Solutions'][0]}</p></div>"
+
+
+def reset_UI():
+    return [
+        {"level": levels[-1], "language": "English"},
+    ]
+
+def next():
+    new_experiment = generate_new_experiment()
+
+    new_img_components = [
+        gr.Image(value=img["name"], label=f"{i}", elem_id="unsel", show_label=False, show_download_button=False, show_share_button=False, interactive=False)
+        for i, img in enumerate(new_experiment["options"])
+    ]
+    new_corrupted_component = gr.Image(value=new_experiment["corrupted"]["name"], label="corr", elem_id="corrupted", show_label=False, show_download_button=False, show_share_button=False, interactive=False)
+
+    return [new_experiment, new_corrupted_component, *new_img_components]
+
+def on_url_change(url, state):
+    material = analyze_resource(url)
+
+    topics = [topic['Topic'] for topic in material['MainTopics']]
+
+    components = reset_UI()
+    state = components[0]
+    state = state | material
+    state['material_url'] = url
+
+    return [gr.Radio(label="Topic", choices=topics, interactive=True), state]
+
+def on_topic_change(topic, old_state):
+    old_state['topic'] = topic
+
+    learning_objective = generate_learning_objective(topic, f"A {old_state['level']} class", old_state["level"])
+    old_state['learningObjectiveList'] = learning_objective
+
+    possible_objectives = list(chain.from_iterable(learning_objective.values()))
+
+    return [gr.Dropdown(label="Learning Objective", choices=possible_objectives, value=possible_objectives[0], interactive=True), old_state]
+
+css = """
+body, html {
+    margin: 0;
+    height: 100%;     /* Full height */
+    width: 100%;      /* Full width */
+    overflow: hidden; /* Prevent scrolling */
+}
+.interface, .block-container {
+    display: flex;
+    flex-direction: column;
+    height: 100%;     /* Full height */
+    width: 100%;      /* Full width */
+}
+.row-content {
+    height: 90vh;        /* Full height */
+}
+.column-content {
+    display: flex;
+    flex-direction: column;
+    flex: 1;             /* Flexibly take up available space */
+    height: 100%;        /* Full height */
+}
+iframe.second-row {
+    width: 100%;         /* Full width */
+    height: 50vh;        /* Full height */
+    border: none;        /* No border */
+    background-color: #f9f9f9; /* Light background */
+}
+
+/* Base style for Markdown content */
+.markdown-body {
+    font-family: 'Helvetica Neue', Arial, sans-serif; /* Clean and modern font */
+    line-height: 1.6;   /* Ample line height for readability */
+    font-size: 16px;    /* Standard font size for readability */
+    color: #333;        /* Dark grey color for text for less strain */
+    background-color: #f9f9f9; /* Light background to reduce glare */
+    padding: 20px;      /* Padding around text */
+    border-radius: 8px; /* Slightly rounded corners for a softer look */
+    box-shadow: 0 2px 4px rgba(0,0,0,0.1); /* Subtle shadow for depth */
+    max-width: 800px;   /* Max width to maintain optimal line length */
+    margin: 20px auto;  /* Center align the Markdown content */
+}
+
+/* Headings with increased weight and spacing for clear hierarchy */
+.markdown-body h1,
+.markdown-body h2,
+.markdown-body h3,
+.markdown-body h4,
+.markdown-body h5,
+.markdown-body h6 {
+    color: #2a2a2a; /* Slightly darker than the text color */
+    margin-top: 24px;
+    margin-bottom: 16px;
+    font-weight: bold;
+}
+
+.markdown-body h1 {
+    font-size: 2em; /* Larger size for main titles */
+}
+
+.markdown-body h2 {
+    font-size: 1.5em;
+}
+
+.markdown-body h3 {
+    font-size: 1.17em;
+}
+
+/* Paragraphs with bottom margin for better separation */
+.markdown-body p {
+    margin-bottom: 16px;
+}
+
+/* Links with a subtle color to stand out */
+.markdown-body a {
+    color: #0656b5;
+    text-decoration: none; /* No underline */
+}
+
+.markdown-body a:hover,
+.markdown-body a:focus {
+    text-decoration: underline; /* Underline on hover/focus for visibility */
+}
+
+/* Lists styled with padding and margin for clarity */
+.markdown-body ul,
+.markdown-body ol {
+    padding-left: 20px;
+    margin-top: 0;
+    margin-bottom: 16px;
+}
+
+.markdown-body li {
+    margin-bottom: 8px; /* Space between list items */
+}
+
+/* Blockquotes with a left border and padding for emphasis */
+.markdown-body blockquote {
+    padding: 10px 20px;
+    margin: 0;
+    border-left: 5px solid #ccc; /* Subtle grey line to indicate quotes */
+    background-color: #f0f0f0; /* Very light background for contrast */
+    font-style: italic;
+}
+
+/* Code styling for inline and blocks */
+.markdown-body code {
+    font-family: monospace;
+    background-color: #eee; /* Light grey background */
+    padding: 2px 4px;
+    border-radius: 3px; /* Rounded corners for code blocks */
+    font-size: 90%;
+}
+
+.markdown-body pre {
+    background-color: #f4f4f4; /* Slightly different background for distinction */
+    border: 1px solid #ddd; /* Border for definition */
+    padding: 10px; /* Padding inside code blocks */
+    overflow: auto; /* Auto-scroll for overflow */
+    line-height: 1.45;
+    border-radius: 5px;
+}
+"""
+
+
+with gr.Blocks(title="Educational AI", css=css) as demo:
+    state = gr.State({"level": levels[-1], "language": "English"})
+
+    with gr.Row(elem_classes=["row-content"]):
+        with gr.Column(scale=3, elem_classes=["column-content"]):
+            language_component = gr.Dropdown(languages, label="Exercise Language", value="English")
+            level_component = gr.Dropdown(label="Level", choices=levels, value=levels[-1])
+            url_component = gr.Textbox(label="Input URL", placeholder="Enter URL here...")
+            iframe_component = gr.HTML("<iframe class='second-row' src='' allowfullscreen></iframe>")
+
+        with gr.Column(scale=3):
+            topic_component = gr.Radio(label="Topic", choices=["placeholder"], interactive=False)
+            lo_component = gr.Dropdown(label="Learning Objective", choices=[], value="placeholder", interactive=False)
+            question_type_component = gr.Dropdown(label="Question Type", choices=type_of_exercise, type="index")
+            
+            correct_answers_component = gr.Number(value=1, minimum=1, maximum=3, step=1, label="Number of correct answers", interactive=False)
+            easy_distractors_component = gr.Number(value=1, minimum=0, maximum=8, step=1, label="Number of easy distractors", interactive=False)
+            distractors_component = gr.Number(value=1, minimum=0, maximum=8, step=1, label="Number of distractors", interactive=False)
+
+        with gr.Column(scale=3):
+            generate_btn = gr.Button("Generate Question")
+            output_component = gr.HTML("<div class='markdown-body'><h3>Output</h3>Placeholder for output</div>")
+
+    # on language change
+    language_component.change(lambda x, old_state: old_state | {"language": x}, [language_component, state], [state])
+
+    # on level change
+    level_component.change(lambda x, old_state: old_state | {"level": x}, [level_component, state], [state])
+
+    # on url change
+    url_component.change(lambda x: gr.HTML(f"<iframe class='second-row' src='{x}' allowfullscreen></iframe>"), [url_component], [iframe_component])
+    url_component.change(lambda x: gr.Info(f"Analyzing resource at {x}..."), [url_component], [])
+    url_component.change(on_url_change, [url_component, state], [topic_component, state])
+
+    # on topic change
+    topic_component.change(lambda x: gr.Info(f"Generating learning objective for {x}..."), [topic_component], [])
+    topic_component.change(on_topic_change, [topic_component, state], [lo_component, state])
+
+    # on lo change
+    lo_component.change(lambda x, old_state: old_state | {"learningObjective": x}, [lo_component, state], [state])
+    
+    # on question type change
+    question_type_component.change(lambda x, old_state: old_state | {"typeOfExercise": x}, [question_type_component, state], [state])
+    
 
-#################################################################################################################################################
-# Interface building
-#################################################################################################################################################
+    # on generate question
+    generate_btn.click(lambda: gr.Info("Generating question..."))
+    generate_btn.click(generate_exercise, [state], [output_component])
 
-def build_fill_gaps_interface():
-    """
-    Build the fill-gaps interface.
-    """
-    with gr.Blocks(title="Fill-gaps") as demo:
-        with gr.Row():
-            with gr.Column(scale=5):
-                input_field = gr.TextArea(lines=10, max_lines=10, label="Input Educational resource text or URL",
-                                          info="Note: If the input resource is too long, the API will return an error. If the input is an URL, it must be a valid URL to webpage or a file.")
-                submit_btn = gr.Button(value="Submit")
-            with gr.Column(scale=4):
-                level = gr.Radio(levels, label="Level")
-                language = gr.Dropdown(languages, label="Language", value="English")
-                output_text_length = gr.Radio(["≈ 150 Words", "≈ 250 Words", "≈ 350 Words"], label="Output text length", value="≈ 150 Words")
-                with gr.Row():
-                    blanks = gr.Number(value=5, minimum=4, maximum=8, step=1, label="Number of blanks")
-                    distractors = gr.Number(value=2, minimum=0, maximum=5, step=1, label="Number of distractors")
-                temperature = gr.Checkbox(value=False, label="Increase creativity (decreases preciseness)", visible=False)
-
-                def update_numeric(output_text_length, blanks, distractors):
-                    if output_text_length == "≈ 150 Words":
-                        min_, max_ = 4, 8
-                    elif output_text_length == "≈ 250 Words":
-                        min_, max_ = 6, 10
-                    elif output_text_length == "≈ 350 Words":
-                        min_, max_ = 8, 12
-
-                    return (
-                        gr.Number(value=clamp(blanks, min_, max_), minimum=min_, maximum=max_, label="Number of blanks"),
-                        gr.Number(value=clamp(distractors, 0, blanks), minimum=0, maximum=blanks, label="Number of distractors")
-                    )
-                
-                def update_blanks(blanks, distractors):
-                    return gr.Number(value=clamp(distractors, 0, blanks), minimum=0, maximum=blanks, label="Number of distractors")
-
-                blanks.change(update_blanks, [blanks, distractors], [distractors])
-                output_text_length.change(update_numeric, [output_text_length, blanks, distractors], [blanks, distractors])
-
-        with gr.Row():
-            output = gr.TextArea(placeholder="Generated text", label="Output")
-        with gr.Row() as button_row:
-            upvote_btn = gr.Button(value="👍  Upvote")
-            remove_preference_btn = gr.Button(value="Remove Preference")
-            downvote_btn = gr.Button(value="👎  Downvote")
-            flag_btn = gr.Button(value="⚠️  Flag")
-        
-        submit_btn.click(generate_fill_gaps, [input_field, level, output_text_length, blanks, distractors, temperature, language], [output])
-        upvote_btn.click(like)
-        remove_preference_btn.click(neutral_like)
-        downvote_btn.click(dislike)
-        flag_btn.click(flag, [flag_btn], [flag_btn])
-
-        return demo
-
-def build_multiplechoice_interface():
-    """
-    Build the open question interface.
-    """
-    with gr.Blocks(title="Open Question") as demo:
-        with gr.Row():
-            with gr.Column(scale=5):
-                input_field = gr.TextArea(lines=10, max_lines=10, label="Input Educational resource text or URL",
-                                          info="Note: If the input resource is too long, the API will return an error. If the input is an URL, it must be a valid URL to webpage or a file.")
-                submit_btn = gr.Button(value="Submit")
-            with gr.Column(scale=4):
-                level = gr.Radio(levels, label="Level")
-                language = gr.Dropdown(languages, label="Language", value="English")
-                with gr.Row():
-                    exercise_type = gr.Radio(["Theoretical", "Practical"], label="Exercise type", value="Theoretical", type="index")
-                    question_category = gr.Dropdown(categories, label="Question Category", value="Factual Knowledge")
-                with gr.Row():
-                    correct_answers = gr.Number(value=1, minimum=1, maximum=3, step=1, label="Number of correct answers")
-                    easy_distractors = gr.Number(value=1, minimum=0, maximum=8, step=1, label="Number of easy distractors")
-                    distractors = gr.Number(value=1, minimum=0, maximum=8, step=1, label="Number of distractors")
-                temperature = gr.Checkbox(value=False, label="Increase creativity (decreases preciseness)", visible=False)
-                
-                def update_distractors(easy_distractors, distractors):
-                    easy_distractors = clamp(easy_distractors, 0, distractors)
-
-                    return gr.Number(value=easy_distractors, minimum=0, maximum=distractors, label="Number of easy distractors")
-
-                def update_exercise_type(exercise_type, question_category, number_of_correct_answers):
-                    if exercise_type == 0:
-                        return (
-                            gr.Dropdown(categories, label="Question Category", value="Analysys And Evaluation"),
-                            gr.Number(value=number_of_correct_answers, minimum=1, maximum=3, step=1, label="Number of correct answers")
-                        )
-                    elif exercise_type == 1:
-                        return (
-                            gr.Dropdown(["Analysys And Evaluation"], label="Question Category", value="Analysys And Evaluation"),
-                            gr.Number(value=1, minimum=1, maximum=1, step=1, label="Number of correct answers")
-                        )
-
-                distractors.change(update_distractors, [easy_distractors, distractors], [easy_distractors])
-                exercise_type.change(update_exercise_type, [exercise_type, question_category, correct_answers], [question_category, correct_answers])
-
-        with gr.Row():
-            output = gr.TextArea(placeholder="Generated text", label="Output")
-        with gr.Row() as button_row:
-            upvote_btn = gr.Button(value="👍  Upvote")
-            remove_preference_btn = gr.Button(value="Remove Preference")
-            downvote_btn = gr.Button(value="👎  Downvote")
-            flag_btn = gr.Button(value="⚠️  Flag")
-        
-        submit_btn.click(generate_multiplechoice, [input_field, level, easy_distractors, distractors, temperature, language, question_category, correct_answers, exercise_type], [output])
-        upvote_btn.click(like)
-        remove_preference_btn.click(neutral_like)
-        downvote_btn.click(dislike)
-        flag_btn.click(flag, [flag_btn], [flag_btn])
-
-        return demo
-
-def build_open_question_interface():
-    """
-    Build the multiple-choice interface.
-    """
-    with gr.Blocks(title="Multiple choice") as demo:
-        with gr.Row():
-            with gr.Column(scale=5):
-                input_field = gr.TextArea(lines=10, max_lines=10, label="Input Educational resource text or URL",
-                                          info="Note: If the input resource is too long, the API will return an error. If the input is an URL, it must be a valid URL to webpage or a file.")
-                submit_btn = gr.Button(value="Submit")
-            with gr.Column(scale=4):
-                level = gr.Radio(levels, label="Level")
-                language = gr.Dropdown(languages, label="Language", value="English")
-                with gr.Row():
-                    question_type = gr.Dropdown(["Open", "ShortAnswer", "TrueFalse"], label="Question Type", value="Open", type="index")
-                    question_category = gr.Dropdown(categories, label="Question Category", value="Factual Knowledge")
-                temperature = gr.Checkbox(value=False, label="Increase creativity (decreases preciseness)", visible=False)
-        with gr.Row():
-            output = gr.TextArea(placeholder="Generated text", label="Output")
-        with gr.Row() as button_row:
-            upvote_btn = gr.Button(value="👍  Upvote")
-            remove_preference_btn = gr.Button(value="Remove Preference")
-            downvote_btn = gr.Button(value="👎  Downvote")
-            flag_btn = gr.Button(value="⚠️  Flag")
-
-        submit_btn.click(generate_open_question, [input_field, level, temperature, language, question_type, question_category], [output])
-        upvote_btn.click(like)
-        remove_preference_btn.click(neutral_like)
-        downvote_btn.click(dislike)
-        flag_btn.click(flag, [flag_btn], [flag_btn])
-
-        return demo
-
-def build_demo():
-    with gr.Blocks(title="Educational AI") as demo:
-        gr.Markdown("<h1 style='text-align: center; margin-bottom: 1rem'>Educational AI</h1>")
-
-
-        with gr.Row():
-            gr.Markdown("<h4>Click on the button on the right to fill up our questionnaire!</h4>")
-            gr.Button(value="📝  Questionnaire", link="https://forms.gle/T8CS5CiQgPbKUdeM9", scale=0.5, interactive=True)
-
-        with gr.Tab("Fill-gaps"):
-            build_fill_gaps_interface()
-
-        with gr.Tab("Open question"):
-            build_open_question_interface()
-
-        with gr.Tab("Multiple-choice"):
-            build_multiplechoice_interface()
-
-        with gr.Blocks():
-            with gr.Row():
-                comment_text = gr.TextArea(placeholder="Comment", label="Comment", scale=6)
-                comment_btn = gr.Button(value="💬 Comment", scale=2)
-                comment_btn.click(comment, [comment_text])
-
-        return demo
-
-if __name__ == "__main__":
-    build_demo().launch(share=False)
+demo.launch(show_api=False)