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

snowflake/cli/__about__.py

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

snowflake/cli/_app/cli_app.py

@@ -14,6 +14,7 @@
 
 from __future__ import annotations
 
+import inspect
 import logging
 import os
 import platform
@@ -47,6 +48,20 @@ from snowflake.connector.config_manager import CONFIG_MANAGER
 
 log = logging.getLogger(__name__)
 
+INTERNAL_CLI_FLAGS = {
+    "custom_help",
+    "version",
+    "docs",
+    "structure",
+    "info",
+    "configuration_file",
+    "pycharm_debug_library_path",
+    "pycharm_debug_server_host",
+    "pycharm_debug_server_port",
+    "disable_external_command_plugins",
+    "commands_registration",
+}
+
 
 def _do_not_execute_on_completion(callback):
     def enriched_callback(value):
@@ -256,7 +271,6 @@ class CliAppFactory:
                 "--commands-registration",
                 help="Commands registration",
                 hidden=True,
-                is_eager=True,
                 callback=self._commands_registration_callback(),
             ),
         ) -> None:
@@ -271,8 +285,36 @@ class CliAppFactory:
                 pycharm_debug_server_port=pycharm_debug_server_port,
             )
 
+        self._validate_internal_flags_excluded_from_telemetry(default)
+
         self._app = app
         return app
 
+    @staticmethod
+    def _validate_internal_flags_excluded_from_telemetry(callback_function):
+        """
+        We have not been interested in collecting telemetry data about root
+        command flags (most of which are internal flags). This method validates
+        that all new flags should be added to INTERNAL_CLI_FLAGS and thus
+        excluded from telemetry as well.
+        """
+        sig = inspect.signature(callback_function)
+        actual_params = {name for name in sig.parameters.keys() if name != "ctx"}
+        if actual_params != INTERNAL_CLI_FLAGS:
+            missing = actual_params - INTERNAL_CLI_FLAGS
+            extra = INTERNAL_CLI_FLAGS - actual_params
+            error_parts = []
+            if missing:
+                error_parts.append(
+                    f"Parameters in default() but not in INTERNAL_CLI_FLAGS: {missing}"
+                )
+            if extra:
+                error_parts.append(
+                    f"Flags in INTERNAL_CLI_FLAGS but not in default(): {extra}"
+                )
+            raise AssertionError(
+                "INTERNAL_CLI_FLAGS mismatch! " + ". ".join(error_parts)
+            )
+
     def get_click_context(self):
         return self._click_context

snowflake/cli/_app/commands_registration/builtin_plugins.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from snowflake.cli._plugins.auth.keypair import plugin_spec as auth_plugin_spec
+from snowflake.cli._plugins.auth import plugin_spec as auth_plugin_spec
 from snowflake.cli._plugins.connection import plugin_spec as connection_plugin_spec
 from snowflake.cli._plugins.cortex import plugin_spec as cortex_plugin_spec
 from snowflake.cli._plugins.dbt import plugin_spec as dbt_plugin_spec

snowflake/cli/_app/commands_registration/command_plugins_loader.py

@@ -69,7 +69,20 @@ class CommandPluginsLoader:
                 )
 
     def load_all_registered_plugins(self) -> List[LoadedCommandPlugin]:
-        for plugin_name, plugin in self._plugin_manager.list_name_plugin():
+        all_plugins = list(self._plugin_manager.list_name_plugin())
+        builtin_plugin_names = set(get_builtin_plugin_name_to_plugin_spec().keys())
+
+        def plugin_sort_key(name_plugin_tuple):
+            _plugin_name, _ = name_plugin_tuple
+            is_builtin = _plugin_name in builtin_plugin_names
+            return (
+                not is_builtin,
+                _plugin_name,
+            )
+
+        sorted_plugins = sorted(all_plugins, key=plugin_sort_key)
+
+        for plugin_name, plugin in sorted_plugins:
             self._load_plugin(plugin_name, plugin)
         return list(self._loaded_plugins.values())
 

snowflake/cli/_app/printing.py

@@ -22,7 +22,7 @@ from decimal import Decimal
 from json import JSONEncoder
 from pathlib import Path
 from textwrap import indent
-from typing import TextIO
+from typing import Any, Dict, TextIO
 
 from rich import box, get_console
 from rich import print as rich_print
@@ -61,13 +61,114 @@ class CustomJSONEncoder(JSONEncoder):
             return list(o.result)
         if isinstance(o, (date, datetime, time)):
             return o.isoformat()
-        if isinstance(o, (Path, Decimal)):
+        if isinstance(o, Path):
+            return o.as_posix()
+        if isinstance(o, Decimal):
             return str(o)
         if isinstance(o, bytearray):
             return o.hex()
         return super().default(o)
 
 
+class StreamingJSONEncoder(JSONEncoder):
+    """Streaming JSON encoder that doesn't materialize generators into lists"""
+
+    def default(self, o):
+        if isinstance(o, str):
+            return sanitize_for_terminal(o)
+        if isinstance(o, (ObjectResult, MessageResult)):
+            return o.result
+        if isinstance(o, (CollectionResult, MultipleResults)):
+            raise TypeError(
+                f"CollectionResult should be handled by streaming functions, not encoder"
+            )
+        if isinstance(o, (date, datetime, time)):
+            return o.isoformat()
+        if isinstance(o, Path):
+            return o.as_posix()
+        if isinstance(o, Decimal):
+            return str(o)
+        if isinstance(o, bytearray):
+            return o.hex()
+        return super().default(o)
+
+
+def _print_json_item_with_array_indentation(item: Any, indent: int):
+    """Print a JSON item with proper indentation for array context"""
+    if indent:
+        indented_output = json.dumps(item, cls=StreamingJSONEncoder, indent=indent)
+        indented_lines = indented_output.split("\n")
+        for i, line in enumerate(indented_lines):
+            if i == 0:
+                print(" " * indent + line, end="")
+            else:
+                print("\n" + " " * indent + line, end="")
+    else:
+        json.dump(item, sys.stdout, cls=StreamingJSONEncoder, separators=(",", ":"))
+
+
+def _stream_collection_as_json(result: CollectionResult, indent: int = 4):
+    """Stream a CollectionResult as a JSON array without loading all data into memory"""
+    items = iter(result.result)
+    try:
+        first_item = next(items)
+    except StopIteration:
+        print("[]", end="")
+        return
+
+    print("[")
+
+    _print_json_item_with_array_indentation(first_item, indent)
+
+    for item in items:
+        print(",")
+        _print_json_item_with_array_indentation(item, indent)
+
+    print("\n]", end="")
+
+
+def _stream_collection_as_csv(result: CollectionResult):
+    """Stream a CollectionResult as CSV without loading all data into memory"""
+    items = iter(result.result)
+    try:
+        first_item = next(items)
+    except StopIteration:
+        return
+
+    fieldnames = list(first_item.keys())
+    if not isinstance(first_item, dict):
+        raise TypeError("CSV output requires dictionary items")
+
+    writer = csv.DictWriter(sys.stdout, fieldnames=fieldnames, lineterminator="\n")
+    writer.writeheader()
+    _write_csv_row(writer, first_item)
+
+    for item in items:
+        _write_csv_row(writer, item)
+
+
+def _write_csv_row(writer: csv.DictWriter, row_data: Dict[str, Any]):
+    """Write a single CSV row, handling special data types"""
+    processed_row = {}
+    for key, value in row_data.items():
+        if isinstance(value, str):
+            processed_row[key] = sanitize_for_terminal(value)
+        elif isinstance(value, (date, datetime, time)):
+            processed_row[key] = value.isoformat()
+        elif isinstance(value, Path):
+            processed_row[key] = value.as_posix()
+        elif isinstance(value, Decimal):
+            processed_row[key] = str(value)
+        elif isinstance(value, bytearray):
+            processed_row[key] = value.hex()
+        elif value is None:
+            processed_row[key] = ""
+        else:
+            processed_row[key] = str(value)
+
+    writer.writerow(processed_row)
+
+
 def _get_format_type() -> OutputFormat:
     output_format = get_cli_context().output_format
     if output_format:
@@ -110,12 +211,13 @@ def is_structured_format(output_format):
 def print_structured(
     result: CommandResult, output_format: OutputFormat = OutputFormat.JSON
 ):
-    """Handles outputs like json, yml and other structured and parsable formats."""
+    """Handles outputs like json, csv and other structured and parsable formats with streaming."""
     printed_end_line = False
+
     if isinstance(result, MultipleResults):
         if output_format == OutputFormat.CSV:
             for command_result in result.result:
-                _print_csv_result(command_result)
+                _print_csv_result_streaming(command_result)
                 print(flush=True)
             printed_end_line = True
         else:
@@ -125,35 +227,67 @@ def print_structured(
         # instead of joining all the values into a JSON array or CSV entry set
         for r in result.result:
             if output_format == OutputFormat.CSV:
-                _print_csv_result(r.result)
+                _print_csv_result_streaming(r)
             else:
-                json.dump(r, sys.stdout, cls=CustomJSONEncoder)
+                json.dump(r, sys.stdout, cls=StreamingJSONEncoder)
             print(flush=True)
             printed_end_line = True
     else:
         if output_format == OutputFormat.CSV:
-            _print_csv_result(result)
+            _print_csv_result_streaming(result)
             printed_end_line = True
         else:
-            json.dump(result, sys.stdout, cls=CustomJSONEncoder, indent=4)
+            _print_json_result_streaming(result)
+
     # Adds empty line at the end
     if not printed_end_line:
         print(flush=True)
 
 
-def _print_csv_result(result: CommandResult):
-    data = json.loads(json.dumps(result, cls=CustomJSONEncoder))
+def _print_json_result_streaming(result: CommandResult):
+    """Print a single CommandResult as JSON with streaming support"""
+    if isinstance(result, CollectionResult):
+        _stream_collection_as_json(result, indent=4)
+    elif isinstance(result, (ObjectResult, MessageResult)):
+        json.dump(result, sys.stdout, cls=StreamingJSONEncoder, indent=4)
+    else:
+        json.dump(result, sys.stdout, cls=StreamingJSONEncoder, indent=4)
+
+
+def _print_object_result_as_csv(result: ObjectResult):
+    """Print an ObjectResult as a single-row CSV.
+
+    Converts the object's key-value pairs into a CSV with headers
+    from the keys and a single data row from the values.
+    """
+    data = result.result
     if isinstance(data, dict):
-        writer = csv.DictWriter(sys.stdout, [*data], lineterminator="\n")
-        writer.writeheader()
-        writer.writerow(data)
-    elif isinstance(data, list):
-        if not data:
-            return
-        writer = csv.DictWriter(sys.stdout, [*data[0]], lineterminator="\n")
+        writer = csv.DictWriter(
+            sys.stdout, fieldnames=list(data.keys()), lineterminator="\n"
+        )
         writer.writeheader()
-        for entry in data:
-            writer.writerow(entry)
+        _write_csv_row(writer, data)
+
+
+def _print_message_result_as_csv(result: MessageResult):
+    """Print a MessageResult as CSV with a single 'message' column.
+
+    Creates a simple CSV structure with one column named 'message'
+    containing the sanitized message text.
+    """
+    writer = csv.DictWriter(sys.stdout, fieldnames=["message"], lineterminator="\n")
+    writer.writeheader()
+    writer.writerow({"message": sanitize_for_terminal(result.message)})
+
+
+def _print_csv_result_streaming(result: CommandResult):
+    """Print a single CommandResult as CSV with streaming support"""
+    if isinstance(result, CollectionResult):
+        _stream_collection_as_csv(result)
+    elif isinstance(result, ObjectResult):
+        _print_object_result_as_csv(result)
+    elif isinstance(result, MessageResult):
+        _print_message_result_as_csv(result)
 
 
 def _stream_json(result):

snowflake/cli/_app/telemetry.py

@@ -18,11 +18,12 @@ import os
 import platform
 import sys
 from enum import Enum, unique
-from typing import Any, Dict, Union
+from typing import Any, Dict, Optional, Union
 
 import click
 import typer
 from snowflake.cli import __about__
+from snowflake.cli._app.cli_app import INTERNAL_CLI_FLAGS
 from snowflake.cli._app.constants import PARAM_APPLICATION_NAME
 from snowflake.cli.api.cli_global_context import (
     _CliGlobalContextAccess,
@@ -38,6 +39,7 @@ from snowflake.connector.telemetry import (
     TelemetryField,
 )
 from snowflake.connector.time_util import get_time_millis
+from typer import Context
 
 
 @unique
@@ -140,17 +142,30 @@ def _get_command_metrics() -> TelemetryDict:
 def _find_command_info() -> TelemetryDict:
     ctx = click.get_current_context()
     command_path = ctx.command_path.split(" ")[1:]
+
+    command_flags = {}
+    format_value = None
+    current_ctx: Optional[Context] = ctx
+    while current_ctx:
+        for flag, flag_value in current_ctx.params.items():
+            if (
+                flag_value
+                and flag not in command_flags
+                and flag not in INTERNAL_CLI_FLAGS
+            ):
+                command_flags[flag] = current_ctx.get_parameter_source(flag).name  # type: ignore[attr-defined]
+        if format_value is None and "format" in current_ctx.params:
+            format_value = current_ctx.params["format"]
+        current_ctx = current_ctx.parent
+
+    if format_value is None:
+        format_value = OutputFormat.TABLE
+
     return {
         CLITelemetryField.COMMAND: command_path,
         CLITelemetryField.COMMAND_GROUP: command_path[0],
-        CLITelemetryField.COMMAND_FLAGS: {
-            k: ctx.get_parameter_source(k).name  # type: ignore[attr-defined]
-            for k, v in ctx.params.items()
-            if v  # noqa
-        },
-        CLITelemetryField.COMMAND_OUTPUT_TYPE: ctx.params.get(
-            "format", OutputFormat.TABLE
-        ).value,
+        CLITelemetryField.COMMAND_FLAGS: command_flags,
+        CLITelemetryField.COMMAND_OUTPUT_TYPE: format_value.value,
         CLITelemetryField.PROJECT_DEFINITION_VERSION: str(_get_definition_version()),
         CLITelemetryField.MODE: _get_cli_running_mode(),
     }
@@ -227,7 +242,7 @@ class CLITelemetryClient:
             **telemetry_payload,
         }
         # To map Enum to string, so we don't have to use .value every time
-        return {getattr(k, "value", k): v for k, v in data.items()}  # type: ignore[arg-type]
+        return {getattr(k, "value", k): v for k, v in data.items()}  # type: ignore[arg-type, misc]
 
     @property
     def _telemetry(self):

snowflake/cli/_plugins/auth/__init__.py

@@ -1,4 +1,3 @@
-from snowflake.cli._plugins.auth.keypair.commands import app as keypair_app
 from snowflake.cli._plugins.auth.oidc.commands import (
     app as oidc_app,
 )
@@ -9,5 +8,4 @@ app = SnowTyperFactory(
     help="Manages authentication methods.",
 )
 
-app.add_typer(keypair_app)
 app.add_typer(oidc_app)

snowflake/cli/_plugins/connection/commands.py

@@ -16,9 +16,8 @@ from __future__ import annotations
 
 import logging
 import os.path
-from copy import deepcopy
 from pathlib import Path
-from typing import Dict, Optional, Tuple
+from typing import Optional
 
 import typer
 from click import (  # type: ignore
@@ -29,14 +28,10 @@ from click import (  # type: ignore
 )
 from click.core import ParameterSource  # type: ignore
 from snowflake import connector
-from snowflake.cli._app.snow_connector import connect_to_snowflake
-from snowflake.cli._plugins.auth.keypair.commands import KEY_PAIR_DEFAULT_PATH
-from snowflake.cli._plugins.auth.keypair.manager import AuthManager
 from snowflake.cli._plugins.connection.util import (
     strip_if_value_present,
 )
 from snowflake.cli._plugins.object.manager import ObjectManager
-from snowflake.cli.api import exceptions
 from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.commands.flags import (
     PLAIN_PASSWORD_MSG,
@@ -69,15 +64,12 @@ from snowflake.cli.api.config import (
 )
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.constants import ObjectType
-from snowflake.cli.api.feature_flags import FeatureFlag
 from snowflake.cli.api.output.types import (
     CollectionResult,
     CommandResult,
     MessageResult,
     ObjectResult,
 )
-from snowflake.cli.api.secret import SecretType
-from snowflake.cli.api.secure_path import SecurePath
 from snowflake.connector import ProgrammingError
 from snowflake.connector.constants import CONNECTIONS_FILE
 
@@ -302,13 +294,6 @@ def add(
     if connection_exists(connection_name):
         raise UsageError(f"Connection {connection_name} already exists")
 
-    if FeatureFlag.ENABLE_AUTH_KEYPAIR.is_enabled() and not no_interactive:
-        connection_options, keypair_error = _extend_add_with_key_pair(
-            connection_name, connection_options
-        )
-    else:
-        keypair_error = ""
-
     connections_file = add_connection_to_proper_file(
         connection_name,
         ConnectionConfig(**connection_options),
@@ -316,12 +301,6 @@ def add(
     if set_as_default:
         set_config_value(path=["default_connection_name"], value=connection_name)
 
-    if keypair_error:
-        return MessageResult(
-            f"Wrote new password-based connection {connection_name} to {connections_file}, "
-            f"however there were some issues during key pair setup. Review the following error and check 'snow auth keypair' "
-            f"commands to setup key pair authentication:\n * {keypair_error}"
-        )
     return MessageResult(
         f"Wrote new connection {connection_name} to {connections_file}"
     )
@@ -459,59 +438,3 @@ def generate_jwt(
         return MessageResult(token)
     except (ValueError, TypeError) as err:
         raise ClickException(str(err))
-
-
-def _extend_add_with_key_pair(
-    connection_name: str, connection_options: Dict
-) -> Tuple[Dict, str]:
-    if not _should_extend_with_key_pair(connection_options):
-        return connection_options, ""
-
-    configure_key_pair = typer.confirm(
-        "Do you want to configure key pair authentication?",
-        default=False,
-    )
-    if not configure_key_pair:
-        return connection_options, ""
-
-    key_length = typer.prompt(
-        "Key length",
-        default=2048,
-        show_default=True,
-    )
-
-    output_path = typer.prompt(
-        "Output path",
-        default=KEY_PAIR_DEFAULT_PATH,
-        show_default=True,
-        value_proc=lambda value: SecurePath(value),
-    )
-    private_key_passphrase = typer.prompt(
-        "Private key passphrase",
-        default="",
-        hide_input=True,
-        show_default=False,
-        value_proc=lambda value: SecretType(value),
-    )
-    connection = connect_to_snowflake(temporary_connection=True, **connection_options)
-    try:
-        connection_options = AuthManager(connection=connection).extend_connection_add(
-            connection_name=connection_name,
-            connection_options=deepcopy(connection_options),
-            key_length=key_length,
-            output_path=output_path,
-            private_key_passphrase=private_key_passphrase,
-        )
-    except exceptions.CouldNotSetKeyPairError:
-        return connection_options, "The public key is set already."
-    except Exception as e:
-        return connection_options, str(e)
-    return connection_options, ""
-
-
-def _should_extend_with_key_pair(connection_options: Dict) -> bool:
-    return (
-        connection_options.get("password") is not None
-        and connection_options.get("private_key_file") is None
-        and connection_options.get("private_key_path") is None
-    )

snowflake/cli/_plugins/dbt/commands.py

@@ -19,7 +19,6 @@ from typing import Optional
 
 import typer
 from click import types
-from rich.progress import Progress, SpinnerColumn, TextColumn
 from snowflake.cli._plugins.dbt.constants import (
     DBT_COMMANDS,
     OUTPUT_COLUMN_NAME,
@@ -31,10 +30,11 @@ from snowflake.cli._plugins.object.command_aliases import add_object_command_ali
 from snowflake.cli._plugins.object.commands import scope_option
 from snowflake.cli.api.commands.decorators import global_options_with_connection
 from snowflake.cli.api.commands.flags import identifier_argument, like_option
+from snowflake.cli.api.commands.overrideable_parameter import OverrideableOption
 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,
@@ -46,8 +46,6 @@ from snowflake.cli.api.secure_path import SecurePath
 app = SnowTyperFactory(
     name="dbt",
     help="Manages dbt on Snowflake projects.",
-    is_hidden=FeatureFlag.ENABLE_DBT.is_disabled,
-    preview=True,
 )
 log = logging.getLogger(__name__)
 
@@ -59,6 +57,16 @@ DBTNameArgument = identifier_argument(sf_object="DBT Project", example="my_pipel
 DBTNameOrCommandArgument = identifier_argument(
     sf_object="DBT Project", example="my_pipeline", click_type=types.StringParamType()
 )
+DefaultTargetOption = OverrideableOption(
+    None,
+    "--default-target",
+    mutually_exclusive=["unset_default_target"],
+)
+UnsetDefaultTargetOption = OverrideableOption(
+    False,
+    "--unset-default-target",
+    mutually_exclusive=["default_target"],
+)
 
 add_object_command_aliases(
     app=app,
@@ -68,7 +76,7 @@ add_object_command_aliases(
         help_example='`list --like "my%"` lists all dbt projects that begin with "my"'
     ),
     scope_option=scope_option(help_example="`list --in database my_db`"),
-    ommit_commands=["drop", "create", "describe"],
+    ommit_commands=["create"],
 )
 
 
@@ -92,21 +100,45 @@ def deploy_dbt(
         False,
         help="Overwrites conflicting files in the project, if any.",
     ),
+    default_target: Optional[str] = DefaultTargetOption(
+        help="Default target for the dbt project. Mutually exclusive with --unset-default-target.",
+    ),
+    unset_default_target: Optional[bool] = UnsetDefaultTargetOption(
+        help="Unset the default target for the dbt project. Mutually exclusive with --default-target.",
+    ),
+    external_access_integrations: Optional[list[str]] = typer.Option(
+        None,
+        "--external-access-integration",
+        show_default=False,
+        help="External access integration to be used by the dbt object.",
+    ),
+    install_local_deps: Optional[bool] = typer.Option(
+        False,
+        "--install-local-deps",
+        show_default=False,
+        help="Installs local dependencies from project that don't require external access.",
+    ),
     **options,
 ) -> CommandResult:
     """
-    Copy dbt files and either recreate dbt on Snowflake if `--force` flag is
-    provided; or create a new one if it doesn't exist; or update files and
-    create a new version if it exists.
+    Upload local dbt project files and create or update a DBT project object on Snowflake.
+
+    Examples:
+        snow dbt deploy PROJECT
+        snow dbt deploy PROJECT --source=/Users/jdoe/project --force
     """
     project_path = SecurePath(source) if source is not None else SecurePath.cwd()
     profiles_dir_path = SecurePath(profiles_dir) if profiles_dir else project_path
     return QueryResult(
         DBTManager().deploy(
             name,
-            project_path.resolve(),
-            profiles_dir_path.resolve(),
+            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,
         )
     )
 
@@ -116,7 +148,6 @@ dbt_execute_app = SnowTyperFactory(
     help="Execute a dbt command on Snowflake. Subcommand name and all "
     "parameters following it will be passed over to dbt.",
     subcommand_metavar="DBT_COMMAND",
-    preview=True,
 )
 app.add_typer(dbt_execute_app)
 
@@ -143,7 +174,6 @@ for cmd in DBT_COMMANDS:
         context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
         help=f"Execute {cmd} command on Snowflake. Command name and all parameters following it will be passed over to dbt.",
         add_help_option=False,
-        preview=True,
     )
     def _dbt_execute(
         ctx: typer.Context,
@@ -161,13 +191,8 @@ for cmd in DBT_COMMANDS:
                 f"Command submitted. You can check the result with `snow sql -q \"select execution_status from table(information_schema.query_history_by_user()) where query_id in ('{result.sfqid}');\"`"
             )
 
-        with Progress(
-            SpinnerColumn(),
-            TextColumn("[progress.description]{task.description}"),
-            transient=True,
-        ) as progress:
-            progress.add_task(description=f"Executing 'dbt {dbt_command}'", total=None)
-
+        with cli_console.spinner() as spinner:
+            spinner.add_task(description=f"Executing 'dbt {dbt_command}'", total=None)
             result = dbt_manager.execute(*execute_args)
 
             try: