Add optional deploy files argument

RELEASE-NOTES.md

@@ -18,6 +18,7 @@
 * Added `--if-not-exists` option to `create` commands for `service`, and `compute-pool`. Added `--replace` and `--if-not-exists` options for `image-repository create`.
 * Added support for python connector diagnostic report.
 * Added `snow app deploy` command that creates an application package and syncs the local changes to the stage without creating or updating the application.
+* Added `snow app deploy [files]` option to sync only specific files to the stage. Can also be used to remove files that exists only on the stage.
 * `snow snowpark package create`:
   * new `--ignore-anaconda` flag disables package lookup in Snowflake Anaconda channel.
     All dependencies will be downloaded from PyPi.

src/snowflake/cli/plugins/nativeapp/commands.py

@@ -1,5 +1,6 @@
 import logging
-from typing import Optional
+from pathlib import Path
+from typing import List, Optional
 
 import typer
 from snowflake.cli.api.cli_global_context import cli_context
@@ -229,6 +230,11 @@ def app_teardown(
 @app.command("deploy", requires_connection=True)
 @with_project_definition("native_app")
 def app_deploy(
+    files: Optional[List[Path]] = typer.Argument(
+        default=None,
+        show_default=False,
+        help=f"""Paths of the files, relative to the deploy root, to be uploaded to a stage. If the path exists remotely but not locally, it will be deleted from the stage [default: sync all local changes to the stage]""",
+    ),
     **options,
 ) -> CommandResult:
     """
@@ -240,6 +246,6 @@ def app_deploy(
     )
 
     manager.build_bundle()
-    manager.deploy()
+    manager.deploy(files)
 
     return MessageResult(f"Deployed successfully.")

src/snowflake/cli/plugins/nativeapp/manager.py

@@ -270,7 +270,11 @@ def build_bundle(self) -> None:
         """
         build_bundle(self.project_root, self.deploy_root, self.artifacts)
 
-    def sync_deploy_root_with_stage(self, role: str) -> DiffResult:
+    def sync_deploy_root_with_stage(
+        self,
+        role: str,
+        files_to_sync: Optional[List[Path]] = None,
+    ) -> DiffResult:
         """
         Ensures that the files on our remote stage match the artifacts we have in
         the local filesystem. Returns the DiffResult used to make changes.
@@ -295,7 +299,7 @@ def sync_deploy_root_with_stage(self, role: str) -> DiffResult:
             "Performing a diff between the Snowflake stage and your local deploy_root ('%s') directory."
             % self.deploy_root
         )
-        diff: DiffResult = stage_diff(self.deploy_root, self.stage_fqn)
+        diff: DiffResult = stage_diff(self.deploy_root, self.stage_fqn, files_to_sync)
         cc.message(str(diff))
 
         # Upload diff-ed files to application package stage
@@ -421,7 +425,10 @@ def _apply_package_scripts(self) -> None:
                 err, role=self.package_role, warehouse=self.package_warehouse
             )
 
-    def deploy(self) -> DiffResult:
+    def deploy(
+        self,
+        files_to_sync: Optional[List[Path]] = None,
+    ) -> DiffResult:
         """app deploy process"""
 
         # 1. Create an empty application package, if none exists
@@ -432,6 +439,6 @@ def deploy(self) -> DiffResult:
             self._apply_package_scripts()
 
             # 3. Upload files from deploy root local folder to the above stage
-            diff = self.sync_deploy_root_with_stage(self.package_role)
+            diff = self.sync_deploy_root_with_stage(self.package_role, files_to_sync)
 
         return diff

src/snowflake/cli/plugins/object/stage/diff.py

@@ -1,11 +1,18 @@
 import hashlib
 import logging
+import os
 import re
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Dict, List, Optional
-
-from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
+from typing import Dict, List, Optional, Set
+
+from click.exceptions import (
+    ClickException,
+    FileError,
+)
+from snowflake.cli.api.exceptions import (
+    SnowflakeSQLExecutionError,
+)
 from snowflake.cli.api.secure_path import UNLIMITED, SecurePath
 from snowflake.connector.cursor import SnowflakeCursor
 
@@ -154,7 +161,36 @@ def build_md5_map(list_stage_cursor: SnowflakeCursor) -> Dict[str, str]:
     }
 
 
-def stage_diff(local_path: Path, stage_fqn: str) -> DiffResult:
+def _get_relative_paths_to_sync(
+    relative_files_to_sync: List[Path], local_path: Path, remote_paths: Set[str]
+) -> List[str]:
+    paths = []
+    for file in relative_files_to_sync:
+        path = Path(os.path.join(local_path, file))
+        relpath = path.relative_to(local_path)
+        if not path.exists() and str(relpath) not in remote_paths:
+            raise FileError(
+                str(file), "This file does not exist either locally or remotely"
+            )
+        elif path.is_dir():
+            raise ClickException(f"Specifying directories is not supported: '{file}'")
+        else:
+            paths.append(str(relpath))
+    return paths
+
+
+def _filter_from_diff(result: DiffResult, paths_to_keep: Set[str]) -> DiffResult:
+    result.different = [i for i in result.different if i in paths_to_keep]
+    result.only_local = [i for i in result.only_local if i in paths_to_keep]
+    result.only_on_stage = [i for i in result.only_on_stage if i in paths_to_keep]
+    return result
+
+
+def stage_diff(
+    local_path: Path,
+    stage_fqn: str,
+    files_to_sync: Optional[List[Path]] = None,  # relative to local_path
+) -> DiffResult:
     """
     Diffs the files in a stage with a local folder.
     """
@@ -190,6 +226,14 @@ def stage_diff(local_path: Path, stage_fqn: str) -> DiffResult:
     for relpath in remote_md5.keys():
         result.only_on_stage.append(relpath)
 
+    if files_to_sync is not None and len(files_to_sync) > 0:
+        paths_to_keep = set(
+            _get_relative_paths_to_sync(
+                files_to_sync, local_path, set(result.only_on_stage)
+            )
+        )
+        return _filter_from_diff(result, paths_to_keep)
+
     return result
 
 

tests/__snapshots__/test_help_messages.ambr

@@ -58,11 +58,17 @@
 # name: test_help_messages[app.deploy]
   '''
 
-   Usage: default app deploy [OPTIONS]                                            
+   Usage: default app deploy [OPTIONS] [FILES]...                                 
 
    Creates an application package in your Snowflake account and syncs the local   
    changes to the stage without creating or updating the application.             
 
+  ╭─ Arguments ──────────────────────────────────────────────────────────────────╮
+  │   files      [FILES]...  Paths of the files, relative to the deploy root, to │
+  │                          be uploaded to a stage. If the path exists remotely │
+  │                          but not locally, it will be deleted from the stage  │
+  │                          [default: sync all local changes to the stage]      │
+  ╰──────────────────────────────────────────────────────────────────────────────╯
   ╭─ Options ────────────────────────────────────────────────────────────────────╮
   │ --project  -p      TEXT  Path where the Snowflake Native App project         │
   │                          resides. Defaults to current working directory.     │

tests/nativeapp/test_manager.py

@@ -94,7 +94,7 @@ def test_sync_deploy_root_with_stage(
     ]
     assert mock_execute.mock_calls == expected
     mock_stage_diff.assert_called_once_with(
-        native_app_manager.deploy_root, "app_pkg.app_src.stage"
+        native_app_manager.deploy_root, "app_pkg.app_src.stage", None
     )
     mock_local_diff_with_stage.assert_called_once_with(
         role="new_role",

tests/object/stage/test_diff.py

@@ -1,12 +1,20 @@
 import hashlib
 from pathlib import Path
-from typing import Dict, List, Tuple, Union
+from typing import Dict, List, Set, Tuple, Union
 from unittest import mock
 
 import pytest
-from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
+from click.exceptions import (
+    ClickException,
+    FileError,
+)
+from snowflake.cli.api.exceptions import (
+    SnowflakeSQLExecutionError,
+)
 from snowflake.cli.plugins.object.stage.diff import (
     DiffResult,
+    _filter_from_diff,
+    _get_relative_paths_to_sync,
     delete_only_on_stage_files,
     enumerate_files,
     get_stage_path_from_file,
@@ -19,6 +27,7 @@
 from tests.testing_utils.files_and_dirs import temp_local_dir
 
 STAGE_MANAGER = "snowflake.cli.plugins.object.stage.manager.StageManager"
+STAGE_DIFF = "snowflake.cli.plugins.object.stage.diff"
 
 FILE_CONTENTS = {
     "README.md": "This is a README\n",
@@ -215,3 +224,90 @@ def test_sync_local_diff_with_stage(mock_remove, other_directory):
             diff_result=diff,
             stage_path=stage_name,
         )
+
+
+def exists_mock(path: Path):
+    if str(path) in ["/file", "/dir", "/dir/nested_file"]:
+        return True
+    else:
+        return False
+
+
+def is_dir_mock(path: Path):
+    if str(path) == "/dir":
+        return True
+    else:
+        return False
+
+
+# Mocking Path to mimic the following directory structure:
+# /file
+# /dir/nested_file
+@mock.patch(f"{STAGE_DIFF}.Path.is_dir", autospec=True)
+@mock.patch(f"{STAGE_DIFF}.Path.exists", autospec=True)
+@pytest.mark.parametrize(
+    "files_to_sync,remote_paths,expected_exception",
+    [
+        [["file", "dir/nested_file"], set(), None],
+        [["file", "file2", "dir/file3"], set(["file2", "dir/file3"]), None],
+        [["file", "file2"], set(), FileError],
+        [["dir/file3"], set(), FileError],
+        [["dir"], set(), ClickException],
+    ],
+)
+def test_get_full_file_paths_to_sync(
+    path_mock_exists,
+    path_mock_is_dir,
+    files_to_sync: List[Path],
+    remote_paths: Set[str],
+    expected_exception: Exception,
+):
+    path_mock_exists.side_effect = exists_mock
+    path_mock_is_dir.side_effect = is_dir_mock
+    if expected_exception is None:
+        result = _get_relative_paths_to_sync(files_to_sync, "/", remote_paths)
+        assert len(result) == len(files_to_sync)
+    else:
+        with pytest.raises(expected_exception):
+            _get_relative_paths_to_sync(files_to_sync, "/", remote_paths)
+
+
+def test_filter_from_diff():
+    diff: DiffResult = DiffResult()
+    diff.different = [
+        "different",
+        "different-2",
+        "dir/different",
+        "dir/different-2",
+    ]
+    diff.only_local = [
+        "only_local",
+        "only_local-2",
+        "dir/only_local",
+        "dir/only_local-2",
+    ]
+    diff.only_on_stage = [
+        "only_on_stage",
+        "only_on_stage-2",
+        "dir/only_on_stage",
+        "dir/only_on_stage-2",
+    ]
+
+    paths_to_keep = set(
+        [
+            "different",
+            "only-local",
+            "only-stage",
+            "dir/different",
+            "dir/only-local",
+            "dir/only-stage",
+        ]
+    )
+    diff = _filter_from_diff(diff, paths_to_keep)
+
+    for path in diff.different:
+        assert path in paths_to_keep
+    for path in diff.only_local:
+        assert path in paths_to_keep
+    for path in diff.only_on_stage:
+        assert path in paths_to_keep