Merge branch 'vlad' into 'main'

Count up quiz

See merge request tangibleai/community/mathtext-fastapi!10

app.py

@@ -1,7 +1,11 @@
 """FastAPI endpoint
 To run locally use 'uvicorn app:app --host localhost --port 7860'
 """
-import re
+import ast
+import scripts.quiz.generators as generators
+import scripts.quiz.hints as hints
+import scripts.quiz.questions as questions
+import scripts.quiz.utils as utils
 
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse
@@ -100,3 +104,168 @@ async def evaluate_user_message_with_nlu_api(request: Request):
     message_data = data_dict.get('message_data', '')
     nlu_response = evaluate_message_with_nlu(message_data)
     return JSONResponse(content=nlu_response)
+    
+
+@app.post("/question")
+async def ask_math_question(request: Request):
+    """Generate a question and return it as response along with question data
+    
+    Input
+    request.body: json - amount of correct and incorrect answers in the account
+    {
+        'number_correct': 0,
+        'number_incorrect': 0,
+        'level': 'easy'
+    }
+
+    Output
+    context: dict - the information for the current state
+    {
+        'text': 'What is 1+2?',
+        'question_numbers': [1,2,3], #3 numbers - current number, ordinal number, times
+        'right_answer': 3,
+        'number_correct': 0,
+        'number_incorrect': 0,
+        'hints_used': 0
+    }
+    """
+    data_dict = await request.json()
+    message_data = ast.literal_eval(data_dict.get('message_data', '').get('message_body', ''))
+    right_answers = message_data['number_correct']
+    wrong_answers = message_data['number_incorrect']
+    level = message_data['level']
+
+    return JSONResponse(generators.start_interactive_math(right_answers, wrong_answers, level))
+
+
+@app.post("/hint")
+async def get_hint(request: Request):
+    """Generate a hint and return it as response along with hint data
+    
+    Input
+    request.body:
+    {
+        'question_numbers': [1,2,3], #3 numbers - current number, ordinal number, times
+        'right_answer': 3,
+        'number_correct': 0,
+        'number_incorrect': 0,
+        'level': 'easy',
+        'hints_used': 0
+    }
+
+    Output
+    context: dict - the information for the current state
+    {
+        'text': 'What is 1+2?',
+        'question_numbers': [1,2,3], #2 or 3 numbers
+        'right_answer': 3,
+        'number_correct': 0,
+        'number_incorrect': 0,
+        'level': 'easy',
+        'hints_used': 0
+    }
+    """
+    data_dict = await request.json()
+    message_data = ast.literal_eval(data_dict.get('message_data', '').get('message_body', ''))
+    question_numbers = message_data['question_numbers']
+    right_answer = message_data['right_answer']
+    number_correct = message_data['number_correct']
+    number_incorrect = message_data['number_incorrect']
+    level = message_data['level']
+    hints_used = message_data['hints_used']
+
+    return JSONResponse(hints.generate_hint(question_numbers, right_answer, number_correct, number_incorrect, level, hints_used))
+
+
+@app.post("/generate_question")
+async def generate_question(request: Request):
+    """Generate a bare question and return it as response
+    
+    Input
+    request.body: json - level
+    {
+        'level': 'easy'
+    }
+
+    Output
+    context: dict - the information for the current state
+    {
+        "question": "Let's count up by 2s. What number is next if we start from 10?
+        6 8 10 ..."
+    }
+    """
+    data_dict = await request.json()
+    message_data = ast.literal_eval(data_dict.get('message_data', '').get('message_body', ''))
+    level = message_data['level']
+
+    return JSONResponse(questions.generate_question_data(level)['question'])
+
+
+@app.post("/numbers_by_level")
+async def get_numbers_by_level(request: Request):
+    """Generate three numbers and return them as response
+    
+    Input
+    request.body: json - level
+    {
+        'level': 'easy'
+    }
+
+    Output
+    context: dict - three generated numbers for specified level
+    {
+        "current_number": 10,
+        "ordinal_number": 2,
+        "times": 1
+    }
+    """
+    data_dict = await request.json()
+    message_data = ast.literal_eval(data_dict.get('message_data', '').get('message_body', ''))
+    level = message_data['level']
+    return JSONResponse(questions.generate_numbers_by_level(level))
+
+
+@app.post("/number_sequence")
+async def get_number_sequence(request: Request):
+    """Generate a number sequence
+    
+    Input
+    request.body: json - level
+    {
+        "current_number": 10,
+        "ordinal_number": 2,
+        "times": 1
+    }
+
+    Output
+    one of following strings with (numbers differ):
+    ... 1 2 3
+    1 2 3 ...
+    """
+    data_dict = await request.json()
+    message_data = ast.literal_eval(data_dict.get('message_data', '').get('message_body', ''))
+    cur_num = message_data['current_number']
+    ord_num = message_data['ordinal_number']
+    times = message_data['times']
+    return JSONResponse(questions.generate_number_sequence(cur_num, ord_num, times))
+
+
+@app.post("/level")
+async def get_next_level(request: Request):
+    """Depending on current level and desire to level up/down return next level
+    
+    Input
+    request.body: json - level
+    {
+        "current_level": "easy",
+        "level_up": True
+    }
+
+    Output
+    Literal - "easy", "medium" or "hard"
+    """
+    data_dict = await request.json()
+    message_data = ast.literal_eval(data_dict.get('message_data', '').get('message_body', ''))
+    cur_level = message_data['current_level']
+    level_up = message_data['level_up']
+    return JSONResponse(utils.get_next_level(cur_level, level_up))

mathtext_fastapi/conversation_manager.py

@@ -10,9 +10,13 @@ import requests
 from dotenv import load_dotenv
 from mathtext_fastapi.nlu import evaluate_message_with_nlu
 from mathtext_fastapi.math_quiz_fsm import MathQuizFSM
+from mathtext_fastapi.math_subtraction_fsm import MathSubtractionFSM
 from supabase import create_client
 from transitions import Machine
 
+from scripts.quiz.generators import start_interactive_math
+from scripts.quiz.hints import generate_hint
+
 load_dotenv()
 
 SUPA = create_client(
@@ -106,24 +110,27 @@ def pickle_and_encode_state_machine(state_machine):
     return dump_encoded
 
 
-def manage_math_quiz_fsm(user_message, contact_uuid):
+def manage_math_quiz_fsm(user_message, contact_uuid, type):
     fsm_check = SUPA.table('state_machines').select("*").eq(
         "contact_uuid",
         contact_uuid
     ).execute()
 
     if fsm_check.data == []:
-        math_quiz_state_machine = MathQuizFSM()
+        if type == 'addition':
+            math_quiz_state_machine = MathQuizFSM()
+        else:
+            math_quiz_state_machine = MathSubtractionFSM()
         messages = [math_quiz_state_machine.response_text]
         dump_encoded = pickle_and_encode_state_machine(math_quiz_state_machine)
 
         SUPA.table('state_machines').insert({
             'contact_uuid': contact_uuid,
-            'addition3': dump_encoded
+            f'{type}': dump_encoded
         }).execute()
     else:
         undump_encoded = base64.b64decode(
-            fsm_check.data[0]['addition3'].encode('utf-8')
+            fsm_check.data[0][type].encode('utf-8')
         )
         math_quiz_state_machine = pickle.loads(undump_encoded)
 
@@ -132,13 +139,61 @@ def manage_math_quiz_fsm(user_message, contact_uuid):
         messages = math_quiz_state_machine.validate_answer()
         dump_encoded = pickle_and_encode_state_machine(math_quiz_state_machine)          
         SUPA.table('state_machines').update({
-            'addition3': dump_encoded
+            f'{type}': dump_encoded
         }).eq(
             "contact_uuid", contact_uuid
         ).execute()
     return messages
 
 
+def use_quiz_module_approach(user_message, context_data):
+    print("USER MESSAGE")
+    print(user_message)
+    print("=======================")
+    if user_message == 'add':
+        context_result = start_interactive_math()
+        message_package = {
+            'messages': [
+                "Great, let's do some addition",
+                "First, we'll start with single digits.",
+                "Type your response as a number.  For example, for '1 + 1', you'd write 2."
+            ],
+            'input_prompt': context_result['text'],
+            'state': "addition-question-sequence"
+        }
+
+    elif user_message == context_data.get('right_answer'):
+        context_result = start_interactive_math(
+            context_data['number_correct'],
+            context_data['number_incorrect'],
+            context_data['level']
+        )
+        message_package = {
+            'messages': [
+                "That's right, great!",
+            ],
+            'input_prompt': context_result['text'],
+            'state': "addition-question-sequence"
+        }
+    else:
+        context_result = generate_hint(
+            context_data['question_numbers'],
+            context_data['right_answer'],
+            context_data['number_correct'],
+            context_data['number_incorrect'],
+            context_data['level'],
+            context_data['hints_used']
+        )
+        message_package = {
+            'messages': [
+                context_result['text'],
+            ],
+            'input_prompt': context_data['text'],
+            'state': "addition-question-sequence"
+        }
+    return message_package, context_result
+
+
 def return_next_conversational_state(context_data, user_message, contact_uuid):
     """ Evaluates the conversation's current state to determine the next state
 
@@ -159,12 +214,36 @@ def return_next_conversational_state(context_data, user_message, contact_uuid):
     elif context_data['state'] == 'addition-question-sequence' or \
         user_message == 'add':
 
-        messages = manage_math_quiz_fsm(user_message, contact_uuid)
+        # Used in FSM
+        # messages = manage_math_quiz_fsm(user_message, contact_uuid)
+
+        message_package, context_result = use_quiz_module_approach(user_message, context_data)
 
         if user_message == 'exit':
             state_label = 'exit'
         else:
             state_label = 'addition-question-sequence'
+        # Used in FSM
+        # input_prompt = messages.pop()
+        # message_package = {
+        #     'messages': messages,
+        #     'input_prompt': input_prompt,
+        #     'state': state_label
+        # }
+
+        print("MESSAGE PACKAGE")
+        print(message_package)
+        context_data = context_result
+        message_package['state'] = state_label
+
+    elif context_data['state'] == 'subtraction-question-sequence' or \
+        user_message == 'subtract':
+        messages = manage_math_quiz_fsm(user_message, contact_uuid, 'subtraction')
+
+        if user_message == 'exit':
+            state_label = 'exit'
+        else:
+            state_label = 'subtraction-question-sequence'
 
         input_prompt = messages.pop()
 
@@ -173,15 +252,15 @@ def return_next_conversational_state(context_data, user_message, contact_uuid):
             'input_prompt': input_prompt,
             'state': state_label
         }
-    elif user_message == 'subtract':
-        message_package = {
-            'messages': [
-                "Time for some subtraction!",
-                "Type your response as a number.  For example, for '1 - 1', you'd write 0."
-            ],
-            'input_prompt': "Here's the first one... What's 3-1?",
-            'state': "subtract-question-sequence"
-        }
+
+        # message_package = {
+        #     'messages': [
+        #         "Time for some subtraction!",
+        #         "Type your response as a number.  For example, for '1 - 1', you'd write 0."
+        #     ],
+        #     'input_prompt': "Here's the first one... What's 3-1?",
+        #     'state': "subtract-question-sequence"
+        # }
     elif context_data['state'] == 'exit' or user_message == 'exit':
         message_package = {
             'messages': [
@@ -198,8 +277,12 @@ def return_next_conversational_state(context_data, user_message, contact_uuid):
             'input_prompt': "Please type add or subtract to start a math activity.",
             'state': "reprompt-menu-options"
         }
+    # Used in FSM
     return message_package
 
+    # Used in quiz folder approach
+    # return context_result, message_package
+
 
 def manage_conversation_response(data_json):
     """ Calls functions necessary to determine message and context data to send
@@ -227,11 +310,18 @@ def manage_conversation_response(data_json):
     # TODO: Need to incorporate nlu_response into wormhole by checking answers against database (spreadsheet?)
     nlu_response = evaluate_message_with_nlu(message_data)
 
-    message_package = return_next_conversational_state(
-        context_data,
-        user_message,
-        contact_uuid
-    )
+    if context_data['state'] == 'addition':
+        context_result, message_package = return_next_conversational_state(
+            context_data,
+            user_message,
+            contact_uuid
+        )
+    else:
+        message_package = return_next_conversational_state(
+            context_data,
+            user_message,
+            contact_uuid
+        )
 
     print("MESSAGE PACKAGE")
     print(message_package)
@@ -255,15 +345,32 @@ def manage_conversation_response(data_json):
         )
 
     # Update the context object with the new state of the conversation
-    context = {
-        "context":{
-            "user": whatsapp_id,
-            "state": message_package['state'],
-            "bot_message": message_package['input_prompt'],
-            "user_message": user_message,
-            "type": 'ask'
+    if context_data['state'] == 'addition':
+        context = {
+            "context": {
+                "user": whatsapp_id,
+                "state": message_package['state'],
+                "bot_message": message_package['input_prompt'],
+                "user_message": user_message,
+                "type": 'ask',
+                # Necessary for quiz folder approach
+                "text": context_result.get('text'),
+                "question_numbers": context_result.get('question_numbers'),
+                "right_answer": context_result.get('right_answer'),
+                "number_correct": context_result.get('number_correct'),
+                "hints_used": context_result.get('hints_used'),
+            }
+        }
+    else:
+        context = {
+            "context": {
+                "user": whatsapp_id,
+                "state": message_package['state'],
+                "bot_message": message_package['input_prompt'],
+                "user_message": user_message,
+                "type": 'ask',
+            }
         }
-    }
 
     return context
 

mathtext_fastapi/math_subtraction_fsm.py

@@ -0,0 +1,58 @@
+import random
+from transitions import Machine
+
+
+class MathSubtractionFSM(object):
+    states = [
+        'quiz_start',
+        'quiz_question',
+        'quiz_end'
+    ]
+
+    transitions = [
+        ['ask_second_question', 'quiz_start', 'quiz_question'],
+        ['ask_next_question', 'quiz_question', 'quiz_question'],
+        ['exit', 'quiz_start', 'quiz_end'],
+        ['exit', 'quiz_question', 'quiz_end'],
+    ]
+
+    def __init__(
+        self,
+        initial_state='quiz_start',
+        question_nums=[4, 3],
+        initial_student_answer=0,
+    ):
+        # Instantiate the FSM
+        self.machine = Machine(
+            model=self,
+            states=MathSubtractionFSM.states,
+            transitions=MathSubtractionFSM.transitions,
+            initial=initial_state
+        )
+
+        # Instantiate variables necessary for tracking activity
+        self.question_nums = question_nums
+        self.correct_answer = self.question_nums[0] - self.question_nums[1]
+        self.student_answer = initial_student_answer
+        self.is_correct_answer = False
+        self.response_text = f"What is {self.question_nums[0]} - {self.question_nums[1]}?"
+
+        # Define functions to run on transitions
+        self.machine.on_enter_quiz_question('generate_math_problem')
+        self.machine.on_exit_quiz_question('validate_answer')
+
+    def validate_answer(self):
+        if self.student_answer == 'exit':
+            self.machine.set_state('quiz_end')
+            return ["Come back any time!"]
+        elif self.correct_answer == self.student_answer:
+            self.machine.set_state('quiz_question')
+            self.generate_math_problem()
+            return ['Great job!', self.response_text]
+        else:
+            return ["That's not quite right.  Try again.", self.response_text]
+    
+    def generate_math_problem(self):
+        self.question_nums = random.sample(range(1, 100), 2)
+        self.response_text = f"What is {self.question_nums[0]} - {self.question_nums[1]}"
+        self.correct_answer = self.question_nums[0] - self.question_nums[1]

scripts/make_request.py

@@ -20,13 +20,25 @@ def add_message_text_to_sample_object(message_text):
     
     """
     message_data = '{' + f'"author_id": "+57787919091", "author_type": "OWNER", "contact_uuid": "j43hk26-2hjl-43jk-hnk2-k4ljl46j0ds09", "message_body": "{message_text}", "message_direction": "inbound", "message_id": "4kl209sd0-a7b8-2hj3-8563-3hu4a89b32", "message_inserted_at": "2023-01-10T02:37:28.477940Z", "message_updated_at": "2023-01-10T02:37:28.487319Z"' + '}'
+    # context_data = '{' + '"user":"", "state":"addition-question-sequence", "bot_message":"", "user_message":"{message_text}"' + '}'
+
     context_data = '{' + '"user":"", "state":"start-conversation", "bot_message":"", "user_message":"{message_text}"' + '}'
 
+    # context_data = '{' + '"user":"", "state":"addition-question-sequence", "bot_message":"", "user_message":"{message_text}","text": "What is 2+3?","question_numbers": [4,3],"right_answer": 7,"number_correct": 2, "number_incorrect": 0, "hints_used": 0, "level": "easy"' + '}'
+
     json_string = '{' + f'"context_data": {context_data}, "message_data": {message_data}' + '}'
     b_string = json_string.encode("utf-8")
 
     return b_string
 
+# """
+#     "text": "What is 2+3?",
+#     "question_numbers": [2,3],
+#     "right_answer": 5,
+#     "number_correct": 2,
+#     "hints_used": 0,
+# """
+
 
 def run_simulated_request(endpoint, sample_answer, context=None):
     print(f"Case: {sample_answer}")
@@ -58,7 +70,35 @@ def run_simulated_request(endpoint, sample_answer, context=None):
 # run_simulated_request('nlu', 'IDK 5?')
 # run_simulated_request('manager', '')
 run_simulated_request('manager', 'add')
-# run_simulated_request('manager', 'subtract')
+run_simulated_request('manager', 'subtract')
+run_simulated_request("question", {
+    'number_correct': 0,
+    'number_incorrect': 0,
+    'level': 'easy'
+})
+run_simulated_request("hint", {
+    'question_numbers': [1, 2, 3],
+    'right_answer': 3,
+    'number_correct': 0,
+    'number_incorrect': 0,
+    'level': 'easy',
+    'hints_used': 0
+})
+run_simulated_request("generate_question", {
+    'level': 'medium'
+})
+run_simulated_request("numbers_by_level", {
+    'level': 'medium'
+})
+run_simulated_request("number_sequence", {
+    "current_number": 10,
+    "ordinal_number": 2,
+    "times": 1
+})
+run_simulated_request("level", {
+    "current_level": "hard",
+    "level_up": False
+})
 # run_simulated_request('manager', 'exit')
 
 

scripts/quiz/generators.py

@@ -0,0 +1,33 @@
+from .questions import generate_question_data
+from .utils import get_next_level
+
+
+def start_interactive_math(right_answers=0, wrong_answers=0, level="easy"):
+    if wrong_answers > 2:
+        wrong_answers = 0
+        right_answers = 0
+        level = get_next_level(level, False)
+    elif right_answers > 2:
+        right_answers = 0
+        wrong_answers = 0
+        level = get_next_level(level)
+        
+    question_data = generate_question_data(level)
+    question = question_data['question']
+    right_answer = question_data['answer']
+    cur_num = question_data['current_number']
+    ord_num = question_data['ordinal_number']
+    times = question_data['times']
+
+    numbers_group = [cur_num, ord_num, times]
+    output = {
+        "text": question,
+        "question_numbers": numbers_group,
+        "right_answer": right_answer,
+        'number_correct': right_answers,
+        'number_incorrect': wrong_answers,
+        'level': level,
+        "hints_used": 0
+    }
+    return output
+

scripts/quiz/hints.py

@@ -0,0 +1,32 @@
+import random
+
+
+def generate_hint(question_nums, right_answer, right_answers, wrong_answers, level, hints_used):
+    ord_num = question_nums[1]  # ordinal number
+    equation = right_answer - 2 * ord_num - 1
+    min_num = equation if equation > 0 else 0
+    seq_before = " ".join(
+        [str(num) for num in range(right_answer - ord_num, min_num, -ord_num)][::-1]
+    )  # sequence before right answer
+    seq_after = " ".join(
+        [str(num) for num in range(right_answer + ord_num, right_answer + 2 * ord_num + 1, ord_num)]
+    )  # sequence after right answer
+    hints = [
+        f"What number will fill the gap in a sequence {seq_before} ... {seq_after}?",
+        f"What number is {ord_num} in the account after {right_answer - ord_num}?",
+        f"What number is {ord_num} in the account before {right_answer + ord_num}?",
+        f"What number is greater than {right_answer - 1} and less than {right_answer + 1}?"
+    ]
+    rand_hint = random.choice(hints)
+    hints_used += 1
+
+    output = {
+        "text": rand_hint,
+        "question_numbers": question_nums,
+        "right_answer": right_answer,
+        'number_correct': right_answers,
+        'number_incorrect': wrong_answers,
+        'level': level,
+        "hints_used": hints_used
+    }
+    return output

scripts/quiz/questions.py

@@ -0,0 +1,116 @@
+import random
+from typing import Literal
+
+
+def generate_question_data(level: Literal["easy", "medium", "hard"] = "easy"):
+    """generate question, its numbers and proper answer"""
+
+    nums = generate_numbers_by_level(level)
+    cur_num = nums['current_number']  # current number
+    ord_num = nums['ordinal_number']  # ordinal number
+    seq_up_by_one = generate_number_sequence(cur_num, ord_num=1, times=1)  # sequence with ord_num = 1, times = 1
+
+    count_up_by_one_questions = [
+        {
+            "question": f"Let's practice counting. After {cur_num}, what number is next?\n{seq_up_by_one}",
+            "current_number": cur_num,
+            "ordinal_number": 1,
+            "times": 1,
+            "answer": cur_num + 1
+        }
+    ]
+    seq_up_by_ord = generate_number_sequence(cur_num, ord_num, times=1)  # sequence with times = 1
+    count_up_by_ord_questions = [
+        {
+            "question": f"What number comes {ord_num} number after {cur_num}?\n{seq_up_by_ord}",
+            "current_number": cur_num,
+            "ordinal_number": ord_num,
+            "times": 1,
+            "answer": cur_num + ord_num 
+        },
+        {
+            "question": f"If we count up {ord_num} from {cur_num}, what number is next?\n{seq_up_by_ord}",
+            "current_number": cur_num,
+            "ordinal_number": ord_num,
+            "times": 1,
+            "answer": cur_num + ord_num
+        }
+    ]
+    times = 1 if level == "easy" else nums['times']
+    times_ord_seq = generate_number_sequence(cur_num, ord_num, times)
+    times_ord_questions = [
+        {
+            "question": f"We're counting up by {times}s. What number is {ord_num} after {cur_num}?\n{times_ord_seq}",
+            "current_number": cur_num,
+            "ordinal_number": ord_num,
+            "times": times,
+            "answer": cur_num + ord_num * times
+        }
+    ]
+    times_only_seq = generate_number_sequence(cur_num, 1, times)  # sequence with ordinal number = 1
+    times_only_questions = [
+        {
+            "question": f"Let's count up by {times}s. What number is next if we start from {cur_num}?\n{times_only_seq}",
+            "current_number": cur_num,
+            "ordinal_number": 1,
+            "times": times,
+            "answer": cur_num + times
+        }
+    ]
+    questions = [*count_up_by_one_questions, *count_up_by_ord_questions, *times_only_questions, *times_ord_questions]
+    random_choice = random.choice(questions)
+    return random_choice
+
+
+def generate_numbers_by_level(level: Literal["easy", "medium", "hard"] = "easy"):
+    """generate current number, ordinal number and times parameter
+    
+    returns
+    dict with params:
+    :param current_number: current number
+    :param ordinal numebr: the number we count up by
+    :param times: the number of times we count up by ordinal number"""
+
+    if level == "easy":
+        cur_num = random.randint(1, 8)
+        ord_num = random.randint(1, 2)
+        times = 1
+    elif level == "medium":
+        cur_num = random.randint(1, 94)
+        ord_num = random.randint(1, 3)
+        times = random.randint(1, 2)
+    elif level == "hard":
+        cur_num = random.randint(1, 488)
+        ord_num = random.randint(1, 4)
+        times = random.randint(1, 2)
+
+    return {
+        "current_number": cur_num,
+        "ordinal_number": ord_num,
+        "times": times
+    }
+
+
+def generate_number_sequence(cur_num, ord_num, times=1):
+    """generate one of 2 sequences. For example we want 55 to be a right answer, then sequences can be:
+    52 53 54 ...
+    ... 56 57 58
+    
+    parameters
+    :cur_num: current number
+    :ord_num: ordinal number
+    :times: times"""
+    max_num = cur_num + times * ord_num
+
+    seq_before = [str(num) for num in range(max_num - times, 0, -times)][:3][::-1]
+    seq_after = [str(num) for num in range(max_num + times, max_num + 4 * times, times)]
+    seq_before.append("...")
+    seq_after.insert(0, "...")
+
+    seqs = []
+    if len(seq_before) == 4:
+        seqs.append(seq_before)
+    if len(seq_after) == 4:
+        seqs.append(seq_after)
+    rand_seq = " ".join(random.choice(seqs))
+    return rand_seq

scripts/quiz/utils.py

@@ -0,0 +1,13 @@
+from typing import Literal
+
+def get_next_level(cur_level, levep_up: Literal[True, False] = True):
+    if levep_up:
+        if cur_level == "easy":
+            return "medium"
+        else:
+            return "hard"
+    else:
+        if cur_level == "medium":
+            return "easy"
+        else:
+            return "medium"