snowflake-cli-labs 2.8.1__py3-none-any.whl → 3.0.0__py3-none-any.whl

snowflake/cli/_plugins/nativeapp/run_processor.py

@@ -0,0 +1,184 @@
+# 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 Optional
+
+import typer
+from snowflake.cli._plugins.nativeapp.artifacts import BundleMap
+from snowflake.cli._plugins.nativeapp.entities.application import ApplicationEntity
+from snowflake.cli._plugins.nativeapp.entities.application_package import (
+    ApplicationPackageEntity,
+)
+from snowflake.cli._plugins.nativeapp.manager import (
+    NativeAppCommandProcessor,
+    NativeAppManager,
+)
+from snowflake.cli._plugins.nativeapp.policy import PolicyBase
+from snowflake.cli._plugins.nativeapp.same_account_install_method import (
+    SameAccountInstallMethod,
+)
+from snowflake.cli.api.console import cli_console as cc
+from snowflake.cli.api.entities.common import get_sql_executor
+from snowflake.cli.api.entities.utils import (
+    generic_sql_error_handler,
+)
+from snowflake.cli.api.errno import (
+    APPLICATION_NO_LONGER_AVAILABLE,
+    APPLICATION_OWNS_EXTERNAL_OBJECTS,
+)
+from snowflake.cli.api.project.schemas.v1.native_app.native_app import NativeApp
+from snowflake.connector import ProgrammingError
+from snowflake.connector.cursor import SnowflakeCursor
+
+
+class NativeAppRunProcessor(NativeAppManager, NativeAppCommandProcessor):
+    def __init__(self, project_definition: NativeApp, project_root: Path):
+        super().__init__(project_definition, project_root)
+
+    def get_all_existing_versions(self) -> SnowflakeCursor:
+        return ApplicationPackageEntity.version_list(
+            self.package_name, self.package_role
+        )
+
+    def get_existing_version_info(self, version: str) -> Optional[dict]:
+        return ApplicationPackageEntity.get_existing_version_info(
+            version=version,
+            package_name=self.package_name,
+            package_role=self.package_role,
+        )
+
+    def drop_application_before_upgrade(
+        self, policy: PolicyBase, is_interactive: bool, cascade: bool = False
+    ):
+        """
+        This method will attempt to drop an application object if a previous upgrade fails.
+        """
+        if cascade:
+            try:
+                if application_objects := self.get_objects_owned_by_application():
+                    application_objects_str = self._application_objects_to_str(
+                        application_objects
+                    )
+                    cc.message(
+                        f"The following objects are owned by application {self.app_name} and need to be dropped:\n{application_objects_str}"
+                    )
+            except ProgrammingError as err:
+                if err.errno != APPLICATION_NO_LONGER_AVAILABLE:
+                    generic_sql_error_handler(err)
+                cc.warning(
+                    "The application owns other objects but they could not be determined."
+                )
+            user_prompt = "Do you want the Snowflake CLI to drop these objects, then drop the existing application object and recreate it?"
+        else:
+            user_prompt = "Do you want the Snowflake CLI to drop the existing application object and recreate it?"
+
+        if not policy.should_proceed(user_prompt):
+            if is_interactive:
+                cc.message("Not upgrading the application object.")
+                raise typer.Exit(0)
+            else:
+                cc.message(
+                    "Cannot upgrade the application object non-interactively without --force."
+                )
+                raise typer.Exit(1)
+        try:
+            cascade_msg = " (cascade)" if cascade else ""
+            cc.step(f"Dropping application object {self.app_name}{cascade_msg}.")
+            cascade_sql = " cascade" if cascade else ""
+            sql_executor = get_sql_executor()
+            sql_executor.execute_query(f"drop application {self.app_name}{cascade_sql}")
+        except ProgrammingError as err:
+            if err.errno == APPLICATION_OWNS_EXTERNAL_OBJECTS and not cascade:
+                # We need to cascade the deletion, let's try again (only if we didn't try with cascade already)
+                return self.drop_application_before_upgrade(
+                    policy, is_interactive, cascade=True
+                )
+            else:
+                generic_sql_error_handler(err)
+
+    def create_or_upgrade_app(
+        self,
+        policy: PolicyBase,
+        install_method: SameAccountInstallMethod,
+        is_interactive: bool = False,
+    ):
+        def drop_app():
+            self.drop_application_before_upgrade(policy, is_interactive)
+
+        return ApplicationEntity.create_or_upgrade_app(
+            console=cc,
+            project_root=self.project_root,
+            package_name=self.package_name,
+            package_role=self.package_role,
+            app_name=self.app_name,
+            app_role=self.app_role,
+            app_warehouse=self.application_warehouse,
+            stage_schema=self.stage_schema,
+            stage_fqn=self.stage_fqn,
+            debug_mode=self.debug_mode,
+            policy=policy,
+            install_method=install_method,
+            is_interactive=is_interactive,
+            post_deploy_hooks=self.app_post_deploy_hooks,
+            drop_application_before_upgrade=drop_app,
+        )
+
+    def process(
+        self,
+        bundle_map: BundleMap,
+        policy: PolicyBase,
+        version: Optional[str] = None,
+        patch: Optional[int] = None,
+        from_release_directive: bool = False,
+        is_interactive: bool = False,
+        validate: bool = True,
+        *args,
+        **kwargs,
+    ):
+        def deploy_package():
+            self.deploy(
+                bundle_map=bundle_map,
+                prune=True,
+                recursive=True,
+                validate=validate,
+                policy=policy,
+            )
+
+        def drop_app():
+            self.drop_application_before_upgrade(policy, is_interactive)
+
+        ApplicationEntity.deploy(
+            console=cc,
+            project_root=self.project_root,
+            app_name=self.app_name,
+            app_role=self.app_role,
+            app_warehouse=self.application_warehouse,
+            package_name=self.package_name,
+            package_role=self.package_role,
+            stage_schema=self.stage_schema,
+            stage_fqn=self.stage_fqn,
+            debug_mode=self.debug_mode,
+            validate=validate,
+            from_release_directive=from_release_directive,
+            is_interactive=is_interactive,
+            policy=policy,
+            version=version,
+            patch=patch,
+            post_deploy_hooks=self.app_post_deploy_hooks,
+            deploy_package=deploy_package,
+            drop_application_before_upgrade=drop_app,
+        )

snowflake/cli/_plugins/nativeapp/same_account_install_method.py

@@ -0,0 +1,70 @@
+from typing import Optional
+
+from snowflake.cli._plugins.nativeapp.constants import (
+    ALLOWED_SPECIAL_COMMENTS,
+    COMMENT_COL,
+)
+from snowflake.cli._plugins.nativeapp.exceptions import (
+    ApplicationCreatedExternallyError,
+)
+
+# from snowflake.cli._plugins.nativeapp.project_model import NativeAppProjectModel
+from snowflake.cli._plugins.stage.manager import StageManager
+
+
+class SameAccountInstallMethod:
+    _requires_created_by_cli: bool
+    _from_release_directive: bool
+    version: Optional[str]
+    patch: Optional[int]
+
+    def __init__(
+        self,
+        requires_created_by_cli: bool,
+        version: Optional[str] = None,
+        patch: Optional[int] = None,
+        from_release_directive: bool = False,
+    ):
+        self._requires_created_by_cli = requires_created_by_cli
+        self.version = version
+        self.patch = patch
+        self._from_release_directive = from_release_directive
+
+    @classmethod
+    def unversioned_dev(cls):
+        """aka. stage dev aka loose files"""
+        return cls(True)
+
+    @classmethod
+    def versioned_dev(cls, version: str, patch: Optional[int] = None):
+        return cls(False, version, patch)
+
+    @classmethod
+    def release_directive(cls):
+        return cls(False, from_release_directive=True)
+
+    @property
+    def is_dev_mode(self) -> bool:
+        return not self._from_release_directive
+
+    def using_clause(
+        self,
+        stage_fqn: str,
+    ) -> str:
+        if self._from_release_directive:
+            return ""
+
+        if self.version:
+            patch_clause = f"patch {self.patch}" if self.patch else ""
+            return f"using version {self.version} {patch_clause}"
+
+        stage_name = StageManager.quote_stage_name(stage_fqn)
+        return f"using {stage_name}"
+
+    def ensure_app_usable(self, app_name: str, app_role: str, show_app_row: dict):
+        """Raise an exception if we cannot proceed with install given the pre-existing application object"""
+
+        if self._requires_created_by_cli:
+            if show_app_row[COMMENT_COL] not in ALLOWED_SPECIAL_COMMENTS:
+                # this application object was not created by this tooling
+                raise ApplicationCreatedExternallyError(app_name)

snowflake/cli/_plugins/nativeapp/teardown_processor.py

@@ -0,0 +1,70 @@
+# 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 Dict, Optional
+
+from snowflake.cli._plugins.nativeapp.entities.application import ApplicationEntity
+from snowflake.cli._plugins.nativeapp.entities.application_package import (
+    ApplicationPackageEntity,
+)
+from snowflake.cli._plugins.nativeapp.manager import (
+    NativeAppCommandProcessor,
+    NativeAppManager,
+)
+from snowflake.cli.api.console import cli_console as cc
+
+
+class NativeAppTeardownProcessor(NativeAppManager, NativeAppCommandProcessor):
+    def __init__(self, project_definition: Dict, project_root: Path):
+        super().__init__(project_definition, project_root)
+
+    def drop_application(
+        self, auto_yes: bool, interactive: bool = False, cascade: Optional[bool] = None
+    ):
+        return ApplicationEntity.drop(
+            console=cc,
+            app_name=self.app_name,
+            app_role=self.app_role,
+            auto_yes=auto_yes,
+            interactive=interactive,
+            cascade=cascade,
+        )
+
+    def drop_package(self, auto_yes: bool):
+        return ApplicationPackageEntity.drop(
+            console=cc,
+            package_name=self.package_name,
+            package_role=self.package_role,
+            force_drop=auto_yes,
+        )
+
+    def process(
+        self,
+        interactive: bool,
+        force_drop: bool = False,
+        cascade: Optional[bool] = None,
+        *args,
+        **kwargs,
+    ):
+
+        # Drop the application object
+        self.drop_application(
+            auto_yes=force_drop, interactive=interactive, cascade=cascade
+        )
+
+        # Drop the application package
+        self.drop_package(auto_yes=force_drop)

snowflake/cli/_plugins/nativeapp/v2_conversions/v2_to_v1_decorator.py

@@ -0,0 +1,262 @@
+# 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 inspect
+from functools import wraps
+from typing import Any, Dict, Optional, Type, TypeVar, Union
+
+import typer
+from click import ClickException
+from snowflake.cli._plugins.nativeapp.entities.application import ApplicationEntityModel
+from snowflake.cli._plugins.nativeapp.entities.application_package import (
+    ApplicationPackageEntityModel,
+)
+from snowflake.cli.api.cli_global_context import (
+    get_cli_context,
+    get_cli_context_manager,
+)
+from snowflake.cli.api.commands.decorators import _options_decorator_factory
+from snowflake.cli.api.project.schemas.entities.common import EntityModelBase
+from snowflake.cli.api.project.schemas.project_definition import (
+    DefinitionV11,
+    DefinitionV20,
+)
+from snowflake.cli.api.project.schemas.v1.native_app.path_mapping import PathMapping
+from snowflake.cli.api.utils.definition_rendering import render_definition_template
+
+
+def _convert_v2_artifact_to_v1_dict(
+    v2_artifact: Union[PathMapping, str]
+) -> Union[Dict, str]:
+    if isinstance(v2_artifact, PathMapping):
+        return {
+            "src": v2_artifact.src,
+            "dest": v2_artifact.dest,
+            "processors": v2_artifact.processors,
+        }
+    return v2_artifact
+
+
+def _pdf_v2_to_v1(
+    v2_definition: DefinitionV20,
+    package_entity_id: str = "",
+    app_entity_id: str = "",
+    app_required: bool = False,
+) -> DefinitionV11:
+    pdfv1: Dict[str, Any] = {"definition_version": "1.1", "native_app": {}}
+
+    # Determine the application entity to convert, there can be zero or one
+    app_definition = find_entity(
+        v2_definition,
+        ApplicationEntityModel,
+        app_entity_id,
+        disambiguation_option="--app-entity-id",
+        required=app_required,
+    )
+
+    # Infer or verify the package if we have an app entity to convert
+    if app_definition:
+        target_package = app_definition.from_.target
+        if package_entity_id:
+            # If the user specified a package entity ID,
+            # check that the app entity targets the user-specified package entity
+            # if the app entity is used by the command being run
+            if target_package != package_entity_id and app_required:
+                raise ClickException(
+                    f"The application entity {app_definition.entity_id} does not "
+                    f"target the application package entity {package_entity_id}. Either"
+                    f"use --package-entity-id {target_package} to target the correct package entity, "
+                    f"or omit the --package-entity-id flag to automatically use the package entity "
+                    f"that the application entity targets."
+                )
+        elif target_package in v2_definition.get_entities_by_type(
+            ApplicationPackageEntityModel.get_type()
+        ):
+            # If the user didn't target a specific package entity, use the one the app entity targets
+            package_entity_id = target_package
+
+    # Determine the package entity to convert, there must be one
+    app_package_definition = find_entity(
+        v2_definition,
+        ApplicationPackageEntityModel,
+        package_entity_id,
+        disambiguation_option="--package-entity-id",
+        required=True,
+    )
+    assert app_package_definition is not None  # satisfy mypy
+
+    # NativeApp
+    if app_definition and app_definition.fqn.identifier:
+        pdfv1["native_app"]["name"] = app_definition.fqn.identifier
+    else:
+        pdfv1["native_app"]["name"] = app_package_definition.fqn.identifier.split(
+            "_pkg_"
+        )[0]
+    pdfv1["native_app"]["artifacts"] = [
+        _convert_v2_artifact_to_v1_dict(a) for a in app_package_definition.artifacts
+    ]
+    pdfv1["native_app"]["source_stage"] = app_package_definition.stage
+    pdfv1["native_app"]["bundle_root"] = app_package_definition.bundle_root
+    pdfv1["native_app"]["generated_root"] = app_package_definition.generated_root
+    pdfv1["native_app"]["deploy_root"] = app_package_definition.deploy_root
+    pdfv1["native_app"]["scratch_stage"] = app_package_definition.scratch_stage
+
+    # Package
+    pdfv1["native_app"]["package"] = {}
+    pdfv1["native_app"]["package"]["name"] = app_package_definition.fqn.identifier
+    if app_package_definition.distribution:
+        pdfv1["native_app"]["package"][
+            "distribution"
+        ] = app_package_definition.distribution
+    if app_package_definition.meta and app_package_definition.meta.post_deploy:
+        pdfv1["native_app"]["package"][
+            "post_deploy"
+        ] = app_package_definition.meta.post_deploy
+    if app_package_definition.meta:
+        if app_package_definition.meta.role:
+            pdfv1["native_app"]["package"]["role"] = app_package_definition.meta.role
+        if app_package_definition.meta.warehouse:
+            pdfv1["native_app"]["package"][
+                "warehouse"
+            ] = app_package_definition.meta.warehouse
+
+    # Application
+    if app_definition:
+        pdfv1["native_app"]["application"] = {}
+        pdfv1["native_app"]["application"]["name"] = app_definition.fqn.identifier
+        if app_definition.debug:
+            pdfv1["native_app"]["application"]["debug"] = app_definition.debug
+        if app_definition.meta:
+            if app_definition.meta.role:
+                pdfv1["native_app"]["application"]["role"] = app_definition.meta.role
+            if app_definition.meta.warehouse:
+                pdfv1["native_app"]["application"][
+                    "warehouse"
+                ] = app_definition.meta.warehouse
+            if app_definition.meta.post_deploy:
+                pdfv1["native_app"]["application"][
+                    "post_deploy"
+                ] = app_definition.meta.post_deploy
+
+    result = render_definition_template(pdfv1, {})
+    # Override the definition object in global context
+    return result.project_definition
+
+
+T = TypeVar("T", bound=EntityModelBase)
+
+
+def find_entity(
+    project_definition: DefinitionV20,
+    entity_class: Type[T],
+    entity_id: str,
+    disambiguation_option: str,
+    required: bool,
+) -> T | None:
+    """
+    Find an entity of the specified type in the project definition file.
+
+    If an ID is passed, only that entity will be considered,
+    otherwise look for a single entity of the specified type.
+
+    If there are multiple entities of the specified type,
+    the user must specify which one to use using the CLI option
+    named in the disambiguation_option parameter.
+
+    If no entity is found, an error is raised if required is True,
+    otherwise None is returned.
+    """
+
+    entity_type = entity_class.get_type()
+    entities = project_definition.get_entities_by_type(entity_type)
+
+    entity: Optional[T] = None
+
+    if entity_id:
+        # If we're looking for a specific entity, use that one directly
+        entity = entities.get(entity_id)
+    elif len(entities) == 1:
+        # Otherwise, if there is only one entity, fall back to that one
+        entity = next(iter(entities.values()))
+    elif len(entities) > 1 and required:
+        # If there are multiple entities and it's required,
+        # the user must specify which one to use
+        raise ClickException(
+            f"More than one {entity_type} entity exists in the project definition file, "
+            f"specify {disambiguation_option} to choose which one to operate on."
+        )
+
+    # If we don't have a package entity to convert, error out if it's required
+    if not entity and required:
+        with_id = f'with ID "{entity_id}" ' if entity_id else ""
+        raise ClickException(
+            f"Could not find an {entity_type} entity {with_id}in the project definition file."
+        )
+
+    return entity
+
+
+def nativeapp_definition_v2_to_v1(*, app_required: bool = False):
+    """
+    A command decorator that attempts to automatically convert a native app project from
+    definition v2 to v1.1. Assumes with_project_definition() has already been called.
+    The definition object in CliGlobalContext will be replaced with the converted object.
+    Exactly one application package entity type is expected, and up to one application
+    entity type is expected.
+    """
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            original_pdf: Optional[DefinitionV20] = get_cli_context().project_definition
+            if not original_pdf:
+                raise ValueError(
+                    "Project definition could not be found. The nativeapp_definition_v2_to_v1 command decorator assumes with_project_definition() was called before it."
+                )
+            if original_pdf.definition_version == "2":
+                package_entity_id = kwargs.get("package_entity_id", "")
+                app_entity_id = kwargs.get("app_entity_id", "")
+                pdfv1 = _pdf_v2_to_v1(
+                    original_pdf, package_entity_id, app_entity_id, app_required
+                )
+                get_cli_context_manager().override_project_definition = pdfv1
+            return func(*args, **kwargs)
+
+        return _options_decorator_factory(
+            wrapper,
+            additional_options=[
+                inspect.Parameter(
+                    "package_entity_id",
+                    inspect.Parameter.KEYWORD_ONLY,
+                    annotation=Optional[str],
+                    default=typer.Option(
+                        default="",
+                        help="The ID of the package entity on which to operate when definition_version is 2 or higher.",
+                    ),
+                ),
+                inspect.Parameter(
+                    "app_entity_id",
+                    inspect.Parameter.KEYWORD_ONLY,
+                    annotation=Optional[str],
+                    default=typer.Option(
+                        default="",
+                        help="The ID of the application entity on which to operate when definition_version is 2 or higher.",
+                    ),
+                ),
+            ],
+        )
+
+    return decorator