rasa-pro 3.12.0.dev13__py3-none-any.whl → 3.12.0rc2__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.0rc2"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rasa-pro
-Version: 3.12.0.dev13
+Version: 3.12.0rc2
 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)
@@ -63,6 +64,7 @@ Requires-Dist: jsonschema (>=4.22)
 Requires-Dist: keras (==2.14.0)
 Requires-Dist: langchain (>=0.2.0,<0.3.0)
 Requires-Dist: langchain-community (>=0.2.0,<0.3.0)
+Requires-Dist: langcodes (>=3.5.0,<4.0.0)
 Requires-Dist: litellm (>=1.52.6,<1.53.0)
 Requires-Dist: matplotlib (>=3.7,<3.8)
 Requires-Dist: mattermostwrapper (>=2.2,<2.3)
@@ -156,15 +158,14 @@ Description-Content-Type: text/markdown
 
 <div align="center">
 
-[![Build Status](https://github.com/RasaHQ/rasa-private/workflows/Continuous%20Integration/badge.svg)](https://github.com/RasaHQ/rasa-private/actions)
 [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=RasaHQ_rasa&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=RasaHQ_rasa)
-[![Documentation Status](https://img.shields.io/badge/docs-stable-brightgreen.svg)](https://rasa.com/docs/rasa-pro/)
+[![Documentation Status](https://img.shields.io/badge/docs-stable-brightgreen.svg)](https://rasa.com/docs/docs/pro/intro)
+![Python version support](https://img.shields.io/pypi/pyversions/rasa-pro)
 
 </div>
 
 <hr />
 
-
 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.
 
 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.
@@ -177,20 +178,18 @@ Building on the foundation of Rasa Open Source, Rasa Pro adds advanced features
 - **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.
 
+A [free developer license](https://rasa.com/docs/pro/intro/#who-rasa-pro-is-for) is available so you can explore and get to know Rasa Pro. It allows you to take your assistant live in production a limited capacity. A paid license is required for larger-scale production use, but all code is visible and can be customized as needed.
 
+To get started right now, you can
 
-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.
-
-To get started right now, you can 
-
-`pip install rasa-pro` 
+`pip install rasa-pro`
 
-Check out our 
+Check out our
 
-- [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/)
+- [Rasa-pro Quickstart](https://rasa.com/docs/learn/quickstart/pro),
+- [Conversational AI with Language Models (CALM) conceptual rundown](https://rasa.com/docs/learn/concepts/calm),
+- [Rasa Pro / CALM tutorial](https://rasa.com/docs/pro/tutorial), and
+- [Rasa pro changelog](https://rasa.com/docs/reference/changelogs/rasa-pro-changelog)
 
 for more. Also feel free to reach out to us on the [Rasa forum](https://forum.rasa.com/).