snowflake-cli 3.9.0__py3-none-any.whl → 3.10.0__py3-none-any.whl

snowflake/cli/__about__.py

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

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/git/manager.py

@@ -14,9 +14,8 @@
 
 from __future__ import annotations
 
-from pathlib import Path, PurePosixPath
+from pathlib import PurePosixPath
 from textwrap import dedent
-from typing import List
 
 from click import UsageError
 from snowflake.cli._plugins.stage.manager import (
@@ -64,19 +63,10 @@ class GitStagePathParts(StagePathParts):
     def full_path(self) -> str:
         return f"{self.stage.rstrip('/')}/{self.directory}"
 
-    def replace_stage_prefix(self, file_path: str) -> str:
-        stage = Path(self.stage).parts[0]
-        file_path_without_prefix = Path(file_path).parts[OMIT_FIRST]
-        return f"{stage}/{'/'.join(file_path_without_prefix)}"
-
     def add_stage_prefix(self, file_path: str) -> str:
         stage = self.stage.rstrip("/")
         return f"{stage}/{file_path.lstrip('/')}"
 
-    def get_directory_from_file_path(self, file_path: str) -> List[str]:
-        stage_path_length = len(Path(self.directory).parts)
-        return list(Path(file_path).parts[3 + stage_path_length : -1])
-
 
 class GitManager(StageManager):
     @staticmethod

snowflake/cli/_plugins/nativeapp/codegen/snowpark/python_processor.py

@@ -49,6 +49,7 @@ from snowflake.cli._plugins.nativeapp.codegen.snowpark.models import (
 from snowflake.cli._plugins.stage.diff import to_stage_path
 from snowflake.cli.api.artifacts.bundle_map import BundleMap
 from snowflake.cli.api.cli_global_context import get_cli_context, span
+from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.console import cli_console as cc
 from snowflake.cli.api.metrics import CLICounterField
 from snowflake.cli.api.project.schemas.entities.common import (
@@ -181,6 +182,9 @@ class SnowparkAnnotationProcessor(ArtifactProcessor):
         setup script with generated SQL that registers these functions.
         """
 
+        cli_console.warning(
+            "Snowpark processor is not supported and will be removed soon."
+        )
         get_cli_context().metrics.set_counter(CLICounterField.SNOWPARK_PROCESSOR, 1)
 
         bundle_map = BundleMap(

snowflake/cli/_plugins/nativeapp/commands.py

@@ -55,7 +55,6 @@ from snowflake.cli.api.exceptions import (
     IncompatibleParametersError,
     UnmetParametersError,
 )
-from snowflake.cli.api.output.formats import OutputFormat
 from snowflake.cli.api.output.types import (
     CommandResult,
     MessageResult,
@@ -117,9 +116,9 @@ def app_diff(
     diff = ws.perform_action(
         package_id,
         EntityActions.DIFF,
-        print_to_console=cli_context.output_format != OutputFormat.JSON,
+        print_to_console=not cli_context.output_format.is_json,
     )
-    if cli_context.output_format == OutputFormat.JSON:
+    if cli_context.output_format.is_json:
         return ObjectResult(diff.to_dict())
 
     return None
@@ -373,7 +372,7 @@ def app_validate(
     )
     package_id = options["package_entity_id"]
     package = ws.get_entity(package_id)
-    if cli_context.output_format == OutputFormat.JSON:
+    if cli_context.output_format.is_json:
         return ObjectResult(
             package.get_validation_result(
                 action_ctx=ws.action_ctx,

snowflake/cli/_plugins/nativeapp/entities/application_package.py

@@ -1330,7 +1330,7 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
                 role=self.role,
                 prune=prune,
                 recursive=recursive,
-                stage_path=stage_path,
+                stage_path_parts=stage_path,
                 local_paths_to_sync=paths,
                 print_diff=print_diff,
             )

snowflake/cli/_plugins/nativeapp/release_channel/commands.py

@@ -26,7 +26,6 @@ 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.snow_typer import SnowTyperFactory
 from snowflake.cli.api.entities.utils import EntityActions
-from snowflake.cli.api.output.formats import OutputFormat
 from snowflake.cli.api.output.types import (
     CollectionResult,
     CommandResult,
@@ -68,7 +67,7 @@ def release_channel_list(
         release_channel=channel,
     )
 
-    if cli_context.output_format == OutputFormat.JSON:
+    if cli_context.output_format.is_json:
         return CollectionResult(channels)
 
 

snowflake/cli/_plugins/nativeapp/version/commands.py

@@ -30,7 +30,6 @@ from snowflake.cli.api.commands.decorators import (
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
 from snowflake.cli.api.entities.utils import EntityActions
-from snowflake.cli.api.output.formats import OutputFormat
 from snowflake.cli.api.output.types import (
     CollectionResult,
     CommandResult,
@@ -105,7 +104,7 @@ def create(
     )
 
     message = "Version create is now complete."
-    if cli_context.output_format == OutputFormat.JSON:
+    if cli_context.output_format.is_json:
         return ObjectResult(
             {
                 "message": message,