snowflake-cli 3.8.3__py3-none-any.whl → 3.9.1__py3-none-any.whl

snowflake/cli/_plugins/dbt/manager.py

@@ -0,0 +1,182 @@
+# Copyright (c) 2025 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.
+
+from __future__ import annotations
+
+from collections import defaultdict
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+import yaml
+from snowflake.cli._plugins.dbt.constants import PROFILES_FILENAME
+from snowflake.cli._plugins.object.manager import ObjectManager
+from snowflake.cli._plugins.stage.manager import StageManager
+from snowflake.cli.api.console import cli_console
+from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB, ObjectType
+from snowflake.cli.api.exceptions import CliError
+from snowflake.cli.api.identifiers import FQN
+from snowflake.cli.api.secure_path import SecurePath
+from snowflake.cli.api.sql_execution import SqlExecutionMixin
+from snowflake.connector.cursor import SnowflakeCursor
+
+
+class DBTManager(SqlExecutionMixin):
+    def list(self) -> SnowflakeCursor:  # noqa: A003
+        query = "SHOW DBT PROJECTS"
+        return self.execute_query(query)
+
+    @staticmethod
+    def exists(name: FQN) -> bool:
+        return ObjectManager().object_exists(
+            object_type=ObjectType.DBT_PROJECT.value.cli_name, fqn=name
+        )
+
+    def deploy(
+        self,
+        name: FQN,
+        path: SecurePath,
+        profiles_path: SecurePath,
+        force: bool,
+    ) -> SnowflakeCursor:
+        dbt_project_path = path / "dbt_project.yml"
+        if not dbt_project_path.exists():
+            raise CliError(
+                f"dbt_project.yml does not exist in directory {path.path.absolute()}."
+            )
+
+        with dbt_project_path.open(read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB) as fd:
+            dbt_project = yaml.safe_load(fd)
+            try:
+                profile = dbt_project["profile"]
+            except KeyError:
+                raise CliError("`profile` is not defined in dbt_project.yml")
+
+        self._validate_profiles(profiles_path, profile)
+
+        with cli_console.phase("Creating temporary stage"):
+            stage_manager = StageManager()
+            stage_fqn = FQN.from_string(f"dbt_{name}_stage").using_context()
+            stage_name = stage_manager.get_standard_stage_prefix(stage_fqn)
+            stage_manager.create(stage_fqn, temporary=True)
+
+        with cli_console.phase("Copying project files to stage"):
+            with TemporaryDirectory() as tmp:
+                tmp_path = Path(tmp)
+                stage_manager.copy_to_tmp_dir(path.path, tmp_path)
+                self._prepare_profiles_file(profiles_path.path, tmp_path)
+                result_count = len(
+                    list(
+                        stage_manager.put_recursive(
+                            path.path, stage_name, temp_directory=tmp_path
+                        )
+                    )
+                )
+                cli_console.step(f"Copied {result_count} files")
+
+        with cli_console.phase("Creating DBT project"):
+            if force is True:
+                query = f"CREATE OR REPLACE DBT PROJECT {name}"
+            elif self.exists(name=name):
+                query = f"ALTER DBT PROJECT {name} ADD VERSION"
+            else:
+                query = f"CREATE DBT PROJECT {name}"
+            query += f"\nFROM {stage_name}"
+            return self.execute_query(query)
+
+    @staticmethod
+    def _validate_profiles(profiles_path: SecurePath, target_profile: str) -> None:
+        """
+        Validates that:
+         * profiles.yml exists
+         * contain profile specified in dbt_project.yml
+         * no other profiles are defined there
+         * does not contain any confidential data like passwords
+        """
+        profiles_file = profiles_path / PROFILES_FILENAME
+        if not profiles_file.exists():
+            raise CliError(
+                f"{PROFILES_FILENAME} does not exist in directory {profiles_path.path.absolute()}."
+            )
+        with profiles_file.open(read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB) as fd:
+            profiles = yaml.safe_load(fd)
+
+        if target_profile not in profiles:
+            raise CliError(
+                f"profile {target_profile} is not defined in {PROFILES_FILENAME}"
+            )
+
+        errors = defaultdict(list)
+        if len(profiles.keys()) > 1:
+            for profile_name in profiles.keys():
+                if profile_name.lower() != target_profile.lower():
+                    errors[profile_name].append("Remove unnecessary profiles")
+
+        required_fields = {
+            "account",
+            "database",
+            "role",
+            "schema",
+            "type",
+            "user",
+            "warehouse",
+        }
+        supported_fields = {
+            "threads",
+        }
+        for target_name, target in profiles[target_profile]["outputs"].items():
+            if missing_keys := required_fields - set(target.keys()):
+                errors[target_profile].append(
+                    f"Missing required fields: {', '.join(sorted(missing_keys))} in target {target_name}"
+                )
+            if (
+                unsupported_keys := set(target.keys())
+                - required_fields
+                - supported_fields
+            ):
+                errors[target_profile].append(
+                    f"Unsupported fields found: {', '.join(sorted(unsupported_keys))} in target {target_name}"
+                )
+            if "type" in target and target["type"].lower() != "snowflake":
+                errors[target_profile].append(
+                    f"Value for type field is invalid. Should be set to `snowflake` in target {target_name}"
+                )
+
+        if errors:
+            message = f"Found following errors in {PROFILES_FILENAME}. Please fix them before proceeding:"
+            for target, issues in errors.items():
+                message += f"\n{target}"
+                message += "\n * " + "\n * ".join(issues)
+            raise CliError(message)
+
+    @staticmethod
+    def _prepare_profiles_file(profiles_path: Path, tmp_path: Path):
+        # We need to copy profiles.yml file (not symlink) in order to redact
+        # any comments without changing original file. This can be achieved
+        # with pyyaml, which looses comments while reading a yaml file
+        source_profiles_file = SecurePath(profiles_path / PROFILES_FILENAME)
+        target_profiles_file = SecurePath(tmp_path / PROFILES_FILENAME)
+        if target_profiles_file.exists():
+            target_profiles_file.unlink()
+        with source_profiles_file.open(
+            read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB
+        ) as sfd, target_profiles_file.open(mode="w") as tfd:
+            yaml.safe_dump(yaml.safe_load(sfd), tfd)
+
+    def execute(
+        self, dbt_command: str, name: str, run_async: bool, *dbt_cli_args
+    ) -> SnowflakeCursor:
+        if dbt_cli_args:
+            dbt_command = " ".join([dbt_command, *dbt_cli_args]).strip()
+        query = f"EXECUTE DBT PROJECT {name} args='{dbt_command}'"
+        return self.execute_query(query, _exec_async=run_async)

snowflake/cli/_plugins/dbt/plugin_spec.py

@@ -0,0 +1,30 @@
+# Copyright (c) 2025 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.
+
+from snowflake.cli._plugins.dbt import commands
+from snowflake.cli.api.plugins.command import (
+    SNOWCLI_ROOT_COMMAND_PATH,
+    CommandSpec,
+    CommandType,
+    plugin_hook_impl,
+)
+
+
+@plugin_hook_impl
+def command_spec():
+    return CommandSpec(
+        parent_command_path=SNOWCLI_ROOT_COMMAND_PATH,
+        command_type=CommandType.COMMAND_GROUP,
+        typer_instance=commands.app.create_instance(),
+    )

snowflake/cli/_plugins/nativeapp/sf_sql_facade.py

@@ -159,7 +159,10 @@ class SnowflakeSQLFacade:
             )
 
         try:
-            prev_obj = to_identifier(current_obj_result_row[0])
+            if current_obj_result_row[0]:
+                prev_obj = to_identifier(current_obj_result_row[0])
+            else:
+                prev_obj = None
         except IndexError:
             prev_obj = None
 

snowflake/cli/_plugins/project/commands.py

@@ -26,6 +26,7 @@ from snowflake.cli._plugins.project.project_entity_model import (
 from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.commands.decorators import with_project_definition
 from snowflake.cli.api.commands.flags import (
+    IfNotExistsOption,
     OverrideableOption,
     PruneOption,
     entity_argument,
@@ -39,7 +40,11 @@ from snowflake.cli.api.console.console import cli_console
 from snowflake.cli.api.constants import ObjectType
 from snowflake.cli.api.exceptions import CliError
 from snowflake.cli.api.identifiers import FQN
-from snowflake.cli.api.output.types import MessageResult, QueryResult, SingleQueryResult
+from snowflake.cli.api.output.types import (
+    MessageResult,
+    QueryJsonValueResult,
+    QueryResult,
+)
 
 app = SnowTyperFactory(
     name="project",
@@ -57,6 +62,12 @@ version_flag = typer.Option(
 variables_flag = variables_option(
     'Variables for the execution context; for example: `-D "<key>=<value>"`.'
 )
+configuration_flag = typer.Option(
+    None,
+    "--configuration",
+    help="Configuration of the project to use. If not specified default configuration is used.",
+    show_default=False,
+)
 from_option = OverrideableOption(
     None,
     "--from",
@@ -82,15 +93,19 @@ def execute(
     identifier: FQN = project_identifier,
     version: Optional[str] = version_flag,
     variables: Optional[List[str]] = variables_flag,
+    configuration: Optional[str] = configuration_flag,
     **options,
 ):
     """
     Executes a project.
     """
     result = ProjectManager().execute(
-        project_name=identifier, version=version, variables=variables
+        project_name=identifier,
+        configuration=configuration,
+        version=version,
+        variables=variables,
     )
-    return SingleQueryResult(result)
+    return QueryJsonValueResult(result)
 
 
 @app.command(requires_connection=True)
@@ -98,15 +113,20 @@ def dry_run(
     identifier: FQN = project_identifier,
     version: Optional[str] = version_flag,
     variables: Optional[List[str]] = variables_flag,
+    configuration: Optional[str] = configuration_flag,
     **options,
 ):
     """
     Validates a project.
     """
     result = ProjectManager().execute(
-        project_name=identifier, version=version, dry_run=True, variables=variables
+        project_name=identifier,
+        configuration=configuration,
+        version=version,
+        dry_run=True,
+        variables=variables,
     )
-    return SingleQueryResult(result)
+    return QueryJsonValueResult(result)
 
 
 @app.command(requires_connection=True)
@@ -118,6 +138,9 @@ def create(
         "--no-version",
         help="Do not initialize project with a new version, only create the snowflake object.",
     ),
+    if_not_exists: bool = IfNotExistsOption(
+        help="Do nothing if the project already exists."
+    ),
     **options,
 ):
     """
@@ -133,7 +156,11 @@ def create(
     )
     om = ObjectManager()
     if om.object_exists(object_type="project", fqn=project.fqn):
-        raise CliError(f"Project '{project.fqn}' already exists.")
+        message = f"Project '{project.fqn}' already exists."
+        if if_not_exists:
+            return MessageResult(message)
+        raise CliError(message)
+
     if not no_version and om.object_exists(
         object_type="stage", fqn=FQN.from_stage(project.stage)
     ):

snowflake/cli/_plugins/project/manager.py

@@ -31,15 +31,20 @@ class ProjectManager(SqlExecutionMixin):
     def execute(
         self,
         project_name: FQN,
+        configuration: str | None = None,
         version: str | None = None,
         variables: List[str] | None = None,
         dry_run: bool = False,
     ):
         query = f"EXECUTE PROJECT {project_name.sql_identifier}"
+        if configuration or variables:
+            query += f" USING"
+        if configuration:
+            query += f" CONFIGURATION {configuration}"
         if variables:
             query += StageManager.parse_execute_variables(
                 parse_key_value_variables(variables)
-            )
+            ).removeprefix(" using")
         if version:
             query += f" WITH VERSION {version}"
         if dry_run:

snowflake/cli/_plugins/snowpark/snowpark_entity.py

@@ -242,7 +242,7 @@ class SnowparkEntity(EntityBase[Generic[T]]):
                     )
 
                 zip_dir(
-                    source=tmp_dir,
+                    source=tmp_dir.path,
                     dest_zip=bundle_dir / archive_name,
                 )
 

snowflake/cli/_plugins/spcs/image_registry/commands.py

@@ -64,10 +64,10 @@ def url(private_link: bool = PrivateLinkOption, **options) -> MessageResult:
 
 
 @app.command(requires_connection=True)
-def login(**options) -> MessageResult:
+def login(private_link: bool = PrivateLinkOption, **options) -> MessageResult:
     """
     Logs in to the account image registry with the current user's credentials through Docker.
 
     Must be called from a role that can view at least one image repository in the image registry.
     """
-    return MessageResult(RegistryManager().docker_registry_login().strip())
+    return MessageResult(RegistryManager().docker_registry_login(private_link).strip())

snowflake/cli/_plugins/spcs/image_registry/manager.py

@@ -101,8 +101,8 @@ class RegistryManager(SqlExecutionMixin):
             sample_repository_url = f"//{sample_repository_url}"
         return urlparse(sample_repository_url).netloc
 
-    def docker_registry_login(self) -> str:
-        registry_url = self.get_registry_url()
+    def docker_registry_login(self, private_link: bool = False) -> str:
+        registry_url = self.get_registry_url(private_link)
         token = self.get_token()
         command = [
             "docker",

snowflake/cli/_plugins/stage/commands.py

@@ -29,7 +29,10 @@ from snowflake.cli._plugins.stage.diff import (
     DiffResult,
     compute_stage_diff,
 )
-from snowflake.cli._plugins.stage.manager import StageManager
+from snowflake.cli._plugins.stage.manager import (
+    InternalStageEncryptionType,
+    StageManager,
+)
 from snowflake.cli._plugins.stage.utils import print_diff_to_console
 from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.commands.common import OnErrorType
@@ -150,11 +153,19 @@ def copy(
 
 
 @app.command("create", requires_connection=True)
-def stage_create(stage_name: FQN = StageNameArgument, **options) -> CommandResult:
+def stage_create(
+    stage_name: FQN = StageNameArgument,
+    encryption: InternalStageEncryptionType = typer.Option(
+        InternalStageEncryptionType.SNOWFLAKE_FULL.value,
+        "--encryption",
+        help="Type of encryption supported for all files stored on the stage.",
+    ),
+    **options,
+) -> CommandResult:
     """
     Creates a named stage if it does not already exist.
     """
-    cursor = StageManager().create(fqn=stage_name)
+    cursor = StageManager().create(fqn=stage_name, encryption=encryption)
     return SingleQueryResult(cursor)
 
 

snowflake/cli/_plugins/stage/manager.py

@@ -25,6 +25,7 @@ import time
 from collections import deque
 from contextlib import nullcontext
 from dataclasses import dataclass
+from enum import Enum
 from os import path
 from pathlib import Path
 from tempfile import TemporaryDirectory
@@ -68,6 +69,11 @@ 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>([^/]*/?)*)?"
 
 
+class InternalStageEncryptionType(Enum):
+    SNOWFLAKE_FULL = "SNOWFLAKE_FULL"
+    SNOWFLAKE_SSE = "SNOWFLAKE_SSE"
+
+
 @dataclass
 class StagePathParts:
     directory: str
@@ -379,15 +385,7 @@ class StageManager(SqlExecutionMixin):
         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]:
+    def copy_to_tmp_dir(self, local_path: Path, tmp_dir: Path):
         if local_path.is_file():
             raise UsageError("Cannot use recursive upload with a single file.")
 
@@ -398,16 +396,32 @@ class StageManager(SqlExecutionMixin):
             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)
+        temp_dir_with_copy = Path(tmp_dir)
 
-            # 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,
-                )
+        # 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,
+            )
+
+    def put_recursive(
+        self,
+        local_path: Path,
+        stage_path: str,
+        parallel: int = 4,
+        overwrite: bool = False,
+        role: Optional[str] = None,
+        auto_compress: bool = False,
+        temp_directory: Optional[Path] = None,
+    ) -> Generator[dict, None, None]:
+        is_temp_dir_provided = temp_directory is not None
+
+        with TemporaryDirectory() if temp_directory is None else nullcontext(str(temp_directory)) as tmp:  # type: ignore[attr-defined]
+            temp_dir_with_copy = Path(tmp)
+            if not is_temp_dir_provided:
+                self.copy_to_tmp_dir(local_path, 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)
@@ -515,10 +529,16 @@ class StageManager(SqlExecutionMixin):
             return self.execute_query(f"remove {stage_path.path_for_sql()}")
 
     def create(
-        self, fqn: FQN, comment: Optional[str] = None, temporary: bool = False
+        self,
+        fqn: FQN,
+        comment: Optional[str] = None,
+        temporary: bool = False,
+        encryption: InternalStageEncryptionType | None = None,
     ) -> 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 comment:
             query += f" comment='{comment}'"
         return self.execute_query(query)

snowflake/cli/_plugins/streamlit/streamlit_entity.py

@@ -99,9 +99,6 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
                 f"Streamlit {self.model.fqn.sql_identifier} already exists. Use 'replace' option to overwrite."
             )
 
-        console.step(f"Creating stage {self.model.stage} if not exists")
-        stage = self._create_stage_if_not_exists()
-
         if (
             experimental
             or GlobalFeatureFlag.ENABLE_STREAMLIT_VERSIONED_STAGE.is_enabled()
@@ -115,23 +112,20 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
             name = (
                 self.model.identifier.name
                 if isinstance(self.model.identifier, Identifier)
-                else self.model.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}"
             )
-            if prune:
-                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=StageManager().stage_path_parts_from_str(stage_root),
-                    print_diff=True,
-                )
-            else:
-                self._upload_files_to_stage(stage, bundle_map, None)
+            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=StageManager().stage_path_parts_from_str(stage_root),
+                print_diff=True,
+            )
 
             console.step(f"Creating Streamlit object {self.model.fqn.sql_identifier}")
 
@@ -266,17 +260,12 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
         else:
             stage_root = f"{embeded_stage_name}/default_checkout"
 
-        stage_resource = self._create_stage_if_not_exists(embeded_stage_name)
-
-        if prune:
-            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=StageManager().stage_path_parts_from_str(stage_root),
-                print_diff=True,
-            )
-        else:
-            self._upload_files_to_stage(stage_resource, bundle_map)
+        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=StageManager().stage_path_parts_from_str(stage_root),
+            print_diff=True,
+        )

snowflake/cli/api/commands/snow_typer.py

@@ -228,6 +228,7 @@ class SnowTyperFactory:
         short_help: Optional[str] = None,
         is_hidden: Optional[Callable[[], bool]] = None,
         deprecated: bool = False,
+        subcommand_metavar: Optional[str] = None,
     ):
         self.name = name
         self.help = help
@@ -237,6 +238,7 @@ class SnowTyperFactory:
         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:
         app = SnowTyper(
@@ -245,6 +247,7 @@ class SnowTyperFactory:
             short_help=self.short_help,
             hidden=self.is_hidden() if self.is_hidden else False,
             deprecated=self.deprecated,
+            subcommand_metavar=self.subcommand_metavar,
         )
         # register commands
         for command in self.commands_to_register:

snowflake/cli/api/constants.py

@@ -35,6 +35,7 @@ class ObjectNames:
 
 class ObjectType(Enum):
     COMPUTE_POOL = ObjectNames("compute-pool", "compute pool", "compute pools")
+    DBT_PROJECT = ObjectNames("dbt-project", "dbt project", "dbt projects")
     DATABASE = ObjectNames("database", "database", "databases")
     FUNCTION = ObjectNames("function", "function", "functions")
     INTEGRATION = ObjectNames("integration", "integration", "integrations")
@@ -79,6 +80,7 @@ UNSUPPORTED_OBJECTS = {
     ObjectType.APPLICATION.value.cli_name,
     ObjectType.APPLICATION_PACKAGE.value.cli_name,
     ObjectType.PROJECT.value.cli_name,
+    ObjectType.DBT_PROJECT.value.cli_name,
 }
 SUPPORTED_OBJECTS = sorted(OBJECT_TO_NAMES.keys() - UNSUPPORTED_OBJECTS)