snowflake-cli 3.8.3__py3-none-any.whl → 3.9.0__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,
@@ -57,6 +58,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,13 +89,17 @@ 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)
 
@@ -98,13 +109,18 @@ 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)
 
@@ -118,6 +134,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 +152,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/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)
 

snowflake/cli/api/entities/common.py

@@ -4,18 +4,13 @@ from pathlib import Path
 from typing import Generic, List, Optional, Type, TypeVar, get_args
 
 from snowflake.cli._plugins.workspace.context import ActionContext, WorkspaceContext
-from snowflake.cli.api.artifacts.bundle_map import BundleMap
 from snowflake.cli.api.cli_global_context import get_cli_context, span
 from snowflake.cli.api.entities.resolver import Dependency, DependencyResolver
 from snowflake.cli.api.entities.utils import EntityActions, get_sql_executor
 from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.sql_execution import SqlExecutor
-from snowflake.cli.api.utils.path_utils import change_directory
-from snowflake.cli.api.utils.python_api_utils import StageEncryptionType
 from snowflake.connector import SnowflakeConnection
 from snowflake.connector.cursor import SnowflakeCursor
-from snowflake.core import CreateMode
-from snowflake.core.stage import Stage, StageEncryption, StageResource
 
 T = TypeVar("T")
 
@@ -129,13 +124,6 @@ class EntityBase(Generic[T]):
             raise ValueError("snow_api_root is not set")
         return root
 
-    @property
-    def stage_object(self) -> "StageResource":
-        if self._stage_object is None:
-            self._stage_object = self._create_stage_if_not_exists()
-
-        return self._stage_object
-
     @property
     def model(self) -> T:
         return self._entity_model
@@ -152,22 +140,6 @@ class EntityBase(Generic[T]):
     def get_drop_sql(self) -> str:
         return f"DROP {self.model.type.upper()} {self.identifier};"  # type: ignore[attr-defined]
 
-    def _create_stage_if_not_exists(
-        self, stage_name: Optional[str] = None
-    ) -> StageResource:
-        if stage_name is None:
-            stage_name = self.model.stage  # type: ignore[attr-defined]
-
-        stage_collection = (
-            self.snow_api_root.databases[self.database].schemas[self.schema].stages  # type: ignore[attr-defined]
-        )
-        stage_object = Stage(
-            name=stage_name,
-            encryption=StageEncryption(type=StageEncryptionType.SNOWFLAKE_SSE.value),
-        )
-
-        return stage_collection.create(stage_object, mode=CreateMode.if_not_exists)
-
     def _get_identifier(
         self, schema: Optional[str] = None, database: Optional[str] = None
     ) -> str:
@@ -175,30 +147,6 @@ class EntityBase(Generic[T]):
         db_to_use = database or self._entity_model.fqn.database or self._conn.database  # type: ignore
         return f"{self._entity_model.fqn.set_schema(schema_to_use).set_database(db_to_use).sql_identifier}"  # type: ignore
 
-    def _upload_files_to_stage(
-        self,
-        stage: StageResource,
-        bundle_map: BundleMap,
-        stage_root: Optional[str] = None,
-    ) -> None:
-        with change_directory(self.root):
-            for src, dest in bundle_map.all_mappings(
-                absolute=True, expand_directories=True
-            ):
-                if src.is_file():
-                    upload_dst = (
-                        f"{stage_root}/{dest.relative_to(self.root)}"
-                        if stage_root
-                        else f"/{self.fqn.name}/{get_parent_path_for_stage_deployment(dest.relative_to(bundle_map.deploy_root()))}"
-                    )
-
-                    stage.put(
-                        local_file_name=src.relative_to(self.root),
-                        stage_location=upload_dst,
-                        overwrite=True,
-                        auto_compress=False,
-                    )
-
     def get_from_fqn_or_conn(self, attribute_name: str) -> str:
         attribute = getattr(self.fqn, attribute_name, None) or getattr(
             self._conn, attribute_name, None

snowflake/cli/api/feature_flags.py

@@ -68,6 +68,7 @@ class FeatureFlag(FeatureFlagMixin):
     )
     ENABLE_SNOWPARK_GLOB_SUPPORT = BooleanFlag("ENABLE_SNOWPARK_GLOB_SUPPORT", False)
     ENABLE_SPCS_SERVICE_EVENTS = BooleanFlag("ENABLE_SPCS_SERVICE_EVENTS", False)
+    ENABLE_DBT = BooleanFlag("ENABLE_DBT", False)
     ENABLE_AUTH_KEYPAIR = BooleanFlag("ENABLE_AUTH_KEYPAIR", False)
     ENABLE_NATIVE_APP_PYTHON_SETUP = BooleanFlag(
         "ENABLE_NATIVE_APP_PYTHON_SETUP", False