snowflake-cli 2.8.2__py3-none-any.whl

snowflake/cli/api/utils/dict_utils.py

@@ -0,0 +1,73 @@
+# 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 typing import Any, Callable
+
+
+def deep_merge_dicts(
+    original_values: dict[Any, Any], override_values: dict[Any, Any]
+) -> None:
+    """
+    Takes 2 dictionaries as input: original and override. The original dictionary is modified.
+
+    For every key in the override dictionary, override the same key
+    in the original dictionary, or create a new one if the key is not present.
+
+    If the override value and the original value are both dictionaries,
+    instead of overriding, this function recursively calls itself to merge the keys of the sub-dictionaries.
+    """
+    if not isinstance(override_values, dict) or not isinstance(original_values, dict):
+        raise ValueError("Arguments are not of type dict")
+
+    for field, value in override_values.items():
+        if (
+            field in original_values
+            and isinstance(original_values[field], dict)
+            and isinstance(value, dict)
+        ):
+            deep_merge_dicts(original_values[field], value)
+        else:
+            original_values[field] = value
+
+
+def traverse(
+    element: Any,
+    visit_action: Callable[[Any], None] = lambda element: None,
+    update_action: Callable[[Any], Any] = lambda element: element,
+) -> Any:
+    """
+    Traverse a nested structure (lists, dicts, scalars).
+
+    On traversal, it allows for actions or updates on each visit.
+
+    visit_action: caller can provide a function to execute on each scalar element in the structure (leaves of the tree).
+    visit_action accepts an element (scalar) as input. Return value is ignored.
+
+    update_action: caller can provide a function to update each scalar element in the structure.
+    update_action accepts an element (scalar) as input, and returns the modified value.
+
+    """
+    if isinstance(element, dict):
+        for key, value in element.items():
+            element[key] = traverse(value, visit_action, update_action)
+        return element
+    elif isinstance(element, list):
+        for index, value in enumerate(element):
+            element[index] = traverse(value, visit_action, update_action)
+        return element
+    else:
+        visit_action(element)
+        return update_action(element)

snowflake/cli/api/utils/error_handling.py

@@ -0,0 +1,23 @@
+# 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 contextlib import contextmanager
+
+
+@contextmanager
+def ignore_exceptions():
+    try:
+        yield
+    except:
+        pass

snowflake/cli/api/utils/graph.py

@@ -0,0 +1,97 @@
+# 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, field
+from enum import Enum
+from typing import Callable, Generic, TypeVar
+
+T = TypeVar("T")
+
+
+class VisitStatus(Enum):
+    VISITING = 1
+    VISITED = 2
+
+
+@dataclass
+class Node(Generic[T]):
+    key: str
+    data: T
+    neighbors: set[Node[T]] = field(default_factory=set)
+
+    def __hash__(self):
+        return hash(self.key)
+
+    def __eq__(self, other):
+        return self.key == other.key
+
+
+class Graph(Generic[T]):
+    def __init__(self):
+        self._graph_nodes_map: dict[str, Node[T]] = {}
+
+    def get(self, key: str) -> Node[T]:
+        if key in self._graph_nodes_map:
+            return self._graph_nodes_map[key]
+        raise KeyError(f"Node with key {key} not found")
+
+    def get_all_nodes(self) -> set[Node[T]]:
+        return set(self._graph_nodes_map.values())
+
+    def add(self, node: Node[T]) -> None:
+        if node.key in self._graph_nodes_map:
+            raise KeyError(f"Node key {node.key} already exists")
+        self._graph_nodes_map[node.key] = node
+
+    def add_directed_edge(self, from_node_key: str, to_node_key: str) -> None:
+        from_node = self.get(from_node_key)
+        to_node = self.get(to_node_key)
+        from_node.neighbors.add(to_node)
+
+    @staticmethod
+    def _dfs_visit(
+        nodes_status: dict[str, VisitStatus],
+        node: Node[T],
+        visit_action: Callable[[Node[T]], None],
+        on_cycle_action: Callable[[Node[T]], None],
+    ) -> None:
+        if nodes_status.get(node.key) == VisitStatus.VISITED:
+            return
+
+        nodes_status[node.key] = VisitStatus.VISITING
+        for neighbor_node in node.neighbors:
+            if nodes_status.get(neighbor_node.key) == VisitStatus.VISITING:
+                on_cycle_action(node)
+            else:
+                Graph._dfs_visit(
+                    nodes_status, neighbor_node, visit_action, on_cycle_action
+                )
+
+        visit_action(node)
+
+        nodes_status[node.key] = VisitStatus.VISITED
+
+    def dfs(
+        self,
+        visit_action: Callable[[Node[T]], None] = lambda node: None,
+        on_cycle_action: Callable[[Node[T]], None] = lambda node: None,
+    ) -> None:
+        nodes_status: dict[str, VisitStatus] = {}
+        for node in self._graph_nodes_map.values():
+            Graph._dfs_visit(nodes_status, node, visit_action, on_cycle_action)
+
+    def __contains__(self, key: str) -> bool:
+        return key in self._graph_nodes_map

snowflake/cli/api/utils/models.py

@@ -0,0 +1,63 @@
+# 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 os
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class ProjectEnvironment:
+    """
+    This class handles retrieval of project env variables.
+    These env variables can be accessed through templating, as ctx.env.<var_name>
+
+    This class checks for env values in the following order:
+    - Check for overrides values from the command line. Use these values first.
+    - Check if these variables are available as environment variables and return them if found.
+    - Check for default values from the project definition file.
+    """
+
+    override_env: Dict[str, Any]
+    default_env: Dict[str, Any]
+
+    def __init__(
+        self,
+        default_env: Optional[Dict[str, Any]] = None,
+        override_env: Optional[Dict[str, Any]] = None,
+    ):
+        self.override_env = override_env or {}
+        self.default_env = default_env or {}
+
+    def __getitem__(self, item):
+        if item in self.override_env:
+            return self.override_env.get(item)
+        if item in os.environ:
+            return os.environ[item]
+        return self.default_env[item]
+
+    def get(self, item, default=None):
+        try:
+            return self[item]
+        except KeyError:
+            return default
+
+    def __contains__(self, item) -> bool:
+        try:
+            self[item]
+            return True
+        except KeyError:
+            return False

snowflake/cli/api/utils/naming_utils.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/utils/path_utils.py

@@ -0,0 +1,36 @@
+# 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
+
+BUFFER_SIZE = 4096
+
+
+def path_resolver(path_to_file: str) -> str:
+    if sys.platform == "win32" and "~1" in path_to_file:
+        from ctypes import create_unicode_buffer, windll  # type: ignore
+
+        buffer = create_unicode_buffer(BUFFER_SIZE)
+        get_long_path_name = windll.kernel32.GetLongPathNameW
+        return_value = get_long_path_name(path_to_file, buffer, BUFFER_SIZE)
+
+        if 0 < return_value <= BUFFER_SIZE:
+            return buffer.value
+    return path_to_file
+
+
+def is_stage_path(path: str) -> bool:
+    return path.startswith("@") or path.startswith("snow://")

snowflake/cli/api/utils/templating_functions.py

@@ -0,0 +1,144 @@
+# 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 typing import Any, List, Optional
+
+from snowflake.cli.api.exceptions import InvalidTemplate
+from snowflake.cli.api.project.util import (
+    concat_identifiers,
+    get_env_username,
+    identifier_to_str,
+    sanitize_identifier,
+    to_identifier,
+)
+
+
+class TemplatingFunctions:
+    """
+    This class contains all the functions available for templating.
+    Any callable not starting with '_' will automatically be available for users to use.
+    """
+
+    @staticmethod
+    def _verify_str_arguments(
+        func_name: str,
+        args: List[Any],
+        *,
+        min_count: Optional[int] = None,
+        max_count: Optional[int] = None,
+    ):
+        if min_count is not None and len(args) < min_count:
+            raise InvalidTemplate(
+                f"{func_name} requires at least {min_count} argument(s)"
+            )
+
+        if max_count is not None and len(args) > max_count:
+            raise InvalidTemplate(
+                f"{func_name} supports at most {max_count} argument(s)"
+            )
+
+        for arg in args:
+            if not isinstance(arg, str):
+                raise InvalidTemplate(f"{func_name} only accepts String values")
+
+    @staticmethod
+    def concat_ids(*args):
+        """
+        input: one or more string arguments (SQL ID or plain String).
+        output: a valid SQL ID (quoted or unquoted)
+
+        Takes on multiple String arguments and concatenate them into one String.
+        If any of the Strings is a valid quoted ID, it will be unescaped for the concatenation process.
+        The resulting String is then escaped and quoted if:
+        - It contains non SQL safe characters
+        - Any of the input was a valid quoted identifier.
+        """
+        TemplatingFunctions._verify_str_arguments("concat_ids", args, min_count=1)
+        return concat_identifiers(args)
+
+    @staticmethod
+    def str_to_id(*args):
+        """
+        input: one string argument. (SQL ID or plain String)
+        output: a valid SQL ID (quoted or unquoted)
+
+        If the input is a valid quoted or valid unquoted identifier, return it as is.
+        Otherwise, if the input contains unsafe characters and is not properly quoted,
+        then escape it and quote it.
+        """
+        TemplatingFunctions._verify_str_arguments(
+            "str_to_id", args, min_count=1, max_count=1
+        )
+        return to_identifier(args[0])
+
+    @staticmethod
+    def id_to_str(*args):
+        """
+        input: one string argument (SQL ID or plain String).
+        output: a plain string
+
+        If the input is a valid SQL ID, then unescape it and return the plain String version.
+        Otherwise, return the input as is.
+        """
+        TemplatingFunctions._verify_str_arguments(
+            "id_to_str", args, min_count=1, max_count=1
+        )
+        return identifier_to_str(args[0])
+
+    @staticmethod
+    def get_username(*args):
+        """
+        input: one optional string containing the fallback value
+        output: current username detected from the Operating System
+
+        If the current username is not found or is blank, return blank
+        or use the fallback value if provided.
+        """
+        TemplatingFunctions._verify_str_arguments(
+            "get_username", args, min_count=0, max_count=1
+        )
+        fallback_username = args[0] if len(args) > 0 else ""
+        return get_env_username() or fallback_username
+
+    @staticmethod
+    def sanitize_id(*args):
+        """
+        input: one string argument
+        output: a valid non-quoted SQL ID
+
+        Removes any unsafe SQL characters from the input,
+        prepend it with an underscore if it does not start with a valid character,
+        and limit the result to 255 characters.
+        The result is a valid unquoted SQL ID.
+        """
+        TemplatingFunctions._verify_str_arguments(
+            "sanitize_id", args, min_count=1, max_count=1
+        )
+
+        return sanitize_identifier(args[0])
+
+
+def get_templating_functions():
+    """
+    Returns a dictionary with all the functions available for templating
+    """
+    templating_functions = {
+        func: getattr(TemplatingFunctions, func)
+        for func in dir(TemplatingFunctions)
+        if callable(getattr(TemplatingFunctions, func)) and not func.startswith("_")
+    }
+
+    return templating_functions

snowflake/cli/api/utils/types.py

@@ -0,0 +1,35 @@
+# 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 typing import Any, Dict
+
+Context = Dict[str, Any]
+Definition = Dict[str, Any]
+
+
+def try_cast_to_bool(value: Any) -> bool:
+    if isinstance(value, bool):
+        return value
+
+    # Now if value is not string then cast it to str. Simplifies logic for 1 and 0
+    if not isinstance(value, str):
+        value = str(value)
+
+    know_booleans_mapping = {"true": True, "false": False, "1": True, "0": False}
+
+    if value.lower() not in know_booleans_mapping:
+        raise ValueError(f"Could not case {value} to bool value")
+    return know_booleans_mapping[value.lower()]

snowflake/cli/app/__init__.py

@@ -0,0 +1,22 @@
+# 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.
+
+import logging
+import os
+
+# Suppress logging from Snowflake connector
+logging.getLogger("snowflake").setLevel(logging.ERROR)
+
+# Restrict permissions of all created files
+os.umask(0o077)

snowflake/cli/app/__main__.py

@@ -0,0 +1,31 @@
+# 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
+
+from snowflake.cli.app.cli_app import app_factory
+
+
+def main(*args):
+    app = app_factory()
+    app(*args)
+
+
+if __name__ == "__main__":
+    main()
+
+if getattr(sys, "frozen", False):
+    main(sys.argv[1:])

snowflake/cli/app/api_impl/__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/app/api_impl/plugin/__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/app/api_impl/plugin/plugin_config_provider_impl.py

@@ -0,0 +1,66 @@
+# 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 typing import List
+
+from snowflake.cli.api import PluginConfigProvider
+from snowflake.cli.api.config import (
+    PLUGINS_SECTION_PATH,
+    config_section_exists,
+    get_config_section,
+    get_config_value,
+    get_plugins_config,
+)
+from snowflake.cli.api.exceptions import InvalidPluginConfiguration
+from snowflake.cli.api.plugins.plugin_config import PluginConfig
+
+
+def _assert_value_is_bool(value, *, value_name: str, plugin_name: str) -> None:
+    if type(value) is not bool:
+        raise InvalidPluginConfiguration(
+            f'[{plugin_name}]: "{value_name}" must be a boolean'
+        )
+
+
+_ENABLED_KEY = "enabled"
+
+
+class PluginConfigProviderImpl(PluginConfigProvider):
+    def get_enabled_plugin_names(self) -> List[str]:
+        enabled_plugins = []
+        for plugin_name, plugin_config_section in get_plugins_config().items():
+            enabled = plugin_config_section.get(_ENABLED_KEY, False)
+            _assert_value_is_bool(
+                enabled, value_name=_ENABLED_KEY, plugin_name=plugin_name
+            )
+            if enabled:
+                enabled_plugins.append(plugin_name)
+        return enabled_plugins
+
+    def get_config(self, plugin_name: str) -> PluginConfig:
+        config_path = PLUGINS_SECTION_PATH + [plugin_name]
+        plugin_config = PluginConfig(is_plugin_enabled=False, internal_config={})
+        plugin_config.is_plugin_enabled = get_config_value(
+            *config_path, key=_ENABLED_KEY, default=False
+        )
+        _assert_value_is_bool(
+            plugin_config.is_plugin_enabled,
+            value_name=_ENABLED_KEY,
+            plugin_name=plugin_name,
+        )
+        if config_section_exists(*config_path, "config"):
+            plugin_config.internal_config = get_config_section(*config_path, "config")
+        return plugin_config

snowflake/cli/app/build_and_push.sh

@@ -0,0 +1,8 @@
+set -e
+export SF_REGISTRY="$(snow spcs image-registry url -c integration)"
+DATABASE=$(echo "${SNOWFLAKE_CONNECTIONS_INTEGRATION_DATABASE}" | tr '[:upper:]' '[:lower:]')
+
+echo "Using registry: ${SF_REGISTRY}"
+docker build --platform linux/amd64 -t "${SF_REGISTRY}/${DATABASE}/public/snowcli_repository/test_counter" .
+snow spcs image-registry token --format=json -c integration | docker login "${SF_REGISTRY}/${DATABASE}/public/snowcli_repository" -u 0sessiontoken --password-stdin
+docker push "${SF_REGISTRY}/${DATABASE}/public/snowcli_repository/test_counter"