snowflake-ml-python 1.19.0__tar.gz → 1.20.0__tar.gz

{snowflake_ml_python-1.19.0 → snowflake_ml_python-1.20.0}/CHANGELOG.md

@@ -1,10 +1,51 @@
 # Release History
 
-## 1.19.0
+## 1.20.0
 
 ### Bug Fixes
 
-* Experiment Tracking (PrPr): No longer throw an exception in `list_artifacts` when run does not have artifacts.
+* Experiment Tracking (PuPr): Reaching the run metadata size limit in `log_metrics` or `log_params` will warn the user
+  instead of raising an exception.
+
+### Behavior Changes
+
+### New Features
+
+* Registry (PrPr): Introducing vLLM as a backend inference engine. The `create_service` API will now
+ accept `inference_engine_options` as an argument.
+
+```python
+from snowflake.ml.model.inference_engine import InferenceEngine
+
+mv = snowflake_registry.log_model(
+    model=generator,
+    model_name=...,
+    ...,
+    # Specifying OPENAI_CHAT_SIGNATURE is necessary to use vLLM inference engine
+    signatures=openai_signatures.OPENAI_CHAT_SIGNATURE,
+)
+
+mv.create_service(
+    service_name=my_serv,
+    service_compute_pool=...,
+    ...,
+    inference_engine_options={
+        "engine": InferenceEngine.VLLM,
+        "engine_args_override": [
+            "--max-model-len=2048",
+            "--gpu-memory-utilization=0.9"
+        ]
+    }
+)
+```
+
+### Deprecations
+
+## 1.19.0 (11-13-2025)
+
+### Bug Fixes
+
+* Experiment Tracking (PuPr): No longer throw an exception in `list_artifacts` when run does not have artifacts.
 * Registry: Fix `get_version_by_alias`: now requires an exact match of snowflake identifier.
 
 ### Behavior Changes

{snowflake_ml_python-1.19.0/snowflake_ml_python.egg-info → snowflake_ml_python-1.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.19.0
+Version: 1.20.0
 Summary: The machine learning client library that is used for interacting with Snowflake to build machine learning solutions.
 Author-email: "Snowflake, Inc" <support@snowflake.com>
 License: 
@@ -240,7 +240,7 @@ Requires-Dist: cryptography
 Requires-Dist: fsspec[http]<2026,>=2024.6.1
 Requires-Dist: importlib_resources<7,>=6.1.1
 Requires-Dist: numpy<3,>=1.23
-Requires-Dist: packaging<25,>=20.9
+Requires-Dist: packaging<26,>=20.9
 Requires-Dist: pandas<3,>=2.1.4
 Requires-Dist: platformdirs<5
 Requires-Dist: pyarrow<19.0.0
@@ -415,11 +415,52 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
-## 1.19.0
+## 1.20.0
 
 ### Bug Fixes
 
-* Experiment Tracking (PrPr): No longer throw an exception in `list_artifacts` when run does not have artifacts.
+* Experiment Tracking (PuPr): Reaching the run metadata size limit in `log_metrics` or `log_params` will warn the user
+  instead of raising an exception.
+
+### Behavior Changes
+
+### New Features
+
+* Registry (PrPr): Introducing vLLM as a backend inference engine. The `create_service` API will now
+ accept `inference_engine_options` as an argument.
+
+```python
+from snowflake.ml.model.inference_engine import InferenceEngine
+
+mv = snowflake_registry.log_model(
+    model=generator,
+    model_name=...,
+    ...,
+    # Specifying OPENAI_CHAT_SIGNATURE is necessary to use vLLM inference engine
+    signatures=openai_signatures.OPENAI_CHAT_SIGNATURE,
+)
+
+mv.create_service(
+    service_name=my_serv,
+    service_compute_pool=...,
+    ...,
+    inference_engine_options={
+        "engine": InferenceEngine.VLLM,
+        "engine_args_override": [
+            "--max-model-len=2048",
+            "--gpu-memory-utilization=0.9"
+        ]
+    }
+)
+```
+
+### Deprecations
+
+## 1.19.0 (11-13-2025)
+
+### Bug Fixes
+
+* Experiment Tracking (PuPr): No longer throw an exception in `list_artifacts` when run does not have artifacts.
 * Registry: Fix `get_version_by_alias`: now requires an exact match of snowflake identifier.
 
 ### Behavior Changes

{snowflake_ml_python-1.19.0 → snowflake_ml_python-1.20.0}/pyproject.toml

@@ -8,7 +8,7 @@ description = "The machine learning client library that is used for interacting
 classifiers = [ "Development Status :: 5 - Production/Stable", "Environment :: Console", "Environment :: Other Environment", "Intended Audience :: Developers", "Intended Audience :: Education", "Intended Audience :: Information Technology", "Intended Audience :: System Administrators", "License :: OSI Approved :: Apache Software License", "Operating System :: OS Independent", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Topic :: Database", "Topic :: Software Development", "Topic :: Software Development :: Libraries", "Topic :: Software Development :: Libraries :: Application Frameworks", "Topic :: Software Development :: Libraries :: Python Modules", "Topic :: Scientific/Engineering :: Information Analysis",]
 requires-python = ">=3.9, <3.13"
 dynamic = [ "version", "readme",]
-dependencies = [ "anyio>=3.5.0,<5", "cachetools>=3.1.1,<6", "cloudpickle>=2.0.0", "cryptography", "fsspec[http]>=2024.6.1,<2026", "importlib_resources>=6.1.1, <7", "numpy>=1.23,<3", "packaging>=20.9,<25", "pandas>=2.1.4,<3", "platformdirs<5", "pyarrow<19.0.0", "pydantic>=2.8.2, <3", "pyjwt>=2.0.0, <3", "pytimeparse>=1.1.8,<2", "pyyaml>=6.0,<7", "retrying>=1.3.3,<2", "s3fs>=2024.6.1,<2026", "scikit-learn<1.8", "scipy>=1.9,<2", "shap>=0.46.0,<1", "snowflake-connector-python[pandas]>=3.17.3,<4", "snowflake-snowpark-python>=1.17.0,<2,!=1.26.0", "snowflake.core>=1.0.2,<2", "sqlparse>=0.4,<1", "tqdm<5", "typing-extensions>=4.1.0,<5", "xgboost<4",]
+dependencies = [ "anyio>=3.5.0,<5", "cachetools>=3.1.1,<6", "cloudpickle>=2.0.0", "cryptography", "fsspec[http]>=2024.6.1,<2026", "importlib_resources>=6.1.1, <7", "numpy>=1.23,<3", "packaging>=20.9,<26", "pandas>=2.1.4,<3", "platformdirs<5", "pyarrow<19.0.0", "pydantic>=2.8.2, <3", "pyjwt>=2.0.0, <3", "pytimeparse>=1.1.8,<2", "pyyaml>=6.0,<7", "retrying>=1.3.3,<2", "s3fs>=2024.6.1,<2026", "scikit-learn<1.8", "scipy>=1.9,<2", "shap>=0.46.0,<1", "snowflake-connector-python[pandas]>=3.17.3,<4", "snowflake-snowpark-python>=1.17.0,<2,!=1.26.0", "snowflake.core>=1.0.2,<2", "sqlparse>=0.4,<1", "tqdm<5", "typing-extensions>=4.1.0,<5", "xgboost<4",]
 [[project.authors]]
 name = "Snowflake, Inc"
 email = "support@snowflake.com"

{snowflake_ml_python-1.19.0 → snowflake_ml_python-1.20.0}/snowflake/ml/_internal/env_utils.py

@@ -16,6 +16,7 @@ from snowflake.ml import version as snowml_version
 from snowflake.ml._internal import env as snowml_env, relax_version_strategy
 from snowflake.ml._internal.utils import query_result_checker
 from snowflake.snowpark import context, exceptions, session
+from snowflake.snowpark._internal import utils as snowpark_utils
 
 
 class CONDA_OS(Enum):
@@ -38,6 +39,21 @@ SNOWPARK_ML_PKG_NAME = "snowflake-ml-python"
 SNOWFLAKE_CONDA_CHANNEL_URL = "https://repo.anaconda.com/pkgs/snowflake"
 
 
+def get_execution_context() -> str:
+    """Detect execution context: EXTERNAL, SPCS, or SPROC.
+
+    Returns:
+        str: The execution context - "SPROC" if running in a stored procedure,
+             "SPCS" if running in SPCS ML runtime, "EXTERNAL" otherwise.
+    """
+    if snowpark_utils.is_in_stored_procedure():  # type: ignore[no-untyped-call]
+        return "SPROC"
+    elif snowml_env.IN_ML_RUNTIME:
+        return "SPCS"
+    else:
+        return "EXTERNAL"
+
+
 def _validate_pip_requirement_string(req_str: str) -> requirements.Requirement:
     """Validate the input pip requirement string according to PEP 508.
 

{snowflake_ml_python-1.19.0 → snowflake_ml_python-1.20.0}/snowflake/ml/_internal/telemetry.py

@@ -16,7 +16,7 @@ from typing_extensions import ParamSpec
 from snowflake import connector
 from snowflake.connector import connect, telemetry as connector_telemetry, time_util
 from snowflake.ml import version as snowml_version
-from snowflake.ml._internal import env
+from snowflake.ml._internal import env, env_utils
 from snowflake.ml._internal.exceptions import (
     error_codes,
     exceptions as snowml_exceptions,
@@ -37,6 +37,22 @@ _CONNECTION_TYPES = {
 _Args = ParamSpec("_Args")
 _ReturnValue = TypeVar("_ReturnValue")
 
+_conn: Optional[connector.SnowflakeConnection] = None
+
+
+def clear_cached_conn() -> None:
+    """Clear the cached Snowflake connection. Primarily for testing purposes."""
+    global _conn
+    if _conn is not None and _conn.is_valid():
+        _conn.close()
+    _conn = None
+
+
+def get_cached_conn() -> Optional[connector.SnowflakeConnection]:
+    """Get the cached Snowflake connection. Primarily for testing purposes."""
+    global _conn
+    return _conn
+
 
 def _get_login_token() -> Union[str, bytes]:
     with open("/snowflake/session/token") as f:
@@ -44,7 +60,11 @@ def _get_login_token() -> Union[str, bytes]:
 
 
 def _get_snowflake_connection() -> Optional[connector.SnowflakeConnection]:
-    conn = None
+    global _conn
+    if _conn is not None and _conn.is_valid():
+        return _conn
+
+    conn: Optional[connector.SnowflakeConnection] = None
     if os.getenv("SNOWFLAKE_HOST") is not None and os.getenv("SNOWFLAKE_ACCOUNT") is not None:
         try:
             conn = connect(
@@ -66,6 +86,13 @@ def _get_snowflake_connection() -> Optional[connector.SnowflakeConnection]:
             # Failed to get an active session. No connection available.
             pass
 
+    # cache the connection if it's a SnowflakeConnection. there is a behavior at runtime where it could be a
+    # StoredProcConnection perhaps incorrect type hinting somewhere
+    if isinstance(conn, connector.SnowflakeConnection):
+        # if _conn was expired, we need to copy telemetry data to new connection
+        if _conn is not None and conn is not None:
+            conn._telemetry._log_batch.extend(_conn._telemetry._log_batch)
+        _conn = conn
     return conn
 
 
@@ -113,6 +140,13 @@ class TelemetryField(enum.Enum):
     FUNC_CAT_USAGE = "usage"
 
 
+@enum.unique
+class CustomTagKey(enum.Enum):
+    """Keys for custom tags in telemetry."""
+
+    EXECUTION_CONTEXT = "execution_context"
+
+
 class _TelemetrySourceType(enum.Enum):
     # Automatically inferred telemetry/statement parameters
     AUTO_TELEMETRY = "SNOWML_AUTO_TELEMETRY"
@@ -441,6 +475,7 @@ def send_api_usage_telemetry(
     sfqids_extractor: Optional[Callable[..., list[str]]] = None,
     subproject_extractor: Optional[Callable[[Any], str]] = None,
     custom_tags: Optional[dict[str, Union[bool, int, str, float]]] = None,
+    log_execution_context: bool = True,
 ) -> Callable[[Callable[_Args, _ReturnValue]], Callable[_Args, _ReturnValue]]:
     """
     Decorator that sends API usage telemetry and adds function usage statement parameters to the dataframe returned by
@@ -455,6 +490,8 @@ def send_api_usage_telemetry(
         sfqids_extractor: Extract sfqids from `self`.
         subproject_extractor: Extract subproject at runtime from `self`.
         custom_tags: Custom tags.
+        log_execution_context: If True, automatically detect and log execution context
+            (EXTERNAL, SPCS, or SPROC) in custom_tags.
 
     Returns:
         Decorator that sends function usage telemetry for any call to the decorated function.
@@ -495,6 +532,11 @@ def send_api_usage_telemetry(
             if subproject_extractor is not None:
                 subproject_name = subproject_extractor(args[0])
 
+            # Add execution context if enabled
+            final_custom_tags = {**custom_tags} if custom_tags is not None else {}
+            if log_execution_context:
+                final_custom_tags[CustomTagKey.EXECUTION_CONTEXT.value] = env_utils.get_execution_context()
+
             statement_params = get_function_usage_statement_params(
                 project=project,
                 subproject=subproject_name,
@@ -502,7 +544,7 @@ def send_api_usage_telemetry(
                 function_name=_get_full_func_name(func),
                 function_parameters=params,
                 api_calls=api_calls,
-                custom_tags=custom_tags,
+                custom_tags=final_custom_tags,
             )
 
             def update_stmt_params_if_snowpark_df(obj: _ReturnValue, statement_params: dict[str, Any]) -> _ReturnValue:
@@ -538,7 +580,10 @@ def send_api_usage_telemetry(
             if conn_attr_name:
                 # raise AttributeError if conn attribute does not exist in `self`
                 conn = operator.attrgetter(conn_attr_name)(args[0])
-                if not isinstance(conn, _CONNECTION_TYPES.get(type(conn).__name__, connector.SnowflakeConnection)):
+                if not isinstance(
+                    conn,
+                    _CONNECTION_TYPES.get(type(conn).__name__, connector.SnowflakeConnection),
+                ):
                     raise TypeError(
                         f"Expected a conn object of type {' or '.join(_CONNECTION_TYPES.keys())} but got {type(conn)}"
                     )
@@ -560,7 +605,7 @@ def send_api_usage_telemetry(
                 func_params=params,
                 api_calls=api_calls,
                 sfqids=sfqids,
-                custom_tags=custom_tags,
+                custom_tags=final_custom_tags,
             )
             try:
                 return ctx.run(execute_func_with_statement_params)
@@ -571,7 +616,8 @@ def send_api_usage_telemetry(
                         raise
                     if isinstance(e, snowpark_exceptions.SnowparkClientException):
                         me = snowml_exceptions.SnowflakeMLException(
-                            error_code=error_codes.INTERNAL_SNOWPARK_ERROR, original_exception=e
+                            error_code=error_codes.INTERNAL_SNOWPARK_ERROR,
+                            original_exception=e,
                         )
                     else:
                         me = snowml_exceptions.SnowflakeMLException(
@@ -627,7 +673,10 @@ def _get_full_func_name(func: Callable[..., Any]) -> str:
 
 
 def _get_func_params(
-    func: Callable[..., Any], func_params_to_log: Optional[Iterable[str]], args: Any, kwargs: Any
+    func: Callable[..., Any],
+    func_params_to_log: Optional[Iterable[str]],
+    args: Any,
+    kwargs: Any,
 ) -> dict[str, Any]:
     """
     Get function parameters.

{snowflake_ml_python-1.19.0 → snowflake_ml_python-1.20.0}/snowflake/ml/experiment/_entities/run.py

@@ -1,4 +1,5 @@
 import types
+import warnings
 from typing import TYPE_CHECKING, Optional
 
 from snowflake.ml._internal.utils import sql_identifier
@@ -7,6 +8,8 @@ from snowflake.ml.experiment import _experiment_info as experiment_info
 if TYPE_CHECKING:
     from snowflake.ml.experiment import experiment_tracking
 
+METADATA_SIZE_WARNING_MESSAGE = "It is likely that no further metrics or parameters will be logged for this run."
+
 
 class Run:
     def __init__(
@@ -20,6 +23,9 @@ class Run:
         self.experiment_name = experiment_name
         self.name = run_name
 
+        # Whether we've already shown the user a warning about exceeding the run metadata size limit.
+        self._warned_about_metadata_size = False
+
         self._patcher = experiment_info.ExperimentInfoPatcher(
             experiment_info=self._get_experiment_info(),
         )
@@ -45,3 +51,12 @@ class Run:
             ),
             run_name=self.name.identifier(),
         )
+
+    def _warn_about_run_metadata_size(self, sql_error_msg: str) -> None:
+        if not self._warned_about_metadata_size:
+            warnings.warn(
+                f"{sql_error_msg}. {METADATA_SIZE_WARNING_MESSAGE}",
+                RuntimeWarning,
+                stacklevel=2,
+            )
+            self._warned_about_metadata_size = True

{snowflake_ml_python-1.19.0 → snowflake_ml_python-1.20.0}/snowflake/ml/experiment/experiment_tracking.py

@@ -283,16 +283,26 @@ class ExperimentTracking:
         Args:
             metrics: Dictionary containing metric keys and float values.
             step: The step of the metrics. Defaults to 0.
+
+        Raises:
+            snowpark.exceptions.SnowparkSQLException: If logging metrics fails due to Snowflake SQL errors,
+                except for run metadata size limit errors which will issue a warning instead of raising.
         """
         run = self._get_or_start_run()
         metrics_list = []
         for key, value in metrics.items():
             metrics_list.append(entities.Metric(key, value, step))
-        self._sql_client.modify_run_add_metrics(
-            experiment_name=run.experiment_name,
-            run_name=run.name,
-            metrics=json.dumps([metric.to_dict() for metric in metrics_list]),
-        )
+        try:
+            self._sql_client.modify_run_add_metrics(
+                experiment_name=run.experiment_name,
+                run_name=run.name,
+                metrics=json.dumps([metric.to_dict() for metric in metrics_list]),
+            )
+        except snowpark.exceptions.SnowparkSQLException as e:
+            if e.sql_error_code == 400003:  # EXPERIMENT_RUN_PROPERTY_SIZE_LIMIT_EXCEEDED
+                run._warn_about_run_metadata_size(e.message)
+            else:
+                raise
 
     def log_param(
         self,
@@ -318,16 +328,26 @@ class ExperimentTracking:
         Args:
             params: Dictionary containing parameter keys and values. Values can be of any type, but will be converted
                 to string.
+
+        Raises:
+            snowpark.exceptions.SnowparkSQLException: If logging parameters fails due to Snowflake SQL errors,
+                except for run metadata size limit errors which will issue a warning instead of raising.
         """
         run = self._get_or_start_run()
         params_list = []
         for key, value in params.items():
             params_list.append(entities.Param(key, str(value)))
-        self._sql_client.modify_run_add_params(
-            experiment_name=run.experiment_name,
-            run_name=run.name,
-            params=json.dumps([param.to_dict() for param in params_list]),
-        )
+        try:
+            self._sql_client.modify_run_add_params(
+                experiment_name=run.experiment_name,
+                run_name=run.name,
+                params=json.dumps([param.to_dict() for param in params_list]),
+            )
+        except snowpark.exceptions.SnowparkSQLException as e:
+            if e.sql_error_code == 400003:  # EXPERIMENT_RUN_PROPERTY_SIZE_LIMIT_EXCEEDED
+                run._warn_about_run_metadata_size(e.message)
+            else:
+                raise
 
     def log_artifact(
         self,

{snowflake_ml_python-1.19.0 → snowflake_ml_python-1.20.0}/snowflake/ml/feature_store/access_manager.py

@@ -202,6 +202,7 @@ def _configure_role_hierarchy(
     session.sql(f"GRANT ROLE {producer_role} TO ROLE {session.get_current_role()}").collect()
 
     if consumer_role is not None:
+        # Create CONSUMER and grant it to PRODUCER to build hierarchy
         consumer_role = SqlIdentifier(consumer_role)
         session.sql(f"CREATE ROLE IF NOT EXISTS {consumer_role}").collect()
         session.sql(f"GRANT ROLE {consumer_role} TO ROLE {producer_role}").collect()

{snowflake_ml_python-1.19.0 → snowflake_ml_python-1.20.0}/snowflake/ml/feature_store/feature_store.py

@@ -1200,7 +1200,7 @@ class FeatureStore:
                 {self._config.database}.INFORMATION_SCHEMA.DYNAMIC_TABLE_REFRESH_HISTORY (RESULT_LIMIT => 10000)
             )
             WHERE NAME = '{fv_resolved_name}'
-            AND SCHEMA_NAME = '{self._config.schema}'
+            AND SCHEMA_NAME = '{self._config.schema.resolved()}'
             """
         )
 

{snowflake_ml_python-1.19.0 → snowflake_ml_python-1.20.0}/snowflake/ml/jobs/_utils/feature_flags.py

@@ -31,6 +31,7 @@ def parse_bool_env_value(value: Optional[str], default: bool = False) -> bool:
 class FeatureFlags(Enum):
     USE_SUBMIT_JOB_V2 = "MLRS_USE_SUBMIT_JOB_V2"
     ENABLE_RUNTIME_VERSIONS = "MLRS_ENABLE_RUNTIME_VERSIONS"
+    ENABLE_STAGE_MOUNT_V2 = "MLRS_ENABLE_STAGE_MOUNT_V2"
 
     def is_enabled(self, default: bool = False) -> bool:
         """Check if the feature flag is enabled.

{snowflake_ml_python-1.19.0 → snowflake_ml_python-1.20.0}/snowflake/ml/jobs/_utils/payload_utils.py

@@ -620,7 +620,12 @@ def _serialize_callable(func: Callable[..., Any]) -> bytes:
     try:
         func_bytes: bytes = cp.dumps(func)
         return func_bytes
-    except pickle.PicklingError as e:
+    except (pickle.PicklingError, TypeError) as e:
+        if isinstance(e, TypeError) and "_thread.lock" in str(e):
+            raise RuntimeError(
+                "Unable to pickle an object that internally holds a reference to a Session object, "
+                "such as a Snowpark DataFrame."
+            ) from e
         if isinstance(func, functools.partial):
             # Try to find which part of the partial isn't serializable for better debuggability
             objects = [

{snowflake_ml_python-1.19.0 → snowflake_ml_python-1.20.0}/snowflake/ml/jobs/_utils/spec_utils.py

@@ -197,7 +197,7 @@ def generate_service_spec(
         resource_limits["nvidia.com/gpu"] = image_spec.resource_limits.gpu
 
     # Add local volumes for ephemeral logs and artifacts
-    volumes: list[dict[str, str]] = []
+    volumes: list[dict[str, Any]] = []
     volume_mounts: list[dict[str, str]] = []
     for volume_name, mount_path in [
         ("system-logs", "/var/log/managedservices/system/mlrs"),
@@ -246,7 +246,16 @@ def generate_service_spec(
     volumes.append(
         {
             "name": constants.STAGE_VOLUME_NAME,
-            "source": payload.stage_path.as_posix(),
+            "source": "stage",
+            "stageConfig": {
+                "name": payload.stage_path.as_posix(),
+                "resources": {
+                    "requests": {
+                        "memory": "0Gi",
+                        "cpu": "0",
+                    },
+                },
+            },
         }
     )
 
@@ -286,7 +295,7 @@ def generate_service_spec(
             "storage",
         ]
 
-    spec_dict = {
+    spec_dict: dict[str, Any] = {
         "containers": [
             {
                 "name": constants.DEFAULT_CONTAINER_NAME,

{snowflake_ml_python-1.19.0 → snowflake_ml_python-1.20.0}/snowflake/ml/jobs/job.py

@@ -113,7 +113,12 @@ class MLJob(Generic[T], SerializableSessionMixin):
         """Get the job's artifact storage stage location."""
         volumes = self._service_spec["spec"]["volumes"]
         stage_volume = next((v for v in volumes if v["name"] == constants.STAGE_VOLUME_NAME), None)
-        return cast(str, stage_volume["source"]) if stage_volume else None
+        if stage_volume is None:
+            return None
+        elif "stageConfig" in stage_volume:
+            return cast(str, stage_volume["stageConfig"]["name"])
+        else:
+            return cast(str, stage_volume["source"])
 
     @property
     def _result_path(self) -> str:

{snowflake_ml_python-1.19.0 → snowflake_ml_python-1.20.0}/snowflake/ml/jobs/manager.py

@@ -520,6 +520,12 @@ def _submit_job(
             raise RuntimeError(
                 "Please specify a schema, either in the session context or as a parameter in the job submission"
             )
+        elif e.sql_error_code == 3001 and "schema" in str(e).lower():
+            raise RuntimeError(
+                "please grant privileges on schema before submitting a job, see",
+                "https://docs.snowflake.com/en/developer-guide/snowflake-ml/ml-jobs/access-control-requirements",
+                " for more details",
+            ) from e
         raise
 
     if feature_flags.FeatureFlags.USE_SUBMIT_JOB_V2.is_enabled(default=True):
@@ -546,6 +552,12 @@ def _submit_job(
         except SnowparkSQLException as e:
             if not (e.sql_error_code == 90237 and sp_utils.is_in_stored_procedure()):  # type: ignore[no-untyped-call]
                 raise
+            elif e.sql_error_code == 3001 and "schema" in str(e).lower():
+                raise RuntimeError(
+                    "please grant privileges on schema before submitting a job, see",
+                    "https://docs.snowflake.com/en/developer-guide/snowflake-ml/ml-jobs/access-control-requirements"
+                    " for more details",
+                ) from e
             # SNOW-2390287: SYSTEM$EXECUTE_ML_JOB() is erroneously blocked in owner's rights
             # stored procedures. This will be fixed in an upcoming release.
             logger.warning(
@@ -690,6 +702,7 @@ def _do_submit_job_v2(
         # when feature flag is enabled, we get the local python version and wrap it in a dict
         # in system function, we can know whether it is python version or image tag or full image URL through the format
         spec_options["RUNTIME"] = json.dumps({"pythonVersion": f"{sys.version_info.major}.{sys.version_info.minor}"})
+
     job_options = {
         "EXTERNAL_ACCESS_INTEGRATIONS": external_access_integrations,
         "QUERY_WAREHOUSE": query_warehouse,

{snowflake_ml_python-1.19.0 → snowflake_ml_python-1.20.0}/snowflake/ml/model/_client/model/inference_engine_utils.py

@@ -4,14 +4,18 @@ from snowflake.ml.model._client.ops import service_ops
 
 
 def _get_inference_engine_args(
-    experimental_options: Optional[dict[str, Any]],
+    inference_engine_options: Optional[dict[str, Any]],
 ) -> Optional[service_ops.InferenceEngineArgs]:
-    if not experimental_options or "inference_engine" not in experimental_options:
+
+    if not inference_engine_options:
         return None
 
+    if "engine" not in inference_engine_options:
+        raise ValueError("'engine' field is required in inference_engine_options")
+
     return service_ops.InferenceEngineArgs(
-        inference_engine=experimental_options["inference_engine"],
-        inference_engine_args_override=experimental_options.get("inference_engine_args_override"),
+        inference_engine=inference_engine_options["engine"],
+        inference_engine_args_override=inference_engine_options.get("engine_args_override"),
     )