snowflake-ml-python 2.0.0__py3-none-any.whl → 2.1.0__py3-none-any.whl

snowflake/ml/_internal/env_utils.py

@@ -8,7 +8,7 @@ import textwrap
 import warnings
 from enum import Enum
 from importlib import metadata as importlib_metadata
-from typing import Any, DefaultDict, Optional
+from typing import Any, DefaultDict
 
 import yaml
 from packaging import requirements, specifiers, version
@@ -376,53 +376,13 @@ def get_package_spec_with_supported_ops_only(req: requirements.Requirement) -> r
         A requirements.Requirement object with supported ops only
     """
 
-    if req.name == "numpy":
-        import numpy as np
-
-        package_specifiers = get_numpy_specifiers(req, version.Version(np.__version__).major)
-    else:
-        package_specifiers = [spec for spec in req.specifier if spec.operator in _SUPPORTED_PACKAGE_SPEC_OPS]
+    package_specifiers = [spec for spec in req.specifier if spec.operator in _SUPPORTED_PACKAGE_SPEC_OPS]
 
     new_req = copy.deepcopy(req)
     new_req.specifier = specifiers.SpecifierSet(specifiers=",".join([str(spec) for spec in package_specifiers]))
     return new_req
 
 
-def get_numpy_specifiers(
-    req: requirements.Requirement,
-    client_numpy_major_version: int,
-) -> list[specifiers.Specifier]:
-    """Get the package spec with supported ops only including ==, >=, <=, > and < based on the client numpy
-    major version.
-
-    Args:
-        req: A requirements.Requirement object showing the requirement.
-        client_numpy_major_version: The major version of numpy to be used.
-
-    Returns:
-        A list of specifiers with supported ops only
-    """
-    req_specifiers = []
-    for org_spec in req.specifier:
-        # check specifier that provides upper bound
-        if org_spec.operator in ["<", "<="]:
-            client_version = version.Version(str(client_numpy_major_version))
-            org_spec_version = version.Version(org_spec.version)
-            # check if the client's numpy major version is less than the specifier's upper bound
-            # if so, pin to max possible client major version
-            if client_version.major < org_spec_version.major:
-                modified_spec = specifiers.Specifier(f"<{client_version.major + 1}")
-                req_specifiers.append(modified_spec)
-            else:
-                # use the original specifier
-                req_specifiers.append(org_spec)
-        else:
-            # use the original specifier
-            req_specifiers.append(org_spec)
-
-    return req_specifiers
-
-
 def _relax_specifier_set(
     specifier_set: specifiers.SpecifierSet, strategy: relax_version_strategy.RelaxVersionStrategy
 ) -> specifiers.SpecifierSet:
@@ -493,7 +453,7 @@ def get_matched_package_versions_in_information_schema(
     session: session.Session,
     reqs: list[requirements.Requirement],
     python_version: str,
-    statement_params: Optional[dict[str, Any]] = None,
+    statement_params: dict[str, Any] | None = None,
 ) -> dict[str, list[version.Version]]:
     """Look up the information_schema table to check if a package with the specified specifier exists in the Snowflake
     Conda channel. Note that this is not the source of truth due to the potential delay caused by a package that might
@@ -567,7 +527,7 @@ def save_conda_env_file(
     path: pathlib.Path,
     conda_chan_deps: DefaultDict[str, list[requirements.Requirement]],
     python_version: str,
-    cuda_version: Optional[str] = None,
+    cuda_version: str | None = None,
     default_channel_override: str = SNOWFLAKE_CONDA_CHANNEL_URL,
 ) -> None:
     """Generate conda.yml file given a dict of dependencies after validation.
@@ -688,7 +648,7 @@ def _has_torch_dependency(pip_deps: list[requirements.Requirement]) -> bool:
 def save_requirements_file(
     path: pathlib.Path,
     pip_deps: list[requirements.Requirement],
-    cuda_version: Optional[str] = None,
+    cuda_version: str | None = None,
 ) -> list[str]:
     """Generate Python requirements.txt file in the given directory path.
 
@@ -727,9 +687,9 @@ def load_conda_env_file(
     path: pathlib.Path,
 ) -> tuple[
     DefaultDict[str, list[requirements.Requirement]],
-    Optional[list[requirements.Requirement]],
-    Optional[str],
-    Optional[str],
+    list[requirements.Requirement] | None,
+    str | None,
+    str | None,
 ]:
     """Read conda.yml file to get a dict of dependencies after validation.
     The channels part of conda.yml file will be processed with following rules:
@@ -830,7 +790,7 @@ def load_requirements_file(path: pathlib.Path) -> list[requirements.Requirement]
 PYTHON_VERSION_PATTERN = re.compile(r"python(?:(?P<op>=|==|>|<|>=|<=|~=|===)(?P<ver>\d(?:\.\d+)+))?(\.*)?")
 
 
-def parse_python_version_string(dep: str) -> Optional[str]:
+def parse_python_version_string(dep: str) -> str | None:
     if dep.startswith("python"):
         m = PYTHON_VERSION_PATTERN.match(dep)
         if m is None:
@@ -849,7 +809,7 @@ def parse_python_version_string(dep: str) -> Optional[str]:
 
 def _find_conda_dep_spec(
     conda_chan_deps: DefaultDict[str, list[requirements.Requirement]], pkg_name: str
-) -> Optional[tuple[str, requirements.Requirement]]:
+) -> tuple[str, requirements.Requirement] | None:
     for channel in conda_chan_deps:
         spec = next(filter(lambda req: req.name == pkg_name, conda_chan_deps[channel]), None)
         if spec:
@@ -857,7 +817,7 @@ def _find_conda_dep_spec(
     return None
 
 
-def _find_pip_req_spec(pip_reqs: list[requirements.Requirement], pkg_name: str) -> Optional[requirements.Requirement]:
+def _find_pip_req_spec(pip_reqs: list[requirements.Requirement], pkg_name: str) -> requirements.Requirement | None:
     spec = next(filter(lambda req: req.name == pkg_name, pip_reqs), None)
     return spec
 
@@ -866,9 +826,9 @@ def find_dep_spec(
     conda_chan_deps: DefaultDict[str, list[requirements.Requirement]],
     pip_reqs: list[requirements.Requirement],
     conda_pkg_name: str,
-    pip_pkg_name: Optional[str] = None,
+    pip_pkg_name: str | None = None,
     remove_spec: bool = False,
-) -> Optional[requirements.Requirement]:
+) -> requirements.Requirement | None:
     if pip_pkg_name is None:
         pip_pkg_name = conda_pkg_name
     spec_conda = _find_conda_dep_spec(conda_chan_deps, conda_pkg_name)

snowflake/ml/experiment/_client/experiment_tracking_sql_client.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional
+from typing import Any
 
 from snowflake.ml._internal import telemetry
 from snowflake.ml._internal.utils import query_result_checker, sql_identifier
@@ -6,7 +6,7 @@ from snowflake.ml.experiment._client import artifact
 from snowflake.ml.experiment._entities import run_metadata
 from snowflake.ml.model._client.sql import _base
 from snowflake.ml.utils import sql_client
-from snowflake.snowpark import dataframe, file_operation, row, session, types
+from snowflake.snowpark import dataframe, file_operation, functions, row, session, types
 
 RUN_NAME_COL_NAME = "name"
 RUN_METADATA_COL_NAME = "metadata"
@@ -16,7 +16,7 @@ def pivot_run_attributes(
     sp_session: session.Session,
     rows: list[row.Row],
     run_names: list[str],
-    cast_value: Optional[type] = None,
+    cast_value: type | None = None,
 ) -> dataframe.DataFrame:
     """Pivot SHOW RUN METRICS/PARAMETERS rows into one row per run.
 
@@ -123,7 +123,7 @@ class ExperimentTrackingSQLClient(_base._BaseSQLClient):
         *,
         experiment_name: sql_identifier.SqlIdentifier,
         run_name: sql_identifier.SqlIdentifier,
-        source_info: Optional[str] = None,
+        source_info: str | None = None,
     ) -> None:
         experiment_fqn = self.fully_qualified_object_name(self._database_name, self._schema_name, experiment_name)
         query = f"ALTER EXPERIMENT {experiment_fqn} ADD RUN {run_name}"
@@ -139,7 +139,7 @@ class ExperimentTrackingSQLClient(_base._BaseSQLClient):
         *,
         experiment_name: sql_identifier.SqlIdentifier,
         run_name: sql_identifier.SqlIdentifier,
-        status: Optional[run_metadata.RunStatus] = None,
+        status: run_metadata.RunStatus | None = None,
     ) -> None:
         experiment_fqn = self.fully_qualified_object_name(self._database_name, self._schema_name, experiment_name)
         query = f"ALTER EXPERIMENT {experiment_fqn} COMMIT RUN {run_name}"
@@ -255,7 +255,7 @@ class ExperimentTrackingSQLClient(_base._BaseSQLClient):
 
     @telemetry.send_api_usage_telemetry(project=telemetry.TelemetryProject.EXPERIMENT_TRACKING.value)
     def show_runs_in_experiment(
-        self, *, experiment_name: sql_identifier.SqlIdentifier, like: Optional[str] = None
+        self, *, experiment_name: sql_identifier.SqlIdentifier, like: str | None = None
     ) -> list[row.Row]:
         experiment_fqn = self.fully_qualified_object_name(self._database_name, self._schema_name, experiment_name)
         like_clause = f"LIKE '{like}'" if like else ""
@@ -268,8 +268,8 @@ class ExperimentTrackingSQLClient(_base._BaseSQLClient):
         self,
         *,
         experiment_name: sql_identifier.SqlIdentifier,
-        run_name: Optional[sql_identifier.SqlIdentifier] = None,
-        like: Optional[str] = None,
+        run_name: sql_identifier.SqlIdentifier | None = None,
+        like: str | None = None,
     ) -> list[row.Row]:
         experiment_fqn = self.fully_qualified_object_name(self._database_name, self._schema_name, experiment_name)
         run_name_clause = f"RUN {run_name}" if run_name else ""
@@ -278,13 +278,46 @@ class ExperimentTrackingSQLClient(_base._BaseSQLClient):
             self._session, f"SHOW RUN METRICS {like_clause} IN EXPERIMENT {experiment_fqn} {run_name_clause}"
         ).validate()
 
+    @telemetry.send_api_usage_telemetry(project=telemetry.TelemetryProject.EXPERIMENT_TRACKING.value)
+    def get_run_metrics_history(
+        self,
+        *,
+        experiment_name: sql_identifier.SqlIdentifier,
+        run_name: sql_identifier.SqlIdentifier,
+    ) -> dataframe.DataFrame:
+        """Return every logged metric point of a run, ordered by name then step.
+
+        Args:
+            experiment_name: Name of the experiment containing the run.
+            run_name: Name of the run to read metric history from.
+
+        Returns:
+            A Snowpark DataFrame with ``name``, ``step``, ``value``, and ``timestamp`` columns.
+        """
+        experiment_fqn = self.fully_qualified_object_name(self._database_name, self._schema_name, experiment_name)
+        history: dataframe.DataFrame = (
+            self._session.table_function(
+                "SYSTEM$GET_EXPERIMENT_RUN_METRICS",
+                functions.lit(experiment_fqn),
+                functions.lit(str(run_name)),
+            )
+            .select(
+                functions.col("METRIC_NAME").alias('"name"'),
+                functions.col("STEP").cast(types.IntegerType()).alias('"step"'),
+                functions.col("VALUE").cast(types.DoubleType()).alias('"value"'),
+                functions.col("TIMESTAMP").alias('"timestamp"'),
+            )
+            .sort(functions.col('"name"').asc(), functions.col('"step"').asc())
+        )
+        return history
+
     @telemetry.send_api_usage_telemetry(project=telemetry.TelemetryProject.EXPERIMENT_TRACKING.value)
     def show_run_parameters_in_experiment(
         self,
         *,
         experiment_name: sql_identifier.SqlIdentifier,
-        run_name: Optional[sql_identifier.SqlIdentifier] = None,
-        like: Optional[str] = None,
+        run_name: sql_identifier.SqlIdentifier | None = None,
+        like: str | None = None,
     ) -> list[row.Row]:
         experiment_fqn = self.fully_qualified_object_name(self._database_name, self._schema_name, experiment_name)
         run_name_clause = f"RUN {run_name}" if run_name else ""

snowflake/ml/experiment/experiment_tracking.py

@@ -6,7 +6,7 @@ import traceback
 import warnings
 from collections.abc import Callable
 from types import TracebackType
-from typing import Any, Optional, Union
+from typing import Any, Optional
 from urllib.parse import quote
 
 from snowflake import snowpark
@@ -28,6 +28,7 @@ from snowflake.ml.experiment._entities import run_metadata
 from snowflake.ml.lineage import lineage_node
 from snowflake.ml.model import type_hints
 from snowflake.ml.utils import sql_client as sql_client_utils
+from snowflake.snowpark import functions
 
 DEFAULT_EXPERIMENT_NAME = sql_identifier.SqlIdentifier("DEFAULT")
 
@@ -48,8 +49,8 @@ class ExperimentTracking:
         self,
         session: snowpark.Session,
         *,
-        database_name: Optional[str] = None,
-        schema_name: Optional[str] = None,
+        database_name: str | None = None,
+        schema_name: str | None = None,
         capture_source_info: bool = True,
     ) -> None:
         """
@@ -116,11 +117,11 @@ class ExperimentTracking:
         self._session = session
 
         # The experiment in context
-        self._experiment: Optional[entities.Experiment] = None
+        self._experiment: entities.Experiment | None = None
         # The run in context
-        self._run: Optional[entities.Run] = None
+        self._run: entities.Run | None = None
         # The logging context used for patching stdout and stderr.
-        self._logging_context: Optional[experiment_logging.ExperimentLoggingContext] = None
+        self._logging_context: experiment_logging.ExperimentLoggingContext | None = None
         self._live_logging_enabled = False
 
         self._initialized = True
@@ -182,8 +183,8 @@ class ExperimentTracking:
     def set_experiment(
         self,
         experiment_name: str,
-        database_name: Optional[str] = None,
-        schema_name: Optional[str] = None,
+        database_name: str | None = None,
+        schema_name: str | None = None,
     ) -> entities.Experiment:
         """
         Set the experiment in context. Creates a new experiment if it doesn't exist.
@@ -228,8 +229,8 @@ class ExperimentTracking:
     def delete_experiment(
         self,
         experiment_name: str,
-        database_name: Optional[str] = None,
-        schema_name: Optional[str] = None,
+        database_name: str | None = None,
+        schema_name: str | None = None,
     ) -> None:
         """
         Delete an experiment.
@@ -270,7 +271,7 @@ class ExperimentTracking:
     @functools.wraps(registry.Registry.log_model)
     def log_model(
         self,
-        model: Union[type_hints.SupportedModelType, ml_model.ModelVersion],
+        model: type_hints.SupportedModelType | ml_model.ModelVersion,
         *,
         model_name: str,
         **kwargs: Any,
@@ -279,7 +280,7 @@ class ExperimentTracking:
         with experiment_info.ExperimentInfoPatcher(experiment_info=run._get_experiment_info()):
             return self._registry.log_model(model, model_name=model_name, **kwargs)
 
-    def list_model_versions(self, run_name: Optional[str] = None) -> list[ml_model.ModelVersion]:
+    def list_model_versions(self, run_name: str | None = None) -> list[ml_model.ModelVersion]:
         """
         List the model versions that were logged under a run.
 
@@ -319,7 +320,7 @@ class ExperimentTracking:
 
     def start_run(
         self,
-        run_name: Optional[str] = None,
+        run_name: str | None = None,
     ) -> entities.Run:
         """
         Start a new run. If a run name of an existing run is provided, resumes the run if it is running.
@@ -354,7 +355,7 @@ class ExperimentTracking:
                 return self._run
 
         run_name = sql_identifier.SqlIdentifier(run_name)
-        source_info_json: Optional[str] = None
+        source_info_json: str | None = None
         if self._capture_source_info:
             captured = source_info.SourceInfo.collect()
             if not captured.is_empty():
@@ -368,7 +369,7 @@ class ExperimentTracking:
         assert self._run is not None  # for mypy
         return self._run
 
-    def end_run(self, run_name: Optional[str] = None, status: Optional[str] = None) -> None:
+    def end_run(self, run_name: str | None = None, status: str | None = None) -> None:
         """
         End the current run if no run name is provided. Otherwise, the specified run is ended.
 
@@ -526,7 +527,7 @@ class ExperimentTracking:
     def log_artifact(
         self,
         local_path: str,
-        artifact_path: Optional[str] = None,
+        artifact_path: str | None = None,
     ) -> None:
         """
         Log an artifact or a directory of artifacts under the current run. If no run is active, this method will create
@@ -546,11 +547,12 @@ class ExperimentTracking:
                 file_path=file_path,
             )
 
-    def list_metrics(self, run_name: Optional[str] = None) -> snowpark.DataFrame:
+    def list_metrics(self, run_name: str | None = None) -> snowpark.DataFrame:
         """
         List metrics for runs within the current experiment.
 
         When a metric is logged at multiple steps, the returned value corresponds to the highest step.
+        Use ``get_metric_history`` to retrieve every logged step.
 
         The returned DataFrame has a ``run_name`` column (str) and one float column per distinct metric name.
         Runs that did not log a given metric have ``NULL`` for that column.
@@ -588,7 +590,52 @@ class ExperimentTracking:
 
         return sql_client.pivot_run_attributes(self._session, rows, run_names=run_names, cast_value=float)
 
-    def list_params(self, run_name: Optional[str] = None) -> snowpark.DataFrame:
+    def get_metric_history(
+        self,
+        run_name: str | None = None,
+        metric_name: str | None = None,
+    ) -> snowpark.DataFrame:
+        """Return the full history of metrics logged under a run as a Snowpark DataFrame.
+
+        Unlike ``list_metrics``, which collapses each metric to its highest step, this returns every
+        recorded point. The result has columns ``name``, ``step``, ``value``, and ``timestamp``,
+        ordered by name then step.
+
+        Filtering and aggregation are pushed down to Snowflake::
+
+            history = experiment.get_metric_history(run_name="RUN_A", metric_name="accuracy")
+            best = history.agg(functions.max_(functions.col('"value"'))).collect()[0][0]
+
+        Args:
+            run_name: Run to query. If None, uses the currently active run.
+            metric_name: Metric to filter on. If None, returns all metrics of the run.
+
+        Returns:
+            A Snowpark DataFrame. Use ``.to_pandas()`` for a pandas DataFrame or ``.collect()``
+            for a list of Row objects.
+
+        Raises:
+            RuntimeError: If no experiment is set, or if no run is active and ``run_name`` is None.
+        """
+        if not self._experiment:
+            raise RuntimeError("No experiment set. Please set an experiment before getting metric history.")
+
+        if run_name:
+            resolved_run_name = sql_identifier.SqlIdentifier(run_name)
+        elif self._run:
+            resolved_run_name = self._run.name
+        else:
+            raise RuntimeError("No run is active. Please provide a run_name or start a run.")
+
+        history = self._sql_client.get_run_metrics_history(
+            experiment_name=self._experiment.name,
+            run_name=resolved_run_name,
+        )
+        if metric_name is not None:
+            history = history.filter(functions.col('"name"') == metric_name)
+        return history
+
+    def list_params(self, run_name: str | None = None) -> snowpark.DataFrame:
         """
         List parameters for runs within the current experiment.
 
@@ -632,7 +679,7 @@ class ExperimentTracking:
     def list_artifacts(
         self,
         run_name: str,
-        artifact_path: Optional[str] = None,
+        artifact_path: str | None = None,
     ) -> list[artifact.ArtifactInfo]:
         """
         List artifacts for a given run within the current experiment.
@@ -660,8 +707,8 @@ class ExperimentTracking:
     def download_artifacts(
         self,
         run_name: str,
-        artifact_path: Optional[str] = None,
-        target_path: Optional[str] = None,
+        artifact_path: str | None = None,
+        target_path: str | None = None,
     ) -> None:
         """
         Download artifacts from a run to a local directory.
@@ -770,7 +817,7 @@ class ExperimentTracking:
 
     def _try_patch_ipython_showtraceback(
         self, stderr_logger: experiment_logging.ExperimentLogger
-    ) -> tuple[Any, Optional[Callable[..., None]]]:
+    ) -> tuple[Any, Callable[..., None] | None]:
         try:
             from IPython import get_ipython
 
@@ -780,7 +827,7 @@ class ExperimentTracking:
 
                 def _patched_showtraceback(
                     etype: type[BaseException],
-                    evalue: Optional[BaseException],
+                    evalue: BaseException | None,
                     stb: list[str],
                 ) -> None:
                     try:
@@ -804,8 +851,8 @@ class ExperimentTracking:
     def _try_log_exception(
         self,
         exc_type: type[BaseException],
-        exc_value: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_value: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         """Append a traceback to the stderr logger before unpatching.
 
@@ -844,7 +891,7 @@ class ExperimentTracking:
         assert self._experiment is not None and self._run is not None  # for mypy
         stdout_logger, stderr_logger, stdout_ctx, stderr_ctx = None, None, None, None  # for exception handling
         ip: Any = None
-        original_showtraceback: Optional[Callable[..., None]] = None
+        original_showtraceback: Callable[..., None] | None = None
         try:
             exp_id = self._sql_client.get_experiment_id(self._experiment.name)
             run_id = self._sql_client.get_run_id(

snowflake/ml/feature_store/feature_store.py

@@ -247,6 +247,100 @@ def _store_type_from_oft_show_row(row: Row) -> OnlineStoreType:
     return OnlineStoreType.HYBRID_TABLE
 
 
+# Setup-readiness columns on SHOW ONLINE FEATURE TABLES. When setup-readiness
+# information is not available for a table, these columns are **absent from the result
+# row entirely** rather than present-and-NULL. "Column missing" is therefore an
+# ordinary case and must never raise -- reads go through
+# ``_oft_show_row_optional_field`` rather than the strict ``extract_field`` used for
+# always-present columns such as ``target_lag``.
+_OFT_SETUP_STATUS_FIELDS = ("setup_status", "setup_error_msg", "setup_time")
+
+
+def _oft_show_row_optional_field(row: Row, field_name: str) -> tuple[bool, Any]:
+    """Read a possibly-absent SHOW ONLINE FEATURE TABLES column.
+
+    Same defensive shape as :func:`_store_type_from_oft_show_row`: try the
+    lowercase key, then the uppercase key, then report absence instead of
+    raising. Absence and a present NULL are reported distinctly because they
+    mean different things for the setup-readiness columns (no setup-readiness
+    information is available at all vs. the table is not Postgres-backed, so
+    readiness does not apply to it).
+
+    Args:
+        row: A Snowpark ``Row`` from SHOW ONLINE FEATURE TABLES.
+        field_name: Lowercase column name to read.
+
+    Returns:
+        ``(present, value)``. ``present`` is False only when the column is
+        absent under both casings, in which case ``value`` is ``None``.
+    """
+    if field_name in row:
+        return True, row[field_name]
+    upper = field_name.upper()
+    if upper in row:
+        return True, row[upper]
+    return False, None
+
+
+def _json_safe_oft_value(value: Any) -> Any:
+    """Coerce a SHOW column value into something ``json.dumps`` accepts.
+
+    Strings (``setup_status``, ``setup_error_msg``) and ``None`` pass through
+    untouched so statuses stay verbatim; ``setup_time`` arrives as a
+    ``datetime`` and is rendered ISO-8601.
+
+    Args:
+        value: Raw value read off the SHOW row.
+
+    Returns:
+        The value unchanged when it is already JSON-encodable as-is, its
+        ``isoformat()`` when it is date-like, otherwise ``str(value)``.
+    """
+    if value is None or isinstance(value, (str, bool, int, float)):
+        return value
+    isoformat = getattr(value, "isoformat", None)
+    if callable(isoformat):
+        return isoformat()
+    return str(value)
+
+
+def _oft_setup_status_display_fields(row: Row) -> dict[str, Any]:
+    """Extract the OFT setup-readiness fields from a SHOW row for display.
+
+    Keys are emitted verbatim (``setup_status``, ``setup_error_msg``,
+    ``setup_time``) and only for columns actually present on the row, so the
+    resulting dict is empty when the row does not carry those columns. A column
+    that is present but NULL is emitted as ``None`` -- for ``setup_status`` that
+    means the online feature table is not Postgres-backed, so setup readiness
+    does not apply to it.
+
+    ``setup_status`` values, passed through exactly as SHOW reports them:
+
+    - ``SETUP_READY``: setup concluded successfully, **or** nothing has ever been
+      reported for the table. These two are indistinguishable here, and in the
+      never-reported case a first report can still arrive later, so a
+      ``SETUP_READY`` may subsequently read ``SETUP_FAILED``.
+    - ``SETUP_NOTREADY``: setup has not concluded yet. This is **not** a failure
+      and it may persist. ``SETUP_FAILED`` is the failure signal.
+    - ``SETUP_FAILED``: setup failed; ``setup_error_msg`` carries the reason.
+
+    ``setup_error_msg`` is NULL for both non-failure statuses.
+
+    Args:
+        row: A Snowpark ``Row`` from SHOW ONLINE FEATURE TABLES.
+
+    Returns:
+        Mapping of present setup columns to JSON-encodable values; empty when
+        none of the columns are present on the row.
+    """
+    fields: dict[str, Any] = {}
+    for field_name in _OFT_SETUP_STATUS_FIELDS:
+        present, value = _oft_show_row_optional_field(row, field_name)
+        if present:
+            fields[field_name] = _json_safe_oft_value(value)
+    return fields
+
+
 # Module-local alias kept so existing callers continue to reference
 # ``_ENTITY_TAG_PREFIX``; the canonical value lives in
 # :data:`snowflake.ml.feature_store.spec.enums.ENTITY_TAG_PREFIX`.
@@ -2074,6 +2168,29 @@ class FeatureStore:
             ``append_only`` (bool). ``initialization_warehouse``, ``source_refs`` and
             ``backup_source`` (all string, nullable) are included only when ``verbose=True``.
 
+            The JSON in the ``online_config`` column may additionally carry the online feature
+            table's setup-readiness fields:
+
+            - ``setup_status``: one of ``SETUP_READY``, ``SETUP_NOTREADY`` or ``SETUP_FAILED``.
+            - ``setup_error_msg``: the failure reason when ``setup_status`` is ``SETUP_FAILED``;
+              null otherwise.
+            - ``setup_time``: ISO-8601 timestamp for when setup concluded.
+
+            These keys are absent from the JSON when no setup-readiness information is available
+            for the online feature table, and are present-but-null when the table is not
+            Postgres-backed, since readiness does not apply to it. Test for key presence rather
+            than assuming the keys exist.
+
+            ``SETUP_FAILED`` is the failure signal, and ``setup_error_msg`` carries the reason.
+            ``SETUP_NOTREADY`` means setup has not concluded yet; it is not a failure, and it may
+            persist.
+
+            Known limitation: ``SETUP_READY`` is reported both when setup concluded successfully
+            and when nothing has ever been reported for the table, and callers cannot distinguish
+            the two. In the second case a first report can still arrive later, so ``setup_status``
+            may change from ``SETUP_READY`` to ``SETUP_FAILED``. Treat ``SETUP_READY`` as "no
+            failure has been reported" rather than as confirmation that setup completed.
+
         Example::
 
             >>> fs = FeatureStore(...)
@@ -8235,6 +8352,10 @@ FROM {batch_cte_names[0]}{''.join(merge_join_parts)}
             version: Feature view version
             include_online_service_metadata: If True, includes additional Online Service metadata
                 (refresh_mode, scheduling_state) in the JSON for display purposes.
+                Also includes the setup-readiness fields (``setup_status``, ``setup_error_msg``,
+                ``setup_time``) when SHOW returns those columns; see
+                ``_oft_setup_status_display_fields`` for their meaning. They are omitted
+                entirely when SHOW does not return those columns.
                 If False, returns only OnlineConfig-compatible JSON.
 
         Returns:
@@ -8294,6 +8415,8 @@ FROM {batch_cte_names[0]}{''.join(merge_join_parts)}
 
                 display_data["refresh_mode"] = extract_field(oft_row, "refresh_mode")
                 display_data["scheduling_state"] = extract_field(oft_row, "scheduling_state")
+                # Setup-readiness columns: omitted entirely when SHOW does not return them.
+                display_data.update(_oft_setup_status_display_fields(oft_row))
 
                 return json.dumps(display_data)
             else: