snowflake-cli 3.5.0__py3-none-any.whl → 3.6.0__py3-none-any.whl

snowflake/cli/_plugins/connection/commands.py

@@ -16,8 +16,9 @@ from __future__ import annotations
 
 import logging
 import os.path
+from copy import deepcopy
 from pathlib import Path
-from typing import Optional
+from typing import Dict, Optional, Tuple
 
 import typer
 from click import (  # type: ignore
@@ -28,10 +29,14 @@ 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,
@@ -67,6 +72,8 @@ from snowflake.cli.api.output.types import (
     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
 
@@ -282,6 +289,13 @@ def add(
     if connection_exists(connection_name):
         raise UsageError(f"Connection {connection_name} already exists")
 
+    if 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),
@@ -289,6 +303,12 @@ 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}"
     )
@@ -402,3 +422,59 @@ 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/nativeapp/entities/application.py

@@ -669,7 +669,7 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
                 role_to_use=package.role,
             )
 
-        return get_snowflake_facade().create_application(
+        create_app_result, warnings = get_snowflake_facade().create_application(
             name=self.name,
             package_name=package.name,
             install_method=install_method,
@@ -680,6 +680,9 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
             warehouse=self.warehouse,
             release_channel=release_channel,
         )
+        for warning in warnings:
+            self.console.warning(warning)
+        return create_app_result
 
     @span("update_app_object")
     def create_or_upgrade_app(

snowflake/cli/_plugins/nativeapp/sf_sql_facade.py

@@ -60,6 +60,7 @@ from snowflake.cli.api.errno import (
     CANNOT_DISABLE_MANDATORY_TELEMETRY,
     CANNOT_DISABLE_RELEASE_CHANNELS,
     CANNOT_MODIFY_RELEASE_CHANNEL_ACCOUNTS,
+    CANNOT_SET_DEBUG_MODE_WITH_MANIFEST_VERSION,
     DOES_NOT_EXIST_OR_CANNOT_BE_PERFORMED,
     DOES_NOT_EXIST_OR_NOT_AUTHORIZED,
     INSUFFICIENT_PRIVILEGES,
@@ -854,7 +855,7 @@ class SnowflakeSQLFacade:
         debug_mode: bool | None,
         should_authorize_event_sharing: bool | None,
         release_channel: str | None = None,
-    ) -> list[tuple[str]]:
+    ) -> tuple[list[tuple[str]], list[str]]:
         """
         Creates a new application object using an application package,
         running the setup script of the application package
@@ -868,6 +869,7 @@ class SnowflakeSQLFacade:
         @param debug_mode: Whether to enable debug mode; None means not explicitly enabled or disabled
         @param should_authorize_event_sharing: Whether to enable event sharing; None means not explicitly enabled or disabled
         @param release_channel [Optional]: Release channel to use when creating the application
+        @return: a tuple containing the result of the create application query and possible warning messages
         """
         package_name = to_identifier(package_name)
         name = to_identifier(name)
@@ -875,11 +877,9 @@ class SnowflakeSQLFacade:
 
         # by default, applications are created in debug mode when possible;
         # this can be overridden in the project definition
-        debug_mode_clause = ""
+        initial_debug_mode = False
         if install_method.is_dev_mode:
             initial_debug_mode = debug_mode if debug_mode is not None else True
-            debug_mode_clause = f"debug_mode = {initial_debug_mode}"
-
         authorize_telemetry_clause = ""
         if should_authorize_event_sharing is not None:
             self._log.info(
@@ -903,13 +903,13 @@ class SnowflakeSQLFacade:
                                     from application package {package_name}
                                     {using_clause}
                                     {release_channel_clause}
-                                    {debug_mode_clause}
                                     {authorize_telemetry_clause}
                                     comment = {SPECIAL_COMMENT}
                             """
                         )
                     ),
                 )
+
             except Exception as err:
                 if isinstance(err, ProgrammingError):
                     if err.errno == APPLICATION_REQUIRES_TELEMETRY_SHARING:
@@ -927,9 +927,36 @@ class SnowflakeSQLFacade:
                             f"Failed to create application {name} with the following error message:\n"
                             f"{err.msg}"
                         ) from err
+
                 handle_unclassified_error(err, f"Failed to create application {name}.")
 
-            return create_cursor.fetchall()
+            warnings = []
+            try:
+                if initial_debug_mode:
+                    self._sql_executor.execute_query(
+                        dedent(
+                            _strip_empty_lines(
+                                f"""\
+                                    alter application {name}
+                                    set debug_mode = {initial_debug_mode}
+                                """
+                            )
+                        )
+                    )
+            except Exception as err:
+                if (
+                    isinstance(err, ProgrammingError)
+                    and err.errno == CANNOT_SET_DEBUG_MODE_WITH_MANIFEST_VERSION
+                ):
+                    warnings.append(
+                        "Did not apply debug mode to application because the manifest version is set to 2 or higher. Please use session debugging instead."
+                    )
+                else:
+                    warnings.append(
+                        f"Failed to set debug mode for application {name}. {str(err)}"
+                    )
+
+            return create_cursor.fetchall(), warnings
 
     def create_application_package(
         self,

snowflake/cli/_plugins/object/command_aliases.py

@@ -36,8 +36,10 @@ def add_object_command_aliases(
     name_argument: typer.Argument,
     like_option: Optional[typer.Option],
     scope_option: Optional[typer.Option],
-    ommit_commands: List[str] = [],
+    ommit_commands: Optional[List[str]] = None,
 ):
+    if ommit_commands is None:
+        ommit_commands = list()
     if "list" not in ommit_commands:
         if not like_option:
             raise ClickException('[like_option] have to be defined for "list" command')

snowflake/cli/_plugins/object/manager.py

@@ -58,14 +58,16 @@ class ObjectManager(SqlExecutionMixin):
         object_name = _get_object_names(object_type).sf_name
         return self.execute_query(f"drop {object_name} {fqn.sql_identifier}")
 
-    def describe(self, *, object_type: str, fqn: FQN):
+    def describe(self, *, object_type: str, fqn: FQN, **kwargs):
         # Image repository is the only supported object that does not have a DESCRIBE command.
         if object_type == "image-repository":
             raise ClickException(
                 f"Describe is currently not supported for object of type image-repository"
             )
         object_name = _get_object_names(object_type).sf_name
-        return self.execute_query(f"describe {object_name} {fqn.sql_identifier}")
+        return self.execute_query(
+            f"describe {object_name} {fqn.sql_identifier}", **kwargs
+        )
 
     def object_exists(self, *, object_type: str, fqn: FQN):
         try:

snowflake/cli/_plugins/project/commands.py

@@ -15,6 +15,8 @@
 from typing import List, Optional
 
 import typer
+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.project.feature_flags import FeatureFlag
 from snowflake.cli._plugins.project.manager import ProjectManager
 from snowflake.cli._plugins.project.project_entity_model import (
@@ -27,11 +29,13 @@ from snowflake.cli.api.commands.decorators import with_project_definition
 from snowflake.cli.api.commands.flags import (
     entity_argument,
     identifier_argument,
+    like_option,
     variables_option,
 )
 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.identifiers import FQN
 from snowflake.cli.api.output.types import MessageResult, SingleQueryResult
 from snowflake.cli.api.project.project_paths import ProjectPaths
@@ -51,6 +55,18 @@ variables_flag = variables_option(
 )
 
 
+add_object_command_aliases(
+    app=app,
+    object_type=ObjectType.PROJECT,
+    name_argument=project_identifier,
+    like_option=like_option(
+        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"],
+)
+
+
 @app.command(requires_connection=True)
 def execute(
     identifier: FQN = project_identifier,

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

@@ -88,9 +88,17 @@ MaxNodesOption = OverrideableOption(
 _AUTO_RESUME_HELP = "The compute pool will automatically resume when a service or job is submitted to it."
 
 AutoResumeOption = OverrideableOption(
-    True,
-    "--auto-resume/--no-auto-resume",
+    False,
+    "--auto-resume",
     help=_AUTO_RESUME_HELP,
+    mutually_exclusive=["no_auto_resume"],
+)
+
+NoAutoResumeOption = OverrideableOption(
+    False,
+    "--no-auto-resume",
+    help=_AUTO_RESUME_HELP,
+    mutually_exclusive=["auto_resume"],
 )
 
 _AUTO_SUSPEND_SECS_HELP = "Number of seconds of inactivity after which you want Snowflake to automatically suspend the compute pool."
@@ -126,6 +134,7 @@ def create(
     min_nodes: int = MinNodesOption(),
     max_nodes: Optional[int] = MaxNodesOption(),
     auto_resume: bool = AutoResumeOption(),
+    no_auto_resume: bool = NoAutoResumeOption(),
     initially_suspended: bool = typer.Option(
         False,
         "--init-suspend/--no-init-suspend",
@@ -140,13 +149,14 @@ def create(
     """
     Creates a new compute pool.
     """
+    resume_option = True if auto_resume else False if no_auto_resume else True
     max_nodes = validate_and_set_instances(min_nodes, max_nodes, "nodes")
     cursor = ComputePoolManager().create(
         pool_name=name.identifier,
         min_nodes=min_nodes,
         max_nodes=max_nodes,
         instance_family=instance_family,
-        auto_resume=auto_resume,
+        auto_resume=resume_option,
         initially_suspended=initially_suspended,
         auto_suspend_secs=auto_suspend_secs,
         tags=tags,
@@ -223,7 +233,8 @@ def set_property(
     name: FQN = ComputePoolNameArgument,
     min_nodes: Optional[int] = MinNodesOption(default=None, show_default=False),
     max_nodes: Optional[int] = MaxNodesOption(show_default=False),
-    auto_resume: Optional[bool] = AutoResumeOption(default=None, show_default=False),
+    auto_resume: bool = AutoResumeOption(default=None, show_default=False),
+    no_auto_resume: bool = NoAutoResumeOption(default=None, show_default=False),
     auto_suspend_secs: Optional[int] = AutoSuspendSecsOption(
         default=None, show_default=False
     ),
@@ -235,11 +246,12 @@ def set_property(
     """
     Sets one or more properties for the compute pool.
     """
+    resume_option = True if auto_resume else False if no_auto_resume else None
     cursor = ComputePoolManager().set_property(
         pool_name=name.identifier,
         min_nodes=min_nodes,
         max_nodes=max_nodes,
-        auto_resume=auto_resume,
+        auto_resume=resume_option,
         auto_suspend_secs=auto_suspend_secs,
         comment=comment,
     )

snowflake/cli/_plugins/sql/manager.py

@@ -14,23 +14,29 @@
 
 from __future__ import annotations
 
+import logging
 import sys
-from io import StringIO
-from itertools import chain
+from functools import partial
 from pathlib import Path
 from typing import Dict, Iterable, List, Tuple
 
 from click import ClickException, UsageError
-from jinja2 import UndefinedError
 from snowflake.cli._plugins.sql.snowsql_templating import transpile_snowsql_templates
+from snowflake.cli._plugins.sql.source_reader import (
+    compile_statements,
+    files_reader,
+    query_reader,
+)
+from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.rendering.sql_templates import snowflake_sql_jinja_render
-from snowflake.cli.api.secure_path import UNLIMITED, SecurePath
+from snowflake.cli.api.secure_path import SecurePath
 from snowflake.cli.api.sql_execution import SqlExecutionMixin, VerboseCursor
 from snowflake.connector.cursor import SnowflakeCursor
-from snowflake.connector.util_text import split_statements
 
 IsSingleStatement = bool
 
+logger = logging.getLogger(__name__)
+
 
 class SqlManager(SqlExecutionMixin):
     def execute(
@@ -41,57 +47,42 @@ class SqlManager(SqlExecutionMixin):
         data: Dict | None = None,
         retain_comments: bool = False,
     ) -> Tuple[IsSingleStatement, Iterable[SnowflakeCursor]]:
-        inputs = [query, files, std_in]
-        # Check if any two inputs were provided simultaneously
-        if len([i for i in inputs if i]) > 1:
-            raise UsageError(
-                "Multiple input sources specified. Please specify only one."
-            )
+        """Reads, transforms and execute statements from input.
 
-        if std_in:
-            query = sys.stdin.read()
-        if query:
-            return self._execute_single_query(
-                query=query, data=data, retain_comments=retain_comments
-            )
+        Only one input can be consumed at a time.
+        When no compilation errors are detected, the sequence on queries
+        in executed and returned as tuple.
 
-        if files:
-            # Multiple files
-            results = []
-            single_statement = False
-            for file in files:
-                query_from_file = SecurePath(file).read_text(
-                    file_size_limit_mb=UNLIMITED
-                )
-                single_statement, result = self._execute_single_query(
-                    query=query_from_file, data=data, retain_comments=retain_comments
-                )
-                results.append(result)
+        Throws an exception ff multiple inputs are provided.
+        """
+        query = sys.stdin.read() if std_in else query
 
-            # Use single_statement if there's only one, otherwise this is multi statement result
-            single_statement = len(files) == 1 and single_statement
-            return single_statement, chain.from_iterable(results)
+        stmt_operators = (
+            transpile_snowsql_templates,
+            partial(snowflake_sql_jinja_render, data=data),
+        )
+        remove_comments = not retain_comments
 
-        # At that point, no stdin, query or files were provided
-        raise UsageError("Use either query, filename or input option.")
+        if query:
+            stmt_reader = query_reader(query, stmt_operators, remove_comments)
+        elif files:
+            secured_files = [SecurePath(f) for f in files]
+            stmt_reader = files_reader(secured_files, stmt_operators, remove_comments)
+        else:
+            raise UsageError("Use either query, filename or input option.")
 
-    def _execute_single_query(
-        self, query: str, data: Dict | None = None, retain_comments: bool = False
-    ) -> Tuple[IsSingleStatement, Iterable[SnowflakeCursor]]:
-        try:
-            query = transpile_snowsql_templates(query)
-            query = snowflake_sql_jinja_render(content=query, data=data)
-        except UndefinedError as err:
-            raise ClickException(f"SQL template rendering error: {err}")
+        errors, stmt_count, compiled_statements = compile_statements(stmt_reader)
+        if not any((errors, stmt_count, compiled_statements)):
+            raise UsageError("Use either query, filename or input option.")
 
-        statements = tuple(
-            statement
-            for statement, _ in split_statements(
-                StringIO(query), remove_comments=not retain_comments
-            )
-        )
-        single_statement = len(statements) == 1
+        if errors:
+            for error in errors:
+                logger.info("Statement compilation error: %s", error)
+                cli_console.warning(error)
+            raise ClickException("SQL rendering error")
 
-        return single_statement, self._execute_string(
-            "\n".join(statements), cursor_class=VerboseCursor
+        is_single_statement = not (stmt_count > 1)
+        return is_single_statement, self.execute_string(
+            "\n".join(compiled_statements),
+            cursor_class=VerboseCursor,
         )