snowflake-cli 3.4.1__py3-none-any.whl → 3.6.0__py3-none-any.whl

snowflake/cli/_plugins/plugin/commands.py

@@ -0,0 +1,79 @@
+# Copyright (c) 2024 Snowflake Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import logging
+from typing import Dict, List
+
+import typer
+from snowflake.cli._plugins.plugin.manager import PluginManager
+from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
+from snowflake.cli.api.output.types import (
+    CollectionResult,
+    CommandResult,
+    MessageResult,
+)
+
+log = logging.getLogger(__name__)
+
+app = SnowTyperFactory(
+    name="plugin",
+    help="Plugin management commands.",
+    is_hidden=lambda: True,
+)
+
+
+@app.command(name="enable", requires_connection=False)
+def enable(
+    plugin_name: str = typer.Argument(None, help="Plugin name"),
+    **options,
+) -> CommandResult:
+    """Enables a plugin with a given name."""
+    plugin_manager = PluginManager()
+    plugin_manager.assert_plugin_is_installed(plugin_name)
+    plugin_manager.enable_plugin(plugin_name)
+
+    return MessageResult(f"Plugin {plugin_name} successfully enabled.")
+
+
+@app.command(name="disable", requires_connection=False)
+def disable(
+    plugin_name: str = typer.Argument(None, help="Plugin name"),
+    **options,
+) -> CommandResult:
+    """Disables a plugin with a given name."""
+    plugin_manager = PluginManager()
+    plugin_manager.assert_plugin_is_installed(plugin_name)
+    plugin_manager.disable_plugin(plugin_name)
+
+    return MessageResult(f"Plugin {plugin_name} successfully disabled.")
+
+
+@app.command(name="list", requires_connection=False)
+def list_(
+    **options,
+) -> CommandResult:
+    """Lists all installed plugins."""
+    plugin_manager = PluginManager()
+    result: List[Dict[str, str]] = []
+    for plugin_name in sorted(plugin_manager.get_installed_plugin_names()):
+        result.append(
+            {
+                "plugin name": plugin_name,
+                "enabled": plugin_manager.is_plugin_enabled(plugin_name),
+            }
+        )
+
+    return CollectionResult(result)

snowflake/cli/_plugins/plugin/manager.py

@@ -0,0 +1,74 @@
+# 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 importlib
+from typing import List
+
+from snowflake.cli.api.config import (
+    PLUGIN_ENABLED_KEY,
+    PLUGINS_SECTION_PATH,
+    config_section_exists,
+    get_config_section,
+    set_config_value,
+)
+from snowflake.cli.api.exceptions import PluginNotInstalledError
+from snowflake.cli.api.plugins.command import SNOWCLI_COMMAND_PLUGIN_NAMESPACE
+from snowflake.cli.api.plugins.plugin_config import PluginConfigProvider
+
+
+class PluginManager:
+    """
+    Manage installation of plugins.
+    """
+
+    def enable_plugin(self, plugin_name: str):
+        self._change_plugin_enabled(plugin_name, enable=True)
+
+    def disable_plugin(self, plugin_name: str):
+        self._change_plugin_enabled(plugin_name, enable=False)
+
+    @staticmethod
+    def _change_plugin_enabled(plugin_name: str, enable: bool):
+        plugin_config_path = PLUGINS_SECTION_PATH + [plugin_name]
+
+        if config_section_exists(*plugin_config_path):
+            plugin_config = get_config_section(*plugin_config_path)
+        elif enable:
+            plugin_config = {}
+        else:
+            # do not add a new plugin config if user wants to disable a plugin which is not configured
+            # (plugins are disabled by default)
+            return
+
+        plugin_config[PLUGIN_ENABLED_KEY] = enable
+        set_config_value(path=plugin_config_path, value=plugin_config)
+
+    @staticmethod
+    def is_plugin_enabled(plugin_name: str) -> bool:
+        return PluginConfigProvider.get_config(plugin_name).is_plugin_enabled
+
+    def assert_plugin_is_installed(self, plugin_name: str):
+        installed_plugins = self.get_installed_plugin_names()
+        if plugin_name not in installed_plugins:
+            raise PluginNotInstalledError(
+                plugin_name, installed_plugins=sorted(installed_plugins)
+            )
+
+    @staticmethod
+    def get_installed_plugin_names() -> List[str]:
+        return [
+            entry_point.name
+            for entry_point in importlib.metadata.entry_points(
+                group=SNOWCLI_COMMAND_PLUGIN_NAMESPACE
+            )
+        ]

snowflake/cli/_plugins/plugin/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._plugins.plugin import commands
+from snowflake.cli.api.plugins.command import (
+    SNOWCLI_ROOT_COMMAND_PATH,
+    CommandSpec,
+    CommandType,
+    plugin_hook_impl,
+)
+
+
+@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/project/commands.py

@@ -0,0 +1,173 @@
+# 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 List, Optional
+
+import typer
+from snowflake.cli._plugins.object.command_aliases import add_object_command_aliases
+from snowflake.cli._plugins.object.commands import scope_option
+from snowflake.cli._plugins.project.feature_flags import FeatureFlag
+from snowflake.cli._plugins.project.manager import ProjectManager
+from snowflake.cli._plugins.project.project_entity_model import (
+    ProjectEntityModel,
+)
+from snowflake.cli._plugins.stage.manager import StageManager
+from snowflake.cli.api.artifacts.upload import put_files
+from snowflake.cli.api.cli_global_context import get_cli_context
+from snowflake.cli.api.commands.decorators import with_project_definition
+from snowflake.cli.api.commands.flags import (
+    entity_argument,
+    identifier_argument,
+    like_option,
+    variables_option,
+)
+from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
+from snowflake.cli.api.commands.utils import get_entity_for_operation
+from snowflake.cli.api.console.console import cli_console
+from snowflake.cli.api.constants import ObjectType
+from snowflake.cli.api.identifiers import FQN
+from snowflake.cli.api.output.types import MessageResult, SingleQueryResult
+from snowflake.cli.api.project.project_paths import ProjectPaths
+
+app = SnowTyperFactory(
+    name="project",
+    help="Manages projects in Snowflake.",
+    is_hidden=FeatureFlag.ENABLE_SNOWFLAKE_PROJECTS.is_disabled,
+)
+
+project_identifier = identifier_argument(sf_object="project", example="MY_PROJECT")
+version_flag = typer.Option(
+    ..., "--version", help="Version of the project to use.", show_default=False
+)
+variables_flag = variables_option(
+    'Variables for the execution context; for example: `-D "<key>=<value>"`.'
+)
+
+
+add_object_command_aliases(
+    app=app,
+    object_type=ObjectType.PROJECT,
+    name_argument=project_identifier,
+    like_option=like_option(
+        help_example='`list --like "my%"` lists all projects that begin with “my”'
+    ),
+    scope_option=scope_option(help_example="`list --in database my_db`"),
+    ommit_commands=["drop", "create", "describe"],
+)
+
+
+@app.command(requires_connection=True)
+def execute(
+    identifier: FQN = project_identifier,
+    version: str = version_flag,
+    variables: Optional[List[str]] = variables_flag,
+    **options,
+):
+    """
+    Executes a project.
+    """
+    result = ProjectManager().execute(
+        project_name=identifier, version=version, variables=variables
+    )
+    return SingleQueryResult(result)
+
+
+@app.command(requires_connection=True)
+def dry_run(
+    identifier: FQN = project_identifier,
+    version: str = version_flag,
+    variables: Optional[List[str]] = variables_flag,
+    **options,
+):
+    """
+    Validates a project.
+    """
+    result = ProjectManager().execute(
+        project_name=identifier, version=version, dry_run=True, variables=variables
+    )
+    return SingleQueryResult(result)
+
+
+@app.command(requires_connection=True)
+@with_project_definition()
+def create_version(
+    entity_id: str = entity_argument("project"),
+    **options,
+):
+    """
+    Upload local files and create a new version of a project using those files. If the stage does not exist, it will be created.
+    """
+    cli_context = get_cli_context()
+    project: ProjectEntityModel = get_entity_for_operation(
+        cli_context=cli_context,
+        entity_id=entity_id,
+        project_definition=cli_context.project_definition,
+        entity_type="project",
+    )
+
+    # Sync state
+    with cli_console.phase("Syncing project state"):
+        stage_name = FQN.from_stage(project.stage)
+        sm = StageManager()
+
+        cli_console.step(f"Creating stage {stage_name}")
+        sm.create(fqn=stage_name)
+
+        put_files(
+            project_paths=ProjectPaths(project_root=cli_context.project_root),
+            stage_root=project.stage,
+            artifacts=project.artifacts,
+        )
+
+    # Create project and version
+    with cli_console.phase("Creating project and version"):
+        pm = ProjectManager()
+        cli_console.step(f"Creating project {project.fqn}")
+        pm.create(project_name=project.fqn)
+
+        cli_console.step(f"Creating version from stage {stage_name}")
+        pm.create_version(project_name=project.fqn, stage_name=stage_name)
+    return MessageResult(f"Project {project.fqn} deployed.")
+
+
+@app.command(requires_connection=True)
+@with_project_definition()
+def add_version(
+    entity_id: str = entity_argument("project"),
+    _from: str = typer.Option(
+        ...,
+        "--from",
+        help="Source stage to create the version from.",
+        show_default=False,
+    ),
+    alias: str
+    | None = typer.Option(
+        None, "--alias", help="Alias for the version.", show_default=False
+    ),
+    comment: str
+    | None = typer.Option(
+        None, "--comment", help="Version comment.", show_default=False
+    ),
+    **options,
+):
+    """Adds a new version to a project using existing sources from provided stage path."""
+
+    pm = ProjectManager()
+    pm.add_version(
+        project_name=entity_id,
+        from_stage=_from,
+        alias=alias,
+        comment=comment,
+    )
+    return MessageResult("Version added.")

snowflake/cli/{_app/api_impl/plugin/__init__.py → _plugins/project/feature_flags.py}

@@ -11,3 +11,12 @@
 # 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 unique
+
+from snowflake.cli.api.feature_flags import BooleanFlag, FeatureFlagMixin
+
+
+@unique
+class FeatureFlag(FeatureFlagMixin):
+    ENABLE_SNOWFLAKE_PROJECTS = BooleanFlag("ENABLE_SNOWFLAKE_PROJECTS", False)

snowflake/cli/_plugins/project/manager.py

@@ -0,0 +1,76 @@
+# 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 textwrap import dedent
+from typing import List
+
+from snowflake.cli._plugins.stage.manager import StageManager
+from snowflake.cli.api.commands.utils import parse_key_value_variables
+from snowflake.cli.api.identifiers import FQN
+from snowflake.cli.api.sql_execution import SqlExecutionMixin
+from snowflake.cli.api.stage_path import StagePath
+
+
+class ProjectManager(SqlExecutionMixin):
+    def execute(
+        self,
+        project_name: FQN,
+        version: str | None = None,
+        variables: List[str] | None = None,
+        dry_run: bool = False,
+    ):
+        query = f"EXECUTE PROJECT {project_name.sql_identifier}"
+        if variables:
+            query += StageManager.parse_execute_variables(
+                parse_key_value_variables(variables)
+            )
+        if version:
+            query += f" WITH VERSION {version}"
+        if dry_run:
+            query += " DRY_RUN=TRUE"
+        return self.execute_query(query=query)
+
+    def create(
+        self,
+        project_name: FQN,
+    ) -> str:
+        queries = dedent(f"CREATE PROJECT IF NOT EXISTS {project_name.sql_identifier}")
+        return self.execute_query(query=queries)
+
+    def create_version(self, project_name: FQN, stage_name: FQN):
+        return self.add_version(
+            project_name=project_name,
+            from_stage=StagePath.from_stage_str(stage_name).absolute_path(
+                at_prefix=True
+            ),
+        )
+
+    def add_version(
+        self,
+        project_name: str | FQN,
+        from_stage: str,
+        alias: str | None = None,
+        comment: str | None = None,
+    ):
+        project_name = (
+            project_name
+            if isinstance(project_name, FQN)
+            else FQN.from_string(project_name)
+        )
+        query = f"ALTER PROJECT {project_name.identifier} ADD VERSION"
+        if alias:
+            query += f" IF NOT EXIST {alias}"
+        query += f" FROM {from_stage}"
+        if comment:
+            query += f" COMMENT = '{comment}'"
+        return self.execute_query(query=query)

snowflake/cli/_plugins/project/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._plugins.project import commands
+from snowflake.cli.api.plugins.command import (
+    SNOWCLI_ROOT_COMMAND_PATH,
+    CommandSpec,
+    CommandType,
+    plugin_hook_impl,
+)
+
+
+@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/project/project_entity_model.py

@@ -0,0 +1,40 @@
+# 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 Literal, Optional, TypeVar
+
+from pydantic import Field
+from snowflake.cli.api.entities.common import EntityBase, attach_spans_to_entity_actions
+from snowflake.cli.api.project.schemas.entities.common import (
+    EntityModelBaseWithArtifacts,
+)
+from snowflake.cli.api.project.schemas.updatable_model import (
+    DiscriminatorField,
+)
+
+T = TypeVar("T")
+
+
+class ProjectEntityModel(EntityModelBaseWithArtifacts):
+    type: Literal["project"] = DiscriminatorField()  # noqa: A003
+    stage: Optional[str] = Field(
+        title="Stage in which the project artifacts will be stored", default=None
+    )
+    main_file: Optional[str] = Field(title="Path to the main file of the project")
+
+
+@attach_spans_to_entity_actions(entity_name="project")
+class ProjectEntity(EntityBase[ProjectEntityModel]):
+    """Placeholder for project entity"""

snowflake/cli/_plugins/snowpark/commands.py

@@ -129,7 +129,8 @@ LikeOption = like_option(
 @with_project_definition()
 def deploy(
     replace: bool = ReplaceOption(
-        help="Replaces procedure or function if there were changes in the definition."
+        help="Replaces procedure or function if there were changes in the definition. It only uploads new and "
+        "overwrites existing files, but does not remove any files already on the stage."
     ),
     force_replace: bool = ForceReplaceOption(),
     **options,