rasa-pro 3.14.0.dev6__py3-none-any.whl → 3.14.0.dev8__py3-none-any.whl

rasa/cli/project_templates/finance/actions/database.py

@@ -0,0 +1,277 @@
+import csv
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+class Database:
+    def __init__(self, csv_path: Optional[Path] = None) -> None:
+        """Initialize the database with CSV file paths."""
+        self.project_root_path = Path(__file__).resolve().parent.parent
+        self.csv_path = csv_path or self.project_root_path / "csvs"
+        self.logger = self.setup_logger()
+
+    def setup_logger(self) -> logging.Logger:
+        """Set up logging configuration."""
+        logger = logging.getLogger(__name__)
+        logger.setLevel(logging.DEBUG)
+
+        formatter = logging.Formatter(
+            "%(asctime)s %(levelname)8s %(name)s  - %(message)s"
+        )
+
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(logging.DEBUG)
+        console_handler.setFormatter(formatter)
+        logger.addHandler(console_handler)
+
+        return logger
+
+    def _read_csv(self, filename: str) -> List[Dict[str, Any]]:
+        """Read CSV file and return list of dictionaries."""
+        try:
+            with open(self.csv_path / filename, "r", newline="") as csvfile:
+                reader = csv.DictReader(csvfile)
+                return list(reader)
+        except Exception as e:
+            self.logger.error(f"Error reading CSV file {filename}: {e}")
+            return []
+
+    def _write_csv(self, filename: str, data: List[Dict[str, Any]]) -> bool:
+        """Write list of dictionaries to CSV file."""
+        try:
+            if not data:
+                return True
+
+            with open(self.csv_path / filename, "w", newline="") as csvfile:
+                writer = csv.DictWriter(csvfile, fieldnames=data[0].keys())
+                writer.writeheader()
+                writer.writerows(data)
+            return True
+        except Exception as e:
+            self.logger.error(f"Error writing CSV file {filename}: {e}")
+            return False
+
+    def get_user_by_name(self, username: str) -> Optional[Dict[str, Any]]:
+        """Get user information by username."""
+        try:
+            users = self._read_csv("users.csv")
+            for user in users:
+                if user["name"] == username:
+                    return user
+            return None
+        except Exception as e:
+            self.logger.error(f"Error getting user by name: {e}")
+            return None
+
+    def get_user_by_id(self, user_id: int) -> Optional[Dict[str, Any]]:
+        """Get user information by user_id."""
+        try:
+            users = self._read_csv("users.csv")
+            for user in users:
+                if int(user["id"]) == user_id:
+                    return user
+            return None
+        except Exception as e:
+            self.logger.error(f"Error getting user by id: {e}")
+            return None
+
+    def get_account_by_user_and_number(
+        self, user_id: int, account_number: str
+    ) -> Optional[Dict[str, Any]]:
+        """Get account information by user_id and account number."""
+        try:
+            accounts = self._read_csv("accounts.csv")
+            for account in accounts:
+                if (
+                    int(account["user_id"]) == user_id
+                    and account["number"] == account_number
+                ):
+                    return account
+            return None
+        except Exception as e:
+            self.logger.error(f"Error getting account: {e}")
+            return None
+
+    def get_accounts_by_user(self, user_id: int) -> List[Dict[str, Any]]:
+        """Get all accounts for a user."""
+        try:
+            accounts = self._read_csv("accounts.csv")
+            return [
+                account for account in accounts if int(account["user_id"]) == user_id
+            ]
+
+        except Exception as e:
+            self.logger.error(f"Error getting accounts by user: {e}")
+            return []
+
+    def get_payees_by_user(self, user_id: int) -> List[Dict[str, Any]]:
+        """Get all payees for a user."""
+        try:
+            payees = self._read_csv("payees.csv")
+            return [payee for payee in payees if int(payee["user_id"]) == user_id]
+        except Exception as e:
+            self.logger.error(f"Error getting payees by user: {e}")
+            return []
+
+    def get_payee_by_name_and_user(
+        self, payee_name: str, user_id: int
+    ) -> Optional[Dict[str, Any]]:
+        """Get payee information by name and user_id."""
+        try:
+            payees = self._read_csv("payees.csv")
+            for payee in payees:
+                if payee["name"] == payee_name and int(payee["user_id"]) == user_id:
+                    return payee
+            return None
+        except Exception as e:
+            self.logger.error(f"Error getting payee by name and user: {e}")
+            return None
+
+    def get_cards_by_user(self, user_id: int) -> List[Dict[str, Any]]:
+        """Get all cards for a user."""
+        try:
+            cards = self._read_csv("cards.csv")
+            return [card for card in cards if int(card["user_id"]) == user_id]
+        except Exception as e:
+            self.logger.error(f"Error getting cards by user: {e}")
+            return []
+
+    def get_card_by_number(self, card_number: str) -> Optional[Dict[str, Any]]:
+        """Get card information by card number."""
+        try:
+            cards = self._read_csv("cards.csv")
+            for card in cards:
+                if card["number"] == card_number:
+                    return card
+            return None
+        except Exception as e:
+            self.logger.error(f"Error getting card by number: {e}")
+            return None
+
+    def update_card_status(self, card_number: str, status: str) -> bool:
+        """Update card status."""
+        try:
+            cards = self._read_csv("cards.csv")
+            for card in cards:
+                if card["number"] == card_number:
+                    card["status"] = status
+                    break
+            return self._write_csv("cards.csv", cards)
+        except Exception as e:
+            self.logger.error(f"Error updating card status: {e}")
+            return False
+
+    def add_payee(
+        self,
+        user_id: int,
+        name: str,
+        sort_code: str,
+        account_number: str,
+        payee_type: str,
+        reference: str = "",
+    ) -> bool:
+        """Add a new payee."""
+        try:
+            payees = self._read_csv("payees.csv")
+
+            # Get the next ID
+            next_id = 1
+            if payees:
+                next_id = max(int(payee["id"]) for payee in payees) + 1
+
+            # Create new payee record
+            new_payee = {
+                "id": str(next_id),
+                "user_id": str(user_id),
+                "name": name,
+                "sort_code": sort_code,
+                "account_number": account_number,
+                "type": payee_type,
+                "reference": reference,
+                "added_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            }
+
+            # Add to list and save
+            payees.append(new_payee)
+            return self._write_csv("payees.csv", payees)
+        except Exception as e:
+            self.logger.error(f"Error adding payee: {e}")
+            return False
+
+    def remove_payee(self, payee_name: str, user_id: int) -> bool:
+        """Remove a payee."""
+        try:
+            payees = self._read_csv("payees.csv")
+            payees = [
+                payee
+                for payee in payees
+                if not (
+                    payee["name"] == payee_name and int(payee["user_id"]) == user_id
+                )
+            ]
+            return self._write_csv("payees.csv", payees)
+        except Exception as e:
+            self.logger.error(f"Error removing payee: {e}")
+            return False
+
+    def check_sufficient_funds(
+        self, user_id: int, account_number: str, amount: float
+    ) -> bool:
+        """Check if account has sufficient funds."""
+        try:
+            account = self.get_account_by_user_and_number(user_id, account_number)
+            if not account:
+                return False
+            return float(account["balance"]) >= amount
+        except Exception as e:
+            self.logger.error(f"Error checking sufficient funds: {e}")
+            return False
+
+    def get_branches(self) -> List[Dict[str, Any]]:
+        """Get all branches."""
+        try:
+            return self._read_csv("branches.csv")
+        except Exception as e:
+            self.logger.error(f"Error getting branches: {e}")
+            return []
+
+    def get_advisors_by_branch(self, branch_id: int) -> List[Dict[str, Any]]:
+        """Get all advisors for a branch."""
+        try:
+            advisors = self._read_csv("advisors.csv")
+            return [
+                advisor
+                for advisor in advisors
+                if int(advisor["branch_id"]) == branch_id
+            ]
+        except Exception as e:
+            self.logger.error(f"Error getting advisors by branch: {e}")
+            return []
+
+    def get_appointments_by_advisor(self, advisor_id: int) -> List[Dict[str, Any]]:
+        """Get all appointments for an advisor."""
+        try:
+            appointments = self._read_csv("appointments.csv")
+            return [
+                appointment
+                for appointment in appointments
+                if int(appointment["advisor_id"]) == advisor_id
+            ]
+        except Exception as e:
+            self.logger.error(f"Error getting appointments by advisor: {e}")
+            return []
+
+    def __enter__(self) -> "Database":
+        """Enter the runtime context related to this object."""
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[type],
+        exc_value: Optional[BaseException],
+        traceback: Optional[Any],
+    ) -> None:
+        """Exit the runtime context related to this object."""
+        self.logger.info("Database connection closed")

rasa/cli/project_templates/finance/actions/transfers/action_add_payee.py

@@ -0,0 +1,52 @@
+from typing import Any, Dict, List, Text
+
+from rasa_sdk import Action, Tracker
+from rasa_sdk.events import SlotSet
+from rasa_sdk.executor import CollectingDispatcher
+
+from actions.database import Database
+
+
+class ActionAddPayee(Action):
+    def name(self) -> Text:
+        return "action_add_payee"
+
+    def run(
+        self,
+        dispatcher: CollectingDispatcher,
+        tracker: Tracker,
+        domain: Dict[Text, Any],
+    ) -> List[Dict[Text, Any]]:
+        name = tracker.get_slot("name")
+        payee_name = tracker.get_slot("payee_name")
+        account_number = tracker.get_slot("account_number")
+        sort_code = tracker.get_slot("sort_code")
+        payee_type = tracker.get_slot("payee_type")
+        reference = tracker.get_slot("reference") or ""
+
+        db = Database()
+
+        # Get user information
+        user = db.get_user_by_name(name)
+        if not user:
+            dispatcher.utter_message(text="User not found.")
+            return []
+
+        # Add the payee
+        success = db.add_payee(
+            int(user["id"]),
+            payee_name,
+            sort_code,
+            account_number,
+            payee_type,
+            reference,
+        )
+
+        if success:
+            dispatcher.utter_message(
+                text=f"Payee {payee_name} has been added successfully."
+            )
+            return [SlotSet("payee_added", True)]
+        else:
+            dispatcher.utter_message(text="Failed to add payee. Please try again.")
+            return [SlotSet("payee_added", False)]

rasa/cli/project_templates/finance/actions/transfers/action_ask_account_from.py

@@ -0,0 +1,51 @@
+from typing import Any, Dict, List, Text
+
+from rasa_sdk import Action, Tracker
+from rasa_sdk.executor import CollectingDispatcher
+
+from actions.database import Database
+
+
+class ActionAskAccountFrom(Action):
+    def name(self) -> Text:
+        return "action_ask_account_from"
+
+    def run(
+        self,
+        dispatcher: CollectingDispatcher,
+        tracker: Tracker,
+        domain: Dict[Text, Any],
+    ) -> List[Dict[Text, Any]]:
+        name = tracker.get_slot("name")
+
+        db = Database()
+
+        # Get user information
+        user = db.get_user_by_name(name)
+        if not user:
+            dispatcher.utter_message(text="User not found.")
+            return []
+
+        # Get all accounts for the user
+        user_id = int(user["id"])
+        accounts = db.get_accounts_by_user(user_id)
+        print(f"DEBUG: Accounts found: {accounts}")
+        if not accounts:
+            dispatcher.utter_message(text="No accounts found for this user.")
+            return []
+
+        buttons = [
+            {
+                "content_type": "text",
+                "title": (
+                    f"{account['type'].title()} (Balance: "
+                    f"${float(account['balance']):.2f})"
+                ),
+                "payload": str(account["number"]),
+            }
+            for account in accounts
+        ]
+        message = "Which account would you like to transfer money from?"
+        dispatcher.utter_message(text=message, buttons=buttons)
+
+        return []

rasa/cli/project_templates/finance/actions/transfers/action_check_payee_existence.py

@@ -0,0 +1,40 @@
+from typing import Any, Dict, List, Text
+
+from rasa_sdk import Action, Tracker
+from rasa_sdk.events import SlotSet
+from rasa_sdk.executor import CollectingDispatcher
+
+from actions.database import Database
+
+
+class ActionCheckPayeeExistence(Action):
+    def name(self) -> Text:
+        return "action_check_payee_existence"
+
+    def run(
+        self,
+        dispatcher: CollectingDispatcher,
+        tracker: Tracker,
+        domain: Dict[Text, Any],
+    ) -> List[Dict[Text, Any]]:
+        name = tracker.get_slot("name")
+        payee_name = tracker.get_slot("payee_name")
+
+        db = Database()
+
+        # Get user information
+        user = db.get_user_by_name(name)
+        if not user:
+            dispatcher.utter_message(text="User not found.")
+            return []
+
+        # Check if payee exists
+        payee = db.get_payee_by_name_and_user(payee_name, int(user["id"]))
+
+        if payee:
+            return [SlotSet("payee_exists", True)]
+
+        dispatcher.utter_message(
+            text=f"{payee_name} is not an authorised payee. Let's add them!"
+        )
+        return [SlotSet("payee_exists", False)]

rasa/cli/project_templates/finance/actions/transfers/action_check_sufficient_funds.py

@@ -0,0 +1,40 @@
+from typing import Any, Dict, List, Text
+
+from rasa_sdk import Action, Tracker
+from rasa_sdk.events import SlotSet
+from rasa_sdk.executor import CollectingDispatcher
+
+from actions.database import Database
+
+
+class ActionCheckSufficientFunds(Action):
+    def name(self) -> Text:
+        return "action_check_sufficient_funds"
+
+    def run(
+        self,
+        dispatcher: CollectingDispatcher,
+        tracker: Tracker,
+        domain: Dict[Text, Any],
+    ) -> List[Dict[Text, Any]]:
+        name = tracker.get_slot("name")
+        account_from = tracker.get_slot("account_from")
+        amount = float(tracker.get_slot("amount"))
+
+        db = Database()
+
+        # Get user information
+        user = db.get_user_by_name(name)
+        if not user:
+            dispatcher.utter_message(text="User not found.")
+            return []
+
+        # Check if user has sufficient funds
+        has_sufficient_funds = db.check_sufficient_funds(
+            int(user["id"]), account_from, amount
+        )
+
+        if has_sufficient_funds:
+            return [SlotSet("sufficient_funds", True)]
+        else:
+            return [SlotSet("sufficient_funds", False)]

rasa/cli/project_templates/finance/actions/transfers/action_list_payees.py

@@ -0,0 +1,46 @@
+from typing import Any, Dict, List, Text
+
+from rasa_sdk import Action, Tracker
+from rasa_sdk.executor import CollectingDispatcher
+
+from actions.database import Database
+
+
+class ActionListPayees(Action):
+    def name(self) -> Text:
+        return "action_list_payees"
+
+    def run(
+        self,
+        dispatcher: CollectingDispatcher,
+        tracker: Tracker,
+        domain: Dict[Text, Any],
+    ) -> List[Dict[Text, Any]]:
+        name = tracker.get_slot("name")
+
+        db = Database()
+
+        # Get user information
+        user = db.get_user_by_name(name)
+        if not user:
+            dispatcher.utter_message(text="User not found.")
+            return []
+
+        # Get payees for the user
+        user_id = int(user["id"])
+        payees = db.get_payees_by_user(user_id)
+
+        if not payees:
+            dispatcher.utter_message(text="You have no payees set up.")
+            return []
+
+        payee_names = [payee["name"] for payee in payees]
+        if len(payee_names) > 1:
+            payees_list = ", ".join(payee_names[:-1]) + " and " + payee_names[-1]
+        else:
+            payees_list = payee_names[0]
+
+        message = f"You are authorised to transfer money to: {payees_list}"
+        dispatcher.utter_message(text=message)
+
+        return []

rasa/cli/project_templates/finance/actions/transfers/action_process_immediate_payment.py

@@ -0,0 +1,18 @@
+from typing import Any, Dict, List, Text
+
+from rasa_sdk import Action, Tracker
+from rasa_sdk.events import SlotSet
+from rasa_sdk.executor import CollectingDispatcher
+
+
+class ActionProcessImmediatePayment(Action):
+    def name(self) -> Text:
+        return "action_process_immediate_payment"
+
+    def run(
+        self,
+        dispatcher: CollectingDispatcher,
+        tracker: Tracker,
+        domain: Dict[Text, Any],
+    ) -> List[Dict[Text, Any]]:
+        return [SlotSet("payment_processed", True)]

rasa/cli/project_templates/finance/actions/transfers/action_remove_payee.py

@@ -0,0 +1,49 @@
+from typing import Any, Dict, List, Text
+
+from rasa_sdk import Action, Tracker
+from rasa_sdk.events import SlotSet
+from rasa_sdk.executor import CollectingDispatcher
+
+from actions.database import Database
+
+
+class ActionRemovePayee(Action):
+    def name(self) -> Text:
+        return "action_remove_payee"
+
+    def run(
+        self,
+        dispatcher: CollectingDispatcher,
+        tracker: Tracker,
+        domain: Dict[Text, Any],
+    ) -> List[Dict[Text, Any]]:
+        name = tracker.get_slot("name")
+        payee_name = tracker.get_slot("payee_name")
+
+        db = Database()
+
+        # Get user information
+        user = db.get_user_by_name(name)
+        if not user:
+            dispatcher.utter_message(text="User not found.")
+            return []
+
+        # Check if payee exists
+        payee = db.get_payee_by_name_and_user(payee_name, int(user["id"]))
+        if not payee:
+            dispatcher.utter_message(
+                text=f"I'm sorry, but I couldn't find a payee named '{payee_name}'"
+            )
+            return [SlotSet("payee_removed", False)]
+
+        # Remove the payee
+        success = db.remove_payee(payee_name, int(user["id"]))
+
+        if success:
+            dispatcher.utter_message(
+                text=f"Payee {payee_name} has been removed successfully."
+            )
+            return [SlotSet("payee_removed", True)]
+        else:
+            dispatcher.utter_message(text="Failed to remove payee. Please try again.")
+            return [SlotSet("payee_removed", False)]

rasa/cli/project_templates/finance/actions/transfers/action_schedule_payment.py

@@ -0,0 +1,19 @@
+from typing import Any, Dict, List, Text
+
+from rasa_sdk import Action, Tracker
+from rasa_sdk.events import SlotSet
+from rasa_sdk.executor import CollectingDispatcher
+
+
+class ActionSchedulePayment(Action):
+    def name(self) -> Text:
+        return "action_schedule_payment"
+
+    def run(
+        self,
+        dispatcher: CollectingDispatcher,
+        tracker: Tracker,
+        domain: Dict[Text, Any],
+    ) -> List[Dict[Text, Any]]:
+        # TODO: Should this add the payment to a scheduled_payment table?
+        return [SlotSet("payment_scheduled", True)]

rasa/cli/project_templates/finance/actions/transfers/action_validate_payment_date.py

@@ -0,0 +1,36 @@
+from datetime import datetime
+from typing import Any, Dict, List, Text
+
+from rasa_sdk import Action, Tracker
+from rasa_sdk.events import SlotSet
+from rasa_sdk.executor import CollectingDispatcher
+
+
+class ActionValidatePaymentDate(Action):
+    def name(self) -> Text:
+        return "action_validate_payment_date"
+
+    def is_future_date(self, payment_date_str: str, current_date_str: str) -> bool:
+        current_date = datetime.strptime(current_date_str, "%d/%m/%Y").date()
+        payment_date = datetime.strptime(payment_date_str, "%d/%m/%Y").date()
+        return payment_date > current_date
+
+    def run(
+        self,
+        dispatcher: CollectingDispatcher,
+        tracker: Tracker,
+        domain: Dict[Text, Any],
+    ) -> List[Dict[Text, Any]]:
+        current_date = tracker.get_slot("current_date")
+        payment_date = tracker.get_slot("payment_date")
+
+        if self.is_future_date(payment_date, current_date):
+            return [
+                SlotSet("valid_payment_date", True),
+                SlotSet("future_payment_date", True),
+            ]
+        else:
+            return [
+                SlotSet("valid_payment_date", True),
+                SlotSet("future_payment_date", False),
+            ]

rasa/cli/project_templates/finance/config.yml

@@ -0,0 +1,23 @@
+recipe: default.v1
+language: en
+assistant_id: placeholder_default
+
+pipeline:
+- name: SearchReadyLLMCommandGenerator
+  llm:
+    model_group: openai-gpt-4o
+  flow_retrieval:
+    active: false
+
+
+policies:
+- name: FlowPolicy
+- name: EnterpriseSearchPolicy
+  vector_store:
+    type: "faiss"
+    source: "./docs"
+  llm:
+    model_group: openai-gpt-4o
+  embeddings:
+    model_group: openai-embeddings
+  check_relevancy: true