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

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,
     )

rasa/studio/auth.py

@@ -6,7 +6,7 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Text, Union
 
 import jwt
-from keycloak import KeycloakOpenID
+from keycloak import KeycloakOpenID, KeycloakError
 from rasa.shared.exceptions import RasaException
 from rasa.shared.utils.yaml import read_yaml_file, write_yaml
 
@@ -17,6 +17,7 @@ from rasa.studio.constants import (
     KEYCLOAK_REFRESH_EXPIRES_IN_KEY,
     KEYCLOAK_REFRESH_TOKEN,
 )
+from rasa.studio.results_logger import with_studio_error_handler, StudioResult
 
 
 class StudioAuth:
@@ -31,26 +32,39 @@ class StudioAuth:
             realm_name=studio_config.realm_name,
         )
 
-    def login(self, username: Text, password: Text, totp: Optional[int] = None) -> None:
+    def health_check(self) -> bool:
+        """Check if the Keycloak server is reachable.
 
+        Returns:
+        True if the server is reachable, False otherwise.
+        """
         try:
-            token_dict = self.keycloak_openid.token(
-                username=username, password=password, totp=totp
-            )
-        except Exception as e:
-            raise RasaException(f"Could not login. Error: {e}")
-
+            self.keycloak_openid.well_known()
+            return True
+        except Exception:
+            return False
+
+    @with_studio_error_handler
+    def login(
+        self, username: Text, password: Text, totp: Optional[int] = None
+    ) -> StudioResult:
+        token_dict = self.keycloak_openid.token(
+            username=username, password=password, totp=totp
+        )
         keycloak_token = self._resolve_token(token_dict)
 
         KeycloakTokenWriter.write_token_to_file(
             keycloak_token, token_file_location=DEFAULT_TOKEN_FILE_PATH
         )
 
-    def refresh_token(self, refresh_token: Text) -> None:
+        return StudioResult.success("Login successful.")
+
+    @with_studio_error_handler
+    def refresh_token(self, refresh_token: Text) -> StudioResult:
         try:
             token_dict = self.keycloak_openid.refresh_token(refresh_token)
         except Exception as e:
-            raise RasaException(f"Could not refresh token. Error: {e}")
+            raise KeycloakError(f"Could not refresh token. Error: {e}")
 
         keycloak_token = self._resolve_token(token_dict)
 
@@ -58,6 +72,8 @@ class StudioAuth:
             keycloak_token, token_file_location=DEFAULT_TOKEN_FILE_PATH
         )
 
+        return StudioResult.success("Token refreshed successfully.")
+
     @staticmethod
     def _resolve_token(token_dict: Dict[Text, Any]) -> KeycloakToken:
         return KeycloakToken(

rasa/studio/constants.py

@@ -14,3 +14,5 @@ RASA_STUDIO_CLI_CLIENT_ID_KEY_ENV = "RASA_STUDIO_CLI_CLIENT_ID_KEY"
 STUDIO_NLU_FILENAME = "studio_nlu.yml"
 STUDIO_DOMAIN_FILENAME = "studio_domain.yml"
 STUDIO_FLOWS_FILENAME = "studio_flows.yml"
+STUDIO_CONFIG_FILENAME = "studio_config.yml"
+STUDIO_ENDPOINTS_FILENAME = "studio_endpoints.yml"

rasa/studio/data_handler.py

@@ -50,7 +50,7 @@ class StudioDataHandler:
                 "query ExportAsEncodedYaml($input: ExportAsEncodedYamlInput!) "
                 "{ exportAsEncodedYaml(input: $input) "
                 "{ ... on ExportModernAsEncodedYamlOutput "
-                "{ nlu flows domain } "
+                "{ nlu flows domain endpoints config } "
                 "... on ExportClassicAsEncodedYamlOutput "
                 "{ nlu domain }}}"
             ),
@@ -148,6 +148,12 @@ class StudioDataHandler:
         response = self._make_request(GQL_req)
         self._extract_data(response)
 
+    def get_config(self) -> Optional[str]:
+        return self.config
+
+    def get_endpoints(self) -> Optional[str]:
+        return self.endpoints
+
     def _validate_response(self, response: dict) -> bool:
         """Validates the response from Rasa Studio.
 
@@ -184,6 +190,8 @@ class StudioDataHandler:
         self.nlu = self._decode_response(return_data.get("nlu"))
         self.domain = self._decode_response(return_data.get("domain"))
         self.flows = self._decode_response(return_data.get("flows"))
+        self.config = self._decode_response(return_data.get("config"))
+        self.endpoints = self._decode_response(return_data.get("endpoints"))
 
         if not self.has_nlu() and not self.has_flows():
             raise RasaException("No nlu or flows data in Studio response.")
@@ -195,114 +203,113 @@ class StudioDataHandler:
         return base64.b64decode(data).decode("utf-8")
 
 
-class DataDiffGenerator:
-    """Generate diff between original and studio data."""
-
-    def __init__(
-        self,
-        original_domain: Optional[Dict] = None,
-        studio_domain: Optional[Dict] = None,
-        original_nlu: Optional[Dict[str, List]] = None,
-        studio_nlu: Optional[Dict[str, List]] = None,
-        original_flows: Optional[List[Flow]] = None,
-        studio_flows: Optional[List[Flow]] = None,
-    ):
-        self.original_domain = original_domain
-        self.studio_domain = studio_domain
-        self.original_nlu = original_nlu
-        self.studio_nlu = studio_nlu
-        self.original_flows = original_flows
-        self.studio_flows = studio_flows
-
-    def create_new_domain_from_diff(self) -> Dict:
-        """Create a new domain file from the diff."""
-        if self.studio_domain is None or self.original_domain is None:
-            return {}
-        return self._domain_from_diff_rec(self.studio_domain, self.original_domain)
-
-    @staticmethod
-    def _domain_from_diff_rec(studio: Dict, original: Dict) -> Dict:
-        ret_dict = {}
-        for key in studio:
-            if key not in original:
-                ret_dict[key] = studio[key]
-            elif isinstance(studio[key], dict):
-                ret_dict[key] = DataDiffGenerator._domain_from_diff_rec(
-                    studio[key], original[key]
-                )
-                # remove empty diffs
-                if not ret_dict[key]:
-                    del ret_dict[key]
-                elif key not in [KEY_SLOTS, KEY_RESPONSES]:
-                    # copy over the whole key not just the diff in case of items
-                    # to get complete (valid) data not just the diff
-                    ret_dict[key] = studio[key]
-            elif isinstance(studio[key], list):
-                ret_dict[key] = []
-                for item in studio[key]:
-                    if item not in original[key]:
-                        ret_dict[key].append(item)
-
-                # if list is empty, remove it
-                if not ret_dict[key]:
-                    del ret_dict[key]
-
-        return ret_dict
-
-    def create_new_nlu_from_diff(self) -> Dict:
-        """Create a new nlu file from the diff."""
-        if self.studio_nlu is None or self.original_nlu is None:
-            return {"nlu": []}
-
-        nlu_diff = []
-        nlu_new_examples = [
-            new for new in self.studio_nlu["nlu"] if new not in self.original_nlu["nlu"]
-        ]
-        if nlu_new_examples:
-            for new_example in nlu_new_examples:
-                nlu_diff.append(new_example)
-                intent = new_example.get("intent")
-                if intent:
-                    self._diff_nlu_examples(new_example, nlu_diff, "intent", intent)
-                synonym = new_example.get("synonym")
-                if synonym:
-                    self._diff_nlu_examples(new_example, nlu_diff, "synonym", synonym)
-
-        return {"nlu": nlu_diff}
-
-    def create_new_flows_from_diff(self) -> List[Flow]:
-        """Create a new flows file from the diff."""
-        if self.studio_flows is None or self.original_flows is None:
-            return []
-
-        flows_new = [new for new in self.studio_flows if new not in self.original_flows]
-        return flows_new
-
-    def _diff_nlu_examples(
-        self, new_example: Dict, nlu_diff: List, match_key: str, match_value: str
-    ) -> None:
-        """Creates diff of nlu data examples.
-
-        Args:
-            new_example (Dict): intent or synonym with examples
-            nlu_diff (List): list of diff examples
-            match_key (str): intent or synonym name
-            match_value (str): intent or synonym value
-        """
-        orig = list(
-            filter(
-                lambda x: x.get(match_key) == match_value,
-                self.original_nlu["nlu"],  # type: ignore[index]
+def combine_domains(
+    studio_domain: Dict[str, Any], original_domain: Dict[str, Any]
+) -> Dict:
+    """Create a new domain file from the diff."""
+    if studio_domain is None or original_domain is None:
+        return {}
+    return _combine_domain_keys(studio_domain, original_domain)
+
+
+def _combine_domain_keys(
+    first_domain: Dict[str, Any], second_domain: Dict[str, Any]
+) -> Dict[str, Any]:
+    combined_keys = {}
+    for key in first_domain:
+        if key not in second_domain:
+            combined_keys[key] = first_domain[key]
+        elif isinstance(first_domain[key], dict):
+            combined_keys[key] = _combine_domain_keys(
+                first_domain[key], second_domain[key]
             )
+            # remove empty diffs
+            if not combined_keys[key]:
+                del combined_keys[key]
+            elif key not in [KEY_SLOTS, KEY_RESPONSES]:
+                # for all keys except slots and responses, we want to keep the
+                # keys from the first domain
+                combined_keys[key] = first_domain[key]
+        elif isinstance(first_domain[key], list):
+            combined_keys[key] = []
+            for item in first_domain[key]:
+                if item not in second_domain[key]:
+                    combined_keys[key].append(item)
+
+            # if list is empty, remove it
+            if not combined_keys[key]:
+                del combined_keys[key]
+
+    return combined_keys
+
+
+def _diff_nlu_examples(
+    new_example: Dict,
+    nlu_diff: List,
+    match_key: str,
+    match_value: str,
+    original_nlu_examples: List,
+) -> None:
+    """Creates diff of nlu data examples.
+
+    Args:
+        new_example (Dict): intent or synonym with examples
+        nlu_diff (List): list of diff examples
+        match_key (str): intent or synonym name
+        match_value (str): intent or synonym value
+        original_nlu_examples (List): original nlu examples
+    """
+    orig = list(
+        filter(
+            lambda x: x.get(match_key) == match_value,
+            original_nlu_examples,
         )
-        if len(orig) == 1:
-            orig_ex = orig[0]["examples"].split("\n")
-            new_ex = new_example["examples"].split("\n")
-            new_example["examples"] = "\n".join(
-                list(set(new_ex).difference(set(orig_ex)))
-            )
-            if not new_example["examples"]:
-                nlu_diff.remove(new_example)
+    )
+    if len(orig) == 1:
+        orig_ex = orig[0]["examples"].split("\n")
+        new_ex = new_example["examples"].split("\n")
+        new_example["examples"] = "\n".join(list(set(new_ex).difference(set(orig_ex))))
+        if not new_example["examples"]:
+            nlu_diff.remove(new_example)
+
+
+def create_new_nlu_from_diff(
+    studio_nlu: Dict[str, Any], original_nlu: Dict[str, Any]
+) -> Dict:
+    """Create a new nlu file from the diff."""
+    # `or []` handles the case where the data contains the property as an empty
+    # key, example yaml:
+    # ```
+    # nlu:
+    # ```
+    # in this case, the yaml parser will return an empty dict (because it
+    # can't know that it is supposed to be a list, so we need to convert it
+    # to a list
+    studio_nlu_data = studio_nlu.get("nlu", []) or []
+    original_nlu_data = original_nlu.get("nlu", []) or []
+
+    nlu_diff = []
+    for new in studio_nlu_data:
+        if new in original_nlu_data:
+            continue
+
+        nlu_diff.append(new)
+        intent = new.get("intent")
+        if intent:
+            _diff_nlu_examples(new, nlu_diff, "intent", intent, original_nlu_data)
+        synonym = new.get("synonym")
+        if synonym:
+            _diff_nlu_examples(new, nlu_diff, "synonym", synonym, original_nlu_data)
+
+    return {"nlu": nlu_diff}
+
+
+def create_new_flows_from_diff(
+    studio_flows: List[Flow], original_flows: List[Flow]
+) -> List[Flow]:
+    """Create a new flows file from the diff."""
+    flows_new = [new for new in studio_flows if new not in original_flows]
+    return flows_new
 
 
 def import_data_from_studio(