rasa-pro 3.9.18__py3-none-any.whl

rasa/cli/studio/studio.py

@@ -0,0 +1,266 @@
+import argparse
+from typing import List, Optional
+from urllib.parse import ParseResult, urlparse
+
+import questionary
+from rasa.cli import SubParsersAction
+
+import rasa.cli.studio.download
+import rasa.cli.studio.train
+import rasa.cli.studio.upload
+from rasa.studio.auth import StudioAuth
+from rasa.studio.config import StudioConfig
+
+
+DEFAULT_REALM_NAME = "rasa-studio"
+
+DEFAULT_CLIENT_ID = "admin-cli"
+
+
+def add_subparser(
+    subparsers: SubParsersAction, parents: List[argparse.ArgumentParser]
+) -> None:
+    studio_parser = subparsers.add_parser(
+        "studio",
+        parents=parents,
+        conflict_handler="resolve",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help="Rasa Studio commands.",
+    )
+    studio_subparsers = studio_parser.add_subparsers()
+
+    rasa.cli.studio.train.add_subparser(studio_subparsers, parents)
+    rasa.cli.studio.upload.add_subparser(studio_subparsers, parents)
+    rasa.cli.studio.download.add_subparser(studio_subparsers, parents)
+
+    _add_config_subparser(studio_subparsers, parents)
+    _add_login_subparser(studio_subparsers, parents)
+
+
+def _add_config_subparser(
+    studio_sub_parsers: SubParsersAction, parents: List[argparse.ArgumentParser]
+) -> None:
+    studio_config_parser = studio_sub_parsers.add_parser(
+        "config",
+        parents=parents,
+        conflict_handler="resolve",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help="Configure communication parameters for Rasa Studio",
+    )
+
+    studio_config_parser.set_defaults(func=create_and_store_studio_config)
+
+    # add advanced configuration flag to trigger
+    # advanced configuration setup for authentication settings
+    studio_config_parser.add_argument(
+        "--advanced",
+        action="store_true",
+        default=False,
+        help="Configure additional authentication parameters for Rasa Studio",
+    )
+
+
+def _add_login_subparser(
+    studio_sub_parsers: SubParsersAction, parents: List[argparse.ArgumentParser]
+) -> None:
+    login_parser = studio_sub_parsers.add_parser(
+        "login",
+        parents=parents,
+        conflict_handler="resolve",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help="Login to Rasa Studio",
+    )
+    login_parser.set_defaults(func=_studio_login)
+
+    login_parser.add_argument(
+        "--username",
+        type=str,
+        help="Username for Rasa Studio",
+    )
+
+    login_parser.add_argument(
+        "--password",
+        type=str,
+        help="Password for Rasa Studio",
+    )
+
+
+def _studio_login(args: argparse.Namespace) -> None:
+    """Login to Rasa Studio.
+
+    Args:
+        args: Commandline arguments
+    """
+    studio_config = StudioConfig.read_config()
+    studio_auth = StudioAuth(studio_config)
+
+    # show the user the studio url they are logging into
+    # urlparse will always return parseresult if a string is passed in as url
+    parsed_url: ParseResult = urlparse(studio_config.studio_url)  # type: ignore[assignment]
+    studio_url = f"{parsed_url.scheme}://{parsed_url.netloc}"
+
+    rasa.shared.utils.cli.print_info(
+        f"Trying to log in to Rasa Studio at {studio_url} ..."
+    )
+
+    try:
+        username = args.username
+        password = args.password
+
+        if not username:
+            username = questionary.text("Please enter your username").unsafe_ask()
+
+        if not password:
+            password = questionary.password("Please enter your password").unsafe_ask()
+
+        studio_auth.login(username, password)
+    except KeyboardInterrupt:
+        rasa.shared.utils.cli.print_error("Login to Rasa Studio aborted.")
+    except Exception as e:
+        rasa.shared.utils.cli.print_error(f"Failed to login to Rasa Studio. {e}")
+
+
+def _configure_studio_url() -> Optional[str]:
+    """Configure the Rasa Studio URL.
+
+    Returns:
+        The configured Rasa Studio URL
+    """
+    studio_url = questionary.text(
+        "Please provide the Rasa Studio URL",
+    ).unsafe_ask()
+
+    if not studio_url.endswith("/"):
+        studio_url += "/"
+
+    # prepend with https if no protocol is provided
+    if not studio_url.startswith("http"):
+        return "https://" + studio_url
+    return studio_url
+
+
+def _get_advanced_config(studio_url: str) -> tuple:
+    """Get the advanced configuration values for Rasa Studio."""
+    keycloak_url = questionary.text(
+        "Please provide your Rasa Studio Keycloak URL",
+        default=studio_url + "auth/",
+    ).unsafe_ask()
+
+    realm_name = questionary.text(
+        "Please enter Realm Name", default=DEFAULT_REALM_NAME
+    ).unsafe_ask()
+
+    client_id = questionary.text(
+        "Please enter client ID", default=DEFAULT_CLIENT_ID
+    ).unsafe_ask()
+
+    return keycloak_url, realm_name, client_id
+
+
+def _get_default_config(studio_url: str) -> tuple:
+    """Get the default configuration values for Rasa Studio."""
+    keycloak_url = studio_url + "auth/"
+    realm_name = DEFAULT_REALM_NAME
+    client_id = DEFAULT_CLIENT_ID
+
+    rasa.shared.utils.cli.print_info(
+        f"Using default values for "
+        f"Keycloak URL: {keycloak_url}, "
+        f"Realm Name: '{realm_name}', "
+        f"Client ID: '{client_id}'. "
+        f"You can use '--advanced' to configure these settings."
+    )
+
+    return keycloak_url, realm_name, client_id
+
+
+def _create_studio_config(
+    studio_url: str, keycloak_url: str, realm_name: str, client_id: str
+) -> StudioConfig:
+    """Create a StudioConfig object with the provided parameters."""
+    return StudioConfig(
+        authentication_server_url=keycloak_url,
+        studio_url=studio_url + "api/graphql/",
+        client_id=client_id,
+        realm_name=realm_name,
+    )
+
+
+def _check_studio_auth(studio_auth: StudioAuth) -> bool:
+    """Check if the Rasa Studio authentication server is reachable."""
+    if studio_auth.health_check():
+        rasa.shared.utils.cli.print_info(
+            "Tried configuration and successfully reached Rasa Studio."
+        )
+        return True
+    return False
+
+
+def _prompt_store_config_anyways() -> bool:
+    """Prompt the user to store the configuration."""
+    should_store_config = questionary.confirm(
+        "Do you want to store the configuration anyway?"
+    ).unsafe_ask()
+
+    return should_store_config
+
+
+def _configure_studio_config(args: argparse.Namespace) -> StudioConfig:
+    """Configure the Rasa Studio connection settings."""
+    studio_url = _configure_studio_url()
+
+    # check if the user wants to configure advanced authentication settings
+    if args.advanced:
+        keycloak_url, realm_name, client_id = _get_advanced_config(studio_url)
+    else:
+        keycloak_url, realm_name, client_id = _get_default_config(studio_url)
+
+    # create a configuration and auth object to try to reach the studio
+    studio_config = _create_studio_config(
+        studio_url, keycloak_url, realm_name, client_id
+    )
+    studio_auth = StudioAuth(studio_config)
+
+    if _check_studio_auth(studio_auth):
+        return studio_config
+
+    rasa.shared.utils.cli.print_error(
+        f"Failed to reach Rasa Studio authentication server at "
+        f"{studio_config.authentication_server_url}."
+    )
+
+    if _prompt_store_config_anyways():
+        return studio_config
+
+    rasa.shared.utils.cli.print_info(
+        "The config was not stored, you can change the values "
+        "again or abort with Ctrl-C."
+    )
+
+    return _configure_studio_config(args)
+
+
+def create_and_store_studio_config(args: argparse.Namespace) -> None:
+    """Create and store the Rasa Studio configuration.
+
+    Args:
+        args: Commandline arguments
+    """
+    try:
+        rasa.shared.utils.cli.print_info(
+            "Configuring Rasa Studio connection settings ..."
+        )
+        studio_config = _configure_studio_config(args)
+
+        if studio_config:
+            studio_config.write_config()
+
+            rasa.shared.utils.cli.print_success(
+                "Successfully configured Rasa Pro to connect to Studio."
+            )
+        else:
+            rasa.shared.utils.cli.print_error(
+                "Failed to configure Rasa Pro to connect to Studio."
+            )
+    except KeyboardInterrupt:
+        rasa.shared.utils.cli.print_error("Configuration of Rasa Studio aborted.")

rasa/cli/studio/train.py

@@ -0,0 +1,59 @@
+import argparse
+from typing import List
+
+from rasa.cli import SubParsersAction
+from rasa.cli.arguments.train import set_train_arguments
+
+from rasa.studio.train import handle_train
+
+
+def add_subparser(
+    subparsers: SubParsersAction, parents: List[argparse.ArgumentParser]
+) -> None:
+    """Add the studio train parser.
+
+    Args:
+        subparsers: subparser we are going to attach to
+        parents: Parent parsers, needed to ensure tree structure in argparse
+    """
+    train_parser = subparsers.add_parser(
+        "train",
+        parents=parents,
+        conflict_handler="resolve",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help=(
+            "Trains a Rasa model using Rasa Studio "
+            "data and your NLU data and stories."
+        ),
+    )
+
+    train_parser.set_defaults(func=handle_train)
+    set_train_arguments(train_parser)
+    set_studio_train_arguments(train_parser)
+
+
+def set_studio_train_arguments(parser: argparse.ArgumentParser) -> None:
+    """Add arguments for running `rasa studio train`."""
+    parser.add_argument(
+        "assistant_name",
+        default=None,
+        nargs=1,
+        type=str,
+        help="Name of the assistant on Rasa Studio",
+    )
+
+    parser.add_argument(
+        "--entities",
+        default=None,
+        nargs="+",
+        type=str,
+        help="Name of entities to download from Rasa Studio",
+    )
+
+    parser.add_argument(
+        "--intents",
+        default=None,
+        nargs="+",
+        type=str,
+        help="Name of intents to download from Rasa Studio",
+    )

rasa/cli/studio/upload.py

@@ -0,0 +1,77 @@
+import argparse
+from typing import List
+
+from rasa.cli import SubParsersAction
+from rasa.cli.arguments.default_arguments import (
+    add_config_param,
+    add_data_param,
+    add_domain_param,
+    add_endpoint_param,
+)
+from rasa.studio.upload import handle_upload
+
+
+def add_subparser(
+    subparsers: SubParsersAction, parents: List[argparse.ArgumentParser]
+) -> None:
+    """Add the upload parser.
+
+    Args:
+        subparsers: subparser we are going to attach to
+        parents: Parent parsers, needed to ensure tree structure in argparse
+    """
+    upload_parser = subparsers.add_parser(
+        "upload",
+        parents=parents,
+        conflict_handler="resolve",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help="Upload primitives to Rasa Studio. Only works with NLU assistants.",
+    )
+
+    upload_parser.set_defaults(func=handle_upload)
+    set_upload_arguments(upload_parser)
+
+
+def add_flows_param(
+    parser: argparse.ArgumentParser,
+    help_text: str = "Name of flows file to upload to Rasa Studio. Works with --calm",
+    default_path: str = "flows.yml",
+) -> None:
+    parser.add_argument(
+        "--flows",
+        default=default_path,
+        nargs="+",
+        type=str,
+        help=help_text,
+    )
+
+
+def set_upload_arguments(parser: argparse.ArgumentParser) -> None:
+    """Add arguments for running `rasa upload`."""
+    add_data_param(parser, data_type="training")
+    add_domain_param(parser)
+    add_flows_param(parser)
+    add_config_param(parser)
+    add_endpoint_param(parser, help_text="Path to the endpoints file.")
+
+    parser.add_argument(
+        "--entities",
+        default=None,
+        nargs="+",
+        type=str,
+        help="Name of entities to upload to Rasa Studio",
+    )
+
+    parser.add_argument(
+        "--intents",
+        default=None,
+        nargs="+",
+        type=str,
+        help="Name of intents to upload to Rasa Studio",
+    )
+
+    parser.add_argument(
+        "--calm",
+        action="store_true",
+        help="If set, creates a new CALM assistant in Rasa Studio.",
+    )

rasa/cli/telemetry.py

@@ -0,0 +1,102 @@
+import argparse
+import textwrap
+from typing import List
+
+from rasa import telemetry
+from rasa.cli import SubParsersAction
+import rasa.cli.utils
+from rasa.shared.constants import DOCS_URL_TELEMETRY
+import rasa.shared.utils.cli
+from rasa.utils import licensing
+
+
+def add_subparser(
+    subparsers: SubParsersAction, parents: List[argparse.ArgumentParser]
+) -> None:
+    """Add all telemetry tracking parsers.
+
+    Args:
+        subparsers: subparser we are going to attach to
+        parents: Parent parsers, needed to ensure tree structure in argparse
+    """
+    telemetry_parser = subparsers.add_parser(
+        "telemetry",
+        parents=parents,
+        help="Configuration of Rasa Pro telemetry reporting.",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+
+    telemetry_subparsers = telemetry_parser.add_subparsers()
+    telemetry_disable_parser = telemetry_subparsers.add_parser(
+        "disable",
+        parents=parents,
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help="Disable Rasa Pro Telemetry reporting.",
+    )
+    telemetry_disable_parser.set_defaults(func=disable_telemetry)
+
+    telemetry_enable_parser = telemetry_subparsers.add_parser(
+        "enable",
+        parents=parents,
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help="Enable Rasa Pro Telemetry reporting.",
+    )
+    telemetry_enable_parser.set_defaults(func=enable_telemetry)
+    telemetry_parser.set_defaults(func=inform_about_telemetry)
+
+
+def inform_about_telemetry(_: argparse.Namespace) -> None:
+    """Inform user about telemetry tracking."""
+    is_enabled = telemetry.is_telemetry_enabled()
+    if is_enabled:
+        rasa.shared.utils.cli.print_success(
+            "Telemetry reporting is currently enabled for this installation."
+        )
+    else:
+        rasa.shared.utils.cli.print_success(
+            "Telemetry reporting is currently disabled for this installation."
+        )
+
+    print(
+        textwrap.dedent(
+            """
+            Rasa uses telemetry to report anonymous usage information. This information
+            is essential to help improve Rasa Pro for all users."""
+        )
+    )
+    if licensing.is_champion_server_license():
+        print(
+            "\nYou are using a developer license, which requires telemetry "
+            "reporting to be enabled."
+        )
+    elif not is_enabled:
+        print("\nYou can enable telemetry reporting using")
+        rasa.shared.utils.cli.print_info("\n\trasa telemetry enable")
+    else:
+        print("\nYou can disable telemetry reporting using:")
+        rasa.shared.utils.cli.print_info("\n\trasa telemetry disable")
+
+    rasa.shared.utils.cli.print_success(
+        "\nYou can find more information about telemetry reporting at "
+        "" + DOCS_URL_TELEMETRY
+    )
+
+
+def disable_telemetry(_: argparse.Namespace) -> None:
+    """Disable telemetry tracking."""
+    if licensing.is_champion_server_license():
+        rasa.shared.utils.cli.print_error(
+            "You are using a developer license, which requires telemetry "
+            "reporting to be enabled."
+        )
+        return
+
+    telemetry.track_telemetry_disabled()
+    telemetry.toggle_telemetry_reporting(is_enabled=False)
+    rasa.shared.utils.cli.print_success("Disabled telemetry reporting.")
+
+
+def enable_telemetry(_: argparse.Namespace) -> None:
+    """Enable telemetry tracking."""
+    telemetry.toggle_telemetry_reporting(is_enabled=True)
+    rasa.shared.utils.cli.print_success("Enabled telemetry reporting.")