Update utility.py

utility.py

@@ -14,17 +14,36 @@ openai.api_key = o_api_key
 # Authenticate to Firesotre with the JSON account key
 db = firestore.Client.from_service_account_json("firestore-key.json")
 
+
 # Generate AI response from user input
-def generateResponse(prompt):
+def generateResponse(prompt,model='Meta-Llama-3.1-70B-Instruct'):
   #----- Call API to classify and extract relevant transaction information
     # These templates help provide a unified response format for use as context clues when
     # parsing the AI generated response into a structured data format
     relevant_info_template = """
-          Intent: The CRUD operation
-          Transaction Type: The type of transaction
-          Details: as a sublist of the key details like name of item, amount, description, among other details you are able to extract. 
+          Intent: The CRUD operation, one of create, read, update, or delete
+          Transaction Type: The type of transaction such as purchases, sales
+          Details: as a sublist of the key details like name of item, quantity, cost price, currency, unit for the quantity, description, among other details you are able to extract. 
       """
-    sample_response_template = """
+    sample_single_transaction_template = """
+      The information provided indicates that you want to **create/record** a new transaction.
+      **Extracted Information**:
+
+      **Intent**: Create
+
+      **Transaction Type**: Purchase
+      **Details**: 
+              - Item: Car
+              - Purpose: Business
+              - Quantity: 1
+              - Unit: None
+              - Cost: 10000
+              - Tax: 200
+              - Currency: USD
+              - Note: A new car for business
+              """
+    
+    sample_multi_transaction_template = """
       The information provided indicates that you want to **create/record** a new transaction.
 
       **Extracted Information**:
@@ -37,8 +56,11 @@ def generateResponse(prompt):
       **Details**: 
               - Item: Car
               - Purpose: Business
-              - Amount: 1000
+              - Quantity: 1
+              - Unit: None
+              - Cost: 10000
               - Tax: 200
+              - Currency: USD
               - Note: A new car for business
 
       Transaction 2:
@@ -46,13 +68,17 @@ def generateResponse(prompt):
       **Transaction Type**: Expense  
       **Details**:  
             - Item: Office Chair  
-            - Amount: 300 USD  
+            - Quantity: 2
+            - Unit: None
+            - Cost: 300 
+            - Currency: USD  
             - Category: Furniture  
       """
-    response = openai.chat.completions.create(
-        model="gpt-4o",
+    response = client.chat.completions.create(
+        model = model,
+        # model="gpt-4o",
         messages=[
-              {"role": "system", "content": f"You are a helpful assistant that classifies transactions written in natural language into CRUD operations (Create, Read, Update, and Delete) and extracts relevant information. Format the relevant information extracted from the transaction text in this format: {relevant_info_template}. You can use markdown syntax to present a nicely formated and readable response to the user, but make sure the user does not see the markdown keyword. Keywords and field names must be in bold face. A sample response could look like this: {sample_response_template}. Delineate multiple transactions with the label 'Transaction 1' before the start of the relevant information for each transaction. There should be only one intent even in the case of multiple transactions."},
+              {"role": "system", "content": f"You are a helpful assistant that classifies transactions written in natural language into CRUD operations (Create, Read, Update, and Delete) and extracts relevant information. You should be able to recognize the currency being used and any quantity units into separate fields. Format the relevant information extracted from the transaction text in this format: {relevant_info_template}. Use markdown syntax to present a nicely formated and readable response to the user, but make sure the user does not see the markdown keyword. Keywords and field names must be in bold face. A sample response for a single transaction could look like this: {sample_single_transaction_template}, while multiple transactions could look like this: {sample_multi_transaction_template}. There should be only one intent even in the case of multiple transactions."},
               {"role": "user", "content": prompt}
         ]
     )
@@ -65,7 +91,68 @@ def generateResponse(prompt):
 
     return response
 
-# TODO Handle multiple multiple transactions from one user input.
+
+def parse_value(value):
+    """
+    Parses a value string into the appropriate data type and detects currency.
+    Handles various currencies, percentages, numbers, and text.
+    """
+    value = value.strip()
+    try:
+        # Match currency codes or symbols dynamically
+        currency_match = re.search(r"([A-Z]{3}|\$|€|£)", value)
+        currency = currency_match.group(1) if currency_match else None
+
+        # Remove currency symbols or codes for numeric conversion
+        cleaned_value = re.sub(r"[A-Z]{3}|\$|€|£", "", value).replace(",", "").strip()
+
+        # Handle percentages
+        if "%" in cleaned_value:
+            return float(cleaned_value.replace("%", "")), currency
+        # Handle plain numbers (integers or floats)
+        elif cleaned_value.replace(".", "", 1).isdigit():
+            return float(cleaned_value) if "." in cleaned_value else int(cleaned_value), currency
+        # Return as text if no numeric parsing is possible
+        return value, currency
+    except ValueError:
+        # Fallback to original value if parsing fails
+        return value, None
+
+def extract_transaction_details(text):
+    """
+    Extracts transaction details from a given text input.
+    Handles both bold (**field**) and non-bold (field) formats.
+    """
+    details = {}
+    transaction_currency = None  # Default currency field
+
+    # Regex to match key-value pairs
+    detail_matches = re.findall(
+        r"-\s*\*{0,2}([\w\s]+)\*{0,2}:\s*([\w\s,.$%-]+?)(?:\s*[\n]|$)",  # Stop matching before newline or end of string
+        text,
+        re.DOTALL
+    )
+    # print("Detail matches:", detail_matches)  # Debugging
+
+    for field, value in detail_matches:
+        # Standardize the field name (convert to snake_case)
+        field = field.strip().lower().replace(" ", "_")
+        
+        # Parse the value and dynamically detect currency
+        parsed_value, detected_currency = parse_value(value)
+        if detected_currency and not transaction_currency:
+            transaction_currency = detected_currency  # Set the transaction-level currency if not already set
+        
+        details[field] = parsed_value
+
+    # Add currency as a separate field
+    if transaction_currency:
+        details["currency"] = transaction_currency
+
+    return details
+
+
+# Parsing single transactions
 def parse_ai_response(response_text):
     # Initialize the structured data dictionary
     data = {
@@ -85,24 +172,8 @@ def parse_ai_response(response_text):
     if transaction_type_match:
         data["transaction_type"] = transaction_type_match.group(1)
     
-    # Extract details
-    details = {}
-    detail_matches = re.findall(r"-\s*([\w\s]+):\s*([\d\w\s,.]+(?:\sUSD)?)", response_text)
-    for field, value in detail_matches:
-        # Clean up the field name and value
-        field = field.strip().lower().replace(" ", "_")  # Convert to snake_case
-        value = value.strip()
-        
-        # Convert numeric values where possible
-        if "USD" in value:
-            value = float(value.replace(" USD", "").replace(",", ""))
-        elif value.isdigit():
-            value = int(value)
-        
-        details[field] = value
-    
     # Store details in the structured data
-    data["details"] = details
+    data["details"] = extract_transaction_details(response_text)
     
     return data
 
@@ -116,13 +187,16 @@ def parse_multiple_transactions(response_text):
     # Remove the first section if it's not a valid transaction
     if not re.search(r"\*\*Transaction Type\*\*", transaction_sections[0], re.IGNORECASE):
         transaction_sections.pop(0)
-    print(len(transaction_sections))
-    print(transaction_sections)
+    # if len(transaction_sections) == 1: # process single transaction
+    #     transaction_data = parse_ai_response(response_text)
+    #     transactions.append(transaction_data)
+    #     return transactions
+    
     # Extract intent: with support for a single intent per user prompt
     intent_match = re.search(r"\*\*Intent\*\*:\s*(\w+)", response_text)
     if intent_match:
         intent = intent_match.group(1)
-
+    
     for section in transaction_sections:
         # Initialize transaction data
         transaction_data = {
@@ -131,7 +205,6 @@ def parse_multiple_transactions(response_text):
             "details": {},
             "created_at": datetime.now().isoformat()
         }
-        # transaction_data["intent"] = intent
 
         # Extract transaction type
         transaction_type_match = re.search(r"\*\*Transaction Type\*\*:\s*(\w+)", section)
@@ -139,28 +212,15 @@ def parse_multiple_transactions(response_text):
             transaction_data["transaction_type"] = transaction_type_match.group(1)
 
         # Extract details
-        details = {}
-        detail_matches = re.findall(r"-\s*([\w\s]+):\s*([\d\w\s,.]+(?:\sUSD)?)", section)
-        for field, value in detail_matches:
-            field = field.strip().lower().replace(" ", "_")  # Convert to snake_case
-            value = value.strip()
-            # Convert numeric values where possible
-            if "USD" in value:
-                value = float(value.replace(" USD", "").replace(",", ""))
-            elif value.isdigit():
-                value = int(value)
-            details[field] = value
-
-        transaction_data["details"] = details
+        transaction_data["details"] = extract_transaction_details(section)
+
         transactions.append(transaction_data)
 
     return transactions
 
 def create_inventory(user_phone, transaction_data):
-    print(transaction_data)
     for transaction in transaction_data:
-        print(transaction)
-        item_name = transaction['Item'] # assumes unique item name
+        item_name = transaction['details']['item'] # assumes unique item name
         doc_ref = db.collection("users").document(user_phone).collection("inventory").document(item_name)
         # transaction_data['transaction_id'] # let's default to random generated document ids
         doc_ref.set(transaction)
@@ -170,13 +230,13 @@ def create_inventory(user_phone, transaction_data):
 def create_sale(user_phone, transaction_data):
     
     for transaction in transaction_data:
-        item_name = transaction['Item'] # assumes unique item name
+        item_name = transaction['details']['item'] # assumes item names are unique per transactions
         # fetch the inventory
         inventory = fetch_transaction(user_phone, item_name)
 
         # Do the sales calculations
-        new_stock_level = inventory['Quantity'] - transaction['Quantity']
-        inventory['Quantity'] = new_stock_level
+        new_stock_level = inventory['details']['quantity'] - transaction['details']['quantity']
+        inventory['details']['quantity'] = new_stock_level
 
         # update the inventory
         doc_ref = db.collection("users").document(user_phone).collection("inventory").document(item_name)
@@ -189,6 +249,7 @@ def create_sale(user_phone, transaction_data):
         # print("Transaction created successfully!")
     return True
 
+
 # Update logic:
 # - 
 def update_transaction(user_phone, transaction_id, update_data):