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

snowflake/cli/_plugins/project/project_entity_model.py

@@ -0,0 +1,40 @@
+# Copyright (c) 2024 Snowflake Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+from typing import Literal, Optional, TypeVar
+
+from pydantic import Field
+from snowflake.cli.api.entities.common import EntityBase, attach_spans_to_entity_actions
+from snowflake.cli.api.project.schemas.entities.common import (
+    EntityModelBaseWithArtifacts,
+)
+from snowflake.cli.api.project.schemas.updatable_model import (
+    DiscriminatorField,
+)
+
+T = TypeVar("T")
+
+
+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")
+
+
+@attach_spans_to_entity_actions(entity_name="project")
+class ProjectEntity(EntityBase[ProjectEntityModel]):
+    """Placeholder for project entity"""

snowflake/cli/_plugins/snowpark/commands.py

@@ -129,7 +129,8 @@ LikeOption = like_option(
 @with_project_definition()
 def deploy(
     replace: bool = ReplaceOption(
-        help="Replaces procedure or function if there were changes in the definition."
+        help="Replaces procedure or function if there were changes in the definition. It only uploads new and "
+        "overwrites existing files, but does not remove any files already on the stage."
     ),
     force_replace: bool = ForceReplaceOption(),
     **options,

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,
 )
@@ -40,6 +47,7 @@ from snowflake.cli.api.constants import ObjectType
 from snowflake.cli.api.exceptions import (
     IncompatibleParametersError,
 )
+from snowflake.cli.api.feature_flags import FeatureFlag
 from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.output.types import (
     CollectionResult,
@@ -50,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(
@@ -199,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,
@@ -320,6 +372,7 @@ def logs(
 
 @app.command(
     requires_connection=True,
+    is_enabled=FeatureFlag.ENABLE_SPCS_SERVICE_EVENTS.is_enabled,
 )
 def events(
     name: FQN = ServiceNameArgument,

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/manager.py

@@ -561,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 = []
 
@@ -663,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]