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

snowflake/cli/_plugins/snowpark/snowpark_project_paths.py

@@ -13,38 +13,60 @@
 # limitations under the License.
 from __future__ import annotations
 
+import glob
+import os
+import re
 from dataclasses import dataclass
 from pathlib import Path, PurePosixPath
+from typing import Optional
 
-from snowflake.cli._plugins.snowpark.snowpark_entity_model import PathMapping
 from snowflake.cli._plugins.snowpark.zipper import zip_dir
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.constants import DEPLOYMENT_STAGE
+from snowflake.cli.api.feature_flags import FeatureFlag
 from snowflake.cli.api.identifiers import FQN
+from snowflake.cli.api.project.project_paths import ProjectPaths, bundle_root
+from snowflake.cli.api.project.schemas.entities.common import PathMapping
 from snowflake.cli.api.secure_path import SecurePath
 
 
 @dataclass
-class SnowparkProjectPaths:
+class SnowparkProjectPaths(ProjectPaths):
     """
-    This class represents allows you to manage files paths related to given project.
+    This class allows you to manage files paths related to given project.
     """
 
-    project_root: Path
-
     def path_relative_to_root(self, artifact_path: Path) -> Path:
         if artifact_path.is_absolute():
             return artifact_path
         return (self.project_root / artifact_path).resolve()
 
-    def get_artefact_dto(self, artifact_path: PathMapping) -> Artefact:
-        return Artefact(
-            dest=artifact_path.dest,
-            path=self.path_relative_to_root(artifact_path.src),
-        )
-
-    def get_dependencies_artefact(self) -> Artefact:
-        return Artefact(dest=None, path=self.dependencies)
+    def get_artifact_dto(self, artifact_path: PathMapping) -> Artifact:
+        if FeatureFlag.ENABLE_SNOWPARK_GLOB_SUPPORT.is_enabled():
+            return Artifact(
+                project_root=self.project_root,
+                bundle_root=self.bundle_root,
+                dest=artifact_path.dest,
+                path=Path(artifact_path.src),
+            )
+        else:
+            return ArtifactOldBuild(
+                dest=artifact_path.dest,
+                path=self.path_relative_to_root(Path(artifact_path.src)),
+            )
+
+    def get_dependencies_artifact(self) -> Artifact:
+        if FeatureFlag.ENABLE_SNOWPARK_GLOB_SUPPORT.is_enabled():
+            return Artifact(
+                project_root=self.project_root,
+                bundle_root=self.bundle_root,
+                dest=None,
+                path=Path("dependencies.zip"),
+            )
+        else:
+            return ArtifactOldBuild(
+                dest=None, path=self.path_relative_to_root(Path("dependencies.zip"))
+            )
 
     @property
     def snowflake_requirements(self) -> SecurePath:
@@ -57,19 +79,130 @@ class SnowparkProjectPaths:
         return SecurePath(self.path_relative_to_root(Path("requirements.txt")))
 
     @property
-    def dependencies(self) -> Path:
-        return self.path_relative_to_root(Path("dependencies.zip"))
+    def bundle_root(self) -> Path:
+        return bundle_root(self.project_root, "snowpark")
 
 
 @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
     path: Path
     dest: str | None = None
 
+    def __init__(
+        self,
+        project_root: Path,
+        bundle_root: Path,
+        path: Path,
+        dest: Optional[str] = None,
+    ) -> None:
+        self.project_root = project_root
+        self.bundle_root = bundle_root
+        self.path = path
+        self.dest = dest
+        if self.dest and not self._is_dest_a_file() and not self.dest.endswith("/"):
+            self.dest = self.dest + "/"
+
+    @property
+    def _artifact_name(self) -> str:
+        """
+        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.
+        """
+        if glob.has_magic(str(self.path)):
+            last_part = None
+            for part in self.path.parts:
+                if glob.has_magic(part):
+                    break
+                else:
+                    last_part = part
+            if not last_part:
+                last_part = os.path.commonpath(
+                    [str(self.path), str(self.path.absolute())]
+                )
+            return last_part + ".zip"
+        if (self.project_root / self.path).is_dir():
+            return self.path.stem + ".zip"
+        if (self.project_root / self.path).is_file() and self._is_dest_a_file():
+            return Path(self.dest).name  # type: ignore
+        return self.path.name
+
+    @property
+    def post_build_path(self) -> Path:
+        """
+        Returns post-build artifact path. Directories are mapped to corresponding .zip files.
+        """
+        bundle_root = self.bundle_root
+        path = (
+            self._path_until_asterisk()
+            if glob.has_magic(str(self.path))
+            else self.path.parent
+        )
+        if self._is_dest_a_file():
+            return bundle_root / self.dest  # type: ignore
+        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 artifact should be uploaded.
+        """
+        stage = stage or DEPLOYMENT_STAGE
+        if isinstance(stage, str):
+            stage = FQN.from_stage(stage).using_context()
+
+        stage_path = PurePosixPath(f"@{stage}")
+        if self.dest:
+            stage_path /= (
+                PurePosixPath(self.dest).parent if self._is_dest_a_file() else self.dest
+            )
+        else:
+            stage_path /= (
+                self._path_until_asterisk()
+                if glob.has_magic(str(self.path))
+                else PurePosixPath(self.path).parent
+            )
+
+        return str(stage_path) + "/"
+
+    def import_path(self, stage: FQN | str | None) -> str:
+        """Path for UDF/sproc imports clause."""
+        return self.upload_path(stage) + self._artifact_name
+
+    def _is_dest_a_file(self) -> bool:
+        if not self.dest:
+            return False
+        return re.search(r"\.[a-zA-Z0-9]{2,4}$", self.dest) is not None
+
+    def _path_until_asterisk(self) -> Path:
+        path = []
+        for part in self.path.parts:
+            if glob.has_magic(part):
+                break
+            else:
+                path.append(part)
+        return Path(*path[:-1])
+
+    # Can be removed after removing ENABLE_SNOWPARK_GLOB_SUPPORT feature flag.
+    def build(self) -> None:
+        raise NotImplementedError("Not implemented in Artifact class.")
+
+
+@dataclass(unsafe_hash=True)
+class ArtifactOldBuild(Artifact):
+    """Helper for getting paths related to given artifact."""
+
+    path: Path
+    dest: str | None = None
+
+    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
@@ -77,13 +210,13 @@ class Artefact:
     @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):
@@ -96,10 +229,10 @@ class Artefact:
 
     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}")

snowflake/cli/_plugins/snowpark/zipper.py

@@ -20,6 +20,10 @@ from pathlib import Path
 from typing import Dict, List, Literal
 from zipfile import ZIP_DEFLATED, ZipFile
 
+from snowflake.cli.api.artifacts.bundle_map import BundleMap
+from snowflake.cli.api.console import cli_console
+from snowflake.cli.api.secure_path import SecurePath
+
 log = logging.getLogger(__name__)
 
 IGNORED_FILES = [
@@ -64,7 +68,10 @@ def zip_dir(
     mode: Literal["r", "w", "x", "a"] = "w",
 ) -> None:
 
-    if isinstance(source, Path):
+    if not dest_zip.parent.exists():
+        SecurePath(dest_zip).parent.mkdir(parents=True)
+
+    if isinstance(source, Path) or isinstance(source, SecurePath):
         source = [source]
 
     files_to_pack: Dict[Path, List[Path]] = {
@@ -74,11 +81,36 @@ def zip_dir(
 
     with ZipFile(dest_zip, mode, ZIP_DEFLATED, allowZip64=True) as package_zip:
         for src, files in files_to_pack.items():
+            if isinstance(src, SecurePath):
+                src = src.path
             for file in files:
                 log.debug("Adding %s to %s", file, dest_zip)
                 package_zip.write(file, arcname=file.relative_to(src))
 
 
+def zip_dir_using_bundle_map(
+    bundle_map: BundleMap,
+    dest_zip: Path,
+    mode: Literal["r", "w", "x", "a"] = "w",
+) -> None:
+    if not dest_zip.parent.exists():
+        SecurePath(dest_zip).parent.mkdir(parents=True)
+
+    with ZipFile(dest_zip, mode, ZIP_DEFLATED, allowZip64=True) as package_zip:
+        cli_console.step(f"Creating: {dest_zip}")
+        for src, _ in bundle_map.all_mappings(expand_directories=True):
+            if src.is_file():
+                log.debug("Adding %s to %s", src, dest_zip)
+                package_zip.write(src, arcname=_path_without_top_level_directory(src))
+
+
+def _path_without_top_level_directory(path: Path) -> str:
+    path_parts = path.parts
+    if len(path_parts) > 1:
+        return str(Path(*path_parts[1:]))
+    return str(path)
+
+
 def _to_be_zipped(file: Path) -> bool:
     for pattern in IGNORED_FILES:
         # This has to be a string because of fnmatch

snowflake/cli/_plugins/spcs/services/commands.py

@@ -40,7 +40,6 @@ from snowflake.cli.api.constants import ObjectType
 from snowflake.cli.api.exceptions import (
     IncompatibleParametersError,
 )
-from snowflake.cli.api.feature_flags import FeatureFlag
 from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.output.types import (
     CollectionResult,
@@ -321,7 +320,6 @@ def logs(
 
 @app.command(
     requires_connection=True,
-    is_enabled=FeatureFlag.ENABLE_SPCS_SERVICE_EVENTS.is_enabled,
 )
 def events(
     name: FQN = ServiceNameArgument,
@@ -369,7 +367,6 @@ def events(
 
 @app.command(
     requires_connection=True,
-    is_enabled=FeatureFlag.ENABLE_SPCS_SERVICE_METRICS.is_enabled,
 )
 def metrics(
     name: FQN = ServiceNameArgument,

snowflake/cli/_plugins/stage/commands.py

@@ -192,7 +192,8 @@ def stage_diff(
     Diffs a stage with a local folder.
     """
     diff: DiffResult = compute_stage_diff(
-        local_root=Path(folder_name), stage_fqn=stage_name
+        local_root=Path(folder_name),
+        stage_path=StageManager.stage_path_parts_from_str(stage_name),  # noqa: SLF001
     )
     if get_cli_context().output_format == OutputFormat.JSON:
         return ObjectResult(diff.to_dict())

snowflake/cli/_plugins/stage/diff.py

@@ -19,13 +19,14 @@ from dataclasses import dataclass, field
 from pathlib import Path, PurePosixPath
 from typing import Collection, Dict, List, Optional, Tuple
 
-from snowflake.cli._plugins.nativeapp.artifacts import BundleMap
+from snowflake.cli.api.artifacts.bundle_map import BundleMap
 from snowflake.cli.api.exceptions import (
     SnowflakeSQLExecutionError,
 )
+from snowflake.cli.api.project.util import unquote_identifier
 from snowflake.connector.cursor import DictCursor
 
-from .manager import StageManager
+from .manager import StageManager, StagePathParts
 from .md5 import UnknownMD5FormatError, file_matches_md5sum
 
 log = logging.getLogger(__name__)
@@ -83,18 +84,31 @@ def enumerate_files(path: Path) -> List[Path]:
     return paths
 
 
-def strip_stage_name(path: str) -> StagePathType:
-    """Returns the given stage path without the stage name as the first part."""
-    return StagePathType(*path.split("/")[1:])
-
-
-def build_md5_map(list_stage_cursor: DictCursor) -> Dict[StagePathType, Optional[str]]:
+def relative_to_stage_path(path: str, stage_path: StagePathParts) -> StagePathType:
+    """
+    @param path: file path on the stage.
+    @param stage_path: stage path object.
+    @return: path of the file relative to the stage and subdirectory
     """
-    Returns a mapping of relative stage paths to their md5sums.
+    # path is returned from a SQL call so it's unquoted. Unquote stage_path identifiers to match.
+    # Stage is always returned in lower-case from ls SQL request
+    stage_name = unquote_identifier(stage_path.stage_name).lower()
+    stage_subdirectory = stage_path.directory
+    path_wo_stage_name = path.removeprefix(stage_name).lstrip("/")
+    relative_path = path_wo_stage_name.removeprefix(stage_subdirectory).lstrip("/")
+    return StagePathType(relative_path)
+
+
+def build_md5_map(
+    list_stage_cursor: DictCursor, stage_path: StagePathParts
+) -> Dict[StagePathType, Optional[str]]:
     """
+    Returns a mapping of file paths to their md5sums. File paths are relative to the stage and subdirectory.
+    """
+    all_files = list_stage_cursor.fetchall()
     return {
-        strip_stage_name(file["name"]): file["md5"]
-        for file in list_stage_cursor.fetchall()
+        relative_to_stage_path(file["name"], stage_path): file["md5"]
+        for file in all_files
     }
 
 
@@ -115,50 +129,50 @@ def preserve_from_diff(
     return preserved_diff
 
 
-def compute_stage_diff(
-    local_root: Path,
-    stage_fqn: str,
-) -> DiffResult:
+def compute_stage_diff(local_root: Path, stage_path: StagePathParts) -> DiffResult:
     """
-    Diffs the files in a stage with a local folder.
+    Diffs the files in the local_root with files in the stage path that is stage_path's full_path.
     """
     stage_manager = StageManager()
     local_files = enumerate_files(local_root)
-    remote_md5 = build_md5_map(stage_manager.list_files(stage_fqn))
+    remote_files = stage_manager.list_files(stage_path.full_path)
+
+    # Create a mapping from remote_file path to file's md5sum. Path is relative to stage_name/directory.
+    remote_md5 = build_md5_map(remote_files, stage_path)
 
     result: DiffResult = DiffResult()
 
     for local_file in local_files:
         relpath = local_file.relative_to(local_root)
-        stage_path = to_stage_path(relpath)
-        if stage_path not in remote_md5:
+        rel_stage_path = to_stage_path(relpath)
+        if rel_stage_path not in remote_md5:
             # doesn't exist on the stage
-            result.only_local.append(stage_path)
+            result.only_local.append(rel_stage_path)
         else:
             # N.B. file size on stage is not always accurate, so cannot fail fast
             try:
-                if file_matches_md5sum(local_file, remote_md5[stage_path]):
+                if file_matches_md5sum(local_file, remote_md5[rel_stage_path]):
                     # We are assuming that we will not get accidental collisions here due to the
                     # large space of the md5sum (32 * 4 = 128 bits means 1-in-9-trillion chance)
                     # combined with the fact that the file name + path must also match elsewhere.
-                    result.identical.append(stage_path)
+                    result.identical.append(rel_stage_path)
                 else:
                     # either the file has changed, or we can't tell if it has
-                    result.different.append(stage_path)
+                    result.different.append(rel_stage_path)
             except UnknownMD5FormatError:
                 log.warning(
                     "Could not compare md5 for %s, assuming file has changed",
                     local_file,
                     exc_info=True,
                 )
-                result.different.append(stage_path)
+                result.different.append(rel_stage_path)
 
             # mark this file as seen
-            del remote_md5[stage_path]
+            del remote_md5[rel_stage_path]
 
     # every entry here is a file we never saw locally
-    for stage_path in remote_md5.keys():
-        result.only_on_stage.append(stage_path)
+    for rel_stage_path in remote_md5.keys():
+        result.only_on_stage.append(rel_stage_path)
 
     return result
 
@@ -185,7 +199,7 @@ def to_local_path(stage_path: StagePathType) -> Path:
 
 def delete_only_on_stage_files(
     stage_manager: StageManager,
-    stage_fqn: str,
+    stage_root: str,
     only_on_stage: List[StagePathType],
     role: Optional[str] = None,
 ):
@@ -193,12 +207,12 @@ def delete_only_on_stage_files(
     Deletes all files from a Snowflake stage according to the input list of filenames, using a custom role.
     """
     for _stage_path in only_on_stage:
-        stage_manager.remove(stage_name=stage_fqn, path=str(_stage_path), role=role)
+        stage_manager.remove(stage_name=stage_root, path=str(_stage_path), role=role)
 
 
 def put_files_on_stage(
     stage_manager: StageManager,
-    stage_fqn: str,
+    stage_root: str,
     deploy_root_path: Path,
     stage_paths: List[StagePathType],
     role: Optional[str] = None,
@@ -210,7 +224,7 @@ def put_files_on_stage(
     for _stage_path in stage_paths:
         stage_sub_path = get_stage_subpath(_stage_path)
         full_stage_path = (
-            f"{stage_fqn}/{stage_sub_path}" if stage_sub_path else stage_fqn
+            f"{stage_root}/{stage_sub_path}" if stage_sub_path else stage_root
         )
         stage_manager.put(
             local_path=deploy_root_path / to_local_path(_stage_path),
@@ -221,7 +235,10 @@ def put_files_on_stage(
 
 
 def sync_local_diff_with_stage(
-    role: str | None, deploy_root_path: Path, diff_result: DiffResult, stage_fqn: str
+    role: str | None,
+    deploy_root_path: Path,
+    diff_result: DiffResult,
+    stage_full_path: str,
 ):
     """
     Syncs a given local directory's contents with a Snowflake stage, including removing old files, and re-uploading modified and new files.
@@ -234,18 +251,22 @@ def sync_local_diff_with_stage(
 
     try:
         delete_only_on_stage_files(
-            stage_manager, stage_fqn, diff_result.only_on_stage, role
+            stage_manager, stage_full_path, diff_result.only_on_stage, role
         )
         put_files_on_stage(
-            stage_manager,
-            stage_fqn,
-            deploy_root_path,
-            diff_result.different,
-            role,
+            stage_manager=stage_manager,
+            stage_root=stage_full_path,
+            deploy_root_path=deploy_root_path,
+            stage_paths=diff_result.different,
+            role=role,
             overwrite=True,
         )
         put_files_on_stage(
-            stage_manager, stage_fqn, deploy_root_path, diff_result.only_local, role
+            stage_manager=stage_manager,
+            stage_root=stage_full_path,
+            deploy_root_path=deploy_root_path,
+            stage_paths=diff_result.only_local,
+            role=role,
         )
     except Exception as err:
         # Could be ProgrammingError or IntegrityError from SnowflakeCursor

snowflake/cli/_plugins/stage/manager.py

@@ -41,11 +41,11 @@ from snowflake.cli.api.commands.utils import parse_key_value_variables
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.constants import PYTHON_3_12
 from snowflake.cli.api.identifiers import FQN
-from snowflake.cli.api.project.util import extract_schema, to_string_literal
+from snowflake.cli.api.project.util import VALID_IDENTIFIER_REGEX, to_string_literal
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.cli.api.stage_path import StagePath
-from snowflake.cli.api.utils.path_utils import path_resolver
+from snowflake.cli.api.utils.path_utils import path_resolver, resolve_without_follow
 from snowflake.connector import DictCursor, ProgrammingError
 from snowflake.connector.cursor import SnowflakeCursor
 
@@ -65,6 +65,7 @@ EXECUTE_SUPPORTED_FILES_FORMATS = (
 
 # Replace magic numbers with constants
 OMIT_FIRST = slice(1, None)
+STAGE_PATH_REGEX = rf"(?P<prefix>@)?(?:(?P<first_qualifier>{VALID_IDENTIFIER_REGEX})\.)?(?:(?P<second_qualifier>{VALID_IDENTIFIER_REGEX})\.)?(?P<name>{VALID_IDENTIFIER_REGEX})/?(?P<directory>([^/]*/?)*)?"
 
 
 @dataclass
@@ -132,15 +133,27 @@ class DefaultStagePathParts(StagePathParts):
     """
 
     def __init__(self, stage_path: str):
-        self.directory = self.get_directory(stage_path)
-        self.stage = StageManager.get_stage_from_path(stage_path)
-        stage_name = self.stage.split(".")[-1]
+        match = re.fullmatch(STAGE_PATH_REGEX, stage_path)
+        if match is None:
+            raise ClickException("Invalid stage path")
+        self.directory = match.group("directory")
+        self._schema = match.group("second_qualifier") or match.group("first_qualifier")
+        self.stage = stage_path.removesuffix(self.directory).rstrip("/")
+
+        stage_name = FQN.from_stage(self.stage).name
         stage_name = (
             stage_name[OMIT_FIRST] if stage_name.startswith("@") else stage_name
         )
         self.stage_name = stage_name
         self.is_directory = True if stage_path.endswith("/") else False
 
+    @classmethod
+    def from_fqn(
+        cls, stage_fqn: str, subdir: str | None = None
+    ) -> DefaultStagePathParts:
+        full_path = f"{stage_fqn}/{subdir}" if subdir else stage_fqn
+        return cls(full_path)
+
     @property
     def path(self) -> str:
         return f"{self.stage_name.rstrip('/')}/{self.directory}".rstrip("/")
@@ -151,7 +164,7 @@ class DefaultStagePathParts(StagePathParts):
 
     @property
     def schema(self) -> str | None:
-        return extract_schema(self.stage)
+        return self._schema
 
     def replace_stage_prefix(self, file_path: str) -> str:
         stage = Path(self.stage).parts[0]
@@ -345,7 +358,6 @@ class StageManager(SqlExecutionMixin):
 
     @staticmethod
     def _symlink_or_copy(source_root: Path, source_file_or_dir: Path, dest_dir: Path):
-        from snowflake.cli._plugins.nativeapp.artifacts import resolve_without_follow
 
         absolute_src = resolve_without_follow(source_file_or_dir)
         dest_path = dest_dir / source_file_or_dir.relative_to(source_root)
@@ -524,7 +536,7 @@ class StageManager(SqlExecutionMixin):
                 stage_path_parts.get_standard_stage_path()
             )
         else:
-            stage_path_parts = self._stage_path_part_factory(stage_path_str)
+            stage_path_parts = self.stage_path_parts_from_str(stage_path_str)
             stage_path = self.build_path(stage_path_str)
 
         all_files_list = self._get_files_list_from_stage(stage_path.root_path())
@@ -592,12 +604,12 @@ class StageManager(SqlExecutionMixin):
         sm = StageManager()
 
         # Rewrite stage paths to temporary stage paths. Git paths become stage paths
-        original_path_parts = self._stage_path_part_factory(stage_path)  # noqa: SLF001
+        original_path_parts = self.stage_path_parts_from_str(stage_path)  # noqa: SLF001
 
         tmp_stage_name = f"snowflake_cli_tmp_stage_{int(time.time())}"
         tmp_stage_fqn = FQN.from_stage(tmp_stage_name).using_connection(conn=self._conn)
         tmp_stage = tmp_stage_fqn.identifier
-        stage_path_parts = sm._stage_path_part_factory(  # noqa: SLF001
+        stage_path_parts = sm.stage_path_parts_from_str(  # noqa: SLF001
             tmp_stage + "/" + original_path_parts.directory
         )
 
@@ -701,7 +713,8 @@ class StageManager(SqlExecutionMixin):
             return StageManager._error_result(file=original_file, msg=e.msg)
 
     @staticmethod
-    def _stage_path_part_factory(stage_path: str) -> StagePathParts:
+    def stage_path_parts_from_str(stage_path: str) -> StagePathParts:
+        """Create StagePathParts object from stage path string."""
         stage_path = StageManager.get_standard_stage_prefix(stage_path)
         if stage_path.startswith(USER_STAGE_PREFIX):
             return UserStagePathParts(stage_path)

snowflake/cli/_plugins/stage/utils.py

@@ -1,11 +1,11 @@
 from typing import Optional
 
-from snowflake.cli._plugins.nativeapp.artifacts import BundleMap
 from snowflake.cli._plugins.stage.diff import (
     DiffResult,
     _to_diff_line,
     _to_src_dest_pair,
 )
+from snowflake.cli.api.artifacts.bundle_map import BundleMap
 from snowflake.cli.api.console import cli_console as cc
 
 

snowflake/cli/_plugins/streamlit/commands.py

@@ -29,6 +29,9 @@ from snowflake.cli._plugins.streamlit.manager import StreamlitManager
 from snowflake.cli._plugins.streamlit.streamlit_entity_model import (
     StreamlitEntityModel,
 )
+from snowflake.cli._plugins.streamlit.streamlit_project_paths import (
+    StreamlitProjectPaths,
+)
 from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.commands.decorators import (
     with_experimental_behaviour,
@@ -156,6 +159,8 @@ def streamlit_deploy(
         entity_type="streamlit"
     )
 
+    streamlit_project_paths = StreamlitProjectPaths(cli_context.project_root)
+
     if not streamlits:
         raise NoProjectDefinitionError(
             project_type="streamlit", project_root=cli_context.project_root
@@ -174,7 +179,11 @@ def streamlit_deploy(
 
     # Get first streamlit
     streamlit: StreamlitEntityModel = streamlits[entity_id]
-    url = StreamlitManager().deploy(streamlit=streamlit, replace=replace)
+    url = StreamlitManager().deploy(
+        streamlit=streamlit,
+        streamlit_project_paths=streamlit_project_paths,
+        replace=replace,
+    )
 
     if open_:
         typer.launch(url)