rasa-pro 3.14.0.dev20250901__py3-none-any.whl → 3.14.0rc1__py3-none-any.whl

rasa/builder/scrape_rasa_docs.py

@@ -1,97 +0,0 @@
-import json
-import os
-from pathlib import Path
-from urllib.parse import urljoin, urlparse
-
-import requests
-from bs4 import BeautifulSoup
-
-BASE_URL = "https://rasa.com"
-DOCS_ROOT = "https://rasa.com/docs"
-OUTPUT_DIR = "rasa_docs_md"
-MAX_PAGES = 100  # Optional limit for safety
-
-visited = set()
-to_visit = [DOCS_ROOT]
-
-os.makedirs(OUTPUT_DIR, exist_ok=True)
-
-
-def is_valid_doc_url(url: str) -> bool:
-    return url.startswith(DOCS_ROOT) and not any(
-        [url.endswith(".pdf"), "#" in url, "mailto:" in url]
-    )
-
-
-def slugify_url(url: str) -> str:
-    path = urlparse(url).path.strip("/").replace("/", "_")
-    return path if path else "index"
-
-
-def clean_text(html: str) -> str:
-    soup = BeautifulSoup(html, "html.parser")
-
-    # Remove navs, footers, and code tabs (customize if needed)
-    for tag in soup(["nav", "footer", "script", "style", "form", "button"]):
-        tag.decompose()
-
-    main = soup.find("main") or soup.body
-    if not main:
-        return ""
-
-    # Replace <code> with backticks
-    for code in main.find_all("code"):
-        code.string = f"`{code.get_text(strip=True)}`"
-
-    text = main.get_text(separator="\n", strip=True)
-    return text
-
-
-def save_as_markdown(text: str, url: str) -> str:
-    slug = slugify_url(url)
-    file_name = f"{slug}.md"
-    md_path = Path(OUTPUT_DIR) / file_name
-    with open(md_path, "w", encoding="utf-8") as f:
-        f.write(text)
-
-    print(f"✅ Saved: {md_path}")
-    return file_name
-
-
-pages_scraped = 0
-markdown_to_url = {}
-
-while to_visit and pages_scraped < MAX_PAGES:
-    url = to_visit.pop(0)
-    if url in visited:
-        continue
-
-    try:
-        print(f"Scraping: {url}")
-        response = requests.get(url)
-        response.raise_for_status()
-
-        html = response.text
-        text = clean_text(html)
-        if len(text) < 200:  # skip very short pages
-            print("⏭️ Skipped (too short)")
-            continue
-
-        file_name = save_as_markdown(text, url)
-        markdown_to_url[file_name] = url
-        pages_scraped += 1
-
-        soup = BeautifulSoup(html, "html.parser")
-        for link_tag in soup.find_all("a", href=True):
-            link = urljoin(url, link_tag["href"])
-            if is_valid_doc_url(link) and link not in visited:
-                to_visit.append(link)
-
-        visited.add(url)
-
-    except Exception as e:
-        print(f"⚠️ Failed to scrape {url}: {e}")
-
-
-with open("markdown_to_url.json", "w") as f:
-    json.dump(markdown_to_url, f, indent=2)

rasa/cli/project_templates/finance/actions/accounts/action_ask_account.py

@@ -1,47 +0,0 @@
-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 ActionAskAccount(Action):
-    def name(self) -> Text:
-        return "action_ask_account"
-
-    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)
-
-        if not accounts:
-            dispatcher.utter_message(text="No accounts found for this user.")
-            return []
-
-        buttons = [
-            {
-                "title": f"{account['number']} ({account['type'].title()})",
-                "payload": account["number"],
-            }
-            for account in accounts
-        ]
-        message = "Which account would you like the balance for?"
-        dispatcher.utter_message(text=message, buttons=buttons)
-
-        return []

rasa/cli/project_templates/finance/actions/accounts/action_check_balance.py

@@ -1,40 +0,0 @@
-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 ActionCheckBalance(Action):
-    def name(self) -> Text:
-        return "action_check_balance"
-
-    def run(
-        self,
-        dispatcher: CollectingDispatcher,
-        tracker: Tracker,
-        domain: Dict[Text, Any],
-    ) -> List[Dict[Text, Any]]:
-        name = tracker.get_slot("name")
-        account_number = tracker.get_slot("account")
-
-        db = Database()
-
-        # Get user information
-        user = db.get_user_by_name(name)
-        if not user:
-            dispatcher.utter_message(text="User not found.")
-            return []
-
-        # Get account information
-        account = db.get_account_by_user_and_number(int(user["id"]), account_number)
-        if not account:
-            dispatcher.utter_message(text="Account not found.")
-            return []
-
-        current_balance = float(account["balance"])
-
-        message = f"The balance on that account is: ${current_balance}"
-        dispatcher.utter_message(text=message)
-        return []

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

@@ -1,74 +0,0 @@
-from datetime import datetime
-from typing import Any, Dict, List, Text
-
-from rasa_sdk import Action, Tracker
-from rasa_sdk.events import ActionExecuted, SlotSet
-from rasa_sdk.executor import CollectingDispatcher
-
-from actions.database import Database
-
-
-class ActionSessionStart(Action):
-    def name(self) -> Text:
-        return "action_session_start"
-
-    def set_current_date(self) -> List[Dict[Text, Any]]:
-        current_date = datetime.now().strftime("%d/%m/%Y")
-        return [SlotSet("current_date", current_date)]
-
-    def set_user_profile(self, name: str) -> List[Dict[Text, Any]]:
-        db = Database()
-
-        # Get user information
-        user = db.get_user_by_name(name)
-
-        if user:
-            return [
-                SlotSet("name", user["name"]),
-                SlotSet("username", user["username"]),
-                SlotSet("segment", user["segment"]),
-                SlotSet("email_address", user["email"]),
-                SlotSet("physical_address", user["address"]),
-            ]
-        else:
-            return []
-
-    def run(
-        self,
-        dispatcher: CollectingDispatcher,
-        tracker: Tracker,
-        domain: Dict[Text, Any],
-    ) -> List[Dict[Text, Any]]:
-        current_date_events = self.set_current_date()
-
-        # Advanced option: It is possible to enable the chatbot with multiple
-        # user profiles.
-        # This option influences the interactions with the assistant.
-        # The bot randomly assigns a user profile at the start of each session.
-        # With this advance option: The demo bot will include three user profiles
-        # with different payees:
-        # John Smith: Payees: Robert (friend), James (son), Food Market (groceries)
-        # Mary Brown: Payees: Richard (business partner), Susan (friend),
-        # Electric Company (utilities)
-        # Dan Young: Payees: Amy (colleague), Fitness Gym (gym), William (friend)
-        #
-        # The default profile is John Smith
-        #
-        # Each profile also has its own accounts—Current (Checking), Savings,
-        # and Business
-        #
-        # Intructions: Just toggle the comments of the following 2 lines.
-        name = "John Smith"
-        # username = random.choice(["John Smith", "Mary Brown", "Dan Young"])
-
-        user_profile_events = self.set_user_profile(name)
-
-        events = (
-            current_date_events
-            + user_profile_events
-            + [
-                ActionExecuted("action_listen"),
-            ]
-        )
-
-        return events

rasa/cli/project_templates/finance/actions/cards/action_ask_card.py

@@ -1,48 +0,0 @@
-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 ActionAskCard(Action):
-    def name(self) -> Text:
-        return "action_ask_card"
-
-    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 cards for the user
-        user_id = int(user["id"])
-        cards = db.get_cards_by_user(user_id)
-
-        if not cards:
-            dispatcher.utter_message(text="No cards found for this user.")
-            return []
-
-        buttons = [
-            {
-                "content_type": "text",
-                "title": f"{i + 1}: x{card['number'][-4:]} ({card['type'].title()})",
-                "payload": f"/SetSlots(card_selection={card['number']!s})",
-            }
-            for i, card in enumerate(cards)
-        ]
-        message = "Select the card you require assistance with:"
-        dispatcher.utter_message(text=message, buttons=buttons)
-
-        return []

rasa/cli/project_templates/finance/actions/cards/action_check_card_existence.py

@@ -1,36 +0,0 @@
-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 ActionCheckCardExistence(Action):
-    def name(self) -> str:
-        return "action_check_card_existence"
-
-    def run(
-        self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[str, Any]
-    ) -> List[Dict[Text, Any]]:
-        name = tracker.get_slot("name")
-        card_number = tracker.get_slot("card_number")
-
-        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 cards for the user
-        user_id = int(user["id"])
-        cards = db.get_cards_by_user(user_id)
-        card_numbers = [card["number"] for card in cards]
-
-        if card_number in card_numbers:
-            return [SlotSet("card_found", True)]
-        else:
-            return [SlotSet("card_found", False)]

rasa/cli/project_templates/finance/actions/cards/action_update_card_status.py

@@ -1,54 +0,0 @@
-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 ActionUpdateCardStatus(Action):
-    def name(self) -> str:
-        return "action_update_card_status"
-
-    def run(
-        self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[str, Any]
-    ) -> List[Dict[Text, Any]]:
-        name = tracker.get_slot("name")
-        card_number = tracker.get_slot("card")
-        new_status = "inactive"
-
-        db = Database()
-
-        # Get user information
-        user = db.get_user_by_name(name)
-        if not user:
-            dispatcher.utter_message(text="User not found.")
-            return []
-
-        # Get card information to verify it belongs to the user
-        card = db.get_card_by_number(card_number)
-        if not card:
-            dispatcher.utter_message(text="I can't find the card within your account.")
-            return []
-
-        # Check if card belongs to the user
-        try:
-            if int(card["user_id"]) != int(user["id"]):
-                dispatcher.utter_message(
-                    text="That card is not associated with your account."
-                )
-                return []
-        except (ValueError, TypeError, KeyError):
-            dispatcher.utter_message(text="Error verifying card ownership.")
-            return []
-
-        # Update card status
-        success = db.update_card_status(card_number, new_status)
-
-        if success:
-            return [SlotSet("card_status", new_status)]
-        else:
-            # Log the error but don't show technical error to user
-            print(f"Error: Failed to update card status for card {card_number}")
-            return []

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

@@ -1,277 +0,0 @@
-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")