rasa-pro 3.11.0rc1__py3-none-any.whl → 3.11.0rc2__py3-none-any.whl

rasa/shared/utils/health_check/health_check.py

@@ -0,0 +1,256 @@
+import os
+from typing import Optional, Dict, Any
+
+from rasa.shared.constants import (
+    LLM_API_HEALTH_CHECK_ENV_VAR,
+    MODELS_CONFIG_KEY,
+    LLM_API_HEALTH_CHECK_DEFAULT_VALUE,
+)
+from rasa.shared.exceptions import ProviderClientValidationError
+from rasa.shared.providers.embedding.embedding_client import EmbeddingClient
+from rasa.shared.providers.llm.llm_client import LLMClient
+from rasa.shared.utils.cli import print_error_and_exit
+from rasa.shared.utils.llm import llm_factory, structlogger, embedder_factory
+
+
+def try_instantiate_llm_client(
+    custom_llm_config: Optional[Dict],
+    default_llm_config: Optional[Dict],
+    log_source_function: str,
+    log_source_component: str,
+) -> LLMClient:
+    """Validate llm configuration."""
+    try:
+        return llm_factory(custom_llm_config, default_llm_config)
+    except (ProviderClientValidationError, ValueError) as e:
+        structlogger.error(
+            f"{log_source_function}.llm_instantiation_failed",
+            message="Unable to instantiate LLM client.",
+            error=e,
+        )
+        print_error_and_exit(
+            f"Unable to create the LLM client for component - {log_source_component}. "
+            f"Please make sure you specified the required environment variables "
+            f"and configuration keys. "
+            f"Error: {e}"
+        )
+
+
+def try_instantiate_embedder(
+    custom_embeddings_config: Optional[Dict],
+    default_embeddings_config: Optional[Dict],
+    log_source_function: str,
+    log_source_component: str,
+) -> EmbeddingClient:
+    """Validate embeddings configuration."""
+    try:
+        return embedder_factory(custom_embeddings_config, default_embeddings_config)
+    except (ProviderClientValidationError, ValueError) as e:
+        structlogger.error(
+            f"{log_source_function}.embedder_instantiation_failed",
+            message="Unable to instantiate Embedding client.",
+            error=e,
+        )
+        print_error_and_exit(
+            f"Unable to create the Embedding client for component - "
+            f"{log_source_component}. Please make sure you specified the required "
+            f"environment variables and configuration keys. Error: {e}"
+        )
+
+
+def perform_llm_health_check(
+    custom_config: Optional[Dict[str, Any]],
+    default_config: Dict[str, Any],
+    log_source_function: str,
+    log_source_component: str,
+) -> None:
+    """Try to instantiate the LLM Client to validate the provided config.
+    If the LLM_API_HEALTH_CHECK environment variable is true, perform a test call
+    to the LLM API. If config contains multiple models, perform a test call for each
+    model in the model group.
+
+    This method supports both single model configurations and model group configurations
+    (configs that have the `models` key).
+    """
+    # Instantiate the LLM client or Router LLM client to validate the provided config.
+    llm_client = try_instantiate_llm_client(
+        custom_config, default_config, log_source_function, log_source_component
+    )
+
+    if is_api_health_check_enabled():
+        if (
+            custom_config
+            and MODELS_CONFIG_KEY in custom_config
+            and len(custom_config[MODELS_CONFIG_KEY]) > 1
+        ):
+            # If the config uses a router, instantiate the LLM client for each model
+            # in the model group. This is required to perform a test api call for each
+            # model in the group.
+            # Note: The Router LLM client is not used here as we need to perform a test
+            # api call and not load balance the requests.
+            for model_config in custom_config[MODELS_CONFIG_KEY]:
+                llm_client = try_instantiate_llm_client(
+                    model_config,
+                    default_config,
+                    log_source_function,
+                    log_source_component,
+                )
+                send_test_llm_api_request(
+                    llm_client, log_source_function, log_source_component
+                )
+        else:
+            # Make a test api call to perform a health check for the LLM client.
+            # LLM config from config file and model group config from endpoint config
+            # without router are handled here.
+            send_test_llm_api_request(
+                llm_client,
+                log_source_function,
+                log_source_component,
+            )
+    else:
+        structlogger.warning(
+            f"{log_source_function}.perform_llm_health_check.disabled",
+            event_info=(
+                f"The {LLM_API_HEALTH_CHECK_ENV_VAR} environment variable is set "
+                f"to false, which will disable LLM health check. "
+                f"It is recommended to set this variable to true in production "
+                f"environments."
+            ),
+        )
+        return None
+
+
+def perform_embeddings_health_check(
+    custom_config: Optional[Dict[str, Any]],
+    default_config: Dict[str, Any],
+    log_source_function: str,
+    log_source_component: str,
+) -> None:
+    """Try to instantiate the Embedder to validate the provided config.
+    If the LLM_API_HEALTH_CHECK environment variable is true, perform a test call
+    to the Embeddings API. If config contains multiple models, perform a test call for
+    each model in the model group.
+
+    This method supports both single model configurations and model group configurations
+    (configs that have the `models` key).
+    """
+    # Instantiate the Embedder client or the Embedder Router client to validate the
+    # provided config. Deprecation warnings and errors are logged here.
+    embedder = try_instantiate_embedder(
+        custom_config, default_config, log_source_function, log_source_component
+    )
+
+    if is_api_health_check_enabled():
+        if (
+            custom_config
+            and MODELS_CONFIG_KEY in custom_config
+            and len(custom_config[MODELS_CONFIG_KEY]) > 1
+        ):
+            # If the config uses a router, instantiate the Embedder client for each
+            # model in the model group. This is required to perform a test api call
+            # for every model in the group.
+            # Note: The Router Embedding client is not used here as we need to perform
+            # a test API call and not load balance the requests.
+            for model_config in custom_config[MODELS_CONFIG_KEY]:
+                embedder = try_instantiate_embedder(
+                    model_config,
+                    default_config,
+                    log_source_function,
+                    log_source_component,
+                )
+                send_test_embeddings_api_request(
+                    embedder, log_source_function, log_source_component
+                )
+        else:
+            # Make a test api call to perform a health check for the Embedding client.
+            # Embeddings config from config file and model group config from endpoint
+            # config without router are handled here.
+            send_test_embeddings_api_request(
+                embedder, log_source_function, log_source_component
+            )
+    else:
+        structlogger.warning(
+            f"{log_source_function}" f".perform_embeddings_health_check.disabled",
+            event_info=(
+                f"The {LLM_API_HEALTH_CHECK_ENV_VAR} environment variable is set "
+                f"to false, which will disable embeddings API health check. "
+                f"It is recommended to set this variable to true in production "
+                f"environments."
+            ),
+        )
+        return None
+
+
+def send_test_llm_api_request(
+    llm_client: LLMClient, log_source_function: str, log_source_component: str
+) -> None:
+    """Sends a test request to the LLM API to perform a health check.
+
+    Raises:
+        Exception: If the API call fails.
+    """
+    structlogger.info(
+        f"{log_source_function}.send_test_llm_api_request",
+        event_info=(
+            f"Sending a test LLM API request for the component - "
+            f"{log_source_component}."
+        ),
+        config=llm_client.config,
+    )
+    try:
+        llm_client.completion("hello")
+    except Exception as e:
+        structlogger.error(
+            f"{log_source_function}.send_test_llm_api_request_failed",
+            event_info="Test call to the LLM API failed.",
+            error=e,
+        )
+        print_error_and_exit(
+            f"Test call to the LLM API failed for component - {log_source_component}. "
+            f"Error: {e}"
+        )
+
+
+def send_test_embeddings_api_request(
+    embedder: EmbeddingClient, log_source_function: str, log_source_component: str
+) -> None:
+    """Sends a test request to the Embeddings API to perform a health check.
+
+    Raises:
+        Exception: If the API call fails.
+    """
+    structlogger.info(
+        f"{log_source_function}.send_test_embeddings_api_request",
+        event_info=(
+            f"Sending a test Embeddings API request for the component - "
+            f"{log_source_component}."
+        ),
+        config=embedder.config,
+    )
+    try:
+        embedder.embed(["hello"])
+    except Exception as e:
+        structlogger.error(
+            f"{log_source_function}.send_test_llm_api_request_failed",
+            event_info="Test call to the Embeddings API failed.",
+            error=e,
+        )
+        print_error_and_exit(
+            f"Test call to the Embeddings API failed for component - "
+            f"{log_source_component}. Error: {e}"
+        )
+
+
+def is_api_health_check_enabled() -> bool:
+    """Determines whether the API health check is enabled based on an environment
+    variable.
+
+    Returns:
+        bool: True if the API health check is enabled, False otherwise.
+    """
+    return (
+        os.getenv(
+            LLM_API_HEALTH_CHECK_ENV_VAR, LLM_API_HEALTH_CHECK_DEFAULT_VALUE
+        ).lower()
+        == "true"
+    )

rasa/shared/utils/health_check/llm_health_check_mixin.py

@@ -0,0 +1,31 @@
+from typing import Optional, Dict, Any
+
+
+class LLMHealthCheckMixin:
+    """Mixin class that provides methods for performing llm health checks during
+    training and inference within components.
+
+    This mixin offers static methods that wrap the following health check functions:
+    - `perform_llm_health_check`
+    """
+
+    @staticmethod
+    def perform_llm_health_check(
+        custom_llm_config: Optional[Dict[str, Any]],
+        default_llm_config: Dict[str, Any],
+        log_source_method: str,
+        log_source_component: str,
+    ) -> None:
+        """Wraps the `perform_llm_health_check` function to enable
+        tracing and instrumentation.
+        """
+        from rasa.shared.utils.health_check.health_check import (
+            perform_llm_health_check,
+        )
+
+        perform_llm_health_check(
+            custom_llm_config,
+            default_llm_config,
+            log_source_method,
+            log_source_component,
+        )

rasa/shared/utils/llm.py

@@ -690,14 +690,16 @@ def resolve_model_client_config(
 ) -> Optional[Dict[str, Any]]:
     """Resolve the model group in the model config.
 
-    If the config is pointing to a model group, the corresponding model group
+    1. If the config is pointing to a model group, the corresponding model group
     of the endpoints.yml is returned.
-    If the config is using the old syntax, e.g. defining the llm
+    2. If the config is using the old syntax, e.g. defining the llm
     directly in config.yml, the config is returned as is.
+    3. If the config is already resolved, return it as is.
 
     Args:
         model_config: The model config to be resolved.
         component_name: The name of the component.
+        component_name: The method of the component.
 
     Returns:
         The resolved llm config.
@@ -718,6 +720,7 @@ def resolve_model_client_config(
     if model_config is None:
         return None
 
+    # Config is already resolved or defines a client without model groups
     if MODEL_GROUP_CONFIG_KEY not in model_config:
         return model_config
 

rasa/shared/utils/yaml.py

@@ -1,4 +1,5 @@
 import datetime
+import io
 import logging
 import os
 import re
@@ -8,19 +9,13 @@ 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
+from typing import Any, List, Optional, Tuple, Dict, Callable, Union
 
 import jsonschema
 from importlib_resources import files
 from packaging import version
 from pykwalify.core import Core
 from pykwalify.errors import SchemaError
-from ruamel import yaml as yaml
-from ruamel.yaml import RoundTripRepresenter, YAMLError
-from ruamel.yaml.comments import CommentedSeq, CommentedMap
-from ruamel.yaml.constructor import DuplicateKeyError, BaseConstructor, ScalarNode
-from ruamel.yaml.loader import SafeLoader
-
 from rasa.shared.constants import (
     ASSERTIONS_SCHEMA_EXTENSIONS_FILE,
     ASSERTIONS_SCHEMA_FILE,
@@ -51,6 +46,11 @@ from rasa.shared.utils.io import (
     raise_warning,
     read_json_file,
 )
+from ruamel import yaml as yaml
+from ruamel.yaml import YAML, RoundTripRepresenter, YAMLError
+from ruamel.yaml.comments import CommentedSeq, CommentedMap
+from ruamel.yaml.constructor import DuplicateKeyError, BaseConstructor, ScalarNode
+from ruamel.yaml.loader import SafeLoader
 
 logger = logging.getLogger(__name__)
 
@@ -64,8 +64,17 @@ SENSITIVE_DATA = [API_KEY]
 
 @dataclass
 class PathWithError:
+    """Represents a validation error at a specific location in the YAML content.
+
+    Attributes:
+        message (str): A description of the validation error.
+        path (List[str]): Path to the node where the error occurred.
+        key (Optional[str]): The specific key associated with the error, if any.
+    """
+
     message: str
     path: List[str] = field(default_factory=list)
+    key: Optional[str] = None
 
 
 def fix_yaml_loader() -> None:
@@ -146,21 +155,72 @@ class YamlValidationException(YamlException, ValueError):
         if self.validation_errors:
             unique_errors = {}
             for error in self.validation_errors:
-                line_number = self._line_number_for_path(self.content, error.path)
+                line_number = self._line_number_for_path(
+                    self.content, error.path, error.key
+                )
 
                 if line_number and self.filename:
-                    error_representation = f"  in {self.filename}:{line_number}:\n"
+                    error_location = f"  in {self.filename}:{line_number}:\n"
                 elif line_number:
-                    error_representation = f"  in Line {line_number}:\n"
+                    error_location = f"  in Line {line_number}:\n"
                 else:
-                    error_representation = ""
+                    error_location = ""
 
-                error_representation += f"      {error.message}"
-                unique_errors[error.message] = error_representation
+                code_snippet = self._get_code_snippet(line_number)
+                error_message = f"{error_location}\n{code_snippet}{error.message}\n"
+                unique_errors[error.message] = error_message
             error_msg = "\n".join(unique_errors.values())
             msg += f":\n{error_msg}"
         return msg
 
+    def _get_code_snippet(
+        self,
+        error_line: Optional[int],
+        context_lines: int = 2,
+    ) -> str:
+        """Extract code snippet from the YAML lines around the error.
+
+        Args:
+            error_line: Line number where the error occurred (1-based).
+            context_lines: Number of context lines before and after the error line.
+                Default is 2, balancing context and readability. Adjust as needed.
+
+        Returns:
+            A string containing the code snippet with the error highlighted.
+        """
+        yaml_lines = self._get_serialized_yaml_lines()
+        if not yaml_lines or error_line is None:
+            return ""
+
+        start = max(error_line - context_lines - 1, 0)
+        end = min(error_line + context_lines, len(yaml_lines))
+        snippet_lines = yaml_lines[start:end]
+        snippet = ""
+        for idx, line_content in enumerate(snippet_lines, start=start + 1):
+            prefix = ">>> " if idx == error_line else "    "
+            line_number_str = str(idx)
+            snippet += f"{prefix}{line_number_str} | {line_content}\n"
+        return snippet
+
+    def _get_serialized_yaml_lines(self) -> List[str]:
+        """Serialize the content back to YAML and return the lines."""
+        yaml_lines = []
+        try:
+            yaml = YAML()
+            yaml.default_flow_style = False
+            # Set width to 1000, so we don't break the lines of the original YAML file
+            yaml.width = 1000  # type: ignore[assignment]
+            yaml.indent(mapping=2, sequence=4, offset=2)
+            stream = io.StringIO()
+            yaml.dump(self.content, stream)
+            serialized_yaml = stream.getvalue()
+            yaml_lines = serialized_yaml.splitlines()
+            return yaml_lines
+        except Exception as exc:
+            logger.debug(f"Error serializing YAML content: {exc}")
+
+        return yaml_lines
+
     def _calculate_number_of_lines(
         self,
         current: Union[CommentedSeq, CommentedMap],
@@ -228,7 +288,9 @@ class YamlValidationException(YamlException, ValueError):
         # Return the calculated child offset and True indicating a line number was found
         return child_offset, True
 
-    def _line_number_for_path(self, current: Any, path: List[str]) -> Optional[int]:
+    def _line_number_for_path(
+        self, current: Any, path: List[str], key: Optional[str] = None
+    ) -> Optional[int]:
         """Get line number for a yaml path in the current content.
 
         Implemented using recursion: algorithm goes down the path navigating to the
@@ -237,6 +299,7 @@ class YamlValidationException(YamlException, ValueError):
         Args:
             current: current content
             path: path to traverse within the content
+            key: the key associated with the error, if any
 
         Returns:
             the line number of the path in the content.
@@ -247,6 +310,10 @@ class YamlValidationException(YamlException, ValueError):
         this_line = current.lc.line + 1 if hasattr(current, "lc") else None
 
         if not path:
+            if key and hasattr(current, "lc"):
+                if hasattr(current.lc, "data") and key in current.lc.data:
+                    key_line_no = current.lc.data[key][0] + 1
+                    return key_line_no
             return this_line
 
         head, tail = path[0], path[1:]
@@ -256,7 +323,7 @@ class YamlValidationException(YamlException, ValueError):
 
         if head:
             if isinstance(current, dict) and head in current:
-                line = self._line_number_for_path(current[head], tail)
+                line = self._line_number_for_path(current[head], tail, key)
                 if line is None:
                     line_offset, found_lc = self._calculate_number_of_lines(
                         current, head
@@ -266,10 +333,13 @@ class YamlValidationException(YamlException, ValueError):
                     return this_line + line_offset
                 return line
             elif isinstance(current, list) and head.isdigit():
-                return self._line_number_for_path(current[int(head)], tail) or this_line
+                return (
+                    self._line_number_for_path(current[int(head)], tail, key)
+                    or this_line
+                )
             else:
                 return this_line
-        return self._line_number_for_path(current, tail) or this_line
+        return self._line_number_for_path(current, tail, key) or this_line
 
 
 def read_schema_file(
@@ -331,13 +401,26 @@ def validate_yaml_content_using_schema(
     try:
         core.validate(raise_exception=True)
     except SchemaError:
+        # PyKwalify propagates each validation error up the data hierarchy, resulting
+        # in multiple redundant errors for a single issue. To present a clear message
+        # about the root cause, we use only the first error.
+        error = core.errors[0]
+
+        # Increment numeric indices by 1 to convert from 0-based to 1-based indexing
+        error_message = re.sub(
+            r"(/)(\d+)", lambda m: f"/{int(m.group(2)) + 1}", str(error)
+        )
+
         raise YamlValidationException(
             "Please make sure the file is correct and all "
             "mandatory parameters are specified. Here are the errors "
             "found during validation",
             [
-                PathWithError(message=str(e), path=e.path.split("/"))
-                for e in core.errors
+                PathWithError(
+                    message=error_message,
+                    path=error.path.removeprefix("/").split("/"),
+                    key=getattr(error, "key", None),
+                )
             ],
             content=yaml_content,
         )
@@ -424,46 +507,6 @@ 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",
@@ -479,9 +522,6 @@ 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,12 +23,10 @@ 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,
-        verify: bool = True,
-    ) -> None:
+    def __init__(self, studio_config: StudioConfig) -> 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,13 +2,14 @@ from __future__ import annotations
 
 import os
 from dataclasses import dataclass
-from typing import Dict, Optional, Text
+from typing import Any, 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,
@@ -19,6 +20,7 @@ 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
@@ -27,13 +29,15 @@ 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[Text]]:
+    def to_dict(self) -> Dict[Text, Optional[Any]]:
         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
@@ -43,6 +47,7 @@ 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:
@@ -73,7 +78,7 @@ class StudioConfig:
         config = read_global_config_value(STUDIO_CONFIG_KEY, unavailable_ok=True)
 
         if config is None:
-            return StudioConfig(None, None, None, None)
+            return StudioConfig(None, None, None, None, False)
 
         if not isinstance(config, dict):
             raise ValueError(
@@ -83,7 +88,7 @@ class StudioConfig:
             )
 
         for key in config:
-            if not isinstance(config[key], str):
+            if not isinstance(config[key], str) and key != DISABLE_VERIFY:
                 raise ValueError(
                     "Invalid config file format. "
                     f"Key '{key}' is not a text value."
@@ -102,6 +107,9 @@ 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
@@ -124,4 +132,5 @@ 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,
         )