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

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

@@ -1,6 +1,38 @@
 # Release History
 
-## 1.53.0
+## 1.54.0
+
+### New Features
+
+* Registry: `log_model(..., options={"case_sensitive": True})` and
+  `options={"max_batch_size": N}` apply those settings to all methods. Per-method
+  `method_options` still override the global values.
+
+* Feature Store: `create_online_service` accepts a `size` kwarg naming the size to provision the Online
+  Service at, one of `"XS"`, `"S"`, `"M"`, `"L"`, `"XL"`, `"2XL"`, `"3XL"` (case-insensitive). When
+  omitted, the server-side default applies; accounts that cap the available size provision at their
+  cap. `get_online_service_status()` now reports the provisioned `size`, which is `None` for services
+  created before sizes were recorded.
+
+* Experiment Tracking: Source provenance now also records the id of the enclosing ML job when a run is created from
+  inside one.
+
+### Bug Fixes
+
+* Feature Store: Feature View metadata tags carrying unknown keys (including a legacy `refresh_mode`)
+  no longer fail to deserialize; unknown keys are ignored on read and the tag still does not persist
+  `refresh_mode`.
+* Registry: Fixed `ModelVersion.load()` failing with `ValueError: ... is not a valid SQL identifier`
+  when the model's owner role is a quoted identifier.
+* Feature Store: Fixed FeatureStore.update_feature_view() failing with `SQL compilation error:
+  invalid value 'ADAPTIVE' for property 'REFRESH_MODE'` when enabling online storage for an existing
+  feature view.
+
+### Behavior Changes
+
+### Deprecations
+
+## 1.53.0 (2026-08-24)
 
 ### New Features
 
@@ -29,6 +61,10 @@
 
 ### Bug Fixes
 
+* Feature Store: online feature reads and stream ingestion no longer fail while the Online Service is
+  changing size (status `UPDATING_SIZE`). The service serves reads and writes throughout a size
+  change, which can take hours, so it is now treated as serviceable like `UPDATING` already was.
+
 ### Behavior Changes
 
 * Feature Store: `register_feature_view` now records `FV_SOURCE_REFS` metadata for managed batch

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.53.0
+Version: 1.54.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,39 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
-## 1.53.0
+## 1.54.0
+
+### New Features
+
+* Registry: `log_model(..., options={"case_sensitive": True})` and
+  `options={"max_batch_size": N}` apply those settings to all methods. Per-method
+  `method_options` still override the global values.
+
+* Feature Store: `create_online_service` accepts a `size` kwarg naming the size to provision the Online
+  Service at, one of `"XS"`, `"S"`, `"M"`, `"L"`, `"XL"`, `"2XL"`, `"3XL"` (case-insensitive). When
+  omitted, the server-side default applies; accounts that cap the available size provision at their
+  cap. `get_online_service_status()` now reports the provisioned `size`, which is `None` for services
+  created before sizes were recorded.
+
+* Experiment Tracking: Source provenance now also records the id of the enclosing ML job when a run is created from
+  inside one.
+
+### Bug Fixes
+
+* Feature Store: Feature View metadata tags carrying unknown keys (including a legacy `refresh_mode`)
+  no longer fail to deserialize; unknown keys are ignored on read and the tag still does not persist
+  `refresh_mode`.
+* Registry: Fixed `ModelVersion.load()` failing with `ValueError: ... is not a valid SQL identifier`
+  when the model's owner role is a quoted identifier.
+* Feature Store: Fixed FeatureStore.update_feature_view() failing with `SQL compilation error:
+  invalid value 'ADAPTIVE' for property 'REFRESH_MODE'` when enabling online storage for an existing
+  feature view.
+
+### Behavior Changes
+
+### Deprecations
+
+## 1.53.0 (2026-08-24)
 
 ### New Features
 
@@ -445,6 +477,10 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 ### Bug Fixes
 
+* Feature Store: online feature reads and stream ingestion no longer fail while the Online Service is
+  changing size (status `UPDATING_SIZE`). The service serves reads and writes throughout a size
+  change, which can take hours, so it is now treated as serviceable like `UPDATING` already was.
+
 ### Behavior Changes
 
 * Feature Store: `register_feature_view` now records `FV_SOURCE_REFS` metadata for managed batch

{snowflake_ml_python-1.53.0 → snowflake_ml_python-1.54.0}/snowflake/ml/_internal/env_utils.py

@@ -689,22 +689,30 @@ def save_requirements_file(
     path: pathlib.Path,
     pip_deps: list[requirements.Requirement],
     cuda_version: Optional[str] = None,
-) -> None:
+) -> list[str]:
     """Generate Python requirements.txt file in the given directory path.
 
     Args:
         path: Path to the requirements.txt file.
         pip_deps: List of dependencies after validation.
         cuda_version: Optional CUDA version for GPU models. If provided and torch is in
-            dependencies, adds PyTorch CUDA index URL and pins torch to CUDA variant.
+            dependencies, pins torch to CUDA variant.
+
+    Returns:
+        List of extra pip index URLs (e.g. ``["https://download.pytorch.org/whl/cu124"]``)
+        that were NOT written to requirements.txt because SPCS rejects non-PEP-508 lines.
+        Callers should persist these via model metadata so the build step can apply them.
     """
     assert path.suffix in [".txt"], "PIP requirement file should have extension of txt."
     path.parent.mkdir(parents=True, exist_ok=True)
 
     lines: list[str] = []
+    pip_extra_index_urls: list[str] = []
 
     if cuda_version and _has_torch_dependency(pip_deps):
-        lines.append(_get_pytorch_cuda_index_url(cuda_version))
+        # Strip the "--extra-index-url " prefix to store just the URL.
+        raw = _get_pytorch_cuda_index_url(cuda_version)
+        pip_extra_index_urls.append(raw.removeprefix("--extra-index-url "))
         pip_deps = _pin_torch_to_cuda_variant(pip_deps, cuda_version)
 
     lines.extend(map(str, pip_deps))
@@ -712,6 +720,8 @@ def save_requirements_file(
     with open(path, "w", encoding="utf-8") as out:
         out.write("\n".join(lines))
 
+    return pip_extra_index_urls
+
 
 def load_conda_env_file(
     path: pathlib.Path,

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

@@ -84,7 +84,7 @@ class PlatformCapabilities:
         return self._get_bool_feature(LIVE_COMMIT_PARAMETER, False)
 
     def is_hidden_live_commit_enabled(self) -> bool:
-        return False
+        return self._get_bool_feature(HIDDEN_LIVE_COMMIT_PARAMETER, False)
 
     def is_model_method_signature_parameters_enabled(self) -> bool:
         return self._get_bool_feature(ENABLE_MODEL_METHOD_SIGNATURE_PARAMETERS, False)

{snowflake_ml_python-1.53.0 → snowflake_ml_python-1.54.0}/snowflake/ml/_internal/telemetry.py

@@ -9,7 +9,8 @@ import sys
 import time
 import traceback
 import types
-from typing import Any, Callable, Iterable, Mapping, Optional, TypeVar, Union, cast
+from collections.abc import Iterable, Mapping
+from typing import Any, Callable, Optional, TypeVar, Union, cast
 
 from typing_extensions import ParamSpec
 
@@ -119,6 +120,7 @@ class TelemetryField(enum.Enum):
     TYPE_FUNCTION_USAGE = "function_usage"
     TYPE_SNOWML_SPCS_USAGE = "snowml_spcs_usage"
     TYPE_SNOWML_PIPELINE_USAGE = "snowml_pipeline_usage"
+    TYPE_SNOWML_LOADED_MODEL_USAGE = "snowml_loaded_model_usage"
     # message keys for telemetry
     KEY_PROJECT = "project"
     KEY_SUBPROJECT = "subproject"
@@ -717,6 +719,12 @@ def _extract_arg_value(field: str, sig: inspect.Signature, args: Any, kwargs: An
         Tuple: First value indicates if `field` exists.
         Second value is the extracted value if existed.
     """
+    # Check keyword arguments first. The field may have no named parameter of its own and instead be
+    # absorbed by a variadic keyword parameter (**kwargs), in which case the signature lookup below
+    # would not find it even though the caller passed a value.
+    if field in kwargs:
+        return True, kwargs[field]
+
     if field not in sig.parameters:
         return False, None
 
@@ -729,10 +737,6 @@ def _extract_arg_value(field: str, sig: inspect.Signature, args: Any, kwargs: An
         if idx < len(args):
             return True, args[idx]
 
-    # Check if value was passed as keyword argument
-    if field in kwargs:
-        return True, kwargs[field]
-
     # Fall back to default value if available
     if param.default is not inspect.Parameter.empty:
         return True, param.default

{snowflake_ml_python-1.53.0 → snowflake_ml_python-1.54.0}/snowflake/ml/experiment/_source_info.py

@@ -44,6 +44,11 @@ _SNOWFLAKE_FILE_DOMAIN_TYPE_ENV = "SNOWFLAKE_FILE_DOMAIN_TYPE"
 _SNOWFLAKE_FILE_DOMAIN_NAME_ENV = "SNOWFLAKE_FILE_DOMAIN_NAME"
 _SNOWFLAKE_MAIN_FILE_PATH_ENV = "SNOWFLAKE_MAIN_FILE_PATH"
 
+# Environment variable Snowflake injects into an ML job's container, carrying the
+# job's fully-qualified id. Its presence is how we recognize that the run was
+# created from inside an ML job.
+_ML_JOB_ID_ENV = "MLRS_JOB_ID"
+
 
 @dataclasses.dataclass(frozen=True)
 class GitInfo:
@@ -72,6 +77,9 @@ class SourceInfo:
     # ``entry_point``, not duplicated here.
     snowflake_file_domain_type: Optional[str] = None
     snowflake_file_domain_name: Optional[str] = None
+    # The fully-qualified id of the ML job this run was created from, taken from
+    # the environment. ``None`` when not running inside an ML job.
+    ml_job_id: Optional[str] = None
 
     def is_empty(self) -> bool:
         """Return True when there is nothing useful to send."""
@@ -80,6 +88,7 @@ class SourceInfo:
             and (self.git is None or self.git.is_empty())
             and self.snowflake_file_domain_type is None
             and self.snowflake_file_domain_name is None
+            and self.ml_job_id is None
         )
 
     def to_json_dict(self) -> dict[str, Any]:
@@ -92,8 +101,9 @@ class SourceInfo:
 
         Returns:
             A JSON-serializable dict whose keys (``entry_point``, ``git``,
-            ``snowflake_file_domain_type``, ``snowflake_file_domain_name``) are
-            included only when resolved. May be empty when nothing was collected.
+            ``snowflake_file_domain_type``, ``snowflake_file_domain_name``,
+            ``ml_job_id``) are included only when resolved. May be empty when
+            nothing was collected.
         """
         out: dict[str, Any] = {}
         if self.entry_point is not None and "$$" not in self.entry_point:
@@ -110,6 +120,8 @@ class SourceInfo:
             out["snowflake_file_domain_type"] = self.snowflake_file_domain_type
         if self.snowflake_file_domain_name is not None and "$$" not in self.snowflake_file_domain_name:
             out["snowflake_file_domain_name"] = self.snowflake_file_domain_name
+        if self.ml_job_id is not None and "$$" not in self.ml_job_id:
+            out["ml_job_id"] = self.ml_job_id
         return out
 
     @classmethod
@@ -121,24 +133,39 @@ class SourceInfo:
             be resolved or collection failed.
         """
         try:
+            # An ML job id is orthogonal to how the entry point is described, so
+            # it is resolved once and attached to whichever shape is returned.
+            ml_job_id = _collect_ml_job_id()
+
             # Snowflake-managed files (notebooks or .py workspace files) describe
             # the running file via environment variables rather than a resolvable
             # local path, so they are handled first and independently of the
             # git/notebook-path machinery.
             snowflake_file = _collect_snowflake_file()
             if snowflake_file is not None:
-                return snowflake_file
+                return dataclasses.replace(snowflake_file, ml_job_id=ml_job_id)
 
             # Resolve the notebook once so entry-point and git agree on the same file.
             notebook_path = _resolve_notebook_path() if _in_ipython_kernel() else None
             return cls(
                 entry_point=_detect_entry_point(notebook_path),
                 git=_collect_git(notebook_path),
+                ml_job_id=ml_job_id,
             )
         except Exception:
             return cls()
 
 
+def _collect_ml_job_id() -> Optional[str]:
+    """Collect the fully-qualified id of the enclosing ML job.
+
+    Returns:
+        The ML job id from the environment, or ``None`` when not running inside
+        an ML job (or when the server does not expose the id).
+    """
+    return os.environ.get(_ML_JOB_ID_ENV) or None
+
+
 def _collect_snowflake_file() -> Optional[SourceInfo]:
     """Collect source info when running inside a Snowflake-managed file.
 

{snowflake_ml_python-1.53.0 → snowflake_ml_python-1.54.0}/snowflake/ml/experiment/experiment_tracking.py

@@ -63,9 +63,10 @@ class ExperimentTracking:
             schema_name: The name of the schema. If None, the current schema of the session
                 will be used. If there is no active schema, the PUBLIC schema will be used. Defaults to None.
             capture_source_info: If True, each new run records best-effort source provenance — the
-                entry-point filename and any surrounding git commit, branch, and remote URL. Set to
-                False to skip collection entirely. Collection is always non-fatal and never blocks
-                run creation. Defaults to True.
+                entry-point filename, any surrounding git commit, branch, and remote URL, and the id
+                of the enclosing ML job when running inside one. Set to False to skip collection
+                entirely. Collection is always non-fatal and never blocks run creation. Defaults to
+                True.
 
         Raises:
             ValueError: If no database is provided and no active database exists in the session.

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

@@ -33,6 +33,12 @@ class AggregationType(Enum):
     - Sketch aggregations (APPROX_COUNT_DISTINCT, APPROX_PERCENTILE): Stored as mergeable state in tiles
     - List aggregations (LAST_N, LAST_DISTINCT_N, FIRST_N, FIRST_DISTINCT_N): Stored as arrays in tiles
     - Secondary-key array (_SECONDARY_KEY_ARRAY): Internal-only ARRAY_AGG of the secondary-key column
+
+    Each value is the short function token used in the imperative metadata
+    tag / FeatureView JSON and in auto-generated output column names. Snowflake
+    ``DESCRIBE ... TYPE = SPECIFICATION`` reports its own SQL spelling for some
+    functions (e.g. ``stddev`` for ``STD``); the declarative layer reconciles
+    that spelling on read/hash rather than changing these values.
     """
 
     SUM = "sum"
@@ -50,6 +56,25 @@ class AggregationType(Enum):
     FIRST_DISTINCT_N = "first_distinct_n"
     _SECONDARY_KEY_ARRAY = "secondary_key_array"
 
+    @classmethod
+    def _missing_(cls, value: object) -> AggregationType | None:
+        """Accept Snowflake's SPECIFICATION spelling ``stddev`` as ``STD``.
+
+        The imperative wire token stays ``"std"``; ``DESCRIBE ... TYPE =
+        SPECIFICATION`` reports ``"stddev"`` for the same function, so reads of
+        the applied spec must resolve that spelling back to ``STD``.
+
+        Args:
+            value: The raw value that failed direct enum lookup.
+
+        Returns:
+            ``STD`` when ``value`` is the string ``"stddev"`` (case-insensitive),
+            otherwise ``None`` to preserve the standard ``ValueError``.
+        """
+        if isinstance(value, str) and value.lower() == "stddev":
+            return cls.STD
+        return None
+
     def is_simple(self) -> bool:
         """Check if this is a simple aggregation (scalar result per tile).
 
@@ -223,7 +248,7 @@ class AggregationSpec:
                 AggregationType.VAR,
             )
             if self.function not in supported_lifetime_types:
-                supported_names = ", ".join(t.value.upper() for t in supported_lifetime_types)
+                supported_names = ", ".join(t.name for t in supported_lifetime_types)
                 raise ValueError(
                     f"Lifetime window is not supported for {self.function.value} aggregation "
                     f"'{self.output_column}'. Lifetime is only supported for: {supported_names}."

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

@@ -1298,24 +1298,33 @@ class FeatureStore:
                 created_resources=created_resources,
             )
 
-            # Step 3: Save aggregation metadata for tiled feature views (atomically)
-            if feature_view.is_tiled:
-                agg_metadata = AggregationMetadata(
-                    feature_granularity=feature_view.feature_granularity,  # type: ignore[arg-type]
-                    features=feature_view.aggregation_specs,  # type: ignore[arg-type]
-                    feature_aggregation_method=(
-                        feature_view.feature_aggregation_method.value
-                        if feature_view.feature_aggregation_method is not None
-                        else None
-                    ),
-                    # Stored in FEATURE_SPECS so ``get_feature_view``
-                    # reconstructs the exact secondary key order registered.
-                    aggregation_secondary_keys=(
-                        list(feature_view.aggregation_secondary_keys)
-                        if feature_view.aggregation_secondary_keys
-                        else None
-                    ),
-                )
+            # Step 3: Save aggregation metadata for tiled feature views (atomically),
+            # and also for non-tiled advanced BFVs that carry aggregation_secondary_keys
+            # so get_feature_view() can restore them without re-deriving from the DT.
+            if feature_view.is_tiled or feature_view.aggregation_secondary_keys:
+                if feature_view.is_tiled:
+                    agg_metadata = AggregationMetadata(
+                        feature_granularity=feature_view.feature_granularity,
+                        features=feature_view.aggregation_specs,
+                        feature_aggregation_method=(
+                            feature_view.feature_aggregation_method.value
+                            if feature_view.feature_aggregation_method is not None
+                            else None
+                        ),
+                        # Stored in FEATURE_SPECS so ``get_feature_view``
+                        # reconstructs the exact secondary key order registered.
+                        aggregation_secondary_keys=(
+                            list(feature_view.aggregation_secondary_keys)
+                            if feature_view.aggregation_secondary_keys
+                            else None
+                        ),
+                    )
+                else:
+                    # Non-tiled advanced BFV: persist only secondary keys.
+                    # feature_granularity and features stay None so that
+                    # get_feature_view() correctly reconstructs is_tiled=False.
+                    sk = list(feature_view.aggregation_secondary_keys)  # type: ignore[arg-type]
+                    agg_metadata = AggregationMetadata(aggregation_secondary_keys=sk)
                 # Convert SqlIdentifier keys to strings if descriptions exist
                 descs = None
                 if feature_view.feature_descs:
@@ -2203,7 +2212,9 @@ class FeatureStore:
         )
 
     @dispatch_decorator()
-    def create_online_service(self, producer_role: str, consumer_role: str) -> online_service.OnlineServiceResult:
+    def create_online_service(
+        self, producer_role: str, consumer_role: str, *, size: Optional[str] = None
+    ) -> online_service.OnlineServiceResult:
         """Create the Online Service for this store's schema.
 
         Requires schema OWNERSHIP and account feature enablement. After SUCCESS, poll
@@ -2213,6 +2224,10 @@ class FeatureStore:
         Args:
             producer_role: Role name granted producer privileges on the Online Service.
             consumer_role: Role name granted consumer privileges on the Online Service.
+            size: Size to provision the Online Service at, one of ``"XS"``, ``"S"``, ``"M"``,
+                ``"L"``, ``"XL"``, ``"2XL"``, ``"3XL"`` (case-insensitive). Defaults to the
+                server-side default when omitted. Accounts that cap the available size
+                provision at their cap instead.
 
         Returns:
             Parsed create result from the Online Service.
@@ -2223,6 +2238,7 @@ class FeatureStore:
             self._config.schema,
             producer_role,
             consumer_role,
+            size=size,
             statement_params=self._telemetry_stmp,
         )
 
@@ -2234,7 +2250,7 @@ class FeatureStore:
         ``RUNNING`` before using online feature reads or stream ingestion.
 
         Returns:
-            OnlineServiceStatus with ``status``, ``message``, and ``endpoints``.
+            OnlineServiceStatus with ``status``, ``message``, ``endpoints``, and ``size``.
         """
         return online_service.get_online_service_status(
             self._session,
@@ -6903,7 +6919,9 @@ END;"""
         feature_view: FeatureView,
         tagging_clause_str: str,
     ) -> str:
-        return f"""CREATE{overwrite_clause} VIEW {view_name} ({column_descs})
+        # Include column definitions only if provided (empty when feature_descs is None).
+        col_clause = f" ({column_descs})" if column_descs else ""
+        return f"""CREATE{overwrite_clause} VIEW {view_name}{col_clause}
             COMMENT = {_sql_string_literal(feature_view.desc)}
             TAG (
                 {tagging_clause_str}
@@ -8058,6 +8076,14 @@ FROM {batch_cte_names[0]}{''.join(merge_join_parts)}
         if target_lag == "DOWNSTREAM":
             target_lag = self._resolve_task_schedule(FeatureView._get_physical_name(name, version), target_lag)
         values.append(target_lag)
+        # ``refresh_mode`` is the Snowflake-resolved value from the deployed
+        # Dynamic Table (``SHOW DYNAMIC TABLES.refresh_mode`` surfaces
+        # ``INCREMENTAL`` / ``FULL`` after ``AUTO`` is resolved).  The
+        # imperative API returns this resolved value to all callers; it is
+        # not persisted on the metadata tag.  The declarative round-trip
+        # handles the authored-vs-resolved asymmetry in
+        # ``decl/invariants._normalize_applied_bfv_for_hash`` rather than by
+        # reading an authored value back here.
         values.append(row["refresh_mode"] if "refresh_mode" in row else None)
         values.append(row["scheduling_state"] if "scheduling_state" in row else None)
         values.append(row["warehouse"] if "warehouse" in row else None)
@@ -8294,7 +8320,10 @@ FROM {batch_cte_names[0]}{''.join(merge_join_parts)}
         agg_metadata = self._metadata_manager.get_feature_specs(name.identifier(), version)
         feature_granularity = agg_metadata.feature_granularity if agg_metadata else None
         aggregation_specs = agg_metadata.features if agg_metadata else None
-        is_tiled = agg_metadata is not None
+        # Tiled iff a tile size was persisted. Null granularity is passthrough (SK-only).
+        is_tiled = agg_metadata is not None and agg_metadata.feature_granularity is not None
+        if not is_tiled:
+            aggregation_specs = None  # [] is not a tiled spec list
         # Restored from the FEATURE_SPECS row; None when no tiling metadata.
         aggregation_secondary_keys = agg_metadata.aggregation_secondary_keys if agg_metadata else None
         # The persisted aggregation method must be known before _construct_feature_view runs
@@ -8575,6 +8604,29 @@ FROM {batch_cte_names[0]}{''.join(merge_join_parts)}
                 descs[SqlIdentifier(r["name"], case_sensitive=True).identifier()] = r["comment"]
         return descs
 
+    _DT_TO_OFT_REFRESH_MODE = {
+        "INCREMENTAL": "INCREMENTAL",
+        "FULL": "FULL",
+        "ADAPTIVE": "INCREMENTAL",
+    }
+
+    @staticmethod
+    def _dt_to_oft_refresh_mode(dt_refresh_mode: str) -> str:
+        """Map a resolved Dynamic Table refresh mode to an Online Feature Table refresh mode.
+
+        ``ADAPTIVE`` is incrementalizable but is not a valid OFT ``REFRESH_MODE``.
+
+        Args:
+            dt_refresh_mode: Resolved DT refresh mode (``INCREMENTAL``, ``FULL``, or ``ADAPTIVE``).
+
+        Returns:
+            OFT refresh mode (``INCREMENTAL`` or ``FULL``).
+        """
+        mapped = FeatureStore._DT_TO_OFT_REFRESH_MODE.get(dt_refresh_mode.upper())
+        if mapped is None:
+            return dt_refresh_mode
+        return mapped
+
     def _tag_oft(self, fully_qualified_oft_name: str, obj_type: _FeatureStoreObjTypes) -> None:
         """Apply the FS object tag to a freshly-created OFT.
 
@@ -8672,7 +8724,8 @@ FROM {batch_cte_names[0]}{''.join(merge_join_parts)}
 
         refresh_mode_clause = ""
         if feature_view.refresh_mode:
-            refresh_mode_clause = f"REFRESH_MODE='{feature_view.refresh_mode}'"
+            oft_refresh_mode = self._dt_to_oft_refresh_mode(feature_view.refresh_mode)
+            refresh_mode_clause = f"REFRESH_MODE='{oft_refresh_mode}'"
 
         timestamp_clause = ""
         if feature_view.timestamp_col:

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

@@ -7,7 +7,7 @@ import json
 import re
 import warnings
 from collections import OrderedDict
-from dataclasses import asdict, dataclass
+from dataclasses import asdict, dataclass, fields
 from enum import Enum
 from typing import TYPE_CHECKING, Any, Optional, Union
 
@@ -410,21 +410,12 @@ class _FeatureViewMetadata:
     @classmethod
     def from_json(cls, json_str: str) -> _FeatureViewMetadata:
         state_dict = json.loads(json_str)
-        # Backward compatibility: old FVs don't have is_tiled
-        if "is_tiled" not in state_dict:
-            state_dict["is_tiled"] = False
-        # Backward compatibility: old FVs don't have is_iceberg
-        if "is_iceberg" not in state_dict:
-            state_dict["is_iceberg"] = False
-        # Backward compatibility: old FVs don't have is_rollup
-        if "is_rollup" not in state_dict:
-            state_dict["is_rollup"] = False
-        # Backward compatibility: old FVs don't have is_streaming
-        if "is_streaming" not in state_dict:
-            state_dict["is_streaming"] = False
-        if "is_append_only" not in state_dict:
-            state_dict["is_append_only"] = False
-        return cls(**state_dict)
+        # Drop keys that are not constructor fields so a tag written by a
+        # different SDK version (carrying keys this one does not know) does not
+        # raise ``TypeError``. Optional fields omitted by older tags fall back
+        # to their dataclass defaults.
+        known_fields = {f.name for f in fields(cls)}
+        return cls(**{k: v for k, v in state_dict.items() if k in known_fields})
 
 
 @dataclass(frozen=True)
@@ -2147,6 +2138,22 @@ Got {len(self._feature_df.queries['queries'])}: {self._feature_df.queries['queri
                     "timestamp_col is required for tile-based aggregations. "
                     "Specify the timestamp column used for time-series lookups."
                 )
+            # refresh_freq is the OFFLINE object's cadence: it drives the
+            # CREATE DYNAMIC TABLE … TARGET_LAG clause over the tiling
+            # query (_get_tile_query).  Every tiled FV — batch AND
+            # streaming — must be a managed Dynamic Table so the
+            # pre-computed partial aggregates exist for the merge-at-read
+            # path.  Without refresh_freq the register flow falls to
+            # _create_offline_feature_view_view_query and builds a plain
+            # VIEW over the untiled source query (empty column list) — no
+            # tiles.  The VIEW path is only correct for non-tiled streaming
+            # FVs.
+            #
+            # This is independent of the Online Feature Table's TARGET_LAG,
+            # which is "0 seconds" for every streaming kind because data
+            # lands via the ingest path (stream source -> UDF transform ->
+            # spec-backed OFT) as soon as it is available.  A zero OFT lag
+            # is not a reason to skip the offline tile Dynamic Table.
             if self._refresh_freq is None:
                 raise ValueError(
                     "refresh_freq is required for tile-based aggregations. "
@@ -2166,12 +2173,7 @@ 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:
-                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)."
-                    )
+                raise ValueError("Online storage is not supported with Iceberg.")
             if self._refresh_freq is None:
                 raise ValueError("Iceberg storage requires refresh_freq.")
 

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

@@ -85,18 +85,32 @@ class FeatureViewMetadataConfig:
 
 @dataclass
 class AggregationMetadata:
-    """Aggregation configuration for tiled feature views."""
+    """Aggregation configuration for tiled feature views.
+
+    ``aggregation_secondary_keys`` was promoted from a tiling-time-only
+    detail to authoritative metadata so the applied-state recovery path
+    can rehydrate it without re-deriving from the synthesized
+    ``_SECONDARY_KEY_ARRAY`` aggregation specs (which is lossy on the
+    ordering boundary and forced an UPDATE_FV on round-trip). See plan
+    section A2.
+
+    Non-tiled BFVs that only carry ``aggregation_secondary_keys`` have
+    ``feature_granularity`` and ``features`` set to None. They still serialize
+    both keys (as null and []) so older clients can read the row, and a null
+    ``feature_granularity`` marks the row as passthrough on read.
+    """
 
-    feature_granularity: str
-    features: list[AggregationSpec]
+    feature_granularity: Optional[str] = None
+    features: Optional[list[AggregationSpec]] = None
     feature_aggregation_method: Optional[str] = None
     aggregation_secondary_keys: Optional[list[str]] = None
 
     def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary for JSON serialization."""
+        # Always emit keys so older from_dict can parse SK-only rows.
         d: dict[str, Any] = {
             "feature_granularity": self.feature_granularity,
-            "features": [f.to_dict() for f in self.features],
+            "features": [f.to_dict() for f in (self.features or [])],
         }
         if self.feature_aggregation_method is not None:
             d["feature_aggregation_method"] = self.feature_aggregation_method
@@ -108,9 +122,10 @@ class AggregationMetadata:
     def from_dict(cls, data: dict[str, Any]) -> AggregationMetadata:
         """Create from dictionary."""
         raw_secondary_keys = data.get("aggregation_secondary_keys")
+        raw_features = data.get("features")
         return cls(
-            feature_granularity=data["feature_granularity"],
-            features=[AggregationSpec.from_dict(f) for f in data["features"]],
+            feature_granularity=data.get("feature_granularity"),
+            features=[AggregationSpec.from_dict(f) for f in raw_features] if raw_features is not None else None,
             feature_aggregation_method=data.get("feature_aggregation_method"),
             aggregation_secondary_keys=list(raw_secondary_keys) if raw_secondary_keys is not None else None,
         )