snowflake-cli 3.2.2__py3-none-any.whl → 3.4.1__py3-none-any.whl

snowflake/cli/__about__.py

@@ -14,4 +14,4 @@
 
 from __future__ import annotations
 
-VERSION = "3.2.2"
+VERSION = "3.4.1"

snowflake/cli/_app/__main__.py

@@ -16,11 +16,11 @@ from __future__ import annotations
 
 import sys
 
-from snowflake.cli._app.cli_app import app_factory
+from snowflake.cli._app.cli_app import CliAppFactory
 
 
 def main(*args):
-    app = app_factory()
+    app = CliAppFactory().create_or_get_app()
     app(*args)
 
 

snowflake/cli/_app/cli_app.py

@@ -18,13 +18,12 @@ import logging
 import os
 import platform
 import sys
-from dataclasses import dataclass
 from pathlib import Path
 from typing import Optional
 
 import click
 import typer
-from click import Context
+from click import Context as ClickContext
 from snowflake.cli import __about__
 from snowflake.cli._app.api_impl.plugin.plugin_config_provider_impl import (
     PluginConfigProviderImpl,
@@ -44,7 +43,7 @@ from snowflake.cli._app.version_check import (
     show_new_version_banner_callback,
 )
 from snowflake.cli.api import Api, api_provider
-from snowflake.cli.api.config import config_init
+from snowflake.cli.api.config import config_init, get_feature_flags_section
 from snowflake.cli.api.output.formats import OutputFormat
 from snowflake.cli.api.output.types import CollectionResult
 from snowflake.cli.api.secure_path import SecurePath
@@ -52,25 +51,6 @@ from snowflake.connector.config_manager import CONFIG_MANAGER
 
 log = logging.getLogger(__name__)
 
-_api = Api(plugin_config_provider=PluginConfigProviderImpl())
-api_provider.register_api(_api)
-
-_commands_registration = CommandsRegistrationWithCallbacks(_api.plugin_config_provider)
-
-
-@dataclass
-class AppContextHolder:
-    # needed to access the context from tests
-    app_context: Optional[Context] = None
-
-
-app_context_holder = AppContextHolder()
-
-
-def _exit_with_cleanup():
-    _commands_registration.reset_running_instance_registration_state()
-    raise typer.Exit()
-
 
 def _do_not_execute_on_completion(callback):
     def enriched_callback(value):
@@ -81,175 +61,227 @@ def _do_not_execute_on_completion(callback):
     return enriched_callback
 
 
-def _commands_registration_callback(value: bool):
-    if value:
-        _commands_registration.register_commands_if_ready_and_not_registered_yet()
-    # required to make the tests working
-    # because a single test can execute multiple commands using always the same "app" instance
-    _commands_registration.reset_running_instance_registration_state()
-    app_context_holder.app_context = click.get_current_context()
-
-
-@_commands_registration.before
-def _config_init_callback(configuration_file: Optional[Path]):
-    config_init(configuration_file)
-
-
-@_commands_registration.before
-def _disable_external_command_plugins_callback(value: bool):
-    if value:
-        _commands_registration.disable_external_command_plugins()
-
-
-@_do_not_execute_on_completion
-@_commands_registration.after
-def _docs_callback(value: bool):
-    if value:
-        ctx = click.get_current_context()
-        generate_docs(SecurePath("gen_docs"), ctx.command)
-        _exit_with_cleanup()
-
-
-@_do_not_execute_on_completion
-@_commands_registration.after
-def _commands_structure_callback(value: bool):
-    if value:
-        ctx = click.get_current_context()
-        generate_commands_structure(ctx.command).print_node()
-        _exit_with_cleanup()
-
-
-@_do_not_execute_on_completion
-def _version_callback(value: bool):
-    if value:
-        print_result(MessageResult(f"Snowflake CLI version: {__about__.VERSION}"))
-        _exit_with_cleanup()
-
-
-from snowflake.cli.api.config import get_feature_flags_section
-
-
-@_do_not_execute_on_completion
-def _info_callback(value: bool):
-    if value:
-        result = CollectionResult(
-            [
-                {"key": "version", "value": __about__.VERSION},
-                {
-                    "key": "default_config_file_path",
-                    "value": str(CONFIG_MANAGER.file_path),
-                },
-                {"key": "python_version", "value": sys.version},
-                {"key": "system_info", "value": platform.platform()},
-                {"key": "feature_flags", "value": get_feature_flags_section()},
-                {"key": "SNOWFLAKE_HOME", "value": os.getenv("SNOWFLAKE_HOME")},
-            ],
+class CliAppFactory:
+    def __init__(self):
+        api = Api(plugin_config_provider=PluginConfigProviderImpl())
+        self._api = api
+        self._commands_registration = CommandsRegistrationWithCallbacks(
+            api.plugin_config_provider
         )
-        print_result(result, output_format=OutputFormat.JSON)
-        _exit_with_cleanup()
-
-
-def app_factory() -> SnowCliMainTyper:
-    app = SnowCliMainTyper()
-    new_version_msg = get_new_version_msg()
-
-    @app.callback(
-        invoke_without_command=True,
-        epilog=new_version_msg,
-        result_callback=show_new_version_banner_callback(new_version_msg),
-        help=f"Snowflake CLI tool for developers [v{__about__.VERSION}]",
-    )
-    def default(
-        ctx: typer.Context,
-        version: bool = typer.Option(
-            None,
-            "--version",
-            help="Shows version of the Snowflake CLI",
-            callback=_version_callback,
-            is_eager=True,
-        ),
-        docs: bool = typer.Option(
-            None,
-            "--docs",
-            hidden=True,
-            help="Generates Snowflake CLI documentation",
-            callback=_docs_callback,
-            is_eager=True,
-        ),
-        structure: bool = typer.Option(
-            None,
-            "--structure",
-            hidden=True,
-            help="Prints Snowflake CLI structure of commands",
-            callback=_commands_structure_callback,
-            is_eager=True,
-        ),
-        info: bool = typer.Option(
-            None,
-            "--info",
-            help="Shows information about the Snowflake CLI",
-            callback=_info_callback,
-        ),
-        configuration_file: Path = typer.Option(
-            None,
-            "--config-file",
-            help="Specifies Snowflake CLI configuration file that should be used",
-            exists=True,
-            dir_okay=False,
-            is_eager=True,
-            callback=_config_init_callback,
-        ),
-        pycharm_debug_library_path: str = typer.Option(
-            None,
-            "--pycharm-debug-library-path",
-            hidden=True,
-        ),
-        pycharm_debug_server_host: str = typer.Option(
-            "localhost",
-            "--pycharm-debug-server-host",
-            hidden=True,
-        ),
-        pycharm_debug_server_port: int = typer.Option(
-            12345,
-            "--pycharm-debug-server-port",
-            hidden=True,
-        ),
-        disable_external_command_plugins: bool = typer.Option(
-            None,
-            "--disable-external-command-plugins",
-            help="Disable external command plugins",
-            callback=_disable_external_command_plugins_callback,
-            is_eager=True,
-            hidden=True,
-        ),
-        # THIS OPTION SHOULD BE THE LAST OPTION IN THE LIST!
-        # ---
-        # This is a hidden artificial option used only to guarantee execution of commands registration
-        # and make this guaranty not dependent on other callbacks.
-        # Commands registration is invoked as soon as all callbacks
-        # decorated with "_commands_registration.before" are executed
-        # but if there are no such callbacks (at the result of possible future changes)
-        # then we need to invoke commands registration manually.
-        #
-        # This option is also responsible for resetting registration state for test purposes.
-        commands_registration: bool = typer.Option(
-            True,
-            "--commands-registration",
-            help="Commands registration",
-            hidden=True,
-            is_eager=True,
-            callback=_commands_registration_callback,
-        ),
-    ) -> None:
-        """
-        Snowflake CLI tool for developers.
-        """
-        if not ctx.invoked_subcommand:
-            typer.echo(ctx.get_help())
-        setup_pycharm_remote_debugger_if_provided(
-            pycharm_debug_library_path=pycharm_debug_library_path,
-            pycharm_debug_server_host=pycharm_debug_server_host,
-            pycharm_debug_server_port=pycharm_debug_server_port,
+        api_provider.register_api(api)
+        self._app: Optional[SnowCliMainTyper] = None
+        self._click_context: Optional[ClickContext] = None
+
+    def _exit_with_cleanup(self):
+        self._commands_registration.reset_running_instance_registration_state()
+        raise typer.Exit()
+
+    def _commands_registration_callback(self):
+        def callback(value: bool):
+            self._click_context = click.get_current_context()
+            if value:
+                self._commands_registration.register_commands_from_plugins()
+            # required to make the tests working
+            # because a single test can execute multiple commands using always the same "app" instance
+            self._commands_registration.reset_running_instance_registration_state()
+
+        return callback
+
+    @staticmethod
+    def _config_init_callback():
+        def callback(configuration_file: Optional[Path]):
+            config_init(configuration_file)
+
+        return callback
+
+    def _disable_external_command_plugins_callback(self):
+        def callback(value: bool):
+            if value:
+                self._commands_registration.disable_external_command_plugins()
+
+        return callback
+
+    def _docs_callback(self):
+        @_do_not_execute_on_completion
+        @self._commands_registration.after
+        def callback(value: bool):
+            if value:
+                ctx = click.get_current_context()
+                generate_docs(SecurePath("gen_docs"), ctx.command)
+                self._exit_with_cleanup()
+
+        return callback
+
+    def _help_callback(self):
+        @_do_not_execute_on_completion
+        @self._commands_registration.after
+        def callback(value: bool):
+            if value:
+                ctx = click.get_current_context()
+                typer.echo(ctx.get_help())
+                self._exit_with_cleanup()
+
+        return callback
+
+    def _commands_structure_callback(self):
+        @_do_not_execute_on_completion
+        @self._commands_registration.after
+        def callback(value: bool):
+            if value:
+                ctx = click.get_current_context()
+                generate_commands_structure(ctx.command).print_node()
+                self._exit_with_cleanup()
+
+        return callback
+
+    def _version_callback(self):
+        @_do_not_execute_on_completion
+        def callback(value: bool):
+            if value:
+                print_result(
+                    MessageResult(f"Snowflake CLI version: {__about__.VERSION}")
+                )
+                self._exit_with_cleanup()
+
+        return callback
+
+    def _info_callback(self):
+        @_do_not_execute_on_completion
+        def callback(value: bool):
+            if value:
+                result = CollectionResult(
+                    [
+                        {"key": "version", "value": __about__.VERSION},
+                        {
+                            "key": "default_config_file_path",
+                            "value": str(CONFIG_MANAGER.file_path),
+                        },
+                        {"key": "python_version", "value": sys.version},
+                        {"key": "system_info", "value": platform.platform()},
+                        {"key": "feature_flags", "value": get_feature_flags_section()},
+                        {"key": "SNOWFLAKE_HOME", "value": os.getenv("SNOWFLAKE_HOME")},
+                    ],
+                )
+                print_result(result, output_format=OutputFormat.JSON)
+                self._exit_with_cleanup()
+
+        return callback
+
+    def create_or_get_app(self) -> SnowCliMainTyper:
+        if self._app:
+            return self._app
+
+        app = SnowCliMainTyper()
+        new_version_msg = get_new_version_msg()
+
+        @app.callback(
+            invoke_without_command=True,
+            epilog=new_version_msg,
+            result_callback=show_new_version_banner_callback(new_version_msg),
+            add_help_option=False,  # custom_help option added below
+            help=f"Snowflake CLI tool for developers [v{__about__.VERSION}]",
         )
-
-    return app
+        def default(
+            ctx: typer.Context,
+            # We need a custom help option with _help_callback called after command registration
+            # to have all commands visible in the help.
+            # This is required since click 8.1.8, when the default help option
+            # has started to being executed before our eager options, including command registration.
+            custom_help: bool = typer.Option(
+                None,
+                "--help",
+                "-h",
+                help="Show this message and exit.",
+                callback=self._help_callback,
+                is_eager=True,
+            ),
+            version: bool = typer.Option(
+                None,
+                "--version",
+                help="Shows version of the Snowflake CLI",
+                callback=self._version_callback(),
+                is_eager=True,
+            ),
+            docs: bool = typer.Option(
+                None,
+                "--docs",
+                hidden=True,
+                help="Generates Snowflake CLI documentation",
+                callback=self._docs_callback(),
+                is_eager=True,
+            ),
+            structure: bool = typer.Option(
+                None,
+                "--structure",
+                hidden=True,
+                help="Prints Snowflake CLI structure of commands",
+                callback=self._commands_structure_callback(),
+                is_eager=True,
+            ),
+            info: bool = typer.Option(
+                None,
+                "--info",
+                help="Shows information about the Snowflake CLI",
+                callback=self._info_callback(),
+            ),
+            configuration_file: Path = typer.Option(
+                None,
+                "--config-file",
+                help="Specifies Snowflake CLI configuration file that should be used",
+                exists=True,
+                dir_okay=False,
+                is_eager=True,
+                callback=self._config_init_callback(),
+            ),
+            pycharm_debug_library_path: str = typer.Option(
+                None,
+                "--pycharm-debug-library-path",
+                hidden=True,
+            ),
+            pycharm_debug_server_host: str = typer.Option(
+                "localhost",
+                "--pycharm-debug-server-host",
+                hidden=True,
+            ),
+            pycharm_debug_server_port: int = typer.Option(
+                12345,
+                "--pycharm-debug-server-port",
+                hidden=True,
+            ),
+            disable_external_command_plugins: bool = typer.Option(
+                None,
+                "--disable-external-command-plugins",
+                help="Disable external command plugins",
+                callback=self._disable_external_command_plugins_callback(),
+                is_eager=True,
+                hidden=True,
+            ),
+            # THIS OPTION SHOULD BE THE LAST OPTION IN THE LIST!
+            # ---
+            # This is a hidden artificial option used only to guarantee execution of commands registration.
+            # This option is also responsible for resetting registration state for test purposes.
+            commands_registration: bool = typer.Option(
+                True,
+                "--commands-registration",
+                help="Commands registration",
+                hidden=True,
+                is_eager=True,
+                callback=self._commands_registration_callback(),
+            ),
+        ) -> None:
+            """
+            Snowflake CLI tool for developers.
+            """
+            if not ctx.invoked_subcommand:
+                typer.echo(ctx.get_help())
+            setup_pycharm_remote_debugger_if_provided(
+                pycharm_debug_library_path=pycharm_debug_library_path,
+                pycharm_debug_server_host=pycharm_debug_server_host,
+                pycharm_debug_server_port=pycharm_debug_server_port,
+            )
+
+        self._app = app
+        return app
+
+    def get_click_context(self):
+        return self._click_context

snowflake/cli/_app/commands_registration/commands_registration_with_callbacks.py

@@ -21,7 +21,6 @@ from snowflake.cli._app.commands_registration.command_plugins_loader import (
     load_builtin_and_external_command_plugins,
     load_only_builtin_command_plugins,
 )
-from snowflake.cli._app.commands_registration.threadsafe import ThreadsafeCounter
 from snowflake.cli._app.commands_registration.typer_registration import (
     register_commands_from_plugins,
 )
@@ -36,27 +35,13 @@ class CommandRegistrationConfig:
 class CommandsRegistrationWithCallbacks:
     def __init__(self, plugin_config_provider: PluginConfigProvider):
         self._plugin_config_provider = plugin_config_provider
-        self._counter_of_callbacks_required_before_registration: ThreadsafeCounter = (
-            ThreadsafeCounter(0)
-        )
-        self._counter_of_callbacks_invoked_before_registration: ThreadsafeCounter = (
-            ThreadsafeCounter(0)
-        )
         self._callbacks_after_registration: List[Callable[[], None]] = []
         self._commands_registration_config: CommandRegistrationConfig = (
             CommandRegistrationConfig(enable_external_command_plugins=True)
         )
         self._commands_already_registered: bool = False
 
-    def register_commands_if_ready_and_not_registered_yet(self):
-        all_required_callbacks_executed = (
-            self._counter_of_callbacks_required_before_registration.value
-            == self._counter_of_callbacks_invoked_before_registration.value
-        )
-        if all_required_callbacks_executed and not self._commands_already_registered:
-            self._register_commands_from_plugins()
-
-    def _register_commands_from_plugins(self) -> None:
+    def register_commands_from_plugins(self) -> None:
         if self._commands_registration_config.enable_external_command_plugins:
             self._register_builtin_and_enabled_external_plugin_commands()
         else:
@@ -83,15 +68,6 @@ class CommandsRegistrationWithCallbacks:
     def disable_external_command_plugins(self):
         self._commands_registration_config.enable_external_command_plugins = False
 
-    def before(self, callback):
-        def enriched_callback(value):
-            self._counter_of_callbacks_invoked_before_registration.increment()
-            callback(value)
-            self.register_commands_if_ready_and_not_registered_yet()
-
-        self._counter_of_callbacks_required_before_registration.increment()
-        return enriched_callback
-
     def after(self, callback):
         def delayed_callback(value):
             self._callbacks_after_registration.append(lambda: callback(value))
@@ -99,7 +75,5 @@ class CommandsRegistrationWithCallbacks:
         return delayed_callback
 
     def reset_running_instance_registration_state(self):
-        self._commands_already_registered = False
-        self._counter_of_callbacks_invoked_before_registration.set(0)
         self._callbacks_after_registration.clear()
         self._commands_registration_config.enable_external_command_plugins = True

snowflake/cli/_app/constants.py

@@ -17,3 +17,7 @@ from __future__ import annotations
 from typing import Literal
 
 PARAM_APPLICATION_NAME: Literal["snowcli"] = "snowcli"
+
+# This is also defined on server side. Changing this parameter would require
+# a change in https://github.com/snowflakedb/snowflake
+INTERNAL_APPLICATION_NAME: Literal["SNOWFLAKE_CLI"] = "SNOWFLAKE_CLI"

snowflake/cli/_app/snow_connector.py

@@ -21,7 +21,9 @@ from typing import Dict, Optional
 
 import snowflake.connector
 from click.exceptions import ClickException
+from snowflake.cli.__about__ import VERSION
 from snowflake.cli._app.constants import (
+    INTERNAL_APPLICATION_NAME,
     PARAM_APPLICATION_NAME,
 )
 from snowflake.cli._app.secret import SecretType
@@ -35,6 +37,7 @@ from snowflake.cli.api.exceptions import (
     InvalidConnectionConfiguration,
     SnowflakeConnectionError,
 )
+from snowflake.cli.api.feature_flags import FeatureFlag
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.connector import SnowflakeConnection
 from snowflake.connector.errors import DatabaseError, ForbiddenError
@@ -150,6 +153,8 @@ def connect_to_snowflake(
 
     _update_connection_application_name(connection_parameters)
 
+    _update_internal_application_info(connection_parameters)
+
     try:
         # Whatever output is generated when creating connection,
         # we don't want it in our output. This is particularly important
@@ -238,6 +243,13 @@ def _update_connection_application_name(connection_parameters: Dict):
     connection_parameters.update(connection_application_params)
 
 
+def _update_internal_application_info(connection_parameters: Dict):
+    """Update internal application data if ENABLE_SEPARATE_AUTHENTICATION_POLICY_ID is enabled."""
+    if FeatureFlag.ENABLE_SEPARATE_AUTHENTICATION_POLICY_ID.is_enabled():
+        connection_parameters["internal_application_name"] = INTERNAL_APPLICATION_NAME
+        connection_parameters["internal_application_version"] = VERSION
+
+
 def _load_pem_from_file(private_key_file: str) -> SecretType:
     with SecurePath(private_key_file).open(
         "rb", read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB

snowflake/cli/_app/telemetry.py

@@ -67,6 +67,10 @@ class CLITelemetryField(Enum):
     CONFIG_FEATURE_FLAGS = "config_feature_flags"
     # Metrics
     COUNTERS = "counters"
+    SPANS = "spans"
+    COMPLETED_SPANS = "completed_spans"
+    NUM_SPANS_PAST_DEPTH_LIMIT = "num_spans_past_depth_limit"
+    NUM_SPANS_PAST_TOTAL_LIMIT = "num_spans_past_total_limit"
     # Information
     EVENT = "event"
     ERROR_MSG = "error_msg"
@@ -129,9 +133,12 @@ def _get_command_metrics() -> TelemetryDict:
     cli_context = get_cli_context()
 
     return {
-        CLITelemetryField.COUNTERS: {
-            **cli_context.metrics.counters,
-        }
+        CLITelemetryField.COUNTERS: cli_context.metrics.counters,
+        CLITelemetryField.SPANS: {
+            CLITelemetryField.COMPLETED_SPANS.value: cli_context.metrics.completed_spans,
+            CLITelemetryField.NUM_SPANS_PAST_DEPTH_LIMIT.value: cli_context.metrics.num_spans_past_depth_limit,
+            CLITelemetryField.NUM_SPANS_PAST_TOTAL_LIMIT.value: cli_context.metrics.num_spans_past_total_limit,
+        },
     }
 
 

snowflake/cli/_plugins/connection/util.py

@@ -19,7 +19,6 @@ import logging
 import os
 from enum import Enum
 from functools import lru_cache
-from textwrap import dedent
 from typing import Any, Dict, Optional
 
 from click.exceptions import ClickException
@@ -57,11 +56,12 @@ class UIParameter(Enum):
     NA_ENFORCE_MANDATORY_FILTERS = (
         "ENFORCE_MANDATORY_FILTERS_FOR_SAME_ACCOUNT_INSTALLATION"
     )
+    NA_FEATURE_RELEASE_CHANNELS = "FEATURE_RELEASE_CHANNELS"
 
 
 def get_ui_parameter(
     conn: SnowflakeConnection, parameter: UIParameter, default: Any
-) -> str:
+) -> Any:
     """
     Returns the value of a single UI parameter.
     If the parameter is not found, the default value is returned.
@@ -77,21 +77,19 @@ def get_ui_parameters(conn: SnowflakeConnection) -> Dict[UIParameter, Any]:
     Returns the UI parameters from the SYSTEM$BOOTSTRAP_DATA_REQUEST function
     """
 
-    parameters_to_fetch = sorted([param.value for param in UIParameter])
+    parameters_to_fetch = [param.value for param in UIParameter]
 
-    query = dedent(
-        f"""
-        select value['value']::string as PARAM_VALUE, value['name']::string as PARAM_NAME from table(flatten(
-            input => parse_json(SYSTEM$BOOTSTRAP_DATA_REQUEST()),
-            path => 'clientParamsInfo'
-        )) where value['name'] in ('{"', '".join(parameters_to_fetch)}');
-        """
-    )
+    # Parsing of the Json and the filtering is happening here in Snowflake CLI
+    # in order to avoid requiring a warehouse in Snowflake
+    query = "call system$bootstrap_data_request('CLIENT_PARAMS_INFO')"
+    *_, cursor = conn.execute_string(query)
 
-    *_, cursor = conn.execute_string(query, cursor_class=DictCursor)
+    json_map = json.loads(cursor.fetchone()[0])
 
     return {
-        UIParameter(row["PARAM_NAME"]): row["PARAM_VALUE"] for row in cursor.fetchall()
+        UIParameter(row["name"]): row["value"]
+        for row in json_map["clientParamsInfo"]
+        if row["name"] in parameters_to_fetch
     }
 
 
@@ -103,12 +101,7 @@ def is_regionless_redirect(conn: SnowflakeConnection) -> bool:
     assume it's regionless, as this is true for most production deployments.
     """
     try:
-        return (
-            get_ui_parameter(
-                conn, UIParameter.NA_ENABLE_REGIONLESS_REDIRECT, "true"
-            ).lower()
-            == "true"
-        )
+        return get_ui_parameter(conn, UIParameter.NA_ENABLE_REGIONLESS_REDIRECT, True)
     except:
         log.warning(
             "Cannot determine regionless redirect; assuming True.", exc_info=True