snowflake-cli 3.2.2__py3-none-any.whl → 3.4.1__py3-none-any.whl

snowflake/cli/_plugins/nativeapp/utils.py

@@ -96,3 +96,14 @@ def verify_no_directories(paths_to_sync: Iterable[Path]):
 def verify_exists(path: Path):
     if not path.exists():
         raise ClickException(f"The following path does not exist: {path}")
+
+
+def sanitize_dir_name(dir_name: str) -> str:
+    """
+    Returns a string that is safe to use as a directory name.
+    For simplicity, this function is over restricitive: it strips non alphanumeric characters,
+    unless listed in the allow list. Additional characters can be allowed in the future, but
+    we need to be careful to consider both Unix/Windows directory naming rules.
+    """
+    allowed_chars = [" ", "_"]
+    return "".join(char for char in dir_name if char in allowed_chars or char.isalnum())

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

@@ -46,7 +46,7 @@ APP_AND_PACKAGE_OPTIONS = [
         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.",
+            help="The ID of the package entity on which to operate when the definition_version is 2 or higher.",
         ),
     ),
     inspect.Parameter(
@@ -55,7 +55,7 @@ APP_AND_PACKAGE_OPTIONS = [
         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.",
+            help="The ID of the application entity on which to operate when the definition_version is 2 or higher.",
         ),
     ),
 ]
@@ -217,7 +217,11 @@ def force_project_definition_v2(
                     entities_to_keep.add(app_definition.entity_id)
                     kwargs["app_entity_id"] = app_definition.entity_id
                 for entity_id in list(original_pdf.entities):
-                    if entity_id not in entities_to_keep:
+                    entity_type = original_pdf.entities[entity_id].type.lower()
+                    if (
+                        entity_type in ["application", "application package"]
+                        and entity_id not in entities_to_keep
+                    ):
                         # This happens after templates are rendered,
                         # so we can safely remove the entity
                         del original_pdf.entities[entity_id]

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

@@ -18,6 +18,7 @@ import logging
 from typing import Optional
 
 import typer
+from snowflake.cli._plugins.nativeapp.artifacts import VersionInfo
 from snowflake.cli._plugins.nativeapp.common_flags import ForceOption, InteractiveOption
 from snowflake.cli._plugins.nativeapp.v2_conversions.compat import (
     force_project_definition_v2,
@@ -28,8 +29,15 @@ from snowflake.cli.api.commands.decorators import (
     with_project_definition,
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
-from snowflake.cli.api.entities.common import EntityActions
-from snowflake.cli.api.output.types import CommandResult, MessageResult, QueryResult
+from snowflake.cli.api.entities.utils import EntityActions
+from snowflake.cli.api.output.formats import OutputFormat
+from snowflake.cli.api.output.types import (
+    CollectionResult,
+    CommandResult,
+    MessageResult,
+    ObjectResult,
+)
+from snowflake.cli.api.project.util import to_identifier
 
 app = SnowTyperFactory(
     name="version",
@@ -64,6 +72,12 @@ def create(
         help="When enabled, the Snowflake CLI skips checking if your project has any untracked or stages files in git. Default: unset.",
         is_flag=True,
     ),
+    from_stage: bool = typer.Option(
+        False,
+        "--from-stage",
+        help="When enabled, the Snowflake CLI creates a version from the current application package stage without syncing to the stage first.",
+        is_flag=True,
+    ),
     interactive: bool = InteractiveOption,
     force: Optional[bool] = ForceOption,
     **options,
@@ -78,7 +92,7 @@ def create(
         project_root=cli_context.project_root,
     )
     package_id = options["package_entity_id"]
-    ws.perform_action(
+    result: VersionInfo = ws.perform_action(
         package_id,
         EntityActions.VERSION_CREATE,
         version=version,
@@ -87,8 +101,21 @@ def create(
         force=force,
         interactive=interactive,
         skip_git_check=skip_git_check,
+        from_stage=from_stage,
     )
-    return MessageResult(f"Version create is now complete.")
+
+    message = "Version create is now complete."
+    if cli_context.output_format == OutputFormat.JSON:
+        return ObjectResult(
+            {
+                "message": message,
+                "version": to_identifier(result.version_name),
+                "patch": result.patch_number,
+                "label": result.label,
+            }
+        )
+    else:
+        return MessageResult(message)
 
 
 @app.command("list", requires_connection=True)
@@ -110,7 +137,7 @@ def version_list(
         package_id,
         EntityActions.VERSION_LIST,
     )
-    return QueryResult(cursor)
+    return CollectionResult(cursor)
 
 
 @app.command(requires_connection=True)

snowflake/cli/_plugins/notebook/commands.py

@@ -15,12 +15,28 @@
 import logging
 
 import typer
+from click import UsageError
 from snowflake.cli._plugins.notebook.manager import NotebookManager
+from snowflake.cli._plugins.notebook.notebook_entity_model import NotebookEntityModel
 from snowflake.cli._plugins.notebook.types import NotebookStagePath
-from snowflake.cli.api.commands.flags import identifier_argument
+from snowflake.cli._plugins.workspace.manager import WorkspaceManager
+from snowflake.cli.api.cli_global_context import get_cli_context
+from snowflake.cli.api.commands.decorators import (
+    with_project_definition,
+)
+from snowflake.cli.api.commands.flags import (
+    ReplaceOption,
+    entity_argument,
+    identifier_argument,
+)
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
+from snowflake.cli.api.commands.utils import get_entity_for_operation
+from snowflake.cli.api.entities.common import EntityActions
 from snowflake.cli.api.identifiers import FQN
-from snowflake.cli.api.output.types import MessageResult
+from snowflake.cli.api.output.types import (
+    CommandResult,
+    MessageResult,
+)
 from typing_extensions import Annotated
 
 app = SnowTyperFactory(
@@ -84,3 +100,40 @@ def create(
         notebook_file=notebook_file,
     )
     return MessageResult(message=notebook_url)
+
+
+@app.command(requires_connection=True)
+@with_project_definition()
+def deploy(
+    entity_id: str = entity_argument("notebook"),
+    replace: bool = ReplaceOption(
+        help="Replace notebook object if it already exists.",
+    ),
+    **options,
+) -> CommandResult:
+    """Uploads a notebook and required files to a stage and creates a Snowflake notebook."""
+    cli_context = get_cli_context()
+    pd = cli_context.project_definition
+    if not pd.meets_version_requirement("2"):
+        raise UsageError(
+            "This command requires project definition of version at least 2."
+        )
+
+    notebook: NotebookEntityModel = get_entity_for_operation(
+        cli_context=cli_context,
+        entity_id=entity_id,
+        project_definition=pd,
+        entity_type="notebook",
+    )
+    ws = WorkspaceManager(
+        project_definition=cli_context.project_definition,
+        project_root=cli_context.project_root,
+    )
+    notebook_url = ws.perform_action(
+        notebook.entity_id,
+        EntityActions.DEPLOY,
+        replace=replace,
+    )
+    return MessageResult(
+        f"Notebook successfully deployed and available under {notebook_url}"
+    )

snowflake/cli/_plugins/notebook/exceptions.py

@@ -15,6 +15,6 @@
 from click.exceptions import ClickException
 
 
-class NotebookStagePathError(ClickException):
+class NotebookFilePathError(ClickException):
     def __init__(self, path: str):
         super().__init__(f"Cannot extract notebook file name from {path=}")

snowflake/cli/_plugins/notebook/manager.py

@@ -16,11 +16,12 @@ from pathlib import Path
 from textwrap import dedent
 
 from snowflake.cli._plugins.connection.util import make_snowsight_url
-from snowflake.cli._plugins.notebook.exceptions import NotebookStagePathError
+from snowflake.cli._plugins.notebook.exceptions import NotebookFilePathError
 from snowflake.cli._plugins.notebook.types import NotebookStagePath
 from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
+from snowflake.cli.api.stage_path import StagePath
 
 
 class NotebookManager(SqlExecutionMixin):
@@ -39,10 +40,11 @@ class NotebookManager(SqlExecutionMixin):
     def parse_stage_as_path(notebook_file: str) -> Path:
         """Parses notebook file path to pathlib.Path."""
         if not notebook_file.endswith(".ipynb"):
-            raise NotebookStagePathError(notebook_file)
-        stage_path = Path(notebook_file)
-        if len(stage_path.parts) < 2:
-            raise NotebookStagePathError(notebook_file)
+            raise NotebookFilePathError(notebook_file)
+        # we don't perform any operations on the path, so we don't need to differentiate git repository paths
+        stage_path = StagePath.from_stage_str(notebook_file)
+        if len(stage_path.parts) < 1:
+            raise NotebookFilePathError(notebook_file)
 
         return stage_path
 

snowflake/cli/_plugins/notebook/notebook_entity.py

@@ -0,0 +1,120 @@
+import functools
+
+from click import ClickException
+from snowflake.cli._plugins.connection.util import make_snowsight_url
+from snowflake.cli._plugins.notebook.notebook_entity_model import NotebookEntityModel
+from snowflake.cli._plugins.notebook.notebook_project_paths import NotebookProjectPaths
+from snowflake.cli._plugins.stage.manager import StageManager
+from snowflake.cli._plugins.workspace.context import ActionContext
+from snowflake.cli.api.artifacts.utils import bundle_artifacts
+from snowflake.cli.api.cli_global_context import get_cli_context
+from snowflake.cli.api.console.console import cli_console
+from snowflake.cli.api.entities.common import EntityBase
+from snowflake.cli.api.stage_path import StagePath
+from snowflake.connector import ProgrammingError
+from snowflake.connector.cursor import SnowflakeCursor
+
+_DEFAULT_NOTEBOOK_STAGE_NAME = "@notebooks"
+
+
+class NotebookEntity(EntityBase[NotebookEntityModel]):
+    """
+    A notebook.
+    """
+
+    @functools.cached_property
+    def _stage_path(self) -> StagePath:
+        stage_path = self.model.stage_path
+        if stage_path is None:
+            stage_path = f"{_DEFAULT_NOTEBOOK_STAGE_NAME}/{self.fqn.name}"
+        return StagePath.from_stage_str(stage_path)
+
+    @functools.cached_property
+    def _project_paths(self):
+        return NotebookProjectPaths(get_cli_context().project_root)
+
+    def _object_exists(self) -> bool:
+        # currently notebook objects are not supported by object manager - re-implementing "exists"
+        try:
+            self.action_describe()
+            return True
+        except ProgrammingError:
+            return False
+
+    def _upload_artifacts(self):
+        stage_fqn = self._stage_path.stage_fqn
+        stage_manager = StageManager()
+        cli_console.step(f"Creating stage {stage_fqn} if not exists")
+        stage_manager.create(fqn=stage_fqn)
+
+        cli_console.step("Uploading artifacts")
+
+        # creating bundle map to handle glob patterns logic
+        bundle_map = bundle_artifacts(self._project_paths, self.model.artifacts)
+        for absolute_src, absolute_dest in bundle_map.all_mappings(
+            absolute=True, expand_directories=True
+        ):
+            artifact_stage_path = self._stage_path / (
+                absolute_dest.relative_to(self._project_paths.bundle_root).parent
+            )
+            stage_manager.put(
+                local_path=absolute_src, stage_path=artifact_stage_path, overwrite=True
+            )
+
+    def get_create_sql(self, replace: bool) -> str:
+        main_file_stage_path = self._stage_path / (
+            self.model.notebook_file.absolute().relative_to(
+                self._project_paths.project_root
+            )
+        )
+        query = "CREATE OR REPLACE " if replace else "CREATE "
+        query += (
+            f"NOTEBOOK {self.fqn.sql_identifier}\n"
+            f"FROM '{main_file_stage_path.stage_with_at}'\n"
+            f"QUERY_WAREHOUSE = '{self.model.query_warehouse}'\n"
+            f"MAIN_FILE = '{main_file_stage_path.path}'"
+        )
+        if self.model.compute_pool:
+            query += f"\nCOMPUTE_POOL = '{self.model.compute_pool}'"
+        if self.model.runtime_name:
+            query += f"\nRUNTIME_NAME = '{self.model.runtime_name}'"
+
+        query += (
+            ";\n// Cannot use IDENTIFIER(...)"
+            f"\nALTER NOTEBOOK {self.fqn.identifier} ADD LIVE VERSION FROM LAST;"
+        )
+        return query
+
+    def action_describe(self) -> SnowflakeCursor:
+        return self._sql_executor.execute_query(self.get_describe_sql())
+
+    def action_create(self, replace: bool) -> str:
+        self._sql_executor.execute_query(self.get_create_sql(replace))
+        return make_snowsight_url(
+            self._conn,
+            f"/#/notebooks/{self.fqn.using_connection(self._conn).url_identifier}",
+        )
+
+    def action_deploy(
+        self,
+        action_ctx: ActionContext,
+        replace: bool,
+        *args,
+        **kwargs,
+    ) -> str:
+        if self._object_exists():
+            if not replace:
+                raise ClickException(
+                    f"Notebook {self.fqn.name} already exists. Consider using --replace."
+                )
+        with cli_console.phase(f"Uploading artifacts to {self._stage_path}"):
+            self._upload_artifacts()
+        with cli_console.phase(f"Creating notebook {self.fqn}"):
+            return self.action_create(replace=replace)
+
+    # complementary actions, currently not used - to be implemented in future
+    def action_drop(self, *args, **kwargs):
+        raise ClickException("action DROP not supported by NOTEBOOK entity")
+
+    def action_teardown(self, *args, **kwargs):
+        raise ClickException("action TEARDOWN not supported by NOTEBOOK entity")

snowflake/cli/_plugins/notebook/notebook_entity_model.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Literal, Optional
+
+from pydantic import Field, model_validator
+from snowflake.cli._plugins.notebook.exceptions import NotebookFilePathError
+from snowflake.cli.api.project.schemas.entities.common import (
+    EntityModelBaseWithArtifacts,
+)
+from snowflake.cli.api.project.schemas.updatable_model import (
+    DiscriminatorField,
+)
+
+
+class NotebookEntityModel(EntityModelBaseWithArtifacts):
+    type: Literal["notebook"] = DiscriminatorField()  # noqa: A003
+    stage_path: Optional[str] = Field(
+        title="Stage directory in which the notebook file will be stored", default=None
+    )
+    notebook_file: Path = Field(title="Notebook file")
+    query_warehouse: str = Field(title="Snowflake warehouse to execute the notebook")
+    compute_pool: Optional[str] = Field(
+        title="Compute pool to run the notebook in", default=None
+    )
+    runtime_name: Optional[str] = Field(title="Container Runtime for ML", default=None)
+
+    @model_validator(mode="after")
+    def validate_notebook_file(self):
+        if not self.notebook_file.exists():
+            raise ValueError(f"Notebook file {self.notebook_file} does not exist")
+        if self.notebook_file.suffix.lower() != ".ipynb":
+            raise NotebookFilePathError(str(self.notebook_file))
+        return self
+
+    @model_validator(mode="after")
+    def validate_container_setup(self):
+        if self.compute_pool and not self.runtime_name:
+            raise ValueError("compute_pool is specified without runtime_name")
+        if self.runtime_name and not self.compute_pool and not self:
+            raise ValueError("runtime_name is specified without compute_pool")
+        return self

snowflake/cli/_plugins/notebook/notebook_project_paths.py

@@ -0,0 +1,15 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+from snowflake.cli.api.project.project_paths import ProjectPaths, bundle_root
+
+
+@dataclass
+class NotebookProjectPaths(ProjectPaths):
+    """
+    This class allows you to manage files paths related to given project.
+    """
+
+    @property
+    def bundle_root(self) -> Path:
+        return bundle_root(self.project_root, "notebook")

snowflake/cli/_plugins/notebook/types.py

@@ -12,4 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from pathlib import Path
+
 NotebookStagePath = str
+NotebookLocalPath = Path

snowflake/cli/_plugins/snowpark/commands.py

@@ -39,7 +39,9 @@ from snowflake.cli._plugins.snowpark.common import (
     SnowparkEntities,
     SnowparkObject,
     SnowparkObjectManager,
-    StageToArtefactMapping,
+    StageToArtifactMapping,
+    map_path_mapping_to_artifact,
+    zip_and_copy_artifacts_to_deploy,
 )
 from snowflake.cli._plugins.snowpark.package.anaconda_packages import (
     AnacondaPackages,
@@ -68,6 +70,7 @@ from snowflake.cli.api.commands.decorators import (
     with_project_definition,
 )
 from snowflake.cli.api.commands.flags import (
+    ForceReplaceOption,
     ReplaceOption,
     execution_identifier_argument,
     identifier_argument,
@@ -81,6 +84,7 @@ from snowflake.cli.api.constants import (
 from snowflake.cli.api.exceptions import (
     SecretsWithoutExternalAccessIntegrationError,
 )
+from snowflake.cli.api.feature_flags import FeatureFlag
 from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.output.types import (
     CollectionResult,
@@ -125,8 +129,9 @@ LikeOption = like_option(
 @with_project_definition()
 def deploy(
     replace: bool = ReplaceOption(
-        help="Replaces procedure or function, even if no detected changes to metadata"
+        help="Replaces procedure or function if there were changes in the definition."
     ),
+    force_replace: bool = ForceReplaceOption(),
     **options,
 ) -> CommandResult:
     """
@@ -156,7 +161,11 @@ def deploy(
     with cli_console.phase("Checking remote state"):
         om = ObjectManager()
         _check_if_all_defined_integrations_exists(om, snowpark_entities)
-        existing_objects = check_for_existing_objects(om, replace, snowpark_entities)
+        existing_objects = (
+            {}
+            if force_replace
+            else check_for_existing_objects(om, replace, snowpark_entities)
+        )
 
     with cli_console.phase("Preparing required stages and artifacts"):
         entities_to_imports_map, stages_to_artifact_map = build_artifacts_mappings(
@@ -189,11 +198,11 @@ def validate_all_artifacts_exists(
     project_paths: SnowparkProjectPaths, snowpark_entities: SnowparkEntities
 ):
     for key, entity in snowpark_entities.items():
-        for artefact in entity.artifacts:
-            path = project_paths.get_artefact_dto(artefact).post_build_path
+        for artifact in entity.artifacts:
+            path = project_paths.get_artifact_dto(artifact).post_build_path
             if not path.exists():
                 raise UsageError(
-                    f"Artefact {path} required for {entity.type} {key} does not exist."
+                    f"Artifact {path} required for {entity.type} {key} does not exist."
                 )
 
 
@@ -213,38 +222,39 @@ def check_for_existing_objects(
 
 def build_artifacts_mappings(
     project_paths: SnowparkProjectPaths, snowpark_entities: SnowparkEntities
-) -> Tuple[EntityToImportPathsMapping, StageToArtefactMapping]:
-    stages_to_artifact_map: StageToArtefactMapping = defaultdict(set)
+) -> Tuple[EntityToImportPathsMapping, StageToArtifactMapping]:
+    stages_to_artifact_map: StageToArtifactMapping = defaultdict(set)
     entities_to_imports_map: EntityToImportPathsMapping = defaultdict(set)
-    for entity_id, entity in snowpark_entities.items():
+    for name, entity in snowpark_entities.items():
         stage = entity.stage
         required_artifacts = set()
-        for artefact in entity.artifacts:
-            artefact_dto = project_paths.get_artefact_dto(artefact)
-            required_artifacts.add(artefact_dto)
-            entities_to_imports_map[entity_id].add(artefact_dto.import_path(stage))
+        for artifact in entity.artifacts:
+            artifact_dto = project_paths.get_artifact_dto(artifact)
+            required_artifacts.add(artifact_dto)
+            entities_to_imports_map[name].add(artifact_dto.import_path(stage))
         stages_to_artifact_map[stage].update(required_artifacts)
 
-        if project_paths.dependencies.exists():
-            deps_artefact = project_paths.get_dependencies_artefact()
-            stages_to_artifact_map[stage].add(deps_artefact)
-            entities_to_imports_map[entity_id].add(deps_artefact.import_path(stage))
+        deps_artifact = project_paths.get_dependencies_artifact()
+        if deps_artifact.post_build_path.exists():
+            stages_to_artifact_map[stage].add(deps_artifact)
+            entities_to_imports_map[name].add(deps_artifact.import_path(stage))
     return entities_to_imports_map, stages_to_artifact_map
 
 
-def create_stages_and_upload_artifacts(stages_to_artifact_map: StageToArtefactMapping):
+def create_stages_and_upload_artifacts(stages_to_artifact_map: StageToArtifactMapping):
     stage_manager = StageManager()
     for stage, artifacts in stages_to_artifact_map.items():
         cli_console.step(f"Creating (if not exists) stage: {stage}")
         stage = FQN.from_stage(stage).using_context()
         stage_manager.create(fqn=stage, comment="deployments managed by Snowflake CLI")
-        for artefact in artifacts:
+        for artifact in artifacts:
+            post_build_path = artifact.post_build_path
             cli_console.step(
-                f"Uploading {artefact.post_build_path.name} to {artefact.upload_path(stage)}"
+                f"Uploading {post_build_path.name} to {artifact.upload_path(stage)}"
             )
             stage_manager.put(
-                local_path=artefact.post_build_path,
-                stage_path=artefact.upload_path(stage),
+                local_path=post_build_path,
+                stage_path=artifact.upload_path(stage),
                 overwrite=True,
             )
 
@@ -324,6 +334,9 @@ def build(
 
     anaconda_packages_manager = AnacondaPackagesManager()
 
+    # Clean up bundle root
+    project_paths.remove_up_bundle_root()
+
     # Resolve dependencies
     if project_paths.requirements.exists():
         with (
@@ -362,22 +375,27 @@ def build(
                 )
 
             if any(temp_deps_dir.path.iterdir()):
-                cli_console.step(f"Creating {project_paths.dependencies.name}")
+                dep_artifact = project_paths.get_dependencies_artifact()
+                cli_console.step(f"Creating {dep_artifact.path.name}")
                 zip_dir(
                     source=temp_deps_dir.path,
-                    dest_zip=project_paths.dependencies,
+                    dest_zip=dep_artifact.post_build_path,
                 )
             else:
                 cli_console.step(f"No external dependencies.")
 
     artifacts = set()
-    for entity in get_snowpark_entities(pd).values():
-        artifacts.update(entity.artifacts)
-
     with cli_console.phase("Preparing artifacts for source code"):
-        for artefact in artifacts:
-            artefact_dto = project_paths.get_artefact_dto(artefact)
-            artefact_dto.build()
+        for entity in get_snowpark_entities(pd).values():
+            artifacts.update(
+                map_path_mapping_to_artifact(project_paths, entity.artifacts)
+            )
+
+        if FeatureFlag.ENABLE_SNOWPARK_GLOB_SUPPORT.is_enabled():
+            zip_and_copy_artifacts_to_deploy(artifacts, project_paths.bundle_root)
+        else:
+            for artifact in artifacts:
+                artifact.build()
 
     return MessageResult(f"Build done.")
 

snowflake/cli/_plugins/snowpark/common.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 import logging
 import re
 from enum import Enum
+from pathlib import Path
 from typing import Dict, List, Set
 
 from click import UsageError
@@ -25,7 +26,13 @@ from snowflake.cli._plugins.snowpark.snowpark_entity_model import (
     ProcedureEntityModel,
     SnowparkEntityModel,
 )
-from snowflake.cli._plugins.snowpark.snowpark_project_paths import Artefact
+from snowflake.cli._plugins.snowpark.snowpark_project_paths import (
+    Artifact,
+    SnowparkProjectPaths,
+)
+from snowflake.cli._plugins.snowpark.zipper import zip_dir_using_bundle_map
+from snowflake.cli.api.artifacts.bundle_map import BundleMap
+from snowflake.cli.api.artifacts.utils import symlink_or_copy
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.constants import (
     INIT_TEMPLATE_VARIABLE_CLOSING,
@@ -34,13 +41,14 @@ from snowflake.cli.api.constants import (
     PROJECT_TEMPLATE_VARIABLE_OPENING,
     ObjectType,
 )
+from snowflake.cli.api.project.schemas.entities.common import PathMapping
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.connector.cursor import SnowflakeCursor
 
 log = logging.getLogger(__name__)
 
 SnowparkEntities = Dict[str, SnowparkEntityModel]
-StageToArtefactMapping = Dict[str, set[Artefact]]
+StageToArtifactMapping = Dict[str, set[Artifact]]
 EntityToImportPathsMapping = Dict[str, set[str]]
 
 DEFAULT_RUNTIME = "3.10"
@@ -214,6 +222,43 @@ def _snowflake_dependencies_differ(
     return _standardize(old_dependencies) != _standardize(new_dependencies)
 
 
+def map_path_mapping_to_artifact(
+    project_paths: SnowparkProjectPaths, artifacts: List[PathMapping]
+) -> List[Artifact]:
+    return [project_paths.get_artifact_dto(artifact) for artifact in artifacts]
+
+
+def zip_and_copy_artifacts_to_deploy(
+    artifacts: Set[Artifact] | List[Artifact], bundle_root: Path
+) -> List[Path]:
+    copied_files = []
+    for artifact in artifacts:
+        bundle_map = BundleMap(
+            project_root=artifact.project_root,
+            deploy_root=bundle_root,
+        )
+        bundle_map.add(PathMapping(src=str(artifact.path), dest=artifact.dest))
+
+        if artifact.path.is_file():
+            for (absolute_src, absolute_dest) in bundle_map.all_mappings(
+                absolute=True, expand_directories=False
+            ):
+                symlink_or_copy(
+                    absolute_src,
+                    absolute_dest,
+                    deploy_root=bundle_map.deploy_root(),
+                )
+                copied_files.append(absolute_dest)
+        else:
+            post_build_path = artifact.post_build_path
+            zip_dir_using_bundle_map(
+                bundle_map=bundle_map,
+                dest_zip=post_build_path,
+            )
+            copied_files.append(post_build_path)
+    return copied_files
+
+
 def same_type(sf_type: str, local_type: str) -> bool:
     sf_type, local_type = sf_type.upper(), local_type.upper()