snowflake-cli-labs 3.0.0rc4__py3-none-any.whl → 3.0.1__py3-none-any.whl

snowflake/cli/_app/commands_registration/command_plugins_loader.py

@@ -1,169 +0,0 @@
-# Copyright (c) 2024 Snowflake Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import annotations
-
-import logging
-from typing import Dict, List, Optional
-
-import pluggy
-from snowflake.cli._app.commands_registration import (
-    LoadedBuiltInCommandPlugin,
-    LoadedCommandPlugin,
-    LoadedExternalCommandPlugin,
-)
-from snowflake.cli._app.commands_registration.builtin_plugins import (
-    get_builtin_plugin_name_to_plugin_spec,
-)
-from snowflake.cli._app.commands_registration.exception_logging import exception_logging
-from snowflake.cli.api.plugins.command import (
-    SNOWCLI_COMMAND_PLUGIN_NAMESPACE,
-    CommandPath,
-    CommandSpec,
-    plugin_hook_specs,
-)
-
-log = logging.getLogger(__name__)
-log_exception = exception_logging(log)
-
-
-class CommandPluginsLoader:
-    def __init__(self):
-        plugin_manager = pluggy.PluginManager(SNOWCLI_COMMAND_PLUGIN_NAMESPACE)
-        plugin_manager.add_hookspecs(plugin_hook_specs)
-        self._plugin_manager = plugin_manager
-        self._loaded_plugins: Dict[str, LoadedCommandPlugin] = {}
-        self._loaded_command_paths: Dict[CommandPath, LoadedCommandPlugin] = {}
-
-    def register_builtin_plugins(self) -> None:
-        for plugin_name, plugin in get_builtin_plugin_name_to_plugin_spec().items():
-            try:
-                self._plugin_manager.register(plugin=plugin, name=plugin_name)
-            except Exception as ex:
-                log_exception(
-                    f"Cannot register plugin [{plugin_name}]: {ex.__str__()}", ex
-                )
-
-    def register_external_plugins(self, plugin_names: List[str]) -> None:
-        for plugin_name in plugin_names:
-            try:
-                self._plugin_manager.load_setuptools_entrypoints(
-                    SNOWCLI_COMMAND_PLUGIN_NAMESPACE, plugin_name
-                )
-            except Exception as ex:
-                log_exception(
-                    f"Cannot register plugin [{plugin_name}]: {ex.__str__()}", ex
-                )
-
-    def load_all_registered_plugins(self) -> List[LoadedCommandPlugin]:
-        for plugin_name, plugin in self._plugin_manager.list_name_plugin():
-            self._load_plugin(plugin_name, plugin)
-        return list(self._loaded_plugins.values())
-
-    def _load_plugin(self, plugin_name: str, plugin) -> Optional[LoadedCommandPlugin]:
-        already_loaded_plugin = self._loaded_plugins.get(plugin_name)
-        if already_loaded_plugin:
-            return already_loaded_plugin
-        return self._load_new_plugin(plugin_name, plugin)
-
-    def _load_new_plugin(
-        self, plugin_name: str, plugin
-    ) -> Optional[LoadedCommandPlugin]:
-        loaded_plugin = self._load_plugin_spec(plugin_name, plugin)
-        if not loaded_plugin:
-            return None
-        other_plugin_with_the_same_command_path = self._loaded_command_paths.get(
-            loaded_plugin.command_spec.full_command_path
-        )
-        if other_plugin_with_the_same_command_path:
-            log.error(
-                "Cannot load plugin [%s] "
-                "because it defines the same command [%s] "
-                "as already loaded plugin [%s].",
-                plugin_name,
-                loaded_plugin.command_spec.full_command_path,
-                other_plugin_with_the_same_command_path.plugin_name,
-            )
-            return None
-        self._loaded_plugins[plugin_name] = loaded_plugin
-        self._loaded_command_paths[
-            loaded_plugin.command_spec.full_command_path
-        ] = loaded_plugin
-
-        if self._is_external_plugin(loaded_plugin):
-            log.info("Loaded external plugin: %s", plugin_name)
-
-        return loaded_plugin
-
-    def _load_plugin_spec(
-        self, plugin_name: str, plugin
-    ) -> Optional[LoadedCommandPlugin]:
-        if plugin_name in get_builtin_plugin_name_to_plugin_spec().keys():
-            return self._load_builtin_plugin_spec(plugin_name, plugin)
-        else:
-            return self._load_external_plugin_spec(plugin_name, plugin)
-
-    def _load_builtin_plugin_spec(
-        self, plugin_name: str, plugin
-    ) -> Optional[LoadedCommandPlugin]:
-        command_spec = self._load_command_spec(plugin_name, plugin)
-        if command_spec:
-            return LoadedBuiltInCommandPlugin(
-                plugin_name=plugin_name,
-                command_spec=command_spec,
-            )
-        else:
-            return None
-
-    def _load_external_plugin_spec(
-        self, plugin_name: str, plugin
-    ) -> Optional[LoadedCommandPlugin]:
-        command_spec = self._load_command_spec(plugin_name, plugin)
-        if command_spec:
-            return LoadedExternalCommandPlugin(
-                plugin_name=plugin_name,
-                command_spec=command_spec,
-            )
-        else:
-            return None
-
-    @staticmethod
-    def _load_command_spec(plugin_name: str, plugin) -> Optional[CommandSpec]:
-        try:
-            return plugin.command_spec()
-        except Exception as ex:
-            log_exception(
-                f"Cannot load command specification from plugin [{plugin_name}]: {ex.__str__()}",
-                ex,
-            )
-            return None
-
-    @staticmethod
-    def _is_external_plugin(plugin) -> bool:
-        return isinstance(plugin, LoadedExternalCommandPlugin)
-
-
-def load_only_builtin_command_plugins() -> List[LoadedCommandPlugin]:
-    loader = CommandPluginsLoader()
-    loader.register_builtin_plugins()
-    return loader.load_all_registered_plugins()
-
-
-def load_builtin_and_external_command_plugins(
-    external_plugin_names: List[str],
-) -> List[LoadedCommandPlugin]:
-    loader = CommandPluginsLoader()
-    loader.register_builtin_plugins()
-    loader.register_external_plugins(external_plugin_names)
-    return loader.load_all_registered_plugins()

snowflake/cli/_app/commands_registration/commands_registration_with_callbacks.py

@@ -1,105 +0,0 @@
-# Copyright (c) 2024 Snowflake Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Callable, List
-
-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,
-)
-from snowflake.cli.api.plugins.plugin_config import PluginConfigProvider
-
-
-@dataclass
-class CommandRegistrationConfig:
-    enable_external_command_plugins: bool
-
-
-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:
-        if self._commands_registration_config.enable_external_command_plugins:
-            self._register_builtin_and_enabled_external_plugin_commands()
-        else:
-            self._register_only_builtin_plugin_commands()
-
-        self._commands_already_registered = True
-        for callback in self._callbacks_after_registration:
-            callback()
-
-    @staticmethod
-    def _register_only_builtin_plugin_commands() -> None:
-        loaded_command_plugins = load_only_builtin_command_plugins()
-        register_commands_from_plugins(loaded_command_plugins)
-
-    def _register_builtin_and_enabled_external_plugin_commands(self):
-        enabled_external_plugins = (
-            self._plugin_config_provider.get_enabled_plugin_names()
-        )
-        loaded_command_plugins = load_builtin_and_external_command_plugins(
-            enabled_external_plugins
-        )
-        register_commands_from_plugins(loaded_command_plugins)
-
-    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))
-
-        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/commands_registration/exception_logging.py

@@ -1,26 +0,0 @@
-# Copyright (c) 2024 Snowflake Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from logging import Logger
-from typing import Callable
-
-from snowflake.cli.api.cli_global_context import get_cli_context
-
-
-def exception_logging(logger: Logger) -> Callable[[str, Exception], None]:
-    def log_error(msg: str, exception: Exception) -> None:
-        exc_info = exception if get_cli_context().enable_tracebacks else None
-        logger.error(msg=msg, exc_info=exc_info)
-
-    return log_error

snowflake/cli/_app/commands_registration/threadsafe.py

@@ -1,48 +0,0 @@
-# Copyright (c) 2024 Snowflake Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import annotations
-
-import threading
-from typing import Callable, Generic, TypeVar
-
-T = TypeVar("T")
-
-
-class ThreadsafeValue(Generic[T]):
-    def __init__(self, value: T):
-        self._value = value
-        self._lock = threading.Lock()
-
-    def set(self, new_value: T) -> T:  # noqa: A003
-        return self.transform(lambda _: new_value)
-
-    def transform(self, f: Callable[[T], T]) -> T:
-        with self._lock:
-            new_value = f(self._value)
-            self._value = new_value
-            return new_value
-
-    @property
-    def value(self) -> T:
-        with self._lock:
-            return self._value
-
-
-class ThreadsafeCounter(ThreadsafeValue[int]):
-    def increment(self, d=1) -> int:
-        return self.transform(lambda v: v + d)
-
-    def decrement(self, d=1) -> int:
-        return self.increment(-d)

snowflake/cli/_app/commands_registration/typer_registration.py

@@ -1,153 +0,0 @@
-# Copyright (c) 2024 Snowflake Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import annotations
-
-import logging
-from typing import List
-
-import click
-from snowflake.cli._app.commands_registration import LoadedCommandPlugin
-from snowflake.cli._app.commands_registration.exception_logging import exception_logging
-from snowflake.cli.api.plugins.command import CommandSpec, CommandType
-from typer.core import TyperGroup
-
-log = logging.getLogger(__name__)
-log_exception = exception_logging(log)
-
-
-class TyperCommandsRegistration:
-    def __init__(self, plugins: List[LoadedCommandPlugin]):
-        self._plugins = plugins
-        self._main_typer_command_group = (
-            self._get_main_typer_command_group_from_click_context()
-        )
-
-    def register_commands(self):
-        for plugin in self._plugins:
-            try:
-                self._add_plugin_to_typer(plugin.command_spec)
-            except Exception as ex:
-                log_exception(
-                    f"Cannot register plugin [{plugin.plugin_name}]: {ex.__str__()}", ex
-                )
-
-    @staticmethod
-    def _get_main_typer_command_group_from_click_context() -> TyperGroup:
-        main_typer_command_group = click.get_current_context().command
-        if isinstance(main_typer_command_group, TyperGroup):
-            return main_typer_command_group
-        else:
-            raise RuntimeError(
-                "Invalid main top-level command type. It should be a TyperGroup but it is not."
-            )
-
-    def _add_plugin_to_typer(
-        self,
-        command_spec: CommandSpec,
-    ) -> None:
-        command_spec = self._adjust_command_spec_if_required(command_spec)
-        parent_group = self._find_typer_group_at_path(
-            current_level_group=self._main_typer_command_group,
-            remaining_parent_path_segments=command_spec.parent_command_path.path_segments,
-            command_spec=command_spec,
-        )
-        self._validate_command_spec(command_spec, parent_group)
-        parent_group.add_command(command_spec.command)
-
-    def _adjust_command_spec_if_required(
-        self,
-        command_spec: CommandSpec,
-    ) -> CommandSpec:
-        command_spec = self._add_empty_callback_to_command_spec_if_required(
-            command_spec
-        )
-        return command_spec
-
-    @staticmethod
-    def _add_empty_callback_to_command_spec_if_required(
-        command_spec: CommandSpec,
-    ) -> CommandSpec:
-        new_command_spec = command_spec
-        is_specified_as_command_group = (
-            command_spec.command_type == CommandType.COMMAND_GROUP
-        )
-        is_typer_group = isinstance(command_spec.command, TyperGroup)
-        if is_specified_as_command_group and not is_typer_group:
-            typer_instance = command_spec.typer_instance
-            typer_instance.callback()(lambda: None)
-            new_command_spec = CommandSpec(
-                parent_command_path=command_spec.parent_command_path,
-                command_type=command_spec.command_type,
-                typer_instance=typer_instance,
-            )
-        return new_command_spec
-
-    @staticmethod
-    def _validate_command_spec(
-        command_spec: CommandSpec,
-        parent_group: TyperGroup,
-    ) -> None:
-        command = command_spec.command
-        command_type = command_spec.command_type
-        is_typer_group = isinstance(command, TyperGroup)
-        if command.name in parent_group.commands:
-            raise RuntimeError(
-                f"Cannot add command [{command_spec.full_command_path}] because it already exists."
-            )
-        if command_type == CommandType.SINGLE_COMMAND and is_typer_group:
-            raise RuntimeError(
-                f"Cannot add command [{command_spec.full_command_path}] "
-                + f"because its command type is {CommandType.SINGLE_COMMAND} "
-                + f"while its implementation contains elements "
-                + f"making it a TyperGroup ({CommandType.COMMAND_GROUP}) "
-                + f"(a callback or multiple nested commands)."
-            )
-        if command_type == CommandType.COMMAND_GROUP and not is_typer_group:
-            raise RuntimeError(
-                f"Cannot add command [{command_spec.full_command_path}] "
-                + f"because its command type is {CommandType.COMMAND_GROUP} "
-                + f"while its implementation is not a TyperGroup."
-            )
-
-    def _find_typer_group_at_path(
-        self,
-        current_level_group: TyperGroup,
-        remaining_parent_path_segments: List[str],
-        command_spec: CommandSpec,
-    ) -> TyperGroup:
-        if remaining_parent_path_segments:
-            expected_name = remaining_parent_path_segments[0]
-            matching_subgroups = [
-                subgroup
-                for subgroup in current_level_group.commands.values()
-                if isinstance(subgroup, TyperGroup) and subgroup.name == expected_name
-            ]
-            if matching_subgroups:
-                return self._find_typer_group_at_path(
-                    current_level_group=matching_subgroups[0],
-                    remaining_parent_path_segments=remaining_parent_path_segments[1:],
-                    command_spec=command_spec,
-                )
-            else:
-                raise RuntimeError(
-                    f"Invalid command path [{command_spec.full_command_path}]. "
-                    f"Command group [{expected_name}] does not exist."
-                )
-        else:
-            return current_level_group
-
-
-def register_commands_from_plugins(plugins: List[LoadedCommandPlugin]) -> None:
-    return TyperCommandsRegistration(plugins).register_commands()

snowflake/cli/_app/constants.py

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

snowflake/cli/_app/dev/__init__.py

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

snowflake/cli/_app/dev/commands_structure.py

@@ -1,48 +0,0 @@
-# Copyright (c) 2024 Snowflake Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Dict
-
-from click import Command
-
-
-@dataclass
-class _Node:
-    name: str
-    children: Dict[str, _Node] = field(default_factory=dict)
-    level: int = 0
-
-    def print_node(self):
-        print("    " * self.level, self.name)
-        for ch in self.children.values():
-            ch.print_node()
-
-
-def generate_commands_structure(command: Command, root: _Node | None = None):
-    """
-    Iterates recursively through commands info. Creates tree-like structure
-    of commands.
-    """
-    if not root:
-        root = _Node(name="snow")
-
-    if hasattr(command, "commands"):
-        for command_name, command_info in command.commands.items():
-            if command_name not in root.children:
-                root.children[command_name] = _Node(command_name, level=root.level + 1)
-            generate_commands_structure(command_info, root.children[command_name])
-    return root

snowflake/cli/_app/dev/docs/__init__.py

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