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

snowflake/cli/api/commands/overrideable_parameter.py

@@ -1,143 +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 abc import ABC, abstractmethod
-from inspect import signature
-from typing import Any, List, Optional, Tuple
-
-import typer
-from click import ClickException
-from snowflake.cli.api.exceptions import IncompatibleParametersError
-
-
-class _OverrideableParameter(ABC):
-    """
-    Class that allows you to generate instances of typer.models.OptionInfo with some default properties while allowing
-    specific values to be overridden.
-
-    Custom parameters:
-    - mutually_exclusive (Tuple[str]|List[str]): A list of parameter names that this Option is not compatible with. If this Option has
-     a truthy value and any of the other parameters in the mutually_exclusive list has a truthy value, a
-     ClickException will be thrown. Note that mutually_exclusive can contain an option's own name but does not require
-     it.
-    """
-
-    def __init__(
-        self,
-        default: Any = ...,
-        *param_decls: str,
-        mutually_exclusive: Optional[List[str] | Tuple[str]] = None,
-        **kwargs,
-    ):
-        self.default = default
-        self.param_decls = param_decls
-        self.mutually_exclusive = mutually_exclusive
-        self.kwargs = kwargs
-
-    def __call__(self, **kwargs) -> typer.models.ParameterInfo:
-        """
-        Returns a typer.models.OptionInfo instance initialized with the specified default values along with any overrides
-        from kwargs. Note that if you are overriding param_decls, you must pass an iterable of strings, you cannot use
-        positional arguments like you can with typer.Option. Does not modify the original instance.
-        """
-        default = kwargs.get("default", self.default)
-        param_decls = kwargs.get("param_decls", self.param_decls)
-        mutually_exclusive = kwargs.get("mutually_exclusive", self.mutually_exclusive)
-        if not isinstance(param_decls, list) and not isinstance(param_decls, tuple):
-            raise TypeError("param_decls must be a list or tuple")
-        passed_kwargs = self.kwargs.copy()
-        passed_kwargs.update(kwargs)
-        if passed_kwargs.get("callback", None) or mutually_exclusive:
-            passed_kwargs["callback"] = self._callback_factory(
-                passed_kwargs.get("callback", None), mutually_exclusive
-            )
-        for non_kwarg in ["default", "param_decls", "mutually_exclusive"]:
-            passed_kwargs.pop(non_kwarg, None)
-
-        return self.get_parameter(default, *param_decls, **passed_kwargs)
-
-    @abstractmethod
-    def get_parameter(
-        self, default: Any = None, *param_decls: str, **kwargs
-    ) -> typer.models.ParameterInfo:
-        pass
-
-    class InvalidCallbackSignature(ClickException):
-        def __init__(self, callback):
-            super().__init__(
-                f"Signature {signature(callback)} is not valid for an OverrideableOption callback function. Must have "
-                f"at most one parameter with each of the following types: (typer.Context, typer.CallbackParam, "
-                f"Any Other Type)"
-            )
-
-    def _callback_factory(
-        self, callback, mutually_exclusive: Optional[List[str] | Tuple[str]]
-    ):
-        callback = callback if callback else lambda x: x
-
-        # inspect existing_callback to make sure signature is valid
-        existing_params = signature(callback).parameters
-        # at most one parameter with each type in [typer.Context, typer.CallbackParam, any other type]
-        limits = [
-            lambda x: x == typer.Context,
-            lambda x: x == typer.CallbackParam,
-            lambda x: x != typer.Context and x != typer.CallbackParam,
-        ]
-        for limit in limits:
-            if len([v for v in existing_params.values() if limit(v.annotation)]) > 1:
-                raise self.InvalidCallbackSignature(callback)
-
-        def generated_callback(ctx: typer.Context, param: typer.CallbackParam, value):
-            if mutually_exclusive:
-                for name in mutually_exclusive:
-                    if value and ctx.params.get(
-                        name, False
-                    ):  # if the current parameter is set to True and a previous parameter is also Truthy
-                        curr_opt = param.opts[0]
-                        other_opt = [x for x in ctx.command.params if x.name == name][
-                            0
-                        ].opts[0]
-                        raise IncompatibleParametersError([curr_opt, other_opt])
-
-            # pass args to existing callback based on its signature (this is how Typer infers callback args)
-            passed_params = {}
-            for existing_param in existing_params:
-                annotation = existing_params[existing_param].annotation
-                if annotation == typer.Context:
-                    passed_params[existing_param] = ctx
-                elif annotation == typer.CallbackParam:
-                    passed_params[existing_param] = param
-                else:
-                    passed_params[existing_param] = value
-            return callback(**passed_params)
-
-        return generated_callback
-
-
-class OverrideableArgument(_OverrideableParameter):
-    def get_parameter(
-        self, default: Any = ..., *param_decls: str, **kwargs
-    ) -> typer.models.ArgumentInfo:
-        return typer.Argument(default, *param_decls, **kwargs)
-
-
-# OverrideableOption doesn't work with flags with type List[Any] and default None, because typer executes the callback
-# function which converts the default value iterating over it, but None is not iterable.
-class OverrideableOption(_OverrideableParameter):
-    def get_parameter(
-        self, default: Any = ..., *param_decls: str, **kwargs
-    ) -> typer.models.OptionInfo:
-        return typer.Option(default, *param_decls, **kwargs)

snowflake/cli/api/commands/snow_typer.py

@@ -1,247 +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 dataclasses
-import logging
-from functools import wraps
-from typing import Any, Callable, Dict, List, Optional, Tuple
-
-import typer
-from click import ClickException
-from snowflake.cli.api.commands.decorators import (
-    global_options,
-    global_options_with_connection,
-)
-from snowflake.cli.api.commands.execution_metadata import (
-    ExecutionMetadata,
-    ExecutionStatus,
-)
-from snowflake.cli.api.commands.flags import DEFAULT_CONTEXT_SETTINGS
-from snowflake.cli.api.exceptions import CommandReturnTypeError
-from snowflake.cli.api.output.types import CommandResult
-from snowflake.cli.api.sanitizers import sanitize_for_terminal
-from snowflake.cli.api.sql_execution import SqlExecutionMixin
-from snowflake.connector import DatabaseError
-
-log = logging.getLogger(__name__)
-
-
-class SnowTyper(typer.Typer):
-    def __init__(self, /, **kwargs):
-        self._sanitize_kwargs(kwargs)
-        super().__init__(
-            **kwargs,
-            context_settings=DEFAULT_CONTEXT_SETTINGS,
-            pretty_exceptions_show_locals=False,
-            no_args_is_help=True,
-            add_completion=True,
-            rich_markup_mode="markdown",
-        )
-
-    @staticmethod
-    def _sanitize_kwargs(kwargs: Dict):
-        # Sanitize all string options that are visible in terminal output
-        known_keywords = [
-            "help",
-            "short_help",
-            "options_metavar",
-            "rich_help_panel",
-            "epilog",
-        ]
-        for kw in known_keywords:
-            if kw in kwargs:
-                kwargs[kw] = sanitize_for_terminal(kwargs[kw])
-        return kwargs
-
-    @wraps(typer.Typer.command)
-    def command(
-        self,
-        name: Optional[str] = None,
-        requires_global_options: bool = True,
-        requires_connection: bool = False,
-        is_enabled: Callable[[], bool] | None = None,
-        require_warehouse: bool = False,
-        **kwargs,
-    ):
-        """
-        Custom implementation of Typer.command that adds ability to execute additional
-        logic before and after execution as well as process the result and act on possible
-        errors.
-        """
-        name = sanitize_for_terminal(name)
-        self._sanitize_kwargs(kwargs)
-        if is_enabled is not None and not is_enabled():
-            return lambda func: func
-
-        def custom_command(command_callable):
-            """Custom command wrapper similar to Typer.command."""
-            # Sanitize doc string which is used to create help in terminal
-            command_callable.__doc__ = sanitize_for_terminal(command_callable.__doc__)
-
-            if requires_connection:
-                command_callable = global_options_with_connection(command_callable)
-            elif requires_global_options:
-                command_callable = global_options(command_callable)
-
-            @wraps(command_callable)
-            def command_callable_decorator(*args, **kw):
-                """Wrapper around command callable. This is what happens at "runtime"."""
-                execution = ExecutionMetadata()
-                self.pre_execute(execution, require_warehouse=require_warehouse)
-                try:
-                    result = command_callable(*args, **kw)
-                    self.process_result(result)
-                    execution.complete(ExecutionStatus.SUCCESS)
-                except BaseException as err:
-                    execution.complete(ExecutionStatus.FAILURE)
-                    exception = self.exception_handler(err, execution)
-                    raise exception
-                finally:
-                    self.post_execute(execution)
-
-            return super(SnowTyper, self).command(name=name, **kwargs)(
-                command_callable_decorator
-            )
-
-        return custom_command
-
-    @staticmethod
-    def pre_execute(execution: ExecutionMetadata, require_warehouse: bool = False):
-        """
-        Callback executed before running any command callable (after context execution).
-        Pay attention to make this method safe to use if performed operations are not necessary
-        for executing the command in proper way.
-        """
-        from snowflake.cli._app.telemetry import log_command_usage
-
-        log.debug("Executing command pre execution callback")
-        log_command_usage(execution)
-        if require_warehouse and not SqlExecutionMixin().session_has_warehouse():
-            raise ClickException(
-                "The command requires warehouse. No warehouse found in current connection."
-            )
-
-    @staticmethod
-    def process_result(result):
-        """Command result processor"""
-        from snowflake.cli._app.printing import print_result
-
-        # Because we still have commands like "logs" that do not return anything.
-        # We should improve it in future.
-        if not result:
-            return
-        if not isinstance(result, CommandResult):
-            raise CommandReturnTypeError(type(result))
-        print_result(result)
-
-    @staticmethod
-    def exception_handler(exception: Exception, execution: ExecutionMetadata):
-        """
-        Callback executed on command execution error.
-        """
-        from snowflake.cli._app.telemetry import log_command_execution_error
-
-        log.debug("Executing command exception callback")
-        log_command_execution_error(exception, execution)
-        if isinstance(exception, DatabaseError):
-            return ClickException(exception.msg)
-        return exception
-
-    @staticmethod
-    def post_execute(execution: ExecutionMetadata):
-        """
-        Callback executed after running any command callable. Pay attention to make this method safe to
-        use if performed operations are not necessary for executing the command in proper way.
-        """
-        from snowflake.cli._app.telemetry import flush_telemetry, log_command_result
-
-        log.debug("Executing command post execution callback")
-        log_command_result(execution)
-        flush_telemetry()
-
-
-@dataclasses.dataclass
-class SnowTyperCommandData:
-    """
-    Class for storing data of commands to be registered in SnowTyper instances created by SnowTyperFactory.
-    """
-
-    func: Callable
-    args: Tuple[Any, ...]
-    kwargs: Dict[str, Any]
-
-
-class SnowTyperFactory:
-    """
-    SnowTyper factory. Usage is similar to SnowTyper, except that create_instance()
-    creates actual SnowTyper instance.
-    """
-
-    def __init__(
-        self,
-        /,
-        name: Optional[str] = None,
-        help: Optional[str] = None,  # noqa: A002
-        short_help: Optional[str] = None,
-        is_hidden: Optional[Callable[[], bool]] = None,
-        deprecated: bool = False,
-    ):
-        self.name = name
-        self.help = help
-        self.short_help = short_help
-        self.is_hidden = is_hidden
-        self.deprecated = deprecated
-        self.commands_to_register: List[SnowTyperCommandData] = []
-        self.subapps_to_register: List[SnowTyperFactory] = []
-        self.callbacks_to_register: List[Callable] = []
-
-    def create_instance(self) -> SnowTyper:
-        app = SnowTyper(
-            name=self.name,
-            help=self.help,
-            short_help=self.short_help,
-            hidden=self.is_hidden() if self.is_hidden else False,
-            deprecated=self.deprecated,
-        )
-        # register commands
-        for command in self.commands_to_register:
-            app.command(*command.args, **command.kwargs)(command.func)
-        # register callbacks
-        for callback in self.callbacks_to_register:
-            app.callback()(callback)
-        # add subgroups
-        for subapp in self.subapps_to_register:
-            app.add_typer(subapp.create_instance())
-        return app
-
-    def command(self, *args, **kwargs):
-        def decorator(command):
-            self.commands_to_register.append(
-                SnowTyperCommandData(command, args=args, kwargs=kwargs)
-            )
-            return command
-
-        return decorator
-
-    def add_typer(self, snow_typer: SnowTyperFactory) -> None:
-        self.subapps_to_register.append(snow_typer)
-
-    def callback(self):
-        def decorator(callback):
-            self.callbacks_to_register.append(callback)
-            return callback
-
-        return decorator

snowflake/cli/api/commands/utils.py

@@ -1,18 +0,0 @@
-from typing import List, Optional
-
-from click import ClickException
-from snowflake.cli.api.commands.common import Variable
-
-
-def parse_key_value_variables(variables: Optional[List[str]]) -> List[Variable]:
-    """Util for parsing key=value input. Useful for commands accepting multiple input options."""
-    result: List[Variable] = []
-    if not variables:
-        return result
-    for p in variables:
-        if "=" not in p:
-            raise ClickException(f"Invalid variable: '{p}'")
-
-        key, value = p.split("=", 1)
-        result.append(Variable(key.strip(), value.strip()))
-    return result