snowflake-cli 3.3.0__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.3.0"
+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/_plugins/cortex/commands.py

@@ -96,16 +96,14 @@ def search(
             "Cortex Search uses Snowflake Python API that currently does not support your Python version"
         )
 
-    from snowflake.core import Root
-
     if not columns:
         columns = []
 
     conn = get_cli_context().connection
+    root = get_cli_context().snow_api_root
 
     search_service = (
-        Root(conn)
-        .databases[conn.database]
+        root.databases[conn.database]
         .schemas[conn.schema]
         .cortex_search_services[service]
     )

snowflake/cli/_plugins/git/manager.py

@@ -116,7 +116,7 @@ class GitManager(StageManager):
         return f"{'/'.join(path_parts[ONLY_STAGE])}/"
 
     @staticmethod
-    def _stage_path_part_factory(stage_path: str) -> StagePathParts:
+    def stage_path_parts_from_str(stage_path: str) -> StagePathParts:
         stage_path = StageManager.get_standard_stage_prefix(stage_path)
         if stage_path.startswith(USER_STAGE_PREFIX):
             return UserStagePathParts(stage_path)