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

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

@@ -35,9 +35,17 @@ from snowflake.cli._plugins.spcs.common import (
     new_logs_only,
     strip_empty_lines,
 )
+from snowflake.cli._plugins.spcs.services.service_project_paths import (
+    ServiceProjectPaths,
+)
+from snowflake.cli._plugins.stage.manager import StageManager
+from snowflake.cli.api.artifacts.utils import bundle_artifacts
 from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB, ObjectType
+from snowflake.cli.api.identifiers import FQN
+from snowflake.cli.api.project.schemas.entities.common import Artifacts
 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.connector.cursor import DictCursor, SnowflakeCursor
 from snowflake.connector.errors import ProgrammingError
 
@@ -95,6 +103,112 @@ class ServiceManager(SqlExecutionMixin):
         except ProgrammingError as e:
             handle_object_already_exists(e, ObjectType.SERVICE, service_name)
 
+    def deploy(
+        self,
+        service_name: str,
+        stage: str,
+        artifacts: List[str],
+        compute_pool: str,
+        spec_path: Path,
+        min_instances: int,
+        max_instances: int,
+        auto_resume: bool,
+        external_access_integrations: Optional[List[str]],
+        query_warehouse: Optional[str],
+        tags: Optional[List[Tag]],
+        comment: Optional[str],
+        service_project_paths: ServiceProjectPaths,
+        upgrade: bool,
+    ) -> SnowflakeCursor:
+        stage_manager = StageManager()
+        stage_manager.create(fqn=FQN.from_stage(stage))
+
+        stage = stage_manager.get_standard_stage_prefix(stage)
+        self._upload_artifacts(
+            stage_manager=stage_manager,
+            service_project_paths=service_project_paths,
+            artifacts=artifacts,
+            stage=stage,
+        )
+
+        if upgrade:
+            self.set_property(
+                service_name=service_name,
+                min_instances=min_instances,
+                max_instances=max_instances,
+                query_warehouse=query_warehouse,
+                auto_resume=auto_resume,
+                external_access_integrations=external_access_integrations,
+                comment=comment,
+            )
+            query = [
+                f"ALTER SERVICE {service_name}",
+                f"FROM {stage}",
+                f"SPECIFICATION_FILE = '{spec_path}'",
+            ]
+            return self.execute_query(strip_empty_lines(query))
+        else:
+            query = [
+                f"CREATE SERVICE {service_name}",
+                f"IN COMPUTE POOL {compute_pool}",
+                f"FROM {stage}",
+                f"SPECIFICATION_FILE = '{spec_path}'",
+                f"AUTO_RESUME = {auto_resume}",
+            ]
+
+            if min_instances:
+                query.append(f"MIN_INSTANCES = {min_instances}")
+
+            if max_instances:
+                query.append(f"MAX_INSTANCES = {max_instances}")
+
+            if query_warehouse:
+                query.append(f"QUERY_WAREHOUSE = {query_warehouse}")
+
+            if external_access_integrations:
+                external_access_integration_list = ",".join(
+                    f"{e}" for e in external_access_integrations
+                )
+                query.append(
+                    f"EXTERNAL_ACCESS_INTEGRATIONS = ({external_access_integration_list})"
+                )
+
+            if comment:
+                query.append(f"COMMENT = {comment}")
+
+            if tags:
+                tag_list = ",".join(
+                    f"{t.name}={t.value_string_literal()}" for t in tags
+                )
+                query.append(f"WITH TAG ({tag_list})")
+
+            try:
+                return self.execute_query(strip_empty_lines(query))
+            except ProgrammingError as e:
+                handle_object_already_exists(e, ObjectType.SERVICE, service_name)
+
+    @staticmethod
+    def _upload_artifacts(
+        stage_manager: StageManager,
+        service_project_paths: ServiceProjectPaths,
+        artifacts: Artifacts,
+        stage: str,
+    ):
+        if not artifacts:
+            raise ValueError("Service needs to have artifacts to deploy")
+
+        bundle_map = bundle_artifacts(service_project_paths, artifacts)
+        for absolute_src, absolute_dest in bundle_map.all_mappings(
+            absolute=True, expand_directories=True
+        ):
+            # We treat the bundle/service root as deploy root
+            stage_path = StagePath.from_stage_str(stage) / (
+                absolute_dest.relative_to(service_project_paths.bundle_root).parent
+            )
+            stage_manager.put(
+                local_path=absolute_dest, stage_path=stage_path, overwrite=True
+            )
+
     def execute_job(
         self,
         job_service_name: str,

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

@@ -0,0 +1,6 @@
+from snowflake.cli._plugins.spcs.services.service_entity_model import ServiceEntityModel
+from snowflake.cli.api.entities.common import EntityBase
+
+
+class ServiceEntity(EntityBase[ServiceEntityModel]):
+    pass

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

@@ -0,0 +1,45 @@
+from pathlib import Path
+from typing import List, Literal, Optional
+
+from pydantic import Field, field_validator
+from snowflake.cli._plugins.object.common import Tag
+from snowflake.cli.api.project.schemas.entities.common import (
+    EntityModelBaseWithArtifacts,
+    ExternalAccessBaseModel,
+)
+from snowflake.cli.api.project.schemas.updatable_model import DiscriminatorField
+from snowflake.cli.api.project.util import to_string_literal
+
+
+class ServiceEntityModel(EntityModelBaseWithArtifacts, ExternalAccessBaseModel):
+    type: Literal["service"] = DiscriminatorField()  # noqa: A003
+    stage: str = Field(
+        title="Stage where the service specification file is located", default=None
+    )
+    compute_pool: str = Field(title="Compute pool to run the service on", default=None)
+    spec_file: Path = Field(
+        title="Path to service specification file on stage", default=None
+    )
+    min_instances: Optional[int] = Field(
+        title="Minimum number of instances", default=1, ge=1
+    )
+    max_instances: Optional[int] = Field(
+        title="Maximum number of instances", default=None, ge=1
+    )
+    auto_resume: bool = Field(
+        title="The service will automatically resume when a service function or ingress is called.",
+        default=True,
+    )
+    query_warehouse: Optional[str] = Field(
+        title="Warehouse to use if a service container connects to Snowflake to execute a query without explicitly specifying a warehouse to use",
+        default=None,
+    )
+    tags: Optional[List[Tag]] = Field(title="Tag for the service", default=None)
+    comment: Optional[str] = Field(title="Comment for the service", default=None)
+
+    @field_validator("comment")
+    @classmethod
+    def _convert_artifacts(cls, comment: Optional[str]):
+        if comment:
+            return to_string_literal(comment)
+        return comment

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

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

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())
@@ -549,7 +561,7 @@ class StageManager(SqlExecutionMixin):
         )
 
         parsed_variables = parse_key_value_variables(variables)
-        sql_variables = self._parse_execute_variables(parsed_variables)
+        sql_variables = self.parse_execute_variables(parsed_variables)
         python_variables = self._parse_python_variables(parsed_variables)
         results = []
 
@@ -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
         )
 
@@ -651,7 +663,7 @@ class StageManager(SqlExecutionMixin):
         return [f for f in files if Path(f).suffix in EXECUTE_SUPPORTED_FILES_FORMATS]
 
     @staticmethod
-    def _parse_execute_variables(variables: List[Variable]) -> Optional[str]:
+    def parse_execute_variables(variables: List[Variable]) -> Optional[str]:
         if not variables:
             return None
         query_parameters = [f"{v.key}=>{v.value}" for v in variables]
@@ -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

@@ -16,11 +16,10 @@ from __future__ import annotations
 
 import logging
 from pathlib import Path
-from typing import Dict
 
 import click
 import typer
-from click import ClickException, UsageError
+from click import ClickException
 from snowflake.cli._plugins.object.command_aliases import (
     add_object_command_aliases,
     scope_option,
@@ -29,6 +28,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,
@@ -41,6 +43,7 @@ from snowflake.cli.api.commands.flags import (
     like_option,
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
+from snowflake.cli.api.commands.utils import get_entity_for_operation
 from snowflake.cli.api.constants import ObjectType
 from snowflake.cli.api.exceptions import NoProjectDefinitionError
 from snowflake.cli.api.identifiers import FQN
@@ -130,7 +133,8 @@ def _default_file_callback(param_name: str):
 @with_experimental_behaviour()
 def streamlit_deploy(
     replace: bool = ReplaceOption(
-        help="Replace the Streamlit app if it already exists."
+        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."
     ),
     entity_id: str = entity_argument("streamlit"),
     open_: bool = OpenOption,
@@ -152,29 +156,19 @@ def streamlit_deploy(
             )
         pd = convert_project_definition_to_v2(cli_context.project_root, pd)
 
-    streamlits: Dict[str, StreamlitEntityModel] = pd.get_entities_by_type(
-        entity_type="streamlit"
+    streamlit: StreamlitEntityModel = get_entity_for_operation(
+        cli_context=cli_context,
+        entity_id=entity_id,
+        project_definition=pd,
+        entity_type="streamlit",
     )
 
-    if not streamlits:
-        raise NoProjectDefinitionError(
-            project_type="streamlit", project_root=cli_context.project_root
-        )
-
-    if entity_id and entity_id not in streamlits:
-        raise UsageError(f"No '{entity_id}' entity in project definition file.")
-
-    if len(streamlits.keys()) == 1:
-        entity_id = list(streamlits.keys())[0]
-
-    if entity_id is None:
-        raise UsageError(
-            "Multiple Streamlit apps found. Please provide entity id for the operation."
-        )
-
-    # Get first streamlit
-    streamlit: StreamlitEntityModel = streamlits[entity_id]
-    url = StreamlitManager().deploy(streamlit=streamlit, replace=replace)
+    streamlit_project_paths = StreamlitProjectPaths(cli_context.project_root)
+    url = StreamlitManager().deploy(
+        streamlit=streamlit,
+        streamlit_project_paths=streamlit_project_paths,
+        replace=replace,
+    )
 
     if open_:
         typer.launch(url)