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

rasa/dialogue_understanding/generator/command_generator.py

@@ -1,11 +1,13 @@
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Text
+from typing import Any, Dict, List, Optional, Set, Text, Tuple
 
 import structlog
 
 from rasa.dialogue_understanding.commands import (
     Command,
+    CorrectSlotsCommand,
     ErrorCommand,
+    SetSlotCommand,
     StartFlowCommand,
 )
 from rasa.dialogue_understanding.utils import (
@@ -198,6 +200,94 @@ class CommandGenerator:
         """
         raise NotImplementedError()
 
+    def _check_commands_overlap(
+        self, prior_commands: List[Command], commands: List[Command]
+    ) -> List[Command]:
+        """Check if there is overlap between the prior commands and the current ones.
+
+        Args:
+            prior_commands: The prior commands.
+            commands: The commands to check.
+
+        Returns:
+            The final commands.
+        """
+        if not prior_commands:
+            return commands
+
+        prior_commands, commands = self._check_slot_command_overlap(
+            prior_commands, commands
+        )
+
+        prior_start_flow_names = {
+            command.flow
+            for command in prior_commands
+            if isinstance(command, StartFlowCommand)
+        }
+        current_start_flow_names = {
+            command.flow
+            for command in commands
+            if isinstance(command, StartFlowCommand)
+        }
+
+        return self._check_start_flow_command_overlap(
+            prior_commands,
+            commands,
+            prior_start_flow_names,
+            current_start_flow_names,
+        )
+
+    def _check_start_flow_command_overlap(
+        self,
+        prior_commands: List[Command],
+        commands: List[Command],
+        prior_start_flow_names: Set[str],
+        current_start_flow_names: Set[str],
+    ) -> List[Command]:
+        """Get the final commands.
+
+        Args:
+            prior_commands: The prior commands.
+            commands: The currently predicted commands to check.
+            prior_start_flow_names: The names of the flows from the prior commands.
+            current_start_flow_names: The names of the flows from the current commands.
+
+        Returns:
+            The final commands.
+        """
+        raise NotImplementedError()
+
+    def _check_slot_command_overlap(
+        self,
+        prior_commands: List[Command],
+        commands: List[Command],
+    ) -> Tuple[List[Command], List[Command]]:
+        """Check if the current commands overlap with the prior commands."""
+        prior_slot_names = gather_slot_names(prior_commands)
+        current_slot_names = gather_slot_names(commands)
+        overlapping_slot_names = prior_slot_names.intersection(current_slot_names)
+
+        structlogger.debug(
+            "command_generator.check_slot_command_overlap",
+            overlapping_slot_names=overlapping_slot_names,
+        )
+
+        if not overlapping_slot_names:
+            return prior_commands, commands
+
+        return self._filter_slot_commands(
+            prior_commands, commands, overlapping_slot_names
+        )
+
+    def _filter_slot_commands(
+        self,
+        prior_commands: List[Command],
+        commands: List[Command],
+        overlapping_slot_names: Set[str],
+    ) -> Tuple[List[Command], List[Command]]:
+        """Filter out the overlapping slot commands."""
+        raise NotImplementedError()
+
     def _check_commands_against_startable_flows(
         self, commands: List[Command], startable_flows: FlowsList
     ) -> List[Command]:
@@ -279,3 +369,16 @@ class CommandGenerator:
         return [
             Command.command_from_json(command) for command in message.get(COMMANDS, [])
         ]
+
+
+def gather_slot_names(commands: List[Command]) -> Set[str]:
+    """Gather all slot names from the commands."""
+    slot_names = set()
+    for command in commands:
+        if isinstance(command, SetSlotCommand):
+            slot_names.add(command.name)
+        if isinstance(command, CorrectSlotsCommand):
+            for slot in command.corrected_slots:
+                slot_names.add(slot.name)
+
+    return slot_names

rasa/dialogue_understanding/generator/llm_based_command_generator.py

@@ -1,10 +1,11 @@
 from abc import ABC, abstractmethod
 from functools import lru_cache
-from typing import Any, Dict, List, Optional, Text, Tuple, Union
+from typing import Any, Dict, List, Optional, Set, Text, Tuple, Union
 
 import structlog
 from jinja2 import Template
 
+import rasa.dialogue_understanding.generator.utils
 import rasa.shared.utils.io
 from rasa.dialogue_understanding.commands import (
     Command,
@@ -27,9 +28,7 @@ from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
 from rasa.shared.core.constants import (
-    KEY_MAPPING_TYPE,
     SetSlotExtractor,
-    SlotMappingType,
 )
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.flows import Flow, FlowsList, FlowStep
@@ -547,11 +546,8 @@ class LLMBasedCommandGenerator(
         for slot in llm_fillable_slots:
             should_fill_slot = False
             for mapping in slot.mappings:  # type: ignore[union-attr]
-                mapping_type = SlotMappingType(mapping.get(KEY_MAPPING_TYPE))
-
                 should_fill_slot = slot_filling_manager.should_fill_slot(
                     slot.name,  # type: ignore[union-attr]
-                    mapping_type,
                     mapping,
                 )
 
@@ -578,3 +574,41 @@ class LLMBasedCommandGenerator(
         ]
 
         return filtered_commands
+
+    def _check_start_flow_command_overlap(
+        self,
+        prior_commands: List[Command],
+        commands: List[Command],
+        prior_start_flow_names: Set[str],
+        current_start_flow_names: Set[str],
+    ) -> List[Command]:
+        """Prioritize the prior commands over the LLM-issued commands."""
+        different_flow_names = current_start_flow_names.difference(
+            prior_start_flow_names
+        )
+
+        if not different_flow_names:
+            return prior_commands + commands
+
+        # discard the flow names that are different to prior start flow commands
+        filtered_commands = [
+            command
+            for command in commands
+            if not isinstance(command, StartFlowCommand)
+            or command.flow not in different_flow_names
+        ]
+        return prior_commands + filtered_commands
+
+    def _filter_slot_commands(
+        self,
+        prior_commands: List[Command],
+        commands: List[Command],
+        overlapping_slot_names: Set[str],
+    ) -> Tuple[List[Command], List[Command]]:
+        """Prioritize prior commands over LLM ones in the case of same slot."""
+        filtered_commands = (
+            rasa.dialogue_understanding.generator.utils.filter_slot_commands(
+                commands, overlapping_slot_names
+            )
+        )
+        return prior_commands, filtered_commands

rasa/dialogue_understanding/generator/multi_step/multi_step_llm_command_generator.py

@@ -229,7 +229,7 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
         domain = kwargs.get("domain")
         commands = self._check_commands_against_slot_mappings(commands, tracker, domain)
 
-        return prior_commands + commands
+        return self._check_commands_overlap(prior_commands, commands)
 
     @classmethod
     def parse_commands(

rasa/dialogue_understanding/generator/nlu_command_adapter.py

@@ -1,7 +1,8 @@
-from typing import Any, Dict, List, Optional, Text
+from typing import Any, Dict, List, Optional, Set, Text, Tuple
 
 import structlog
 
+import rasa.dialogue_understanding.generator.utils
 from rasa.dialogue_understanding.commands import (
     Command,
     SetSlotCommand,
@@ -148,7 +149,7 @@ class NLUCommandAdapter(GraphComponent, CommandGenerator):
                 commands=commands,
             )
 
-        return prior_commands + commands
+        return self._check_commands_overlap(prior_commands, commands)
 
     @staticmethod
     def convert_nlu_to_commands(
@@ -210,6 +211,44 @@ class NLUCommandAdapter(GraphComponent, CommandGenerator):
         )
         return commands
 
+    def _check_start_flow_command_overlap(
+        self,
+        prior_commands: List[Command],
+        commands: List[Command],
+        prior_start_flow_names: Set[str],
+        current_start_flow_names: Set[str],
+    ) -> List[Command]:
+        """Prioritize the current NLU commands over the prior commands."""
+        different_flow_names = prior_start_flow_names.difference(
+            current_start_flow_names
+        )
+
+        if not different_flow_names:
+            return prior_commands + commands
+
+        filtered_commands = [
+            command
+            for command in prior_commands
+            if not isinstance(command, StartFlowCommand)
+            or command.flow not in different_flow_names
+        ]
+
+        return filtered_commands + commands
+
+    def _filter_slot_commands(
+        self,
+        prior_commands: List[Command],
+        commands: List[Command],
+        overlapping_slot_names: Set[str],
+    ) -> Tuple[List[Command], List[Command]]:
+        """Prioritize NLU commands over prior_commands in the case of same slot."""
+        filtered_prior_commands = (
+            rasa.dialogue_understanding.generator.utils.filter_slot_commands(
+                prior_commands, overlapping_slot_names
+            )
+        )
+        return filtered_prior_commands, commands
+
 
 def _issue_set_slot_commands(
     message: Message,

rasa/dialogue_understanding/generator/single_step/single_step_llm_command_generator.py

@@ -236,7 +236,7 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
         domain = kwargs.get("domain")
         commands = self._check_commands_against_slot_mappings(commands, tracker, domain)
 
-        return prior_commands + commands
+        return self._check_commands_overlap(prior_commands, commands)
 
     async def _predict_commands(
         self,

rasa/dialogue_understanding/generator/utils.py

@@ -1,14 +1,16 @@
-from typing import Dict, Type
+from typing import Dict, List, Set, Type
 
 from rasa.dialogue_understanding.commands import (
     CancelFlowCommand,
     CannotHandleCommand,
     ChitChatAnswerCommand,
     Command,
+    CorrectSlotsCommand,
     HumanHandoffCommand,
     KnowledgeAnswerCommand,
     RestartCommand,
     SessionStartCommand,
+    SetSlotCommand,
     SkipQuestionCommand,
 )
 from rasa.dialogue_understanding.commands.user_silence_command import UserSilenceCommand
@@ -43,3 +45,32 @@ triggerable_pattern_to_command_class: Dict[str, Type[Command]] = {
     CannotHandlePatternFlowStackFrame.flow_id: CannotHandleCommand,
     RestartPatternFlowStackFrame.flow_id: RestartCommand,
 }
+
+
+def filter_slot_commands(
+    commands: List[Command], overlapping_slot_names: Set[str]
+) -> List[Command]:
+    """Filter out slot commands that set overlapping slots."""
+    filtered_commands = []
+
+    for command in commands:
+        if (
+            isinstance(command, SetSlotCommand)
+            and command.name in overlapping_slot_names
+        ):
+            continue
+
+        if isinstance(command, CorrectSlotsCommand):
+            allowed_slots = [
+                slot
+                for slot in command.corrected_slots
+                if slot.name not in overlapping_slot_names
+            ]
+            if not allowed_slots:
+                continue
+
+            command.corrected_slots = allowed_slots
+
+        filtered_commands.append(command)
+
+    return filtered_commands

rasa/dialogue_understanding/processor/command_processor.py

@@ -45,13 +45,12 @@ from rasa.shared.constants import (
 from rasa.shared.core.constants import (
     ACTION_TRIGGER_CHITCHAT,
     FLOW_HASHES_SLOT,
-    KEY_ALLOW_NLU_CORRECTION,
-    KEY_MAPPING_TYPE,
     SlotMappingType,
 )
 from rasa.shared.core.events import Event, SlotSet
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.flows.steps.collect import CollectInformationFlowStep
+from rasa.shared.core.slot_mappings import SlotMapping
 from rasa.shared.core.slots import Slot
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.core.training_data.structures import StoryGraph
@@ -582,9 +581,9 @@ def clean_up_slot_command(
     ):
         allow_nlu_correction = any(
             [
-                mapping.get(KEY_ALLOW_NLU_CORRECTION, False)
+                mapping.allow_nlu_correction is True
                 for mapping in slot.mappings
-                if mapping.get(KEY_MAPPING_TYPE) == SlotMappingType.FROM_LLM.value
+                if mapping.type == SlotMappingType.FROM_LLM
             ]
         )
 
@@ -742,12 +741,9 @@ def should_slot_be_set(
     slot_mappings = slot.mappings
 
     if not slot.mappings:
-        slot_mappings = [{KEY_MAPPING_TYPE: SlotMappingType.FROM_LLM.value}]
+        slot_mappings = [SlotMapping(type=SlotMappingType.FROM_LLM)]
 
-    mapping_types = [
-        SlotMappingType(mapping.get(KEY_MAPPING_TYPE, SlotMappingType.FROM_LLM.value))
-        for mapping in slot_mappings
-    ]
+    mapping_types = [mapping.type for mapping in slot_mappings]
 
     slot_has_nlu_mapping = any(
         [mapping_type.is_predefined_type() for mapping_type in mapping_types]
@@ -755,8 +751,8 @@ def should_slot_be_set(
     slot_has_llm_mapping = any(
         [mapping_type == SlotMappingType.FROM_LLM for mapping_type in mapping_types]
     )
-    slot_has_custom_mapping = any(
-        [mapping_type == SlotMappingType.CUSTOM for mapping_type in mapping_types]
+    slot_has_controlled_mapping = any(
+        [mapping_type == SlotMappingType.CONTROLLED for mapping_type in mapping_types]
     )
 
     if set_slot_commands_so_far and command.extractor == SetSlotExtractor.LLM.value:
@@ -785,7 +781,9 @@ def should_slot_be_set(
     ):
         return False
 
-    if slot_has_custom_mapping and not (slot_has_nlu_mapping or slot_has_llm_mapping):
+    if slot_has_controlled_mapping and not (
+        slot_has_nlu_mapping or slot_has_llm_mapping
+    ):
         return False
 
     return True

rasa/dialogue_understanding_test/README.md

@@ -377,3 +377,53 @@ Test cases in **to_review** may require manual intervention because the E2E test
 Review these cases to ensure that the converted test cases are correct and the list of commands and
 bot responses is complete.
 
+
+## Converting DUT test from one DSL to a another DSL
+
+If you need to transform your commands from one DSL format to another
+(for instance, updating `StartFlow(flow_name)` to `start flow_name` or `SetSlot(slot_name, slot_value)` to `set slot_name slot_value`),
+you can use a standalone Python script:
+
+```bash
+python convert_dut_dsl.py --dut-tests-dir <path> --output-dir <path> --dsl-mappings <path>
+```
+
+The script has the following required parameters:
+
+- `--dut-tests-dir <path>`: The directory (relative or absolute) containing your
+  existing Dialogue Understanding Tests (DUT). The script will look for `.yaml` or 
+  `.yml` files within this folder (and subfolders).
+- `--output-dir <path>`: The directory where transformed files will be saved. The folder
+  structure from your `dut-tests-dir` is preserved.
+- `--dsl-mappings <path>`: The YAML file defining your DSL mapping rules.
+
+The YAML file containing the mappings must adhere to the following format: 
+  ```yaml
+  mappings:
+  
+  - from_dsl_regex: "^StartFlow\\(([^)]*)\\)$"
+    to_dsl_pattern: "start {1}"
+  
+  - from_dsl_regex: "^SetSlot\\(([^,]+),\\s*(.*)\\)$"
+    to_dsl_pattern: "set {1} {2}"
+  
+  - from_dsl_regex: "Clarify\(([\"\'a-zA-Z0-9_, ]*)\)"
+    to_dsl_pattern: "clarify {1}"
+    input_separators:
+      - ","
+      - " "
+    output_separator: " "
+  
+  # ... add more mappings here
+
+  ```
+
+- `from_dsl_regex`: A regular expression (string) used to match the old DSL command.
+  Must include any necessary anchors (like ^ and $) and capturing groups ( ... ) for 
+  dynamic parts.
+- `to_dsl_pattern`: A string that contains placeholders like `{1}`, `{2}`, etc. Each
+  placeholder corresponds to a capturing group in from_dsl_regex, in order of
+  appearance.
+- `input_separators`: Optional list of separators of the captured groups that can be replaced
+  with the `output_separator`
+- `output_separator`: Output separator to replace separators from the list of `input_separators` in the captured group.

rasa/dialogue_understanding_test/test_case_simulation/test_case_tracker_simulator.py

@@ -20,7 +20,7 @@ from rasa.dialogue_understanding_test.test_case_simulation.exception import (
 )
 from rasa.dialogue_understanding_test.utils import filter_metadata
 from rasa.e2e_test.e2e_test_case import Fixture, Metadata
-from rasa.shared.core.constants import KEY_MAPPING_TYPE, SlotMappingType
+from rasa.shared.core.constants import SlotMappingType
 from rasa.shared.core.events import BotUttered, SlotSet, UserUttered
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.nlu.constants import COMMANDS, ENTITIES, INTENT
@@ -328,8 +328,8 @@ class TestCaseTrackerSimulator:
                     command.extractor = SetSlotExtractor.COMMAND_PAYLOAD_READER.value
                 # Use the SetSlotExtractor.NLU extractor if the slot mapping type is
                 # not FROM_LLM.
-                elif SlotMappingType.FROM_LLM.value not in [
-                    mapping[KEY_MAPPING_TYPE] for mapping in slot_definition.mappings
+                elif SlotMappingType.FROM_LLM not in [
+                    mapping.type for mapping in slot_definition.mappings
                 ]:
                     command.extractor = SetSlotExtractor.NLU.value
 

rasa/model_service.py

@@ -61,6 +61,7 @@ def main() -> None:
     The API server can receive requests to train models, run bots, and manage
     the lifecycle of models and bots.
     """
+    import rasa.telemetry
     import rasa.utils.licensing
 
     log_level = logging.DEBUG
@@ -74,6 +75,9 @@ def main() -> None:
 
     rasa.utils.licensing.validate_license_from_env()
 
+    rasa.telemetry.initialize_telemetry()
+    rasa.telemetry.initialize_error_reporting()
+
     try:
         model_api.prepare_working_directories()
     except Exception as e:

rasa/model_training.py

@@ -352,34 +352,31 @@ async def _train_graph(
         model_name = determine_model_name(fixed_model_name, training_type)
         full_model_path = Path(output_path, model_name)
 
-        with telemetry.track_model_training(
-            file_importer, model_type=training_type.model_type
-        ):
-            await trainer.train(
-                model_configuration,
-                file_importer,
-                full_model_path,
-                force_retraining=force_full_training,
-                is_finetuning=is_finetuning,
+        await trainer.train(
+            model_configuration,
+            file_importer,
+            full_model_path,
+            force_retraining=force_full_training,
+            is_finetuning=is_finetuning,
+        )
+        if remote_storage:
+            push_model_to_remote_storage(full_model_path, remote_storage)
+            if not keep_local_model_copy:
+                full_model_path.unlink()
+            structlogger.info(
+                "model_training.train.finished_training",
+                event_info=(
+                    f"Your Rasa model {model_name} is trained "
+                    f"and saved at remote storage provider '{remote_storage}'."
+                ),
+            )
+        else:
+            structlogger.info(
+                "model_training.train.finished_training",
+                event_info=(
+                    f"Your Rasa model is trained and saved at '{full_model_path}'."
+                ),
             )
-            if remote_storage:
-                push_model_to_remote_storage(full_model_path, remote_storage)
-                if not keep_local_model_copy:
-                    full_model_path.unlink()
-                structlogger.info(
-                    "model_training.train.finished_training",
-                    event_info=(
-                        f"Your Rasa model {model_name} is trained "
-                        f"and saved at remote storage provider '{remote_storage}'."
-                    ),
-                )
-            else:
-                structlogger.info(
-                    "model_training.train.finished_training",
-                    event_info=(
-                        f"Your Rasa model is trained and saved at '{full_model_path}'."
-                    ),
-                )
 
         return TrainingResult(str(full_model_path), 0)
 

rasa/shared/core/constants.py

@@ -143,6 +143,8 @@ SLOT_MAPPINGS = "mappings"
 MAPPING_CONDITIONS = "conditions"
 KEY_MAPPING_TYPE = "type"
 KEY_ALLOW_NLU_CORRECTION = "allow_nlu_correction"
+KEY_ACTION = "action"
+KEY_RUN_ACTION_EVERY_TURN = "run_action_every_turn"
 
 
 class SlotMappingType(Enum):
@@ -153,7 +155,7 @@ class SlotMappingType(Enum):
     FROM_TRIGGER_INTENT = "from_trigger_intent"
     FROM_TEXT = "from_text"
     FROM_LLM = "from_llm"
-    CUSTOM = "custom"
+    CONTROLLED = "controlled"
 
     def __str__(self) -> str:
         """Returns the string representation that should be used in config files."""
@@ -161,7 +163,9 @@ class SlotMappingType(Enum):
 
     def is_predefined_type(self) -> bool:
         """Returns True if the mapping type is NLU-predefined."""
-        return not (self == SlotMappingType.CUSTOM or self == SlotMappingType.FROM_LLM)
+        return not (
+            self == SlotMappingType.CONTROLLED or self == SlotMappingType.FROM_LLM
+        )
 
 
 class SetSlotExtractor(Enum):

rasa/shared/core/domain.py

@@ -46,10 +46,8 @@ from rasa.shared.constants import (
 )
 from rasa.shared.core.constants import (
     ACTION_SHOULD_SEND_DOMAIN,
-    ACTIVE_LOOP,
     KEY_MAPPING_TYPE,
     KNOWLEDGE_BASE_SLOT_NAMES,
-    MAPPING_CONDITIONS,
     SLOT_MAPPINGS,
     SlotMappingType,
 )
@@ -290,8 +288,6 @@ class Domain:
         responses = data.get(KEY_RESPONSES, {})
 
         domain_slots = data.get(KEY_SLOTS, {})
-        if domain_slots:
-            rasa.shared.core.slot_mappings.validate_slot_mappings(domain_slots)
         slots = cls.collect_slots(domain_slots)
         domain_actions = data.get(KEY_ACTIONS, [])
         actions = cls._collect_action_names(domain_actions)
@@ -1569,23 +1565,18 @@ class Domain:
                 matching_entities = []
 
                 for mapping in slot.mappings:
-                    mapping_conditions = mapping.get(MAPPING_CONDITIONS)
-                    if mapping[KEY_MAPPING_TYPE] != str(
-                        SlotMappingType.FROM_ENTITY
-                    ) or (
+                    mapping_conditions = mapping.conditions
+                    if mapping.type != SlotMappingType.FROM_ENTITY or (
                         mapping_conditions
-                        and mapping_conditions[0].get(ACTIVE_LOOP) is not None
+                        and mapping_conditions[0].active_loop is not None
                     ):
                         continue
 
                     for entity in entities:
                         if (
-                            entity.get(ENTITY_ATTRIBUTE_TYPE)
-                            == mapping.get(ENTITY_ATTRIBUTE_TYPE)
-                            and entity.get(ENTITY_ATTRIBUTE_ROLE)
-                            == mapping.get(ENTITY_ATTRIBUTE_ROLE)
-                            and entity.get(ENTITY_ATTRIBUTE_GROUP)
-                            == mapping.get(ENTITY_ATTRIBUTE_GROUP)
+                            entity.get(ENTITY_ATTRIBUTE_TYPE) == mapping.entity
+                            and entity.get(ENTITY_ATTRIBUTE_ROLE) == mapping.role
+                            and entity.get(ENTITY_ATTRIBUTE_GROUP) == mapping.group
                         ):
                             matching_entities.append(entity.get("value"))
 
@@ -2017,19 +2008,19 @@ class Domain:
             is the total number of mappings which have conditions attached.
         """
         total_mappings = 0
-        custom_mappings = 0
+        controlled_mappings = 0
         conditional_mappings = 0
 
         for slot in self.slots:
             total_mappings += len(slot.mappings)
             for mapping in slot.mappings:
-                if mapping[KEY_MAPPING_TYPE] == str(SlotMappingType.CUSTOM):
-                    custom_mappings += 1
+                if mapping.type == SlotMappingType.CONTROLLED:
+                    controlled_mappings += 1
 
-                if MAPPING_CONDITIONS in mapping:
+                if mapping.conditions:
                     conditional_mappings += 1
 
-        return (total_mappings, custom_mappings, conditional_mappings)
+        return total_mappings, controlled_mappings, conditional_mappings
 
     def does_custom_action_explicitly_need_domain(self, action_name: Text) -> bool:
         """Assert if action has explicitly stated that it needs domain.