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

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.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_entity import (
+    ApplicationEntity,
+)
 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,14 +14,17 @@
 
 from __future__ import annotations
 
+import inspect
 from functools import wraps
 from typing import Any, Dict, Optional, 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.commands.decorators import _options_decorator_factory
 from snowflake.cli.api.project.schemas.entities.application_entity_model import (
     ApplicationEntityModel,
 )
@@ -48,28 +51,75 @@ 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 = "",
+) -> DefinitionV11:
     pdfv1: Dict[str, Any] = {"definition_version": "1.1", "native_app": {}}
 
     app_package_definition: Optional[ApplicationPackageEntityModel] = None
     app_definition: Optional[ApplicationEntityModel] = None
 
-    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:
+    # 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."
+        )
+
+    # 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 target_package != package_entity_id:
                 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
+        elif target_package in packages:
+            # 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(
-            "Could not find an application package entity in the project definition file."
+            f"Could not find an application package entity {with_id}in the project definition file."
         )
 
     # NativeApp
@@ -141,14 +191,38 @@ def nativeapp_definition_v2_to_v1(func):
 
     @wraps(func)
     def wrapper(*args, **kwargs):
-        original_pdf: DefinitionV20 = get_cli_context().project_definition
+        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":
-            pdfv1 = _pdf_v2_to_v1(original_pdf)
-            get_cli_context_manager().set_project_definition(pdfv1)
+            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 wrapper
+    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.",
+                ),
+            ),
+        ],
+    )

snowflake/cli/_plugins/snowpark/commands.py

@@ -446,5 +446,5 @@ def describe(
 def _get_v2_project_definition(cli_context) -> ProjectDefinitionV2:
     pd = cli_context.project_definition
     if not pd.meets_version_requirement("2"):
-        pd = convert_project_definition_to_v2(pd)
+        pd = convert_project_definition_to_v2(cli_context.project_root, pd)
     return pd

snowflake/cli/_plugins/snowpark/models.py

@@ -121,13 +121,14 @@ class WheelMetadata:
                 if line.startswith(dep_keyword)
             ]
             name = cls._get_name_from_wheel_filename(wheel_path.name)
+
             return cls(name=name, wheel_path=wheel_path, dependencies=dependencies)
 
     @staticmethod
     def _get_name_from_wheel_filename(wheel_filename: str) -> str:
         # wheel filename is in format {name}-{version}[-{extra info}]
         # https://peps.python.org/pep-0491/#file-name-convention
-        return wheel_filename.split("-")[0]
+        return wheel_filename.split("-")[0].lower()
 
     @staticmethod
     def to_wheel_name_format(package_name: str) -> str:

snowflake/cli/_plugins/streamlit/commands.py

@@ -138,7 +138,7 @@ def streamlit_deploy(
             raise NoProjectDefinitionError(
                 project_type="streamlit", project_root=cli_context.project_root
             )
-        pd = convert_project_definition_to_v2(pd)
+        pd = convert_project_definition_to_v2(cli_context.project_root, pd)
 
     streamlits: Dict[str, StreamlitEntityModel] = pd.get_entities_by_type(
         entity_type="streamlit"

snowflake/cli/_plugins/streamlit/manager.py

@@ -18,11 +18,13 @@ import logging
 from pathlib import Path
 from typing import List, Optional
 
+from click import ClickException
 from snowflake.cli._plugins.connection.util import (
     MissingConnectionAccountError,
     MissingConnectionRegionError,
     make_snowsight_url,
 )
+from snowflake.cli._plugins.object.manager import ObjectManager
 from snowflake.cli._plugins.stage.manager import StageManager
 from snowflake.cli.api.commands.experimental_behaviour import (
     experimental_behaviour_enabled,
@@ -112,6 +114,13 @@ class StreamlitManager(SqlExecutionMixin):
 
     def deploy(self, streamlit: StreamlitEntityModel, replace: bool = False):
         streamlit_id = streamlit.fqn.using_connection(self._conn)
+        if (
+            ObjectManager().object_exists(object_type="streamlit", fqn=streamlit_id)
+            and not replace
+        ):
+            raise ClickException(
+                f"Streamlit {streamlit.fqn} already exist. If you want to replace it use --replace flag."
+            )
 
         # for backwards compatibility - quoted stage path might be case-sensitive
         # https://docs.snowflake.com/en/sql-reference/identifiers-syntax#double-quoted-identifiers

snowflake/cli/_plugins/workspace/action_context.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Optional
+from typing import Callable, Optional
 
 from snowflake.cli.api.console.abc import AbstractConsole
 
@@ -15,3 +15,4 @@ class ActionContext:
     project_root: Path
     default_role: str
     default_warehouse: Optional[str]
+    get_entity: Callable

snowflake/cli/_plugins/workspace/commands.py

@@ -24,6 +24,7 @@ import yaml
 from snowflake.cli._plugins.nativeapp.artifacts import BundleMap
 from snowflake.cli._plugins.nativeapp.common_flags import (
     ForceOption,
+    InteractiveOption,
     ValidateOption,
 )
 from snowflake.cli._plugins.workspace.manager import WorkspaceManager
@@ -53,13 +54,14 @@ def migrate(
     ),
     **options,
 ):
-    """Migrates the Snowpark and Streamlit project definition files from V1 to V2."""
-    pd = DefinitionManager().unrendered_project_definition
+    """Migrates the Snowpark, Streamlit, and Native App project definition files from V1 to V2."""
+    manager = DefinitionManager()
+    pd = manager.unrendered_project_definition
 
     if pd.meets_version_requirement("2"):
         return MessageResult("Project definition is already at version 2.")
 
-    pd_v2 = convert_project_definition_to_v2(pd, accept_templates)
+    pd_v2 = convert_project_definition_to_v2(manager.project_root, pd, accept_templates)
 
     SecurePath("snowflake.yml").rename("snowflake_V1.yml")
     with open("snowflake.yml", "w") as file:
@@ -72,16 +74,6 @@ def migrate(
     return MessageResult("Project definition migrated to version 2.")
 
 
-@ws.command(requires_connection=True, hidden=True)
-@with_project_definition()
-def validate(
-    **options,
-):
-    """Validates the project definition file."""
-    # If we get to this point, @with_project_definition() has already validated the PDF schema
-    return MessageResult("Project definition is valid.")
-
-
 @ws.command(requires_connection=True, hidden=True)
 @with_project_definition()
 def bundle(
@@ -104,7 +96,7 @@ def bundle(
     return MessageResult(f"Bundle generated at {bundle_map.deploy_root()}")
 
 
-@ws.command(requires_connection=True)
+@ws.command(requires_connection=True, hidden=True)
 @with_project_definition()
 def deploy(
     entity_id: str = typer.Option(
@@ -132,6 +124,15 @@ def deploy(
             unspecified, the command syncs all local changes to the stage."""
         ).strip(),
     ),
+    from_release_directive: Optional[bool] = typer.Option(
+        False,
+        "--from-release-directive",
+        help=f"""Creates or upgrades an application object to the version and patch specified by the release directive applicable to your Snowflake account.
+        The command fails if no release directive exists for your Snowflake account for a given application package, which is determined from the project definition file. Default: unset.""",
+        is_flag=True,
+    ),
+    interactive: bool = InteractiveOption,
+    force: Optional[bool] = ForceOption,
     validate: bool = ValidateOption,
     **options,
 ):
@@ -163,24 +164,32 @@ def deploy(
         recursive=recursive,
         paths=paths,
         validate=validate,
+        from_release_directive=from_release_directive,
+        interactive=interactive,
+        force=force,
     )
     return MessageResult("Deployed successfully.")
 
 
-@ws.command(requires_connection=True)
+@ws.command(requires_connection=True, hidden=True)
 @with_project_definition()
 def drop(
     entity_id: str = typer.Option(
         help=f"""The ID of the entity you want to drop.""",
     ),
     # TODO The following options should be generated automatically, depending on the specified entity type
+    interactive: bool = InteractiveOption,
     force: Optional[bool] = ForceOption,
+    cascade: Optional[bool] = typer.Option(
+        None,
+        help=f"""Whether to drop all application objects owned by the application within the account. Default: false.""",
+        show_default=False,
+    ),
     **options,
 ):
     """
     Drops the specified entity.
     """
-
     cli_context = get_cli_context()
     ws = WorkspaceManager(
         project_definition=cli_context.project_definition,
@@ -191,4 +200,27 @@ def drop(
         entity_id,
         EntityActions.DROP,
         force_drop=force,
+        interactive=interactive,
+        cascade=cascade,
+    )
+
+
+@ws.command(requires_connection=True, hidden=True)
+@with_project_definition()
+def validate(
+    entity_id: str = typer.Option(
+        help=f"""The ID of the entity you want to validate.""",
+    ),
+    **options,
+):
+    """Validates the specified entity."""
+    cli_context = get_cli_context()
+    ws = WorkspaceManager(
+        project_definition=cli_context.project_definition,
+        project_root=cli_context.project_root,
+    )
+
+    ws.perform_action(
+        entity_id,
+        EntityActions.VALIDATE,
     )

snowflake/cli/_plugins/workspace/manager.py

@@ -64,6 +64,7 @@ class WorkspaceManager:
                 project_root=self.project_root(),
                 default_role=self._default_role,
                 default_warehouse=self.default_warehouse,
+                get_entity=self.get_entity,
             )
             return entity.perform(action, action_ctx, *args, **kwargs)
         else: