rasa-pro 3.8.18__py3-none-any.whl → 3.9.14__py3-none-any.whl

rasa/shared/data.py

@@ -4,12 +4,33 @@ import tempfile
 import uuid
 from enum import Enum
 from pathlib import Path
-from typing import Text, Optional, Union, List, Callable, Set, Iterable
+from typing import (
+    Any,
+    Protocol,
+    TYPE_CHECKING,
+    Text,
+    Optional,
+    Union,
+    List,
+    Callable,
+    Set,
+    Iterable,
+    runtime_checkable,
+)
+
+import structlog
+
+if TYPE_CHECKING:
+    from rasa.core.channels import UserMessage
+    from rasa.shared.core.domain import Domain
+    from rasa.shared.nlu.training_data.message import Message
 
 YAML_FILE_EXTENSIONS = [".yml", ".yaml"]
 JSON_FILE_EXTENSIONS = [".json"]
 TRAINING_DATA_EXTENSIONS = set(JSON_FILE_EXTENSIONS + YAML_FILE_EXTENSIONS)
 
+structlogger = structlog.get_logger()
+
 
 def yaml_file_extension() -> Text:
     """Return YAML file extension."""
@@ -190,3 +211,39 @@ class TrainingType(Enum):
         if self == TrainingType.CORE:
             return "core"
         return "rasa"
+
+
+@runtime_checkable
+class RegexReader(Protocol):
+    def unpack_regex_message(self, message: "Message", **kwargs: Any) -> "Message": ...
+
+
+def create_regex_pattern_reader(
+    message: "UserMessage", domain: "Domain"
+) -> Optional[RegexReader]:
+    """Create a new instance of a class to unpack regex patterns.
+
+    Args:
+        message: The user message to unpack.
+        domain: The domain of the assistant.
+    """
+    from rasa.shared.core.command_payload_reader import CommandPayloadReader
+    from rasa.shared.core.training_data.story_reader.yaml_story_reader import (
+        YAMLStoryReader,
+    )
+
+    if message.text is None:
+        structlogger.warning(
+            "empty.user.message",
+            user_text="None",
+        )
+        return None
+
+    reader: Union[CommandPayloadReader, YAMLStoryReader, None] = None
+
+    if message.text.startswith("/SetSlots"):
+        reader = CommandPayloadReader()
+    elif message.text.startswith("/"):
+        reader = YAMLStoryReader(domain)
+
+    return reader if isinstance(reader, RegexReader) else None

rasa/shared/exceptions.py

@@ -1,5 +1,5 @@
 import json
-from typing import Optional, Text
+from typing import Optional, Text, Dict, Any
 
 import jsonschema
 from ruamel.yaml.error import (
@@ -10,7 +10,7 @@ from ruamel.yaml.error import (
 
 
 class RasaException(Exception):
-    """Base exception class for all errors raised by Rasa Open Source.
+    """Base exception class for all errors raised by Rasa Pro.
 
     These exceptions result from invalid use cases and will be reported
     to the users, but will be ignored in telemetry.
@@ -127,3 +127,37 @@ class ConnectionException(RasaException):
     It's used by our broker and tracker store classes, when
     they can't connect to services like postgres, dynamoDB, mongo.
     """
+
+
+class ProviderClientAPIException(RasaException):
+    """Raised for errors that occur during API interactions
+    with LLM / embedding providers.
+
+    Attributes:
+        original_exception (Exception): The original exception that was
+            caught and led to this custom exception.
+        message: (Optional[str]): Optional explanation of the error.
+    """
+
+    def __init__(
+        self,
+        original_exception: Exception,
+        message: Optional[str] = None,
+        info: Optional[Dict[Text, Any]] = None,
+    ):
+        super().__init__(
+            f"{message if message is not None else ''}"
+            f"\nOriginal error: {original_exception})"
+        )
+        self.message = message
+        self.original_exception = original_exception
+        self.info = info
+
+    def __str__(self) -> Text:
+        s = f"{self.__class__.__name__}:"
+        if self.message is not None:
+            s += f"\n{self.message}"
+        s += f"\nOriginal error: {self.original_exception}\n"
+        if self.info:
+            s += f"\nInfo: \n{self.info}\n"
+        return s

rasa/shared/importers/importer.py

@@ -581,7 +581,7 @@ class ResponsesSyncImporter(PassThroughImporter):
 
     @staticmethod
     def _get_nlu_data_with_responses(
-        responses: Dict[Text, List[Dict[Text, Any]]]
+        responses: Dict[Text, List[Dict[Text, Any]]],
     ) -> TrainingData:
         """Construct training data object with only the responses supplied.
 
@@ -611,7 +611,6 @@ class E2EImporter(PassThroughImporter):
         return original.merge(e2e_domain)
 
     def _get_domain_with_e2e_actions(self) -> Domain:
-
         stories = self.get_stories()
 
         additional_e2e_action_names = set()

rasa/shared/importers/rasa.py

@@ -30,7 +30,6 @@ class RasaFileImporter(TrainingDataImporter):
         domain_path: Optional[Text] = None,
         training_data_paths: Optional[Union[List[Text], Text]] = None,
     ):
-
         self._domain_path = domain_path
 
         self._nlu_files = rasa.shared.data.get_data_files(

rasa/shared/nlu/constants.py

@@ -43,3 +43,5 @@ NO_ENTITY_TAG = "O"
 SPLIT_ENTITIES_BY_COMMA = "split_entities_by_comma"
 SPLIT_ENTITIES_BY_COMMA_DEFAULT_VALUE = True
 SINGLE_ENTITY_ALLOWED_INTERLEAVING_CHARSET = {".", ",", " ", ";"}
+
+SET_SLOT_COMMAND = "set slot"

rasa/shared/nlu/training_data/entities_parser.py

@@ -24,7 +24,7 @@ GROUP_COMPLETE_MATCH = 0
 
 # regex for: `[entity_text]((entity_type(:entity_synonym)?)|{entity_dict}|[list_entity_dicts])` # noqa: E501
 ENTITY_REGEX = re.compile(
-    r"\[(?P<entity_text>[^\]]+?)\](\((?P<entity>[^:)]+?)(?:\:(?P<value>[^)]+))?\)|\{(?P<entity_dict>[^}]+?)\}|\[(?P<list_entity_dicts>.*?)\])"  # noqa: E501
+    r"\[(?P<entity_text>[^\]]+?)\](\((?P<entity>[^:)]+?)(?:\:(?P<value>[^)]+))?\)|\{(?P<entity_dict>[^}]+?)\}|\[(?P<list_entity_dicts>.*?)\])"
 )
 
 SINGLE_ENTITY_DICT = re.compile(r"{(?P<entity_dict>[^}]+?)\}")
@@ -84,7 +84,6 @@ def find_entities_in_training_example(example: Text) -> List[Dict[Text, Any]]:
             for match_inner in re.finditer(
                 SINGLE_ENTITY_DICT, match.groupdict()[GROUP_ENTITY_DICT_LIST]
             ):
-
                 entity_attributes = extract_entity_attributes_from_dict(
                     entity_text=entity_text, match=match_inner
                 )

rasa/shared/nlu/training_data/features.py

@@ -1,133 +1,15 @@
 from __future__ import annotations
-
-import itertools
-from dataclasses import dataclass
 from typing import Iterable, Union, Text, Optional, List, Any, Tuple, Dict, Set
+import itertools
 
 import numpy as np
 import scipy.sparse
-from safetensors.numpy import save_file, load_file
 
-import rasa.shared.nlu.training_data.util
 import rasa.shared.utils.io
+import rasa.shared.nlu.training_data.util
 from rasa.shared.nlu.constants import FEATURE_TYPE_SEQUENCE, FEATURE_TYPE_SENTENCE
 
 
-@dataclass
-class FeatureMetadata:
-    data_type: str
-    attribute: str
-    origin: Union[str, List[str]]
-    is_sparse: bool
-    shape: tuple
-    safetensors_key: str
-
-
-def save_features(
-    features_dict: Dict[Text, List[Features]], file_name: str
-) -> Dict[str, Any]:
-    """Save a dictionary of Features lists to disk using safetensors.
-
-    Args:
-        features_dict: Dictionary mapping strings to lists of Features objects
-        file_name: File to save the features to
-
-    Returns:
-        The metadata to reconstruct the features.
-    """
-    # All tensors are stored in a single safetensors file
-    tensors_to_save = {}
-    # Metadata will be stored separately
-    metadata = {}
-
-    for key, features_list in features_dict.items():
-        feature_metadata_list = []
-
-        for idx, feature in enumerate(features_list):
-            # Create a unique key for this tensor in the safetensors file
-            safetensors_key = f"{key}_{idx}"
-
-            # Convert sparse matrices to dense if needed
-            if feature.is_sparse():
-                # For sparse matrices, use the COO format
-                coo = feature.features.tocoo()  # type:ignore[union-attr]
-                # Save data, row indices and col indices separately
-                tensors_to_save[f"{safetensors_key}_data"] = coo.data
-                tensors_to_save[f"{safetensors_key}_row"] = coo.row
-                tensors_to_save[f"{safetensors_key}_col"] = coo.col
-            else:
-                tensors_to_save[safetensors_key] = feature.features
-
-            # Store metadata
-            metadata_item = FeatureMetadata(
-                data_type=feature.type,
-                attribute=feature.attribute,
-                origin=feature.origin,
-                is_sparse=feature.is_sparse(),
-                shape=feature.features.shape,
-                safetensors_key=safetensors_key,
-            )
-            feature_metadata_list.append(vars(metadata_item))
-
-        metadata[key] = feature_metadata_list
-
-    # Save tensors
-    save_file(tensors_to_save, file_name)
-
-    return metadata
-
-
-def load_features(
-    filename: str, metadata: Dict[str, Any]
-) -> Dict[Text, List[Features]]:
-    """Load Features dictionary from disk.
-
-    Args:
-        filename: File name of the safetensors file.
-        metadata: Metadata to reconstruct the features.
-
-    Returns:
-        Dictionary mapping strings to lists of Features objects
-    """
-    # Load tensors
-    tensors = load_file(filename)
-
-    # Reconstruct the features dictionary
-    features_dict: Dict[Text, List[Features]] = {}
-
-    for key, feature_metadata_list in metadata.items():
-        features_list = []
-
-        for meta in feature_metadata_list:
-            safetensors_key = meta["safetensors_key"]
-
-            if meta["is_sparse"]:
-                # Reconstruct sparse matrix from COO format
-                data = tensors[f"{safetensors_key}_data"]
-                row = tensors[f"{safetensors_key}_row"]
-                col = tensors[f"{safetensors_key}_col"]
-
-                features_matrix = scipy.sparse.coo_matrix(
-                    (data, (row, col)), shape=tuple(meta["shape"])
-                ).tocsr()  # Convert back to CSR format
-            else:
-                features_matrix = tensors[safetensors_key]
-
-            # Reconstruct Features object
-            features = Features(
-                features=features_matrix,
-                feature_type=meta["data_type"],
-                attribute=meta["attribute"],
-                origin=meta["origin"],
-            )
-
-            features_list.append(features)
-
-        features_dict[key] = features_list
-
-    return features_dict
-
-
 class Features:
     """Stores the features produced by any featurizer."""
 

rasa/shared/nlu/training_data/formats/dialogflow.py

@@ -34,8 +34,9 @@ class DialogflowReader(TrainingDataReader):
 
         if fformat not in {DIALOGFLOW_INTENT, DIALOGFLOW_ENTITIES}:
             raise ValueError(
-                "fformat must be either {}, or {}"
-                "".format(DIALOGFLOW_INTENT, DIALOGFLOW_ENTITIES)
+                "fformat must be either {}, or {}".format(
+                    DIALOGFLOW_INTENT, DIALOGFLOW_ENTITIES
+                )
             )
 
         root_js = rasa.shared.utils.io.read_json_file(filename)

rasa/shared/nlu/training_data/formats/rasa_yaml.py

@@ -108,7 +108,6 @@ class RasaYAMLReader(TrainingDataReader):
         )
 
     def _parse_nlu(self, nlu_data: Optional[List[Dict[Text, Any]]]) -> None:
-
         if not nlu_data:
             return
 
@@ -162,7 +161,6 @@ class RasaYAMLReader(TrainingDataReader):
         for example, entities, metadata in self._parse_training_examples(
             examples, intent
         ):
-
             plain_text = entities_parser.replace_entities(example)
 
             synonyms_parser.add_synonyms_from_entities(
@@ -534,9 +532,9 @@ class RasaYAMLWriter(TrainingDataWriter):
             )
 
             if examples_have_metadata or example_texts_have_escape_chars:
-                intent[
-                    key_examples
-                ] = RasaYAMLWriter._render_training_examples_as_objects(converted)
+                intent[key_examples] = (
+                    RasaYAMLWriter._render_training_examples_as_objects(converted)
+                )
             else:
                 intent[key_examples] = RasaYAMLWriter._render_training_examples_as_text(
                     converted

rasa/shared/nlu/training_data/formats/readerwriter.py

@@ -122,7 +122,6 @@ class TrainingDataWriter:
         # format (e.g. `/greet{"name": "Rasa"}) and we don't have to add the NLU
         # entity annotation
         if not text.startswith(INTENT_MESSAGE_PREFIX):
-
             entities = message.get("entities", [])
             entities_with_start_and_end = [
                 e for e in entities if "start" in e and "end" in e

rasa/shared/nlu/training_data/message.py

@@ -6,6 +6,7 @@ import copy
 import rasa.shared.utils.io
 from rasa.shared.exceptions import RasaException
 from rasa.shared.nlu.constants import (
+    COMMANDS,
     TEXT,
     INTENT,
     RESPONSE,
@@ -475,3 +476,15 @@ class Message:
                 else:
                     break
         return overlapping_pairs
+
+    def has_intent(self) -> bool:
+        """Checks if the message has an intent."""
+        return self.data.get(INTENT) is not None
+
+    def has_commands(self) -> bool:
+        """Checks if the message has any commands."""
+        return self.data.get(COMMANDS) is not None
+
+    def starts_with_slash_syntax(self) -> bool:
+        """Checks if the message text starts with a slash syntax."""
+        return self.data.get(TEXT, "").strip().startswith("/")

rasa/shared/nlu/training_data/training_data.py

@@ -47,7 +47,6 @@ class TrainingData:
         lookup_tables: Optional[List[Dict[Text, Any]]] = None,
         responses: Optional[Dict[Text, List[Dict[Text, Any]]]] = None,
     ) -> None:
-
         if training_examples:
             self.training_examples = self.sanitize_examples(training_examples)
         else:
@@ -339,7 +338,6 @@ class TrainingData:
             )
             assistant_utterances = self.responses.get(story_lookup_key, [])
             if assistant_utterances:
-
                 # Use the first response text as training label if needed downstream
                 for assistant_utterance in assistant_utterances:
                     if assistant_utterance.get(TEXT):

rasa/shared/providers/openai/session_handler.py

@@ -6,7 +6,7 @@ from typing import Text
 import certifi
 import openai
 import structlog
-from aiohttp import TCPConnector, ClientSession
+from aiohttp import ClientSession, TCPConnector
 
 structlogger = structlog.get_logger()
 
@@ -58,7 +58,7 @@ class OpenAISessionHandler:
     def _create_session(self) -> ClientSession:
         """
         Create client session with an SSL context
-        created from the certificate path.
+        created from the certificate path
         """
         ssl_context = self._create_ssl_context()
         conn = TCPConnector(ssl=ssl_context)

rasa/shared/utils/constants.py

@@ -1 +1,4 @@
 DEFAULT_ENCODING = "utf-8"
+
+READ_YAML_FILE_CACHE_MAXSIZE_ENV_VAR = "READ_YAML_FILE_CACHE_MAXSIZE"
+DEFAULT_READ_YAML_FILE_CACHE_MAXSIZE = 256

rasa/shared/utils/io.py

@@ -10,7 +10,6 @@ from typing import Any, Dict, List, Optional, Text, Type, Union
 import warnings
 import random
 import string
-
 import portalocker
 
 from rasa.shared.constants import (
@@ -402,3 +401,14 @@ def handle_print_blocking(output: Text) -> None:
             lock = AnsiToWin32(lock).stream
 
         print(output, file=lock, flush=True)
+
+
+def file_as_bytes(file_path: Text) -> bytes:
+    """Read in a file as a byte array."""
+    try:
+        with open(file_path, "rb") as f:
+            return f.read()
+    except FileNotFoundError:
+        raise FileNotFoundException(
+            f"Failed to read file, " f"'{os.path.abspath(file_path)}' does not exist."
+        )

rasa/shared/utils/llm.py

@@ -106,7 +106,6 @@ def tracker_as_readable_transcript(
     # using `applied_events` rather than `events` means that only events after the
     # most recent `Restart` or `SessionStarted` are included in the transcript
     for event in tracker.applied_events():
-
         if isinstance(event, UserUttered):
             if event.has_triggered_error:
                 first_error = event.error_commands[0]
@@ -273,7 +272,7 @@ def llm_factory(
     #   packages/langchain/llms/openai.py:189: UserWarning: You are trying to
     #   use a chat model. This way of initializing it is no longer supported.
     #   Instead, please use: `from langchain.chat_models import ChatOpenAI
-    with (warnings.catch_warnings()):
+    with warnings.catch_warnings():
         warnings.simplefilter("ignore", category=UserWarning)
         if is_azure_config(config):
             # Azure deployments are treated differently. This is done as the

rasa/shared/utils/pykwalify_extensions.py

@@ -3,6 +3,7 @@ loaded as an extension of the pykwalify library:
 
 https://pykwalify.readthedocs.io/en/latest/extensions.html#extensions
 """
+
 from typing import Any, List, Dict, Text, Union
 
 from pykwalify.errors import SchemaError

rasa/shared/utils/schemas/domain.yml

@@ -109,6 +109,9 @@ mapping:
                             nullable: True
                           requested_slot:
                             type: "str"
+                          active_flow:
+                            type: "str"
+                            nullable: True
   forms:
     type: "map"
     required: False

rasa/shared/utils/yaml.py

@@ -1,40 +1,25 @@
-from io import StringIO
-from pathlib import Path
-import re
-from collections import OrderedDict
 import logging
 import os
+import re
+from collections import OrderedDict
+from dataclasses import dataclass
+from dataclasses import field
+from functools import lru_cache
+from io import StringIO
+from pathlib import Path
 from typing import Dict, List, Optional, Any, Callable, Tuple, Union
 
-
+import jsonschema
 from importlib_resources import files
 from packaging import version
 from packaging.version import LegacyVersion
 from pykwalify.core import Core
 from pykwalify.errors import SchemaError
-from dataclasses import dataclass
-import jsonschema
-from dataclasses import field
+from ruamel import yaml as yaml
 from ruamel.yaml import RoundTripRepresenter, YAMLError
 from ruamel.yaml.constructor import DuplicateKeyError, BaseConstructor, ScalarNode
-from ruamel import yaml as yaml
 from ruamel.yaml.comments import CommentedSeq, CommentedMap
 
-from rasa.shared.utils.constants import DEFAULT_ENCODING
-from rasa.shared.utils.io import (
-    read_file,
-    convert_to_ordered_dict,
-    raise_warning,
-    read_json_file,
-)
-
-from rasa.shared.exceptions import (
-    YamlException,
-    YamlSyntaxException,
-    SchemaValidationError,
-    RasaException,
-    FileNotFoundException,
-)
 from rasa.shared.constants import (
     MODEL_CONFIG_SCHEMA_FILE,
     CONFIG_SCHEMA_FILE,
@@ -44,11 +29,32 @@ from rasa.shared.constants import (
     SCHEMA_EXTENSIONS_FILE,
     RESPONSES_SCHEMA_FILE,
 )
+from rasa.shared.exceptions import (
+    YamlException,
+    YamlSyntaxException,
+    SchemaValidationError,
+    RasaException,
+    FileNotFoundException,
+)
+from rasa.shared.utils.constants import (
+    DEFAULT_ENCODING,
+    READ_YAML_FILE_CACHE_MAXSIZE_ENV_VAR,
+    DEFAULT_READ_YAML_FILE_CACHE_MAXSIZE,
+)
+from rasa.shared.utils.io import (
+    read_file,
+    convert_to_ordered_dict,
+    raise_warning,
+    read_json_file,
+)
 
 logger = logging.getLogger(__name__)
 
 KEY_TRAINING_DATA_FORMAT_VERSION = "version"
 YAML_VERSION = (1, 2)
+READ_YAML_FILE_CACHE_MAXSIZE = os.environ.get(
+    READ_YAML_FILE_CACHE_MAXSIZE_ENV_VAR, DEFAULT_READ_YAML_FILE_CACHE_MAXSIZE
+)
 
 
 @dataclass
@@ -437,8 +443,9 @@ def _is_ascii(text: str) -> bool:
     return all(ord(character) < 128 for character in text)
 
 
+@lru_cache(maxsize=READ_YAML_FILE_CACHE_MAXSIZE)
 def read_yaml_file(
-    filename: Union[str, Path], reader_type: Union[str, List[str]] = "safe"
+    filename: Union[str, Path], reader_type: Union[str, Tuple[str]] = "safe"
 ) -> Union[List[Any], Dict[str, Any]]:
     """Parses a yaml file.
 
@@ -452,7 +459,10 @@ def read_yaml_file(
         Parsed content of the file.
     """
     try:
-        return read_yaml(read_file(filename, DEFAULT_ENCODING), reader_type)
+        fixed_reader_type = (
+            list(reader_type) if isinstance(reader_type, tuple) else reader_type
+        )
+        return read_yaml(read_file(filename, DEFAULT_ENCODING), fixed_reader_type)
     except (YAMLError, DuplicateKeyError) as e:
         raise YamlSyntaxException(filename, e)
 
@@ -635,14 +645,14 @@ def validate_training_data_format_version(
     """Validates version on the training data content using `version` field.
 
        Warns users if the file is not compatible with the current version of
-       Rasa Open Source.
+       Rasa Pro.
 
     Args:
         yaml_file_content: Raw content of training data file as a dictionary.
         filename: Name of the validated file.
 
     Returns:
-        `True` if the file can be processed by current version of Rasa Open Source,
+        `True` if the file can be processed by current version of Rasa Pro,
         `False` otherwise.
     """
     if filename:
@@ -662,7 +672,7 @@ def validate_training_data_format_version(
         logger.info(
             f"The '{KEY_TRAINING_DATA_FORMAT_VERSION}' key is missing in "
             f"the training data file {filename}. "
-            f"Rasa Open Source will read the file as a "
+            f"Rasa Pro will read the file as a "
             f"version '{LATEST_TRAINING_DATA_FORMAT_VERSION}' file. "
             f"See {DOCS_URL_TRAINING_DATA}."
         )
@@ -680,9 +690,9 @@ def validate_training_data_format_version(
         if parsed_version < latest_version:
             raise_warning(
                 f"Training data file {filename} has a lower "
-                f"format version than your Rasa Open Source installation: "
+                f"format version than your Rasa Pro installation: "
                 f"{version_value} < {LATEST_TRAINING_DATA_FORMAT_VERSION}. "
-                f"Rasa Open Source will read the file as a version "
+                f"Rasa Pro will read the file as a version "
                 f"{LATEST_TRAINING_DATA_FORMAT_VERSION} file. "
                 f"Please update your version key to "
                 f"{LATEST_TRAINING_DATA_FORMAT_VERSION}. "
@@ -690,7 +700,6 @@ def validate_training_data_format_version(
             )
 
         if latest_version >= parsed_version:
-
             return True
 
     except TypeError:
@@ -699,7 +708,7 @@ def validate_training_data_format_version(
             f"'{KEY_TRAINING_DATA_FORMAT_VERSION}' as string, for example:\n"
             f"{KEY_TRAINING_DATA_FORMAT_VERSION}: "
             f"'{LATEST_TRAINING_DATA_FORMAT_VERSION}'\n"
-            f"Rasa Open Source will read the file as a "
+            f"Rasa Pro will read the file as a "
             f"version '{LATEST_TRAINING_DATA_FORMAT_VERSION}' file.",
             docs=DOCS_URL_TRAINING_DATA,
         )
@@ -707,9 +716,9 @@ def validate_training_data_format_version(
 
     raise_warning(
         f"Training data file {filename} has a greater "
-        f"format version than your Rasa Open Source installation: "
+        f"format version than your Rasa Pro installation: "
         f"{version_value} > {LATEST_TRAINING_DATA_FORMAT_VERSION}. "
-        f"Please consider updating to the latest version of Rasa Open Source."
+        f"Please consider updating to the latest version of Rasa Pro."
         f"This file will be skipped.",
         docs=DOCS_URL_TRAINING_DATA,
     )