snowflake-cli 2.8.2__py3-none-any.whl

snowflake/cli/api/identifiers.py

@@ -0,0 +1,167 @@
+# 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.cli_global_context import cli_context
+from snowflake.cli.api.exceptions import FQNInconsistencyError, FQNNameError
+from snowflake.cli.api.project.schemas.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(cls, model: ObjectIdentifierBaseModel) -> "FQN":
+        """Create an instance from object model."""
+        if not isinstance(model, ObjectIdentifierBaseModel):
+            raise ClickException(
+                f"Expected {type(ObjectIdentifierBaseModel)}, 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)
+
+    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."""
+        return self.using_connection(cli_context.connection)

snowflake/cli/api/output/__init__.py

@@ -0,0 +1,13 @@
+# 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

@@ -0,0 +1,20 @@
+# 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

@@ -0,0 +1,118 @@
+# 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

@@ -0,0 +1,13 @@
+# 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/plugins/command/__init__.py

@@ -0,0 +1,72 @@
+# 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 dataclasses import dataclass
+from enum import Enum
+from functools import cached_property
+from typing import List
+
+import click
+import pluggy
+from typer import Typer
+from typer.main import get_command
+
+SNOWCLI_COMMAND_PLUGIN_NAMESPACE = "snowflake.cli.plugin.command"
+
+plugin_hook_spec = pluggy.HookspecMarker(SNOWCLI_COMMAND_PLUGIN_NAMESPACE)
+plugin_hook_impl = pluggy.HookimplMarker(SNOWCLI_COMMAND_PLUGIN_NAMESPACE)
+
+
+class CommandPath:
+    def __init__(self, path_segments: List[str]):
+        self._path_segments = tuple(path_segments)
+
+    @property
+    def path_segments(self) -> List[str]:
+        return list(self._path_segments)
+
+    def __hash__(self):
+        return hash(self._path_segments)
+
+    def __eq__(self, other):
+        return self._path_segments == other._path_segments
+
+    def __str__(self) -> str:
+        return "snow " + " ".join(self.path_segments)
+
+
+SNOWCLI_ROOT_COMMAND_PATH = CommandPath(path_segments=[])
+
+
+class CommandType(Enum):
+    SINGLE_COMMAND = "SINGLE_COMMAND"
+    COMMAND_GROUP = "COMMAND_GROUP"
+
+
+@dataclass(frozen=True)
+class CommandSpec:
+    parent_command_path: CommandPath
+    command_type: CommandType
+    typer_instance: Typer
+
+    @cached_property
+    def command(self) -> click.Command:
+        self.typer_instance._add_completion = False  # noqa: SLF001
+        return get_command(self.typer_instance)
+
+    @cached_property
+    def full_command_path(self) -> CommandPath:
+        return CommandPath(self.parent_command_path.path_segments + [self.command.name])

snowflake/cli/api/plugins/command/plugin_hook_specs.py

@@ -0,0 +1,21 @@
+# 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.plugins.command import plugin_hook_spec
+
+
+@plugin_hook_spec
+def command_spec():
+    """Command spec"""
+    pass

snowflake/cli/api/plugins/plugin_config.py

@@ -0,0 +1,32 @@
+# 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 dataclasses import dataclass
+from typing import Any, Dict, List
+
+
+@dataclass
+class PluginConfig:
+    is_plugin_enabled: bool
+    internal_config: Dict[str, Any]
+
+
+class PluginConfigProvider:
+    def get_enabled_plugin_names(self) -> List[str]:
+        raise NotImplementedError()
+
+    def get_config(self, plugin_name: str) -> PluginConfig:
+        raise NotImplementedError()

snowflake/cli/api/project/__init__.py

@@ -0,0 +1,13 @@
+# 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/project/definition.py

@@ -0,0 +1,84 @@
+# 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 List, Optional
+
+import yaml
+from snowflake.cli.api.cli_global_context import cli_context
+from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB
+from snowflake.cli.api.project.schemas.project_definition import (
+    ProjectProperties,
+)
+from snowflake.cli.api.project.util import (
+    append_to_identifier,
+    get_env_username,
+    sanitize_identifier,
+    to_identifier,
+)
+from snowflake.cli.api.secure_path import SecurePath
+from snowflake.cli.api.utils.definition_rendering import render_definition_template
+from snowflake.cli.api.utils.dict_utils import deep_merge_dicts
+from snowflake.cli.api.utils.types import Context, Definition
+
+DEFAULT_USERNAME = "unknown_user"
+
+
+def _get_merged_definitions(paths: List[Path]) -> Optional[Definition]:
+    spaths: List[SecurePath] = [SecurePath(p) for p in paths]
+    if len(spaths) == 0:
+        return None
+
+    with spaths[0].open("r", read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB) as base_yml:
+        definition = yaml.load(base_yml.read(), Loader=yaml.loader.BaseLoader) or {}
+
+    for override_path in spaths[1:]:
+        with override_path.open(
+            "r", read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB
+        ) as override_yml:
+            overrides = (
+                yaml.load(override_yml.read(), Loader=yaml.loader.BaseLoader) or {}
+            )
+            deep_merge_dicts(definition, overrides)
+
+    return definition
+
+
+def load_project(
+    paths: List[Path], context_overrides: Optional[Context] = None
+) -> ProjectProperties:
+    """
+    Loads project definition, optionally overriding values. Definition values
+    are merged in left-to-right order (increasing precedence).
+    Templating is also applied after the merging process.
+    """
+    merged_definitions = _get_merged_definitions(paths)
+    return render_definition_template(merged_definitions, context_overrides or {})
+
+
+def default_app_package(project_name: str):
+    user = sanitize_identifier(get_env_username() or DEFAULT_USERNAME).lower()
+    return append_to_identifier(to_identifier(project_name), f"_pkg_{user}")
+
+
+def default_role():
+    conn = cli_context.connection
+    return conn.role
+
+
+def default_application(project_name: str):
+    user = sanitize_identifier(get_env_username() or DEFAULT_USERNAME).lower()
+    return append_to_identifier(to_identifier(project_name), f"_{user}")

snowflake/cli/api/project/definition_manager.py

@@ -0,0 +1,134 @@
+# 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 functools
+import os
+from pathlib import Path
+from typing import List, Optional
+
+from snowflake.cli.api.project.definition import ProjectProperties, load_project
+from snowflake.cli.api.project.schemas.project_definition import ProjectDefinitionV1
+from snowflake.cli.api.utils.types import Context
+
+
+def _compat_is_mount(path: Path):
+    try:
+        return path.is_mount()
+    except NotImplementedError:
+        # If we can't figure out if path is mount then let's assume it is
+        # Windows support added in Python 3.12
+        return True
+
+
+class DefinitionManager:
+    BASE_DEFINITION_FILENAME = "snowflake.yml"
+    USER_DEFINITION_FILENAME = "snowflake.local.yml"
+
+    project_root: Path
+    _project_config_paths: List[Path]
+
+    def __init__(
+        self,
+        project_arg: Optional[str] = None,
+        context_overrides: Optional[Context] = None,
+    ) -> None:
+        project_root = Path(
+            os.path.abspath(project_arg) if project_arg else os.getcwd()
+        )
+
+        self.project_root = project_root
+        self._project_config_paths = self._find_definition_files(self.project_root)
+        self._context_overrides = context_overrides
+
+    @functools.cached_property
+    def has_definition_file(self):
+        return len(self._project_config_paths) > 0
+
+    @staticmethod
+    def _find_definition_files(project_root: Path) -> List[Path]:
+        base_config_file_path = DefinitionManager._base_definition_file_if_available(
+            project_root
+        )
+        user_config_file_path = DefinitionManager._user_definition_file_if_available(
+            project_root
+        )
+
+        definition_files: List[Path] = []
+        if base_config_file_path:
+            definition_files.append(base_config_file_path)
+            if user_config_file_path:
+                definition_files.append(user_config_file_path)
+
+        return definition_files
+
+    @staticmethod
+    def find_project_root(search_path: Path) -> Optional[Path]:
+        """
+        Recurse up the directory tree from the given search path until we find
+        a directory that contains a snowflake.yml file. We'll stop if we cross
+        a filesystem boundary or hit the user's HOME directory.
+        """
+        current_path = search_path
+        starting_mount = _compat_is_mount(search_path)
+        while current_path:
+            if (
+                _compat_is_mount(current_path) != starting_mount
+                or current_path.parent == current_path
+                or current_path == Path.home()
+            ):
+                return None
+
+            if (
+                DefinitionManager._base_definition_file_if_available(current_path)
+                is not None
+            ):
+                # found snowflake.yml, end the search here
+                return current_path
+
+            current_path = current_path.parent
+
+        return None
+
+    @staticmethod
+    def _definition_if_available(filename, project_path: Path) -> Optional[Path]:
+        file_path = Path(project_path) / filename
+        if file_path.is_file():
+            return file_path
+        return None
+
+    @staticmethod
+    def _base_definition_file_if_available(project_path: Path) -> Optional[Path]:
+        return DefinitionManager._definition_if_available(
+            DefinitionManager.BASE_DEFINITION_FILENAME, project_path
+        )
+
+    @staticmethod
+    def _user_definition_file_if_available(project_path: Path) -> Optional[Path]:
+        return DefinitionManager._definition_if_available(
+            DefinitionManager.USER_DEFINITION_FILENAME, project_path
+        )
+
+    @functools.cached_property
+    def _project_properties(self) -> ProjectProperties:
+        return load_project(self._project_config_paths, self._context_overrides)
+
+    @functools.cached_property
+    def project_definition(self) -> ProjectDefinitionV1:
+        return self._project_properties.project_definition
+
+    @functools.cached_property
+    def template_context(self) -> Context:
+        return self._project_properties.project_context