rasa-pro 3.10.7.dev4__py3-none-any.whl → 3.10.8__py3-none-any.whl

rasa/shared/constants.py

@@ -183,8 +183,6 @@ STREAM_CONFIG_KEY = "stream"
 N_REPHRASES_CONFIG_KEY = "n"
 USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY = "use_chat_completions_endpoint"
 
-LLM_API_HEALTH_CHECK_ENV_VAR = "LLM_API_HEALTH_CHECK"
-
 AZURE_API_KEY_ENV_VAR = "AZURE_API_KEY"
 AZURE_AD_TOKEN_ENV_VAR = "AZURE_AD_TOKEN"
 AZURE_API_BASE_ENV_VAR = "AZURE_API_BASE"
@@ -212,6 +210,9 @@ AZURE_OPENAI_PROVIDER = "azure"
 SELF_HOSTED_PROVIDER = "self-hosted"
 HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER = "huggingface_local"
 
+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"
 

rasa/shared/core/domain.py

@@ -1,21 +1,16 @@
-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,
@@ -24,6 +19,7 @@ from typing import (
     Tuple,
     Union,
     cast,
+    MutableMapping,
 )
 
 import structlog
@@ -55,11 +51,11 @@ from rasa.shared.core.constants import (
 )
 from rasa.shared.core.events import SlotSet, UserUttered
 from rasa.shared.core.slots import (
-    AnySlot,
-    CategoricalSlot,
-    ListSlot,
     Slot,
+    CategoricalSlot,
     TextSlot,
+    AnySlot,
+    ListSlot,
 )
 from rasa.shared.exceptions import (
     RasaException,
@@ -67,21 +63,21 @@ from rasa.shared.exceptions import (
     YamlSyntaxException,
 )
 from rasa.shared.nlu.constants import (
-    ENTITIES,
-    ENTITY_ATTRIBUTE_GROUP,
-    ENTITY_ATTRIBUTE_ROLE,
     ENTITY_ATTRIBUTE_TYPE,
-    INTENT_NAME_KEY,
+    ENTITY_ATTRIBUTE_ROLE,
+    ENTITY_ATTRIBUTE_GROUP,
     RESPONSE_IDENTIFIER_DELIMITER,
+    INTENT_NAME_KEY,
+    ENTITIES,
 )
 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:
@@ -159,7 +155,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,
@@ -195,15 +191,13 @@ 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(
@@ -221,15 +215,8 @@ class Domain:
         return domain
 
     @classmethod
-    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.
-        """
+    def from_path(cls, path: Union[Text, Path]) -> "Domain":
+        """Loads the `Domain` from a path."""
         path = os.path.abspath(path)
 
         if os.path.isfile(path):
@@ -245,30 +232,17 @@ class Domain:
         return domain
 
     @classmethod
-    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.
-        """
+    def from_file(cls, path: Text) -> "Domain":
+        """Loads the `Domain` from a YAML file."""
         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.
-
-        Args:
-            yaml: The YAML string to load the domain from.
-            original_filename: The filename of the original YAML file.
-
-        Returns:
-            The instantiated `Domain` object.
-        """
+    def from_yaml(cls, yaml: Text, original_filename: Text = "") -> "Domain":
+        """Loads the `Domain` from YAML text after validating it."""
         try:
-            data = cls._dict_from_raw_yaml_content(yaml)
+            validate_raw_yaml_using_schema_file_with_responses(yaml, DOMAIN_SCHEMA_FILE)
+
+            data = read_yaml(yaml)
             if not validate_training_data_format_version(data, original_filename):
                 return Domain.empty()
             return cls.from_dict(data)
@@ -277,7 +251,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:
@@ -308,8 +282,8 @@ class Domain:
         _validate_forms(forms)
 
         return cls(
-            intents=intents or [],
-            entities=data.get(KEY_ENTITIES, []),
+            intents=intents,
+            entities=data.get(KEY_ENTITIES, {}),
             slots=slots,
             responses=responses,
             action_names=actions,
@@ -334,15 +308,8 @@ 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.
-
-        Args:
-            path: Path to the root directory.
-
-        Returns:
-            The instantiated `Domain` object.
-        """
+    def from_directory(cls, path: Text) -> "Domain":
+        """Loads and merges multiple domain files recursively from a directory tree."""
         combined: Dict[Text, Any] = {}
         duplicates: List[Dict[Text, List[Text]]] = []
 
@@ -352,10 +319,10 @@ class Domain:
                 if not Domain.is_domain_file(full_path):
                     continue
 
-                other_dict = cls._dict_from_raw_yaml_content(
-                    rasa.shared.utils.io.read_file(full_path)
-                )
+                # does the validation here only
+                _ = Domain.from_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", {}))
 
@@ -401,10 +368,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``,
@@ -707,7 +674,7 @@ class Domain:
 
         return intent
 
-    @cached_property
+    @rasa.shared.utils.common.lazy_property
     def retrieval_intents(self) -> List[Text]:
         """List retrieval intents present in the domain."""
         return [
@@ -932,7 +899,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
@@ -1036,23 +1003,23 @@ class Domain:
         sorted_intents = sorted(intents, key=sort)
         return sorted_intents
 
-    @cached_property
+    @rasa.shared.utils.common.lazy_property
     def user_actions_and_forms(self) -> List[Text]:
         """Returns combination of user actions and forms."""
         return self.user_actions + self.form_names
 
-    @cached_property
+    @rasa.shared.utils.common.lazy_property
     def num_actions(self) -> int:
         """Returns the number of available actions."""
         # noinspection PyTypeChecker
         return len(self.action_names_or_texts)
 
-    @cached_property
+    @rasa.shared.utils.common.lazy_property
     def num_states(self) -> int:
         """Number of used input states for the action prediction."""
         return len(self.input_states)
 
-    @cached_property
+    @rasa.shared.utils.common.lazy_property
     def retrieval_intent_responses(self) -> Dict[Text, List[Dict[Text, Any]]]:
         """Return only the responses which are defined for retrieval intents."""
         return dict(
@@ -1204,7 +1171,8 @@ class Domain:
             f"Available actions are: \n{action_names}"
         )
 
-    @cached_property
+    # noinspection PyTypeChecker
+    @rasa.shared.utils.common.lazy_property
     def slot_states(self) -> List[Text]:
         """Returns all available slot state strings."""
         return [
@@ -1213,7 +1181,8 @@ class Domain:
             for feature_index in range(0, slot.feature_dimensionality())
         ]
 
-    @cached_property
+    # noinspection PyTypeChecker
+    @rasa.shared.utils.common.lazy_property
     def entity_states(self) -> List[Text]:
         """Returns all available entity state strings."""
         entity_states = copy.deepcopy(self.entities)
@@ -1261,12 +1230,12 @@ class Domain:
             for entity_sub_label in entity_sub_labels
         ]
 
-    @cached_property
+    @rasa.shared.utils.common.lazy_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)}
 
-    @cached_property
+    @rasa.shared.utils.common.lazy_property
     def input_states(self) -> List[Text]:
         """Returns all available states."""
         return (
@@ -1496,7 +1465,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 tracker's history.
+        """List of states for each state of the trackers history.
 
         Args:
             tracker: Dialogue state tracker containing the dialogue so far.
@@ -1713,12 +1682,12 @@ class Domain:
         """Return the configuration for an intent."""
         return self.intent_properties.get(intent_name, {})
 
-    @cached_property
+    @rasa.shared.utils.common.lazy_property
     def intents(self) -> List[Text]:
         """Returns sorted list of intents."""
         return sorted(self.intent_properties.keys())
 
-    @cached_property
+    @rasa.shared.utils.common.lazy_property
     def entities(self) -> List[Text]:
         """Returns sorted list of entities."""
         return sorted(self.entity_properties.entities)
@@ -2086,29 +2055,6 @@ 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/flows/flows_list.py

@@ -16,7 +16,6 @@ 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
 
@@ -50,31 +49,21 @@ class FlowsList:
         return len(self.underlying_flows) == 0
 
     @classmethod
-    def from_multiple_flows_lists(
-        cls, *other: FlowsList, ignore_duplicates: bool = True
-    ) -> FlowsList:
+    def from_multiple_flows_lists(cls, *other: FlowsList) -> 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[Text, Flow] = dict()
+        merged_flows = dict()
         for flow_list in other:
             for flow in flow_list:
-                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
+                if flow.id not in merged_flows:
+                    merged_flows[flow.id] = flow
         return FlowsList(list(merged_flows.values()))
 
     @classmethod
@@ -129,11 +118,9 @@ 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, ignore_duplicates: bool = True) -> FlowsList:
+    def merge(self, other: FlowsList) -> FlowsList:
         """Merges two lists of flows together."""
-        return FlowsList.from_multiple_flows_lists(
-            self, other, ignore_duplicates=ignore_duplicates
-        )
+        return FlowsList.from_multiple_flows_lists(self, other)
 
     def flow_by_id(self, flow_id: Text) -> Optional[Flow]:
         """Return the flow with the given id."""

rasa/shared/core/flows/validation.py

@@ -101,31 +101,6 @@ 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,5 +1,6 @@
+import textwrap
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Text, Union
+from typing import Any, Dict, List, Text, Union, Optional
 
 import jsonschema
 import ruamel.yaml.nodes as yaml_nodes
@@ -11,11 +12,12 @@ 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"
@@ -260,6 +262,25 @@ 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.