rasa-pro 3.13.1a18__py3-none-any.whl → 3.13.1a20__py3-none-any.whl

rasa/exceptions.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import Text
+from typing import Any, Dict, Text
 
 from packaging import version
 
@@ -51,6 +51,31 @@ class MissingDependencyException(RasaException):
     """Raised if a python package dependency is needed, but not installed."""
 
 
+class DetailedRasaException(RasaException):
+    """Base class for exceptions that carry an error code and extra context."""
+
+    def __init__(self, *, code: str, event_info: str, **ctx: Any) -> None:
+        super().__init__(event_info)
+        self.code: str = code
+        self.info: str = event_info
+        self.ctx: Dict[str, Any] = ctx
+
+    def __str__(self) -> str:
+        return self.info
+
+
+class HealthCheckError(DetailedRasaException):
+    """Raised when an error occurs during health checks."""
+
+
+class EnterpriseSearchPolicyError(DetailedRasaException):
+    """Raised when an error occurs in EnterpriseSearchPolicy."""
+
+
+class ValidationError(DetailedRasaException):
+    """Raised when an error occurs during validation."""
+
+
 @dataclass
 class PublishingError(RasaException):
     """Raised when publishing of an event fails.

rasa/model_manager/model_api.py

@@ -104,7 +104,7 @@ async def update_status_of_all_bots() -> None:
         await update_bot_status(bot)
 
 
-def base_server_url(request: Optional[Request]) -> str:
+def base_server_url(request: Request) -> str:
     """Return the base URL of the server."""
     if SERVER_BASE_URL:
         return SERVER_BASE_URL.rstrip("/")
@@ -570,7 +570,7 @@ def external_blueprint() -> Blueprint:
     """Create a blueprint for the model manager API."""
     from rasa.core.channels.socketio import SocketBlueprint
 
-    sio = AsyncServer(async_mode="sanic", cors_allowed_origins=[])
+    sio = AsyncServer(async_mode="sanic", cors_allowed_origins="*")
     bp = SocketBlueprint(sio, "", "model_api_external")
 
     create_bridge_server(sio, running_bots)

rasa/model_manager/socket_bridge.py

@@ -2,8 +2,7 @@ import json
 from typing import Any, Dict, Optional
 
 import structlog
-from socketio import AsyncServer
-from socketio.asyncio_client import AsyncClient
+from socketio import AsyncClient, AsyncServer  # type: ignore[attr-defined]
 from socketio.exceptions import ConnectionRefusedError
 
 from rasa.model_manager.runner_service import BotSession
@@ -131,6 +130,13 @@ async def create_bridge_client(
         structlogger.debug("model_runner.bot_message", deployment_id=deployment_id)
         await sio.emit("bot_message", data, room=sid)
 
+    @client.event  # type: ignore[misc]
+    async def error(data: Dict[str, Any]) -> None:
+        structlogger.debug(
+            "model_runner.bot_error", deployment_id=deployment_id, data=data
+        )
+        await sio.emit("error", data, room=sid)
+
     @client.event  # type: ignore[misc]
     async def tracker(data: Dict[str, Any]) -> None:
         await sio.emit("tracker", json.loads(data), room=sid)

rasa/shared/providers/_configs/default_litellm_client_config.py

@@ -5,7 +5,7 @@ from typing import Any, Dict
 
 import structlog
 
-import rasa.shared.utils.cli
+from rasa.exceptions import ValidationError
 from rasa.shared.constants import (
     MODEL_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
@@ -124,9 +124,5 @@ class DefaultLiteLLMClientConfig:
                 f"Unsupported parameter - {MODEL_NAME_CONFIG_KEY} is set. Please use "
                 f"{MODEL_CONFIG_KEY} instead."
             )
-            structlogger.error(
-                "default_litellm_client_config.unsupported_parameter_in_config",
-                event_info=event_info,
-                config=config,
-            )
-            rasa.shared.utils.cli.print_error_and_exit(event_info)
+            error_code = "default_litellm_client_config.unsupported_parameter_in_config"
+            raise ValidationError(code=error_code, event_info=event_info, config=config)

rasa/shared/utils/cli.py

@@ -65,6 +65,8 @@ def print_error(*args: Any) -> None:
 
 def print_error_and_exit(message: Text, exit_code: int = 1) -> NoReturn:
     """Print an error message and exit the application.
+    This function is intended only for the CLI module; library code
+    should raise an appropriate exception instead
 
     Args:
         message: The error message to be printed.

rasa/shared/utils/common.py

@@ -373,7 +373,8 @@ def validate_environment(
             importlib.import_module(p)
         except ImportError:
             raise MissingDependencyException(
-                f"Missing package for {component_name}: {p}"
+                f"Missing dependency for {component_name}: {p}. "
+                f"Please ensure the correct package is installed."
             )
 
 

rasa/shared/utils/health_check/health_check.py

@@ -1,7 +1,7 @@
 import os
-import sys
 from typing import Any, Dict, Optional
 
+from rasa.exceptions import HealthCheckError
 from rasa.shared.constants import (
     LLM_API_HEALTH_CHECK_DEFAULT_VALUE,
     LLM_API_HEALTH_CHECK_ENV_VAR,
@@ -23,8 +23,8 @@ def try_instantiate_llm_client(
     try:
         return llm_factory(custom_llm_config, default_llm_config)
     except (ProviderClientValidationError, ValueError) as e:
-        structlogger.error(
-            f"{log_source_function}.llm_instantiation_failed",
+        raise HealthCheckError(
+            code=f"{log_source_function}.llm_instantiation_failed",
             event_info=(
                 f"Unable to create the LLM client for component - "
                 f"{log_source_component}. "
@@ -33,7 +33,6 @@ def try_instantiate_llm_client(
             ),
             error=e,
         )
-        sys.exit(1)
 
 
 def try_instantiate_embedder(
@@ -46,8 +45,8 @@ def try_instantiate_embedder(
     try:
         return embedder_factory(custom_embeddings_config, default_embeddings_config)
     except (ProviderClientValidationError, ValueError) as e:
-        structlogger.error(
-            f"{log_source_function}.embedder_instantiation_failed",
+        raise HealthCheckError(
+            code=f"{log_source_function}.embedder_instantiation_failed",
             event_info=(
                 f"Unable to create the Embedding client for component - "
                 f"{log_source_component}. Please make sure you specified the required "
@@ -55,7 +54,6 @@ def try_instantiate_embedder(
             ),
             error=e,
         )
-        sys.exit(1)
 
 
 def perform_llm_health_check(
@@ -200,16 +198,15 @@ def send_test_llm_api_request(
     try:
         llm_client.completion("hello")
     except Exception as e:
-        structlogger.error(
-            f"{log_source_function}.send_test_llm_api_request_failed",
+        raise HealthCheckError(
+            code=f"{log_source_function}.send_test_llm_api_request_failed",
             event_info=(
                 f"Test call to the LLM API failed for component - "
-                f"{log_source_component}.",
+                f"{log_source_component}."
             ),
             config=llm_client.config,
             error=e,
         )
-        sys.exit(1)
 
 
 def send_test_embeddings_api_request(
@@ -231,8 +228,8 @@ def send_test_embeddings_api_request(
     try:
         embedder.embed(["hello"])
     except Exception as e:
-        structlogger.error(
-            f"{log_source_function}.send_test_llm_api_request_failed",
+        raise HealthCheckError(
+            code=f"{log_source_function}.send_test_llm_api_request_failed",
             event_info=(
                 f"Test call to the Embeddings API failed for component - "
                 f"{log_source_component}."
@@ -240,7 +237,6 @@ def send_test_embeddings_api_request(
             config=embedder.config,
             error=e,
         )
-        sys.exit(1)
 
 
 def is_api_health_check_enabled() -> bool:

rasa/studio/upload.py

@@ -108,9 +108,10 @@ def run_validation(args: argparse.Namespace) -> None:
     """
     from rasa.validator import Validator
 
+    training_data_paths = args.data if isinstance(args.data, list) else [args.data]
     training_data_importer = TrainingDataImporter.load_from_dict(
         domain_path=args.domain,
-        training_data_paths=[args.data],
+        training_data_paths=training_data_paths,
         config_path=args.config,
         expand_env_vars=False,
     )
@@ -238,9 +239,11 @@ def build_calm_import_parts(
     Returns:
         The assistant name and the parts to be uploaded
     """
+    training_data_paths = data_path if isinstance(data_path, list) else [str(data_path)]
     importer = TrainingDataImporter.load_from_dict(
         domain_path=domain_path,
         config_path=config_path,
+        training_data_paths=training_data_paths,
         expand_env_vars=False,
     )
 
@@ -314,9 +317,10 @@ def upload_nlu_assistant(
         "rasa.studio.upload.nlu_data_read",
         event_info="Found DM1 assistant data, parsing...",
     )
+    training_data_paths = args.data if isinstance(args.data, list) else [args.data]
     importer = TrainingDataImporter.load_from_dict(
         domain_path=args.domain,
-        training_data_paths=[args.data],
+        training_data_paths=training_data_paths,
         config_path=args.config,
         expand_env_vars=False,
     )

rasa/studio/utils.py

@@ -1,33 +1,44 @@
 import argparse
 from pathlib import Path
+from typing import List
 
 import rasa.shared.utils.cli
-from rasa.shared.constants import (
-    DEFAULT_CONFIG_PATH,
-    DEFAULT_DATA_PATH,
-    DEFAULT_ENDPOINTS_PATH,
-)
-from rasa.studio.constants import DOMAIN_FILENAME
+
+DOMAIN_FILENAME = "domain.yml"
+DEFAULT_CONFIG_PATH = "config.yml"
+DEFAULT_ENDPOINTS_PATH = "endpoints.yml"
+DEFAULT_DATA_PATH = "data"
 
 
 def validate_argument_paths(args: argparse.Namespace) -> None:
-    """Validates the paths provided in the command line arguments.
+    """Validate every path passed via CLI arguments.
 
     Args:
-        args: The command line arguments containing paths to validate.
+        args: CLI arguments containing paths to validate.
+
+    Raises:
+        rasa.shared.utils.cli.PrintErrorAndExit: If any path does not exist.
     """
+    invalid_paths: List[str] = []
+
+    def collect_invalid_paths(arg_name: str, default: str) -> None:
+        value = getattr(args, arg_name, None)
+        path_values = value if isinstance(value, list) else [value]
+        for path_value in path_values:
+            if not path_value or path_value == default:
+                continue
+
+            if not Path(path_value).resolve().exists():
+                invalid_paths.append(f"{arg_name}: '{path_value}'")
+
+    collect_invalid_paths("domain", DOMAIN_FILENAME)
+    collect_invalid_paths("config", DEFAULT_CONFIG_PATH)
+    collect_invalid_paths("endpoints", DEFAULT_ENDPOINTS_PATH)
+    collect_invalid_paths("data", DEFAULT_DATA_PATH)
 
-    def validate_path(arg_name: str, default: str) -> None:
-        path_value = getattr(args, arg_name, None)
-        if path_value and path_value != default:
-            resolved_path = Path(path_value).resolve()
-            if not resolved_path.exists():
-                rasa.shared.utils.cli.print_error_and_exit(
-                    f"{arg_name.capitalize()} file or directory "
-                    f"'{path_value}' does not exist."
-                )
-
-    validate_path("domain", DOMAIN_FILENAME)
-    validate_path("config", DEFAULT_CONFIG_PATH)
-    validate_path("endpoints", DEFAULT_ENDPOINTS_PATH)
-    validate_path("data", DEFAULT_DATA_PATH)
+    if invalid_paths:
+        message = (
+            "The following files or directories do not exist:\n  - "
+            + "\n  - ".join(invalid_paths)
+        )
+        rasa.shared.utils.cli.print_error_and_exit(message)

rasa/telemetry.py

@@ -3,7 +3,6 @@ import contextlib
 import hashlib
 import inspect
 import json
-import logging
 import multiprocessing
 import os
 import platform
@@ -70,7 +69,7 @@ if typing.TYPE_CHECKING:
     from rasa.shared.importers.importer import TrainingDataImporter
     from rasa.shared.nlu.training_data.training_data import TrainingData
 
-logger = logging.getLogger(__name__)
+structlogger = structlog.get_logger()
 
 SEGMENT_TRACK_ENDPOINT = "https://api.segment.io/v1/track"
 SEGMENT_IDENTIFY_ENDPOINT = "https://api.segment.io/v1/identify"
@@ -197,6 +196,10 @@ TELEMETRY_E2E_TEST_CONVERSION_EVENT = "E2E Test Conversion Completed"
 E2E_TEST_CONVERSION_FILE_TYPE = "file_type"
 E2E_TEST_CONVERSION_TEST_CASE_COUNT = "test_case_count"
 
+# Copilot telemetry
+TELEMETRY_COPILOT_USER_MESSAGE_EVENT = "copilot_user_message"
+TELEMETRY_COPILOT_BOT_MESSAGE_EVENT = "copilot_bot_message"
+
 
 def print_telemetry_reporting_info() -> None:
     """Print telemetry information to std out."""
@@ -255,7 +258,11 @@ def _is_telemetry_enabled_in_configuration() -> bool:
 
         return stored_config[CONFIG_TELEMETRY_ENABLED]
     except ValueError as e:
-        logger.debug(f"Could not read telemetry settings from configuration file: {e}")
+        structlogger.debug(
+            "telemetry.is_telemetry_enabled_in_configuration.error",
+            error=str(e),
+            event_info="Could not read telemetry settings from configuration file",
+        )
 
         # seems like there is no config, we'll create one and enable telemetry
         success = _write_default_telemetry_configuration()
@@ -272,7 +279,10 @@ def is_telemetry_enabled() -> bool:
     from rasa.utils import licensing
 
     if licensing.is_champion_server_license():
-        logger.debug("Telemetry is enabled for developer licenses.")
+        structlogger.debug(
+            "telemetry.enabled.developer_license",
+            event_info="Telemetry is enabled for developer licenses.",
+        )
         return True
 
     telemetry_environ = os.environ.get(TELEMETRY_ENABLED_ENVIRONMENT_VARIABLE)
@@ -308,9 +318,13 @@ def initialize_telemetry() -> bool:
 
         return telemetry_environ.lower() == "true"
     except Exception as e:  # skipcq:PYL-W0703
-        logger.exception(
-            f"Failed to initialize telemetry reporting: {e}."
-            f"Telemetry reporting will be disabled."
+        structlogger.exception(
+            "telemetry.initialize_telemetry.error",
+            error=str(e),
+            event_info=(
+                "Failed to initialize telemetry reporting. "
+                "Telemetry reporting will be disabled."
+            ),
         )
         return False
 
@@ -481,7 +495,10 @@ def print_telemetry_payload(payload: Dict[Text, Any]) -> None:
         payload: payload to be delivered to segment.
     """
     payload_json = json.dumps(payload, indent=2)
-    logger.debug(f"Telemetry payload: {payload_json}")
+    structlogger.debug(
+        "telemetry.print_telemetry_payload.debug",
+        event_info=f"Telemetry payload: {payload_json}",
+    )
 
 
 def _get_telemetry_write_key() -> Optional[Text]:
@@ -535,10 +552,24 @@ def _send_request(url: Text, payload: Dict[Text, Any]) -> None:
     if not write_key:
         # If RASA_TELEMETRY_WRITE_KEY is empty or `None`, telemetry has not
         # been enabled for this build (e.g. because it is running from source)
-        logger.debug("Skipping request to external service: telemetry key not set.")
+        structlogger.debug(
+            "telemetry.send_request.no_telemetry_key",
+            event_info="Skipping request to external service: telemetry key not set.",
+        )
         return
 
-    headers = rasa.telemetry.segment_request_header(write_key)
+    send_segment_request(url, payload, write_key)
+
+
+def send_segment_request(url: Text, payload: Dict[Text, Any], write_key: Text) -> None:
+    """Send a request to the Segment API.
+
+    Args:
+        url: URL of the Segment API endpoint
+        payload: payload to send to the Segment API
+        write_key: write key for the Segment API
+    """
+    headers = segment_request_header(write_key)
 
     resp = requests.post(
         url=url,
@@ -548,15 +579,22 @@ def _send_request(url: Text, payload: Dict[Text, Any]) -> None:
     )
     # handle different failure cases
     if resp.status_code != 200:
-        logger.debug(
-            f"Segment telemetry request returned a {resp.status_code} response. "
-            f"Body: {resp.text}"
+        structlogger.debug(
+            "telemetry.send_segment_request.error_response",
+            event_info=(
+                f"Segment telemetry request returned a {resp.status_code} "
+                f"response. Body: {resp.text}"
+            ),
         )
     else:
         data = resp.json()
         if not data.get("success"):
-            logger.debug(
-                f"Segment telemetry request returned a failure. Response: {data}"
+            structlogger.debug(
+                "telemetry.send_segment_request.failure",
+                event_info=(
+                    f"Segment telemetry request returned a failure. "
+                    f"Response: {data}"
+                ),
             )
 
 
@@ -609,6 +647,15 @@ def with_default_context_fields(
     return {**_default_context_fields(), **context}
 
 
+def get_deployment_stack() -> Text:
+    """Return the deployment stack.
+
+    Returns:
+        The deployment stack.
+    """
+    return os.environ.get("DEPLOYMENT_STACK", "")
+
+
 def _default_context_fields() -> Dict[Text, Any]:
     """Return a dictionary that contains the default context values.
 
@@ -632,6 +679,7 @@ def _default_context_fields() -> Dict[Text, Any]:
             "cpu": multiprocessing.cpu_count(),
             "docker": _is_docker(),
             "license_hash": get_license_hash(),
+            "deployment_stack": get_deployment_stack(),
             "company": property_of_active_license(
                 lambda active_license: active_license.company
             ),
@@ -663,7 +711,10 @@ def _track(
         telemetry_id = get_telemetry_id()
 
         if not telemetry_id:
-            logger.debug("Will not report telemetry events as no ID was found.")
+            structlogger.debug(
+                "telemetry.track.no_id_found",
+                event_info="Will not report telemetry events as no ID was found.",
+            )
             return
 
         if not properties:
@@ -681,7 +732,11 @@ def _track(
                 with_default_context_fields(context),
             )
     except Exception as e:  # skipcq:PYL-W0703
-        logger.debug(f"Skipping telemetry reporting: {e}")
+        structlogger.debug(
+            "telemetry.track.error",
+            error=str(e),
+            event_info="Skipping telemetry reporting",
+        )
 
 
 def _identify(
@@ -702,7 +757,10 @@ def _identify(
         telemetry_id = get_telemetry_id()
 
         if not telemetry_id:
-            logger.debug("Will not report telemetry events as no ID was found.")
+            structlogger.debug(
+                "telemetry.identify.no_id_found",
+                event_info="Will not report telemetry events as no ID was found.",
+            )
             return
 
         if not traits:
@@ -710,7 +768,11 @@ def _identify(
 
         _send_traits(telemetry_id, traits, with_default_context_fields(context))
     except Exception as e:
-        logger.debug(f"Skipping telemetry reporting: {e}")
+        structlogger.debug(
+            "telemetry.identify.error",
+            error=str(e),
+            event_info="Skipping telemetry reporting",
+        )
 
 
 def _send_traits(
@@ -868,13 +930,16 @@ def strip_sensitive_data_from_sentry_event(
 
 
 @ensure_telemetry_enabled
-def initialize_error_reporting() -> None:
+def initialize_error_reporting(private_mode: bool = True) -> None:
     """Sets up automated error reporting.
 
     Exceptions are reported to sentry. We avoid sending any metadata (local
     variables, paths, ...) to make sure we don't compromise any data. Only the
     exception and its stacktrace is logged and only if the exception origins
     from the `rasa` package.
+
+    Args:
+        private_mode: If True, try to send as little data as possible.
     """
     import sentry_sdk
     from sentry_sdk import configure_scope
@@ -892,11 +957,18 @@ def initialize_error_reporting() -> None:
 
     telemetry_id = get_telemetry_id()
 
+    # in hello rasa we use a different project, so we need to be able
+    # to set the whole url. since we can't change the behavior of sentry in pro
+    # we have two kinds of keys, full urls and jsut the key within the fixed rasa
+    # pro project.
+    if not key.startswith("https://"):
+        key = f"https://{key}.ingest.sentry.io/2801673"
+
     # this is a very defensive configuration, avoiding as many integrations as
     # possible. it also submits very little data (exception with error message
     # and line numbers).
     sentry_sdk.init(
-        f"https://{key}.ingest.sentry.io/2801673",
+        key,
         before_send=before_send,
         integrations=[
             ExcepthookIntegration(),
@@ -916,7 +988,7 @@ def initialize_error_reporting() -> None:
             OSError,
         ],
         in_app_include=["rasa"],  # only submit errors in this package
-        include_local_variables=False,  # don't submit local variables
+        include_local_variables=not private_mode,
         release=f"rasa-{rasa.__version__}",
         default_integrations=False,
         environment="development" if in_continuous_integration() else "production",
@@ -937,6 +1009,7 @@ def initialize_error_reporting() -> None:
                 # os is a nested dict, hence we report it separately
                 scope.set_context("Operating System", default_context.pop("os"))
             scope.set_context("Environment", default_context)
+    structlogger.debug("telemetry.sentry.initialized")
 
 
 @contextlib.contextmanager

rasa/utils/licensing.py

@@ -20,7 +20,8 @@ from rasa.shared.utils.cli import print_error_and_exit
 if typing.TYPE_CHECKING:
     from rasa.core.tracker_stores.tracker_store import TrackerStore
 
-LICENSE_ENV_VAR = "RASA_PRO_LICENSE"
+LICENSE_ENV_VAR = "RASA_LICENSE"
+LICENSE_ENV_VAR_LEGACY = "RASA_PRO_LICENSE"
 ALGORITHM = "RS256"
 # deepcode ignore HardcodedKey: This is a public key - not a security issue.
 PUBLIC_KEY = """-----BEGIN PUBLIC KEY-----
@@ -265,12 +266,22 @@ class License:
 
 def retrieve_license_from_env() -> Text:
     """Return the license found in the env var."""
+    # Check environment variables first
+    license_value = os.environ.get(LICENSE_ENV_VAR) or os.environ.get(
+        LICENSE_ENV_VAR_LEGACY
+    )
+    if license_value:
+        return license_value
+
+    # Fall back to .env file
     stored_env_values = dotenv_values(".env")
-    license_from_env = os.environ.get(LICENSE_ENV_VAR)
-    license = license_from_env or stored_env_values.get(LICENSE_ENV_VAR)
-    if not license:
-        raise LicenseNotFoundException()
-    return license
+    license_value = stored_env_values.get(LICENSE_ENV_VAR) or stored_env_values.get(
+        LICENSE_ENV_VAR_LEGACY
+    )
+    if license_value:
+        return license_value
+
+    raise LicenseNotFoundException()
 
 
 def is_license_expiring_soon(license: License) -> bool:
@@ -297,15 +308,15 @@ def validate_license_from_env(product_area: Text = PRODUCT_AREA) -> None:
     except LicenseNotFoundException:
         structlogger.error("license.not_found.error")
         raise SystemExit(
-            f"A Rasa Pro license is required. "
-            f"Please set the environmental variable "
+            f"A Rasa license is required. "
+            f"Please set the environment variable "
             f"`{LICENSE_ENV_VAR}` to a valid license string. "
         )
     except LicenseValidationException as e:
         structlogger.error("license.validation.error", error=e)
         raise SystemExit(
-            f"Failed to validate Rasa Pro license "
-            f"which was read from environmental variable `{LICENSE_ENV_VAR}`. "
+            f"Failed to validate Rasa license "
+            f"which was read from environment variable `{LICENSE_ENV_VAR}`. "
             f"Please ensure `{LICENSE_ENV_VAR}` is set to a valid license string. "
         )
 

rasa/utils/log_utils.py

@@ -37,7 +37,7 @@ class HumanConsoleRenderer(ConsoleRenderer):
 def configure_structlog(
     log_level: Optional[int] = None,
     include_time: bool = False,
-    additional_processors: Optional[List[structlog.processors.Processor]] = None,
+    additional_processors: Optional[List[structlog.typing.Processor]] = None,
 ) -> None:
     """Configure logging of the server."""
     if log_level is None:  # Log level NOTSET is 0 so we use `is None` here

rasa/utils/tensorflow/transformer.py

@@ -7,7 +7,7 @@ import tensorflow as tf
 from keras.src.utils.control_flow_util import smart_cond
 from tensorflow.keras import backend as K
 
-import rasa.shared.utils.cli
+from rasa.utils.tensorflow.exceptions import TFLayerConfigException
 from rasa.utils.tensorflow.layers import RandomlyConnectedDense
 
 
@@ -48,8 +48,8 @@ class MultiHeadAttention(tf.keras.layers.Layer):
         super().__init__()
 
         if units % num_heads != 0:
-            rasa.shared.utils.cli.print_error_and_exit(
-                f"Value Error: The given transformer size {units} should be a "
+            raise TFLayerConfigException(
+                f"The given transformer size {units} should be a "
                 f"multiple of the number of attention heads {num_heads}."
             )