snowflake-cli 3.6.0__py3-none-any.whl → 3.7.1__py3-none-any.whl

snowflake/cli/_plugins/notebook/notebook_entity.py

@@ -4,9 +4,8 @@ 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.artifacts.upload import sync_artifacts_with_stage
 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
@@ -22,12 +21,15 @@ class NotebookEntity(EntityBase[NotebookEntityModel]):
     A notebook.
     """
 
+    @property
+    def _stage_path_from_model(self) -> str:
+        if self.model.stage_path is None:
+            return f"{_DEFAULT_NOTEBOOK_STAGE_NAME}/{self.fqn.name}"
+        return self.model.stage_path
+
     @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)
+        return StagePath.from_stage_str(self._stage_path_from_model)
 
     @functools.cached_property
     def _project_paths(self):
@@ -41,26 +43,6 @@ class NotebookEntity(EntityBase[NotebookEntityModel]):
         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(
@@ -99,6 +81,7 @@ class NotebookEntity(EntityBase[NotebookEntityModel]):
         self,
         action_ctx: ActionContext,
         replace: bool,
+        prune: bool,
         *args,
         **kwargs,
     ) -> str:
@@ -108,7 +91,13 @@ class NotebookEntity(EntityBase[NotebookEntityModel]):
                     f"Notebook {self.fqn.name} already exists. Consider using --replace."
                 )
         with cli_console.phase(f"Uploading artifacts to {self._stage_path}"):
-            self._upload_artifacts()
+            sync_artifacts_with_stage(
+                project_paths=self._project_paths,
+                stage_root=self._stage_path_from_model,
+                prune=prune,
+                artifacts=self.model.artifacts,
+            )
+
         with cli_console.phase(f"Creating notebook {self.fqn}"):
             return self.action_create(replace=replace)
 

snowflake/cli/_plugins/project/commands.py

@@ -15,18 +15,20 @@
 from typing import List, Optional
 
 import typer
+from click import ClickException
 from snowflake.cli._plugins.object.command_aliases import add_object_command_aliases
 from snowflake.cli._plugins.object.commands import scope_option
+from snowflake.cli._plugins.object.manager import ObjectManager
 from snowflake.cli._plugins.project.feature_flags import FeatureFlag
 from snowflake.cli._plugins.project.manager import ProjectManager
 from snowflake.cli._plugins.project.project_entity_model import (
     ProjectEntityModel,
 )
-from snowflake.cli._plugins.stage.manager import StageManager
-from snowflake.cli.api.artifacts.upload import put_files
 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 (
+    OverrideableOption,
+    PruneOption,
     entity_argument,
     identifier_argument,
     like_option,
@@ -37,8 +39,7 @@ from snowflake.cli.api.commands.utils import get_entity_for_operation
 from snowflake.cli.api.console.console import cli_console
 from snowflake.cli.api.constants import ObjectType
 from snowflake.cli.api.identifiers import FQN
-from snowflake.cli.api.output.types import MessageResult, SingleQueryResult
-from snowflake.cli.api.project.project_paths import ProjectPaths
+from snowflake.cli.api.output.types import MessageResult, QueryResult, SingleQueryResult
 
 app = SnowTyperFactory(
     name="project",
@@ -48,11 +49,20 @@ app = SnowTyperFactory(
 
 project_identifier = identifier_argument(sf_object="project", example="MY_PROJECT")
 version_flag = typer.Option(
-    ..., "--version", help="Version of the project to use.", show_default=False
+    None,
+    "--version",
+    help="Version of the project to use. If not specified default version is used",
+    show_default=False,
 )
 variables_flag = variables_option(
     'Variables for the execution context; for example: `-D "<key>=<value>"`.'
 )
+from_option = OverrideableOption(
+    None,
+    "--from",
+    help="Create a new version using given stage instead of uploading local files.",
+    show_default=False,
+)
 
 
 add_object_command_aliases(
@@ -70,7 +80,7 @@ add_object_command_aliases(
 @app.command(requires_connection=True)
 def execute(
     identifier: FQN = project_identifier,
-    version: str = version_flag,
+    version: Optional[str] = version_flag,
     variables: Optional[List[str]] = variables_flag,
     **options,
 ):
@@ -86,7 +96,7 @@ def execute(
 @app.command(requires_connection=True)
 def dry_run(
     identifier: FQN = project_identifier,
-    version: str = version_flag,
+    version: Optional[str] = version_flag,
     variables: Optional[List[str]] = variables_flag,
     **options,
 ):
@@ -101,12 +111,18 @@ def dry_run(
 
 @app.command(requires_connection=True)
 @with_project_definition()
-def create_version(
+def create(
     entity_id: str = entity_argument("project"),
+    no_version: bool = typer.Option(
+        False,
+        "--no-version",
+        help="Do not initialize project with a new version, only create the snowflake object.",
+    ),
     **options,
 ):
     """
-    Upload local files and create a new version of a project using those files. If the stage does not exist, it will be created.
+    Creates a project in Snowflake.
+    By default, the project is initialized with a new version created from local files.
     """
     cli_context = get_cli_context()
     project: ProjectEntityModel = get_entity_for_operation(
@@ -115,59 +131,68 @@ def create_version(
         project_definition=cli_context.project_definition,
         entity_type="project",
     )
+    om = ObjectManager()
+    if om.object_exists(object_type="project", fqn=project.fqn):
+        raise ClickException(f"Project '{project.fqn}' already exists.")
+    if not no_version and om.object_exists(
+        object_type="stage", fqn=FQN.from_stage(project.stage)
+    ):
+        raise ClickException(f"Stage '{project.stage}' already exists.")
 
-    # Sync state
-    with cli_console.phase("Syncing project state"):
-        stage_name = FQN.from_stage(project.stage)
-        sm = StageManager()
-
-        cli_console.step(f"Creating stage {stage_name}")
-        sm.create(fqn=stage_name)
-
-        put_files(
-            project_paths=ProjectPaths(project_root=cli_context.project_root),
-            stage_root=project.stage,
-            artifacts=project.artifacts,
-        )
-
-    # Create project and version
-    with cli_console.phase("Creating project and version"):
-        pm = ProjectManager()
-        cli_console.step(f"Creating project {project.fqn}")
-        pm.create(project_name=project.fqn)
+    pm = ProjectManager()
+    with cli_console.phase(f"Creating project '{project.fqn}'"):
+        pm.create(project=project, initialize_version_from_local_files=not no_version)
 
-        cli_console.step(f"Creating version from stage {stage_name}")
-        pm.create_version(project_name=project.fqn, stage_name=stage_name)
-    return MessageResult(f"Project {project.fqn} deployed.")
+    if no_version:
+        return MessageResult(f"Project '{project.fqn}' successfully created.")
+    return MessageResult(
+        f"Project '{project.fqn}' successfully created and initial version is added."
+    )
 
 
 @app.command(requires_connection=True)
 @with_project_definition()
 def add_version(
     entity_id: str = entity_argument("project"),
-    _from: str = typer.Option(
-        ...,
-        "--from",
-        help="Source stage to create the version from.",
-        show_default=False,
-    ),
-    alias: str
-    | None = typer.Option(
+    _from: Optional[str] = from_option(mutually_exclusive=["prune"]),
+    _alias: Optional[str] = typer.Option(
         None, "--alias", help="Alias for the version.", show_default=False
     ),
-    comment: str
-    | None = typer.Option(
+    comment: Optional[str] = typer.Option(
         None, "--comment", help="Version comment.", show_default=False
     ),
+    prune: bool = PruneOption(mutually_exclusive=["_from"]),
     **options,
 ):
-    """Adds a new version to a project using existing sources from provided stage path."""
-
-    pm = ProjectManager()
-    pm.add_version(
-        project_name=entity_id,
+    """Uploads local files to Snowflake and cerates a new project version."""
+    cli_context = get_cli_context()
+    project: ProjectEntityModel = get_entity_for_operation(
+        cli_context=cli_context,
+        entity_id=entity_id,
+        project_definition=cli_context.project_definition,
+        entity_type="project",
+    )
+    ProjectManager().add_version(
+        project=project,
+        prune=prune,
         from_stage=_from,
-        alias=alias,
+        alias=_alias,
         comment=comment,
     )
-    return MessageResult("Version added.")
+    alias_str = "" if _alias is None else f"'{_alias}' "
+    return MessageResult(
+        f"New project version {alias_str}added to project '{project.fqn}'"
+    )
+
+
+@app.command(requires_connection=True)
+def list_versions(
+    identifier: FQN = project_identifier,
+    **options,
+):
+    """
+    Lists versions of given project.
+    """
+    pm = ProjectManager()
+    results = pm.list_versions(project_name=identifier)
+    return QueryResult(results)

snowflake/cli/_plugins/project/manager.py

@@ -12,13 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from textwrap import dedent
-from typing import List
+from typing import List, Optional
 
+from snowflake.cli._plugins.project.project_entity_model import ProjectEntityModel
 from snowflake.cli._plugins.stage.manager import StageManager
+from snowflake.cli.api.artifacts.upload import sync_artifacts_with_stage
+from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.commands.utils import parse_key_value_variables
+from snowflake.cli.api.console.console import cli_console
 from snowflake.cli.api.identifiers import FQN
+from snowflake.cli.api.project.project_paths import ProjectPaths
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.cli.api.stage_path import StagePath
+from snowflake.connector.cursor import SnowflakeCursor
 
 
 class ProjectManager(SqlExecutionMixin):
@@ -40,37 +46,65 @@ class ProjectManager(SqlExecutionMixin):
             query += " DRY_RUN=TRUE"
         return self.execute_query(query=query)
 
-    def create(
-        self,
-        project_name: FQN,
-    ) -> str:
-        queries = dedent(f"CREATE PROJECT IF NOT EXISTS {project_name.sql_identifier}")
-        return self.execute_query(query=queries)
+    def _create_object(self, project_name: FQN) -> SnowflakeCursor:
+        query = dedent(f"CREATE PROJECT {project_name.sql_identifier}")
+        return self.execute_query(query)
 
-    def create_version(self, project_name: FQN, stage_name: FQN):
-        return self.add_version(
-            project_name=project_name,
-            from_stage=StagePath.from_stage_str(stage_name).absolute_path(
-                at_prefix=True
-            ),
-        )
+    def create(
+        self, project: ProjectEntityModel, initialize_version_from_local_files: bool
+    ) -> None:
+        self._create_object(project.fqn)
+        if initialize_version_from_local_files:
+            self.add_version(project=project)
 
-    def add_version(
+    def _create_version(
         self,
-        project_name: str | FQN,
+        project_name: FQN,
         from_stage: str,
         alias: str | None = None,
         comment: str | None = None,
     ):
-        project_name = (
-            project_name
-            if isinstance(project_name, FQN)
-            else FQN.from_string(project_name)
-        )
+        stage_path = StagePath.from_stage_str(from_stage)
         query = f"ALTER PROJECT {project_name.identifier} ADD VERSION"
         if alias:
-            query += f" IF NOT EXIST {alias}"
-        query += f" FROM {from_stage}"
+            query += f' IF NOT EXISTS "{alias}"'
+        query += f" FROM {stage_path.absolute_path(at_prefix=True)}"
         if comment:
             query += f" COMMENT = '{comment}'"
         return self.execute_query(query=query)
+
+    def add_version(
+        self,
+        project: ProjectEntityModel,
+        prune: bool = False,
+        from_stage: Optional[str] = None,
+        alias: Optional[str] = None,
+        comment: Optional[str] = None,
+    ):
+        """
+        Adds a version to project. If [from_stage] is not defined,
+        uploads local files to the stage defined in project definition.
+        """
+
+        if not from_stage:
+            cli_context = get_cli_context()
+            from_stage = project.stage
+            with cli_console.phase("Uploading artifacts"):
+                sync_artifacts_with_stage(
+                    project_paths=ProjectPaths(project_root=cli_context.project_root),
+                    stage_root=from_stage,
+                    artifacts=project.artifacts,
+                    prune=prune,
+                )
+
+        with cli_console.phase(f"Creating project version from stage {from_stage}"):
+            return self._create_version(
+                project_name=project.fqn,
+                from_stage=from_stage,  # type:ignore
+                alias=alias,
+                comment=comment,
+            )
+
+    def list_versions(self, project_name: FQN):
+        query = f"SHOW VERSIONS IN PROJECT {project_name.identifier}"
+        return self.execute_query(query=query)

snowflake/cli/_plugins/project/project_entity_model.py

@@ -13,26 +13,45 @@
 # limitations under the License.
 from __future__ import annotations
 
-from typing import Literal, Optional, TypeVar
+from typing import List, Literal, Optional, TypeVar
 
-from pydantic import Field
+from pydantic import Field, field_validator
+from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.entities.common import EntityBase, attach_spans_to_entity_actions
+from snowflake.cli.api.exceptions import CliError
 from snowflake.cli.api.project.schemas.entities.common import (
+    Artifacts,
     EntityModelBaseWithArtifacts,
+    PathMapping,
 )
 from snowflake.cli.api.project.schemas.updatable_model import (
     DiscriminatorField,
 )
+from snowflake.cli.api.secure_path import SecurePath
 
 T = TypeVar("T")
 
 
+MANIFEST_FILE_NAME = "manifest.yml"
+
+
 class ProjectEntityModel(EntityModelBaseWithArtifacts):
     type: Literal["project"] = DiscriminatorField()  # noqa: A003
     stage: Optional[str] = Field(
         title="Stage in which the project artifacts will be stored", default=None
     )
-    main_file: Optional[str] = Field(title="Path to the main file of the project")
+
+    @field_validator("artifacts")
+    @classmethod
+    def transform_artifacts(cls, orig_artifacts: Artifacts) -> List[PathMapping]:
+        if not (
+            SecurePath(get_cli_context().project_root) / MANIFEST_FILE_NAME
+        ).exists():
+            raise CliError(
+                f"{MANIFEST_FILE_NAME} was not found in project root directory"
+            )
+        orig_artifacts.append(PathMapping(src=MANIFEST_FILE_NAME))
+        return super().transform_artifacts(orig_artifacts)
 
 
 @attach_spans_to_entity_actions(entity_name="project")

snowflake/cli/_plugins/snowpark/commands.py

@@ -71,6 +71,7 @@ from snowflake.cli.api.commands.decorators import (
 )
 from snowflake.cli.api.commands.flags import (
     ForceReplaceOption,
+    PruneOption,
     ReplaceOption,
     execution_identifier_argument,
     identifier_argument,
@@ -133,6 +134,9 @@ def deploy(
         "overwrites existing files, but does not remove any files already on the stage."
     ),
     force_replace: bool = ForceReplaceOption(),
+    prune: bool = PruneOption(
+        help="Remove contents of the stage before uploading artifacts."
+    ),
     **options,
 ) -> CommandResult:
     """
@@ -174,7 +178,7 @@ def deploy(
             snowpark_entities=snowpark_entities,
         )
 
-        create_stages_and_upload_artifacts(stages_to_artifact_map)
+        create_stages_and_upload_artifacts(stages_to_artifact_map, prune=prune)
 
     # Create snowpark entities
     with cli_console.phase("Creating Snowpark entities"):
@@ -242,8 +246,17 @@ def build_artifacts_mappings(
     return entities_to_imports_map, stages_to_artifact_map
 
 
-def create_stages_and_upload_artifacts(stages_to_artifact_map: StageToArtifactMapping):
+def create_stages_and_upload_artifacts(
+    stages_to_artifact_map: StageToArtifactMapping, prune: bool
+):
     stage_manager = StageManager()
+    if prune:
+        # snowflake.cli._plugins.snowpark.snowpark_project_paths.Artifact class assumes that "stage"
+        # is a stage object, not path on stage - whole stage is managed by snowpark - it can be removed
+        for stage in stages_to_artifact_map.keys():
+            cli_console.step(f"Removing contents of stage {stage}")
+            stage_manager.remove(stage, path="")
+
     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()

snowflake/cli/_plugins/spcs/image_registry/manager.py

@@ -74,12 +74,21 @@ class RegistryManager(SqlExecutionMixin):
         return re.fullmatch(r"^.*//.+", url) is not None
 
     def get_registry_url(self) -> str:
-        repositories_query = "show image repositories in account"
-        result_set = self.execute_query(repositories_query, cursor_class=DictCursor)
-        results = result_set.fetchall()
-        if len(results) == 0:
-            raise NoImageRepositoriesFoundError()
-        sample_repository_url = results[0]["repository_url"]
+        images_query = "show image repositories in schema snowflake.images;"
+        images_result = self.execute_query(images_query, cursor_class=DictCursor)
+
+        results = images_result.fetchone()
+
+        if not results:
+            # fallback to account level query - slower one, so we try to avoid it if possible
+            repositories_query = "show image repositories in account"
+            result_set = self.execute_query(repositories_query, cursor_class=DictCursor)
+            results = result_set.fetchone()
+
+            if not results:
+                raise NoImageRepositoriesFoundError()
+
+        sample_repository_url = results["repository_url"]
         if not self._has_url_scheme(sample_repository_url):
             sample_repository_url = f"//{sample_repository_url}"
         return urlparse(sample_repository_url).netloc

snowflake/cli/_plugins/sql/manager.py

@@ -20,7 +20,6 @@ from functools import partial
 from pathlib import Path
 from typing import Dict, Iterable, List, Tuple
 
-from click import ClickException, UsageError
 from snowflake.cli._plugins.sql.snowsql_templating import transpile_snowsql_templates
 from snowflake.cli._plugins.sql.source_reader import (
     compile_statements,
@@ -28,6 +27,7 @@ from snowflake.cli._plugins.sql.source_reader import (
     query_reader,
 )
 from snowflake.cli.api.console import cli_console
+from snowflake.cli.api.exceptions import CliArgumentError, CliSqlError
 from snowflake.cli.api.rendering.sql_templates import snowflake_sql_jinja_render
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.cli.api.sql_execution import SqlExecutionMixin, VerboseCursor
@@ -69,17 +69,17 @@ class SqlManager(SqlExecutionMixin):
             secured_files = [SecurePath(f) for f in files]
             stmt_reader = files_reader(secured_files, stmt_operators, remove_comments)
         else:
-            raise UsageError("Use either query, filename or input option.")
+            raise CliArgumentError("Use either query, filename or input option.")
 
         errors, stmt_count, compiled_statements = compile_statements(stmt_reader)
         if not any((errors, stmt_count, compiled_statements)):
-            raise UsageError("Use either query, filename or input option.")
+            raise CliArgumentError("Use either query, filename or input option.")
 
         if errors:
             for error in errors:
                 logger.info("Statement compilation error: %s", error)
                 cli_console.warning(error)
-            raise ClickException("SQL rendering error")
+            raise CliSqlError("SQL rendering error")
 
         is_single_statement = not (stmt_count > 1)
         return is_single_statement, self.execute_string(

snowflake/cli/_plugins/stage/manager.py

@@ -65,7 +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>([^/]*/?)*)?"
+STAGE_PATH_REGEX = rf"(?P<prefix>(@|{re.escape('snow://')}))?(?:(?P<first_qualifier>{VALID_IDENTIFIER_REGEX})\.)?(?:(?P<second_qualifier>{VALID_IDENTIFIER_REGEX})\.)?(?P<name>{VALID_IDENTIFIER_REGEX})/?(?P<directory>([^/]*/?)*)?"
 
 
 @dataclass
@@ -119,6 +119,14 @@ class StagePathParts:
         raise NotImplementedError
 
 
+def _strip_standard_stage_prefix(path: str) -> str:
+    """Removes '@' or 'snow://' prefix from given string"""
+    for prefix in ["@", "snow://"]:
+        if path.startswith(prefix):
+            path = path.removeprefix(prefix)
+    return path
+
+
 @dataclass
 class DefaultStagePathParts(StagePathParts):
     """
@@ -126,8 +134,8 @@ class DefaultStagePathParts(StagePathParts):
         directory = dir
         stage = @db.schema.stage
         stage_name = stage
-    For `@stage/dir` to
-        stage -> @stage
+    For `snow://stage/dir` to
+        stage -> snow://stage
         stage_name -> stage
         directory -> dir
     """
@@ -138,12 +146,12 @@ class DefaultStagePathParts(StagePathParts):
             raise ClickException("Invalid stage path")
         self.directory = match.group("directory")
         self._schema = match.group("second_qualifier") or match.group("first_qualifier")
+        self._prefix = match.group("prefix") or "@"
         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
-        )
+        if stage_name.startswith(self._prefix):
+            stage_name = stage_name.removeprefix(self._prefix)
         self.stage_name = stage_name
         self.is_directory = True if stage_path.endswith("/") else False
 
@@ -167,13 +175,12 @@ class DefaultStagePathParts(StagePathParts):
         return self._schema
 
     def replace_stage_prefix(self, file_path: str) -> str:
-        stage = Path(self.stage).parts[0]
+        file_path = _strip_standard_stage_prefix(file_path)
         file_path_without_prefix = Path(file_path).parts[OMIT_FIRST]
-        return f"{stage}/{'/'.join(file_path_without_prefix)}"
+        return f"{self.stage}/{'/'.join(file_path_without_prefix)}"
 
     def strip_stage_prefix(self, file_path: str) -> str:
-        if file_path.startswith("@"):
-            file_path = file_path[OMIT_FIRST]
+        file_path = _strip_standard_stage_prefix(file_path)
         if file_path.startswith(self.stage_name):
             return file_path[len(self.stage_name) :]
         return file_path

snowflake/cli/_plugins/streamlit/commands.py

@@ -37,6 +37,7 @@ from snowflake.cli.api.commands.decorators import (
     with_project_definition,
 )
 from snowflake.cli.api.commands.flags import (
+    PruneOption,
     ReplaceOption,
     entity_argument,
     identifier_argument,
@@ -136,6 +137,7 @@ def streamlit_deploy(
         help="Replaces the Streamlit app if it already exists. It only uploads new and overwrites existing files, "
         "but does not remove any files already on the stage."
     ),
+    prune: bool = PruneOption(),
     entity_id: str = entity_argument("streamlit"),
     open_: bool = OpenOption,
     **options,
@@ -168,6 +170,7 @@ def streamlit_deploy(
         streamlit=streamlit,
         streamlit_project_paths=streamlit_project_paths,
         replace=replace,
+        prune=prune,
     )
 
     if open_: