rasa-pro 3.9.18__py3-none-any.whl → 3.10.4__py3-none-any.whl

rasa/utils/common.py

@@ -32,6 +32,7 @@ from rasa.constants import (
     DEFAULT_LOG_LEVEL_LIBRARIES,
     ENV_LOG_LEVEL_LIBRARIES,
     ENV_LOG_LEVEL_MATPLOTLIB,
+    ENV_LOG_LEVEL_MLFLOW,
     ENV_LOG_LEVEL_RABBITMQ,
     ENV_LOG_LEVEL_KAFKA,
 )
@@ -44,12 +45,6 @@ logger = logging.getLogger(__name__)
 
 T = TypeVar("T")
 
-EXPECTED_PILLOW_DEPRECATION_WARNINGS: List[Tuple[Type[Warning], str]] = [
-    # Keras uses deprecated Pillow features
-    # cf. https://github.com/keras-team/keras/issues/16639
-    (DeprecationWarning, f"{method} is deprecated and will be removed in Pillow 10 .*")
-    for method in ["BICUBIC", "NEAREST", "BILINEAR", "HAMMING", "BOX", "LANCZOS"]
-]
 
 EXPECTED_WARNINGS: List[Tuple[Type[Warning], str]] = [
     # TODO (issue #9932)
@@ -57,22 +52,17 @@ EXPECTED_WARNINGS: List[Tuple[Type[Warning], str]] = [
         np.VisibleDeprecationWarning,
         "Creating an ndarray from ragged nested sequences.*",
     ),
-    # raised by langchain -> faiss
-    (
-        DeprecationWarning,
-        "distutils Version classes are deprecated. Use packaging.version instead",
-    ),
     # raised by pycountry (rasa-plus anonymization), magic_filter, google rpc
     # and probably other dependencies that use pkg_resources instead of importlib
     (DeprecationWarning, ".*pkg_resources.*"),
-    # This warning is triggered by sanic-cors 2.0.0.
+    # This warning is triggered by sanic-cors 2.0.0 and by langchain -> faiss.
     # The warning can be removed after the packages are updated:
     # sanic-cors: ^2.1.0
     # packaging`: 23.2 (introduces breaking changes)
     # pep440-version-utils (also requires update on packaging)
     (
         DeprecationWarning,
-        "distutils Version classes are deprecated. Use packaging.version instead.",
+        "distutils Version classes are deprecated. Use packaging.version instead",
     ),
     # cf. https://github.com/tensorflow/tensorflow/issues/38168
     (
@@ -81,11 +71,6 @@ EXPECTED_WARNINGS: List[Tuple[Type[Warning], str]] = [
         "shape. This may consume a large amount of memory.",
     ),
     (UserWarning, "Slot auto-fill has been removed in 3.0 .*"),
-    # This warning is caused by the flatbuffers package
-    # The import was fixed on Github, but the latest version
-    # is not available on PyPi, so we cannot pin the newer version.
-    # cf. https://github.com/google/flatbuffers/issues/6957
-    (DeprecationWarning, "the imp module is deprecated in favour of importlib.*"),
     # Cannot fix this deprecation warning since we need to support two
     # numpy versions as long as we keep python 37 around
     (DeprecationWarning, "the `interpolation=` argument to quantile was renamed"),
@@ -102,10 +87,11 @@ EXPECTED_WARNINGS: List[Tuple[Type[Warning], str]] = [
         DeprecationWarning,
         "non-integer arguments to randrange\\(\\) have been deprecated since",
     ),
+    # Ignore Keras DeprecationWarning since it requires that we
+    # upgrade tensorflow-macos to 2.13.0 version.
     (DeprecationWarning, "invalid escape sequence*"),
 ]
 
-EXPECTED_WARNINGS.extend(EXPECTED_PILLOW_DEPRECATION_WARNINGS)
 PYTHON_LOGGING_SCHEMA_DOCS = (
     "https://docs.python.org/3/library/logging.config.html#dictionary-schema-details"
 )
@@ -402,6 +388,19 @@ def update_faker_log_level(library_log_level: Text) -> None:
     logging.getLogger("faker").propagate = False
 
 
+def update_mlflow_log_level() -> None:
+    """Set the log level of mlflow.
+
+    Uses the library specific log level or the general libraries log level.
+    """
+    library_log_level = os.environ.get(
+        ENV_LOG_LEVEL_LIBRARIES, DEFAULT_LOG_LEVEL_LIBRARIES
+    )
+    log_level = os.environ.get(ENV_LOG_LEVEL_MLFLOW, library_log_level)
+    logging.getLogger("mlflow").setLevel(log_level)
+    logging.getLogger("mlflow").propagate = False
+
+
 def sort_list_of_dicts_by_first_key(dicts: List[Dict]) -> List[Dict]:
     """Sorts a list of dictionaries by their first key."""
     return sorted(dicts, key=lambda d: next(iter(d.keys())))

rasa/utils/endpoints.py

@@ -1,14 +1,15 @@
+import os
 import ssl
+from types import ModuleType
+from typing import Any, Optional, Text, Dict, Union
 
 import aiohttp
-import os
+import structlog
 from aiohttp.client_exceptions import ContentTypeError
 from sanic.request import Request
-from typing import Any, Optional, Text, Dict
 
-from rasa.shared.exceptions import FileNotFoundException
-import structlog
 from rasa.core.constants import DEFAULT_REQUEST_TIMEOUT
+from rasa.shared.exceptions import FileNotFoundException
 from rasa.shared.utils.yaml import read_config_file
 
 structlogger = structlog.get_logger()
@@ -87,6 +88,7 @@ class EndpointConfig:
         token: Optional[Text] = None,
         token_name: Text = "token",
         cafile: Optional[Text] = None,
+        actions_module: Optional[Union[Text, ModuleType]] = None,
         **kwargs: Any,
     ) -> None:
         """Creates an `EndpointConfig` instance."""
@@ -98,6 +100,7 @@ class EndpointConfig:
         self.token_name = token_name
         self.type = kwargs.pop("store_type", kwargs.pop("type", None))
         self.cafile = cafile
+        self.actions_module = actions_module
         self.kwargs = kwargs
 
     def session(self) -> aiohttp.ClientSession:

rasa/utils/io.py

@@ -2,6 +2,7 @@ import asyncio
 import filecmp
 import logging
 import os
+import pickle
 import tempfile
 import warnings
 import re
@@ -97,6 +98,29 @@ def enable_async_loop_debugging(
     return event_loop
 
 
+def pickle_dump(filename: Union[Text, Path], obj: Any) -> None:
+    """Saves object to file.
+
+    Args:
+        filename: the filename to save the object to
+        obj: the object to store
+    """
+    with open(filename, "wb") as f:
+        pickle.dump(obj, f)
+
+
+def pickle_load(filename: Union[Text, Path]) -> Any:
+    """Loads an object from a file.
+
+    Args:
+        filename: the filename to load the object from
+
+    Returns: the loaded object
+    """
+    with open(filename, "rb") as f:
+        return pickle.load(f)
+
+
 def create_temporary_file(data: Any, suffix: Text = "", mode: Text = "w+") -> Text:
     """Creates a tempfile.NamedTemporaryFile object for data."""
     encoding = None if "b" in mode else rasa.shared.utils.io.DEFAULT_ENCODING
@@ -167,6 +191,48 @@ def create_validator(
     return FunctionValidator
 
 
+def json_unpickle(
+    file_name: Union[Text, Path], encode_non_string_keys: bool = False
+) -> Any:
+    """Unpickle an object from file using json.
+
+    Args:
+        file_name: the file to load the object from
+        encode_non_string_keys: If set to `True` then jsonpickle will encode non-string
+          dictionary keys instead of coercing them into strings via `repr()`.
+
+    Returns: the object
+    """
+    import jsonpickle.ext.numpy as jsonpickle_numpy
+    import jsonpickle
+
+    jsonpickle_numpy.register_handlers()
+
+    file_content = rasa.shared.utils.io.read_file(file_name)
+    return jsonpickle.loads(file_content, keys=encode_non_string_keys)
+
+
+def json_pickle(
+    file_name: Union[Text, Path], obj: Any, encode_non_string_keys: bool = False
+) -> None:
+    """Pickle an object to a file using json.
+
+    Args:
+        file_name: the file to store the object to
+        obj: the object to store
+        encode_non_string_keys: If set to `True` then jsonpickle will encode non-string
+          dictionary keys instead of coercing them into strings via `repr()`.
+    """
+    import jsonpickle.ext.numpy as jsonpickle_numpy
+    import jsonpickle
+
+    jsonpickle_numpy.register_handlers()
+
+    rasa.shared.utils.io.write_text_file(
+        jsonpickle.dumps(obj, keys=encode_non_string_keys), file_name
+    )
+
+
 def get_emoji_regex() -> Pattern:
     """Returns regex to identify emojis."""
     return re.compile(

rasa/utils/json_utils.py

@@ -0,0 +1,60 @@
+import json
+from decimal import Decimal
+from typing import Any, Text
+
+
+class DecimalEncoder(json.JSONEncoder):
+    """`json.JSONEncoder` that dumps `Decimal`s as `float`s."""
+
+    def default(self, obj: Any) -> Any:
+        """Get serializable object for `o`.
+
+        Args:
+            obj: Object to serialize.
+
+        Returns:
+            `obj` converted to `float` if `o` is a `Decimals`, else the base class
+            `default()` method.
+        """
+        if isinstance(obj, Decimal):
+            return float(obj)
+        return super().default(obj)
+
+
+class SetEncoder(json.JSONEncoder):
+    """`json.JSONEncoder` that dumps `set`s as `list`s."""
+
+    def default(self, obj: Any) -> Any:
+        if isinstance(obj, set):
+            return list(obj)
+        return super().default(obj)
+
+
+def replace_floats_with_decimals(obj: Any, round_digits: int = 9) -> Any:
+    """Convert all instances in `obj` of `float` to `Decimal`.
+
+    Args:
+        obj: Input object.
+        round_digits: Rounding precision of `Decimal` values.
+
+    Returns:
+        Input `obj` with all `float` types replaced by `Decimal`s rounded to
+        `round_digits` decimal places.
+    """
+
+    def _float_to_rounded_decimal(s: Text) -> Decimal:
+        return Decimal(s).quantize(Decimal(10) ** -round_digits)
+
+    return json.loads(json.dumps(obj), parse_float=_float_to_rounded_decimal)
+
+
+def replace_decimals_with_floats(obj: Any) -> Any:
+    """Convert all instances in `obj` of `Decimal` to `float`.
+
+    Args:
+        obj: A `List` or `Dict` object.
+
+    Returns:
+        Input `obj` with all `Decimal` types replaced by `float`s.
+    """
+    return json.loads(json.dumps(obj, cls=DecimalEncoder))

rasa/utils/licensing.py

@@ -293,7 +293,9 @@ def validate_license_from_env(product_area: Text = PRODUCT_AREA) -> None:
                     "Your license is about to expire. "
                     "Please contact Rasa for a renewal."
                 ),
-                expiration_date=datetime.utcfromtimestamp(license.exp).isoformat(),
+                expiration_date=datetime.fromtimestamp(
+                    license.exp, timezone.utc
+                ).isoformat(),
             )
     except LicenseNotFoundException:
         structlogger.error("license.not_found.error")
@@ -311,6 +313,12 @@ def validate_license_from_env(product_area: Text = PRODUCT_AREA) -> None:
         )
 
 
+def get_license_expiration_date() -> Text:
+    """Return the expiration date of the license."""
+    license_exp = property_of_active_license(lambda active_license: active_license.exp)
+    return datetime.fromtimestamp(license_exp, timezone.utc).isoformat()
+
+
 def is_valid_license_scope(product_area: Text, license_scope: Text) -> bool:
     """Verifies that the license scope matches the rasa-plus product area."""
     required_scopes = derive_scope_hierarchy(product_area)

rasa/utils/ml_utils.py

@@ -4,7 +4,7 @@ from typing import Any, Dict, List, Optional, Text
 import numpy as np
 import structlog
 from langchain.schema.embeddings import Embeddings
-from langchain.vectorstores import FAISS
+from langchain_community.vectorstores import FAISS
 from rasa.shared.constants import REQUIRED_SLOTS_KEY
 from rasa.shared.core.domain import KEY_RESPONSES_TEXT, Domain
 from rasa.shared.utils.llm import AI
@@ -34,7 +34,9 @@ def load_faiss_vector_store(path: Path, embedder: Embeddings) -> Optional[FAISS]
         The loaded vector store or None if the path does not exist.
     """
     if path.exists():
-        return FAISS.load_local(str(path), embedder)
+        return FAISS.load_local(
+            str(path), embedder, allow_dangerous_deserialization=True
+        )
     else:
         return None
 

rasa/utils/tensorflow/model_data.py

@@ -20,8 +20,6 @@ import numpy as np
 import scipy.sparse
 from sklearn.model_selection import train_test_split
 
-from rasa.utils.tensorflow.feature_array import FeatureArray
-
 logger = logging.getLogger(__name__)
 
 
@@ -39,6 +37,199 @@ def ragged_array_to_ndarray(ragged_array: Iterable[np.ndarray]) -> np.ndarray:
         return np.array(ragged_array, dtype=object)
 
 
+class FeatureArray(np.ndarray):
+    """Stores any kind of features ready to be used by a RasaModel.
+
+    Next to the input numpy array of features, it also received the number of
+    dimensions of the features.
+    As our features can have 1 to 4 dimensions we might have different number of numpy
+    arrays stacked. The number of dimensions helps us to figure out how to handle this
+    particular feature array. Also, it is automatically determined whether the feature
+    array is sparse or not and the number of units is determined as well.
+
+    Subclassing np.array: https://numpy.org/doc/stable/user/basics.subclassing.html
+    """
+
+    def __new__(
+        cls, input_array: np.ndarray, number_of_dimensions: int
+    ) -> "FeatureArray":
+        """Create and return a new object.  See help(type) for accurate signature."""
+        FeatureArray._validate_number_of_dimensions(number_of_dimensions, input_array)
+
+        feature_array = np.asarray(input_array).view(cls)
+
+        if number_of_dimensions <= 2:
+            feature_array.units = input_array.shape[-1]
+            feature_array.is_sparse = isinstance(input_array[0], scipy.sparse.spmatrix)
+        elif number_of_dimensions == 3:
+            feature_array.units = input_array[0].shape[-1]
+            feature_array.is_sparse = isinstance(input_array[0], scipy.sparse.spmatrix)
+        elif number_of_dimensions == 4:
+            feature_array.units = input_array[0][0].shape[-1]
+            feature_array.is_sparse = isinstance(
+                input_array[0][0], scipy.sparse.spmatrix
+            )
+        else:
+            raise ValueError(
+                f"Number of dimensions '{number_of_dimensions}' currently not "
+                f"supported."
+            )
+
+        feature_array.number_of_dimensions = number_of_dimensions
+
+        return feature_array
+
+    def __init__(
+        self, input_array: Any, number_of_dimensions: int, **kwargs: Any
+    ) -> None:
+        """Initialize. FeatureArray.
+
+        Needed in order to avoid 'Invalid keyword argument number_of_dimensions
+        to function FeatureArray.__init__ '
+        Args:
+            input_array: the array that contains features
+            number_of_dimensions: number of dimensions in input_array
+        """
+        super().__init__(**kwargs)
+        self.number_of_dimensions = number_of_dimensions
+
+    def __array_finalize__(self, obj: Optional[np.ndarray]) -> None:
+        """This method is called when the system allocates a new array from obj.
+
+        Args:
+            obj: A subclass (subtype) of ndarray.
+        """
+        if obj is None:
+            return
+
+        self.units = getattr(obj, "units", None)
+        self.number_of_dimensions = getattr(obj, "number_of_dimensions", None)  # type: ignore[assignment]
+        self.is_sparse = getattr(obj, "is_sparse", None)
+
+        default_attributes = {
+            "units": self.units,
+            "number_of_dimensions": self.number_of_dimensions,
+            "is_spare": self.is_sparse,
+        }
+        self.__dict__.update(default_attributes)
+
+    # pytype: disable=attribute-error
+    def __array_ufunc__(
+        self, ufunc: Any, method: Text, *inputs: Any, **kwargs: Any
+    ) -> Any:
+        """Overwrite this method as we are subclassing numpy array.
+
+        Args:
+            ufunc: The ufunc object that was called.
+            method: A string indicating which Ufunc method was called
+                    (one of "__call__", "reduce", "reduceat", "accumulate", "outer",
+                    "inner").
+            *inputs: A tuple of the input arguments to the ufunc.
+            **kwargs: Any additional arguments
+
+        Returns:
+            The result of the operation.
+        """
+        f = {
+            "reduce": ufunc.reduce,
+            "accumulate": ufunc.accumulate,
+            "reduceat": ufunc.reduceat,
+            "outer": ufunc.outer,
+            "at": ufunc.at,
+            "__call__": ufunc,
+        }
+        # convert the inputs to np.ndarray to prevent recursion, call the function,
+        # then cast it back as FeatureArray
+        output = FeatureArray(
+            f[method](*(i.view(np.ndarray) for i in inputs), **kwargs),
+            number_of_dimensions=kwargs["number_of_dimensions"],
+        )
+        output.__dict__ = self.__dict__  # carry forward attributes
+        return output
+
+    def __reduce__(self) -> Tuple[Any, Any, Any]:
+        """Needed in order to pickle this object.
+
+        Returns:
+            A tuple.
+        """
+        pickled_state = super(FeatureArray, self).__reduce__()
+        if isinstance(pickled_state, str):
+            raise TypeError("np array __reduce__ returned string instead of tuple.")
+        new_state = pickled_state[2] + (
+            self.number_of_dimensions,
+            self.is_sparse,
+            self.units,
+        )
+        return pickled_state[0], pickled_state[1], new_state
+
+    def __setstate__(self, state: Any, **kwargs: Any) -> None:
+        """Sets the state.
+
+        Args:
+            state: The state argument must be a sequence that contains the following
+                   elements version, shape, dtype, isFortan, rawdata.
+            **kwargs: Any additional parameter
+        """
+        # Needed in order to load the object
+        self.number_of_dimensions = state[-3]
+        self.is_sparse = state[-2]
+        self.units = state[-1]
+        super(FeatureArray, self).__setstate__(state[0:-3], **kwargs)
+
+    # pytype: enable=attribute-error
+
+    @staticmethod
+    def _validate_number_of_dimensions(
+        number_of_dimensions: int, input_array: np.ndarray
+    ) -> None:
+        """Validates if the the input array has given number of dimensions.
+
+        Args:
+            number_of_dimensions: number of dimensions
+            input_array: input array
+
+        Raises: ValueError in case the dimensions do not match
+        """
+        _sub_array = input_array
+        dim = 0
+        # Go number_of_dimensions into the given input_array
+        for i in range(1, number_of_dimensions + 1):
+            _sub_array = _sub_array[0]
+            if isinstance(_sub_array, scipy.sparse.spmatrix):
+                dim = i
+                break
+            if isinstance(_sub_array, np.ndarray) and _sub_array.shape[0] == 0:
+                # sequence dimension is 0, we are dealing with "fake" features
+                dim = i
+                break
+
+        # If the resulting sub_array is sparse, the remaining number of dimensions
+        # should be at least 2
+        if isinstance(_sub_array, scipy.sparse.spmatrix):
+            if dim > 2:
+                raise ValueError(
+                    f"Given number of dimensions '{number_of_dimensions}' does not "
+                    f"match dimensions of given input array: {input_array}."
+                )
+        elif isinstance(_sub_array, np.ndarray) and _sub_array.shape[0] == 0:
+            # sequence dimension is 0, we are dealing with "fake" features,
+            # but they should be of dim 2
+            if dim > 2:
+                raise ValueError(
+                    f"Given number of dimensions '{number_of_dimensions}' does not "
+                    f"match dimensions of given input array: {input_array}."
+                )
+        # If the resulting sub_array is dense, the sub_array should be a single number
+        elif not np.issubdtype(type(_sub_array), np.integer) and not isinstance(
+            _sub_array, (np.float32, np.float64)
+        ):
+            raise ValueError(
+                f"Given number of dimensions '{number_of_dimensions}' does not match "
+                f"dimensions of given input array: {input_array}."
+            )
+
+
 class FeatureSignature(NamedTuple):
     """Signature of feature arrays.