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

snowflake/cli/_app/loggers.py

@@ -1,199 +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 logging.config
-from dataclasses import asdict, dataclass, field
-from typing import Any, Dict, List
-
-import typer
-from snowflake.cli.api.exceptions import InvalidLogsConfiguration
-from snowflake.cli.api.secure_path import SecurePath
-from snowflake.connector.errors import ConfigSourceError
-
-_DEFAULT_LOG_FILENAME = "snowflake-cli.log"
-
-
-@dataclass
-class LogFormatterConfig:
-    _format: str
-    _class: str = "logging.Formatter"
-    datefmt: str = "%Y-%m-%d %H:%M:%S"
-
-
-@dataclass
-class LoggerConfig:
-    level: int = logging.NOTSET
-    handlers: List[str] = field(default_factory=list)
-
-
-@dataclass
-class DefaultLoggingConfig:
-    version: int = 1
-    disable_existing_loggers: bool = True
-    formatters: Dict[str, LogFormatterConfig] = field(
-        default_factory=lambda: {
-            "default_formatter": LogFormatterConfig(
-                _format="%(asctime)s %(levelname)s %(message)s"
-            ),
-            "detailed_formatter": LogFormatterConfig(
-                _format="%(asctime)s %(levelname)s [%(name)s] %(message)s"
-            ),
-        }
-    )
-    filters: Dict[str, Any] = field(default_factory=dict)
-    handlers: Dict[str, Any] = field(
-        default_factory=lambda: {
-            "console": {
-                "class": "logging.StreamHandler",
-                "formatter": "default_formatter",
-                "level": logging.ERROR,
-            },
-            "file": {
-                "class": "logging.handlers.TimedRotatingFileHandler",
-                "filename": None,
-                "when": "midnight",
-                "formatter": "detailed_formatter",
-                "level": logging.INFO,
-            },
-        },
-    )
-    loggers: Dict[str, Any] = field(
-        default_factory=lambda: {
-            "snowflake.cli": LoggerConfig(handlers=["console", "file"]),
-            "snowflake": LoggerConfig(),
-            "snowflake.connector.telemetry": LoggerConfig(level=logging.CRITICAL),
-        }
-    )
-
-
-@dataclass
-class InitialLoggingConfig(DefaultLoggingConfig):
-    loggers: Dict[str, Any] = field(
-        default_factory=lambda: {
-            "snowflake.cli": LoggerConfig(level=logging.INFO, handlers=["file"]),
-            "snowflake": LoggerConfig(),
-        }
-    )
-
-
-def _remove_underscore_prefixes_from_keys(d: Dict[str, Any]) -> None:
-    for k, v in list(d.items()):
-        if k.startswith("_"):
-            d[k[1:]] = d.pop(k)
-        if isinstance(v, dict):
-            _remove_underscore_prefixes_from_keys(v)
-
-
-class FileLogsConfig:
-    def __init__(self, debug: bool) -> None:
-        from snowflake.cli.api.config import (
-            get_logs_config,
-        )
-
-        config = get_logs_config()
-
-        self.path: SecurePath = SecurePath(config["path"])
-        self.save_logs: bool = config["save_logs"]
-        self.level: int = logging.getLevelName(config["level"].upper())
-        if debug:
-            self.level = logging.DEBUG
-
-        self._check_log_level(config)
-        if self.save_logs:
-            self._create_logs_directory_if_not_exists()
-
-    def _create_logs_directory_if_not_exists(self):
-        if not self.path.exists():
-            self.path.mkdir(parents=True)
-
-    def _check_log_level(self, config):
-        possible_log_levels = [
-            logging.DEBUG,
-            logging.INFO,
-            logging.WARN,
-            logging.ERROR,
-            logging.CRITICAL,
-        ]
-        if self.level not in possible_log_levels:
-            raise InvalidLogsConfiguration(
-                f"Invalid 'level' value set in [logs] section: {config['level']}. "
-                f"'level' should be one of: {' / '.join(logging.getLevelName(lvl) for lvl in possible_log_levels)}"
-            )
-
-    @property
-    def filename(self):
-        return self.path.path / _DEFAULT_LOG_FILENAME
-
-
-def create_initial_loggers():
-    config = InitialLoggingConfig()
-    try:
-        file_logs_config = FileLogsConfig(debug=False)
-        if file_logs_config.save_logs:
-            config.handlers["file"]["filename"] = file_logs_config.filename
-            _configurate_logging(config)
-    except ConfigSourceError:
-        pass
-
-
-def create_loggers(verbose: bool, debug: bool):
-    """Creates a logger depending on the SnowCLI parameters and config file.
-    verbose == True - print info and higher logs in default format
-    debug == True - print debug and higher logs in debug format
-    none of above - print only error logs in default format
-    """
-    config = DefaultLoggingConfig()
-
-    if verbose and debug:
-        raise typer.BadParameter("Only one parameter `verbose` or `debug` is possible")
-    elif debug:
-        config.handlers["console"].update(
-            level=logging.DEBUG,
-            formatter="detailed_formatter",
-        )
-        # In debug mode we also want to get snowflake connector logs
-        config.loggers["snowflake"].handlers = ["file", "console"]
-    elif verbose:
-        config.handlers["console"].update(level=logging.INFO)
-
-    global_log_level = config.handlers["console"]["level"]
-
-    file_logs_config = FileLogsConfig(debug=debug)
-    if file_logs_config.save_logs:
-        config.handlers["file"].update(
-            level=file_logs_config.level,
-            filename=file_logs_config.filename,
-        )
-        if file_logs_config.level < global_log_level:
-            global_log_level = file_logs_config.level
-    else:
-        # We need to remove handler definition - otherwise it creates file even if `save_logs` is False
-        del config.handlers["file"]
-        for logger in config.loggers.values():
-            if "file" in logger.handlers:
-                logger.handlers.remove("file")
-
-    config.loggers["snowflake.cli"].level = global_log_level
-    config.loggers["snowflake"].level = global_log_level
-
-    _configurate_logging(config)
-
-
-def _configurate_logging(config: DefaultLoggingConfig | InitialLoggingConfig) -> None:
-    dict_config = asdict(config)
-    _remove_underscore_prefixes_from_keys(dict_config)
-    logging.config.dictConfig(dict_config)

snowflake/cli/_app/main_typer.py

@@ -1,62 +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 sys
-
-import typer
-from snowflake.cli.api.cli_global_context import get_cli_context
-from snowflake.cli.api.commands.flags import DEFAULT_CONTEXT_SETTINGS, DebugOption
-from snowflake.cli.api.console import cli_console
-
-
-def _handle_exception(exception: Exception):
-    if get_cli_context().enable_tracebacks:
-        raise exception
-    else:
-        cli_console.warning(
-            "\nAn unexpected exception occurred. Use --debug option to see the traceback. Exception message:\n\n"
-            + exception.__str__()
-        )
-        raise SystemExit(1)
-
-
-class SnowCliMainTyper(typer.Typer):
-    """
-    Top-level SnowCLI Typer.
-    It contains global exception handling.
-    """
-
-    def __init__(self):
-        super().__init__(
-            context_settings=DEFAULT_CONTEXT_SETTINGS,
-            pretty_exceptions_show_locals=False,
-            add_completion=True,
-        )
-
-    def __call__(self, *args, **kwargs):
-        # early detection of "--debug" flag
-        # necessary in case of errors which happen during argument parsing
-        # (for example badly formatted config file)
-        # Hack: We have to go around Typer by checking sys.argv as it does not allow
-        #       to easily peek into subcommand arguments.
-        DebugOption.callback(
-            any(param in sys.argv for param in DebugOption.param_decls)
-        )
-
-        try:
-            super().__call__(*args, **kwargs)
-        except Exception as exception:
-            _handle_exception(exception)

snowflake/cli/_app/printing.py

@@ -1,181 +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 json
-import sys
-from datetime import datetime
-from json import JSONEncoder
-from pathlib import Path
-from textwrap import indent
-from typing import TextIO
-
-from rich import box, get_console
-from rich import print as rich_print
-from rich.live import Live
-from rich.table import Table
-from snowflake.cli.api.cli_global_context import get_cli_context
-from snowflake.cli.api.output.formats import OutputFormat
-from snowflake.cli.api.output.types import (
-    CollectionResult,
-    CommandResult,
-    MessageResult,
-    MultipleResults,
-    ObjectResult,
-    StreamResult,
-)
-from snowflake.cli.api.sanitizers import sanitize_for_terminal
-
-NO_ITEMS_FOUND: str = "No data"
-
-# ensure we do not break URLs that wrap lines
-get_console().soft_wrap = True
-
-# Disable markup to avoid escaping errors
-get_console()._markup = False  # noqa: SLF001
-
-
-class CustomJSONEncoder(JSONEncoder):
-    """Custom JSON encoder handling serialization of non-standard types"""
-
-    def default(self, o):
-        if isinstance(o, str):
-            return sanitize_for_terminal(o)
-        if isinstance(o, (ObjectResult, MessageResult)):
-            return o.result
-        if isinstance(o, (CollectionResult, MultipleResults)):
-            return list(o.result)
-        if isinstance(o, datetime):
-            return o.isoformat()
-        if isinstance(o, Path):
-            return str(o)
-        return super().default(o)
-
-
-def _get_format_type() -> OutputFormat:
-    output_format = get_cli_context().output_format
-    if output_format:
-        return output_format
-    return OutputFormat.TABLE
-
-
-def _get_table():
-    return Table(show_header=True, box=box.ASCII)
-
-
-def _print_multiple_table_results(obj: CollectionResult):
-    items = obj.result
-    try:
-        first_item = next(items)
-    except StopIteration:
-        rich_print(NO_ITEMS_FOUND, end="\n\n")
-        return
-    table = _get_table()
-    for column in first_item.keys():
-        table.add_column(column, overflow="fold")
-    with Live(table, refresh_per_second=4):
-        table.add_row(*[str(i) for i in first_item.values()])
-        for item in items:
-            table.add_row(*[str(i) for i in item.values()])
-    # Add separator between tables
-    rich_print(flush=True)
-
-
-def is_structured_format(output_format):
-    return output_format == OutputFormat.JSON
-
-
-def print_structured(result: CommandResult):
-    """Handles outputs like json, yml and other structured and parsable formats."""
-    printed_end_line = False
-    if isinstance(result, MultipleResults):
-        _stream_json(result)
-    elif isinstance(result, StreamResult):
-        # A StreamResult prints each value onto its own line
-        # instead of joining all the values into a JSON array
-        for r in result.result:
-            json.dump(r, sys.stdout, cls=CustomJSONEncoder)
-            print(flush=True)
-            printed_end_line = True
-    else:
-        json.dump(result, sys.stdout, cls=CustomJSONEncoder, indent=4)
-    # Adds empty line at the end
-    if not printed_end_line:
-        print(flush=True)
-
-
-def _stream_json(result):
-    """Simple helper for streaming multiple results as a JSON."""
-    indent_size = 2
-
-    class _Indented:
-        def __init__(self, stream: TextIO):
-            self._stream = stream
-
-        def write(self, text: str):
-            return self._stream.write(indent(text, " " * indent_size))
-
-    print("[")
-    results = result.result
-    res = next(results, None)
-    while res:
-        json.dump(res, _Indented(sys.stdout), cls=CustomJSONEncoder, indent=indent_size)  # type: ignore
-        if res := next(results, None):
-            print(",")
-    print("\n]")
-
-
-def print_unstructured(obj: CommandResult | None):
-    """Handles outputs like table, plain text and other unstructured types."""
-    if not obj:
-        rich_print("Done", flush=True)
-    elif not obj.result:
-        rich_print("No data", flush=True)
-    elif isinstance(obj, MessageResult):
-        rich_print(sanitize_for_terminal(obj.message), flush=True)
-    else:
-        if isinstance(obj, ObjectResult):
-            _print_single_table(obj)
-        elif isinstance(obj, CollectionResult):
-            _print_multiple_table_results(obj)
-        else:
-            raise TypeError(f"No print strategy for type: {type(obj)}")
-
-
-def _print_single_table(obj):
-    table = _get_table()
-    table.add_column("key", overflow="fold")
-    table.add_column("value", overflow="fold")
-    for key, value in obj.result.items():
-        table.add_row(
-            sanitize_for_terminal(str(key)), sanitize_for_terminal(str(value))
-        )
-    rich_print(table, flush=True)
-
-
-def print_result(cmd_result: CommandResult, output_format: OutputFormat | None = None):
-    output_format = output_format or _get_format_type()
-    if is_structured_format(output_format):
-        print_structured(cmd_result)
-    elif isinstance(cmd_result, (MultipleResults, StreamResult)):
-        for res in cmd_result.result:
-            print_result(res)
-    elif (
-        isinstance(cmd_result, (MessageResult, ObjectResult, CollectionResult))
-        or cmd_result is None
-    ):
-        print_unstructured(cmd_result)
-    else:
-        raise ValueError(f"Unexpected type {type(cmd_result)}")

snowflake/cli/_app/secret.py

@@ -1,9 +0,0 @@
-class SecretType:
-    def __init__(self, value):
-        self.value = value
-
-    def __repr__(self):
-        return "SecretType(***)"
-
-    def __str___(self):
-        return "***"