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

snowflake/cli/__about__.py

@@ -14,4 +14,4 @@
 
 from __future__ import annotations
 
-VERSION = "3.4.1"
+VERSION = "3.5.0"

snowflake/cli/_app/cli_app.py

@@ -25,9 +25,6 @@ import click
 import typer
 from click import Context as ClickContext
 from snowflake.cli import __about__
-from snowflake.cli._app.api_impl.plugin.plugin_config_provider_impl import (
-    PluginConfigProviderImpl,
-)
 from snowflake.cli._app.commands_registration.commands_registration_with_callbacks import (
     CommandsRegistrationWithCallbacks,
 )
@@ -42,7 +39,6 @@ from snowflake.cli._app.version_check import (
     get_new_version_msg,
     show_new_version_banner_callback,
 )
-from snowflake.cli.api import Api, api_provider
 from snowflake.cli.api.config import config_init, get_feature_flags_section
 from snowflake.cli.api.output.formats import OutputFormat
 from snowflake.cli.api.output.types import CollectionResult
@@ -63,12 +59,7 @@ def _do_not_execute_on_completion(callback):
 
 class CliAppFactory:
     def __init__(self):
-        api = Api(plugin_config_provider=PluginConfigProviderImpl())
-        self._api = api
-        self._commands_registration = CommandsRegistrationWithCallbacks(
-            api.plugin_config_provider
-        )
-        api_provider.register_api(api)
+        self._commands_registration = CommandsRegistrationWithCallbacks()
         self._app: Optional[SnowCliMainTyper] = None
         self._click_context: Optional[ClickContext] = None
 

snowflake/cli/_app/commands_registration/builtin_plugins.py

@@ -20,6 +20,8 @@ from snowflake.cli._plugins.init import plugin_spec as init_plugin_spec
 from snowflake.cli._plugins.nativeapp import plugin_spec as nativeapp_plugin_spec
 from snowflake.cli._plugins.notebook import plugin_spec as notebook_plugin_spec
 from snowflake.cli._plugins.object import plugin_spec as object_plugin_spec
+from snowflake.cli._plugins.plugin import plugin_spec as plugin_plugin_spec
+from snowflake.cli._plugins.project import plugin_spec as project_plugin_spec
 from snowflake.cli._plugins.snowpark import plugin_spec as snowpark_plugin_spec
 from snowflake.cli._plugins.spcs import plugin_spec as spcs_plugin_spec
 from snowflake.cli._plugins.sql import plugin_spec as sql_plugin_spec
@@ -34,8 +36,9 @@ def get_builtin_plugin_name_to_plugin_spec():
         "connection": connection_plugin_spec,
         "helpers": migrate_plugin_spec,
         "spcs": spcs_plugin_spec,
-        "nativeapp": nativeapp_plugin_spec,
+        "app": nativeapp_plugin_spec,
         "object": object_plugin_spec,
+        "project": project_plugin_spec,
         "snowpark": snowpark_plugin_spec,
         "stage": stage_plugin_spec,
         "sql": sql_plugin_spec,
@@ -45,6 +48,7 @@ def get_builtin_plugin_name_to_plugin_spec():
         "cortex": cortex_plugin_spec,
         "init": init_plugin_spec,
         "workspace": workspace_plugin_spec,
+        "plugin": plugin_plugin_spec,
     }
 
     return plugin_specs

snowflake/cli/_app/commands_registration/command_plugins_loader.py

@@ -47,7 +47,9 @@ class CommandPluginsLoader:
         self._loaded_command_paths: Dict[CommandPath, LoadedCommandPlugin] = {}
 
     def register_builtin_plugins(self) -> None:
-        for plugin_name, plugin in get_builtin_plugin_name_to_plugin_spec().items():
+        for plugin_name, plugin in sorted(
+            get_builtin_plugin_name_to_plugin_spec().items()
+        ):
             try:
                 self._plugin_manager.register(plugin=plugin, name=plugin_name)
             except Exception as ex:

snowflake/cli/_app/commands_registration/commands_registration_with_callbacks.py

@@ -33,8 +33,8 @@ class CommandRegistrationConfig:
 
 
 class CommandsRegistrationWithCallbacks:
-    def __init__(self, plugin_config_provider: PluginConfigProvider):
-        self._plugin_config_provider = plugin_config_provider
+    def __init__(self):
+        self._plugin_config_manager = PluginConfigProvider()
         self._callbacks_after_registration: List[Callable[[], None]] = []
         self._commands_registration_config: CommandRegistrationConfig = (
             CommandRegistrationConfig(enable_external_command_plugins=True)
@@ -58,7 +58,7 @@ class CommandsRegistrationWithCallbacks:
 
     def _register_builtin_and_enabled_external_plugin_commands(self):
         enabled_external_plugins = (
-            self._plugin_config_provider.get_enabled_plugin_names()
+            self._plugin_config_manager.get_enabled_plugin_names()
         )
         loaded_command_plugins = load_builtin_and_external_command_plugins(
             enabled_external_plugins

snowflake/cli/_app/printing.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import json
 import sys
-from datetime import datetime
+from datetime import date, datetime
 from json import JSONEncoder
 from pathlib import Path
 from textwrap import indent
@@ -57,7 +57,7 @@ class CustomJSONEncoder(JSONEncoder):
             return o.result
         if isinstance(o, (CollectionResult, MultipleResults)):
             return list(o.result)
-        if isinstance(o, datetime):
+        if isinstance(o, (date, datetime)):
             return o.isoformat()
         if isinstance(o, Path):
             return str(o)

snowflake/cli/_plugins/connection/commands.py

@@ -287,9 +287,7 @@ def add(
         ConnectionConfig(**connection_options),
     )
     if set_as_default:
-        set_config_value(
-            section=None, key="default_connection_name", value=connection_name
-        )
+        set_config_value(path=["default_connection_name"], value=connection_name)
 
     return MessageResult(
         f"Wrote new connection {connection_name} to {connections_file}"
@@ -357,7 +355,7 @@ def set_default(
 ):
     """Changes default connection to provided value."""
     get_connection_dict(connection_name=name)
-    set_config_value(section=None, key="default_connection_name", value=name)
+    set_config_value(path=["default_connection_name"], value=name)
     return MessageResult(f"Default connection set to: {name}")
 
 

snowflake/cli/_plugins/helpers/commands.py

@@ -49,7 +49,7 @@ def v1_to_v2(
     accept_templates: bool = typer.Option(
         False, "-t", "--accept-templates", help="Allows the migration of templates."
     ),
-    migrate_local_yml: (bool | None) = typer.Option(
+    migrate_local_yml: Optional[bool] = typer.Option(
         None,
         "-l",
         "--migrate-local-overrides/--no-migrate-local-overrides",
@@ -234,7 +234,7 @@ def _validate_imported_default_connection_name(
 
 
 def _convert_connection_from_snowsql_config_section(
-    snowsql_connection: list[tuple[str, Any]]
+    snowsql_connection: list[tuple[str, Any]],
 ) -> dict[str, Any]:
     from ast import literal_eval
 
@@ -290,7 +290,6 @@ def _validate_and_save_connections_imported_from_snowsql(
             f"Setting [{default_cli_connection_name}] connection as Snowflake CLI's default connection."
         )
         set_config_value(
-            section=None,
-            key="default_connection_name",
+            path=["default_connection_name"],
             value=default_cli_connection_name,
         )

snowflake/cli/_plugins/notebook/commands.py

@@ -21,9 +21,7 @@ from snowflake.cli._plugins.notebook.notebook_entity_model import NotebookEntity
 from snowflake.cli._plugins.notebook.types import NotebookStagePath
 from snowflake.cli._plugins.workspace.manager import WorkspaceManager
 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.decorators import with_project_definition
 from snowflake.cli.api.commands.flags import (
     ReplaceOption,
     entity_argument,
@@ -107,7 +105,8 @@ def create(
 def deploy(
     entity_id: str = entity_argument("notebook"),
     replace: bool = ReplaceOption(
-        help="Replace notebook object if it already exists.",
+        help="Replace notebook object if it already exists. It only uploads new and overwrites existing files, "
+        "but does not remove any files already on the stage.",
     ),
     **options,
 ) -> CommandResult:

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,157 @@
+# 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.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,
+    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.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>"`.'
+)
+
+
+@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(),
+    )