snowflake-cli 2.8.2__py3-none-any.whl

snowflake/cli/plugins/notebook/manager.py

@@ -0,0 +1,71 @@
+# 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 pathlib import Path
+from textwrap import dedent
+
+from snowflake.cli.api.cli_global_context import cli_context
+from snowflake.cli.api.identifiers import FQN
+from snowflake.cli.api.sql_execution import SqlExecutionMixin
+from snowflake.cli.plugins.connection.util import make_snowsight_url
+from snowflake.cli.plugins.notebook.exceptions import NotebookStagePathError
+from snowflake.cli.plugins.notebook.types import NotebookStagePath
+
+
+class NotebookManager(SqlExecutionMixin):
+    def execute(self, notebook_name: FQN):
+        query = f"EXECUTE NOTEBOOK {notebook_name.sql_identifier}()"
+        return self._execute_query(query=query)
+
+    def get_url(self, notebook_name: FQN):
+        fqn = notebook_name.using_connection(self._conn)
+        return make_snowsight_url(
+            self._conn,
+            f"/#/notebooks/{fqn.url_identifier}",
+        )
+
+    @staticmethod
+    def parse_stage_as_path(notebook_file: str) -> Path:
+        """Parses notebook file path to pathlib.Path."""
+        if not notebook_file.endswith(".ipynb"):
+            raise NotebookStagePathError(notebook_file)
+        stage_path = Path(notebook_file)
+        if len(stage_path.parts) < 2:
+            raise NotebookStagePathError(notebook_file)
+
+        return stage_path
+
+    def create(
+        self,
+        notebook_name: FQN,
+        notebook_file: NotebookStagePath,
+    ) -> str:
+        notebook_fqn = notebook_name.using_connection(self._conn)
+        stage_path = self.parse_stage_as_path(notebook_file)
+
+        queries = dedent(
+            f"""
+            CREATE OR REPLACE NOTEBOOK {notebook_fqn.sql_identifier}
+            FROM '{stage_path.parent}'
+            QUERY_WAREHOUSE = '{cli_context.connection.warehouse}'
+            MAIN_FILE = '{stage_path.name}';
+            // Cannot use IDENTIFIER(...)
+            ALTER NOTEBOOK {notebook_fqn.identifier} ADD LIVE VERSION FROM LAST;
+            """
+        )
+        self._execute_queries(queries=queries)
+
+        return make_snowsight_url(
+            self._conn, f"/#/notebooks/{notebook_fqn.url_identifier}"
+        )

snowflake/cli/plugins/notebook/plugin_spec.py

@@ -0,0 +1,30 @@
+# 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 (
+    SNOWCLI_ROOT_COMMAND_PATH,
+    CommandSpec,
+    CommandType,
+    plugin_hook_impl,
+)
+from snowflake.cli.plugins.notebook import commands
+
+
+@plugin_hook_impl
+def command_spec():
+    return CommandSpec(
+        parent_command_path=SNOWCLI_ROOT_COMMAND_PATH,
+        command_type=CommandType.COMMAND_GROUP,
+        typer_instance=commands.app.create_instance(),
+    )

snowflake/cli/plugins/notebook/types.py

@@ -0,0 +1,15 @@
+# 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.
+
+NotebookStagePath = str

snowflake/cli/plugins/object/__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/plugins/object/command_aliases.py

@@ -0,0 +1,95 @@
+# 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, Optional, Tuple
+
+import typer
+from click import ClickException
+from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
+from snowflake.cli.api.constants import ObjectType
+from snowflake.cli.api.identifiers import FQN
+from snowflake.cli.plugins.object.commands import (
+    ScopeOption,
+    describe,
+    drop,
+    list_,
+    scope_option,  # noqa: F401
+)
+
+
+def add_object_command_aliases(
+    app: SnowTyperFactory,
+    object_type: ObjectType,
+    name_argument: typer.Argument,
+    like_option: Optional[typer.Option],
+    scope_option: Optional[typer.Option],
+    ommit_commands: List[str] = [],
+):
+    if "list" not in ommit_commands:
+        if not like_option:
+            raise ClickException('[like_option] have to be defined for "list" command')
+
+        if not scope_option:
+
+            @app.command("list", requires_connection=True)
+            def list_cmd(like: str = like_option, **options):  # type: ignore
+                return list_(
+                    object_type=object_type.value.cli_name,
+                    like=like,
+                    scope=ScopeOption.default,
+                    **options,
+                )
+
+        else:
+
+            @app.command("list", requires_connection=True)
+            def list_cmd(
+                like: str = like_option,  # type: ignore
+                scope: Tuple[str, str] = scope_option,  # type: ignore
+                **options,
+            ):
+                return list_(
+                    object_type=object_type.value.cli_name,
+                    like=like,
+                    scope=scope,
+                    **options,
+                )
+
+        list_cmd.__doc__ = f"Lists all available {object_type.value.sf_plural_name}."
+
+    if "drop" not in ommit_commands:
+
+        @app.command("drop", requires_connection=True)
+        def drop_cmd(name: FQN = name_argument, **options):
+            return drop(
+                object_type=object_type.value.cli_name,
+                object_name=name,
+                **options,
+            )
+
+        drop_cmd.__doc__ = f"Drops {object_type.value.sf_name} with given name."
+
+    if "describe" not in ommit_commands:
+
+        @app.command("describe", requires_connection=True)
+        def describe_cmd(name: FQN = name_argument, **options):
+            return describe(
+                object_type=object_type.value.cli_name,
+                object_name=name,
+                **options,
+            )
+
+        describe_cmd.__doc__ = f"Provides description of {object_type.value.sf_name}."

snowflake/cli/plugins/object/commands.py

@@ -0,0 +1,181 @@
+# 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, Optional, Tuple
+
+import typer
+from click import ClickException
+from snowflake.cli.api.commands.flags import (
+    IdentifierType,
+    like_option,
+    parse_key_value_variables,
+)
+from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
+from snowflake.cli.api.constants import SUPPORTED_OBJECTS, VALID_SCOPES
+from snowflake.cli.api.identifiers import FQN
+from snowflake.cli.api.output.types import MessageResult, QueryResult
+from snowflake.cli.api.project.util import is_valid_identifier
+from snowflake.cli.plugins.object.manager import ObjectManager
+
+app = SnowTyperFactory(
+    name="object",
+    help="Manages Snowflake objects like warehouses and stages",
+)
+
+
+NameArgument = typer.Argument(
+    help="Name of the object.", show_default=False, click_type=IdentifierType()
+)
+ObjectArgument = typer.Argument(
+    help="Type of object. For example table, database, compute-pool.",
+    case_sensitive=False,
+    show_default=False,
+)
+# TODO: add documentation link
+ObjectAttributesArgument = typer.Argument(
+    None,
+    help="""Object attributes provided as a list of key=value pairs,
+for example name=my_db comment='created with Snowflake CLI'.
+
+Check documentation for the full list of available parameters
+for every object.
+""",
+    show_default=False,
+)
+# TODO: add documentation link
+ObjectDefinitionJsonOption = typer.Option(
+    None,
+    "--json",
+    help="""Object definition in JSON format, for example
+\'{"name": "my_db", "comment": "created with Snowflake CLI"}\'.
+
+Check documentation for the full list of available parameters
+for every object.
+""",
+    show_default=False,
+)
+LikeOption = like_option(
+    help_example='`list function --like "my%"` lists all functions that begin with “my”',
+)
+
+
+def _scope_validate(object_type: str, scope: Tuple[str, str]):
+    if scope[1] is not None and not is_valid_identifier(scope[1]):
+        raise ClickException("scope name must be a valid identifier")
+    if scope[0] is not None and scope[0].lower() not in VALID_SCOPES:
+        raise ClickException(
+            f"scope must be one of the following: {', '.join(VALID_SCOPES)}"
+        )
+    if scope[0] == "compute-pool" and object_type != "service":
+        raise ClickException("compute-pool scope is only supported for listing service")
+
+
+def scope_option(help_example: str):
+    return typer.Option(
+        (None, None),
+        "--in",
+        help=f"Specifies the scope of this command using '--in <scope> <name>', for example {help_example}.",
+    )
+
+
+ScopeOption = scope_option(
+    help_example="`list table --in database my_db`. Some object types have specialized scopes (e.g. list service --in compute-pool my_pool)"
+)
+
+SUPPORTED_TYPES_MSG = "\n\nSupported types: " + ", ".join(SUPPORTED_OBJECTS)
+
+
+@app.command(
+    "list",
+    help=f"Lists all available Snowflake objects of given type.{SUPPORTED_TYPES_MSG}",
+    requires_connection=True,
+)
+def list_(
+    object_type: str = ObjectArgument,
+    like: str = LikeOption,
+    scope: Tuple[str, str] = ScopeOption,
+    **options,
+):
+    _scope_validate(object_type, scope)
+    return QueryResult(
+        ObjectManager().show(object_type=object_type, like=like, scope=scope)
+    )
+
+
+@app.command(
+    help=f"Drops Snowflake object of given name and type. {SUPPORTED_TYPES_MSG}",
+    requires_connection=True,
+)
+def drop(object_type: str = ObjectArgument, object_name: FQN = NameArgument, **options):
+    return QueryResult(ObjectManager().drop(object_type=object_type, fqn=object_name))
+
+
+# Image repository is the only supported object that does not have a DESCRIBE command.
+DESCRIBE_SUPPORTED_TYPES_MSG = f"\n\nSupported types: {', '.join(obj for obj in SUPPORTED_OBJECTS if obj != 'image-repository')}"
+
+
+@app.command(
+    help=f"Provides description of an object of given type. {DESCRIBE_SUPPORTED_TYPES_MSG}",
+    requires_connection=True,
+)
+def describe(
+    object_type: str = ObjectArgument, object_name: FQN = NameArgument, **options
+):
+    return QueryResult(
+        ObjectManager().describe(object_type=object_type, fqn=object_name)
+    )
+
+
+@app.command(name="create", requires_connection=True)
+def create(
+    object_type: str = ObjectArgument,
+    object_attributes: Optional[List[str]] = ObjectAttributesArgument,
+    object_json: str = ObjectDefinitionJsonOption,
+    **options,
+):
+    """
+    Create an object of a given type. Check documentation for the list of supported objects
+    and parameters.
+    """
+    import json
+
+    if object_attributes and object_json:
+        raise ClickException(
+            "Conflict: both object attributes and JSON definition are provided"
+        )
+
+    if object_json:
+        object_data = json.loads(object_json)
+    elif object_attributes:
+
+        def _parse_if_json(value: str):
+            try:
+                return json.loads(value)
+            except json.JSONDecodeError:
+                return value
+
+        object_data = {
+            v.key: _parse_if_json(v.value)
+            for v in parse_key_value_variables(object_attributes)
+        }
+
+    else:
+        raise ClickException(
+            "Provide either list of object attributes, or object definition in JSON format"
+        )
+
+    result = ObjectManager().create(object_type=object_type, object_data=object_data)
+    return MessageResult(result)

snowflake/cli/plugins/object/common.py

@@ -0,0 +1,85 @@
+# 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 Optional
+
+from click import ClickException
+from snowflake.cli.api.commands.flags import OverrideableOption
+from snowflake.cli.api.project.util import (
+    VALID_IDENTIFIER_REGEX,
+    is_valid_identifier,
+    to_string_literal,
+)
+
+
+@dataclass
+class Tag:
+    name: str
+    value: str
+
+    def __post_init__(self):
+        if not is_valid_identifier(self.name):
+            raise ValueError("name of a tag must be a valid Snowflake identifier")
+
+    def value_string_literal(self):
+        return to_string_literal(self.value)
+
+
+class TagError(ClickException):
+    def __init__(self):
+        super().__init__(
+            "tag must be in the format <name>=<value> where 'name' is a valid identifier and value is a string"
+        )
+
+
+def _parse_tag(tag: str) -> Tag:
+    import re
+
+    identifier_pattern = rf"(?P<tag_name>{VALID_IDENTIFIER_REGEX})"
+    value_pattern = r"(?P<tag_value>.+)"
+    result = re.fullmatch(rf"{identifier_pattern}={value_pattern}", tag)
+    if result is not None:
+        try:
+            return Tag(result.group("tag_name"), result.group("tag_value"))
+        except ValueError:
+            raise TagError()
+    else:
+        raise TagError()
+
+
+"""
+Provides a common interface for all commands that accept a tag option (e.g. when altering the tag of an object).
+Parses the input string in the format "name=value" into a Tag object with 'name' and 'value' properties.
+"""
+TagOption = OverrideableOption(
+    None, "--tag", help=f"Tag for the object.", parser=_parse_tag, metavar="NAME=VALUE"
+)
+
+
+def _comment_callback(comment: Optional[str]):
+    if comment is None:
+        return comment
+    return to_string_literal(comment)
+
+
+"""
+Provides a common interface for all commands that accept a comment option (e.g. when creating a new object).
+Parses the input string into a string literal.
+"""
+CommentOption = OverrideableOption(
+    None, "--comment", help="Comment for the object.", callback=_comment_callback
+)

snowflake/cli/plugins/object/manager.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 textwrap import dedent
+from typing import Any, Dict, Optional, Tuple, Union
+
+from click import ClickException
+from snowflake.cli.api.constants import (
+    OBJECT_TO_NAMES,
+    ObjectNames,
+)
+from snowflake.cli.api.identifiers import FQN
+from snowflake.cli.api.rest_api import RestApi
+from snowflake.cli.api.sql_execution import SqlExecutionMixin
+from snowflake.connector import ProgrammingError
+from snowflake.connector.cursor import SnowflakeCursor
+from snowflake.connector.errors import BadRequest
+
+
+def _get_object_names(object_type: str) -> ObjectNames:
+    object_type = object_type.lower()
+    if object_type.lower() not in OBJECT_TO_NAMES:
+        raise ClickException(f"Object of type {object_type} is not supported.")
+    return OBJECT_TO_NAMES[object_type]
+
+
+class ObjectManager(SqlExecutionMixin):
+    def show(
+        self,
+        *,
+        object_type: str,
+        like: Optional[str] = None,
+        scope: Union[Tuple[str, str], Tuple[None, None]] = (None, None),
+        **kwargs,
+    ) -> SnowflakeCursor:
+        object_name = _get_object_names(object_type).sf_plural_name
+        query = f"show {object_name}"
+        if like:
+            query += f" like '{like}'"
+        if scope[0] is not None:
+            query += f" in {scope[0].replace('-', ' ')} {scope[1]}"
+        return self._execute_query(query, **kwargs)
+
+    def drop(self, *, object_type: str, fqn: FQN) -> SnowflakeCursor:
+        object_name = _get_object_names(object_type).sf_name
+        return self._execute_query(f"drop {object_name} {fqn.sql_identifier}")
+
+    def describe(self, *, object_type: str, fqn: FQN):
+        # Image repository is the only supported object that does not have a DESCRIBE command.
+        if object_type == "image-repository":
+            raise ClickException(
+                f"Describe is currently not supported for object of type image-repository"
+            )
+        object_name = _get_object_names(object_type).sf_name
+        return self._execute_query(f"describe {object_name} {fqn.sql_identifier}")
+
+    def object_exists(self, *, object_type: str, fqn: FQN):
+        try:
+            self.describe(object_type=object_type, fqn=fqn)
+            return True
+        except ProgrammingError:
+            return False
+
+    def create(self, object_type: str, object_data: Dict[str, Any]) -> str:
+        rest = RestApi(self._conn)
+        url = rest.determine_url_for_create_query(object_type=object_type)
+
+        try:
+            response = rest.send_rest_request(url=url, method="post", data=object_data)
+            # workaround as SnowflakeRestful class ignores some errors, dropping their info and returns {} instead.
+            if not response:
+                raise ClickException(
+                    dedent(
+                        """                An unexpected error occurred while creating the object. Try again with --debug for more info.
+                Most probable reasons:
+                  * object you are trying to create already exists
+                  * role you are using do not have permissions to create this object"""
+                    )
+                )
+            return response["status"]
+        except BadRequest:
+            raise ClickException(
+                "Incorrect object definition (arguments misspelled or malformatted)."
+            )

snowflake/cli/plugins/object/plugin_spec.py

@@ -0,0 +1,30 @@
+# 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 (
+    SNOWCLI_ROOT_COMMAND_PATH,
+    CommandSpec,
+    CommandType,
+    plugin_hook_impl,
+)
+from snowflake.cli.plugins.object import commands
+
+
+@plugin_hook_impl
+def command_spec():
+    return CommandSpec(
+        parent_command_path=SNOWCLI_ROOT_COMMAND_PATH,
+        command_type=CommandType.COMMAND_GROUP,
+        typer_instance=commands.app.create_instance(),
+    )

snowflake/cli/plugins/object_stage_deprecated/__init__.py

@@ -0,0 +1,15 @@
+# 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.
+
+# TODO 3.0: remove this file