snowflake-ml-python 1.45.0__tar.gz → 1.46.0__tar.gz

{snowflake_ml_python-1.45.0 → snowflake_ml_python-1.46.0}/CHANGELOG.md

@@ -1,6 +1,22 @@
 # Release History
 
-## 1.45.0
+## 1.46.0
+
+### New Features
+
+### Bug Fixes
+
+### Behavior Changes
+
+* Registry: For Snowpark ML Pipeline models with explainability enabled, explanations now cover only the columns the
+  final estimator was actually trained on (its `input_cols`). Untransformed passthrough columns (e.g. raw string
+  columns left in place by an encoder using new `output_cols`, or the label column) are no longer included in the
+  explain output. This also fixes a failure where such passthrough columns could reach the SHAP explainer and raise an
+  error during `log_model(..., enable_explainability=True)`.
+
+### Deprecations
+
+## 1.45.0 (2026-07-01)
 
 ### New Features
 

{snowflake_ml_python-1.45.0 → snowflake_ml_python-1.46.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.45.0
+Version: 1.46.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: 
@@ -416,7 +416,23 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
-## 1.45.0
+## 1.46.0
+
+### New Features
+
+### Bug Fixes
+
+### Behavior Changes
+
+* Registry: For Snowpark ML Pipeline models with explainability enabled, explanations now cover only the columns the
+  final estimator was actually trained on (its `input_cols`). Untransformed passthrough columns (e.g. raw string
+  columns left in place by an encoder using new `output_cols`, or the label column) are no longer included in the
+  explain output. This also fixes a failure where such passthrough columns could reach the SHAP explainer and raise an
+  error during `log_model(..., enable_explainability=True)`.
+
+### Deprecations
+
+## 1.45.0 (2026-07-01)
 
 ### New Features
 

{snowflake_ml_python-1.45.0 → snowflake_ml_python-1.46.0}/snowflake/ml/_internal/utils/jwt_generator.py

@@ -1,3 +1,7 @@
+# Annotations are lazy so ``types.PrivateKeyTypes`` (added in cryptography 40.0, replacing the
+# now-removed ``PRIVATE_KEY_TYPES``) is never evaluated at runtime and stays version-tolerant.
+from __future__ import annotations
+
 import base64
 import hashlib
 import logging
@@ -30,7 +34,7 @@ class JWTGenerator:
         self,
         account: str,
         user: str,
-        private_key: types.PRIVATE_KEY_TYPES,
+        private_key: types.PrivateKeyTypes,
         lifetime: Optional[timedelta] = None,
         renewal_delay: Optional[timedelta] = None,
     ) -> None:
@@ -125,7 +129,7 @@ class JWTGenerator:
         return token
 
     @staticmethod
-    def _calculate_public_key_fingerprint(private_key: types.PRIVATE_KEY_TYPES) -> str:
+    def _calculate_public_key_fingerprint(private_key: types.PrivateKeyTypes) -> str:
         # Get the raw bytes of public key.
         public_key_raw = private_key.public_key().public_bytes(
             serialization.Encoding.DER, serialization.PublicFormat.SubjectPublicKeyInfo

{snowflake_ml_python-1.45.0 → snowflake_ml_python-1.46.0}/snowflake/ml/feature_store/feature_store.py

@@ -97,6 +97,7 @@ from snowflake.ml.feature_store.spec.models import (
     validate_spec_oft_offline_table_schema,
     validate_spec_oft_tiled_offline_table_schema,
 )
+from snowflake.ml.feature_store.stream_config import StreamConfig
 from snowflake.ml.feature_store.stream_source import (
     _LIST_STREAM_SOURCE_SCHEMA,
     StreamSource,
@@ -1323,11 +1324,16 @@ class FeatureStore:
         """Update a registered feature view.
             Check feature_view.py for which fields are allowed to be updated after registration.
 
+            ``RealtimeFeatureView`` does not support ``refresh_freq`` or ``warehouse``
+            updates. Recreate-only fields (``stream_source``, ``transformation_fn``,
+            ``feature_granularity``, ``aggregation_secondary_keys``, ``backfill_table``,
+            ``source_refs``) require :meth:`delete_feature_view` + :meth:`register_feature_view`.
+
         Args:
             name: FeatureView object or name to suspend.
             version: Optional version of feature view. Must set when argument feature_view is a str.
-            refresh_freq: updated refresh frequency.
-            warehouse: updated warehouse.
+            refresh_freq: updated refresh frequency. Not applicable to ``RealtimeFeatureView``.
+            warehouse: updated warehouse. Not applicable to ``RealtimeFeatureView``.
             initialization_warehouse: updated initialization warehouse, used for the initial build and
                 reinitializations of the backing dynamic table. Pass a warehouse name to set it, or ``None`` to clear
                 it (all refreshes then run on ``warehouse``). When omitted, the existing value is left unchanged.
@@ -1341,7 +1347,7 @@ class FeatureStore:
             updated_feature_df: Optional replacement Snowpark ``DataFrame`` for the feature view
                 definition. When set, the returned :class:`~snowflake.ml.feature_store.feature_view.FeatureView`
                 is reinitialized from this dataframe (same session as the ``FeatureStore``). Not supported for
-                streaming or rollup feature views.
+                streaming, realtime, or rollup feature views.
 
         Returns:
             Updated FeatureView.
@@ -1435,6 +1441,18 @@ class FeatureStore:
                 ),
             )
 
+        # RTFVs are OFT-only — no Dynamic Table or refresh Task.
+        if feature_view.is_realtime_feature_view and (actual_refresh_freq is not None or warehouse is not None):
+            full_name = f"{feature_view.name}/{feature_view.version}"
+            raise snowml_exceptions.SnowflakeMLException(
+                error_code=error_codes.INVALID_ARGUMENT,
+                original_exception=RuntimeError(
+                    f"Realtime feature view '{full_name}' does not support refresh_freq or warehouse "
+                    "updates; the underlying online feature table has no Dynamic Table or refresh Task. "
+                    "Only desc and online_config are alterable for realtime feature views."
+                ),
+            )
+
         # Fail fast on an online store type that cannot back this feature view (e.g. HYBRID_TABLE
         # for a tiled FV) before any planning/resource work, so it surfaces as a clean
         # INVALID_ARGUMENT rather than being wrapped by the update-failure rollback handler. The
@@ -1542,6 +1560,16 @@ class FeatureStore:
             # Step 3: Execute atomically
             self._execute_atomic_operations(operations)
 
+            # RTFVs have no offline resources (DT/task); their desc lives in the
+            # REALTIME_CONFIG metadata row and must be updated separately.
+            if feature_view.is_realtime_feature_view and new_desc != feature_view.desc:
+                rt_meta = self._metadata_manager.get_realtime_config(
+                    feature_view.name.resolved(), str(feature_view.version)
+                )
+                if rt_meta is not None:
+                    rt_meta.desc = new_desc
+                    self._metadata_manager.save_realtime_config(rt_meta)
+
         except Exception as e:
             # Step 4: Rollback on failure
             self._handle_update_failure(e, rollback_operations, feature_view)
@@ -4181,16 +4209,31 @@ class FeatureStore:
         desc: str,
         online_config: Optional[fv_mod.OnlineConfig],
     ) -> tuple[list[tuple[str, Union[str, FeatureView]]], list[tuple[str, Union[str, FeatureView]]],]:
-        """Plan all update operations and their rollbacks."""
+        """Plan all update operations and their rollbacks.
+
+        Args:
+            feature_view: The registered ``FeatureView`` to update.
+            refresh_freq: New refresh frequency, or ``None`` to leave it unchanged.
+            warehouse: New warehouse identifier, or ``None`` to leave it unchanged.
+            initialization_warehouse: Warehouse used for the initial backfill task,
+                or ``None`` to leave it unchanged.
+            desc: New description.
+            online_config: Online configuration update, or ``None`` to leave
+                online state unchanged.
+
+        Returns:
+            A tuple ``(operations, rollback_operations)`` of ``(op_type, op_data)`` pairs.
+        """
         operations: list[tuple[str, Union[str, FeatureView]]] = []
         rollback_operations: list[tuple[str, Union[str, FeatureView]]] = []
 
-        # Plan offline updates
-        offline_ops, offline_rollback_ops = self._build_offline_update_queries(
-            feature_view, refresh_freq, warehouse, initialization_warehouse, desc
-        )
-        operations.extend(offline_ops)
-        rollback_operations.extend(offline_rollback_ops)
+        # RealtimeFeatureViews have no offline resources to update.
+        if not feature_view.is_realtime_feature_view:
+            offline_ops, offline_rollback_ops = self._build_offline_update_queries(
+                feature_view, refresh_freq, warehouse, initialization_warehouse, desc
+            )
+            operations.extend(offline_ops)
+            rollback_operations.extend(offline_rollback_ops)
 
         # Plan online updates
         online_strategy = self._plan_online_update(feature_view, online_config)
@@ -7681,6 +7724,12 @@ FROM {batch_cte_names[0]}{''.join(merge_join_parts)}
         source_refs_meta = self._metadata_manager.get_feature_view_source_refs(name, version)
         source_refs_json = json.dumps(source_refs_meta.sources) if source_refs_meta is not None else None
 
+        # Surface the authored source-ref list (JSON-encoded) when a
+        # ``FV_SOURCE_REFS`` row exists; otherwise leave the column null.
+        # Verbose-only: goes into output_values_extra alongside backup_source.
+        source_refs_meta = self._metadata_manager.get_feature_view_source_refs(name, version)
+        source_refs_json = json.dumps(source_refs_meta.sources) if source_refs_meta is not None else None
+
         backup_source: Optional[str] = None
         if fv_metadata.is_append_only:
             append_only_meta = self._metadata_manager.get_append_only_metadata(name, version)
@@ -7864,6 +7913,11 @@ FROM {batch_cte_names[0]}{''.join(merge_join_parts)}
         source_refs_meta = self._metadata_manager.get_feature_view_source_refs(name.identifier(), version)
         restored_source_refs = source_refs_meta.sources if source_refs_meta is not None else None
 
+        # Rehydrate the authored source-ref list onto the reconstructed
+        # FV when a ``FV_SOURCE_REFS`` row was persisted at register time.
+        source_refs_meta = self._metadata_manager.get_feature_view_source_refs(name.identifier(), version)
+        restored_source_refs = source_refs_meta.sources if source_refs_meta is not None else None
+
         if obj_type == _FeatureStoreObjTypes.MANAGED_FEATURE_VIEW:
             df = self._session.sql(query)
             entities = [find_and_compose_entity(n) for n in fv_metadata.entities]
@@ -7950,6 +8004,25 @@ FROM {batch_cte_names[0]}{''.join(merge_join_parts)}
                 streaming_meta = self._metadata_manager.get_streaming_metadata(name.identifier(), version)
                 if streaming_meta and streaming_meta.transformation_fn_source:
                     fv._transformation_fn_source = streaming_meta.transformation_fn_source
+                # Restore a metadata-only ``StreamConfig`` so callers see the
+                # authored ``backfill_table`` / ``backfill_start_time`` /
+                # ``stream_source`` values rather than ``None``.
+                # ``transformation_fn`` and ``backfill_df`` are not
+                # rehydrated — the live callable is unavailable on the
+                # read path and the source DataFrame is not re-executable
+                # from a fresh session.
+                if streaming_meta is not None:
+                    parsed_backfill_start: Optional[datetime.datetime] = None
+                    if streaming_meta.backfill_start_time is not None:
+                        try:
+                            parsed_backfill_start = datetime.datetime.fromisoformat(streaming_meta.backfill_start_time)
+                        except (TypeError, ValueError):
+                            parsed_backfill_start = None
+                    fv._stream_config = StreamConfig._for_reconstruction(
+                        stream_source=streaming_meta.stream_source_name,
+                        backfill_table=streaming_meta.backfill_table,
+                        backfill_start_time=parsed_backfill_start,
+                    )
 
             # Load rollup metadata if this is a rollup FV
             if fv_metadata.is_rollup:

{snowflake_ml_python-1.45.0 → snowflake_ml_python-1.46.0}/snowflake/ml/feature_store/feature_view.py

@@ -1544,7 +1544,7 @@ class FeatureView(lineage_node.LineageNode):
                 df["is_large"] = df["amount"] > 1000
                 return df
         """
-        if self._stream_config is not None:
+        if self._stream_config is not None and self._stream_config.transformation_fn is not None:
             return self._stream_config.get_function_source()
         return self._transformation_fn_source
 
@@ -2469,6 +2469,7 @@ Got {len(self._feature_df.queries['queries'])}: {self._feature_df.queries['queri
             ),
             feature_granularity=json_dict.get("_feature_granularity"),
             aggregation_specs=aggregation_specs,
+            aggregation_secondary_keys=json_dict.get("_aggregation_secondary_keys"),
             feature_aggregation_method=feature_aggregation_method,
             storage_config=(
                 StorageConfig.from_json(json_dict["_storage_config"]) if json_dict.get("_storage_config") else None
@@ -2580,6 +2581,7 @@ Got {len(self._feature_df.queries['queries'])}: {self._feature_df.queries['queri
         is_realtime: bool = False,
         realtime_config: Optional[RealtimeConfig] = None,
         source_refs: Optional[list[dict[str, Any]]] = None,
+        stream_config: Optional[StreamConfig] = None,
     ) -> FeatureView:
         if is_realtime:
             # Realtime FVs have no feature_df, no DT/View, no schema inference.
@@ -2620,6 +2622,9 @@ Got {len(self._feature_df.queries['queries'])}: {self._feature_df.queries['queri
                 append_only=append_only,
                 backup_source=backup_source,
             )
+            # Restore the rehydrated stream_config on the reconstructed FV.
+            if stream_config is not None:
+                fv._stream_config = stream_config
         fv._version = FeatureViewVersion(version) if version is not None else None
         fv._status = status
         fv._database = SqlIdentifier(database) if database is not None else None

{snowflake_ml_python-1.45.0 → snowflake_ml_python-1.46.0}/snowflake/ml/feature_store/metadata_manager.py

@@ -145,6 +145,13 @@ class StreamingMetadata:
     # ``FAILED`` once the finalizer has observed terminal state. ``None`` for
     # streaming FVs registered before this field existed.
     backfill_state: Optional[str] = None
+    # Pre-expansion FQN of the operator-supplied backfill table (e.g.
+    # ``MY_DB.MY_SCH.HISTORICAL_TXNS``). Captured at register time so the
+    # round-trip can restore ``StreamConfig.backfill_table`` losslessly
+    # (Plan section A3). ``None`` for streaming FVs registered before
+    # this field existed and for callers that supplied an inline
+    # ``backfill_df`` rather than a table reference.
+    backfill_table: Optional[str] = None
 
     def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary for JSON serialization."""
@@ -168,6 +175,8 @@ class StreamingMetadata:
             d["backfill_udtf_signature"] = self.backfill_udtf_signature
         if self.backfill_state is not None:
             d["backfill_state"] = self.backfill_state
+        if self.backfill_table is not None:
+            d["backfill_table"] = self.backfill_table
         return d
 
     @classmethod
@@ -198,6 +207,7 @@ class StreamingMetadata:
             backfill_udtf_name=data.get("backfill_udtf_name"),
             backfill_udtf_signature=data.get("backfill_udtf_signature"),
             backfill_state=raw_backfill_state,
+            backfill_table=data.get("backfill_table"),
         )
 
 

{snowflake_ml_python-1.45.0 → snowflake_ml_python-1.46.0}/snowflake/ml/feature_store/spec/builder.py

@@ -174,9 +174,11 @@ _PG_DISTINCT_N_SOURCE_TYPES: frozenset[str] = frozenset(
 # Aggregation functions whose output type is predetermined regardless of source type.
 # Functions not listed here (SUM, MIN, MAX, LAST_N, etc.) preserve the source type.
 _AGG_PREDETERMINED_OUTPUT: dict[AggregationType, FSColumn] = {
-    # COUNT / APPROX_COUNT_DISTINCT always produce an integer.
-    AggregationType.COUNT: FSColumn(name="", type="DecimalType", precision=18, scale=0),
-    AggregationType.APPROX_COUNT_DISTINCT: FSColumn(name="", type="DecimalType", precision=18, scale=0),
+    # COUNT / APPROX_COUNT_DISTINCT produce NUMBER(38,0), which Snowpark
+    # surfaces as LongType. DecimalType here would mismatch the upstream FV's
+    # stored ArrayType<LongType> and be rejected by the exact-shape check.
+    AggregationType.COUNT: FSColumn(name="", type="LongType"),
+    AggregationType.APPROX_COUNT_DISTINCT: FSColumn(name="", type="LongType"),
     # AVG / STD / VAR / APPROX_PERCENTILE always produce a float.
     AggregationType.AVG: FSColumn(name="", type="DoubleType"),
     AggregationType.STD: FSColumn(name="", type="DoubleType"),
@@ -801,9 +803,11 @@ class FeatureViewSpecBuilder:
         For tiled FVs the columns are derived from ``aggregation_specs`` because
         ``output_schema`` exposes ``_PARTIAL_*`` tile columns, not the FV's logical
         aggregation outputs. A secondary-key FV (``aggregation_secondary_keys``)
-        additionally wraps each value aggregation as ``ArrayType<scalar>`` so the
-        column matches the upstream FV's stored ``OutputColumn`` for the Online
-        Service exact-shape check.
+        additionally wraps each value aggregation as ``ArrayType<scalar>`` and emits
+        the companion ``<SK>_KEYS_<window>`` keys array (also ``ArrayType<scalar>``)
+        so the columns match the upstream FV's stored ``OutputColumn`` for the Online
+        Service exact-shape check. Without the keys array the value arrays cannot be
+        mapped back to their secondary-key values.
 
         For non-tiled, non-RTFV sources, when ``materialized_schema`` is
         provided, column shapes are read from it instead of the authoring-time
@@ -817,6 +821,10 @@ class FeatureViewSpecBuilder:
 
         Returns:
             FSColumns for the source's feature columns, in declaration order.
+
+        Raises:
+            ValueError: If a tiled secondary-key FV's keys array references a
+                secondary-key column absent from the tiled schema.
         """
         if fv.realtime_config is not None:
             entity_names = set(fv.ordered_entity_columns)
@@ -831,6 +839,18 @@ class FeatureViewSpecBuilder:
             columns: list[FSColumn] = []
             for spec in fv.aggregation_specs:
                 if spec.function.is_secondary_key_array():
+                    # Keys array has no _PARTIAL_* companion; its element type is
+                    # the secondary-key column, which the tiled DT exposes directly.
+                    sk_column = partials_by_name.get(spec.source_column)
+                    if sk_column is None:
+                        raise ValueError(
+                            f"feature retrieval: secondary aggregation key column "
+                            f"'{spec.source_column}' was not found in feature view "
+                            f"'{fv.name.resolved()}'; its keys array cannot be built."
+                        )
+                    columns.append(
+                        _as_secondary_key_array_column(sk_column.model_copy(update={"name": spec.output_column}))
+                    )
                     continue
                 resolved = _resolve_tiled_fv_output_column(spec, partials_by_name)
                 if has_secondary_key:

{snowflake_ml_python-1.45.0 → snowflake_ml_python-1.46.0}/snowflake/ml/feature_store/stream_config.py

@@ -178,6 +178,8 @@ class StreamConfig:
     transformation_fn: Callable[[pd.DataFrame], pd.DataFrame]
     backfill_df: Any  # DataFrame — Any avoids circular import
     backfill_start_time: Optional[datetime.datetime] = None
+    # FQN of the backfill table; persisted so get_feature_view can restore it.
+    backfill_table: Optional[str] = None
 
     def __post_init__(self) -> None:
         fn = self.transformation_fn
@@ -239,6 +241,38 @@ class StreamConfig:
         """Return the ``__name__`` of ``transformation_fn``."""
         return self.transformation_fn.__name__
 
+    @classmethod
+    def _for_reconstruction(
+        cls,
+        stream_source: Union[str, Any],
+        backfill_table: Optional[str] = None,
+        backfill_start_time: Optional[datetime.datetime] = None,
+    ) -> StreamConfig:
+        """Build a metadata-only ``StreamConfig`` for round-trip reconstruction.
+
+        Bypasses ``__post_init__`` validation so ``StreamConfig`` can be
+        rehydrated from ``StreamingMetadata`` without a live
+        ``transformation_fn`` or ``backfill_df``. Do not call
+        ``get_function_source`` or ``get_function_name`` on the result.
+
+        Args:
+            stream_source: ``StreamSource`` object or registered name string.
+            backfill_table: FQN of the backfill table, or ``None`` for legacy
+                streaming FVs registered before this field existed.
+            backfill_start_time: Authored ``backfill_start_time``, if any.
+
+        Returns:
+            A frozen ``StreamConfig`` with ``transformation_fn`` and
+            ``backfill_df`` set to ``None``.
+        """
+        instance = cls.__new__(cls)
+        object.__setattr__(instance, "stream_source", stream_source)
+        object.__setattr__(instance, "transformation_fn", None)
+        object.__setattr__(instance, "backfill_df", None)
+        object.__setattr__(instance, "backfill_start_time", backfill_start_time)
+        object.__setattr__(instance, "backfill_table", backfill_table)
+        return instance
+
     def get_stream_source_name(self) -> str:
         """Return the stream source name as a string.
 

{snowflake_ml_python-1.45.0 → snowflake_ml_python-1.46.0}/snowflake/ml/feature_store/streaming_registration.py

@@ -623,6 +623,8 @@ def run_streaming_postamble(
             backfill_udtf_name=fq_udtf,
             backfill_udtf_signature=udtf_signature,
             backfill_state=BACKFILL_STATE_RUNNING,
+            # Persist backfill_table so get_feature_view can restore it.
+            backfill_table=stream_config.backfill_table,
         ),
     )
 

{snowflake_ml_python-1.45.0 → snowflake_ml_python-1.46.0}/snowflake/ml/model/_client/model/model_version_impl.py

@@ -1338,7 +1338,12 @@ class ModelVersion(lineage_node.LineageNode):
             func_name: core.ModelSignature.from_dict(sig_dict) for func_name, sig_dict in signatures_dict.items()
         }
 
-        if deserialized_signatures not in VALID_OPENAI_SIGNATURES:
+        # Check if the model is logged with OpenAI compatible signature that contains messages feature group.
+        if not any(
+            isinstance(spec, core.FeatureGroupSpec) and spec.name == "messages"
+            for sig in deserialized_signatures.values()
+            for spec in sig.inputs
+        ):
             raise ValueError(
                 "Inference engine requires the model to be logged with one of the following signatures: "
                 f"{VALID_OPENAI_SIGNATURES}. Please log the model again with one of these supported signatures."

{snowflake_ml_python-1.45.0 → snowflake_ml_python-1.46.0}/snowflake/ml/model/_packager/model_handlers/_utils.py

@@ -26,6 +26,7 @@ from snowflake.snowpark import DataFrame as SnowparkDataFrame
 logger = logging.getLogger(__name__)
 
 EXPLAIN_BACKGROUND_DATA_ROWS_COUNT_LIMIT = 1000
+_WRITABLE_HF_CACHE_DIR = "/tmp"
 
 
 class NumpyEncoder(json.JSONEncoder):
@@ -278,6 +279,30 @@ def get_explain_target_method(
     return None
 
 
+def redirect_hf_cache_to_writable_dir() -> None:
+    """Point HuggingFace cache env vars at a writable directory in sandboxed runtimes.
+
+    Warehouse stored procedures and SPCS inference containers often run with a
+    non-writable home cache (for example ``/root/.cache``). Models that load
+    transformers remote code need a writable HuggingFace modules cache.
+    """
+    from snowflake.snowpark._internal import utils as snowpark_utils
+
+    if snowpark_utils.is_in_stored_procedure():  # type: ignore[no-untyped-call]
+        os.environ["TRANSFORMERS_CACHE"] = _WRITABLE_HF_CACHE_DIR
+        os.environ["HF_HOME"] = _WRITABLE_HF_CACHE_DIR
+        os.environ["XDG_CACHE_HOME"] = _WRITABLE_HF_CACHE_DIR
+        return
+
+    default_cache_root = os.path.join(os.path.expanduser("~"), ".cache")
+    if os.access(default_cache_root, os.W_OK):
+        return
+
+    os.environ.setdefault("HF_HOME", _WRITABLE_HF_CACHE_DIR)
+    os.environ.setdefault("TRANSFORMERS_CACHE", _WRITABLE_HF_CACHE_DIR)
+    os.environ.setdefault("XDG_CACHE_HOME", _WRITABLE_HF_CACHE_DIR)
+
+
 def save_transformers_config_with_auto_map(local_model_path: str) -> None:
     import huggingface_hub
 

{snowflake_ml_python-1.45.0 → snowflake_ml_python-1.46.0}/snowflake/ml/model/_packager/model_handlers/huggingface/_handler.py

@@ -30,7 +30,6 @@ from snowflake.ml.model.models import (
     huggingface as huggingface_base,
     huggingface_pipeline,
 )
-from snowflake.snowpark._internal import utils as snowpark_utils
 
 logger = logging.getLogger(__name__)
 
@@ -366,10 +365,7 @@ class TransformersPipelineHandler(
     ) -> Union[
         huggingface_pipeline.HuggingFacePipelineModel, huggingface_base.TransformersPipeline, "transformers.Pipeline"
     ]:
-        if snowpark_utils.is_in_stored_procedure():  # type: ignore[no-untyped-call]
-            # We need to redirect the some folders to a writable location in the sandbox.
-            os.environ["HF_HOME"] = "/tmp"
-            os.environ["XDG_CACHE_HOME"] = "/tmp"
+        handlers_utils.redirect_hf_cache_to_writable_dir()
 
         model_blob_path = os.path.join(model_blobs_dir_path, name)
         model_blobs_metadata = model_meta.models

{snowflake_ml_python-1.45.0 → snowflake_ml_python-1.46.0}/snowflake/ml/model/_packager/model_handlers/sentence_transformers.py

@@ -26,7 +26,6 @@ from snowflake.ml.model._packager.model_meta import (
     model_meta_schema,
 )
 from snowflake.ml.model.models import huggingface as snowml_huggingface
-from snowflake.snowpark._internal import utils as snowpark_utils
 
 if TYPE_CHECKING:
     import sentence_transformers
@@ -894,9 +893,7 @@ class SentenceTransformerHandler(_base.BaseModelHandler["sentence_transformers.S
     ) -> "sentence_transformers.SentenceTransformer":
         import sentence_transformers
 
-        if snowpark_utils.is_in_stored_procedure():  # type: ignore[no-untyped-call]
-            os.environ["TRANSFORMERS_CACHE"] = "/tmp"
-            os.environ["HF_HOME"] = "/tmp"
+        handlers_utils.redirect_hf_cache_to_writable_dir()
 
         model_blob_path = os.path.join(model_blobs_dir_path, name)
         model_blob_metadata = model_meta.models[name]

{snowflake_ml_python-1.45.0 → snowflake_ml_python-1.46.0}/snowflake/ml/model/_packager/model_handlers/snowmlmodel.py

@@ -38,6 +38,14 @@ def _apply_transforms_up_to_last_step(
             if not hasattr(step, "transform"):
                 raise ValueError(f"Step '{step_name}' does not have a 'transform' method.")
             data = pd.DataFrame(step.transform(data))
+        # A transform step can leave columns the final predictor was not trained on in the frame (e.g. raw string
+        # columns that an encoder wrote to new output_cols without dropping, or label columns). The predictor
+        # itself selects only its `input_cols` before predicting, so restrict the frame the same way here.
+        # Otherwise these passthrough columns reach the underlying SHAP explainer, which rejects non-numeric data.
+        final_estimator = model.steps[-1][1]  # type: ignore[attr-defined]
+        input_cols = getattr(final_estimator, "input_cols", None)
+        if input_cols and isinstance(data, pd.DataFrame) and all(col in data.columns for col in input_cols):
+            data = data[list(input_cols)]
     return data
 
 

{snowflake_ml_python-1.45.0 → snowflake_ml_python-1.46.0}/snowflake/ml/utils/authentication.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import http
 import logging
 from datetime import timedelta
@@ -16,7 +18,7 @@ _JWT_TOKEN_CACHE: dict[str, dict[int, str]] = {}
 def get_jwt_token_generator(
     account: str,
     user: str,
-    private_key: types.PRIVATE_KEY_TYPES,
+    private_key: types.PrivateKeyTypes,
     lifetime: Optional[timedelta] = None,
     renewal_delay: Optional[timedelta] = None,
 ) -> jwt_generator.JWTGenerator:

{snowflake_ml_python-1.45.0 → snowflake_ml_python-1.46.0}/snowflake/ml/version.py

@@ -1,2 +1,2 @@
 # This is parsed by regex in conda recipe meta file. Make sure not to break it.
-VERSION = "1.45.0"
+VERSION = "1.46.0"

{snowflake_ml_python-1.45.0 → snowflake_ml_python-1.46.0}/snowflake_ml_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.45.0
+Version: 1.46.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: 
@@ -416,7 +416,23 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
-## 1.45.0
+## 1.46.0
+
+### New Features
+
+### Bug Fixes
+
+### Behavior Changes
+
+* Registry: For Snowpark ML Pipeline models with explainability enabled, explanations now cover only the columns the
+  final estimator was actually trained on (its `input_cols`). Untransformed passthrough columns (e.g. raw string
+  columns left in place by an encoder using new `output_cols`, or the label column) are no longer included in the
+  explain output. This also fixes a failure where such passthrough columns could reach the SHAP explainer and raise an
+  error during `log_model(..., enable_explainability=True)`.
+
+### Deprecations
+
+## 1.45.0 (2026-07-01)
 
 ### New Features