rasa-pro 3.12.0.dev1__py3-none-any.whl

rasa/api.py

@@ -0,0 +1,160 @@
+import asyncio
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Union
+
+import rasa.shared.constants
+from rasa.core.persistor import StorageType
+
+# WARNING: Be careful about adding any top level imports at this place!
+#   These functions are imported in `rasa.__init__` and any top level import
+#   added here will get executed as soon as someone runs `import rasa`.
+#   Some imports are very slow (e.g. `tensorflow`) and we want them to get
+#   imported when running `import rasa`. If you add more imports here,
+#   please check that in the chain you are importing, no slow packages
+#   are getting imported.
+
+if TYPE_CHECKING:
+    from rasa.model_training import TrainingResult
+    from rasa.shared.importers.importer import TrainingDataImporter
+
+
+def run(
+    model: Text,
+    endpoints: Text,
+    connector: Optional[Text] = None,
+    credentials: Optional[Text] = None,
+    **kwargs: Dict[Text, Any],
+) -> None:
+    """Runs a Rasa model.
+
+    Args:
+        model: Path to model archive.
+        endpoints: Path to endpoints file.
+        connector: Connector which should be use (overwrites `credentials`
+        field).
+        credentials: Path to channel credentials file.
+        **kwargs: Additional arguments which are passed to
+        `rasa.core.run.serve_application`.
+
+    """
+    import rasa.core.run
+    import rasa.shared.utils.common
+    from rasa.core.utils import AvailableEndpoints
+    from rasa.shared.constants import DOCS_BASE_URL
+    from rasa.shared.utils.cli import print_warning
+
+    _endpoints = AvailableEndpoints.get_instance(endpoints)
+
+    if not connector and not credentials:
+        connector = "rest"
+
+        print_warning(
+            f"No chat connector configured, falling back to the "
+            f"REST input channel. To connect your bot to another channel, "
+            f"read the docs here: {DOCS_BASE_URL}/messaging-and-voice-channels"
+        )
+
+    kwargs = rasa.shared.utils.common.minimal_kwargs(
+        kwargs, rasa.core.run.serve_application
+    )
+    rasa.core.run.serve_application(
+        model,
+        channel=connector,
+        credentials=credentials,
+        endpoints=_endpoints,
+        **kwargs,
+    )
+
+
+def train(
+    domain: Text,
+    config: Text,
+    training_files: "Union[Text, List[Text]]",
+    output: Text = rasa.shared.constants.DEFAULT_MODELS_PATH,
+    dry_run: bool = False,
+    force_training: bool = False,
+    fixed_model_name: Optional[Text] = None,
+    persist_nlu_training_data: bool = False,
+    core_additional_arguments: Optional[Dict] = None,
+    nlu_additional_arguments: Optional[Dict] = None,
+    model_to_finetune: Optional[Text] = None,
+    finetuning_epoch_fraction: float = 1.0,
+    remote_storage: Optional[StorageType] = None,
+    file_importer: Optional["TrainingDataImporter"] = None,
+    keep_local_model_copy: bool = False,
+) -> "TrainingResult":
+    """Runs Rasa Core and NLU training in `async` loop.
+
+    Args:
+        domain: Path to the domain file.
+        config: Path to the config for Core and NLU.
+        training_files: Paths to the training data for Core and NLU.
+        output: Output path.
+        dry_run: If `True` then no training will be done, and the information about
+            whether the training needs to be done will be printed.
+        force_training: If `True` retrain model even if data has not changed.
+        fixed_model_name: Name of model to be stored.
+        persist_nlu_training_data: `True` if the NLU training data should be persisted
+            with the model.
+        core_additional_arguments: Additional training parameters for core training.
+        nlu_additional_arguments: Additional training parameters forwarded to training
+            method of each NLU component.
+        model_to_finetune: Optional path to a model which should be finetuned or
+            a directory in case the latest trained model should be used.
+        finetuning_epoch_fraction: The fraction currently specified training epochs
+            in the model configuration which should be used for finetuning.
+        remote_storage: Optional name of the remote storage to
+            use for storing the model.
+        file_importer: Instance of `TrainingDataImporter` to use for training.
+            If it is not provided, a new instance will be created.
+        keep_local_model_copy: If `True` the model will be stored locally even if
+            remote storage is configured.
+
+    Returns:
+        An instance of `TrainingResult`.
+    """
+    from rasa.model_training import train
+
+    return asyncio.run(
+        train(
+            domain=domain,
+            config=config,
+            training_files=training_files,
+            output=output,
+            dry_run=dry_run,
+            force_training=force_training,
+            fixed_model_name=fixed_model_name,
+            persist_nlu_training_data=persist_nlu_training_data,
+            core_additional_arguments=core_additional_arguments,
+            nlu_additional_arguments=nlu_additional_arguments,
+            model_to_finetune=model_to_finetune,
+            finetuning_epoch_fraction=finetuning_epoch_fraction,
+            remote_storage=remote_storage,
+            file_importer=file_importer,
+            keep_local_model_copy=keep_local_model_copy,
+        )
+    )
+
+
+def test(
+    model: Text,
+    stories: Text,
+    nlu_data: Text,
+    output: Text = rasa.shared.constants.DEFAULT_RESULTS_PATH,
+    additional_arguments: Optional[Dict] = None,
+) -> None:
+    """Test a Rasa model against a set of test data.
+
+    Args:
+        model: model to test
+        stories: path to the dialogue test data
+        nlu_data: path to the NLU test data
+        output: path to folder where all output will be stored
+        additional_arguments: additional arguments for the test call
+    """
+    from rasa.model_testing import test_core, test_nlu
+
+    if additional_arguments is None:
+        additional_arguments = {}
+
+    test_core(model, stories, output, additional_arguments)  # type: ignore[unused-coroutine]
+    test_nlu(model, nlu_data, output, additional_arguments)  # type: ignore[unused-coroutine]

rasa/cli/__init__.py

@@ -0,0 +1,5 @@
+import argparse
+
+# skipcq:PYL-W0212
+# noinspection PyProtectedMember
+SubParsersAction = argparse._SubParsersAction

rasa/cli/arguments/data.py

@@ -0,0 +1,106 @@
+import argparse
+from typing import Text
+
+from rasa.cli.arguments.default_arguments import (
+    add_nlu_data_param,
+    add_out_param,
+    add_data_param,
+    add_domain_param,
+)
+from rasa.shared.constants import DEFAULT_CONVERTED_DATA_PATH
+
+
+def set_convert_nlu_arguments(parser: argparse.ArgumentParser, data_type: Text) -> None:
+    """Sets convert nlu command arguments."""
+    parser.add_argument(
+        "-f",
+        "--format",
+        default="yaml",
+        choices=["json", "yaml"],
+        help="Output format the training data should be converted into.",
+    )
+
+    add_data_param(parser, required=True, data_type=data_type)
+
+    add_out_param(
+        parser,
+        default=DEFAULT_CONVERTED_DATA_PATH,
+        help_text="File (for `json`) or existing path (for `yaml`) "
+        "where to save training data in Rasa format.",
+    )
+
+    parser.add_argument("-l", "--language", default="en", help="Language of data.")
+
+
+def set_convert_e2e_arguments(parser: argparse.ArgumentParser) -> None:
+    """Sets convert e2e command arguments.
+
+    Args:
+        parser: Parser we are going to attach arguments to.
+    """
+    parser.add_argument(
+        "path",
+        type=str,
+        help="Path to the input CSV or XLS/XLSX file.",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        type=str,
+        default="e2e_tests",
+        help="Output directory to store the tests.",
+    )
+    parser.add_argument(
+        "--sheet-name",
+        type=str,
+        help="Worksheet name containing relevant data. Mandatory for Excel file input.",
+    )
+
+
+def set_split_arguments(parser: argparse.ArgumentParser) -> None:
+    add_nlu_data_param(parser, help_text="File or folder containing your NLU data.")
+
+    parser.add_argument(
+        "--training-fraction",
+        type=float,
+        default=0.8,
+        help="Percentage of the data which should be in the training data.",
+    )
+
+    parser.add_argument(
+        "--random-seed",
+        type=int,
+        default=None,
+        help="Seed to generate the same train/test split.",
+    )
+
+    add_out_param(
+        parser,
+        default="train_test_split",
+        help_text="Directory where the split files should be stored.",
+    )
+
+
+def set_validator_arguments(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--fail-on-warnings",
+        default=False,
+        action="store_true",
+        help="Fail validation on warnings and errors. "
+        "If omitted only errors will result in a non zero exit code.",
+    )
+    add_domain_param(parser)
+    add_data_param(parser)
+
+
+def set_migrate_arguments(parser: argparse.ArgumentParser) -> None:
+    """Sets migrate command arguments."""
+    add_domain_param(parser)
+
+    add_out_param(
+        parser,
+        default=None,
+        help_text="Path (for `yaml`) where to save migrated domain in Rasa 3.0 format."
+        "If none is specified, either a `new_domain.yml` file or `new_domain` folder "
+        "will be created in the folder that contains the given domain.",
+    )

rasa/cli/arguments/default_arguments.py

@@ -0,0 +1,207 @@
+import argparse
+import logging
+from enum import Enum
+from typing import List, Optional, Text, Union
+
+from rasa.core.persistor import RemoteStorageType, StorageType, parse_remote_storage
+from rasa.shared.constants import (
+    DEFAULT_CONFIG_PATH,
+    DEFAULT_DATA_PATH,
+    DEFAULT_ENDPOINTS_PATH,
+    DEFAULT_MODELS_PATH,
+)
+
+
+def add_model_param(
+    parser: Union[argparse.ArgumentParser, argparse._ActionsContainer],
+    model_name: Text = "Rasa",
+    add_positional_arg: bool = True,
+    default: Optional[Text] = DEFAULT_MODELS_PATH,
+) -> None:
+    help_text = (
+        "Path to a trained {} model. If a directory is specified, it will "
+        "use the latest model in this directory.".format(model_name)
+    )
+    parser.add_argument("-m", "--model", type=str, default=default, help=help_text)
+    if add_positional_arg:
+        parser.add_argument(
+            "model-as-positional-argument", nargs="?", type=str, help=help_text
+        )
+
+
+def add_stories_param(
+    parser: Union[argparse.ArgumentParser, argparse._ActionsContainer],
+    stories_name: Text = "training",
+) -> None:
+    parser.add_argument(
+        "-s",
+        "--stories",
+        type=str,
+        default=DEFAULT_DATA_PATH,
+        help=f"File or folder containing your {stories_name} stories.",
+    )
+
+
+def add_nlu_data_param(
+    parser: Union[argparse.ArgumentParser, argparse._ActionsContainer],
+    help_text: Text,
+    default: Optional[Text] = DEFAULT_DATA_PATH,
+) -> None:
+    parser.add_argument("-u", "--nlu", type=str, default=default, help=help_text)
+
+
+def add_domain_param(
+    parser: Union[argparse.ArgumentParser, argparse._ActionsContainer],
+    default: Optional[Text] = None,
+) -> None:
+    parser.add_argument(
+        "-d",
+        "--domain",
+        type=str,
+        default=default,
+        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.",
+    )
+
+
+def add_config_param(
+    parser: Union[argparse.ArgumentParser, argparse._ActionsContainer],
+    default: Optional[Text] = DEFAULT_CONFIG_PATH,
+) -> None:
+    parser.add_argument(
+        "-c",
+        "--config",
+        type=str,
+        default=default,
+        help="The policy and pipeline configuration of your bot.",
+    )
+
+
+def add_out_param(
+    parser: Union[argparse.ArgumentParser, argparse._ActionsContainer],
+    help_text: Text,
+    default: Optional[Text] = DEFAULT_MODELS_PATH,
+    required: bool = False,
+) -> None:
+    parser.add_argument(
+        "--out",
+        type=str,
+        default=default,
+        help=help_text,
+        # The desired behaviour is that required indicates if this argument must
+        # have a value, but argparse interprets it as "must have a value
+        # from user input", so we toggle it only if our default is not set
+        required=required and default is None,
+    )
+
+
+def add_endpoint_param(
+    parser: Union[argparse.ArgumentParser, argparse._ActionsContainer],
+    help_text: Text,
+    default: Optional[Text] = DEFAULT_ENDPOINTS_PATH,
+) -> None:
+    """Adds an option to an argument parser to configure endpoints path."""
+    parser.add_argument("--endpoints", type=str, default=default, help=help_text)
+
+
+def add_data_param(
+    parser: Union[argparse.ArgumentParser, argparse._ActionsContainer],
+    default: Optional[Text] = DEFAULT_DATA_PATH,
+    required: bool = False,
+    data_type: Text = "Rasa ",
+) -> None:
+    parser.add_argument(
+        "--data",
+        default=default,
+        nargs="+",
+        type=str,
+        help=f"Paths to the files or directories containing {data_type} data.",
+        # The desired behaviour is that required indicates if this argument must
+        # have a value, but argparse interprets it as "must have a value
+        # from user input", so we toggle it only if our default is not set
+        required=required and default is None,
+    )
+
+
+def add_logging_options(parser: argparse.ArgumentParser) -> None:
+    """Add options to an argument parser to configure logging levels."""
+    logging_arguments = parser.add_argument_group(
+        "Python Logging Options",
+        "You can control level of log messages printed. "
+        "In addition to these arguments, a more fine grained configuration can be "
+        "achieved with environment variables. See online documentation for more info.",
+    )
+
+    # arguments for logging configuration
+    logging_arguments.add_argument(
+        "-v",
+        "--verbose",
+        help="Be verbose. Sets logging level to INFO.",
+        action="store_const",
+        dest="loglevel",
+        const=logging.INFO,
+    )
+    logging_arguments.add_argument(
+        "-vv",
+        "--debug",
+        help="Print lots of debugging statements. Sets logging level to DEBUG.",
+        action="store_const",
+        dest="loglevel",
+        const=logging.DEBUG,
+    )
+    logging_arguments.add_argument(
+        "--quiet",
+        help="Be quiet! Sets logging level to WARNING.",
+        action="store_const",
+        dest="loglevel",
+        const=logging.WARNING,
+    )
+
+    logging_arguments.add_argument(
+        "--logging-config-file",
+        type=str,
+        help="If set, the name of the logging configuration file will be set "
+        "to the given name.",
+    )
+
+
+def add_remote_storage_param(
+    parser: Union[argparse.ArgumentParser, argparse._ActionsContainer],
+    required: bool = False,
+) -> None:
+    parser.add_argument(
+        "--remote-storage",
+        help="Remote storage which should be used to store/load the model."
+        f"Supported storages are: {RemoteStorageType.list()}. "
+        "You can also provide your own implementation of the `Persistor` interface.",
+        required=required,
+        type=parse_remote_storage_arg,
+    )
+
+
+def parse_remote_storage_arg(value: str) -> StorageType:
+    try:
+        return parse_remote_storage(value)
+    except ValueError as e:
+        raise argparse.ArgumentTypeError(str(e))
+
+
+class SkipYamlValidation(Enum):
+    DOMAIN = "domain"
+
+    @classmethod
+    def list(cls) -> List[str]:
+        return [e.value for e in SkipYamlValidation]
+
+
+def add_skip_validation_flag(
+    parser: Union[argparse.ArgumentParser, argparse._ActionsContainer],
+) -> None:
+    parser.add_argument(
+        "--skip-yaml-validation",
+        default=[],
+        choices=SkipYamlValidation.list(),
+        action="append",
+        help="Skip YAML validation for selected parts of the training data.",
+    )

rasa/cli/arguments/evaluate.py

@@ -0,0 +1,65 @@
+import argparse
+from pathlib import Path
+from rasa.cli.arguments.default_arguments import add_endpoint_param, add_domain_param
+
+
+def set_markers_arguments(parser: argparse.ArgumentParser) -> None:
+    """Specifies arguments for `rasa evaluate markers`."""
+    parser.add_argument(
+        "output_filename",
+        type=Path,
+        help="The filename to write the extracted markers to (CSV format).",
+    )
+
+    parser.add_argument(
+        "--config",
+        default="markers.yml",
+        type=Path,
+        help="The marker configuration file(s) containing marker definitions. "
+        "This can be a single YAML file, or a directory that contains several "
+        "files with marker definitions in it. The content of these files will "
+        "be read and merged together.",
+    )
+
+    stats = parser.add_mutually_exclusive_group()
+
+    stats.add_argument(
+        "--no-stats",
+        action="store_false",
+        dest="stats",
+        help="Do not compute summary statistics.",
+    )
+
+    stats.add_argument(
+        "--stats-file-prefix",
+        default="stats",
+        nargs="?",
+        type=Path,
+        help="The common file prefix of the files where we write out the compute "
+        "statistics. More precisely, the file prefix must consist of a common "
+        "path plus a common file prefix, to which suffixes `-overall.csv` and "
+        "`-per-session.csv` will be added automatically.",
+    )
+
+    add_endpoint_param(
+        parser, help_text="Configuration file for the tracker store as a yml file."
+    )
+
+    add_domain_param(parser)
+
+
+def set_markers_first_n_arguments(parser: argparse.ArgumentParser) -> None:
+    """Specifies arguments for `rasa evaluate markers first_n`."""
+    parser.add_argument(
+        "count", type=int, help="The number of trackers to extract markers from"
+    )
+
+
+def set_markers_sample_arguments(parser: argparse.ArgumentParser) -> None:
+    """Specifies arguments for `rasa evaluate markers sample_n`."""
+    parser.add_argument(
+        "--seed", type=int, help="Seed to use if selecting trackers by 'sample_n'"
+    )
+    parser.add_argument(
+        "count", type=int, help="The number of trackers to extract markers from"
+    )

rasa/cli/arguments/export.py

@@ -0,0 +1,51 @@
+import argparse
+
+from rasa.cli.arguments import default_arguments
+from rasa.shared.constants import DEFAULT_ENDPOINTS_PATH
+
+
+def set_export_arguments(parser: argparse.ArgumentParser) -> None:
+    default_arguments.add_endpoint_param(
+        parser,
+        default=DEFAULT_ENDPOINTS_PATH,
+        help_text=(
+            "Endpoint configuration file specifying the tracker store "
+            "and event broker."
+        ),
+    )
+
+    parser.add_argument(
+        "--minimum-timestamp",
+        type=float,
+        help=(
+            "Minimum timestamp of events to be exported. The constraint is applied "
+            "in a 'greater than or equal' comparison."
+        ),
+    )
+
+    parser.add_argument(
+        "--maximum-timestamp",
+        type=float,
+        help=(
+            "Maximum timestamp of events to be exported. The constraint is "
+            "applied in a 'less than' comparison."
+        ),
+    )
+
+    parser.add_argument(
+        "--offset-timestamps-by-seconds",
+        type=int,
+        help=(
+            "Offset all event timestamps by the specified amount of seconds. "
+            "This won't modify the stored events in the tracker store, but only "
+            "change the timestamps in the events exported to the broker."
+        ),
+    )
+
+    parser.add_argument(
+        "--conversation-ids",
+        help=(
+            "Comma-separated list of conversation IDs to migrate. If unset, "
+            "all available conversation IDs will be exported."
+        ),
+    )

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