rasa-pro 3.12.18.dev1__py3-none-any.whl → 3.13.0a1.dev1__py3-none-any.whl

rasa/shared/core/flows/nlu_trigger.py

@@ -28,6 +28,14 @@ class NLUTrigger:
         """
         return self.intent == intent and confidence >= self.confidence_threshold
 
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, NLUTrigger):
+            return (
+                self.intent == other.intent
+                and self.confidence_threshold == other.confidence_threshold
+            )
+        return False
+
 
 @dataclass
 class NLUTriggers:
@@ -115,3 +123,8 @@ class NLUTriggers:
             trigger_condition.is_triggered(intent, confidence)
             for trigger_condition in self.trigger_conditions
         )
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, NLUTriggers):
+            return self.trigger_conditions == other.trigger_conditions
+        return False

rasa/shared/core/flows/steps/action.py

@@ -31,15 +31,13 @@ class ActionFlowStep(FlowStep):
             **base.__dict__,
         )
 
-    def as_json(self) -> Dict[Text, Any]:
+    def as_json(self) -> Dict[Text, Any]:  # type: ignore[override]
         """Serialize the ActionFlowStep
 
         Returns:
             The ActionFlowStep object as serialized data.
         """
-        data = super().as_json()
-        data["action"] = self.action
-        return data
+        return super().as_json(step_properties={"action": self.action})
 
     @property
     def default_id_postfix(self) -> str:
@@ -55,3 +53,8 @@ class ActionFlowStep(FlowStep):
     def custom_action(self) -> Optional[str]:
         """Return all the custom actions used in this step."""
         return self.action if not self.action.startswith(UTTER_PREFIX) else None
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, type(self)):
+            return self.action == other.action and super().__eq__(other)
+        return False

rasa/shared/core/flows/steps/call.py

@@ -34,15 +34,13 @@ class CallFlowStep(FlowStep):
             **base.__dict__,
         )
 
-    def as_json(self) -> Dict[Text, Any]:
+    def as_json(self) -> Dict[Text, Any]:  # type: ignore[override]
         """Returns the flow step as a dictionary.
 
         Returns:
             The flow step as a dictionary.
         """
-        dump = super().as_json()
-        dump["call"] = self.call
-        return dump
+        return super().as_json(step_properties={"call": self.call})
 
     def steps_in_tree(
         self, should_resolve_calls: bool = True
@@ -62,3 +60,12 @@ class CallFlowStep(FlowStep):
     def default_id_postfix(self) -> str:
         """Returns the default id postfix of the flow step."""
         return f"call_{self.call}"
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, type(self)):
+            return (
+                self.call == other.call
+                and self.called_flow_reference == other.called_flow_reference
+                and super().__eq__(other)
+            )
+        return False

rasa/shared/core/flows/steps/collect.py

@@ -1,11 +1,22 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Dict, List, Set, Text
+from typing import Any, Dict, List, Optional, Set, Text, Union
+
+import structlog
 
 from rasa.shared.constants import ACTION_ASK_PREFIX, UTTER_ASK_PREFIX
 from rasa.shared.core.flows.flow_step import FlowStep
 from rasa.shared.core.slots import SlotRejection
+from rasa.shared.exceptions import RasaException
+
+DEFAULT_ASK_BEFORE_FILLING = False
+DEFAULT_RESET_AFTER_FLOW_ENDS = True
+DEFAULT_FORCE_SLOT_FILLING = False
+
+logger = structlog.get_logger(__name__)
+
+SilenceTimeoutInstructionType = Union[int, float, Dict[str, Any]]
 
 
 @dataclass
@@ -20,12 +31,14 @@ class CollectInformationFlowStep(FlowStep):
     """The action that the assistant uses to ask for the slot."""
     rejections: List[SlotRejection]
     """how the slot value is validated using predicate evaluation."""
-    ask_before_filling: bool = False
+    ask_before_filling: bool = DEFAULT_ASK_BEFORE_FILLING
     """Whether to always ask the question even if the slot is already filled."""
-    reset_after_flow_ends: bool = True
+    reset_after_flow_ends: bool = DEFAULT_RESET_AFTER_FLOW_ENDS
     """Whether to reset the slot value at the end of the flow."""
     force_slot_filling: bool = False
     """Whether to keep only the SetSlot command for the collected slot."""
+    silence_timeout: Optional[float] = None
+    """The silence timeout for the collect information step."""
 
     @classmethod
     def from_json(
@@ -40,10 +53,15 @@ class CollectInformationFlowStep(FlowStep):
         Returns:
             A CollectInformationFlowStep object
         """
+
+        silence_timeout = cls._deserialise_silence_timeout(
+            data.get("silence_timeout", None)
+        )
+
         base = super().from_json(flow_id, data)
         return CollectInformationFlowStep(
             collect=data["collect"],
-            utter=data.get("utter", f"{UTTER_ASK_PREFIX}{data['collect']}"),
+            utter=data.get("utter", cls._default_utter(data["collect"])),
             # as of now it is not possible to define a different name for the
             # action, always use the default name 'action_ask_<slot_name>'
             collect_action=f"{ACTION_ASK_PREFIX}{data['collect']}",
@@ -54,10 +72,40 @@ class CollectInformationFlowStep(FlowStep):
                 for rejection in data.get("rejections", [])
             ],
             force_slot_filling=data.get("force_slot_filling", False),
+            silence_timeout=silence_timeout,
             **base.__dict__,
         )
 
-    def as_json(self) -> Dict[str, Any]:
+    @staticmethod
+    def _deserialise_silence_timeout(
+        silence_timeout_json: Optional[SilenceTimeoutInstructionType],
+    ) -> Optional[float]:
+        """Deserialize silence timeout from JSON."""
+        if not silence_timeout_json:
+            return None
+
+        if not isinstance(silence_timeout_json, (int, float)):
+            raise RasaException(
+                f"Invalid silence timeout value: {silence_timeout_json}. "
+                "If defined at collect step, silence timeout must be a number."
+            )
+
+        silence_timeout = silence_timeout_json
+
+        if silence_timeout and silence_timeout < 0:
+            raise RasaException(
+                f"Invalid silence timeout value: {silence_timeout}. "
+                "Silence timeout must be a non-negative number."
+            )
+        return silence_timeout
+
+    @staticmethod
+    def _default_utter(collect: str) -> str:
+        return f"{UTTER_ASK_PREFIX}{collect}"
+
+    def as_json(
+        self, step_properties: Optional[Dict[Text, Any]] = None
+    ) -> Dict[str, Any]:
         """Serialize the CollectInformationFlowStep object.
 
         Returns:
@@ -70,8 +118,10 @@ class CollectInformationFlowStep(FlowStep):
         data["reset_after_flow_ends"] = self.reset_after_flow_ends
         data["rejections"] = [rejection.as_dict() for rejection in self.rejections]
         data["force_slot_filling"] = self.force_slot_filling
+        if self.silence_timeout:
+            data["silence_timeout"] = self.silence_timeout
 
-        return data
+        return super().as_json(step_properties=data)
 
     @property
     def default_id_postfix(self) -> str:
@@ -82,3 +132,18 @@ class CollectInformationFlowStep(FlowStep):
     def utterances(self) -> Set[str]:
         """Return all the utterances used in this step."""
         return {self.utter} | {r.utter for r in self.rejections}
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, type(self)):
+            return (
+                self.collect == other.collect
+                and self.utter == other.utter
+                and self.collect_action == other.collect_action
+                and self.rejections == other.rejections
+                and self.ask_before_filling == other.ask_before_filling
+                and self.reset_after_flow_ends == other.reset_after_flow_ends
+                and self.force_slot_filling == other.force_slot_filling
+                and self.silence_timeout == other.silence_timeout
+                and super().__eq__(other)
+            )
+        return False

rasa/shared/core/flows/steps/internal.py

@@ -28,7 +28,7 @@ class InternalFlowStep(FlowStep):
             "or de-serialized."
         )
 
-    def as_json(self) -> Dict[Text, Any]:
+    def as_json(self) -> Dict[Text, Any]:  # type: ignore[override]
         """Serialize the InternalFlowStep object
 
         Returns:
@@ -43,3 +43,8 @@ class InternalFlowStep(FlowStep):
     def default_id_postfix(self) -> str:
         """Returns the default id postfix of the flow step."""
         raise ValueError("Internal flow steps do not need a default id")
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, type(self)):
+            return super().__eq__(other)
+        return False

rasa/shared/core/flows/steps/link.py

@@ -37,17 +37,20 @@ class LinkFlowStep(FlowStep):
             **base.__dict__,
         )
 
-    def as_json(self) -> Dict[Text, Any]:
+    def as_json(self) -> Dict[Text, Any]:  # type: ignore[override]
         """Serialize the LinkFlowStep object
 
         Returns:
             the LinkFlowStep object as serialized data.
         """
-        data = super().as_json()
-        data["link"] = self.link
-        return data
+        return super().as_json(step_properties={"link": self.link})
 
     @property
     def default_id_postfix(self) -> str:
         """Returns the default id postfix of the flow step."""
         return f"link_{self.link}"
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, type(self)):
+            return self.link == other.link and super().__eq__(other)
+        return False

rasa/shared/core/flows/steps/no_operation.py

@@ -34,17 +34,20 @@ class NoOperationFlowStep(FlowStep):
             **base.__dict__,
         )
 
-    def as_json(self) -> Dict[Text, Any]:
+    def as_json(self) -> Dict[Text, Any]:  # type: ignore[override]
         """Serialize the NoOperationFlowStep object
 
         Returns:
             the NoOperationFlowStep object as serialized data.
         """
-        data = super().as_json()
-        data["noop"] = self.noop
-        return data
+        return super().as_json(step_properties={"noop": self.noop})
 
     @property
     def default_id_postfix(self) -> str:
         """Returns the default id postfix of the flow step."""
         return "noop"
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, type(self)):
+            return self.noop == other.noop and super().__eq__(other)
+        return False

rasa/shared/core/flows/steps/set_slots.py

@@ -35,17 +35,21 @@ class SetSlotsFlowStep(FlowStep):
             **base.__dict__,
         )
 
-    def as_json(self) -> Dict[Text, Any]:
+    def as_json(self) -> Dict[Text, Any]:  # type: ignore[override]
         """Serialize the SetSlotsFlowStep object
 
         Returns:
             the SetSlotsFlowStep object as serialized data
         """
-        data = super().as_json()
-        data["set_slots"] = [{slot["key"]: slot["value"]} for slot in self.slots]
-        return data
+        set_slots = [{slot["key"]: slot["value"]} for slot in self.slots]
+        return super().as_json(step_properties={"set_slots": set_slots})
 
     @property
     def default_id_postfix(self) -> str:
         """Returns the default id postfix of the flow step."""
         return "set_slots"
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, type(self)):
+            return self.slots == other.slots and super().__eq__(other)
+        return False

rasa/shared/core/flows/validation.py

@@ -8,6 +8,7 @@ from typing import List, Optional, Set, Text
 
 from rasa.shared.constants import (
     RASA_DEFAULT_FLOW_PATTERN_PREFIX,
+    RASA_PATTERN_CHITCHAT,
     RASA_PATTERN_HUMAN_HANDOFF,
     RASA_PATTERN_INTERNAL_ERROR,
 )
@@ -186,8 +187,10 @@ class ReferenceToPatternException(RasaException):
             return message + "Patterns can not be used as a target for a call step."
         else:
             return message + (
-                "All patterns, except for 'pattern_human_handoff', can "
-                "not be used as a target for a link step."
+                "Patterns cannot be used as a target in link steps, except for "
+                "'pattern_human_handoff', which may be linked from both user-defined "
+                "flows and other patterns. 'pattern_chitchat' may only be linked "
+                "from other patterns."
             )
 
 
@@ -597,7 +600,13 @@ def validate_patterns_are_not_called_or_linked(flows: "FlowsList") -> None:
             if (
                 isinstance(step, LinkFlowStep)
                 and step.link.startswith(RASA_DEFAULT_FLOW_PATTERN_PREFIX)
+                # Allow linking to human-handoff from both patterns
+                # and user-defined flows
                 and step.link != RASA_PATTERN_HUMAN_HANDOFF
+                # Allow linking to 'pattern_chitchat' only from other patterns
+                and not (
+                    flow.is_rasa_default_flow and step.link == RASA_PATTERN_CHITCHAT
+                )
             ):
                 raise ReferenceToPatternException(
                     step.link, flow.id, step.id, call_step=False
@@ -617,7 +626,8 @@ def validate_patterns_are_not_calling_or_linking_other_flows(
     """Validates that patterns do not contain call or link steps.
 
     Link steps to user flows are allowed for all patterns but 'pattern_internal_error'.
-    Link steps to other patterns, except for 'pattern_human_handoff', are forbidden.
+    Link steps to other patterns, except for 'pattern_human_handoff' and
+    'pattern_chitchat' are forbidden.
     """
     for flow in flows.underlying_flows:
         if not flow.is_rasa_default_flow:
@@ -627,6 +637,9 @@ def validate_patterns_are_not_calling_or_linking_other_flows(
                 if step.link == RASA_PATTERN_HUMAN_HANDOFF:
                     # links to 'pattern_human_handoff' are allowed
                     continue
+                if step.link == RASA_PATTERN_CHITCHAT:
+                    # links to 'pattern_chitchat' are allowed
+                    continue
                 if step.link.startswith(RASA_DEFAULT_FLOW_PATTERN_PREFIX):
                     # all other patterns are allowed to link to user flows, but not
                     # to other patterns

rasa/shared/core/flows/yaml_flows_io.py

@@ -8,8 +8,15 @@ from ruamel import yaml as yaml
 import rasa.shared
 import rasa.shared.data
 import rasa.shared.utils.io
-from rasa.shared.core.flows.flow import Flow
+from rasa.shared.core.flows.flow import DEFAULT_RUN_PATTERN_COMPLETED, Flow
+from rasa.shared.core.flows.flow_step import FlowStep
 from rasa.shared.core.flows.flows_list import FlowsList
+from rasa.shared.core.flows.steps import CollectInformationFlowStep
+from rasa.shared.core.flows.steps.collect import (
+    DEFAULT_ASK_BEFORE_FILLING,
+    DEFAULT_FORCE_SLOT_FILLING,
+    DEFAULT_RESET_AFTER_FLOW_ENDS,
+)
 from rasa.shared.exceptions import RasaException, YamlException
 from rasa.shared.utils.yaml import (
     dump_obj_as_yaml_to_string,
@@ -242,31 +249,43 @@ class YamlFlowsWriter:
     """Class that writes flows information in YAML format."""
 
     @staticmethod
-    def dumps(flows: List[Flow]) -> Text:
+    def dumps(
+        flows: List[Flow],
+        should_clean_json: bool = False,
+    ) -> Text:
         """Dump `Flow`s to YAML.
 
         Args:
             flows: The `Flow`s to dump.
+            should_clean_json: Flag whether to clean the flow JSON.
 
         Returns:
             The dumped YAML.
         """
         dump = {}
         for flow in flows:
-            dumped_flow = flow.as_json()
+            dumped_flow = get_flow_as_json(flow, should_clean_json)
             del dumped_flow["id"]
             dump[flow.id] = dumped_flow
         return dump_obj_as_yaml_to_string({KEY_FLOWS: dump})
 
     @staticmethod
-    def dump(flows: List[Flow], filename: Union[Text, Path]) -> None:
+    def dump(
+        flows: List[Flow],
+        filename: Union[Text, Path],
+        should_clean_json: bool = False,
+    ) -> None:
         """Dump `Flow`s to YAML file.
 
         Args:
             flows: The `Flow`s to dump.
             filename: The path to the file to write to.
+            should_clean_json: Flag whether to clean the flow JSON.
         """
-        rasa.shared.utils.io.write_text_file(YamlFlowsWriter.dumps(flows), filename)
+        rasa.shared.utils.io.write_text_file(
+            YamlFlowsWriter.dumps(flows, should_clean_json),
+            filename,
+        )
 
 
 def is_flows_file(file_path: Union[Text, Path]) -> bool:
@@ -403,3 +422,85 @@ def process_yaml_content(yaml_content: Dict[str, Any]) -> Dict[str, Any]:
     )
 
     return yaml_content
+
+
+def get_flow_as_json(flow: Flow, should_clean_json: bool = False) -> Dict[str, Any]:
+    """
+    Clean the Flow JSON by removing default values and empty fields.
+
+    Args:
+        flow: The Flow object to clean.
+        should_clean_json: Flag indicating whether to clean the JSON.
+
+    Returns:
+        The cleaned Flow JSON as a dictionary.
+    """
+    step_id_to_default_id = {}
+    flow_data = flow.as_json()
+    if not should_clean_json:
+        return flow_data
+
+    def gather_step_ids(step: FlowStep) -> None:
+        """Create a map of step IDs to their default IDs."""
+        step_id_to_default_id[step.id] = step.default_id
+        for link in step.next.links:
+            for child in link.child_steps():
+                gather_step_ids(child)
+
+    def clean_flow_data(data: Dict[str, Any]) -> None:
+        """Remove or omit flow-level fields if they match defaults."""
+        for top_level_step in flow.step_sequence.steps:
+            gather_step_ids(top_level_step)
+
+        if data.get("run_pattern_completed") == DEFAULT_RUN_PATTERN_COMPLETED:
+            data.pop("run_pattern_completed", None)
+
+        if not data.get("persisted_slots"):
+            data.pop("persisted_slots", None)
+
+        _remove_keys_recursively(data, ["metadata"])
+
+        data.pop("file_path", None)
+
+        steps = data.get("steps", [])
+        for i, current_step in enumerate(steps):
+            # Look ahead to the next step if we should remove the 'next' field
+            next_step_data = steps[i + 1] if i + 1 < len(steps) else None
+            clean_step(current_step, next_step_data)
+
+    def clean_step(current_step: Dict[str, Any], next_step: Dict[str, Any]) -> None:
+        """Remove default fields from a step."""
+        # Remove 'next' if it exactly matches the next step's default ID
+        if next_step:
+            next_id = next_step.get("id")
+            default_id = step_id_to_default_id.get(next_id)
+            if next_id and current_step.get("next") == default_id:
+                current_step.pop("next", None)
+
+        # Remove 'id' if it equals its own default
+        step_id = current_step.get("id")
+        if step_id and step_id == step_id_to_default_id.get(step_id):
+            current_step.pop("id", None)
+
+        if "collect" in current_step:
+            clean_collect_step(current_step)
+
+    def clean_collect_step(step_data: Dict[str, Any]) -> None:
+        """Remove default fields from a collect step."""
+        slot_name = step_data["collect"]
+        default_utter = CollectInformationFlowStep._default_utter(slot_name)
+
+        if step_data.get("utter") == default_utter:
+            step_data.pop("utter", None)
+        if step_data.get("ask_before_filling") is DEFAULT_ASK_BEFORE_FILLING:
+            step_data.pop("ask_before_filling", None)
+        if step_data.get("reset_after_flow_ends") is DEFAULT_RESET_AFTER_FLOW_ENDS:
+            step_data.pop("reset_after_flow_ends", None)
+        if step_data.get("force_slot_filling") is DEFAULT_FORCE_SLOT_FILLING:
+            step_data.pop("force_slot_filling", None)
+        if not step_data.get("rejections"):
+            step_data.pop("rejections", None)
+
+    clean_flow_data(flow_data)
+
+    return flow_data

rasa/shared/core/slots.py

@@ -273,10 +273,14 @@ class Slot(ABC):
         try:
             return rasa.shared.utils.common.class_from_module_path(type_name)
         except (ImportError, AttributeError):
+            known_types = [
+                cls.type_name for cls in rasa.shared.utils.common.all_subclasses(Slot)
+            ]
             raise InvalidSlotTypeException(
                 f"Failed to find slot type, '{type_name}' is neither a known type nor "
                 f"user-defined. If you are creating your own slot type, make "
                 f"sure its module path is correct. "
+                f"Known types: {', '.join(known_types)} "
                 f"You can find all build in types at {DOCS_URL_SLOTS}"
             )
 
@@ -311,6 +315,34 @@ class Slot(ABC):
         """Indicates if the slot requires validation."""
         return True if self.validation else False
 
+    def to_dict(
+        self,
+        *,
+        include_private: bool = False,
+    ) -> Dict[str, Any]:
+        """Return a dictionary with attributes of this slot instance.
+
+        Args:
+            include_private: If `True`, private attributes are included.
+
+        Returns:
+            A plain `dict` that can be JSON-serialised.
+        """
+        result: Dict[str, Any] = {}
+
+        for attr, value in vars(self).items():
+            if not include_private and attr.startswith("_"):
+                continue
+
+            if attr == "mappings":
+                result[attr] = [mapping.as_dict() for mapping in value]
+                continue
+
+            result[attr] = value
+
+        result.setdefault("type", self.type_name)
+        return result
+
 
 class FloatSlot(Slot):
     """A slot storing a float value."""
@@ -787,7 +819,7 @@ class StrictCategoricalSlot(CategoricalSlot):
     def coerce_value(self, value: Any) -> Any:
         """Coerce the value to one of the allowed ones or raise an error if invalid."""
         if value is None:
-            return self.initial_value
+            return value
 
         for allowed_value in self.values:
             # Allowed values are always stored as strings, so we can use casefold().

rasa/shared/core/trackers.py

@@ -1123,16 +1123,10 @@ class DialogueStateTracker:
                 f"Please update the slot configuration accordingly."
             )
 
-        supported_languages = []
-        for language_code in language_slot.values:
-            is_default = language_code == language_slot.initial_value
-            language = Language.from_language_code(
-                language_code=language_code,
-                is_default=is_default,
-            )
-            supported_languages.append(language)
-
-        return supported_languages
+        return [
+            Language.from_language_code(language_code)
+            for language_code in language_slot.values
+        ]
 
     @property
     def current_language(self) -> Optional[Language]:

rasa/shared/core/training_data/story_reader/yaml_story_reader.py

@@ -1,4 +1,3 @@
-import copy
 import functools
 import json
 import logging
@@ -648,9 +647,7 @@ class YAMLStoryReader(StoryReader):
         # message text did start with the special prefix -- however, a user might
         # just have decided to start their text this way.
         if not match:
-            structlogger.warning(
-                "message.parsing.failed", user_text=copy.deepcopy(user_text)
-            )
+            structlogger.warning("message.parsing.failed")
             return message
 
         # Extract attributes from the match - and validate it via the domain.

rasa/shared/importers/importer.py

@@ -18,6 +18,7 @@ import importlib_resources
 
 import rasa.shared.constants
 import rasa.shared.core.constants
+import rasa.shared.data
 import rasa.shared.utils.common
 import rasa.shared.utils.io
 from rasa.shared.constants import CONFIG_ADDITIONAL_LANGUAGES_KEY, CONFIG_LANGUAGE_KEY
@@ -206,6 +207,12 @@ class TrainingDataImporter(ABC):
                 )
             ]
 
+        return TrainingDataImporter.wrap_in_builtins(importers)
+
+    @staticmethod
+    def wrap_in_builtins(
+        importers: List["TrainingDataImporter"],
+    ) -> "TrainingDataImporter":
         return LanguageImporter(
             E2EImporter(
                 FlowSyncImporter(ResponsesSyncImporter(CombinedDataImporter(importers)))
@@ -279,6 +286,13 @@ class TrainingDataImporter(ABC):
         """
         raise NotImplementedError
 
+    @staticmethod
+    def get_domain_files(
+        data_paths: Optional[Union[List[Text], Text]] = None,
+    ) -> List[Text]:
+        """Returns the domain file path (see parent class for full docstring)."""
+        return rasa.shared.data.get_data_files(data_paths, Domain.is_domain_file)
+
 
 class NluDataImporter(TrainingDataImporter):
     """Importer that skips any Core-related file reading."""