rasa-pro 3.9.17__py3-none-any.whl → 3.10.3__py3-none-any.whl

README.md

@@ -236,39 +236,6 @@ To check the types execute
 make types
 ```
 
-### Backporting
-
-In order to port changes to `main` and across release branches, we use the `backport` workflow located at
-the `.github/workflows/backport.yml` path.
-This workflow is triggered by the `backport-to-<release-branch>` label applied to a PR, for example `backport-to-3.8.x`.
-Current available target branches are `main` and maintained release branches.
-
-When a PR gets labelled `backport-to-<release-branch>`, a PR is opened by the `backport-github-action` as soon as the
-source PR gets closed (by merging). If you want to close the PR without merging changes, make sure to remove the `backport-to-<release-branch>` label.
-
-The PR author which the action assigns to the backporting PR has to resolve any conflicts before approving and merging.
-Release PRs should also be labelled with `backport-to-main` to backport the `CHANGELOG.md` updates to `main`.
-Backporting version updates should be accepted to the `main` branch from the latest release branch only.
-
-Here are some guidelines to follow when backporting changes and resolving conflicts:
-
-a) for conflicts in `version.py`: accept only the version from the latest release branch. Do not merge version changes
-from earlier release branches into `main` because this could cause issues when trying to make the next minor release.
-
-b) for conflicts in `pyproject.toml`: if related to the `rasa-pro` version, accept only the latest release branch; 
-if related to other dependencies, accept `main` or whichever is the higher upgrade (main usually has the updated 
-dependencies because we only do housekeeping on `main`, apart from vulnerability updates). Be mindful of dependencies that
-are removed from `main` but still exist in former release branches (for example `langchain`).
-
-c) for conflicts in `poetry.lock`: accept changes which were already present on the target branch, then run
-`poetry lock --no-update` so that the lock file contains your changes from `pyproject.toml` too.
-
-d) for conflicts in `CHANGELOG.md`: Manually place the changelog in their allocated section (e.g. 3.8.10 will go under the 
-3.8 section with the other releases, rather than go at the top of the file)
-
-If the backporting workflow fails, you are encouraged to cherry-pick the commits manually and create a PR to
-the target branch. Alternatively, you can install the backporting CLI tool as described [here](https://github.com/sorenlouv/backport?tab=readme-ov-file#install).
-
 ## Releases
 Rasa has implemented robust policies governing version naming, as well as release pace for major, minor, and patch releases.
 
@@ -351,12 +318,9 @@ Releasing a new version is quite simple, as the packages are build and distribut
 9. If however an error occurs in the build, then we should see a failure message automatically posted in the company's Slack (`dev-tribe` channel) like this [one](https://rasa-hq.slack.com/archives/C01M5TAHDHA/p1701444735622919)
    (In this case do the following checks):
     - Check the workflows in [Github Actions](https://github.com/RasaHQ/rasa-private/actions) and make sure that the merged PR of the current release is completed successfully. To easily find your PR you can use the filters `event: push` and `branch: <version number>` (example on release 2.4 you can see [here](https://github.com/RasaHQ/rasa/actions/runs/643344876))
-    - If the workflow is not completed, then try to re-run the workflow in case that solves the problem
+    - If the workflow is not completed, then try to re run the workflow in case that solves the problem
     - If the problem persists, check also the log files and try to find the root cause of the issue
     - If you still cannot resolve the error, contact the infrastructure team by providing any helpful information from your investigation
-10. If the release is successful, add the newly created release branch to the backporting configuration in the `.backportrc.json` file to
-the `targetBranchesChoices` list. This is necessary for the backporting workflow to work correctly with new release branches.
-
 
 ### Cutting a Patch release
 
@@ -405,6 +369,10 @@ steps.
 
 Please refer to the [Rasa Product Release and Maintenance Policy](https://rasa.com/rasa-product-release-and-maintenance-policy/) page.
 
+### Active workflows on the CI
+
+Please refer to the [WORKFLOW_README FILE](https://github.com/RasaHQ/rasa-private/blob/main/WORKFLOW_README.md)
+
 ## Troubleshooting
 
 - When running docker commands, if you encounter this error: `OSError No space left on device`, consider running:

rasa/__init__.py

@@ -1,7 +1,6 @@
 import logging
 
-from rasa import version, plugin  # noqa: F401
-from rasa.api import run, train, test  # noqa: F401
+from rasa import version
 
 # define the version before the other imports since these need it
 __version__ = version.__version__

rasa/__main__.py

@@ -25,6 +25,7 @@ from rasa.cli import (
     visualize,
     x,
     evaluate,
+    llm_fine_tuning,
 )
 from rasa.cli.arguments.default_arguments import add_logging_options
 from rasa.cli.utils import (
@@ -76,6 +77,7 @@ def create_argument_parser() -> argparse.ArgumentParser:
     export.add_subparser(subparsers, parents=parent_parsers)
     x.add_subparser(subparsers, parents=parent_parsers)
     evaluate.add_subparser(subparsers, parents=parent_parsers)
+    llm_fine_tuning.add_subparser(subparsers, parent_parsers)
     plugin_manager().hook.refine_cli(
         subparsers=subparsers, parent_parsers=parent_parsers
     )
@@ -85,12 +87,15 @@ def create_argument_parser() -> argparse.ArgumentParser:
 
 def print_version() -> None:
     """Prints version information of rasa tooling and python."""
+    from rasa.utils.licensing import get_license_expiration_date
+
     print(f"Rasa Version      :         {version.__version__}")
     print(f"Minimum Compatible Version: {MINIMUM_COMPATIBLE_VERSION}")
     print(f"Rasa SDK Version  :         {rasa_sdk_version}")
     print(f"Python Version    :         {platform.python_version()}")
     print(f"Operating System  :         {platform.platform()}")
     print(f"Python Path       :         {sys.executable}")
+    print(f"License Expires   :         {get_license_expiration_date()}")
 
 
 def main() -> None:

rasa/anonymization/anonymization_rule_executor.py

@@ -123,7 +123,7 @@ class AnonymizationRuleExecutor:
             else None
         )
 
-        self.anonymizer_engine = AnonymizerEngine()
+        self.anonymizer_engine = AnonymizerEngine()  # type: ignore
 
     @staticmethod
     def _validate_anonymization_rule_list(
@@ -146,7 +146,7 @@ class AnonymizationRuleExecutor:
 
         return True
 
-    def run(self, text: Text) -> Text:
+    def run(self, text: Text) -> Optional[Text]:
         """Anonymizes the given text using the given anonymization rule list."""
         if (
             self.analyzer is None

rasa/api.py

@@ -1,6 +1,8 @@
-from typing import Any, Text, Dict, Union, List, Optional, TYPE_CHECKING
 import asyncio
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Union
+
 import rasa.shared.constants
+from rasa.nlu.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
@@ -15,11 +17,11 @@ if TYPE_CHECKING:
 
 
 def run(
-    model: "Text",
-    endpoints: "Text",
-    connector: "Optional[Text]" = None,
-    credentials: "Optional[Text]" = None,
-    **kwargs: "Dict[Text, Any]",
+    model: Text,
+    endpoints: Text,
+    connector: Optional[Text] = None,
+    credentials: Optional[Text] = None,
+    **kwargs: Dict[Text, Any],
 ) -> None:
     """Runs a Rasa model.
 
@@ -34,10 +36,10 @@ def run(
 
     """
     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.core.utils import AvailableEndpoints
     from rasa.shared.constants import DOCS_BASE_URL
+    from rasa.shared.utils.cli import print_warning
 
     _endpoints = AvailableEndpoints.read_endpoints(endpoints)
 
@@ -63,18 +65,19 @@ def run(
 
 
 def train(
-    domain: "Text",
-    config: "Text",
+    domain: Text,
+    config: Text,
     training_files: "Union[Text, List[Text]]",
-    output: "Text" = rasa.shared.constants.DEFAULT_MODELS_PATH,
+    output: Text = rasa.shared.constants.DEFAULT_MODELS_PATH,
     dry_run: bool = False,
     force_training: bool = False,
-    fixed_model_name: "Optional[Text]" = None,
+    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,
+    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,
 ) -> "TrainingResult":
     """Runs Rasa Core and NLU training in `async` loop.
 
@@ -96,6 +99,7 @@ def train(
             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: Remote storage to use for model storage.
 
     Returns:
         An instance of `TrainingResult`.
@@ -116,16 +120,17 @@ def train(
             nlu_additional_arguments=nlu_additional_arguments,
             model_to_finetune=model_to_finetune,
             finetuning_epoch_fraction=finetuning_epoch_fraction,
+            remote_storage=remote_storage,
         )
     )
 
 
 def test(
-    model: "Text",
-    stories: "Text",
-    nlu_data: "Text",
-    output: "Text" = rasa.shared.constants.DEFAULT_RESULTS_PATH,
-    additional_arguments: "Optional[Dict]" = None,
+    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.
 
@@ -136,8 +141,7 @@ def test(
         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
+    from rasa.model_testing import test_core, test_nlu
 
     if additional_arguments is None:
         additional_arguments = {}

rasa/cli/arguments/data.py

@@ -10,8 +10,8 @@ from rasa.cli.arguments.default_arguments import (
 from rasa.shared.constants import DEFAULT_CONVERTED_DATA_PATH
 
 
-def set_convert_arguments(parser: argparse.ArgumentParser, data_type: Text) -> None:
-    """Sets convert command arguments."""
+def set_convert_nlu_arguments(parser: argparse.ArgumentParser, data_type: Text) -> None:
+    """Sets convert nlu command arguments."""
     parser.add_argument(
         "-f",
         "--format",
@@ -32,6 +32,31 @@ def set_convert_arguments(parser: argparse.ArgumentParser, data_type: Text) -> N
     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.")
 

rasa/cli/arguments/default_arguments.py

@@ -1,13 +1,14 @@
 import argparse
 import logging
-from typing import Text, Union, Optional
+from typing import Optional, Text, Union
 
+from rasa.nlu.persistor import RemoteStorageType, StorageType, parse_remote_storage
 from rasa.shared.constants import (
     DEFAULT_CONFIG_PATH,
-    DEFAULT_DOMAIN_PATH,
-    DEFAULT_MODELS_PATH,
     DEFAULT_DATA_PATH,
+    DEFAULT_DOMAIN_PATH,
     DEFAULT_ENDPOINTS_PATH,
+    DEFAULT_MODELS_PATH,
 )
 
 
@@ -163,3 +164,24 @@ def add_logging_options(parser: argparse.ArgumentParser) -> None:
         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))

rasa/cli/arguments/run.py

@@ -1,16 +1,19 @@
-import os
-
 import argparse
+import os
 from typing import Union
 
-from rasa.cli.arguments.default_arguments import add_model_param, add_endpoint_param
+from rasa.cli.arguments.default_arguments import (
+    add_endpoint_param,
+    add_model_param,
+    add_remote_storage_param,
+)
 from rasa.core import constants
 from rasa.env import (
+    AUTH_TOKEN_ENV,
     DEFAULT_JWT_METHOD,
     JWT_METHOD_ENV,
-    JWT_SECRET_ENV,
     JWT_PRIVATE_KEY_ENV,
-    AUTH_TOKEN_ENV,
+    JWT_SECRET_ENV,
 )
 
 
@@ -136,10 +139,7 @@ def add_server_settings_arguments(parser: argparse.ArgumentParser) -> None:
         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.",
-    )
+    add_remote_storage_param(server_arguments)
     server_arguments.add_argument(
         "--ssl-certificate",
         help="Set the SSL Certificate to create a TLS secured server.",

rasa/cli/arguments/train.py

@@ -8,6 +8,7 @@ from rasa.cli.arguments.default_arguments import (
     add_out_param,
     add_domain_param,
     add_endpoint_param,
+    add_remote_storage_param,
 )
 from rasa.graph_components.providers.training_tracker_provider import (
     TrainingTrackerProvider,
@@ -38,6 +39,7 @@ def set_train_arguments(parser: argparse.ArgumentParser) -> None:
     add_endpoint_param(
         parser, help_text="Configuration file for the connectors as a yml file."
     )
+    add_remote_storage_param(parser)
 
 
 def set_train_core_arguments(parser: argparse.ArgumentParser) -> None:

rasa/cli/data.py

@@ -3,28 +3,36 @@ import logging
 import pathlib
 from typing import List
 
+import rasa.cli.utils
 import rasa.shared.core.domain
+import rasa.shared.data
+import rasa.shared.nlu.training_data.loading
+import rasa.shared.nlu.training_data.util
+import rasa.shared.utils.cli
+import rasa.shared.utils.io
+import rasa.utils.common
 from rasa import telemetry
 from rasa.cli import SubParsersAction
 from rasa.cli.arguments import data as arguments
 from rasa.cli.arguments import default_arguments
-import rasa.cli.utils
+from rasa.e2e_test.e2e_config import create_llm_e2e_test_converter_config
+from rasa.e2e_test.e2e_test_converter import E2ETestConverter
+from rasa.e2e_test.utils.e2e_yaml_utils import E2ETestYAMLWriter
 from rasa.shared.constants import (
     DEFAULT_DATA_PATH,
     DEFAULT_CONFIG_PATH,
     DEFAULT_DOMAIN_PATHS,
 )
-import rasa.shared.data
+from rasa.shared.exceptions import RasaException
 from rasa.shared.importers.importer import TrainingDataImporter
-import rasa.shared.nlu.training_data.loading
-import rasa.shared.nlu.training_data.util
-import rasa.shared.utils.cli
-import rasa.utils.common
-import rasa.shared.utils.io
+from rasa.shared.utils.common import minimal_kwargs
 from rasa.shared.utils.yaml import read_yaml_file, write_yaml
+from rasa.utils.beta import ensure_beta_feature_is_enabled
 
 logger = logging.getLogger(__name__)
 
+RASA_PRO_BETA_E2E_CONVERSION_ENV_VAR_NAME = "RASA_PRO_BETA_E2E_CONVERSION"
+
 
 def add_subparser(
     subparsers: SubParsersAction, parents: List[argparse.ArgumentParser]
@@ -71,7 +79,16 @@ def _add_data_convert_parsers(
         help="Converts NLU data between formats.",
     )
     convert_nlu_parser.set_defaults(func=_convert_nlu_data)
-    arguments.set_convert_arguments(convert_nlu_parser, data_type="Rasa NLU")
+    arguments.set_convert_nlu_arguments(convert_nlu_parser, data_type="Rasa NLU")
+
+    convert_e2e_parser = convert_subparsers.add_parser(
+        "e2e",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        parents=parents,
+        help="Convert input sample conversations into E2E test cases.",
+    )
+    convert_e2e_parser.set_defaults(func=convert_data_to_e2e_tests)
+    arguments.set_convert_e2e_arguments(convert_e2e_parser)
 
 
 def _add_data_split_parsers(
@@ -290,3 +307,48 @@ def _migrate_domain(args: argparse.Namespace) -> None:
     import rasa.core.migrate
 
     rasa.core.migrate.migrate_domain_format(args.domain, args.out)
+
+
+def validate_e2e_test_conversion_output_path(output_path: str) -> None:
+    """Validates that the provided output path is within the project directory.
+
+    Args:
+        output_path (str): The output path to be validated.
+
+    Raises:
+        RasaException: If the provided output path is an absolute path.
+    """
+    if pathlib.Path(output_path).is_absolute():
+        raise RasaException(
+            "Please provide a relative output path within the assistant "
+            "project directory in which the command is running."
+        )
+
+
+def convert_data_to_e2e_tests(args: argparse.Namespace) -> None:
+    """Converts sample conversation data into E2E test cases
+    and stores them in the output YAML file.
+
+    Args:
+        args: The arguments passed in from the CLI.
+    """
+    try:
+        ensure_beta_feature_is_enabled(
+            "conversion of sample conversations into end-to-end tests",
+            RASA_PRO_BETA_E2E_CONVERSION_ENV_VAR_NAME,
+        )
+        validate_e2e_test_conversion_output_path(args.output)
+
+        config_path = pathlib.Path(args.output)
+        llm_config = create_llm_e2e_test_converter_config(config_path)
+
+        kwargs = minimal_kwargs(vars(args), E2ETestConverter)
+        converter = E2ETestConverter(llm_config=llm_config, **kwargs)
+        yaml_tests_string = converter.run()
+
+        writer = E2ETestYAMLWriter(output_path=args.output)
+        writer.write_to_file(yaml_tests_string)
+    except RasaException as exc:
+        rasa.shared.utils.cli.print_error_and_exit(
+            f"Failed to convert the data into E2E tests. Error: {exc}"
+        )