rasa-pro 3.9.18__py3-none-any.whl

rasa/anonymization/schemas/config.yml

@@ -0,0 +1,47 @@
+allowempty: True
+mapping:
+  anonymization:
+    type: "map"
+    mapping:
+      rule_lists:
+        type: "seq"
+        matching: "any"
+        required: True
+        sequence:
+        - type: "map"
+          mapping:
+            id:
+              type: "str"
+              required: True
+            rules:
+              type: "seq"
+              required: True
+              matching: "any"
+              sequence:
+              - type: "map"
+                mapping:
+                  entity:
+                    type: "str"
+                    required: True
+                  substitution:
+                    type: "str"
+                    enum: ["text", "mask", "faker"]
+                    required: False
+                  value:
+                    type: "str"
+                    required: False
+
+      metadata:
+        type: "map"
+        required: True
+        mapping:
+          language:
+            type: "str"
+            required: True
+          model_name:
+            type: "any"
+            required: True
+          model_provider:
+            type: "str"
+            required: True
+            enum: ["spacy", "stanza", "transformers"]

rasa/anonymization/utils.py

@@ -0,0 +1,118 @@
+import logging
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional, Text
+
+from rasa.shared.exceptions import RasaException, YamlException
+from rasa.shared.utils.yaml import (
+    read_config_file,
+    read_yaml_file,
+    validate_yaml_content_using_schema,
+)
+
+logger = logging.getLogger(__name__)
+SCHEMA_FILE = Path(__file__).parent / "schemas" / "config.yml"
+
+
+def read_endpoint_config(
+    filename: Optional[Text], endpoint_type: Text
+) -> Optional[Dict[Text, Any]]:
+    """Reads a configuration file from disk and extract one config."""
+    if not filename:
+        return None
+
+    try:
+        content = read_config_file(filename, reader_type=["safe", "rt"])
+
+        if content.get(endpoint_type) is None:
+            return None
+
+        return content
+    except FileNotFoundError:
+        logger.error(
+            "Failed to read configuration from {}. No such file.".format(
+                os.path.abspath(filename)
+            ),
+        )
+        return None
+
+
+def extract_anonymization_traits(
+    anonymization_config: Optional[Dict[Text, Any]], endpoint_type: Text
+) -> Dict[Text, Any]:
+    """Extract anonymization traits from the anonymization config.
+
+    Args:
+        anonymization_config: The anonymization config.
+        endpoint_type: The endpoint type.
+
+    Returns:
+        A dictionary containing the anonymization traits.
+    """
+    if not anonymization_config:
+        return {"enabled": False}
+
+    anonymization_value = anonymization_config.get(endpoint_type)
+    if not anonymization_value:
+        logger.debug("Anonymization config found but nothing is defined.")
+        return {"enabled": False}
+
+    try:
+        validate_anonymization_yaml(anonymization_config)
+    except RasaException as exception:
+        logger.debug(exception)
+        return {"enabled": False}
+
+    rule_lists = anonymization_value.get("rule_lists", [])
+
+    traits = {
+        "enabled": True,
+        "metadata": anonymization_value.get("metadata", {}),
+        "number_of_rule_lists": len(rule_lists),
+        "number_of_rules": 0,
+        "substitutions": {
+            "mask": 0,
+            "faker": 0,
+            "text": 0,
+            "not_defined": 0,
+        },
+        "entities": set(),
+    }
+
+    for rule_list in rule_lists:
+        traits["number_of_rules"] += len(rule_list.get("rules", []))
+        for rule in rule_list.get("rules", []):
+            traits["substitutions"][rule.get("substitution", "not_defined")] += 1
+            traits["entities"].add(rule.get("entity"))
+
+    entities = list(traits["entities"])
+    entities.sort()
+    traits["entities"] = entities
+
+    return traits
+
+
+def validate_anonymization_yaml(yaml_content: Dict[Text, Any]) -> None:
+    """Checks if the yaml_content adheres to the anonymization rule schema.
+
+    If the yaml_content is not in the right format, an exception will be raised.
+    """
+    schema = read_yaml_file(SCHEMA_FILE, reader_type=("safe", "rt"))
+    try:
+        validate_yaml_content_using_schema(yaml_content, schema)
+    except YamlException as exception:
+        raise RasaException(
+            f"Invalid configuration for `anonymization_rules` : {exception}"
+        ) from exception
+
+    rule_lists = yaml_content.get("anonymization", {}).get("rule_lists", [])
+
+    rule_set = set()
+    for rule_list in rule_lists:
+        rule_id = rule_list.get("id")
+        if rule_id in rule_set:
+            raise RasaException(
+                f"Invalid configuration for `anonymization_rules` :"
+                f"Duplicate rule id: '{rule_id}' encountered in rule_lists"
+            )
+        rule_set.add(rule_id)

rasa/api.py

@@ -0,0 +1,146 @@
+from typing import Any, Text, Dict, Union, List, Optional, TYPE_CHECKING
+import asyncio
+import rasa.shared.constants
+
+# 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
+
+
+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
+    from rasa.core.utils import AvailableEndpoints
+    from rasa.shared.utils.cli import print_warning
+    import rasa.shared.utils.common
+    from rasa.shared.constants import DOCS_BASE_URL
+
+    _endpoints = AvailableEndpoints.read_endpoints(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,
+) -> "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.
+
+    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,
+        )
+    )
+
+
+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
+    from rasa.model_testing import 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,81 @@
+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_arguments(parser: argparse.ArgumentParser, data_type: Text) -> None:
+    """Sets convert 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_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,165 @@
+import argparse
+import logging
+from typing import Text, Union, Optional
+
+from rasa.shared.constants import (
+    DEFAULT_CONFIG_PATH,
+    DEFAULT_DOMAIN_PATH,
+    DEFAULT_MODELS_PATH,
+    DEFAULT_DATA_PATH,
+    DEFAULT_ENDPOINTS_PATH,
+)
+
+
+def add_model_param(
+    parser: argparse.ArgumentParser,
+    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] = DEFAULT_DOMAIN_PATH,
+) -> 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.",
+    )

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."
+        ),
+    )