snowflake-cli-labs 3.0.0rc5__py3-none-any.whl → 3.0.2__py3-none-any.whl

snowflake/cli/api/cli_global_context.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
-
-from contextlib import contextmanager
-from contextvars import ContextVar
-from dataclasses import dataclass, field, replace
-from pathlib import Path
-from typing import TYPE_CHECKING, Iterator
-
-from snowflake.cli.api.connections import ConnectionContext, OpenConnectionCache
-from snowflake.cli.api.exceptions import MissingConfiguration
-from snowflake.cli.api.metrics import CLIMetrics
-from snowflake.cli.api.output.formats import OutputFormat
-from snowflake.cli.api.rendering.jinja import CONTEXT_KEY
-from snowflake.connector import SnowflakeConnection
-
-if TYPE_CHECKING:
-    from snowflake.cli.api.project.definition_manager import DefinitionManager
-    from snowflake.cli.api.project.schemas.project_definition import ProjectDefinition
-
-_CONNECTION_CACHE = OpenConnectionCache()
-
-
-@dataclass
-class _CliGlobalContextManager:
-    connection_context: ConnectionContext = field(default_factory=ConnectionContext)
-    connection_cache: OpenConnectionCache = (
-        _CONNECTION_CACHE  # by default, use global cache
-    )
-
-    output_format: OutputFormat = OutputFormat.TABLE
-    silent: bool = False
-    verbose: bool = False
-    experimental: bool = False
-    enable_tracebacks: bool = True
-
-    metrics: CLIMetrics = field(default_factory=CLIMetrics)
-
-    project_path_arg: str | None = None
-    project_is_optional: bool = True
-    project_env_overrides_args: dict[str, str] = field(default_factory=dict)
-
-    # FIXME: this property only exists to help implement
-    # nativeapp_definition_v2_to_v1. Consider changing the way
-    # this calculation is provided to commands in order to remove
-    # this logic (then make project_definition a non-cloned @property)
-    override_project_definition: ProjectDefinition | None = None
-
-    _definition_manager: DefinitionManager | None = None
-
-    # which properties invalidate our current DefinitionManager?
-    DEFINITION_MANAGER_DEPENDENCIES = [
-        "project_path_arg",
-        "project_is_optional",
-        "project_env_overrides_args",
-    ]
-
-    def reset(self):
-        self.__init__()
-
-    def clone(self) -> _CliGlobalContextManager:
-        return replace(
-            self,
-            connection_context=self.connection_context.clone(),
-            project_env_overrides_args=self.project_env_overrides_args.copy(),
-        )
-
-    def __setattr__(self, prop, val):
-        if prop in self.DEFINITION_MANAGER_DEPENDENCIES:
-            self._clear_definition_manager()
-
-        super().__setattr__(prop, val)
-
-    @property
-    def project_definition(self) -> ProjectDefinition | None:
-        if self.override_project_definition:
-            return self.override_project_definition
-
-        return self._definition_manager_or_raise().project_definition
-
-    @property
-    def project_root(self) -> Path:
-        return Path(self._definition_manager_or_raise().project_root)
-
-    @property
-    def template_context(self) -> dict:
-        return self._definition_manager_or_raise().template_context
-
-    @property
-    def connection(self) -> SnowflakeConnection:
-        """
-        Returns a connection for our configured context from the configured cache.
-        By default, this is the global _CONNECTION_CACHE. If a matching connection
-        does not already exist, creates a new connection and caches it.
-        """
-        self.connection_context.validate_and_complete()
-        return self.connection_cache[self.connection_context]
-
-    def _definition_manager_or_raise(self) -> DefinitionManager:
-        """
-        (Re-)parses project definition based on project args (project_path_arg and
-        project_env_overrides_args). If we cannot provide a project definition
-        (i.e. no snowflake.yml) and require one, raises MissingConfiguration.
-        """
-        from snowflake.cli.api.project.definition_manager import DefinitionManager
-
-        # don't need to re-parse definition if we already have one
-        if not self._definition_manager:
-            dm = DefinitionManager(
-                self.project_path_arg,
-                {CONTEXT_KEY: {"env": self.project_env_overrides_args}},
-            )
-            if not dm.has_definition_file and not self.project_is_optional:
-                raise MissingConfiguration(
-                    "Cannot find project definition (snowflake.yml). Please provide a path to the project or run this command in a valid project directory."
-                )
-            self._definition_manager = dm
-
-        return self._definition_manager
-
-    def _clear_definition_manager(self):
-        """
-        Force re-calculation of definition_manager and its dependent attributes
-        (template_context, project_definition, and project_root).
-        """
-        self._definition_manager = None
-
-
-class _CliGlobalContextAccess:
-    def __init__(self, manager: _CliGlobalContextManager):
-        self._manager = manager
-
-    @property
-    def connection(self) -> SnowflakeConnection:
-        return self._manager.connection
-
-    @property
-    def connection_context(self) -> ConnectionContext:
-        return self._manager.connection_context
-
-    @property
-    def enable_tracebacks(self) -> bool:
-        return self._manager.enable_tracebacks
-
-    @property
-    def metrics(self):
-        return self._manager.metrics
-
-    @property
-    def output_format(self) -> OutputFormat:
-        return self._manager.output_format
-
-    @property
-    def verbose(self) -> bool:
-        return self._manager.verbose
-
-    @property
-    def experimental(self) -> bool:
-        return self._manager.experimental
-
-    @property
-    def project_definition(self) -> ProjectDefinition | None:
-        return self._manager.project_definition
-
-    @property
-    def project_root(self) -> Path | None:
-        return self._manager.project_root
-
-    @property
-    def template_context(self) -> dict:
-        return self._manager.template_context
-
-    @property
-    def silent(self) -> bool:
-        if self._should_force_mute_intermediate_output:
-            return True
-        return self._manager.silent
-
-    @property
-    def _should_force_mute_intermediate_output(self) -> bool:
-        """Computes whether cli_console output should be muted."""
-        return self._manager.output_format == OutputFormat.JSON
-
-
-_CLI_CONTEXT_MANAGER: ContextVar[_CliGlobalContextManager | None] = ContextVar(
-    "cli_context", default=None
-)
-
-
-def get_cli_context_manager() -> _CliGlobalContextManager:
-    mgr = _CLI_CONTEXT_MANAGER.get()
-    if not mgr:
-        mgr = _CliGlobalContextManager()
-        _CLI_CONTEXT_MANAGER.set(mgr)
-    return mgr
-
-
-def get_cli_context() -> _CliGlobalContextAccess:
-    return _CliGlobalContextAccess(get_cli_context_manager())
-
-
-@contextmanager
-def fork_cli_context(
-    connection_overrides: dict | None = None,
-    project_env_overrides: dict[str, str] | None = None,
-    project_is_optional: bool | None = None,
-    project_path: str | None = None,
-) -> Iterator[_CliGlobalContextAccess]:
-    """
-    Forks the global CLI context, making changes that are only visible
-    (e.g. via get_cli_context()) while inside this context manager.
-
-    Please note that environment variable changes are only visible through
-    the project definition; os.getenv / os.environ / get_env_value are not
-    affected by these new values.
-    """
-    old_manager = get_cli_context_manager()
-    new_manager = old_manager.clone()
-    token = _CLI_CONTEXT_MANAGER.set(new_manager)
-
-    if connection_overrides:
-        new_manager.connection_context.update(**connection_overrides)
-
-    if project_env_overrides:
-        new_manager.project_env_overrides_args.update(project_env_overrides)
-
-    if project_is_optional is not None:
-        new_manager.project_is_optional = project_is_optional
-
-    if project_path:
-        new_manager.project_path_arg = project_path
-
-    yield _CliGlobalContextAccess(new_manager)
-    _CLI_CONTEXT_MANAGER.reset(token)

snowflake/cli/api/commands/__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/api/commands/alias.py

@@ -1,23 +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 copy import deepcopy
-
-
-def build_alias(main_app, name: str, help_str: str):
-    alias = deepcopy(main_app)
-    alias.info.name = name
-    alias.info.help = help_str
-    alias.info.hidden = True
-    return alias

snowflake/cli/api/commands/common.py

@@ -1,25 +0,0 @@
-from dataclasses import dataclass
-from enum import Enum
-
-
-class OnErrorType(Enum):
-    """
-    Command option values for what to do when an error occurs.
-    """
-
-    BREAK = "break"
-    CONTINUE = "continue"
-
-
-@dataclass
-class Variable:
-    """
-    Key-value pair dataclass, returned after parsing "key=value" command options.
-    """
-
-    key: str
-    value: str
-
-    def __init__(self, key: str, value: str):
-        self.key = key
-        self.value = value

snowflake/cli/api/commands/decorators.py

@@ -1,369 +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 inspect
-from functools import wraps
-from inspect import Signature
-from typing import Callable, Dict, List, Optional, get_type_hints
-
-from snowflake.cli.api.cli_global_context import get_cli_context
-from snowflake.cli.api.commands.flags import (
-    AccountOption,
-    AuthenticatorOption,
-    ConnectionOption,
-    DatabaseOption,
-    DebugOption,
-    DiagAllowlistPathOption,
-    DiagLogPathOption,
-    EnableDiagOption,
-    HostOption,
-    MasterTokenOption,
-    MfaPasscodeOption,
-    OutputFormatOption,
-    PasswordOption,
-    PortOption,
-    PrivateKeyPathOption,
-    RoleOption,
-    SchemaOption,
-    SessionTokenOption,
-    SilentOption,
-    TemporaryConnectionOption,
-    TokenFilePathOption,
-    UserOption,
-    VerboseOption,
-    WarehouseOption,
-    experimental_option,
-    project_definition_option,
-    project_env_overrides_option,
-)
-from snowflake.cli.api.exceptions import CommandReturnTypeError
-from snowflake.cli.api.output.formats import OutputFormat
-from snowflake.cli.api.output.types import CommandResult
-
-
-def global_options(func: Callable):
-    """
-    Decorator providing default flags for overriding global parameters. Values are
-    updated in global SnowCLI state.
-
-    To use this decorator your command needs to accept **options as last argument.
-    """
-    return _global_options_decorator_factory(func, GLOBAL_OPTIONS)
-
-
-def global_options_with_connection(func: Callable):
-    """
-    Decorator providing default flags including connection flags for overriding
-    global parameters. Values are updated in global SnowCLI state.
-
-    To use this decorator your command needs to accept **options as last argument.
-    """
-    return _global_options_decorator_factory(
-        func, [*GLOBAL_CONNECTION_OPTIONS, *GLOBAL_OPTIONS]
-    )
-
-
-def with_project_definition(is_optional: bool = False):
-    def _decorator(func: Callable):
-
-        return _options_decorator_factory(
-            func,
-            additional_options=[
-                inspect.Parameter(
-                    "project_definition",
-                    inspect.Parameter.KEYWORD_ONLY,
-                    annotation=Optional[str],
-                    default=project_definition_option(is_optional),
-                ),
-                inspect.Parameter(
-                    "env_overrides",
-                    inspect.Parameter.KEYWORD_ONLY,
-                    annotation=List[str],
-                    default=project_env_overrides_option(),
-                ),
-            ],
-        )
-
-    return _decorator
-
-
-def with_experimental_behaviour(
-    experimental_behaviour_description: Optional[str] = None,
-):
-    """
-    Decorator providing --experimental flag, which allows to use experimental behaviour in commands implementation.
-
-    To use this decorator your command needs to accept **options as last argument.
-    """
-    additional_options = [
-        inspect.Parameter(
-            "experimental",
-            inspect.Parameter.KEYWORD_ONLY,
-            annotation=Optional[bool],
-            default=experimental_option(experimental_behaviour_description),
-        ),
-    ]
-
-    def decorator(func: Callable):
-        return _options_decorator_factory(
-            func=func,
-            additional_options=additional_options,
-        )
-
-    return decorator
-
-
-def _execute_before_command_using_global_options(**options):
-    from snowflake.cli._app.loggers import create_loggers
-
-    cli_context = get_cli_context()
-    create_loggers(cli_context.verbose, cli_context.enable_tracebacks)
-
-
-def _global_options_decorator_factory(
-    func: Callable, additional_options: List[inspect.Parameter]
-):
-    return _options_decorator_factory(
-        func=func,
-        additional_options=additional_options,
-        execute_before_command_using_new_options=_execute_before_command_using_global_options,
-    )
-
-
-def _options_decorator_factory(
-    func: Callable,
-    additional_options: List[inspect.Parameter],
-    execute_before_command_using_new_options: Optional[Callable] = None,
-):
-    """
-    execute_before_command_using_new_options executes before command telemetry has been emitted,
-    but after command line options have been populated.
-    """
-
-    @wraps(func)
-    def wrapper(**options):
-        if execute_before_command_using_new_options:
-            execute_before_command_using_new_options(**options)
-        return func(**options)
-
-    wrapper.__signature__ = _extend_signature_with_additional_options(func, additional_options)  # type: ignore
-    return wrapper
-
-
-def _extend_signature_with_additional_options(
-    func: Callable, additional_options: List[inspect.Parameter]
-) -> Signature:
-    """Extends function signature with additional options"""
-    sig = inspect.signature(func)
-
-    # Remove **options from signature
-    existing_parameters = tuple(
-        [p for p in sig.parameters.values() if not _is_options_parameter(p)]
-    )
-
-    type_hints = get_type_hints(func)
-    existing_parameters_with_evaluated_types = [
-        _evaluate_param_type(p, type_hints) for p in existing_parameters
-    ]
-    parameters = [
-        *existing_parameters_with_evaluated_types,
-        *additional_options,
-    ]
-    return sig.replace(parameters=parameters)
-
-
-def _is_options_parameter(param: inspect.Parameter) -> bool:
-    return param.kind == inspect.Parameter.VAR_KEYWORD and param.name == "options"
-
-
-def _evaluate_param_type(
-    param: inspect.Parameter, type_hints: Dict[str, type]
-) -> inspect.Parameter:
-    type_annotation = (
-        type_hints.get(param.annotation)
-        if isinstance(param.annotation, str)
-        else param.annotation
-    )
-    return inspect.Parameter(
-        name=param.name,
-        kind=param.kind,
-        annotation=type_annotation,
-        default=param.default,
-    )
-
-
-GLOBAL_CONNECTION_OPTIONS = [
-    inspect.Parameter(
-        "connection",
-        inspect.Parameter.KEYWORD_ONLY,
-        annotation=Optional[str],
-        default=ConnectionOption,
-    ),
-    inspect.Parameter(
-        "host",
-        inspect.Parameter.KEYWORD_ONLY,
-        annotation=Optional[str],
-        default=HostOption,
-    ),
-    inspect.Parameter(
-        "port",
-        inspect.Parameter.KEYWORD_ONLY,
-        annotation=Optional[int],
-        default=PortOption,
-    ),
-    inspect.Parameter(
-        "account",
-        inspect.Parameter.KEYWORD_ONLY,
-        annotation=Optional[str],
-        default=AccountOption,
-    ),
-    inspect.Parameter(
-        "user",
-        inspect.Parameter.KEYWORD_ONLY,
-        annotation=Optional[str],
-        default=UserOption,
-    ),
-    inspect.Parameter(
-        "password",
-        inspect.Parameter.KEYWORD_ONLY,
-        annotation=Optional[str],
-        default=PasswordOption,
-    ),
-    inspect.Parameter(
-        "authenticator",
-        inspect.Parameter.KEYWORD_ONLY,
-        annotation=Optional[str],
-        default=AuthenticatorOption,
-    ),
-    inspect.Parameter(
-        "private_key_file",
-        inspect.Parameter.KEYWORD_ONLY,
-        annotation=Optional[str],
-        default=PrivateKeyPathOption,
-    ),
-    inspect.Parameter(
-        "session_token",
-        inspect.Parameter.KEYWORD_ONLY,
-        annotation=Optional[str],
-        default=SessionTokenOption,
-    ),
-    inspect.Parameter(
-        "master_token",
-        inspect.Parameter.KEYWORD_ONLY,
-        annotation=Optional[str],
-        default=MasterTokenOption,
-    ),
-    inspect.Parameter(
-        "token_file_path",
-        inspect.Parameter.KEYWORD_ONLY,
-        annotation=Optional[str],
-        default=TokenFilePathOption,
-    ),
-    inspect.Parameter(
-        "database",
-        inspect.Parameter.KEYWORD_ONLY,
-        annotation=Optional[str],
-        default=DatabaseOption,
-    ),
-    inspect.Parameter(
-        "schema",
-        inspect.Parameter.KEYWORD_ONLY,
-        annotation=Optional[str],
-        default=SchemaOption,
-    ),
-    inspect.Parameter(
-        "role",
-        inspect.Parameter.KEYWORD_ONLY,
-        annotation=Optional[str],
-        default=RoleOption,
-    ),
-    inspect.Parameter(
-        "warehouse",
-        inspect.Parameter.KEYWORD_ONLY,
-        annotation=Optional[str],
-        default=WarehouseOption,
-    ),
-    inspect.Parameter(
-        "temporary_connection",
-        inspect.Parameter.KEYWORD_ONLY,
-        annotation=Optional[bool],
-        default=TemporaryConnectionOption,
-    ),
-    inspect.Parameter(
-        "mfa_passcode",
-        inspect.Parameter.KEYWORD_ONLY,
-        annotation=Optional[str],
-        default=MfaPasscodeOption,
-    ),
-    inspect.Parameter(
-        "enable_diag",
-        inspect.Parameter.KEYWORD_ONLY,
-        annotation=Optional[bool],
-        default=EnableDiagOption,
-    ),
-    inspect.Parameter(
-        "diag_log_path",
-        inspect.Parameter.KEYWORD_ONLY,
-        annotation=Optional[str],
-        default=DiagLogPathOption,
-    ),
-    inspect.Parameter(
-        "diag_allowlist_path",
-        inspect.Parameter.KEYWORD_ONLY,
-        annotation=Optional[str],
-        default=DiagAllowlistPathOption,
-    ),
-]
-
-GLOBAL_OPTIONS = [
-    inspect.Parameter(
-        "format",
-        inspect.Parameter.KEYWORD_ONLY,
-        annotation=OutputFormat,
-        default=OutputFormatOption,
-    ),
-    inspect.Parameter(
-        "verbose",
-        inspect.Parameter.KEYWORD_ONLY,
-        annotation=Optional[bool],
-        default=VerboseOption,
-    ),
-    inspect.Parameter(
-        "debug",
-        inspect.Parameter.KEYWORD_ONLY,
-        annotation=Optional[bool],
-        default=DebugOption,
-    ),
-    inspect.Parameter(
-        "silent",
-        inspect.Parameter.KEYWORD_ONLY,
-        annotation=Optional[bool],
-        default=SilentOption,
-    ),
-]
-
-
-def with_output(func):
-    from snowflake.cli._app.printing import print_result
-
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        output_data = func(*args, **kwargs)
-        if not isinstance(output_data, CommandResult):
-            raise CommandReturnTypeError(type(output_data))
-        print_result(output_data)
-
-    return wrapper