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

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

@@ -16,26 +16,27 @@ 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._plugins.nativeapp.application_entity_model import (
+    ApplicationEntityModel,
+)
+from snowflake.cli._plugins.nativeapp.application_package_entity_model 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.application_entity_model import (
-    ApplicationEntityModel,
-)
-from snowflake.cli.api.project.schemas.entities.application_package_entity_model import (
-    ApplicationPackageEntityModel,
-)
-from snowflake.cli.api.project.schemas.native_app.path_mapping import PathMapping
+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
 
 
@@ -55,33 +56,18 @@ 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
-
-    # Enumerate all application package and application entities in the project definition
-    packages: dict[
-        str, ApplicationPackageEntityModel
-    ] = v2_definition.get_entities_by_type(ApplicationPackageEntityModel.get_type())
-    apps: dict[str, ApplicationEntityModel] = v2_definition.get_entities_by_type(
-        ApplicationEntityModel.get_type()
-    )
-
     # Determine the application entity to convert, there can be zero or one
-    if app_entity_id:
-        # If the user specified an app entity ID, use that one directly
-        app_definition = apps.get(app_entity_id)
-    elif len(apps) == 1:
-        # Otherwise, if there is only one app entity, fall back to that one
-        app_definition = next(iter(apps.values()))
-    elif len(apps) > 1:
-        # If there are multiple app entities, the user must specify which one to use
-        raise ClickException(
-            "More than one application entity exists in the project definition file, "
-            "specify --app-entity-id to choose which one to operate on."
-        )
+    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:
@@ -89,7 +75,8 @@ def _pdf_v2_to_v1(
         if package_entity_id:
             # If the user specified a package entity ID,
             # check that the app entity targets the user-specified package entity
-            if target_package != package_entity_id:
+            # 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"
@@ -97,30 +84,21 @@ def _pdf_v2_to_v1(
                     f"or omit the --package-entity-id flag to automatically use the package entity "
                     f"that the application entity targets."
                 )
-        elif target_package in packages:
+        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
-    if package_entity_id:
-        # If the user specified a package entity ID (or we inferred one from the app entity), use that one directly
-        app_package_definition = packages.get(package_entity_id)
-    elif len(packages) == 1:
-        # Otherwise, if there is only one package entity, fall back to that one
-        app_package_definition = next(iter(packages.values()))
-    elif len(packages) > 1:
-        # If there are multiple package entities, the user must specify which one to use
-        raise ClickException(
-            "More than one application package entity exists in the project definition file, "
-            "specify --package-entity-id to choose which one to operate on."
-        )
-
-    # If we don't have a package entity to convert, error out since it's not optional
-    if not app_package_definition:
-        with_id = f'with ID "{package_entity_id}" ' if package_entity_id else ""
-        raise ClickException(
-            f"Could not find an application package entity {with_id}in the project definition file."
-        )
+    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:
@@ -180,7 +158,60 @@ def _pdf_v2_to_v1(
     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.
@@ -189,40 +220,45 @@ def nativeapp_definition_v2_to_v1(func):
     entity type is expected.
     """
 
-    @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)
-            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.",
+    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.",
+                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,

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

@@ -16,17 +16,17 @@ from __future__ import annotations
 
 from pathlib import Path
 from textwrap import dedent
-from typing import Dict, List, Optional
+from typing import Dict, Optional
 
 import typer
-from click import BadOptionUsage, ClickException
+from click import ClickException
+from snowflake.cli._plugins.nativeapp.application_package_entity import (
+    ApplicationPackageEntity,
+)
 from snowflake.cli._plugins.nativeapp.artifacts import (
-    BundleMap,
     find_version_info_in_manifest_file,
 )
-from snowflake.cli._plugins.nativeapp.constants import VERSION_COL
 from snowflake.cli._plugins.nativeapp.exceptions import (
-    ApplicationPackageAlreadyExistsError,
     ApplicationPackageDoesNotExistError,
 )
 from snowflake.cli._plugins.nativeapp.manager import (
@@ -36,245 +36,50 @@ from snowflake.cli._plugins.nativeapp.manager import (
 from snowflake.cli._plugins.nativeapp.policy import PolicyBase
 from snowflake.cli._plugins.nativeapp.run_processor import NativeAppRunProcessor
 from snowflake.cli.api.console import cli_console as cc
-from snowflake.cli.api.entities.utils import ensure_correct_owner
-from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
-from snowflake.cli.api.project.schemas.native_app.native_app import NativeApp
-from snowflake.cli.api.project.util import to_identifier, unquote_identifier
-from snowflake.cli.api.utils.cursor import (
-    find_all_rows,
-)
+from snowflake.cli.api.project.schemas.v1.native_app.native_app import NativeApp
+from snowflake.cli.api.project.util import to_identifier
 from snowflake.connector import ProgrammingError
-from snowflake.connector.cursor import DictCursor
-
-
-def check_index_changes_in_git_repo(
-    project_root: Path, policy: PolicyBase, is_interactive: bool
-) -> None:
-    """
-    Checks if the project root, i.e. the native apps project is a git repository. If it is a git repository,
-    it also checks if there any local changes to the directory that may not be on the application package stage.
-    """
-    from git import Repo
-    from git.exc import InvalidGitRepositoryError
-
-    try:
-        repo = Repo(project_root, search_parent_directories=True)
-        assert repo.git_dir is not None
-
-        # Check if the repo has any changes, including untracked files
-        if repo.is_dirty(untracked_files=True):
-            cc.warning(
-                "Changes detected in the git repository. "
-                "(Rerun your command with --skip-git-check flag to ignore this check)"
-            )
-            repo.git.execute(["git", "status"])
-
-            user_prompt = (
-                "You have local changes in this repository that are not part of a previous commit. "
-                "Do you still want to continue?"
-            )
-            if not policy.should_proceed(user_prompt):
-                if is_interactive:
-                    cc.message("Not creating a new version.")
-                    raise typer.Exit(0)
-                else:
-                    cc.message(
-                        "Cannot create a new version non-interactively without --force."
-                    )
-                    raise typer.Exit(1)
-
-    except InvalidGitRepositoryError:
-        pass  # not a git repository, which is acceptable
 
 
 class NativeAppVersionCreateProcessor(NativeAppRunProcessor):
     def __init__(self, project_definition: Dict, project_root: Path):
         super().__init__(project_definition, project_root)
 
-    def get_existing_release_directive_info_for_version(
-        self, version: str
-    ) -> List[dict]:
-        """
-        Get all existing release directives, if present, set on the version defined in an application package.
-        It executes a 'show release directives in application package' query and returns the filtered results, if they exist.
-        """
-        with self.use_role(self.package_role):
-            show_obj_query = (
-                f"show release directives in application package {self.package_name}"
-            )
-            show_obj_cursor = self._execute_query(
-                show_obj_query, cursor_class=DictCursor
-            )
-
-            if show_obj_cursor.rowcount is None:
-                raise SnowflakeSQLExecutionError(show_obj_query)
-
-            show_obj_rows = find_all_rows(
-                show_obj_cursor,
-                lambda row: row[VERSION_COL] == unquote_identifier(version),
-            )
-
-            return show_obj_rows
-
-    def add_new_version(self, version: str) -> None:
-        """
-        Defines a new version in an existing application package.
-        """
-        # Make the version a valid identifier, adding quotes if necessary
-        version = to_identifier(version)
-        with self.use_role(self.package_role):
-            cc.step(
-                f"Defining a new version {version} in application package {self.package_name}"
-            )
-            add_version_query = dedent(
-                f"""\
-                    alter application package {self.package_name}
-                        add version {version}
-                        using @{self.stage_fqn}
-                """
-            )
-            self._execute_query(add_version_query, cursor_class=DictCursor)
-            cc.message(
-                f"Version {version} created for application package {self.package_name}."
-            )
-
-    def add_new_patch_to_version(self, version: str, patch: Optional[int] = None):
-        """
-        Add a new patch, optionally a custom one, to an existing version in an application package.
-        """
-        # Make the version a valid identifier, adding quotes if necessary
-        version = to_identifier(version)
-        with self.use_role(self.package_role):
-            cc.step(
-                f"Adding new patch to version {version} defined in application package {self.package_name}"
-            )
-            add_version_query = dedent(
-                f"""\
-                    alter application package {self.package_name}
-                        add patch {patch if patch else ""} for version {version}
-                        using @{self.stage_fqn}
-                """
-            )
-            result_cursor = self._execute_query(
-                add_version_query, cursor_class=DictCursor
-            )
-
-            show_row = result_cursor.fetchall()[0]
-            new_patch = show_row["patch"]
-            cc.message(
-                f"Patch {new_patch} created for version {version} defined in application package {self.package_name}."
-            )
-
     def process(
         self,
-        bundle_map: BundleMap,
         version: Optional[str],
         patch: Optional[int],
-        policy: PolicyBase,
-        git_policy: PolicyBase,
-        is_interactive: bool,
+        force: bool,
+        interactive: bool,
+        skip_git_check: bool,
         *args,
         **kwargs,
     ):
-        """
-        Perform bundle, application package creation, stage upload, version and/or patch to an application package.
-        """
-
-        # Make sure version is not None before proceeding any further.
-        # This will raise an exception if version information is not found. Patch can be None.
-        if not version:
-            cc.message(
-                "Version was not provided through the Snowflake CLI. Checking version in the manifest.yml instead."
-            )
-
-            version, patch = find_version_info_in_manifest_file(self.deploy_root)
-            if not version:
-                raise ClickException(
-                    "Manifest.yml file does not contain a value for the version field."
-                )
-
-        # Check if --patch needs to throw a bad option error, either if application package does not exist or if version does not exist
-        if patch:
-            try:
-                if not self.get_existing_version_info(version):
-                    raise BadOptionUsage(
-                        option_name="patch",
-                        message=f"Cannot create a custom patch when version {version} is not defined in the application package {self.package_name}. Try again without using --patch.",
-                    )
-            except ApplicationPackageDoesNotExistError as app_err:
-                raise BadOptionUsage(
-                    option_name="patch",
-                    message=f"Cannot create a custom patch when application package {self.package_name} does not exist. Try again without using --patch.",
-                )
-
-        if git_policy.should_proceed():
-            check_index_changes_in_git_repo(
-                project_root=self.project_root,
-                policy=policy,
-                is_interactive=is_interactive,
-            )
-
-        # TODO: consider using self.deploy() instead
-
-        try:
-            self.create_app_package()
-        except ApplicationPackageAlreadyExistsError as e:
-            cc.warning(e.message)
-            if not policy.should_proceed("Proceed with using this package?"):
-                raise typer.Abort() from e
-
-        with self.use_role(self.package_role):
-            # Now that the application package exists, create shared data
-            self._apply_package_scripts()
-
-            # Upload files from deploy root local folder to the above stage
-            self.sync_deploy_root_with_stage(
-                bundle_map=bundle_map,
-                role=self.package_role,
-                prune=True,
-                recursive=True,
-                stage_fqn=self.stage_fqn,
-            )
-            with self.use_package_warehouse():
-                self.execute_package_post_deploy_hooks()
-
-        # Warn if the version exists in a release directive(s)
-        existing_release_directives = (
-            self.get_existing_release_directive_info_for_version(version)
+        return ApplicationPackageEntity.version_create(
+            console=cc,
+            project_root=self.project_root,
+            deploy_root=self.deploy_root,
+            bundle_root=self.bundle_root,
+            generated_root=self.generated_root,
+            artifacts=self.artifacts,
+            package_name=self.package_name,
+            package_role=self.package_role,
+            package_distribution=self.package_distribution,
+            prune=True,
+            recursive=True,
+            paths=None,
+            print_diff=True,
+            validate=True,
+            stage_fqn=self.stage_fqn,
+            package_warehouse=self.package_warehouse,
+            post_deploy_hooks=self.package_post_deploy_hooks,
+            package_scripts=self.package_scripts,
+            version=version,
+            patch=patch,
+            force=force,
+            interactive=interactive,
+            skip_git_check=skip_git_check,
         )
-        if existing_release_directives:
-            release_directive_names = ", ".join(
-                row["name"] for row in existing_release_directives
-            )
-            cc.warning(
-                dedent(
-                    f"""\
-                    Version {version} already defined in application package {self.package_name} and in release directive(s): {release_directive_names}.
-                    """
-                )
-            )
-
-            user_prompt = (
-                f"Are you sure you want to create a new patch for version {version} in application "
-                f"package {self.package_name}? Once added, this operation cannot be undone."
-            )
-            if not policy.should_proceed(user_prompt):
-                if is_interactive:
-                    cc.message("Not creating a new patch.")
-                    raise typer.Exit(0)
-                else:
-                    cc.message(
-                        "Cannot create a new patch non-interactively without --force."
-                    )
-                    raise typer.Exit(1)
-
-        # Define a new version in the application package
-        if not self.get_existing_version_info(version):
-            self.add_new_version(version=version)
-            return  # A new version created automatically has patch 0, we do not need to further increment the patch.
-
-        # Add a new patch to an existing (old) version
-        self.add_new_patch_to_version(version=version, patch=patch)
 
 
 class NativeAppVersionDropProcessor(NativeAppManager, NativeAppCommandProcessor):
@@ -295,12 +100,7 @@ class NativeAppVersionDropProcessor(NativeAppManager, NativeAppCommandProcessor)
 
         # 1. Check for existing an existing application package
         show_obj_row = self.get_existing_app_pkg_info()
-        if show_obj_row:
-            # Check for the right owner role
-            ensure_correct_owner(
-                row=show_obj_row, role=self.package_role, obj_name=self.package_name
-            )
-        else:
+        if not show_obj_row:
             raise ApplicationPackageDoesNotExistError(self.package_name)
 
         # 2. Check distribution of the existing application package

snowflake/cli/_plugins/snowpark/commands.py

@@ -46,6 +46,10 @@ from snowflake.cli._plugins.snowpark.package.anaconda_packages import (
     AnacondaPackagesManager,
 )
 from snowflake.cli._plugins.snowpark.package.commands import app as package_app
+from snowflake.cli._plugins.snowpark.snowpark_entity_model import (
+    FunctionEntityModel,
+    ProcedureEntityModel,
+)
 from snowflake.cli._plugins.snowpark.snowpark_project_paths import (
     SnowparkProjectPaths,
 )
@@ -87,10 +91,6 @@ from snowflake.cli.api.output.types import (
 from snowflake.cli.api.project.definition_conversion import (
     convert_project_definition_to_v2,
 )
-from snowflake.cli.api.project.schemas.entities.snowpark_entity import (
-    FunctionEntityModel,
-    ProcedureEntityModel,
-)
 from snowflake.cli.api.project.schemas.project_definition import (
     ProjectDefinition,
     ProjectDefinitionV2,