Duplicate from thompsgj/mathtext-fastapi

.gitattributes

@@ -0,0 +1,34 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,163 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+.idea/
+
+*history_sentiment*
+*history_text2int*

.gitlab-ci.yml

@@ -0,0 +1,16 @@
+# Official Python language image.
+test_py38:
+  image: python:3.8
+  before_script:
+    - python -v
+    - pip install -r requirements.txt
+  script:
+    - pytest --verbose
+
+test_py39:
+  image: python:3.9
+  before_script:
+    - python -v
+    - pip install -r requirements.txt
+  script:
+    - pytest --verbose

Dockerfile

@@ -0,0 +1,22 @@
+# https://huggingface.co/docs/hub/spaces-sdks-docker-first-demo
+
+FROM python:3.9
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+RUN useradd -m -u 1000 user
+
+USER user
+
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+COPY --chown=user . $HOME/app
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,12 @@
+---
+title: Mathtext Fastapi
+emoji: 🐨
+colorFrom: blue
+colorTo: red
+sdk: docker
+pinned: false
+license: agpl-3.0
+duplicated_from: thompsgj/mathtext-fastapi
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,279 @@
+"""FastAPI endpoint
+To run locally use 'uvicorn app:app --host localhost --port 7860'
+"""
+import ast
+import scripts.quiz.generators as generators
+import scripts.quiz.hints as hints
+import scripts.quiz.questions as questions
+import scripts.quiz.utils as utils
+
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from mathtext.sentiment import sentiment
+from mathtext.text2int import text2int
+from pydantic import BaseModel
+
+from mathtext_fastapi.logging import prepare_message_data_for_logging
+from mathtext_fastapi.conversation_manager import manage_conversation_response
+from mathtext_fastapi.nlu import evaluate_message_with_nlu
+from mathtext_fastapi.nlu import run_intent_classification
+
+app = FastAPI()
+
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+templates = Jinja2Templates(directory="templates")
+
+
+class Text(BaseModel):
+    content: str = ""
+
+
+@app.get("/")
+def home(request: Request):
+    return templates.TemplateResponse("home.html", {"request": request})
+
+
+@app.post("/hello")
+def hello(content: Text = None):
+    content = {"message": f"Hello {content.content}!"}
+    return JSONResponse(content=content)
+
+
+@app.post("/sentiment-analysis")
+def sentiment_analysis_ep(content: Text = None):
+    ml_response = sentiment(content.content)
+    content = {"message": ml_response}
+    return JSONResponse(content=content)
+
+
+@app.post("/text2int")
+def text2int_ep(content: Text = None):
+    ml_response = text2int(content.content)
+    content = {"message": ml_response}
+    return JSONResponse(content=content)
+
+
+@app.post("/manager")
+async def programmatic_message_manager(request: Request):
+    """
+    Calls conversation management function to determine the next state
+
+    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",
+    }
+
+    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 evaluation and returns the nlu_response
+
+    Input
+    - request.body: json - message data for the most recent user response
+
+    Output
+    - 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', '')
+    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

@@ -0,0 +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()
+
+SUPA = create_client(
+    os.environ.get('SUPABASE_URL'),
+    os.environ.get('SUPABASE_KEY')
+)
+
+
+def create_text_message(message_text, whatsapp_id):
+    """ Fills a template with input values to send a text message to Whatsapp
+
+    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
+
+
+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)
+
+    data = {
+        "to": whatsapp_id,
+        "type": "interactive",
+        "interactive": {
+            "type": "button",
+            # "header": { },
+            "body": {
+                "text": message_text
+            },
+            # "footer": { },
+            "action": {
+                "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
+        )
+
+    # 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

@@ -0,0 +1,105 @@
+input,output,text2int,score
+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,52 @@
+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
+
+
+def predict_message_intent(message):
+    encoder = SentenceTransformer('all-MiniLM-L6-v2')
+    model = retrieve_intent_classification_model()
+    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

@@ -0,0 +1,175 @@
+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}
+
+
+# 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
+
+
+def test_for_number_sequence(message_text_arr, message_data, message_text):
+    """ Determines if the student's message is a sequence of numbers
+
+    >>> 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 run_text2int_on_each_list_item(message_text_arr):
+    """ Attempts to convert each list item to an integer
+
+    Input
+    - message_text_arr: list - a set of text extracted from the student message
+
+    Output
+    - student_response_arr: list - a set of integers (32202 for error code)
+
+    >>> run_text2int_on_each_list_item(['1','2','3'])
+    [1, 2, 3]
+    """
+    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
+
+
+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:
+        ratio = fuzz.ratio(command, message_text.lower())
+        if ratio > 80:
+            nlu_response['data'] = command
+            nlu_response['confidence'] = ratio / 100
+    
+    return nlu_response
+
+
+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}
+    """
+    # Keeps system working with two different inputs - full and filtered @event object
+    try:
+        message_text = 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 = message_data['message_body']
+
+    # Run intent classification only for keywords
+    intent_api_response = run_intent_classification(message_text)
+    if intent_api_response['data']:
+        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
+            return nlu_response
+
+        # 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

pyproject.toml

@@ -0,0 +1,43 @@
+[tool.poetry]
+name = "MathText_FastAPI"
+version = "0.0.1"
+authors = [
+  "Sebastian Larsen <sebastianlarson22@gmail.com>",
+  "Çetin ÇAKIR <cetincakirtr@gmail.com>",
+  "Hobson Lane <gitlab@totalgood.com>",
+  ]
+description = "Natural Language Understanding (text processing) for math symbols, digits, and words with a Gradio user interface and REST API."
+readme = "README.md"
+# requires-python = ">=3.8"
+license = "AGPL-3.0-or-later"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)",
+    "Operating System :: OS Independent",
+]
+
+
+[tool.poetry.dependencies]
+mathtext = {git = "https://gitlab.com/tangibleai/community/mathtext", rev = "main"}
+fastapi = "0.74.*"
+pydantic = "*"
+python = "^3.8,<3.10"
+requests = "2.27.*"
+sentencepiece = "0.1.*"
+supabase = "*"
+uvicorn = "0.17.*"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^7.2"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+# [build-system]
+# requires = ["hatchling"]
+# build-backend = "hatchling.build"
+
+# repository = "https://gitlab.com/tangibleai/community/mathtext-fastapi"

requirements.txt

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

scripts/api_scaling.py

@@ -0,0 +1,96 @@
+"""https://zetcode.com/python/concurrent-http-requests/"""
+
+import asyncio
+import random
+import time
+import pandas as pd
+import httpx
+from os.path import exists
+
+NUMBER_OF_CALLS = 1
+
+headers = {"Content-Type": "application/json; charset=utf-8"}
+
+# base_url = "https://tangibleai-mathtext-fastapi.hf.space/{endpoint}"
+base_url = "http://localhost:7860/run/{endpoint}"
+
+data_list_1 = {
+    "endpoint": "text2int",
+    "test_data": [
+        "one hundred forty five",
+        "twenty thousand nine hundred fifty",
+        "one hundred forty five",
+        "nine hundred eighty three",
+        "five million",
+    ]
+}
+
+data_list_2 = {
+    "endpoint": "text2int-preprocessed",
+    "test_data": [
+        "one hundred forty five",
+        "twenty thousand nine hundred fifty",
+        "one hundred forty five",
+        "nine hundred eighty three",
+        "five million",
+    ]
+}
+data_list_3 = {
+    "endpoint": "sentiment-analysis",
+    "test_data": [
+        "Totally agree",
+        "I like it",
+        "No more",
+        "I am not sure",
+        "Never",
+    ]
+}
+
+
+# async call to endpoint
+async def call_api(url, data, call_number, number_of_calls):
+    json = {"data": [data]}
+    async with httpx.AsyncClient() as client:
+        start = time.perf_counter()  # Used perf_counter for more precise result.
+        response = await client.post(url=url, headers=headers, json=json, timeout=30)
+        end = time.perf_counter()
+        return {
+            "endpoint": url.split("/")[-1],
+            "test data": data,
+            "status code": response.status_code,
+            "response": response.json().get("data"),
+            "call number": call_number,
+            "number of calls": number_of_calls,
+            "start": start.__round__(4),
+            "end": end.__round__(4),
+            "delay": (end - start).__round__(4)
+        }
+
+
+data_lists = [data_list_1, data_list_2, data_list_3]
+
+results = []
+
+
+async def main(number_of_calls):
+    for data_list in data_lists:
+        calls = []
+        for call_number in range(1, number_of_calls + 1):
+            url = base_url.format(endpoint=data_list["endpoint"])
+            data = random.choice(data_list["test_data"])
+            calls.append(call_api(url, data, call_number, number_of_calls))
+        r = await asyncio.gather(*calls)
+        results.extend(r)
+
+
+
+start = time.perf_counter()
+asyncio.run(main(NUMBER_OF_CALLS))
+end = time.perf_counter()
+print(end-start)
+df = pd.DataFrame(results)
+
+if exists("call_history.csv"):
+    df.to_csv(path_or_buf="call_history.csv", mode="a", header=False, index=False)
+else:
+    df.to_csv(path_or_buf="call_history.csv", mode="w", header=True, index=False)

scripts/api_scaling.sh

@@ -0,0 +1,83 @@
+#! /bin/env bash
+
+LOG_FILE_NAME="call_history_bash.csv"
+
+if [[ ! -f "$LOG_FILE_NAME" ]]; then
+  # Creation of column names if the file does not exits
+  echo "student_id;active_students;endpoint;inputs;outputs;started;finished" >$LOG_FILE_NAME
+fi
+
+data_list_1() {
+  responses=(
+    "one hundred forty five"
+    "twenty thousand nine hundred fifty"
+    "one hundred forty five"
+    "nine hundred eighty three"
+    "five million"
+  )
+  echo "${responses[$1]}"
+}
+
+data_list_2() {
+  responses=(
+    "Totally agree"
+    "I like it"
+    "No more"
+    "I am not sure"
+    "Never"
+  )
+  echo "${responses[$1]}"
+}
+
+# endpoints: "text2int" "sentiment-analysis"
+# selected endpoint to test
+endpoint="sentiment-analysis"
+
+create_random_delay() {
+  # creates a random delay for given arguments
+  echo "scale=8; $RANDOM/32768*$1" | bc
+}
+
+simulate_student() {
+  # Student simulator waits randomly between 0-10s after an interaction.
+  # Based on 100 interactions per student
+  for i in {1..100}; do
+
+    random_value=$((RANDOM % 5))
+    text=$(data_list_2 $random_value)
+    data='{"data": ["'$text'"]}'
+
+    start_=$(date +"%F %T.%6N")
+
+    url="https://tangibleai-mathtext-fastapi.hf.space/$3"
+    response=$(curl --silent --connect-timeout 30 --max-time 30 -X POST "$url" -H 'Content-Type: application/json' -d "$data")
+
+    if [[ "$response" == *"Time-out"* ]]; then
+      echo "$response" >>bad_response.txt
+      response="504 Gateway Time-out"
+    elif [[ -z "$response" ]]; then
+      echo "No response" >>bad_response.txt
+      response="504 Gateway Time-out"
+    fi
+
+    end_=$(date +"%F %T.%6N")
+
+    printf "%s;%s;%s;%s;%s;%s;%s\n" "$1" "$2" "$3" "$data" "$response" "$start_" "$end_" >>$LOG_FILE_NAME
+    sleep "$(create_random_delay 10)"
+
+  done
+}
+
+echo "start: $(date)"
+
+active_students=250 # the number of students using the system at the same time
+
+i=1
+while [[ "$i" -le "$active_students" ]]; do
+  simulate_student "student$i" "$active_students" "$endpoint" &
+  sleep "$(create_random_delay 1)" # adding a random delay between students
+  i=$(("$i" + 1))
+done
+
+wait
+echo "end: $(date)"

scripts/build.sh

@@ -0,0 +1,8 @@
+deactivate
+pip install virtualenv
+rm -rf .venv
+python3.9 -m virtualenv --python 3.9 .venv
+# pip install --upgrade scikit-learn
+# pip install --upgrade transformers
+# pip install --upgrade pandas
+pip install --upgrade -e .

scripts/make_request.py

@@ -0,0 +1,194 @@
+import json
+import requests
+
+
+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/make_request.sh

@@ -0,0 +1,46 @@
+#root_url="localhost:7860"
+root_url="https://tangibleai-mathtext-fastapi.hf.space"
+
+ep="/"
+url=$root_url$ep
+data=''
+
+response=$(curl --silent -X GET "$url" -H 'Content-Type: application/json')
+
+echo "URL: $url"
+echo "Data: $data"
+echo "Response: $response"
+echo
+
+ep="/hello"
+url=$root_url$ep
+data='{"content":"Rori"}'
+
+response=$(curl --silent -X POST "$url" -H 'Content-Type: application/json' -d "$data")
+
+echo "URL: $url"
+echo "Data: $data"
+echo "Response: $response"
+echo
+
+ep="/sentiment-analysis"
+url=$root_url$ep
+data='{"content":"I am happy with it!"}'
+
+response=$(curl --silent -X POST "$url" -H 'Content-Type: application/json' -d "$data")
+
+echo "URL: $url"
+echo "Data: $data"
+echo "Response: $response"
+echo
+
+ep="/text2int"
+url=$root_url$ep
+data='{"content":"one hundred forty two"}'
+
+response=$(curl --silent -X POST "$url" -H 'Content-Type: application/json' -d "$data")
+
+echo "URL: $url"
+echo "Data: $data"
+echo "Response: $response"
+echo

scripts/plot_calls.py

@@ -0,0 +1,116 @@
+import math
+from datetime import datetime
+
+import matplotlib.pyplot as plt
+import pandas as pd
+
+pd.set_option('display.max_columns', None)
+pd.set_option('display.max_rows', None)
+
+log_files = [
+    'call_history_sentiment_1_bash.csv',
+    'call_history_text2int_1_bash.csv',
+]
+
+for log_file in log_files:
+    path_ = f"./data/{log_file}"
+    df = pd.read_csv(filepath_or_buffer=path_, sep=";")
+    df["finished_ts"] = df["finished"].apply(
+        lambda x: datetime.strptime(x, "%Y-%m-%d %H:%M:%S.%f").timestamp())
+    df["started_ts"] = df["started"].apply(
+        lambda x: datetime.strptime(x, "%Y-%m-%d %H:%M:%S.%f").timestamp())
+    df["elapsed"] = df["finished_ts"] - df["started_ts"]
+
+    df["success"] = df["outputs"].apply(lambda x: 0 if "Time-out" in x else 1)
+
+    student_numbers = sorted(df['active_students'].unique())
+
+    bins_dict = dict()  # bins size for each group
+    min_finished_dict = dict()  # zero time for each group
+
+    for student_number in student_numbers:
+        # for each student group calculates bins size and zero time
+        min_finished = df["finished_ts"][df["active_students"] == student_number].min()
+        max_finished = df["finished_ts"][df["active_students"] == student_number].max()
+        bins = math.ceil(max_finished - min_finished)
+        bins_dict.update({student_number: bins})
+        min_finished_dict.update({student_number: min_finished})
+        print(f"student number: {student_number}")
+        print(f"min finished: {min_finished}")
+        print(f"max finished: {max_finished}")
+        print(f"bins finished seconds: {bins}, minutes: {bins / 60}")
+
+    df["time_line"] = None
+    for student_number in student_numbers:
+        # calculates time-line for each student group
+        df["time_line"] = df.apply(
+            lambda x: x["finished_ts"] - min_finished_dict[student_number]
+            if x["active_students"] == student_number
+            else x["time_line"],
+            axis=1
+        )
+
+    # creates a '.csv' from the dataframe
+    df.to_csv(f"./data/processed_{log_file}", index=False, sep=";")
+
+    result = df.groupby(['active_students', 'success']) \
+        .agg({
+        'elapsed': ['mean', 'median', 'min', 'max'],
+        'success': ['count'],
+    })
+
+    print(f"Results for {log_file}")
+    print(result, "\n")
+
+    title = None
+    if "sentiment" in log_file.lower():
+        title = "API result for 'sentiment-analysis' endpoint"
+    elif "text2int" in log_file.lower():
+        title = "API result for 'text2int' endpoint"
+
+    for student_number in student_numbers:
+        # Prints percentage of the successful and failed calls
+        try:
+            failed_calls = result.loc[(student_number, 0), 'success'][0]
+        except:
+            failed_calls = 0
+        successful_calls = result.loc[(student_number, 1), 'success'][0]
+        percentage = (successful_calls / (failed_calls + successful_calls)) * 100
+        print(f"Percentage of successful API calls for {student_number} students: {percentage.__round__(2)}")
+
+    rows = len(student_numbers)
+
+    fig, axs = plt.subplots(rows, 2)  # (rows, columns)
+
+    for index, student_number in enumerate(student_numbers):
+        # creates a boxplot for each test group
+        data = df[df["active_students"] == student_number]
+        axs[index][0].boxplot(x=data["elapsed"])  # axs[row][column]
+        # axs[index][0].set_title(f'Boxplot for {student_number} students')
+        axs[index][0].set_xlabel(f'student number {student_number}')
+        axs[index][0].set_ylabel('Elapsed time (s)')
+
+        # creates a histogram for each test group
+        axs[index][1].hist(x=data["elapsed"], bins=25)  # axs[row][column]
+        # axs[index][1].set_title(f'Histogram for {student_number} students')
+        axs[index][1].set_xlabel('seconds')
+        axs[index][1].set_ylabel('Count of API calls')
+
+    fig.suptitle(title, fontsize=16)
+
+    fig, axs = plt.subplots(rows, 1)  # (rows, columns)
+
+    for index, student_number in enumerate(student_numbers):
+        # creates a histogram and shows API calls on a timeline for each test group
+        data = df[df["active_students"] == student_number]
+
+        print(data["time_line"].head(10))
+
+        axs[index].hist(x=data["time_line"], bins=bins_dict[student_number])  # axs[row][column]
+        # axs[index][1].set_title(f'Histogram for {student_number} students')
+        axs[index].set_xlabel('seconds')
+        axs[index].set_ylabel('Count of API calls')
+
+    fig.suptitle(title, fontsize=16)
+
+plt.show()

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"

static/styles.css

@@ -0,0 +1,8 @@
+@import url('https://fonts.googleapis.com/css2?family=Roboto:wght@300&display=swap');
+
+body {
+font-family: 'Roboto', sans-serif;
+font-size: 16px;
+background-color: black;
+color: white
+}

templates/home.html

@@ -0,0 +1,35 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Title</title>
+    <link rel="stylesheet" href="{{ url_for('static', path='/styles.css') }}">
+</head>
+<body>
+<h2>Mathbot</h2>
+<h3>Created with FastAPI</h3>
+
+<h4>To make a request with python</h4>
+<pre><code>
+import requests
+
+requests.post(
+    url='https://tangibleai-mathtext-fastapi.hf.space/sentiment-analysis',
+    json={"content": "I reject it"}
+    ).json()
+
+requests.post(
+    url='https://tangibleai-mathtext-fastapi.hf.space/text2int',
+    json={"content": "forty two"}
+    ).json()
+
+</code></pre>
+
+<h4>To make a request with curl</h4>
+<pre><code>
+curl --silent -X POST "https://tangibleai-mathtext-fastapi.hf.space/sentiment-analysis" -H 'Content-Type: application/json' -d '{"content":"I am happy with it!"}'
+
+curl --silent -X POST "https://tangibleai-mathtext-fastapi.hf.space/text2int" -H 'Content-Type: application/json' -d '{"content":"forty two"}'
+</code></pre>
+</body>
+</html>

tests/test_text2int.py

@@ -0,0 +1,57 @@
+import unittest
+from pathlib import Path
+
+import pandas as pd
+from fastapi.testclient import TestClient
+
+from app import app
+
+# The raw file URL has to be used for GitLab.
+URL = "https://gitlab.com/tangibleai/community/mathtext/-/raw/main/mathtext/data/master_test_text2int.csv"
+
+DATA_DIR = Path(__file__).parent.parent / "mathtext_fastapi" / "data"
+print(DATA_DIR)
+
+client = TestClient(app)
+
+
+class TestStringMethods(unittest.TestCase):
+
+    def setUp(self):
+        """Creates a fastapi test client"""
+        self.client = TestClient(app)
+        self.df = pd.read_csv(URL)
+
+    def get_response_text2int(self, text):
+        """Makes a post request to the endpoint"""
+        r = None
+        try:
+            r = self.client.post("/text2int", json={"content": text}) \
+                .json().get("message")
+        except:
+            pass
+        return r
+
+    def test_endpoint_text2int(self):
+        """Tests if endpoint is working"""
+        response = self.client.post("/text2int",
+                                    json={"content": "fourteen"}
+                                    )
+        self.assertEqual(response.status_code, 200)
+
+    def test_acc_score_text2int(self):
+        """Calculates accuracy score for endpoint"""
+
+        self.df["text2int"] = self.df["input"].apply(func=self.get_response_text2int)
+        self.df["score"] = self.df[["output", "text2int"]].apply(
+            lambda row: row[0] == row[1],
+            axis=1
+        )
+        self.df.to_csv(f"{DATA_DIR}/text2int_results.csv", index=False)
+        acc_score = self.df["score"].mean().__round__(2)
+
+        self.assertGreaterEqual(acc_score, 0.5, f"Accuracy score: '{acc_score}'. Value is too low!")
+
+
+if __name__ == '__main__':
+    unittest.main()