rasa-pro 3.10.15__py3-none-any.whl → 3.11.0__py3-none-any.whl

rasa/shared/core/domain.py

@@ -1,16 +1,21 @@
+from __future__ import annotations
+
 import collections
 import copy
 import json
 import os
 from dataclasses import dataclass
+from functools import cached_property
 from pathlib import Path
 from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
+    ClassVar,
     Dict,
     Iterable,
     List,
+    MutableMapping,
     NamedTuple,
     NoReturn,
     Optional,
@@ -19,7 +24,6 @@ from typing import (
     Tuple,
     Union,
     cast,
-    MutableMapping,
 )
 
 import structlog
@@ -51,11 +55,11 @@ from rasa.shared.core.constants import (
 )
 from rasa.shared.core.events import SlotSet, UserUttered
 from rasa.shared.core.slots import (
-    Slot,
-    CategoricalSlot,
-    TextSlot,
     AnySlot,
+    CategoricalSlot,
     ListSlot,
+    Slot,
+    TextSlot,
 )
 from rasa.shared.exceptions import (
     RasaException,
@@ -63,21 +67,21 @@ from rasa.shared.exceptions import (
     YamlSyntaxException,
 )
 from rasa.shared.nlu.constants import (
-    ENTITY_ATTRIBUTE_TYPE,
-    ENTITY_ATTRIBUTE_ROLE,
+    ENTITIES,
     ENTITY_ATTRIBUTE_GROUP,
-    RESPONSE_IDENTIFIER_DELIMITER,
+    ENTITY_ATTRIBUTE_ROLE,
+    ENTITY_ATTRIBUTE_TYPE,
     INTENT_NAME_KEY,
-    ENTITIES,
+    RESPONSE_IDENTIFIER_DELIMITER,
 )
 from rasa.shared.utils.cli import print_error_and_exit
 from rasa.shared.utils.yaml import (
     KEY_TRAINING_DATA_FORMAT_VERSION,
+    dump_obj_as_yaml_to_string,
     read_yaml,
-    validate_training_data_format_version,
     read_yaml_file,
-    dump_obj_as_yaml_to_string,
     validate_raw_yaml_using_schema_file_with_responses,
+    validate_training_data_format_version,
 )
 
 if TYPE_CHECKING:
@@ -155,7 +159,7 @@ class SessionConfig(NamedTuple):
     carry_over_slots: bool
 
     @staticmethod
-    def default() -> "SessionConfig":
+    def default() -> SessionConfig:
         """Returns the SessionConfig with the default values."""
         return SessionConfig(
             DEFAULT_SESSION_EXPIRATION_TIME_IN_MINUTES,
@@ -191,13 +195,16 @@ class Domain:
     and entities it can recognise.
     """
 
+    validate_yaml: ClassVar[bool] = True
+    expand_env_vars: ClassVar[bool] = True
+
     @classmethod
-    def empty(cls) -> "Domain":
+    def empty(cls) -> Domain:
         """Returns empty Domain."""
         return Domain.from_dict({})
 
     @classmethod
-    def load(cls, paths: Union[List[Union[Path, Text]], Text, Path]) -> "Domain":
+    def load(cls, paths: Union[List[Union[Path, Text]], Text, Path]) -> Domain:
         """Returns loaded Domain after merging all domain files."""
         if not paths:
             raise InvalidDomain(
@@ -215,8 +222,15 @@ class Domain:
         return domain
 
     @classmethod
-    def from_path(cls, path: Union[Text, Path]) -> "Domain":
-        """Loads the `Domain` from a path."""
+    def from_path(cls, path: Union[Text, Path]) -> Domain:
+        """Loads the `Domain` from a path.
+
+        Args:
+            path: Path to the domain file.
+
+        Returns:
+            The instantiated `Domain` object.
+        """
         path = os.path.abspath(path)
 
         if os.path.isfile(path):
@@ -232,17 +246,30 @@ class Domain:
         return domain
 
     @classmethod
-    def from_file(cls, path: Text) -> "Domain":
-        """Loads the `Domain` from a YAML file."""
+    def from_file(cls, path: Text) -> Domain:
+        """Loads the `Domain` from a YAML file.
+
+        Args:
+            path: Path to the domain file.
+
+        Returns:
+            The instantiated `Domain` object.
+        """
         return cls.from_yaml(rasa.shared.utils.io.read_file(path), path)
 
     @classmethod
-    def from_yaml(cls, yaml: Text, original_filename: Text = "") -> "Domain":
-        """Loads the `Domain` from YAML text after validating it."""
-        try:
-            validate_raw_yaml_using_schema_file_with_responses(yaml, DOMAIN_SCHEMA_FILE)
+    def from_yaml(cls, yaml: Text, original_filename: Text = "") -> Domain:
+        """Loads the `Domain` from YAML text after validating it.
 
-            data = read_yaml(yaml)
+        Args:
+            yaml: The YAML string to load the domain from.
+            original_filename: The filename of the original YAML file.
+
+        Returns:
+            The instantiated `Domain` object.
+        """
+        try:
+            data = cls._dict_from_raw_yaml_content(yaml)
             if not validate_training_data_format_version(data, original_filename):
                 return Domain.empty()
             return cls.from_dict(data)
@@ -251,7 +278,7 @@ class Domain:
             raise e
 
     @classmethod
-    def from_dict(cls, data: Dict) -> "Domain":
+    def from_dict(cls, data: Dict) -> Domain:
         """Deserializes and creates domain.
 
         Args:
@@ -282,8 +309,8 @@ class Domain:
         _validate_forms(forms)
 
         return cls(
-            intents=intents,
-            entities=data.get(KEY_ENTITIES, {}),
+            intents=intents or [],
+            entities=data.get(KEY_ENTITIES, []),
             slots=slots,
             responses=responses,
             action_names=actions,
@@ -308,8 +335,15 @@ class Domain:
         return SessionConfig(session_expiration_time_min, carry_over_slots)
 
     @classmethod
-    def from_directory(cls, path: Text) -> "Domain":
-        """Loads and merges multiple domain files recursively from a directory tree."""
+    def from_directory(cls, path: Text) -> Domain:
+        """Loads and merges multiple domain files recursively from a directory tree.
+
+        Args:
+            path: Path to the root directory.
+
+        Returns:
+            The instantiated `Domain` object.
+        """
         combined: Dict[Text, Any] = {}
         duplicates: List[Dict[Text, List[Text]]] = []
 
@@ -319,10 +353,10 @@ class Domain:
                 if not Domain.is_domain_file(full_path):
                     continue
 
-                # does the validation here only
-                _ = Domain.from_file(full_path)
+                other_dict = cls._dict_from_raw_yaml_content(
+                    rasa.shared.utils.io.read_file(full_path)
+                )
 
-                other_dict = read_yaml(rasa.shared.utils.io.read_file(full_path))
                 combined = Domain.merge_domain_dicts(other_dict, combined)
                 duplicates.append(combined.pop("duplicates", {}))
 
@@ -368,10 +402,10 @@ class Domain:
 
     def merge(
         self,
-        domain: Optional["Domain"],
+        domain: Optional[Domain],
         override: bool = False,
         ignore_warnings_about_duplicates: bool = False,
-    ) -> "Domain":
+    ) -> Domain:
         """Merges this domain dict with another one, combining their attributes.
 
         This method merges domain dicts, and ensures all attributes (like ``intents``,
@@ -674,7 +708,7 @@ class Domain:
 
         return intent
 
-    @rasa.shared.utils.common.lazy_property
+    @cached_property
     def retrieval_intents(self) -> List[Text]:
         """List retrieval intents present in the domain."""
         return [
@@ -899,7 +933,7 @@ class Domain:
         self.store_entities_as_slots = store_entities_as_slots
         self._check_domain_sanity()
 
-    def __deepcopy__(self, memo: Optional[Dict[int, Any]]) -> "Domain":
+    def __deepcopy__(self, memo: Optional[Dict[int, Any]]) -> Domain:
         """Enables making a deep copy of the `Domain` using `copy.deepcopy`.
 
         See https://docs.python.org/3/library/copy.html#copy.deepcopy
@@ -1003,23 +1037,23 @@ class Domain:
         sorted_intents = sorted(intents, key=sort)
         return sorted_intents
 
-    @rasa.shared.utils.common.lazy_property
+    @cached_property
     def user_actions_and_forms(self) -> List[Text]:
         """Returns combination of user actions and forms."""
         return self.user_actions + self.form_names
 
-    @rasa.shared.utils.common.lazy_property
+    @cached_property
     def num_actions(self) -> int:
         """Returns the number of available actions."""
         # noinspection PyTypeChecker
         return len(self.action_names_or_texts)
 
-    @rasa.shared.utils.common.lazy_property
+    @cached_property
     def num_states(self) -> int:
         """Number of used input states for the action prediction."""
         return len(self.input_states)
 
-    @rasa.shared.utils.common.lazy_property
+    @cached_property
     def retrieval_intent_responses(self) -> Dict[Text, List[Dict[Text, Any]]]:
         """Return only the responses which are defined for retrieval intents."""
         return dict(
@@ -1171,8 +1205,7 @@ class Domain:
             f"Available actions are: \n{action_names}"
         )
 
-    # noinspection PyTypeChecker
-    @rasa.shared.utils.common.lazy_property
+    @cached_property
     def slot_states(self) -> List[Text]:
         """Returns all available slot state strings."""
         return [
@@ -1181,8 +1214,7 @@ class Domain:
             for feature_index in range(0, slot.feature_dimensionality())
         ]
 
-    # noinspection PyTypeChecker
-    @rasa.shared.utils.common.lazy_property
+    @cached_property
     def entity_states(self) -> List[Text]:
         """Returns all available entity state strings."""
         entity_states = copy.deepcopy(self.entities)
@@ -1230,12 +1262,12 @@ class Domain:
             for entity_sub_label in entity_sub_labels
         ]
 
-    @rasa.shared.utils.common.lazy_property
+    @cached_property
     def input_state_map(self) -> Dict[Text, int]:
         """Provide a mapping from state names to indices."""
         return {f: i for i, f in enumerate(self.input_states)}
 
-    @rasa.shared.utils.common.lazy_property
+    @cached_property
     def input_states(self) -> List[Text]:
         """Returns all available states."""
         return (
@@ -1465,7 +1497,7 @@ class Domain:
         ignore_rule_only_turns: bool = False,
         rule_only_data: Optional[Dict[Text, Any]] = None,
     ) -> List[State]:
-        """List of states for each state of the trackers history.
+        """List of states for each state of the tracker's history.
 
         Args:
             tracker: Dialogue state tracker containing the dialogue so far.
@@ -1682,12 +1714,12 @@ class Domain:
         """Return the configuration for an intent."""
         return self.intent_properties.get(intent_name, {})
 
-    @rasa.shared.utils.common.lazy_property
+    @cached_property
     def intents(self) -> List[Text]:
         """Returns sorted list of intents."""
         return sorted(self.intent_properties.keys())
 
-    @rasa.shared.utils.common.lazy_property
+    @cached_property
     def entities(self) -> List[Text]:
         """Returns sorted list of entities."""
         return sorted(self.entity_properties.entities)
@@ -1924,8 +1956,8 @@ class Domain:
         """Check whether the domain is empty."""
         return self.as_dict() == Domain.empty().as_dict()
 
-    @staticmethod
-    def is_domain_file(filename: Union[Text, Path]) -> bool:
+    @classmethod
+    def is_domain_file(cls, filename: Union[Text, Path]) -> bool:
         """Checks whether the given file path is a Rasa domain file.
 
         Args:
@@ -1944,7 +1976,7 @@ class Domain:
             return False
 
         try:
-            content = read_yaml_file(filename)
+            content = read_yaml_file(filename, expand_env_vars=cls.expand_env_vars)
         except (RasaException, YamlSyntaxException):
             structlogger.warning(
                 "domain.cannot_load_domain_file",
@@ -2055,6 +2087,31 @@ class Domain:
     def is_custom_action(self, action_name: str) -> bool:
         return action_name in self._custom_actions
 
+    @classmethod
+    def _dict_from_raw_yaml_content(cls, raw_yaml_content: Text) -> Any:
+        """Loads the Domain dict from raw YAML content.
+
+        Validates the raw YAML content using the schema file if `validate_yaml` is set
+        to `True`.
+
+        Args:
+            raw_yaml_content: The raw YAML content of the domain file.
+
+        Returns:
+            The Domain dict.
+        """
+        if cls.validate_yaml:
+            structlogger.info(
+                "domain.from_yaml.validating",
+            )
+            validate_raw_yaml_using_schema_file_with_responses(
+                raw_yaml_content,
+                DOMAIN_SCHEMA_FILE,
+                expand_env_vars=cls.expand_env_vars,
+            )
+
+        return read_yaml(raw_yaml_content, expand_env_vars=cls.expand_env_vars)
+
 
 def warn_about_duplicates_found_during_domain_merging(
     duplicates: Dict[Text, List[Text]],

rasa/shared/core/events.py

@@ -2528,3 +2528,32 @@ class FlowCancelled(SkipEventInMDStoryMixin):
             )
         except KeyError as e:
             raise ValueError(f"Failed to parse flow_cancelled event. {e}")
+
+
+class SessionEnded(AlwaysEqualEventMixin):
+    """Mark the end of a conversation session."""
+
+    type_name = "session_ended"
+
+    def __hash__(self) -> int:
+        """Returns unique hash for event."""
+        return hash(32143124321)
+
+    def __repr__(self) -> Text:
+        """Returns event as string for debugging."""
+        return f"SessionEnded(type_name: {self.type_name})"
+
+    def __str__(self) -> Text:
+        """Returns event as human-readable string."""
+        return f"{self.__class__.__name__}({self.type_name})"
+
+    def as_story_string(self) -> None:
+        """Skips representing event in stories."""
+        logger.warning(
+            f"'{self.type_name}' events cannot be serialised as story strings."
+        )
+
+    def apply_to(self, tracker: "DialogueStateTracker") -> None:
+        """Applies event to current conversation state."""
+        # noinspection PyProtectedMember
+        tracker._reset()

rasa/shared/core/flows/flow.py

@@ -60,6 +60,8 @@ class Flow:
     """
     file_path: Optional[str] = None
     """The path to the file where the flow is stored."""
+    persisted_slots: List[str] = field(default_factory=list)
+    """The list of slots that should be persisted after the flow ends."""
 
     @staticmethod
     def from_json(
@@ -95,6 +97,7 @@ class Flow:
             # If we are reading the flows in after training the file_path is part of
             # data. When the model is trained, take the provided file_path.
             file_path=data.get("file_path") if "file_path" in data else file_path,
+            persisted_slots=data.get("persisted_slots", []),
         )
 
     def get_full_name(self) -> str:
@@ -167,6 +170,8 @@ class Flow:
             data["nlu_trigger"] = self.nlu_triggers.as_json()
         if self.file_path:
             data["file_path"] = self.file_path
+        if self.persisted_slots:
+            data["persisted_slots"] = self.persisted_slots
 
         return data
 

rasa/shared/core/flows/flows_list.py

@@ -16,6 +16,7 @@ from rasa.shared.core.flows.validation import (
     validate_patterns_are_not_called_or_linked,
     validate_patterns_are_not_calling_or_linking_other_flows,
     validate_step_ids_are_unique,
+    DuplicatedFlowIdException,
 )
 from rasa.shared.core.slots import Slot
 
@@ -49,21 +50,31 @@ class FlowsList:
         return len(self.underlying_flows) == 0
 
     @classmethod
-    def from_multiple_flows_lists(cls, *other: FlowsList) -> FlowsList:
+    def from_multiple_flows_lists(
+        cls, *other: FlowsList, ignore_duplicates: bool = True
+    ) -> FlowsList:
         """Merges multiple lists of flows into a single flow ensuring each flow is
         unique, based on its ID.
 
         Args:
             other: Variable number of flow lists instances to be merged.
+            ignore_duplicates: Whether to ignore duplicate flow ids, or raise an error.
 
         Returns:
             Merged flow list.
         """
-        merged_flows = dict()
+        merged_flows: Dict[Text, Flow] = dict()
         for flow_list in other:
             for flow in flow_list:
-                if flow.id not in merged_flows:
-                    merged_flows[flow.id] = flow
+                if flow.id in merged_flows:
+                    if ignore_duplicates:
+                        continue
+                    current_flow_path = flow.file_path
+                    other_flow_path = merged_flows[flow.id].file_path
+                    raise DuplicatedFlowIdException(
+                        flow.id, current_flow_path, other_flow_path
+                    )
+                merged_flows[flow.id] = flow
         return FlowsList(list(merged_flows.values()))
 
     @classmethod
@@ -118,9 +129,11 @@ class FlowsList:
         flow_dicts = [flow.as_json() for flow in self.underlying_flows]
         return rasa.shared.utils.io.get_list_fingerprint(flow_dicts)
 
-    def merge(self, other: FlowsList) -> FlowsList:
+    def merge(self, other: FlowsList, ignore_duplicates: bool = True) -> FlowsList:
         """Merges two lists of flows together."""
-        return FlowsList.from_multiple_flows_lists(self, other)
+        return FlowsList.from_multiple_flows_lists(
+            self, other, ignore_duplicates=ignore_duplicates
+        )
 
     def flow_by_id(self, flow_id: Text) -> Optional[Flow]:
         """Return the flow with the given id."""

rasa/shared/core/flows/flows_yaml_schema.json

@@ -279,6 +279,9 @@
                 },
                 "steps": {
                     "$ref": "#/$defs/steps"
+                },
+                "persisted_slots": {
+                    "$ref": "#/$defs/persisted_slots"
                 }
             }
         },
@@ -288,6 +291,13 @@
             "items": {
                 "type": "object"
             }
+        },
+        "persisted_slots": {
+            "type": "array",
+            "schema_name": "list of slots",
+            "items": {
+                "type": "string"
+            }
         }
     }
 }

rasa/shared/core/flows/utils.py

@@ -0,0 +1,39 @@
+from typing import Set
+from rasa.shared.utils.io import raise_deprecation_warning
+
+RESET_PROPERTY_NAME = "reset_after_flow_ends"
+PERSIST_PROPERTY_NAME = "persisted_slots"
+
+
+def warn_deprecated_collect_step_config(flow_id: str, collect_step: str) -> None:
+    """Warns about deprecated reset_after_flow_ends usage in collect steps."""
+    raise_deprecation_warning(
+        f"Configuring '{RESET_PROPERTY_NAME}' in collect step '{collect_step}' is "
+        f"deprecated and will be removed in Rasa Pro 4.0.0. In flow id '{flow_id}', "
+        f"please use the '{PERSIST_PROPERTY_NAME}' "
+        "property at the flow level instead."
+    )
+
+
+def get_duplicate_slot_persistence_config_error_message(
+    flow_id: str, collect_step: str
+) -> str:
+    """Returns an error message for duplicate slot persistence configuration."""
+    return (
+        f"Flow with id '{flow_id}' uses the '{RESET_PROPERTY_NAME}' property "
+        f"in collect step '{collect_step}' and also the "
+        f"'{PERSIST_PROPERTY_NAME}' property at the flow level. "
+        "Please use only one of the two configuration methods."
+    )
+
+
+def get_invalid_slot_persistence_config_error_message(
+    flow_id: str, invalid_slots: Set[str]
+) -> str:
+    """Returns an error message for invalid slot persistence configuration."""
+    return (
+        f"Flow with id '{flow_id}' lists slot(s) '{invalid_slots}' in the "
+        f"'{PERSIST_PROPERTY_NAME}' property. However these slots "
+        f"are neither used in a collect step nor a set_slot step of the flow. "
+        f"Please remove such slots from the '{PERSIST_PROPERTY_NAME}' property."
+    )