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

snowflake/cli/__about__.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 from enum import Enum, unique
 
-VERSION = "3.14.0"
+VERSION = "3.15.0"
 
 
 @unique

snowflake/cli/_app/dev/docs/project_definition_generate_json_schema.py

@@ -38,8 +38,8 @@ class ProjectDefinitionProperty:
 
 
 class ProjectDefinitionGenerateJsonSchema(GenerateJsonSchema):
-    def __init__(self, by_alias: bool = False, ref_template: str = ""):
-        super().__init__(by_alias, "{model}")
+    def __init__(self, by_alias: bool = False, ref_template: str = "", **kwargs):
+        super().__init__(by_alias, "{model}", **kwargs)
         self._remapped_definitions: Dict[str, Any] = {}
 
     def generate(self, schema, mode="validation"):

snowflake/cli/_app/printing.py

@@ -33,6 +33,7 @@ from snowflake.cli.api.output.formats import OutputFormat
 from snowflake.cli.api.output.types import (
     CollectionResult,
     CommandResult,
+    EmptyResult,
     MessageResult,
     MultipleResults,
     ObjectResult,
@@ -341,15 +342,16 @@ def _print_single_table(obj):
 
 def print_result(cmd_result: CommandResult, output_format: OutputFormat | None = None):
     output_format = output_format or _get_format_type()
-    if is_structured_format(output_format):
-        print_structured(cmd_result, output_format)
-    elif isinstance(cmd_result, (MultipleResults, StreamResult)):
-        for res in cmd_result.result:
-            print_result(res)
-    elif (
-        isinstance(cmd_result, (MessageResult, ObjectResult, CollectionResult))
-        or cmd_result is None
-    ):
-        print_unstructured(cmd_result)
-    else:
-        raise ValueError(f"Unexpected type {type(cmd_result)}")
+
+    match cmd_result:
+        case EmptyResult():
+            return
+        case _ if is_structured_format(output_format):
+            print_structured(cmd_result, output_format)
+        case MultipleResults() | StreamResult():
+            for res in cmd_result.result:
+                print_result(res)
+        case MessageResult() | ObjectResult() | CollectionResult() | None:
+            print_unstructured(cmd_result)
+        case _:
+            raise ValueError(f"Unexpected type {type(cmd_result)}")

snowflake/cli/_app/snow_connector.py

@@ -15,9 +15,11 @@
 from __future__ import annotations
 
 import contextlib
+import io
 import logging
 import os
-from typing import Dict, Optional
+import sys
+from typing import Dict, Literal, Optional, TextIO
 
 import snowflake.connector
 from click.exceptions import ClickException
@@ -29,9 +31,7 @@ from snowflake.cli._app.constants import (
     PARAM_APPLICATION_NAME,
 )
 from snowflake.cli._app.telemetry import command_info
-from snowflake.cli._plugins.auth.oidc.manager import (
-    OidcManager,
-)
+from snowflake.cli._plugins.auth.oidc.manager import OidcManager
 from snowflake.cli.api.config import (
     get_connection_dict,
     get_env_value,
@@ -53,6 +53,8 @@ log = logging.getLogger(__name__)
 
 ENCRYPTED_PKCS8_PK_HEADER = b"-----BEGIN ENCRYPTED PRIVATE KEY-----"
 UNENCRYPTED_PKCS8_PK_HEADER = b"-----BEGIN PRIVATE KEY-----"
+AUTHENTICATOR_EXTERNAL_BROWSER: Literal["externalbrowser"] = "externalbrowser"
+AUTHENTICATOR_PARAM: Literal["authenticator"] = "authenticator"
 
 # connection keys that can be set using SNOWFLAKE_* env vars
 SUPPORTED_ENV_OVERRIDES = [
@@ -88,6 +90,32 @@ SUPPORTED_ENV_OVERRIDES = [
 CONNECTION_KEY_ALIASES = {"private_key_path": "private_key_file"}
 
 
+class _BufferedMirrorStream(io.StringIO):
+    """Buffer connector chatter while optionally mirroring to another stream."""
+
+    def __init__(self, mirror: Optional[TextIO] = None) -> None:
+        super().__init__()
+        self._mirror = mirror
+
+    def write(self, text: str) -> int:
+        text = text or ""
+        written = super().write(text)
+        if self._mirror is not None:
+            self._mirror.write(text)
+            self._mirror.flush()
+        return written
+
+    def flush(self) -> None:
+        super().flush()
+        if self._mirror is not None:
+            self._mirror.flush()
+
+    def isatty(self) -> bool:
+        if self._mirror is not None and hasattr(self._mirror, "isatty"):
+            return bool(self._mirror.isatty())
+        return False
+
+
 def _resolve_alias(key_or_alias: str):
     """
     Given the key of an override / env var, what key should it be set as in the connection parameters?
@@ -95,6 +123,24 @@ def _resolve_alias(key_or_alias: str):
     return CONNECTION_KEY_ALIASES.get(key_or_alias, key_or_alias)
 
 
+def _build_silent_streams(
+    connection_parameters: Dict,
+) -> tuple[_BufferedMirrorStream, _BufferedMirrorStream]:
+    """
+    Build stdout/stderr silent streams.
+
+    We must provide a writable stdout for authenticators (notably externalbrowser)
+    that prompt via input(); redirecting to None breaks sys.stdout.
+    For externalbrowser we mirror stdout to stderr so prompts remain visible
+    without polluting structured stdout (e.g., JSON output).
+    """
+    authenticator = str(connection_parameters.get(AUTHENTICATOR_PARAM, "")).lower()
+    mirror_stdout: Optional[TextIO] = (
+        sys.stderr if authenticator == AUTHENTICATOR_EXTERNAL_BROWSER else None
+    )
+    return _BufferedMirrorStream(mirror_stdout), _BufferedMirrorStream()
+
+
 def connect_to_snowflake(
     temporary_connection: bool = False,
     mfa_passcode: Optional[str] = None,
@@ -186,12 +232,16 @@ def connect_to_snowflake(
 
     _update_internal_application_info(connection_parameters)
 
+    silent_stdout, silent_stderr = _build_silent_streams(connection_parameters)
+
     try:
-        # Whatever output is generated when creating connection,
-        # we don't want it in our output. This is particularly important
-        # for cases when external browser and json format are used.
-        # Redirecting both stdout and stderr for offline usage.
-        with contextlib.redirect_stdout(None), contextlib.redirect_stderr(None):
+        # The output is redirected to silent stream for reuse
+        # in cases like externalbrowser auth not to pollute output
+        # in formats like JSON
+        with (
+            contextlib.redirect_stdout(silent_stdout),
+            contextlib.redirect_stderr(silent_stderr),
+        ):
             return snowflake.connector.connect(
                 application=command_info(),
                 **connection_parameters,

snowflake/cli/_plugins/dbt/commands.py

@@ -25,7 +25,11 @@ from snowflake.cli._plugins.dbt.constants import (
     PROFILES_FILENAME,
     RESULT_COLUMN_NAME,
 )
-from snowflake.cli._plugins.dbt.manager import DBTManager
+from snowflake.cli._plugins.dbt.manager import (
+    DBTDeployAttributes,
+    DBTManager,
+    SemanticVersionType,
+)
 from snowflake.cli._plugins.object.command_aliases import add_object_command_aliases
 from snowflake.cli._plugins.object.commands import scope_option
 from snowflake.cli.api.commands.decorators import global_options_with_connection
@@ -35,6 +39,7 @@ from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
 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.feature_flags import FeatureFlag
 from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.output.types import (
     CommandResult,
@@ -118,6 +123,14 @@ def deploy_dbt(
         show_default=False,
         help="Installs local dependencies from project that don't require external access.",
     ),
+    dbt_version: Optional[str] = typer.Option(
+        None,
+        "--dbt-version",
+        click_type=SemanticVersionType(),
+        show_default=False,
+        hidden=not FeatureFlag.ENABLE_DBT_VERSION.is_enabled(),
+        help="dbt version to use for the project, for example '1.9.4'.",
+    ),
     **options,
 ) -> CommandResult:
     """
@@ -127,18 +140,24 @@ def deploy_dbt(
         snow dbt deploy PROJECT
         snow dbt deploy PROJECT --source=/Users/jdoe/project --force
     """
+    if not FeatureFlag.ENABLE_DBT_VERSION.is_enabled():
+        dbt_version = None
     project_path = SecurePath(source) if source is not None else SecurePath.cwd()
     profiles_dir_path = SecurePath(profiles_dir) if profiles_dir else project_path
+    attrs = DBTDeployAttributes(
+        default_target=default_target,
+        unset_default_target=unset_default_target,
+        external_access_integrations=external_access_integrations,
+        install_local_deps=install_local_deps,
+        dbt_version=dbt_version,
+    )
     return QueryResult(
         DBTManager().deploy(
             name,
             path=project_path.resolve(),
             profiles_path=profiles_dir_path.resolve(),
             force=force,
-            default_target=default_target,
-            unset_default_target=unset_default_target,
-            external_access_integrations=external_access_integrations,
-            install_local_deps=install_local_deps,
+            attrs=attrs,
         )
     )
 
@@ -159,9 +178,17 @@ def before_callback(
     run_async: Optional[bool] = typer.Option(
         False, help="Run dbt command asynchronously and check it's result later."
     ),
+    dbt_version: Optional[str] = typer.Option(
+        None,
+        "--dbt-version",
+        click_type=SemanticVersionType(),
+        show_default=False,
+        hidden=not FeatureFlag.ENABLE_DBT_VERSION.is_enabled(),
+        help="dbt version to use for execution (ephemeral, does not change project configuration).",
+    ),
     **options,
 ):
-    """Handles global options passed before the command and takes pipeline name to be accessed through child context later"""
+    """Handles global options passed before the command and takes pipeline name to be accessed through child context later."""
     pass
 
 
@@ -182,7 +209,10 @@ for cmd in DBT_COMMANDS:
         dbt_command = ctx.command.name
         name = FQN.from_string(ctx.parent.params["name"])
         run_async = ctx.parent.params["run_async"]
-        execute_args = (dbt_command, name, run_async, *dbt_cli_args)
+        dbt_version = ctx.parent.params.get("dbt_version")
+        if not FeatureFlag.ENABLE_DBT_VERSION.is_enabled():
+            dbt_version = None
+        execute_args = (dbt_command, name, run_async, dbt_version, *dbt_cli_args)
         dbt_manager = DBTManager()
 
         if run_async is True:

snowflake/cli/_plugins/dbt/manager.py

@@ -14,11 +14,14 @@
 
 from __future__ import annotations
 
+import re
 from collections import defaultdict
+from dataclasses import dataclass
 from pathlib import Path
 from tempfile import TemporaryDirectory
 from typing import Dict, List, Optional, TypedDict
 
+import click
 import yaml
 from snowflake.cli._plugins.dbt.constants import PROFILES_FILENAME
 from snowflake.cli._plugins.object.manager import ObjectManager
@@ -32,10 +35,43 @@ from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.connector.cursor import SnowflakeCursor
 from snowflake.connector.errors import ProgrammingError
 
+SEMANTIC_VERSION_PATTERN = re.compile(r"^\d+\.\d+\.\d+$")
+
+
+class SemanticVersionType(click.ParamType):
+    """Custom Click type that validates semantic version format (major.minor.patch)."""
+
+    name = "VERSION"
+
+    def convert(self, value, param, ctx):
+        if value is None:
+            return None
+        if not isinstance(value, str):
+            self.fail(f"Expected string, got {type(value).__name__}.", param, ctx)
+        if not SEMANTIC_VERSION_PATTERN.match(value):
+            self.fail(
+                f"Invalid version format '{value}'. Expected format: major.minor.patch (e.g., '1.9.4').",
+                param,
+                ctx,
+            )
+        return value
+
 
 class DBTObjectEditableAttributes(TypedDict):
     default_target: Optional[str]
     external_access_integrations: Optional[List[str]]
+    dbt_version: Optional[str]
+
+
+@dataclass
+class DBTDeployAttributes:
+    """Attributes for deploying a DBT project."""
+
+    default_target: Optional[str] = None
+    unset_default_target: bool = False
+    external_access_integrations: Optional[List[str]] = None
+    install_local_deps: bool = False
+    dbt_version: Optional[str] = None
 
 
 class DBTManager(SqlExecutionMixin):
@@ -90,6 +126,7 @@ class DBTManager(SqlExecutionMixin):
         return DBTObjectEditableAttributes(
             default_target=row_dict.get("default_target"),
             external_access_integrations=external_access_integrations,
+            dbt_version=row_dict.get("dbt_version"),
         )
 
     def deploy(
@@ -98,10 +135,7 @@ class DBTManager(SqlExecutionMixin):
         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,
+        attrs: DBTDeployAttributes,
     ) -> SnowflakeCursor:
         dbt_project_path = path / "dbt_project.yml"
         if not dbt_project_path.exists():
@@ -116,7 +150,7 @@ class DBTManager(SqlExecutionMixin):
             except KeyError:
                 raise CliError("`profile` is not defined in dbt_project.yml")
 
-        self._validate_profiles(profiles_path, profile, default_target)
+        self._validate_profiles(profiles_path, profile, attrs.default_target)
 
         with cli_console.phase("Creating temporary stage"):
             stage_manager = StageManager()
@@ -140,43 +174,22 @@ class DBTManager(SqlExecutionMixin):
 
         with cli_console.phase("Creating DBT project"):
             if force is True:
-                return self._deploy_create_or_replace(
-                    fqn,
-                    stage_name,
-                    default_target,
-                    external_access_integrations,
-                    install_local_deps,
-                )
+                return self._deploy_create_or_replace(fqn, stage_name, attrs)
             else:
                 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,
+                        fqn, stage_name, dbt_object_attributes, attrs
                     )
                 else:
-                    return self._deploy_create(
-                        fqn,
-                        stage_name,
-                        default_target,
-                        external_access_integrations,
-                        install_local_deps,
-                    )
+                    return self._deploy_create(fqn, stage_name, attrs)
 
     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,
+        attrs: DBTDeployAttributes,
     ) -> SnowflakeCursor:
         query = f"ALTER DBT PROJECT {fqn} ADD VERSION"
         query += f"\nFROM {stage_name}"
@@ -186,28 +199,35 @@ class DBTManager(SqlExecutionMixin):
         unset_properties = []
 
         current_default_target = dbt_object_attributes.get("default_target")
-        if unset_default_target and current_default_target is not None:
+        if attrs.unset_default_target and current_default_target is not None:
             unset_properties.append("DEFAULT_TARGET")
-        elif default_target and (
+        elif attrs.default_target and (
             current_default_target is None
-            or current_default_target.lower() != default_target.lower()
+            or current_default_target.lower() != attrs.default_target.lower()
         ):
-            set_properties.append(f"DEFAULT_TARGET='{default_target}'")
+            set_properties.append(f"DEFAULT_TARGET='{attrs.default_target}'")
+
+        # Comparing dbt_version to existing project's dbt_version might be ambiguous
+        # if previously project was locked to just minor version and now user wants to
+        # lock it to a patch as well. If target version is provided, it's better to just
+        # apply it.
+        if attrs.dbt_version:
+            set_properties.append(f"DBT_VERSION='{attrs.dbt_version}'")
 
         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,
+            attrs.external_access_integrations,
+            attrs.install_local_deps,
         ):
-            if external_access_integrations:
-                integrations_str = ", ".join(sorted(external_access_integrations))
+            if attrs.external_access_integrations:
+                integrations_str = ", ".join(sorted(attrs.external_access_integrations))
                 set_properties.append(
                     f"EXTERNAL_ACCESS_INTEGRATIONS=({integrations_str})"
                 )
-            elif install_local_deps:
+            elif attrs.install_local_deps:
                 set_properties.append("EXTERNAL_ACCESS_INTEGRATIONS=()")
 
         if set_properties or unset_properties:
@@ -245,16 +265,16 @@ class DBTManager(SqlExecutionMixin):
         self,
         fqn: FQN,
         stage_name: str,
-        default_target: Optional[str],
-        external_access_integrations: Optional[List[str]],
-        install_local_deps: bool,
+        attrs: DBTDeployAttributes,
     ) -> SnowflakeCursor:
         query = f"CREATE DBT PROJECT {fqn}"
         query += f"\nFROM {stage_name}"
-        if default_target:
-            query += f" DEFAULT_TARGET='{default_target}'"
+        if attrs.default_target:
+            query += f" DEFAULT_TARGET='{attrs.default_target}'"
+        if attrs.dbt_version:
+            query += f" DBT_VERSION='{attrs.dbt_version}'"
         query = self._handle_external_access_integrations_query(
-            query, external_access_integrations, install_local_deps
+            query, attrs.external_access_integrations, attrs.install_local_deps
         )
         return self.execute_query(query)
 
@@ -276,16 +296,16 @@ class DBTManager(SqlExecutionMixin):
         self,
         fqn: FQN,
         stage_name: str,
-        default_target: Optional[str],
-        external_access_integrations: Optional[List[str]],
-        install_local_deps: bool,
+        attrs: DBTDeployAttributes,
     ) -> SnowflakeCursor:
         query = f"CREATE OR REPLACE DBT PROJECT {fqn}"
         query += f"\nFROM {stage_name}"
-        if default_target:
-            query += f" DEFAULT_TARGET='{default_target}'"
+        if attrs.default_target:
+            query += f" DEFAULT_TARGET='{attrs.default_target}'"
+        if attrs.dbt_version:
+            query += f" DBT_VERSION='{attrs.dbt_version}'"
         query = self._handle_external_access_integrations_query(
-            query, external_access_integrations, install_local_deps
+            query, attrs.external_access_integrations, attrs.install_local_deps
         )
         return self.execute_query(query)
 
@@ -379,13 +399,21 @@ class DBTManager(SqlExecutionMixin):
             yaml.safe_dump(yaml.safe_load(sfd), tfd)
 
     def execute(
-        self, dbt_command: str, name: FQN, run_async: bool, *dbt_cli_args
+        self,
+        dbt_command: str,
+        name: FQN,
+        run_async: bool,
+        dbt_version: Optional[str] = None,
+        *dbt_cli_args,
     ) -> SnowflakeCursor:
         if dbt_cli_args:
             processed_args = self._process_dbt_args(dbt_cli_args)
             dbt_command = f"{dbt_command} {processed_args}".strip()
         dbt_command_escaped = dbt_command.replace("'", "\\'")
-        query = f"EXECUTE DBT PROJECT {name} args='{dbt_command_escaped}'"
+        query = f"EXECUTE DBT PROJECT {name}"
+        if dbt_version:
+            query += f" dbt_version='{dbt_version}'"
+        query += f" args='{dbt_command_escaped}'"
         return self.execute_query(query, _exec_async=run_async)
 
     @staticmethod

snowflake/cli/_plugins/dcm/commands.py

@@ -15,6 +15,8 @@ from typing import List, Optional
 
 import typer
 from snowflake.cli._plugins.dcm.manager import DCMProjectManager
+from snowflake.cli._plugins.dcm.reporters import RefreshReporter, TestReporter
+from snowflake.cli._plugins.dcm.utils import mock_dcm_response
 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
@@ -36,6 +38,7 @@ from snowflake.cli.api.exceptions import CliError
 from snowflake.cli.api.feature_flags import FeatureFlag
 from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.output.types import (
+    EmptyResult,
     MessageResult,
     QueryJsonValueResult,
     QueryResult,
@@ -287,6 +290,41 @@ def preview(
     return QueryResult(result)
 
 
+@app.command(requires_connection=True)
+@mock_dcm_response("refresh")
+def refresh(
+    identifier: FQN = dcm_identifier,
+    **options,
+):
+    """
+    Refreshes dynamic tables defined in DCM project.
+    """
+    with cli_console.spinner() as spinner:
+        spinner.add_task(description=f"Refreshing dcm project {identifier}", total=None)
+        result = DCMProjectManager().refresh(project_identifier=identifier)
+
+    RefreshReporter().process(result)
+    return EmptyResult()
+
+
+@app.command(requires_connection=True)
+@mock_dcm_response("test")
+def test(
+    identifier: FQN = dcm_identifier,
+    **options,
+):
+    """
+    Tests all expectations defined in DCM project.
+    """
+    with cli_console.spinner() as spinner:
+        spinner.add_task(description=f"Testing dcm project {identifier}", total=None)
+        result = DCMProjectManager().test(project_identifier=identifier)
+
+    reporter = TestReporter()
+    reporter.process(result)
+    return EmptyResult()
+
+
 def _get_effective_stage(identifier: FQN, from_location: Optional[str]):
     manager = DCMProjectManager()
     if not from_location:

snowflake/cli/_plugins/dcm/manager.py

@@ -160,6 +160,14 @@ class DCMProjectManager(SqlExecutionMixin):
             query += f" LIMIT {limit}"
         return self.execute_query(query=query)
 
+    def refresh(self, project_identifier: FQN):
+        query = f"EXECUTE DCM PROJECT {project_identifier.sql_identifier} REFRESH ALL"
+        return self.execute_query(query=query)
+
+    def test(self, project_identifier: FQN):
+        query = f"EXECUTE DCM PROJECT {project_identifier.sql_identifier} TEST ALL"
+        return self.execute_query(query=query)
+
     @staticmethod
     def _get_from_stage_query(from_stage: str) -> str:
         stage_path = StagePath.from_stage_str(from_stage)