rasa-pro 3.10.16__py3-none-any.whl → 3.11.0a1__py3-none-any.whl

rasa/shared/utils/yaml.py

@@ -416,6 +416,47 @@ def validate_raw_yaml_using_schema_file_with_responses(
     )
 
 
+def process_content(content: str) -> str:
+    """
+    Process the content to handle both Windows paths and emojis.
+    Windows paths are processed by escaping backslashes but emojis are left untouched.
+
+    Args:
+        content: yaml content to be processed
+    """
+    # Detect common Windows path patterns: e.g., C:\ or \\
+    UNESCAPED_WINDOWS_PATH_PATTERN = re.compile(
+        r"(?<!\w)[a-zA-Z]:(\\[a-zA-Z0-9_ -]+)*(\\)?(?!\\n)"
+    )
+    ESCAPED_WINDOWS_PATH_PATTERN = re.compile(
+        r"(?<!\w)[a-zA-Z]:(\\\\[a-zA-Z0-9_ -]+)+\\\\?(?!\\n)"
+    )
+
+    # Function to escape backslashes in Windows paths but leave other content as is
+    def escape_windows_paths(match: re.Match) -> str:
+        path = str(match.group(0))
+        return path.replace("\\", "\\\\")  # Escape backslashes only in Windows paths
+
+    def unescape_windows_paths(match: re.Match) -> str:
+        path = str(match.group(0))
+        return path.replace("\\\\", "\\")
+
+    # First, process Windows paths by escaping backslashes
+    content = re.sub(UNESCAPED_WINDOWS_PATH_PATTERN, escape_windows_paths, content)
+
+    # Ensure proper handling of emojis by decoding Unicode sequences
+    content = (
+        content.encode("utf-8")
+        .decode("raw_unicode_escape")
+        .encode("utf-16", "surrogatepass")
+        .decode("utf-16")
+    )
+
+    content = re.sub(ESCAPED_WINDOWS_PATH_PATTERN, unescape_windows_paths, content)
+
+    return content
+
+
 def read_yaml(
     content: str,
     reader_type: Union[str, List[str]] = "safe",
@@ -431,6 +472,9 @@ def read_yaml(
     Raises:
         ruamel.yaml.parser.ParserError: If there was an error when parsing the YAML.
     """
+    if _is_ascii(content):
+        content = process_content(content)
+
     custom_constructor = kwargs.get("custom_constructor", None)
 
     # Create YAML parser with custom constructor

rasa/studio/auth.py

@@ -23,10 +23,12 @@ from rasa.studio.results_logger import with_studio_error_handler, StudioResult
 class StudioAuth:
     """Handles the authentication with the Rasa Studio authentication server."""
 
-    def __init__(self, studio_config: StudioConfig) -> None:
+    def __init__(
+        self,
+        studio_config: StudioConfig,
+        verify: bool = True,
+    ) -> None:
         self.config = studio_config
-        verify = not studio_config.disable_verify
-
         self.keycloak_openid = KeycloakOpenID(
             server_url=studio_config.authentication_server_url,
             client_id=studio_config.client_id,

rasa/studio/config.py

@@ -2,14 +2,13 @@ from __future__ import annotations
 
 import os
 from dataclasses import dataclass
-from typing import Any, Dict, Optional, Text
+from typing import Dict, Optional, Text
 
 from rasa.utils.common import read_global_config_value, write_global_config_value
 
 from rasa.studio.constants import (
     RASA_STUDIO_AUTH_SERVER_URL_ENV,
     RASA_STUDIO_CLI_CLIENT_ID_KEY_ENV,
-    RASA_STUDIO_CLI_DISABLE_VERIFY_KEY_ENV,
     RASA_STUDIO_CLI_REALM_NAME_KEY_ENV,
     RASA_STUDIO_CLI_STUDIO_URL_ENV,
     STUDIO_CONFIG_KEY,
@@ -20,7 +19,6 @@ STUDIO_URL_KEY = "studio_url"
 CLIENT_ID_KEY = "client_id"
 REALM_NAME_KEY = "realm_name"
 CLIENT_SECRET_KEY = "client_secret"
-DISABLE_VERIFY = "disable_verify"
 
 
 @dataclass
@@ -29,15 +27,13 @@ class StudioConfig:
     studio_url: Optional[Text]
     client_id: Optional[Text]
     realm_name: Optional[Text]
-    disable_verify: bool = False
 
-    def to_dict(self) -> Dict[Text, Optional[Any]]:
+    def to_dict(self) -> Dict[Text, Optional[Text]]:
         return {
             AUTH_SERVER_URL_KEY: self.authentication_server_url,
             STUDIO_URL_KEY: self.studio_url,
             CLIENT_ID_KEY: self.client_id,
             REALM_NAME_KEY: self.realm_name,
-            DISABLE_VERIFY: self.disable_verify,
         }
 
     @classmethod
@@ -47,7 +43,6 @@ class StudioConfig:
             studio_url=data[STUDIO_URL_KEY],
             client_id=data[CLIENT_ID_KEY],
             realm_name=data[REALM_NAME_KEY],
-            disable_verify=data.get(DISABLE_VERIFY, False),
         )
 
     def write_config(self) -> None:
@@ -78,7 +73,7 @@ class StudioConfig:
         config = read_global_config_value(STUDIO_CONFIG_KEY, unavailable_ok=True)
 
         if config is None:
-            return StudioConfig(None, None, None, None, False)
+            return StudioConfig(None, None, None, None)
 
         if not isinstance(config, dict):
             raise ValueError(
@@ -88,7 +83,7 @@ class StudioConfig:
             )
 
         for key in config:
-            if not isinstance(config[key], str) and key != DISABLE_VERIFY:
+            if not isinstance(config[key], str):
                 raise ValueError(
                     "Invalid config file format. "
                     f"Key '{key}' is not a text value."
@@ -107,9 +102,6 @@ class StudioConfig:
             studio_url=StudioConfig._read_env_value(RASA_STUDIO_CLI_STUDIO_URL_ENV),
             client_id=StudioConfig._read_env_value(RASA_STUDIO_CLI_CLIENT_ID_KEY_ENV),
             realm_name=StudioConfig._read_env_value(RASA_STUDIO_CLI_REALM_NAME_KEY_ENV),
-            disable_verify=bool(
-                os.getenv(RASA_STUDIO_CLI_DISABLE_VERIFY_KEY_ENV, False)
-            ),
         )
 
     @staticmethod
@@ -132,5 +124,4 @@ class StudioConfig:
             studio_url=self.studio_url or other.studio_url,
             client_id=self.client_id or other.client_id,
             realm_name=self.realm_name or other.realm_name,
-            disable_verify=self.disable_verify or other.disable_verify,
         )

rasa/studio/constants.py

@@ -10,7 +10,6 @@ RASA_STUDIO_AUTH_SERVER_URL_ENV = "RASA_STUDIO_AUTH_SERVER_URL"
 RASA_STUDIO_CLI_STUDIO_URL_ENV = "RASA_STUDIO_CLI_STUDIO_URL"
 RASA_STUDIO_CLI_REALM_NAME_KEY_ENV = "RASA_STUDIO_CLI_REALM_NAME_KEY"
 RASA_STUDIO_CLI_CLIENT_ID_KEY_ENV = "RASA_STUDIO_CLI_CLIENT_ID_KEY"
-RASA_STUDIO_CLI_DISABLE_VERIFY_KEY_ENV = "RASA_STUDIO_CLI_DISABLE_VERIFY_KEY"
 
 STUDIO_NLU_FILENAME = "studio_nlu.yml"
 STUDIO_DOMAIN_FILENAME = "studio_domain.yml"

rasa/studio/data_handler.py

@@ -76,9 +76,7 @@ class StudioDataHandler:
 
         return request
 
-    def _make_request(
-        self, GQL_req: Dict[Any, Any], verify: bool = True
-    ) -> Dict[Any, Any]:
+    def _make_request(self, GQL_req: Dict[Any, Any]) -> Dict[Any, Any]:
         token = KeycloakTokenReader().get_token()
         if token.is_expired():
             token = self.refresh_token(token)
@@ -95,7 +93,6 @@ class StudioDataHandler:
                 "Authorization": f"{token.token_type} {token.access_token}",
                 "Content-Type": "application/json",
             },
-            verify=verify,
         )
 
         if res.status_code != 200:
@@ -131,9 +128,7 @@ class StudioDataHandler:
             The data from Rasa Studio.
         """
         GQL_req = self._build_request()
-        verify = not self.studio_config.disable_verify
-
-        response = self._make_request(GQL_req, verify=verify)
+        response = self._make_request(GQL_req)
         self._extract_data(response)
 
     def request_data(
@@ -150,9 +145,7 @@ class StudioDataHandler:
             The data from Rasa Studio.
         """
         GQL_req = self._build_request(intent_names, entity_names)
-        verify = not self.studio_config.disable_verify
-
-        response = self._make_request(GQL_req, verify=verify)
+        response = self._make_request(GQL_req)
         self._extract_data(response)
 
     def get_config(self) -> Optional[str]:

rasa/studio/upload.py

@@ -56,10 +56,7 @@ def _get_selected_entities_and_intents(
 
 def handle_upload(args: argparse.Namespace) -> None:
     """Uploads primitives to rasa studio."""
-    studio_config = StudioConfig.read_config()
-    endpoint = studio_config.studio_url
-    verify = not studio_config.disable_verify
-
+    endpoint = StudioConfig.read_config().studio_url
     if not endpoint:
         rasa.shared.utils.cli.print_error_and_exit(
             "No GraphQL endpoint found in config. Please run `rasa studio config`."
@@ -79,9 +76,9 @@ def handle_upload(args: argparse.Namespace) -> None:
 
         # check safely if args.calm is set and not fail if not
         if hasattr(args, "calm") and args.calm:
-            upload_calm_assistant(args, endpoint, verify=verify)
+            upload_calm_assistant(args, endpoint)
         else:
-            upload_nlu_assistant(args, endpoint, verify=verify)
+            upload_nlu_assistant(args, endpoint)
 
 
 config_keys = [
@@ -129,9 +126,7 @@ def _get_assistant_name(config: Dict[Text, Any]) -> str:
 
 
 @with_studio_error_handler
-def upload_calm_assistant(
-    args: argparse.Namespace, endpoint: str, verify: bool = True
-) -> StudioResult:
+def upload_calm_assistant(args: argparse.Namespace, endpoint: str) -> StudioResult:
     """Uploads the CALM assistant data to Rasa Studio.
 
     Args:
@@ -221,13 +216,11 @@ def upload_calm_assistant(
     )
 
     structlogger.info("Uploading to Rasa Studio...")
-    return make_request(endpoint, graphql_req, verify)
+    return make_request(endpoint, graphql_req)
 
 
 @with_studio_error_handler
-def upload_nlu_assistant(
-    args: argparse.Namespace, endpoint: str, verify: bool = True
-) -> StudioResult:
+def upload_nlu_assistant(args: argparse.Namespace, endpoint: str) -> StudioResult:
     """Uploads the classic (dm1) assistant data to Rasa Studio.
 
     Args:
@@ -275,16 +268,15 @@ def upload_nlu_assistant(
     graphql_req = build_request(assistant_name, nlu_examples_yaml, domain_yaml)
 
     structlogger.info("Uploading to Rasa Studio...")
-    return make_request(endpoint, graphql_req, verify)
+    return make_request(endpoint, graphql_req)
 
 
-def make_request(endpoint: str, graphql_req: Dict, verify: bool = True) -> StudioResult:
+def make_request(endpoint: str, graphql_req: Dict) -> StudioResult:
     """Makes a request to the studio endpoint to upload data.
 
     Args:
         endpoint: The studio endpoint
         graphql_req: The graphql request
-        verify: Whether to verify SSL
     """
     token = KeycloakTokenReader().get_token()
     res = requests.post(
@@ -294,7 +286,6 @@ def make_request(endpoint: str, graphql_req: Dict, verify: bool = True) -> Studi
             "Authorization": f"{token.token_type} {token.access_token}",
             "Content-Type": "application/json",
         },
-        verify=verify,
     )
 
     if results_logger.response_has_errors(res.json()):

rasa/tracing/instrumentation/attribute_extractors.py

@@ -664,7 +664,7 @@ def extract_attrs_for_custom_action_executor_run(
 
     attrs: Dict[str, Any] = {
         "class_name": self.__class__.__name__,
-        "action_name": self.action_name,
+        "action_name": self.action_name if hasattr(self, "action_name") else "None",
         "sender_id": tracker.sender_id,
         "url": str(url),
         "actions_module": str(actions_module),

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

@@ -303,18 +303,6 @@ class Validator:
         everything_is_alright = True
 
         for response_text, response_variations in self.domain.responses.items():
-            if not response_variations:
-                structlogger.error(
-                    "validator.empty_response",
-                    response=response_text,
-                    event_info=(
-                        f"The response '{response_text}' in the domain file "
-                        f"does not have any variations. Please add at least one "
-                        f"variation to the response."
-                    ),
-                )
-                everything_is_alright = False
-
             for response in response_variations:
                 if any(
                     self.check_for_placeholder(response.get(key))

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.16"
+__version__ = "3.11.0a1"