snowflake-cli 3.13.1__py3-none-any.whl → 3.15.0__py3-none-any.whl

snowflake/cli/_plugins/dcm/utils.py

@@ -0,0 +1,88 @@
+# Copyright (c) 2024 Snowflake Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import json
+import os
+from functools import wraps
+from pathlib import Path
+from typing import Any
+
+from snowflake.cli._plugins.dcm.reporters import RefreshReporter, TestReporter
+from snowflake.cli.api.output.types import EmptyResult
+
+
+class FakeCursor:
+    def __init__(self, data: Any):
+        self._data = data
+        self._fetched = False
+
+    def fetchone(self):
+        if self._fetched:
+            return None
+        self._fetched = True
+        return (json.dumps(self._data),)
+
+
+def _get_debug_file_number():
+    dcm_debug = os.environ.get("DCM_DEBUG")
+    if dcm_debug:
+        try:
+            return int(dcm_debug)
+        except ValueError:
+            return None
+    return None
+
+
+def _load_debug_data(command_name: str, file_number: int):
+    results_dir = Path.cwd() / "results"
+
+    debug_file = results_dir / f"{command_name}{file_number}.json"
+
+    if not debug_file.exists():
+        raise FileNotFoundError(f"Debug file not found: {debug_file}")
+
+    with open(debug_file, "r") as f:
+        data = json.load(f)
+
+    if isinstance(data, list) and len(data) > 0:
+        if command_name in ("test", "refresh", "analyze"):
+            data = data[0]
+
+    return data
+
+
+def mock_dcm_response(command_name: str):
+    # testing utility to test different reporting styles on mocked responses without touching the backend
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any):
+            file_number = _get_debug_file_number()
+            if file_number is None:
+                return func(*args, **kwargs)
+
+            actual_command = "plan" if command_name == "deploy" else command_name
+            data = _load_debug_data(actual_command, file_number)
+
+            if data is None:
+                return func(*args, **kwargs)
+
+            cursor = FakeCursor(data)
+            reporter_mapping = {"refresh": RefreshReporter, "test": TestReporter}
+
+            reporter = reporter_mapping[command_name]()
+            reporter.process(cursor)
+            return EmptyResult()
+
+        return wrapper
+
+    return decorator

snowflake/cli/_plugins/git/manager.py

@@ -14,6 +14,7 @@
 
 from __future__ import annotations
 
+import re
 from pathlib import PurePosixPath
 from textwrap import dedent
 
@@ -69,6 +70,16 @@ class GitStagePathParts(StagePathParts):
 
 
 class GitManager(StageManager):
+    """
+    Git stage manager utilities.
+
+    The `_QUOTED_OR_TOKEN` regex matches either a quoted span (double quotes
+    included) or a run of non-slash characters. We use it to tokenize git stage
+    paths while preserving quoted repo or branch names that may contain slashes.
+    """
+
+    _QUOTED_OR_TOKEN = re.compile(r'"[^"]*"|[^/]+')
+
     @staticmethod
     def build_path(stage_path: str) -> StagePathParts:
         return StagePath.from_git_str(stage_path)
@@ -114,32 +125,23 @@ class GitManager(StageManager):
 
     @staticmethod
     def split_git_path(path: str):
-        # Check if path contains quotes and split it accordingly
-        if '/"' in path and '"/' in path:
-            if path.count('"') > 2:
+        match path.count('"'):
+            case 0:
+                return GitManager._split_path_without_empty_parts(path)
+            case 2 | 4:
+                tokens = GitManager._QUOTED_OR_TOKEN.findall(path)
+            case _:
                 raise UsageError(
-                    f'Invalid string {path}, too much " in path, expected 2.'
+                    f'Invalid path "{path}": expected 0, 2, or 4 double quotes.'
                 )
 
-            path_parts = path.split('"')
-            before_quoted_part = GitManager._split_path_without_empty_parts(
-                path_parts[0]
-            )
-
-            if path_parts[2] == "/":
-                after_quoted_part = []
+        parts = []
+        for token in tokens:
+            if token.startswith('"') and token.endswith('"'):
+                parts.append(token)
             else:
-                after_quoted_part = GitManager._split_path_without_empty_parts(
-                    path_parts[2]
-                )
-
-            return [
-                *before_quoted_part,
-                f'"{path_parts[1]}"',
-                *after_quoted_part,
-            ]
-        else:
-            return GitManager._split_path_without_empty_parts(path)
+                parts.extend(GitManager._split_path_without_empty_parts(token))
+        return parts
 
     @staticmethod
     def _split_path_without_empty_parts(path: str):

snowflake/cli/_plugins/object/command_aliases.py

@@ -27,6 +27,7 @@ from snowflake.cli._plugins.object.commands import (
     scope_option,  # noqa: F401
     terse_option_,
 )
+from snowflake.cli.api.commands.flags import IfExistsOption
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
 from snowflake.cli.api.constants import ObjectType
 from snowflake.cli.api.identifiers import FQN
@@ -90,10 +91,15 @@ def add_object_command_aliases(
     if "drop" not in ommit_commands:
 
         @app.command("drop", requires_connection=True)
-        def drop_cmd(name: FQN = name_argument, **options):
+        def drop_cmd(
+            name: FQN = name_argument,
+            if_exists: bool = IfExistsOption(),
+            **options,
+        ):
             return drop(
                 object_type=object_type.value.cli_name,
                 object_name=name,
+                if_exists=if_exists,
                 **options,
             )
 

snowflake/cli/_plugins/object/commands.py

@@ -21,6 +21,7 @@ from click import ClickException
 from snowflake.cli._plugins.object.manager import ObjectManager
 from snowflake.cli.api.commands.flags import (
     IdentifierType,
+    IfExistsOption,
     IfNotExistsOption,
     ReplaceOption,
     like_option,
@@ -148,8 +149,17 @@ def list_(
     help=f"Drops Snowflake object of given name and type. {SUPPORTED_TYPES_MSG}",
     requires_connection=True,
 )
-def drop(object_type: str = ObjectArgument, object_name: FQN = NameArgument, **options):
-    return QueryResult(ObjectManager().drop(object_type=object_type, fqn=object_name))
+def drop(
+    object_type: str = ObjectArgument,
+    object_name: FQN = NameArgument,
+    if_exists: bool = IfExistsOption(),
+    **options,
+):
+    return QueryResult(
+        ObjectManager().drop(
+            object_type=object_type, fqn=object_name, if_exists=if_exists
+        )
+    )
 
 
 # Image repository is the only supported object that does not have a DESCRIBE command.

snowflake/cli/_plugins/object/manager.py

@@ -65,9 +65,14 @@ class ObjectManager(SqlExecutionMixin):
             query += f" limit {limit}"
         return self.execute_query(query, **kwargs)
 
-    def drop(self, *, object_type: str, fqn: FQN) -> SnowflakeCursor:
+    def drop(
+        self, *, object_type: str, fqn: FQN, if_exists: bool = False
+    ) -> SnowflakeCursor:
         object_name = _get_object_names(object_type).sf_name
-        return self.execute_query(f"drop {object_name} {fqn.sql_identifier}")
+        if_exists_clause = " if exists" if if_exists else ""
+        return self.execute_query(
+            f"drop {object_name}{if_exists_clause} {fqn.sql_identifier}"
+        )
 
     def describe(self, *, object_type: str, fqn: FQN, **kwargs):
         # Image repository is the only supported object that does not have a DESCRIBE command.

snowflake/cli/_plugins/snowpark/commands.py

@@ -71,6 +71,7 @@ from snowflake.cli.api.commands.decorators import (
 )
 from snowflake.cli.api.commands.flags import (
     ForceReplaceOption,
+    IfExistsOption,
     PruneOption,
     ReplaceOption,
     execution_identifier_argument,
@@ -462,10 +463,16 @@ def list_(
 def drop(
     object_type: SnowparkObject = ObjectTypeArgument,
     identifier: FQN = IdentifierArgument,
+    if_exists: bool = IfExistsOption(),
     **options,
 ):
     """Drop procedure or function."""
-    return object_drop(object_type=object_type.value, object_name=identifier, **options)
+    return object_drop(
+        object_type=object_type.value,
+        object_name=identifier,
+        if_exists=if_exists,
+        **options,
+    )
 
 
 @app.command("describe", requires_connection=True)

snowflake/cli/_plugins/snowpark/package/commands.py

@@ -183,7 +183,7 @@ def package_create(
                 f"""
                 The package {name} is successfully created, but depends on the following
                 Anaconda libraries. They need to be included in project requirements,
-                as their are not included in .zip.
+                as they are not included in the .zip.
                 """
             )
             message += "\n".join(

snowflake/cli/_plugins/streamlit/commands.py

@@ -127,9 +127,17 @@ def _default_file_callback(param_name: str):
     return _check_file_exists_if_not_default
 
 
+LegacyOption = typer.Option(
+    False,
+    "--legacy",
+    help="Use legacy ROOT_LOCATION SQL syntax.",
+    is_flag=True,
+)
+
+
 @app.command("deploy", requires_connection=True)
 @with_project_definition()
-@with_experimental_behaviour()
+@with_experimental_behaviour()  # Kept for backward compatibility
 def streamlit_deploy(
     replace: bool = ReplaceOption(
         help="Replaces the Streamlit app if it already exists. It only uploads new and overwrites existing files, "
@@ -138,16 +146,27 @@ def streamlit_deploy(
     prune: bool = PruneOption(),
     entity_id: str = entity_argument("streamlit"),
     open_: bool = OpenOption,
+    legacy: bool = LegacyOption,
     **options,
 ) -> CommandResult:
     """
     Deploys a Streamlit app defined in the project definition file (snowflake.yml). By default, the command uploads
-    environment.yml and any other pages or folders, if present. If you don’t specify a stage name, the `streamlit`
+    environment.yml and any other pages or folders, if present. If you don't specify a stage name, the `streamlit`
     stage is used. If the specified stage does not exist, the command creates it. If multiple Streamlits are defined
     in snowflake.yml and no entity_id is provided then command will raise an error.
     """
 
     cli_context = get_cli_context()
+    workspace_ctx = _get_current_workspace_context()
+
+    # Handle deprecated --experimental flag for backward compatibility
+    if options.get("experimental"):
+        workspace_ctx.console.warning(
+            "[Deprecation] The --experimental flag is deprecated. "
+            "Versioned deployment is now the default behavior. "
+            "This flag will be removed in a future version."
+        )
+
     pd = cli_context.project_definition
     if not pd.meets_version_requirement("2"):
         if not pd.streamlit:
@@ -163,7 +182,7 @@ def streamlit_deploy(
             project_definition=pd,
             entity_type=ObjectType.STREAMLIT.value.cli_name,
         ),
-        workspace_ctx=_get_current_workspace_context(),
+        workspace_ctx=workspace_ctx,
     )
 
     url = streamlit.perform(
@@ -173,7 +192,7 @@ def streamlit_deploy(
         ),
         _open=open_,
         replace=replace,
-        experimental=options.get("experimental"),
+        legacy=legacy,
         prune=prune,
     )
 

snowflake/cli/_plugins/streamlit/streamlit_entity.py

@@ -15,7 +15,7 @@ from snowflake.cli._plugins.workspace.context import ActionContext
 from snowflake.cli.api.artifacts.bundle_map import BundleMap
 from snowflake.cli.api.entities.common import EntityBase
 from snowflake.cli.api.entities.utils import EntityActions, sync_deploy_root_with_stage
-from snowflake.cli.api.feature_flags import FeatureFlag as GlobalFeatureFlag
+from snowflake.cli.api.exceptions import CliError
 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
@@ -66,15 +66,20 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
             self._conn, f"/#/streamlit-apps/{name.url_identifier}"
         )
 
-    def _is_spcs_runtime_v2_mode(self, experimental: bool = False) -> bool:
+    def _is_spcs_runtime_v2_mode(self) -> bool:
         """Check if SPCS runtime v2 mode is enabled."""
         return (
-            experimental
-            and self.model.runtime_name == SPCS_RUNTIME_V2_NAME
-            and self.model.compute_pool
+            self.model.runtime_name == SPCS_RUNTIME_V2_NAME and self.model.compute_pool
         )
 
     def bundle(self, output_dir: Optional[Path] = None) -> BundleMap:
+        artifacts = list(self._entity_model.artifacts or [])
+
+        # Ensure main_file is included in artifacts
+        main_file = self._entity_model.main_file
+        if main_file and not any(artifact.src == main_file for artifact in artifacts):
+            artifacts.insert(0, PathMapping(src=main_file))
+
         return build_bundle(
             self.root,
             output_dir or bundle_root(self.root, "streamlit") / self.entity_id,
@@ -82,7 +87,7 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
                 PathMapping(
                     src=artifact.src, dest=artifact.dest, processors=artifact.processors
                 )
-                for artifact in self._entity_model.artifacts
+                for artifact in artifacts
             ],
         )
 
@@ -93,7 +98,7 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
         replace: bool,
         prune: bool = False,
         bundle_map: Optional[BundleMap] = None,
-        experimental: bool = False,
+        legacy: bool = False,
         *args,
         **kwargs,
     ):
@@ -104,49 +109,40 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
 
         console = self._workspace_ctx.console
         console.step(f"Checking if object exists")
-        if self._object_exists() and not replace:
+        object_exists = self._object_exists()
+
+        if object_exists and not replace:
             raise ClickException(
                 f"Streamlit {self.model.fqn.sql_identifier} already exists. Use 'replace' option to overwrite."
             )
 
-        if (
-            experimental
-            or GlobalFeatureFlag.ENABLE_STREAMLIT_VERSIONED_STAGE.is_enabled()
-        ):
-            self._deploy_experimental(bundle_map=bundle_map, replace=replace)
-        else:
-            console.step(f"Uploading artifacts to stage {self.model.stage}")
-
-            # We use a static method from StageManager here, but maybe this logic could be implemented elswhere, as we implement entities?
-            name = (
-                self.model.identifier.name
-                if isinstance(self.model.identifier, Identifier)
-                else self.model.identifier or self.entity_id
-            )
-            stage_root = StageManager.get_standard_stage_prefix(
-                f"{FQN.from_string(self.model.stage).using_connection(self._conn)}/{name}"
-            )
-            sync_deploy_root_with_stage(
-                console=self._workspace_ctx.console,
-                deploy_root=bundle_map.deploy_root(),
-                bundle_map=bundle_map,
-                prune=prune,
-                recursive=True,
-                stage_path_parts=StageManager().stage_path_parts_from_str(stage_root),
-                print_diff=True,
+        if legacy and self._is_spcs_runtime_v2_mode():
+            raise CliError(
+                "runtime_name and compute_pool are not compatible with --legacy flag. "
+                "Please remove the --legacy flag to use versioned deployment, or remove "
+                "runtime_name and compute_pool from your snowflake.yml to use legacy deployment."
             )
 
-            console.step(f"Creating Streamlit object {self.model.fqn.sql_identifier}")
-
-            self._execute_query(
-                self.get_deploy_sql(
-                    replace=replace,
-                    from_stage_name=stage_root,
-                    experimental=False,
+        # Warn if replacing with a different deployment style
+        if object_exists and replace:
+            existing_is_legacy = self._is_legacy_deployment()
+            if existing_is_legacy and not legacy:
+                console.warning(
+                    "Replacing legacy ROOT_LOCATION deployment with versioned deployment. "
+                    "Files from the old stage location will not be automatically migrated. "
+                    "The new deployment will use a separate versioned stage location."
+                )
+            elif not existing_is_legacy and legacy:
+                console.warning(
+                    "Deployment style is changing from versioned to legacy. "
+                    "Your existing files will remain in the versioned stage. "
+                    "If needed, manually copy any additional files to the legacy stage after deployment."
                 )
-            )
 
-            StreamlitManager(connection=self._conn).grant_privileges(self.model)
+        if legacy:
+            self._deploy_legacy(bundle_map=bundle_map, replace=replace, prune=prune)
+        else:
+            self._deploy_versioned(bundle_map=bundle_map, replace=replace, prune=prune)
 
         return self.perform(EntityActions.GET_URL, action_context, *args, **kwargs)
 
@@ -172,7 +168,7 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
         artifacts_dir: Optional[Path] = None,
         schema: Optional[str] = None,
         database: Optional[str] = None,
-        experimental: bool = False,
+        legacy: bool = False,
         *args,
         **kwargs,
     ) -> str:
@@ -218,7 +214,7 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
 
         # SPCS runtime fields are only supported for FBE/versioned streamlits (FROM syntax)
         # Never add these fields for stage-based deployments (ROOT_LOCATION syntax)
-        if not from_stage_name and self._is_spcs_runtime_v2_mode(experimental):
+        if not from_stage_name and not legacy and self._is_spcs_runtime_v2_mode():
             query += f"\nRUNTIME_NAME = '{self.model.runtime_name}'"
             query += f"\nCOMPUTE_POOL = '{self.model.compute_pool}'"
 
@@ -249,14 +245,61 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
         except ProgrammingError:
             return False
 
-    def _deploy_experimental(
+    def _is_legacy_deployment(self) -> bool:
+        """Check if the existing streamlit uses legacy ROOT_LOCATION deployment."""
+        try:
+            result = self.describe().fetchone()
+            # Versioned deployments have live_version_location_uri, legacy ones don't
+            return result.get("live_version_location_uri") is None
+        except (ProgrammingError, AttributeError, KeyError):
+            # If we can't determine, assume it doesn't exist or is inaccessible
+            return False
+
+    def _deploy_legacy(
+        self, bundle_map: BundleMap, replace: bool = False, prune: bool = False
+    ):
+        console = self._workspace_ctx.console
+        console.step(f"Uploading artifacts to stage {self.model.stage}")
+
+        # We use a static method from StageManager here, but maybe this logic could be implemented elswhere, as we implement entities?
+        name = (
+            self.model.identifier.name
+            if isinstance(self.model.identifier, Identifier)
+            else self.model.identifier or self.entity_id
+        )
+        stage_root = StageManager.get_standard_stage_prefix(
+            f"{FQN.from_string(self.model.stage).using_connection(self._conn)}/{name}"
+        )
+        sync_deploy_root_with_stage(
+            console=self._workspace_ctx.console,
+            deploy_root=bundle_map.deploy_root(),
+            bundle_map=bundle_map,
+            prune=prune,
+            recursive=True,
+            stage_path_parts=StageManager().stage_path_parts_from_str(stage_root),
+            print_diff=True,
+        )
+
+        console.step(f"Creating Streamlit object {self.model.fqn.sql_identifier}")
+
+        self._execute_query(
+            self.get_deploy_sql(
+                replace=replace,
+                from_stage_name=stage_root,
+                legacy=True,
+            )
+        )
+
+        StreamlitManager(connection=self._conn).grant_privileges(self.model)
+
+    def _deploy_versioned(
         self, bundle_map: BundleMap, replace: bool = False, prune: bool = False
     ):
         self._execute_query(
             self.get_deploy_sql(
                 if_not_exists=True,
                 replace=replace,
-                experimental=True,
+                legacy=False,
             )
         )
         try:

snowflake/cli/api/commands/decorators.py

@@ -163,7 +163,7 @@ def _options_decorator_factory(
 ):
     """
     execute_before_command_using_new_options executes before command telemetry has been emitted,
-    but after command line options have been populated.
+    but after command-line options have been populated.
     """
 
     @wraps(func)

snowflake/cli/api/commands/flags.py

@@ -28,13 +28,18 @@ from snowflake.cli.api.cli_global_context import (
 from snowflake.cli.api.commands.common import OnErrorType
 from snowflake.cli.api.commands.overrideable_parameter import OverrideableOption
 from snowflake.cli.api.commands.utils import parse_key_value_variables
-from snowflake.cli.api.config import get_all_connections, get_config_value
+from snowflake.cli.api.config import (
+    get_all_connections,
+    get_config_value,
+    get_env_value,
+)
 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
+from snowflake.cli.api.utils.types import try_cast_to_int
 from snowflake.connector.auth.workload_identity import ApiFederatedAuthenticationType
 
 DEFAULT_CONTEXT_SETTINGS = {"help_option_names": ["--help", "-h"]}
@@ -97,7 +102,7 @@ TemporaryConnectionOption = typer.Option(
     False,
     "--temporary-connection",
     "-x",
-    help="Uses a connection defined with command line parameters, instead of one defined in config",
+    help="Uses a connection defined with command-line parameters, instead of one defined in config",
     callback=_connection_callback("temporary_connection"),
     is_flag=True,
     rich_help_panel=_CONNECTION_SECTION,
@@ -515,16 +520,36 @@ EnhancedExitCodesOption = typer.Option(
 )
 
 
-def _decimal_precision_callback(value: int | None):
+def _decimal_precision_callback(value: int | str | None):
     """Callback to set decimal precision globally when provided."""
     if value is None:
         try:
-            value = get_config_value(key="decimal_precision", default=None)
+            value = get_config_value("cli", key="decimal_precision", default=None)
         except Exception:
             pass
 
+        # env variable name and it's expected location within config file got inconsistent, so we
+        # need to handle this extra pattern
+        env_variable = get_env_value(key="decimal_precision")
+        if env_variable:
+            value = env_variable
+
     if value is not None:
-        getcontext().prec = value
+        try:
+            int_value = try_cast_to_int(value)
+        except ValueError:
+            raise ClickException(
+                f"Invalid value for decimal_precision: '{value}'. Must be a positive integer."
+            )
+
+        if int_value <= 0:
+            raise ClickException(
+                f"Invalid value for decimal_precision: '{value}'. Must be a positive integer."
+            )
+
+        getcontext().prec = int_value
+        return int_value
+
     return value
 
 

snowflake/cli/api/console/abc.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from contextlib import contextmanager
-from typing import Callable, Iterator, Optional
+from typing import Any, Callable, Iterator, Optional
 
 from rich import print as rich_print
 from rich.jupyter import JupyterMixin
@@ -61,10 +61,10 @@ class AbstractConsole(ABC):
         """Indicated whether output should be grouped."""
         return self._in_phase
 
-    def _print(self, text: JupyterMixin):
+    def _print(self, text: JupyterMixin, end: str = "\n"):
         if self.is_silent:
             return
-        rich_print(text)
+        rich_print(text, end=end)
 
     @contextmanager
     @abstractmethod
@@ -109,3 +109,7 @@ class AbstractConsole(ABC):
         """
         A context manager for indicating a long-running operation.
         """
+
+    @abstractmethod
+    def styled_message(self, message: str, style: Any):
+        """Displays a message with provided style."""