rasa-pro 3.9.18__py3-none-any.whl

rasa/cli/utils.py

@@ -0,0 +1,464 @@
+import json
+import argparse
+import structlog
+import importlib
+import os
+import sys
+import time
+from pathlib import Path
+from types import FrameType
+from typing import Any, Dict, List, Optional, TYPE_CHECKING, Text, Union, overload
+import randomname
+
+import rasa.shared.utils.cli
+import rasa.shared.utils.io
+from rasa.shared.importers.importer import TrainingDataImporter
+from rasa.shared.constants import (
+    ASSISTANT_ID_DEFAULT_VALUE,
+    ASSISTANT_ID_KEY,
+    DEFAULT_CONFIG_PATH,
+)
+from rasa import telemetry
+from rasa.shared.utils.yaml import read_config_file
+from rasa.utils.io import write_yaml
+
+if TYPE_CHECKING:
+    from questionary import Question
+    from typing_extensions import Literal
+    from rasa.validator import Validator
+
+structlogger = structlog.get_logger()
+
+FREE_TEXT_INPUT_PROMPT = "Type out your own message..."
+
+
+@overload
+def get_validated_path(
+    current: Optional[Union[Path, Text]],
+    parameter: Text,
+    default: Optional[Union[Path, Text, List[Text]]] = ...,
+    none_is_valid: "Literal[False]" = ...,
+) -> Union[Path, Text]: ...
+
+
+@overload
+def get_validated_path(
+    current: Optional[Union[Path, Text]],
+    parameter: Text,
+    default: Optional[Union[Path, Text, List[Text]]] = ...,
+    none_is_valid: "Literal[True]" = ...,
+) -> Optional[Union[Path, Text]]: ...
+
+
+def get_validated_path(
+    current: Optional[Union[Path, Text]],
+    parameter: Text,
+    default: Optional[Union[Path, Text, List[Text]]] = None,
+    none_is_valid: bool = False,
+) -> Optional[Union[Path, Text]]:
+    """Checks whether a file path or its default value is valid and returns it.
+
+    Args:
+        current: The parsed value.
+        parameter: The name of the parameter.
+        default: one or multiple default values of the parameter.
+        none_is_valid: `True` if `None` is valid value for the path,
+                        else `False``
+
+    Returns:
+        The current value if valid,
+        otherwise one of the default values of the argument if valid,
+        otherwise `None` if allowed,
+        otherwise raises an error and exits.
+    """
+    if current and os.path.exists(current):
+        return current
+
+    # try to find a valid option among the defaults
+    if isinstance(default, str) or isinstance(default, Path):
+        default_options = [str(default)]
+    elif isinstance(default, list):
+        default_options = default
+    else:
+        default_options = []
+
+    valid_options = (option for option in default_options if os.path.exists(option))
+    chosen_option = next(valid_options, None)
+
+    # warn and log if user-chosen parameter wasn't found and thus overwritten
+    if chosen_option:
+        shared_info = f"Using default location '{chosen_option}' instead."
+        if current is None:
+            structlogger.debug(
+                "cli.get_validated_path.parameter_not_set",
+                parameter=parameter,
+                event_info=(f"Parameter '{parameter}' was not set. {shared_info}"),
+            )
+        else:
+            structlogger.warn(
+                "cli.get_validated_path.path_does_not_exists",
+                path=current,
+                event_info=(
+                    f"The path '{current}' does not seem to exist. {shared_info}"
+                ),
+            )
+
+    if chosen_option is None and not none_is_valid:
+        cancel_cause_not_found(current, parameter, default)
+
+    return chosen_option
+
+
+def missing_config_keys(
+    path: Union["Path", Text], mandatory_keys: List[Text]
+) -> List[Text]:
+    """Checks whether the config file at `path` contains the `mandatory_keys`.
+
+    Args:
+        path: The path to the config file.
+        mandatory_keys: A list of mandatory config keys.
+
+    Returns:
+        The list of missing config keys.
+    """
+    if not os.path.exists(path):
+        return mandatory_keys
+
+    config_data = read_config_file(path)
+
+    return [k for k in mandatory_keys if k not in config_data or config_data[k] is None]
+
+
+def validate_assistant_id_in_config(config_file: Union["Path", Text]) -> None:
+    """Verifies that the assistant_id key exists and has a unique value in config.
+
+    Issues a warning if the key does not exist or has the default value and replaces it
+    with a pseudo-random string value.
+    """
+    config_data = read_config_file(config_file, reader_type=["safe", "rt"])
+    assistant_id = config_data.get(ASSISTANT_ID_KEY)
+
+    if assistant_id is None or assistant_id == ASSISTANT_ID_DEFAULT_VALUE:
+        structlogger.warn(
+            "cli.validate_assistant_id_in_config.missing_unique_assistant_id_key",
+            config=config_file,
+            missing_key=ASSISTANT_ID_KEY,
+            event_info=(
+                f"The config file '{config_file!s}' is "
+                f"missing a unique value for the "
+                f"'{ASSISTANT_ID_KEY}' mandatory key. "
+                f"Proceeding with generating a random "
+                f"value and overwriting the '{ASSISTANT_ID_KEY}'"
+                f" in the config file."
+            ),
+        )
+
+        # add random value for assistant id, overwrite config file
+        time_format = "%Y%m%d-%H%M%S"
+        config_data[ASSISTANT_ID_KEY] = (
+            f"{time.strftime(time_format)}-{randomname.get_name()}"
+        )
+
+        write_yaml(data=config_data, target=config_file, should_preserve_key_order=True)
+
+    return
+
+
+def validate_config_path(
+    config: Optional[Union[Text, "Path"]],
+    default_config: Text = DEFAULT_CONFIG_PATH,
+) -> Text:
+    """Verifies that the config path exists.
+
+    Exit if the config file does not exist.
+
+    Args:
+        config: Path to the config file.
+        default_config: default config to use if the file at `config` doesn't exist.
+
+    Returns: The path to the config file.
+    """
+    config = rasa.cli.utils.get_validated_path(config, "config", default_config)
+
+    if not config or not os.path.exists(config):
+        structlogger.error(
+            "cli.validate_config_path.does_not_exists",
+            config=config,
+            event_info=(
+                f"The config file '{config}' does not exist. "
+                f"Use '--config' to specify a valid config file."
+            ),
+        )
+        sys.exit(1)
+
+    return str(config)
+
+
+def validate_mandatory_config_keys(
+    config: Union[Text, "Path"],
+    mandatory_keys: List[Text],
+) -> Text:
+    """Get a config from a config file and check if it is valid.
+
+    Exit if the config isn't valid.
+
+    Args:
+        config: Path to the config file.
+        mandatory_keys: The keys that have to be specified in the config file.
+
+    Returns: The path to the config file if the config is valid.
+    """
+    missing_keys = set(rasa.cli.utils.missing_config_keys(config, mandatory_keys))
+    if missing_keys:
+        structlogger.error(
+            "cli.validate_mandatory_config_keys.missing_keys",
+            config=config,
+            missing_keys=missing_keys,
+            event_info=(
+                "The config file '{}' is missing mandatory parameters: "
+                "'{}'. Add missing parameters to config file and try again.".format(
+                    config, "', '".join(missing_keys)
+                )
+            ),
+        )
+        sys.exit(1)
+
+    return str(config)
+
+
+def get_validated_config(
+    config: Optional[Union[Text, "Path"]],
+    mandatory_keys: List[Text],
+    default_config: Text = DEFAULT_CONFIG_PATH,
+) -> Text:
+    """Validates config and returns path to validated config file."""
+    config = validate_config_path(config, default_config)
+    validate_assistant_id_in_config(config)
+
+    config = validate_mandatory_config_keys(config, mandatory_keys)
+
+    return config
+
+
+def validate_files(
+    fail_on_warnings: bool,
+    max_history: Optional[int],
+    importer: TrainingDataImporter,
+    stories_only: bool = False,
+    flows_only: bool = False,
+) -> None:
+    """Validates either the story structure or the entire project.
+
+    Args:
+        fail_on_warnings: `True` if the process should exit with a non-zero status
+        max_history: The max history to use when validating the story structure.
+        importer: The `TrainingDataImporter` to use to load the training data.
+        stories_only: If `True`, only the story structure is validated.
+        flows_only: If `True`, only the flows are validated.
+    """
+    from rasa.validator import Validator
+
+    validator = Validator.from_importer(importer)
+
+    if stories_only:
+        all_good = _validate_story_structure(validator, max_history, fail_on_warnings)
+    elif flows_only:
+        all_good = validator.verify_flows()
+    else:
+        if importer.get_domain().is_empty():
+            structlogger.error(
+                "cli.validate_files.empty_domain",
+                event_info="Encountered empty domain during validation.",
+            )
+            sys.exit(1)
+
+        valid_domain = _validate_domain(validator)
+        valid_nlu = _validate_nlu(validator, fail_on_warnings)
+        valid_stories = _validate_story_structure(
+            validator, max_history, fail_on_warnings
+        )
+        valid_flows = validator.verify_flows()
+        valid_CALM_slot_mappings = validator.validate_CALM_slot_mappings()
+
+        all_good = (
+            valid_domain
+            and valid_nlu
+            and valid_stories
+            and valid_flows
+            and valid_CALM_slot_mappings
+        )
+
+    validator.warn_if_config_mandatory_keys_are_not_set()
+
+    telemetry.track_validate_files(all_good)
+    if not all_good:
+        structlogger.error(
+            "cli.validate_files.project_validation_error",
+            event_info="Project validation completed with errors.",
+        )
+        sys.exit(1)
+
+
+def _validate_domain(validator: "Validator") -> bool:
+    valid_domain_validity = validator.verify_domain_validity()
+    valid_actions_in_stories_rules = validator.verify_actions_in_stories_rules()
+    valid_forms_in_stories_rules = validator.verify_forms_in_stories_rules()
+    valid_form_slots = validator.verify_form_slots()
+    valid_slot_mappings = validator.verify_slot_mappings()
+    valid_responses = validator.check_for_no_empty_paranthesis_in_responses()
+    valid_buttons = validator.validate_button_payloads()
+    return (
+        valid_domain_validity
+        and valid_actions_in_stories_rules
+        and valid_forms_in_stories_rules
+        and valid_form_slots
+        and valid_slot_mappings
+        and valid_responses
+        and valid_buttons
+    )
+
+
+def _validate_nlu(validator: "Validator", fail_on_warnings: bool) -> bool:
+    return validator.verify_nlu(not fail_on_warnings)
+
+
+def _validate_story_structure(
+    validator: "Validator", max_history: Optional[int], fail_on_warnings: bool
+) -> bool:
+    # Check if a valid setting for `max_history` was given
+    if isinstance(max_history, int) and max_history < 1:
+        raise argparse.ArgumentTypeError(
+            f"The value of `--max-history {max_history}` " f"is not a positive integer."
+        )
+
+    return validator.verify_story_structure(
+        not fail_on_warnings, max_history=max_history
+    )
+
+
+def cancel_cause_not_found(
+    current: Optional[Union["Path", Text]],
+    parameter: Text,
+    default: Optional[Union["Path", Text, List[Text]]],
+) -> None:
+    """Exits with an error because the given path was not valid.
+
+    Args:
+        current: The path given by the user.
+        parameter: The name of the parameter.
+        default: The default value of the parameter.
+
+    """
+    default_clause = ""
+    if default and isinstance(default, str):
+        default_clause = f"use the default location ('{default}') or"
+    elif default and isinstance(default, list):
+        default_clause = f"use one of the default locations ({', '.join(default)}) or"
+
+    structlogger.error(
+        "cli.path_does_not_exist",
+        path=current,
+        event_info=(
+            f"The path '{current}' does not exist. "
+            f"Please make sure to {default_clause} specify it "
+            f"with '--{parameter}'."
+        ),
+    )
+    sys.exit(1)
+
+
+def parse_last_positional_argument_as_model_path() -> None:
+    """Fixes the parsing of a potential positional model path argument."""
+    if (
+        len(sys.argv) >= 2
+        # support relevant commands ...
+        and sys.argv[1] in ["run", "shell", "interactive"]
+        # but avoid interpreting subparser commands as model paths
+        and sys.argv[1:] != ["run", "actions"]
+        and not sys.argv[-2].startswith("-")
+        and os.path.exists(sys.argv[-1])
+    ):
+        sys.argv.append(sys.argv[-1])
+        sys.argv[-2] = "--model"
+
+
+def button_to_string(button: Dict[Text, Any], idx: int = 0) -> Text:
+    """Create a string representation of a button."""
+    title = button.pop("title", "")
+
+    if "payload" in button:
+        payload = " ({})".format(button.pop("payload"))
+    else:
+        payload = ""
+
+    # if there are any additional attributes, we append them to the output
+    if button:
+        details = " - {}".format(json.dumps(button, sort_keys=True))
+    else:
+        details = ""
+
+    button_string = "{idx}: {title}{payload}{details}".format(
+        idx=idx + 1, title=title, payload=payload, details=details
+    )
+
+    return button_string
+
+
+def element_to_string(element: Dict[Text, Any], idx: int = 0) -> Text:
+    """Create a string representation of an element."""
+    title = element.pop("title", "")
+
+    element_string = "{idx}: {title} - {element}".format(
+        idx=idx + 1, title=title, element=json.dumps(element, sort_keys=True)
+    )
+
+    return element_string
+
+
+def button_choices_from_message_data(
+    message: Dict[Text, Any], allow_free_text_input: bool = True
+) -> List[Text]:
+    """Return list of choices to present to the user.
+
+    If allow_free_text_input is True, an additional option is added
+    at the end along with the response buttons that allows the user
+    to type in free text.
+    """
+    choices = [
+        button_to_string(button, idx)
+        for idx, button in enumerate(message.get("buttons"))
+    ]
+    if allow_free_text_input:
+        choices.append(FREE_TEXT_INPUT_PROMPT)
+    return choices
+
+
+async def payload_from_button_question(button_question: "Question") -> Text:
+    """Prompt user with a button question and returns the nlu payload."""
+    response = await button_question.ask_async()
+    if response != FREE_TEXT_INPUT_PROMPT:
+        # Extract intent slash command if it's a button
+        response = response[response.rfind("(") + 1 : response.rfind(")")]
+    return response
+
+
+def signal_handler(_: int, __: FrameType) -> None:
+    """Kills Rasa when OS signal is received."""
+    print("Goodbye 👋")
+    sys.exit(0)
+
+
+def warn_if_rasa_plus_package_installed() -> None:
+    """Issue a user warning in case the `rasa_plus` package is installed."""
+    rasa_plus_package = "rasa_plus"
+    if importlib.util.find_spec(rasa_plus_package) is not None:
+        rasa.shared.utils.io.raise_warning(
+            f"{rasa_plus_package} python package is no longer necessary "
+            f"for using Rasa Pro. Please uninstall it.",
+            UserWarning,
+        )
+
+
+def check_if_studio_command() -> bool:
+    """Checks if the command is a Rasa Studio command."""
+    return len(sys.argv) >= 2 and sys.argv[1] == "studio"

rasa/cli/visualize.py

@@ -0,0 +1,40 @@
+import argparse
+import os
+from typing import List
+
+from rasa.cli import SubParsersAction
+from rasa.cli.arguments import visualize as arguments
+from rasa.shared.constants import DEFAULT_DATA_PATH
+
+
+def add_subparser(
+    subparsers: SubParsersAction, parents: List[argparse.ArgumentParser]
+) -> None:
+    """Add all visualization parsers.
+
+    Args:
+        subparsers: subparser we are going to attach to
+        parents: Parent parsers, needed to ensure tree structure in argparse
+    """
+    visualize_parser = subparsers.add_parser(
+        "visualize",
+        parents=parents,
+        conflict_handler="resolve",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help="Visualize stories.",
+    )
+    visualize_parser.set_defaults(func=visualize_stories)
+
+    arguments.set_visualize_stories_arguments(visualize_parser)
+
+
+def visualize_stories(args: argparse.Namespace) -> None:
+    import rasa.core.visualize
+
+    args.stories = rasa.shared.data.get_core_directory(args.stories)
+    if args.nlu is None and os.path.exists(DEFAULT_DATA_PATH):
+        args.nlu = rasa.shared.data.get_nlu_directory(DEFAULT_DATA_PATH)
+
+    rasa.core.visualize.visualize(
+        args.domain, args.stories, args.nlu, args.out, args.max_history
+    )

rasa/cli/x.py

@@ -0,0 +1,206 @@
+import argparse
+import asyncio
+import logging
+from pathlib import Path
+import signal
+from typing import Iterable, List, Optional, Text, Tuple, Union
+
+import aiohttp
+import ruamel.yaml as yaml
+
+from rasa.cli import SubParsersAction
+from rasa.cli.arguments import x as arguments
+import rasa.cli.utils
+from rasa.shared.constants import (
+    DEFAULT_CREDENTIALS_PATH,
+    DEFAULT_ENDPOINTS_PATH,
+)
+from rasa.core.utils import AvailableEndpoints
+import rasa.shared.utils.cli
+import rasa.shared.utils.io
+import rasa.utils.common
+import rasa.utils.io
+from rasa.shared.utils.yaml import read_config_file
+
+logger = logging.getLogger(__name__)
+
+
+def add_subparser(
+    subparsers: SubParsersAction, parents: List[argparse.ArgumentParser]
+) -> None:
+    """Add all rasa x parsers.
+
+    Args:
+        subparsers: subparser we are going to attach to
+        parents: Parent parsers, needed to ensure tree structure in argparse
+    """
+    x_parser_args = {
+        "parents": parents,
+        "conflict_handler": "resolve",
+        "formatter_class": argparse.ArgumentDefaultsHelpFormatter,
+    }
+
+    x_parser_args["help"] = (
+        "Run a Rasa server in a mode that enables connecting "
+        "to Rasa Enterprise as the config endpoint."
+    )
+
+    shell_parser = subparsers.add_parser("x", **x_parser_args)
+    shell_parser.set_defaults(func=rasa_x)
+
+    arguments.set_x_arguments(shell_parser)
+
+
+def _rasa_service(
+    args: argparse.Namespace,
+    endpoints: AvailableEndpoints,
+    rasa_x_url: Optional[Text] = None,
+    credentials_path: Optional[Text] = None,
+) -> None:
+    """Starts the Rasa application."""
+    from rasa.core.run import serve_application
+
+    # needs separate logging configuration as it is started in its own process
+    rasa.utils.common.configure_logging_and_warnings(args.loglevel)
+    rasa.utils.io.configure_colored_logging(args.loglevel)
+
+    if not credentials_path:
+        credentials_path = _prepare_credentials_for_rasa_x(
+            args.credentials, rasa_x_url=rasa_x_url
+        )
+
+    serve_application(
+        endpoints=endpoints,
+        port=args.port,
+        credentials=credentials_path,
+        cors=args.cors,
+        auth_token=args.auth_token,
+        enable_api=True,
+        jwt_secret=args.jwt_secret,
+        jwt_method=args.jwt_method,
+        ssl_certificate=args.ssl_certificate,
+        ssl_keyfile=args.ssl_keyfile,
+        ssl_ca_file=args.ssl_ca_file,
+        ssl_password=args.ssl_password,
+    )
+
+
+def _prepare_credentials_for_rasa_x(
+    credentials_path: Optional[Text], rasa_x_url: Optional[Text] = None
+) -> Text:
+    if credentials_path:
+        credentials_path = str(
+            rasa.cli.utils.get_validated_path(
+                credentials_path, "credentials", DEFAULT_CREDENTIALS_PATH, True
+            )
+        )
+        credentials = read_config_file(credentials_path)
+    else:
+        credentials = {}
+
+    # this makes sure the Rasa X is properly configured no matter what
+    if rasa_x_url:
+        credentials["rasa"] = {"url": rasa_x_url}
+    dumped_credentials = yaml.dump(credentials, default_flow_style=False)
+    tmp_credentials = rasa.utils.io.create_temporary_file(dumped_credentials, "yml")
+
+    return tmp_credentials
+
+
+def rasa_x(args: argparse.Namespace) -> None:
+    """Run Rasa with the `x` subcommand."""
+    from rasa.cli.utils import signal_handler
+
+    signal.signal(signal.SIGINT, signal_handler)
+
+    if args.production:
+        run_in_enterprise_connection_mode(args)
+    else:
+        rasa.shared.utils.io.raise_warning(
+            "Running Rasa X in local mode is no longer supported as Rasa has "
+            "stopped supporting the Community Edition (free version) of ‘Rasa X’."
+            "For more information please see "
+            "https://rasa.com/blog/rasa-x-community-edition-changes/",
+            UserWarning,
+        )
+        exit()
+
+
+async def _pull_runtime_config_from_server(
+    config_endpoint: Optional[Text],
+    attempts: int = 60,
+    wait_time_between_pulls: float = 5,
+    keys: Iterable[Text] = ("endpoints", "credentials"),
+) -> List[Text]:
+    """Pull runtime config from `config_endpoint`.
+
+    Returns a list of paths to yaml dumps, each containing the contents of one of
+    `keys`.
+    """
+    while attempts:
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(config_endpoint) as resp:
+                    if resp.status == 200:
+                        rjs = await resp.json()
+                        try:
+                            return [
+                                rasa.utils.io.create_temporary_file(rjs[k])
+                                for k in keys
+                            ]
+                        except KeyError as e:
+                            rasa.shared.utils.cli.print_error_and_exit(
+                                "Failed to find key '{}' in runtime config. "
+                                "Exiting.".format(e)
+                            )
+                    else:
+                        logger.debug(
+                            "Failed to get a proper response from remote "
+                            "server. Status Code: {}. Response: '{}'"
+                            "".format(resp.status, await resp.text())
+                        )
+        except aiohttp.ClientError as e:
+            logger.debug(f"Failed to connect to server. Retrying. {e}")
+
+        await asyncio.sleep(wait_time_between_pulls)
+        attempts -= 1
+
+    rasa.shared.utils.cli.print_error_and_exit(
+        "Could not fetch runtime config from server at '{}'. Exiting.".format(
+            config_endpoint
+        )
+    )
+
+
+def run_in_enterprise_connection_mode(args: argparse.Namespace) -> None:
+    """Run Rasa in a mode that enables using Rasa X as the config endpoint."""
+    from rasa.shared.utils.cli import print_success
+
+    print_success("Starting a Rasa server in Rasa Enterprise connection mode... 🚀")
+
+    credentials_path, endpoints_path = _get_credentials_and_endpoints_paths(args)
+    endpoints = AvailableEndpoints.read_endpoints(endpoints_path)
+
+    _rasa_service(args, endpoints, None, credentials_path)
+
+
+def _get_credentials_and_endpoints_paths(
+    args: argparse.Namespace,
+) -> Tuple[Optional[Text], Optional[Text]]:
+    config_endpoint = args.config_endpoint
+    endpoints_config_path: Optional[Union[Path, Text]]
+
+    if config_endpoint:
+        endpoints_config_path, credentials_path = asyncio.run(
+            _pull_runtime_config_from_server(config_endpoint)
+        )
+    else:
+        endpoints_config_path = rasa.cli.utils.get_validated_path(
+            args.endpoints, "endpoints", DEFAULT_ENDPOINTS_PATH, True
+        )
+        credentials_path = None
+
+    return (
+        credentials_path,
+        str(endpoints_config_path) if endpoints_config_path else None,
+    )