snowflake-cli-labs 2.5.0rc3__py3-none-any.whl → 2.6.0.dev0__py3-none-any.whl

snowflake/cli/plugins/nativeapp/feature_flags.py

@@ -0,0 +1,24 @@
+# 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 enum import unique
+
+from snowflake.cli.api.feature_flags import BooleanFlag, FeatureFlagMixin
+
+
+@unique
+class FeatureFlag(FeatureFlagMixin):
+    ENABLE_NATIVE_APP_PYTHON_SETUP = BooleanFlag(
+        "ENABLE_NATIVE_APP_PYTHON_SETUP", False
+    )

snowflake/cli/plugins/nativeapp/init.py

@@ -21,6 +21,7 @@ from typing import Optional
 
 from click.exceptions import ClickException
 from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB
+from snowflake.cli.api.exceptions import MissingConfiguration
 from snowflake.cli.api.project.definition_manager import DefinitionManager
 from snowflake.cli.api.project.util import (
     is_valid_identifier,
@@ -197,6 +198,10 @@ def _validate_and_update_snowflake_yml(target_directory: Path, project_identifie
     """
     # 1. Determine if a snowflake.yml file exists, at the very least
     definition_manager = DefinitionManager(target_directory)
+    if not definition_manager.has_definition_file:
+        raise MissingConfiguration(
+            "Cannot find project definition (snowflake.yml). Please provide a path to the project or run this command in a valid project directory."
+        )
 
     # 2. Change the project name in snowflake.yml if necessary
     _replace_snowflake_yml_name_with_project(

snowflake/cli/plugins/nativeapp/manager.py

@@ -26,17 +26,13 @@ import jinja2
 from click import ClickException
 from snowflake.cli.api.console import cli_console as cc
 from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
-from snowflake.cli.api.project.definition import (
-    default_app_package,
-    default_application,
-    default_role,
+from snowflake.cli.api.project.schemas.native_app.application import (
+    ApplicationPostDeployHook,
 )
 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,
     identifier_for_url,
-    to_identifier,
     unquote_identifier,
 )
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
@@ -68,18 +64,21 @@ from snowflake.cli.plugins.nativeapp.exceptions import (
     SetupScriptFailedValidation,
     UnexpectedOwnerError,
 )
+from snowflake.cli.plugins.nativeapp.project_model import (
+    NativeAppProjectModel,
+)
 from snowflake.cli.plugins.nativeapp.utils import verify_exists, verify_no_directories
 from snowflake.cli.plugins.stage.diff import (
     DiffResult,
     StagePath,
     compute_stage_diff,
     preserve_from_diff,
+    print_diff_to_console,
     sync_local_diff_with_stage,
     to_stage_path,
 )
 from snowflake.cli.plugins.stage.manager import StageManager
 from snowflake.connector import ProgrammingError
-from snowflake.connector.cursor import DictCursor
 
 ApplicationOwnedObject = TypedDict("ApplicationOwnedObject", {"name": str, "type": str})
 
@@ -164,125 +163,94 @@ class NativeAppManager(SqlExecutionMixin):
 
     def __init__(self, project_definition: NativeApp, project_root: Path):
         super().__init__()
-        self._project_root = project_root
-        self._project_definition = project_definition
+        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._project_root
+        return self.na_project.project_root
 
     @property
     def definition(self) -> NativeApp:
-        return self._project_definition
+        return self.na_project.definition
 
-    @cached_property
+    @property
     def artifacts(self) -> List[PathMapping]:
-        return self.definition.artifacts
+        return self.na_project.artifacts
 
-    @cached_property
+    @property
+    def bundle_root(self) -> Path:
+        return self.na_project.bundle_root
+
+    @property
     def deploy_root(self) -> Path:
-        return Path(self.project_root, self.definition.deploy_root)
+        return self.na_project.deploy_root
 
-    @cached_property
+    @property
     def generated_root(self) -> Path:
-        return Path(self.deploy_root, self.definition.generated_root)
+        return self.na_project.generated_root
 
-    @cached_property
+    @property
     def package_scripts(self) -> List[str]:
-        """
-        Relative paths to package scripts from the project root.
-        """
-        if self.definition.package and self.definition.package.scripts:
-            return self.definition.package.scripts
-        else:
-            return []
+        return self.na_project.package_scripts
 
-    @cached_property
+    @property
     def stage_fqn(self) -> str:
-        return f"{self.package_name}.{self.definition.source_stage}"
+        return self.na_project.stage_fqn
 
-    @cached_property
+    @property
     def scratch_stage_fqn(self) -> str:
-        return f"{self.package_name}.{self.definition.scratch_stage}"
+        return self.na_project.scratch_stage_fqn
 
-    @cached_property
+    @property
     def stage_schema(self) -> Optional[str]:
-        return extract_schema(self.stage_fqn)
+        return self.na_project.stage_schema
 
-    @cached_property
+    @property
     def package_warehouse(self) -> Optional[str]:
-        if self.definition.package and self.definition.package.warehouse:
-            return self.definition.package.warehouse
-        else:
-            return self._conn.warehouse
+        return self.na_project.package_warehouse
 
-    @cached_property
+    @property
     def application_warehouse(self) -> Optional[str]:
-        if self.definition.application and self.definition.application.warehouse:
-            return self.definition.application.warehouse
-        else:
-            return self._conn.warehouse
+        return self.na_project.application_warehouse
 
-    @cached_property
+    @property
     def project_identifier(self) -> str:
-        # name is expected to be a valid Snowflake identifier, but PyYAML
-        # will sometimes strip out double quotes so we try to get them back here.
-        return to_identifier(self.definition.name)
+        return self.na_project.project_identifier
 
-    @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))
+        return self.na_project.package_name
 
-    @cached_property
+    @property
     def package_role(self) -> str:
-        if self.definition.package and self.definition.package.role:
-            return self.definition.package.role
-        else:
-            return self._default_role
+        return self.na_project.package_role
 
-    @cached_property
+    @property
     def package_distribution(self) -> str:
-        if self.definition.package and self.definition.package.distribution:
-            return self.definition.package.distribution.lower()
-        else:
-            return "internal"
+        return self.na_project.package_distribution
 
-    @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))
+        return self.na_project.app_name
 
-    @cached_property
+    @property
     def app_role(self) -> str:
-        if self.definition.application and self.definition.application.role:
-            return self.definition.application.role
-        else:
-            return self._default_role
+        return self.na_project.app_role
 
-    @cached_property
-    def _default_role(self) -> str:
-        role = default_role()
-        if role is None:
-            role = self._get_current_role()
-        return role
-
-    def _get_current_role(self) -> str:
-        role_result = self._execute_query(
-            "select current_role()", cursor_class=DictCursor
-        ).fetchone()
-        return role_result["CURRENT_ROLE()"]
+    @property
+    def app_post_deploy_hooks(self) -> Optional[List[ApplicationPostDeployHook]]:
+        return self.na_project.app_post_deploy_hooks
 
-    @cached_property
+    @property
     def debug_mode(self) -> bool:
-        if self.definition.application:
-            return self.definition.application.debug
-        else:
-            return True
+        return self.na_project.debug_mode
 
     @cached_property
     def get_app_pkg_distribution_in_snowflake(self) -> str:
@@ -341,15 +309,12 @@ class NativeAppManager(SqlExecutionMixin):
         """
         Populates the local deploy root from artifact sources.
         """
-        mapped_files = build_bundle(self.project_root, self.deploy_root, self.artifacts)
+        bundle_map = build_bundle(self.project_root, self.deploy_root, self.artifacts)
         compiler = NativeAppCompiler(
-            project_definition=self._project_definition,
-            project_root=self.project_root,
-            deploy_root=self.deploy_root,
-            generated_root=self.generated_root,
+            na_project=self.na_project,
         )
         compiler.compile_artifacts()
-        return mapped_files
+        return bundle_map
 
     def sync_deploy_root_with_stage(
         self,
@@ -359,6 +324,7 @@ class NativeAppManager(SqlExecutionMixin):
         recursive: bool,
         stage_fqn: str,
         local_paths_to_sync: List[Path] | None = None,
+        print_diff: bool = True,
     ) -> DiffResult:
         """
         Ensures that the files on our remote stage match the artifacts we have in
@@ -372,6 +338,7 @@ class NativeAppManager(SqlExecutionMixin):
             stage_fqn (str): The name of the stage to diff against and upload to.
             local_paths_to_sync (List[Path], optional): List of local paths to sync. Defaults to None to sync all
              local paths. Note that providing an empty list here is equivalent to None.
+            print_diff (bool): Whether to print the diff between the local files and the remote stage. Defaults to True
 
         Returns:
             A `DiffResult` instance describing the changes that were performed.
@@ -394,13 +361,13 @@ class NativeAppManager(SqlExecutionMixin):
             )
 
         # Perform a diff operation and display results to the user for informational purposes
-        cc.step(
-            "Performing a diff between the Snowflake stage and your local deploy_root ('%s') directory."
-            % self.deploy_root
-        )
+        if print_diff:
+            cc.step(
+                "Performing a diff between the Snowflake stage and your local deploy_root ('%s') directory."
+                % self.deploy_root.resolve()
+            )
         diff: DiffResult = compute_stage_diff(self.deploy_root, stage_fqn)
 
-        files_not_removed = []
         if local_paths_to_sync:
             # Deploying specific files/directories
             resolved_paths_to_sync = [
@@ -413,6 +380,17 @@ class NativeAppManager(SqlExecutionMixin):
             for resolved_path in resolved_paths_to_sync:
                 verify_exists(resolved_path)
                 deploy_paths = bundle_map.to_deploy_paths(resolved_path)
+                if not deploy_paths:
+                    if resolved_path.is_dir() and recursive:
+                        # No direct artifact mapping found for this path. Check to see
+                        # if there are subpaths of this directory that are matches. We
+                        # loop over sources because it's likely a much smaller list
+                        # than the project directory.
+                        for src in bundle_map.all_sources(absolute=True):
+                            if resolved_path in src.parents:
+                                # There is a source that contains this path, get its dest path(s)
+                                deploy_paths.extend(bundle_map.to_deploy_paths(src))
+
                 if not deploy_paths:
                     raise ClickException(f"No artifact found for {resolved_path}")
                 deploy_paths_to_sync.extend(deploy_paths)
@@ -424,8 +402,7 @@ class NativeAppManager(SqlExecutionMixin):
         else:
             # Full deploy
             if not recursive:
-                deploy_files = [p for p in self.deploy_root.resolve().iterdir()]
-                verify_no_directories(deploy_files)
+                verify_no_directories(self.deploy_root.resolve().iterdir())
 
         if not prune:
             files_not_removed = [str(path) for path in diff.only_on_stage]
@@ -437,13 +414,14 @@ class NativeAppManager(SqlExecutionMixin):
                     f"The following files exist only on the stage:\n{files_not_removed_str}\n\nUse the --prune flag to delete them from the stage."
                 )
 
-        cc.message(str(diff))
+        if print_diff:
+            print_diff_to_console(diff, bundle_map)
 
         # Upload diff-ed files to application package stage
         if diff.has_changes():
             cc.step(
-                "Uploading diff-ed files from your local %s directory to the Snowflake stage."
-                % self.deploy_root,
+                "Updating the Snowflake stage from your local %s directory."
+                % self.deploy_root.resolve(),
             )
             sync_local_diff_with_stage(
                 role=role,
@@ -484,6 +462,23 @@ class NativeAppManager(SqlExecutionMixin):
             ).fetchall()
             return [{"name": row[1], "type": row[2]} for row in results]
 
+    def _application_objects_to_str(
+        self, application_objects: list[ApplicationOwnedObject]
+    ) -> str:
+        """
+        Returns a list in an "(Object Type) Object Name" format. Database-level and schema-level object names are fully qualified:
+        (COMPUTE_POOL) POOL_NAME
+        (DATABASE) DB_NAME
+        (SCHEMA) DB_NAME.PUBLIC
+        ...
+        """
+        return "\n".join(
+            [self._application_object_to_str(obj) for obj in application_objects]
+        )
+
+    def _application_object_to_str(self, obj: ApplicationOwnedObject) -> str:
+        return f"({obj['type']}) {obj['name']}"
+
     def get_snowsight_url(self) -> str:
         """Returns the URL that can be used to visit this app via Snowsight."""
         name = identifier_for_url(self.app_name)
@@ -580,6 +575,7 @@ class NativeAppManager(SqlExecutionMixin):
         stage_fqn: Optional[str] = None,
         local_paths_to_sync: List[Path] | None = None,
         validate: bool = True,
+        print_diff: bool = True,
     ) -> DiffResult:
         """app deploy process"""
 
@@ -599,6 +595,7 @@ class NativeAppManager(SqlExecutionMixin):
                 recursive=recursive,
                 stage_fqn=stage_fqn,
                 local_paths_to_sync=local_paths_to_sync,
+                print_diff=print_diff,
             )
 
         if validate:
@@ -637,6 +634,7 @@ class NativeAppManager(SqlExecutionMixin):
                 recursive=True,
                 stage_fqn=stage_fqn,
                 validate=False,
+                print_diff=False,
             )
         prefixed_stage_fqn = StageManager.get_standard_stage_prefix(stage_fqn)
         try:

snowflake/cli/plugins/nativeapp/project_model.py

@@ -0,0 +1,181 @@
+# 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 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.api.project.definition import (
+    default_app_package,
+    default_application,
+    default_role,
+)
+from snowflake.cli.api.project.schemas.native_app.application import (
+    ApplicationPostDeployHook,
+)
+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:
+    """
+    Exposes properties of a native app project defined in a Snowflake Project Definition file. Whenever
+    appropriate, APIs defined in this class provide suitable defaults or fallback logic to access properties
+    of the project.
+    """
+
+    def __init__(
+        self,
+        project_definition: NativeApp,
+        project_root: Path,
+    ):
+        self._project_definition = project_definition
+        self._project_root = resolve_without_follow(project_root)
+
+    @property
+    def project_root(self) -> Path:
+        return self._project_root
+
+    @property
+    def definition(self) -> NativeApp:
+        return self._project_definition
+
+    @cached_property
+    def artifacts(self) -> List[PathMapping]:
+        return self.definition.artifacts
+
+    @cached_property
+    def bundle_root(self) -> Path:
+        return self.project_root / self.definition.bundle_root
+
+    @cached_property
+    def deploy_root(self) -> Path:
+        return self.project_root / self.definition.deploy_root
+
+    @cached_property
+    def generated_root(self) -> Path:
+        return self.deploy_root / self.definition.generated_root
+
+    @cached_property
+    def package_scripts(self) -> List[str]:
+        """
+        Relative paths to package scripts from the project root.
+        """
+        if self.definition.package and self.definition.package.scripts:
+            return self.definition.package.scripts
+        else:
+            return []
+
+    @cached_property
+    def stage_fqn(self) -> str:
+        return f"{self.package_name}.{self.definition.source_stage}"
+
+    @cached_property
+    def scratch_stage_fqn(self) -> str:
+        return f"{self.package_name}.{self.definition.scratch_stage}"
+
+    @cached_property
+    def stage_schema(self) -> Optional[str]:
+        return extract_schema(self.stage_fqn)
+
+    @cached_property
+    def package_warehouse(self) -> Optional[str]:
+        if self.definition.package and self.definition.package.warehouse:
+            return self.definition.package.warehouse
+        else:
+            return cli_context.connection.warehouse
+
+    @cached_property
+    def application_warehouse(self) -> Optional[str]:
+        if self.definition.application and self.definition.application.warehouse:
+            return self.definition.application.warehouse
+        else:
+            return cli_context.connection.warehouse
+
+    @cached_property
+    def project_identifier(self) -> str:
+        # name is expected to be a valid Snowflake identifier, but YAML parsers will
+        # sometimes strip out double quotes, so we try to get them back here.
+        return to_identifier(self.definition.name)
+
+    @cached_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))
+
+    @cached_property
+    def package_role(self) -> str:
+        if self.definition.package and self.definition.package.role:
+            return self.definition.package.role
+        else:
+            return self._default_role
+
+    @cached_property
+    def package_distribution(self) -> str:
+        if self.definition.package and self.definition.package.distribution:
+            return self.definition.package.distribution.lower()
+        else:
+            return "internal"
+
+    @cached_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))
+
+    @cached_property
+    def app_role(self) -> str:
+        if self.definition.application and self.definition.application.role:
+            return self.definition.application.role
+        else:
+            return self._default_role
+
+    @cached_property
+    def app_post_deploy_hooks(self) -> Optional[List[ApplicationPostDeployHook]]:
+        """
+        List of application post deploy hooks.
+        """
+        if self.definition.application and self.definition.application.post_deploy:
+            return self.definition.application.post_deploy
+        else:
+            return None
+
+    @cached_property
+    def _default_role(self) -> str:
+        role = default_role()
+        if role is None:
+            role = current_role()
+        return role
+
+    @cached_property
+    def debug_mode(self) -> Optional[bool]:
+        if self.definition.application:
+            return self.definition.application.debug
+        return None