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

snowflake/cli/__about__.py

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

snowflake/cli/_app/commands_registration/builtin_plugins.py

@@ -16,6 +16,7 @@ from snowflake.cli._plugins.auth.keypair 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
+from snowflake.cli._plugins.dcm import plugin_spec as dcm_project_plugin_spec
 from snowflake.cli._plugins.git import plugin_spec as git_plugin_spec
 from snowflake.cli._plugins.helpers import plugin_spec as migrate_plugin_spec
 from snowflake.cli._plugins.init import plugin_spec as init_plugin_spec
@@ -24,7 +25,6 @@ from snowflake.cli._plugins.nativeapp import plugin_spec as nativeapp_plugin_spe
 from snowflake.cli._plugins.notebook import plugin_spec as notebook_plugin_spec
 from snowflake.cli._plugins.object import plugin_spec as object_plugin_spec
 from snowflake.cli._plugins.plugin import plugin_spec as plugin_plugin_spec
-from snowflake.cli._plugins.project import plugin_spec as project_plugin_spec
 from snowflake.cli._plugins.snowpark import plugin_spec as snowpark_plugin_spec
 from snowflake.cli._plugins.spcs import plugin_spec as spcs_plugin_spec
 from snowflake.cli._plugins.sql import plugin_spec as sql_plugin_spec
@@ -42,7 +42,7 @@ def get_builtin_plugin_name_to_plugin_spec():
         "spcs": spcs_plugin_spec,
         "app": nativeapp_plugin_spec,
         "object": object_plugin_spec,
-        "project": project_plugin_spec,
+        "dcm": dcm_project_plugin_spec,
         "snowpark": snowpark_plugin_spec,
         "stage": stage_plugin_spec,
         "sql": sql_plugin_spec,

snowflake/cli/_app/printing.py

@@ -14,9 +14,11 @@
 
 from __future__ import annotations
 
+import csv
 import json
 import sys
-from datetime import date, datetime
+from datetime import date, datetime, time
+from decimal import Decimal
 from json import JSONEncoder
 from pathlib import Path
 from textwrap import indent
@@ -57,10 +59,12 @@ class CustomJSONEncoder(JSONEncoder):
             return o.result
         if isinstance(o, (CollectionResult, MultipleResults)):
             return list(o.result)
-        if isinstance(o, (date, datetime)):
+        if isinstance(o, (date, datetime, time)):
             return o.isoformat()
-        if isinstance(o, Path):
+        if isinstance(o, (Path, Decimal)):
             return str(o)
+        if isinstance(o, bytearray):
+            return o.hex()
         return super().default(o)
 
 
@@ -86,36 +90,72 @@ def _print_multiple_table_results(obj: CollectionResult):
     for column in first_item.keys():
         table.add_column(column, overflow="fold")
     with Live(table, refresh_per_second=4):
-        table.add_row(*[str(i) for i in first_item.values()])
+        table.add_row(*[__to_str(i) for i in first_item.values()])
         for item in items:
-            table.add_row(*[str(i) for i in item.values()])
+            table.add_row(*[__to_str(i) for i in item.values()])
     # Add separator between tables
     rich_print(flush=True)
 
 
+def __to_str(val):
+    if isinstance(val, bytearray):
+        return val.hex()
+    return str(val)
+
+
 def is_structured_format(output_format):
-    return output_format == OutputFormat.JSON
+    return output_format.is_json or output_format == OutputFormat.CSV
 
 
-def print_structured(result: CommandResult):
+def print_structured(
+    result: CommandResult, output_format: OutputFormat = OutputFormat.JSON
+):
     """Handles outputs like json, yml and other structured and parsable formats."""
     printed_end_line = False
     if isinstance(result, MultipleResults):
-        _stream_json(result)
+        if output_format == OutputFormat.CSV:
+            for command_result in result.result:
+                _print_csv_result(command_result)
+                print(flush=True)
+            printed_end_line = True
+        else:
+            _stream_json(result)
     elif isinstance(result, StreamResult):
         # A StreamResult prints each value onto its own line
-        # instead of joining all the values into a JSON array
+        # instead of joining all the values into a JSON array or CSV entry set
         for r in result.result:
-            json.dump(r, sys.stdout, cls=CustomJSONEncoder)
+            if output_format == OutputFormat.CSV:
+                _print_csv_result(r.result)
+            else:
+                json.dump(r, sys.stdout, cls=CustomJSONEncoder)
             print(flush=True)
             printed_end_line = True
     else:
-        json.dump(result, sys.stdout, cls=CustomJSONEncoder, indent=4)
+        if output_format == OutputFormat.CSV:
+            _print_csv_result(result)
+            printed_end_line = True
+        else:
+            json.dump(result, sys.stdout, cls=CustomJSONEncoder, indent=4)
     # 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))
+    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.writeheader()
+        for entry in data:
+            writer.writerow(entry)
+
+
 def _stream_json(result):
     """Simple helper for streaming multiple results as a JSON."""
     indent_size = 2
@@ -160,7 +200,7 @@ def _print_single_table(obj):
     table.add_column("value", overflow="fold")
     for key, value in obj.result.items():
         table.add_row(
-            sanitize_for_terminal(str(key)), sanitize_for_terminal(str(value))
+            sanitize_for_terminal(str(key)), sanitize_for_terminal(__to_str(value))
         )
     rich_print(table, flush=True)
 
@@ -168,7 +208,7 @@ 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)
+        print_structured(cmd_result, output_format)
     elif isinstance(cmd_result, (MultipleResults, StreamResult)):
         for res in cmd_result.result:
             print_result(res)

snowflake/cli/_app/snow_connector.py

@@ -63,6 +63,7 @@ SUPPORTED_ENV_OVERRIDES = [
     "warehouse",
     "session_token",
     "master_token",
+    "token",
     "token_file_path",
     "oauth_client_id",
     "oauth_client_secret",

snowflake/cli/_app/telemetry.py

@@ -178,6 +178,8 @@ def _get_definition_version() -> str | None:
 
 
 def _get_ci_environment_type() -> str:
+    if "SF_GITHUB_ACTION" in os.environ:
+        return "SF_GITHUB_ACTION"
     if "GITHUB_ACTIONS" in os.environ:
         return "GITHUB_ACTIONS"
     if "GITLAB_CI" in os.environ:

snowflake/cli/_app/version_check.py

@@ -6,18 +6,54 @@ import requests
 from packaging.version import Version
 from snowflake.cli.__about__ import VERSION
 from snowflake.cli.api.cli_global_context import get_cli_context
+from snowflake.cli.api.config import (
+    CLI_SECTION,
+    IGNORE_NEW_VERSION_WARNING_KEY,
+    get_config_bool_value,
+)
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.connector.config_manager import CONFIG_MANAGER
 
 REPOSITORY_URL_PIP = "https://pypi.org/pypi/snowflake-cli/json"
 REPOSITORY_URL_BREW = "https://formulae.brew.sh/api/formula/snowflake-cli.json"
 
+# How often to refresh the version cache (seconds)
+VERSION_CACHE_REFRESH_INTERVAL = 60 * 60  # 1 hour
+# How often to show the new version message (seconds)
+NEW_VERSION_MESSAGE_INTERVAL = 60 * 60 * 24 * 7  # 1 week
+
+
+def should_ignore_new_version_warning() -> bool:
+    return get_config_bool_value(
+        CLI_SECTION, key=IGNORE_NEW_VERSION_WARNING_KEY, default=False
+    )
+
+
+def was_warning_shown_recently(last_time_shown: float | int | None) -> bool:
+    """
+    Returns True if the new version warning was shown recently (within the interval),
+    meaning we should NOT show the warning again yet.
+    """
+    if not last_time_shown:
+        return False
+    now = time.time()
+    return last_time_shown >= now - NEW_VERSION_MESSAGE_INTERVAL
+
 
 def get_new_version_msg() -> str | None:
-    last = _VersionCache().get_last_version()
-    current = Version(VERSION)
-    if last and last > current:
-        return f"\nNew version of Snowflake CLI available. Newest: {last}, current: {VERSION}\n"
+    if should_ignore_new_version_warning():
+        return None
+    cache = _VersionCache()
+    last_version = cache.get_last_version()
+    last_time_shown = cache.get_last_time_shown()
+    current_version = Version(VERSION)
+    if (
+        last_version
+        and last_version > current_version
+        and not was_warning_shown_recently(last_time_shown)
+    ):
+        cache.update_last_time_shown()
+        return f"\nNew version of Snowflake CLI available. Newest: {last_version}, current: {VERSION}\n"
     return None
 
 
@@ -32,6 +68,7 @@ def show_new_version_banner_callback(msg):
 class _VersionCache:
     _last_time = "last_time_check"
     _version = "version"
+    _last_time_shown = "last_time_shown"
     _version_cache_file = SecurePath(
         CONFIG_MANAGER.file_path.parent / ".cli_version.cache"
     )
@@ -44,6 +81,28 @@ class _VersionCache:
             _VersionCache._last_time: time.time(),
             _VersionCache._version: str(version),
         }
+        if self._cache_file.exists():
+            try:
+                old_data = json.loads(self._cache_file.read_text(file_size_limit_mb=1))
+                if _VersionCache._last_time_shown in old_data:
+                    data[_VersionCache._last_time_shown] = old_data[
+                        _VersionCache._last_time_shown
+                    ]
+            except Exception:
+                pass
+        self._cache_file.parent.mkdir(parents=True, exist_ok=True)
+        self._cache_file.write_text(json.dumps(data))
+
+    def update_last_time_shown(self):
+        if self._cache_file.exists():
+            try:
+                data = json.loads(self._cache_file.read_text(file_size_limit_mb=1))
+            except Exception:
+                data = {}
+        else:
+            data = {}
+        data[_VersionCache._last_time_shown] = time.time()
+        self._cache_file.parent.mkdir(parents=True, exist_ok=True)
         self._cache_file.write_text(json.dumps(data))
 
     @staticmethod
@@ -73,9 +132,8 @@ class _VersionCache:
         if self._cache_file.exists():
             data = json.loads(self._cache_file.read_text(file_size_limit_mb=1))
             now = time.time()
-            if data[_VersionCache._last_time] > now - 60 * 60:
+            if data[_VersionCache._last_time] > now - VERSION_CACHE_REFRESH_INTERVAL:
                 return Version(data[_VersionCache._version])
-
         return self._update_latest_version()
 
     def get_last_version(self) -> Version | None:
@@ -83,3 +141,12 @@ class _VersionCache:
             return self._read_latest_version()
         except:  # anything, this it not crucial feature
             return None
+
+    def get_last_time_shown(self) -> float | int | None:
+        if self._cache_file.exists():
+            try:
+                data = json.loads(self._cache_file.read_text(file_size_limit_mb=1))
+                return data.get(_VersionCache._last_time_shown, 0)
+            except Exception:
+                return None
+        return None

snowflake/cli/_plugins/cortex/commands.py

@@ -41,6 +41,7 @@ from snowflake.cli.api.commands.overrideable_parameter import (
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
 from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB, PYTHON_3_12
+from snowflake.cli.api.exceptions import CliError
 from snowflake.cli.api.output.types import (
     CollectionResult,
     CommandResult,
@@ -94,6 +95,7 @@ def search(
     """
     Performs query search using Cortex Search Services.
     """
+    from snowflake.core import Root
 
     if not SEARCH_COMMAND_ENABLED:
         raise click.ClickException(
@@ -104,7 +106,12 @@ def search(
         columns = []
 
     conn = get_cli_context().connection
-    root = get_cli_context().snow_api_root
+    if conn:
+        root = Root(conn)
+    else:
+        raise CliError(
+            "Cortex Search requires a connection to be established. Please connect to a Snowflake account first."
+        )
 
     search_service = (
         root.databases[conn.database]
@@ -173,11 +180,9 @@ def complete(
             is_file_input=is_file_input,
         )
     elif backend == Backend.REST:
-        root = get_cli_context().snow_api_root
         result_text = manager.rest_complete(
             text=Text(prompt),
             model=Model(model),
-            root=root,
         )
     else:
         raise UsageError("--backend option should be either rest or sql.")

snowflake/cli/_plugins/cortex/manager.py

@@ -26,18 +26,13 @@ from snowflake.cli._plugins.cortex.types import (
     SourceDocument,
     Text,
 )
+from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB
-from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
+from snowflake.cli.api.exceptions import CliError, SnowflakeSQLExecutionError
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.connector import ProgrammingError
 from snowflake.connector.cursor import DictCursor
-from snowflake.core._root import Root
-from snowflake.core.cortex.inference_service import CortexInferenceService
-from snowflake.core.cortex.inference_service._generated.models import CompleteRequest
-from snowflake.core.cortex.inference_service._generated.models.complete_request_messages_inner import (
-    CompleteRequestMessagesInner,
-)
 
 log = logging.getLogger(__name__)
 
@@ -89,24 +84,33 @@ class CortexManager(SqlExecutionMixin):
                 lambda: json_result["choices"][0]["messages"]
             )
 
-    def make_rest_complete_request(
-        self,
-        model: Model,
-        prompt: Text,
-    ) -> CompleteRequest:
-        return CompleteRequest(
-            model=str(model),
-            messages=[CompleteRequestMessagesInner(content=str(prompt))],
-            stream=True,
-        )
-
     def rest_complete(
         self,
         text: Text,
         model: Model,
-        root: "Root",
     ) -> str:
-        complete_request = self.make_rest_complete_request(model=model, prompt=text)
+        from snowflake.core import Root
+        from snowflake.core.cortex.inference_service import CortexInferenceService
+        from snowflake.core.cortex.inference_service._generated.models import (
+            CompleteRequest,
+        )
+        from snowflake.core.cortex.inference_service._generated.models.complete_request_messages_inner import (
+            CompleteRequestMessagesInner,
+        )
+
+        cli_context = get_cli_context()
+        if cli_context.connection:
+            root = Root(cli_context.connection)
+        else:
+            raise CliError(
+                "Cortex Search requires a connection to be established. Please connect to a Snowflake account first."
+            )
+
+        complete_request = CompleteRequest(
+            model=str(model),
+            messages=[CompleteRequestMessagesInner(content=str(text))],
+            stream=True,
+        )
         cortex_inference_service = CortexInferenceService(root=root)
         try:
             raw_resp = cortex_inference_service.complete(

snowflake/cli/_plugins/dbt/commands.py

@@ -45,8 +45,9 @@ from snowflake.cli.api.secure_path import SecurePath
 
 app = SnowTyperFactory(
     name="dbt",
-    help="Manages dbt on Snowflake projects",
+    help="Manages dbt on Snowflake projects.",
     is_hidden=FeatureFlag.ENABLE_DBT.is_disabled,
+    preview=True,
 )
 log = logging.getLogger(__name__)
 
@@ -64,7 +65,7 @@ add_object_command_aliases(
     object_type=ObjectType.DBT_PROJECT,
     name_argument=DBTNameArgument,
     like_option=like_option(
-        help_example='`list --like "my%"` lists all dbt projects that begin with “my”'
+        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"],
@@ -115,6 +116,7 @@ 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)
 
@@ -141,6 +143,7 @@ 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,

snowflake/cli/_plugins/dbt/manager.py

@@ -26,6 +26,7 @@ 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.project.util import unquote_identifier
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.connector.cursor import SnowflakeCursor
@@ -44,7 +45,7 @@ class DBTManager(SqlExecutionMixin):
 
     def deploy(
         self,
-        name: FQN,
+        fqn: FQN,
         path: SecurePath,
         profiles_path: SecurePath,
         force: bool,
@@ -66,7 +67,8 @@ class DBTManager(SqlExecutionMixin):
 
         with cli_console.phase("Creating temporary stage"):
             stage_manager = StageManager()
-            stage_fqn = FQN.from_string(f"dbt_{name}_stage").using_context()
+            unquoted_name = unquote_identifier(fqn.name)
+            stage_fqn = FQN.from_string(f"DBT_{unquoted_name}_STAGE").using_context()
             stage_name = stage_manager.get_standard_stage_prefix(stage_fqn)
             stage_manager.create(stage_fqn, temporary=True)
 
@@ -86,11 +88,11 @@ class DBTManager(SqlExecutionMixin):
 
         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"
+                query = f"CREATE OR REPLACE DBT PROJECT {fqn}"
+            elif self.exists(name=fqn):
+                query = f"ALTER DBT PROJECT {fqn} ADD VERSION"
             else:
-                query = f"CREATE DBT PROJECT {name}"
+                query = f"CREATE DBT PROJECT {fqn}"
             query += f"\nFROM {stage_name}"
             return self.execute_query(query)
 
@@ -174,7 +176,7 @@ class DBTManager(SqlExecutionMixin):
             yaml.safe_dump(yaml.safe_load(sfd), tfd)
 
     def execute(
-        self, dbt_command: str, name: str, run_async: bool, *dbt_cli_args
+        self, dbt_command: str, name: FQN, run_async: bool, *dbt_cli_args
     ) -> SnowflakeCursor:
         if dbt_cli_args:
             dbt_command = " ".join([dbt_command, *dbt_cli_args]).strip()