snowflake-cli-labs 3.0.0rc1__py3-none-any.whl → 3.0.0rc3__py3-none-any.whl

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

@@ -15,179 +15,36 @@
 from __future__ import annotations
 
 from pathlib import Path
-from textwrap import dedent
 from typing import Dict, Optional
 
-import typer
-from snowflake.cli._plugins.nativeapp.constants import (
-    ALLOWED_SPECIAL_COMMENTS,
-    COMMENT_COL,
-    OWNER_COL,
+from snowflake.cli._plugins.nativeapp.application_entity import (
+    ApplicationEntity,
+)
+from snowflake.cli._plugins.nativeapp.application_package_entity import (
+    ApplicationPackageEntity,
 )
 from snowflake.cli._plugins.nativeapp.manager import (
     NativeAppCommandProcessor,
     NativeAppManager,
 )
-from snowflake.cli._plugins.nativeapp.utils import (
-    needs_confirmation,
-)
 from snowflake.cli.api.console import cli_console as cc
-from snowflake.cli.api.entities.application_package_entity import (
-    ApplicationPackageEntity,
-)
-from snowflake.cli.api.entities.utils import (
-    drop_generic_object,
-    ensure_correct_owner,
-)
-from snowflake.cli.api.errno import APPLICATION_NO_LONGER_AVAILABLE
-from snowflake.connector import ProgrammingError
 
 
 class NativeAppTeardownProcessor(NativeAppManager, NativeAppCommandProcessor):
     def __init__(self, project_definition: Dict, project_root: Path):
         super().__init__(project_definition, project_root)
 
-    def drop_generic_object(
-        self, object_type: str, object_name: str, role: str, cascade: bool = False
-    ):
-        return drop_generic_object(
-            console=cc,
-            object_type=object_type,
-            object_name=object_name,
-            role=role,
-            cascade=cascade,
-        )
-
     def drop_application(
         self, auto_yes: bool, interactive: bool = False, cascade: Optional[bool] = None
     ):
-        """
-        Attempts to drop the application object if all validations and user prompts allow so.
-        """
-
-        needs_confirm = True
-
-        # 1. If existing application is not found, exit gracefully
-        show_obj_row = self.get_existing_app_info()
-        if show_obj_row is None:
-            cc.warning(
-                f"Role {self.app_role} does not own any application object with the name {self.app_name}, or the application object does not exist."
-            )
-            return
-
-        # 2. Check for the right owner
-        ensure_correct_owner(
-            row=show_obj_row, role=self.app_role, obj_name=self.app_name
-        )
-
-        # 3. Check if created by the Snowflake CLI
-        row_comment = show_obj_row[COMMENT_COL]
-        if row_comment not in ALLOWED_SPECIAL_COMMENTS and needs_confirmation(
-            needs_confirm, auto_yes
-        ):
-            should_drop_object = typer.confirm(
-                dedent(
-                    f"""\
-                        Application object {self.app_name} was not created by Snowflake CLI.
-                        Application object details:
-                        Name: {self.app_name}
-                        Created on: {show_obj_row["created_on"]}
-                        Source: {show_obj_row["source"]}
-                        Owner: {show_obj_row[OWNER_COL]}
-                        Comment: {show_obj_row[COMMENT_COL]}
-                        Version: {show_obj_row["version"]}
-                        Patch: {show_obj_row["patch"]}
-                        Are you sure you want to drop it?
-                    """
-                )
-            )
-            if not should_drop_object:
-                cc.message(f"Did not drop application object {self.app_name}.")
-                # The user desires to keep the app, therefore we can't proceed since it would
-                # leave behind an orphan app when we get to dropping the package
-                raise typer.Abort()
-
-        # 4. Check for application objects owned by the application
-        # This query will fail if the application package has already been dropped, so handle this case gracefully
-        has_objects_to_drop = False
-        message_prefix = ""
-        cascade_true_message = ""
-        cascade_false_message = ""
-        interactive_prompt = ""
-        non_interactive_abort = ""
-        try:
-            if application_objects := self.get_objects_owned_by_application():
-                has_objects_to_drop = True
-                message_prefix = (
-                    f"The following objects are owned by application {self.app_name}"
-                )
-                cascade_true_message = f"{message_prefix} and will be dropped:"
-                cascade_false_message = f"{message_prefix} and will NOT be dropped:"
-                interactive_prompt = "Would you like to drop these objects in addition to the application? [y/n/ABORT]"
-                non_interactive_abort = "Re-run teardown again with --cascade or --no-cascade to specify whether these objects should be dropped along with the application"
-        except ProgrammingError as e:
-            if e.errno != APPLICATION_NO_LONGER_AVAILABLE:
-                raise
-            application_objects = []
-            message_prefix = f"Could not determine which objects are owned by application {self.app_name}"
-            has_objects_to_drop = True  # potentially, but we don't know what they are
-            cascade_true_message = (
-                f"{message_prefix}, an unknown number of objects will be dropped."
-            )
-            cascade_false_message = f"{message_prefix}, they will NOT be dropped."
-            interactive_prompt = f"Would you like to drop an unknown set of objects in addition to the application? [y/n/ABORT]"
-            non_interactive_abort = f"Re-run teardown again with --cascade or --no-cascade to specify whether any objects should be dropped along with the application."
-
-        if has_objects_to_drop:
-            if cascade is True:
-                # If the user explicitly passed the --cascade flag
-                cc.message(cascade_true_message)
-                with cc.indented():
-                    for obj in application_objects:
-                        cc.message(self._application_object_to_str(obj))
-            elif cascade is False:
-                # If the user explicitly passed the --no-cascade flag
-                cc.message(cascade_false_message)
-                with cc.indented():
-                    for obj in application_objects:
-                        cc.message(self._application_object_to_str(obj))
-            elif interactive:
-                # If the user didn't pass any cascade flag and the session is interactive
-                cc.message(message_prefix)
-                with cc.indented():
-                    for obj in application_objects:
-                        cc.message(self._application_object_to_str(obj))
-                user_response = typer.prompt(
-                    interactive_prompt,
-                    show_default=False,
-                    default="ABORT",
-                ).lower()
-                if user_response in ["y", "yes"]:
-                    cascade = True
-                elif user_response in ["n", "no"]:
-                    cascade = False
-                else:
-                    raise typer.Abort()
-            else:
-                # Else abort since we don't know what to do and can't ask the user
-                cc.message(message_prefix)
-                with cc.indented():
-                    for obj in application_objects:
-                        cc.message(self._application_object_to_str(obj))
-                cc.message(non_interactive_abort)
-                raise typer.Abort()
-        elif cascade is None:
-            # If there's nothing to drop, set cascade to an explicit False value
-            cascade = False
-
-        # 5. All validations have passed, drop object
-        self.drop_generic_object(
-            object_type="application",
-            object_name=self.app_name,
-            role=self.app_role,
+        return ApplicationEntity.drop(
+            console=cc,
+            app_name=self.app_name,
+            app_role=self.app_role,
+            auto_yes=auto_yes,
+            interactive=interactive,
             cascade=cascade,
         )
-        return  # The application object was successfully dropped, therefore exit gracefully
 
     def drop_package(self, auto_yes: bool):
         return ApplicationPackageEntity.drop(

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

@@ -14,25 +14,29 @@
 
 from __future__ import annotations
 
+import inspect
 from functools import wraps
-from typing import Any, Dict, Optional, Union
+from typing import Any, Dict, Optional, Type, TypeVar, Union
 
+import typer
 from click import ClickException
-from snowflake.cli.api.cli_global_context import (
-    get_cli_context,
-    get_cli_context_manager,
-)
-from snowflake.cli.api.project.schemas.entities.application_entity_model import (
+from snowflake.cli._plugins.nativeapp.application_entity_model import (
     ApplicationEntityModel,
 )
-from snowflake.cli.api.project.schemas.entities.application_package_entity_model import (
+from snowflake.cli._plugins.nativeapp.application_package_entity_model import (
     ApplicationPackageEntityModel,
 )
-from snowflake.cli.api.project.schemas.native_app.path_mapping import PathMapping
+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
 
 
@@ -48,29 +52,53 @@ def _convert_v2_artifact_to_v1_dict(
     return v2_artifact
 
 
-def _pdf_v2_to_v1(v2_definition: DefinitionV20) -> DefinitionV11:
+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": {}}
 
-    app_package_definition: Optional[ApplicationPackageEntityModel] = None
-    app_definition: Optional[ApplicationEntityModel] = None
+    # 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,
+    )
 
-    for key, entity in v2_definition.entities.items():
-        if entity.get_type() == ApplicationPackageEntityModel.get_type():
-            if app_package_definition:
-                raise ClickException(
-                    "More than one application package entity exists in the project definition file."
-                )
-            app_package_definition = entity
-        elif entity.get_type() == ApplicationEntityModel.get_type():
-            if app_definition:
+    # 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(
-                    "More than one application entity exists in the project definition file."
+                    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."
                 )
-            app_definition = entity
-    if not app_package_definition:
-        raise ClickException(
-            "Could not find an application package entity in the project definition file."
-        )
+        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:
@@ -130,7 +158,60 @@ def _pdf_v2_to_v1(v2_definition: DefinitionV20) -> DefinitionV11:
     return result.project_definition
 
 
-def nativeapp_definition_v2_to_v1(func):
+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.
@@ -139,16 +220,45 @@ def nativeapp_definition_v2_to_v1(func):
     entity type is expected.
     """
 
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        original_pdf: 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":
-            pdfv1 = _pdf_v2_to_v1(original_pdf)
-            get_cli_context_manager().set_project_definition(pdfv1)
-        return func(*args, **kwargs)
-
-    return wrapper
+    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

snowflake/cli/_plugins/nativeapp/version/commands.py

@@ -51,7 +51,7 @@ log = logging.getLogger(__name__)
 
 @app.command(requires_connection=True)
 @with_project_definition()
-@nativeapp_definition_v2_to_v1
+@nativeapp_definition_v2_to_v1()
 def create(
     version: Optional[str] = typer.Argument(
         None,
@@ -82,42 +82,24 @@ def create(
     if version is None and patch is not None:
         raise MissingParameter("Cannot provide a patch without version!")
 
-    is_interactive = False
-    if force:
-        policy = AllowAlwaysPolicy()
-    elif interactive:
-        is_interactive = True
-        policy = AskAlwaysPolicy()
-    else:
-        policy = DenyAlwaysPolicy()
-
-    if skip_git_check:
-        git_policy = DenyAlwaysPolicy()
-    else:
-        git_policy = AllowAlwaysPolicy()
-
     cli_context = get_cli_context()
     processor = NativeAppVersionCreateProcessor(
         project_definition=cli_context.project_definition.native_app,
         project_root=cli_context.project_root,
     )
-
-    # We need build_bundle() to (optionally) find version in manifest.yml and create an application package
-    bundle_map = processor.build_bundle()
     processor.process(
-        bundle_map=bundle_map,
         version=version,
         patch=patch,
-        policy=policy,
-        git_policy=git_policy,
-        is_interactive=is_interactive,
+        force=force,
+        interactive=interactive,
+        skip_git_check=skip_git_check,
     )
     return MessageResult(f"Version create is now complete.")
 
 
 @app.command("list", requires_connection=True)
 @with_project_definition()
-@nativeapp_definition_v2_to_v1
+@nativeapp_definition_v2_to_v1()
 def version_list(
     **options,
 ) -> CommandResult:
@@ -138,7 +120,7 @@ def version_list(
 
 @app.command(requires_connection=True)
 @with_project_definition()
-@nativeapp_definition_v2_to_v1
+@nativeapp_definition_v2_to_v1()
 def drop(
     version: Optional[str] = typer.Argument(
         None,