snowflake-cli 3.5.0__py3-none-any.whl → 3.7.0__py3-none-any.whl

snowflake/cli/api/commands/flags.py

@@ -32,6 +32,7 @@ from snowflake.cli.api.connections import ConnectionContext
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.output.formats import OutputFormat
+from snowflake.cli.api.secret import SecretType
 from snowflake.cli.api.stage_path import StagePath
 
 DEFAULT_CONTEXT_SETTINGS = {"help_option_names": ["--help", "-h"]}
@@ -214,7 +215,7 @@ MasterTokenOption = typer.Option(
 TokenFilePathOption = typer.Option(
     None,
     "--token-file-path",
-    help="Path to file with an OAuth token that should be used when connecting to Snowflake",
+    help="Path to file with an OAuth token to use when connecting to Snowflake.",
     callback=_connection_callback("token_file_path"),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
@@ -324,7 +325,7 @@ def _diag_log_allowlist_path_callback(path: str):
 DiagAllowlistPathOption: Path = typer.Option(
     None,
     "--diag-allowlist-path",
-    help="Path to a JSON file containing allowlist parameters.",
+    help="Path to a JSON file that contains allowlist parameters.",
     callback=_diag_log_allowlist_path_callback,
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
@@ -370,6 +371,17 @@ DebugOption = typer.Option(
     rich_help_panel=_CLI_BEHAVIOUR,
 )
 
+EnhancedExitCodesOption = typer.Option(
+    False,
+    "--enhanced-exit-codes",
+    help="Differentiate exit error codes based on failure type.",
+    callback=_context_callback("enhanced_exit_codes"),
+    is_flag=True,
+    rich_help_panel=_CLI_BEHAVIOUR,
+    is_eager=True,
+    envvar="SNOWFLAKE_ENHANCED_EXIT_CODES",
+)
+
 
 # If IfExistsOption, IfNotExistsOption, or ReplaceOption are used with names other than those in CREATE_MODE_OPTION_NAMES,
 # you must also override mutually_exclusive if you want to retain the validation that at most one of these flags is
@@ -411,9 +423,19 @@ OnErrorOption = typer.Option(
 
 NoInteractiveOption = typer.Option(False, "--no-interactive", help="Disable prompting.")
 
+PruneOption = OverrideableOption(
+    False,
+    "--prune",
+    help=f"Delete files that exist in the stage, but not in the local filesystem.",
+    show_default=False,
+)
+
 
-def entity_argument(entity_type: str) -> typer.Argument:
-    return typer.Argument(None, help=f"ID of {entity_type} entity.")
+def entity_argument(entity_type: str, required=False) -> typer.Argument:
+    _help = f"ID of {entity_type} entity."
+    if not required:
+        return typer.Argument(None, help=_help)
+    return typer.Argument(..., help=_help, show_default=False)
 
 
 def variables_option(description: str):
@@ -501,6 +523,15 @@ class IdentifierStagePathType(click.ParamType):
         return StagePath.from_stage_str(value)
 
 
+class SecretTypeParser(click.ParamType):
+    name = "TEXT"
+
+    def convert(self, value, param, ctx):
+        if not isinstance(value, SecretType):
+            return SecretType(value)
+        return value
+
+
 def identifier_argument(
     sf_object: str,
     example: str,

snowflake/cli/api/commands/snow_typer.py

@@ -31,7 +31,13 @@ from snowflake.cli.api.commands.execution_metadata import (
     ExecutionStatus,
 )
 from snowflake.cli.api.commands.flags import DEFAULT_CONTEXT_SETTINGS
-from snowflake.cli.api.exceptions import CommandReturnTypeError
+from snowflake.cli.api.exceptions import (
+    BaseCliError,
+    CliArgumentError,
+    CliError,
+    CliSqlError,
+    CommandReturnTypeError,
+)
 from snowflake.cli.api.output.types import CommandResult
 from snowflake.cli.api.sanitizers import sanitize_for_terminal
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
@@ -168,8 +174,20 @@ class SnowTyper(typer.Typer):
 
         log.debug("Executing command exception callback")
         log_command_execution_error(exception, execution)
+        exception = SnowTyper._cli_base_exception_migration_dispatcher(exception)
+        return exception
+
+    @staticmethod
+    def _cli_base_exception_migration_dispatcher(exception):
+        """Handler used for dispatching exception until migration completed."""
+        if isinstance(
+            exception, (BaseCliError, CliError, CliArgumentError, CliSqlError)
+        ):
+            return exception
+
         if isinstance(exception, DatabaseError):
-            return ClickException(exception.msg)
+            return CliSqlError(exception.msg)
+
         return exception
 
     @staticmethod

snowflake/cli/api/config.py

@@ -26,7 +26,7 @@ import tomlkit
 from click import ClickException
 from snowflake.cli.api.exceptions import (
     ConfigFileTooWidePermissionsError,
-    MissingConfiguration,
+    MissingConfigurationError,
     UnsupportedConfigSectionTypeError,
 )
 from snowflake.cli.api.secure_path import SecurePath
@@ -252,7 +252,9 @@ def get_connection_dict(connection_name: str) -> dict:
     try:
         return get_config_section(CONNECTIONS_SECTION, connection_name)
     except KeyError:
-        raise MissingConfiguration(f"Connection {connection_name} is not configured")
+        raise MissingConfigurationError(
+            f"Connection {connection_name} is not configured"
+        )
 
 
 def get_default_connection_name() -> str:
@@ -262,7 +264,7 @@ def get_default_connection_name() -> str:
 def get_default_connection_dict() -> dict:
     def_connection_name = get_default_connection_name()
     if not connection_exists(def_connection_name):
-        raise MissingConfiguration(
+        raise MissingConfigurationError(
             f"Couldn't find connection for default connection `{def_connection_name}`. "
             f"Specify connection name or configure default connection."
         )

snowflake/cli/api/constants.py

@@ -47,6 +47,7 @@ class ObjectType(Enum):
     NETWORK_RULE = ObjectNames("network-rule", "network rule", "network rules")
     NOTEBOOK = ObjectNames("notebook", "notebook", "notebooks")
     PROCEDURE = ObjectNames("procedure", "procedure", "procedures")
+    PROJECT = ObjectNames("project", "project", "projects")
     ROLE = ObjectNames("role", "role", "roles")
     SCHEMA = ObjectNames("schema", "schema", "schemas")
     SERVICE = ObjectNames("service", "service", "services")
@@ -77,6 +78,7 @@ OBJECT_TO_NAMES = {o.value.cli_name: o.value for o in ObjectType}
 UNSUPPORTED_OBJECTS = {
     ObjectType.APPLICATION.value.cli_name,
     ObjectType.APPLICATION_PACKAGE.value.cli_name,
+    ObjectType.PROJECT.value.cli_name,
 }
 SUPPORTED_OBJECTS = sorted(OBJECT_TO_NAMES.keys() - UNSUPPORTED_OBJECTS)
 

snowflake/cli/api/entities/utils.py

@@ -19,7 +19,10 @@ from snowflake.cli._plugins.stage.diff import (
     sync_local_diff_with_stage,
     to_stage_path,
 )
-from snowflake.cli._plugins.stage.manager import DefaultStagePathParts
+from snowflake.cli._plugins.stage.manager import (
+    StageManager,
+    StagePathParts,
+)
 from snowflake.cli._plugins.stage.utils import print_diff_to_console
 from snowflake.cli.api.artifacts.bundle_map import BundleMap
 from snowflake.cli.api.cli_global_context import get_cli_context, span
@@ -33,6 +36,7 @@ from snowflake.cli.api.exceptions import (
     NoWarehouseSelectedInSessionError,
     SnowflakeSQLExecutionError,
 )
+from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.metrics import CLICounterField
 from snowflake.cli.api.project.schemas.entities.common import PostDeployHook
 from snowflake.cli.api.rendering.sql_templates import (
@@ -79,12 +83,12 @@ def _get_stage_paths_to_sync(
 def sync_deploy_root_with_stage(
     console: AbstractConsole,
     deploy_root: Path,
-    package_name: str,
     bundle_map: BundleMap,
-    role: str,
     prune: bool,
     recursive: bool,
-    stage_path: DefaultStagePathParts,
+    stage_path: StagePathParts,
+    role: str | None = None,
+    package_name: str | None = None,
     local_paths_to_sync: List[Path] | None = None,
     print_diff: bool = True,
 ) -> DiffResult:
@@ -99,6 +103,8 @@ def sync_deploy_root_with_stage(
         recursive (bool): Whether to traverse directories recursively.
         stage_path (DefaultStagePathParts): stage path object.
 
+        package_name (str): supported for Native App compatibility. Should be None out of Native App context.
+
         local_paths_to_sync (List[Path], optional): List of local paths to sync. Defaults to None to sync all
         local paths. Note that providing an empty list here is equivalent to None.
         print_diff (bool): Whether to print the diff between the local files and the remote stage. Defaults to True
@@ -106,17 +112,24 @@ def sync_deploy_root_with_stage(
     Returns:
         A `DiffResult` instance describing the changes that were performed.
     """
-    sql_facade = get_snowflake_facade()
-    schema = stage_path.schema
-    stage_fqn = stage_path.stage
-    # Does a stage already exist within the application package, or we need to create one?
-    # Using "if not exists" should take care of either case.
-    console.step(
-        f"Checking if stage {stage_fqn} exists, or creating a new one if none exists."
-    )
-    if not sql_facade.stage_exists(stage_fqn):
-        sql_facade.create_schema(schema, database=package_name)
-        sql_facade.create_stage(stage_fqn)
+    if not package_name:
+        # ensure stage exists
+        stage_fqn = FQN.from_stage(stage_path.stage)
+        console.step(f"Creating stage {stage_fqn} if not exists.")
+        StageManager().create(fqn=stage_fqn)
+    else:
+        # ensure stage exists - nativeapp behavior
+        sql_facade = get_snowflake_facade()
+        schema = stage_path.schema
+        stage_fqn = stage_path.stage
+        # Does a stage already exist within the application package, or we need to create one?
+        # Using "if not exists" should take care of either case.
+        console.step(
+            f"Checking if stage {stage_fqn} exists, or creating a new one if none exists."
+        )
+        if not sql_facade.stage_exists(stage_fqn):
+            sql_facade.create_schema(schema, database=package_name)
+            sql_facade.create_stage(stage_fqn)
 
     # Perform a diff operation and display results to the user for informational purposes
     if print_diff:
@@ -178,7 +191,7 @@ def sync_deploy_root_with_stage(
     if print_diff:
         print_diff_to_console(diff, bundle_map)
 
-    # Upload diff-ed files to application package stage
+    # Upload diff-ed files to the stage
     if diff.has_changes():
         console.step(
             "Updating the Snowflake stage from your local %s directory."

snowflake/cli/api/errno.py

@@ -78,6 +78,7 @@ MAX_VERSIONS_IN_RELEASE_CHANNEL_REACHED = 512004
 MAX_UNBOUND_VERSIONS_REACHED = 512023
 CANNOT_DEREGISTER_VERSION_ASSOCIATED_WITH_CHANNEL = 512021
 TARGET_ACCOUNT_USED_BY_OTHER_RELEASE_DIRECTIVE = 93091
+CANNOT_SET_DEBUG_MODE_WITH_MANIFEST_VERSION = 93362
 
 
 ERR_JAVASCRIPT_EXECUTION = 100132

snowflake/cli/api/exceptions.py

@@ -22,46 +22,87 @@ from snowflake.cli.api.constants import ObjectType
 from snowflake.connector.compat import IS_WINDOWS
 
 
-class EnvironmentVariableNotFoundError(ClickException):
+class BaseCliError(ClickException):
+    """Base Cli Exception.
+
+    0 Everything ran smoothly.
+    1 Something went wrong with the client.
+    2 Something went wrong with command line arguments.
+    3 Cli could not connect to server.
+    4 Cli could not communicate properly with server.
+    5 The enhanced_exit_codes parameter was set and Cli exited because of error.
+    """
+
+    def __init__(self, *args, **kwargs):
+        from snowflake.cli.api.cli_global_context import get_cli_context
+
+        if not get_cli_context().enhanced_exit_codes:
+            self.exit_code = kwargs.pop("exit_code", 1)
+        super().__init__(*args, **kwargs)
+
+
+class CliError(BaseCliError):
+    """Generic Cli Error - to be used in favour of ClickException."""
+
+    exit_code = 1
+
+
+class CliArgumentError(BaseCliError):
+    exit_code = 2
+
+
+class CliConnectionError(BaseCliError):
+    exit_code = 3
+
+
+class CliCommunicationError(BaseCliError):
+    exit_code = 4
+
+
+class CliSqlError(BaseCliError):
+    exit_code = 5
+
+
+class EnvironmentVariableNotFoundError(CliError):
     def __init__(self, env_variable_name: str):
         super().__init__(f"Environment variable {env_variable_name} not found")
 
 
-class MissingConfiguration(ClickException):
+class MissingConfigurationError(CliError):
     pass
 
 
-class CycleDetectedError(ClickException):
+class CycleDetectedError(CliError):
     pass
 
 
-class InvalidTemplate(ClickException):
+class InvalidTemplateError(CliError):
     pass
 
 
-class InvalidConnectionConfiguration(ClickException):
+class InvalidConnectionConfigurationError(CliError):
     def format_message(self):
         return f"Invalid connection configuration. {self.message}"
 
 
-class InvalidLogsConfiguration(ClickException):
+class InvalidLogsConfigurationError(CliError):
     def format_message(self):
         return f"Invalid logs configuration. {self.message}"
 
 
-class InvalidPluginConfiguration(ClickException):
+class InvalidPluginConfigurationError(CliError):
     def format_message(self):
         return f"Invalid plugin configuration. {self.message}"
 
 
-class PluginNotInstalledError(ClickException):
+class PluginNotInstalledError(CliError):
     def __init__(self, plugin_name, installed_plugins: List[str]):
         super().__init__(
             f"Plugin {plugin_name} is not installed. Available plugins: {', '.join(installed_plugins)}."
         )
 
 
-class SnowflakeConnectionError(ClickException):
+class SnowflakeConnectionError(CliError):
     def __init__(self, snowflake_err: Exception):
         super().__init__(f"Could not connect to Snowflake. Reason: {snowflake_err}")
 
@@ -71,17 +112,17 @@ class UnsupportedConfigSectionTypeError(Exception):
         super().__init__(f"Unsupported configuration section type {section_type}")
 
 
-class OutputDataTypeError(ClickException):
+class OutputDataTypeError(CliError):
     def __init__(self, got_type: type, expected_type: type):
         super().__init__(f"Got {got_type} type but expected {expected_type}")
 
 
-class CommandReturnTypeError(ClickException):
+class CommandReturnTypeError(CliError):
     def __init__(self, got_type: type):
         super().__init__(f"Commands have to return OutputData type, but got {got_type}")
 
 
-class SnowflakeSQLExecutionError(ClickException):
+class SnowflakeSQLExecutionError(CliError):
     """
     Could not successfully execute the Snowflake SQL statements.
     """
@@ -95,7 +136,7 @@ class SnowflakeSQLExecutionError(ClickException):
         )
 
 
-class ObjectAlreadyExistsError(ClickException):
+class ObjectAlreadyExistsError(CliError):
     def __init__(
         self,
         object_type: ObjectType,
@@ -108,45 +149,45 @@ class ObjectAlreadyExistsError(ClickException):
         super().__init__(msg)
 
 
-class NoProjectDefinitionError(ClickException):
+class NoProjectDefinitionError(CliError):
     def __init__(self, project_type: str, project_root: str | Path):
         super().__init__(
             f"No {project_type} project definition found in {project_root}"
         )
 
 
-class InvalidProjectDefinitionVersionError(ClickException):
+class InvalidProjectDefinitionVersionError(CliError):
     def __init__(self, expected_version: str, actual_version: str):
         super().__init__(
             f"This command only supports definition version {expected_version}, got {actual_version}."
         )
 
 
-class InvalidSchemaError(ClickException):
+class InvalidSchemaError(CliError):
     def __init__(self, schema: str):
         super().__init__(f"Invalid schema {schema}")
 
 
-class SecretsWithoutExternalAccessIntegrationError(ClickException):
+class SecretsWithoutExternalAccessIntegrationError(CliError):
     def __init__(self, object_name: str):
         super().__init__(
             f"{object_name} defined with secrets but without external integration."
         )
 
 
-class FileTooLargeError(ClickException):
+class FileTooLargeError(CliError):
     def __init__(self, path: Path, size_limit_in_kb: int):
         super().__init__(
             f"File {path} is too large (size limit: {size_limit_in_kb} KB)"
         )
 
 
-class DirectoryIsNotEmptyError(ClickException):
+class DirectoryIsNotEmptyError(CliError):
     def __init__(self, path: Path):
         super().__init__(f"Directory '{path}' is not empty")
 
 
-class ConfigFileTooWidePermissionsError(ClickException):
+class ConfigFileTooWidePermissionsError(CliError):
     def __init__(self, path: Path):
         change_permissons_command = (
             f'icacls "{path}" /deny <USER_ID>:F'
@@ -162,26 +203,26 @@ class ConfigFileTooWidePermissionsError(ClickException):
         super().__init__(msg)
 
 
-class DatabaseNotProvidedError(ClickException):
+class DatabaseNotProvidedError(CliError):
     def __init__(self):
         super().__init__(
             "Database not specified. Please update connection to add `database` parameter, or re-run command using `--database` option. Use `snow connection list` to list existing connections."
         )
 
 
-class SchemaNotProvidedError(ClickException):
+class SchemaNotProvidedError(CliError):
     def __init__(self):
         super().__init__(
             "Schema not specified. Please update connection to add `schema` parameter, or re-run command using `--schema` option. Use `snow connection list` to list existing connections."
         )
 
 
-class FQNNameError(ClickException):
+class FQNNameError(CliError):
     def __init__(self, name: str):
         super().__init__(f"Specified name '{name}' is not valid name.")
 
 
-class FQNInconsistencyError(ClickException):
+class FQNInconsistencyError(CliError):
     def __init__(self, part: str, name: str):
         super().__init__(
             f"{part.capitalize()} provided but name '{name}' is fully qualified name."
@@ -206,7 +247,7 @@ class UnmetParametersError(UsageError):
         )
 
 
-class NoWarehouseSelectedInSessionError(ClickException):
+class NoWarehouseSelectedInSessionError(CliError):
     def __init__(self, msg: str):
         super().__init__(
             "Received the following error message while executing SQL statement:\n"
@@ -215,7 +256,7 @@ class NoWarehouseSelectedInSessionError(ClickException):
         )
 
 
-class DoesNotExistOrUnauthorizedError(ClickException):
+class DoesNotExistOrUnauthorizedError(CliError):
     def __init__(self, msg: str):
         super().__init__(
             "Received the following error message while executing SQL statement:\n"
@@ -224,7 +265,7 @@ class DoesNotExistOrUnauthorizedError(ClickException):
         )
 
 
-class CouldNotUseObjectError(ClickException):
+class CouldNotUseObjectError(CliError):
     def __init__(self, object_type: ObjectType, name: str):
         super().__init__(
             f"Could not use {object_type} {name}. Object does not exist, or operation cannot be performed."
@@ -236,3 +277,10 @@ class ShowSpecificObjectMultipleRowsError(RuntimeError):
         super().__init__(
             f"Received multiple rows from result of SQL statement: {show_obj_query}. Usage of 'show_specific_object' may not be properly scoped."
         )
+
+
+class CouldNotSetKeyPairError(CliError):
+    def __init__(self):
+        super().__init__(
+            "The public key is set already. Use the rotate command instead."
+        )

snowflake/cli/api/feature_flags.py

@@ -68,3 +68,4 @@ class FeatureFlag(FeatureFlagMixin):
     )
     ENABLE_SNOWPARK_GLOB_SUPPORT = BooleanFlag("ENABLE_SNOWPARK_GLOB_SUPPORT", False)
     ENABLE_SPCS_SERVICE_EVENTS = BooleanFlag("ENABLE_SPCS_SERVICE_EVENTS", False)
+    ENABLE_AUTH_KEYPAIR = BooleanFlag("ENABLE_AUTH_KEYPAIR", False)

snowflake/cli/api/identifiers.py

@@ -122,6 +122,8 @@ class FQN:
         name = stage
         if stage.startswith("@"):
             name = stage[1:]
+        if stage.startswith("snow://"):
+            name = stage[7:]
         if stage.startswith("~"):
             return cls(name="~", database=None, schema=None)
         return cls.from_string(name)

snowflake/cli/api/plugins/plugin_config.py

@@ -25,7 +25,7 @@ from snowflake.cli.api.config import (
     get_config_value,
     get_plugins_config,
 )
-from snowflake.cli.api.exceptions import InvalidPluginConfiguration
+from snowflake.cli.api.exceptions import InvalidPluginConfigurationError
 
 
 @dataclass
@@ -66,6 +66,6 @@ class PluginConfigProvider:
 
 def _assert_value_is_bool(value, *, value_name: str, plugin_name: str) -> None:
     if type(value) is not bool:
-        raise InvalidPluginConfiguration(
+        raise InvalidPluginConfigurationError(
             f'[{plugin_name}]: "{value_name}" must be a boolean'
         )

snowflake/cli/api/project/schemas/template.py

@@ -19,7 +19,7 @@ from typing import Any, List, Literal, Optional, Union
 import typer
 from click import ClickException
 from pydantic import BaseModel, Field
-from snowflake.cli.api.exceptions import InvalidTemplate
+from snowflake.cli.api.exceptions import InvalidTemplateError
 from snowflake.cli.api.secure_path import SecurePath
 
 
@@ -68,10 +68,10 @@ class Template(BaseModel):
         for path_in_template in self.files_to_render:
             full_path = template_root / path_in_template
             if not full_path.exists():
-                raise InvalidTemplate(
+                raise InvalidTemplateError(
                     f"[files_to_render] contains not-existing file: {path_in_template}"
                 )
             if full_path.is_dir():
-                raise InvalidTemplate(
+                raise InvalidTemplateError(
                     f"[files_to_render] contains a dictionary: {path_in_template}"
                 )

snowflake/cli/api/rendering/project_templates.py

@@ -24,7 +24,7 @@ from jinja2 import (
     UndefinedError,
     loaders,
 )
-from snowflake.cli.api.exceptions import InvalidTemplate
+from snowflake.cli.api.exceptions import InvalidTemplateError
 from snowflake.cli.api.rendering.jinja import IgnoreAttrEnvironment, env_bootstrap
 from snowflake.cli.api.secure_path import SecurePath
 
@@ -90,9 +90,9 @@ def render_template_files(
             full_path = template_root / path
             full_path.write_text(rendered_result)
         except TemplateSyntaxError as err:
-            raise InvalidTemplate(
+            raise InvalidTemplateError(
                 f"Invalid template syntax in line {err.lineno} of file {path}:\n"
                 f"{err.message}"
             )
         except UndefinedError as err:
-            raise InvalidTemplate(err.message)
+            raise InvalidTemplateError(err.message)

snowflake/cli/api/rendering/sql_templates.py

@@ -20,7 +20,7 @@ from click import ClickException
 from jinja2 import Environment, StrictUndefined, loaders, meta
 from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.console.console import cli_console
-from snowflake.cli.api.exceptions import InvalidTemplate
+from snowflake.cli.api.exceptions import InvalidTemplateError
 from snowflake.cli.api.metrics import CLICounterField
 from snowflake.cli.api.rendering.jinja import (
     CONTEXT_KEY,
@@ -72,7 +72,7 @@ def choose_sql_jinja_env_based_on_template_syntax(
     has_new_syntax = _does_template_have_env_syntax(new_syntax_env, template_content)
     reference_name_str = f" in {reference_name}" if reference_name else ""
     if has_old_syntax and has_new_syntax:
-        raise InvalidTemplate(
+        raise InvalidTemplateError(
             f"The SQL query{reference_name_str} mixes {_OLD_SQL_TEMPLATE_START} ... {_OLD_SQL_TEMPLATE_END} syntax"
             f" and {_SQL_TEMPLATE_START} ... {_SQL_TEMPLATE_END} syntax."
         )

snowflake/cli/api/rest_api.py

@@ -155,9 +155,8 @@ class RestApi:
             raise SchemaNotDefinedException(
                 "Schema not defined in connection. Please try again with `--schema` flag."
             )
-        # temporarily disable this check due to an issue on server side: SNOW-1747450
-        # if not self._schema_exists(db_name=db, schema_name=schema):
-        #     raise SchemaNotExistsException(f"Schema '{schema}' does not exist.")
+        if not self._schema_exists(db_name=db, schema_name=schema):
+            raise SchemaNotExistsException(f"Schema '{schema}' does not exist.")
         if self.get_endpoint_exists(
             url := f"{SF_REST_API_URL_PREFIX}/databases/{self.conn.database}/schemas/{self.conn.schema}/{plural_object_type}/"
         ):

snowflake/cli/{_app → api}/secret.py

@@ -5,5 +5,8 @@ class SecretType:
     def __repr__(self):
         return "SecretType(***)"
 
-    def __str___(self):
+    def __str__(self):
         return "***"
+
+    def __bool__(self):
+        return self.value is not None and self.value != ""