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

rasa/shared/utils/yaml.py

@@ -1,5 +1,4 @@
 import datetime
-import io
 import logging
 import os
 import re
@@ -9,13 +8,19 @@ from dataclasses import field
 from functools import lru_cache
 from io import StringIO
 from pathlib import Path
-from typing import Any, List, Optional, Tuple, Dict, Callable, Union
+from typing import Dict, List, Optional, Any, Callable, Tuple, 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.constructor import DuplicateKeyError, BaseConstructor, ScalarNode
+from ruamel.yaml.comments import CommentedSeq, CommentedMap
+from ruamel.yaml.loader import SafeLoader
+
 from rasa.shared.constants import (
     ASSERTIONS_SCHEMA_EXTENSIONS_FILE,
     ASSERTIONS_SCHEMA_FILE,
@@ -26,7 +31,6 @@ from rasa.shared.constants import (
     LATEST_TRAINING_DATA_FORMAT_VERSION,
     SCHEMA_EXTENSIONS_FILE,
     RESPONSES_SCHEMA_FILE,
-    SENSITIVE_DATA,
 )
 from rasa.shared.exceptions import (
     YamlException,
@@ -46,11 +50,6 @@ 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__)
 
@@ -63,17 +62,8 @@ READ_YAML_FILE_CACHE_MAXSIZE = os.environ.get(
 
 @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:
@@ -97,12 +87,6 @@ def replace_environment_variables() -> None:
     def env_var_constructor(loader: BaseConstructor, node: ScalarNode) -> str:
         """Process environment variables found in the YAML."""
         value = loader.construct_scalar(node)
-
-        # get key of current node
-        key_node = list(loader.constructed_objects)[-1]
-        if isinstance(key_node, ScalarNode) and key_node.value in SENSITIVE_DATA:
-            return value
-
         expanded_vars = os.path.expandvars(value)
         not_expanded = [
             w for w in expanded_vars.split() if w.startswith("$") and w in value
@@ -120,6 +104,7 @@ def replace_environment_variables() -> None:
 
 
 fix_yaml_loader()
+replace_environment_variables()
 
 
 class YamlValidationException(YamlException, ValueError):
@@ -153,72 +138,21 @@ 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, error.key
-                )
+                line_number = self._line_number_for_path(self.content, error.path)
 
                 if line_number and self.filename:
-                    error_location = f"  in {self.filename}:{line_number}:\n"
+                    error_representation = f"  in {self.filename}:{line_number}:\n"
                 elif line_number:
-                    error_location = f"  in Line {line_number}:\n"
+                    error_representation = f"  in Line {line_number}:\n"
                 else:
-                    error_location = ""
+                    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_representation += f"      {error.message}"
+                unique_errors[error.message] = error_representation
             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],
@@ -286,9 +220,7 @@ 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], key: Optional[str] = None
-    ) -> Optional[int]:
+    def _line_number_for_path(self, current: Any, path: List[str]) -> Optional[int]:
         """Get line number for a yaml path in the current content.
 
         Implemented using recursion: algorithm goes down the path navigating to the
@@ -297,7 +229,6 @@ 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.
@@ -308,10 +239,6 @@ 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:]
@@ -321,7 +248,7 @@ class YamlValidationException(YamlException, ValueError):
 
         if head:
             if isinstance(current, dict) and head in current:
-                line = self._line_number_for_path(current[head], tail, key)
+                line = self._line_number_for_path(current[head], tail)
                 if line is None:
                     line_offset, found_lc = self._calculate_number_of_lines(
                         current, head
@@ -331,17 +258,14 @@ 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, key)
-                    or this_line
-                )
+                return self._line_number_for_path(current[int(head)], tail) or this_line
             else:
                 return this_line
-        return self._line_number_for_path(current, tail, key) or this_line
+        return self._line_number_for_path(current, tail) or this_line
 
 
 def read_schema_file(
-    schema_file: str, package_name: str = PACKAGE_NAME, expand_env_vars: bool = True
+    schema_file: str, package_name: str = PACKAGE_NAME
 ) -> Union[List[Any], Dict[str, Any]]:
     """Read a schema file from the package.
 
@@ -349,13 +273,12 @@ def read_schema_file(
         schema_file: The schema file to read.
         package_name: the name of the package the schema is located in. defaults
             to `rasa`.
-        expand_env_vars: Whether to expand environment variables in the file.
 
     Returns:
         The schema as a dictionary.
     """
     schema_path = str(files(package_name).joinpath(schema_file))
-    return read_yaml_file(schema_path, expand_env_vars=expand_env_vars)
+    return read_yaml_file(schema_path)
 
 
 def parse_raw_yaml(raw_yaml_content: str) -> Dict[str, Any]:
@@ -400,26 +323,13 @@ 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=error_message,
-                    path=error.path.removeprefix("/").split("/"),
-                    key=getattr(error, "key", None),
-                )
+                PathWithError(message=str(e), path=e.path.split("/"))
+                for e in core.errors
             ],
             content=yaml_content,
         )
@@ -429,7 +339,6 @@ def validate_raw_yaml_using_schema(
     raw_yaml_content: str,
     schema_content: Dict[str, Any],
     schema_extensions: Optional[List[str]] = None,
-    expand_env_vars: bool = True,
 ) -> None:
     """Validate raw yaml content using a schema.
 
@@ -439,7 +348,6 @@ def validate_raw_yaml_using_schema(
         raw_yaml_content: the raw YAML content to be validated (usually a string)
         schema_content: the schema for the yaml_file_content
         schema_extensions: pykwalify schema extension files
-        expand_env_vars: Whether to expand environment variables.
     """
     try:
         # we need "rt" since
@@ -447,11 +355,7 @@ def validate_raw_yaml_using_schema(
         # will include e.g. at which line an object was parsed. this is very
         # helpful when we validate files later on and want to point the user to the
         # right line
-        yaml_data = read_yaml(
-            raw_yaml_content,
-            reader_type=["safe", "rt"],
-            expand_env_vars=expand_env_vars,
-        )
+        yaml_data = read_yaml(raw_yaml_content, reader_type=["safe", "rt"])
     except (YAMLError, DuplicateKeyError) as e:
         raise YamlSyntaxException(underlying_yaml_exception=e)
 
@@ -459,10 +363,7 @@ def validate_raw_yaml_using_schema(
 
 
 def validate_raw_yaml_using_schema_file(
-    raw_yaml_content: str,
-    schema_path: str,
-    package_name: str = PACKAGE_NAME,
-    expand_env_vars: bool = True,
+    raw_yaml_content: str, schema_path: str, package_name: str = PACKAGE_NAME
 ) -> None:
     """Validate raw yaml content using a schema from file.
 
@@ -471,21 +372,15 @@ def validate_raw_yaml_using_schema_file(
         schema_path: the schema used for validation
         package_name: the name of the package the schema is located in. defaults
             to `rasa`.
-        expand_env_vars: Whether to expand environment variables in the file.
     """
-    schema_content = read_schema_file(
-        schema_path, package_name, expand_env_vars=expand_env_vars
-    )
-    validate_raw_yaml_using_schema(
-        raw_yaml_content, schema_content, expand_env_vars=expand_env_vars
-    )
+    schema_content = read_schema_file(schema_path, package_name)
+    validate_raw_yaml_using_schema(raw_yaml_content, schema_content)
 
 
 def validate_raw_yaml_content_using_schema_with_responses(
     raw_yaml_content: str,
     schema_content: Union[List[Any], Dict[str, Any]],
     package_name: str = PACKAGE_NAME,
-    expand_env_vars: bool = True,
 ) -> None:
     """Validate raw yaml content using a schema with responses sub-schema.
 
@@ -494,26 +389,18 @@ def validate_raw_yaml_content_using_schema_with_responses(
         schema_content: the content of the YAML schema
         package_name: the name of the package the schema is located in. defaults
         to `rasa`.
-        expand_env_vars: Whether to expand environment variables in the file.
     """
     # bot responses are part of the schema extension
     # it will be included if the schema explicitly references it with include: responses
-    bot_responses_schema_content = read_schema_file(
-        RESPONSES_SCHEMA_FILE, package_name, expand_env_vars=expand_env_vars
-    )
+    bot_responses_schema_content = read_schema_file(RESPONSES_SCHEMA_FILE, package_name)
     schema_content = dict(schema_content, **bot_responses_schema_content)
     schema_extensions = [str(files(package_name).joinpath(SCHEMA_EXTENSIONS_FILE))]
 
-    validate_raw_yaml_using_schema(
-        raw_yaml_content, schema_content, schema_extensions, expand_env_vars
-    )
+    validate_raw_yaml_using_schema(raw_yaml_content, schema_content, schema_extensions)
 
 
 def validate_raw_yaml_using_schema_file_with_responses(
-    raw_yaml_content: str,
-    schema_path: str,
-    package_name: str = PACKAGE_NAME,
-    expand_env_vars: bool = True,
+    raw_yaml_content: str, schema_path: str, package_name: str = PACKAGE_NAME
 ) -> None:
     """Validate domain yaml content using a schema from file with responses sub-schema.
 
@@ -522,12 +409,52 @@ def validate_raw_yaml_using_schema_file_with_responses(
         schema_path: the schema of the yaml file
         package_name: the name of the package the schema is located in. defaults
             to `rasa`.
-        expand_env_vars: Whether to expand environment variables in the file.
     """
-    schema_content = read_schema_file(schema_path, package_name, expand_env_vars)
+    schema_content = read_schema_file(schema_path, package_name)
     validate_raw_yaml_content_using_schema_with_responses(
-        raw_yaml_content, schema_content, package_name, expand_env_vars
+        raw_yaml_content, schema_content, package_name
+    )
+
+
+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(
@@ -545,15 +472,15 @@ 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)
-    expand_env_vars = kwargs.get("expand_env_vars", True)
 
     # Create YAML parser with custom constructor
     yaml_parser, reset_constructors = create_yaml_parser(
         reader_type, custom_constructor
     )
-    if expand_env_vars:
-        replace_environment_variables()
     yaml_content = yaml_parser.load(content) or {}
 
     # Reset to default constructors
@@ -609,10 +536,6 @@ def create_yaml_parser(
             yaml.resolver.BaseResolver.DEFAULT_SEQUENCE_TAG,
             original_sequence_constructor,
         )
-        # replace env var constructor with one that does not expand env vars
-        yaml_parser.constructor.add_constructor(
-            "!env_var", lambda loader, node: loader.construct_scalar(node)
-        )
 
     def custom_date_constructor(loader: SafeLoader, node: ScalarNode) -> str:
         """Custom constructor for parsing dates in the format '%Y-%m-%d'.
@@ -647,9 +570,7 @@ def _is_ascii(text: str) -> bool:
 
 @lru_cache(maxsize=READ_YAML_FILE_CACHE_MAXSIZE)
 def read_yaml_file(
-    filename: Union[str, Path],
-    reader_type: Union[str, Tuple[str]] = "safe",
-    expand_env_vars: bool = True,
+    filename: Union[str, Path], reader_type: Union[str, Tuple[str]] = "safe"
 ) -> Union[List[Any], Dict[str, Any]]:
     """Parses a yaml file.
 
@@ -658,7 +579,6 @@ def read_yaml_file(
     Args:
         filename: The path to the file which should be read.
         reader_type: Reader type to use. By default "safe" will be used.
-        expand_env_vars: Whether to expand environment variables in the file.
 
     Returns:
         Parsed content of the file.
@@ -667,11 +587,7 @@ def read_yaml_file(
         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,
-            expand_env_vars=expand_env_vars,
-        )
+        return read_yaml(read_file(filename, DEFAULT_ENCODING), fixed_reader_type)
     except (YAMLError, DuplicateKeyError) as e:
         raise YamlSyntaxException(filename, e)
 
@@ -694,14 +610,11 @@ def read_config_file(
     return read_validated_yaml(filename, CONFIG_SCHEMA_FILE, reader_type)
 
 
-def read_model_configuration(
-    filename: Union[Path, str], expand_env_vars: bool = True
-) -> Dict[str, Any]:
+def read_model_configuration(filename: Union[Path, str]) -> Dict[str, Any]:
     """Parses a model configuration file.
 
     Args:
         filename: The path to the file which should be read.
-        expand_env_vars: Whether to expand environment variables in the file.
 
     Raises:
         YamlValidationException: In case the model configuration doesn't match the
@@ -710,9 +623,7 @@ def read_model_configuration(
     Returns:
         Parsed config file.
     """
-    return read_validated_yaml(
-        filename, MODEL_CONFIG_SCHEMA_FILE, expand_env_vars=expand_env_vars
-    )
+    return read_validated_yaml(filename, MODEL_CONFIG_SCHEMA_FILE)
 
 
 def dump_obj_as_yaml_to_string(
@@ -810,7 +721,6 @@ def read_validated_yaml(
     filename: Union[str, Path],
     schema: str,
     reader_type: Union[str, List[str]] = "safe",
-    expand_env_vars: bool = True,
 ) -> Any:
     """Validates YAML file content and returns parsed content.
 
@@ -819,7 +729,6 @@ def read_validated_yaml(
         schema: The path to the schema file which should be used for validating the
             file content.
         reader_type: Reader type to use. By default, "safe" will be used.
-        expand_env_vars: Whether to expand environment variables in the file.
 
     Returns:
         The parsed file content.
@@ -830,10 +739,8 @@ def read_validated_yaml(
     """
     content = read_file(filename)
 
-    validate_raw_yaml_using_schema_file(
-        content, schema, expand_env_vars=expand_env_vars
-    )
-    return read_yaml(content, reader_type, expand_env_vars=expand_env_vars)
+    validate_raw_yaml_using_schema_file(content, schema)
+    return read_yaml(content, reader_type)
 
 
 def validate_training_data(json_data: Dict[str, Any], schema: Dict[str, Any]) -> None:
@@ -952,7 +859,6 @@ def validate_yaml_with_jsonschema(
     humanize_error: Callable[
         [jsonschema.ValidationError], str
     ] = default_error_humanizer,
-    expand_env_vars: bool = True,
 ) -> None:
     """Validate data format.
 
@@ -963,7 +869,6 @@ def validate_yaml_with_jsonschema(
             to `rasa`.
         humanize_error: a function to convert a jsonschema.ValidationError into a
             human-readable error message. Defaults to `default_error_humanizer`.
-        expand_env_vars: Whether to expand environment variables in the file.
 
     Raises:
         YamlSyntaxException: if the yaml file is not valid.
@@ -981,11 +886,7 @@ def validate_yaml_with_jsonschema(
         # will include e.g. at which line an object was parsed. this is very
         # helpful when we validate files later on and want to point the user to the
         # right line
-        source_data = read_yaml(
-            yaml_file_content,
-            reader_type=["safe", "rt"],
-            expand_env_vars=expand_env_vars,
-        )
+        source_data = read_yaml(yaml_file_content, reader_type=["safe", "rt"])
     except (YAMLError, DuplicateKeyError) as e:
         raise YamlSyntaxException(underlying_yaml_exception=e)
 

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"