rasa-pro 3.11.5__py3-none-any.whl → 3.12.0__py3-none-any.whl

rasa/e2e_test/utils/io.py

@@ -6,7 +6,7 @@ import sys
 from functools import lru_cache
 from pathlib import Path
 from textwrap import dedent
-from typing import Any, Dict, Generator, List, Optional, TYPE_CHECKING, Tuple, Union
+from typing import TYPE_CHECKING, Any, Dict, Generator, List, Optional, Tuple, Union
 
 import matplotlib.pyplot as plt
 import pandas as pd
@@ -27,7 +27,11 @@ from rasa.e2e_test.constants import (
     STATUS_PASSED,
     STUB_CUSTOM_ACTION_NAME_SEPARATOR,
 )
-from rasa.e2e_test.e2e_test_case import Fixture, Metadata, TestSuite, TestCase
+from rasa.e2e_test.e2e_test_case import Fixture, Metadata, TestCase, TestSuite
+from rasa.e2e_test.stub_custom_action import (
+    StubCustomAction,
+    get_stub_custom_action_key,
+)
 from rasa.e2e_test.utils.validation import (
     read_e2e_test_schema,
     validate_path_to_test_cases,
@@ -41,11 +45,10 @@ from rasa.shared.utils.yaml import (
 from rasa.utils.beta import BetaNotEnabledException, ensure_beta_feature_is_enabled
 
 if TYPE_CHECKING:
-    from rasa.e2e_test.e2e_test_result import TestResult
     from rasa.e2e_test.aggregate_test_stats_calculator import AccuracyCalculation
+    from rasa.e2e_test.e2e_test_result import TestResult
 
 
-RASA_PRO_BETA_E2E_ASSERTIONS_ENV_VAR_NAME = "RASA_PRO_BETA_E2E_ASSERTIONS"
 RASA_PRO_BETA_STUB_CUSTOM_ACTION_ENV_VAR_NAME = "RASA_PRO_BETA_STUB_CUSTOM_ACTION"
 
 structlogger = structlog.get_logger()
@@ -274,16 +277,6 @@ def split_into_passed_failed(
     return passed_cases, failed_cases
 
 
-def has_test_case_with_assertions(test_cases: List["TestCase"]) -> bool:
-    """Check if the test cases contain assertions."""
-    try:
-        next(test_case for test_case in test_cases if test_case.uses_assertions())
-    except StopIteration:
-        return False
-
-    return True
-
-
 @lru_cache(maxsize=1)
 def extract_test_case_from_path(path: str) -> Tuple[str, str]:
     """Extract test case from path if specified.
@@ -318,6 +311,104 @@ def is_test_case_file(file_path: Union[str, Path]) -> bool:
     )
 
 
+def extract_test_cases(
+    test_file_content: dict,
+    test_case_name: str,
+    test_file: str,
+) -> List[TestCase]:
+    """Extract test cases from the test file content.
+
+    Args:
+        test_file_content: Content of the test file.
+        test_case_name: Name of the test case to extract.
+        test_file: Path to the test file.
+
+    Returns:
+        List of test cases.
+    """
+    test_cases_content = test_file_content.get(KEY_TEST_CASES) or []
+    if test_case_name:
+        return [
+            TestCase.from_dict(test_case_dict, file=test_file)
+            for test_case_dict in test_cases_content
+            if test_case_name == test_case_dict.get(KEY_TEST_CASE)
+        ]
+    return [
+        TestCase.from_dict(test_case_dict, file=test_file)
+        for test_case_dict in test_cases_content
+    ]
+
+
+def extract_fixtures(
+    test_file_content: dict, existing_fixtures: Dict[str, Fixture]
+) -> Dict[str, Fixture]:
+    """Extract fixtures from the test file content.
+
+    Args:
+        test_file_content: Content of the test file.
+        existing_fixtures: Existing fixtures.
+
+    Returns:
+        Dict of fixtures.
+    """
+    fixtures_content = test_file_content.get(KEY_FIXTURES) or []
+    _fixtures = {}
+    for fixture in fixtures_content:
+        fixture_obj = Fixture.from_dict(fixture_dict=fixture)
+        if existing_fixtures.get(fixture_obj.name) is None:
+            _fixtures[fixture_obj.name] = fixture_obj
+    return _fixtures
+
+
+def extract_metadata(
+    test_file_content: dict, existing_metadata: Dict[str, Metadata]
+) -> Dict[str, Metadata]:
+    """Extract metadata from the test file content.
+
+    Args:
+        test_file_content: Content of the test file.
+        existing_metadata: Existing metadata.
+
+    Returns:
+        Dict of metadata.
+    """
+    metadata_contents = test_file_content.get(KEY_METADATA) or []
+    _metadata = {}
+    for metadata_content in metadata_contents:
+        metadata_obj = Metadata.from_dict(metadata_dict=metadata_content)
+        if existing_metadata.get(metadata_obj.name) is None:
+            _metadata[metadata_obj.name] = metadata_obj
+    return _metadata
+
+
+def extract_stub_custom_actions(
+    test_file_content: dict, test_file: str
+) -> Dict[str, StubCustomAction]:
+    """Extract stub custom actions from the test file content.
+
+    Args:
+        test_file_content: Content of the test file.
+        test_file: Path to the test file.
+
+    Returns:
+        Dict of stub custom actions.
+    """
+    stub_custom_actions_contents = test_file_content.get(KEY_STUB_CUSTOM_ACTIONS) or {}
+    _stub_custom_actions = {}
+    for action_name, stub_data in stub_custom_actions_contents.items():
+        if STUB_CUSTOM_ACTION_NAME_SEPARATOR in action_name:
+            stub_custom_action_key = action_name
+        else:
+            test_file_name = Path(test_file).name
+            stub_custom_action_key = get_stub_custom_action_key(
+                test_file_name, action_name
+            )
+        _stub_custom_actions[stub_custom_action_key] = StubCustomAction.from_dict(
+            action_name=action_name, stub_data=stub_data
+        )
+    return _stub_custom_actions
+
+
 def read_test_cases(path: str) -> TestSuite:
     """Read test cases from the given path.
 
@@ -327,92 +418,41 @@ def read_test_cases(path: str) -> TestSuite:
     Returns:
         TestSuite.
     """
-    from rasa.e2e_test.stub_custom_action import (
-        StubCustomAction,
-        get_stub_custom_action_key,
-    )
-
+    # Extract test case path and name
     path, test_case_name = extract_test_case_from_path(path)
     validate_path_to_test_cases(path)
 
+    # Load test files and schema
     test_files = rasa.shared.data.get_data_files([path], is_test_case_file)
     e2e_test_schema = read_e2e_test_schema()
 
+    # Initialize containers
     input_test_cases = []
     fixtures: Dict[str, Fixture] = {}
     metadata: Dict[str, Metadata] = {}
     stub_custom_actions: Dict[str, StubCustomAction] = {}
 
-    beta_flag_verified = False
-
+    # Process each test file
     for test_file in test_files:
         test_file_content = parse_raw_yaml(Path(test_file).read_text(encoding="utf-8"))
 
+        # Validate YAML content using the provided function
         validate_yaml_data_using_schema_with_assertions(
             yaml_data=test_file_content, schema_content=e2e_test_schema
         )
 
-        test_cases_content = test_file_content.get(KEY_TEST_CASES) or []
-
-        if test_case_name:
-            test_cases = [
-                TestCase.from_dict(test_case_dict, file=test_file)
-                for test_case_dict in test_cases_content
-                if test_case_name == test_case_dict.get(KEY_TEST_CASE)
-            ]
-        else:
-            test_cases = [
-                TestCase.from_dict(test_case_dict, file=test_file)
-                for test_case_dict in test_cases_content
-            ]
-
-        beta_flag_verified = verify_beta_feature_flag_for_assertions(
-            test_cases, beta_flag_verified
+        # Parse test cases, fixtures, metadata, and stub custom actions
+        test_cases = extract_test_cases(test_file_content, test_case_name, test_file)
+        fixtures.update(extract_fixtures(test_file_content, fixtures))
+        metadata.update(extract_metadata(test_file_content, metadata))
+        stub_custom_actions.update(
+            extract_stub_custom_actions(test_file_content, test_file)
         )
-
         input_test_cases.extend(test_cases)
-        fixtures_content = test_file_content.get(KEY_FIXTURES) or []
-        for fixture in fixtures_content:
-            fixture_obj = Fixture.from_dict(fixture_dict=fixture)
 
-            # avoid adding duplicates from across multiple files
-            if fixtures.get(fixture_obj.name) is None:
-                fixtures[fixture_obj.name] = fixture_obj
-
-        metadata_contents = test_file_content.get(KEY_METADATA) or []
-        for metadata_content in metadata_contents:
-            metadata_obj = Metadata.from_dict(metadata_dict=metadata_content)
-
-            # avoid adding duplicates from across multiple files
-            if metadata.get(metadata_obj.name) is None:
-                metadata[metadata_obj.name] = metadata_obj
-
-        stub_custom_actions_contents = (
-            test_file_content.get(KEY_STUB_CUSTOM_ACTIONS) or {}
-        )
-
-        for action_name, stub_data in stub_custom_actions_contents.items():
-            if STUB_CUSTOM_ACTION_NAME_SEPARATOR in action_name:
-                stub_custom_action_key = action_name
-            else:
-                test_file_name = Path(test_file).name
-                stub_custom_action_key = get_stub_custom_action_key(
-                    test_file_name, action_name
-                )
-            stub_custom_actions[stub_custom_action_key] = StubCustomAction.from_dict(
-                action_name=action_name,
-                stub_data=stub_data,
-            )
-
-    validate_test_case(test_case_name, input_test_cases)
-    try:
-        if stub_custom_actions:
-            ensure_beta_feature_is_enabled(
-                "enabling stubs for custom actions",
-                RASA_PRO_BETA_STUB_CUSTOM_ACTION_ENV_VAR_NAME,
-            )
-    except BetaNotEnabledException as exc:
-        rasa.shared.utils.cli.print_error_and_exit(str(exc))
+    validate_test_case(test_case_name, input_test_cases, fixtures, metadata)
+    if stub_custom_actions:
+        check_beta_feature_flag_for_custom_actions_stubs()
 
     return TestSuite(
         input_test_cases,
@@ -422,26 +462,16 @@ def read_test_cases(path: str) -> TestSuite:
     )
 
 
-def verify_beta_feature_flag_for_assertions(
-    test_cases: List["TestCase"], beta_flag_verified: bool
-) -> bool:
-    """Verify the beta feature flag for assertions."""
-    if beta_flag_verified:
-        return True
-
-    if not has_test_case_with_assertions(test_cases):
-        return beta_flag_verified
-
+def check_beta_feature_flag_for_custom_actions_stubs() -> None:
+    """Check the beta feature flag for custom actions stub and exit if not enabled."""
     try:
         ensure_beta_feature_is_enabled(
-            "end-to-end testing with assertions",
-            RASA_PRO_BETA_E2E_ASSERTIONS_ENV_VAR_NAME,
+            "enabling stubs for custom actions",
+            RASA_PRO_BETA_STUB_CUSTOM_ACTION_ENV_VAR_NAME,
         )
     except BetaNotEnabledException as exc:
         rasa.shared.utils.cli.print_error_and_exit(str(exc))
 
-    return True
-
 
 def _save_coverage_report(
     report: Optional[pd.DataFrame], test_status: str, output_dir: str

rasa/e2e_test/utils/validation.py

@@ -1,11 +1,12 @@
 import sys
 from pathlib import Path
-from typing import Any, Dict, List, Optional, TYPE_CHECKING, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
 import structlog
 
 import rasa.shared.utils.io
 from rasa.e2e_test.constants import SCHEMA_FILE_PATH
+from rasa.e2e_test.e2e_test_case import Fixture, Metadata
 from rasa.shared.utils.yaml import read_schema_file
 
 if TYPE_CHECKING:
@@ -27,8 +28,24 @@ def validate_path_to_test_cases(path: str) -> None:
         sys.exit(1)
 
 
-def validate_test_case(test_case_name: str, input_test_cases: List["TestCase"]) -> None:
-    """Validate that test case exists."""
+def validate_test_case(
+    test_case_name: str,
+    input_test_cases: List["TestCase"],
+    fixtures: Dict[str, Fixture],
+    metadata: Dict[str, Metadata],
+) -> None:
+    """
+    Validate the test case, its fixtures, and metadata.
+
+    Args:
+        test_case_name (str): The name of the test case to validate.
+        input_test_cases (List["TestCase"]): A list of test cases to validate.
+        fixtures (Dict[str, Fixture]): A dictionary of defined fixtures.
+        metadata (Dict[str, Metadata]): A dictionary of defined metadata.
+
+    Raises:
+        SystemExit: If the test case, fixtures, or metadata are not defined.
+    """
     if test_case_name and not input_test_cases:
         rasa.shared.utils.io.raise_warning(
             f"Test case does not exist: {test_case_name}. "
@@ -38,6 +55,87 @@ def validate_test_case(test_case_name: str, input_test_cases: List["TestCase"])
         )
         sys.exit(1)
 
+    all_good = True
+    for test_case in input_test_cases:
+        all_good_fixtures = validate_test_case_fixtures(test_case, fixtures)
+        all_good_metadata = validate_test_case_metadata(test_case, metadata)
+        all_good = all_good and all_good_fixtures and all_good_metadata
+
+    if not all_good:
+        sys.exit(1)
+
+
+def validate_test_case_fixtures(
+    test_case: "TestCase", fixtures: Dict[str, Fixture]
+) -> bool:
+    """Validates that the fixtures used in the test case are defined.
+
+    Args:
+        test_case (TestCase): The test case to validate.
+        fixtures (Dict[str, Fixture]): A dictionary of defined fixtures.
+
+    Returns:
+        True if all fixtures used in the test case are defined, False otherwise.
+
+    Raises:
+        Logs an error if a fixture used in the test case is not defined.
+    """
+    all_good = True
+    if not test_case.fixture_names:
+        return all_good
+
+    for fixture_name in test_case.fixture_names:
+        if fixture_name not in fixtures:
+            structlogger.error(
+                "validation.validate_test_case_fixtures",
+                event_info=(
+                    f"Fixture '{fixture_name}' referenced in the "
+                    f"test case '{test_case.name}' is not defined."
+                ),
+            )
+            all_good = False
+    return all_good
+
+
+def validate_test_case_metadata(
+    test_case: "TestCase", metadata: Dict[str, Metadata]
+) -> bool:
+    """
+    Validates that the metadata used in the test case and its steps are defined.
+
+    Args:
+        test_case (TestCase): The test case to validate.
+        metadata (Dict[str, Metadata]): A dictionary of defined metadata.
+
+    Returns:
+        True if all fixtures used in the test case are defined, False otherwise.
+
+    Raises:
+        Logs an error if metadata used in the test case or its steps is not defined.
+    """
+    all_good = True
+    if test_case.metadata_name and test_case.metadata_name not in metadata:
+        structlogger.error(
+            "validation.validate_test_case_metadata.test_case_metadata",
+            event_info=(
+                f"Metadata '{test_case.metadata_name}' referenced in "
+                f"the test case '{test_case.name}' is not defined."
+            ),
+        )
+        all_good = False
+
+    for step in test_case.steps:
+        if step.metadata_name and step.metadata_name not in metadata:
+            structlogger.error(
+                "validation.validate_test_case_metadata.step_metadata",
+                event_info=(
+                    f"Metadata '{step.metadata_name}' referenced in the "
+                    f"step of the test case '{test_case.name}' is not defined."
+                ),
+            )
+            all_good = False
+    return all_good
+
 
 def validate_model_path(model_path: Optional[str], parameter: str, default: str) -> str:
     """Validate the model path.

rasa/engine/caching.py

@@ -5,27 +5,25 @@ import logging
 import shutil
 from datetime import datetime
 from pathlib import Path
-from typing import Text, Any, Optional, Tuple, List
+from typing import Any, List, Optional, Text, Tuple
 
+import sqlalchemy as sa
+import sqlalchemy.orm
 from packaging import version
 from sqlalchemy.engine import URL
-
 from sqlalchemy.exc import OperationalError
 from typing_extensions import Protocol, runtime_checkable
 
 import rasa
 import rasa.model
-import rasa.utils.common
 import rasa.shared.utils.common
+import rasa.utils.common
 from rasa.constants import MINIMUM_COMPATIBLE_VERSION
-import sqlalchemy as sa
-import sqlalchemy.orm
-
 from rasa.engine.storage.storage import ModelStorage
 from rasa.shared.engine.caching import (
+    get_cache_database_name,
     get_local_cache_location,
     get_max_cache_size,
-    get_cache_database_name,
 )
 
 logger = logging.getLogger(__name__)

rasa/engine/constants.py

@@ -1,9 +1,9 @@
 from typing import List, Optional
 
 from rasa.core.channels import UserMessage
+from rasa.core.utils import AvailableEndpoints
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.importers.importer import TrainingDataImporter
-from rasa.core.utils import AvailableEndpoints
 
 PLACEHOLDER_IMPORTER = "__importer__"
 PLACEHOLDER_MESSAGE = "__message__"

rasa/engine/graph.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
+import asyncio
 import dataclasses
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
-from typing import Any, Callable, Dict, List, Optional, Text, Type, Tuple, Union
+from typing import Any, Callable, Dict, List, Optional, Text, Tuple, Type, Union
 
 import structlog
-import asyncio
 
 import rasa.shared.utils.common
 import rasa.utils.common
@@ -640,3 +640,4 @@ class GraphModelConfiguration:
     language: Optional[Text]
     core_target: Optional[Text]
     nlu_target: Optional[Text]
+    additional_languages: Optional[List[Text]]

rasa/engine/language.py

@@ -0,0 +1,182 @@
+from dataclasses import dataclass
+from typing import Any, Dict, Text
+
+from langcodes import Language as LangcodesLanguage
+from langcodes import standardize_tag
+from langcodes.tag_parser import LanguageTagError
+
+from rasa.shared.exceptions import RasaException
+
+CUSTOM_LANGUAGE_CODE_PREFIX = "x-"
+
+
+@dataclass(frozen=True)
+class Language:
+    code: str
+    label: str
+    is_default: bool
+
+    @classmethod
+    def from_language_code(
+        cls, language_code: str, is_default: bool = False
+    ) -> "Language":
+        """Creates a Language object from a language code.
+
+        Args:
+            language_code: The language code.
+            is_default: Whether the language is the default language.
+
+        Returns:
+            A Language object.
+
+        Raises:
+            RasaException: If the language code or custom language code is invalid.
+        """
+        if cls.is_custom_language_code(language_code):
+            cls.validate_custom_language_code(language_code)
+        elif not cls.is_language_code_bcp_47_standard(language_code):
+            raise RasaException(
+                f"Language '{language_code}' is not a BCP 47 standard language code."
+            )
+
+        language = LangcodesLanguage.get(language_code)
+        return cls(
+            code=language_code,
+            label=cls.get_language_label(language),
+            is_default=is_default,
+        )
+
+    @staticmethod
+    def is_language_code_bcp_47_standard(language_code: str) -> bool:
+        """Checks if a language code is a BCP 47 standard language code.
+
+        Args:
+            language_code: The language code to check.
+
+        Returns:
+            `True` if the language code is a BCP 47 standard, `False` otherwise.
+        """
+        try:
+            standardized_language_code = standardize_tag(language_code)
+            return (
+                standardized_language_code == language_code
+                and LangcodesLanguage.get(language_code).is_valid()
+            )
+        except LanguageTagError:
+            return False
+
+    @staticmethod
+    def is_custom_language_code(language_code: str) -> bool:
+        """Checks if a language code is a custom language code.
+
+        Args:
+            language_code: The language code to check.
+
+        Returns:
+            `True` if the language code is a custom language code, `False` otherwise.
+        """
+        return language_code.startswith(CUSTOM_LANGUAGE_CODE_PREFIX)
+
+    @classmethod
+    def get_language_label(cls, language: LangcodesLanguage) -> str:
+        """Gets the display name of a language.
+
+        For custom languages (in the format "x-<base_lang>-<custom_label>"),
+        the label is derived from the base language code.
+        This method considers that the language code has previously been validated.
+
+        Args:
+            language: The language code.
+
+        Returns:
+            The display name of the language.
+        """
+        language_code = str(language)
+
+        if cls.is_custom_language_code(language_code):
+            # If it's a custom language, derive the label from the base language code.
+            without_prefix = language_code[len(CUSTOM_LANGUAGE_CODE_PREFIX) :]
+            base_language_code, _ = without_prefix.rsplit("-", 1)
+            base_language = LangcodesLanguage.get(base_language_code)
+            return base_language.display_name()
+        else:
+            return language.display_name()
+
+    @classmethod
+    def validate_language(cls, language: LangcodesLanguage) -> None:
+        """Validates a language code.
+
+        Args:
+            language: The language object to validate.
+
+        Raises:
+            RasaException: If the language validation fails.
+        """
+        if not language.is_valid():
+            raise RasaException(f"Language '{language}' is not a valid language code.")
+
+        language_code = str(language)
+        if language_code.startswith(CUSTOM_LANGUAGE_CODE_PREFIX):
+            cls.validate_custom_language_code(language_code)
+
+    @classmethod
+    def validate_custom_language_code(cls, custom_language_code: str) -> None:
+        """Validates a custom language code.
+
+        A valid custom language code should adhere to the format:
+          "x-<existing_language_code>-<custom_label>"
+        Example: x-en-formal or x-en-US-formal.
+
+        Args:
+            custom_language_code: The custom language code to validate.
+
+        Raises:
+            RasaException: If the custom language code validation fails.
+        """
+        # Ensure the custom language code starts with the custom prefix.
+        if not custom_language_code.startswith(CUSTOM_LANGUAGE_CODE_PREFIX):
+            raise RasaException(
+                f"Custom language '{custom_language_code}' must "
+                f"start with '{CUSTOM_LANGUAGE_CODE_PREFIX}'."
+            )
+
+        # Remove the custom prefix.
+        without_prefix = custom_language_code[len(CUSTOM_LANGUAGE_CODE_PREFIX) :]
+        if "-" not in without_prefix:
+            raise RasaException(
+                f"Custom language '{custom_language_code}' must be in the format "
+                f"'{CUSTOM_LANGUAGE_CODE_PREFIX}<language_code>-<custom_label>'."
+            )
+
+        base_language_code, custom_label = without_prefix.rsplit("-", 1)
+        if not base_language_code:
+            raise RasaException(
+                f"Base language in '{custom_language_code}' cannot be empty. "
+                f"Expected custom language code format is "
+                f"'{CUSTOM_LANGUAGE_CODE_PREFIX}<language_code>-<custom_label>'."
+            )
+        if not custom_label:
+            raise RasaException(
+                f"Custom label in '{custom_language_code}' cannot be empty."
+                f"Expected custom language code format is "
+                f"'{CUSTOM_LANGUAGE_CODE_PREFIX}<language_code>-<custom_label>'."
+            )
+
+        # Validate the base language code using langcodes.
+        if not cls.is_language_code_bcp_47_standard(base_language_code):
+            raise RasaException(
+                f"Base language '{base_language_code}' in custom language "
+                f"'{custom_language_code}' is not a valid language code."
+            )
+
+    def as_dict(self) -> Dict[Text, Any]:
+        """Converts the Language dataclass instance into a dictionary.
+
+        Returns:
+            A dictionary representing the Language object.
+        """
+        return {
+            "code": self.code,
+            "label": self.label,
+            "is_default": self.is_default,
+        }

rasa/engine/recipes/config_files/default_config.yml

@@ -9,6 +9,10 @@ assistant_id: placeholder_default
 # Configuration for the Rasa NLU components.
 # https://rasa.com/docs/rasa-pro/nlu-based-assistants/components
 language: en
+additional_languages:
+  - it
+  - de
+  - es
 
 pipeline:
   - name: WhitespaceTokenizer