Update code for PEP8 formatting

app.py

@@ -12,7 +12,7 @@ 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_conversational_response
+from mathtext_fastapi.conversation_manager import manage_conversation_response
 from mathtext_fastapi.nlu import evaluate_message_with_nlu
 
 app = FastAPI()
@@ -54,10 +54,10 @@ def text2int_ep(content: Text = None):
 @app.post("/manager")
 async def programmatic_message_manager(request: Request):
     """
-    Calls the conversation management function to determine what to send to the user based on the current state and user response
+    Calls conversation management function to determine the next state
 
     Input
-    request.body: dict - a json object of message data for the most recent user response
+    request.body: dict - message data for the most recent user response
     {
         "author_id": "+47897891",
         "contact_uuid": "j43hk26-2hjl-43jk-hnk2-k4ljl46j0ds09",
@@ -70,7 +70,7 @@ async def programmatic_message_manager(request: Request):
     }
 
     Output
-    context: dict - a json object that holds the information for the current state
+    context: dict - the information for the current state
     {
         "user": "47897891", 
         "state": "welcome-message-state", 
@@ -86,13 +86,13 @@ async def programmatic_message_manager(request: Request):
 
 @app.post("/nlu")
 async def evaluate_user_message_with_nlu_api(request: Request):
-    """ Calls the nlu evaluation function to run nlu functions and returns the nlu_response to Turn.io
-
+    """ Calls nlu evaluation and returns the nlu_response
+    
     Input
-    - request.body: a json object of message data for the most recent user response
-
+    - request.body: json - message data for the most recent user response
+    
     Output
-    - int_data_dict or sent_data_dict: A dictionary telling the type of NLU run and the resulting data
+    - int_data_dict or sent_data_dict: dict - the type of NLU run and result
       {'type':'integer', 'data': '8'}
       {'type':'sentiment', 'data': 'negative'}
     """

mathtext_fastapi/conversation_manager.py

@@ -11,14 +11,14 @@ load_dotenv()
 
 
 def create_text_message(message_text, whatsapp_id):
-    """ Fills a template with the necessary information to send a text message to Whatsapp
+    """ 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 with the inputs' values included
+    - message_data: dict - a preformatted template filled with inputs
     """
     message_data = {
         "preview_url": False,
@@ -38,7 +38,7 @@ def create_button_objects(button_options):
     - button_options: list - a list of text to be displayed in buttons
 
     Output
-    - button_arr: list - a list of button objects that use a template filled with the input values
+    - button_arr: list - preformatted button objects filled with the inputs
 
     NOTE: Not fully implemented and tested
     """
@@ -56,11 +56,13 @@ def create_button_objects(button_options):
 
 
 def create_interactive_message(message_text, button_options, whatsapp_id):
-    """ Fills a template with the necessary information to send a message with button options to Whatsapp
+    """ 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
+    * 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
@@ -88,17 +90,18 @@ def create_interactive_message(message_text, button_options, whatsapp_id):
 
 
 def return_next_conversational_state(context_data, user_message):
-    """ Evaluates the current state of the conversation to determine resources for the next state of the conversation
+    """ Evaluates the conversation's current state to determine the next state
 
     Input
-    - context_data: dict - data about the conversation's current state received from the Turn.io stack
+    - 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 user input to send the user
+    - message_package: dict - a series of messages and prompt to send
     """
-    if context_data['user_message'] == '' and context_data['state'] == 'start-conversation':
-            message_package = {
+    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"
@@ -141,11 +144,11 @@ def return_next_conversational_state(context_data, user_message):
     return message_package
 
 
-def manage_conversational_response(data_json):
-    """ Parses message data, determines how to respond to user message at a given conversational state, builds/sends messages, and updates/sends context
+def manage_conversation_response(data_json):
+    """ Calls functions necessary to determine message and context data to send
 
     Input
-    - data_json: dict - the data for a message the user sent to Turn.io/Whatsapp
+    - data_json: dict - message data from Turn.io/Whatsapp
 
     Output
     - context: dict - a record of the state at a given point a conversation
@@ -166,7 +169,10 @@ def manage_conversational_response(data_json):
     # TODO: Need to incorporate nlu_response into wormhole by checking answers against database (spreadsheet?)
     nlu_response = evaluate_message_with_nlu(message_data)
     
-    message_package = return_next_conversational_state(context_data, user_message)
+    message_package = return_next_conversational_state(
+        context_data, 
+        user_message
+    )
 
     headers = {
         'Authorization': f"Bearer {os.environ.get('TURN_AUTHENTICATION_TOKEN')}",
@@ -176,7 +182,11 @@ def manage_conversational_response(data_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)
-        r = requests.post(f'https://whatsapp.turn.io/v1/messages', data=json.dumps(data), headers=headers)
+        r = requests.post(
+            f'https://whatsapp.turn.io/v1/messages', 
+            data=json.dumps(data), 
+            headers=headers
+        )
 
     # Update the context object with the new state of the conversation
     context = {
@@ -191,8 +201,6 @@ def manage_conversational_response(data_json):
 
     return context
 
-
-
     # data = {
     #     "to": whatsapp_id,
     #     "type": "interactive",

mathtext_fastapi/logging.py

@@ -6,7 +6,10 @@ from supabase import create_client
 
 load_dotenv()
 
-SUPA = create_client(os.environ.get('SUPABASE_URL'), os.environ.get('SUPABASE_KEY'))
+SUPA = create_client(
+    os.environ.get('SUPABASE_URL'), 
+    os.environ.get('SUPABASE_KEY')
+)
 
 
 def log_message_data_through_supabase_api(table_name, log_data):
@@ -18,32 +21,43 @@ def format_datetime_in_isoformat(dt):
 
 
 def get_or_create_supabase_entry(table_name, insert_data, check_variable=None):
-    """ Checks whether a project or contact exists in the database and adds if one is not found
+    """ 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 examine for existing matches
+    - 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()
+        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()
+        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)
+        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 the message data for each table and ensures it's logged to the database
+    """ 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
@@ -52,7 +66,11 @@ def prepare_message_data_for_logging(message_data, nlu_response):
         'name': "Rori",
         # Autogenerated fields: id, created_at, modified_at   
     }
-    project_data_log = get_or_create_supabase_entry('project', project_data, 'name')
+    project_data_log = get_or_create_supabase_entry(
+        'project', 
+        project_data, 
+        'name'
+    )
 
     contact_data = {
         'project': project_data_log.data[0]['id'],  # FK
@@ -64,7 +82,6 @@ def prepare_message_data_for_logging(message_data, nlu_response):
     }
     contact_data_log = get_or_create_supabase_entry('contact', contact_data)
 
-
     del message_data['author_id']
 
     message_data = {
@@ -81,4 +98,7 @@ def prepare_message_data_for_logging(message_data, nlu_response):
         'request_object': message_data
         # Autogenerated fields: created_at, modified_at
     }
-    message_data_log = log_message_data_through_supabase_api('message', message_data)
+    message_data_log = log_message_data_through_supabase_api(
+        'message', 
+        message_data
+    )

mathtext_fastapi/nlu.py

@@ -5,11 +5,11 @@ import re
 
 
 def build_nlu_response_object(type, data, confidence):
-    """ Builds a json object from the result of nlu functions to send back to Turn.io
+    """ 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 - the student message
-    - confidence: - the nlu confidence score.  Integer is ''.  Sentiment analysis is a float
+    - confidence: - the nlu confidence score (sentiment) or '' (integer)
     """
     return {'type': type, 'data': data, 'confidence': confidence}
 
@@ -25,19 +25,23 @@ def test_for_float_or_int(message_data, message_text):
 def test_for_number_sequence(message_text_arr, message_data, message_text):
     nlu_response = {}
     if all(ele.isdigit() for ele in message_text_arr):
-        nlu_response = build_nlu_response_object('integer', ','.join(message_text_arr), '')
+        nlu_response = build_nlu_response_object(
+            'integer', 
+            ','.join(message_text_arr), 
+            ''
+        )
         prepare_message_data_for_logging(message_data, nlu_response)
     return nlu_response
 
 
 def run_text2int_on_each_list_item(message_text_arr):
-    """ Checks each item in an array to see if it can be converted to an integer
+    """ 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 derived from the nlu function
+    - student_response_arr: list - a set of integers (32202 for error code)
     """
     student_response_arr = []
     for student_response in message_text_arr:
@@ -74,12 +78,24 @@ def evaluate_message_with_nlu(message_data):
     student_response_arr = run_text2int_on_each_list_item(message_text_arr)
     if 32202 in student_response_arr:
         sentiment_api_resp = sentiment(message_text)
-        nlu_response = build_nlu_response_object('sentiment', sentiment_api_resp[0]['label'], sentiment_api_resp[0]['score'])
+        nlu_response = build_nlu_response_object(
+            'sentiment', 
+            sentiment_api_resp[0]['label'], 
+            sentiment_api_resp[0]['score']
+        )
     else:
         if len(student_response_arr) > 1:
-            nlu_response = build_nlu_response_object('integer', ','.join(str(num) for num in student_response_arr), '' )
+            nlu_response = build_nlu_response_object(
+                'integer', 
+                ','.join(str(num) for num in student_response_arr), 
+                ''
+            )
         else:
-            nlu_response = build_nlu_response_object('integer', student_response_arr[0], '')
+            nlu_response = build_nlu_response_object(
+                'integer', 
+                student_response_arr[0], 
+                ''
+            )
 
     prepare_message_data_for_logging(message_data, nlu_response)
     return nlu_response