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

snowflake/cli/__about__.py

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

snowflake/cli/_app/commands_registration/builtin_plugins.py

@@ -15,6 +15,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.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
@@ -52,6 +53,7 @@ def get_builtin_plugin_name_to_plugin_spec():
         "init": init_plugin_spec,
         "workspace": workspace_plugin_spec,
         "plugin": plugin_plugin_spec,
+        "dbt": dbt_plugin_spec,
         "logs": logs_plugin_spec,
     }
 

snowflake/cli/_app/version_check.py

@@ -9,7 +9,8 @@ from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.connector.config_manager import CONFIG_MANAGER
 
-REPOSITORY_URL = "https://pypi.org/pypi/snowflake-cli/json"
+REPOSITORY_URL_PIP = "https://pypi.org/pypi/snowflake-cli/json"
+REPOSITORY_URL_BREW = "https://formulae.brew.sh/api/formula/snowflake-cli.json"
 
 
 def get_new_version_msg() -> str | None:
@@ -48,12 +49,21 @@ class _VersionCache:
     @staticmethod
     def _get_version_from_pypi() -> str | None:
         headers = {"Content-Type": "application/vnd.pypi.simple.v1+json"}
-        response = requests.get(REPOSITORY_URL, headers=headers, timeout=3)
+        response = requests.get(REPOSITORY_URL_PIP, headers=headers, timeout=3)
         response.raise_for_status()
-        return response.json()["info"]["version"]
+        return response.json().get("info", {}).get("version", None)
+
+    @staticmethod
+    def _get_version_from_brew() -> str | None:
+        response = requests.get(REPOSITORY_URL_BREW, timeout=3)
+        response.raise_for_status()
+        return response.json().get("versions", {}).get("stable", None)
 
     def _update_latest_version(self) -> Version | None:
-        version = self._get_version_from_pypi()
+        # Use brew version, fallback to pypi if brew is not available.
+        # Brew repo takes longer to propagate the upgrade and is triggered later in our release process,
+        # we treat it as "slowest point" and determinant that the released version is available.
+        version = self._get_version_from_brew() or self._get_version_from_pypi()
         if version is None:
             return None
         self._save_latest_version(version)

snowflake/cli/_plugins/cortex/commands.py

@@ -15,13 +15,17 @@
 from __future__ import annotations
 
 import sys
+from enum import Enum
 from pathlib import Path
 from typing import List, Optional
 
 import click
 import typer
 from click import UsageError
-from snowflake.cli._plugins.cortex.constants import DEFAULT_MODEL
+from snowflake.cli._plugins.cortex.constants import (
+    DEFAULT_BACKEND,
+    DEFAULT_MODEL,
+)
 from snowflake.cli._plugins.cortex.manager import CortexManager
 from snowflake.cli._plugins.cortex.types import (
     Language,
@@ -36,7 +40,7 @@ from snowflake.cli.api.commands.overrideable_parameter import (
     OverrideableOption,
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
-from snowflake.cli.api.constants import PYTHON_3_12
+from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB, PYTHON_3_12
 from snowflake.cli.api.output.types import (
     CollectionResult,
     CommandResult,
@@ -115,6 +119,11 @@ def search(
     return CollectionResult(response.results)
 
 
+class Backend(Enum):
+    SQL = "sql"
+    REST = "rest"
+
+
 @app.command(
     name="complete",
     requires_connection=True,
@@ -130,6 +139,11 @@ def complete(
         "--model",
         help="String specifying the model to be used.",
     ),
+    backend: Optional[Backend] = typer.Option(
+        DEFAULT_BACKEND,
+        "--backend",
+        help="String specifying whether to use sql or rest backend.",
+    ),
     file: Optional[Path] = ExclusiveReadableFileOption(
         help="JSON file containing conversation history to be used to generate a completion. Cannot be combined with TEXT argument.",
     ),
@@ -143,18 +157,30 @@ def complete(
 
     manager = CortexManager()
 
+    is_file_input: bool = False
     if text:
-        result_text = manager.complete_for_prompt(
-            text=Text(text),
+        prompt = text
+    elif file:
+        prompt = SecurePath(file).read_text(file_size_limit_mb=DEFAULT_SIZE_LIMIT_MB)
+        is_file_input = True
+    else:
+        raise UsageError("Either --file option or TEXT argument has to be provided.")
+
+    if backend == Backend.SQL:
+        result_text = manager.complete(
+            text=Text(prompt),
             model=Model(model),
+            is_file_input=is_file_input,
         )
-    elif file:
-        result_text = manager.complete_for_conversation(
-            conversation_json_file=SecurePath(file),
+    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("Either --file option or TEXT argument has to be provided.")
+        raise UsageError("--backend option should be either rest or sql.")
 
     return MessageResult(result_text.strip())
 

snowflake/cli/_plugins/cortex/constants.py

@@ -14,4 +14,5 @@
 
 from snowflake.cli._plugins.cortex.types import Model
 
-DEFAULT_MODEL: Model = Model("snowflake-arctic")
+DEFAULT_MODEL: Model = Model("llama3.1-70b")
+DEFAULT_BACKEND = "rest"

snowflake/cli/_plugins/cortex/manager.py

@@ -32,43 +32,103 @@ 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__)
 
 
+class ResponseParseError(Exception):
+    """This exception is raised when the server response cannot be parsed."""
+
+    pass
+
+
+class MidStreamError(Exception):
+    """The SSE (Server-sent Event) stream can contain error messages in the middle of the stream,
+    using the “error” event type. This exception is raised when there is such a mid-stream error."""
+
+    def __init__(
+        self,
+        reason: Optional[str] = None,
+    ) -> None:
+        message = ""
+        if reason is not None:
+            message = reason
+        super().__init__(message)
+
+
 class CortexManager(SqlExecutionMixin):
-    def complete_for_prompt(
+    def complete(
         self,
         text: Text,
         model: Model,
+        is_file_input: bool = False,
     ) -> str:
-        query = f"""\
+        if not is_file_input:
+            query = f"""\
+                SELECT SNOWFLAKE.CORTEX.COMPLETE(
+                    '{model}',
+                    '{self._escape_input(text)}'
+                ) AS CORTEX_RESULT;"""
+            return self._query_cortex_result_str(query)
+        else:
+            query = f"""\
             SELECT SNOWFLAKE.CORTEX.COMPLETE(
                 '{model}',
-                '{self._escape_input(text)}'
+                PARSE_JSON('{self._escape_input(text)}'),
+                {{}}
             ) AS CORTEX_RESULT;"""
-        return self._query_cortex_result_str(query)
+            raw_result = self._query_cortex_result_str(query)
+            json_result = json.loads(raw_result)
+            return self._extract_text_result_from_json_result(
+                lambda: json_result["choices"][0]["messages"]
+            )
 
-    def complete_for_conversation(
+    def make_rest_complete_request(
         self,
-        conversation_json_file: SecurePath,
         model: Model,
-    ) -> str:
-        json_content = conversation_json_file.read_text(
-            file_size_limit_mb=DEFAULT_SIZE_LIMIT_MB
-        )
-        query = f"""\
-            SELECT SNOWFLAKE.CORTEX.COMPLETE(
-                '{model}',
-                PARSE_JSON('{self._escape_input(json_content)}'),
-                {{}}
-            ) AS CORTEX_RESULT;"""
-        raw_result = self._query_cortex_result_str(query)
-        json_result = json.loads(raw_result)
-        return self._extract_text_result_from_json_result(
-            lambda: json_result["choices"][0]["messages"]
+        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)
+        cortex_inference_service = CortexInferenceService(root=root)
+        try:
+            raw_resp = cortex_inference_service.complete(
+                complete_request=complete_request
+            )
+        except Exception as e:
+            raise
+        result = ""
+        for event in raw_resp.events():
+            try:
+                parsed_resp = json.loads(event.data)
+            except json.JSONDecodeError:
+                raise ResponseParseError("Server response cannot be parsed")
+            try:
+                result += parsed_resp["choices"][0]["delta"]["content"]
+            except (json.JSONDecodeError, KeyError, IndexError):
+                if parsed_resp.get("error"):
+                    raise MidStreamError(reason=event.data)
+            else:
+                pass
+        return result
+
     def extract_answer_from_source_document(
         self,
         source_document: SourceDocument,
@@ -170,7 +230,7 @@ class CortexManager(SqlExecutionMixin):
 
     @staticmethod
     def _extract_text_result_from_json_result(
-        extract_function: Callable[[], str]
+        extract_function: Callable[[], str],
     ) -> str:
         try:
             return extract_function()

snowflake/cli/_plugins/dbt/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2025 Snowflake Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

snowflake/cli/_plugins/dbt/commands.py

@@ -0,0 +1,187 @@
+# Copyright (c) 2025 Snowflake Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import logging
+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,
+    PROFILES_FILENAME,
+    RESULT_COLUMN_NAME,
+)
+from snowflake.cli._plugins.dbt.manager import DBTManager
+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
+from snowflake.cli.api.commands.flags import identifier_argument, like_option
+from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
+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,
+    MessageResult,
+    QueryResult,
+)
+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,
+)
+log = logging.getLogger(__name__)
+
+
+DBTNameArgument = identifier_argument(sf_object="DBT Project", example="my_pipeline")
+
+# in passthrough commands we need to support that user would either provide the name of dbt object or name of dbt
+# command, in which case FQN validation could fail
+DBTNameOrCommandArgument = identifier_argument(
+    sf_object="DBT Project", example="my_pipeline", click_type=types.StringParamType()
+)
+
+add_object_command_aliases(
+    app=app,
+    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”'
+    ),
+    scope_option=scope_option(help_example="`list --in database my_db`"),
+    ommit_commands=["drop", "create", "describe"],
+)
+
+
+@app.command(
+    "deploy",
+    requires_connection=True,
+)
+def deploy_dbt(
+    name: FQN = DBTNameArgument,
+    source: Optional[str] = typer.Option(
+        help="Path to directory containing dbt files to deploy. Defaults to current working directory.",
+        show_default=False,
+        default=None,
+    ),
+    profiles_dir: Optional[str] = typer.Option(
+        help=f"Path to directory containing {PROFILES_FILENAME}. Defaults to directory provided in --source or current working directory",
+        show_default=False,
+        default=None,
+    ),
+    force: Optional[bool] = typer.Option(
+        False,
+        help="Overwrites conflicting files in the project, if any.",
+    ),
+    **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.
+    """
+    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(),
+            force=force,
+        )
+    )
+
+
+dbt_execute_app = SnowTyperFactory(
+    name="execute",
+    help="Execute a dbt command on Snowflake. Subcommand name and all "
+    "parameters following it will be passed over to dbt.",
+    subcommand_metavar="DBT_COMMAND",
+)
+app.add_typer(dbt_execute_app)
+
+
+@dbt_execute_app.callback()
+@global_options_with_connection
+def before_callback(
+    name: str = DBTNameOrCommandArgument,
+    run_async: Optional[bool] = typer.Option(
+        False, help="Run dbt command asynchronously and check it's result later."
+    ),
+    **options,
+):
+    """Handles global options passed before the command and takes pipeline name to be accessed through child context later"""
+    pass
+
+
+for cmd in DBT_COMMANDS:
+
+    @dbt_execute_app.command(
+        name=cmd,
+        requires_connection=False,
+        requires_global_options=False,
+        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,
+    )
+    def _dbt_execute(
+        ctx: typer.Context,
+    ) -> CommandResult:
+        dbt_cli_args = ctx.args
+        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_manager = DBTManager()
+
+        if run_async is True:
+            result = dbt_manager.execute(*execute_args)
+            return MessageResult(
+                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)
+
+            result = dbt_manager.execute(*execute_args)
+
+            try:
+                columns = [column.name for column in result.description]
+                success_column_index = columns.index(RESULT_COLUMN_NAME)
+                stdout_column_index = columns.index(OUTPUT_COLUMN_NAME)
+            except ValueError:
+                raise CliError("Malformed server response")
+            try:
+                is_success, output = [
+                    (row[success_column_index], row[stdout_column_index])
+                    for row in result
+                ][-1]
+            except IndexError:
+                raise CliError("No data returned from server")
+
+            if is_success is True:
+                return MessageResult(output)
+            else:
+                raise CliError(output)

snowflake/cli/_plugins/dbt/constants.py

@@ -0,0 +1,41 @@
+# Copyright (c) 2025 Snowflake Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+RESULT_COLUMN_NAME = "SUCCESS"
+OUTPUT_COLUMN_NAME = "STDOUT"
+PROFILES_FILENAME = "profiles.yml"
+
+DBT_COMMANDS = [
+    "build",
+    "compile",
+    "deps",
+    "list",
+    "parse",
+    "run",
+    "run-operation",
+    "seed",
+    "show",
+    "snapshot",
+    "test",
+]
+
+UNSUPPORTED_COMMANDS = [
+    "clean",
+    "clone",
+    "debug",
+    "docs",
+    "init",
+    "retry",
+    "source",
+]