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

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:
@@ -101,6 +108,31 @@ class DuplicatedStepIdException(RasaException):
         )
 
 
+class DuplicatedFlowIdException(RasaException):
+    """Raised when a flow is using the same id as another flow."""
+
+    def __init__(
+        self, flow_id: str, first_file_path: str, second_file_path: str
+    ) -> None:
+        """Initializes the exception."""
+        self.flow_id = flow_id
+        self.first_file_path = first_file_path
+        self.second_file_path = second_file_path
+
+    def __str__(self) -> str:
+        """Return a string representation of the exception."""
+        if self.first_file_path == self.second_file_path:
+            return (
+                f"Flow '{self.flow_id}' is used twice in `{self.first_file_path}`. "
+                f"Please make sure flow IDs are unique across all files."
+            )
+        return (
+            f"Flow '{self.flow_id}' is used in both "
+            f"`{self.first_file_path}` and `{self.second_file_path}`. "
+            f"Please make sure flow IDs are unique across all files."
+        )
+
+
 class MissingElseBranchException(RasaException):
     """Raised when a flow step is missing an else branch."""
 
@@ -354,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.
 
@@ -362,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)
@@ -372,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."""
@@ -612,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/flows/yaml_flows_io.py

@@ -1,6 +1,5 @@
-import textwrap
 from pathlib import Path
-from typing import Any, Dict, List, Text, Union, Optional
+from typing import Any, ClassVar, Dict, List, Optional, Text, Union
 
 import jsonschema
 import ruamel.yaml.nodes as yaml_nodes
@@ -12,12 +11,11 @@ import rasa.shared.utils.io
 from rasa.shared.core.flows.flow import Flow
 from rasa.shared.core.flows.flows_list import FlowsList
 from rasa.shared.exceptions import RasaException, YamlException
-from rasa.shared.importers.importer import FlowSyncImporter
 from rasa.shared.utils.yaml import (
-    validate_yaml_with_jsonschema,
-    read_yaml,
     dump_obj_as_yaml_to_string,
     is_key_in_yaml,
+    read_yaml,
+    validate_yaml_with_jsonschema,
 )
 
 FLOWS_SCHEMA_FILE = "shared/core/flows/flows_yaml_schema.json"
@@ -27,6 +25,8 @@ 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,14 +219,21 @@ class YAMLFlowsReader:
             `Flow`s read from `string`.
         """
         validate_yaml_with_jsonschema(
-            string, FLOWS_SCHEMA_FILE, humanize_error=cls.humanize_flow_error
+            string,
+            FLOWS_SCHEMA_FILE,
+            humanize_error=cls.humanize_flow_error,
+            expand_env_vars=cls.expand_env_vars,
         )
         if add_line_numbers:
-            yaml_content = read_yaml(string, custom_constructor=line_number_constructor)
+            yaml_content = read_yaml(
+                string,
+                custom_constructor=line_number_constructor,
+                expand_env_vars=cls.expand_env_vars,
+            )
             yaml_content = process_yaml_content(yaml_content)
 
         else:
-            yaml_content = read_yaml(string)
+            yaml_content = read_yaml(string, expand_env_vars=cls.expand_env_vars)
 
         return FlowsList.from_json(yaml_content.get(KEY_FLOWS, {}), file_path=file_path)
 
@@ -262,25 +269,6 @@ class YamlFlowsWriter:
         rasa.shared.utils.io.write_text_file(YamlFlowsWriter.dumps(flows), filename)
 
 
-def flows_from_str(yaml_str: str) -> FlowsList:
-    """Reads flows from a YAML string."""
-    flows = YAMLFlowsReader.read_from_string(
-        textwrap.dedent(yaml_str), add_line_numbers=False
-    )
-    flows.validate()
-    return flows
-
-
-def flows_from_str_including_defaults(yaml_str: str) -> FlowsList:
-    """Reads flows from a YAML string and combine them with default flows."""
-    flows = YAMLFlowsReader.read_from_string(
-        textwrap.dedent(yaml_str), add_line_numbers=False
-    )
-    all_flows = FlowSyncImporter.merge_with_default_flows(flows)
-    all_flows.validate()
-    return all_flows
-
-
 def is_flows_file(file_path: Union[Text, Path]) -> bool:
     """Check if file contains Flow training data.
 

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."""

rasa/shared/importers/importer.py

@@ -1,9 +1,18 @@
-from __future__ import annotations
-
 import logging
 from abc import ABC, abstractmethod
 from functools import reduce
-from typing import Any, Dict, List, Optional, Set, Text, Tuple, Type, Union, cast
+from typing import (
+    Any,
+    Dict,
+    List,
+    Optional,
+    Set,
+    Text,
+    Tuple,
+    Type,
+    Union,
+    cast,
+)
 
 import importlib_resources
 
@@ -25,6 +34,7 @@ from rasa.shared.core.training_data.structures import StoryGraph
 from rasa.shared.nlu.constants import ACTION_NAME, ENTITIES
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.nlu.training_data.training_data import TrainingData
+from rasa.shared.utils.common import cached_method
 from rasa.shared.utils.yaml import read_config_file
 
 logger = logging.getLogger(__name__)
@@ -115,8 +125,8 @@ class TrainingDataImporter(ABC):
         config_path: Text,
         domain_path: Optional[Text] = None,
         training_data_paths: Optional[List[Text]] = None,
-        args: Optional[Dict[Text, Any]] = {},
-    ) -> TrainingDataImporter:
+        args: Optional[Dict[Text, Any]] = None,
+    ) -> "TrainingDataImporter":
         """Loads a `TrainingDataImporter` instance from a configuration file."""
         config = read_config_file(config_path)
         return TrainingDataImporter.load_from_dict(
@@ -128,8 +138,8 @@ class TrainingDataImporter(ABC):
         config_path: Text,
         domain_path: Optional[Text] = None,
         training_data_paths: Optional[List[Text]] = None,
-        args: Optional[Dict[Text, Any]] = {},
-    ) -> TrainingDataImporter:
+        args: Optional[Dict[Text, Any]] = None,
+    ) -> "TrainingDataImporter":
         """Loads core `TrainingDataImporter` instance.
 
         Instance loaded from configuration file will only read Core training data.
@@ -144,8 +154,8 @@ class TrainingDataImporter(ABC):
         config_path: Text,
         domain_path: Optional[Text] = None,
         training_data_paths: Optional[List[Text]] = None,
-        args: Optional[Dict[Text, Any]] = {},
-    ) -> TrainingDataImporter:
+        args: Optional[Dict[Text, Any]] = None,
+    ) -> "TrainingDataImporter":
         """Loads nlu `TrainingDataImporter` instance.
 
         Instance loaded from configuration file will only read NLU training data.
@@ -168,7 +178,8 @@ class TrainingDataImporter(ABC):
         domain_path: Optional[Text] = None,
         training_data_paths: Optional[List[Text]] = None,
         args: Optional[Dict[Text, Any]] = None,
-    ) -> TrainingDataImporter:
+        expand_env_vars: bool = True,
+    ) -> "TrainingDataImporter":
         """Loads a `TrainingDataImporter` instance from a dictionary."""
         from rasa.shared.importers.rasa import RasaFileImporter
 
@@ -183,7 +194,12 @@ class TrainingDataImporter(ABC):
         importers = [importer for importer in importers if importer]
         if not importers:
             importers = [
-                RasaFileImporter(config_path, domain_path, training_data_paths)
+                RasaFileImporter(
+                    config_path,
+                    domain_path,
+                    training_data_paths,
+                    expand_env_vars=expand_env_vars,
+                )
             ]
 
         return E2EImporter(
@@ -197,15 +213,18 @@ class TrainingDataImporter(ABC):
         domain_path: Optional[Text] = None,
         training_data_paths: Optional[List[Text]] = None,
         args: Optional[Dict[Text, Any]] = None,
-    ) -> Optional[TrainingDataImporter]:
+    ) -> Optional["TrainingDataImporter"]:
         from rasa.shared.importers.multi_project import MultiProjectImporter
         from rasa.shared.importers.rasa import RasaFileImporter
+        from rasa.shared.importers.remote_importer import RemoteTrainingDataImporter
 
         module_path = importer_config.pop("name", None)
         if module_path == RasaFileImporter.__name__:
             importer_class: Type[TrainingDataImporter] = RasaFileImporter
         elif module_path == MultiProjectImporter.__name__:
             importer_class = MultiProjectImporter
+        elif module_path == RemoteTrainingDataImporter.__name__:
+            importer_class = RemoteTrainingDataImporter
         else:
             try:
                 importer_class = rasa.shared.utils.common.class_from_module_path(
@@ -225,7 +244,8 @@ class TrainingDataImporter(ABC):
             **constructor_arguments,
         )
 
-    def fingerprint(self) -> Text:
+    @staticmethod
+    def fingerprint() -> Text:
         """Returns a random fingerprint as data shouldn't be cached."""
         return rasa.shared.utils.io.random_string(25)
 
@@ -281,7 +301,6 @@ class NluDataImporter(TrainingDataImporter):
         """Retrieves NLU training data (see parent class for full docstring)."""
         return self._importer.get_nlu_data(language)
 
-    @rasa.shared.utils.common.cached_method
     def get_config_file_for_auto_config(self) -> Optional[Text]:
         """Returns config file path for auto-config only if there is a single one."""
         return self._importer.get_config_file_for_auto_config()
@@ -297,14 +316,14 @@ class CombinedDataImporter(TrainingDataImporter):
     def __init__(self, importers: List[TrainingDataImporter]):
         self._importers = importers
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_config(self) -> Dict:
         """Retrieves model config (see parent class for full docstring)."""
         configs = [importer.get_config() for importer in self._importers]
 
         return reduce(lambda merged, other: {**merged, **(other or {})}, configs, {})
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_domain(self) -> Domain:
         """Retrieves model domain (see parent class for full docstring)."""
         domains = [importer.get_domain() for importer in self._importers]
@@ -315,7 +334,7 @@ class CombinedDataImporter(TrainingDataImporter):
             Domain.empty(),
         )
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_stories(self, exclusion_percentage: Optional[int] = None) -> StoryGraph:
         """Retrieves training stories / rules (see parent class for full docstring)."""
         stories = [
@@ -326,7 +345,7 @@ class CombinedDataImporter(TrainingDataImporter):
             lambda merged, other: merged.merge(other), stories, StoryGraph([])
         )
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_flows(self) -> FlowsList:
         """Retrieves training stories / rules (see parent class for full docstring)."""
         flow_lists = [importer.get_flows() for importer in self._importers]
@@ -337,7 +356,7 @@ class CombinedDataImporter(TrainingDataImporter):
             FlowsList(underlying_flows=[]),
         )
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_conversation_tests(self) -> StoryGraph:
         """Retrieves conversation test stories (see parent class for full docstring)."""
         stories = [importer.get_conversation_tests() for importer in self._importers]
@@ -346,7 +365,7 @@ class CombinedDataImporter(TrainingDataImporter):
             lambda merged, other: merged.merge(other), stories, StoryGraph([])
         )
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
         """Retrieves NLU training data (see parent class for full docstring)."""
         nlu_data = [importer.get_nlu_data(language) for importer in self._importers]
@@ -355,7 +374,7 @@ class CombinedDataImporter(TrainingDataImporter):
             lambda merged, other: merged.merge(other), nlu_data, TrainingData()
         )
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_config_file_for_auto_config(self) -> Optional[Text]:
         """Returns config file path for auto-config only if there is a single one."""
         if len(self._importers) != 1:
@@ -414,26 +433,22 @@ class FlowSyncImporter(PassThroughImporter):
         """Loads the default flows from the file system."""
         from rasa.shared.core.flows.yaml_flows_io import YAMLFlowsReader
 
-        default_flows_file = str(
-            importlib_resources.files("rasa.dialogue_understanding.patterns").joinpath(
-                DEFAULT_PATTERN_FLOWS_FILE_NAME
-            )
-        )
-
-        flows = YAMLFlowsReader.read_from_file(default_flows_file)
+        flows = YAMLFlowsReader.read_from_file(FlowSyncImporter.default_pattern_path())
         flows.validate()
         return flows
 
     @staticmethod
-    def load_default_pattern_flows_domain() -> Domain:
-        """Loads the default flows from the file system."""
-        default_flows_file = str(
+    def default_pattern_path() -> str:
+        return str(
             importlib_resources.files("rasa.dialogue_understanding.patterns").joinpath(
                 DEFAULT_PATTERN_FLOWS_FILE_NAME
             )
         )
 
-        return Domain.from_path(default_flows_file)
+    @staticmethod
+    def load_default_pattern_flows_domain() -> Domain:
+        """Loads the default flows from the file system."""
+        return Domain.from_path(FlowSyncImporter.default_pattern_path())
 
     @classmethod
     def merge_with_default_flows(cls, flows: FlowsList) -> FlowsList:
@@ -459,7 +474,7 @@ class FlowSyncImporter(PassThroughImporter):
 
         return flows.merge(FlowsList(missing_default_flows))
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_flows(self) -> FlowsList:
         flows = self._importer.get_flows()
 
@@ -469,11 +484,11 @@ class FlowSyncImporter(PassThroughImporter):
 
         return self.merge_with_default_flows(flows)
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_user_flows(self) -> FlowsList:
         return self._importer.get_flows()
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_domain(self) -> Domain:
         """Merge existing domain with properties of flows."""
         # load domain data from user defined domain files
@@ -515,7 +530,7 @@ class ResponsesSyncImporter(PassThroughImporter):
     back to the Domain.
     """
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_domain(self) -> Domain:
         """Merge existing domain with properties of retrieval intents in NLU data."""
         existing_domain = self._importer.get_domain()
@@ -597,7 +612,7 @@ class ResponsesSyncImporter(PassThroughImporter):
             }
         )
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
         """Updates NLU data with responses for retrieval intents from domain."""
         existing_nlu_data = self._importer.get_nlu_data(language)
@@ -632,7 +647,7 @@ class E2EImporter(PassThroughImporter):
     - adds potential end-to-end bot messages from stories as actions to the domain
     """
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_user_flows(self) -> FlowsList:
         if not isinstance(self._importer, FlowSyncImporter):
             raise NotImplementedError(
@@ -641,9 +656,12 @@ class E2EImporter(PassThroughImporter):
 
         return self._importer.get_user_flows()
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_domain(self) -> Domain:
-        """Retrieves model domain (see parent class for full docstring)."""
+        """Merge existing domain with properties of end-to-end actions in stories.
+
+        Returns: Domain with end-to-end actions added to action names.
+        """
         original = self._importer.get_domain()
         e2e_domain = self._get_domain_with_e2e_actions()
 
@@ -673,7 +691,7 @@ class E2EImporter(PassThroughImporter):
 
         return Domain.from_dict({KEY_E2E_ACTIONS: list(additional_e2e_action_names)})
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
         """Retrieves NLU training data (see parent class for full docstring)."""
         training_datasets = [

rasa/shared/importers/multi_project.py

@@ -1,22 +1,23 @@
-import logging
-from functools import reduce
-from typing import Text, Set, Dict, Optional, List, Union, Any
 import os
+from functools import reduce
+from typing import Any, Dict, List, Optional, Set, Text, Union
+
+import structlog
 
 import rasa.shared.data
 import rasa.shared.utils.io
 from rasa.shared.core.domain import Domain
-from rasa.shared.importers.importer import TrainingDataImporter
-from rasa.shared.importers import utils
-from rasa.shared.nlu.training_data.training_data import TrainingData
-from rasa.shared.core.training_data.structures import StoryGraph
-from rasa.shared.utils.common import mark_as_experimental_feature
 from rasa.shared.core.training_data.story_reader.yaml_story_reader import (
     YAMLStoryReader,
 )
+from rasa.shared.core.training_data.structures import StoryGraph
+from rasa.shared.importers import utils
+from rasa.shared.importers.importer import TrainingDataImporter
+from rasa.shared.nlu.training_data.training_data import TrainingData
+from rasa.shared.utils.common import cached_method, mark_as_experimental_feature
 from rasa.shared.utils.yaml import read_config_file, read_model_configuration
 
-logger = logging.getLogger(__name__)
+structlogger = structlog.get_logger()
 
 
 class MultiProjectImporter(TrainingDataImporter):
@@ -50,8 +51,13 @@ class MultiProjectImporter(TrainingDataImporter):
         self._story_paths += extra_story_files
         self._nlu_paths += extra_nlu_files
 
-        logger.debug(
-            "Selected projects: {}".format("".join([f"\n-{i}" for i in self._imports]))
+        structlogger.debug(
+            "multi_project_importer.initialisation",
+            event_info=(
+                "Selected projects: {}".format(
+                    "".join([f"\n-{i}" for i in self._imports])
+                )
+            ),
         )
 
         mark_as_experimental_feature(feature_name="MultiProjectImporter")
@@ -135,6 +141,7 @@ class MultiProjectImporter(TrainingDataImporter):
 
         return training_paths
 
+    @cached_method
     def is_imported(self, path: Text) -> bool:
         """Checks whether a path is imported by a skill.
 
@@ -175,6 +182,7 @@ class MultiProjectImporter(TrainingDataImporter):
             [rasa.shared.utils.io.is_subdirectory(path, i) for i in self._imports]
         )
 
+    @cached_method
     def get_domain(self) -> Domain:
         """Retrieves model domain (see parent class for full docstring)."""
         domains = [Domain.load(path) for path in self._domain_paths]
@@ -184,20 +192,24 @@ class MultiProjectImporter(TrainingDataImporter):
             Domain.empty(),
         )
 
+    @cached_method
     def get_stories(self, exclusion_percentage: Optional[int] = None) -> StoryGraph:
         """Retrieves training stories / rules (see parent class for full docstring)."""
         return utils.story_graph_from_paths(
             self._story_paths, self.get_domain(), exclusion_percentage
         )
 
+    @cached_method
     def get_conversation_tests(self) -> StoryGraph:
         """Retrieves conversation test stories (see parent class for full docstring)."""
         return utils.story_graph_from_paths(self._e2e_story_paths, self.get_domain())
 
+    @cached_method
     def get_config(self) -> Dict:
         """Retrieves model config (see parent class for full docstring)."""
         return self.config
 
+    @cached_method
     def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
         """Retrieves NLU training data (see parent class for full docstring)."""
         return utils.training_data_from_paths(self._nlu_paths, language)