rasa-pro 3.9.18__py3-none-any.whl

rasa/cli/run.py

@@ -0,0 +1,135 @@
+import argparse
+import logging
+import os
+from typing import List, Text
+
+from rasa.cli import SubParsersAction
+from rasa.cli.arguments import run as arguments
+from rasa.shared.constants import (
+    DOCS_BASE_URL,
+    DEFAULT_ENDPOINTS_PATH,
+    DEFAULT_CREDENTIALS_PATH,
+    DEFAULT_ACTIONS_PATH,
+    DEFAULT_MODELS_PATH,
+)
+from rasa.exceptions import ModelNotFound
+
+logger = logging.getLogger(__name__)
+
+
+def add_subparser(
+    subparsers: SubParsersAction, parents: List[argparse.ArgumentParser]
+) -> None:
+    """Add all run parsers.
+
+    Args:
+        subparsers: subparser we are going to attach to
+        parents: Parent parsers, needed to ensure tree structure in argparse
+    """
+    run_parser = subparsers.add_parser(
+        "run",
+        parents=parents,
+        conflict_handler="resolve",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help="Starts a Rasa server with your trained model.",
+    )
+    run_parser.set_defaults(func=run)
+
+    run_subparsers = run_parser.add_subparsers()
+    sdk_subparser = run_subparsers.add_parser(
+        "actions",
+        parents=parents,
+        conflict_handler="resolve",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help="Runs the action server.",
+    )
+    sdk_subparser.set_defaults(func=run_actions)
+
+    arguments.set_run_arguments(run_parser)
+    arguments.set_run_action_arguments(sdk_subparser)
+
+
+def run_actions(args: argparse.Namespace) -> None:
+    import rasa_sdk.__main__ as sdk
+
+    args.actions = args.actions or DEFAULT_ACTIONS_PATH
+
+    sdk.main_from_args(args)
+
+
+def _validate_model_path(model_path: Text, parameter: Text, default: Text) -> Text:
+    if model_path is not None and not os.path.exists(model_path):
+        reason_str = f"'{model_path}' not found."
+        if model_path is None:
+            reason_str = f"Parameter '{parameter}' not set."
+
+        logger.debug(f"{reason_str} Using default location '{default}' instead.")
+
+        os.makedirs(default, exist_ok=True)
+        model_path = default
+
+    return model_path
+
+
+def run(args: argparse.Namespace) -> None:
+    """Entrypoint for `rasa run`.
+
+    Args:
+        args: The CLI arguments.
+    """
+    import rasa
+
+    args.endpoints = rasa.cli.utils.get_validated_path(
+        args.endpoints, "endpoints", DEFAULT_ENDPOINTS_PATH, True
+    )
+    args.credentials = rasa.cli.utils.get_validated_path(
+        args.credentials, "credentials", DEFAULT_CREDENTIALS_PATH, True
+    )
+
+    if args.enable_api:
+        if not args.remote_storage:
+            args.model = _validate_model_path(args.model, "model", DEFAULT_MODELS_PATH)
+        rasa.run(**vars(args))
+        return
+
+    # if the API is not enable you cannot start without a model
+    # make sure either a model server, a remote storage, or a local model is
+    # configured
+
+    import rasa.model
+    from rasa.core.utils import AvailableEndpoints
+
+    # start server if remote storage is configured
+    if args.remote_storage is not None:
+        rasa.run(**vars(args))
+        return
+
+    # start server if model server is configured
+    endpoints = AvailableEndpoints.read_endpoints(args.endpoints)
+    model_server = endpoints.model if endpoints and endpoints.model else None
+    if model_server is not None:
+        rasa.run(**vars(args))
+        return
+
+    # start server if local model found
+    args.model = _validate_model_path(args.model, "model", DEFAULT_MODELS_PATH)
+    local_model_set = True
+    try:
+        rasa.model.get_local_model(args.model)
+    except ModelNotFound:
+        local_model_set = False
+
+    if local_model_set:
+        rasa.run(**vars(args))
+        return
+
+    rasa.shared.utils.cli.print_error(
+        f"No model found. You have three options to provide a model:\n"
+        f"1. Configure a model server in the endpoint configuration and provide "
+        f"the configuration via '--endpoints'.\n"
+        f"2. Specify a remote storage via '--remote-storage' to load the model "
+        f"from.\n"
+        f"3. Train a model before running the server using `rasa train` and "
+        f"use '--model' to provide the model path.\n"
+        f"For more information check {DOCS_BASE_URL}/model-storage."
+    )

rasa/cli/scaffold.py

@@ -0,0 +1,269 @@
+import argparse
+from collections import defaultdict
+from enum import Enum
+import os
+import sys
+from typing import List, Text
+
+from rasa import telemetry
+from rasa.cli import SubParsersAction
+from rasa.cli.inspect import inspect
+from rasa.shared.utils.cli import print_success, print_error_and_exit
+from rasa.shared.constants import (
+    DOCS_BASE_URL,
+    DEFAULT_CONFIG_PATH,
+    DEFAULT_DOMAIN_PATH,
+    DEFAULT_DATA_PATH,
+    DEFAULT_MODELS_PATH,
+)
+
+
+class ProjectTemplateName(Enum):
+    """Enum of the different project templates."""
+
+    DEFAULT = "default"
+    TUTORIAL = "tutorial"
+    CALM = "calm"
+
+    def __str__(self) -> str:
+        return self.value
+
+
+template_domain_path = defaultdict(lambda: DEFAULT_DOMAIN_PATH)
+template_domain_path[ProjectTemplateName.CALM] = "domain"
+
+
+def add_subparser(
+    subparsers: SubParsersAction, parents: List[argparse.ArgumentParser]
+) -> None:
+    """Add all init parsers.
+
+    Args:
+        subparsers: subparser we are going to attach to
+        parents: Parent parsers, needed to ensure tree structure in argparse
+    """
+    scaffold_parser = subparsers.add_parser(
+        "init",
+        parents=parents,
+        help="Creates a new project, with example training data, "
+        "actions, and config files.",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    scaffold_parser.add_argument(
+        "--no-prompt",
+        action="store_true",
+        help="Automatically choose default options for prompts and suppress warnings.",
+    )
+    scaffold_parser.add_argument(
+        "--init-dir",
+        default=None,
+        help="Directory where your project should be initialized.",
+    )
+    scaffold_parser.add_argument(
+        "--template",
+        type=ProjectTemplateName,
+        choices=list(ProjectTemplateName),
+        default=ProjectTemplateName.DEFAULT,
+        help="Select the template to use for the project.",
+    )
+    scaffold_parser.set_defaults(func=run)
+
+
+def print_train_or_instructions(args: argparse.Namespace) -> None:
+    """Train a model if the user wants to."""
+    import questionary
+    import rasa
+
+    print_success("Finished creating project structure.")
+
+    should_train = (
+        questionary.confirm("Do you want to train an initial model? 💪🏽")
+        .skip_if(args.no_prompt, default=True)
+        .ask()
+    )
+
+    if should_train:
+        print_success("Training an initial model...")
+        training_result = rasa.train(
+            template_domain_path[args.template],
+            DEFAULT_CONFIG_PATH,
+            DEFAULT_DATA_PATH,
+            DEFAULT_MODELS_PATH,
+        )
+        args.model = training_result.model
+
+        print_run_or_instructions(args)
+
+    else:
+        print_success(
+            "No problem 👍🏼. You can also train a model later by going "
+            "to the project directory and running 'rasa train'."
+        )
+
+
+def print_run_or_instructions(args: argparse.Namespace) -> None:
+    from rasa.core import constants
+    import questionary
+
+    should_run = (
+        questionary.confirm("Do you want to speak to the trained assistant? 🤖")
+        .skip_if(args.no_prompt, default=False)
+        .ask()
+    )
+
+    if should_run:
+        # provide defaults for command line arguments
+        attributes = [
+            "endpoints",
+            "credentials",
+            "cors",
+            "auth_token",
+            "jwt_secret",
+            "jwt_method",
+            "enable_api",
+            "remote_storage",
+        ]
+        for a in attributes:
+            setattr(args, a, None)
+
+        args.port = constants.DEFAULT_SERVER_PORT
+
+        inspect(args)
+    else:
+        if args.no_prompt:
+            print(
+                "If you want to speak to the assistant, "
+                "run 'rasa shell' at any time inside "
+                "the project directory."
+            )
+        else:
+            print_success(
+                "Ok 👍🏼. "
+                "If you want to speak to the assistant, "
+                "run 'rasa shell' at any time inside "
+                "the project directory."
+            )
+
+
+def init_project(args: argparse.Namespace, path: Text) -> None:
+    """Inits project."""
+    os.chdir(path)
+    create_initial_project(".", args.template)
+    print(f"Created project directory at '{os.getcwd()}'.")
+    print_train_or_instructions(args)
+
+
+def create_initial_project(
+    path: Text, template: ProjectTemplateName = ProjectTemplateName.DEFAULT
+) -> None:
+    """Creates directory structure and templates for initial project."""
+    from distutils.dir_util import copy_tree
+
+    copy_tree(scaffold_path(template), path)
+
+
+def scaffold_path(template: ProjectTemplateName) -> Text:
+    import importlib_resources
+    import rasa.cli.project_templates
+
+    template_module = rasa.cli.project_templates.__name__
+    return str(importlib_resources.files(template_module).joinpath(template.value))
+
+
+def print_cancel() -> None:
+    print_success("Ok. You can continue setting up by running 'rasa init' 🙋🏽‍♀️")
+    sys.exit(0)
+
+
+def _ask_create_path(path: Text) -> None:
+    import questionary
+
+    should_create = questionary.confirm(
+        f"Path '{path}' does not exist 🧐. Create path?"
+    ).ask()
+
+    if should_create:
+        try:
+            os.makedirs(path)
+        except (PermissionError, OSError, FileExistsError) as e:
+            print_error_and_exit(
+                f"Failed to create project path at '{path}'. " f"Error: {e}"
+            )
+    else:
+        print_success(
+            "Ok, will exit for now. You can continue setting up by "
+            "running 'rasa init' again 🙋🏽‍♀️"
+        )
+        sys.exit(0)
+
+
+def _ask_overwrite(path: Text) -> None:
+    import questionary
+
+    overwrite = questionary.confirm(
+        "Directory '{}' is not empty. Continue?".format(os.path.abspath(path))
+    ).ask()
+    if not overwrite:
+        print_cancel()
+
+
+def run(args: argparse.Namespace) -> None:
+    import questionary
+
+    print_success("Welcome to Rasa! 🤖\n")
+    print(
+        "By installing and using this software, you agree to be bound by the terms "
+        "and conditions of the Developer Terms available at "
+        "https://rasa.com/developer-terms. "
+        "Please review the Developer Terms carefully before proceeding.\n"
+    )
+    if args.no_prompt:
+        print(
+            f"To get started quickly, an "
+            f"initial project will be created.\n"
+            f"If you need some help, check out "
+            f"the documentation at {DOCS_BASE_URL}.\n"
+        )
+    else:
+        print(
+            f"To get started quickly, an "
+            f"initial project will be created.\n"
+            f"If you need some help, check out "
+            f"the documentation at {DOCS_BASE_URL}.\n"
+            f"Now let's start! 👇🏽\n"
+        )
+
+    if args.init_dir is not None:
+        path = args.init_dir
+    else:
+        path = (
+            questionary.text(
+                "Please enter a path where the project will be "
+                "created [default: current directory]"
+            )
+            .skip_if(args.no_prompt, default="")
+            .ask()
+        )
+        # set the default directory. we can't use the `default` property
+        # in questionary as we want to avoid showing the "." in the prompt as the
+        # initial value. users tend to overlook it and it leads to invalid
+        # paths like: ".C:\mydir".
+        # Can't use `if not path` either, as `None` will be handled differently (abort)
+        if path == "":
+            path = "."
+
+    if args.no_prompt and not os.path.isdir(path):
+        print_error_and_exit(f"Project init path '{path}' not found.")
+
+    if path and not os.path.isdir(path):
+        _ask_create_path(path)
+
+    if path is None or not os.path.isdir(path):
+        print_cancel()
+
+    if not args.no_prompt and len(os.listdir(path)) > 0:
+        _ask_overwrite(path)
+
+    telemetry.track_project_init(path)
+
+    init_project(args, path)

rasa/cli/shell.py

@@ -0,0 +1,141 @@
+import argparse
+import logging
+import uuid
+
+from typing import List
+
+from rasa import telemetry
+from rasa.cli import SubParsersAction
+from rasa.cli.arguments import shell as arguments
+from rasa.engine.storage.local_model_storage import LocalModelStorage
+from rasa.model import get_local_model
+from rasa.shared.constants import ASSISTANT_ID_KEY
+from rasa.shared.data import TrainingType
+from rasa.shared.utils.cli import print_error
+from rasa.exceptions import ModelNotFound
+
+logger = logging.getLogger(__name__)
+
+
+def add_subparser(
+    subparsers: SubParsersAction, parents: List[argparse.ArgumentParser]
+) -> None:
+    """Add all shell parsers.
+
+    Args:
+        subparsers: subparser we are going to attach to
+        parents: Parent parsers, needed to ensure tree structure in argparse
+    """
+    shell_parser = subparsers.add_parser(
+        "shell",
+        parents=parents,
+        conflict_handler="resolve",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help=(
+            "Loads your trained model and lets you talk to your "
+            "assistant on the command line."
+        ),
+    )
+    shell_parser.set_defaults(func=shell)
+
+    shell_parser.add_argument(
+        "--conversation-id",
+        default=uuid.uuid4().hex,
+        required=False,
+        help="Set the conversation ID.",
+    )
+
+    run_subparsers = shell_parser.add_subparsers()
+
+    shell_nlu_subparser = run_subparsers.add_parser(
+        "nlu",
+        parents=parents,
+        conflict_handler="resolve",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help="Interprets messages on the command line using your NLU model.",
+    )
+
+    shell_nlu_subparser.set_defaults(func=shell_nlu)
+
+    arguments.set_shell_arguments(shell_parser)
+    arguments.set_shell_nlu_arguments(shell_nlu_subparser)
+
+
+def shell_nlu(args: argparse.Namespace) -> None:
+    """Talk with an NLU only bot though the command line."""
+    from rasa.cli.utils import get_validated_path
+    from rasa.shared.constants import DEFAULT_MODELS_PATH
+    import rasa.nlu.run
+
+    args.connector = "cmdline"
+
+    model_path = get_validated_path(args.model, "model", DEFAULT_MODELS_PATH)
+
+    try:
+        model = get_local_model(model_path)
+    except ModelNotFound:
+        print_error(
+            "No model found. Train a model before running the "
+            "server using `rasa train nlu`."
+        )
+        return
+
+    metadata = LocalModelStorage.metadata_from_archive(model)
+
+    if metadata.assistant_id is None:
+        print_error(
+            f"The model metadata does not contain a value for the '{ASSISTANT_ID_KEY}' "
+            f"attribute. Check that 'config.yml' file contains a value for "
+            f"the '{ASSISTANT_ID_KEY}' key and re-train the model.",
+        )
+
+    if metadata.training_type == TrainingType.CORE:
+        print_error(
+            "No NLU model found. Train a model before running the "
+            "server using `rasa train nlu`."
+        )
+        return
+
+    telemetry.track_shell_started("nlu")
+    rasa.nlu.run.run_cmdline(model)
+
+
+def shell(args: argparse.Namespace) -> None:
+    """Talk with a bot though the command line."""
+    from rasa.cli.utils import get_validated_path
+    from rasa.shared.constants import DEFAULT_MODELS_PATH
+
+    args.connector = "cmdline"
+
+    model = get_validated_path(args.model, "model", DEFAULT_MODELS_PATH)
+
+    try:
+        model = get_local_model(model)
+    except ModelNotFound:
+        print_error(
+            "No model found. Train a model before running the "
+            "server using `rasa train`."
+        )
+        return
+
+    metadata = LocalModelStorage.metadata_from_archive(model)
+
+    if metadata.assistant_id is None:
+        print_error(
+            f"The model metadata does not contain a value for the '{ASSISTANT_ID_KEY}' "
+            f"attribute. Check that 'config.yml' file contains a value for "
+            f"the '{ASSISTANT_ID_KEY}' key and re-train the model.",
+        )
+
+    if metadata.training_type == TrainingType.NLU:
+        import rasa.nlu.run
+
+        telemetry.track_shell_started("nlu")
+
+        rasa.nlu.run.run_cmdline(model)
+    else:
+        import rasa.cli.run
+
+        telemetry.track_shell_started("rasa")
+
+        rasa.cli.run.run(args)

rasa/cli/studio/download.py

@@ -0,0 +1,62 @@
+import argparse
+from typing import List
+
+from rasa.cli import SubParsersAction
+from rasa.cli.arguments.default_arguments import (
+    add_config_param,
+    add_endpoint_param,
+)
+from rasa.cli.arguments.train import add_data_param, add_domain_param
+from rasa.shared.constants import DEFAULT_ENDPOINTS_PATH, DEFAULT_CONFIG_PATH
+
+from rasa.studio.download import handle_download
+
+
+def add_subparser(
+    subparsers: SubParsersAction, parents: List[argparse.ArgumentParser]
+) -> None:
+    """Add the studio download parser.
+
+    Args:
+        subparsers: subparser we are going to attach to
+        parents: Parent parsers, needed to ensure tree structure in argparse
+    """
+    download_parser = subparsers.add_parser(
+        "download",
+        parents=parents,
+        conflict_handler="resolve",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help=(
+            "Download data from Rasa Studio including "
+            "flows and NLU data depending on the assistant type."
+        ),
+    )
+
+    download_parser.set_defaults(func=handle_download)
+    set_studio_download_arguments(download_parser)
+
+
+def set_studio_download_arguments(parser: argparse.ArgumentParser) -> None:
+    """Add arguments for running `rasa studio download`."""
+    add_domain_param(parser)
+    add_data_param(parser)
+    add_config_param(parser, default=DEFAULT_CONFIG_PATH)
+    add_endpoint_param(
+        parser,
+        "Configuration file for the model endpoints.",
+        default=DEFAULT_ENDPOINTS_PATH,
+    )
+
+    parser.add_argument(
+        "assistant_name",
+        default=None,
+        nargs=1,
+        type=str,
+        help="Name of the assistant on Rasa Studio",
+    )
+
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Overwrite local data with data from Rasa Studio",
+    )