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

rasa/nlu/featurizers/sparse_featurizer/lexical_syntactic_featurizer.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
-
 import logging
 from collections import OrderedDict
+
+import scipy.sparse
+import numpy as np
 from typing import (
     Any,
     Dict,
@@ -15,34 +17,30 @@ 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.exceptions import InvalidConfigException
-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
+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
 
 logger = logging.getLogger(__name__)
 
+
 END_OF_SENTENCE = "EOS"
 BEGIN_OF_SENTENCE = "BOS"
 
 FEATURES = "features"
 
-SEPERATOR = "###"
-
 
 @DefaultV1Recipe.register(
     DefaultV1Recipe.ComponentType.MESSAGE_FEATURIZER, is_trainable=True
@@ -74,7 +72,7 @@ class LexicalSyntacticFeaturizer(SparseFeaturizer, GraphComponent):
       of the token at position `t+1`.
     """
 
-    FILENAME_FEATURE_TO_IDX_DICT = "feature_to_idx_dict.json"
+    FILENAME_FEATURE_TO_IDX_DICT = "feature_to_idx_dict.pkl"
 
     # NOTE: "suffix5" of the token "is" will be "is". Hence, when combining multiple
     # prefixes, short words will be represented/encoded repeatedly.
@@ -490,32 +488,6 @@ 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,
@@ -528,13 +500,10 @@ class LexicalSyntacticFeaturizer(SparseFeaturizer, GraphComponent):
         """Loads trained component (see parent class for full docstring)."""
         try:
             with model_storage.read_from(resource) as model_path:
-                loaded_data = rasa.shared.utils.io.read_json_file(
+                feature_to_idx_dict = rasa.utils.io.json_unpickle(
                     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,
@@ -559,13 +528,9 @@ 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.shared.utils.io.dump_obj_as_json_to_file(
+            rasa.utils.io.json_pickle(
                 model_path / self.FILENAME_FEATURE_TO_IDX_DICT,
-                restructured_feature_dict,
+                self._feature_to_idx_dict,
+                encode_non_string_keys=True,
             )

rasa/nlu/featurizers/sparse_featurizer/regex_featurizer.py

@@ -1,13 +1,11 @@
 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
+
 import rasa.shared.utils.io
 import rasa.utils.io
 import rasa.nlu.utils.pattern_utils as pattern_utils
@@ -242,7 +240,7 @@ class RegexFeaturizer(SparseFeaturizer, GraphComponent):
 
         try:
             with model_storage.read_from(resource) as model_dir:
-                patterns_file_name = model_dir / "patterns.json"
+                patterns_file_name = model_dir / "patterns.pkl"
                 known_patterns = rasa.shared.utils.io.read_json_file(patterns_file_name)
         except (ValueError, FileNotFoundError):
             logger.warning(
@@ -260,7 +258,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.json"
+            regex_file = model_dir / "patterns.pkl"
             rasa.shared.utils.io.dump_obj_as_json_to_file(
                 regex_file, self.known_patterns
             )

rasa/nlu/tokenizers/whitespace_tokenizer.py

@@ -43,6 +43,8 @@ class WhitespaceTokenizer(Tokenizer):
     def __init__(self, config: Dict[Text, Any]) -> None:
         """Initialize the tokenizer."""
         super().__init__(config)
+        self.emoji_pattern = rasa.utils.io.get_emoji_regex()
+
         if "case_sensitive" in self._config:
             rasa.shared.utils.io.raise_warning(
                 "The option 'case_sensitive' was moved from the tokenizers to the "
@@ -62,9 +64,18 @@ class WhitespaceTokenizer(Tokenizer):
         # Path to the dictionaries on the local filesystem.
         return cls(config)
 
+    def remove_emoji(self, text: Text) -> Text:
+        """Remove emoji if the full text, aka token, matches the emoji regex."""
+        match = self.emoji_pattern.fullmatch(text)
+
+        if match is not None:
+            return ""
+
+        return text
+
     def tokenize(self, message: Message, attribute: Text) -> List[Token]:
-        original_text = message.get(attribute)
-        text = rasa.utils.io.remove_emojis(original_text)
+        text = message.get(attribute)
+
         # we need to use regex instead of re, because of
         # https://stackoverflow.com/questions/12746458/python-unicode-regular-expression-matching-failing-with-some-unicode-characters
 
@@ -83,11 +94,11 @@ class WhitespaceTokenizer(Tokenizer):
             text,
         ).split()
 
+        words = [self.remove_emoji(w) for w in words]
         words = [w for w in words if w]
 
         # if we removed everything like smiles `:)`, use the whole text as 1 token
         if not words:
-            text = original_text
             words = [text]
 
         tokens = self._convert_words_to_tokens(words, text)

rasa/server.py

@@ -78,7 +78,6 @@ from rasa.shared.utils.schemas.events import EVENTS_SCHEMA
 from rasa.shared.utils.yaml import validate_training_data
 from rasa.utils.common import TempDirectoryPath, get_temp_dir_name
 from rasa.utils.endpoints import EndpointConfig
-from rasa.utils.sanic_error_handler import register_custom_sanic_error_handler
 
 if TYPE_CHECKING:
     from ssl import SSLContext
@@ -529,7 +528,7 @@ def add_root_route(app: Sanic) -> None:
                 <p>Hello from Rasa: {rasa.__version__}</p>
                 <a href="./webhooks/inspector/inspect.html">Go to the inspector</a>
                 <script>
-                    window.location.replace("./webhooks/socketio/inspect.html");
+                    window.location.replace("./webhooks/inspector/inspect.html");
                 </script>
             </body>
         </html>
@@ -688,7 +687,6 @@ def create_app(
     app = Sanic("rasa_server")
     app.config.RESPONSE_TIMEOUT = response_timeout
     configure_cors(app, cors_origins)
-    register_custom_sanic_error_handler(app)
 
     # Reset Sanic warnings filter that allows the triggering of Sanic warnings
     warnings.filterwarnings("ignore", category=DeprecationWarning, module=r"sanic.*")

rasa/shared/constants.py

@@ -149,10 +149,6 @@ AZURE_AD_TOKEN_ENV_VAR = "AZURE_AD_TOKEN"
 AZURE_API_BASE_ENV_VAR = "AZURE_API_BASE"
 AZURE_API_VERSION_ENV_VAR = "AZURE_API_VERSION"
 AZURE_API_TYPE_ENV_VAR = "AZURE_API_TYPE"
-AZURE_SPEECH_API_KEY_ENV_VAR = "AZURE_SPEECH_API_KEY"
-
-DEEPGRAM_API_KEY_ENV_VAR = "DEEPGRAM_API_KEY"
-CARTESIA_API_KEY_ENV_VAR = "CARTESIA_API_KEY"
 
 OPENAI_API_KEY_ENV_VAR = "OPENAI_API_KEY"
 OPENAI_API_TYPE_ENV_VAR = "OPENAI_API_TYPE"
@@ -163,9 +159,6 @@ OPENAI_API_BASE_CONFIG_KEY = "openai_api_base"
 OPENAI_API_TYPE_CONFIG_KEY = "openai_api_type"
 OPENAI_API_VERSION_CONFIG_KEY = "openai_api_version"
 
-AWS_BEDROCK_PROVIDER = "bedrock"
-AWS_SAGEMAKER_PROVIDER = "sagemaker"
-
 API_BASE_CONFIG_KEY = "api_base"
 API_TYPE_CONFIG_KEY = "api_type"
 API_VERSION_CONFIG_KEY = "api_version"
@@ -190,34 +183,7 @@ STREAM_CONFIG_KEY = "stream"
 N_REPHRASES_CONFIG_KEY = "n"
 USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY = "use_chat_completions_endpoint"
 
-ROUTER_CONFIG_KEY = "router"
-ROUTING_STRATEGY_CONFIG_KEY = "routing_strategy"
-REDIS_HOST_CONFIG_KEY = "redis_host"
-ROUTING_STRATEGIES_REQUIRING_REDIS_CACHE = [
-    "cost-based-routing",
-    "usage-based-routing",
-]
-ROUTING_STRATEGIES_NOT_REQUIRING_CACHE = [
-    "latency-based-routing",
-    "least-busy",
-    "simple-shuffle",
-]
-VALID_ROUTING_STRATEGIES = (
-    ROUTING_STRATEGIES_REQUIRING_REDIS_CACHE + ROUTING_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"
@@ -225,16 +191,6 @@ 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"
-AWS_ACCESS_KEY_ID_CONFIG_KEY = "aws_access_key_id"
-AWS_SECRET_ACCESS_KEY_CONFIG_KEY = "aws_secret_access_key"
-AWS_SESSION_TOKEN_CONFIG_KEY = "aws_session_token"
-
-AWS_ACCESS_KEY_ID_ENV_VAR = "AWS_ACCESS_KEY_ID"
-AWS_SECRET_ACCESS_KEY_ENV_VAR = "AWS_SECRET_ACCESS_KEY"
-AWS_REGION_NAME_ENV_VAR = "AWS_REGION_NAME"
-AWS_SESSION_TOKEN_ENV_VAR = "AWS_SESSION_TOKEN"
-
 HUGGINGFACE_MULTIPROCESS_CONFIG_KEY = "multi_process"
 HUGGINGFACE_CACHE_FOLDER_CONFIG_KEY = "cache_folder"
 HUGGINGFACE_SHOW_PROGRESS_CONFIG_KEY = "show_progress"
@@ -255,16 +211,6 @@ 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"
 
 AZURE_API_TYPE = "azure"
 OPENAI_API_TYPE = "openai"
@@ -295,10 +241,3 @@ RASA_PATTERN_CANNOT_HANDLE_INVALID_INTENT = (
 )
 
 ROUTE_TO_CALM_SLOT = "route_session_to_calm"
-
-SENSITIVE_DATA = [
-    API_KEY,
-    AWS_ACCESS_KEY_ID_CONFIG_KEY,
-    AWS_SECRET_ACCESS_KEY_CONFIG_KEY,
-    AWS_SESSION_TOKEN_CONFIG_KEY,
-]

rasa/shared/core/constants.py

@@ -11,7 +11,6 @@ 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 = [
@@ -20,7 +19,6 @@ 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,
 ]
 
@@ -50,7 +48,6 @@ ACTION_TRIGGER_SEARCH = "action_trigger_search"
 ACTION_TRIGGER_CHITCHAT = "action_trigger_chitchat"
 ACTION_RESET_ROUTING = "action_reset_routing"
 ACTION_HANGUP = "action_hangup"
-ACTION_REPEAT_BOT_MESSAGES = "action_repeat_bot_messages"
 
 
 DEFAULT_ACTION_NAMES = [
@@ -77,7 +74,6 @@ DEFAULT_ACTION_NAMES = [
     ACTION_TRIGGER_CHITCHAT,
     ACTION_RESET_ROUTING,
     ACTION_HANGUP,
-    ACTION_REPEAT_BOT_MESSAGES,
 ]
 
 ACTION_SHOULD_SEND_DOMAIN = "send_domain"
@@ -108,11 +104,6 @@ FLOW_HASHES_SLOT = "flow_hashes"
 
 FLOW_SLOT_NAMES = [FLOW_HASHES_SLOT]
 
-# slots for audio timeout
-SLOT_SILENCE_TIMEOUT = "silence_timeout"
-SLOT_CONSECUTIVE_SILENCE_TIMEOUTS = "consecutive_silence_timeouts"
-SILENCE_TIMEOUT_DEFAULT_VALUE = 6.0
-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

@@ -196,7 +196,6 @@ class Domain:
     """
 
     validate_yaml: ClassVar[bool] = True
-    expand_env_vars: ClassVar[bool] = True
 
     @classmethod
     def empty(cls) -> Domain:
@@ -1956,8 +1955,8 @@ class Domain:
         """Check whether the domain is empty."""
         return self.as_dict() == Domain.empty().as_dict()
 
-    @classmethod
-    def is_domain_file(cls, filename: Union[Text, Path]) -> bool:
+    @staticmethod
+    def is_domain_file(filename: Union[Text, Path]) -> bool:
         """Checks whether the given file path is a Rasa domain file.
 
         Args:
@@ -1976,7 +1975,7 @@ class Domain:
             return False
 
         try:
-            content = read_yaml_file(filename, expand_env_vars=cls.expand_env_vars)
+            content = read_yaml_file(filename)
         except (RasaException, YamlSyntaxException):
             structlogger.warning(
                 "domain.cannot_load_domain_file",
@@ -2105,12 +2104,10 @@ class Domain:
                 "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,
+                raw_yaml_content, DOMAIN_SCHEMA_FILE
             )
 
-        return read_yaml(raw_yaml_content, expand_env_vars=cls.expand_env_vars)
+        return read_yaml(raw_yaml_content)
 
 
 def warn_about_duplicates_found_during_domain_merging(

rasa/shared/core/flows/flow.py

@@ -60,8 +60,6 @@ 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(
@@ -97,7 +95,6 @@ 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:
@@ -170,8 +167,6 @@ 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

@@ -234,16 +234,12 @@ class FlowsList:
             [f for f in self.underlying_flows if not f.is_startable_only_via_link()]
         )
 
-    def available_slot_names(
-        self, ask_before_filling: Optional[bool] = None
-    ) -> Set[str]:
+    def available_slot_names(self) -> Set[str]:
         """Get all slot names collected by flows."""
         return {
             step.collect
             for flow in self.underlying_flows
             for step in flow.get_collect_steps()
-            if ask_before_filling is None
-            or step.ask_before_filling == ask_before_filling
         }
 
     def available_custom_actions(self) -> Set[str]:

rasa/shared/core/flows/flows_yaml_schema.json

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

rasa/shared/core/flows/validation.py

@@ -3,7 +3,6 @@ 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 (
@@ -27,12 +26,6 @@ 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:
@@ -386,42 +379,6 @@ 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.
 
@@ -430,8 +387,6 @@ 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)
@@ -442,12 +397,6 @@ 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."""
@@ -688,48 +637,3 @@ 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/flows/yaml_flows_io.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Any, ClassVar, Dict, List, Optional, Text, Union
+from typing import Any, Dict, List, Optional, Text, Union
 
 import jsonschema
 import ruamel.yaml.nodes as yaml_nodes
@@ -25,8 +25,6 @@ KEY_FLOWS = "flows"
 class YAMLFlowsReader:
     """Class that reads flows information in YAML format."""
 
-    expand_env_vars: ClassVar[bool] = True
-
     @classmethod
     def read_from_file(
         cls, filename: Union[Text, Path], add_line_numbers: bool = True
@@ -219,21 +217,14 @@ class YAMLFlowsReader:
             `Flow`s read from `string`.
         """
         validate_yaml_with_jsonschema(
-            string,
-            FLOWS_SCHEMA_FILE,
-            humanize_error=cls.humanize_flow_error,
-            expand_env_vars=cls.expand_env_vars,
+            string, FLOWS_SCHEMA_FILE, humanize_error=cls.humanize_flow_error
         )
         if add_line_numbers:
-            yaml_content = read_yaml(
-                string,
-                custom_constructor=line_number_constructor,
-                expand_env_vars=cls.expand_env_vars,
-            )
+            yaml_content = read_yaml(string, custom_constructor=line_number_constructor)
             yaml_content = process_yaml_content(yaml_content)
 
         else:
-            yaml_content = read_yaml(string, expand_env_vars=cls.expand_env_vars)
+            yaml_content = read_yaml(string)
 
         return FlowsList.from_json(yaml_content.get(KEY_FLOWS, {}), file_path=file_path)
 

rasa/shared/core/slots.py

@@ -193,11 +193,6 @@ 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."""