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

snowflake/cli/api/exceptions.py

@@ -1,190 +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 pathlib import Path
-from typing import Optional
-
-from click.exceptions import ClickException, UsageError
-from snowflake.cli.api.constants import ObjectType
-from snowflake.connector.compat import IS_WINDOWS
-
-
-class EnvironmentVariableNotFoundError(ClickException):
-    def __init__(self, env_variable_name: str):
-        super().__init__(f"Environment variable {env_variable_name} not found")
-
-
-class MissingConfiguration(ClickException):
-    pass
-
-
-class CycleDetectedError(ClickException):
-    pass
-
-
-class InvalidTemplate(ClickException):
-    pass
-
-
-class InvalidConnectionConfiguration(ClickException):
-    def format_message(self):
-        return f"Invalid connection configuration. {self.message}"
-
-
-class InvalidLogsConfiguration(ClickException):
-    def format_message(self):
-        return f"Invalid logs configuration. {self.message}"
-
-
-class InvalidPluginConfiguration(ClickException):
-    def format_message(self):
-        return f"Invalid plugin configuration. {self.message}"
-
-
-class SnowflakeConnectionError(ClickException):
-    def __init__(self, snowflake_err: Exception):
-        super().__init__(f"Could not connect to Snowflake. Reason: {snowflake_err}")
-
-
-class UnsupportedConfigSectionTypeError(Exception):
-    def __init__(self, section_type: type):
-        super().__init__(f"Unsupported configuration section type {section_type}")
-
-
-class OutputDataTypeError(ClickException):
-    def __init__(self, got_type: type, expected_type: type):
-        super().__init__(f"Got {got_type} type but expected {expected_type}")
-
-
-class CommandReturnTypeError(ClickException):
-    def __init__(self, got_type: type):
-        super().__init__(f"Commands have to return OutputData type, but got {got_type}")
-
-
-class SnowflakeSQLExecutionError(ClickException):
-    """
-    Could not successfully execute the Snowflake SQL statements.
-    """
-
-    def __init__(self, queries: Optional[str] = None):
-        super().__init__(
-            f"""
-                {self.__doc__}
-                {queries if queries else ""}
-            """
-        )
-
-
-class ObjectAlreadyExistsError(ClickException):
-    def __init__(
-        self,
-        object_type: ObjectType,
-        name: str,
-        replace_available: bool = False,
-    ):
-        msg = f"{str(object_type).capitalize()} {name} already exists."
-        if replace_available:
-            msg += " Use --replace flag to update objects."
-        super().__init__(msg)
-
-
-class NoProjectDefinitionError(ClickException):
-    def __init__(self, project_type: str, project_root: str | Path):
-        super().__init__(
-            f"No {project_type} project definition found in {project_root}"
-        )
-
-
-class InvalidProjectDefinitionVersionError(ClickException):
-    def __init__(self, expected_version: str, actual_version: str):
-        super().__init__(
-            f"This command only supports definition version {expected_version}, got {actual_version}."
-        )
-
-
-class InvalidSchemaError(ClickException):
-    def __init__(self, schema: str):
-        super().__init__(f"Invalid schema {schema}")
-
-
-class SecretsWithoutExternalAccessIntegrationError(ClickException):
-    def __init__(self, object_name: str):
-        super().__init__(
-            f"{object_name} defined with secrets but without external integration."
-        )
-
-
-class FileTooLargeError(ClickException):
-    def __init__(self, path: Path, size_limit_in_kb: int):
-        super().__init__(
-            f"File {path} is too large (size limit: {size_limit_in_kb} KB)"
-        )
-
-
-class DirectoryIsNotEmptyError(ClickException):
-    def __init__(self, path: Path):
-        super().__init__(f"Directory '{path}' is not empty")
-
-
-class ConfigFileTooWidePermissionsError(ClickException):
-    def __init__(self, path: Path):
-        change_permissons_command = (
-            f'icacls "{path}" /deny <USER_ID>:F'
-            if IS_WINDOWS
-            else f'chmod 0600 "{path}"'
-        )
-        msg = f"Configuration file {path} has too wide permissions, run `{change_permissons_command}`."
-        if IS_WINDOWS:
-            msg += (
-                f'\nTo check which users have access to the file run `icacls "{path}"`.'
-                "Run the above command for all users except you and administrators."
-            )
-        super().__init__(msg)
-
-
-class DatabaseNotProvidedError(ClickException):
-    def __init__(self):
-        super().__init__(
-            "Database not specified. Please update connection to add `database` parameter, or re-run command using `--database` option. Use `snow connection list` to list existing connections."
-        )
-
-
-class SchemaNotProvidedError(ClickException):
-    def __init__(self):
-        super().__init__(
-            "Schema not specified. Please update connection to add `schema` parameter, or re-run command using `--schema` option. Use `snow connection list` to list existing connections."
-        )
-
-
-class FQNNameError(ClickException):
-    def __init__(self, name: str):
-        super().__init__(f"Specified name '{name}' is not valid name.")
-
-
-class FQNInconsistencyError(ClickException):
-    def __init__(self, part: str, name: str):
-        super().__init__(
-            f"{part.capitalize()} provided but name '{name}' is fully qualified name."
-        )
-
-
-class IncompatibleParametersError(UsageError):
-    def __init__(self, options: list[str]):
-        options_with_quotes = [f"'{option}'" for option in options]
-        comma_separated_options = ", ".join(options_with_quotes[:-1])
-        super().__init__(
-            f"Parameters {comma_separated_options} and {options_with_quotes[-1]} are incompatible and cannot be used simultaneously."
-        )

snowflake/cli/api/feature_flags.py

@@ -1,54 +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 enum import Enum, unique
-from typing import NamedTuple
-
-from snowflake.cli.api.config import (
-    FEATURE_FLAGS_SECTION_PATH,
-    get_config_bool_value,
-    get_env_variable_name,
-)
-
-
-class BooleanFlag(NamedTuple):
-    name: str
-    default: bool = False
-
-
-@unique
-class FeatureFlagMixin(Enum):
-    def is_enabled(self) -> bool:
-        return get_config_bool_value(
-            *FEATURE_FLAGS_SECTION_PATH,
-            key=self.value.name.lower(),
-            default=self.value.default,
-        )
-
-    def is_disabled(self):
-        return not self.is_enabled()
-
-    def env_variable(self):
-        return get_env_variable_name(*FEATURE_FLAGS_SECTION_PATH, key=self.value.name)
-
-
-@unique
-class FeatureFlag(FeatureFlagMixin):
-    ENABLE_STREAMLIT_EMBEDDED_STAGE = BooleanFlag(
-        "ENABLE_STREAMLIT_EMBEDDED_STAGE", False
-    )
-    ENABLE_STREAMLIT_NO_CHECKOUTS = BooleanFlag("ENABLE_STREAMLIT_NO_CHECKOUTS", False)
-    ENABLE_STREAMLIT_VERSIONED_STAGE = BooleanFlag(
-        "ENABLE_STREAMLIT_VERSIONED_STAGE", False
-    )

snowflake/cli/api/identifiers.py

@@ -1,190 +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 re
-
-from click import ClickException
-from snowflake.cli.api.exceptions import FQNInconsistencyError, FQNNameError
-from snowflake.cli.api.project.schemas.v1.identifier_model import (
-    ObjectIdentifierBaseModel,
-)
-from snowflake.cli.api.project.util import VALID_IDENTIFIER_REGEX, identifier_for_url
-
-
-class FQN:
-    """
-    Class representing an identifier and supporting fully qualified names.
-
-    The instance supports builder pattern that allows updating the identifier with database and
-    schema from different sources. For example:
-
-    fqn = FQN.from_string("my_schema.object").using_connection(conn)
-    fqn = FQN.from_identifier_model(cli_context.project_definition.streamlit).using_context()
-    fqn = FQN.from_string("my_name").set_database("db").set_schema("foo")
-    """
-
-    def __init__(
-        self,
-        database: str | None,
-        schema: str | None,
-        name: str,
-        signature: str | None = None,
-    ):
-        self._database = database
-        self._schema = schema
-        self._name = name
-        self.signature = signature
-
-    @property
-    def database(self) -> str | None:
-        return self._database
-
-    @property
-    def schema(self) -> str | None:
-        return self._schema
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-    @property
-    def prefix(self) -> str:
-        if self.database:
-            return f"{self.database}.{self.schema if self.schema else 'PUBLIC'}"
-        if self.schema:
-            return f"{self.schema}"
-        return ""
-
-    @property
-    def identifier(self) -> str:
-        if self.prefix:
-            return f"{self.prefix}.{self.name}"
-        return self.name
-
-    @property
-    def url_identifier(self) -> str:
-        return ".".join(identifier_for_url(part) for part in self.identifier.split("."))
-
-    @property
-    def sql_identifier(self) -> str:
-        if self.signature:
-            return f"IDENTIFIER('{self.identifier}'){self.signature}"
-        return f"IDENTIFIER('{self.identifier}')"
-
-    def __str__(self):
-        return self.identifier
-
-    def __eq__(self, other):
-        return self.identifier == other.identifier
-
-    @classmethod
-    def from_string(cls, identifier: str) -> "FQN":
-        """
-        Takes in an object name in the form [[database.]schema.]name. Returns a FQN instance.
-        """
-        qualifier_pattern = rf"(?:(?P<first_qualifier>{VALID_IDENTIFIER_REGEX})\.)?(?:(?P<second_qualifier>{VALID_IDENTIFIER_REGEX})\.)?(?P<name>{VALID_IDENTIFIER_REGEX})(?P<signature>\(.*\))?"
-        result = re.fullmatch(qualifier_pattern, identifier)
-
-        if result is None:
-            raise FQNNameError(identifier)
-
-        unqualified_name = result.group("name")
-        if result.group("second_qualifier") is not None:
-            database = result.group("first_qualifier")
-            schema = result.group("second_qualifier")
-        else:
-            database = None
-            schema = result.group("first_qualifier")
-
-        signature = None
-        if result.group("signature"):
-            signature = result.group("signature")
-        return cls(
-            name=unqualified_name, schema=schema, database=database, signature=signature
-        )
-
-    @classmethod
-    def from_stage(cls, stage: str) -> "FQN":
-        name = stage
-        if stage.startswith("@"):
-            name = stage[1:]
-        return cls.from_string(name)
-
-    @classmethod
-    def from_identifier_model_v1(cls, model: ObjectIdentifierBaseModel) -> "FQN":
-        """Create an instance from object model."""
-        if not isinstance(model, ObjectIdentifierBaseModel):
-            raise ClickException(
-                f"Expected {type(ObjectIdentifierBaseModel).__name__}, got {model}."
-            )
-
-        fqn = cls.from_string(model.name)
-
-        if fqn.database and model.database:
-            raise FQNInconsistencyError("database", model.name)
-        if fqn.schema and model.schema_name:
-            raise FQNInconsistencyError("schema", model.name)
-
-        return fqn.set_database(model.database).set_schema(model.schema_name)
-
-    @classmethod
-    def from_identifier_model_v2(cls, model) -> "FQN":
-        """Create an instance from object model."""
-        from snowflake.cli.api.project.schemas.entities.common import Identifier
-
-        if not isinstance(model, Identifier):
-            raise ClickException(f"Expected {type(Identifier).__name__}, got {model}.")
-
-        fqn = cls.from_string(model.name)
-
-        if fqn.database and model.database:
-            raise FQNInconsistencyError("database", model.name)
-        if fqn.schema and model.schema_:
-            raise FQNInconsistencyError("schema", model.name)
-
-        return fqn.set_database(model.database).set_schema(model.schema_)
-
-    def set_database(self, database: str | None) -> "FQN":
-        if database:
-            self._database = database
-        return self
-
-    def set_schema(self, schema: str | None) -> "FQN":
-        if schema:
-            self._schema = schema
-        return self
-
-    def set_name(self, name: str) -> "FQN":
-        self._name = name
-        return self
-
-    def using_connection(self, conn) -> "FQN":
-        """Update the instance with database and schema from connection."""
-        # Update the identifier only it if wasn't already a qualified name
-        if conn.database and not self.database:
-            self.set_database(conn.database)
-        if conn.schema and not self.schema:
-            self.set_schema(conn.schema)
-        return self
-
-    def using_context(self) -> "FQN":
-        """Update the instance with database and schema from connection in current cli context."""
-        from snowflake.cli.api.cli_global_context import get_cli_context
-
-        return self.using_connection(get_cli_context().connection)
-
-    def to_dict(self) -> dict:
-        return {"name": self.name, "schema": self.schema, "database": self.database}

snowflake/cli/api/metrics.py

@@ -1,92 +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 typing import Dict, Optional
-
-
-class _TypePrefix:
-    FEATURES = "features"
-
-
-class _DomainPrefix:
-    GLOBAL = "global"
-    APP = "app"
-    SQL = "sql"
-
-
-class CLICounterField:
-    """
-    for each counter field we're adopting a convention of
-    <type>.<domain>.<name>
-    for example, if we're tracking a global feature, then the field name would be
-    features.global.feature_name
-
-    The metrics API is implemented to be generic, but we are adopting a convention
-    for feature tracking with the following model for a given command execution:
-    * counter not present -> feature is not available
-    * counter == 0 -> feature is available, but not used
-    * counter == 1 -> feature is used
-    this makes it easy to compute percentages for feature dashboards in Snowsight
-    """
-
-    TEMPLATES_PROCESSOR = (
-        f"{_TypePrefix.FEATURES}.{_DomainPrefix.GLOBAL}.templates_processor"
-    )
-    SQL_TEMPLATES = f"{_TypePrefix.FEATURES}.{_DomainPrefix.SQL}.sql_templates"
-    PDF_TEMPLATES = f"{_TypePrefix.FEATURES}.{_DomainPrefix.GLOBAL}.pdf_templates"
-    SNOWPARK_PROCESSOR = (
-        f"{_TypePrefix.FEATURES}.{_DomainPrefix.APP}.snowpark_processor"
-    )
-    POST_DEPLOY_SCRIPTS = (
-        f"{_TypePrefix.FEATURES}.{_DomainPrefix.APP}.post_deploy_scripts"
-    )
-    PACKAGE_SCRIPTS = f"{_TypePrefix.FEATURES}.{_DomainPrefix.APP}.package_scripts"
-
-
-class CLIMetrics:
-    """
-    Class to track various metrics across the execution of a command
-    """
-
-    def __init__(self):
-        self._counters: Dict[str, int] = {}
-
-    def __eq__(self, other):
-        if isinstance(other, CLIMetrics):
-            return self._counters == other._counters
-        return False
-
-    def get_counter(self, name: str) -> Optional[int]:
-        return self._counters.get(name)
-
-    def set_counter(self, name: str, value: int) -> None:
-        self._counters[name] = value
-
-    def set_counter_default(self, name: str, value: int) -> None:
-        """
-        sets the counter if it does not already exist
-        """
-        if name not in self._counters:
-            self.set_counter(name, value)
-
-    def increment_counter(self, name: str, value: int = 1) -> None:
-        if name not in self._counters:
-            self.set_counter(name, value)
-        else:
-            self._counters[name] += value
-
-    @property
-    def counters(self) -> Dict[str, int]:
-        # return a copy of the original dict to avoid mutating the original
-        return self._counters.copy()

snowflake/cli/api/output/__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/output/formats.py

@@ -1,20 +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 enum import Enum
-
-
-class OutputFormat(Enum):
-    TABLE = "TABLE"
-    JSON = "JSON"

snowflake/cli/api/output/types.py

@@ -1,118 +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 typing as t
-
-from snowflake.connector import DictCursor
-from snowflake.connector.cursor import SnowflakeCursor
-
-
-class CommandResult:
-    @property
-    def result(self):
-        raise NotImplementedError()
-
-
-class ObjectResult(CommandResult):
-    def __init__(self, element: t.Dict):
-        self._element = element
-
-    @property
-    def result(self):
-        return self._element
-
-
-class CollectionResult(CommandResult):
-    def __init__(self, elements: t.Iterable[t.Dict]):
-        self._elements = elements
-
-    @property
-    def result(self):
-        yield from self._elements
-
-
-class MultipleResults(CommandResult):
-    def __init__(self, elements: t.Iterable[CommandResult] | None = None):
-        self._elements = elements or []
-
-    def add(self, element: CommandResult):
-        self._elements.append(element)  # type: ignore
-
-    @property
-    def result(self):
-        return (element for element in self._elements)
-
-
-class StreamResult(CommandResult):
-    def __init__(self, generator: t.Generator[CommandResult, None, None]):
-        self._generator = generator
-
-    @property
-    def result(self):
-        return self._generator
-
-
-class QueryResult(CollectionResult):
-    def __init__(self, cursor: SnowflakeCursor | DictCursor):
-        self.column_names = [col.name for col in cursor.description]
-        super().__init__(elements=self._prepare_payload(cursor))
-        self._query = cursor.query
-
-    def _prepare_payload(self, cursor: SnowflakeCursor | DictCursor):
-        if isinstance(cursor, DictCursor):
-            return (k for k in cursor)
-        return ({k: v for k, v in zip(self.column_names, row)} for row in cursor)
-
-    @property
-    def query(self):
-        return self._query
-
-
-class SingleQueryResult(ObjectResult):
-    def __init__(self, cursor: SnowflakeCursor):
-        super().__init__(element=self._prepare_payload(cursor))
-
-    def _prepare_payload(self, cursor):
-        results = list(QueryResult(cursor).result)
-        if results:
-            return results[0]
-        return None
-
-
-class QueryJsonValueResult(QueryResult):
-    def __init__(self, cursor: SnowflakeCursor):
-        super().__init__(cursor)
-
-    def _prepare_payload(self, cursor):
-        results = list(QueryResult(cursor).result)
-        if results:
-            # Return value of the first tuple
-            return json.loads(list(results[0].items())[0][1])
-        return None
-
-
-class MessageResult(CommandResult):
-    def __init__(self, message: str):
-        self._message = message
-
-    @property
-    def message(self):
-        return self._message
-
-    @property
-    def result(self):
-        return {"message": self._message}

snowflake/cli/api/plugins/__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.