snowflake-ml-python 1.48.0__tar.gz → 1.50.0__tar.gz

{snowflake_ml_python-1.48.0 → snowflake_ml_python-1.50.0}/CHANGELOG.md

@@ -1,6 +1,34 @@
 # Release History
 
-## 1.48.0
+## 1.50.0
+
+### New Features
+
+### Bug Fixes
+
+### Behavior Changes
+
+### Deprecations
+
+## 1.49.0 (2026-07-29)
+
+### New Features
+
+* Experiment Tracking: `ExperimentTracking` now captures best-effort source provenance (entry-point filename and any
+  surrounding git commit, branch, and remote URL) for each new run by default. Pass `capture_source_info=False` to
+  disable it. Collection is always non-fatal and never blocks run creation.
+
+### Bug Fixes
+
+* Registry: Fixed `ModelVersion.load()` failing with `Result for query <id> has expired` inside Snowflake Container
+  Runtime notebooks. Model file downloads now use the `session.file.get` FileOperation API (the same mechanism used
+  when logging a model) instead of a raw `GET` query, avoiding a dependency on `collect()` result sets.
+
+### Behavior Changes
+
+### Deprecations
+
+## 1.48.0 (2026-07-22)
 
 ### New Features
 
@@ -10,6 +38,11 @@
 
 ### Bug Fixes
 
+* Registry: Fixed a bug where logging a model with explainability enabled could fail with a data validation error
+  ("There is no non-null data in column ...") when a numeric input column was entirely null within the background
+  sample. The `explain` method now reuses the model's existing input signature instead of re-inferring it from the
+  sample.
+
 ### Behavior Changes
 
 ### Deprecations

{snowflake_ml_python-1.48.0 → snowflake_ml_python-1.50.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.48.0
+Version: 1.50.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: 
@@ -234,9 +234,8 @@ Requires-Python: <3.14,>=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: anyio<5,>=3.5.0
-Requires-Dist: cachetools<6,>=3.1.1
+Requires-Dist: cachetools>=3.1.1
 Requires-Dist: cloudpickle>=2.0.0
-Requires-Dist: cryptography
 Requires-Dist: fsspec[http]<2026,>=2024.6.1
 Requires-Dist: h2<5,>=4.3.0
 Requires-Dist: importlib_resources<7,>=6.1.1
@@ -417,7 +416,35 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
-## 1.48.0
+## 1.50.0
+
+### New Features
+
+### Bug Fixes
+
+### Behavior Changes
+
+### Deprecations
+
+## 1.49.0 (2026-07-29)
+
+### New Features
+
+* Experiment Tracking: `ExperimentTracking` now captures best-effort source provenance (entry-point filename and any
+  surrounding git commit, branch, and remote URL) for each new run by default. Pass `capture_source_info=False` to
+  disable it. Collection is always non-fatal and never blocks run creation.
+
+### Bug Fixes
+
+* Registry: Fixed `ModelVersion.load()` failing with `Result for query <id> has expired` inside Snowflake Container
+  Runtime notebooks. Model file downloads now use the `session.file.get` FileOperation API (the same mechanism used
+  when logging a model) instead of a raw `GET` query, avoiding a dependency on `collect()` result sets.
+
+### Behavior Changes
+
+### Deprecations
+
+## 1.48.0 (2026-07-22)
 
 ### New Features
 
@@ -427,6 +454,11 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 ### Bug Fixes
 
+* Registry: Fixed a bug where logging a model with explainability enabled could fail with a data validation error
+  ("There is no non-null data in column ...") when a numeric input column was entirely null within the background
+  sample. The `explain` method now reuses the model's existing input signature instead of re-inferring it from the
+  sample.
+
 ### Behavior Changes
 
 ### Deprecations

{snowflake_ml_python-1.48.0 → snowflake_ml_python-1.50.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.14"
 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", "h2>=4.3.0,<5", "importlib_resources>=6.1.1, <7", "jinja2>=3.1.0,<4", "numpy>=1.23,<3", "packaging>=20.9,<26", "pandas>=2.1.4,<3", "platformdirs<5", "pyarrow", "pydantic>=2.8.2, <3", "pyjwt>=2.0.0, <3", "pytimeparse>=1.1.8,<2", "pyyaml>=6.0,<7", "retrying>=1.3.3,<2", "scikit-learn<1.9", "scipy>=1.9,<2", "shap>=0.46.0,<1", "snowflake-connector-python[pandas]>=3.17.3,<5", "snowflake-snowpark-python>=1.17.0,<2,!=1.26.0", "sqlparse>=0.4,<1", "tqdm<5", "typing-extensions>=4.1.0,<5", "xgboost<4",]
+dependencies = [ "anyio>=3.5.0,<5", "cachetools>=3.1.1", "cloudpickle>=2.0.0", "fsspec[http]>=2024.6.1,<2026", "h2>=4.3.0,<5", "importlib_resources>=6.1.1, <7", "jinja2>=3.1.0,<4", "numpy>=1.23,<3", "packaging>=20.9,<26", "pandas>=2.1.4,<3", "platformdirs<5", "pyarrow", "pydantic>=2.8.2, <3", "pyjwt>=2.0.0, <3", "pytimeparse>=1.1.8,<2", "pyyaml>=6.0,<7", "retrying>=1.3.3,<2", "scikit-learn<1.9", "scipy>=1.9,<2", "shap>=0.46.0,<1", "snowflake-connector-python[pandas]>=3.17.3,<5", "snowflake-snowpark-python>=1.17.0,<2,!=1.26.0", "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.48.0 → snowflake_ml_python-1.50.0}/snowflake/ml/_internal/platform_capabilities.py

@@ -16,6 +16,7 @@ from snowflake.snowpark import (
 logger = logging.getLogger(__name__)
 
 LIVE_COMMIT_PARAMETER = "ENABLE_LIVE_VERSION_IN_SDK"
+HIDDEN_LIVE_COMMIT_PARAMETER = "ENABLE_HIDDEN_LIVE_VERSION_IN_SDK"
 INLINE_DEPLOYMENT_SPEC_PARAMETER = "ENABLE_INLINE_DEPLOYMENT_SPEC_FROM_CLIENT_VERSION"
 SET_MODULE_FUNCTIONS_VOLATILITY_FROM_MANIFEST = "SET_MODULE_FUNCTIONS_VOLATILITY_FROM_MANIFEST"
 ENABLE_MODEL_METHOD_SIGNATURE_PARAMETERS = "ENABLE_MODEL_METHOD_SIGNATURE_PARAMETERS"
@@ -80,6 +81,9 @@ class PlatformCapabilities:
     def is_live_commit_enabled(self) -> bool:
         return self._get_bool_feature(LIVE_COMMIT_PARAMETER, False)
 
+    def is_hidden_live_commit_enabled(self) -> bool:
+        return False
+
     def is_model_method_signature_parameters_enabled(self) -> bool:
         return self._get_bool_feature(ENABLE_MODEL_METHOD_SIGNATURE_PARAMETERS, False)
 
@@ -127,7 +131,7 @@ class PlatformCapabilities:
         self, *, session: Optional[snowpark_session.Session] = None, features: Optional[dict[str, Any]] = None
     ) -> None:
         # This is for testing purposes only.
-        if features:
+        if features is not None:
             self.features = features
             return
         if not session:

{snowflake_ml_python-1.48.0 → snowflake_ml_python-1.50.0}/snowflake/ml/_internal/utils/query_result_checker.py

@@ -242,23 +242,34 @@ class SqlResultValidator(ResultValidator):
         result = (
             SqlResultValidator(
                 session=self._session,
-                query="UPDATE table SET NAME = 'name'",
+                query="UPDATE table SET NAME = ?",
                 statement_params=statement_params,
+                params=["name"],
             )
             .has_dimensions(expected_rows=1, expected_cols=1)
             .has_partial_match(row_idx=0, col_idx=0, expected_value="number of rows updated=1")
             .validate()
         )
+
+    ``params`` are bound as SQL query parameters (``?`` placeholders) rather than interpolated into the query.
     """
 
     def __init__(
-        self, session: snowpark.Session, query: str, statement_params: Optional[dict[str, Any]] = None
+        self,
+        session: snowpark.Session,
+        query: str,
+        statement_params: Optional[dict[str, Any]] = None,
+        *,
+        params: Optional[list[Any]] = None,
     ) -> None:
         self._session: snowpark.Session = session
         self._query: str = query
         self._success_matchers: list[Callable[[list[snowpark.Row], Optional[str]], bool]] = []
         self._statement_params: Optional[dict[str, Any]] = statement_params
+        self._params: Optional[list[Any]] = params
 
     def _get_result(self) -> list[snowpark.Row]:
         """Collect the result of the given SQL query."""
-        return self._session.sql(self._query).collect(statement_params=self._statement_params)
+        if self._params is None:
+            return self._session.sql(self._query).collect(statement_params=self._statement_params)
+        return self._session.sql(self._query, params=self._params).collect(statement_params=self._statement_params)

{snowflake_ml_python-1.48.0 → snowflake_ml_python-1.50.0}/snowflake/ml/feature_store/feature_store.py

@@ -27,7 +27,6 @@ from typing_extensions import Concatenate, ParamSpec
 
 import snowflake.ml.feature_store.feature_view as fv_mod
 import snowflake.ml.version as snowml_version
-from snowflake.ml import dataset
 from snowflake.ml._internal import telemetry
 from snowflake.ml._internal.exceptions import (
     dataset_errors,
@@ -42,7 +41,10 @@ from snowflake.ml._internal.utils.sql_identifier import (
     parse_fully_qualified_name,
     to_sql_identifiers,
 )
-from snowflake.ml.dataset.dataset_metadata import FeatureStoreMetadata
+
+if TYPE_CHECKING:
+    from snowflake.ml import dataset
+
 from snowflake.ml.feature_store import (
     feature_group as fg_mod,
     feature_view_append_only_validation,
@@ -3783,6 +3785,11 @@ class FeatureStore:
             -------------------------------------------------------
 
         """
+        from snowflake.ml import (
+            dataset,  # lazy import — heavy deps (numpy/pandas/pyarrow)
+        )
+        from snowflake.ml.dataset.dataset_metadata import FeatureStoreMetadata
+
         if output_type not in {"table", "dataset"}:
             raise snowml_exceptions.SnowflakeMLException(
                 error_code=error_codes.INVALID_ARGUMENT,
@@ -3904,6 +3911,10 @@ class FeatureStore:
             1.0
 
         """
+        from snowflake.ml.dataset.dataset_metadata import (
+            FeatureStoreMetadata,  # lazy import
+        )
+
         assert ds.selected_version is not None
         source_meta = ds.selected_version._get_metadata()
         if (
@@ -8274,8 +8285,8 @@ FROM {batch_cte_names[0]}{''.join(merge_join_parts)}
                 (e.g. ``"get_feature_view"``, ``"get_feature_group"``).
 
         Returns:
-            The query endpoint URL when the Online Service is RUNNING and
-            advertises a ``query`` endpoint; ``None`` otherwise.
+            The query endpoint URL when the Online Service is RUNNING or
+            UPDATING and advertises a ``query`` endpoint; ``None`` otherwise.
         """
         try:
             st = online_service.fetch_online_service_status(
@@ -8293,7 +8304,8 @@ FROM {batch_cte_names[0]}{''.join(merge_join_parts)}
             )
             return None
         query_url = online_service.endpoint_url(st, "query", access=self._online_service_access)
-        if st.status == "RUNNING" and query_url:
+        # UPDATING (redeploy in progress) still serves the query endpoint, so accept it too.
+        if st.status in ("RUNNING", "UPDATING") and query_url:
             # Temporary: SYSTEM$ may return host-only query URLs until server sends full https URLs.
             return query_url
         warnings.warn(

{snowflake_ml_python-1.48.0 → snowflake_ml_python-1.50.0}/snowflake/ml/feature_store/feature_view.py

@@ -66,6 +66,34 @@ _PG_IDENTIFIER_BYTE_LIMIT = 63
 _POSTGRES_ONLINE_MAX_NAME_VERSION_LEN = 45
 _POSTGRES_ONLINE_MAX_COLUMN_LEN = 30
 
+# The online-store schema is derived as "{schema}__{oft_id}", so its budget reserves room for the "__"
+# separator and a 19-digit (64-bit) oft_id, keeping the derived identifier within the limit (63 - 2 - 19).
+_POSTGRES_ONLINE_MAX_SCHEMA_LEN = 42
+
+
+def validate_postgres_online_schema_length(feature_store_schema: str) -> None:
+    """Reject a Feature Store schema too long for the Postgres online-store schema identifier.
+
+    The online store derives its schema as "{feature_store_schema}__{oft_id}" and must fit PostgreSQL's
+    63-byte identifier limit, so the budget reserves room for the "__" separator and the downstream-assigned
+    oft_id. Called from :func:`online_service.create_online_service`, before any feature view or feature
+    group is materialized.
+
+    Args:
+        feature_store_schema: The Feature Store schema name that will prefix the Postgres online-store
+            schema.
+
+    Raises:
+        ValueError: If the schema length exceeds the Postgres online-store budget.
+    """
+    if len(feature_store_schema) > _POSTGRES_ONLINE_MAX_SCHEMA_LEN:
+        raise ValueError(
+            f"feature store schema '{feature_store_schema}' is too long for the Postgres online store: "
+            f"it uses {len(feature_store_schema)} characters, but the limit is "
+            f"{_POSTGRES_ONLINE_MAX_SCHEMA_LEN}. Use a shorter Feature Store schema."
+        )
+
+
 _RESULT_SCAN_QUERY_PATTERN = re.compile(
     r".*FROM\s*TABLE\s*\(\s*RESULT_SCAN\s*\(.*",
     flags=re.DOTALL | re.IGNORECASE | re.X,

{snowflake_ml_python-1.48.0 → snowflake_ml_python-1.50.0}/snowflake/ml/feature_store/metadata_manager.py

@@ -1377,6 +1377,9 @@ class FeatureStoreMetadataManager:
         # Strip surrounding quotes if present; callers pass resolved() which handles casing.
         normalized_name = object_name.strip('"')
 
+        # Writes append via INSERT and Snowflake does not enforce the primary
+        # key, so multiple rows can share a key after a re-register. Return the
+        # most recently written row so reads reflect the latest registration.
         result = self._session.sql(
             f"""
             SELECT METADATA
@@ -1385,6 +1388,8 @@ class FeatureStoreMetadataManager:
             AND OBJECT_NAME = '{normalized_name}'
             AND VERSION = '{version}'
             AND METADATA_TYPE = '{metadata_type.value}'
+            ORDER BY UPDATED_AT DESC, CREATED_AT DESC
+            LIMIT 1
             """
         ).collect(statement_params=self._telemetry_stmp)
 

{snowflake_ml_python-1.48.0 → snowflake_ml_python-1.50.0}/snowflake/ml/feature_store/online_service.py

@@ -241,6 +241,16 @@ def create_online_service(
             error_code=error_codes.INVALID_ARGUMENT,
             original_exception=ValueError("producer_role and consumer_role must be non-empty."),
         )
+    from snowflake.ml.feature_store.feature_view import (
+        validate_postgres_online_schema_length,
+    )
+
+    try:
+        validate_postgres_online_schema_length(schema.resolved())
+    except ValueError as e:
+        raise snowml_exceptions.SnowflakeMLException(
+            error_code=error_codes.INVALID_ARGUMENT, original_exception=e
+        ) from e
     payload = json.dumps(
         {
             "roles": {
@@ -533,7 +543,9 @@ def _assert_online_service_running(
                 "then poll get_online_service_status() until RUNNING."
             ),
         )
-    if st.status != "RUNNING":
+    # UPDATING means a redeploy is in progress; the service is still operational and
+    # serves reads/writes, so treat it like RUNNING as long as an endpoint is available.
+    if st.status not in ("RUNNING", "UPDATING"):
         raise snowml_exceptions.SnowflakeMLException(
             error_code=error_codes.INVALID_ARGUMENT,
             original_exception=ValueError(

{snowflake_ml_python-1.48.0 → snowflake_ml_python-1.50.0}/snowflake/ml/feature_store/tile_sql_generator.py

@@ -1077,11 +1077,9 @@ class MergingSqlGenerator:
 
             elif spec.function == AggregationType.APPROX_COUNT_DISTINCT:
                 col_name = spec.get_tile_column_name("DS_HLL")
-                agg_columns.append(
-                    f"DATASKETCHES_HLL_ESTIMATE(DATASKETCHES_HLL_COMBINE("
-                    f"CASE WHEN {tile_filter} THEN {col_name} ELSE NULL END"
-                    f")) AS {output_col}"
-                )
+                # Round the HLL estimate to a BIGINT for online/offline parity.
+                sketch_expr = f"DATASKETCHES_HLL_COMBINE(CASE WHEN {tile_filter} THEN {col_name} ELSE NULL END)"
+                agg_columns.append(f"ROUND(DATASKETCHES_HLL_ESTIMATE({sketch_expr}))::BIGINT AS {output_col}")
 
             elif spec.function == AggregationType.APPROX_PERCENTILE:
                 # Combine T-Digest states and estimate percentile
@@ -1209,9 +1207,9 @@ class MergingSqlGenerator:
                     )
                 elif spec.function == AggregationType.APPROX_COUNT_DISTINCT:
                     partial = spec.get_tile_column_name("DS_HLL")
-                    inner_exprs.append(
-                        f"DATASKETCHES_HLL_ESTIMATE(DATASKETCHES_HLL_COMBINE({partial})) AS {output_col}"
-                    )
+                    # Round the HLL estimate to a BIGINT for online/offline parity.
+                    sketch_expr = f"DATASKETCHES_HLL_COMBINE({partial})"
+                    inner_exprs.append(f"ROUND(DATASKETCHES_HLL_ESTIMATE({sketch_expr}))::BIGINT AS {output_col}")
                 elif spec.function == AggregationType.APPROX_PERCENTILE:
                     # T-Digest states are likewise mergeable across tiles per
                     # (entity, sk): combine then estimate at the requested
@@ -1378,7 +1376,8 @@ class MergingSqlGenerator:
 
             elif spec.function == AggregationType.APPROX_COUNT_DISTINCT:
                 cum_col = spec.get_cumulative_column_name("DS_HLL")
-                select_cols.append(f"DATASKETCHES_HLL_ESTIMATE(TILES.{cum_col}) AS {output_col}")
+                # Round the HLL estimate to a BIGINT for online/offline parity.
+                select_cols.append(f"ROUND(DATASKETCHES_HLL_ESTIMATE(TILES.{cum_col}))::BIGINT AS {output_col}")
 
             elif spec.function == AggregationType.APPROX_PERCENTILE:
                 cum_col = spec.get_cumulative_column_name("TDIGEST")

snowflake_ml_python-1.50.0/snowflake/ml/model/_client/model/batch_inference_job_specs.py

@@ -0,0 +1,166 @@
+from enum import Enum
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict, field_serializer, field_validator
+from typing_extensions import TypedDict
+
+from snowflake.ml.model import inference_engine as inference_engine_module
+
+
+class SaveMode(str, Enum):
+    """Save mode options for batch inference output.
+
+    Determines the behavior when files already exist in the output stage location.
+
+    OVERWRITE: Remove existing files and write new results.
+
+    ERROR: Raise an error if files already exist in the output stage location.
+    """
+
+    OVERWRITE = "overwrite"
+    ERROR = "error"
+
+
+class InputFormat(str, Enum):
+    """The format of the input column data."""
+
+    FULL_STAGE_PATH = "full_stage_path"
+
+
+class FileEncoding(str, Enum):
+    """The encoding of the file content that will be passed to the custom model."""
+
+    RAW_BYTES = "raw_bytes"
+    BASE64 = "base64"
+    BASE64_DATA_URL = "base64_data_url"
+
+
+class ColumnHandlingOptions(TypedDict):
+    """Options for handling specific columns during run_batch for file I/O."""
+
+    input_format: InputFormat
+    convert_to: FileEncoding
+
+
+class InputSpec(BaseModel):
+    """Input block of the batch inference job specification.
+
+    Attributes:
+        params (Optional[dict[str, Any]]): Optional dictionary of model inference parameters
+            (e.g., temperature, top_k for LLMs). These are passed as keyword arguments to the
+            model's inference method. Defaults to None.
+        column_handling (Optional[dict[str, ColumnHandlingOptions]]): Optional dictionary
+            specifying how to handle specific columns during file I/O. Maps column names to their
+            input format and file encoding configuration.
+        partition_column (Optional[str]): Optional column name to use for partitioning the input
+            data. When set, the batch inference job will partition the data by this column.
+            Defaults to None.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    params: Optional[dict[str, Any]] = None
+    column_handling: Optional[dict[str, ColumnHandlingOptions]] = None
+    partition_column: Optional[str] = None
+
+
+class OutputSpec(BaseModel):
+    """Output block of the batch inference job specification.
+
+    Results are written under ``<stage_location>/<job_name>/``.
+
+    Attributes:
+        stage_location (str): The stage path under which batch inference results will be saved.
+            This should be a full path including the stage with @ prefix. For example,
+            '@My_DB.PUBLIC.MY_STAGE/some/path/'. Only Snowflake internal stages are supported.
+        mode (SaveMode): The save mode that determines behavior when files already exist
+            at the output stage location. Defaults to SaveMode.ERROR.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    stage_location: str
+    mode: SaveMode = SaveMode.ERROR
+
+
+class ResourcesSpec(BaseModel):
+    """Resources block of the batch inference job specification.
+
+    Attributes:
+        cpu_requests (Optional[str]): The cpu limit for CPU based inference. Can be an integer,
+            fractional or string values. If None, we attempt to utilize all the vCPU of the node.
+        memory_requests (Optional[str]): The memory limit for inference. Can be an integer
+            or a fractional value, but requires a unit (GiB, MiB). If None, we attempt to utilize
+            all the memory of the node.
+        gpu_requests (Optional[str]): The gpu limit for GPU based inference. Can be integer or
+            string values. Use CPU if None.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    cpu_requests: Optional[str] = None
+    memory_requests: Optional[str] = None
+    gpu_requests: Optional[str] = None
+
+
+class EngineOptions(BaseModel):
+    """``inference.engine_options`` sub-block of the job specification.
+
+    Attributes:
+        engine (Optional[InferenceEngine]): The inference engine to use.
+        engine_args_override (Optional[list[str]]): Arguments passed through to the inference engine.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    engine: Optional[inference_engine_module.InferenceEngine] = None
+    engine_args_override: Optional[list[str]] = None
+
+    @field_validator("engine", mode="before")
+    @classmethod
+    def _coerce_engine(cls, value: Any) -> Optional[inference_engine_module.InferenceEngine]:
+        # Accept an InferenceEngine member or a case-insensitive value/name string
+        # (e.g. "vllm", "VLLM", "python_generic") rather than only the exact enum value.
+        if value is None:
+            return None
+        return inference_engine_module.InferenceEngine.from_value(value)
+
+    @field_serializer("engine")
+    def _serialize_engine(self, engine: Optional[inference_engine_module.InferenceEngine]) -> Optional[str]:
+        # Emit the enum member name (e.g. "VLLM") rather than its lower-case value,
+        # to match the canonical spelling used in the EXECUTE INFERENCE JOB SERVICE spec.
+        return engine.name if engine is not None else None
+
+
+class InferenceSpec(BaseModel):
+    """Inference block of the batch inference job specification.
+
+    Attributes:
+        num_workers (Optional[int]): The number of workers to run the inference service for handling
+            requests in parallel within an instance of the service. Auto determined if None.
+        max_batch_rows (Optional[int]): Maximum number of rows to process in a single batch.
+            Auto determined if None. Larger values may improve throughput.
+        engine_options (Optional[EngineOptions]): Options for a custom inference engine.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    num_workers: Optional[int] = None
+    max_batch_rows: Optional[int] = None
+    engine_options: Optional[EngineOptions] = None
+
+
+class ImageBuildSpec(BaseModel):
+    """Image-build block of the batch inference job specification.
+
+    Attributes:
+        image_repo (Optional[str]): Container image repository for the inference job.
+            If not specified, uses the default repository.
+        force_rebuild (bool): Whether to force rebuilding the container image even if
+            it already exists. Defaults to False.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    image_repo: Optional[str] = None
+    force_rebuild: bool = False

{snowflake_ml_python-1.48.0 → snowflake_ml_python-1.50.0}/snowflake/ml/model/_client/model/batch_inference_serialization.py

@@ -5,7 +5,9 @@ from typing import Any, Optional
 
 from pydantic import TypeAdapter
 
-from snowflake.ml.model._client.model.batch_inference_specs import ColumnHandlingOptions
+from snowflake.ml.model._client.model.batch_inference_job_specs import (
+    ColumnHandlingOptions,
+)
 
 _UTF8_ENCODING = "utf-8"