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

rasa/shared/utils/llm.py

@@ -6,7 +6,6 @@ from typing import (
     Any,
     Callable,
     Dict,
-    List,
     Optional,
     Text,
     Type,
@@ -238,90 +237,6 @@ def tracker_as_readable_transcript(
     return "\n".join(transcript)
 
 
-def sanitize_command_for_prompt(cmd_dict):
-    command = ""
-    if cmd_dict["command"] == "start flow":
-        command = f"start {cmd_dict['flow']}"
-    elif cmd_dict["command"] == "set slot":
-        command = f"set {cmd_dict['name']} {cmd_dict['value']}"
-    elif cmd_dict["command"] == "skip question":
-        command = "skip"
-    elif cmd_dict["command"] == "clarify":
-        command = f"clarify {' '.join(cmd_dict['options'])}"
-    elif cmd_dict["command"] == "knowledge":
-        command = "search"
-    elif cmd_dict["command"] == "chitchat":
-        command = "chat"
-    elif cmd_dict["command"] == "cancel flow":
-        command = "cancel"
-    else:
-        command = cmd_dict["command"]
-
-    return command
-
-
-def tracker_as_message_list(
-    tracker: "DialogueStateTracker",
-    max_turns: Optional[int] = 20,
-) -> List[str]:
-    """Creates a readable dialogue from a tracker.
-
-    Args:
-        tracker: the tracker to convert
-        max_turns: the maximum number of turns to include in the transcript
-
-    Example:
-        >>> tracker = Tracker(
-        ...     sender_id="test",
-        ...     slots=[],
-        ...     events=[
-        ...         UserUttered("hello"),
-        ...         BotUttered("hi"),
-        ...     ],
-        ... )
-        >>> tracker_as_readable_transcript(tracker)
-        USER: hello
-        AI: hi
-
-    Returns:
-    A string representing the transcript of the tracker
-    """
-    messages = []
-
-    # using `applied_events` rather than `events` means that only events after the
-    # most recent `Restart` or `SessionStarted` are included in the transcript
-    # last_commands = None
-    for event in tracker.applied_events():
-        if isinstance(event, UserUttered):
-            if event.has_triggered_error:
-                first_error = event.error_commands[0]
-                error_type = first_error.get("error_type")
-                message = ERROR_PLACEHOLDER.get(
-                    error_type, ERROR_PLACEHOLDER["default"]
-                )
-            else:
-                message = sanitize_message_for_prompt(event.text)
-                # last_commands = event.commands
-            messages.append({"role": "user", "content": message})
-            # messages.append({"role": "system", "content": ' \n '.join([sanitize_command_for_prompt(cmd) for cmd in last_commands])})  # noqa: E501
-            # transcript.append(f"{human_prefix}: {message}")
-
-        elif isinstance(event, BotUttered):
-            messages.append(
-                {
-                    "role": "assistant",
-                    "content": f"{sanitize_message_for_prompt(event.text)}",
-                }
-            )
-            # transcript.append(f"{ai_prefix}: {sanitize_message_for_prompt(event.text)}")  # noqa: E501
-
-    if max_turns:
-        messages = messages[-max_turns:]
-        # transcript = transcript[-max_turns:]
-
-    return messages
-
-
 def sanitize_message_for_prompt(text: Optional[str]) -> str:
     """Removes new lines from a string.
 
@@ -765,7 +680,7 @@ def allowed_values_for_slot(slot: Slot) -> Union[str, None]:
     if isinstance(slot, BooleanSlot):
         return str([True, False])
     if isinstance(slot, CategoricalSlot):
-        return str([v for v in slot.values if v != "__other__"] + ["other"])
+        return str([v for v in slot.values if v != "__other__"])
     else:
         return None
 

rasa/shared/utils/schemas/domain.yml

@@ -78,7 +78,6 @@ mapping:
           mappings:
            type: "seq"
            required: False
-           allowempty: False
            sequence:
               - type: "map"
                 allowempty: True

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
+from typing import Any, Callable, Dict, List, Optional, Text, Tuple
 
 import importlib_resources
 import requests
@@ -35,6 +35,7 @@ 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,
@@ -111,6 +112,7 @@ 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"
@@ -976,6 +978,7 @@ 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),
@@ -1021,13 +1024,28 @@ def track_model_training(
         tracking_data,
     )
     start = datetime.now()
-    yield
+    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
+
     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()),
         },
@@ -1326,24 +1344,28 @@ def track_server_start(
     """
     from rasa.core.utils import AvailableEndpoints
 
-    def project_fingerprint_from_model(
+    def project_fingerprint_and_assistant_id_from_model(
         _model_directory: Optional[Text],
-    ) -> Optional[Text]:
+    ) -> Tuple[Optional[Text], Optional[Text]]:
         """Gets project fingerprint from an app's loaded model."""
         if not model_directory:
-            return None
+            return None, None
 
         try:
             model_archive = model.get_local_model(_model_directory)
             metadata = LocalModelStorage.metadata_from_archive(model_archive)
 
-            return metadata.project_fingerprint
+            return metadata.project_fingerprint, metadata.assistant_id
         except Exception:
-            return None
+            return None, None
 
     if not endpoints:
         endpoints = AvailableEndpoints()
 
+    project, assistant_id = project_fingerprint_and_assistant_id_from_model(
+        model_directory
+    )
+
     _track(
         TELEMETRY_SERVER_STARTED_EVENT,
         {
@@ -1365,7 +1387,8 @@ def track_server_start(
             "endpoints_event_broker": endpoints.event_broker.type
             if endpoints.event_broker
             else None,
-            "project": project_fingerprint_from_model(model_directory),
+            "project": project,
+            "assistant_id": assistant_id,
         },
     )
 
@@ -1383,23 +1406,30 @@ def track_project_init(path: Text) -> None:
 
 
 @ensure_telemetry_enabled
-def track_shell_started(model_type: Text) -> None:
+def track_shell_started(model_type: Text, assistant_id: 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})
+    _track(
+        TELEMETRY_SHELL_STARTED_EVENT,
+        {"type": model_type, "assistant_id": assistant_id},
+    )
 
 
 @ensure_telemetry_enabled
-def track_inspect_started(model_type: Text) -> None:
+def track_inspect_started(channel: Text, assistant_id: Text) -> None:
     """Track when a user starts a bot using rasa inspect.
 
     Args:
-        model_type: Type of the model, core / nlu or rasa.
+        channel: Type of channel used.
+        assistant_id: ID of the assistant being inspected.
     """
-    _track(TELEMETRY_INSPECT_STARTED_EVENT, {"type": model_type})
+    _track(
+        TELEMETRY_INSPECT_STARTED_EVENT,
+        {"type": channel, "assistant_id": assistant_id},
+    )
 
 
 @ensure_telemetry_enabled

rasa/utils/common.py

@@ -70,7 +70,6 @@ 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,9 +35,7 @@ from rasa.shared.core.command_payload_reader import (
     CommandPayloadReader,
 )
 from rasa.shared.core.constants import (
-    ACTIVE_LOOP,
-    MAPPING_CONDITIONS,
-    MAPPING_TYPE,
+    KEY_ALLOW_NLU_CORRECTION,
     SlotMappingType,
 )
 from rasa.shared.core.domain import (
@@ -45,13 +43,14 @@ from rasa.shared.core.domain import (
     Domain,
 )
 from rasa.shared.core.events import ActionExecuted, ActiveLoop, UserUttered
-from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.flows import Flow, 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,
@@ -518,9 +517,9 @@ class Validator:
 
         for slot in self.domain.slots:
             for mapping in slot.mappings:
-                for condition in mapping.get(MAPPING_CONDITIONS, []):
-                    condition_active_loop = condition.get(ACTIVE_LOOP)
-                    mapping_type = SlotMappingType(mapping.get(MAPPING_TYPE))
+                for condition in mapping.conditions:
+                    condition_active_loop = condition.active_loop
+                    mapping_type = mapping.type
                     if (
                         condition_active_loop
                         and condition_active_loop not in self.domain.form_names
@@ -1264,6 +1263,7 @@ 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,34 +1392,22 @@ class Validator:
 
         for slot in self.domain._user_slots:
             nlu_mappings = any(
-                [
-                    SlotMappingType(
-                        mapping.get("type", SlotMappingType.FROM_LLM.value)
-                    ).is_predefined_type()
-                    for mapping in slot.mappings
-                ]
+                [mapping.type.is_predefined_type() for mapping in slot.mappings]
             )
             llm_mappings = any(
-                [
-                    SlotMappingType(mapping.get("type", SlotMappingType.FROM_LLM.value))
-                    == SlotMappingType.FROM_LLM
-                    for mapping in slot.mappings
-                ]
+                [mapping.type == SlotMappingType.FROM_LLM for mapping in slot.mappings]
             )
-            custom_mappings = any(
+            controlled_mappings = any(
                 [
-                    SlotMappingType(mapping.get("type", SlotMappingType.FROM_LLM.value))
-                    == SlotMappingType.CUSTOM
+                    mapping.type == SlotMappingType.CONTROLLED
                     for mapping in slot.mappings
                 ]
             )
 
-            all_good = self._slot_contains_all_mappings_types(
-                llm_mappings, nlu_mappings, custom_mappings, slot.name, all_good
-            )
+            all_good = self._allow_nlu_correction_is_valid(slot, nlu_mappings, all_good)
 
             all_good = self._custom_action_name_is_defined_in_the_domain(
-                custom_mappings, slot, all_good
+                controlled_mappings, slot, all_good
             )
 
             all_good = self._config_contains_nlu_command_adapter(
@@ -1433,23 +1421,45 @@ class Validator:
         return all_good
 
     @staticmethod
-    def _slot_contains_all_mappings_types(
-        llm_mappings: bool,
-        nlu_mappings: bool,
-        custom_mappings: bool,
-        slot_name: str,
-        all_good: bool,
+    def _allow_nlu_correction_is_valid(
+        slot: Slot, nlu_mappings: bool, all_good: bool
     ) -> bool:
-        if llm_mappings and (nlu_mappings or custom_mappings):
+        """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:
             structlogger.error(
-                "validator.validate_slot_mappings_in_CALM.llm_and_nlu_mappings",
-                slot_name=slot_name,
+                "validator.validate_slot_mappings_in_CALM.allow_nlu_correction",
+                slot_name=slot.name,
                 event_info=(
-                    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."
+                    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."
                 ),
-                docs_link=DOCS_URL_DOMAIN + "#calm-slot-mappings",
             )
             all_good = False
 
@@ -1457,55 +1467,32 @@ class Validator:
 
     def _custom_action_name_is_defined_in_the_domain(
         self,
-        custom_mappings: bool,
+        controlled_mappings: bool,
         slot: Slot,
         all_good: bool,
     ) -> bool:
-        if not custom_mappings:
-            return all_good
-
-        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:
+        if not controlled_mappings:
             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
+        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
 
         return all_good
 
@@ -1658,3 +1645,123 @@ 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.dev9"
+__version__ = "3.12.0.dev11"

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

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