rasa-pro 3.10.16__py3-none-any.whl → 3.11.0a1__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,15 @@ class Domain:
     and entities it can recognise.
     """
 
+    validate_yaml: 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 +221,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 +245,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.
+
+        Args:
+            yaml: The YAML string to load the domain from.
+            original_filename: The filename of the original YAML file.
 
-            data = read_yaml(yaml)
+        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 +277,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 +308,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 +334,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 +352,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 +401,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 +707,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 +932,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 +1036,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 +1204,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 +1213,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 +1261,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 +1496,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 +1713,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)
@@ -2055,6 +2086,29 @@ 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
+            )
+
+        return read_yaml(raw_yaml_content)
+
 
 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/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."""
@@ -221,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/validation.py

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

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, 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"
@@ -262,25 +260,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.