rasa-pro 3.9.18__py3-none-any.whl

rasa/cli/arguments/interactive.py

@@ -0,0 +1,74 @@
+import argparse
+import uuid
+
+import rasa.cli.arguments.default_arguments
+import rasa.cli.arguments.train
+import rasa.cli.arguments.run
+
+
+def set_interactive_arguments(parser: argparse.ArgumentParser) -> None:
+    """Specifies arguments for `rasa interactive`."""
+    parser.add_argument(
+        "--e2e",
+        action="store_true",
+        help="Save story files in e2e format. In this format user messages "
+        "will be included in the stories.",
+    )
+    rasa.cli.arguments.run.add_port_argument(parser)
+
+    rasa.cli.arguments.default_arguments.add_model_param(parser, default=None)
+    rasa.cli.arguments.train.add_data_param(parser)
+
+    _add_common_params(parser)
+    train_arguments = _add_training_arguments(parser)
+
+    rasa.cli.arguments.train.add_force_param(train_arguments)
+    rasa.cli.arguments.train.add_persist_nlu_data_param(train_arguments)
+
+
+def set_interactive_core_arguments(parser: argparse.ArgumentParser) -> None:
+    """Specifies arguments for `rasa interactive core`."""
+    rasa.cli.arguments.default_arguments.add_model_param(
+        parser, model_name="Rasa Core", default=None
+    )
+    rasa.cli.arguments.default_arguments.add_stories_param(parser)
+
+    _add_common_params(parser)
+    _add_training_arguments(parser)
+    rasa.cli.arguments.run.add_port_argument(parser)
+
+
+def _add_common_params(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--skip-visualization",
+        default=False,
+        action="store_true",
+        help="Disable plotting the visualization during interactive learning.",
+    )
+
+    parser.add_argument(
+        "--conversation-id",
+        default=uuid.uuid4().hex,
+        help="Specify the id of the conversation the messages are in. Defaults to a "
+        "UUID that will be randomly generated.",
+    )
+
+    rasa.cli.arguments.default_arguments.add_endpoint_param(
+        parser,
+        help_text="Configuration file for the model server "
+        "and the connectors as a yml file.",
+    )
+
+
+# noinspection PyProtectedMember
+def _add_training_arguments(parser: argparse.ArgumentParser) -> argparse._ArgumentGroup:
+    train_arguments = parser.add_argument_group("Train Arguments")
+    rasa.cli.arguments.train.add_config_param(train_arguments)
+    rasa.cli.arguments.default_arguments.add_domain_param(train_arguments)
+    rasa.cli.arguments.train.add_out_param(
+        train_arguments, help_text="Directory where your models should be stored."
+    )
+    rasa.cli.arguments.train.add_augmentation_param(train_arguments)
+    rasa.cli.arguments.train.add_debug_plots_param(train_arguments)
+    rasa.cli.arguments.train.add_finetune_params(train_arguments)
+    return train_arguments

rasa/cli/arguments/run.py

@@ -0,0 +1,204 @@
+import os
+
+import argparse
+from typing import Union
+
+from rasa.cli.arguments.default_arguments import add_model_param, add_endpoint_param
+from rasa.core import constants
+from rasa.env import (
+    DEFAULT_JWT_METHOD,
+    JWT_METHOD_ENV,
+    JWT_SECRET_ENV,
+    JWT_PRIVATE_KEY_ENV,
+    AUTH_TOKEN_ENV,
+)
+
+
+def set_run_arguments(parser: argparse.ArgumentParser) -> None:
+    """Arguments for running Rasa directly using `rasa run`."""
+    add_model_param(parser)
+    add_server_arguments(parser)
+
+
+def set_run_action_arguments(parser: argparse.ArgumentParser) -> None:
+    """Set arguments for running Rasa SDK."""
+    import rasa_sdk.cli.arguments as sdk
+
+    sdk.add_endpoint_arguments(parser)
+
+
+def add_interface_argument(
+    parser: Union[argparse.ArgumentParser, argparse._ArgumentGroup],
+) -> None:
+    """Binds the RASA process to a network interface."""
+    parser.add_argument(
+        "-i",
+        "--interface",
+        default=constants.DEFAULT_SERVER_INTERFACE,
+        type=str,
+        help="Network interface to run the server on.",
+    )
+
+
+# noinspection PyProtectedMember
+def add_port_argument(
+    parser: Union[argparse.ArgumentParser, argparse._ArgumentGroup],
+) -> None:
+    """Add an argument for port."""
+    parser.add_argument(
+        "-p",
+        "--port",
+        default=constants.DEFAULT_SERVER_PORT,
+        type=int,
+        help="Port to run the server at.",
+    )
+
+
+def add_server_arguments(parser: argparse.ArgumentParser) -> None:
+    """Add arguments for running API endpoint."""
+    parser.add_argument(
+        "--log-file",
+        type=str,
+        # Rasa should not log to a file by default, otherwise there will be problems
+        # when running on OpenShift
+        default=None,
+        help="Store logs in specified file.",
+    )
+    parser.add_argument(
+        "--use-syslog", action="store_true", help="Add syslog as a log handler"
+    )
+    parser.add_argument(
+        "--syslog-address",
+        type=str,
+        default=constants.DEFAULT_SYSLOG_HOST,
+        help="Address of the syslog server. --use-sylog flag is required",
+    )
+    parser.add_argument(
+        "--syslog-port",
+        type=int,
+        default=constants.DEFAULT_SYSLOG_PORT,
+        help="Port of the syslog server. --use-sylog flag is required",
+    )
+    parser.add_argument(
+        "--syslog-protocol",
+        type=str,
+        default=constants.DEFAULT_PROTOCOL,
+        help="Protocol used with the syslog server. Can be UDP (default) or TCP ",
+    )
+    add_endpoint_param(
+        parser,
+        help_text="Configuration file for the model server and the connectors as a "
+        "yml file.",
+    )
+
+    add_server_settings_arguments(parser)
+
+
+def add_server_settings_arguments(parser: argparse.ArgumentParser) -> None:
+    """Add arguments for the API server.
+
+    Args:
+        parser: Argument parser.
+    """
+    server_arguments = parser.add_argument_group("Server Settings")
+
+    add_interface_argument(server_arguments)
+    add_port_argument(server_arguments)
+
+    server_arguments.add_argument(
+        "-t",
+        "--auth-token",
+        type=str,
+        default=os.getenv(AUTH_TOKEN_ENV),
+        help="Enable token based authentication. Requests need to provide "
+        "the token to be accepted.",
+    )
+    server_arguments.add_argument(
+        "--cors",
+        nargs="*",
+        type=str,
+        help="Enable CORS for the passed origin. Use * to whitelist all origins.",
+    )
+    server_arguments.add_argument(
+        "--enable-api",
+        action="store_true",
+        help="Start the web server API in addition to the input channel.",
+    )
+    server_arguments.add_argument(
+        "--response-timeout",
+        default=constants.DEFAULT_RESPONSE_TIMEOUT,
+        type=int,
+        help="Maximum time a response can take to process (sec).",
+    )
+    server_arguments.add_argument(
+        "--request-timeout",
+        default=constants.DEFAULT_REQUEST_TIMEOUT,
+        type=int,
+        help="Maximum time a request can take to process (sec).",
+    )
+    server_arguments.add_argument(
+        "--remote-storage",
+        help="Set the remote location where your Rasa model is stored, e.g. on AWS.",
+    )
+    server_arguments.add_argument(
+        "--ssl-certificate",
+        help="Set the SSL Certificate to create a TLS secured server.",
+    )
+    server_arguments.add_argument(
+        "--ssl-keyfile", help="Set the SSL Keyfile to create a TLS secured server."
+    )
+    server_arguments.add_argument(
+        "--ssl-ca-file",
+        help="If your SSL certificate needs to be verified, "
+        "you can specify the CA file "
+        "using this parameter.",
+    )
+    server_arguments.add_argument(
+        "--ssl-password",
+        help="If your ssl-keyfile is protected by a password, you can specify it "
+        "using this paramer.",
+    )
+    channel_arguments = parser.add_argument_group("Channels")
+    channel_arguments.add_argument(
+        "--credentials",
+        default=None,
+        help="Authentication credentials for the connector as a yml file.",
+    )
+    channel_arguments.add_argument(
+        "--connector", type=str, help="Service to connect to."
+    )
+
+    add_jwt_arguments(parser)
+
+
+def add_jwt_arguments(parser: argparse.ArgumentParser) -> None:
+    """Adds arguments related to JWT authentication.
+
+    Args:
+        parser: Argument parser.
+    """
+    jwt_auth = parser.add_argument_group("JWT Authentication")
+    jwt_auth.add_argument(
+        "--jwt-secret",
+        type=str,
+        default=os.getenv(JWT_SECRET_ENV),
+        help="Public key for asymmetric JWT methods or shared secret"
+        "for symmetric methods. Please also make sure to use "
+        "--jwt-method to select the method of the signature, "
+        "otherwise this argument will be ignored."
+        "Note that this key is meant for securing the HTTP API.",
+    )
+    jwt_auth.add_argument(
+        "--jwt-method",
+        type=str,
+        default=os.getenv(JWT_METHOD_ENV, DEFAULT_JWT_METHOD),
+        help="Method used for the signature of the JWT authentication payload.",
+    )
+    jwt_auth.add_argument(
+        "--jwt-private-key",
+        type=str,
+        default=os.getenv(JWT_PRIVATE_KEY_ENV),
+        help="A private key used for generating web tokens, dependent upon "
+        "which hashing algorithm is used. It must be used together with "
+        "--jwt-secret for providing the public key.",
+    )

rasa/cli/arguments/shell.py

@@ -0,0 +1,13 @@
+import argparse
+
+from rasa.cli.arguments.default_arguments import add_model_param
+from rasa.cli.arguments.run import add_server_arguments
+
+
+def set_shell_arguments(parser: argparse.ArgumentParser) -> None:
+    add_model_param(parser)
+    add_server_arguments(parser)
+
+
+def set_shell_nlu_arguments(parser: argparse.ArgumentParser) -> None:
+    add_model_param(parser)

rasa/cli/arguments/test.py

@@ -0,0 +1,211 @@
+import argparse
+from typing import Union
+
+from rasa.shared.constants import DEFAULT_MODELS_PATH, DEFAULT_RESULTS_PATH
+
+from rasa.cli.arguments.default_arguments import (
+    add_stories_param,
+    add_model_param,
+    add_nlu_data_param,
+    add_endpoint_param,
+    add_out_param,
+)
+from rasa.model import get_latest_model
+from rasa.shared.constants import DEFAULT_DOMAIN_PATH
+
+
+def set_test_arguments(parser: argparse.ArgumentParser) -> None:
+    """Sets test arguments for a parser."""
+    add_model_param(parser, add_positional_arg=False)
+
+    core_arguments = parser.add_argument_group("Core Test Arguments")
+    add_test_core_argument_group(core_arguments)
+
+    nlu_arguments = parser.add_argument_group("NLU Test Arguments")
+    add_test_nlu_argument_group(nlu_arguments)
+
+    add_no_plot_param(parser)
+    add_errors_success_params(parser)
+    add_out_param(
+        parser,
+        default=DEFAULT_RESULTS_PATH,
+        help_text="Output path for any files created during the evaluation.",
+    )
+
+
+def set_test_core_arguments(parser: argparse.ArgumentParser) -> None:
+    add_test_core_model_param(parser)
+    add_test_core_argument_group(parser, include_e2e_argument=True)
+
+
+def set_test_nlu_arguments(parser: argparse.ArgumentParser) -> None:
+    add_model_param(parser, add_positional_arg=False)
+    add_test_nlu_argument_group(parser)
+
+
+def add_test_core_argument_group(
+    parser: Union[argparse.ArgumentParser, argparse._ActionsContainer],
+    include_e2e_argument: bool = False,
+) -> None:
+    add_stories_param(parser, "test")
+    parser.add_argument(
+        "--max-stories", type=int, help="Maximum number of stories to test on."
+    )
+    add_out_param(
+        parser,
+        default=DEFAULT_RESULTS_PATH,
+        help_text="Output path for any files created during the evaluation.",
+    )
+    if include_e2e_argument:
+        parser.add_argument(
+            "--e2e",
+            "--end-to-end",
+            action="store_true",
+            help="Run an end-to-end evaluation for combined action and "
+            "intent prediction. Requires a story file in end-to-end "
+            "format.",
+        )
+    add_endpoint_param(
+        parser, help_text="Configuration file for the connectors as a yml file."
+    )
+    parser.add_argument(
+        "--fail-on-prediction-errors",
+        action="store_true",
+        help="If a prediction error is encountered, an exception "
+        "is thrown. This can be used to validate stories during "
+        "tests, e.g. on travis.",
+    )
+    parser.add_argument(
+        "--url",
+        type=str,
+        help="If supplied, downloads a story file from a URL and "
+        "trains on it. Fetches the data by sending a GET request "
+        "to the supplied URL.",
+    )
+    parser.add_argument(
+        "--evaluate-model-directory",
+        default=False,
+        action="store_true",
+        help="Should be set to evaluate models trained via "
+        "'rasa train core --config <config-1> <config-2>'. "
+        "All models in the provided directory are evaluated "
+        "and compared against each other.",
+    )
+    add_no_plot_param(parser)
+    add_errors_success_params(parser)
+
+
+def add_test_nlu_argument_group(
+    parser: Union[argparse.ArgumentParser, argparse._ActionsContainer],
+) -> None:
+    add_nlu_data_param(parser, help_text="File or folder containing your NLU data.")
+
+    add_out_param(
+        parser,
+        default=DEFAULT_RESULTS_PATH,
+        help_text="Output path for any files created during the evaluation.",
+    )
+    parser.add_argument(
+        "-c",
+        "--config",
+        nargs="+",
+        default=None,
+        help="Model configuration file. If a single file is passed and cross "
+        "validation mode is chosen, cross-validation is performed, if "
+        "multiple configs or a folder of configs are passed, models "
+        "will be trained and compared directly.",
+    )
+
+    parser.add_argument(
+        "-d",
+        "--domain",
+        type=str,
+        default=DEFAULT_DOMAIN_PATH,
+        help="Domain specification. This can be a single YAML file, or a directory "
+        "that contains several files with domain specifications in it. The content "
+        "of these files will be read and merged together.",
+    )
+
+    cross_validation_arguments = parser.add_argument_group("Cross Validation")
+    cross_validation_arguments.add_argument(
+        "--cross-validation",
+        action="store_true",
+        default=False,
+        help="Switch on cross validation mode. Any provided model will be ignored.",
+    )
+    cross_validation_arguments.add_argument(
+        "-f",
+        "--folds",
+        required=False,
+        default=5,
+        help="Number of cross validation folds (cross validation only).",
+    )
+    comparison_arguments = parser.add_argument_group("Comparison Mode")
+    comparison_arguments.add_argument(
+        "-r",
+        "--runs",
+        required=False,
+        default=3,
+        type=int,
+        help="Number of comparison runs to make.",
+    )
+    comparison_arguments.add_argument(
+        "-p",
+        "--percentages",
+        required=False,
+        nargs="+",
+        type=int,
+        default=[0, 25, 50, 75],
+        help="Percentages of training data to exclude during comparison.",
+    )
+
+    add_no_plot_param(parser)
+    add_errors_success_params(parser)
+
+
+def add_test_core_model_param(parser: argparse.ArgumentParser) -> None:
+    default_path = get_latest_model(DEFAULT_MODELS_PATH)
+    parser.add_argument(
+        "-m",
+        "--model",
+        nargs="+",
+        default=[default_path],
+        help="Path to a pre-trained model. If it is a 'tar.gz' file that model file "
+        "will be used. If it is a directory, the latest model in that directory "
+        "will be used (exception: '--evaluate-model-directory' flag is set). "
+        "If multiple 'tar.gz' files are provided, all those models will be compared.",
+    )
+
+
+def add_no_plot_param(
+    parser: argparse.ArgumentParser, default: bool = False, required: bool = False
+) -> None:
+    parser.add_argument(
+        "--no-plot",
+        dest="disable_plotting",
+        action="store_true",
+        default=default,
+        help="Don't render evaluation plots.",
+        required=required,
+    )
+
+
+def add_errors_success_params(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--successes",
+        action="store_true",
+        default=False,
+        help="If set successful predictions will be written to a file.",
+    )
+    parser.add_argument(
+        "--no-errors",
+        action="store_true",
+        default=False,
+        help="If set incorrect predictions will NOT be written to a file.",
+    )
+    parser.add_argument(
+        "--no-warnings",
+        action="store_true",
+        default=False,
+        help="If set prediction warnings will NOT be written to a file.",
+    )