rasa-pro 3.11.0a4.dev3__py3-none-any.whl → 3.11.0rc1__py3-none-any.whl

rasa/nlu/featurizers/sparse_featurizer/count_vectors_featurizer.py

@@ -1,30 +1,32 @@
 from __future__ import annotations
+
 import logging
 import re
+from typing import Any, Dict, List, Optional, Text, Tuple, Set, Type, Union
+
+import numpy as np
 import scipy.sparse
-from typing import Any, Dict, List, Optional, Text, Tuple, Set, Type
-from rasa.nlu.tokenizers.tokenizer import Tokenizer
+from sklearn.exceptions import NotFittedError
+from sklearn.feature_extraction.text import CountVectorizer
 
 import rasa.shared.utils.io
 from rasa.engine.graph import GraphComponent, ExecutionContext
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
-from rasa.nlu.featurizers.sparse_featurizer.sparse_featurizer import SparseFeaturizer
-from rasa.nlu.utils.spacy_utils import SpacyModel
-from rasa.shared.constants import DOCS_URL_COMPONENTS
-import rasa.utils.io as io_utils
-from sklearn.exceptions import NotFittedError
-from sklearn.feature_extraction.text import CountVectorizer
-from rasa.shared.nlu.training_data.training_data import TrainingData
-from rasa.shared.nlu.training_data.message import Message
-from rasa.shared.exceptions import RasaException, FileIOException
 from rasa.nlu.constants import (
     TOKENS_NAMES,
     MESSAGE_ATTRIBUTES,
     DENSE_FEATURIZABLE_ATTRIBUTES,
 )
+from rasa.nlu.featurizers.sparse_featurizer.sparse_featurizer import SparseFeaturizer
+from rasa.nlu.tokenizers.tokenizer import Tokenizer
+from rasa.nlu.utils.spacy_utils import SpacyModel
+from rasa.shared.constants import DOCS_URL_COMPONENTS
+from rasa.shared.exceptions import RasaException, FileIOException
 from rasa.shared.nlu.constants import TEXT, INTENT, INTENT_RESPONSE_KEY, ACTION_NAME
+from rasa.shared.nlu.training_data.message import Message
+from rasa.shared.nlu.training_data.training_data import TrainingData
 
 BUFFER_SLOTS_PREFIX = "buf_"
 
@@ -688,6 +690,31 @@ class CountVectorsFeaturizer(SparseFeaturizer, GraphComponent):
         """Check if any model got trained."""
         return any(value is not None for value in attribute_vocabularies.values())
 
+    @staticmethod
+    def convert_vocab(
+        vocab: Dict[str, Union[int, Optional[Dict[str, int]]]], to_int: bool
+    ) -> Dict[str, Union[None, int, np.int64, Dict[str, Union[int, np.int64]]]]:
+        """Converts numpy integers in the vocabulary to Python integers."""
+
+        def convert_value(value: int) -> Union[int, np.int64]:
+            """Helper function to convert a single value based on to_int flag."""
+            return int(value) if to_int else np.int64(value)
+
+        result_dict: Dict[
+            str, Union[None, int, np.int64, Dict[str, Union[int, np.int64]]]
+        ] = {}
+        for key, sub_dict in vocab.items():
+            if isinstance(sub_dict, int):
+                result_dict[key] = convert_value(sub_dict)
+            elif not sub_dict:
+                result_dict[key] = None
+            else:
+                result_dict[key] = {
+                    sub_key: convert_value(value) for sub_key, value in sub_dict.items()
+                }
+
+        return result_dict
+
     def persist(self) -> None:
         """Persist this model into the passed directory.
 
@@ -701,17 +728,18 @@ class CountVectorsFeaturizer(SparseFeaturizer, GraphComponent):
             attribute_vocabularies = self._collect_vectorizer_vocabularies()
             if self._is_any_model_trained(attribute_vocabularies):
                 # Definitely need to persist some vocabularies
-                featurizer_file = model_dir / "vocabularies.pkl"
+                featurizer_file = model_dir / "vocabularies.json"
 
                 # Only persist vocabulary from one attribute if `use_shared_vocab`.
                 # Can be loaded and distributed to all attributes.
-                vocab = (
+                loaded_vocab = (
                     attribute_vocabularies[TEXT]
                     if self.use_shared_vocab
                     else attribute_vocabularies
                 )
+                vocab = self.convert_vocab(loaded_vocab, to_int=True)
 
-                io_utils.json_pickle(featurizer_file, vocab)
+                rasa.shared.utils.io.dump_obj_as_json_to_file(featurizer_file, vocab)
 
                 # Dump OOV words separately as they might have been modified during
                 # training
@@ -786,8 +814,9 @@ class CountVectorsFeaturizer(SparseFeaturizer, GraphComponent):
         """Loads trained component (see parent class for full docstring)."""
         try:
             with model_storage.read_from(resource) as model_dir:
-                featurizer_file = model_dir / "vocabularies.pkl"
-                vocabulary = io_utils.json_unpickle(featurizer_file)
+                featurizer_file = model_dir / "vocabularies.json"
+                vocabulary = rasa.shared.utils.io.read_json_file(featurizer_file)
+                vocabulary = cls.convert_vocab(vocabulary, to_int=False)
 
                 share_vocabulary = config["use_shared_vocab"]
 

rasa/nlu/featurizers/sparse_featurizer/lexical_syntactic_featurizer.py

@@ -1,9 +1,7 @@
 from __future__ import annotations
+
 import logging
 from collections import OrderedDict
-
-import scipy.sparse
-import numpy as np
 from typing import (
     Any,
     Dict,
@@ -17,30 +15,34 @@ from typing import (
     Union,
 )
 
+import numpy as np
+import scipy.sparse
+
+import rasa.shared.utils.io
+import rasa.utils.io
 from rasa.engine.graph import ExecutionContext, GraphComponent
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
+from rasa.nlu.constants import TOKENS_NAMES
+from rasa.nlu.featurizers.sparse_featurizer.sparse_featurizer import SparseFeaturizer
 from rasa.nlu.tokenizers.spacy_tokenizer import POS_TAG_KEY, SpacyTokenizer
 from rasa.nlu.tokenizers.tokenizer import Token, Tokenizer
-from rasa.nlu.featurizers.sparse_featurizer.sparse_featurizer import SparseFeaturizer
-from rasa.nlu.constants import TOKENS_NAMES
 from rasa.shared.constants import DOCS_URL_COMPONENTS
-from rasa.shared.nlu.training_data.training_data import TrainingData
-from rasa.shared.nlu.training_data.message import Message
-from rasa.shared.nlu.constants import TEXT
 from rasa.shared.exceptions import InvalidConfigException
-import rasa.shared.utils.io
-import rasa.utils.io
+from rasa.shared.nlu.constants import TEXT
+from rasa.shared.nlu.training_data.message import Message
+from rasa.shared.nlu.training_data.training_data import TrainingData
 
 logger = logging.getLogger(__name__)
 
-
 END_OF_SENTENCE = "EOS"
 BEGIN_OF_SENTENCE = "BOS"
 
 FEATURES = "features"
 
+SEPERATOR = "###"
+
 
 @DefaultV1Recipe.register(
     DefaultV1Recipe.ComponentType.MESSAGE_FEATURIZER, is_trainable=True
@@ -72,7 +74,7 @@ class LexicalSyntacticFeaturizer(SparseFeaturizer, GraphComponent):
       of the token at position `t+1`.
     """
 
-    FILENAME_FEATURE_TO_IDX_DICT = "feature_to_idx_dict.pkl"
+    FILENAME_FEATURE_TO_IDX_DICT = "feature_to_idx_dict.json"
 
     # NOTE: "suffix5" of the token "is" will be "is". Hence, when combining multiple
     # prefixes, short words will be represented/encoded repeatedly.
@@ -488,6 +490,32 @@ class LexicalSyntacticFeaturizer(SparseFeaturizer, GraphComponent):
         """Creates a new untrained component (see parent class for full docstring)."""
         return cls(config, model_storage, resource, execution_context)
 
+    @staticmethod
+    def _restructure_feature_to_idx_dict(
+        loaded_data: Dict[str, Dict[str, int]],
+    ) -> Dict[Tuple[int, str], Dict[str, int]]:
+        """Reconstructs the feature to idx dict.
+
+        When storing the feature_to_idx_dict to disk, we need to convert the tuple (key)
+        into a string to be able to store it via json. When loading the data
+        we need to reconstruct the tuple from the stored string.
+
+        Args:
+            loaded_data: The loaded feature to idx dict from file.
+
+        Returns:
+            The reconstructed feature_to_idx_dict
+        """
+        feature_to_idx_dict = {}
+        for tuple_string, feature_value in loaded_data.items():
+            # Example of tuple_string: "1###low"
+            index, feature_name = tuple_string.split(SEPERATOR)
+
+            feature_key = (int(index), feature_name)
+            feature_to_idx_dict[feature_key] = feature_value
+
+        return feature_to_idx_dict
+
     @classmethod
     def load(
         cls,
@@ -500,10 +528,13 @@ class LexicalSyntacticFeaturizer(SparseFeaturizer, GraphComponent):
         """Loads trained component (see parent class for full docstring)."""
         try:
             with model_storage.read_from(resource) as model_path:
-                feature_to_idx_dict = rasa.utils.io.json_unpickle(
+                loaded_data = rasa.shared.utils.io.read_json_file(
                     model_path / cls.FILENAME_FEATURE_TO_IDX_DICT,
-                    encode_non_string_keys=True,
                 )
+
+                # convert the key back into tuple
+                feature_to_idx_dict = cls._restructure_feature_to_idx_dict(loaded_data)
+
                 return cls(
                     config=config,
                     model_storage=model_storage,
@@ -528,9 +559,13 @@ class LexicalSyntacticFeaturizer(SparseFeaturizer, GraphComponent):
         if not self._feature_to_idx_dict:
             return None
 
+        # as we cannot dump tuples, convert the tuple into a string
+        restructured_feature_dict = {
+            f"{k[0]}{SEPERATOR}{k[1]}": v for k, v in self._feature_to_idx_dict.items()
+        }
+
         with self._model_storage.write_to(self._resource) as model_path:
-            rasa.utils.io.json_pickle(
+            rasa.shared.utils.io.dump_obj_as_json_to_file(
                 model_path / self.FILENAME_FEATURE_TO_IDX_DICT,
-                self._feature_to_idx_dict,
-                encode_non_string_keys=True,
+                restructured_feature_dict,
             )

rasa/nlu/featurizers/sparse_featurizer/regex_featurizer.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
+
 import logging
 import re
 from typing import Any, Dict, List, Optional, Text, Tuple, Type
+
 import numpy as np
 import scipy.sparse
-from rasa.nlu.tokenizers.tokenizer import Tokenizer
 
+from rasa.nlu.tokenizers.tokenizer import Tokenizer
 import rasa.shared.utils.io
 import rasa.utils.io
 import rasa.nlu.utils.pattern_utils as pattern_utils
@@ -240,7 +242,7 @@ class RegexFeaturizer(SparseFeaturizer, GraphComponent):
 
         try:
             with model_storage.read_from(resource) as model_dir:
-                patterns_file_name = model_dir / "patterns.pkl"
+                patterns_file_name = model_dir / "patterns.json"
                 known_patterns = rasa.shared.utils.io.read_json_file(patterns_file_name)
         except (ValueError, FileNotFoundError):
             logger.warning(
@@ -258,7 +260,7 @@ class RegexFeaturizer(SparseFeaturizer, GraphComponent):
 
     def _persist(self) -> None:
         with self._model_storage.write_to(self._resource) as model_dir:
-            regex_file = model_dir / "patterns.pkl"
+            regex_file = model_dir / "patterns.json"
             rasa.shared.utils.io.dump_obj_as_json_to_file(
                 regex_file, self.known_patterns
             )

rasa/shared/constants.py

@@ -183,7 +183,34 @@ STREAM_CONFIG_KEY = "stream"
 N_REPHRASES_CONFIG_KEY = "n"
 USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY = "use_chat_completions_endpoint"
 
+ROUTER_CONFIG_KEY = "router"
+ROUTER_STRATEGY_CONFIG_KEY = "router_strategy"
+REDIS_HOST_CONFIG_KEY = "redis_host"
+ROUTER_STRATEGIES_REQUIRING_REDIS_CACHE = [
+    "cost-based-routing",
+    "usage-based-routing",
+]
+ROUTER_STRATEGIES_NOT_REQUIRING_CACHE = [
+    "latency-based-routing",
+    "least-busy",
+    "simple-shuffle",
+]
+VALID_ROUTER_STRATEGIES = (
+    ROUTER_STRATEGIES_REQUIRING_REDIS_CACHE + ROUTER_STRATEGIES_NOT_REQUIRING_CACHE
+)
+
+MODELS_CONFIG_KEY = "models"
+MODEL_GROUPS_CONFIG_KEY = "model_groups"
+MODEL_GROUP_CONFIG_KEY = "model_group"
+MODEL_GROUP_ID_CONFIG_KEY = "id"
+
+EXTRA_PARAMETERS_KEY = "extra_parameters"
+MODEL_GROUP_ID_KEY = "model_group_id"
+MODEL_LIST_KEY = "model_list"
+LITELLM_PARAMS_KEY = "litellm_params"
+
 LLM_API_HEALTH_CHECK_ENV_VAR = "LLM_API_HEALTH_CHECK"
+LLM_API_HEALTH_CHECK_DEFAULT_VALUE = "false"
 
 AZURE_API_KEY_ENV_VAR = "AZURE_API_KEY"
 AZURE_AD_TOKEN_ENV_VAR = "AZURE_AD_TOKEN"
@@ -191,6 +218,8 @@ AZURE_API_BASE_ENV_VAR = "AZURE_API_BASE"
 AZURE_API_VERSION_ENV_VAR = "AZURE_API_VERSION"
 AZURE_API_TYPE_ENV_VAR = "AZURE_API_TYPE"
 
+AWS_REGION_NAME_CONFIG_KEY = "aws_region_name"
+
 HUGGINGFACE_MULTIPROCESS_CONFIG_KEY = "multi_process"
 HUGGINGFACE_CACHE_FOLDER_CONFIG_KEY = "cache_folder"
 HUGGINGFACE_SHOW_PROGRESS_CONFIG_KEY = "show_progress"
@@ -211,6 +240,13 @@ OPENAI_PROVIDER = "openai"
 AZURE_OPENAI_PROVIDER = "azure"
 SELF_HOSTED_PROVIDER = "self-hosted"
 HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER = "huggingface_local"
+RASA_PROVIDER = "rasa"
+
+SELF_HOSTED_VLLM_PREFIX = "hosted_vllm"
+SELF_HOSTED_VLLM_API_KEY_ENV_VAR = "HOSTED_VLLM_API_KEY"
+
+SELF_HOSTED_VLLM_PREFIX = "hosted_vllm"
+SELF_HOSTED_VLLM_API_KEY_ENV_VAR = "HOSTED_VLLM_API_KEY"
 
 SELF_HOSTED_VLLM_PREFIX = "hosted_vllm"
 SELF_HOSTED_VLLM_API_KEY_ENV_VAR = "HOSTED_VLLM_API_KEY"
@@ -244,6 +280,3 @@ RASA_PATTERN_CANNOT_HANDLE_INVALID_INTENT = (
 )
 
 ROUTE_TO_CALM_SLOT = "route_session_to_calm"
-
-ORIGINAL_VALUE = "original_value"
-RESOLVED_VALUE = "resolved_value"

rasa/shared/core/constants.py

@@ -11,6 +11,7 @@ USER_INTENT_BACK = "back"
 USER_INTENT_OUT_OF_SCOPE = "out_of_scope"
 USER_INTENT_SESSION_START = "session_start"
 USER_INTENT_SESSION_END = "session_end"
+USER_INTENT_SILENCE_TIMEOUT = "silence_timeout"
 SESSION_START_METADATA_SLOT = "session_started_metadata"
 
 DEFAULT_INTENTS = [
@@ -19,6 +20,7 @@ DEFAULT_INTENTS = [
     USER_INTENT_OUT_OF_SCOPE,
     USER_INTENT_SESSION_START,
     USER_INTENT_SESSION_END,
+    USER_INTENT_SILENCE_TIMEOUT,
     constants.DEFAULT_NLU_FALLBACK_INTENT_NAME,
 ]
 
@@ -106,6 +108,11 @@ FLOW_HASHES_SLOT = "flow_hashes"
 
 FLOW_SLOT_NAMES = [FLOW_HASHES_SLOT]
 
+# slots for audio timeout
+SLOT_SILENCE_TIMEOUT = "silence_timeout"
+SILENCE_TIMEOUT_DEFAULT_VALUE = 6.0
+SLOT_CONSECUTIVE_SILENCE_TIMEOUTS = "consecutive_silence_timeouts"
+SILENCE_SLOTS = [SLOT_SILENCE_TIMEOUT, SLOT_CONSECUTIVE_SILENCE_TIMEOUTS]
 # slots for knowledge base
 SLOT_LISTED_ITEMS = "knowledge_base_listed_objects"
 SLOT_LAST_OBJECT = "knowledge_base_last_object"

rasa/shared/core/domain.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import collections
 import copy
 import json
+import math
 import os
 from dataclasses import dataclass
 from functools import cached_property
@@ -57,6 +58,7 @@ from rasa.shared.core.events import SlotSet, UserUttered
 from rasa.shared.core.slots import (
     AnySlot,
     CategoricalSlot,
+    FloatSlot,
     ListSlot,
     Slot,
     TextSlot,
@@ -1082,6 +1084,7 @@ class Domain:
         self._add_knowledge_base_slots()
         self._add_categorical_slot_default_value()
         self._add_session_metadata_slot()
+        self._add_audio_slots()
 
     def _add_categorical_slot_default_value(self) -> None:
         """Add a default value to all categorical slots.
@@ -1136,6 +1139,29 @@ class Domain:
                 )
             )
 
+    def _add_audio_slots(self) -> None:
+        """Add slots relevant for audio channels."""
+        self.slots.append(
+            FloatSlot(
+                rasa.shared.core.constants.SLOT_SILENCE_TIMEOUT,
+                mappings=[],
+                influence_conversation=False,
+                is_builtin=True,
+                initial_value=rasa.shared.core.constants.SILENCE_TIMEOUT_DEFAULT_VALUE,
+                max_value=math.inf,
+            )
+        )
+        self.slots.append(
+            FloatSlot(
+                rasa.shared.core.constants.SLOT_CONSECUTIVE_SILENCE_TIMEOUTS,
+                mappings=[],
+                influence_conversation=False,
+                is_builtin=True,
+                initial_value=0.0,
+                max_value=math.inf,
+            )
+        )
+
     def _add_knowledge_base_slots(self) -> None:
         """Add slots for the knowledge base action to slots.
 

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_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."
+    )

rasa/shared/core/flows/validation.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import re
 import typing
 from collections import defaultdict
+from dataclasses import dataclass
 from typing import Optional, Set, Text, List
 
 from rasa.shared.constants import (
@@ -26,6 +27,12 @@ from rasa.shared.core.flows.steps.call import CallFlowStep
 from rasa.shared.core.flows.steps.collect import CollectInformationFlowStep
 from rasa.shared.core.flows.steps.constants import CONTINUE_STEP_PREFIX, DEFAULT_STEPS
 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 (
+    warn_deprecated_collect_step_config,
+    get_duplicate_slot_persistence_config_error_message,
+    get_invalid_slot_persistence_config_error_message,
+)
 from rasa.shared.exceptions import RasaException
 
 if typing.TYPE_CHECKING:
@@ -379,6 +386,42 @@ class FlowIdNamingException(RasaException):
         )
 
 
+class DuplicateSlotPersistConfigException(RasaException):
+    """Raised when a slot persist configuration is duplicated."""
+
+    def __init__(self, flow_id: str, collect_step: str) -> None:
+        """Initializes the exception."""
+        self.flow_id = flow_id
+        self.collect_step = collect_step
+
+    def __str__(self) -> str:
+        """Return a string representation of the exception."""
+        return get_duplicate_slot_persistence_config_error_message(
+            self.flow_id, self.collect_step
+        )
+
+
+class InvalidPersistSlotsException(RasaException):
+    """Raised when a slot persist configuration is duplicated."""
+
+    def __init__(self, flow_id: str, invalid_slots: Set[str]) -> None:
+        """Initializes the exception."""
+        self.flow_id = flow_id
+        self.invalid_slots = invalid_slots
+
+    def __str__(self) -> str:
+        """Return a string representation of the exception."""
+        return get_invalid_slot_persistence_config_error_message(
+            self.flow_id, self.invalid_slots
+        )
+
+
+@dataclass
+class ValidationResult:
+    is_valid: bool
+    invalid_slots: Set[str]
+
+
 def validate_flow(flow: Flow) -> None:
     """Validates the flow configuration.
 
@@ -387,6 +430,8 @@ def validate_flow(flow: Flow) -> None:
         - whether all next links point to existing steps
         - whether all steps can be reached from the start step
     """
+    from rasa.cli.utils import is_skip_validation_flag_set
+
     validate_flow_not_empty(flow)
     validate_no_empty_step_sequences(flow)
     validate_all_steps_next_property(flow)
@@ -397,6 +442,12 @@ def validate_flow(flow: Flow) -> None:
     validate_slot_names_to_be_collected(flow)
     validate_flow_id(flow)
 
+    if is_skip_validation_flag_set():
+        # we only want to run this validation if the --skip-validation flag is used
+        # during training because Flow Validation exceptions are raised one by one
+        # as opposed to all at once with the Validator class
+        validate_slot_persistence_configuration(flow)
+
 
 def validate_flow_not_empty(flow: Flow) -> None:
     """Validate that the flow is not empty."""
@@ -637,3 +688,48 @@ def validate_flow_id(flow: Flow) -> None:
     flow_re = re.compile(FLOW_ID_REGEX)
     if not flow_re.search(flow.id):
         raise FlowIdNamingException(flow.id)
+
+
+def validate_slot_persistence_configuration(flow: Flow) -> None:
+    """Validates that slot persistence configuration is valid.
+
+    Only slots used in either a collect step or a set_slot step can be persisted
+    and the configuration can either be set at the flow level or the collect step level,
+    but not both.
+
+    Args:
+        flow: The flow to validate.
+
+    Raises:
+        DuplicateSlotPersistConfigException: If slot persist config is duplicated.
+    """
+
+    def _is_persist_slots_valid(
+        persist_slots: List[str], flow_slots: Set[str]
+    ) -> ValidationResult:
+        """Validates that the slots that should be persisted are used in the flow."""
+        invalid_slots = set(persist_slots) - flow_slots
+        is_valid = False if invalid_slots else True
+
+        return ValidationResult(is_valid, invalid_slots)
+
+    flow_id = flow.id
+    persist_slots = flow.persisted_slots
+    has_flow_level_persistence = True if persist_slots else False
+    flow_slots = set()
+
+    for step in flow.steps_with_calls_resolved:
+        if isinstance(step, SetSlotsFlowStep):
+            flow_slots.update([slot["key"] for slot in step.slots])
+        elif isinstance(step, CollectInformationFlowStep):
+            flow_slots.add(step.collect)
+            if not step.reset_after_flow_ends:
+                collect_step = step.collect
+                warn_deprecated_collect_step_config(flow_id, collect_step)
+                if has_flow_level_persistence:
+                    raise DuplicateSlotPersistConfigException(flow_id, collect_step)
+
+    if has_flow_level_persistence:
+        result = _is_persist_slots_valid(persist_slots, flow_slots)
+        if not result.is_valid:
+            raise InvalidPersistSlotsException(flow_id, result.invalid_slots)

rasa/shared/core/slots.py

@@ -193,6 +193,11 @@ class Slot(ABC):
         data.update(self.persistence_info())
         return rasa.shared.utils.io.get_dictionary_fingerprint(data)
 
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, Slot):
+            return False
+        return self.name == other.name and self.value == other.value
+
 
 class FloatSlot(Slot):
     """A slot storing a float value."""