Merge branch 'vlad' into 'feature-wormhole'

Data-driven quiz

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

app.py

@@ -1,12 +1,10 @@
 """FastAPI endpoint
 To run locally use 'uvicorn app:app --host localhost --port 7860'
+or
+`python -m uvicorn app:app --reload --host localhost --port 7860`
 """
 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
-
+import mathactive.microlessons.num_one as num_one_quiz
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse
 from fastapi.staticfiles import StaticFiles
@@ -146,168 +144,186 @@ 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("/num_one")
+async def num_one(request: Request):
+    """
+    Input: 
+    {
+        "user_id": 1,
+        "message_text": 5,
+    }
+    Output:
+    {
+        'messages': 
+            ["Let's", 'practice', 'counting', '', '', '46...', '47...', '48...', '49', '', '', 'After', '49,', 'what', 'is', 'the', 'next', 'number', 'you', 'will', 'count?\n46,', '47,', '48,', '49'], 
+        'input_prompt': '50', 
+        'state': 'question'
+    }
+    """
+    data_dict = await request.json()
+    message_data = ast.literal_eval(data_dict.get('message_data', '').get('message_body', ''))
+    user_id = message_data['user_id']
+    message_text = message_data['message_text']
+    return num_one_quiz.process_user_message(user_id, message_text)
     
 
-@app.post("/question")
+@app.post("/start")
 async def ask_math_question(request: Request):
-    """Generate a question and return it as response along with question data
+    """Generate a question data
     
     Input
-    request.body: json - amount of correct and incorrect answers in the account
     {
-        'number_correct': 0,
-        'number_incorrect': 0,
-        'level': 'easy'
+        'difficulty': 0.1,
+        'do_increase': True | False
     }
 
     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
+        'difficulty': 0.2,
+        'question_numbers': [3, 1, 4]
     }
     """
     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']
+    difficulty = message_data['difficulty']
+    do_increase = message_data['do_increase']
 
-    return JSONResponse(generators.start_interactive_math(right_answers, wrong_answers, level))
+    return JSONResponse(generators.start_interactive_math(difficulty, do_increase))
 
 
 @app.post("/hint")
 async def get_hint(request: Request):
-    """Generate a hint and return it as response along with hint data
+    """Generate a 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
+        'start': 5,
+        'step': 1,
+        'difficulty': 0.1
     }
 
     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
+        'text': 'What number is greater than 4 and less than 6?',
+        'difficulty': 0.1,
+        'question_numbers': [5, 1, 6]
     }
     """
     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']
+    start = message_data['start']
+    step = message_data['step']
+    difficulty = message_data['difficulty']
 
-    return JSONResponse(hints.generate_hint(question_numbers, right_answer, number_correct, number_incorrect, level, hints_used))
+    return JSONResponse(hints.generate_hint(start, step, difficulty))
 
 
-@app.post("/generate_question")
-async def generate_question(request: Request):
-    """Generate a bare question and return it as response
+@app.post("/question")
+async def ask_math_question(request: Request):
+    """Generate a question data
     
     Input
-    request.body: json - level
     {
-        'level': 'easy'
+        'start': 5,
+        'step': 1,
+        'question_num': 1  # optional
     }
 
     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 ..."
+        'question': 'What is 1+2?',
+        'start': 5,
+        'step': 1,
+        'answer': 6
     }
     """
     data_dict = await request.json()
     message_data = ast.literal_eval(data_dict.get('message_data', '').get('message_body', ''))
-    level = message_data['level']
+    start = message_data['start']
+    step = message_data['step']
+    arg_tuple = (start, step)
+    try:
+        question_num = message_data['question_num']
+        arg_tuple += (question_num,)
+    except KeyError:
+        pass
 
-    return JSONResponse(questions.generate_question_data(level)['question'])
+    return JSONResponse(questions.generate_question_data(*arg_tuple))
 
 
-@app.post("/numbers_by_level")
-async def get_numbers_by_level(request: Request):
-    """Generate three numbers and return them as response
+@app.post("/difficulty")
+async def get_hint(request: Request):
+    """Generate a number matching difficulty
     
     Input
-    request.body: json - level
     {
-        'level': 'easy'
+        'difficulty': 0.01,
+        'do_increase': True
     }
 
-    Output
-    context: dict - three generated numbers for specified level
-    {
-        "current_number": 10,
-        "ordinal_number": 2,
-        "times": 1
-    }
+    Output - value from 0.01 to 0.99 inclusively:
+    0.09
     """
     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))
+    difficulty = message_data['difficulty']
+    do_increase = message_data['do_increase']
 
+    return JSONResponse(utils.get_next_difficulty(difficulty, do_increase))
 
-@app.post("/number_sequence")
-async def get_number_sequence(request: Request):
-    """Generate a number sequence
+
+@app.post("/start_step")
+async def get_hint(request: Request):
+    """Generate a start and step values
     
     Input
-    request.body: json - level
     {
-        "current_number": 10,
-        "ordinal_number": 2,
-        "times": 1
+        'difficulty': 0.01,
+        'path_to_csv_file': 'scripts/quiz/data.csv'  # optional
     }
 
-    Output
-    one of following strings with (numbers differ):
-    ... 1 2 3
-    1 2 3 ...
+    Output - tuple (start, step):
+    (5, 1)
     """
     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))
+    difficulty = message_data['difficulty']
+    arg_tuple = (difficulty,)
+    try:
+        path_to_csv_file = message_data['path_to_csv_file']
+        arg_tuple += (path_to_csv_file,)
+    except KeyError:
+        pass
+
+    return JSONResponse(utils.get_next_difficulty(*arg_tuple))
 
 
-@app.post("/level")
-async def get_next_level(request: Request):
-    """Depending on current level and desire to level up/down return next level
+@app.post("/sequence")
+async def generate_question(request: Request):
+    """Generate a sequence from start, step and optional separator parameter
     
     Input
-    request.body: json - level
     {
-        "current_level": "easy",
-        "level_up": True
+        'start': 5,
+        'step': 1,
+        'sep': ', '  # optional
     }
 
     Output
-    Literal - "easy", "medium" or "hard"
+    5, 6, 7
     """
     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))
+    start = message_data['start']
+    step = message_data['step']
+    arg_tuple = (start, step)
+    try:
+        sep = message_data['sep']
+        arg_tuple += (sep,)
+    except KeyError:
+        pass
+
+    return JSONResponse(utils.convert_sequence_to_string(*arg_tuple))

mathtext_fastapi/conversation_manager.py

@@ -14,8 +14,8 @@ 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
+from mathactive.generators import start_interactive_math
+from mathactive.hints import generate_hint
 
 load_dotenv()
 

mathtext_fastapi/v2_conversation_manager.py

@@ -16,8 +16,8 @@ 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
+from mathactive.generators import start_interactive_math
+from mathactive.hints import generate_hint
 
 load_dotenv()
 

pyproject.toml

@@ -20,14 +20,17 @@ classifiers = [
 
 
 [tool.poetry.dependencies]
+mathactive = {git = "git@gitlab.com:tangibleai/community/mathactive.git", rev = "vlad"}
 mathtext = {git = "https://gitlab.com/tangibleai/community/mathtext", rev = "main"}
-fastapi = "0.74.*"
+fastapi = "^0.90.0"
 pydantic = "*"
-python = "^3.8,<3.10"
-requests = "2.27.*"
+python = "^3.8"
+requests = "2.27.*" 
 sentencepiece = "0.1.*"
 supabase = "*"
 uvicorn = "0.17.*"
+pandas = "^1.5.3"
+scipy = "^1.10.1"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^7.2"

requirements.txt

@@ -2,15 +2,24 @@ dill
 en-core-web-sm @ https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.4.1/en_core_web_sm-3.4.1-py3-none-any.whl
 fuzzywuzzy
 jsonpickle
-mathtext @ git+https://gitlab.com/tangibleai/community/mathtext@main
-fastapi==0.74.*
+mathtext
+mathactive
+fastapi
+pydantic
+requests
+sentencepiece
 openpyxl
-pydantic==1.10.*
 python-Levenshtein
-requests==2.27.*
-sentencepiece==0.1.*
 sentence-transformers
 supabase
 transitions
-uvicorn==0.17.*
+uvicorn
+pandas
+scipy
 
+# Deprecated
+# mathtext @ git+https://gitlab.com/tangibleai/community/mathtext@main
+# fastapi==0.74.*
+# pydantic==1.10.*
+# requests==2.27.*
+# sentencepiece==0.1.*

scripts/make_request.py

@@ -84,34 +84,35 @@ run_simulated_request('v2/manager', '5')
 # run_simulated_request('manager', '')
 # run_simulated_request('manager', 'add')
 # run_simulated_request('manager', 'subtract')
-# run_simulated_request("question", {
-#     'number_correct': 0,
-#     'number_incorrect': 0,
-#     'level': 'easy'
+
+# run_simulated_request("start", {
+#     'difficulty': 0.04,
+#     'do_increase': True
 # })
 # 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'
+#     'start': 5,
+#     'step': 1,
+#     'difficulty': 0.56  # optional
 # })
-# run_simulated_request("numbers_by_level", {
-#     'level': 'medium'
+# run_simulated_request("question", {
+#     'start': 2,
+#     'step': 1,
+#     'question_num': 2  # optional
 # })
-# run_simulated_request("number_sequence", {
-#     "current_number": 10,
-#     "ordinal_number": 2,
-#     "times": 1
+# run_simulated_request("difficulty", {
+#     'difficulty': 0.01,
+#     'do_increase': False  # True | False
 # })
-# run_simulated_request("level", {
-#     "current_level": "hard",
-#     "level_up": False
+run_simulated_request("num_one", {
+    "user_id": "1",
+    "message_text": "61",
+})
+# run_simulated_request("sequence", {
+#     'start': 2,
+#     'step': 1,
+#     'sep': '... '
 # })
+
 # run_simulated_request('manager', 'exit')
 
 

scripts/quiz/data.csv

@@ -0,0 +1,56 @@
+difficulty,start
+0.01,1
+0.02,0
+0.05,5
+0.07,10
+0.08,14
+0.1,20
+0.11,22
+0.13,27
+0.14,28
+0.16,30
+0.17,32
+0.18,34
+0.2,37
+0.21,39
+0.23,42
+0.25,43
+0.27,46
+0.3,50
+0.34,57
+0.35,64
+0.37,78
+0.39,89
+0.41,100
+0.44,112
+0.45,130
+0.48,147
+0.5,164
+0.52,180
+0.55,195
+0.58,209
+0.6,223
+0.61,236
+0.63,248
+0.64,259
+0.65,271
+0.67,284
+0.69,296
+0.7,308
+0.72,321
+0.73,333
+0.75,346
+0.78,359
+0.8,370
+0.81,385
+0.83,399
+0.84,408
+0.87,420
+0.88,435
+0.89,447
+0.9,458
+0.93,469
+0.94,483
+0.96,494
+0.97,500
+0.99,513

scripts/quiz/generators.py

@@ -1,33 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,116 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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"