latest update

app.py

@@ -15,9 +15,9 @@ from mathtext.sentiment import sentiment
 from mathtext.text2int import text2int
 from pydantic import BaseModel
 
-from mathtext_fastapi.logging import prepare_message_data_for_logging
-from mathtext_fastapi.conversation_manager import manage_conversation_response
-from mathtext_fastapi.nlu import evaluate_message_with_nlu
+# from mathtext_fastapi.logging import prepare_message_data_for_logging
+# from mathtext_fastapi.conversation_manager import manage_conversation_response
+# from mathtext_fastapi.nlu import evaluate_message_with_nlu
 
 app = FastAPI()
 
@@ -269,3 +269,47 @@ async def get_next_level(request: Request):
     cur_level = message_data['current_level']
     level_up = message_data['level_up']
     return JSONResponse(utils.get_next_level(cur_level, level_up))
+
+
+@app.post("/score")
+async def get_next_level(request: Request):
+    """Depending on current level and desire to level up/down return next level
+    
+    Input
+    request.body: json - score argument with value from 0 to 1
+    {
+        "score": 0.1
+    }
+
+    Output
+    number in range 1-495
+    """
+    data_dict = await request.json()
+    message_data = ast.literal_eval(data_dict.get('message_data', '').get('message_body', ''))
+    score = message_data['score']
+    return JSONResponse(questions.generate_start_by_score(score))
+
+
+@app.post("/question_new")
+async def get_next_level(request: Request):
+    """Depending on current level and desire to level up/down return next level
+    
+    Input
+    request.body: json - score argument with value from 0 to 1
+    {
+        "score": 0.1
+    }
+
+    Output
+    number in range 1-495
+    """
+    data_dict = await request.json()
+    message_data = ast.literal_eval(data_dict.get('message_data', '').get('message_body', ''))
+    start = message_data.get('start', "")
+    start = int(start) if start else start
+    step = message_data.get('step', "")
+    step = int(step) if step else step
+    sequence = message_data.get('sequence', "")
+    question_num = message_data.get('question_num', "")
+    question_num = int(question_num) if question_num else question_num
+    return JSONResponse(questions.generate_question(start, step=step, seq=sequence, question_num=question_num))

scripts/make_request.py

@@ -57,7 +57,41 @@ def run_simulated_request(endpoint, sample_answer, context=None):
 # run_simulated_request('nlu', 'Today is a wonderful day')
 # run_simulated_request('nlu', 'IDK 5?')
 # run_simulated_request('manager', '')
-run_simulated_request('manager', 'add')
+# run_simulated_request('manager', 'add')
+# 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("question_new", {
+    "start": 10,
+    "step": 1,
+    "sequence": "8... 9... 10...",
+    "question_num": 1
+})
 # run_simulated_request('manager', 'subtract')
 # run_simulated_request('manager', 'exit')
 

scripts/quiz/questions.py

@@ -2,24 +2,24 @@ import random
 from typing import Literal
 
 
-def generate_question_data(level: Literal["easy", "medium", "hard"] = "easy"):
+def generate_question_data(level: Literal["easy", "medium", "hard"] = "easy", increment=1):
     """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
+    cur_num = nums['current_number']                                        # current number
+    ord_num = nums['ordinal_number']                                        # ordinal number
+    num_seq = generate_number_sequence(cur_num, ord_num, times=increment)   # 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}",
+            "question": f"Let's practice counting. After {cur_num}, what number is next?\n{num_seq}",
             "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
+    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}",
@@ -47,7 +47,7 @@ def generate_question_data(level: Literal["easy", "medium", "hard"] = "easy"):
             "answer": cur_num + ord_num * times
         }
     ]
-    times_only_seq = generate_number_sequence(cur_num, 1, times)  # sequence with ordinal number = 1
+    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}",
@@ -57,11 +57,70 @@ def generate_question_data(level: Literal["easy", "medium", "hard"] = "easy"):
             "answer": cur_num + times
         }
     ]
+    print(f"Let's practice counting   {'... '.join([str(num) for num in range(8, 11)])}... After 10, what is the next number you will count?")
+    # Let's practice counting   8...  9... 10...   After 10, what is the next number you will count?
+    8, 9, 10
     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_question(start, step=None, seq=None, question_num=1):
+    """returns question by provided number with filled parameters
+    
+    parameters
+    ----------
+    :num: question number
+    :start: current number
+    :step: interval between current and next numbers
+    :seq: sequence of numbers"""
+    convert_sequence_to_string(start, step, )
+    questions = {
+        1: f"Let's practice counting   {seq}   After {start}, what is the next number you will count?",
+        2: f"What number comes {step} number after {start}?",
+        3: f"We're counting by {step}s.  What number is 1 after {start}?",
+        4: f"What is {step} number up from {start}?",
+        5: f"If we could up {step} from {start}, what number is next?",
+    }
+    if step > 1:
+        questions.update({
+            6: f"Now we're counting up by {step} 😄 From {start - 2 * step}, I count {step} numbers to get to {start - step}.  Then from {start - step} I count {step} numbers to get to {start}.  What is {step} numbers after {start}?",
+            7: f"What is {step} numbers after {start}?  Let's count one number ... {start + 1}... now what is the next number?"
+        })
+    return questions[question_num]
+
+
+def generate_start_by_score(score):
+    """generate number by scrore
+    
+    to calculate the starting point """
+    if score <= 0.3:
+        range_size = 27 - 1                              # total range size
+        range_offset = score                             # offset from the lower end of the range
+        proportion = range_offset / 0.3                  # proportion of the total range
+        number_range = int(proportion * range_size)      # size of the range based on the argument
+        return random.randint(1, 1 + number_range)
+    elif score >= 0.6:
+        range_size = 495 - 97                            # total range size
+        range_offset = score - 0.6                       # offset from the lower end of the range
+        proportion = range_offset / (1 - 0.6)            # proportion of the total range
+        number_range = int(proportion * range_size)      # size of the range based on the argument
+        return random.randint(98, 98 + number_range)
+    else:
+        range_size = 97 - 28                             # total range size
+        range_offset = score - 0.3                       # offset from the lower end of the range
+        proportion = range_offset / (0.6 - 0.3)          # proportion of the total range
+        number_range = int(proportion * range_size)      # size of the range based on the argument
+        return random.randint(28, 28 + number_range)
+
+
+def convert_sequence_to_string(start, step):
+    func_vars = {}
+    exec("seq = ', '.join([str(num) for num in range({start}, {stop}, {step})][::-1])".format(start=start, stop=start-3*step, step=step * (-1)), func_vars)
+    return func_vars['seq']
+
+
+
 def generate_numbers_by_level(level: Literal["easy", "medium", "hard"] = "easy"):
     """generate current number, ordinal number and times parameter
     
@@ -72,7 +131,7 @@ def generate_numbers_by_level(level: Literal["easy", "medium", "hard"] = "easy")
     :param times: the number of times we count up by ordinal number"""
 
     if level == "easy":
-        cur_num = random.randint(1, 8)
+        cur_num = random.randint(5, 15)
         ord_num = random.randint(1, 2)
         times = 1
     elif level == "medium":