Merge main into staging

CHANGELOG.md

@@ -0,0 +1,18 @@
+
+## [0.0.12](https://gitlab.com/tangibleai/community/mathtext-fastapi/-/tags/0.0.12)
+
+Improve NLU capabilities
+- Improved handling for integers (1), floats (1.0), and text numbers (one)
+- Integrates fuzzy keyword matching for 'easier', 'exit', 'harder', 'hint', 'next', 'stop'
+- Integrates intent classification for user messages
+- Improved conversation management system
+- Created a data-driven quiz prototype
+
+
+## [0.0.0](https://gitlab.com/tangibleai/community/mathtext-fastapi/-/tags/0.0.0)
+
+Initial release
+- Basic text to integer NLU evaluation of user responses
+- Basic sentiment analysis evaluation of user responses
+- Prototype conversation manager using finite state machines
+- Support for logging of user message data

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
@@ -11,8 +15,10 @@ from mathtext.sentiment import sentiment
 from mathtext.text2int import text2int
 from pydantic import BaseModel
 
-from mathtext_fastapi.nlu import prepare_message_data_for_logging
-from mathtext_fastapi.conversation_manager import *
+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.nlu import run_intent_classification
 
 app = FastAPI()
 
@@ -52,67 +58,222 @@ def text2int_ep(content: Text = None):
 
 @app.post("/manager")
 async def programmatic_message_manager(request: Request):
-    print(request)
+    """
+    Calls conversation management function to determine the next state
 
-    data_dict = await request.json()
-    message_data = data_dict.get('message_data', '')
+    Input
+    request.body: dict - message data for the most recent user response
+    {
+        "author_id": "+47897891",
+        "contact_uuid": "j43hk26-2hjl-43jk-hnk2-k4ljl46j0ds09",
+        "author_type": "OWNER",
+        "message_body": "a test message",
+        "message_direction": "inbound",
+        "message_id": "ABJAK64jlk3-agjkl2QHFAFH",
+        "message_inserted_at": "2022-07-05T04:00:34.03352Z",
+        "message_updated_at": "2023-02-14T03:54:19.342950Z",
+    }
 
-    context = generate_message(message_data)
+    Output
+    context: dict - the information for the current state
+    {
+        "user": "47897891",
+        "state": "welcome-message-state",
+        "bot_message": "Welcome to Rori!",
+        "user_message": "",
+        "type": "ask"
+    }
+    """
+    data_dict = await request.json()
+    context = manage_conversation_response(data_dict)
     return JSONResponse(context)
 
+
+@app.post("/intent-classification")
+def intent_classification_ep(content: Text = None):
+    ml_response = run_intent_classification(content.content)
+    content = {"message": ml_response}
+    return JSONResponse(content=content)
+
+
 @app.post("/nlu")
 async def evaluate_user_message_with_nlu_api(request: Request):
-    """ Calls NLU APIs on the most recent user message from Turn.io message data and logs the message data
+    """ Calls nlu evaluation and returns the nlu_response
 
     Input
-    - request.body: a json object of message data for the most recent user response
+    - request.body: json - message data for the most recent user response
 
     Output
-    - int_data_dict or sent_data_dict: A dictionary telling the type of NLU run and the resulting data
-      {'type':'integer', 'data': '8'}
-      {'type':'sentiment', 'data': 'negative'}
+    - int_data_dict or sent_data_dict: dict - the type of NLU run and result
+      {'type':'integer', 'data': '8', 'confidence': 0}
+      {'type':'sentiment', 'data': 'negative', 'confidence': 0.99}
     """
-
     data_dict = await request.json()
     message_data = data_dict.get('message_data', '')
-    message_text = message_data['message']['text']['body']
-
-    # Handles if a student answer is already an integer or a float (ie., 8)
-    if type(message_text) == int or type(message_text) == float:
-        nlu_response = {'type': 'integer', 'data': message_text, 'confidence': ''}
-        prepare_message_data_for_logging(message_data, nlu_response, message_data)
-        return JSONResponse(content=nlu_response)
-
-    # Removes whitespace and converts str to arr to handle multiple numbers
-    message_text_arr = re.split(", |,| ", message_text.strip())
-
-    # Handle if a student answer is a string of numbers (ie., "8,9, 10")
-    if all(ele.isdigit() for ele in message_text_arr):
-        nlu_response = {'type': 'integer', 'data': ','.join(message_text_arr), 'confidence': ''}
-        prepare_message_data_for_logging(message_data, nlu_response, message_data)
-        return JSONResponse(content=nlu_response)
-
-    student_response_arr = []
-
-    for student_response in message_text_arr:
-        # Checks the student answer and returns an integer
-
-        int_api_resp = text2int(student_response.lower())
-        student_response_arr.append(int_api_resp)
-
-    # '32202' is text2int's error code for non-integer student answers (ie., "I don't know")
-    # If any part of the list is 32202, sentiment analysis will run
-    if 32202 in student_response_arr:
-        sentiment_api_resp = sentiment(message_text)
-        # [{'label': 'POSITIVE', 'score': 0.991188645362854}]
-        sent_data_dict = {'type': 'sentiment', 'data': sentiment_api_resp[0]['label']}
-        nlu_response = {'type': 'sentiment', 'data': sentiment_api_resp[0]['label'], 'confidence': sentiment_api_resp[0]['score']}
-    else:
-        if len(student_response_arr) > 1:
-            nlu_response = {'type': 'integer', 'data': ','.join(str(num) for num in student_response_arr), 'confidence': ''}
-        else:
-            nlu_response = {'type': 'integer', 'data': student_response_arr[0], 'confidence': ''}
-
-    # Uncomment to enable logging to Supabase
-    prepare_message_data_for_logging(message_data, nlu_response, 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))

docs/transitions_math_quiz_example.ipynb

@@ -0,0 +1,368 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "d3da0422",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import random\n",
+    "\n",
+    "from transitions import State, Machine"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "07cfb740",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class MathQuizFSM(object):\n",
+    "    states = [\n",
+    "        'quiz_start', \n",
+    "        'quiz_question', \n",
+    "        'quiz_end'\n",
+    "    ]\n",
+    "\n",
+    "    transitions = [\n",
+    "        ['ask_second_question', 'quiz_start', 'quiz_question'],\n",
+    "        ['ask_next_question', 'quiz_question', 'quiz_question'],\n",
+    "        ['exit', 'quiz_start', 'quiz_end'],\n",
+    "        ['exit', 'quiz_question', 'quiz_end'],\n",
+    "    ]\n",
+    "    \n",
+    "    \n",
+    "    def __init__(self):\n",
+    "        # Instantiate the FSM\n",
+    "        self.machine = Machine(model=self, states=MathQuizFSM.states, transitions=MathQuizFSM.transitions,initial='quiz_start')\n",
+    "\n",
+    "        # Instantiate variables necessary for tracking activity\n",
+    "        self.question_nums = [2, 3]\n",
+    "        self.correct_answer = 5\n",
+    "        self.student_answer = 0\n",
+    "        self.is_correct_answer = False\n",
+    "        self.response_text = \"What is 2 + 3?\"\n",
+    "\n",
+    "        # Define transitions\n",
+    "#         self.machine.add_transition('ask_second_question', 'quiz_start', 'quiz_question')\n",
+    "#         self.machine.add_transition('ask_next_question', 'quiz_question', 'quiz_question')\n",
+    "#         self.machine.add_transition('exit', 'quiz_start', 'quiz_end')\n",
+    "#         self.machine.add_transition('exit', 'quiz_question', 'quiz_end')\n",
+    "\n",
+    "        # Define functions to run on transitions\n",
+    "        self.machine.on_enter_quiz_question('generate_math_problem')\n",
+    "        self.machine.on_exit_quiz_question('validate_answer')\n",
+    "\n",
+    "    def validate_answer(self):\n",
+    "        if self.student_answer == 'exit':\n",
+    "            self.machine.set_state('quiz_end')\n",
+    "            return [\"Come back any time!\"]\n",
+    "        elif self.correct_answer == self.student_answer:\n",
+    "            self.machine.set_state('quiz_question')\n",
+    "            self.generate_math_problem()\n",
+    "            return ['Great job!', self.response_text]\n",
+    "        else:\n",
+    "            return [\"That's not quite right.  Try again.\",self.response_text]\n",
+    "    \n",
+    "    def generate_math_problem(self):\n",
+    "        self.question_nums = random.sample(range(1,100),2)\n",
+    "        self.response_text = f\"What is {self.question_nums[0]} + {self.question_nums[1]}\"\n",
+    "        self.correct_answer = self.question_nums[0] + self.question_nums[1]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "ebdf92ae",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test = MathQuizFSM()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "92024fcc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'quiz_start'"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Set as `quiz_start` due to the initial setting in Line 10\n",
+    "test.state"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "fd1ba433",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['quiz_start', 'quiz_question', 'quiz_end']"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Available states for the quiz module\n",
+    "test.states"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "bb190089",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "What is 2 + 3?\n",
+      "Initial Correct Answer: 5\n",
+      "Initial Student Answer: 0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# When the FSM is created, it comes with a default question/answer pair loaded\n",
+    "print(test.response_text)\n",
+    "print(f\"Initial Correct Answer: {test.correct_answer}\")\n",
+    "print(f\"Initial Student Answer: {test.student_answer}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "3de7c4e0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[\"That's not quite right.  Try again.\", 'What is 2 + 3?']"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Calling the validation fails because the answer is wrong.  The state remains the same.\n",
+    "test.validate_answer()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "4935b470",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# The student tries again\n",
+    "test.student_answer = 5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "03722434",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['Great job!', 'What is 58 + 89']"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Since the student answered correctly, MathQuizFSM generates a new math problem\n",
+    "test.validate_answer()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "d98a4d5b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'quiz_question'"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# It will repeatedly re-activate the same state\n",
+    "test.state"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "76c8a5b2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[\"That's not quite right.  Try again.\", 'What is 58 + 89']"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "test.validate_answer()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "ec0a7e6a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test.student_answer = 128"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "a093ff27",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[\"That's not quite right.  Try again.\", 'What is 58 + 89']"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "test.validate_answer()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "f992d34d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test.student_answer = 'exit'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "28800a2b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['Come back any time!']"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "test.validate_answer()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "360ef774",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'quiz_end'"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "test.state"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3f0392ae",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.7"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "32cf04bfac80a5e1e74e86fca42ae7f3079b15fa61041a60732bc19e88699268"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

mathtext_fastapi/conversation_manager.py

@@ -1,80 +1,437 @@
+import base64
+import dill
 import os
 import json
+import jsonpickle
+import pickle
+import random
 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()
 
-# os.environ.get('SUPABASE_URL')
+SUPA = create_client(
+    os.environ.get('SUPABASE_URL'),
+    os.environ.get('SUPABASE_KEY')
+)
 
-def parse_data(data):
-    data_bytes = requests.body
-    data_decoded = data_bytes.decode()
-    data_json = json.loads(data_decoded)
-    return data_json
 
-def generate_message(data_json):
-    """ pending
+def create_text_message(message_text, whatsapp_id):
+    """ Fills a template with input values to send a text message to Whatsapp
 
-    REQUIREMENTS
-    - implement logging of message
-    - have a very simple activity which allows for different dialogue
-      * add - Add the numbers, 1+1, 2+2
-      * subtract - Subtract the numbers, 1-1, 2-2
-      * menu - Choose one
-    - send message data to retrieve dialogue state
-    - retrieve response and build message object
-    - send message object
-
-    Need to make util functions that apply to both /nlu and /conversation_manager
+    Inputs
+    - message_text: str - the content that the message should display
+    - whatsapp_id: str - the message recipient's phone number
+
+    Outputs
+    - message_data: dict - a preformatted template filled with inputs
     """
+    message_data = {
+        "preview_url": False,
+        "recipient_type": "individual",
+        "to": whatsapp_id,
+        "type": "text",
+        "text": {
+            "body": message_text
+        }
+    }
+    return message_data
 
-    # Intent Labelling #######################
-    # Call to Wit.ai for intent recognition
 
-    # message = data_json['messages'][0]['text']['body']
-    # formatted_message = message.replace(' ', '%20')
+def create_button_objects(button_options):
+    """ Creates a list of button objects using the input values
+    Input
+    - button_options: list - a list of text to be displayed in buttons
+
+    Output
+    - button_arr: list - preformatted button objects filled with the inputs
+
+    NOTE: Not fully implemented and tested
+    """
+    button_arr = []
+    for option in button_options:
+        button_choice = {
+            "type": "reply",
+            "reply": {
+                "id": "inquiry-yes",
+                "title": option['text']
+            }
+        }
+        button_arr.append(button_choice)
+    return button_arr
+
+
+def create_interactive_message(message_text, button_options, whatsapp_id):
+    """ Fills a template to create a button message for Whatsapp
+
+    * NOTE: Not fully implemented and tested
+    * NOTE/TODO: It is possible to create other kinds of messages
+                 with the 'interactive message' template
+    * Documentation:
+      https://whatsapp.turn.io/docs/api/messages#interactive-messages
+
+    Inputs
+    - message_text: str - the content that the message should display
+    - button_options: list - what each button option should display
+    - whatsapp_id: str - the message recipient's phone number
+    """
+    button_arr = create_button_objects(button_options)
 
-    # Send a custom message with buttons
-    headers = {
-        'Authorization': f"Bearer {os.environ.get('TURN_AUTHENTICATION_TOKEN')}",
-        'Content-Type': 'application/json'
-    }
     data = {
-        "to": data_json['message']['_vnd']['v1']['chat']['owner'],
-        # "to": "alan",
+        "to": whatsapp_id,
         "type": "interactive",
         "interactive": {
             "type": "button",
             # "header": { },
             "body": {
-                "text": "Did I answer your question?"
+                "text": message_text
             },
             # "footer": { },
             "action": {
-                "buttons": [
-                    {
-                        "type": "reply",
-                        "reply": {
-                            "id": "inquiry-yes",
-                            "title": "Yes" 
-                        }
-                    },
-                    {
-                        "type": "reply",
-                        "reply": {
-                            "id": "inquiry-no",
-                            "title": "No" 
-                        }
-                    }
-                ]
+                "buttons": button_arr
             }
         }
     }
+    return data
+
+
+def pickle_and_encode_state_machine(state_machine):
+    dump = pickle.dumps(state_machine)
+    dump_encoded = base64.b64encode(dump).decode('utf-8')
+    return dump_encoded
+
+
+def manage_math_quiz_fsm(user_message, contact_uuid, type):
+    fsm_check = SUPA.table('state_machines').select("*").eq(
+        "contact_uuid",
+        contact_uuid
+    ).execute()
+
+    # This doesn't allow for when one FSM is present and the other is empty
+    """
+    1
+    data=[] count=None
+    
+    2
+    data=[{'id': 29, 'contact_uuid': 'j43hk26-2hjl-43jk-hnk2-k4ljl46j0ds09', 'addition3': None, 'subtraction': None, 'addition': 
+
+    - but problem is there is no subtraction , but it's assuming there's a subtration
+
+
+    Cases
+    - make a completely new record
+    - update an existing record with an existing FSM
+    - update an existing record without an existing FSM
+    """
+
+
+    # Make a completely new entry
+    if fsm_check.data == []:
+        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,
+            f'{type}': dump_encoded
+        }).execute()
+    # Update an existing record with a new state machine
+    elif not fsm_check.data[0][type]:
+        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').update({
+            f'{type}': dump_encoded
+        }).eq(
+            "contact_uuid", contact_uuid
+        ).execute()      
+    # Update an existing record with an existing state machine
+    elif fsm_check.data[0][type]:
+        undump_encoded = base64.b64decode(
+            fsm_check.data[0][type].encode('utf-8')
+        )
+        math_quiz_state_machine = pickle.loads(undump_encoded)
+
+        math_quiz_state_machine.student_answer = user_message
+        math_quiz_state_machine.correct_answer = str(math_quiz_state_machine.correct_answer)
+        messages = math_quiz_state_machine.validate_answer()
+        dump_encoded = pickle_and_encode_state_machine(math_quiz_state_machine)          
+        SUPA.table('state_machines').update({
+            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
+
+    Input
+    - context_data: dict - data about the conversation's current state
+    - user_message: str - the message the user sent in response to the state
+
+    Output
+    - message_package: dict - a series of messages and prompt to send
+    """
+    if context_data['user_message'] == '' and \
+       context_data['state'] == 'start-conversation':
+        message_package = {
+            'messages': [],
+            'input_prompt': "Welcome to our math practice.  What would you like to try?  Type add or subtract.",
+            'state': "welcome-sequence"
+        }
+    elif context_data['state'] == 'addition-question-sequence' or \
+        user_message == 'add':
+
+        # Used in FSM
+        # messages = manage_math_quiz_fsm(user_message, contact_uuid)
+
+        # message_package, context_result = use_quiz_module_approach(user_message, context_data)
+        messages = manage_math_quiz_fsm(user_message, contact_uuid, 'addition')
+
+        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
+        }
+
+        # Used in quiz w/ hints
+        # 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()
+
+        message_package = {
+            'messages': messages,
+            'input_prompt': input_prompt,
+            'state': state_label
+        }
+
+        # 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': [
+                "Great, thanks for practicing math today.  Come back any time."
+            ],
+            'input_prompt': "",
+            'state': "exit"
+        }
+    else:
+        message_package = {
+            'messages': [
+                "Hmmm...sorry friend.  I'm not really sure what to do."
+            ],
+            '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
+
+    Input
+    - data_json: dict - message data from Turn.io/Whatsapp
+
+    Output
+    - context: dict - a record of the state at a given point a conversation
+
+    TODOs
+    - implement logging of message
+    - test interactive messages
+    - review context object and re-work to use a standardized format
+    - review ways for more robust error handling
+    - need to make util functions that apply to both /nlu and /conversation_manager
+    """
+    message_data = data_json.get('message_data', '')
+    context_data = data_json.get('context_data', '')
+
+    whatsapp_id = message_data['author_id']
+    user_message = message_data['message_body']
+    contact_uuid = message_data['contact_uuid']
+
+    # TODO: Need to incorporate nlu_response into wormhole by checking answers against database (spreadsheet?)
+    nlu_response = evaluate_message_with_nlu(message_data)
+
+    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
+        )
+
+    headers = {
+        'Authorization': f"Bearer {os.environ.get('TURN_AUTHENTICATION_TOKEN')}",
+        'Content-Type': 'application/json'
+    }
+
+    # Send all messages for the current state before a user input prompt (text/button input request)
+    for message in message_package['messages']:
+        data = create_text_message(message, whatsapp_id)
+
+        print("data")
+        print(data)
 
-    # r = requests.post(f'https://whatsapp.turn.io/v1/messages', data=json.dumps(data), headers=headers)
+        r = requests.post(
+            f'https://whatsapp.turn.io/v1/messages',
+            data=json.dumps(data),
+            headers=headers
+        )
 
-    context = {"content":{"user":"Alan", "state": "received-and-replied-state"}}
+    # Update the context object with the new state of the conversation
+    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
+
+    # data = {
+    #     "to": whatsapp_id,
+    #     "type": "interactive",
+    #     "interactive": {
+    #         "type": "button",
+    #         # "header": { },
+    #         "body": {
+    #             "text": "Did I answer your question?"
+    #         },
+    #         # "footer": { },
+    #         "action": {
+    #             "buttons": [
+    #                 {
+    #                     "type": "reply",
+    #                     "reply": {
+    #                         "id": "inquiry-yes",
+    #                         "title": "Yes"
+    #                     }
+    #                 },
+    #                 {
+    #                     "type": "reply",
+    #                     "reply": {
+    #                         "id": "inquiry-no",
+    #                         "title": "No"
+    #                     }
+    #                 }
+    #             ]
+    #         }
+    #     }
+    # }

mathtext_fastapi/data/intent_classification_model.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ea4954368c3b95673167ce347f2962b5508c4af295b6af58b6c11b3c1075b42e
+size 127903

mathtext_fastapi/data/labeled_data.csv

@@ -0,0 +1,144 @@
+Utterance,Label
+skip this,skip
+this is stupid,skip
+this is stupid,harder
+this is stupid,feedback
+I'm done,exit
+quit,exit
+I don't know,hint
+help,hint
+can I do something else?,main menu
+what's going on,rapport 
+what's going on,main menu
+tell me a joke,rapport
+tell me a joke,main menu
+Sorry I don't understand,do not know
+Ten thousand,number
+1.234,number
+"10,000",number
+"123, 456",numbers
+"11, 12, 13",numbers
+"100, 200, 300",numbers
+"100, 200",numbers
+Stop for a minute,wait
+Bye bye,exit
+Good night,exit
+Am done,exit
+Yes,yes
+Help,help
+Idiot,harder
+Stop,exit
+I don't get it,hint
+Math,main menu
+Math,math topic
+Tomorrow let do math,wait
+Later,wait
+Pls i will continue pls,skip
+Rori tell me now,help
+harder,skip
+Stop for now i wont  to go to  School,exit
+Next,next
+Okay,okay
+Great,affirmation
+Give me for example,example
+No I want to learn algebraic expressions,algebra
+Hi rori,greeting
+*help*,help
+*Next*,next
+Okay nice,okay
+I don't know it,hint
+Nex,next
+I need a help,hint
+Please can I ask your any math questions?,faq
+The answer is 1,answer
+The answer is 1,number
+But 0.8 is also same as . 8 so I was actually right,I'm right
+What is the number system?,faq
+Ok thanks,thanks
+I'm going to school now,exit
+Let's move to another topic,main menu
+"Ummanni saba
+Kebena bara kana galmi keenya inni guddaan bilisummaa qofa #Gabrummaan_ammaan booda_gaha namni hundi bakka jiru irraa kutatee ka,ee jira obboleewwan goototni keenya jiran haqa Kebenaaf jechaa jiru Guraandhala 29 booda walabummaa keenya labsina Dhugaa qabna Ni injifanna *** . Naannoo giddu galeessa Itoophiyaatti #Kebenaan aanaa addaati Kun murtoo ummata Kebenaa hundaati",spam
+Yes it,yes
+U type fast,too fast
+I mean your typing is fast,too fast
+Why do u type so fast,too fast
+Ur  typing is fast,too fast
+Can we go to a real work,harder
+I know all this,harder
+Answer this,preamble
+Am tired,exit
+This is not what I asked for,main menu
+Bye,exit
+😱😱😂😂😂😡😰😰😰😒,spam
+Gbxbxbcbcbbcbchcbchc,spam
+I want to solve math,math topic
+Pleas let start with the fraction,fractions topic
+Okey,okay
+i need substraction,subtraction topic
+Can you please stop with me,exit
+Another one,next
+Harder or easy,main menu
+Hard or easier,main menu
+Jump topic,menu
+Got it,okay
+I didn't understand,don't know
+Don't understand,don't know
+Excuse me pls,hint
+Let stop for today,exit
+Help and stop asking me stupid questions,
+Ykay,okay
+Not interested in solving this,menu
+Stpo,exit
+Hiiiiiii,greeting
+Hi rori,greeting
+I've done this things before,harder
+Which number my phone number,
+Unit,main menu
+No ide,don't know
+No ide,hint
+No idea,don't know
+🙈🤩😇🙏,spam
+Thank u,thanks
+Do you know programming,faq
+Delete my number,unsubscribe
+See u,exit
+Can I go for break ??,wait
+I wanna fuck,profanity
+Enough of this nw,exit
+Can we move to equations,equations
+Do you know you are an idiot,insult
+3 digit number,number
+3 digit number,answer
+Three digit number,confident answer
+Three digit number,number
+Good evening Rori,greeting
+89 Next,answer
+89 Next,number
+3 digit number,answer
+Three digit number,answer
+This is too simple,harder
+Am not a kid,harder
+Hey Miss Roribcan you ask me some question from Secondary 2,greeting
+Hey Miss Roribcan you ask me some question from Secondary 2,faq
+Hey Miss Roribcan you ask me some question from Secondary 2,main menu
+don't know,hint
+don't know,easier
+𝑴𝒂𝒕𝒉,math
+Rori can you help me to gat value,
+I called but u are not picking up,
+0.3 answer,answer
+Sorry rori was101,answer
+Y is it 6,answer
+Y is it 6,number
+0.3 answer,number
+Why 0.5,more explanation
+Why 0.5,number
+6\nNext,Next
+How is the answer is 11,more explanation
+How comes we have 11,more explanation
+Yes 6,answer
+Yes 6,number
+6\nNext,number
+How is the answer is 11,number
+How comes we have 11,number

mathtext_fastapi/data/text2int_results.csv

@@ -1,92 +1,105 @@
 input,output,text2int,score
-notanumber,32202,32202,True
-this is not a number,32202,32202,True
-fourteen,14,14,True
-forteen,14,14,True
-one thousand four hundred ninety two,1492,1492,True
-one thousand ninety two,1092,1092,True
-Fourteen Hundred Ninety-Two,1492,1492,True
-Fourteen Hundred,1400,1400,True
-Ninety nine,99,99,True
-fifteen thousand five hundred-sixty,15560,15560,True
-three hundred fifty,350,350,True
-one nine eight five,1985,1985,True
-nineteen eighty-five,1985,1605,False
-oh one,1,1,True
-six oh 1,601,601,True
-sex,6,6,True
-six,6,6,True
-eight oh,80,8,False
-eighty,80,80,True
-ate,8,1,False
-double eight,88,32202,False
-eight three seven five three O nine,8375309,8375329,False
-eight three seven five three oh nine,8375309,8375309,True
-eight three seven five three zero nine,8375309,8375309,True
-eight three seven five three oh ni-ee-ine,8375309,837530611,False
-two eight,28,16,False
-seven oh eleven,7011,77,False
-seven elevens,77,77,True
-seven eleven,711,77,False
-ninety nine oh five,9905,149,False
-seven 0 seven 0 seven 0 seven,7070707,7070707,True
-123 hundred,123000,223,False
-5 o 5,505,525,False
-15 o 5,1505,22,False
-15-o 5,1505,22,False
-15 o-5,1505,22,False
-911-thousand,911000,911000,True
-twenty-two twenty-two,2222,44,False
-twenty-two twenty-twos,484,44,False
-four eighty four,484,404,False
-four eighties,320,72,False
-four eighties and nine nineties,1130,243,False
-ninety nine hundred and seventy seven,9977,276,False
-seven thousands,7000,7000,True
-2 hundreds,200,200,True
-99 thousands and one,99001,99001,True
-"forty-five thousand, seven hundred and nine",45709,1161,False
-eighty eight hundred eighty,8880,268,False
-a hundred hundred,10000,32202,False
-a hundred thousand,100000,32202,False
-a hundred million,100000000,32202,False
-nineteen ninety nine,1999,1809,False
-forteen twenty seven,1427,307,False
-seventeen-thousand and seventy two,17072,17072,True
-two hundred and nine,209,209,True
-two thousand ten,2010,2010,True
-two thousand and ten,2010,2010,True
-twelve million,12000000,12000000,True
-8 billion,8000000000,8000000000,True
-twenty ten,2010,2010,True
-thirty-two hundred,3200,3200,True
-nine,9,9,True
-forty two,42,42,True
-1 2 three,123,123,True
-fourtean,14,14,True
-one tousand four hundred ninty two,1492,1492,True
-Furteen Hundrd Ninety-Too,1492,1492,True
-forrteen,14,14,True
-sevnteen-thosand and seventy two,17072,17072,True
-ninety nine hundred ad seventy seven,9977,32202,False
-seven thusands,7000,7000,True
-2 hunreds,200,200,True
-99 tousands and one,99001,99001,True
-eighty ate hundred eighty,8880,261,False
-fourteen Hundred,1400,1400,True
-8 Bilion,8000000000,8000000,False
-one million three thousand one,1003001,1003001,True
-four million nine thousand seven,4009007,4009007,True
-two million five hundred thousand,2500000,2001500,False
-two tousand ten,2010,2010,True
-two thousand teen,2010,2007,False
-tvelve milion,12000000,12000000,True
-tventy ten,2010,2010,True
-tirty-twoo hunred,3200,3200,True
-sevn thoosands,7000,7000,True
-five,5,5,True
-ten,10,10,True
-one two three and ten,12310,51,False
-ONE MILLion three hunded and fiv,1000305,1000305,True
-"50,500 and six",50506,50506,True
-one_million_and_five,1000005,1000005,True
+notanumber,32202.0,32202.0,True
+this is not a number,32202.0,32202.0,True
+fourteen,14.0,14.0,True
+forteen,14.0,14.0,True
+one thousand four hundred ninety two,1492.0,1492.0,True
+one thousand ninety two,1092.0,1092.0,True
+Fourteen Hundred Ninety-Two,1492.0,1492.0,True
+Fourteen Hundred,1400.0,1400.0,True
+Ninety nine,99.0,99.0,True
+fifteen thousand five hundred-sixty,15560.0,15560.0,True
+three hundred fifty,350.0,350.0,True
+one nine eight five,1985.0,1985.0,True
+nineteen eighty-five,1985.0,1605.0,False
+oh one,1.0,1.0,True
+six oh 1,601.0,601.0,True
+sex,6.0,6.0,True
+six,6.0,6.0,True
+eight oh,80.0,8.0,False
+eighty,80.0,80.0,True
+ate,8.0,1.0,False
+double eight,88.0,8.0,False
+eight three seven five three O nine,8375309.0,8375329.0,False
+eight three seven five three oh nine,8375309.0,8375309.0,True
+eight three seven five three zero nine,8375309.0,8375309.0,True
+eight three seven five three oh ni-ee-ine,8375309.0,837530619.0,False
+two eight,28.0,16.0,False
+seven oh eleven,7011.0,77.0,False
+seven elevens,77.0,77.0,True
+seven eleven,711.0,77.0,False
+ninety nine oh five,9905.0,149.0,False
+seven 0 seven 0 seven 0 seven,7070707.0,7070707.0,True
+123 hundred,123000.0,223.0,False
+5 o 5,505.0,525.0,False
+15 o 5,1505.0,22.0,False
+15-o 5,1505.0,22.0,False
+15 o-5,1505.0,22.0,False
+911-thousand,911000.0,911000.0,True
+twenty-two twenty-two,2222.0,44.0,False
+twenty-two twenty-twos,484.0,44.0,False
+four eighty four,484.0,404.0,False
+four eighties,320.0,72.0,False
+four eighties and nine nineties,1130.0,243.0,False
+ninety nine hundred and seventy seven,9977.0,276.0,False
+seven thousands,7000.0,7000.0,True
+2 hundreds,200.0,200.0,True
+99 thousands and one,99001.0,99001.0,True
+"forty-five thousand, seven hundred and nine",45709.0,1161.0,False
+eighty eight hundred eighty,8880.0,268.0,False
+a hundred hundred,10000.0,100.0,False
+a hundred thousand,100000.0,100.0,False
+a hundred million,100000000.0,100.0,False
+nineteen ninety nine,1999.0,1809.0,False
+forteen twenty seven,1427.0,307.0,False
+seventeen-thousand and seventy two,17072.0,17072.0,True
+two hundred and nine,209.0,209.0,True
+two thousand ten,2010.0,2010.0,True
+two thousand and ten,2010.0,2010.0,True
+twelve million,12000000.0,12000000.0,True
+8 billion,8000000000.0,8000000000.0,True
+twenty ten,2010.0,2010.0,True
+thirty-two hundred,3200.0,3200.0,True
+nine,9.0,9.0,True
+forty two,42.0,42.0,True
+1 2 three,123.0,123.0,True
+fourtean,14.0,14.0,True
+one tousand four hundred ninty two,1492.0,1492.0,True
+Furteen Hundrd Ninety-Too,1492.0,1492.0,True
+forrteen,14.0,14.0,True
+sevnteen-thosand and seventy two,17072.0,17072.0,True
+ninety nine hundred ad seventy seven,9977.0,90.0,False
+seven thusands,7000.0,7000.0,True
+2 hunreds,200.0,200.0,True
+99 tousands and one,99001.0,99001.0,True
+eighty ate hundred eighty,8880.0,261.0,False
+fourteen Hundred,1400.0,1400.0,True
+8 Bilion,8000000000.0,8000000.0,False
+one million three thousand one,1003001.0,1003001.0,True
+four million nine thousand seven,4009007.0,4009007.0,True
+two million five hundred thousand,2500000.0,2001500.0,False
+two tousand ten,2010.0,2010.0,True
+two thousand teen,2010.0,2007.0,False
+tvelve milion,12000000.0,12000000.0,True
+tventy ten,2010.0,2010.0,True
+tirty-twoo hunred,3200.0,3200.0,True
+sevn thoosands,7000.0,7000.0,True
+five,5.0,5.0,True
+ten,10.0,10.0,True
+one two three and ten,12310.0,51.0,False
+ONE MILLion three hunded and fiv,1000305.0,1000305.0,True
+"50,500 and six",50506.0,50506.0,True
+one_million_and_five,1000005.0,1000005.0,True
+2.0,2.0,2.0,True
+4.5,4.5,4.5,True
+12345.001,12345.001,12345.001,True
+7..0,7.0,7.0,True
+0.06,0.06,0.06,True
+"0,25",0.25,25.0,False
+o.45,0.45,32202.0,False
+0.1.2,0.12,32202.0,False
+0.00009,9e-05,9e-05,True
+0.01.,0.01,0.01,True
+I don't know 8,8.0,8.0,True
+"You're wrong it's not 20, it's 45",45.0,20.0,False
+I don't understand why it's 19,19.0,19.0,True

mathtext_fastapi/intent_classification.py

@@ -0,0 +1,56 @@
+import numpy as np
+import pandas as pd
+
+from pathlib import Path
+from sentence_transformers import SentenceTransformer
+from sklearn.linear_model import LogisticRegression
+from joblib import dump, load
+
+def pickle_model(model):
+    DATA_DIR = Path(__file__).parent.parent / "mathtext_fastapi" / "data" / "intent_classification_model.joblib"
+    dump(model, DATA_DIR)
+
+
+def create_intent_classification_model():
+    encoder = SentenceTransformer('all-MiniLM-L6-v2')
+    # path = list(Path.cwd().glob('*.csv'))
+    DATA_DIR = Path(__file__).parent.parent / "mathtext_fastapi" / "data" / "labeled_data.csv"
+
+    print("DATA_DIR")
+    print(f"{DATA_DIR}")
+
+    with open(f"{DATA_DIR}",'r', newline='', encoding='utf-8') as f:
+        df = pd.read_csv(f)
+    df = df[df.columns[:2]]
+    df = df.dropna()
+    X_explore = np.array([list(encoder.encode(x)) for x in df['Utterance']])
+    X = np.array([list(encoder.encode(x)) for x in df['Utterance']])
+    y = df['Label']
+    model = LogisticRegression(class_weight='balanced')
+    model.fit(X, y, sample_weight=None)
+
+    print("MODEL")
+    print(model)
+
+    pickle_model(model)
+
+
+def retrieve_intent_classification_model():
+    DATA_DIR = Path(__file__).parent.parent / "mathtext_fastapi" / "data" / "intent_classification_model.joblib"
+    model = load(DATA_DIR)
+    return model
+
+
+encoder = SentenceTransformer('all-MiniLM-L6-v2')
+# model = retrieve_intent_classification_model()
+DATA_DIR = Path(__file__).parent.parent / "mathtext_fastapi" / "data" / "intent_classification_model.joblib"
+model = load(DATA_DIR)
+
+
+def predict_message_intent(message):
+    tokenized_utterance = np.array([list(encoder.encode(message))])
+    predicted_label = model.predict(tokenized_utterance)
+    predicted_probabilities = model.predict_proba(tokenized_utterance)
+    confidence_score = predicted_probabilities.max()
+
+    return {"type": "intent", "data": predicted_label[0], "confidence": confidence_score}

mathtext_fastapi/logging.py

@@ -0,0 +1,103 @@
+import os
+from datetime import datetime
+
+from dotenv import load_dotenv
+from supabase import create_client
+
+load_dotenv()
+
+SUPA = create_client(
+    os.environ.get('SUPABASE_URL'),
+    os.environ.get('SUPABASE_KEY')
+)
+
+
+def log_message_data_through_supabase_api(table_name, log_data):
+    return SUPA.table(table_name).insert(log_data).execute()
+
+
+def format_datetime_in_isoformat(dt):
+    return getattr(dt.now(), 'isoformat', lambda x: None)()
+
+
+def get_or_create_supabase_entry(table_name, insert_data, check_variable=None):
+    """ Checks if project or contact exists and adds entry if not found
+
+    Input:
+    - table_name: str- the name of the table in Supabase that is being examined
+    - insert_data: json - the data to insert
+    - check_variable: str/None - the specific field to check for existing match
+
+    Result
+    - logged_data - an object with the Supabase data
+    """
+    if table_name == 'contact':
+        resp = SUPA.table('contact').select("*").eq(
+            "original_contact_id",
+            insert_data['original_contact_id']
+        ).eq(
+            "project",
+            insert_data['project']
+        ).execute()
+    else:
+        resp = SUPA.table(table_name).select("*").eq(
+            check_variable,
+            insert_data[check_variable]
+        ).execute()
+
+    if len(resp.data) == 0:
+        logged_data = log_message_data_through_supabase_api(
+            table_name,
+            insert_data
+        )
+    else:
+        logged_data = resp
+    return logged_data
+
+
+def prepare_message_data_for_logging(message_data, nlu_response):
+    """ Builds objects for each table and logs them to the database
+
+    Input:
+    - message_data: an object with the full message data from Turn.io/Whatsapp
+    """
+    project_data = {
+        'name': "Rori",
+        # Autogenerated fields: id, created_at, modified_at
+    }
+    project_data_log = get_or_create_supabase_entry(
+        'project',
+        project_data,
+        'name'
+    )
+
+    contact_data = {
+        'project': project_data_log.data[0]['id'],  # FK
+        'original_contact_id': message_data['contact_uuid'],
+        'urn': "",
+        'language_code': "en",
+        'contact_inserted_at': format_datetime_in_isoformat(datetime.now())
+        # Autogenerated fields: id, created_at, modified_at
+    }
+    contact_data_log = get_or_create_supabase_entry('contact', contact_data)
+
+    del message_data['author_id']
+
+    message_data = {
+        'contact': contact_data_log.data[0]['id'],  # FK
+        'original_message_id': message_data['message_id'],
+        'text': message_data['message_body'],
+        'direction': message_data['message_direction'],
+        'sender_type': message_data['author_type'],
+        'channel_type': "whatsapp / turn.io",
+        'message_inserted_at': message_data['message_inserted_at'],
+        'message_modified_at': message_data['message_updated_at'],
+        'message_sent_at': format_datetime_in_isoformat(datetime.now()),
+        'nlu_response': nlu_response,
+        'request_object': message_data
+        # Autogenerated fields: created_at, modified_at
+    }
+    message_data_log = log_message_data_through_supabase_api(
+        'message',
+        message_data
+    )

mathtext_fastapi/math_quiz_fsm.py

@@ -0,0 +1,58 @@
+import random
+from transitions import Machine
+
+
+class MathQuizFSM(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=[2, 3],
+        initial_student_answer=0,
+    ):
+        # Instantiate the FSM
+        self.machine = Machine(
+            model=self,
+            states=MathQuizFSM.states,
+            transitions=MathQuizFSM.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]

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]

mathtext_fastapi/nlu.py

@@ -1,81 +1,178 @@
-import os
-from datetime import datetime
+from fuzzywuzzy import fuzz
+from mathtext_fastapi.logging import prepare_message_data_for_logging
+from mathtext.sentiment import sentiment
+from mathtext.text2int import text2int
+from mathtext_fastapi.intent_classification import create_intent_classification_model, retrieve_intent_classification_model, predict_message_intent
+import re
+
+
+def build_nlu_response_object(type, data, confidence):
+    """ Turns nlu results into an object to send back to Turn.io
+    Inputs
+    - type: str - the type of nlu run (integer or sentiment-analysis)
+    - data: str/int - the student message
+    - confidence: - the nlu confidence score (sentiment) or '' (integer)
+
+    >>> build_nlu_response_object('integer', 8, 0)
+    {'type': 'integer', 'data': 8, 'confidence': 0}
+
+    >>> build_nlu_response_object('sentiment', 'POSITIVE', 0.99)
+    {'type': 'sentiment', 'data': 'POSITIVE', 'confidence': 0.99}
+    """
+    return {'type': type, 'data': data, 'confidence': confidence}
 
-from dotenv import load_dotenv
-from supabase import create_client
 
-load_dotenv()
+# def test_for_float_or_int(message_data, message_text):
+#     nlu_response = {}
+#     if type(message_text) == int or type(message_text) == float:
+#         nlu_response = build_nlu_response_object('integer', message_text, '')
+#         prepare_message_data_for_logging(message_data, nlu_response)
+#     return nlu_response
 
-SUPA = create_client(os.environ.get('SUPABASE_URL'), os.environ.get('SUPABASE_KEY'))
 
+def test_for_number_sequence(message_text_arr, message_data, message_text):
+    """ Determines if the student's message is a sequence of numbers
 
-def log_message_data_through_supabase_api(table_name, log_data):
-    return SUPA.table(table_name).insert(log_data).execute()
+    >>> test_for_number_sequence(['1','2','3'], {"author_id": "57787919091", "author_type": "OWNER", "contact_uuid": "df78gsdf78df", "message_body": "I am tired", "message_direction": "inbound", "message_id": "dfgha789789ag9ga", "message_inserted_at": "2023-01-10T02:37:28.487319Z", "message_updated_at": "2023-01-10T02:37:28.487319Z"}, '1, 2, 3')
+    {'type': 'integer', 'data': '1,2,3', 'confidence': 0}
 
+    >>> test_for_number_sequence(['a','b','c'], {"author_id": "57787919091", "author_type": "OWNER", "contact_uuid": "df78gsdf78df", "message_body": "I am tired", "message_direction": "inbound", "message_id": "dfgha789789ag9ga", "message_inserted_at": "2023-01-10T02:37:28.487319Z", "message_updated_at": "2023-01-10T02:37:28.487319Z"}, 'a, b, c')
+    {}
+    """
+    nlu_response = {}
+    if all(ele.isdigit() for ele in message_text_arr):
+        nlu_response = build_nlu_response_object(
+            'integer',
+            ','.join(message_text_arr),
+            0
+        )
+        prepare_message_data_for_logging(message_data, nlu_response)
+    return nlu_response
 
-def format_datetime_in_isoformat(dt):
-    return getattr(dt.now(), 'isoformat', lambda x: None)()
 
+def run_text2int_on_each_list_item(message_text_arr):
+    """ Attempts to convert each list item to an integer
 
-def get_or_create_supabase_entry(table_name, insert_data, check_variable=None):
-    """ Checks whether a project or contact exists in the database and adds if one is not found
+    Input
+    - message_text_arr: list - a set of text extracted from the student message
 
-    Input:
-    - table_name: str- the name of the table in Supabase that is being examined
-    - insert_data: json - the data to insert
-    - check_variable: str/None - the specific field to examine for existing matches
+    Output
+    - student_response_arr: list - a set of integers (32202 for error code)
 
-    Result
-    - logged_data - an object with the Supabase data
-    
+    >>> run_text2int_on_each_list_item(['1','2','3'])
+    [1, 2, 3]
     """
-    if table_name == 'contact':
-        resp = SUPA.table('contact').select("*").eq("original_contact_id", insert_data['original_contact_id']).eq("project", insert_data['project']).execute()
-    else:
-        resp = SUPA.table(table_name).select("*").eq(check_variable, insert_data[check_variable]).execute()
+    student_response_arr = []
+    for student_response in message_text_arr:
+        int_api_resp = text2int(student_response.lower())
+        student_response_arr.append(int_api_resp)
+    return student_response_arr
 
-    if len(resp.data) == 0:
-        logged_data = log_message_data_through_supabase_api(table_name, insert_data)
-    else:
-        logged_data = resp
-    return logged_data
 
+def run_sentiment_analysis(message_text):
+    """ Evaluates the sentiment of a student message
 
+    >>> run_sentiment_analysis("I am tired")
+    [{'label': 'NEGATIVE', 'score': 0.9997807145118713}]
+
+    >>> run_sentiment_analysis("I am full of joy")
+    [{'label': 'POSITIVE', 'score': 0.999882698059082}]
+    """
+    # TODO: Add intent labelling here
+    # TODO: Add logic to determine whether intent labeling or sentiment analysis is more appropriate (probably default to intent labeling)
+    return sentiment(message_text)
+
+
+def run_intent_classification(message_text):
+    """ Process a student's message using basic fuzzy text comparison
+
+    >>> run_intent_classification("exit")
+    {'type': 'intent', 'data': 'exit', 'confidence': 1.0}
+    >>> run_intent_classification("exi")     
+    {'type': 'intent', 'data': 'exit', 'confidence': 0.86}
+    >>> run_intent_classification("eas")
+    {'type': 'intent', 'data': '', 'confidence': 0}
+    >>> run_intent_classification("hard")
+    {'type': 'intent', 'data': '', 'confidence': 0}
+    >>> run_intent_classification("hardier") 
+    {'type': 'intent', 'data': 'harder', 'confidence': 0.92}
+    """
+    label = ''
+    ratio = 0
+    nlu_response = {'type': 'intent', 'data': label, 'confidence': ratio}
+    commands = [
+        'easier',
+        'exit',
+        'harder',
+        'hint',
+        'next',
+        'stop',
+    ]
+    
+    for command in commands:
+        try:
+            ratio = fuzz.ratio(command, message_text.lower())
+        except:
+            ratio = 0
+        if ratio > 80:
+            nlu_response['data'] = command
+            nlu_response['confidence'] = ratio / 100
+    
+    return nlu_response
 
-def prepare_message_data_for_logging(message_data, nlu_response, request_object):
-    """ Builds the message data for each table and ensures it's logged to the database
 
-    Input:
-    - message_data: an object with the full message data from Turn.io/Whatsapp
+def evaluate_message_with_nlu(message_data):
+    """ Process a student's message using NLU functions and send the result
+    
+    >>> evaluate_message_with_nlu({"author_id": "57787919091", "author_type": "OWNER", "contact_uuid": "df78gsdf78df", "message_body": "8", "message_direction": "inbound", "message_id": "dfgha789789ag9ga", "message_inserted_at": "2023-01-10T02:37:28.487319Z", "message_updated_at": "2023-01-10T02:37:28.487319Z"})
+    {'type': 'integer', 'data': 8, 'confidence': 0}
+
+    >>> evaluate_message_with_nlu({"author_id": "57787919091", "author_type": "OWNER", "contact_uuid": "df78gsdf78df", "message_body": "I am tired", "message_direction": "inbound", "message_id": "dfgha789789ag9ga", "message_inserted_at": "2023-01-10T02:37:28.487319Z", "message_updated_at": "2023-01-10T02:37:28.487319Z"})
+    {'type': 'sentiment', 'data': 'NEGATIVE', 'confidence': 0.9997807145118713}
     """
-    project_data = {
-        'name': "Rori",
-        # Autogenerated fields: id, created_at, modified_at   
-    }
-    project_data_log = get_or_create_supabase_entry('project', project_data, 'name')
-
-    contact_data = {
-        'project': project_data_log.data[0]['id'],  # FK
-        'original_contact_id': message_data['message']['_vnd']['v1']['chat']['contact_uuid'],
-        'urn': "",
-        'language_code': "en",
-        'contact_inserted_at': format_datetime_in_isoformat(datetime.now())
-        # Autogenerated fields: id, created_at, modified_at
-    }
-    contact_data_log = get_or_create_supabase_entry('contact', contact_data)
-
-    message_data = {
-        'contact': contact_data_log.data[0]['id'],  # FK
-        'original_message_id': message_data['message']['id'],
-        'text': message_data['message']['text']['body'],
-        'direction': message_data['message']['_vnd']['v1']['direction'],
-        'sender_type': message_data['message']['_vnd']['v1']['author']['type'],
-        'channel_type': "whatsapp / turn.io",
-        'message_inserted_at': message_data['message']['_vnd']['v1']['chat']['inserted_at'],
-        'message_modified_at': message_data['message']['_vnd']['v1']['chat']['updated_at'],
-        'message_sent_at': format_datetime_in_isoformat(datetime.now()),
-        'nlu_response': nlu_response,
-        'request_object': request_object
-        # Autogenerated fields: created_at, modified_at
-    }
-    message_data_log = log_message_data_through_supabase_api('message', message_data)
+    # Keeps system working with two different inputs - full and filtered @event object
+    try:
+        message_text = str(message_data['message_body'])
+    except KeyError:
+        message_data = {
+            'author_id': message_data['message']['_vnd']['v1']['chat']['owner'],
+            'author_type': message_data['message']['_vnd']['v1']['author']['type'],
+            'contact_uuid': message_data['message']['_vnd']['v1']['chat']['contact_uuid'],
+            'message_body': message_data['message']['text']['body'],
+            'message_direction': message_data['message']['_vnd']['v1']['direction'],
+            'message_id': message_data['message']['id'],
+            'message_inserted_at': message_data['message']['_vnd']['v1']['chat']['inserted_at'],
+            'message_updated_at': message_data['message']['_vnd']['v1']['chat']['updated_at'],
+        }
+        message_text = str(message_data['message_body'])
+
+    # Run intent classification only for keywords
+    intent_api_response = run_intent_classification(message_text)
+    if intent_api_response['data']:
+        prepare_message_data_for_logging(message_data, intent_api_response)
+        return intent_api_response
+
+    number_api_resp = text2int(message_text.lower())
+
+    if number_api_resp == 32202:
+        # Run intent classification with logistic regression model
+        predicted_label = predict_message_intent(message_text)
+        if predicted_label['confidence'] > 0.01:
+            nlu_response = predicted_label
+        else:
+            # Run sentiment analysis
+            sentiment_api_resp = sentiment(message_text)
+            nlu_response = build_nlu_response_object(
+                'sentiment',
+                sentiment_api_resp[0]['label'],
+                sentiment_api_resp[0]['score']
+            )
+    else:
+        nlu_response = build_nlu_response_object(
+            'integer',
+            number_api_resp,
+            0
+        )
+
+    prepare_message_data_for_logging(message_data, nlu_response)
+    return nlu_response

requirements.txt

@@ -8,6 +8,8 @@ pydantic==1.10.*
 python-Levenshtein
 requests==2.27.*
 sentencepiece==0.1.*
+sentence-transformers
 supabase
 transitions
-uvicorn==0.17.*
+uvicorn==0.17.*
+

scripts/make_request.py

@@ -1,144 +1,194 @@
+import json
 import requests
 
-# request = requests.post(url=
-#                         'https://tangibleai-mathtext-fastapi.hf.space/sentiment-analysis',
-#                         json={"content": "I reject it"}).json()
-
-# print(request)
-
-# request = requests.post(url=
-#                         'https://tangibleai-mathtext-fastapi.hf.space/text2int',
-#                         json={"content": "seven thousand nine hundred fifty seven"}
-#                         ).json()
-
-# print(request)
-
-
-# # json = {
-# #     'message': {
-# #         '_vnd': {
-# #             'v1': {
-# #                 'author': {
-# #                     'id': 57787919091,
-# #                     'name': 'GT',
-# #                     'type': 'OWNER'
-# #                 },
-# #                 'card_uuid': None,
-# #                 'chat': {
-# #                     'assigned_to': {
-# #                         'id': 'jhk151kl-hj42-3752-3hjk-h4jk6hjkk2',
-# #                         'name': 'Greg Thompson',
-# #                         'type': 'OPERATOR'
-# #                     },
-# #                     'contact_uuid': 'j43hk26-2hjl-43jk-hnk2-k4ljl46j0ds09',
-# #                     'inserted_at': '2022-07-05T04:00:34.033522Z',
-# #                     'owner': '+57787919091',
-# #                     'permalink': 'https://app.turn.io/c/4kl209sd0-a7b8-2hj3-8563-3hu4a89b32',
-# #                     'state': 'OPEN',
-# #                     'state_reason': 'Re-opened by inbound message.',
-# #                     'unread_count': 19,
-# #                     'updated_at': '2023-01-10T02:37:28.487319Z',
-# #                     'uuid': '4kl209sd0-a7b8-2hj3-8563-3hu4a89b32'
-# #                 },
-# #                 'direction': 'inbound',
-# #                 'faq_uuid': None,
-# #                 'in_reply_to': None,
-# #                 'inserted_at': '2023-01-10T02:37:28.477940Z',
-# #                 'labels': [{
-# #                     'confidence': 0.506479332,
-# #                     'metadata': {
-# #                         'nlu': {
-# #                             'confidence': 0.506479332,
-# #                             'intent': 'question',
-# #                             'model_name': 'nlu-general-spacy-ngrams-20191014'
-# #                         }
-# #                     },
-# #                     'uuid': 'ha7890s2k-hjk2-2476-s8d9-fh9779a8a9ds',
-# #                     'value': 'Unclassified'
-# #                 }],
-# #                 'last_status': None,
-# #                 'last_status_timestamp': None,
-# #                 'on_fallback_channel': False,
-# #                 'rendered_content': None,
-# #                 'uuid': 's8df79zhws-h89s-hj23-7s8d-thb248d9bh2qn'
-# #             }
-# #         },
-# #         'from': 57787919091,
-# #         'id': 'hsjkthzZGehkzs09sijWA3',
-# #         'text': {'body': 'eight'},
-# #         'timestamp': 1673318248,
-# #         'type': 'text'
-# #     },
-# #     'type': 'message'
-# # }
-
-# json = b'{"message_data": {"message":{"_vnd":{"v1":{"author":{"id":57787919091,"name":"GT","type":"OWNER"},"card_uuid":null,"chat":{"assigned_to":{"id":"jhk151kl-hj42-3752-3hjk-h4jk6hjkk2","name":"Greg Thompson","type":"OPERATOR"},"contact_uuid":"j43hk26-2hjl-43jk-hnk2-k4ljl46j0ds09","inserted_at":"2022-07-05T04:00:34.033522Z","owner":"+57787919091","permalink":"https://app.turn.io/c/4kl209sd0-a7b8-2hj3-8563-3hu4a89b32","state":"OPEN","state_reason":"Re-opened by inbound message.","unread_count":14,"updated_at":"2023-01-10T02:37:28.487319Z","uuid":"4kl209sd0-a7b8-2hj3-8563-3hu4a89b32"},"direction":"inbound","faq_uuid":null,"in_reply_to":null,"inserted_at":"2023-01-10T02:37:28.477940Z","labels":[{"confidence":0.506479332,"metadata":{"nlu":{"confidence":0.506479332,"intent":"question","model_name":"nlu-general-spacy-ngrams-20191014"}},"uuid":"ha7890s2k-hjk2-2476-s8d9-fh9779a8a9ds","value":"Unclassified"}],"last_status":null,"last_status_timestamp":null,"on_fallback_channel":false,"rendered_content":null,"uuid":"s8df79zhws-h89s-hj23-7s8d-thb248d9bh2qn"}},"from":57787919091,"id":"hsjkthzZGehkzs09sijWA3","text":{"body":"eight"},"timestamp":1673318248,"type":"text"},"type":"message"}}\n'
-
-# # eight > 8
-# request = requests.post(url=
-#                         'http://localhost:7860/nlu',
-#                         data=json
-#                         ).json()
-# print(request)
-
-# json2 = b'{"message_data": {"message":{"_vnd":{"v1":{"author":{"id":57787919091,"name":"GT","type":"OWNER"},"card_uuid":null,"chat":{"assigned_to":{"id":"jhk151kl-hj42-3752-3hjk-h4jk6hjkk2","name":"Greg Thompson","type":"OPERATOR"},"contact_uuid":"j43hk26-2hjl-43jk-hnk2-k4ljl46j0ds09","inserted_at":"2022-07-05T04:00:34.033522Z","owner":"+57787919091","permalink":"https://app.turn.io/c/4kl209sd0-a7b8-2hj3-8563-3hu4a89b32","state":"OPEN","state_reason":"Re-opened by inbound message.","unread_count":14,"updated_at":"2023-01-10T02:37:28.487319Z","uuid":"4kl209sd0-a7b8-2hj3-8563-3hu4a89b32"},"direction":"inbound","faq_uuid":null,"in_reply_to":null,"inserted_at":"2023-01-10T02:37:28.477940Z","labels":[{"confidence":0.506479332,"metadata":{"nlu":{"confidence":0.506479332,"intent":"question","model_name":"nlu-general-spacy-ngrams-20191014"}},"uuid":"ha7890s2k-hjk2-2476-s8d9-fh9779a8a9ds","value":"Unclassified"}],"last_status":null,"last_status_timestamp":null,"on_fallback_channel":false,"rendered_content":null,"uuid":"s8df79zhws-h89s-hj23-7s8d-thb248d9bh2qn"}},"from":57787919091,"id":"hsjkthzZGehkzs09sijWA3","text":{"body":"eight, nine, ten"},"timestamp":1673318248,"type":"text"},"type":"message"}}\n'
-
-# # "eight, nine, ten" > 8,9,10
-# request = requests.post(url=
-#                         'http://localhost:7860/nlu',
-#                         data=json2
-#                         ).json()
-
-# print(request)
-
-
-# json = b'{"message_data": {"message":{"_vnd":{"v1":{"author":{"id":57787919091,"name":"GT","type":"OWNER"},"card_uuid":null,"chat":{"assigned_to":{"id":"jhk151kl-hj42-3752-3hjk-h4jk6hjkk2","name":"Greg Thompson","type":"OPERATOR"},"contact_uuid":"j43hk26-2hjl-43jk-hnk2-k4ljl46j0ds09","inserted_at":"2022-07-05T04:00:34.033522Z","owner":"+57787919091","permalink":"https://app.turn.io/c/4kl209sd0-a7b8-2hj3-8563-3hu4a89b32","state":"OPEN","state_reason":"Re-opened by inbound message.","unread_count":14,"updated_at":"2023-01-10T02:37:28.487319Z","uuid":"4kl209sd0-a7b8-2hj3-8563-3hu4a89b32"},"direction":"inbound","faq_uuid":null,"in_reply_to":null,"inserted_at":"2023-01-10T02:37:28.477940Z","labels":[{"confidence":0.506479332,"metadata":{"nlu":{"confidence":0.506479332,"intent":"question","model_name":"nlu-general-spacy-ngrams-20191014"}},"uuid":"ha7890s2k-hjk2-2476-s8d9-fh9779a8a9ds","value":"Unclassified"}],"last_status":null,"last_status_timestamp":null,"on_fallback_channel":false,"rendered_content":null,"uuid":"s8df79zhws-h89s-hj23-7s8d-thb248d9bh2qn"}},"from":57787919091,"id":"hsjkthzZGehkzs09sijWA3","text":{"body":8},"timestamp":1673318248,"type":"text"},"type":"message"}}\n'
-
-# # 8 > 8
-# request = requests.post(url=
-#                         'http://localhost:7860/nlu',
-#                         data=json
-#                         ).json()
-
-# print(request)
-
-# json = b'{"message_data": {"message":{"_vnd":{"v1":{"author":{"id":57787919091,"name":"GT","type":"OWNER"},"card_uuid":null,"chat":{"assigned_to":{"id":"jhk151kl-hj42-3752-3hjk-h4jk6hjkk2","name":"Greg Thompson","type":"OPERATOR"},"contact_uuid":"j43hk26-2hjl-43jk-hnk2-k4ljl46j0ds09","inserted_at":"2022-07-05T04:00:34.033522Z","owner":"+57787919091","permalink":"https://app.turn.io/c/4kl209sd0-a7b8-2hj3-8563-3hu4a89b32","state":"OPEN","state_reason":"Re-opened by inbound message.","unread_count":14,"updated_at":"2023-01-10T02:37:28.487319Z","uuid":"4kl209sd0-a7b8-2hj3-8563-3hu4a89b32"},"direction":"inbound","faq_uuid":null,"in_reply_to":null,"inserted_at":"2023-01-10T02:37:28.477940Z","labels":[{"confidence":0.506479332,"metadata":{"nlu":{"confidence":0.506479332,"intent":"question","model_name":"nlu-general-spacy-ngrams-20191014"}},"uuid":"ha7890s2k-hjk2-2476-s8d9-fh9779a8a9ds","value":"Unclassified"}],"last_status":null,"last_status_timestamp":null,"on_fallback_channel":false,"rendered_content":null,"uuid":"s8df79zhws-h89s-hj23-7s8d-thb248d9bh2qn"}},"from":57787919091,"id":"hsjkthzZGehkzs09sijWA3","text":{"body":"8, 9, 10"},"timestamp":1673318248,"type":"text"},"type":"message"}}\n'
-
-# # "8, 9, 10" > "8,9,10"
-# request = requests.post(url=
-#                         'http://localhost:7860/nlu',
-#                         data=json
-#                         ).json()
-
-# print(request)
-
-# json = b'{"message_data": {"message":{"_vnd":{"v1":{"author":{"id":57787919091,"name":"GT","type":"OWNER"},"card_uuid":null,"chat":{"assigned_to":{"id":"jhk151kl-hj42-3752-3hjk-h4jk6hjkk2","name":"Greg Thompson","type":"OPERATOR"},"contact_uuid":"j43hk26-2hjl-43jk-hnk2-k4ljl46j0ds09","inserted_at":"2022-07-05T04:00:34.033522Z","owner":"+57787919091","permalink":"https://app.turn.io/c/4kl209sd0-a7b8-2hj3-8563-3hu4a89b32","state":"OPEN","state_reason":"Re-opened by inbound message.","unread_count":14,"updated_at":"2023-01-10T02:37:28.487319Z","uuid":"4kl209sd0-a7b8-2hj3-8563-3hu4a89b32"},"direction":"inbound","faq_uuid":null,"in_reply_to":null,"inserted_at":"2023-01-10T02:37:28.477940Z","labels":[{"confidence":0.506479332,"metadata":{"nlu":{"confidence":0.506479332,"intent":"question","model_name":"nlu-general-spacy-ngrams-20191014"}},"uuid":"ha7890s2k-hjk2-2476-s8d9-fh9779a8a9ds","value":"Unclassified"}],"last_status":null,"last_status_timestamp":null,"on_fallback_channel":false,"rendered_content":null,"uuid":"s8df79zhws-h89s-hj23-7s8d-thb248d9bh2qn"}},"from":57787919091,"id":"hsjkthzZGehkzs09sijWA3","text":{"body":"I dont know"},"timestamp":1673318248,"type":"text"},"type":"message"}}\n'
-
-# # "8, 9, 10" > "8,9,10"
-# request = requests.post(url=
-#                         'http://localhost:7860/nlu',
-#                         data=json
-#                         ).json()
-
-# print(request)
-
-# json = b'{"message_data": {"message":{"_vnd":{"v1":{"author":{"id":57787919091,"name":"GT","type":"OWNER"},"card_uuid":null,"chat":{"assigned_to":{"id":"jhk151kl-hj42-3752-3hjk-h4jk6hjkk2","name":"Greg Thompson","type":"OPERATOR"},"contact_uuid":"j43hk26-2hjl-43jk-hnk2-k4ljl46j0ds09","inserted_at":"2022-07-05T04:00:34.033522Z","owner":"+57787919091","permalink":"https://app.turn.io/c/4kl209sd0-a7b8-2hj3-8563-3hu4a89b32","state":"OPEN","state_reason":"Re-opened by inbound message.","unread_count":14,"updated_at":"2023-01-10T02:37:28.487319Z","uuid":"4kl209sd0-a7b8-2hj3-8563-3hu4a89b32"},"direction":"inbound","faq_uuid":null,"in_reply_to":null,"inserted_at":"2023-01-10T02:37:28.477940Z","labels":[{"confidence":0.506479332,"metadata":{"nlu":{"confidence":0.506479332,"intent":"question","model_name":"nlu-general-spacy-ngrams-20191014"}},"uuid":"ha7890s2k-hjk2-2476-s8d9-fh9779a8a9ds","value":"Unclassified"}],"last_status":null,"last_status_timestamp":null,"on_fallback_channel":false,"rendered_content":null,"uuid":"s8df79zhws-h89s-hj23-7s8d-thb248d9bh2qn"}},"from":57787919091,"id":"hsjkthzZGehkzs09sijWA3","text":{"body":"Today is a wonderful day"},"timestamp":1673318248,"type":"text"},"type":"message"}}\n'
-
-# # "8, 9, 10" > "8,9,10"
-# request = requests.post(url=
-#                         'http://localhost:7860/nlu',
-#                         data=json
-#                         ).json()
-
-# print(request)
-
-
-json = b'{"message_data": {"message":{"_vnd":{"v1":{"author":{"id":57787919091,"name":"GT","type":"OWNER"},"card_uuid":null,"chat":{"assigned_to":{"id":"jhk151kl-hj42-3752-3hjk-h4jk6hjkk2","name":"Greg Thompson","type":"OPERATOR"},"contact_uuid":"j43hk26-2hjl-43jk-hnk2-k4ljl46j0ds09","inserted_at":"2022-07-05T04:00:34.033522Z","owner":"+57787919091","permalink":"https://app.turn.io/c/4kl209sd0-a7b8-2hj3-8563-3hu4a89b32","state":"OPEN","state_reason":"Re-opened by inbound message.","unread_count":14,"updated_at":"2023-01-10T02:37:28.487319Z","uuid":"4kl209sd0-a7b8-2hj3-8563-3hu4a89b32"},"direction":"inbound","faq_uuid":null,"in_reply_to":null,"inserted_at":"2023-01-10T02:37:28.477940Z","labels":[{"confidence":0.506479332,"metadata":{"nlu":{"confidence":0.506479332,"intent":"question","model_name":"nlu-general-spacy-ngrams-20191014"}},"uuid":"ha7890s2k-hjk2-2476-s8d9-fh9779a8a9ds","value":"Unclassified"}],"last_status":null,"last_status_timestamp":null,"on_fallback_channel":false,"rendered_content":null,"uuid":"s8df79zhws-h89s-hj23-7s8d-thb248d9bh2qn"}},"from":57787919091,"id":"hsjkthzZGehkzs09sijWA3","text":{"body":"Today is a wonderful day"},"timestamp":1673318248,"type":"text"},"type":"message"}}\n'
-
-
-
-request = requests.post(url=
-                        'http://localhost:7860/manager',
-                        data=json
-                        ).json()
-print(request)
+
+def add_message_text_to_sample_object(message_text):
+    """
+    Builds a sample request object using an example of a student answer
+
+    Input
+    - message_text: str - an example of user input to test
+
+    Example Input
+    "test message"
+
+    Output
+    - b_string: json b-string - simulated Turn.io message data
+
+    Example Output
+    b'{"context": "hi", "message_data": {"author_id": "+57787919091", "author_type": "OWNER", "contact_uuid": "j43hk26-2hjl-43jk-hnk2-k4ljl46j0ds09", "message_body": "test message", "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"}}'
+    
+    """
+    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}")
+    b_string = add_message_text_to_sample_object(sample_answer)
+
+    if endpoint == 'sentiment-analysis' or endpoint == 'text2int' or endpoint =='intent-classification':
+        request = requests.post(
+            url=f'http://localhost:7860/{endpoint}',
+            json={'content': sample_answer}
+        ).json()
+    else:
+        request = requests.post(
+            url=f'http://localhost:7860/{endpoint}',
+            data=b_string
+        ).json()
+
+    print(request)
+
+
+# run_simulated_request('intent-classification', 'exit')
+# run_simulated_request('intent-classification', "I'm not sure")
+# run_simulated_request('sentiment-analysis', 'I reject it')
+# run_simulated_request('text2int', 'seven thousand nine hundred fifty seven')
+run_simulated_request('nlu', 'test message')
+run_simulated_request('nlu', 'eight')
+run_simulated_request('nlu', 'is it 8')
+run_simulated_request('nlu', 'can I know how its 0.5')
+run_simulated_request('nlu', 'eight, nine, ten')
+run_simulated_request('nlu', '8, 9, 10')
+run_simulated_request('nlu', '8')
+run_simulated_request('nlu', "I don't know")
+run_simulated_request('nlu', "I don't know eight")
+run_simulated_request('nlu', "I don't 9")
+run_simulated_request('nlu', "0.2")
+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', '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')
+
+
+# Example of simplified object received from Turn.io stacks
+# This is a contrived example to show the structure, not an actual state
+# NOTE: This is actually a bstring, not a dict
+simplified_json = {
+    "context": {
+        "user": "+57787919091", 
+        "state": "answer-addition-problem", 
+        "bot_message": "What is 2+2?", 
+        "user_message": "eight",
+        "type": "ask"
+    },
+    "message_data": {
+        "author_id": "+57787919091", 
+        "author_type": "OWNER", 
+        "contact_uuid": "j43hk26-2hjl-43jk-hnk2-k4ljl46j0ds09", 
+        "message_body": "eight", 
+        "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"
+    }
+}
+
+
+# Full example of event data from Turn.io 
+# simplified_json is built from this in Turn.io
+# full_json = {
+#     'message': {
+#         '_vnd': {
+#             'v1': {
+#                 'author': {
+#                     'id': 57787919091,
+#                     'name': 'GT',
+#                     'type': 'OWNER'
+#                 },
+#                 'card_uuid': None,
+#                 'chat': {
+#                     'assigned_to': {
+#                         'id': 'jhk151kl-hj42-3752-3hjk-h4jk6hjkk2',
+#                         'name': 'Greg Thompson',
+#                         'type': 'OPERATOR'
+#                     },
+#                     'contact_uuid': 'j43hk26-2hjl-43jk-hnk2-k4ljl46j0ds09',
+#                     'inserted_at': '2022-07-05T04:00:34.033522Z',
+#                     'owner': '+57787919091',
+#                     'permalink': 'https://app.turn.io/c/4kl209sd0-a7b8-2hj3-8563-3hu4a89b32',
+#                     'state': 'OPEN',
+#                     'state_reason': 'Re-opened by inbound message.',
+#                     'unread_count': 19,
+#                     'updated_at': '2023-01-10T02:37:28.487319Z',
+#                     'uuid': '4kl209sd0-a7b8-2hj3-8563-3hu4a89b32'
+#                 },
+#                 'direction': 'inbound',
+#                 'faq_uuid': None,
+#                 'in_reply_to': None,
+#                 'inserted_at': '2023-01-10T02:37:28.477940Z',
+#                 'labels': [{
+#                     'confidence': 0.506479332,
+#                     'metadata': {
+#                         'nlu': {
+#                             'confidence': 0.506479332,
+#                             'intent': 'question',
+#                             'model_name': 'nlu-general-spacy-ngrams-20191014'
+#                         }
+#                     },
+#                     'uuid': 'ha7890s2k-hjk2-2476-s8d9-fh9779a8a9ds',
+#                     'value': 'Unclassified'
+#                 }],
+#                 'last_status': None,
+#                 'last_status_timestamp': None,
+#                 'on_fallback_channel': False,
+#                 'rendered_content': None,
+#                 'uuid': 's8df79zhws-h89s-hj23-7s8d-thb248d9bh2qn'
+#             }
+#         },
+#         'from': 57787919091,
+#         'id': 'hsjkthzZGehkzs09sijWA3',
+#         'text': {'body': 'eight'},
+#         'timestamp': 1673318248,
+#         'type': 'text'
+#     },
+#     'type': 'message'
+# }

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"