rasa-pro 3.12.0.dev11__py3-none-any.whl → 3.12.0.dev12__py3-none-any.whl

rasa/telemetry.py

@@ -15,7 +15,7 @@ from collections import defaultdict
 from datetime import datetime
 from functools import wraps
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Text, Tuple
+from typing import Any, Callable, Dict, List, Optional, Text
 
 import importlib_resources
 import requests
@@ -35,7 +35,6 @@ from rasa.constants import (
 )
 from rasa.engine.storage.local_model_storage import LocalModelStorage
 from rasa.shared.constants import (
-    ASSISTANT_ID_KEY,
     CONFIG_LANGUAGE_KEY,
     CONFIG_PIPELINE_KEY,
     CONFIG_POLICIES_KEY,
@@ -112,7 +111,6 @@ CI_ENVIRONMENT_TELL = [
 # https://rasa.com/docs/rasa-pro/telemetry/reference
 TRAINING_STARTED_EVENT = "Training Started"
 TRAINING_COMPLETED_EVENT = "Training Completed"
-TRAINING_FAILED_EVENT = "Training Failed"
 TELEMETRY_DISABLED_EVENT = "Telemetry Disabled"
 TELEMETRY_DATA_SPLIT_EVENT = "Training Data Split"
 TELEMETRY_DATA_VALIDATED_EVENT = "Training Data Validated"
@@ -978,7 +976,6 @@ def track_model_training(
         "language": config.get(CONFIG_LANGUAGE_KEY),
         "training_id": training_id,
         "type": model_type,
-        "assistant_id": config.get(ASSISTANT_ID_KEY),
         "pipeline": config.get(CONFIG_PIPELINE_KEY),
         "policies": config.get(CONFIG_POLICIES_KEY),
         "train_schema": config.get(CONFIG_TRAIN_SCHEMA),
@@ -1024,28 +1021,13 @@ def track_model_training(
         tracking_data,
     )
     start = datetime.now()
-    try:
-        yield
-    except (Exception, SystemExit):
-        runtime = datetime.now() - start
-        _track(
-            TRAINING_FAILED_EVENT,
-            {
-                "training_id": training_id,
-                "assistant_id": config.get(ASSISTANT_ID_KEY),
-                "type": model_type,
-                "runtime": int(runtime.total_seconds()),
-            },
-        )
-        raise
-
+    yield
     runtime = datetime.now() - start
 
     _track(
         TRAINING_COMPLETED_EVENT,
         {
             "training_id": training_id,
-            "assistant_id": config.get(ASSISTANT_ID_KEY),
             "type": model_type,
             "runtime": int(runtime.total_seconds()),
         },
@@ -1344,28 +1326,24 @@ def track_server_start(
     """
     from rasa.core.utils import AvailableEndpoints
 
-    def project_fingerprint_and_assistant_id_from_model(
+    def project_fingerprint_from_model(
         _model_directory: Optional[Text],
-    ) -> Tuple[Optional[Text], Optional[Text]]:
+    ) -> Optional[Text]:
         """Gets project fingerprint from an app's loaded model."""
         if not model_directory:
-            return None, None
+            return None
 
         try:
             model_archive = model.get_local_model(_model_directory)
             metadata = LocalModelStorage.metadata_from_archive(model_archive)
 
-            return metadata.project_fingerprint, metadata.assistant_id
+            return metadata.project_fingerprint
         except Exception:
-            return None, None
+            return None
 
     if not endpoints:
         endpoints = AvailableEndpoints()
 
-    project, assistant_id = project_fingerprint_and_assistant_id_from_model(
-        model_directory
-    )
-
     _track(
         TELEMETRY_SERVER_STARTED_EVENT,
         {
@@ -1387,8 +1365,7 @@ def track_server_start(
             "endpoints_event_broker": endpoints.event_broker.type
             if endpoints.event_broker
             else None,
-            "project": project,
-            "assistant_id": assistant_id,
+            "project": project_fingerprint_from_model(model_directory),
         },
     )
 
@@ -1406,30 +1383,23 @@ def track_project_init(path: Text) -> None:
 
 
 @ensure_telemetry_enabled
-def track_shell_started(model_type: Text, assistant_id: Text) -> None:
+def track_shell_started(model_type: Text) -> None:
     """Track when a user starts a bot using rasa shell.
 
     Args:
         model_type: Type of the model, core / nlu or rasa.
     """
-    _track(
-        TELEMETRY_SHELL_STARTED_EVENT,
-        {"type": model_type, "assistant_id": assistant_id},
-    )
+    _track(TELEMETRY_SHELL_STARTED_EVENT, {"type": model_type})
 
 
 @ensure_telemetry_enabled
-def track_inspect_started(channel: Text, assistant_id: Text) -> None:
+def track_inspect_started(model_type: Text) -> None:
     """Track when a user starts a bot using rasa inspect.
 
     Args:
-        channel: Type of channel used.
-        assistant_id: ID of the assistant being inspected.
+        model_type: Type of the model, core / nlu or rasa.
     """
-    _track(
-        TELEMETRY_INSPECT_STARTED_EVENT,
-        {"type": channel, "assistant_id": assistant_id},
-    )
+    _track(TELEMETRY_INSPECT_STARTED_EVENT, {"type": model_type})
 
 
 @ensure_telemetry_enabled

rasa/utils/common.py

@@ -70,6 +70,7 @@ EXPECTED_WARNINGS: List[Tuple[Type[Warning], str]] = [
         "Converting sparse IndexedSlices.* to a dense Tensor of unknown "
         "shape. This may consume a large amount of memory.",
     ),
+    (UserWarning, "Slot auto-fill has been removed in 3.0 .*"),
     # Cannot fix this deprecation warning since we need to support two
     # numpy versions as long as we keep python 37 around
     (DeprecationWarning, "the `interpolation=` argument to quantile was renamed"),

rasa/validator.py

@@ -35,7 +35,9 @@ from rasa.shared.core.command_payload_reader import (
     CommandPayloadReader,
 )
 from rasa.shared.core.constants import (
-    KEY_ALLOW_NLU_CORRECTION,
+    ACTIVE_LOOP,
+    MAPPING_CONDITIONS,
+    MAPPING_TYPE,
     SlotMappingType,
 )
 from rasa.shared.core.domain import (
@@ -43,14 +45,13 @@ from rasa.shared.core.domain import (
     Domain,
 )
 from rasa.shared.core.events import ActionExecuted, ActiveLoop, UserUttered
-from rasa.shared.core.flows import Flow, FlowsList
+from rasa.shared.core.flows import FlowsList
 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
 from rasa.shared.core.flows.steps.link import LinkFlowStep
 from rasa.shared.core.flows.steps.set_slots import SetSlotsFlowStep
 from rasa.shared.core.flows.utils import (
-    ALL_LABEL,
     get_duplicate_slot_persistence_config_error_message,
     get_invalid_slot_persistence_config_error_message,
     warn_deprecated_collect_step_config,
@@ -517,9 +518,9 @@ class Validator:
 
         for slot in self.domain.slots:
             for mapping in slot.mappings:
-                for condition in mapping.conditions:
-                    condition_active_loop = condition.active_loop
-                    mapping_type = mapping.type
+                for condition in mapping.get(MAPPING_CONDITIONS, []):
+                    condition_active_loop = condition.get(ACTIVE_LOOP)
+                    mapping_type = SlotMappingType(mapping.get(MAPPING_TYPE))
                     if (
                         condition_active_loop
                         and condition_active_loop not in self.domain.form_names
@@ -1263,7 +1264,6 @@ class Validator:
             self.verify_unique_flows(),
             self.verify_predicates(),
             self.verify_slot_persistence_configuration(),
-            self.verify_digression_configuration(),
         ]
 
         all_good = all(flow_validation_conditions)
@@ -1392,22 +1392,34 @@ class Validator:
 
         for slot in self.domain._user_slots:
             nlu_mappings = any(
-                [mapping.type.is_predefined_type() for mapping in slot.mappings]
+                [
+                    SlotMappingType(
+                        mapping.get("type", SlotMappingType.FROM_LLM.value)
+                    ).is_predefined_type()
+                    for mapping in slot.mappings
+                ]
             )
             llm_mappings = any(
-                [mapping.type == SlotMappingType.FROM_LLM for mapping in slot.mappings]
+                [
+                    SlotMappingType(mapping.get("type", SlotMappingType.FROM_LLM.value))
+                    == SlotMappingType.FROM_LLM
+                    for mapping in slot.mappings
+                ]
             )
-            controlled_mappings = any(
+            custom_mappings = any(
                 [
-                    mapping.type == SlotMappingType.CONTROLLED
+                    SlotMappingType(mapping.get("type", SlotMappingType.FROM_LLM.value))
+                    == SlotMappingType.CUSTOM
                     for mapping in slot.mappings
                 ]
             )
 
-            all_good = self._allow_nlu_correction_is_valid(slot, nlu_mappings, all_good)
+            all_good = self._slot_contains_all_mappings_types(
+                llm_mappings, nlu_mappings, custom_mappings, slot.name, all_good
+            )
 
             all_good = self._custom_action_name_is_defined_in_the_domain(
-                controlled_mappings, slot, all_good
+                custom_mappings, slot, all_good
             )
 
             all_good = self._config_contains_nlu_command_adapter(
@@ -1421,45 +1433,23 @@ class Validator:
         return all_good
 
     @staticmethod
-    def _allow_nlu_correction_is_valid(
-        slot: Slot, nlu_mappings: bool, all_good: bool
+    def _slot_contains_all_mappings_types(
+        llm_mappings: bool,
+        nlu_mappings: bool,
+        custom_mappings: bool,
+        slot_name: str,
+        all_good: bool,
     ) -> bool:
-        """Verify that `allow_nlu_correction` property is used correctly in a `from_llm` mappings only."""  # noqa: E501
-        if not slot.mappings:
-            return all_good
-
-        invalid_usage = False
-
-        for mapping in slot.mappings:
-            allow_nlu_correction = mapping.allow_nlu_correction
-            if allow_nlu_correction and mapping.type != SlotMappingType.FROM_LLM:
-                invalid_usage = True
-
-            if allow_nlu_correction and not nlu_mappings:
-                structlogger.error(
-                    "validator.validate_slot_mappings_in_CALM.nlu_mappings_not_present",
-                    slot_name=slot.name,
-                    event_info=(
-                        f"The slot '{slot.name}' does not have any "
-                        f"NLU-based slot mappings. "
-                        f"The property `allow_nlu_correction` is only "
-                        f"applicable when the slot "
-                        f"contains both NLU-based and LLM-based slot mappings."
-                    ),
-                )
-                all_good = False
-
-        if invalid_usage:
+        if llm_mappings and (nlu_mappings or custom_mappings):
             structlogger.error(
-                "validator.validate_slot_mappings_in_CALM.allow_nlu_correction",
-                slot_name=slot.name,
+                "validator.validate_slot_mappings_in_CALM.llm_and_nlu_mappings",
+                slot_name=slot_name,
                 event_info=(
-                    f"The slot '{slot.name}' has at least 1 slot mapping with "
-                    f"'{KEY_ALLOW_NLU_CORRECTION}' set to 'true', but "
-                    f"the slot mapping type is not 'from_llm'. "
-                    f"Please set the slot mapping type to 'from_llm' "
-                    f"to allow the LLM to correct this slot."
+                    f"The slot '{slot_name}' has both LLM and "
+                    f"NLU or custom slot mappings. "
+                    f"Please make sure that the slot has only one type of mapping."
                 ),
+                docs_link=DOCS_URL_DOMAIN + "#calm-slot-mappings",
             )
             all_good = False
 
@@ -1467,32 +1457,55 @@ class Validator:
 
     def _custom_action_name_is_defined_in_the_domain(
         self,
-        controlled_mappings: bool,
+        custom_mappings: bool,
         slot: Slot,
         all_good: bool,
     ) -> bool:
-        if not controlled_mappings:
+        if not custom_mappings:
             return all_good
 
-        for mapping in slot.mappings:
-            if (
-                mapping.run_action_every_turn is not None
-                and mapping.run_action_every_turn
-                not in self.domain.action_names_or_texts
-            ):
-                structlogger.error(
-                    "validator.validate_slot_mappings_in_CALM.custom_action_not_in_domain",
-                    slot_name=slot.name,
-                    action_name=mapping.run_action_every_turn,
-                    event_info=(
-                        f"The slot '{slot.name}' has a custom action "
-                        f"'{mapping.run_action_every_turn}' "
-                        f"defined in its slot mappings, "
-                        f"but the action is not listed in the domain actions. "
-                        f"Please add the action to your domain file."
-                    ),
-                )
-                all_good = False
+        if not self.flows:
+            return all_good
+
+        is_custom_action_defined = any(
+            [
+                mapping.get("action") is not None
+                and mapping.get("action") in self.domain.action_names_or_texts
+                for mapping in slot.mappings
+            ]
+        )
+
+        if is_custom_action_defined:
+            return all_good
+
+        slot_collected_by_flows = any(
+            [
+                step.collect == slot.name
+                for flow in self.flows.underlying_flows
+                for step in flow.steps
+                if isinstance(step, CollectInformationFlowStep)
+            ]
+        )
+
+        if not slot_collected_by_flows:
+            # if the slot is not collected by any flow,
+            # it could be a DM1 custom slot
+            return all_good
+
+        custom_action_ask_name = f"action_ask_{slot.name}"
+        if custom_action_ask_name not in self.domain.action_names_or_texts:
+            structlogger.error(
+                "validator.validate_slot_mappings_in_CALM.custom_action_not_in_domain",
+                slot_name=slot.name,
+                event_info=(
+                    f"The slot '{slot.name}' has a custom slot mapping, but "
+                    f"neither the action '{custom_action_ask_name}' nor "
+                    f"another custom action are defined in the domain file. "
+                    f"Please add one of the actions to your domain file."
+                ),
+                docs_link=DOCS_URL_DOMAIN + "#custom-slot-mappings",
+            )
+            all_good = False
 
         return all_good
 
@@ -1645,123 +1658,3 @@ class Validator:
         )
 
         return all_good
-
-    def verify_digression_configuration(self) -> bool:
-        """Validates the digression configuration in flows."""
-        all_good = True
-
-        for flow in self.flows.underlying_flows:
-            all_good = self._validate_ask_confirm_digressions(flow, all_good)
-            all_good = self._validate_block_digressions(flow, all_good)
-
-        return all_good
-
-    def _validate_ask_confirm_digressions(self, flow: Flow, all_good: bool) -> bool:
-        """Validates the ask_confirm_digressions configuration in a flow."""
-        for flow_id in flow.ask_confirm_digressions:
-            if flow_id == ALL_LABEL:
-                continue
-            if flow_id not in self.flows.flow_ids:
-                structlogger.error(
-                    "validator.verify_digression_configuration.ask_confirm_digressions",
-                    flow=flow.id,
-                    event_info=(
-                        f"The flow '{flow_id}' is listed in the "
-                        f"`ask_confirm_digressions` configuration of flow "
-                        f"'{flow.id}', but it is not found in the "
-                        f"flows file. Please make sure that the flow id is correct."
-                    ),
-                )
-                all_good = False
-
-            if flow_id in flow.block_digressions:
-                structlogger.error(
-                    "validator.verify_digression_configuration.overlap_digressions",
-                    flow=flow.id,
-                    event_info=(
-                        f"The flow '{flow_id}' is listed in both the "
-                        f"`ask_confirm_digressions` and `block_digressions` "
-                        f"configuration of flow '{flow.id}'. "
-                        f"Please make sure that the flow id is not listed in both "
-                        f"configurations."
-                    ),
-                )
-                all_good = False
-
-        for step in flow.get_collect_steps():
-            for flow_id in step.ask_confirm_digressions:
-                if flow_id == ALL_LABEL:
-                    continue
-
-                if flow_id not in self.flows.flow_ids:
-                    structlogger.error(
-                        "validator.verify_digression_configuration.ask_confirm_digressions",
-                        flow=flow.id,
-                        step_id=step.id,
-                        event_info=(
-                            f"The flow '{flow_id}' is listed in the "
-                            f"`ask_confirm_digressions` configuration of step "
-                            f"'{step.id}' in flow '{flow.id}', but it is "
-                            f"not found in the flows file. "
-                            f"Please make sure that the flow id is correct."
-                        ),
-                    )
-                    all_good = False
-
-                if flow_id in step.block_digressions:
-                    structlogger.error(
-                        "validator.verify_digression_configuration.overlap_digressions",
-                        flow=flow.id,
-                        step_id=step.id,
-                        event_info=(
-                            f"The flow '{flow_id}' is listed in both the "
-                            f"`ask_confirm_digressions` and `block_digressions` "
-                            f"configuration of step '{step.id}' in flow '{flow.id}'. "
-                            f"Please make sure that the flow id is not listed in both "
-                            f"configurations."
-                        ),
-                    )
-                    all_good = False
-
-        return all_good
-
-    def _validate_block_digressions(self, flow: Flow, all_good: bool) -> bool:
-        """Validates the block_digressions configuration in a flow."""
-        for flow_id in flow.block_digressions:
-            if flow_id == ALL_LABEL:
-                continue
-
-            if flow_id not in self.flows.flow_ids:
-                structlogger.error(
-                    "validator.verify_digression_configuration.block_digressions",
-                    flow=flow.id,
-                    event_info=(
-                        f"The flow '{flow_id}' is listed in the `block_digressions` "
-                        f"configuration of flow '{flow.id}', but it is not found "
-                        f"in the flows file. Please make sure that the flow id "
-                        f"is correct."
-                    ),
-                )
-                all_good = False
-
-        for step in flow.get_collect_steps():
-            for flow_id in step.block_digressions:
-                if flow_id == ALL_LABEL:
-                    continue
-
-                if flow_id not in self.flows.flow_ids:
-                    structlogger.error(
-                        "validator.verify_digression_configuration.block_digressions",
-                        flow=flow.id,
-                        step_id=step.id,
-                        event_info=(
-                            f"The flow '{flow_id}' is listed in the "
-                            f"`block_digressions` configuration of step "
-                            f"'{step.id}' in flow '{flow.id}', but it is "
-                            f"not found in the flows file. "
-                            f"Please make sure that the flow id is correct."
-                        ),
-                    )
-                    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.dev11"
+__version__ = "3.12.0.dev12"

{rasa_pro-3.12.0.dev11.dist-info → rasa_pro-3.12.0.dev12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rasa-pro
-Version: 3.12.0.dev11
+Version: 3.12.0.dev12
 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