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

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

@@ -1,6 +1,56 @@
 # Release History
 
-## 1.51.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
+
+### Bug Fixes
+
+### 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)
 
 ### New Features
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.51.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,57 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
-## 1.51.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
+
+### Bug Fixes
+
+### 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)
 
 ### New Features
 

{snowflake_ml_python-1.51.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.51.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.51.0 → snowflake_ml_python-1.53.0}/snowflake/ml/_internal/telemetry.py

@@ -300,7 +300,7 @@ def add_statement_params_custom_tags(
     """
     if not statement_params:
         return {}
-    existing_custom_tags: dict[str, Any] = statement_params.pop(TelemetryField.KEY_CUSTOM_TAGS.value, {})
+    existing_custom_tags: dict[str, Any] = dict(statement_params.get(TelemetryField.KEY_CUSTOM_TAGS.value, {}))
     existing_custom_tags.update(custom_tags)
     # NOTE: This can be done with | operator after upgrade from py3.8
     return {

{snowflake_ml_python-1.51.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(
@@ -3218,7 +3312,9 @@ class FeatureStore:
                 original_exception=ValueError(f"Cannot find StreamSource with name: {name_id}."),
             )
 
-        return StreamSource._from_dict(metadata)
+        stream_source = StreamSource._from_dict(metadata)
+        self._hydrate_stream_source_online_service(stream_source)
+        return stream_source
 
     @dispatch_decorator()
     def stream_ingest(
@@ -3259,20 +3355,26 @@ class FeatureStore:
             src = self.get_stream_source(str(stream_source))
             stream_name_wire = src.name.resolved()
 
-        stmp = self._telemetry_stmp if statement_params is None else statement_params
-        st = online_service.assert_online_service_running_with_ingest_endpoint(
-            self._session,
-            self._config.database,
-            self._config.schema,
-            statement_params=stmp,
-        )
-        ingest_url = online_service.endpoint_url(st, "ingest", access=self._online_service_access)
-        if not ingest_url:
-            raise snowml_exceptions.SnowflakeMLException(
-                error_code=error_codes.INVALID_ARGUMENT,
-                original_exception=ValueError("Online Service returned no ingest endpoint."),
+        # Reuse the ingest endpoint cached on the StreamSource by get_stream_source to
+        # skip the per-call GS status lookup. Fall back to a live status fetch when the
+        # URL is absent (manually constructed StreamSource, or hydrated before the
+        # Online Service was RUNNING).
+        ingest_base = getattr(src, "_postgres_online_ingest_url", None)
+        if not ingest_base:
+            stmp = self._telemetry_stmp if statement_params is None else statement_params
+            st = online_service.assert_online_service_running_with_ingest_endpoint(
+                self._session,
+                self._config.database,
+                self._config.schema,
+                statement_params=stmp,
             )
-        ingest_base = ingest_url
+            ingest_url = online_service.endpoint_url(st, "ingest", access=self._online_service_access)
+            if not ingest_url:
+                raise snowml_exceptions.SnowflakeMLException(
+                    error_code=error_codes.INVALID_ARGUMENT,
+                    original_exception=ValueError("Online Service returned no ingest endpoint."),
+                )
+            ingest_base = ingest_url
 
         expected_cols = _stream_source_schema_field_names(src.schema)
         rows = _normalize_stream_ingest_records(records)
@@ -5016,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,
@@ -8320,21 +8468,28 @@ FROM {batch_cte_names[0]}{''.join(merge_join_parts)}
 
             return fv
 
-    def _resolve_postgres_online_query_url(self, *, log_label: str) -> Optional[str]:
-        """Fetch the Postgres OFT query endpoint URL or warn and return ``None``.
+    def _resolve_postgres_online_endpoint_url(
+        self, endpoint_name: str, *, log_label: str, warn: bool = True
+    ) -> Optional[str]:
+        """Fetch a Postgres OFT Online Service endpoint URL or return ``None``.
 
         Failures (status not RUNNING, missing endpoint URL, transient
-        SYSTEM$ errors) are downgraded to ``UserWarning`` so callers can
-        still construct the target object and see the "Online Service not
-        RUNNING" error on first read.
+        SYSTEM$ errors) are downgraded to a return value of ``None`` so callers
+        can still construct the target object and surface the "Online Service
+        not RUNNING" error at use time. When ``warn`` is ``True`` these
+        failures also emit a ``UserWarning``.
 
         Args:
+            endpoint_name: Endpoint to resolve (``"query"`` or ``"ingest"``).
             log_label: Caller name embedded in the warning log
-                (e.g. ``"get_feature_view"``, ``"get_feature_group"``).
+                (e.g. ``"get_feature_view"``, ``"get_stream_source"``).
+            warn: When ``True``, emit a ``UserWarning`` on failure. Callers that
+                have their own use-time fallback (e.g. ``stream_ingest``) pass
+                ``False`` to avoid spurious warnings during metadata reads.
 
         Returns:
-            The query endpoint URL when the Online Service is RUNNING or
-            UPDATING and advertises a ``query`` endpoint; ``None`` otherwise.
+            The endpoint URL when the Online Service is RUNNING or UPDATING and
+            advertises the named endpoint; ``None`` otherwise.
         """
         try:
             st = online_service.fetch_online_service_status(
@@ -8345,30 +8500,62 @@ FROM {batch_cte_names[0]}{''.join(merge_join_parts)}
             )
         except Exception as ex:
             logger.warning("Could not fetch Online Service status during %s: %s", log_label, ex)
+            if warn:
+                warnings.warn(
+                    online_service.online_service_not_ready_message(),
+                    category=UserWarning,
+                    stacklevel=4,
+                )
+            return None
+        endpoint = online_service.endpoint_url(st, endpoint_name, access=self._online_service_access)
+        # UPDATING (redeploy in progress) still serves endpoints, so accept it too.
+        if st.status in ("RUNNING", "UPDATING") and endpoint:
+            # Temporary: SYSTEM$ may return host-only URLs until server sends full https URLs.
+            return endpoint
+        if warn:
             warnings.warn(
                 online_service.online_service_not_ready_message(),
                 category=UserWarning,
                 stacklevel=4,
             )
-            return None
-        query_url = online_service.endpoint_url(st, "query", access=self._online_service_access)
-        # 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(
-            online_service.online_service_not_ready_message(),
-            category=UserWarning,
-            stacklevel=4,
-        )
         return None
 
+    def _resolve_postgres_online_query_url(self, *, log_label: str) -> Optional[str]:
+        """Resolve the Postgres OFT ``query`` endpoint URL (thin wrapper).
+
+        Args:
+            log_label: Caller name embedded in the warning log
+                (e.g. ``"get_feature_view"``, ``"get_feature_group"``).
+
+        Returns:
+            The query endpoint URL when the Online Service is RUNNING or
+            UPDATING and advertises a ``query`` endpoint; ``None`` otherwise.
+        """
+        return self._resolve_postgres_online_endpoint_url("query", log_label=log_label)
+
     def _hydrate_postgres_online_service(self, fv: FeatureView) -> None:
         """Set ``_postgres_online_query_url`` and warn when Postgres online reads are not ready."""
         if not fv.online or fv.online_config is None or fv.online_config.store_type != OnlineStoreType.POSTGRES:
             return
         fv._postgres_online_query_url = self._resolve_postgres_online_query_url(log_label="get_feature_view")
 
+    def _hydrate_stream_source_online_service(self, stream_source: StreamSource) -> None:
+        """Cache the Online Service ingest endpoint URL on a StreamSource for reuse.
+
+        Best-effort: resolves the ``ingest`` endpoint without emitting a
+        ``UserWarning`` (``warn=False``) because ``get_stream_source`` is a
+        metadata read that also backs ``register_stream_source``; a not-yet-RUNNING
+        service should not warn here. ``stream_ingest`` surfaces a clear,
+        actionable error at ingest time via its live fallback when the URL is
+        unavailable.
+
+        Args:
+            stream_source: The StreamSource whose ingest URL should be populated.
+        """
+        stream_source._postgres_online_ingest_url = self._resolve_postgres_online_endpoint_url(
+            "ingest", log_label="get_stream_source", warn=False
+        )
+
     def _hydrate_fg_postgres_online_service(self, fg: FeatureGroup) -> None:
         """Set ``FeatureGroup._postgres_online_query_url`` for read-time use.
 

{snowflake_ml_python-1.51.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.51.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,