rasa-pro 3.10.9.dev1__py3-none-any.whl → 3.10.11__py3-none-any.whl

rasa/shared/constants.py

@@ -111,7 +111,10 @@ CONFIG_KEYS_NLU = ["language", "pipeline"] + CONFIG_MANDATORY_COMMON_KEYS
 CONFIG_KEYS = CONFIG_KEYS_CORE + CONFIG_KEYS_NLU
 CONFIG_MANDATORY_KEYS_CORE: List[Text] = [] + CONFIG_MANDATORY_COMMON_KEYS
 CONFIG_MANDATORY_KEYS_NLU = ["language"] + CONFIG_MANDATORY_COMMON_KEYS
-CONFIG_MANDATORY_KEYS = CONFIG_MANDATORY_KEYS_CORE + CONFIG_MANDATORY_KEYS_NLU
+# we need the list to contain unique values
+CONFIG_MANDATORY_KEYS = list(
+    set(CONFIG_MANDATORY_KEYS_CORE + CONFIG_MANDATORY_KEYS_NLU)
+)
 
 # Keys related to Forms (in the Domain)
 REQUIRED_SLOTS_KEY = "required_slots"

rasa/shared/importers/importer.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import logging
 from abc import ABC, abstractmethod
 from functools import reduce
@@ -114,7 +116,7 @@ class TrainingDataImporter(ABC):
         domain_path: Optional[Text] = None,
         training_data_paths: Optional[List[Text]] = None,
         args: Optional[Dict[Text, Any]] = {},
-    ) -> "TrainingDataImporter":
+    ) -> TrainingDataImporter:
         """Loads a `TrainingDataImporter` instance from a configuration file."""
         config = read_config_file(config_path)
         return TrainingDataImporter.load_from_dict(
@@ -127,7 +129,7 @@ class TrainingDataImporter(ABC):
         domain_path: Optional[Text] = None,
         training_data_paths: Optional[List[Text]] = None,
         args: Optional[Dict[Text, Any]] = {},
-    ) -> "TrainingDataImporter":
+    ) -> TrainingDataImporter:
         """Loads core `TrainingDataImporter` instance.
 
         Instance loaded from configuration file will only read Core training data.
@@ -143,7 +145,7 @@ class TrainingDataImporter(ABC):
         domain_path: Optional[Text] = None,
         training_data_paths: Optional[List[Text]] = None,
         args: Optional[Dict[Text, Any]] = {},
-    ) -> "TrainingDataImporter":
+    ) -> TrainingDataImporter:
         """Loads nlu `TrainingDataImporter` instance.
 
         Instance loaded from configuration file will only read NLU training data.
@@ -166,7 +168,7 @@ class TrainingDataImporter(ABC):
         domain_path: Optional[Text] = None,
         training_data_paths: Optional[List[Text]] = None,
         args: Optional[Dict[Text, Any]] = None,
-    ) -> "TrainingDataImporter":
+    ) -> TrainingDataImporter:
         """Loads a `TrainingDataImporter` instance from a dictionary."""
         from rasa.shared.importers.rasa import RasaFileImporter
 
@@ -195,18 +197,15 @@ 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(

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/utils/io.py

@@ -13,7 +13,6 @@ from typing import Any, cast, Callable, Dict, List, Optional, Text, Type, TypeVa
 import warnings
 import random
 import string
-
 import portalocker
 
 from rasa.shared.constants import (

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

rasa/version.py

@@ -1,3 +1,3 @@
 # this file will automatically be changed,
 # do not add anything but the version number here!
-__version__ = "3.10.9.dev1"
+__version__ = "3.10.11"

{rasa_pro-3.10.9.dev1.dist-info → rasa_pro-3.10.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rasa-pro
-Version: 3.10.9.dev1
+Version: 3.10.11
 Summary: State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development.
 Home-page: https://rasa.com
 Keywords: nlp,machine-learning,machine-learning-library,bot,bots,botkit,rasa conversational-agents,conversational-ai,chatbot,chatbot-framework,bot-framework
@@ -34,6 +34,7 @@ Requires-Dist: attrs (>=23.1,<23.2)
 Requires-Dist: azure-storage-blob (>=12.16.0,<12.17.0)
 Requires-Dist: boto3 (>=1.35.5,<1.36.0)
 Requires-Dist: certifi (>=2024.07.04)
+Requires-Dist: cloudpickle (>=2.2.1,<3.1)
 Requires-Dist: colorama (>=0.4.6,<0.5.0) ; sys_platform == "win32"
 Requires-Dist: colorclass (>=2.2,<2.3)
 Requires-Dist: coloredlogs (>=15,<16)
@@ -56,19 +57,20 @@ Requires-Dist: importlib-metadata (>=8.5.0,<8.6.0)
 Requires-Dist: importlib-resources (==6.1.3)
 Requires-Dist: jieba (>=0.42.1,<0.43) ; extra == "jieba" or extra == "full"
 Requires-Dist: jinja2 (>=3.1.4,<4.0.0)
+Requires-Dist: joblib (>=1.2.0,<1.3.0)
 Requires-Dist: jsonpatch (>=1.33,<2.0)
 Requires-Dist: jsonpickle (>=3.0,<3.1)
 Requires-Dist: jsonschema (>=4.22)
 Requires-Dist: keras (==2.14.0)
 Requires-Dist: langchain (>=0.2.0,<0.3.0)
 Requires-Dist: langchain-community (>=0.2.0,<0.3.0)
-Requires-Dist: litellm (>=1.50.0,<1.51.0)
+Requires-Dist: litellm (>=1.52.6,<1.53.0)
 Requires-Dist: matplotlib (>=3.7,<3.8)
 Requires-Dist: mattermostwrapper (>=2.2,<2.3)
 Requires-Dist: mlflow (>=2.15.1,<3.0.0) ; extra == "mlflow"
 Requires-Dist: networkx (>=3.1,<3.2)
 Requires-Dist: numpy (>=1.23.5,<1.25.0) ; python_version >= "3.9" and python_version < "3.11"
-Requires-Dist: openai (>=1.52.0,<1.53.0)
+Requires-Dist: openai (>=1.54.0,<1.55.0)
 Requires-Dist: openpyxl (>=3.1.5,<4.0.0)
 Requires-Dist: opentelemetry-api (>=1.16.0,<1.17.0)
 Requires-Dist: opentelemetry-exporter-jaeger (>=1.16.0,<1.17.0)
@@ -101,14 +103,13 @@ Requires-Dist: pyyaml (>=6.0)
 Requires-Dist: qdrant-client (>=1.9.0,<2.0.0)
 Requires-Dist: questionary (>=1.10.0,<2.1.0)
 Requires-Dist: randomname (>=0.2.1,<0.3.0)
-Requires-Dist: rasa-sdk (==3.10.0)
+Requires-Dist: rasa-sdk (>=3.10.0,<3.11.0)
 Requires-Dist: redis (>=4.6.0,<6.0)
 Requires-Dist: regex (>=2022.10.31,<2022.11)
 Requires-Dist: requests (>=2.31.0,<2.32.0)
 Requires-Dist: rich (>=13.4.2,<14.0.0)
 Requires-Dist: rocketchat_API (>=1.30.0,<1.31.0)
 Requires-Dist: ruamel.yaml (>=0.17.21,<0.17.22)
-Requires-Dist: safetensors (>=0.4.5,<0.5.0)
 Requires-Dist: sanic (>=22.12,<22.13)
 Requires-Dist: sanic-cors (>=2.2.0,<2.3.0)
 Requires-Dist: sanic-jwt (>=1.8.0,<2.0.0)
@@ -119,7 +120,6 @@ Requires-Dist: sentencepiece[sentencepiece] (>=0.1.99,<0.2.0) ; extra == "transf
 Requires-Dist: sentry-sdk (>=1.14.0,<1.15.0)
 Requires-Dist: setuptools (>=70.0.0,<70.1.0)
 Requires-Dist: sklearn-crfsuite (>=0.3.6,<0.4.0)
-Requires-Dist: skops (>=0.10.0,<0.11.0)
 Requires-Dist: slack-sdk (>=3.27.1,<4.0.0)
 Requires-Dist: spacy (>=3.5.4,<4.0.0) ; extra == "spacy" or extra == "full"
 Requires-Dist: structlog (>=23.1.0,<23.2.0)