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

snowflake/cli/api/config.py

@@ -1,380 +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
-import os
-import warnings
-from contextlib import contextmanager
-from dataclasses import asdict, dataclass, field
-from pathlib import Path
-from typing import Any, Dict, Optional, Union
-
-import tomlkit
-from click import ClickException
-from snowflake.cli.api.exceptions import (
-    ConfigFileTooWidePermissionsError,
-    MissingConfiguration,
-    UnsupportedConfigSectionTypeError,
-)
-from snowflake.cli.api.secure_path import SecurePath
-from snowflake.cli.api.secure_utils import (
-    file_permissions_are_strict,
-    windows_get_not_whitelisted_users_with_access,
-)
-from snowflake.cli.api.utils.types import try_cast_to_bool
-from snowflake.connector.compat import IS_WINDOWS
-from snowflake.connector.config_manager import CONFIG_MANAGER
-from snowflake.connector.constants import CONFIG_FILE, CONNECTIONS_FILE
-from snowflake.connector.errors import ConfigSourceError, MissingConfigOptionError
-from tomlkit import TOMLDocument, dump
-from tomlkit.container import Container
-from tomlkit.exceptions import NonExistentKey
-from tomlkit.items import Table
-
-log = logging.getLogger(__name__)
-
-
-class Empty:
-    pass
-
-
-CONNECTIONS_SECTION = "connections"
-CLI_SECTION = "cli"
-LOGS_SECTION = "logs"
-PLUGINS_SECTION = "plugins"
-
-LOGS_SECTION_PATH = [CLI_SECTION, LOGS_SECTION]
-PLUGINS_SECTION_PATH = [CLI_SECTION, PLUGINS_SECTION]
-FEATURE_FLAGS_SECTION_PATH = [CLI_SECTION, "features"]
-
-CONFIG_MANAGER.add_option(
-    name=CLI_SECTION,
-    parse_str=tomlkit.parse,
-    default=dict(),
-)
-
-
-@dataclass
-class ConnectionConfig:
-    account: Optional[str] = None
-    user: Optional[str] = None
-    password: Optional[str] = field(default=None, repr=False)
-    host: Optional[str] = None
-    region: Optional[str] = None
-    port: Optional[int] = None
-    database: Optional[str] = None
-    schema: Optional[str] = None
-    warehouse: Optional[str] = None
-    role: Optional[str] = None
-    authenticator: Optional[str] = None
-    private_key_file: Optional[str] = None
-    token_file_path: Optional[str] = None
-
-    _other_settings: dict = field(default_factory=lambda: {})
-
-    @classmethod
-    def from_dict(cls, config_dict: dict) -> ConnectionConfig:
-        known_settings = {}
-        other_settings = {}
-        for key, value in config_dict.items():
-            if key in cls.__dict__:
-                known_settings[key] = value
-            else:
-                other_settings[key] = value
-        return cls(**known_settings, _other_settings=other_settings)
-
-    def to_dict_of_known_non_empty_values(self) -> dict:
-        return {
-            k: v
-            for k, v in asdict(self).items()
-            if k != "_other_settings" and v is not None
-        }
-
-    def _non_empty_other_values(self) -> dict:
-        return {k: v for k, v in self._other_settings.items() if v is not None}
-
-    def to_dict_of_all_non_empty_values(self) -> dict:
-        return {
-            **self.to_dict_of_known_non_empty_values(),
-            **self._non_empty_other_values(),
-        }
-
-
-def config_init(config_file: Optional[Path]):
-    """
-    Initializes the app configuration. Config provided via cli flag takes precedence.
-    If config file does not exist we create an empty one.
-    """
-    from snowflake.cli._app.loggers import create_initial_loggers
-
-    if config_file:
-        CONFIG_MANAGER.file_path = config_file
-    else:
-        _check_default_config_files_permissions()
-    if not CONFIG_MANAGER.file_path.exists():
-        _initialise_config(CONFIG_MANAGER.file_path)
-    _read_config_file()
-    create_initial_loggers()
-
-
-def add_connection_to_proper_file(name: str, connection_config: ConnectionConfig):
-    if CONNECTIONS_FILE.exists():
-        existing_connections = _read_connections_toml()
-        existing_connections.update(
-            {name: connection_config.to_dict_of_all_non_empty_values()}
-        )
-        _update_connections_toml(existing_connections)
-        return CONNECTIONS_FILE
-    else:
-        set_config_value(
-            section=CONNECTIONS_SECTION,
-            key=name,
-            value=connection_config.to_dict_of_all_non_empty_values(),
-        )
-        return CONFIG_MANAGER.file_path
-
-
-_DEFAULT_LOGS_CONFIG = {
-    "save_logs": True,
-    "path": str(CONFIG_MANAGER.file_path.parent / "logs"),
-    "level": "info",
-}
-
-_DEFAULT_CLI_CONFIG = {LOGS_SECTION: _DEFAULT_LOGS_CONFIG}
-
-
-@contextmanager
-def _config_file():
-    _read_config_file()
-    conf_file_cache = CONFIG_MANAGER.conf_file_cache
-    yield conf_file_cache
-    _dump_config(conf_file_cache)
-
-
-def _read_config_file():
-    with warnings.catch_warnings():
-        if IS_WINDOWS:
-            warnings.filterwarnings(
-                action="ignore",
-                message="Bad owner or permissions.*",
-                module="snowflake.connector.config_manager",
-            )
-
-            if not file_permissions_are_strict(CONFIG_MANAGER.file_path):
-                users = ", ".join(
-                    windows_get_not_whitelisted_users_with_access(
-                        CONFIG_MANAGER.file_path
-                    )
-                )
-                warnings.warn(
-                    f"Unauthorized users ({users}) have access to configuration file {CONFIG_MANAGER.file_path}.\n"
-                    f'Run `icacls "{CONFIG_MANAGER.file_path}" /deny <USER_ID>:F` on those users to restrict permissions.'
-                )
-
-        try:
-            CONFIG_MANAGER.read_config()
-        except ConfigSourceError as exception:
-            raise ClickException(
-                f"Configuration file seems to be corrupted. {str(exception.__cause__)}"
-            )
-
-
-def _initialise_logs_section():
-    with _config_file() as conf_file_cache:
-        if conf_file_cache.get(CLI_SECTION) is None:
-            conf_file_cache[CLI_SECTION] = _DEFAULT_CLI_CONFIG
-        if conf_file_cache[CLI_SECTION].get(LOGS_SECTION) is None:
-            conf_file_cache[CLI_SECTION][LOGS_SECTION] = _DEFAULT_LOGS_CONFIG
-
-
-def set_config_value(section: str | None, key: str, value: Any):
-    with _config_file() as conf_file_cache:
-        if section:
-            if conf_file_cache.get(section) is None:
-                conf_file_cache[section] = {}
-            conf_file_cache[section][key] = value
-        else:
-            conf_file_cache[key] = value
-
-
-def get_logs_config() -> dict:
-    logs_config = _DEFAULT_LOGS_CONFIG.copy()
-    if config_section_exists(*LOGS_SECTION_PATH):
-        logs_config.update(**get_config_section(*LOGS_SECTION_PATH))
-    return logs_config
-
-
-def get_plugins_config() -> dict:
-    if config_section_exists(*PLUGINS_SECTION_PATH):
-        return get_config_section(*PLUGINS_SECTION_PATH)
-    else:
-        return {}
-
-
-def connection_exists(connection_name: str) -> bool:
-    return config_section_exists(CONNECTIONS_SECTION, connection_name)
-
-
-def config_section_exists(*path) -> bool:
-    try:
-        _find_section(*path)
-        return True
-    except (KeyError, NonExistentKey, MissingConfigOptionError):
-        return False
-
-
-def get_all_connections() -> dict[str, ConnectionConfig]:
-    return {
-        k: ConnectionConfig.from_dict(connection_dict)
-        for k, connection_dict in get_config_section("connections").items()
-    }
-
-
-def get_connection_dict(connection_name: str) -> dict:
-    try:
-        return get_config_section(CONNECTIONS_SECTION, connection_name)
-    except KeyError:
-        raise MissingConfiguration(f"Connection {connection_name} is not configured")
-
-
-def get_default_connection_name() -> str:
-    return CONFIG_MANAGER["default_connection_name"]
-
-
-def get_default_connection_dict() -> dict:
-    def_connection_name = get_default_connection_name()
-    if not connection_exists(def_connection_name):
-        raise MissingConfiguration(
-            f"Couldn't find connection for default connection `{def_connection_name}`. "
-            f"Specify connection name or configure default connection."
-        )
-    return get_connection_dict(def_connection_name)
-
-
-def get_config_section(*path) -> dict:
-    section = _find_section(*path)
-    if isinstance(section, Container):
-        return {s: _merge_section_with_env(section[s], *path, s) for s in section}
-    if isinstance(section, dict):
-        return _merge_section_with_env(section, *path)
-    raise UnsupportedConfigSectionTypeError(type(section))
-
-
-def get_config_value(*path, key: str, default: Optional[Any] = Empty) -> Any:
-    """Looks for given key under nested path in toml file."""
-    env_variable = get_env_value(*path, key=key)
-    if env_variable:
-        return env_variable
-    try:
-        return get_config_section(*path)[key]
-    except (KeyError, NonExistentKey, MissingConfigOptionError):
-        if default is not Empty:
-            return default
-        raise
-
-
-def get_config_bool_value(*path, key: str, default: Optional[Any] = Empty) -> bool:
-    value = get_config_value(*path, key=key, default=default)
-    try:
-        return try_cast_to_bool(value)
-    except ValueError:
-        raise ClickException(
-            f"Expected boolean value for {'.'.join((*path, key))} option."
-        )
-
-
-def _initialise_config(config_file: Path) -> None:
-    config_file = SecurePath(config_file)
-    config_file.parent.mkdir(parents=True, exist_ok=True)
-    config_file.touch()
-    _initialise_logs_section()
-    log.info("Created Snowflake configuration file at %s", CONFIG_MANAGER.file_path)
-
-
-def get_env_variable_name(*path, key: str) -> str:
-    return ("_".join(["snowflake", *path, key])).upper()
-
-
-def get_env_value(*path, key: str) -> str | None:
-    return os.environ.get(get_env_variable_name(*path, key=key))
-
-
-def _find_section(*path) -> TOMLDocument:
-    section = CONFIG_MANAGER
-    idx = 0
-    while idx < len(path):
-        section = section[path[idx]]
-        idx += 1
-    return section
-
-
-def _merge_section_with_env(section: Union[Table, Any], *path) -> Dict[str, str]:
-    if isinstance(section, Table):
-        env_variables = _get_envs_for_path(*path)
-        section_copy = section.copy()
-        section_copy.update(env_variables)
-        return section_copy.unwrap()
-    # It's a atomic value
-    return section
-
-
-def _get_envs_for_path(*path) -> dict:
-    env_variables_prefix = "_".join(["SNOWFLAKE"] + [p.upper() for p in path]) + "_"
-    return {
-        k.replace(env_variables_prefix, "").lower(): os.environ[k]
-        for k in os.environ.keys()
-        if k.startswith(env_variables_prefix)
-    }
-
-
-def _dump_config(conf_file_cache: Dict):
-    with SecurePath(CONFIG_MANAGER.file_path).open("w+") as fh:
-        dump(conf_file_cache, fh)
-
-
-def _check_default_config_files_permissions() -> None:
-    if CONNECTIONS_FILE.exists() and not file_permissions_are_strict(CONNECTIONS_FILE):
-        raise ConfigFileTooWidePermissionsError(CONNECTIONS_FILE)
-    if CONFIG_FILE.exists() and not file_permissions_are_strict(CONFIG_FILE):
-        raise ConfigFileTooWidePermissionsError(CONFIG_FILE)
-
-
-from typing import Literal
-
-
-def get_feature_flags_section() -> Dict[str, bool | Literal["UNKNOWN"]]:
-    if not config_section_exists(*FEATURE_FLAGS_SECTION_PATH):
-        return {}
-
-    flags = get_config_section(*FEATURE_FLAGS_SECTION_PATH)
-
-    def _bool_or_unknown(value):
-        try:
-            return try_cast_to_bool(value)
-        except ValueError:
-            return "UNKNOWN"
-
-    return {k: _bool_or_unknown(v) for k, v in flags.items()}
-
-
-def _read_connections_toml() -> dict:
-    with open(CONNECTIONS_FILE, "r") as f:
-        return tomlkit.loads(f.read()).unwrap()
-
-
-def _update_connections_toml(connections: dict):
-    with open(CONNECTIONS_FILE, "w") as f:
-        f.write(tomlkit.dumps(connections))

snowflake/cli/api/connections.py

@@ -1,216 +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 asyncio
-import logging
-import re
-import warnings
-from dataclasses import asdict, dataclass, field, fields, replace
-from pathlib import Path
-from typing import Optional
-
-from snowflake.cli.api.config import get_default_connection_name
-from snowflake.cli.api.exceptions import InvalidSchemaError
-from snowflake.connector import SnowflakeConnection
-from snowflake.connector.compat import IS_WINDOWS
-
-logger = logging.getLogger(__name__)
-
-schema_pattern = re.compile(r".+\..+")
-
-
-@dataclass
-class ConnectionContext:
-    # FIXME: can reduce duplication using config.ConnectionConfig
-    connection_name: Optional[str] = None
-    host: Optional[str] = None
-    port: Optional[int] = None
-    account: Optional[str] = None
-    database: Optional[str] = None
-    role: Optional[str] = None
-    schema: Optional[str] = None
-    user: Optional[str] = None
-    password: Optional[str] = field(default=None, repr=False)
-    authenticator: Optional[str] = None
-    private_key_file: Optional[str] = None
-    warehouse: Optional[str] = None
-    mfa_passcode: Optional[str] = None
-    enable_diag: Optional[bool] = False
-    diag_log_path: Optional[Path] = None
-    diag_allowlist_path: Optional[Path] = None
-    temporary_connection: bool = False
-    session_token: Optional[str] = None
-    master_token: Optional[str] = None
-    token_file_path: Optional[Path] = None
-
-    VALIDATED_FIELD_NAMES = ["schema"]
-
-    def present_values_as_dict(self) -> dict:
-        """Dictionary representation of this ConnectionContext for values that are not None"""
-        return {k: v for (k, v) in asdict(self).items() if v is not None}
-
-    def clone(self) -> ConnectionContext:
-        return replace(self)
-
-    def update(self, **updates):
-        """
-        Given a dictionary of property (key, value) mappings, update properties
-        of this context object with equivalent names to the keys.
-
-        Raises KeyError if a non-property is specified as a key.
-        """
-        field_map = {field.name: field for field in fields(self)}
-        for key, value in updates.items():
-            # ensure key represents a property
-            if key not in field_map:
-                raise KeyError(f"{key} is not a field of {self.__class__.__name__}")
-            setattr(self, key, value)
-
-    def __repr__(self) -> str:
-        """Minimal repr where None values have their keys omitted."""
-        items = [f"{k}={repr(v)}" for (k, v) in self.present_values_as_dict().items()]
-        return f"{self.__class__.__name__}({', '.join(items)})"
-
-    def __setattr__(self, prop, val):
-        """Runs registered validators before setting fields."""
-        if prop in self.VALIDATED_FIELD_NAMES:
-            validate = getattr(self, f"validate_{prop}")
-            validate(val)
-        super().__setattr__(prop, val)
-
-    def validate_schema(self, value: Optional[str]):
-        if (
-            value
-            and not (value.startswith('"') and value.endswith('"'))
-            # if schema is fully qualified name (db.schema)
-            and schema_pattern.match(value)
-        ):
-            raise InvalidSchemaError(value)
-
-    def validate_and_complete(self):
-        """
-        Ensure we can create a connection from this context.
-        """
-        if not self.temporary_connection and not self.connection_name:
-            self.connection_name = get_default_connection_name()
-
-    def build_connection(self):
-        from snowflake.cli._app.snow_connector import connect_to_snowflake
-
-        # Ignore warnings about bad owner or permissions on Windows
-        # Telemetry omit our warning filter from config.py
-        if IS_WINDOWS:
-            warnings.filterwarnings(
-                action="ignore",
-                message="Bad owner or permissions.*",
-                module="snowflake.connector.config_manager",
-            )
-
-        return connect_to_snowflake(**self.present_values_as_dict())
-
-
-class OpenConnectionCache:
-    """
-    A connection cache that transparently manages SnowflakeConnection objects
-    and is keyed by ConnectionContext objects, e.g. cache[ctx].execute_string(...).
-    Connections are automatically closed after CONNECTION_CLEANUP_SEC, but
-    are guaranteed to be open (if config is valid) when returned by the cache.
-    """
-
-    connections: dict[str, SnowflakeConnection]
-    cleanup_futures: dict[str, asyncio.TimerHandle]
-
-    CONNECTION_CLEANUP_SEC: float = 10.0 * 60
-    """Connections are closed this many seconds after the last time they are accessed."""
-
-    def __init__(self):
-        self.connections = {}
-        self.cleanup_futures = {}
-
-    def __getitem__(self, ctx):
-        if not isinstance(ctx, ConnectionContext):
-            raise ValueError(
-                f"Expected key to be ConnectionContext but got {repr(ctx)}"
-            )
-        key = repr(ctx)
-        if not self._has_open_connection(key):
-            self._insert(key, ctx)
-        self._touch(key)
-        return self.connections[key]
-
-    def clear(self):
-        """Closes all connections and resets the cache to its initial state."""
-        connection_keys = list(self.connections.keys())
-        for key in connection_keys:
-            self._cleanup(key)
-
-        # if any orphaned futures still exist, clean them up too
-        for future in self.cleanup_futures.values():
-            future.cancel()
-        self.cleanup_futures.clear()
-
-    def _has_open_connection(self, key: str):
-        return key in self.connections
-
-    def _insert(self, key: str, ctx: ConnectionContext):
-        try:
-            # N.B. build_connection ultimately calls connect_to_snowflake, which
-            # interpolates in connection dicts (from config) and environment variables.
-            # This means that we could return a stale (incorrect) connection for the
-            # given ConnectionContext if get_env_value or get_connection_dict would
-            # have returned different values (i.e. env / config have changed).
-            self.connections[key] = ctx.build_connection()
-        except Exception:
-            logger.debug(
-                "ConnectionCache: failed to connect using %s; not caching.", key
-            )
-            raise
-
-    def _cancel_cleanup_future_if_exists(self, key: str):
-        if key in self.cleanup_futures:
-            self.cleanup_futures.pop(key).cancel()
-
-    def _touch(self, key: str):
-        """
-        Extend the lifetime of the cached connection at the given key.
-        """
-        loop = None
-        try:
-            loop = asyncio.get_event_loop()
-        except RuntimeError:
-            # Python 3.11+ will throw when no event loop;
-            # Python 3.10 will issue a DeprecationWarning and return None
-            pass
-
-        if not loop:
-            logger.debug(
-                "ConnectionCache: no event loop; connections will close at exit."
-            )
-            return
-
-        self._cancel_cleanup_future_if_exists(key)
-        self.cleanup_futures[key] = loop.call_later(
-            self.CONNECTION_CLEANUP_SEC, lambda: self._cleanup(key)
-        )
-
-    def _cleanup(self, key: str):
-        """Closes the cached connection at the given key."""
-        if key not in self.connections:
-            logger.debug("Cleaning up connection %s, but not found in cache!", key)
-
-        # doesn't cancel in-flight async queries
-        self._cancel_cleanup_future_if_exists(key)
-        self.connections.pop(key).close()

snowflake/cli/api/console/__init__.py

@@ -1,17 +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 snowflake.cli.api.console.console import cli_console
-
-__all__ = ("cli_console",)

snowflake/cli/api/console/abc.py

@@ -1,94 +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 contextlib import contextmanager
-from typing import Callable, Iterator, Optional
-
-from rich import print as rich_print
-from rich.text import Text
-from snowflake.cli.api.cli_global_context import (
-    _CliGlobalContextAccess,
-    get_cli_context,
-)
-
-
-class AbstractConsole(ABC):
-    """Interface for cli console implementation.
-
-    Each console should have three methods implemented:
-    - `step` - for more detailed information on steps
-    - `warning` - for displaying messages in a style that makes it
-      visually stand out from other output
-    - `phase` a context manager for organising steps into logical group
-    """
-
-    _print_fn: Callable[[str], None]
-    _in_phase: bool
-
-    def __init__(self):
-        super().__init__()
-        self._in_phase = False
-
-    @property
-    def _cli_context(self) -> _CliGlobalContextAccess:
-        return get_cli_context()
-
-    @property
-    def is_silent(self) -> bool:
-        """Returns information whether intermediate output is muted."""
-        return self._cli_context.silent
-
-    @property
-    def in_phase(self) -> bool:
-        """Indicated whether output should be grouped."""
-        return self._in_phase
-
-    def _print(self, text: Text):
-        if self.is_silent:
-            return
-        rich_print(text)
-
-    @contextmanager
-    @abstractmethod
-    def phase(
-        self,
-        enter_message: str,
-        exit_message: Optional[str] = None,
-    ) -> Iterator[Callable[[str], None]]:
-        """A context manager for organising steps into logical group."""
-
-    @contextmanager
-    @abstractmethod
-    def indented(self):
-        """
-        A context manager for temporarily indenting messages and warnings. Phases and steps cannot be used in indented blocks,
-        but multiple indented blocks can be nested (use sparingly).
-        """
-
-    @abstractmethod
-    def step(self, message: str):
-        """Displays a message to output."""
-
-    @abstractmethod
-    def message(self, _message: str):
-        """Displays an informational message to output."""
-
-    @abstractmethod
-    def warning(self, message: str):
-        """Displays message in a style that makes it visually stand out from other output.
-
-        Intended for displaying messages related to important messages."""