Renamed Artefact (#2048)

Author: sfc-gh-astus

src/snowflake/cli/_plugins/snowpark/commands.py

@@ -39,7 +39,7 @@
     SnowparkEntities,
     SnowparkObject,
     SnowparkObjectManager,
-    StageToArtefactMapping,
+    StageToArtifactMapping,
     map_path_mapping_to_artifact,
     zip_and_copy_artifacts_to_deploy,
 )
@@ -198,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."
                 )
 
 
@@ -222,39 +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 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[name].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)
 
-        deps_artefact = project_paths.get_dependencies_artefact()
-        if deps_artefact.post_build_path.exists():
-            stages_to_artifact_map[stage].add(deps_artefact)
-            entities_to_imports_map[name].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:
-            post_build_path = artefact.post_build_path
+        for artifact in artifacts:
+            post_build_path = artifact.post_build_path
             cli_console.step(
-                f"Uploading {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=post_build_path,
-                stage_path=artefact.upload_path(stage),
+                stage_path=artifact.upload_path(stage),
                 overwrite=True,
             )
 
@@ -375,7 +375,7 @@ def build(
                 )
 
             if any(temp_deps_dir.path.iterdir()):
-                dep_artifact = project_paths.get_dependencies_artefact()
+                dep_artifact = project_paths.get_dependencies_artifact()
                 cli_console.step(f"Creating {dep_artifact.path.name}")
                 zip_dir(
                     source=temp_deps_dir.path,
@@ -394,8 +394,8 @@ def build(
         if FeatureFlag.ENABLE_SNOWPARK_GLOB_SUPPORT.is_enabled():
             zip_and_copy_artifacts_to_deploy(artifacts, project_paths.bundle_root)
         else:
-            for artefact in artifacts:
-                artefact.build()
+            for artifact in artifacts:
+                artifact.build()
 
     return MessageResult(f"Build done.")
 

src/snowflake/cli/_plugins/snowpark/common.py

@@ -27,7 +27,7 @@
     SnowparkEntityModel,
 )
 from snowflake.cli._plugins.snowpark.snowpark_project_paths import (
-    Artefact,
+    Artifact,
     SnowparkProjectPaths,
 )
 from snowflake.cli._plugins.snowpark.zipper import zip_dir_using_bundle_map
@@ -48,7 +48,7 @@
 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"
@@ -224,22 +224,22 @@ def _standardize(packages: List[str]) -> Set[str]:
 
 def map_path_mapping_to_artifact(
     project_paths: SnowparkProjectPaths, artifacts: List[PathMapping]
-) -> List[Artefact]:
-    return [project_paths.get_artefact_dto(artifact) for artifact in artifacts]
+) -> List[Artifact]:
+    return [project_paths.get_artifact_dto(artifact) for artifact in artifacts]
 
 
 def zip_and_copy_artifacts_to_deploy(
-    artifacts: Set[Artefact] | List[Artefact], bundle_root: Path
+    artifacts: Set[Artifact] | List[Artifact], bundle_root: Path
 ) -> List[Path]:
     copied_files = []
-    for artefact in artifacts:
+    for artifact in artifacts:
         bundle_map = BundleMap(
-            project_root=artefact.project_root,
+            project_root=artifact.project_root,
             deploy_root=bundle_root,
         )
-        bundle_map.add(PathMapping(src=str(artefact.path), dest=artefact.dest))
+        bundle_map.add(PathMapping(src=str(artifact.path), dest=artifact.dest))
 
-        if artefact.path.is_file():
+        if artifact.path.is_file():
             for (absolute_src, absolute_dest) in bundle_map.all_mappings(
                 absolute=True, expand_directories=False
             ):
@@ -250,7 +250,7 @@ def zip_and_copy_artifacts_to_deploy(
                 )
                 copied_files.append(absolute_dest)
         else:
-            post_build_path = artefact.post_build_path
+            post_build_path = artifact.post_build_path
             zip_dir_using_bundle_map(
                 bundle_map=bundle_map,
                 dest_zip=post_build_path,

src/snowflake/cli/_plugins/snowpark/snowpark_entity.py

@@ -139,9 +139,9 @@ def bundle(
             )
         else:
             copied_files = []
-            for artefact in artifacts:
-                artefact.build()
-                copied_files.append(artefact.post_build_path)
+            for artifact in artifacts:
+                artifact.build()
+                copied_files.append(artifact.post_build_path)
             return copied_files
 
     def check_if_exists(

src/snowflake/cli/_plugins/snowpark/snowpark_project_paths.py

@@ -41,30 +41,30 @@ def path_relative_to_root(self, artifact_path: Path) -> Path:
             return artifact_path
         return (self.project_root / artifact_path).resolve()
 
-    def get_artefact_dto(self, artifact_path: PathMapping) -> Artefact:
+    def get_artifact_dto(self, artifact_path: PathMapping) -> Artifact:
         if FeatureFlag.ENABLE_SNOWPARK_GLOB_SUPPORT.is_enabled():
-            return Artefact(
+            return Artifact(
                 project_root=self.project_root,
                 bundle_root=self.bundle_root,
                 dest=artifact_path.dest,
                 path=Path(artifact_path.src),
             )
         else:
-            return ArtefactOldBuild(
+            return ArtifactOldBuild(
                 dest=artifact_path.dest,
                 path=self.path_relative_to_root(Path(artifact_path.src)),
             )
 
-    def get_dependencies_artefact(self) -> Artefact:
+    def get_dependencies_artifact(self) -> Artifact:
         if FeatureFlag.ENABLE_SNOWPARK_GLOB_SUPPORT.is_enabled():
-            return Artefact(
+            return Artifact(
                 project_root=self.project_root,
                 bundle_root=self.bundle_root,
                 dest=None,
                 path=Path("dependencies.zip"),
             )
         else:
-            return ArtefactOldBuild(
+            return ArtifactOldBuild(
                 dest=None, path=self.path_relative_to_root(Path("dependencies.zip"))
             )
 
@@ -84,8 +84,8 @@ def bundle_root(self) -> Path:
 
 
 @dataclass(unsafe_hash=True)
-class Artefact:
-    """Helper for getting paths related to given artefact."""
+class Artifact:
+    """Helper for getting paths related to given artifact."""
 
     project_root: Path
     bundle_root: Path
@@ -107,9 +107,9 @@ def __init__(
             self.dest = self.dest + "/"
 
     @property
-    def _artefact_name(self) -> str:
+    def _artifact_name(self) -> str:
         """
-        Returns artefact name. Directories are mapped to corresponding .zip files.
+        Returns artifact name. Directories are mapped to corresponding .zip files.
         For paths with glob patterns, the last part of the path is used.
         For files, the file name is used.
         """
@@ -134,7 +134,7 @@ def _artefact_name(self) -> str:
     @property
     def post_build_path(self) -> Path:
         """
-        Returns post-build artefact path. Directories are mapped to corresponding .zip files.
+        Returns post-build artifact path. Directories are mapped to corresponding .zip files.
         """
         bundle_root = self.bundle_root
         path = (
@@ -144,11 +144,11 @@ def post_build_path(self) -> Path:
         )
         if self._is_dest_a_file():
             return bundle_root / self.dest  # type: ignore
-        return bundle_root / (self.dest or path) / self._artefact_name
+        return bundle_root / (self.dest or path) / self._artifact_name
 
     def upload_path(self, stage: FQN | str | None) -> str:
         """
-        Path on stage to which the artefact should be uploaded.
+        Path on stage to which the artifact should be uploaded.
         """
         stage = stage or DEPLOYMENT_STAGE
         if isinstance(stage, str):
@@ -170,7 +170,7 @@ def upload_path(self, stage: FQN | str | None) -> str:
 
     def import_path(self, stage: FQN | str | None) -> str:
         """Path for UDF/sproc imports clause."""
-        return self.upload_path(stage) + self._artefact_name
+        return self.upload_path(stage) + self._artifact_name
 
     def _is_dest_a_file(self) -> bool:
         if not self.dest:
@@ -188,12 +188,12 @@ def _path_until_asterisk(self) -> Path:
 
     # Can be removed after removing ENABLE_SNOWPARK_GLOB_SUPPORT feature flag.
     def build(self) -> None:
-        raise NotImplementedError("Not implemented in Artefact class.")
+        raise NotImplementedError("Not implemented in Artifact class.")
 
 
 @dataclass(unsafe_hash=True)
-class ArtefactOldBuild(Artefact):
-    """Helper for getting paths related to given artefact."""
+class ArtifactOldBuild(Artifact):
+    """Helper for getting paths related to given artifact."""
 
     path: Path
     dest: str | None = None
@@ -202,21 +202,21 @@ def __init__(self, path: Path, dest: Optional[str] = None) -> None:
         super().__init__(project_root=Path(), bundle_root=Path(), path=path, dest=dest)
 
     @property
-    def _artefact_name(self) -> str:
+    def _artifact_name(self) -> str:
         if self.path.is_dir():
             return self.path.stem + ".zip"
         return self.path.name
 
     @property
     def post_build_path(self) -> Path:
         """
-        Returns post-build artefact path. Directories are mapped to corresponding .zip files.
+        Returns post-build artifact path. Directories are mapped to corresponding .zip files.
         """
-        return self.path.parent / self._artefact_name
+        return self.path.parent / self._artifact_name
 
     def upload_path(self, stage: FQN | str | None) -> str:
         """
-        Path on stage to which the artefact should be uploaded.
+        Path on stage to which the artifact should be uploaded.
         """
         stage = stage or DEPLOYMENT_STAGE
         if isinstance(stage, str):
@@ -229,10 +229,10 @@ def upload_path(self, stage: FQN | str | None) -> str:
 
     def import_path(self, stage: FQN | str | None) -> str:
         """Path for UDF/sproc imports clause."""
-        return self.upload_path(stage) + self._artefact_name
+        return self.upload_path(stage) + self._artifact_name
 
     def build(self) -> None:
-        """Build the artefact. Applies only to directories. Files are untouched."""
+        """Build the artifact. Applies only to directories. Files are untouched."""
         if not self.path.is_dir():
             return
         cli_console.step(f"Creating: {self.post_build_path.name}")

tests/snowpark/test_project_paths.py

@@ -2,7 +2,7 @@
 from unittest import mock
 
 import pytest
-from snowflake.cli._plugins.snowpark.snowpark_project_paths import Artefact
+from snowflake.cli._plugins.snowpark.snowpark_project_paths import Artifact
 
 bundle_root = Path("output") / "bundle" / "snowpark"
 absolute_bundle_root = Path.cwd().absolute() / "output" / "bundle" / "snowpark"
@@ -34,7 +34,7 @@ def test_artifact_import_path(mock_ctx_context, path, dest, is_file, expected_pa
     stage = "stage"
 
     with mock.patch.object(Path, "is_file" if is_file else "is_dir", return_value=True):
-        import_path = Artefact(Path(), bundle_root, Path(path), dest).import_path(stage)
+        import_path = Artifact(Path(), bundle_root, Path(path), dest).import_path(stage)
 
     assert import_path == expected_path
 
@@ -64,7 +64,7 @@ def test_artifact_upload_path(mock_ctx_context, path, dest, is_file, expected_pa
     mock_ctx_context.return_value.connection = mock_connection
 
     with mock.patch.object(Path, "is_file" if is_file else "is_dir", return_value=True):
-        upload_path = Artefact(Path(), bundle_root, Path(path), dest).upload_path(
+        upload_path = Artifact(Path(), bundle_root, Path(path), dest).upload_path(
             "stage"
         )
 
@@ -106,7 +106,7 @@ def test_artifact_upload_path(mock_ctx_context, path, dest, is_file, expected_pa
 )
 def test_artifact_post_build_path(path, dest, is_file, expected_path):
     with mock.patch.object(Path, "is_file" if is_file else "is_dir", return_value=True):
-        post_build_path = Artefact(
+        post_build_path = Artifact(
             Path(), bundle_root, Path(path), dest
         ).post_build_path
 
@@ -141,7 +141,7 @@ def test_artifact_import_path_from_other_directory(
     stage = "stage"
 
     with mock.patch.object(Path, "is_file" if is_file else "is_dir", return_value=True):
-        import_path = Artefact(
+        import_path = Artifact(
             Path("/tmp"),
             Path("/tmp") / "output" / "deploy" / "snowpark",
             Path(path),
@@ -178,7 +178,7 @@ def test_artifact_upload_path_from_other_directory(
     mock_ctx_context.return_value.connection = mock_connection
 
     with mock.patch.object(Path, "is_file" if is_file else "is_dir", return_value=True):
-        upload_path = Artefact(
+        upload_path = Artifact(
             Path("/tmp"), Path("/tmp") / "output" / "deploy", Path(path), dest
         ).upload_path("stage")
 
@@ -236,7 +236,7 @@ def test_artifact_post_build_path_from_other_directory(
     path, dest, is_file, expected_path
 ):
     with mock.patch.object(Path, "is_file" if is_file else "is_dir", return_value=True):
-        post_build_path = Artefact(
+        post_build_path = Artifact(
             Path.cwd().absolute(),
             absolute_bundle_root,
             Path(path),