snowflake-ml-python 1.52.0__tar.gz → 1.53.0__tar.gz

{snowflake_ml_python-1.52.0 → snowflake_ml_python-1.53.0}/CHANGELOG.md

@@ -1,6 +1,43 @@
 # Release History
 
-## 1.52.0
+## 1.53.0
+
+### New Features
+
+* ML Jobs: `submit_file`, `submit_directory`, and `submit_from_stage` accept a `parallel` kwarg (default `False`).
+  With `parallel=True`, the entrypoint is executed directly on every instance with the job topology injected into the
+  environment (`SNOWFLAKE_JOB_INDEX`, `SNOWFLAKE_JOBS_COUNT`, `MLRS_HEAD_IP`, `MLRS_RDZV_PORT`, `MLRS_NODE_IPS`).
+  Not supported for callable (`@remote`) payloads.
+
+* ML Jobs: added `MLJob.distributed_result()`, the result API for distributed (e.g. `parallel=True`) jobs, which
+  have no single head result. On full success it returns a `DistributedResult` (`success`, per-instance `exit_codes`,
+  `failed_instance`, and instance 0's `return_value`); if any instance failed it raises `DistributedJobError`, which
+  carries that `DistributedResult` as `.result` and the earliest-failing instance's reconstructed exception as its
+  cause. `DistributedResult` and `DistributedJobError` are exported from `snowflake.ml.jobs`.
+
+* ML Jobs: `submit_file`, `submit_directory`, and `submit_from_stage` accept a `preflight` kwarg, supported only
+  together with `parallel=True`. It takes the name of a check level, run on every instance before the entrypoint:
+  `"wiring"` checks the rendezvous plus a small collective, and `"reference"` additionally times a short synthetic
+  DDP step and reports its step times from instance 0. If a requested check fails, the job aborts without running
+  the entrypoint and the failure surfaces through `distributed_result()`. A check that does not apply to the job
+  (`"reference"` on a CPU pool or a single instance) is reported as skipped and the job continues. Covers only the
+  PyTorch c10d rendezvous backend.
+
+* Feature Store: Iceberg-backed feature views can enable online storage when using the Postgres online store
+  (`OnlineConfig(store_type=OnlineStoreType.POSTGRES)`). Online storage with Iceberg remains unsupported for
+  other store types.
+
+### Bug Fixes
+
+### Behavior Changes
+
+* Feature Store: `register_feature_view` now records `FV_SOURCE_REFS` metadata for managed batch
+  feature views (derived from the `feature_df` schema) when the caller does not supply
+  `source_refs`. Streaming and realtime feature views are unaffected.
+
+### Deprecations
+
+## 1.52.0 (2026-08-20)
 
 ### New Features
 
@@ -8,6 +45,9 @@
 
 ### Behavior Changes
 
+* Feature Store: `stream_ingest` now reuses the Online Service ingest endpoint cached on the
+  `StreamSource` by `get_stream_source`, avoiding a per-call server status round-trip.
+
 ### Deprecations
 
 ## 1.51.0 (2026-08-12)
@@ -26,9 +66,6 @@
 
 ### Behavior Changes
 
-* Feature Store: `stream_ingest` now reuses the Online Service ingest endpoint cached on the
-  `StreamSource` by `get_stream_source`, avoiding a per-call server status round-trip.
-
 ### Deprecations
 
 ## 1.50.0 (2026-08-03)

{snowflake_ml_python-1.52.0 → snowflake_ml_python-1.53.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.52.0
+Version: 1.53.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,44 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
-## 1.52.0
+## 1.53.0
+
+### New Features
+
+* ML Jobs: `submit_file`, `submit_directory`, and `submit_from_stage` accept a `parallel` kwarg (default `False`).
+  With `parallel=True`, the entrypoint is executed directly on every instance with the job topology injected into the
+  environment (`SNOWFLAKE_JOB_INDEX`, `SNOWFLAKE_JOBS_COUNT`, `MLRS_HEAD_IP`, `MLRS_RDZV_PORT`, `MLRS_NODE_IPS`).
+  Not supported for callable (`@remote`) payloads.
+
+* ML Jobs: added `MLJob.distributed_result()`, the result API for distributed (e.g. `parallel=True`) jobs, which
+  have no single head result. On full success it returns a `DistributedResult` (`success`, per-instance `exit_codes`,
+  `failed_instance`, and instance 0's `return_value`); if any instance failed it raises `DistributedJobError`, which
+  carries that `DistributedResult` as `.result` and the earliest-failing instance's reconstructed exception as its
+  cause. `DistributedResult` and `DistributedJobError` are exported from `snowflake.ml.jobs`.
+
+* ML Jobs: `submit_file`, `submit_directory`, and `submit_from_stage` accept a `preflight` kwarg, supported only
+  together with `parallel=True`. It takes the name of a check level, run on every instance before the entrypoint:
+  `"wiring"` checks the rendezvous plus a small collective, and `"reference"` additionally times a short synthetic
+  DDP step and reports its step times from instance 0. If a requested check fails, the job aborts without running
+  the entrypoint and the failure surfaces through `distributed_result()`. A check that does not apply to the job
+  (`"reference"` on a CPU pool or a single instance) is reported as skipped and the job continues. Covers only the
+  PyTorch c10d rendezvous backend.
+
+* Feature Store: Iceberg-backed feature views can enable online storage when using the Postgres online store
+  (`OnlineConfig(store_type=OnlineStoreType.POSTGRES)`). Online storage with Iceberg remains unsupported for
+  other store types.
+
+### Bug Fixes
+
+### Behavior Changes
+
+* Feature Store: `register_feature_view` now records `FV_SOURCE_REFS` metadata for managed batch
+  feature views (derived from the `feature_df` schema) when the caller does not supply
+  `source_refs`. Streaming and realtime feature views are unaffected.
+
+### Deprecations
+
+## 1.52.0 (2026-08-20)
 
 ### New Features
 
@@ -424,6 +461,9 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 ### Behavior Changes
 
+* Feature Store: `stream_ingest` now reuses the Online Service ingest endpoint cached on the
+  `StreamSource` by `get_stream_source`, avoiding a per-call server status round-trip.
+
 ### Deprecations
 
 ## 1.51.0 (2026-08-12)
@@ -442,9 +482,6 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 ### Behavior Changes
 
-* Feature Store: `stream_ingest` now reuses the Online Service ingest endpoint cached on the
-  `StreamSource` by `get_stream_source`, avoiding a per-call server status round-trip.
-
 ### Deprecations
 
 ## 1.50.0 (2026-08-03)

{snowflake_ml_python-1.52.0 → snowflake_ml_python-1.53.0}/snowflake/ml/_internal/exceptions/exceptions.py

@@ -15,7 +15,8 @@ class SnowflakeMLException(Exception):
 
         Attributes:
             error_code: Error code.
-            original_exception: Original exception with an error code in its message.
+            original_exception: Original exception. The error code is added to its message when the exception
+                type can be constructed from a message.
             suppress_source_trace: Suppress source stacktrace.
 
         Raises:
@@ -34,7 +35,12 @@ class SnowflakeMLException(Exception):
             raise ValueError("Must provide non-empty error_code and original_exception.")
 
         self.error_code = error_code
-        self.original_exception = type(original_exception)(f"({self.error_code}) {str(original_exception)}")
+        try:
+            self.original_exception = type(original_exception)(f"({self.error_code}) {str(original_exception)}")
+        except Exception:
+            # Not every exception class can be rebuilt from a message alone: sqlalchemy's DBAPIError, for one,
+            # requires a statement, parameters and the driver error. Keep the original rather than masking it.
+            self.original_exception = original_exception
         self.suppress_source_trace = suppress_source_trace
         self._pretty_msg = repr(self.original_exception)
 

{snowflake_ml_python-1.52.0 → snowflake_ml_python-1.53.0}/snowflake/ml/_internal/platform_capabilities.py

@@ -21,6 +21,8 @@ INLINE_DEPLOYMENT_SPEC_PARAMETER = "ENABLE_INLINE_DEPLOYMENT_SPEC_FROM_CLIENT_VE
 SET_MODULE_FUNCTIONS_VOLATILITY_FROM_MANIFEST = "SET_MODULE_FUNCTIONS_VOLATILITY_FROM_MANIFEST"
 ENABLE_MODEL_METHOD_SIGNATURE_PARAMETERS = "ENABLE_MODEL_METHOD_SIGNATURE_PARAMETERS"
 ENABLE_PIP_ONLY_PACKAGING = "ENABLE_PIP_ONLY_PACKAGING"
+ENABLE_LORA_ADAPTERS = "ENABLE_LORA_ADAPTERS"
+ENABLE_SINGLE_OUTPUT_NATIVE_TYPE = "ENABLE_SINGLE_OUTPUT_NATIVE_TYPE"
 
 
 class PlatformCapabilities:
@@ -87,6 +89,21 @@ class PlatformCapabilities:
     def is_model_method_signature_parameters_enabled(self) -> bool:
         return self._get_bool_feature(ENABLE_MODEL_METHOD_SIGNATURE_PARAMETERS, False)
 
+    def is_lora_adapters_enabled(self) -> bool:
+        return False
+
+    def is_single_output_native_type_enabled(self) -> bool:
+        """Whether a single, non-OBJECT model FUNCTION output is registered with its native SQL type.
+
+        When enabled (and supported server-side), a scalar FUNCTION method with exactly one non-OBJECT output
+        is declared with that native type in the manifest and returns the value directly, instead of packing it
+        into an OBJECT. Defaults to disabled when the capability is absent (older servers).
+
+        Returns:
+            True if single-output native typing is enabled for this account; otherwise False.
+        """
+        return self._get_bool_feature(ENABLE_SINGLE_OUTPUT_NATIVE_TYPE, False)
+
     def is_pip_only_packaging_enabled(self) -> bool:
         """Whether pip-only model packaging is enabled for this account.
 

{snowflake_ml_python-1.52.0 → snowflake_ml_python-1.53.0}/snowflake/ml/feature_store/feature_store.py

@@ -93,10 +93,12 @@ from snowflake.ml.feature_store.spec.enums import (
     ENTITY_TAG_PREFIX,
     FeatureAggregationMethod,
     FeatureViewKind,
+    SourceType,
     TableType,
 )
 from snowflake.ml.feature_store.spec.models import (
     FeatureViewSpec,
+    _columns_from_tiled_struct_type,
     validate_spec_oft_offline_table_schema,
     validate_spec_oft_tiled_offline_table_schema,
 )
@@ -178,6 +180,11 @@ def _validate_stream_ingest_record_keys(expected: list[str], row: dict[str, Any]
         )
 
 
+# Timezone names that place the session on the same time grid as UTC, so reading
+# through them carries no tile-boundary alignment risk.
+_UTC_TIMEZONE_NAMES = frozenset({"UTC", "ETC/UTC", "ETC/GMT", "GMT", "UCT", "UNIVERSAL", "ZULU"})
+
+
 def _store_type_from_oft_show_row(row: Row) -> OnlineStoreType:
     """Map SHOW ONLINE FEATURE TABLES ``store_type`` to ``OnlineStoreType``.
 
@@ -355,6 +362,85 @@ def _initialization_warehouse_clause(feature_view: FeatureView) -> str:
     return f"\n                INITIALIZATION_WAREHOUSE = {iw}" if iw is not None else ""
 
 
+def _derive_source_refs_from_feature_df(feature_view: FeatureView) -> Optional[list[dict[str, Any]]]:
+    """Record the batch FV's raw input columns so it can be recovered as code.
+
+    Background: a feature view can be registered two ways. The declarative
+    flow authors it as YAML/spec (which names its upstream *sources* and their
+    columns), while ``register_feature_view`` registers it imperatively from a
+    Snowpark ``feature_df`` and usually names no sources at all. Later,
+    ``snow feature init`` reverse-engineers deployed FVs back into that
+    declarative spec so they can be managed as code. For a tiled batch FV that
+    round-trip needs the *pre-aggregation* input schema (the columns the
+    ``feature_df`` read before aggregation). That schema cannot be read back
+    from the deployed object: the backing Dynamic Table only stores the
+    post-aggregation result (renamed/aggregated columns, plus internal
+    ``ArrayType`` tile columns). With nothing to compare against, recovery
+    guesses wrong, the planner sees a "changed" FV, and rebuilds it
+    (``RECREATE_FV``). This function captures the raw ``feature_df`` schema at
+    registration time and stores it as a source-ref so recovery reproduces the
+    same spec and the planner reports ``NO_CHANGE``.
+
+    What gets stored, and why each field:
+
+    - ``columns``: the whole point — the raw input schema recovery can't
+      otherwise reconstruct.
+    - ``source_type``: hard-coded to ``Batch`` because this path only runs for
+      managed batch FVs (streaming/realtime bail out above), so there is no
+      other value it could take. It is a fixed label for the stored entry, not
+      something derived from a real source object (we don't have one here).
+    - ``name``: a synthetic ``<FV>__SOURCE`` rather than the bare FV name.
+      Source names and FV names live in the same namespace during recovery, so
+      naming this after the FV would make the FV look like it depends on
+      itself.
+    - ``table``/``query`` are deliberately absent. When recovery diffs a
+      source it identifies it by its binding — ``table``, else ``query``, else
+      ``name`` — never by ``columns``. That binding is recovered independently
+      from the Dynamic Table's ``FROM`` clause. This entry therefore contributes
+      only columns and carries no binding of its own, so it can never disagree
+      with (or override) the recovered one. The row is immutable once written,
+      so getting this shape right at registration time is what matters.
+
+    Best-effort: schema reads are wrapped so a failure only skips the stamp
+    (worst case, the old ``RECREATE_FV`` behavior) and never breaks
+    registration.
+
+    Args:
+        feature_view: The feature view being registered.
+
+    Returns:
+        A one-element source-ref list
+        ``[{"name": "<FV>__SOURCE", "source_type": "Batch", "columns": [...]}]``
+        derived from ``feature_view.feature_df.schema``, or ``None`` when the
+        FV is not a managed batch FV, has no feature DataFrame, exposes no
+        columns, or its schema cannot be read.
+    """
+    if feature_view.is_streaming or feature_view.is_realtime_feature_view:
+        return None
+    feature_df = feature_view.feature_df
+    if feature_df is None:
+        return None
+    try:
+        # ``_columns_from_tiled_struct_type`` (not the scalar converter) so
+        # ArrayType/Binary tile columns serialize instead of raising.
+        columns = [col.model_dump(exclude_none=True) for col in _columns_from_tiled_struct_type(feature_df.schema)]
+    except Exception:
+        # Never let best-effort source-ref capture break registration.
+        return None
+    if not columns:
+        return None
+    # Columns only, no ``table``/``query`` binding — see the merge contract in
+    # the docstring. The ``<FV>__SOURCE`` name is synthetic so it can't be
+    # confused with the feature view itself.
+    return [
+        {
+            "name": f"{feature_view.name.resolved()}__SOURCE",
+            "source_type": SourceType.BATCH.value,
+            "columns": columns,
+        }
+    ]
+
+
 # ``list_feature_views`` output schemas. Row builders always populate the verbose
 # schema; non-verbose callers receive _LIST_FEATURE_VIEW_SCHEMA after trimming
 # verbose-only trailing fields.
@@ -1249,14 +1335,19 @@ class FeatureStore:
                     feature_view.name, version, agg_metadata, descs, fv_metadata_config=fv_meta_config
                 )
 
-            # Persist the authored source-ref list when the caller
-            # supplied one; callers that leave ``source_refs`` unset skip
-            # the metadata write and no ``FV_SOURCE_REFS`` row is created.
-            if feature_view.source_refs:
+            # Persist the source-ref list. Prefer the caller-supplied list;
+            # otherwise auto-stamp one derived from the raw ``feature_df``
+            # schema (managed batch FVs) so imperatively-registered FVs carry
+            # FV_SOURCE_REFS and recover cleanly during declarative
+            # ``snow feature init`` instead of triggering a one-time
+            # RECREATE_FV. Streaming/realtime FVs and un-derivable schemas fall
+            # through with no row, preserving prior behavior for them.
+            source_refs = feature_view.source_refs or _derive_source_refs_from_feature_df(feature_view)
+            if source_refs:
                 self._metadata_manager.save_feature_view_source_refs(
                     feature_view.name,
                     version,
-                    FvSourceRefsMetadata(sources=list(feature_view.source_refs)),
+                    FvSourceRefsMetadata(sources=list(source_refs)),
                 )
 
             # Step 4: Save rollup metadata for PIT-correct training queries
@@ -1910,6 +2001,9 @@ class FeatureStore:
                         "Snowpark DataFrame instead if you accept the full-scan cost."
                     ),
                 )
+            # TODO(okharatsidi): add a persistent FV-level "timezone" parameter. For now, we warn
+            # the user about potentially inaccurate results.
+            self._warn_on_non_utc_session_timezone(feature_view)
             return self._read_from_offline_store(feature_view, keys, feature_names)
         else:
             raise snowml_exceptions.SnowflakeMLException(
@@ -5024,6 +5118,52 @@ class FeatureStore:
         query = f"SELECT {select_clause} FROM {table_name}{where_clause}"
         return self._session.sql(query)
 
+    def _get_session_timezone(self) -> Optional[str]:
+        """Read the timezone configured for the current session.
+
+        Returns:
+            The configured timezone name, or ``None`` when it cannot be determined.
+        """
+        try:
+            rows = self._session.sql("SHOW PARAMETERS LIKE 'TIMEZONE' IN SESSION").collect()
+        except Exception as e:
+            logger.debug("feature store: could not determine the session timezone: %s", e)
+            return None
+
+        if not rows:
+            return None
+        row = rows[0]
+        for key in ("value", "VALUE"):
+            if key in row:
+                raw = row[key]
+                return str(raw) if raw is not None else None
+        return None
+
+    def _warn_on_non_utc_session_timezone(self, feature_view: FeatureView) -> None:
+        """Warn before an offline read of a tiled Postgres-backed feature view from a non-UTC session.
+
+        Args:
+            feature_view: The feature view about to be read from the offline store.
+        """
+        if not feature_view.is_tiled:
+            return
+        online_config = feature_view.online_config
+        if online_config is None or online_config.store_type != OnlineStoreType.POSTGRES:
+            return
+
+        session_timezone = self._get_session_timezone()
+        if session_timezone is None or session_timezone.strip().upper() in _UTC_TIMEZONE_NAMES:
+            return
+
+        warnings.warn(
+            f"feature store: the current session timezone is '{session_timezone}', not UTC. Aggregation "
+            "window boundaries are resolved in the session timezone while tile boundaries are bucketed in "
+            "the UTC timezone, so feature values may be inaccurate. Set the session timezone to UTC "
+            "(ALTER SESSION SET TIMEZONE = 'UTC') for consistent results.",
+            stacklevel=3,
+            category=UserWarning,
+        )
+
     def _read_tiled_fv_at_current_time(
         self,
         feature_view: FeatureView,

{snowflake_ml_python-1.52.0 → snowflake_ml_python-1.53.0}/snowflake/ml/feature_store/feature_view.py

@@ -60,11 +60,16 @@ _FEATURE_VIEW_VERSION_MAX_LENGTH = 128
 
 # Postgres online store identifiers must fit PostgreSQL's 63-byte limit (NAMEDATALEN - 1); longer names
 # are silently truncated and can collide. name+version maps to "{name}${version}$UDF_TRANSFORMED"
-# (17 bytes of affixes) and columns to a distinct-N tile column "_PARTIAL_FIRST_DISTINCT_1000_TS_<col>"
-# (32 bytes), so each budget below leaves a 1-byte margin. The padding-guard test rechecks the affixes.
+# (17 bytes of affixes), so its budget leaves a 1-byte margin. Column budgets depend on the feature view:
+#   - Tiled (aggregation) feature views wrap each column in a tile prefix, worst case the distinct-N tile
+#     column "_PARTIAL_FIRST_DISTINCT_1000_TS_<col>" (32 bytes), so the tile budget is tight.
+#   - Non-tiled (passthrough) feature views map each column 1:1 to a Postgres column with no prefix, so
+#     the passthrough budget only reserves the 1-byte margin.
+# The padding-guard test rechecks the affixes.
 _PG_IDENTIFIER_BYTE_LIMIT = 63
 _POSTGRES_ONLINE_MAX_NAME_VERSION_LEN = 45
 _POSTGRES_ONLINE_MAX_COLUMN_LEN = 30
+_POSTGRES_ONLINE_MAX_PASSTHROUGH_COLUMN_LEN = _PG_IDENTIFIER_BYTE_LIMIT - 1
 
 # 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).
@@ -1085,8 +1090,11 @@ class FeatureView(lineage_node.LineageNode):
         # Optional authored source-ref list. When the caller passes one,
         # ``FeatureStore.register_feature_view`` persists it under
         # ``MetadataType.FV_SOURCE_REFS`` and ``get_feature_view``
-        # rehydrates the same list onto reconstructed FVs; callers that
-        # leave it ``None`` skip the metadata write entirely.
+        # rehydrates the same list onto reconstructed FVs. When it is left
+        # ``None``, ``register_feature_view`` auto-stamps a best-effort
+        # source-ref derived from the raw ``feature_df`` schema for managed
+        # batch FVs (so declarative state recovery round-trips); streaming and
+        # realtime FVs still skip the write.
         self._source_refs: Optional[list[dict[str, Any]]] = _kwargs.pop("_source_refs", None)
         if self._stream_config is not None:
             if online_config is not None and online_config.enable is False:
@@ -1645,8 +1653,10 @@ class FeatureView(lineage_node.LineageNode):
         When set, :meth:`FeatureStore.register_feature_view` persists
         these entries under :attr:`MetadataType.FV_SOURCE_REFS` and
         ``get_feature_view`` returns the same list on the reconstructed
-        FV. Callers that did not supply a list see ``None`` here and no
-        metadata row is written.
+        FV. When it is ``None``, ``register_feature_view`` still auto-stamps
+        a best-effort source-ref derived from the raw ``feature_df`` schema
+        for managed batch FVs; this property reflects only what was supplied
+        at construction and is unaffected by that register-time default.
 
         Returns:
             The list of source-ref dicts as supplied, or ``None`` when
@@ -2156,7 +2166,12 @@ Got {len(self._feature_df.queries['queries'])}: {self._feature_df.queries['queri
         # Validate Iceberg storage configuration
         if self._storage_config is not None and self._storage_config.format == StorageFormat.ICEBERG:
             if self.online:
-                raise ValueError("Online storage is not supported with Iceberg.")
+                store_type = self._online_config.store_type if self._online_config is not None else None
+                if store_type != OnlineStoreType.POSTGRES:
+                    raise ValueError(
+                        "Online storage with Iceberg is only supported with the Postgres online store. "
+                        "Use OnlineConfig(store_type=OnlineStoreType.POSTGRES)."
+                    )
             if self._refresh_freq is None:
                 raise ValueError("Iceberg storage requires refresh_freq.")
 
@@ -2226,11 +2241,16 @@ Got {len(self._feature_df.queries['queries'])}: {self._feature_df.queries['queri
                 key = join_key if isinstance(join_key, SqlIdentifier) else SqlIdentifier(join_key)
                 resolved_columns.add(key.resolved())
 
+        # Tiled feature views wrap each column in a tile prefix, so they get the tighter budget;
+        # non-tiled (passthrough) columns map 1:1 to Postgres columns and can use the full budget.
+        column_budget = (
+            _POSTGRES_ONLINE_MAX_COLUMN_LEN if self.is_tiled else _POSTGRES_ONLINE_MAX_PASSTHROUGH_COLUMN_LEN
+        )
         for resolved in sorted(resolved_columns):
-            if len(resolved) > _POSTGRES_ONLINE_MAX_COLUMN_LEN:
+            if len(resolved) > column_budget:
                 raise ValueError(
                     f"column '{resolved}' is too long for the Postgres online store: {len(resolved)} "
-                    f"characters exceeds the limit of {_POSTGRES_ONLINE_MAX_COLUMN_LEN}. Rename the column."
+                    f"characters exceeds the limit of {column_budget}. Rename the column."
                 )
 
     def _validate_window_offset_alignment(self) -> None:

{snowflake_ml_python-1.52.0 → snowflake_ml_python-1.53.0}/snowflake/ml/feature_store/online_service.py

@@ -7,6 +7,7 @@ as well as reading online features and ingesting records for streaming feature v
 from __future__ import annotations
 
 import datetime
+import decimal
 import json
 import logging
 import os
@@ -411,6 +412,10 @@ def _json_serialize_value(value: Any) -> Any:
         # NaN -> None. NB: NaN is the only float for which ``v != v`` holds.
         if value != value:
             return None
+        if value == float("inf"):
+            return "inf"
+        if value == float("-inf"):
+            return "-inf"
         return value
     if isinstance(value, str):
         return value
@@ -1196,7 +1201,7 @@ def _parse_query_batch_response(
             ``batch_size``, or feature metadata is missing.
     """
     try:
-        data = json.loads(raw.decode("utf-8"))
+        data = json.loads(raw.decode("utf-8"), parse_float=decimal.Decimal)
     except (json.JSONDecodeError, UnicodeDecodeError) as e:
         raise snowml_exceptions.SnowflakeMLException(
             error_code=error_codes.INTERNAL_SNOWML_ERROR,

{snowflake_ml_python-1.52.0 → snowflake_ml_python-1.53.0}/snowflake/ml/jobs/__init__.py

@@ -1,4 +1,5 @@
 from snowflake.ml.jobs._interop.exception_utils import install_exception_display_hooks
+from snowflake.ml.jobs._interop.results import DistributedJobError, DistributedResult
 from snowflake.ml.jobs._utils.type_utils import JOB_STATUS
 from snowflake.ml.jobs.decorators import remote
 from snowflake.ml.jobs.job import MLJob
@@ -26,4 +27,6 @@ __all__ = [
     "JOB_STATUS",
     "submit_from_stage",
     "MLJobDefinition",
+    "DistributedResult",
+    "DistributedJobError",
 ]

snowflake_ml_python-1.53.0/snowflake/ml/jobs/_interop/results.py

@@ -0,0 +1,99 @@
+from dataclasses import dataclass
+from typing import Any, Optional
+
+
+@dataclass(frozen=True)
+class ExecutionResult:
+    """
+    A result of a job execution.
+
+    Args:
+        success: Whether the execution was successful.
+        value: The value of the execution.
+    """
+
+    success: bool
+    value: Any
+
+    def get_value(self, wrap_exceptions: bool = True) -> Any:
+        if not self.success:
+            assert isinstance(self.value, BaseException), "Unexpected non-exception value for failed result"
+            self._raise_exception(self.value, wrap_exceptions)
+        return self.value
+
+    def _raise_exception(self, exception: BaseException, wrap_exceptions: bool) -> None:
+        if wrap_exceptions:
+            raise RuntimeError(f"Job execution failed with error: {exception!r}") from exception
+        else:
+            raise exception
+
+
+@dataclass(frozen=True)
+class LoadedExecutionResult(ExecutionResult):
+    """
+    A result of a job execution that has been loaded from a file.
+    """
+
+    load_error: Optional[Exception] = None
+    result_metadata: Optional[dict[str, Any]] = None
+
+    def get_value(self, wrap_exceptions: bool = True) -> Any:
+        if not self.success:
+            # Raise the original exception if available, otherwise raise the load error
+            ex = self.value
+            if not isinstance(ex, BaseException):
+                ex = RuntimeError(f"Unknown error {ex or ''}")
+                ex.__cause__ = self.load_error
+            self._raise_exception(ex, wrap_exceptions)
+        else:
+            if self.load_error:
+                raise ValueError("Job execution succeeded but result retrieval failed") from self.load_error
+            return self.value
+
+
+@dataclass(frozen=True)
+class DistributedResult:
+    """Aggregated result of a multi-node job that has no single result-bearing instance.
+
+    For jobs where every instance runs the entrypoint independently — no head/worker
+    split (e.g. submitted with parallel=True) — there is no single head result to read.
+    Instead this LEFT-JOINs every instance's per-instance record onto the authoritative
+    control-plane instance set.
+
+    Args:
+        success: True iff every instance in the control-plane set exited 0.
+        exit_codes: instance_id -> exit code; None = lost (killed before writing a record).
+        failed_instance: Earliest-failing instance id; None on success.
+        return_value: The run's Python return value on success — persisted by instance 0, if the
+            entrypoint produced one — else None (subprocess entrypoints, lost instances, and
+            failures have no return value).
+    """
+
+    success: bool
+    exit_codes: dict[int, Optional[int]]
+    failed_instance: Optional[int] = None
+    return_value: Any = None
+
+
+class DistributedJobError(RuntimeError):
+    """Raised by ``MLJob.distributed_result()`` when a multi-node job did not fully succeed.
+
+    Carries the full :class:`DistributedResult` (``.result``) so callers can inspect per-instance
+    ``exit_codes`` and ``failed_instance``. The earliest-failing instance's reconstructed
+    exception is attached by the raising site as ``__cause__`` (via ``raise ... from``), so
+    the original error and its remote traceback surface on an uncaught raise.
+    """
+
+    def __init__(self, message: str, result: Optional[DistributedResult] = None) -> None:
+        super().__init__(message)
+        self.result = result
+
+    @classmethod
+    def from_result(cls, result: DistributedResult) -> "DistributedJobError":
+        num_succeeded = sum(1 for code in result.exit_codes.values() if code == 0)
+        num_failed = len(result.exit_codes) - num_succeeded
+        return cls(
+            f"Distributed job failed: {num_failed}/{len(result.exit_codes)} instances did not exit 0 "
+            f"(earliest failed instance: {result.failed_instance}); see .result.exit_codes for details.",
+            result=result,
+        )

{snowflake_ml_python-1.52.0 → snowflake_ml_python-1.53.0}/snowflake/ml/jobs/_utils/constants.py

@@ -19,6 +19,14 @@ INSTANCES_TIMEOUT_ENV_VAR = "MLRS_INSTANCES_TIMEOUT"
 INSTANCES_CHECK_INTERVAL_ENV_VAR = "MLRS_INSTANCES_CHECK_INTERVAL"
 RUNTIME_IMAGE_TAG_ENV_VAR = "MLRS_CONTAINER_IMAGE_TAG"
 USE_EMBEDDED_SCRIPTS_ENV_VAR = "MLRS_USE_EMBEDDED_SCRIPTS"
+PREFLIGHT_ENV_VAR = "MLRS_DISTRIBUTED_PREFLIGHT"
+# Adds the reference step to the preflight; no effect on its own.
+PREFLIGHT_REFERENCE_STEP_ENV_VAR = "MLRS_PREFLIGHT_REFERENCE_STEP"
+LAUNCH_BACKEND_ENV_VAR = "MLRS_LAUNCH_BACKEND"
+# Value for LAUNCH_BACKEND_ENV_VAR that selects the passthrough launch path: the user's
+# entrypoint runs directly on every instance (Ray is still brought up, for readiness only).
+# Must match the literal the image's launcher compares against.
+LAUNCH_BACKEND_PASSTHROUGH = "passthrough"
 
 # Stage mount paths
 STAGE_VOLUME_MOUNT_PATH = "/mnt/job_stage"

{snowflake_ml_python-1.52.0 → snowflake_ml_python-1.53.0}/snowflake/ml/jobs/_utils/payload_utils.py

@@ -239,7 +239,7 @@ def resolve_entrypoint(
     if entrypoint.suffix not in _SUPPORTED_ENTRYPOINT_EXTENSIONS:
         raise ValueError(
             "Unsupported entrypoint type:"
-            f" supported={','.join(_SUPPORTED_ENTRYPOINT_EXTENSIONS)} got={entrypoint.suffix}"
+            f" supported={','.join(sorted(_SUPPORTED_ENTRYPOINT_EXTENSIONS))} got={entrypoint.suffix}"
         )
 
     return type_utils.PayloadEntrypoint(