snowflake-ml-python 1.33.0__tar.gz → 1.34.0__tar.gz

{snowflake_ml_python-1.33.0 → snowflake_ml_python-1.34.0}/CHANGELOG.md

@@ -1,6 +1,27 @@
 # Release History
 
-## 1.33.0
+## 1.34.0
+
+### New Features
+
+* Experiment Tracking: Added `list_params` and `list_metrics` methods to retrieve parameters and metrics
+  for runs within an experiment. Both methods return a Dataframe and accept an optional `run_name` argument
+  to filter to a specific run.
+
+### Bug Fixes
+
+* Feature Store: Fixed `generate_dataset()`/`generate_training_set()` SQL generation for Unicode and case-sensitive
+  identifiers (for example Japanese column names), ensuring columns are quoted exactly once and preventing SQL
+  compilation errors such as `unexpected '<column_name>'`.
+
+### Behavior Changes
+
+* Registry: `enable_explainability=True` is now allowed for SPCS-only and non-warehouse-runnable models. Previously
+  this raised a `ValueError`.
+
+### Deprecations
+
+## 1.33.0 (2026-03-31)
 
 ### New Features
 
@@ -124,6 +145,9 @@
 
 ### Behavior Changes
 
+* Dependencies: Removed `snowflake.core` as a runtime dependency. If you use `snowflake.core` (e.g.,
+  `TaskDag`, `Root`, `Task`), add `snowflake.core` explicitly to your dependencies.
+
 ### Deprecations
 
 ## 1.28.0 (2026-02-17)

{snowflake_ml_python-1.33.0/snowflake_ml_python.egg-info → snowflake_ml_python-1.34.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.33.0
+Version: 1.34.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,28 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
-## 1.33.0
+## 1.34.0
+
+### New Features
+
+* Experiment Tracking: Added `list_params` and `list_metrics` methods to retrieve parameters and metrics
+  for runs within an experiment. Both methods return a Dataframe and accept an optional `run_name` argument
+  to filter to a specific run.
+
+### Bug Fixes
+
+* Feature Store: Fixed `generate_dataset()`/`generate_training_set()` SQL generation for Unicode and case-sensitive
+  identifiers (for example Japanese column names), ensuring columns are quoted exactly once and preventing SQL
+  compilation errors such as `unexpected '<column_name>'`.
+
+### Behavior Changes
+
+* Registry: `enable_explainability=True` is now allowed for SPCS-only and non-warehouse-runnable models. Previously
+  this raised a `ValueError`.
+
+### Deprecations
+
+## 1.33.0 (2026-03-31)
 
 ### New Features
 
@@ -540,6 +561,9 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 ### Behavior Changes
 
+* Dependencies: Removed `snowflake.core` as a runtime dependency. If you use `snowflake.core` (e.g.,
+  `TaskDag`, `Root`, `Task`), add `snowflake.core` explicitly to your dependencies.
+
 ### Deprecations
 
 ## 1.28.0 (2026-02-17)

{snowflake_ml_python-1.33.0 → snowflake_ml_python-1.34.0}/snowflake/ml/_internal/platform_capabilities.py

@@ -1,7 +1,7 @@
 import json
 import logging
 from contextlib import contextmanager
-from typing import Any, Optional
+from typing import Any, Iterator, Optional
 
 from packaging import version
 
@@ -57,13 +57,11 @@ class PlatformCapabilities:
     def clear_mock_features(cls) -> None:
         cls._mock_features = None
 
-    # For contextmanager, we need to have return type Iterator[Never]. However, Never type is introduced only in
-    # Python 3.11. So, we are ignoring the type for this method.
     _dummy_features: dict[str, Any] = {"dummy": "dummy"}
 
-    @classmethod  # type: ignore[arg-type]
+    @classmethod
     @contextmanager
-    def mock_features(cls, features: dict[str, Any] = _dummy_features) -> None:  # type: ignore[misc]
+    def mock_features(cls, features: dict[str, Any] = _dummy_features) -> Iterator[None]:
         logger.debug(f"Setting mock features: {features}")
         cls.set_mock_features(features)
         try:

{snowflake_ml_python-1.33.0 → snowflake_ml_python-1.34.0}/snowflake/ml/experiment/_client/experiment_tracking_sql_client.py

@@ -1,16 +1,62 @@
-from typing import Optional
+from typing import Any, Optional
 
 from snowflake.ml._internal import telemetry
 from snowflake.ml._internal.utils import query_result_checker, sql_identifier
 from snowflake.ml.experiment._client import artifact
 from snowflake.ml.model._client.sql import _base
 from snowflake.ml.utils import sql_client
-from snowflake.snowpark import file_operation, row, session
+from snowflake.snowpark import dataframe, file_operation, row, session, types
 
 RUN_NAME_COL_NAME = "name"
 RUN_METADATA_COL_NAME = "metadata"
 
 
+def pivot_run_attributes(
+    sp_session: session.Session,
+    rows: list[row.Row],
+    run_names: list[str],
+    cast_value: Optional[type] = None,
+) -> dataframe.DataFrame:
+    """Pivot SHOW RUN METRICS/PARAMETERS rows into one row per run.
+
+    Each row is expected to have "run_name", "name", and "value" keys.
+    Returns a Snowpark DataFrame with a "run_name" column and one column per distinct
+    attribute name (sorted alphabetically). Runs present in ``run_names`` but absent
+    from ``rows`` appear with all-NULL attribute columns.
+
+    Args:
+        sp_session: Snowpark session used to create the result DataFrame.
+        rows: Collected rows from a SHOW RUN METRICS/PARAMETERS command.
+        run_names: Exhaustive list of run names (from SHOW RUNS) to include in the output.
+        cast_value: If provided, cast each value with this callable (e.g. ``float`` for metrics).
+                    Values that fail to cast are set to ``None``.
+
+    Returns:
+        A Snowpark DataFrame with a "run_name" column and one column per distinct attribute name.
+    """
+    pivoted: dict[str, dict[str, Any]] = {name: {} for name in run_names}
+    attr_names: set[str] = set()
+    for r in rows:
+        d = r.as_dict()
+        value = d["value"]
+        if cast_value is not None:
+            try:
+                value = cast_value(value)
+            except (ValueError, TypeError):
+                value = None
+        pivoted.setdefault(d["run_name"], {})[d["name"]] = value
+        attr_names.add(d["name"])
+
+    col_order = sorted(attr_names)
+    data = [[run_name] + [attrs.get(c) for c in col_order] for run_name, attrs in pivoted.items()]
+    value_type = types.DoubleType() if cast_value is float else types.StringType()
+    schema = types.StructType(
+        [types.StructField('"run_name"', types.StringType())]
+        + [types.StructField(f'"{c}"', value_type) for c in col_order]
+    )
+    return sp_session.create_dataframe(data, schema=schema)
+
+
 class ExperimentTrackingSQLClient(_base._BaseSQLClient):
     def __init__(
         self,

{snowflake_ml_python-1.33.0 → snowflake_ml_python-1.34.0}/snowflake/ml/experiment/experiment_tracking.py

@@ -478,6 +478,89 @@ class ExperimentTracking:
                 file_path=file_path,
             )
 
+    def list_metrics(self, run_name: Optional[str] = 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.
+
+        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.
+
+        Example output::
+
+              run_name  accuracy  loss    f1
+            0 RUN_1     0.95      0.05    0.90
+            1 RUN_2     0.90      0.10    NULL
+
+        Args:
+            run_name: Name of the run to list metrics from. If None, lists metrics for all runs in the current
+                experiment.
+
+        Returns:
+            A Snowpark DataFrame (one row per run). Use ``.to_pandas()`` for a pandas DataFrame or
+            ``.collect()`` for a list of Row objects.
+
+        Raises:
+            RuntimeError: If no experiment is currently set.
+        """
+        if not self._experiment:
+            raise RuntimeError("No experiment set. Please use the `set_experiment` method before listing metrics.")
+
+        if run_name:
+            run_names = [run_name]
+        else:
+            runs = self._sql_client.show_runs_in_experiment(experiment_name=self._experiment.name)
+            run_names = [r[sql_client.RUN_NAME_COL_NAME] for r in runs]
+
+        rows = self._sql_client.show_run_metrics_in_experiment(
+            experiment_name=self._experiment.name,
+            run_name=sql_identifier.SqlIdentifier(run_name) if run_name else None,
+        )
+
+        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:
+        """
+        List parameters for runs within the current experiment.
+
+        The returned DataFrame has a ``run_name`` column (str) and one string column per distinct parameter name.
+        Use ``.cast()`` for numeric comparisons on parameter values. Runs that did not log a given parameter
+        have ``NULL`` for that column.
+
+        Example output::
+
+              run_name  learning_rate  batch_size  optimizer
+            0 RUN_1     0.01           32          adam
+            1 RUN_2     0.02           64          NULL
+
+        Args:
+            run_name: Name of the run to list parameters from. If None, lists parameters for all runs in the current
+                experiment.
+
+        Returns:
+            A Snowpark DataFrame (one row per run). Use ``.to_pandas()`` for a pandas DataFrame or
+            ``.collect()`` for a list of Row objects.
+
+        Raises:
+            RuntimeError: If no experiment is currently set.
+        """
+        if not self._experiment:
+            raise RuntimeError("No experiment set. Please use the `set_experiment` method before listing parameters.")
+
+        if run_name:
+            run_names = [run_name]
+        else:
+            runs = self._sql_client.show_runs_in_experiment(experiment_name=self._experiment.name)
+            run_names = [r[sql_client.RUN_NAME_COL_NAME] for r in runs]
+
+        rows = self._sql_client.show_run_parameters_in_experiment(
+            experiment_name=self._experiment.name,
+            run_name=sql_identifier.SqlIdentifier(run_name) if run_name else None,
+        )
+
+        return sql_client.pivot_run_attributes(self._session, rows, run_names=run_names)
+
     def list_artifacts(
         self,
         run_name: str,
@@ -599,7 +682,6 @@ class ExperimentTracking:
         scheme: str = "https",
         host: str = "app.snowflake.com",
     ) -> None:
-
         experiment_url = (
             f"{scheme}://{host}/_deeplink/#/experiments"
             f"/databases/{quote(str(self._database_name))}"

{snowflake_ml_python-1.33.0 → snowflake_ml_python-1.34.0}/snowflake/ml/feature_store/__init__.py

@@ -5,6 +5,7 @@ from snowflake.ml._internal import init_utils
 from .access_manager import setup_feature_store
 from .feature import Feature
 from .feature_view import RollupConfig
+from .stream_config import StreamConfig
 from .stream_source import StreamSource
 
 pkg_dir = os.path.dirname(__file__)
@@ -17,5 +18,6 @@ __all__ = list(exportable_classes.keys()) + [
     "setup_feature_store",
     "Feature",
     "RollupConfig",
+    "StreamConfig",
     "StreamSource",
 ]

{snowflake_ml_python-1.33.0 → snowflake_ml_python-1.34.0}/snowflake/ml/feature_store/aggregation.py

@@ -6,12 +6,18 @@ that are computed using a tile-based approach for efficiency and correctness.
 
 from __future__ import annotations
 
-import re
 from dataclasses import dataclass, field
 from enum import Enum
 from typing import Any
 
 from snowflake.ml._internal.utils.sql_identifier import SqlIdentifier
+from snowflake.ml.feature_store.interval_utils import (  # noqa: F401 - re-export
+    LIFETIME_WINDOW as LIFETIME_WINDOW,
+    format_interval_for_snowflake as format_interval_for_snowflake,
+    interval_to_seconds as interval_to_seconds,
+    is_lifetime_window as is_lifetime_window,
+    parse_interval as parse_interval,
+)
 
 
 class AggregationType(Enum):
@@ -76,127 +82,11 @@ class AggregationType(Enum):
         )
 
 
-# Special window value for lifetime aggregations
-LIFETIME_WINDOW = "lifetime"
-
 # Internal column name prefixes used in tile tables.
 # WARNING: Changing these will break existing registered tiled feature views.
 _PARTIAL_COL_PREFIX = "_PARTIAL_"
 _CUMULATIVE_COL_PREFIX = "_CUM_"
 
-# Regex pattern for interval parsing: "1h", "24 hours", "30 minutes", etc.
-_INTERVAL_PATTERN = re.compile(
-    r"^\s*(\d+)\s*(s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours|d|day|days)\s*$",
-    re.IGNORECASE,
-)
-
-# Mapping of interval unit aliases to canonical Snowflake units
-_INTERVAL_UNIT_MAP = {
-    "s": "SECOND",
-    "sec": "SECOND",
-    "secs": "SECOND",
-    "second": "SECOND",
-    "seconds": "SECOND",
-    "m": "MINUTE",
-    "min": "MINUTE",
-    "mins": "MINUTE",
-    "minute": "MINUTE",
-    "minutes": "MINUTE",
-    "h": "HOUR",
-    "hr": "HOUR",
-    "hrs": "HOUR",
-    "hour": "HOUR",
-    "hours": "HOUR",
-    "d": "DAY",
-    "day": "DAY",
-    "days": "DAY",
-}
-
-# Seconds per unit for calculating window sizes
-_SECONDS_PER_UNIT = {
-    "SECOND": 1,
-    "MINUTE": 60,
-    "HOUR": 3600,
-    "DAY": 86400,
-}
-
-
-def is_lifetime_window(window: str) -> bool:
-    """Check if a window string represents a lifetime aggregation.
-
-    Args:
-        window: The window string to check.
-
-    Returns:
-        True if the window is "lifetime", False otherwise.
-    """
-    return window.lower().strip() == LIFETIME_WINDOW
-
-
-def parse_interval(interval: str) -> tuple[int, str]:
-    """Parse an interval string into (value, unit) tuple.
-
-    Args:
-        interval: Interval string like "1h", "24 hours", "30 minutes".
-            Note: "lifetime" is NOT a valid interval - use is_lifetime_window() first.
-
-    Returns:
-        Tuple of (numeric_value, snowflake_unit) e.g. (1, "HOUR").
-
-    Raises:
-        ValueError: If the interval format is invalid.
-    """
-    if is_lifetime_window(interval):
-        raise ValueError(
-            f"'{interval}' is not a numeric interval. " f"Use is_lifetime_window() to check for lifetime windows."
-        )
-
-    match = _INTERVAL_PATTERN.match(interval)
-    if not match:
-        raise ValueError(
-            f"Invalid interval format: '{interval}'. "
-            f"Expected format: '<number> <unit>' where unit is one of: "
-            f"seconds, minutes, hours, days (or abbreviations s, m, h, d)"
-        )
-
-    value = int(match.group(1))
-    unit_str = match.group(2).lower()
-    unit = _INTERVAL_UNIT_MAP[unit_str]
-
-    if value <= 0:
-        raise ValueError(f"Interval value must be positive, got: {value}")
-
-    return value, unit
-
-
-def interval_to_seconds(interval: str) -> int:
-    """Convert an interval string to total seconds.
-
-    Args:
-        interval: Interval string like "1h", "24 hours".
-            Note: "lifetime" is NOT supported - returns -1 as sentinel.
-
-    Returns:
-        Total seconds represented by the interval, or -1 for lifetime.
-    """
-    if is_lifetime_window(interval):
-        return -1  # Sentinel value for lifetime
-    value, unit = parse_interval(interval)
-    return value * _SECONDS_PER_UNIT[unit]
-
-
-def format_interval_for_snowflake(interval: str) -> str:
-    """Format an interval string for use in Snowflake SQL.
-
-    Args:
-        interval: Interval string like "1h", "24 hours".
-
-    Returns:
-        Formatted string like "HOUR" or "DAY" for use with DATEADD/TIME_SLICE.
-    """
-    _, unit = parse_interval(interval)
-    return unit
-
 
 @dataclass(frozen=True)
 class AggregationSpec:
@@ -232,9 +122,13 @@ class AggregationSpec:
         # Validate window format (allow "lifetime" as special case)
         if not is_lifetime_window(self.window):
             try:
-                interval_to_seconds(self.window)
+                window_seconds = interval_to_seconds(self.window)
             except ValueError as e:
                 raise ValueError(f"Invalid window for aggregation '{self.output_column}': {e}") from e
+            if window_seconds <= 0:
+                raise ValueError(
+                    f"Aggregation window must be positive for '{self.output_column}', got: '{self.window}'"
+                )
 
         # Validate offset format (if not "0")
         # Note: offset is not allowed with lifetime windows