snowflake-cli 3.1.0__py3-none-any.whl → 3.2.0__py3-none-any.whl

snowflake/cli/_plugins/stage/manager.py

@@ -17,17 +17,21 @@ from __future__ import annotations
 import fnmatch
 import glob
 import logging
+import os
 import re
+import shutil
 import sys
 import time
+from collections import deque
 from contextlib import nullcontext
 from dataclasses import dataclass
 from os import path
 from pathlib import Path
+from tempfile import TemporaryDirectory
 from textwrap import dedent
-from typing import Dict, List, Optional, Union
+from typing import Deque, Dict, Generator, List, Optional, Union
 
-from click import ClickException
+from click import ClickException, UsageError
 from snowflake.cli._plugins.snowpark.package_utils import parse_requirements
 from snowflake.cli.api.commands.common import (
     OnErrorType,
@@ -260,7 +264,7 @@ class StageManager(SqlExecutionMixin):
         query = f"ls {stage_path}"
         if pattern is not None:
             query += f" pattern = '{pattern}'"
-        return self._execute_query(query, cursor_class=DictCursor)
+        return self.execute_query(query, cursor_class=DictCursor)
 
     @staticmethod
     def _assure_is_existing_directory(path: Path) -> None:
@@ -275,7 +279,7 @@ class StageManager(SqlExecutionMixin):
         spath = self.build_path(stage_path)
         self._assure_is_existing_directory(dest_path)
         dest_directory = f"{dest_path}/"
-        return self._execute_query(
+        return self.execute_query(
             f"get {spath.path_for_sql()} {self._to_uri(dest_directory)} parallel={parallel}"
         )
 
@@ -291,7 +295,7 @@ class StageManager(SqlExecutionMixin):
             )
             self._assure_is_existing_directory(local_dir)
 
-            result = self._execute_query(
+            result = self.execute_query(
                 f"get {file_path.path_for_sql()} {self._to_uri(f'{local_dir}/')} parallel={parallel}"
             )
             results.append(result)
@@ -306,6 +310,7 @@ class StageManager(SqlExecutionMixin):
         overwrite: bool = False,
         role: Optional[str] = None,
         auto_compress: bool = False,
+        use_dict_cursor: bool = False,
     ) -> SnowflakeCursor:
         """
         This method will take a file path from the user's system and put it into a Snowflake stage,
@@ -313,16 +318,140 @@ class StageManager(SqlExecutionMixin):
         If provided with a role, then temporarily use this role to perform the operation above,
         and switch back to the original role for the next commands to run.
         """
+        if "*" not in str(local_path):
+            local_path = (
+                os.path.join(local_path, "*")
+                if Path(local_path).is_dir()
+                else str(local_path)
+            )
         with self.use_role(role) if role else nullcontext():
             spath = self.build_path(stage_path)
             local_resolved_path = path_resolver(str(local_path))
             log.info("Uploading %s to %s", local_resolved_path, stage_path)
-            cursor = self._execute_query(
+            cursor = self.execute_query(
                 f"put {self._to_uri(local_resolved_path)} {spath.path_for_sql()} "
-                f"auto_compress={str(auto_compress).lower()} parallel={parallel} overwrite={overwrite}"
+                f"auto_compress={str(auto_compress).lower()} parallel={parallel} overwrite={overwrite}",
+                cursor_class=DictCursor if use_dict_cursor else SnowflakeCursor,
             )
         return cursor
 
+    @staticmethod
+    def _symlink_or_copy(source_root: Path, source_file_or_dir: Path, dest_dir: Path):
+        from snowflake.cli._plugins.nativeapp.artifacts import resolve_without_follow
+
+        absolute_src = resolve_without_follow(source_file_or_dir)
+        dest_path = dest_dir / source_file_or_dir.relative_to(source_root)
+
+        if absolute_src.is_file():
+            try:
+                os.symlink(absolute_src, dest_path)
+            except OSError:
+                if not dest_path.parent.exists():
+                    dest_path.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copyfile(absolute_src, dest_path)
+        else:
+            dest_path.mkdir(exist_ok=True, parents=True)
+
+    def put_recursive(
+        self,
+        local_path: Path,
+        stage_path: str,
+        parallel: int = 4,
+        overwrite: bool = False,
+        role: Optional[str] = None,
+        auto_compress: bool = False,
+    ) -> Generator[dict, None, None]:
+        if local_path.is_file():
+            raise UsageError("Cannot use recursive upload with a single file.")
+
+        if local_path.is_dir():
+            root = local_path
+            glob_pattern = str(local_path / "**/*")
+        else:
+            root = Path([p for p in local_path.parents if p.is_dir()][0])
+            glob_pattern = str(local_path)
+
+        with TemporaryDirectory() as tmp:
+            temp_dir_with_copy = Path(tmp)
+
+            # Create a symlink or copy the file to the temp directory
+            for file_or_dir in glob.iglob(glob_pattern, recursive=True):
+                self._symlink_or_copy(
+                    source_root=root,
+                    source_file_or_dir=Path(file_or_dir),
+                    dest_dir=temp_dir_with_copy,
+                )
+
+            # Find the deepest directories, we will be iterating from bottom to top
+            deepest_dirs_list = self._find_deepest_directories(temp_dir_with_copy)
+
+            while deepest_dirs_list:
+                # Remove as visited
+                directory = deepest_dirs_list.pop(0)
+
+                # We reached root but there are still directories to process
+                if directory == temp_dir_with_copy and deepest_dirs_list:
+                    continue
+
+                # Upload the directory content, at this moment the directory has only files
+                if list(directory.iterdir()):
+                    destination = StagePath.from_stage_str(
+                        stage_path
+                    ) / directory.relative_to(temp_dir_with_copy)
+                    results: list[dict] = self.put(
+                        local_path=directory,
+                        stage_path=destination,
+                        parallel=parallel,
+                        overwrite=overwrite,
+                        role=role,
+                        auto_compress=auto_compress,
+                        use_dict_cursor=True,
+                    ).fetchall()
+
+                    # Rewrite results to have resolved paths for better UX
+                    for item in results:
+                        item["source"] = (directory / item["source"]).relative_to(
+                            temp_dir_with_copy
+                        )
+                        item["target"] = str(destination / item["target"])
+                        yield item
+
+                # We end if we reach the root directory
+                if directory == temp_dir_with_copy:
+                    break
+
+                # Add parent directory to the list if it's not already there
+                if directory.parent not in deepest_dirs_list:
+                    deepest_dirs_list.append(directory.parent)
+
+                # Remove the directory so the parent directory will contain only files
+                shutil.rmtree(directory)
+
+    @staticmethod
+    def _find_deepest_directories(root_directory: Path) -> list[Path]:
+        """
+        BFS to find the deepest directories. Build a tree of directories
+        structure and return leaves.
+        """
+        deepest_dirs: list[Path] = list()
+
+        queue: Deque[Path] = deque()
+        queue.append(root_directory)
+        while queue:
+            current_dir = queue.popleft()
+            # Sorted to have deterministic order
+            children_directories = sorted(
+                list(d for d in current_dir.iterdir() if d.is_dir())
+            )
+            if not children_directories and current_dir not in deepest_dirs:
+                deepest_dirs.append(current_dir)
+            else:
+                queue.extend([c for c in children_directories if c not in deepest_dirs])
+        deepest_dirs_list = sorted(
+            list(deepest_dirs), key=lambda d: len(d.parts), reverse=True
+        )
+        return deepest_dirs_list
+
     def copy_files(self, source_path: str, destination_path: str) -> SnowflakeCursor:
         source_stage_path = self.build_path(source_path)
         # We copy only into stage
@@ -339,7 +468,7 @@ class StageManager(SqlExecutionMixin):
         # Destination needs to end with /
         dest = destination_stage_path.absolute_path().rstrip("/") + "/"
         query = f"copy files into {dest} from {source_stage_path}"
-        return self._execute_query(query)
+        return self.execute_query(query)
 
     def remove(
         self, stage_name: str, path: str, role: Optional[str] = None
@@ -352,7 +481,7 @@ class StageManager(SqlExecutionMixin):
         """
         with self.use_role(role) if role else nullcontext():
             stage_path = self.build_path(stage_name) / path
-            return self._execute_query(f"remove {stage_path.path_for_sql()}")
+            return self.execute_query(f"remove {stage_path.path_for_sql()}")
 
     def create(
         self, fqn: FQN, comment: Optional[str] = None, temporary: bool = False
@@ -361,7 +490,7 @@ class StageManager(SqlExecutionMixin):
         query = f"create {temporary_str}stage if not exists {fqn.sql_identifier}"
         if comment:
             query += f" comment='{comment}'"
-        return self._execute_query(query)
+        return self.execute_query(query)
 
     def iter_stage(self, stage_path: StagePath):
         for file in self.list_files(stage_path.absolute_path()).fetchall():
@@ -557,7 +686,7 @@ class StageManager(SqlExecutionMixin):
             query = f"execute immediate from {self.quote_stage_name(file_stage_path)}"
             if variables:
                 query += variables
-            self._execute_query(query)
+            self.execute_query(query)
             return StageManager._success_result(file=original_file)
         except ProgrammingError as e:
             StageManager._handle_execution_exception(on_error=on_error, exception=e)

snowflake/cli/_plugins/streamlit/manager.py

@@ -45,10 +45,10 @@ log = logging.getLogger(__name__)
 class StreamlitManager(SqlExecutionMixin):
     def execute(self, app_name: FQN):
         query = f"EXECUTE STREAMLIT {app_name.sql_identifier}()"
-        return self._execute_query(query=query)
+        return self.execute_query(query=query)
 
     def share(self, streamlit_name: FQN, to_role: str) -> SnowflakeCursor:
-        return self._execute_query(
+        return self.execute_query(
             f"grant usage on streamlit {streamlit_name.sql_identifier} to role {to_role}"
         )
 
@@ -118,7 +118,7 @@ class StreamlitManager(SqlExecutionMixin):
         if streamlit.secrets:
             query.append(streamlit.get_secrets_sql())
 
-        self._execute_query("\n".join(query))
+        self.execute_query("\n".join(query))
 
     def deploy(self, streamlit: StreamlitEntityModel, replace: bool = False):
         streamlit_id = streamlit.fqn.using_connection(self._conn)
@@ -152,11 +152,11 @@ class StreamlitManager(SqlExecutionMixin):
             )
             try:
                 if use_versioned_stage:
-                    self._execute_query(
+                    self.execute_query(
                         f"ALTER STREAMLIT {streamlit_id.identifier} ADD LIVE VERSION FROM LAST"
                     )
                 elif not FeatureFlag.ENABLE_STREAMLIT_NO_CHECKOUTS.is_enabled():
-                    self._execute_query(
+                    self.execute_query(
                         f"ALTER streamlit {streamlit_id.identifier} CHECKOUT"
                     )
             except ProgrammingError as e:

snowflake/cli/_plugins/workspace/commands.py

@@ -22,7 +22,6 @@ from typing import List, Optional
 
 import typer
 import yaml
-from click import MissingParameter
 from snowflake.cli._plugins.nativeapp.artifacts import BundleMap
 from snowflake.cli._plugins.nativeapp.common_flags import (
     ForceOption,
@@ -263,6 +262,11 @@ def version_create(
         help=f"""The patch number you want to create for an existing version.
         Defaults to undefined if it is not set, which means the Snowflake CLI either uses the patch specified in the `manifest.yml` file or automatically generates a new patch number.""",
     ),
+    label: Optional[str] = typer.Option(
+        None,
+        "--label",
+        help="A label for the version that is displayed to consumers. If unset, the version label specified in `manifest.yml` file is used.",
+    ),
     skip_git_check: Optional[bool] = typer.Option(
         False,
         "--skip-git-check",
@@ -274,8 +278,6 @@ def version_create(
     **options,
 ):
     """Creates a new version for the specified entity."""
-    if version is None and patch is not None:
-        raise MissingParameter("Cannot provide a patch without version!")
 
     cli_context = get_cli_context()
     ws = WorkspaceManager(
@@ -287,6 +289,7 @@ def version_create(
         EntityActions.VERSION_CREATE,
         version=version,
         patch=patch,
+        label=label,
         skip_git_check=skip_git_check,
         interactive=interactive,
         force=force,

snowflake/cli/api/cli_global_context.py

@@ -76,6 +76,7 @@ class _CliGlobalContextManager:
             self,
             connection_context=self.connection_context.clone(),
             project_env_overrides_args=self.project_env_overrides_args.copy(),
+            metrics=self.metrics.clone(),
         )
 
     def __setattr__(self, prop, val):

snowflake/cli/api/config.py

@@ -181,7 +181,7 @@ def _read_config_file():
                 )
                 warnings.warn(
                     f"Unauthorized users ({users}) have access to configuration file {CONFIG_MANAGER.file_path}.\n"
-                    f'Run `icacls "{CONFIG_MANAGER.file_path}" /deny <USER_ID>:F` on those users to restrict permissions.'
+                    f'Run `icacls "{CONFIG_MANAGER.file_path}" /remove:g <USER_ID>` on those users to restrict permissions.'
                 )
 
         try:
@@ -340,9 +340,24 @@ def _get_envs_for_path(*path) -> dict:
     }
 
 
-def _dump_config(conf_file_cache: Dict):
+def _dump_config(config_and_connections: Dict):
+    config_toml_dict = config_and_connections.copy()
+
+    if CONNECTIONS_FILE.exists():
+        # update connections in connections.toml
+        # it will add only connections (maybe updated) which were originally read from connections.toml
+        # it won't add connections from config.toml
+        # because config manager doesn't have connections from config.toml if connections.toml exists
+        _update_connections_toml(config_and_connections.get("connections") or {})
+        # to config.toml save only connections from config.toml
+        connections_to_save_in_config_toml = _read_config_file_toml().get("connections")
+        if connections_to_save_in_config_toml:
+            config_toml_dict["connections"] = connections_to_save_in_config_toml
+        else:
+            config_toml_dict.pop("connections", None)
+
     with SecurePath(CONFIG_MANAGER.file_path).open("w+") as fh:
-        dump(conf_file_cache, fh)
+        dump(config_toml_dict, fh)
 
 
 def _check_default_config_files_permissions() -> None:
@@ -373,9 +388,12 @@ def get_feature_flags_section() -> Dict[str, bool | Literal["UNKNOWN"]]:
     return {k: _bool_or_unknown(v) for k, v in flags.items()}
 
 
+def _read_config_file_toml() -> dict:
+    return tomlkit.loads(CONFIG_MANAGER.file_path.read_text()).unwrap()
+
+
 def _read_connections_toml() -> dict:
-    with open(CONNECTIONS_FILE, "r") as f:
-        return tomlkit.loads(f.read()).unwrap()
+    return tomlkit.loads(CONNECTIONS_FILE.read_text()).unwrap()
 
 
 def _update_connections_toml(connections: dict):

snowflake/cli/api/console/console.py

@@ -29,10 +29,6 @@ IMPORTANT_STYLE: Style = Style(bold=True, italic=True)
 INDENTATION_LEVEL: int = 2
 
 
-class CliConsoleNestingProhibitedError(RuntimeError):
-    """CliConsole phase nesting not allowed."""
-
-
 class CliConsole(AbstractConsole):
     """An utility for displaying intermediate output.
 
@@ -70,28 +66,21 @@ class CliConsole(AbstractConsole):
     @contextmanager
     def phase(self, enter_message: str, exit_message: Optional[str] = None):
         """A context manager for organising steps into logical group."""
-        if self.in_phase:
-            raise CliConsoleNestingProhibitedError("Only one phase allowed at a time.")
-        if self._extra_indent > 0:
-            raise CliConsoleNestingProhibitedError(
-                "Phase cannot be used in an indented block."
-            )
-
         self._print(self._format_message(enter_message, Output.PHASE))
-        self._in_phase = True
+        self._extra_indent += 1
 
         try:
             yield self.step
         finally:
-            self._in_phase = False
+            self._extra_indent -= 1
             if exit_message:
                 self._print(self._format_message(exit_message, Output.PHASE))
 
     @contextmanager
     def indented(self):
         """
-        A context manager for temporarily indenting messages and warnings. Phases and steps cannot be used in indented blocks,
-        but multiple indented blocks can be nested (use sparingly).
+        A context manager for temporarily indenting messages and warnings.
+        Multiple indented blocks can be nested (use sparingly).
         """
         self._extra_indent += 1
         try:
@@ -104,10 +93,6 @@ class CliConsole(AbstractConsole):
 
         If called within a phase, the output will be indented.
         """
-        if self._extra_indent > 0:
-            raise CliConsoleNestingProhibitedError(
-                "Step cannot be used in an indented block."
-            )
         text = self._format_message(message, Output.STEP)
         self._print(text)
 

snowflake/cli/api/entities/utils.py

@@ -12,6 +12,7 @@ from snowflake.cli._plugins.nativeapp.exceptions import (
     InvalidTemplateInFileError,
     MissingScriptError,
 )
+from snowflake.cli._plugins.nativeapp.sf_facade import get_snowflake_facade
 from snowflake.cli._plugins.nativeapp.utils import verify_exists, verify_no_directories
 from snowflake.cli._plugins.stage.diff import (
     DiffResult,
@@ -106,22 +107,15 @@ def sync_deploy_root_with_stage(
         A `DiffResult` instance describing the changes that were performed.
     """
 
-    sql_executor = get_sql_executor()
+    sql_facade = get_snowflake_facade()
     # 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."
     )
-    with sql_executor.use_role(role):
-        sql_executor.execute_query(
-            f"create schema if not exists {package_name}.{stage_schema}"
-        )
-        sql_executor.execute_query(
-            f"""
-                    create stage if not exists {stage_fqn}
-                    encryption = (TYPE = 'SNOWFLAKE_SSE')
-                    DIRECTORY = (ENABLE = TRUE)"""
-        )
+    if not sql_facade.stage_exists(stage_fqn):
+        sql_facade.create_schema(stage_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:
@@ -195,36 +189,24 @@ def sync_deploy_root_with_stage(
     return diff
 
 
-def _execute_sql_script(
-    script_content: str,
-    database_name: Optional[str] = None,
-) -> None:
-    """
-    Executing the provided SQL script content.
-    This assumes that a relevant warehouse is already active.
-    If database_name is passed in, it will be used first.
-    """
-    try:
-        sql_executor = get_sql_executor()
-        if database_name is not None:
-            sql_executor.execute_query(f"use database {database_name}")
-        sql_executor.execute_queries(script_content)
-    except ProgrammingError as err:
-        generic_sql_error_handler(err)
-
-
 def execute_post_deploy_hooks(
     console: AbstractConsole,
     project_root: Path,
     post_deploy_hooks: Optional[List[PostDeployHook]],
     deployed_object_type: str,
+    role_name: str,
     database_name: str,
+    warehouse_name: str,
 ) -> None:
     """
     Executes post-deploy hooks for the given object type.
     While executing SQL post deploy hooks, it first switches to the database provided in the input.
     All post deploy scripts templates will first be expanded using the global template context.
     """
+    get_cli_context().metrics.set_counter_default(
+        CLICounterField.POST_DEPLOY_SCRIPTS, 0
+    )
+
     if not post_deploy_hooks:
         return
 
@@ -248,11 +230,16 @@ def execute_post_deploy_hooks(
             sql_scripts_paths,
         )
 
+        sql_facade = get_snowflake_facade()
+
         for index, sql_script_path in enumerate(display_paths):
             console.step(f"Executing SQL script: {sql_script_path}")
-            _execute_sql_script(
-                script_content=scripts_content_list[index],
-                database_name=database_name,
+            sql_facade.execute_user_script(
+                queries=scripts_content_list[index],
+                script_name=sql_script_path,
+                role=role_name,
+                warehouse=warehouse_name,
+                database=database_name,
             )
 
 

snowflake/cli/api/errno.py

@@ -26,3 +26,5 @@ ONLY_SUPPORTED_ON_DEV_MODE_APPLICATIONS = 93046
 NOT_SUPPORTED_ON_DEV_MODE_APPLICATIONS = 93055
 APPLICATION_NO_LONGER_AVAILABLE = 93079
 APPLICATION_OWNS_EXTERNAL_OBJECTS = 93128
+APPLICATION_REQUIRES_TELEMETRY_SHARING = 93321
+CANNOT_DISABLE_MANDATORY_TELEMETRY = 93329

snowflake/cli/api/exceptions.py

@@ -190,6 +190,15 @@ class IncompatibleParametersError(UsageError):
         )
 
 
+class UnmetParametersError(UsageError):
+    def __init__(self, options: list[str]):
+        options_with_quotes = [f"'{option}'" for option in options]
+        comma_separated_options = ", ".join(options_with_quotes[:-1])
+        super().__init__(
+            f"Parameters {comma_separated_options} and {options_with_quotes[-1]} must be used simultaneously."
+        )
+
+
 class NoWarehouseSelectedInSessionError(ClickException):
     def __init__(self, msg: str):
         super().__init__(