snowflake-cli 3.7.1__py3-none-any.whl → 3.8.0__py3-none-any.whl

snowflake/cli/__about__.py

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

snowflake/cli/_app/snow_connector.py

@@ -64,6 +64,16 @@ SUPPORTED_ENV_OVERRIDES = [
     "session_token",
     "master_token",
     "token_file_path",
+    "oauth_client_id",
+    "oauth_client_secret",
+    "oauth_authorization_url",
+    "oauth_token_request_url",
+    "oauth_redirect_uri",
+    "oauth_scope",
+    "oauth_disable_pkce",
+    "oauth_enable_refresh_tokens",
+    "oauth_enable_single_use_refresh_tokens",
+    "client_store_temporary_credential",
 ]
 
 # mapping of found key -> key to set
@@ -103,14 +113,18 @@ def connect_to_snowflake(
         temporary_connection, using_session_token, using_master_token
     )
 
+    connection_parameters = {}
     if connection_name:
         connection_parameters = {
             _resolve_alias(k): v
             for k, v in get_connection_dict(connection_name).items()
         }
+
     elif temporary_connection:
         connection_parameters = {}  # we will apply overrides in next step
 
+    connection_parameters["using_session_keep_alive"] = True
+
     # Apply overrides to connection details
     # (1) Command line override case
     for key, value in overrides.items():

snowflake/cli/_app/telemetry.py

@@ -75,6 +75,7 @@ class CLITelemetryField(Enum):
     IS_CLI_EXCEPTION = "is_cli_exception"
     # Project context
     PROJECT_DEFINITION_VERSION = "project_definition_version"
+    MODE = "mode"
 
 
 class TelemetryEvent(Enum):
@@ -151,9 +152,19 @@ def _find_command_info() -> TelemetryDict:
             "format", OutputFormat.TABLE
         ).value,
         CLITelemetryField.PROJECT_DEFINITION_VERSION: str(_get_definition_version()),
+        CLITelemetryField.MODE: _get_cli_running_mode(),
     }
 
 
+def _get_cli_running_mode() -> str:
+    try:
+        if get_cli_context().is_repl:
+            return "repl"
+    except Exception:
+        pass
+    return "cmd"
+
+
 def _get_definition_version() -> str | None:
     try:
         cli_context = get_cli_context()

snowflake/cli/_plugins/connection/commands.py

@@ -90,9 +90,11 @@ class EmptyInput:
         return "optional"
 
 
-def _mask_password(connection_params: dict):
+def _mask_sensitive_parameters(connection_params: dict):
     if "password" in connection_params:
         connection_params["password"] = "****"
+    if "oauth_client_secret" in connection_params:
+        connection_params["oauth_client_secret"] = "****"
     return connection_params
 
 
@@ -106,7 +108,7 @@ def list_connections(**options) -> CommandResult:
     result = (
         {
             "connection_name": connection_name,
-            "parameters": _mask_password(
+            "parameters": _mask_sensitive_parameters(
                 connection_config.to_dict_of_known_non_empty_values()
             ),
             "is_default": connection_name == default_connection,

snowflake/cli/_plugins/nativeapp/codegen/setup/native_app_setup_processor.py

@@ -35,10 +35,10 @@ from snowflake.cli._plugins.nativeapp.codegen.sandbox import (
     SandboxEnvBuilder,
     execute_script_in_sandbox,
 )
-from snowflake.cli._plugins.nativeapp.feature_flags import FeatureFlag
 from snowflake.cli._plugins.stage.diff import to_stage_path
 from snowflake.cli.api.artifacts.bundle_map import BundleMap
 from snowflake.cli.api.console import cli_console as cc
+from snowflake.cli.api.feature_flags import FeatureFlag
 from snowflake.cli.api.project.schemas.entities.common import (
     PathMapping,
     ProcessorMapping,

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

@@ -44,7 +44,6 @@ from snowflake.cli._plugins.nativeapp.exceptions import (
     ObjectPropertyNotFoundError,
     SetupScriptFailedValidation,
 )
-from snowflake.cli._plugins.nativeapp.feature_flags import FeatureFlag
 from snowflake.cli._plugins.nativeapp.policy import (
     AllowAlwaysPolicy,
     AskAlwaysPolicy,
@@ -88,6 +87,7 @@ from snowflake.cli.api.entities.utils import (
 )
 from snowflake.cli.api.errno import DOES_NOT_EXIST_OR_NOT_AUTHORIZED
 from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
+from snowflake.cli.api.feature_flags import FeatureFlag
 from snowflake.cli.api.project.schemas.entities.common import (
     EntityModelBaseWithArtifacts,
     Identifier,
@@ -190,6 +190,10 @@ class ApplicationPackageEntityModel(EntityModelBaseWithArtifacts):
         title="Entities that will be bundled and deployed as part of this application package",
         default=[],
     )
+    enable_release_channels: bool = Field(
+        title="Enable release channels for this application package",
+        default=False,
+    )
 
     @field_validator("children")
     @classmethod
@@ -1550,24 +1554,33 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
     def _get_enable_release_channels_flag(self) -> Optional[bool]:
         """
         Returns the requested value of enable_release_channels flag for the application package.
-        It retrieves the value from the configuration file and checks that the feature is enabled in the account.
+        It retrieves the value from snowflake.yml (and from the configuration file),
+        and checks that the feature is enabled in the account.
         If return value is None, it means do not explicitly set the flag.
         """
-        feature_flag_from_config = FeatureFlag.ENABLE_RELEASE_CHANNELS.get_value()
+        value_from_snowflake_yml = self.model.enable_release_channels
+        feature_flag_from_config = FeatureFlag.ENABLE_RELEASE_CHANNELS.is_enabled()
+        if feature_flag_from_config and not value_from_snowflake_yml:
+            self._workspace_ctx.console.warning(
+                f"{FeatureFlag.ENABLE_RELEASE_CHANNELS.name} value in config.toml is deprecated."
+                f" Set [enable_release_channels] for the application package in snowflake.yml instead."
+            )
+        enable_release_channels = value_from_snowflake_yml or feature_flag_from_config
+
         feature_enabled_in_account = (
             get_snowflake_facade().get_ui_parameter(
                 UIParameter.NA_FEATURE_RELEASE_CHANNELS, "ENABLED"
             )
             == "ENABLED"
         )
-
-        if feature_flag_from_config is not None and not feature_enabled_in_account:
+        if enable_release_channels and not feature_enabled_in_account:
             self._workspace_ctx.console.warning(
-                f"Ignoring feature flag {FeatureFlag.ENABLE_RELEASE_CHANNELS.name} because release channels are not enabled in the current account."
+                f"Ignoring [enable_release_channels] value because "
+                "release channels are not enabled in the current account."
             )
             return None
 
-        return feature_flag_from_config
+        return enable_release_channels
 
     def create_app_package(self) -> None:
         """

snowflake/cli/_plugins/nativeapp/sf_sql_facade.py

@@ -148,6 +148,7 @@ class SnowflakeSQLFacade:
             yield
             return
 
+        name = to_identifier(name)
         try:
             current_obj_result_row = self._sql_executor.execute_query(
                 f"select current_{object_type}()"
@@ -158,7 +159,7 @@ class SnowflakeSQLFacade:
             )
 
         try:
-            prev_obj = current_obj_result_row[0]
+            prev_obj = to_identifier(current_obj_result_row[0])
         except IndexError:
             prev_obj = None
 
@@ -230,12 +231,13 @@ class SnowflakeSQLFacade:
         with self._use_role_optional(role_to_use):
             try:
                 self._sql_executor.execute_query(
-                    f"grant {comma_separated_privileges} on {object_type_and_name} to role {role_to_grant}"
+                    f"grant {comma_separated_privileges} on {object_type_and_name} to role {to_identifier(role_to_grant)}"
                 )
             except Exception as err:
                 handle_unclassified_error(
                     err,
-                    f"Failed to grant {comma_separated_privileges} on {object_type_and_name} to role {role_to_grant}.",
+                    f"Failed to grant {comma_separated_privileges} on {object_type_and_name}"
+                    f" to role {to_identifier(role_to_grant)}.",
                 )
 
     def execute_user_script(

snowflake/cli/_plugins/project/commands.py

@@ -15,7 +15,6 @@
 from typing import List, Optional
 
 import typer
-from click import ClickException
 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
@@ -38,6 +37,7 @@ from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
 from snowflake.cli.api.commands.utils import get_entity_for_operation
 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.identifiers import FQN
 from snowflake.cli.api.output.types import MessageResult, QueryResult, SingleQueryResult
 
@@ -73,7 +73,7 @@ add_object_command_aliases(
         help_example='`list --like "my%"` lists all projects that begin with “my”'
     ),
     scope_option=scope_option(help_example="`list --in database my_db`"),
-    ommit_commands=["drop", "create", "describe"],
+    ommit_commands=["create", "describe"],
 )
 
 
@@ -133,11 +133,11 @@ def create(
     )
     om = ObjectManager()
     if om.object_exists(object_type="project", fqn=project.fqn):
-        raise ClickException(f"Project '{project.fqn}' already exists.")
+        raise CliError(f"Project '{project.fqn}' already exists.")
     if not no_version and om.object_exists(
         object_type="stage", fqn=FQN.from_stage(project.stage)
     ):
-        raise ClickException(f"Stage '{project.stage}' already exists.")
+        raise CliError(f"Stage '{project.stage}' already exists.")
 
     pm = ProjectManager()
     with cli_console.phase(f"Creating project '{project.fqn}'"):
@@ -154,17 +154,22 @@ def create(
 @with_project_definition()
 def add_version(
     entity_id: str = entity_argument("project"),
-    _from: Optional[str] = from_option(mutually_exclusive=["prune"]),
+    _from: Optional[str] = from_option(),
     _alias: Optional[str] = typer.Option(
         None, "--alias", help="Alias for the version.", show_default=False
     ),
     comment: Optional[str] = typer.Option(
         None, "--comment", help="Version comment.", show_default=False
     ),
-    prune: bool = PruneOption(mutually_exclusive=["_from"]),
+    prune: bool = PruneOption(default=True),
     **options,
 ):
     """Uploads local files to Snowflake and cerates a new project version."""
+    if _from is not None and prune:
+        cli_console.warning(
+            "When `--from` option is used, `--prune` option will be ignored and files from stage will be used as they are."
+        )
+        prune = False
     cli_context = get_cli_context()
     project: ProjectEntityModel = get_entity_for_operation(
         cli_context=cli_context,
@@ -172,6 +177,11 @@ def add_version(
         project_definition=cli_context.project_definition,
         entity_type="project",
     )
+    om = ObjectManager()
+    if not om.object_exists(object_type="project", fqn=project.fqn):
+        raise CliError(
+            f"Project '{project.fqn}' does not exist. Use `project create` command first"
+        )
     ProjectManager().add_version(
         project=project,
         prune=prune,

snowflake/cli/_plugins/snowpark/common.py

@@ -103,6 +103,21 @@ class SnowparkObjectManager(SqlExecutionMixin):
         if isinstance(entity, ProcedureEntityModel) and entity.execute_as_caller:
             query.append("execute as caller")
 
+        if entity.artifact_repository and entity.artifact_repository_packages:
+            packages = [f"'{item}'" for item in entity.artifact_repository_packages]
+            query.extend(
+                [
+                    f"ARTIFACT_REPOSITORY= {entity.artifact_repository}",
+                    f"ARTIFACT_REPOSITORY_PACKAGES=({','.join(packages)})",
+                ]
+            )
+
+        if entity.resource_constraint:
+            constraints = ",".join(
+                f"{key}='{value}'" for key, value in entity.resource_constraint.items()
+            )
+            query.append(f"RESOURCE_CONSTRAINT=({constraints})")
+
         return self.execute_query("\n".join(query))
 
     def deploy_entity(
@@ -184,6 +199,22 @@ def _check_if_replace_is_required(
         log.info("Runtime versions do not match. Replacing the %s", object_type)
         return True
 
+    if entity.resource_constraint != resource_json.get("resource_constraint", None):
+        log.info("Resource constraints do not match. Replacing the %s", object_type)
+        return True
+
+    if entity.artifact_repository != resource_json.get("artifact_repository", None):
+        log.info("Artifact repository does not match. Replacing the %s", object_type)
+        return True
+
+    if entity.artifact_repository_packages != resource_json.get(
+        "artifact_repository_packages", None
+    ):
+        log.info(
+            "Artifact repository packages do not match. Replacing the %s", object_type
+        )
+        return True
+
     if isinstance(entity, ProcedureEntityModel):
         if resource_json.get("execute as", "OWNER") != (
             "CALLER" if entity.execute_as_caller else "OWNER"

snowflake/cli/_plugins/snowpark/package/anaconda_packages.py

@@ -88,6 +88,9 @@ class AnacondaPackages:
             return False
         if skip_version_check or not package.specs:
             return True
+        if any(spec[0] == "!=" for spec in package.specs):
+            # Snowflake doesn't support '!=' so we need to resolve this requirement externally
+            return False
         return self._packages[package.name].is_required_version_available(package)
 
     def package_latest_version(self, package: Requirement) -> str | None:

snowflake/cli/_plugins/snowpark/snowpark_entity.py

@@ -3,7 +3,6 @@ from pathlib import Path
 from typing import Generic, List, Optional, TypeVar
 
 from click import ClickException
-from snowflake.cli._plugins.nativeapp.feature_flags import FeatureFlag
 from snowflake.cli._plugins.snowpark import package_utils
 from snowflake.cli._plugins.snowpark.common import (
     DEFAULT_RUNTIME,
@@ -25,6 +24,7 @@ from snowflake.cli._plugins.snowpark.snowpark_project_paths import SnowparkProje
 from snowflake.cli._plugins.snowpark.zipper import zip_dir
 from snowflake.cli._plugins.workspace.context import ActionContext
 from snowflake.cli.api.entities.common import EntityBase
+from snowflake.cli.api.feature_flags import FeatureFlag
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.connector import ProgrammingError
 
@@ -176,6 +176,17 @@ class SnowparkEntity(EntityBase[Generic[T]]):
         if self.model.type == "procedure" and self.model.execute_as_caller:
             query.append("EXECUTE AS CALLER")
 
+        if self.model.artifact_repository and self.model.artifact_repository_packages:
+            packages = [f"'{item}'" for item in self.model.artifact_repository_packages]
+            query.extend(
+                [
+                    f"ARTIFACT_REPOSITORY= {self.model.artifact_repository} ",
+                    f"ARTIFACT_REPOSITORY_PACKAGES=({','.join(packages)})",
+                ]
+            )
+        if self.model.resource_constraint:
+            query.append(self._get_resource_constraints_sql())
+
         return "\n".join(query)
 
     def get_execute_sql(self, execution_arguments: List[str] | None = None):
@@ -237,6 +248,15 @@ class SnowparkEntity(EntityBase[Generic[T]]):
 
         return download_result
 
+    def _get_resource_constraints_sql(self) -> str:
+        if self.model.resource_constraint:
+            constraints = ",".join(
+                f"{key}='{value}'"
+                for key, value in self.model.resource_constraint.items()
+            )
+            return f"RESOURCE_CONSTRAINT=({constraints})"
+        return ""
+
 
 class FunctionEntity(SnowparkEntity[FunctionEntityModel]):
     """

snowflake/cli/_plugins/snowpark/snowpark_entity_model.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 import glob
 from typing import List, Literal, Optional, Union
 
-from pydantic import Field, field_validator
+from pydantic import Field, field_validator, model_validator
 from snowflake.cli.api.feature_flags import FeatureFlag
 from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.project.schemas.entities.common import (
@@ -50,6 +50,17 @@ class SnowparkEntityModel(
     )
     stage: str = Field(title="Stage in which artifacts will be stored")
 
+    artifact_repository: Optional[str] = Field(
+        default=None, title="Artifact repository to be used"
+    )
+    artifact_repository_packages: Optional[List[str]] = Field(
+        default=None, title="Packages to be installed from artifact repository"
+    )
+
+    resource_constraint: Optional[dict] = Field(
+        default=None, title="Resource constraints for the function/procedure"
+    )
+
     @field_validator("artifacts")
     @classmethod
     def _convert_artifacts(cls, artifacts: Union[dict, str]):
@@ -75,6 +86,17 @@ class SnowparkEntityModel(
             return str(runtime_input)
         return runtime_input
 
+    @model_validator(mode="before")
+    @classmethod
+    def check_artifact_repository(cls, values: dict) -> dict:
+        artifact_repository = values.get("artifact_repository")
+        artifact_repository_packages = values.get("artifact_repository_packages")
+        if artifact_repository_packages and not artifact_repository:
+            raise ValueError(
+                "You specified Artifact_repository_packages without setting Artifact_repository.",
+            )
+        return values
+
     @property
     def udf_sproc_identifier(self) -> UdfSprocIdentifier:
         return UdfSprocIdentifier.from_definition(self)

snowflake/cli/_plugins/spcs/common.py

@@ -181,6 +181,13 @@ def build_time_clauses(
     return since_clause, until_clause
 
 
+def build_db_and_schema_clause(database_name: str, schema_name: str | None) -> str:
+    return f"""
+        and resource_attributes:"snow.database.name" = '{database_name}'
+        and resource_attributes:"snow.schema.name" = '{schema_name or 'PUBLIC'}'
+"""
+
+
 def format_event_row(event_dict: dict) -> dict:
     try:
         resource_attributes = json.loads(event_dict.get("RESOURCE_ATTRIBUTES", "{}"))

snowflake/cli/_plugins/spcs/image_repository/commands.py

@@ -75,7 +75,7 @@ add_object_command_aliases(
     object_type=ObjectType.IMAGE_REPOSITORY,
     name_argument=REPO_NAME_ARGUMENT,
     like_option=like_option(
-        help_example='`list --like "my%"` lists all image repositories that begin with “my”.'
+        help_example='`--like "my%"` lists all image repositories that begin with “my”.'
     ),
     scope_option=scope_option(help_example="`list --in database my_db`"),
     ommit_commands=["describe"],
@@ -126,10 +126,15 @@ def deploy(
 @app.command("list-images", requires_connection=True)
 def list_images(
     name: FQN = REPO_NAME_ARGUMENT,
+    like_option: Optional[str] = like_option(
+        help_example='`--like "my%"` lists all image repositories that begin with “my”.'
+    ),
     **options,
 ) -> CollectionResult:
     """Lists images in the given repository."""
-    return QueryResult(ImageRepositoryManager().list_images(name.identifier))
+    return QueryResult(
+        ImageRepositoryManager().list_images(name.identifier, like_option)
+    )
 
 
 @app.command("list-tags", requires_connection=True, deprecated=True)

snowflake/cli/_plugins/spcs/image_repository/manager.py

@@ -83,5 +83,9 @@ class ImageRepositoryManager(SqlExecutionMixin):
                 e, ObjectType.IMAGE_REPOSITORY, name, replace_available=True
             )
 
-    def list_images(self, repo_name: str) -> SnowflakeCursor:
-        return self.execute_query(f"show images in image repository {repo_name}")
+    def list_images(self, repo_name: str, like_option: str) -> SnowflakeCursor:
+        if like_option:
+            query = f"show images like '{like_option}' in image repository {repo_name}"
+        else:
+            query = f"show images in image repository {repo_name}"
+        return self.execute_query(query)

snowflake/cli/_plugins/spcs/services/commands.py

@@ -437,7 +437,7 @@ def metrics(
     manager = ServiceManager()
     if since or until:
         metrics = manager.get_all_metrics(
-            service_name=name.identifier,
+            service_name=name,
             container_name=container_name,
             instance_id=instance_id,
             since=since,
@@ -446,7 +446,7 @@ def metrics(
         )
     else:
         metrics = manager.get_latest_metrics(
-            service_name=name.identifier,
+            service_name=name,
             container_name=container_name,
             instance_id=instance_id,
             show_all_columns=show_all_columns,

snowflake/cli/_plugins/spcs/services/manager.py

@@ -26,6 +26,7 @@ from snowflake.cli._plugins.spcs.common import (
     EVENT_COLUMN_NAMES,
     NoPropertiesProvidedError,
     SPCSEventTableError,
+    build_db_and_schema_clause,
     build_resource_clause,
     build_time_clauses,
     filter_log_timestamp,
@@ -197,6 +198,8 @@ class ServiceManager(SqlExecutionMixin):
         if not artifacts:
             raise ValueError("Service needs to have artifacts to deploy")
 
+        service_project_paths.remove_up_bundle_root()
+        SecurePath(service_project_paths.bundle_root).mkdir(parents=True, exist_ok=True)
         bundle_map = bundle_artifacts(service_project_paths, artifacts)
         for absolute_src, absolute_dest in bundle_map.all_mappings(
             absolute=True, expand_directories=True
@@ -208,6 +211,7 @@ class ServiceManager(SqlExecutionMixin):
             stage_manager.put(
                 local_path=absolute_dest, stage_path=stage_path, overwrite=True
             )
+        service_project_paths.clean_up_output()
 
     def execute_job(
         self,
@@ -388,13 +392,14 @@ class ServiceManager(SqlExecutionMixin):
 
     def get_all_metrics(
         self,
-        service_name: str,
+        service_name: FQN | str,
         instance_id: str,
         container_name: str,
         since: str | datetime | None = None,
         until: str | datetime | None = None,
         show_all_columns: bool = False,
     ):
+        service_name, database, schema = parse_service_details(service_name)
 
         account_event_table = self.get_account_event_table()
         resource_clause = build_resource_clause(
@@ -402,11 +407,18 @@ class ServiceManager(SqlExecutionMixin):
         )
         since_clause, until_clause = build_time_clauses(since, until)
 
+        db_and_schema_clause = ""
+        if database:
+            db_and_schema_clause = build_db_and_schema_clause(
+                database_name=database, schema_name=schema
+            )
+
         query = f"""\
                     select *
                     from {account_event_table}
                     where (
                         {resource_clause}
+                        {db_and_schema_clause}
                         {since_clause}
                         {until_clause}
                     )
@@ -438,12 +450,19 @@ class ServiceManager(SqlExecutionMixin):
         container_name: str,
         show_all_columns: bool = False,
     ):
+        service_name, database, schema = parse_service_details(service_name)
 
         account_event_table = self.get_account_event_table()
         resource_clause = build_resource_clause(
             service_name, instance_id, container_name
         )
 
+        db_and_schema_clause = ""
+        if database:
+            db_and_schema_clause = build_db_and_schema_clause(
+                database_name=database, schema_name=schema
+            )
+
         query = f"""
             with rankedmetrics as (
                 select
@@ -457,6 +476,7 @@ class ServiceManager(SqlExecutionMixin):
                     record_type = 'METRIC'
                     and scope['name'] = 'snow.spcs.platform'
                     and {resource_clause}
+                    {db_and_schema_clause}
                     and timestamp > dateadd('hour', -1, current_timestamp)
             )
             select *
@@ -580,3 +600,18 @@ class ServiceManager(SqlExecutionMixin):
         unset_list = [property_name for property_name, value in property_pairs if value]
         query = f"alter service {service_name} unset {','.join(unset_list)}"
         return self.execute_query(query)
+
+
+def parse_service_details(
+    service_identifier: str | FQN,
+) -> tuple[str, str | None, str | None]:
+    if isinstance(service_identifier, FQN):
+        name = service_identifier.name
+        database = service_identifier.database
+        schema = service_identifier.schema
+    else:
+        name = service_identifier
+        database = None
+        schema = None
+
+    return name, database, schema