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

README.md

@@ -10,35 +10,39 @@
 
 <hr />
 
+<img align="right" height="255" src="https://www.rasa.com/assets/img/sara/sara-open-source-2.0.png" alt="An image of Sara, the Rasa mascot bird, holding a flag that reads Open Source with one wing, and a wrench in the other" title="Rasa Pro">
 
-Rasa Pro is a framework for building scalable, dynamic conversational AI assistants that integrate large language models (LLMs) to enable more contextually aware and agentic interactions. Whether you’re new to conversational AI or an experienced developer, Rasa Pro offers enhanced flexibility, control, and performance for mission-critical applications.
+Rasa Pro is an open core product that extends Rasa Open Source. With over 50 million downloads, Rasa Open Source is the most popular open source framework for building chat and voice-based AI assistants.
 
-Building on the foundation of Rasa Open Source, Rasa Pro adds advanced features like CALM (Conversational AI with Language Models) and Dialogue Understanding (DU), which enable developers to shift from traditional intent-driven systems to LLM-based agents. This allows for more robust, responsive interactions that adhere strictly to business logic, while reducing risks like prompt injection and minimizing hallucinations.
+Rasa Pro introduces CALM, a generative AI-native approach to developing assistants, combined with enterprise-ready analytics, security, and observability capabilities. A paid license is required to run Rasa Pro, but all Rasa Pro code is visible to end users and can be customized as needed.
 
-**Key Features:**
+Rasa Pro is the pro-code component of our enterprise solution, Rasa Platform, for implementing resilient and trustworthy AI assistants at scale. Rasa Studio complements Rasa Pro with a low-code user interface, enabling anyone on your team to create and improve your assistant.
 
-- **Flows for Business Logic:** Easily define business logic through Flows, a simplified way to describe how your AI assistant should handle conversations. Flows help streamline the development process, focusing on key tasks and reducing the complexity involved in managing conversations.
-- **Automatic Conversation Repair:** Ensure seamless interactions by automatically handling interruptions or unexpected inputs. Developers have full control to customize these repairs based on specific use cases.
-- **Customizable and Open:** Fully customizable code that allows developers to modify Rasa Pro to meet specific requirements, ensuring flexibility and adaptability to various conversational AI needs.
-- **Robustness and Control:** Maintain strict adherence to business logic, preventing unwanted behaviors like prompt injection and hallucinations, leading to more reliable responses and secure interactions.
-- **Built-in Security:** Safeguard sensitive data, control access, and ensure secure deployment, essential for production environments that demand high levels of security and compliance.
+---
+- 🤓 [Read The Docs](https://rasa.com/docs/rasa-pro/)
 
+- 😁 [Install Rasa Pro](https://rasa.com/docs/rasa-pro/installation/python/installation)
 
+---
 
-A [free developer license](https://rasa.com/docs/rasa-pro/developer-edition/) is available so you can explore and get to know Rasa Pro. For small production deployments, the Extended Developer License allows you to take your assistant live in a limited capacity. A paid license is required for larger-scale production use, but all code is visible and can be customized as needed.
+## README Contents:
+- [Development Internals](#development-internals)
+- [Releases](#releases)
+- [Troubleshooting](#troubleshooting)
 
-To get started right now, you can 
+## Development Internals
 
-`pip install rasa-pro` 
+### Installing Poetry
 
-Check out our 
+Rasa uses Poetry for packaging and dependency management. If you want to build it from source,
+you have to install Poetry first. Please follow
+[the official guide](https://python-poetry.org/docs/#installation) to see all possible options.
 
-- [Rasa-pro Quickstart](https://rasa.com/docs/rasa-pro/installation/quickstart/),
-- [Conversational AI with Language Models (CALM) conceptual rundown](https://rasa.com/docs/rasa-pro/calm/),
-- [Rasa Pro / CALM tutorial](https://rasa.com/docs/rasa-pro/tutorial), and
-- [Rasa pro changelog](https://rasa.com/docs/rasa/rasa-pro-changelog/)
+To update an existing poetry version to the [version](.github/poetry_version.txt), currently used in rasa, run:
+```shell
+    poetry self update <version>
+```
 
-<<<<<<< HEAD
 ### Managing environments
 
 The official [Poetry guide](https://python-poetry.org/docs/managing-environments/) suggests to use
@@ -232,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.
 
@@ -347,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
 
@@ -401,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:
@@ -410,6 +382,3 @@ Please refer to the [Rasa Product Release and Maintenance Policy](https://rasa.c
   ```
 
   For more information on this command, please see the [Official Docker Documentation](https://docs.docker.com/engine/reference/commandline/system_prune/).
-=======
-for more. Also feel free to reach out to us on the [Rasa forum](https://forum.rasa.com/).
->>>>>>> 2c5cd7bc639 (update readme.md from main branch on 3.10.x (#1597))

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}"
+        )