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

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 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
@@ -86,6 +87,10 @@ class StagePathParts:
     def full_path(self) -> str:
         raise NotImplementedError
 
+    @property
+    def schema(self) -> str | None:
+        raise NotImplementedError
+
     def replace_stage_prefix(self, file_path: str) -> str:
         raise NotImplementedError
 
@@ -128,22 +133,38 @@ 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}"
+        return f"{self.stage_name.rstrip('/')}/{self.directory}".rstrip("/")
 
     @property
     def full_path(self) -> str:
-        return f"{self.stage.rstrip('/')}/{self.directory}"
+        return f"{self.stage.rstrip('/')}/{self.directory}".rstrip("/")
+
+    @property
+    def schema(self) -> str | None:
+        return self._schema
 
     def replace_stage_prefix(self, file_path: str) -> str:
         stage = Path(self.stage).parts[0]
@@ -193,7 +214,7 @@ class UserStagePathParts(StagePathParts):
 
     @property
     def full_path(self) -> str:
-        return f"{self.stage}/{self.directory}"
+        return f"{self.stage}/{self.directory}".rstrip("/")
 
     def replace_stage_prefix(self, file_path: str) -> str:
         if Path(file_path).parts[0] == self.stage_name:
@@ -337,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)
@@ -516,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())
@@ -584,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
         )
 
@@ -693,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)

snowflake/cli/_plugins/streamlit/manager.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import logging
-from pathlib import Path
+from pathlib import PurePosixPath
 from typing import List, Optional
 
 from click import ClickException
@@ -29,12 +29,18 @@ from snowflake.cli._plugins.stage.manager import StageManager
 from snowflake.cli._plugins.streamlit.streamlit_entity_model import (
     StreamlitEntityModel,
 )
+from snowflake.cli._plugins.streamlit.streamlit_project_paths import (
+    StreamlitProjectPaths,
+)
+from snowflake.cli.api.artifacts.bundle_map import BundleMap
+from snowflake.cli.api.artifacts.utils import symlink_or_copy
 from snowflake.cli.api.commands.experimental_behaviour import (
     experimental_behaviour_enabled,
 )
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.feature_flags import FeatureFlag
 from snowflake.cli.api.identifiers import FQN
+from snowflake.cli.api.project.schemas.entities.common import PathMapping
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.connector.cursor import SnowflakeCursor
 from snowflake.connector.errors import ProgrammingError
@@ -54,26 +60,45 @@ class StreamlitManager(SqlExecutionMixin):
 
     def _put_streamlit_files(
         self,
-        root_location: str,
-        artifacts: Optional[List[Path]] = None,
+        streamlit_project_paths: StreamlitProjectPaths,
+        stage_root: str,
+        artifacts: Optional[List[PathMapping]] = None,
     ):
-        cli_console.step(f"Deploying files to {root_location}")
+        cli_console.step(f"Deploying files to {stage_root}")
         if not artifacts:
             return
         stage_manager = StageManager()
-        for file in artifacts:
-            if file.is_dir():
-                if not any(file.iterdir()):
-                    cli_console.warning(f"Skipping empty directory: {file}")
-                    continue
+        # We treat the bundle root as deploy root
+        bundle_map = BundleMap(
+            project_root=streamlit_project_paths.project_root,
+            deploy_root=streamlit_project_paths.bundle_root,
+        )
+        for artifact in artifacts:
+            bundle_map.add(PathMapping(src=str(artifact.src), dest=artifact.dest))
+
+        # Clean up bundle root
+        streamlit_project_paths.remove_up_bundle_root()
 
+        for (absolute_src, absolute_dest) in bundle_map.all_mappings(
+            absolute=True, expand_directories=True
+        ):
+            if absolute_src.is_file():
+                # We treat the bundle/streamlit root as deploy root
+                symlink_or_copy(
+                    absolute_src,
+                    absolute_dest,
+                    deploy_root=streamlit_project_paths.bundle_root,
+                )
+                # Temporary solution, will be replaced with diff
+                stage_path = (
+                    PurePosixPath(absolute_dest)
+                    .relative_to(streamlit_project_paths.bundle_root)
+                    .parent
+                )
+                full_stage_path = f"{stage_root}/{stage_path}".rstrip("/")
                 stage_manager.put(
-                    f"{file.joinpath('*')}", f"{root_location}/{file}", 4, True
+                    local_path=absolute_dest, stage_path=full_stage_path, overwrite=True
                 )
-            elif len(file.parts) > 1:
-                stage_manager.put(file, f"{root_location}/{file.parent}", 4, True)
-            else:
-                stage_manager.put(file, root_location, 4, True)
 
     def _create_streamlit(
         self,
@@ -104,8 +129,15 @@ class StreamlitManager(SqlExecutionMixin):
         query.append(f"MAIN_FILE = '{streamlit.main_file}'")
         if streamlit.imports:
             query.append(streamlit.get_imports_sql())
-        if streamlit.query_warehouse:
+
+        if not streamlit.query_warehouse:
+            cli_console.warning(
+                "[Deprecation] In next major version we will remove default query_warehouse='streamlit'."
+            )
+            query.append(f"QUERY_WAREHOUSE = 'streamlit'")
+        else:
             query.append(f"QUERY_WAREHOUSE = {streamlit.query_warehouse}")
+
         if streamlit.title:
             query.append(f"TITLE = '{streamlit.title}'")
 
@@ -120,7 +152,12 @@ class StreamlitManager(SqlExecutionMixin):
 
         self.execute_query("\n".join(query))
 
-    def deploy(self, streamlit: StreamlitEntityModel, replace: bool = False):
+    def deploy(
+        self,
+        streamlit: StreamlitEntityModel,
+        streamlit_project_paths: StreamlitProjectPaths,
+        replace: bool = False,
+    ):
         streamlit_id = streamlit.fqn.using_connection(self._conn)
         if (
             ObjectManager().object_exists(object_type="streamlit", fqn=streamlit_id)
@@ -172,12 +209,13 @@ class StreamlitManager(SqlExecutionMixin):
             embedded_stage_name = f"snow://streamlit/{stage_path}"
             if use_versioned_stage:
                 # "LIVE" is the only supported version for now, but this may change later.
-                root_location = f"{embedded_stage_name}/versions/live"
+                stage_root = f"{embedded_stage_name}/versions/live"
             else:
-                root_location = f"{embedded_stage_name}/default_checkout"
+                stage_root = f"{embedded_stage_name}/default_checkout"
 
             self._put_streamlit_files(
-                root_location,
+                streamlit_project_paths,
+                stage_root,
                 streamlit.artifacts,
             )
         else:
@@ -194,21 +232,31 @@ class StreamlitManager(SqlExecutionMixin):
             cli_console.step(f"Creating {stage_name} stage")
             stage_manager.create(fqn=stage_name)
 
-            root_location = stage_manager.get_standard_stage_prefix(
+            stage_root = stage_manager.get_standard_stage_prefix(
                 f"{stage_name}/{streamlit_name_for_root_location}"
             )
 
-            self._put_streamlit_files(root_location, streamlit.artifacts)
+            self._put_streamlit_files(
+                streamlit_project_paths, stage_root, streamlit.artifacts
+            )
 
             self._create_streamlit(
                 streamlit=streamlit,
                 replace=replace,
-                from_stage_name=root_location,
+                from_stage_name=stage_root,
                 experimental=False,
             )
 
+            self.grant_privileges(streamlit)
+
         return self.get_url(streamlit_name=streamlit_id)
 
+    def grant_privileges(self, entity_model: StreamlitEntityModel):
+        if not entity_model.grants:
+            return
+        for grant in entity_model.grants:
+            self.execute_query(grant.get_grant_sql(entity_model))
+
     def get_url(self, streamlit_name: FQN) -> str:
         try:
             fqn = streamlit_name.using_connection(self._conn)

snowflake/cli/_plugins/streamlit/streamlit_entity.py

@@ -1,7 +1,18 @@
+from pathlib import Path
+from typing import Optional
+
+from click import ClickException
+from snowflake.cli._plugins.connection.util import make_snowsight_url
+from snowflake.cli._plugins.nativeapp.artifacts import build_bundle
+from snowflake.cli._plugins.nativeapp.feature_flags import FeatureFlag
 from snowflake.cli._plugins.streamlit.streamlit_entity_model import (
     StreamlitEntityModel,
 )
+from snowflake.cli._plugins.workspace.context import ActionContext
 from snowflake.cli.api.entities.common import EntityBase
+from snowflake.cli.api.project.project_paths import bundle_root
+from snowflake.cli.api.project.schemas.entities.common import PathMapping
+from snowflake.connector.cursor import SnowflakeCursor
 
 
 class StreamlitEntity(EntityBase[StreamlitEntityModel]):
@@ -9,4 +20,123 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
     A Streamlit app.
     """
 
-    pass
+    def __init__(self, *args, **kwargs):
+        if not FeatureFlag.ENABLE_NATIVE_APP_CHILDREN.is_enabled():
+            raise NotImplementedError("Streamlit entity is not implemented yet")
+        super().__init__(*args, **kwargs)
+
+    @property
+    def root(self):
+        return self._workspace_ctx.project_root
+
+    @property
+    def artifacts(self):
+        return self._entity_model.artifacts
+
+    def action_bundle(self, action_ctx: ActionContext, *args, **kwargs):
+        return self.bundle()
+
+    def action_deploy(self, action_ctx: ActionContext, *args, **kwargs):
+        # After adding bundle map- we should use it's mapping here
+        # To copy artifacts to destination on stage.
+
+        return self.deploy()
+
+    def action_drop(self, action_ctx: ActionContext, *args, **kwargs):
+        return self._execute_query(self.get_drop_sql())
+
+    def action_execute(
+        self, action_ctx: ActionContext, *args, **kwargs
+    ) -> SnowflakeCursor:
+        return self._execute_query(self.get_execute_sql())
+
+    def action_get_url(
+        self, action_ctx: ActionContext, *args, **kwargs
+    ):  # maybe this should be a property
+        name = self._entity_model.fqn.using_connection(self._conn)
+        return make_snowsight_url(
+            self._conn, f"/#/streamlit-apps/{name.url_identifier}"
+        )
+
+    def bundle(self, output_dir: Optional[Path] = None):
+        build_bundle(
+            self.root,
+            output_dir or bundle_root(self.root, "streamlit"),
+            [
+                PathMapping(
+                    src=artifact.src, dest=artifact.dest, processors=artifact.processors
+                )
+                for artifact in self._entity_model.artifacts
+            ],
+        )
+
+    def deploy(self, *args, **kwargs):
+        return self._execute_query(self.get_deploy_sql())
+
+    def action_share(
+        self, action_ctx: ActionContext, to_role: str, *args, **kwargs
+    ) -> SnowflakeCursor:
+        return self._execute_query(self.get_share_sql(to_role))
+
+    def get_deploy_sql(
+        self,
+        if_not_exists: bool = False,
+        replace: bool = False,
+        from_stage_name: Optional[str] = None,
+        artifacts_dir: Optional[Path] = None,
+        schema: Optional[str] = None,
+        *args,
+        **kwargs,
+    ):
+        if replace and if_not_exists:
+            raise ClickException("Cannot specify both replace and if_not_exists")
+
+        if replace:
+            query = "CREATE OR REPLACE "
+        elif if_not_exists:
+            query = "CREATE IF NOT EXISTS "
+        else:
+            query = "CREATE "
+
+        schema_to_use = schema or self._entity_model.fqn.schema
+        query += f"STREAMLIT {self._entity_model.fqn.set_schema(schema_to_use).sql_identifier}"
+
+        if from_stage_name:
+            query += f"\nROOT_LOCATION = '{from_stage_name}'"
+        elif artifacts_dir:
+            query += f"\nFROM '{artifacts_dir}'"
+
+        query += f"\nMAIN_FILE = '{self._entity_model.main_file}'"
+
+        if self.model.imports:
+            query += "\n" + self.model.get_imports_sql()
+
+        if self.model.query_warehouse:
+            query += f"\nQUERY_WAREHOUSE = '{self.model.query_warehouse}'"
+
+        if self.model.title:
+            query += f"\nTITLE = '{self.model.title}'"
+
+        if self.model.comment:
+            query += f"\nCOMMENT = '{self.model.comment}'"
+
+        if self.model.external_access_integrations:
+            query += "\n" + self.model.get_external_access_integrations_sql()
+
+        if self.model.secrets:
+            query += "\n" + self.model.get_secrets_sql()
+
+        return query + ";"
+
+    def get_share_sql(self, to_role: str) -> str:
+        return f"GRANT USAGE ON STREAMLIT {self.model.fqn.sql_identifier} TO ROLE {to_role};"
+
+    def get_execute_sql(self):
+        return f"EXECUTE STREAMLIT {self._entity_model.fqn}();"
+
+    def get_usage_grant_sql(self, app_role: str, schema: Optional[str] = None) -> str:
+        entity_id = self.entity_id
+        streamlit_name = f"{schema}.{entity_id}" if schema else entity_id
+        return (
+            f"GRANT USAGE ON STREAMLIT {streamlit_name} TO APPLICATION ROLE {app_role};"
+        )