snowflake-cli 3.3.0__py3-none-any.whl → 3.5.0__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/compute_pool/commands.py

@@ -14,28 +14,37 @@
 
 from __future__ import annotations
 
-from typing import Optional
+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.common import CommentOption
-from snowflake.cli._plugins.spcs.common import (
-    validate_and_set_instances,
+from snowflake.cli._plugins.object.common import CommentOption, Tag, TagOption
+from snowflake.cli._plugins.spcs.common import validate_and_set_instances
+from snowflake.cli._plugins.spcs.compute_pool.compute_pool_entity_model import (
+    ComputePoolEntityModel,
 )
 from snowflake.cli._plugins.spcs.compute_pool.manager import ComputePoolManager
+from snowflake.cli.api.commands.decorators import with_project_definition
 from snowflake.cli.api.commands.flags import (
     IfNotExistsOption,
     OverrideableOption,
+    entity_argument,
     identifier_argument,
     like_option,
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
 from snowflake.cli.api.constants import ObjectType
 from snowflake.cli.api.identifiers import FQN
-from snowflake.cli.api.output.types import CommandResult, SingleQueryResult
+from snowflake.cli.api.output.types import (
+    CommandResult,
+    SingleQueryResult,
+)
+from snowflake.cli.api.project.definition_helper import (
+    get_entity_from_project_definition,
+)
 from snowflake.cli.api.project.util import is_valid_object_name
 
 app = SnowTyperFactory(
@@ -123,6 +132,7 @@ def create(
         help="Starts the compute pool in a suspended state.",
     ),
     auto_suspend_secs: int = AutoSuspendSecsOption(),
+    tags: Optional[List[Tag]] = TagOption(help="Tag for the compute pool."),
     comment: Optional[str] = CommentOption(help=_COMMENT_HELP),
     if_not_exists: bool = IfNotExistsOption(),
     **options,
@@ -139,12 +149,50 @@ def create(
         auto_resume=auto_resume,
         initially_suspended=initially_suspended,
         auto_suspend_secs=auto_suspend_secs,
+        tags=tags,
         comment=comment,
         if_not_exists=if_not_exists,
     )
     return SingleQueryResult(cursor)
 
 
+@app.command("deploy", requires_connection=True)
+@with_project_definition()
+def deploy(
+    entity_id: str = entity_argument("compute-pool"),
+    upgrade: bool = typer.Option(
+        False,
+        "--upgrade",
+        help="Updates the existing compute pool. Can update min_nodes, max_nodes, auto_resume, auto_suspend_seconds and comment.",
+    ),
+    **options,
+):
+    """
+    Deploys a compute pool from the project definition file.
+    """
+    compute_pool: ComputePoolEntityModel = get_entity_from_project_definition(
+        entity_type=ObjectType.COMPUTE_POOL, entity_id=entity_id
+    )
+    max_nodes = validate_and_set_instances(
+        compute_pool.min_nodes, compute_pool.max_nodes, "nodes"
+    )
+
+    cursor = ComputePoolManager().deploy(
+        pool_name=compute_pool.fqn.identifier,
+        min_nodes=compute_pool.min_nodes,
+        max_nodes=max_nodes,
+        instance_family=compute_pool.instance_family,
+        auto_resume=compute_pool.auto_resume,
+        initially_suspended=compute_pool.initially_suspended,
+        auto_suspend_seconds=compute_pool.auto_suspend_seconds,
+        tags=compute_pool.tags,
+        comment=compute_pool.comment,
+        upgrade=upgrade,
+    )
+
+    return SingleQueryResult(cursor)
+
+
 @app.command("stop-all", requires_connection=True)
 def stop_all(name: FQN = ComputePoolNameArgument, **options) -> CommandResult:
     """

snowflake/cli/_plugins/spcs/compute_pool/compute_pool_entity.py

@@ -0,0 +1,8 @@
+from snowflake.cli._plugins.spcs.compute_pool.compute_pool_entity_model import (
+    ComputePoolEntityModel,
+)
+from snowflake.cli.api.entities.common import EntityBase
+
+
+class ComputePoolEntity(EntityBase[ComputePoolEntityModel]):
+    pass

snowflake/cli/_plugins/spcs/compute_pool/compute_pool_entity_model.py

@@ -0,0 +1,37 @@
+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 EntityModelBase
+from snowflake.cli.api.project.schemas.updatable_model import DiscriminatorField
+from snowflake.cli.api.project.util import to_string_literal
+
+
+class ComputePoolEntityModel(EntityModelBase):
+    type: Literal["compute-pool"] = DiscriminatorField()  # noqa: A003
+    min_nodes: Optional[int] = Field(title="Minimum number of nodes", default=1, ge=1)
+    max_nodes: Optional[int] = Field(
+        title="Maximum number of nodes", default=None, ge=1
+    )
+    instance_family: str = Field(title="Name of the instance family", default=None)
+    auto_resume: Optional[bool] = Field(
+        title="The compute pool will automatically resume when a service or job is submitted to it",
+        default=True,
+    )
+    initially_suspended: Optional[bool] = Field(
+        title="Starts the compute pool in a suspended state", default=False
+    )
+    auto_suspend_seconds: Optional[int] = Field(
+        title="Number of seconds of inactivity after which you want Snowflake to automatically suspend the compute pool",
+        default=3600,
+        ge=1,
+    )
+    comment: Optional[str] = Field(title="Comment for the compute pool", default=None)
+    tags: Optional[List[Tag]] = Field(title="Tag for the compute pool", 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/compute_pool/manager.py

@@ -16,6 +16,7 @@ from __future__ import annotations
 
 from typing import List, Optional
 
+from snowflake.cli._plugins.object.common import Tag
 from snowflake.cli._plugins.spcs.common import (
     NoPropertiesProvidedError,
     handle_object_already_exists,
@@ -37,9 +38,11 @@ class ComputePoolManager(SqlExecutionMixin):
         auto_resume: bool,
         initially_suspended: bool,
         auto_suspend_secs: int,
+        tags: Optional[List[Tag]],
         comment: Optional[str],
         if_not_exists: bool,
     ) -> SnowflakeCursor:
+
         create_statement = "CREATE COMPUTE POOL"
         if if_not_exists:
             create_statement = f"{create_statement} IF NOT EXISTS"
@@ -55,11 +58,52 @@ class ComputePoolManager(SqlExecutionMixin):
         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.COMPUTE_POOL, pool_name)
 
+    def deploy(
+        self,
+        pool_name: str,
+        min_nodes: int,
+        max_nodes: int,
+        instance_family: str,
+        auto_resume: bool,
+        initially_suspended: bool,
+        auto_suspend_seconds: int,
+        tags: Optional[List[Tag]],
+        comment: Optional[str],
+        upgrade: bool,
+    ):
+
+        if upgrade:
+            return self.set_property(
+                pool_name=pool_name,
+                min_nodes=min_nodes,
+                max_nodes=max_nodes,
+                auto_resume=auto_resume,
+                auto_suspend_secs=auto_suspend_seconds,
+                comment=comment,
+            )
+        else:
+            return self.create(
+                pool_name=pool_name,
+                min_nodes=min_nodes,
+                max_nodes=max_nodes,
+                instance_family=instance_family,
+                auto_resume=auto_resume,
+                initially_suspended=initially_suspended,
+                auto_suspend_secs=auto_suspend_seconds,
+                tags=tags,
+                comment=comment,
+                if_not_exists=False,
+            )
+
     def stop(self, pool_name: str) -> SnowflakeCursor:
         return self.execute_query(f"alter compute pool {pool_name} stop all")
 
@@ -95,6 +139,7 @@ class ComputePoolManager(SqlExecutionMixin):
         for property_name, value in property_pairs:
             if value is not None:
                 query.append(f"{property_name} = {value}")
+
         return self.execute_query(strip_empty_lines(query))
 
     def unset_property(

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

@@ -26,9 +26,11 @@ from snowflake.cli._plugins.object.command_aliases import (
 )
 from snowflake.cli._plugins.spcs.image_registry.manager import RegistryManager
 from snowflake.cli._plugins.spcs.image_repository.manager import ImageRepositoryManager
+from snowflake.cli.api.commands.decorators import with_project_definition
 from snowflake.cli.api.commands.flags import (
     IfNotExistsOption,
     ReplaceOption,
+    entity_argument,
     identifier_argument,
     like_option,
 )
@@ -42,6 +44,9 @@ from snowflake.cli.api.output.types import (
     QueryResult,
     SingleQueryResult,
 )
+from snowflake.cli.api.project.definition_helper import (
+    get_entity_from_project_definition,
+)
 from snowflake.cli.api.project.util import is_valid_object_name
 
 app = SnowTyperFactory(
@@ -94,6 +99,30 @@ def create(
     )
 
 
+@app.command(requires_connection=True)
+@with_project_definition()
+def deploy(
+    entity_id: str = entity_argument("image-repository"),
+    replace: bool = ReplaceOption(
+        help="Replace the image repository if it already exists."
+    ),
+    **options,
+):
+    """
+    Deploys a new image repository from snowflake.yml file.
+    """
+    image_repository = get_entity_from_project_definition(
+        ObjectType.IMAGE_REPOSITORY, entity_id
+    )
+
+    cursor = ImageRepositoryManager().create(
+        name=image_repository.fqn.identifier,
+        if_not_exists=False,
+        replace=replace,
+    )
+    return SingleQueryResult(cursor)
+
+
 @app.command("list-images", requires_connection=True)
 def list_images(
     name: FQN = REPO_NAME_ARGUMENT,

snowflake/cli/_plugins/spcs/image_repository/image_repository_entity.py

@@ -0,0 +1,8 @@
+from snowflake.cli._plugins.spcs.image_repository.image_repository_entity_model import (
+    ImageRepositoryEntityModel,
+)
+from snowflake.cli.api.entities.common import EntityBase
+
+
+class ImageRepositoryEntity(EntityBase[ImageRepositoryEntityModel]):
+    pass

snowflake/cli/_plugins/spcs/image_repository/image_repository_entity_model.py

@@ -0,0 +1,8 @@
+from typing import Literal
+
+from snowflake.cli.api.project.schemas.entities.common import EntityModelBase
+from snowflake.cli.api.project.schemas.updatable_model import DiscriminatorField
+
+
+class ImageRepositoryEntityModel(EntityModelBase):
+    type: Literal["image-repository"] = DiscriminatorField()  # noqa: A003

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

@@ -64,7 +64,7 @@ class ImageRepositoryManager(SqlExecutionMixin):
         name: str,
         if_not_exists: bool,
         replace: bool,
-    ):
+    ) -> SnowflakeCursor:
         if if_not_exists and replace:
             raise ValueError(
                 "'replace' and 'if_not_exists' options are mutually exclusive for ImageRepositoryManager.create"

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

@@ -29,9 +29,16 @@ from snowflake.cli._plugins.spcs.common import (
     validate_and_set_instances,
 )
 from snowflake.cli._plugins.spcs.services.manager import ServiceManager
+from snowflake.cli._plugins.spcs.services.service_entity_model import ServiceEntityModel
+from snowflake.cli._plugins.spcs.services.service_project_paths import (
+    ServiceProjectPaths,
+)
+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 (
     IfNotExistsOption,
     OverrideableOption,
+    entity_argument,
     identifier_argument,
     like_option,
 )
@@ -51,6 +58,9 @@ from snowflake.cli.api.output.types import (
     SingleQueryResult,
     StreamResult,
 )
+from snowflake.cli.api.project.definition_helper import (
+    get_entity_from_project_definition,
+)
 from snowflake.cli.api.project.util import is_valid_object_name
 
 app = SnowTyperFactory(
@@ -200,6 +210,47 @@ def create(
     return SingleQueryResult(cursor)
 
 
+@app.command(requires_connection=True)
+@with_project_definition()
+def deploy(
+    entity_id: str = entity_argument("service"),
+    upgrade: bool = typer.Option(
+        False,
+        "--upgrade",
+        help="Updates the existing service. Can update min_instances, max_instances, query_warehouse, auto_resume, external_access_integrations and comment.",
+    ),
+    **options,
+) -> CommandResult:
+    """
+    Deploys a service defined in the project definition file.
+    """
+    service: ServiceEntityModel = get_entity_from_project_definition(
+        entity_type=ObjectType.SERVICE,
+        entity_id=entity_id,
+    )
+    service_project_paths = ServiceProjectPaths(get_cli_context().project_root)
+    max_instances = validate_and_set_instances(
+        service.min_instances, service.max_instances, "instances"
+    )
+    cursor = ServiceManager().deploy(
+        service_name=service.fqn.identifier,
+        stage=service.stage,
+        artifacts=service.artifacts,
+        compute_pool=service.compute_pool,
+        spec_path=service.spec_file,
+        min_instances=service.min_instances,
+        max_instances=max_instances,
+        auto_resume=service.auto_resume,
+        external_access_integrations=service.external_access_integrations,
+        query_warehouse=service.query_warehouse,
+        tags=service.tags,
+        comment=service.comment,
+        service_project_paths=service_project_paths,
+        upgrade=upgrade,
+    )
+    return SingleQueryResult(cursor)
+
+
 @app.command(requires_connection=True)
 def execute_job(
     name: FQN = ServiceNameArgument,
@@ -369,7 +420,6 @@ def events(
 
 @app.command(
     requires_connection=True,
-    is_enabled=FeatureFlag.ENABLE_SPCS_SERVICE_METRICS.is_enabled,
 )
 def metrics(
     name: FQN = ServiceNameArgument,