snowflake-ml-python 1.14.0__py3-none-any.whl → 1.15.0__py3-none-any.whl

snowflake/ml/_internal/platform_capabilities.py

@@ -1,8 +1,8 @@
 import json
+import logging
 from contextlib import contextmanager
 from typing import Any, Optional
 
-from absl import logging
 from packaging import version
 
 from snowflake.ml import version as snowml_version
@@ -13,6 +13,8 @@ from snowflake.snowpark import (
     session as snowpark_session,
 )
 
+logger = logging.getLogger(__name__)
+
 LIVE_COMMIT_PARAMETER = "ENABLE_LIVE_VERSION_IN_SDK"
 INLINE_DEPLOYMENT_SPEC_PARAMETER = "ENABLE_INLINE_DEPLOYMENT_SPEC_FROM_CLIENT_VERSION"
 
@@ -60,12 +62,12 @@ class PlatformCapabilities:
     @classmethod  # type: ignore[arg-type]
     @contextmanager
     def mock_features(cls, features: dict[str, Any] = _dummy_features) -> None:  # type: ignore[misc]
-        logging.debug(f"Setting mock features: {features}")
+        logger.debug(f"Setting mock features: {features}")
         cls.set_mock_features(features)
         try:
             yield
         finally:
-            logging.debug(f"Clearing mock features: {features}")
+            logger.debug(f"Clearing mock features: {features}")
             cls.clear_mock_features()
 
     def is_inlined_deployment_spec_enabled(self) -> bool:
@@ -98,7 +100,7 @@ class PlatformCapabilities:
                         error_code=error_codes.INTERNAL_SNOWML_ERROR, original_exception=RuntimeError(message)
                     )
         except snowpark_exceptions.SnowparkSQLException as e:
-            logging.debug(f"Failed to retrieve platform capabilities: {e}")
+            logger.debug(f"Failed to retrieve platform capabilities: {e}")
             # This can happen is server side is older than 9.2. That is fine.
         return {}
 
@@ -144,7 +146,7 @@ class PlatformCapabilities:
 
         value = self.features.get(feature_name)
         if value is None:
-            logging.debug(f"Feature {feature_name} not found, returning large version number")
+            logger.debug(f"Feature {feature_name} not found, returning large version number")
             return large_version
 
         try:
@@ -152,7 +154,7 @@ class PlatformCapabilities:
             version_str = str(value)
             return version.Version(version_str)
         except (version.InvalidVersion, ValueError, TypeError) as e:
-            logging.debug(
+            logger.debug(
                 f"Failed to parse version from feature {feature_name} with value '{value}': {e}. "
                 f"Returning large version number"
             )
@@ -171,7 +173,7 @@ class PlatformCapabilities:
         feature_version = self._get_version_feature(feature_name)
 
         result = current_version >= feature_version
-        logging.debug(
+        logger.debug(
             f"Version comparison for feature {feature_name}: "
             f"current={current_version}, feature={feature_version}, enabled={result}"
         )

snowflake/ml/_internal/utils/connection_params.py

@@ -1,11 +1,13 @@
 import configparser
+import logging
 import os
 from typing import Optional, Union
 
-from absl import logging
 from cryptography.hazmat import backends
 from cryptography.hazmat.primitives import serialization
 
+logger = logging.getLogger(__name__)
+
 _DEFAULT_CONNECTION_FILE = "~/.snowsql/config"
 
 
@@ -106,7 +108,7 @@ def _load_from_snowsql_config_file(connection_name: str, login_file: str = "") -
     """Loads the dictionary from snowsql config file."""
     snowsql_config_file = login_file if login_file else os.path.expanduser(_DEFAULT_CONNECTION_FILE)
     if not os.path.exists(snowsql_config_file):
-        logging.error(f"Connection name given but snowsql config file is not found at: {snowsql_config_file}")
+        logger.error(f"Connection name given but snowsql config file is not found at: {snowsql_config_file}")
         raise Exception("Snowflake SnowSQL config not found.")
 
     config = configparser.ConfigParser(inline_comment_prefixes="#")
@@ -122,7 +124,7 @@ def _load_from_snowsql_config_file(connection_name: str, login_file: str = "") -
         # See https://docs.snowflake.com/en/user-guide/snowsql-start.html#configuring-default-connection-settings
         connection_name = "connections"
 
-    logging.info(f"Reading {snowsql_config_file} for connection parameters defined as {connection_name}")
+    logger.info(f"Reading {snowsql_config_file} for connection parameters defined as {connection_name}")
     config.read(snowsql_config_file)
     conn_params = dict(config[connection_name])
     # Remap names to appropriate args in Python Connector API

snowflake/ml/_internal/utils/jwt_generator.py

@@ -110,15 +110,16 @@ class JWTGenerator:
         }
 
         # Regenerate the actual token
-        token = jwt.encode(payload, key=self.private_key, algorithm=JWTGenerator.ALGORITHM)
+        token = jwt.encode(payload, key=self.private_key, algorithm=JWTGenerator.ALGORITHM)  # type: ignore[arg-type]
         # If you are using a version of PyJWT prior to 2.0, jwt.encode returns a byte string instead of a string.
         # If the token is a byte string, convert it to a string.
         if isinstance(token, bytes):
             token = token.decode("utf-8")
         self.token = token
+        public_key = self.private_key.public_key()
         logger.info(
             "Generated a JWT with the following payload: %s",
-            jwt.decode(self.token, key=self.private_key.public_key(), algorithms=[JWTGenerator.ALGORITHM]),
+            jwt.decode(self.token, key=public_key, algorithms=[JWTGenerator.ALGORITHM]),  # type: ignore[arg-type]
         )
 
         return token

snowflake/ml/_internal/utils/temp_file_utils.py

@@ -1,10 +1,9 @@
+import logging
 import os
 import shutil
 import tempfile
 from typing import Iterable, Union
 
-from absl.logging import logging
-
 logger = logging.getLogger(__name__)
 
 

snowflake/ml/experiment/_client/experiment_tracking_sql_client.py

@@ -76,17 +76,30 @@ class ExperimentTrackingSQLClient(_base._BaseSQLClient):
             self._session, f"ALTER EXPERIMENT {experiment_fqn} DROP RUN {run_name}"
         ).has_dimensions(expected_rows=1, expected_cols=1).validate()
 
-    def modify_run(
+    def modify_run_add_metrics(
         self,
         *,
         experiment_name: sql_identifier.SqlIdentifier,
         run_name: sql_identifier.SqlIdentifier,
-        run_metadata: str,
+        metrics: str,
     ) -> None:
         experiment_fqn = self.fully_qualified_object_name(self._database_name, self._schema_name, experiment_name)
         query_result_checker.SqlResultValidator(
             self._session,
-            f"ALTER EXPERIMENT {experiment_fqn} MODIFY RUN {run_name} SET METADATA=$${run_metadata}$$",
+            f"ALTER EXPERIMENT {experiment_fqn} MODIFY RUN {run_name} ADD METRICS=$${metrics}$$",
+        ).has_dimensions(expected_rows=1, expected_cols=1).validate()
+
+    def modify_run_add_params(
+        self,
+        *,
+        experiment_name: sql_identifier.SqlIdentifier,
+        run_name: sql_identifier.SqlIdentifier,
+        params: str,
+    ) -> None:
+        experiment_fqn = self.fully_qualified_object_name(self._database_name, self._schema_name, experiment_name)
+        query_result_checker.SqlResultValidator(
+            self._session,
+            f"ALTER EXPERIMENT {experiment_fqn} MODIFY RUN {run_name} ADD PARAMETERS=$${params}$$",
         ).has_dimensions(expected_rows=1, expected_cols=1).validate()
 
     def put_artifact(

snowflake/ml/experiment/_entities/__init__.py

@@ -1,4 +1,5 @@
 from snowflake.ml.experiment._entities.experiment import Experiment
 from snowflake.ml.experiment._entities.run import Run
+from snowflake.ml.experiment._entities.run_metadata import Metric, Param
 
-__all__ = ["Experiment", "Run"]
+__all__ = ["Experiment", "Run", "Metric", "Param"]

snowflake/ml/experiment/_entities/run.py

@@ -1,11 +1,8 @@
-import json
 import types
 from typing import TYPE_CHECKING, Optional
 
 from snowflake.ml._internal.utils import sql_identifier
 from snowflake.ml.experiment import _experiment_info as experiment_info
-from snowflake.ml.experiment._client import experiment_tracking_sql_client
-from snowflake.ml.experiment._entities import run_metadata
 
 if TYPE_CHECKING:
     from snowflake.ml.experiment import experiment_tracking
@@ -41,18 +38,6 @@ class Run:
         if self._experiment_tracking._run is self:
             self._experiment_tracking.end_run()
 
-    def _get_metadata(
-        self,
-    ) -> run_metadata.RunMetadata:
-        runs = self._experiment_tracking._sql_client.show_runs_in_experiment(
-            experiment_name=self.experiment_name, like=str(self.name)
-        )
-        if not runs:
-            raise RuntimeError(f"Run {self.name} not found in experiment {self.experiment_name}.")
-        return run_metadata.RunMetadata.from_dict(
-            json.loads(runs[0][experiment_tracking_sql_client.ExperimentTrackingSQLClient.RUN_METADATA_COL_NAME])
-        )
-
     def _get_experiment_info(self) -> experiment_info.ExperimentInfo:
         return experiment_info.ExperimentInfo(
             fully_qualified_name=self._experiment_tracking._sql_client.fully_qualified_object_name(

snowflake/ml/experiment/_entities/run_metadata.py

@@ -1,12 +1,4 @@
 import dataclasses
-import enum
-import typing
-
-
-class RunStatus(str, enum.Enum):
-    UNKNOWN = "UNKNOWN"
-    RUNNING = "RUNNING"
-    FINISHED = "FINISHED"
 
 
 @dataclasses.dataclass
@@ -15,54 +7,14 @@ class Metric:
     value: float
     step: int
 
+    def to_dict(self) -> dict:  # type: ignore[type-arg]
+        return dataclasses.asdict(self)
+
 
 @dataclasses.dataclass
 class Param:
     name: str
     value: str
 
-
-@dataclasses.dataclass
-class RunMetadata:
-    status: RunStatus
-    metrics: list[Metric]
-    parameters: list[Param]
-
-    @classmethod
-    def from_dict(
-        cls,
-        metadata: dict,  # type: ignore[type-arg]
-    ) -> "RunMetadata":
-        return RunMetadata(
-            status=RunStatus(metadata.get("status", RunStatus.UNKNOWN.value)),
-            metrics=[Metric(**m) for m in metadata.get("metrics", [])],
-            parameters=[Param(**p) for p in metadata.get("parameters", [])],
-        )
-
     def to_dict(self) -> dict:  # type: ignore[type-arg]
         return dataclasses.asdict(self)
-
-    def set_metric(
-        self,
-        key: str,
-        value: float,
-        step: int,
-    ) -> None:
-        for metric in self.metrics:
-            if metric.name == key and metric.step == step:
-                metric.value = value
-                break
-        else:
-            self.metrics.append(Metric(name=key, value=value, step=step))
-
-    def set_param(
-        self,
-        key: str,
-        value: typing.Any,
-    ) -> None:
-        for parameter in self.parameters:
-            if parameter.name == key:
-                parameter.value = str(value)
-                break
-        else:
-            self.parameters.append(Param(name=key, value=str(value)))

snowflake/ml/experiment/experiment_tracking.py

@@ -261,13 +261,13 @@ class ExperimentTracking(mixins.SerializableSessionMixin):
             step: The step of the metrics. Defaults to 0.
         """
         run = self._get_or_start_run()
-        metadata = run._get_metadata()
+        metrics_list = []
         for key, value in metrics.items():
-            metadata.set_metric(key, value, step)
-        self._sql_client.modify_run(
+            metrics_list.append(entities.Metric(key, value, step))
+        self._sql_client.modify_run_add_metrics(
             experiment_name=run.experiment_name,
             run_name=run.name,
-            run_metadata=json.dumps(metadata.to_dict()),
+            metrics=json.dumps([metric.to_dict() for metric in metrics_list]),
         )
 
     def log_param(
@@ -296,13 +296,13 @@ class ExperimentTracking(mixins.SerializableSessionMixin):
                 to string.
         """
         run = self._get_or_start_run()
-        metadata = run._get_metadata()
+        params_list = []
         for key, value in params.items():
-            metadata.set_param(key, value)
-        self._sql_client.modify_run(
+            params_list.append(entities.Param(key, str(value)))
+        self._sql_client.modify_run_add_params(
             experiment_name=run.experiment_name,
             run_name=run.name,
-            run_metadata=json.dumps(metadata.to_dict()),
+            params=json.dumps([param.to_dict() for param in params_list]),
         )
 
     def log_artifact(

snowflake/ml/model/__init__.py

@@ -1,10 +1,6 @@
-from snowflake.ml.model._client.model.batch_inference_specs import (
-    InputSpec,
-    JobSpec,
-    OutputSpec,
-)
+from snowflake.ml.model._client.model.batch_inference_specs import JobSpec, OutputSpec
 from snowflake.ml.model._client.model.model_impl import Model
 from snowflake.ml.model._client.model.model_version_impl import ExportMode, ModelVersion
 from snowflake.ml.model.models.huggingface_pipeline import HuggingFacePipelineModel
 
-__all__ = ["Model", "ModelVersion", "ExportMode", "HuggingFacePipelineModel", "InputSpec", "JobSpec", "OutputSpec"]
+__all__ = ["Model", "ModelVersion", "ExportMode", "HuggingFacePipelineModel", "JobSpec", "OutputSpec"]

snowflake/ml/model/_client/model/batch_inference_specs.py

@@ -3,10 +3,6 @@ from typing import Optional, Union
 from pydantic import BaseModel
 
 
-class InputSpec(BaseModel):
-    stage_location: str
-
-
 class OutputSpec(BaseModel):
     stage_location: str
 

snowflake/ml/model/_client/model/inference_engine_utils.py

@@ -0,0 +1,55 @@
+from typing import Any, Optional, Union
+
+from snowflake.ml.model._client.ops import service_ops
+
+
+def _get_inference_engine_args(
+    experimental_options: Optional[dict[str, Any]],
+) -> Optional[service_ops.InferenceEngineArgs]:
+
+    if not experimental_options:
+        return None
+
+    if "inference_engine" not in experimental_options:
+        raise ValueError("inference_engine is required in experimental_options")
+
+    return service_ops.InferenceEngineArgs(
+        inference_engine=experimental_options["inference_engine"],
+        inference_engine_args_override=experimental_options.get("inference_engine_args_override"),
+    )
+
+
+def _enrich_inference_engine_args(
+    inference_engine_args: service_ops.InferenceEngineArgs,
+    gpu_requests: Optional[Union[str, int]] = None,
+) -> Optional[service_ops.InferenceEngineArgs]:
+    """Enrich inference engine args with model path and tensor parallelism settings.
+
+    Args:
+        inference_engine_args: The original inference engine args
+        gpu_requests: The number of GPUs requested
+
+    Returns:
+        Enriched inference engine args
+
+    Raises:
+        ValueError: Invalid gpu_requests
+    """
+    if inference_engine_args.inference_engine_args_override is None:
+        inference_engine_args.inference_engine_args_override = []
+
+    gpu_count = None
+
+    # Set tensor-parallelism if gpu_requests is specified
+    if gpu_requests is not None:
+        # assert gpu_requests is a string or an integer before casting to int
+        try:
+            gpu_count = int(gpu_requests)
+            if gpu_count > 0:
+                inference_engine_args.inference_engine_args_override.append(f"--tensor-parallel-size={gpu_count}")
+            else:
+                raise ValueError(f"GPU count must be greater than 0, got {gpu_count}")
+        except ValueError:
+            raise ValueError(f"Invalid gpu_requests: {gpu_requests} with type {type(gpu_requests).__name__}")
+
+    return inference_engine_args

snowflake/ml/model/_client/model/model_version_impl.py

@@ -12,7 +12,10 @@ from snowflake.ml._internal import telemetry
 from snowflake.ml._internal.utils import sql_identifier
 from snowflake.ml.lineage import lineage_node
 from snowflake.ml.model import task, type_hints
-from snowflake.ml.model._client.model import batch_inference_specs
+from snowflake.ml.model._client.model import (
+    batch_inference_specs,
+    inference_engine_utils,
+)
 from snowflake.ml.model._client.ops import metadata_ops, model_ops, service_ops
 from snowflake.ml.model._model_composer import model_composer
 from snowflake.ml.model._model_composer.model_manifest import model_manifest_schema
@@ -22,6 +25,7 @@ from snowflake.snowpark import Session, async_job, dataframe
 _TELEMETRY_PROJECT = "MLOps"
 _TELEMETRY_SUBPROJECT = "ModelManagement"
 _BATCH_INFERENCE_JOB_ID_PREFIX = "BATCH_INFERENCE_"
+_BATCH_INFERENCE_TEMPORARY_FOLDER = "_temporary"
 
 
 class ExportMode(enum.Enum):
@@ -553,7 +557,7 @@ class ModelVersion(lineage_node.LineageNode):
         self,
         *,
         compute_pool: str,
-        input_spec: batch_inference_specs.InputSpec,
+        input_spec: dataframe.DataFrame,
         output_spec: batch_inference_specs.OutputSpec,
         job_spec: Optional[batch_inference_specs.JobSpec] = None,
     ) -> jobs.MLJob[Any]:
@@ -569,6 +573,18 @@ class ModelVersion(lineage_node.LineageNode):
         if warehouse is None:
             raise ValueError("Warehouse is not set. Please set the warehouse field in the JobSpec.")
 
+        # use a temporary folder in the output stage to store the intermediate output from the dataframe
+        output_stage_location = output_spec.stage_location
+        if not output_stage_location.endswith("/"):
+            output_stage_location += "/"
+        input_stage_location = f"{output_stage_location}{_BATCH_INFERENCE_TEMPORARY_FOLDER}/"
+
+        try:
+            input_spec.write.copy_into_location(location=input_stage_location, file_format_type="parquet", header=True)
+        # todo: be specific about the type of errors to provide better error messages.
+        except Exception as e:
+            raise RuntimeError(f"Failed to process input_spec: {e}")
+
         if job_spec.job_name is None:
             # Same as the MLJob ID generation logic with a different prefix
             job_name = f"{_BATCH_INFERENCE_JOB_ID_PREFIX}{str(uuid.uuid4()).replace('-', '_').upper()}"
@@ -592,9 +608,9 @@ class ModelVersion(lineage_node.LineageNode):
             job_name=job_name,
             replicas=job_spec.replicas,
             # input and output
-            input_stage_location=input_spec.stage_location,
+            input_stage_location=input_stage_location,
             input_file_pattern="*",
-            output_stage_location=output_spec.stage_location,
+            output_stage_location=output_stage_location,
             completion_filename="_SUCCESS",
             # misc
             statement_params=statement_params,
@@ -768,60 +784,6 @@ class ModelVersion(lineage_node.LineageNode):
             version_name=sql_identifier.SqlIdentifier(version),
         )
 
-    def _get_inference_engine_args(
-        self, experimental_options: Optional[dict[str, Any]]
-    ) -> Optional[service_ops.InferenceEngineArgs]:
-
-        if not experimental_options:
-            return None
-
-        if "inference_engine" not in experimental_options:
-            raise ValueError("inference_engine is required in experimental_options")
-
-        return service_ops.InferenceEngineArgs(
-            inference_engine=experimental_options["inference_engine"],
-            inference_engine_args_override=experimental_options.get("inference_engine_args_override"),
-        )
-
-    def _enrich_inference_engine_args(
-        self,
-        inference_engine_args: service_ops.InferenceEngineArgs,
-        gpu_requests: Optional[Union[str, int]] = None,
-    ) -> Optional[service_ops.InferenceEngineArgs]:
-        """Enrich inference engine args with tensor parallelism settings.
-
-        Args:
-            inference_engine_args: The original inference engine args
-            gpu_requests: The number of GPUs requested
-
-        Returns:
-            Enriched inference engine args
-
-        Raises:
-            ValueError: Invalid gpu_requests
-        """
-        if inference_engine_args.inference_engine_args_override is None:
-            inference_engine_args.inference_engine_args_override = []
-
-        gpu_count = None
-
-        # Set tensor-parallelism if gpu_requests is specified
-        if gpu_requests is not None:
-            # assert gpu_requests is a string or an integer before casting to int
-            if isinstance(gpu_requests, str) or isinstance(gpu_requests, int):
-                try:
-                    gpu_count = int(gpu_requests)
-                except ValueError:
-                    raise ValueError(f"Invalid gpu_requests: {gpu_requests}")
-
-        if gpu_count is not None:
-            if gpu_count > 0:
-                inference_engine_args.inference_engine_args_override.append(f"--tensor-parallel-size={gpu_count}")
-            else:
-                raise ValueError(f"Invalid gpu_requests: {gpu_requests}")
-
-        return inference_engine_args
-
     def _check_huggingface_text_generation_model(
         self,
         statement_params: Optional[dict[str, Any]] = None,
@@ -1101,13 +1063,14 @@ class ModelVersion(lineage_node.LineageNode):
         if experimental_options:
             self._check_huggingface_text_generation_model(statement_params)
 
-        inference_engine_args: Optional[service_ops.InferenceEngineArgs] = self._get_inference_engine_args(
-            experimental_options
-        )
+        inference_engine_args = inference_engine_utils._get_inference_engine_args(experimental_options)
 
         # Enrich inference engine args if inference engine is specified
         if inference_engine_args is not None:
-            inference_engine_args = self._enrich_inference_engine_args(inference_engine_args, gpu_requests)
+            inference_engine_args = inference_engine_utils._enrich_inference_engine_args(
+                inference_engine_args,
+                gpu_requests,
+            )
 
         from snowflake.ml.model import event_handler
         from snowflake.snowpark import exceptions

snowflake/ml/model/_client/ops/service_ops.py

@@ -155,7 +155,8 @@ class ServiceOperator:
             database_name=database_name,
             schema_name=schema_name,
         )
-        if pc.PlatformCapabilities.get_instance().is_inlined_deployment_spec_enabled():
+        self._use_inlined_deployment_spec = pc.PlatformCapabilities.get_instance().is_inlined_deployment_spec_enabled()
+        if self._use_inlined_deployment_spec:
             self._workspace = None
             self._model_deployment_spec = model_deployment_spec.ModelDeploymentSpec()
         else:
@@ -264,7 +265,14 @@ class ServiceOperator:
             self._model_deployment_spec.add_hf_logger_spec(
                 hf_model_name=hf_model_args.hf_model_name,
                 hf_task=hf_model_args.hf_task,
-                hf_token=hf_model_args.hf_token,
+                hf_token=(
+                    # when using inlined deployment spec, we need to use QMARK_RESERVED_TOKEN
+                    # to avoid revealing the token while calling the SYSTEM$DEPLOY_MODEL function
+                    # noop if using file-based deployment spec or token is not provided
+                    service_sql.QMARK_RESERVED_TOKEN
+                    if hf_model_args.hf_token and self._use_inlined_deployment_spec
+                    else hf_model_args.hf_token
+                ),
                 hf_tokenizer=hf_model_args.hf_tokenizer,
                 hf_revision=hf_model_args.hf_revision,
                 hf_trust_remote_code=hf_model_args.hf_trust_remote_code,
@@ -320,6 +328,14 @@ class ServiceOperator:
                 model_deployment_spec.ModelDeploymentSpec.DEPLOY_SPEC_FILE_REL_PATH if self._workspace else None
             ),
             model_deployment_spec_yaml_str=None if self._workspace else spec_yaml_str_or_path,
+            query_params=(
+                # when using inlined deployment spec, we need to add the token to the query params
+                # to avoid revealing the token while calling the SYSTEM$DEPLOY_MODEL function
+                # noop if using file-based deployment spec or token is not provided
+                [hf_model_args.hf_token]
+                if (self._use_inlined_deployment_spec and hf_model_args and hf_model_args.hf_token)
+                else []
+            ),
             statement_params=statement_params,
         )
 

snowflake/ml/model/_client/sql/service.py

@@ -1,8 +1,9 @@
+import contextlib
 import dataclasses
 import enum
 import logging
 import textwrap
-from typing import Any, Optional
+from typing import Any, Generator, Optional
 
 from snowflake import snowpark
 from snowflake.ml._internal.utils import (
@@ -17,6 +18,11 @@ from snowflake.snowpark._internal import utils as snowpark_utils
 
 logger = logging.getLogger(__name__)
 
+# Using this token instead of '?' to avoid escaping issues
+# After quotes are escaped, we replace this token with '|| ? ||'
+QMARK_RESERVED_TOKEN = "<QMARK_RESERVED_TOKEN>"
+QMARK_PARAMETER_TOKEN = "'|| ? ||'"
+
 
 class ServiceStatus(enum.Enum):
     PENDING = "PENDING"
@@ -70,12 +76,26 @@ class ServiceSQLClient(_base._BaseSQLClient):
     CONTAINER_STATUS = "status"
     MESSAGE = "message"
 
+    @contextlib.contextmanager
+    def _qmark_paramstyle(self) -> Generator[None, None, None]:
+        """Context manager that temporarily changes paramstyle to qmark and restores original value on exit."""
+        if not hasattr(self._session, "_options"):
+            yield
+        else:
+            original_paramstyle = self._session._options["paramstyle"]
+            try:
+                self._session._options["paramstyle"] = "qmark"
+                yield
+            finally:
+                self._session._options["paramstyle"] = original_paramstyle
+
     def deploy_model(
         self,
         *,
         stage_path: Optional[str] = None,
         model_deployment_spec_yaml_str: Optional[str] = None,
         model_deployment_spec_file_rel_path: Optional[str] = None,
+        query_params: Optional[list[Any]] = None,
         statement_params: Optional[dict[str, Any]] = None,
     ) -> tuple[str, snowpark.AsyncJob]:
         assert model_deployment_spec_yaml_str or model_deployment_spec_file_rel_path
@@ -83,11 +103,18 @@ class ServiceSQLClient(_base._BaseSQLClient):
             model_deployment_spec_yaml_str = snowpark_utils.escape_single_quotes(
                 model_deployment_spec_yaml_str
             )  # type: ignore[no-untyped-call]
+            model_deployment_spec_yaml_str = model_deployment_spec_yaml_str.replace(  # type: ignore[union-attr]
+                QMARK_RESERVED_TOKEN, QMARK_PARAMETER_TOKEN
+            )
             logger.info(f"Deploying model with spec={model_deployment_spec_yaml_str}")
             sql_str = f"CALL SYSTEM$DEPLOY_MODEL('{model_deployment_spec_yaml_str}')"
         else:
             sql_str = f"CALL SYSTEM$DEPLOY_MODEL('@{stage_path}/{model_deployment_spec_file_rel_path}')"
-        async_job = self._session.sql(sql_str).collect(block=False, statement_params=statement_params)
+        with self._qmark_paramstyle():
+            async_job = self._session.sql(
+                sql_str,
+                params=query_params if query_params else None,
+            ).collect(block=False, statement_params=statement_params)
         assert isinstance(async_job, snowpark.AsyncJob)
         return async_job.query_id, async_job