snowflake-cli 3.9.0__py3-none-any.whl → 3.10.0__py3-none-any.whl

snowflake/cli/_plugins/stage/diff.py

@@ -239,6 +239,7 @@ def sync_local_diff_with_stage(
     deploy_root_path: Path,
     diff_result: DiffResult,
     stage_full_path: str,
+    force_overwrite: bool = False,
 ):
     """
     Syncs a given local directory's contents with a Snowflake stage, including removing old files, and re-uploading modified and new files.
@@ -267,6 +268,7 @@ def sync_local_diff_with_stage(
             deploy_root_path=deploy_root_path,
             stage_paths=diff_result.only_local,
             role=role,
+            overwrite=force_overwrite,
         )
     except Exception as err:
         # Could be ProgrammingError or IntegrityError from SnowflakeCursor

snowflake/cli/_plugins/stage/manager.py

@@ -32,7 +32,7 @@ from tempfile import TemporaryDirectory
 from textwrap import dedent
 from typing import Deque, Dict, Generator, List, Optional, Union
 
-from click import ClickException, UsageError
+from click import UsageError
 from snowflake.cli._plugins.snowpark.package_utils import parse_requirements
 from snowflake.cli.api.commands.common import (
     OnErrorType,
@@ -41,6 +41,7 @@ from snowflake.cli.api.commands.common import (
 from snowflake.cli.api.commands.utils import parse_key_value_variables
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.constants import PYTHON_3_12
+from snowflake.cli.api.exceptions import CliError
 from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.project.util import VALID_IDENTIFIER_REGEX, to_string_literal
 from snowflake.cli.api.secure_path import SecurePath
@@ -58,7 +59,10 @@ log = logging.getLogger(__name__)
 
 
 UNQUOTED_FILE_URI_REGEX = r"[\w/*?\-.=&{}$#[\]\"\\!@%^+:]+"
+AT_PREFIX = "@"
 USER_STAGE_PREFIX = "@~"
+SNOW_PREFIX = "snow://"
+
 EXECUTE_SUPPORTED_FILES_FORMATS = (
     ".sql",
     ".py",
@@ -68,6 +72,17 @@ EXECUTE_SUPPORTED_FILES_FORMATS = (
 OMIT_FIRST = slice(1, None)
 STAGE_PATH_REGEX = rf"(?P<prefix>(@|{re.escape('snow://')}))?(?:(?P<first_qualifier>{VALID_IDENTIFIER_REGEX})\.)?(?:(?P<second_qualifier>{VALID_IDENTIFIER_REGEX})\.)?(?P<name>{VALID_IDENTIFIER_REGEX})/?(?P<directory>([^/]*/?)*)?"
 
+# Define supported VSTAGE resource types
+VSTAGE_RESOURCE_TYPE_REGEX = r"[a-zA-Z0-9\-]+"
+VSTAGE_PATH_REGEX = (
+    rf"(?P<prefix>{re.escape(SNOW_PREFIX)})"
+    rf"(?P<resource_type>{VSTAGE_RESOURCE_TYPE_REGEX})/"
+    rf"(?:(?P<first_qualifier>{VALID_IDENTIFIER_REGEX})\.)?"
+    rf"(?:(?P<second_qualifier>{VALID_IDENTIFIER_REGEX})\.)?"
+    rf"(?P<name>{VALID_IDENTIFIER_REGEX})/?"
+    rf"(?P<directory>([^/]*/?)*)?"
+)
+
 
 class InternalStageEncryptionType(Enum):
     SNOWFLAKE_FULL = "SNOWFLAKE_FULL"
@@ -80,6 +95,7 @@ class StagePathParts:
     stage: str
     stage_name: str
     is_directory: bool
+    is_vstage: bool = False
 
     @classmethod
     def get_directory(cls, stage_path: str) -> str:
@@ -97,15 +113,9 @@ class StagePathParts:
     def schema(self) -> str | None:
         raise NotImplementedError
 
-    def replace_stage_prefix(self, file_path: str) -> str:
-        raise NotImplementedError
-
     def add_stage_prefix(self, file_path: str) -> str:
         raise NotImplementedError
 
-    def get_directory_from_file_path(self, file_path: str) -> List[str]:
-        raise NotImplementedError
-
     def get_full_stage_path(self, path: str):
         if prefix := FQN.from_stage_path(self.stage).prefix:
             return prefix + "." + path
@@ -113,7 +123,7 @@ class StagePathParts:
 
     def get_standard_stage_path(self) -> str:
         path = self.get_full_stage_path(self.path)
-        return f"@{path}{'/'if self.is_directory and not path.endswith('/') else ''}"
+        return f"{AT_PREFIX}{path}{'/'if self.is_directory and not path.endswith('/') else ''}"
 
     def get_standard_stage_directory_path(self) -> str:
         path = self.get_standard_stage_path()
@@ -121,17 +131,6 @@ class StagePathParts:
             return path + "/"
         return path
 
-    def strip_stage_prefix(self, path: str):
-        raise NotImplementedError
-
-
-def _strip_standard_stage_prefix(path: str) -> str:
-    """Removes '@' or 'snow://' prefix from given string"""
-    for prefix in ["@", "snow://"]:
-        if path.startswith(prefix):
-            path = path.removeprefix(prefix)
-    return path
-
 
 @dataclass
 class DefaultStagePathParts(StagePathParts):
@@ -149,10 +148,10 @@ class DefaultStagePathParts(StagePathParts):
     def __init__(self, stage_path: str):
         match = re.fullmatch(STAGE_PATH_REGEX, stage_path)
         if match is None:
-            raise ClickException("Invalid stage path")
+            raise CliError("Invalid stage path")
         self.directory = match.group("directory")
         self._schema = match.group("second_qualifier") or match.group("first_qualifier")
-        self._prefix = match.group("prefix") or "@"
+        self._prefix = match.group("prefix") or AT_PREFIX
         self.stage = stage_path.removesuffix(self.directory).rstrip("/")
 
         stage_name = FQN.from_stage(self.stage).name
@@ -180,24 +179,47 @@ class DefaultStagePathParts(StagePathParts):
     def schema(self) -> str | None:
         return self._schema
 
-    def replace_stage_prefix(self, file_path: str) -> str:
-        file_path = _strip_standard_stage_prefix(file_path)
-        file_path_without_prefix = Path(file_path).parts[OMIT_FIRST]
-        return f"{self.stage}/{'/'.join(file_path_without_prefix)}"
-
-    def strip_stage_prefix(self, file_path: str) -> str:
-        file_path = _strip_standard_stage_prefix(file_path)
-        if file_path.startswith(self.stage_name):
-            return file_path[len(self.stage_name) :]
-        return file_path
-
     def add_stage_prefix(self, file_path: str) -> str:
         stage = self.stage.rstrip("/")
         return f"{stage}/{file_path.lstrip('/')}"
 
-    def get_directory_from_file_path(self, file_path: str) -> List[str]:
-        stage_path_length = len(Path(self.directory).parts)
-        return list(Path(file_path).parts[1 + stage_path_length : -1])
+
+@dataclass
+class VStagePathParts(StagePathParts):
+    def __init__(self, stage_path: str):
+        match = re.fullmatch(VSTAGE_PATH_REGEX, stage_path)
+        if match is None or not match.group("resource_type") or not match.group("name"):
+            raise CliError(f"Invalid vstage path: {stage_path}.")
+        self.resource_type = match.group("resource_type")
+        self.directory = match.group("directory")
+        self._schema = match.group("second_qualifier") or match.group("first_qualifier")
+        self._prefix = match.group("prefix")
+        self.stage = stage_path.removesuffix(self.directory).rstrip("/")
+        self.stage_name = self.stage.removeprefix(self._prefix)
+        self.is_directory = True if stage_path.endswith("/") else False
+        self.is_vstage = True
+
+    @property
+    def path(self) -> str:
+        return f"{self._prefix}{self.stage_name.rstrip('/')}/{self.directory}".rstrip(
+            "/"
+        )
+
+    @property
+    def full_path(self) -> str:
+        return f"{self._prefix}{self.stage_name.rstrip('/')}/{self.directory}".rstrip(
+            "/"
+        )
+
+    @property
+    def schema(self) -> str | None:
+        return self._schema
+
+    def add_stage_prefix(self, file_path: str) -> str:
+        return self.full_path
+
+    def get_standard_stage_path(self) -> str:
+        return self.full_path
 
 
 @dataclass
@@ -229,37 +251,29 @@ class UserStagePathParts(StagePathParts):
     def full_path(self) -> str:
         return f"{self.stage}/{self.directory}".rstrip("/")
 
-    def replace_stage_prefix(self, file_path: str) -> str:
-        if Path(file_path).parts[0] == self.stage_name:
-            return file_path
-        return f"{self.stage}/{file_path}"
-
     def add_stage_prefix(self, file_path: str) -> str:
         return f"{self.stage}/{file_path}"
 
-    def get_directory_from_file_path(self, file_path: str) -> List[str]:
-        stage_path_length = len(Path(self.directory).parts)
-        return list(Path(file_path).parts[stage_path_length:-1])
-
 
 class StageManager(SqlExecutionMixin):
     def __init__(self):
         super().__init__()
         self._python_exe_procedure = None
 
-    @staticmethod
-    def build_path(stage_path: str) -> StagePath:
+    def build_path(self, stage_path: Union[str, StagePath]) -> StagePath:
+        if isinstance(stage_path, StagePath):
+            return stage_path
         return StagePath.from_stage_str(stage_path)
 
     @staticmethod
     def get_standard_stage_prefix(name: str | FQN) -> str:
         if isinstance(name, FQN):
             name = name.identifier
-        # Handle embedded stages
-        if name.startswith("snow://") or name.startswith("@"):
+        # Handle vstages
+        if name.startswith(SNOW_PREFIX) or name.startswith(AT_PREFIX):
             return name
 
-        return f"@{name}"
+        return f"{AT_PREFIX}{name}"
 
     @staticmethod
     def get_stage_from_path(path: str):
@@ -275,7 +289,7 @@ class StageManager(SqlExecutionMixin):
             return name  # already quoted
 
         standard_name = StageManager.get_standard_stage_prefix(name)
-        if standard_name.startswith("@") and not re.fullmatch(
+        if standard_name.startswith(AT_PREFIX) and not re.fullmatch(
             r"@([\w./$])+", standard_name
         ):
             return to_string_literal(standard_name)
@@ -503,7 +517,7 @@ class StageManager(SqlExecutionMixin):
         destination_stage_path = StagePath.from_stage_str(destination_path)
 
         if destination_stage_path.is_user_stage():
-            raise ClickException(
+            raise CliError(
                 "Destination path cannot be a user stage. Please provide a named stage."
             )
 
@@ -534,11 +548,14 @@ class StageManager(SqlExecutionMixin):
         comment: Optional[str] = None,
         temporary: bool = False,
         encryption: InternalStageEncryptionType | None = None,
+        enable_directory: bool = False,
     ) -> SnowflakeCursor:
         temporary_str = "temporary " if temporary else ""
         query = f"create {temporary_str}stage if not exists {fqn.sql_identifier}"
         if encryption:
             query += f" encryption = (type = '{encryption.value}')"
+        if enable_directory:
+            query += f" directory = (enable = true)"
         if comment:
             query += f" comment='{comment}'"
         return self.execute_query(query)
@@ -572,7 +589,7 @@ class StageManager(SqlExecutionMixin):
 
         all_files_list = self._get_files_list_from_stage(stage_path.root_path())
         if not all_files_list:
-            raise ClickException(f"No files found on stage '{stage_path}'")
+            raise CliError(f"No files found on stage '{stage_path}'")
 
         all_files_with_stage_name_prefix = [
             stage_path_parts.get_directory(file) for file in all_files_list
@@ -584,7 +601,7 @@ class StageManager(SqlExecutionMixin):
         )
 
         if not filtered_file_list:
-            raise ClickException(f"No files matched pattern '{stage_path}'")
+            raise CliError(f"No files matched pattern '{stage_path}'")
 
         # sort filtered files in alphabetical order with directories at the end
         sorted_file_path_list = sorted(
@@ -678,7 +695,7 @@ class StageManager(SqlExecutionMixin):
             if filtered_files:
                 return filtered_files
             else:
-                raise ClickException(
+                raise CliError(
                     f"Invalid file extension, only {', '.join(EXECUTE_SUPPORTED_FILES_FORMATS)} files are allowed."
                 )
         # Filter with fnmatch if contains `*` or `?`
@@ -750,8 +767,15 @@ class StageManager(SqlExecutionMixin):
         stage_path = StageManager.get_standard_stage_prefix(stage_path)
         if stage_path.startswith(USER_STAGE_PREFIX):
             return UserStagePathParts(stage_path)
+        elif stage_path.startswith(SNOW_PREFIX):
+            return VStagePathParts(stage_path)
         return DefaultStagePathParts(stage_path)
 
+    def refresh(self, stage_name):
+        sql = f"ALTER STAGE {stage_name} REFRESH"
+        log.info("Refreshing stage %s", stage_name)
+        return self.execute_query(sql)
+
     def _check_for_requirements_file(self, stage_path: StagePath) -> List[str]:
         """Looks for requirements.txt file on stage."""
         current_dir = stage_path.parent if stage_path.is_file() else stage_path
@@ -800,7 +824,7 @@ class StageManager(SqlExecutionMixin):
     def _bootstrap_snowpark_execution_environment(self, stage_path: StagePath):
         """Prepares Snowpark session for executing Python code remotely."""
         if sys.version_info >= PYTHON_3_12:
-            raise ClickException(
+            raise CliError(
                 f"Executing Python files is not supported in Python >= 3.12. Current version: {sys.version}"
             )
 

snowflake/cli/_plugins/streamlit/streamlit_entity.py

@@ -18,7 +18,7 @@ from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.project.project_paths import bundle_root
 from snowflake.cli.api.project.schemas.entities.common import Identifier, PathMapping
 from snowflake.connector import ProgrammingError
-from snowflake.connector.cursor import SnowflakeCursor
+from snowflake.connector.cursor import DictCursor, SnowflakeCursor
 
 log = logging.getLogger(__name__)
 
@@ -102,7 +102,6 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
         if (
             experimental
             or GlobalFeatureFlag.ENABLE_STREAMLIT_VERSIONED_STAGE.is_enabled()
-            or GlobalFeatureFlag.ENABLE_STREAMLIT_EMBEDDED_STAGE.is_enabled()
         ):
             self._deploy_experimental(bundle_map=bundle_map, replace=replace)
         else:
@@ -123,7 +122,7 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
                 bundle_map=bundle_map,
                 prune=prune,
                 recursive=True,
-                stage_path=StageManager().stage_path_parts_from_str(stage_root),
+                stage_path_parts=StageManager().stage_path_parts_from_str(stage_root),
                 print_diff=True,
             )
 
@@ -136,7 +135,7 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
         return self.perform(EntityActions.GET_URL, action_context, *args, **kwargs)
 
     def describe(self) -> SnowflakeCursor:
-        return self._execute_query(self.get_describe_sql())
+        return self._execute_query(self.get_describe_sql(), cursor_class=DictCursor)
 
     def action_share(
         self, action_ctx: ActionContext, to_role: str, *args, **kwargs
@@ -146,13 +145,9 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
     def get_add_live_version_sql(
         self, schema: Optional[str] = None, database: Optional[str] = None
     ):
+        # this query unlike most others doesn't accept fqn wrapped in `IDENTIFIER('')`
         return f"ALTER STREAMLIT {self._get_identifier(schema,database)} ADD LIVE VERSION FROM LAST;"
 
-    def get_checkout_sql(
-        self, schema: Optional[str] = None, database: Optional[str] = None
-    ):
-        return f"ALTER STREAMLIT {self._get_identifier(schema,database)} CHECKOUT;"
-
     def get_deploy_sql(
         self,
         if_not_exists: bool = False,
@@ -172,7 +167,7 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
         else:
             query = "CREATE STREAMLIT"
 
-        query += f" {self._get_identifier(schema, database)}"
+        query += f" {self._get_sql_identifier(schema, database)}"
 
         if from_stage_name:
             query += f"\nROOT_LOCATION = '{from_stage_name}'"
@@ -207,13 +202,15 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
         return query + ";"
 
     def get_describe_sql(self) -> str:
-        return f"DESCRIBE STREAMLIT {self._get_identifier()};"
+        return f"DESCRIBE STREAMLIT {self._get_sql_identifier()};"
 
     def get_share_sql(self, to_role: str) -> str:
-        return f"GRANT USAGE ON STREAMLIT {self._get_identifier()} TO ROLE {to_role};"
+        return (
+            f"GRANT USAGE ON STREAMLIT {self._get_sql_identifier()} TO ROLE {to_role};"
+        )
 
     def get_execute_sql(self):
-        return f"EXECUTE STREAMLIT {self._get_identifier()}();"
+        return f"EXECUTE STREAMLIT {self._get_sql_identifier()}();"
 
     def get_usage_grant_sql(self, app_role: str, schema: Optional[str] = None) -> str:
         entity_id = self.entity_id
@@ -239,26 +236,15 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
             )
         )
         try:
-            if GlobalFeatureFlag.ENABLE_STREAMLIT_VERSIONED_STAGE.is_enabled():
-                self._execute_query(self.get_add_live_version_sql())
-            elif not GlobalFeatureFlag.ENABLE_STREAMLIT_NO_CHECKOUTS.is_enabled():
-                self._execute_query(self.get_checkout_sql())
+            self._execute_query(self.get_add_live_version_sql())
         except ProgrammingError as e:
-            if "Checkout already exists" in str(
-                e
-            ) or "There is already a live version" in str(e):
-                log.info("Checkout already exists, continuing")
+            if "There is already a live version" in str(e):
+                log.info("Live version already exists, continuing")
             else:
                 raise
 
-        embeded_stage_name = (
-            f"snow://streamlit/{self.model.fqn.using_connection(self._conn).identifier}"
-        )
-
-        if GlobalFeatureFlag.ENABLE_STREAMLIT_VERSIONED_STAGE.is_enabled():
-            stage_root = f"{embeded_stage_name}/versions/live"
-        else:
-            stage_root = f"{embeded_stage_name}/default_checkout"
+        stage_root = self.describe().fetchone()["live_version_location_uri"]
+        stage_path_parts = StageManager().stage_path_parts_from_str(stage_root)
 
         sync_deploy_root_with_stage(
             console=self._workspace_ctx.console,
@@ -266,6 +252,7 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
             bundle_map=bundle_map,
             prune=prune,
             recursive=True,
-            stage_path=StageManager().stage_path_parts_from_str(stage_root),
+            stage_path_parts=stage_path_parts,
             print_diff=True,
+            force_overwrite=True,  # files copied to streamlit vstage need to be overwritten
         )

snowflake/cli/api/artifacts/upload.py

@@ -30,7 +30,7 @@ def sync_artifacts_with_stage(
         bundle_map=bundle_map,
         prune=prune,
         recursive=True,
-        stage_path=stage_path_parts,
+        stage_path_parts=stage_path_parts,
         print_diff=True,
     )
     project_paths.clean_up_output()

snowflake/cli/api/cli_global_context.py

@@ -19,7 +19,7 @@ from contextvars import ContextVar
 from dataclasses import dataclass, field, replace
 from functools import wraps
 from pathlib import Path
-from typing import TYPE_CHECKING, Iterator, Optional
+from typing import TYPE_CHECKING, Iterator
 
 from snowflake.cli.api.connections import ConnectionContext, OpenConnectionCache
 from snowflake.cli.api.exceptions import MissingConfigurationError
@@ -31,7 +31,6 @@ from snowflake.connector import SnowflakeConnection
 if TYPE_CHECKING:
     from snowflake.cli.api.project.definition_manager import DefinitionManager
     from snowflake.cli.api.project.schemas.project_definition import ProjectDefinition
-    from snowflake.core import Root
 
 _CONNECTION_CACHE = OpenConnectionCache()
 
@@ -197,18 +196,10 @@ class _CliGlobalContextAccess:
     @property
     def _should_force_mute_intermediate_output(self) -> bool:
         """Computes whether cli_console output should be muted."""
-        return self._manager.output_format == OutputFormat.JSON
-
-    @property
-    def snow_api_root(
-        self,
-    ) -> Optional[Root]:
-        from snowflake.core import Root
-
-        if self.connection:
-            return Root(self.connection)
-        else:
-            return None
+        return (
+            self._manager.output_format.is_json
+            or self._manager.output_format == OutputFormat.CSV
+        )
 
     @property
     def enhanced_exit_codes(self) -> bool:

snowflake/cli/api/commands/decorators.py

@@ -53,6 +53,7 @@ from snowflake.cli.api.commands.flags import (
     SilentOption,
     TemporaryConnectionOption,
     TokenFilePathOption,
+    TokenOption,
     UserOption,
     VerboseOption,
     WarehouseOption,
@@ -279,6 +280,12 @@ GLOBAL_CONNECTION_OPTIONS = [
         annotation=Optional[str],
         default=MasterTokenOption,
     ),
+    inspect.Parameter(
+        "token",
+        inspect.Parameter.KEYWORD_ONLY,
+        annotation=Optional[str],
+        default=TokenOption,
+    ),
     inspect.Parameter(
         "token_file_path",
         inspect.Parameter.KEYWORD_ONLY,

snowflake/cli/api/commands/flags.py

@@ -212,6 +212,16 @@ MasterTokenOption = typer.Option(
     hidden=True,
 )
 
+
+TokenOption = typer.Option(
+    None,
+    "--token",
+    help="OAuth token to use when connecting to Snowflake.",
+    callback=_connection_callback("token"),
+    show_default=False,
+    rich_help_panel=_CONNECTION_SECTION,
+)
+
 TokenFilePathOption = typer.Option(
     None,
     "--token-file-path",
@@ -274,6 +284,7 @@ MfaPasscodeOption = typer.Option(
     rich_help_panel=_CONNECTION_SECTION,
 )
 
+
 EnableDiagOption = typer.Option(
     False,
     "--enable-diag",
@@ -435,6 +446,7 @@ OutputFormatOption = typer.Option(
     rich_help_panel=_CLI_BEHAVIOUR,
 )
 
+
 SilentOption = typer.Option(
     False,
     "--silent",

snowflake/cli/api/commands/snow_typer.py

@@ -46,6 +46,8 @@ from typer.core import TyperGroup
 
 log = logging.getLogger(__name__)
 
+PREVIEW_PREFIX = ""
+
 
 class SortedTyperGroup(TyperGroup):
     def list_commands(self, ctx: click.Context) -> List[str]:
@@ -92,6 +94,7 @@ class SnowTyper(typer.Typer):
         requires_connection: bool = False,
         is_enabled: Callable[[], bool] | None = None,
         require_warehouse: bool = False,
+        preview: bool = False,
         **kwargs,
     ):
         """
@@ -106,9 +109,18 @@ class SnowTyper(typer.Typer):
 
         def custom_command(command_callable):
             """Custom command wrapper similar to Typer.command."""
-            # Sanitize doc string which is used to create help in terminal
             command_callable.__doc__ = sanitize_for_terminal(command_callable.__doc__)
 
+            if preview and command_callable.__doc__:
+                if not command_callable.__doc__.strip().startswith(PREVIEW_PREFIX):
+                    command_callable.__doc__ = (
+                        f"{PREVIEW_PREFIX}{command_callable.__doc__.strip()}"
+                    )
+
+            if preview and "help" in kwargs and kwargs["help"]:
+                if not kwargs["help"].strip().startswith(PREVIEW_PREFIX):
+                    kwargs["help"] = f"{PREVIEW_PREFIX}{kwargs['help'].strip()}"
+
             if requires_connection:
                 command_callable = global_options_with_connection(command_callable)
             elif requires_global_options:
@@ -228,6 +240,7 @@ class SnowTyperFactory:
         short_help: Optional[str] = None,
         is_hidden: Optional[Callable[[], bool]] = None,
         deprecated: bool = False,
+        preview: bool = False,
         subcommand_metavar: Optional[str] = None,
     ):
         self.name = name
@@ -235,15 +248,21 @@ class SnowTyperFactory:
         self.short_help = short_help
         self.is_hidden = is_hidden
         self.deprecated = deprecated
+        self.preview = preview
         self.commands_to_register: List[SnowTyperCommandData] = []
         self.subapps_to_register: List[SnowTyperFactory] = []
         self.callbacks_to_register: List[Callable] = []
         self.subcommand_metavar = subcommand_metavar
 
     def create_instance(self) -> SnowTyper:
+        help_text = self.help
+        if self.preview and help_text:
+            if not help_text.strip().startswith(PREVIEW_PREFIX):
+                help_text = f"{PREVIEW_PREFIX}{help_text.strip()}"
+
         app = SnowTyper(
             name=self.name,
-            help=self.help,
+            help=help_text,
             short_help=self.short_help,
             hidden=self.is_hidden() if self.is_hidden else False,
             deprecated=self.deprecated,
@@ -251,6 +270,8 @@ class SnowTyperFactory:
         )
         # register commands
         for command in self.commands_to_register:
+            if self.preview and "preview" not in command.kwargs:
+                command.kwargs["preview"] = True
             app.command(*command.args, **command.kwargs)(command.func)
         # register callbacks
         for callback in self.callbacks_to_register:

snowflake/cli/api/config.py

@@ -55,6 +55,7 @@ CONNECTIONS_SECTION = "connections"
 CLI_SECTION = "cli"
 LOGS_SECTION = "logs"
 PLUGINS_SECTION = "plugins"
+IGNORE_NEW_VERSION_WARNING_KEY = "ignore_new_version_warning"
 
 LOGS_SECTION_PATH = [CLI_SECTION, LOGS_SECTION]
 PLUGINS_SECTION_PATH = [CLI_SECTION, PLUGINS_SECTION]
@@ -204,10 +205,12 @@ def _read_config_file():
 
 def _initialise_logs_section():
     with _config_file() as conf_file_cache:
-        if conf_file_cache.get(CLI_SECTION) is None:
-            conf_file_cache[CLI_SECTION] = _DEFAULT_CLI_CONFIG
-        if conf_file_cache[CLI_SECTION].get(LOGS_SECTION) is None:
-            conf_file_cache[CLI_SECTION][LOGS_SECTION] = _DEFAULT_LOGS_CONFIG
+        conf_file_cache[CLI_SECTION][LOGS_SECTION] = _DEFAULT_LOGS_CONFIG
+
+
+def _initialise_cli_section():
+    with _config_file() as conf_file_cache:
+        conf_file_cache[CLI_SECTION] = {IGNORE_NEW_VERSION_WARNING_KEY: False}
 
 
 def set_config_value(path: List[str], value: Any) -> None:
@@ -297,7 +300,7 @@ def get_config_value(*path, key: str, default: Optional[Any] = Empty) -> Any:
         return env_variable
     try:
         return get_config_section(*path)[key]
-    except (KeyError, NonExistentKey, MissingConfigOptionError):
+    except (KeyError, NonExistentKey, MissingConfigOptionError, ConfigSourceError):
         if default is not Empty:
             return default
         raise
@@ -321,6 +324,7 @@ def _initialise_config(config_file: Path) -> None:
     config_file = SecurePath(config_file)
     config_file.parent.mkdir(parents=True, exist_ok=True)
     config_file.touch()
+    _initialise_cli_section()
     _initialise_logs_section()
     log.info("Created Snowflake configuration file at %s", CONFIG_MANAGER.file_path)
 

snowflake/cli/api/connections.py

@@ -48,6 +48,7 @@ class ConnectionContext:
     private_key_file: Optional[str] = None
     warehouse: Optional[str] = None
     mfa_passcode: Optional[str] = None
+    token: Optional[str] = None
     enable_diag: Optional[bool] = False
     diag_log_path: Optional[Path] = None
     diag_allowlist_path: Optional[Path] = None