rasa-pro 3.12.0.dev13__py3-none-any.whl → 3.12.0rc1__py3-none-any.whl

rasa/validator.py

@@ -16,9 +16,12 @@ import rasa.shared.utils.cli
 import rasa.shared.utils.io
 from rasa.core.channels import UserMessage
 from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.engine.language import Language
 from rasa.shared.constants import (
     ASSISTANT_ID_DEFAULT_VALUE,
     ASSISTANT_ID_KEY,
+    CONFIG_ADDITIONAL_LANGUAGES_KEY,
+    CONFIG_LANGUAGE_KEY,
     CONFIG_MANDATORY_KEYS,
     CONFIG_PIPELINE_KEY,
     DOCS_URL_ACTIONS,
@@ -27,6 +30,7 @@ from rasa.shared.constants import (
     DOCS_URL_FORMS,
     DOCS_URL_RESPONSES,
     REQUIRED_SLOTS_KEY,
+    RESPONSE_CONDITION,
     UTTER_PREFIX,
 )
 from rasa.shared.core import constants
@@ -36,6 +40,7 @@ from rasa.shared.core.command_payload_reader import (
 )
 from rasa.shared.core.constants import (
     KEY_ALLOW_NLU_CORRECTION,
+    SLOTS,
     SlotMappingType,
 )
 from rasa.shared.core.domain import (
@@ -44,6 +49,7 @@ from rasa.shared.core.domain import (
 )
 from rasa.shared.core.events import ActionExecuted, ActiveLoop, UserUttered
 from rasa.shared.core.flows import Flow, FlowsList
+from rasa.shared.core.flows.constants import KEY_NAME, KEY_TRANSLATION
 from rasa.shared.core.flows.flow_step_links import IfFlowStepLink
 from rasa.shared.core.flows.steps.action import ActionFlowStep
 from rasa.shared.core.flows.steps.collect import CollectInformationFlowStep
@@ -56,12 +62,14 @@ from rasa.shared.core.flows.utils import (
     warn_deprecated_collect_step_config,
 )
 from rasa.shared.core.generator import TrainingDataGenerator
+from rasa.shared.core.slot_mappings import CoexistenceSystemType
 from rasa.shared.core.slots import BooleanSlot, CategoricalSlot, ListSlot, Slot
 from rasa.shared.core.training_data.story_reader.yaml_story_reader import (
     YAMLStoryReader,
 )
 from rasa.shared.core.training_data.structures import StoryGraph
 from rasa.shared.data import create_regex_pattern_reader
+from rasa.shared.exceptions import RasaException
 from rasa.shared.importers.importer import TrainingDataImporter
 from rasa.shared.nlu.constants import COMMANDS
 from rasa.shared.nlu.training_data.message import Message
@@ -907,6 +915,16 @@ class Validator:
                         f"'{object_id}': {exception}"
                     ),
                 )
+            elif object_id.startswith("utter_"):
+                structlogger.error(
+                    "validator.validate_conditional_response_variation_predicates.error",
+                    utter=object_id,
+                    exception=exception,
+                    event_info=(
+                        f"Could not initialize the predicate found under response "
+                        f"variation '{object_id}': {exception}"
+                    ),
+                )
             else:
                 structlogger.error(
                     "validator.verify_predicates.flow_guard_predicate.error",
@@ -938,7 +956,7 @@ class Validator:
     def _extract_slot_name_and_slot_value(
         self,
         predicate_syntax_tree: Any,
-    ) -> tuple:
+    ) -> Tuple[Optional[List[str]], Optional[Any]]:
         """Extract the slot name and slot value from the predicate syntax tree.
 
         Args:
@@ -1043,15 +1061,15 @@ class Validator:
             False, if validation failed, previous value of all_good, otherwise
         """
         predicate_syntax_tree = self._extract_predicate_syntax_tree(predicate)
-        slot_name, slot_value = self._extract_slot_name_and_slot_value(
+        slot_namespace, slot_value = self._extract_slot_name_and_slot_value(
             predicate_syntax_tree
         )
 
-        if slot_name is None:
+        if slot_namespace is None:
             return all_good
 
-        if slot_name[0] == "slots":
-            slot_name = slot_name[1]
+        if slot_namespace[0] == "slots":
+            slot_name = slot_namespace[1]
             # slots.{{context.variable}} gets evaluated to `slots.None`,
             # these predicates can only be validated during runtime
             if slot_name == "None":
@@ -1272,6 +1290,165 @@ class Validator:
 
         return all_good
 
+    def _get_response_translation_warnings(self) -> list:
+        """Collect warnings for responses missing translations.
+
+        Returns:
+            List of warnings for responses missing translations.
+        """
+        additional_languages = self.config.get(CONFIG_ADDITIONAL_LANGUAGES_KEY) or []
+        response_warnings = []
+
+        for response_name, responses in self.domain.responses.items():
+            provided_languages = set()
+            # For each response variation, we check if the additional
+            # languages are available in at least on variation
+            for response in responses:
+                translation = response.get(KEY_TRANSLATION) or {}
+                for language_code in additional_languages:
+                    if translation.get(language_code):
+                        provided_languages.add(language_code)
+
+            missing_languages = [
+                lang for lang in additional_languages if lang not in provided_languages
+            ]
+            if missing_languages:
+                language_code_str = ", ".join(missing_languages)
+                response_warnings.append(
+                    {
+                        "event": (
+                            "validator.verify_translations.missing_response_translation"
+                        ),
+                        "response": response_name,
+                        "missing_languages": missing_languages,
+                        "event_info": (
+                            f"The response '{response_name}' is "
+                            f"missing a translation for the following "
+                            f"languages: {language_code_str}."
+                        ),
+                    }
+                )
+        return response_warnings
+
+    def _get_flow_translation_warnings(self) -> list:
+        """Collect warnings for flows missing translations.
+
+        Returns:
+            List of warnings for flows missing translations.
+        """
+        additional_languages = self.config.get(CONFIG_ADDITIONAL_LANGUAGES_KEY) or []
+
+        flow_warnings = []
+        for flow in self.flows.underlying_flows:
+            required_field_translation = [KEY_NAME]
+            missing_languages = []
+            for language_code in additional_languages:
+                translation = flow.translation.get(language_code)
+                # If translation for the language code doesn't exist,
+                # or the required fields are not set properly,
+                # we add the language code to the list.
+                if not translation or not all(
+                    getattr(translation, field, None)
+                    for field in required_field_translation
+                ):
+                    missing_languages.append(language_code)
+
+            if missing_languages:
+                language_code_str = ", ".join(missing_languages)
+                flow_warnings.append(
+                    {
+                        "event": (
+                            "validator.verify_translations.missing_flow_translation"
+                        ),
+                        "flow": flow.id,
+                        "missing_languages": missing_languages,
+                        "event_info": (
+                            f"The flow '{flow.id}' is missing the translation for "
+                            f"the following languages: {language_code_str}."
+                        ),
+                    }
+                )
+        return flow_warnings
+
+    def verify_config_language(self) -> bool:
+        """Verify that config languages are properly set up.
+
+        Returns:
+            `True` if all languages are properly set up, `False` otherwise.
+
+        Raises:
+            RasaException: If the default language is listed as an
+            additional language or if the language code is invalid.
+        """
+        language = self.config.get(CONFIG_LANGUAGE_KEY)
+        additional_languages = self.config.get(CONFIG_ADDITIONAL_LANGUAGES_KEY, [])
+
+        # Check if the default language is in the additional languages.
+        if language in additional_languages:
+            raise RasaException(
+                f"The default language '{language}' is listed as an additional "
+                f"language in the configuration file. Please remove it from "
+                f"the list of additional languages."
+            )
+
+        # Verify the language codes by initializing the Language class.
+        for language_code in [language] + additional_languages:
+            Language.from_language_code(language_code=language_code)
+
+        return True
+
+    def verify_translations(self, summary_mode: bool = False) -> bool:
+        """Checks for inconsistencies in translations.
+
+        Args:
+            summary_mode: If True, logs a single aggregated warning per category;
+                otherwise, logs each warning individually.
+
+        Returns:
+            `True` if no inconsistencies were found, `False` otherwise.
+
+        Raises:
+            Warning: Single warning per response or flow missing translations
+            if `summary_mode` is `True`, otherwise one warning per missing translation.
+        """
+        all_good = self.verify_config_language()
+
+        additional_languages = self.config.get(CONFIG_ADDITIONAL_LANGUAGES_KEY, [])
+        if not additional_languages:
+            return all_good
+
+        response_warnings = self._get_response_translation_warnings()
+        flow_warnings = self._get_flow_translation_warnings()
+
+        if summary_mode:
+            if response_warnings:
+                count = len(response_warnings)
+                structlogger.warn(
+                    "validator.verify_translations.missing_response_translation_summary",
+                    count=count,
+                    event_info=(
+                        f"{count} response{' is' if count == 1 else 's are'} "
+                        f"missing translations for some languages. "
+                        "Run 'rasa data validate language' for details."
+                    ),
+                )
+            if flow_warnings:
+                count = len(flow_warnings)
+                structlogger.warn(
+                    "validator.verify_translations.missing_flow_translation_summary",
+                    count=count,
+                    event_info=(
+                        f"{count} flow{' is' if count == 1 else 's are'} "
+                        f"missing translations for some languages. "
+                        "Run 'rasa data validate language' for details."
+                    ),
+                )
+        else:
+            for warning in response_warnings + flow_warnings:
+                structlogger.warn(**warning)
+
+        return all_good
+
     def validate_button_payloads(self) -> bool:
         """Check if the response button payloads are valid."""
         all_good = True
@@ -1410,6 +1587,8 @@ class Validator:
                 controlled_mappings, slot, all_good
             )
 
+            all_good = self._validate_controlled_mappings(slot, all_good)
+
             all_good = self._config_contains_nlu_command_adapter(
                 nlu_mappings, slot.name, all_good
             )
@@ -1577,7 +1756,7 @@ class Validator:
                     collect_step = step.collect
                     flow_slots.add(collect_step)
                     if not step.reset_after_flow_ends:
-                        warn_deprecated_collect_step_config(flow_id, collect_step)
+                        warn_deprecated_collect_step_config()
 
                         if has_flow_level_persistence:
                             structlogger.error(
@@ -1638,10 +1817,15 @@ class Validator:
                 self.verify_predicates(),
             ]
         )
+        valid_translations = self.verify_translations(summary_mode=True)
         valid_calm_slot_mappings = self.validate_CALM_slot_mappings()
 
         all_good = (
-            valid_responses and valid_nlu and valid_flows and valid_calm_slot_mappings
+            valid_responses
+            and valid_nlu
+            and valid_flows
+            and valid_translations
+            and valid_calm_slot_mappings
         )
 
         return all_good
@@ -1765,3 +1949,184 @@ class Validator:
                     all_good = False
 
         return all_good
+
+    def verify_slot_validation(self) -> bool:
+        """Validates the slot validation configuration in the domain file."""
+        all_good = True
+
+        for slot in self.domain._user_slots:
+            if slot.requires_validation():
+                refill_utter = slot.validation.refill_utter  # type: ignore[union-attr]
+                if refill_utter and refill_utter not in self.domain.responses:
+                    self._log_slot_validation_error(
+                        slot.name, "refill utterance", refill_utter
+                    )
+                    all_good = False
+                rejections = slot.validation.rejections  # type: ignore[union-attr]
+                for rejection in rejections:
+                    if rejection.utter not in self.domain.responses:
+                        self._log_slot_validation_error(
+                            slot.name, "rejection utterance", rejection.utter
+                        )
+                        all_good = False
+
+        return all_good
+
+    def _log_slot_validation_error(self, slot_name: str, key: str, value: str) -> None:
+        structlogger.error(
+            "validator.verify_slot_validation.response_not_in_domain",
+            slot=slot_name,
+            event_info=(
+                f"The slot '{slot_name}' requires validation, "
+                f"but the {key} '{value}' "
+                f"is not listed in the domain responses. "
+                f"Please add it to your domain file."
+            ),
+        )
+
+    @staticmethod
+    def _validate_controlled_mappings(slot: Slot, all_good: bool) -> bool:
+        for mapping in slot.mappings:
+            if (
+                mapping.run_action_every_turn is not None
+                and mapping.type != SlotMappingType.CONTROLLED
+            ):
+                structlogger.error(
+                    "validator.validate_slot_mappings_in_CALM.run_action_every_turn_invalid",
+                    slot_name=slot.name,
+                    event_info=(
+                        f"The slot '{slot.name}' has a custom action "
+                        f"'{mapping.run_action_every_turn}' "
+                        f"defined in its slot mapping, "
+                        f"but the slot mapping type is not 'controlled'. "
+                    ),
+                )
+                all_good = False
+
+            if (
+                mapping.coexistence_system is not None
+                and mapping.type != SlotMappingType.CONTROLLED
+            ):
+                structlogger.error(
+                    "validator.validate_slot_mappings_in_CALM.coexistence_system_invalid",
+                    slot_name=slot.name,
+                    event_info=(
+                        f"The slot '{slot.name}' has a coexistence system "
+                        f"'{mapping.coexistence_system.value}' "
+                        f"defined in its slot mapping, "
+                        f"but the slot mapping type is not 'controlled'. "
+                    ),
+                )
+                all_good = False
+
+            if (
+                mapping.coexistence_system is not None
+                and mapping.coexistence_system != CoexistenceSystemType.SHARED
+                and slot.shared_for_coexistence
+            ):
+                structlogger.error(
+                    "validator.validate_slot_mappings_in_CALM.shared_for_coexistence_invalid",
+                    slot_name=slot.name,
+                    event_info=(
+                        f"The slot '{slot.name}' has the `shared_for_coexistence` "
+                        f"property set to `True`, but the slot mapping `controlled` "
+                        f"type defines the `coexistence_system` property with a "
+                        f"value different to the expected `SHARED` value. "
+                    ),
+                )
+                all_good = False
+
+        multiple_controlled_mappings = {
+            mapping.coexistence_system.value
+            for mapping in slot.mappings
+            if mapping.type == SlotMappingType.CONTROLLED
+            and mapping.coexistence_system is not None
+        }
+        contains_inconsistent_coexistence_system = len(multiple_controlled_mappings) > 1
+
+        if contains_inconsistent_coexistence_system:
+            structlogger.error(
+                "validator.validate_slot_mappings_in_CALM.inconsistent_multiple_mappings",
+                slot_name=slot.name,
+                event_info=(
+                    f"The slot '{slot.name}' has multiple `controlled` mappings "
+                    f"with different coexistence systems defined: "
+                    f"'{sorted(list(multiple_controlled_mappings))}'. "
+                    f"Please only define one coexistence system for the slot. "
+                ),
+            )
+            all_good = False
+
+        return all_good
+
+    def validate_conditional_response_variation_predicates(self) -> bool:
+        """Validate the conditional response variation predicates."""
+        context = {"slots": {slot.name: None for slot in self.domain.slots}}
+        all_good = True
+
+        for utter_name, variations in self.domain.responses.items():
+            for variation in variations:
+                condition = variation.get(RESPONSE_CONDITION)
+                if not isinstance(condition, str):
+                    continue
+
+                predicate, all_good = self._construct_predicate(
+                    condition,
+                    utter_name,
+                    context,
+                    is_step=False,
+                    all_good=all_good,
+                )
+                if not predicate:
+                    continue
+
+                if not predicate.is_valid():
+                    structlogger.error(
+                        "validator.validate_conditional_response_variation_predicates.invalid_condition",
+                        utter=utter_name,
+                        event_info=(
+                            f"Detected invalid condition '{condition}' "
+                            f"for response variation '{utter_name}'. "
+                            f"Please make sure that all conditions are valid."
+                        ),
+                    )
+                    all_good = False
+                    continue
+
+                predicate_syntax_tree = self._extract_predicate_syntax_tree(predicate)
+                slot_namespace, _ = self._extract_slot_name_and_slot_value(
+                    predicate_syntax_tree
+                )
+
+                if slot_namespace is not None and slot_namespace[0] != SLOTS:
+                    structlogger.error(
+                        "validator.validate_conditional_response_variation_predicates.invalid_namespace",
+                        utter=utter_name,
+                        event_info=(
+                            f"Detected invalid namespace '{slot_namespace[0]}' in "
+                            f"condition '{condition}' for response variation "
+                            f"'{utter_name}'. Please make sure that you're "
+                            f"using a valid namespace. "
+                            f"The current supported option is: 'slots'."
+                        ),
+                    )
+                    all_good = False
+                    continue
+
+                if (
+                    slot_namespace is not None
+                    and slot_namespace[1] not in self.domain.slots
+                ):
+                    structlogger.error(
+                        "validator.validate_conditional_response_variation_predicates.invalid_slot",
+                        utter=utter_name,
+                        event_info=(
+                            f"Detected invalid slot '{slot_namespace[1]}' in "
+                            f"condition '{condition}' for response variation "
+                            f"'{utter_name}'. Please make sure that all slots "
+                            f"are specified in the domain file."
+                        ),
+                    )
+                    all_good = False
+
+        return all_good

rasa/version.py

@@ -1,3 +1,3 @@
 # this file will automatically be changed,
 # do not add anything but the version number here!
-__version__ = "3.12.0.dev13"
+__version__ = "3.12.0rc1"

{rasa_pro-3.12.0.dev13.dist-info → rasa_pro-3.12.0rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rasa-pro
-Version: 3.12.0.dev13
+Version: 3.12.0rc1
 Summary: State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development.
 Home-page: https://rasa.com
 Keywords: nlp,machine-learning,machine-learning-library,bot,bots,botkit,rasa conversational-agents,conversational-ai,chatbot,chatbot-framework,bot-framework
@@ -31,6 +31,7 @@ Requires-Dist: aiogram (>=3.15,<3.16)
 Requires-Dist: aiohttp (>=3.9.4,<3.10)
 Requires-Dist: apscheduler (>=3.10,<3.11)
 Requires-Dist: attrs (>=23.1,<23.2)
+Requires-Dist: azure-identity (>=1.19.0,<1.20.0)
 Requires-Dist: azure-storage-blob (>=12.16.0,<12.17.0)
 Requires-Dist: boto3 (>=1.35.15,<1.36.0)
 Requires-Dist: certifi (>=2024.07.04)