snowflake-cli 2.8.2__py3-none-any.whl → 3.0.2__py3-none-any.whl

snowflake/cli/{plugins → _plugins}/nativeapp/exceptions.py

@@ -48,15 +48,6 @@ class ApplicationCreatedExternallyError(ClickException):
         )
 
 
-class UnexpectedOwnerError(ClickException):
-    """An operation is blocked because an object is owned by an unexpected role."""
-
-    def __init__(self, item: str, expected_owner: str, actual_owner: str):
-        super().__init__(
-            f"Cannot operate on {item}: owned by {actual_owner} (expected {expected_owner})"
-        )
-
-
 class MissingScriptError(ClickException):
     """A referenced script was not found."""
 
@@ -64,15 +55,15 @@ class MissingScriptError(ClickException):
         super().__init__(f'Script "{relpath}" does not exist')
 
 
-class InvalidScriptError(ClickException):
-    """A referenced script had syntax error(s)."""
+class InvalidTemplateInFileError(ClickException):
+    """A referenced templated file had syntax error(s)."""
 
     def __init__(
         self, relpath: str, err: jinja2.TemplateError, lineno: Optional[int] = None
     ):
         lineno_str = f":{lineno}" if lineno is not None else ""
         super().__init__(
-            f'Script "{relpath}{lineno_str}" does not contain a valid template: {err.message}'
+            f'File "{relpath}{lineno_str}" does not contain a valid template: {err.message}'
         )
         self.err = err
 

snowflake/cli/_plugins/nativeapp/manager.py

@@ -0,0 +1,415 @@
+# 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 abc import ABC, abstractmethod
+from datetime import datetime
+from functools import cached_property
+from pathlib import Path
+from typing import Generator, List, Optional
+
+from snowflake.cli._plugins.nativeapp.artifacts import (
+    BundleMap,
+)
+from snowflake.cli._plugins.nativeapp.entities.application import (
+    ApplicationEntity,
+    ApplicationOwnedObject,
+)
+from snowflake.cli._plugins.nativeapp.entities.application_package import (
+    ApplicationPackageEntity,
+)
+from snowflake.cli._plugins.nativeapp.policy import AllowAlwaysPolicy, PolicyBase
+from snowflake.cli._plugins.nativeapp.project_model import (
+    NativeAppProjectModel,
+)
+from snowflake.cli._plugins.stage.diff import (
+    DiffResult,
+)
+from snowflake.cli.api.console import cli_console as cc
+from snowflake.cli.api.entities.utils import (
+    execute_post_deploy_hooks,
+    sync_deploy_root_with_stage,
+)
+from snowflake.cli.api.project.schemas.entities.common import PostDeployHook
+from snowflake.cli.api.project.schemas.v1.native_app.native_app import NativeApp
+from snowflake.cli.api.project.schemas.v1.native_app.path_mapping import PathMapping
+
+
+class NativeAppCommandProcessor(ABC):
+    @abstractmethod
+    def process(self, *args, **kwargs):
+        pass
+
+
+class NativeAppManager:
+    """
+    Base class with frequently used functionality already implemented and ready to be used by related subclasses.
+    """
+
+    def __init__(self, project_definition: NativeApp, project_root: Path):
+        super().__init__()
+        self._na_project = NativeAppProjectModel(
+            project_definition=project_definition,
+            project_root=project_root,
+        )
+
+    @property
+    def na_project(self) -> NativeAppProjectModel:
+        return self._na_project
+
+    @property
+    def project_root(self) -> Path:
+        return self.na_project.project_root
+
+    @property
+    def definition(self) -> NativeApp:
+        return self.na_project.definition
+
+    @property
+    def artifacts(self) -> List[PathMapping]:
+        return self.na_project.artifacts
+
+    @property
+    def bundle_root(self) -> Path:
+        return self.na_project.bundle_root
+
+    @property
+    def deploy_root(self) -> Path:
+        return self.na_project.deploy_root
+
+    @property
+    def generated_root(self) -> Path:
+        return self.na_project.generated_root
+
+    @property
+    def package_scripts(self) -> List[str]:
+        return self.na_project.package_scripts
+
+    @property
+    def stage_fqn(self) -> str:
+        return self.na_project.stage_fqn
+
+    @property
+    def scratch_stage_fqn(self) -> str:
+        return self.na_project.scratch_stage_fqn
+
+    @property
+    def stage_schema(self) -> Optional[str]:
+        return self.na_project.stage_schema
+
+    @property
+    def package_warehouse(self) -> Optional[str]:
+        return self.na_project.package_warehouse
+
+    def use_package_warehouse(self):
+        return ApplicationPackageEntity.use_package_warehouse(
+            self.package_warehouse,
+        )
+
+    @property
+    def application_warehouse(self) -> Optional[str]:
+        return self.na_project.application_warehouse
+
+    @property
+    def project_identifier(self) -> str:
+        return self.na_project.project_identifier
+
+    @property
+    def package_name(self) -> str:
+        return self.na_project.package_name
+
+    @property
+    def package_role(self) -> str:
+        return self.na_project.package_role
+
+    @property
+    def package_distribution(self) -> str:
+        return self.na_project.package_distribution
+
+    @property
+    def app_name(self) -> str:
+        return self.na_project.app_name
+
+    @property
+    def app_role(self) -> str:
+        return self.na_project.app_role
+
+    @property
+    def app_post_deploy_hooks(self) -> Optional[List[PostDeployHook]]:
+        return self.na_project.app_post_deploy_hooks
+
+    @property
+    def package_post_deploy_hooks(self) -> Optional[List[PostDeployHook]]:
+        return self.na_project.package_post_deploy_hooks
+
+    @property
+    def debug_mode(self) -> bool:
+        return self.na_project.debug_mode
+
+    @cached_property
+    def get_app_pkg_distribution_in_snowflake(self) -> str:
+        return ApplicationPackageEntity.get_app_pkg_distribution_in_snowflake(
+            self.package_name, self.package_role
+        )
+
+    @cached_property
+    def account_event_table(self) -> str:
+        return ApplicationEntity.get_account_event_table()
+
+    def verify_project_distribution(
+        self, expected_distribution: Optional[str] = None
+    ) -> bool:
+        return ApplicationPackageEntity.verify_project_distribution(
+            console=cc,
+            package_name=self.package_name,
+            package_role=self.package_role,
+            package_distribution=self.package_distribution,
+            expected_distribution=expected_distribution,
+        )
+
+    def build_bundle(self) -> BundleMap:
+        """
+        Populates the local deploy root from artifact sources.
+        """
+        return ApplicationPackageEntity.bundle(
+            project_root=self.project_root,
+            deploy_root=self.deploy_root,
+            bundle_root=self.bundle_root,
+            generated_root=self.generated_root,
+            package_name=self.package_name,
+            artifacts=self.artifacts,
+        )
+
+    def sync_deploy_root_with_stage(
+        self,
+        bundle_map: BundleMap,
+        role: str,
+        prune: bool,
+        recursive: bool,
+        stage_fqn: str,
+        local_paths_to_sync: List[Path] | None = None,
+        print_diff: bool = True,
+    ) -> DiffResult:
+        return sync_deploy_root_with_stage(
+            console=cc,
+            deploy_root=self.deploy_root,
+            package_name=self.package_name,
+            stage_schema=self.stage_schema,
+            bundle_map=bundle_map,
+            role=role,
+            prune=prune,
+            recursive=recursive,
+            stage_fqn=stage_fqn,
+            local_paths_to_sync=local_paths_to_sync,
+            print_diff=print_diff,
+        )
+
+    def get_existing_app_info(self) -> Optional[dict]:
+        return ApplicationEntity.get_existing_app_info(
+            app_name=self.app_name,
+            app_role=self.app_role,
+        )
+
+    def get_existing_app_pkg_info(self) -> Optional[dict]:
+        return ApplicationPackageEntity.get_existing_app_pkg_info(
+            package_name=self.package_name,
+            package_role=self.package_role,
+        )
+
+    def get_objects_owned_by_application(self):
+        return ApplicationEntity.get_objects_owned_by_application(
+            app_name=self.app_name,
+            app_role=self.app_role,
+        )
+
+    def _application_objects_to_str(
+        self, application_objects: list[ApplicationOwnedObject]
+    ) -> str:
+        return ApplicationEntity.application_objects_to_str(application_objects)
+
+    def _application_object_to_str(self, obj: ApplicationOwnedObject):
+        return ApplicationEntity.application_object_to_str(obj)
+
+    def get_snowsight_url(self) -> str:
+        """Returns the URL that can be used to visit this app via Snowsight."""
+        return ApplicationEntity.get_snowsight_url(
+            self.app_name, self.application_warehouse
+        )
+
+    def create_app_package(self) -> None:
+        return ApplicationPackageEntity.create_app_package(
+            console=cc,
+            package_name=self.package_name,
+            package_role=self.package_role,
+            package_distribution=self.package_distribution,
+        )
+
+    def _apply_package_scripts(self) -> None:
+        return ApplicationPackageEntity.apply_package_scripts(
+            console=cc,
+            package_scripts=self.package_scripts,
+            package_warehouse=self.package_warehouse,
+            project_root=self.project_root,
+            package_role=self.package_role,
+            package_name=self.package_name,
+        )
+
+    def execute_package_post_deploy_hooks(self) -> None:
+        execute_post_deploy_hooks(
+            console=cc,
+            project_root=self.project_root,
+            post_deploy_hooks=self.package_post_deploy_hooks,
+            deployed_object_type="application package",
+            database_name=self.package_name,
+        )
+
+    def execute_app_post_deploy_hooks(self) -> None:
+        execute_post_deploy_hooks(
+            console=cc,
+            project_root=self.project_root,
+            post_deploy_hooks=self.app_post_deploy_hooks,
+            deployed_object_type="application",
+            database_name=self.app_name,
+        )
+
+    def deploy(
+        self,
+        bundle_map: BundleMap,
+        prune: bool,
+        recursive: bool,
+        policy: PolicyBase,
+        stage_fqn: Optional[str] = None,
+        local_paths_to_sync: List[Path] | None = None,
+        validate: bool = True,
+        print_diff: bool = True,
+    ) -> DiffResult:
+        return ApplicationPackageEntity.deploy(
+            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,
+            bundle_map=bundle_map,
+            package_name=self.package_name,
+            package_role=self.package_role,
+            package_distribution=self.package_distribution,
+            prune=prune,
+            recursive=recursive,
+            paths=local_paths_to_sync,
+            print_diff=print_diff,
+            validate=validate,
+            stage_fqn=stage_fqn or self.stage_fqn,
+            package_warehouse=self.package_warehouse,
+            post_deploy_hooks=self.package_post_deploy_hooks,
+            package_scripts=self.package_scripts,
+            policy=policy,
+        )
+
+    def validate(self, use_scratch_stage: bool = False):
+        return ApplicationPackageEntity.validate_setup_script(
+            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=[],
+            stage_fqn=self.stage_fqn,
+            package_warehouse=self.package_warehouse,
+            post_deploy_hooks=self.package_post_deploy_hooks,
+            package_scripts=self.package_scripts,
+            policy=AllowAlwaysPolicy(),
+            use_scratch_stage=use_scratch_stage,
+            scratch_stage_fqn=self.scratch_stage_fqn,
+        )
+
+    def get_validation_result(self, use_scratch_stage: bool = False):
+        return ApplicationPackageEntity.get_validation_result(
+            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=[],
+            stage_fqn=self.stage_fqn,
+            package_warehouse=self.package_warehouse,
+            post_deploy_hooks=self.package_post_deploy_hooks,
+            package_scripts=self.package_scripts,
+            policy=AllowAlwaysPolicy(),
+            use_scratch_stage=use_scratch_stage,
+            scratch_stage_fqn=self.scratch_stage_fqn,
+        )
+
+    def get_events(  # type: ignore
+        self,
+        since: str | datetime | None = None,
+        until: str | datetime | None = None,
+        record_types: list[str] | None = None,
+        scopes: list[str] | None = None,
+        consumer_org: str = "",
+        consumer_account: str = "",
+        consumer_app_hash: str = "",
+        first: int = -1,
+        last: int = -1,
+    ) -> list[dict]:
+        return ApplicationEntity.get_events(
+            app_name=self.app_name,
+            package_name=self.package_name,
+            since=since,
+            until=until,
+            record_types=record_types,
+            scopes=scopes,
+            consumer_org=consumer_org,
+            consumer_account=consumer_account,
+            consumer_app_hash=consumer_app_hash,
+            first=first,
+            last=last,
+        )
+
+    def stream_events(
+        self,
+        interval_seconds: int,
+        since: str | datetime | None = None,
+        record_types: list[str] | None = None,
+        scopes: list[str] | None = None,
+        consumer_org: str = "",
+        consumer_account: str = "",
+        consumer_app_hash: str = "",
+        last: int = -1,
+    ) -> Generator[dict, None, None]:
+        return ApplicationEntity.stream_events(
+            app_name=self.app_name,
+            package_name=self.package_name,
+            interval_seconds=interval_seconds,
+            since=since,
+            record_types=record_types,
+            scopes=scopes,
+            consumer_org=consumer_org,
+            consumer_account=consumer_account,
+            consumer_app_hash=consumer_app_hash,
+            last=last,
+        )

snowflake/cli/{plugins/connection → _plugins/nativeapp}/plugin_spec.py

@@ -12,13 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from snowflake.cli._plugins.nativeapp import commands
 from snowflake.cli.api.plugins.command import (
     SNOWCLI_ROOT_COMMAND_PATH,
     CommandSpec,
     CommandType,
     plugin_hook_impl,
 )
-from snowflake.cli.plugins.connection import commands
 
 
 @plugin_hook_impl

snowflake/cli/{plugins → _plugins}/nativeapp/policy.py

@@ -27,6 +27,9 @@ class PolicyBase(ABC):
     def should_proceed(self, user_prompt: Optional[str]) -> bool:
         pass
 
+    def __eq__(self, value: object) -> bool:
+        return self.__class__ == value.__class__
+
 
 class AllowAlwaysPolicy(PolicyBase):
     """Always allow a Snowflake CLI command to continue execution."""

snowflake/cli/{plugins → _plugins}/nativeapp/project_model.py

@@ -18,27 +18,23 @@ from functools import cached_property
 from pathlib import Path
 from typing import List, Optional
 
-from snowflake.cli.api.cli_global_context import cli_context
+from snowflake.cli._plugins.nativeapp.artifacts import resolve_without_follow
+from snowflake.cli._plugins.nativeapp.bundle_context import BundleContext
+from snowflake.cli.api.cli_global_context import get_cli_context
+from snowflake.cli.api.entities.common import get_sql_executor
 from snowflake.cli.api.project.definition import (
     default_app_package,
     default_application,
     default_role,
 )
-from snowflake.cli.api.project.schemas.native_app.application import (
-    PostDeployHook,
+from snowflake.cli.api.project.schemas.entities.common import PostDeployHook
+from snowflake.cli.api.project.schemas.v1.native_app.native_app import NativeApp
+from snowflake.cli.api.project.schemas.v1.native_app.path_mapping import PathMapping
+from snowflake.cli.api.project.util import (
+    append_test_resource_suffix,
+    extract_schema,
+    to_identifier,
 )
-from snowflake.cli.api.project.schemas.native_app.native_app import NativeApp
-from snowflake.cli.api.project.schemas.native_app.path_mapping import PathMapping
-from snowflake.cli.api.project.util import extract_schema, to_identifier
-from snowflake.cli.plugins.nativeapp.artifacts import resolve_without_follow
-from snowflake.connector import DictCursor
-
-
-def current_role() -> str:
-    conn = cli_context.connection
-    *_, cursor = conn.execute_string("select current_role()", cursor_class=DictCursor)
-    role_result = cursor.fetchone()
-    return role_result["CURRENT_ROLE()"]
 
 
 class NativeAppProjectModel:
@@ -107,6 +103,7 @@ class NativeAppProjectModel:
         if self.definition.package and self.definition.package.warehouse:
             return to_identifier(self.definition.package.warehouse)
         else:
+            cli_context = get_cli_context()
             if cli_context.connection.warehouse:
                 return to_identifier(cli_context.connection.warehouse)
             return None
@@ -116,6 +113,7 @@ class NativeAppProjectModel:
         if self.definition.application and self.definition.application.warehouse:
             return to_identifier(self.definition.application.warehouse)
         else:
+            cli_context = get_cli_context()
             if cli_context.connection.warehouse:
                 return to_identifier(cli_context.connection.warehouse)
             return None
@@ -126,12 +124,16 @@ class NativeAppProjectModel:
         # sometimes strip out double quotes, so we try to get them back here.
         return to_identifier(self.definition.name)
 
-    @cached_property
+    @property
     def package_name(self) -> str:
         if self.definition.package and self.definition.package.name:
             return to_identifier(self.definition.package.name)
         else:
-            return to_identifier(default_app_package(self.project_identifier))
+            # V1.0 PDF doesn't support templating, so if the identifier isn't
+            # explicitly specified, the default is generated here,
+            # so we have to append the test resource suffix here
+            name = default_app_package(self.project_identifier)
+            return to_identifier(append_test_resource_suffix(name))
 
     @cached_property
     def package_role(self) -> str:
@@ -147,12 +149,16 @@ class NativeAppProjectModel:
         else:
             return "internal"
 
-    @cached_property
+    @property
     def app_name(self) -> str:
         if self.definition.application and self.definition.application.name:
             return to_identifier(self.definition.application.name)
         else:
-            return to_identifier(default_application(self.project_identifier))
+            # V1.0 PDF doesn't support templating, so if the identifier isn't
+            # explicitly specified, the default is generated here,
+            # so we have to append the test resource suffix here
+            name = default_application(self.project_identifier)
+            return to_identifier(append_test_resource_suffix(name))
 
     @cached_property
     def app_role(self) -> str:
@@ -185,7 +191,7 @@ class NativeAppProjectModel:
     def _default_role(self) -> str:
         role = default_role()
         if role is None:
-            role = current_role()
+            role = get_sql_executor().current_role()
         return role
 
     @cached_property
@@ -193,3 +199,13 @@ class NativeAppProjectModel:
         if self.definition.application:
             return self.definition.application.debug
         return None
+
+    def get_bundle_context(self) -> BundleContext:
+        return BundleContext(
+            package_name=self.package_name,
+            artifacts=self.artifacts,
+            project_root=self.project_root,
+            bundle_root=self.bundle_root,
+            deploy_root=self.deploy_root,
+            generated_root=self.generated_root,
+        )