snowflake-cli 3.11.0__py3-none-any.whl → 3.13.0__py3-none-any.whl

snowflake/cli/_plugins/dbt/constants.py

@@ -22,6 +22,7 @@ DBT_COMMANDS = [
     "deps",
     "list",
     "parse",
+    "retry",
     "run",
     "run-operation",
     "seed",
@@ -36,6 +37,5 @@ UNSUPPORTED_COMMANDS = [
     "debug",
     "docs",
     "init",
-    "retry",
     "source",
 ]

snowflake/cli/_plugins/dbt/manager.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 from collections import defaultdict
 from pathlib import Path
 from tempfile import TemporaryDirectory
+from typing import Dict, List, Optional, TypedDict
 
 import yaml
 from snowflake.cli._plugins.dbt.constants import PROFILES_FILENAME
@@ -29,6 +30,12 @@ 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
+from snowflake.connector.errors import ProgrammingError
+
+
+class DBTObjectEditableAttributes(TypedDict):
+    default_target: Optional[str]
+    external_access_integrations: Optional[List[str]]
 
 
 class DBTManager(SqlExecutionMixin):
@@ -42,12 +49,59 @@ class DBTManager(SqlExecutionMixin):
             object_type=ObjectType.DBT_PROJECT.value.cli_name, fqn=name
         )
 
+    @staticmethod
+    def describe(name: FQN) -> SnowflakeCursor:
+        return ObjectManager().describe(
+            object_type=ObjectType.DBT_PROJECT.value.cli_name, fqn=name
+        )
+
+    @staticmethod
+    def get_dbt_object_attributes(name: FQN) -> Optional[DBTObjectEditableAttributes]:
+        """Get editable attributes of an existing DBT project, or None if it doesn't exist."""
+        try:
+            cursor = DBTManager().describe(name)
+        except ProgrammingError as exc:
+            if "DBT PROJECT" in exc.msg and "does not exist" in exc.msg:
+                return None
+            raise exc
+
+        rows = list(cursor)
+        if not rows:
+            return None
+
+        row = rows[0]
+        # Convert row to dict using column names
+        columns = [desc[0].lower() for desc in cursor.description]
+        row_dict = dict(zip(columns, row))
+
+        external_access_integrations = row_dict.get("external_access_integrations")
+        if external_access_integrations:
+            if isinstance(external_access_integrations, str):
+                external_access_integrations = [
+                    x.strip()
+                    for x in external_access_integrations.strip("[]").split(",")
+                    if x.strip()
+                ]
+            elif not isinstance(external_access_integrations, list):
+                external_access_integrations = None
+        else:
+            external_access_integrations = None
+
+        return DBTObjectEditableAttributes(
+            default_target=row_dict.get("default_target"),
+            external_access_integrations=external_access_integrations,
+        )
+
     def deploy(
         self,
         fqn: FQN,
         path: SecurePath,
         profiles_path: SecurePath,
         force: bool,
+        default_target: Optional[str] = None,
+        unset_default_target: bool = False,
+        external_access_integrations: Optional[List[str]] = None,
+        install_local_deps: bool = False,
     ) -> SnowflakeCursor:
         dbt_project_path = path / "dbt_project.yml"
         if not dbt_project_path.exists():
@@ -62,13 +116,13 @@ class DBTManager(SqlExecutionMixin):
             except KeyError:
                 raise CliError("`profile` is not defined in dbt_project.yml")
 
-        self._validate_profiles(profiles_path, profile)
+        self._validate_profiles(profiles_path, profile, default_target)
 
         with cli_console.phase("Creating temporary stage"):
             stage_manager = StageManager()
-            stage_fqn = FQN.from_string(f"dbt_{fqn.name}_stage").using_context()
-            stage_name = stage_manager.get_standard_stage_prefix(stage_fqn)
+            stage_fqn = FQN.from_resource(ObjectType.DBT_PROJECT, fqn, "STAGE")
             stage_manager.create(stage_fqn, temporary=True)
+            stage_name = stage_manager.get_standard_stage_prefix(stage_fqn)
 
         with cli_console.phase("Copying project files to stage"):
             with TemporaryDirectory() as tmp:
@@ -86,22 +140,166 @@ class DBTManager(SqlExecutionMixin):
 
         with cli_console.phase("Creating DBT project"):
             if force is True:
-                query = f"CREATE OR REPLACE DBT PROJECT {fqn}"
-            elif self.exists(name=fqn):
-                query = f"ALTER DBT PROJECT {fqn} ADD VERSION"
+                return self._deploy_create_or_replace(
+                    fqn,
+                    stage_name,
+                    default_target,
+                    external_access_integrations,
+                    install_local_deps,
+                )
             else:
-                query = f"CREATE DBT PROJECT {fqn}"
-            query += f"\nFROM {stage_name}"
-            return self.execute_query(query)
+                dbt_object_attributes = self.get_dbt_object_attributes(fqn)
+                if dbt_object_attributes is not None:
+                    return self._deploy_alter(
+                        fqn,
+                        stage_name,
+                        dbt_object_attributes,
+                        default_target,
+                        unset_default_target,
+                        external_access_integrations,
+                        install_local_deps,
+                    )
+                else:
+                    return self._deploy_create(
+                        fqn,
+                        stage_name,
+                        default_target,
+                        external_access_integrations,
+                        install_local_deps,
+                    )
+
+    def _deploy_alter(
+        self,
+        fqn: FQN,
+        stage_name: str,
+        dbt_object_attributes: DBTObjectEditableAttributes,
+        default_target: Optional[str],
+        unset_default_target: bool,
+        external_access_integrations: Optional[List[str]],
+        install_local_deps: bool,
+    ) -> SnowflakeCursor:
+        query = f"ALTER DBT PROJECT {fqn} ADD VERSION"
+        query += f"\nFROM {stage_name}"
+        result = self.execute_query(query)
+
+        set_properties = []
+        unset_properties = []
+
+        current_default_target = dbt_object_attributes.get("default_target")
+        if unset_default_target and current_default_target is not None:
+            unset_properties.append("DEFAULT_TARGET")
+        elif default_target and (
+            current_default_target is None
+            or current_default_target.lower() != default_target.lower()
+        ):
+            set_properties.append(f"DEFAULT_TARGET='{default_target}'")
+
+        current_external_access_integrations = dbt_object_attributes.get(
+            "external_access_integrations"
+        )
+        if self._should_update_external_access_integrations(
+            current_external_access_integrations,
+            external_access_integrations,
+            install_local_deps,
+        ):
+            if external_access_integrations:
+                integrations_str = ", ".join(sorted(external_access_integrations))
+                set_properties.append(
+                    f"EXTERNAL_ACCESS_INTEGRATIONS=({integrations_str})"
+                )
+            elif install_local_deps:
+                set_properties.append("EXTERNAL_ACCESS_INTEGRATIONS=()")
+
+        if set_properties or unset_properties:
+            self._execute_property_updates(fqn, set_properties, unset_properties)
+
+        return result
 
     @staticmethod
-    def _validate_profiles(profiles_path: SecurePath, target_profile: str) -> None:
+    def _should_update_external_access_integrations(
+        current: Optional[List[str]],
+        requested: Optional[List[str]],
+        install_local_deps: bool,
+    ) -> bool:
+        if requested is not None:
+            current_set = set(current) if current else set()
+            requested_set = set(requested)
+            return current_set != requested_set
+        elif install_local_deps:
+            current_set = set(current) if current else set()
+            return current_set != set()
+        return False
+
+    def _execute_property_updates(
+        self, fqn: FQN, set_clauses: List[str], unset_properties: List[str]
+    ) -> None:
+        if set_clauses:
+            query = f"ALTER DBT PROJECT {fqn} SET {', '.join(set_clauses)}"
+            self.execute_query(query)
+
+        for property_name in unset_properties:
+            query = f"ALTER DBT PROJECT {fqn} UNSET {property_name}"
+            self.execute_query(query)
+
+    def _deploy_create(
+        self,
+        fqn: FQN,
+        stage_name: str,
+        default_target: Optional[str],
+        external_access_integrations: Optional[List[str]],
+        install_local_deps: bool,
+    ) -> SnowflakeCursor:
+        query = f"CREATE DBT PROJECT {fqn}"
+        query += f"\nFROM {stage_name}"
+        if default_target:
+            query += f" DEFAULT_TARGET='{default_target}'"
+        query = self._handle_external_access_integrations_query(
+            query, external_access_integrations, install_local_deps
+        )
+        return self.execute_query(query)
+
+    @staticmethod
+    def _handle_external_access_integrations_query(
+        query: str,
+        external_access_integrations: Optional[List[str]],
+        install_local_deps: bool,
+    ) -> str:
+        # Providing external access integrations will trigger installation of local deps as well
+        if external_access_integrations:
+            integrations_str = ", ".join(external_access_integrations)
+            query += f"\nEXTERNAL_ACCESS_INTEGRATIONS = ({integrations_str})"
+        elif install_local_deps:
+            query += f"\nEXTERNAL_ACCESS_INTEGRATIONS = ()"
+        return query
+
+    def _deploy_create_or_replace(
+        self,
+        fqn: FQN,
+        stage_name: str,
+        default_target: Optional[str],
+        external_access_integrations: Optional[List[str]],
+        install_local_deps: bool,
+    ) -> SnowflakeCursor:
+        query = f"CREATE OR REPLACE DBT PROJECT {fqn}"
+        query += f"\nFROM {stage_name}"
+        if default_target:
+            query += f" DEFAULT_TARGET='{default_target}'"
+        query = self._handle_external_access_integrations_query(
+            query, external_access_integrations, install_local_deps
+        )
+        return self.execute_query(query)
+
+    def _validate_profiles(
+        self,
+        profiles_path: SecurePath,
+        profile_name: str,
+        default_target: str | None = None,
+    ) -> 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
+         * default_target (if specified) exists in the profile's outputs
         """
         profiles_file = profiles_path / PROFILES_FILENAME
         if not profiles_file.exists():
@@ -111,53 +309,60 @@ class DBTManager(SqlExecutionMixin):
         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:
+        if profile_name not in profiles:
             raise CliError(
-                f"profile {target_profile} is not defined in {PROFILES_FILENAME}"
+                f"Profile {profile_name} 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")
+        profile = profiles[profile_name]
+        target_name = default_target or profile.get("target")
+        available_targets = set(profile["outputs"].keys())
+        if target_name in available_targets:
+            target = profile["outputs"][target_name]
+            target_errors = self._validate_target(target_name, target)
+            if target_errors:
+                errors[profile_name].extend(target_errors)
+        else:
+            available_targets_str = ", ".join(sorted(available_targets))
+            errors[profile_name].append(
+                f"Target '{target_name}' is not defined in profile '{profile_name}'. "
+                f"Available targets: {available_targets_str}"
+            )
 
+        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)
+
+    def _validate_target(
+        self, target_name: str, target_details: Dict[str, str]
+    ) -> List[str]:
+        errors = []
         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 missing_keys := required_fields - set(target_details.keys()):
+            errors.append(
+                f"Missing required fields: {', '.join(sorted(missing_keys))} in target {target_name}"
+            )
+        if role := target_details.get("role"):
+            if not self._validate_role(role_name=role):
+                errors.append(f"Role '{role}' does not exist or is not accessible.")
+        return errors
 
-        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)
+    def _validate_role(self, role_name: str) -> bool:
+        try:
+            with self.use_role(role_name):
+                self.execute_query("select 1")
+            return True
+        except ProgrammingError:
+            return False
 
     @staticmethod
     def _prepare_profiles_file(profiles_path: Path, tmp_path: Path):

snowflake/cli/_plugins/dcm/commands.py

@@ -14,29 +14,23 @@
 from typing import List, Optional
 
 import typer
-from snowflake.cli._plugins.dcm.dcm_project_entity_model import (
-    DCMProjectEntityModel,
-)
 from snowflake.cli._plugins.dcm.manager import DCMProjectManager
 from snowflake.cli._plugins.object.command_aliases import add_object_command_aliases
 from snowflake.cli._plugins.object.commands import scope_option
 from snowflake.cli._plugins.object.manager import ObjectManager
-from snowflake.cli.api.artifacts.upload import sync_artifacts_with_stage
-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 (
     IfExistsOption,
     IfNotExistsOption,
     OverrideableOption,
-    entity_argument,
     identifier_argument,
     like_option,
     variables_option,
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
-from snowflake.cli.api.commands.utils import get_entity_for_operation
 from snowflake.cli.api.console.console import cli_console
-from snowflake.cli.api.constants import ObjectType
+from snowflake.cli.api.constants import (
+    ObjectType,
+)
 from snowflake.cli.api.exceptions import CliError
 from snowflake.cli.api.feature_flags import FeatureFlag
 from snowflake.cli.api.identifiers import FQN
@@ -45,7 +39,7 @@ from snowflake.cli.api.output.types import (
     QueryJsonValueResult,
     QueryResult,
 )
-from snowflake.cli.api.project.project_paths import ProjectPaths
+from snowflake.cli.api.utils.path_utils import is_stage_path
 
 app = SnowTyperFactory(
     name="dcm",
@@ -63,18 +57,10 @@ configuration_flag = typer.Option(
     help="Configuration of the DCM Project to use. If not specified default configuration is used.",
     show_default=False,
 )
-from_option = OverrideableOption(
+from_option = typer.Option(
     None,
     "--from",
-    mutually_exclusive=["prune"],
-    show_default=False,
-)
-
-prune_option = OverrideableOption(
-    False,
-    "--prune",
-    help="Remove unused artifacts from the stage during sync. Mutually exclusive with --from.",
-    mutually_exclusive=["from_stage"],
+    help="Source location: stage path (starting with '@') or local directory path. Omit to use current directory.",
     show_default=False,
 )
 
@@ -122,61 +108,65 @@ add_object_command_aliases(
 @app.command(requires_connection=True)
 def deploy(
     identifier: FQN = dcm_identifier,
-    from_stage: Optional[str] = from_option(
-        help="Deploy DCM Project deployment from a given stage."
-    ),
+    from_location: Optional[str] = from_option,
     variables: Optional[List[str]] = variables_flag,
     configuration: Optional[str] = configuration_flag,
     alias: Optional[str] = alias_option,
-    prune: bool = prune_option(),
     **options,
 ):
     """
     Applies changes defined in DCM Project to Snowflake.
     """
-    result = DCMProjectManager().execute(
-        project_name=identifier,
-        configuration=configuration,
-        from_stage=from_stage if from_stage else _sync_local_files(prune=prune),
-        variables=variables,
-        alias=alias,
-        output_path=None,
-    )
+    manager = DCMProjectManager()
+    effective_stage = _get_effective_stage(identifier, from_location)
+
+    with cli_console.spinner() as spinner:
+        spinner.add_task(description=f"Deploying dcm project {identifier}", total=None)
+        result = manager.execute(
+            project_identifier=identifier,
+            configuration=configuration,
+            from_stage=effective_stage,
+            variables=variables,
+            alias=alias,
+            output_path=None,
+        )
     return QueryJsonValueResult(result)
 
 
 @app.command(requires_connection=True)
 def plan(
     identifier: FQN = dcm_identifier,
-    from_stage: Optional[str] = from_option(
-        help="Plan DCM Project deployment from a given stage."
-    ),
+    from_location: Optional[str] = from_option,
     variables: Optional[List[str]] = variables_flag,
     configuration: Optional[str] = configuration_flag,
-    prune: bool = prune_option(),
     output_path: Optional[str] = output_path_option(
-        help="Stage path where the deployment plan output will be stored."
+        help="Path where the deployment plan output will be stored. Can be a stage path (starting with '@') or a local directory path."
     ),
     **options,
 ):
     """
     Plans a DCM Project deployment (validates without executing).
     """
-    result = DCMProjectManager().execute(
-        project_name=identifier,
-        configuration=configuration,
-        from_stage=from_stage if from_stage else _sync_local_files(prune=prune),
-        dry_run=True,
-        variables=variables,
-        output_path=output_path,
-    )
+    manager = DCMProjectManager()
+    effective_stage = _get_effective_stage(identifier, from_location)
+
+    with cli_console.spinner() as spinner:
+        spinner.add_task(description=f"Planning dcm project {identifier}", total=None)
+        result = manager.execute(
+            project_identifier=identifier,
+            configuration=configuration,
+            from_stage=effective_stage,
+            dry_run=True,
+            variables=variables,
+            output_path=output_path,
+        )
+
     return QueryJsonValueResult(result)
 
 
 @app.command(requires_connection=True)
-@with_project_definition()
 def create(
-    entity_id: str = entity_argument("dcm"),
+    identifier: FQN = dcm_identifier,
     if_not_exists: bool = IfNotExistsOption(
         help="Do nothing if the project already exists."
     ),
@@ -185,28 +175,18 @@ def create(
     """
     Creates a DCM Project in Snowflake.
     """
-    cli_context = get_cli_context()
-    project: DCMProjectEntityModel = get_entity_for_operation(
-        cli_context=cli_context,
-        entity_id=entity_id,
-        project_definition=cli_context.project_definition,
-        entity_type="dcm",
-    )
     om = ObjectManager()
-    if om.object_exists(object_type="dcm", fqn=project.fqn):
-        message = f"DCM Project '{project.fqn}' already exists."
+    if om.object_exists(object_type="dcm", fqn=identifier):
+        message = f"DCM Project '{identifier}' already exists."
         if if_not_exists:
             return MessageResult(message)
         raise CliError(message)
 
-    if om.object_exists(object_type="stage", fqn=FQN.from_stage(project.stage)):
-        raise CliError(f"Stage '{project.stage}' already exists.")
-
     dpm = DCMProjectManager()
-    with cli_console.phase(f"Creating DCM Project '{project.fqn}'"):
-        dpm.create(project=project)
+    with cli_console.phase(f"Creating DCM Project '{identifier}'"):
+        dpm.create(project_identifier=identifier)
 
-    return MessageResult(f"DCM Project '{project.fqn}' successfully created.")
+    return MessageResult(f"DCM Project '{identifier}' successfully created.")
 
 
 @app.command(requires_connection=True)
@@ -218,56 +198,51 @@ def list_deployments(
     Lists deployments of given DCM Project.
     """
     pm = DCMProjectManager()
-    results = pm.list_versions(project_name=identifier)
+    results = pm.list_deployments(project_identifier=identifier)
     return QueryResult(results)
 
 
 @app.command(requires_connection=True)
 def drop_deployment(
     identifier: FQN = dcm_identifier,
-    version_name: str = typer.Argument(
-        help="Name or alias of the version to drop. For names containing '$', use single quotes to prevent shell expansion (e.g., 'VERSION$1').",
+    deployment_name: str = typer.Argument(
+        help="Name or alias of the deployment to drop. For names containing '$', use single quotes to prevent shell expansion (e.g., 'DEPLOYMENT$1').",
         show_default=False,
     ),
-    if_exists: bool = IfExistsOption(help="Do nothing if the version does not exist."),
+    if_exists: bool = IfExistsOption(
+        help="Do nothing if the deployment does not exist."
+    ),
     **options,
 ):
     """
-    Drops a version from the DCM Project.
+    Drops a deployment from the DCM Project.
     """
     # Detect potential shell expansion issues
-    if version_name and version_name.upper() == "VERSION":
+    if deployment_name and deployment_name.upper() == "DEPLOYMENT":
         cli_console.warning(
-            f"Version name '{version_name}' might be truncated due to shell expansion. "
-            f"If you meant to use a version like 'VERSION$1', try using single quotes: 'VERSION$1'."
+            f"Deployment name '{deployment_name}' might be truncated due to shell expansion. "
+            f"If you meant to use a deployment like 'DEPLOYMENT$1', try using single quotes: 'DEPLOYMENT$1'."
         )
 
     dpm = DCMProjectManager()
     dpm.drop_deployment(
-        project_name=identifier,
-        version_name=version_name,
+        project_identifier=identifier,
+        deployment_name=deployment_name,
         if_exists=if_exists,
     )
     return MessageResult(
-        f"Version '{version_name}' dropped from DCM Project '{identifier}'."
+        f"Deployment '{deployment_name}' dropped from DCM Project '{identifier}'."
     )
 
 
-def _sync_local_files(prune: bool = False) -> str:
-    cli_context = get_cli_context()
-    project_entity = get_entity_for_operation(
-        cli_context=cli_context,
-        entity_id=None,
-        project_definition=cli_context.project_definition,
-        entity_type="dcm",
-    )
-
-    with cli_console.phase("Syncing local files to stage"):
-        sync_artifacts_with_stage(
-            project_paths=ProjectPaths(project_root=cli_context.project_root),
-            stage_root=project_entity.stage,
-            artifacts=project_entity.artifacts,
-            prune=prune,
+def _get_effective_stage(identifier: FQN, from_location: Optional[str]):
+    manager = DCMProjectManager()
+    if not from_location:
+        from_stage = manager.sync_local_files(project_identifier=identifier)
+    elif is_stage_path(from_location):
+        from_stage = from_location
+    else:
+        from_stage = manager.sync_local_files(
+            project_identifier=identifier, source_directory=from_location
         )
-
-    return project_entity.stage
+    return from_stage