snowflake-ml-python 1.18.0__tar.gz → 1.19.0__tar.gz

{snowflake_ml_python-1.18.0 → snowflake_ml_python-1.19.0}/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Release History
 
+## 1.19.0
+
+### Bug Fixes
+
+* Experiment Tracking (PrPr): No longer throw an exception in `list_artifacts` when run does not have artifacts.
+* Registry: Fix `get_version_by_alias`: now requires an exact match of snowflake identifier.
+
+### Behavior Changes
+
+### New Features
+
+* Online feature serving in Feature Store is in public preview.
+* Experiment Tracking (`snowflake.ml.experiment`) is in public preview.
+
+### Deprecations
+
 ## 1.18.0
 
 ### Bug Fixes

{snowflake_ml_python-1.18.0/snowflake_ml_python.egg-info → snowflake_ml_python-1.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.18.0
+Version: 1.19.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: 
@@ -253,7 +253,7 @@ Requires-Dist: s3fs<2026,>=2024.6.1
 Requires-Dist: scikit-learn<1.8
 Requires-Dist: scipy<2,>=1.9
 Requires-Dist: shap<1,>=0.46.0
-Requires-Dist: snowflake-connector-python[pandas]<4,>=3.17.0
+Requires-Dist: snowflake-connector-python[pandas]<4,>=3.17.3
 Requires-Dist: snowflake-snowpark-python!=1.26.0,<2,>=1.17.0
 Requires-Dist: snowflake.core<2,>=1.0.2
 Requires-Dist: sqlparse<1,>=0.4
@@ -285,6 +285,14 @@ Requires-Dist: tensorflow<3,>=2.17.0; extra == "keras"
 Requires-Dist: torch<3,>=2.0.1; extra == "keras"
 Provides-Extra: lightgbm
 Requires-Dist: lightgbm<5,>=4.1.0; extra == "lightgbm"
+Provides-Extra: llm
+Requires-Dist: mlflow<3,>=2.16.0; extra == "llm"
+Requires-Dist: sentence-transformers<4,>=2.7.0; extra == "llm"
+Requires-Dist: sentencepiece<0.2.0,>=0.1.95; extra == "llm"
+Requires-Dist: tokenizers<1,>=0.15.1; extra == "llm"
+Requires-Dist: torch<3,>=2.0.1; extra == "llm"
+Requires-Dist: torchdata<1,>=0.4; extra == "llm"
+Requires-Dist: transformers!=4.51.3,<5,>=4.39.3; extra == "llm"
 Provides-Extra: mlflow
 Requires-Dist: mlflow<3,>=2.16.0; extra == "mlflow"
 Provides-Extra: prophet
@@ -299,9 +307,7 @@ Requires-Dist: torchdata<1,>=0.4; extra == "torch"
 Provides-Extra: transformers
 Requires-Dist: sentence-transformers<4,>=2.7.0; extra == "transformers"
 Requires-Dist: sentencepiece<0.2.0,>=0.1.95; extra == "transformers"
-Requires-Dist: tokenizers<1,>=0.15.1; extra == "transformers"
 Requires-Dist: torch<3,>=2.0.1; extra == "transformers"
-Requires-Dist: transformers!=4.51.3,<5,>=4.39.3; extra == "transformers"
 Dynamic: license-file
 
 # Snowflake ML Python
@@ -409,6 +415,22 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
+## 1.19.0
+
+### Bug Fixes
+
+* Experiment Tracking (PrPr): No longer throw an exception in `list_artifacts` when run does not have artifacts.
+* Registry: Fix `get_version_by_alias`: now requires an exact match of snowflake identifier.
+
+### Behavior Changes
+
+### New Features
+
+* Online feature serving in Feature Store is in public preview.
+* Experiment Tracking (`snowflake.ml.experiment`) is in public preview.
+
+### Deprecations
+
 ## 1.18.0
 
 ### Bug Fixes

{snowflake_ml_python-1.18.0 → snowflake_ml_python-1.19.0}/pyproject.toml

@@ -8,7 +8,7 @@ description = "The machine learning client library that is used for interacting
 classifiers = [ "Development Status :: 5 - Production/Stable", "Environment :: Console", "Environment :: Other Environment", "Intended Audience :: Developers", "Intended Audience :: Education", "Intended Audience :: Information Technology", "Intended Audience :: System Administrators", "License :: OSI Approved :: Apache Software License", "Operating System :: OS Independent", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Topic :: Database", "Topic :: Software Development", "Topic :: Software Development :: Libraries", "Topic :: Software Development :: Libraries :: Application Frameworks", "Topic :: Software Development :: Libraries :: Python Modules", "Topic :: Scientific/Engineering :: Information Analysis",]
 requires-python = ">=3.9, <3.13"
 dynamic = [ "version", "readme",]
-dependencies = [ "anyio>=3.5.0,<5", "cachetools>=3.1.1,<6", "cloudpickle>=2.0.0", "cryptography", "fsspec[http]>=2024.6.1,<2026", "importlib_resources>=6.1.1, <7", "numpy>=1.23,<3", "packaging>=20.9,<25", "pandas>=2.1.4,<3", "platformdirs<5", "pyarrow<19.0.0", "pydantic>=2.8.2, <3", "pyjwt>=2.0.0, <3", "pytimeparse>=1.1.8,<2", "pyyaml>=6.0,<7", "retrying>=1.3.3,<2", "s3fs>=2024.6.1,<2026", "scikit-learn<1.8", "scipy>=1.9,<2", "shap>=0.46.0,<1", "snowflake-connector-python[pandas]>=3.17.0,<4", "snowflake-snowpark-python>=1.17.0,<2,!=1.26.0", "snowflake.core>=1.0.2,<2", "sqlparse>=0.4,<1", "tqdm<5", "typing-extensions>=4.1.0,<5", "xgboost<4",]
+dependencies = [ "anyio>=3.5.0,<5", "cachetools>=3.1.1,<6", "cloudpickle>=2.0.0", "cryptography", "fsspec[http]>=2024.6.1,<2026", "importlib_resources>=6.1.1, <7", "numpy>=1.23,<3", "packaging>=20.9,<25", "pandas>=2.1.4,<3", "platformdirs<5", "pyarrow<19.0.0", "pydantic>=2.8.2, <3", "pyjwt>=2.0.0, <3", "pytimeparse>=1.1.8,<2", "pyyaml>=6.0,<7", "retrying>=1.3.3,<2", "s3fs>=2024.6.1,<2026", "scikit-learn<1.8", "scipy>=1.9,<2", "shap>=0.46.0,<1", "snowflake-connector-python[pandas]>=3.17.3,<4", "snowflake-snowpark-python>=1.17.0,<2,!=1.26.0", "snowflake.core>=1.0.2,<2", "sqlparse>=0.4,<1", "tqdm<5", "typing-extensions>=4.1.0,<5", "xgboost<4",]
 [[project.authors]]
 name = "Snowflake, Inc"
 email = "support@snowflake.com"
@@ -29,12 +29,13 @@ altair = [ "altair>=5,<6",]
 catboost = [ "catboost>=1.2.0, <2",]
 keras = [ "keras>=2.0.0,<4", "tensorflow>=2.17.0,<3", "torch>=2.0.1,<3",]
 lightgbm = [ "lightgbm>=4.1.0, <5",]
+llm = [ "mlflow>=2.16.0, <3", "sentence-transformers>=2.7.0,<4", "sentencepiece>=0.1.95,<0.2.0", "tokenizers>=0.15.1,<1", "torch>=2.0.1,<3", "torchdata>=0.4,<1", "transformers>=4.39.3,<5,!=4.51.3",]
 mlflow = [ "mlflow>=2.16.0, <3",]
 prophet = [ "prophet>=1.1.0, <2",]
 streamlit = [ "streamlit>=1.30.0,<2",]
 tensorflow = [ "tensorflow>=2.17.0,<3",]
 torch = [ "torch>=2.0.1,<3", "torchdata>=0.4,<1",]
-transformers = [ "sentence-transformers>=2.7.0,<4", "sentencepiece>=0.1.95,<0.2.0", "tokenizers>=0.15.1,<1", "torch>=2.0.1,<3", "transformers>=4.39.3,<5,!=4.51.3",]
+transformers = [ "sentence-transformers>=2.7.0,<4", "sentencepiece>=0.1.95,<0.2.0", "torch>=2.0.1,<3",]
 
 [tool.setuptools.package-data]
 "*" = [ "*",]

{snowflake_ml_python-1.18.0 → snowflake_ml_python-1.19.0}/snowflake/ml/experiment/_client/experiment_tracking_sql_client.py

@@ -128,13 +128,7 @@ class ExperimentTrackingSQLClient(_base._BaseSQLClient):
         run_name: sql_identifier.SqlIdentifier,
         artifact_path: str,
     ) -> list[artifact.ArtifactInfo]:
-        results = (
-            query_result_checker.SqlResultValidator(
-                self._session, f"LIST {self._build_snow_uri(experiment_name, run_name, artifact_path)}"
-            )
-            .has_dimensions(expected_cols=4)
-            .validate()
-        )
+        results = self._session.sql(f"LIST {self._build_snow_uri(experiment_name, run_name, artifact_path)}").collect()
         return [
             artifact.ArtifactInfo(
                 name=str(result.name).removeprefix(f"/versions/{run_name}/"),

{snowflake_ml_python-1.18.0 → snowflake_ml_python-1.19.0}/snowflake/ml/experiment/experiment_tracking.py

@@ -1,13 +1,13 @@
 import functools
 import json
 import sys
-from typing import Any, Callable, Concatenate, Optional, ParamSpec, TypeVar, Union
+from typing import Any, Optional, Union
 from urllib.parse import quote
 
 from snowflake import snowpark
 from snowflake.ml import model as ml_model, registry
 from snowflake.ml._internal.human_readable_id import hrid_generator
-from snowflake.ml._internal.utils import mixins, sql_identifier
+from snowflake.ml._internal.utils import connection_params, sql_identifier
 from snowflake.ml.experiment import (
     _entities as entities,
     _experiment_info as experiment_info,
@@ -21,34 +21,12 @@ from snowflake.ml.utils import sql_client as sql_client_utils
 
 DEFAULT_EXPERIMENT_NAME = sql_identifier.SqlIdentifier("DEFAULT")
 
-P = ParamSpec("P")
-T = TypeVar("T")
 
-
-def _restore_session(
-    func: Callable[Concatenate["ExperimentTracking", P], T],
-) -> Callable[Concatenate["ExperimentTracking", P], T]:
-    @functools.wraps(func)
-    def wrapper(self: "ExperimentTracking", /, *args: P.args, **kwargs: P.kwargs) -> T:
-        if self._session is None:
-            if self._session_state is None:
-                raise RuntimeError(
-                    f"Session is not set before calling {func.__name__}, and there is no session state to restore from"
-                )
-            self._set_session(self._session_state)
-            if self._session is None:
-                raise RuntimeError(f"Failed to restore session before calling {func.__name__}")
-        return func(self, *args, **kwargs)
-
-    return wrapper
-
-
-class ExperimentTracking(mixins.SerializableSessionMixin):
+class ExperimentTracking:
     """
     Class to manage experiments in Snowflake.
     """
 
-    @snowpark._internal.utils.private_preview(version="1.9.1")
     def __init__(
         self,
         session: snowpark.Session,
@@ -93,10 +71,7 @@ class ExperimentTracking(mixins.SerializableSessionMixin):
             database_name=self._database_name,
             schema_name=self._schema_name,
         )
-        self._session: Optional[snowpark.Session] = session
-        # Used to store information about the session if the session could not be restored during unpickling
-        # _session_state is None if and only if _session is not None
-        self._session_state: Optional[mixins._SessionState] = None
+        self._session = session
 
         # The experiment in context
         self._experiment: Optional[entities.Experiment] = None
@@ -104,35 +79,40 @@ class ExperimentTracking(mixins.SerializableSessionMixin):
         self._run: Optional[entities.Run] = None
 
     def __getstate__(self) -> dict[str, Any]:
-        state = super().__getstate__()
+        parent_state = (
+            super().__getstate__()  # type: ignore[misc] # object.__getstate__ appears in 3.11
+            if hasattr(super(), "__getstate__")
+            else self.__dict__
+        )
+        state = dict(parent_state)  # Create a copy so we can safely modify the state
+
         # Remove unpicklable attributes
+        state["_session"] = None
         state["_sql_client"] = None
         state["_registry"] = None
         return state
 
-    def _set_session(self, session_state: mixins._SessionState) -> None:
-        try:
-            super()._set_session(session_state)
-            assert self._session is not None
-        except (snowpark.exceptions.SnowparkSessionException, AssertionError):
-            # If session was not set, store the session state
-            self._session = None
-            self._session_state = session_state
+    def __setstate__(self, state: dict[str, Any]) -> None:
+        if hasattr(super(), "__setstate__"):
+            super().__setstate__(state)  # type: ignore[misc]
         else:
-            # If session was set, clear the session state, and reinitialize the SQL client and registry
-            self._session_state = None
-            self._sql_client = sql_client.ExperimentTrackingSQLClient(
-                session=self._session,
-                database_name=self._database_name,
-                schema_name=self._schema_name,
-            )
-            self._registry = registry.Registry(
-                session=self._session,
-                database_name=self._database_name,
-                schema_name=self._schema_name,
-            )
+            self.__dict__.update(state)
+
+        # Restore unpicklable attributes
+        options: dict[str, Any] = connection_params.SnowflakeLoginOptions()
+        options["client_session_keep_alive"] = True  # Needed for long-running training jobs
+        self._session = snowpark.Session.builder.configs(options).getOrCreate()
+        self._sql_client = sql_client.ExperimentTrackingSQLClient(
+            session=self._session,
+            database_name=self._database_name,
+            schema_name=self._schema_name,
+        )
+        self._registry = registry.Registry(
+            session=self._session,
+            database_name=self._database_name,
+            schema_name=self._schema_name,
+        )
 
-    @_restore_session
     def set_experiment(
         self,
         experiment_name: str,
@@ -157,7 +137,6 @@ class ExperimentTracking(mixins.SerializableSessionMixin):
         self._run = None
         return self._experiment
 
-    @_restore_session
     def delete_experiment(
         self,
         experiment_name: str,
@@ -174,10 +153,8 @@ class ExperimentTracking(mixins.SerializableSessionMixin):
             self._run = None
 
     @functools.wraps(registry.Registry.log_model)
-    @_restore_session
     def log_model(
         self,
-        /,  # self needs to be a positional argument to stop mypy from complaining
         model: Union[type_hints.SupportedModelType, ml_model.ModelVersion],
         *,
         model_name: str,
@@ -187,7 +164,6 @@ class ExperimentTracking(mixins.SerializableSessionMixin):
         with experiment_info.ExperimentInfoPatcher(experiment_info=run._get_experiment_info()):
             return self._registry.log_model(model, model_name=model_name, **kwargs)
 
-    @_restore_session
     def start_run(
         self,
         run_name: Optional[str] = None,
@@ -229,7 +205,6 @@ class ExperimentTracking(mixins.SerializableSessionMixin):
         self._run = entities.Run(experiment_tracking=self, experiment_name=experiment.name, run_name=run_name)
         return self._run
 
-    @_restore_session
     def end_run(self, run_name: Optional[str] = None) -> None:
         """
         End the current run if no run name is provided. Otherwise, the specified run is ended.
@@ -259,7 +234,6 @@ class ExperimentTracking(mixins.SerializableSessionMixin):
             self._run = None
         self._print_urls(experiment_name=experiment_name, run_name=run_name)
 
-    @_restore_session
     def delete_run(
         self,
         run_name: str,
@@ -298,7 +272,6 @@ class ExperimentTracking(mixins.SerializableSessionMixin):
         """
         self.log_metrics(metrics={key: value}, step=step)
 
-    @_restore_session
     def log_metrics(
         self,
         metrics: dict[str, float],
@@ -335,7 +308,6 @@ class ExperimentTracking(mixins.SerializableSessionMixin):
         """
         self.log_params({key: value})
 
-    @_restore_session
     def log_params(
         self,
         params: dict[str, Any],
@@ -357,7 +329,6 @@ class ExperimentTracking(mixins.SerializableSessionMixin):
             params=json.dumps([param.to_dict() for param in params_list]),
         )
 
-    @_restore_session
     def log_artifact(
         self,
         local_path: str,
@@ -381,7 +352,6 @@ class ExperimentTracking(mixins.SerializableSessionMixin):
                 file_path=file_path,
             )
 
-    @_restore_session
     def list_artifacts(
         self,
         run_name: str,
@@ -410,7 +380,6 @@ class ExperimentTracking(mixins.SerializableSessionMixin):
             artifact_path=artifact_path or "",
         )
 
-    @_restore_session
     def download_artifacts(
         self,
         run_name: str,
@@ -452,7 +421,6 @@ class ExperimentTracking(mixins.SerializableSessionMixin):
             return self._run
         return self.start_run()
 
-    @_restore_session
     def _generate_run_name(self, experiment: entities.Experiment) -> sql_identifier.SqlIdentifier:
         generator = hrid_generator.HRID16()
         existing_runs = self._sql_client.show_runs_in_experiment(experiment_name=experiment.name)

{snowflake_ml_python-1.18.0 → snowflake_ml_python-1.19.0}/snowflake/ml/feature_store/feature_store.py

@@ -474,8 +474,8 @@ class FeatureStore:
             feature_view: FeatureView instance to materialize.
             version: version of the registered FeatureView.
                 NOTE: Version only accepts letters, numbers and underscore. Also version will be capitalized.
-            block: Specify whether the FeatureView backend materialization should be blocking or not. If blocking then
-                the API will wait until the initial FeatureView data is generated. Default to true.
+            block: Deprecated. To make the initial refresh asynchronous, set the `initialize`
+                argument on the `FeatureView` to `"ON_SCHEDULE"`. Default is true.
             overwrite: Overwrite the existing FeatureView with same version. This is the same as dropping the
                 FeatureView first then recreate. NOTE: there will be backfill cost associated if the FeatureView is
                 being continuously maintained.
@@ -521,6 +521,15 @@ class FeatureStore:
         """
         version = FeatureViewVersion(version)
 
+        if block is False:
+            raise snowml_exceptions.SnowflakeMLException(
+                error_code=error_codes.INVALID_ARGUMENT,
+                original_exception=ValueError(
+                    'block=False is deprecated. Use FeatureView(..., initialize="ON_SCHEDULE") '
+                    "for async initial refresh."
+                ),
+            )
+
         if feature_view.status != FeatureViewStatus.DRAFT:
             try:
                 return self._get_feature_view_if_exists(feature_view.name, str(version))
@@ -2094,26 +2103,48 @@ class FeatureStore:
     def _plan_online_update(
         self, feature_view: FeatureView, online_config: Optional[fv_mod.OnlineConfig]
     ) -> _OnlineUpdateStrategy:
-        """Plan online update operations based on current state and target config."""
+        """Plan online update operations based on current state and target config.
+
+        Handles three cases:
+        - enable is None: Preserve current online state, only update if currently online
+        - enable is True: Enable online storage (create if needed, update if exists)
+        - enable is False: Disable online storage (drop if exists)
+
+        Args:
+            feature_view: The FeatureView object to check current online state.
+            online_config: The OnlineConfig with target enable and lag settings.
+
+        Returns:
+            _OnlineUpdateStrategy containing operations and their rollbacks.
+        """
         if online_config is None:
             return self._OnlineUpdateStrategy([], [], None)
 
         current_online = feature_view.online
         target_online = online_config.enable
 
-        # Enable online (create table)
+        # Case 1: enable is None - preserve current online state, only update if currently online
+        if target_online is None:
+            if current_online and (online_config.target_lag is not None):
+                # Online is currently enabled and user wants to update lag
+                return self._plan_online_update_existing(feature_view, online_config)
+            else:
+                # No online changes needed (either not online, or lag not specified)
+                return self._OnlineUpdateStrategy([], [], None)
+
+        # Case 2: Enable online (create table)
         if target_online and not current_online:
             return self._plan_online_enable(feature_view, online_config)
 
-        # Disable online (drop table)
+        # Case 3: Disable online (drop table)
         elif not target_online and current_online:
             return self._plan_online_disable(feature_view)
 
-        # Update existing online table
+        # Case 4: Update existing online table
         elif target_online and current_online:
             return self._plan_online_update_existing(feature_view, online_config)
 
-        # No change needed
+        # Case 5: No change needed
         else:
             return self._OnlineUpdateStrategy([], [], online_config)
 
@@ -2621,9 +2652,10 @@ class FeatureStore:
 
         This method supports feature views with different join keys by:
         1. Creating a spine CTE that includes all possible join keys
-        2. Performing ASOF JOINs for each feature view using only its specific join keys when timestamp columns exist
-        3. Performing LEFT JOINs for each feature view when timestamp columns are missing
-        4. Combining results using INNER JOINs on each feature view's specific join keys
+        2. For each feature view, creating a deduplicated spine subquery with only that FV's join keys
+        3. Performing ASOF JOINs on the deduplicated spine when timestamp columns exist
+        4. Performing LEFT JOINs on the deduplicated spine when timestamp columns are missing
+        5. Combining results by LEFT JOINing each FV CTE back to the original SPINE
 
         Args:
             feature_views: A list of feature views to join.
@@ -2633,9 +2665,6 @@ class FeatureStore:
             include_feature_view_timestamp_col: Whether to include the timestamp column of
                 the feature view in the result. Default to false.
 
-        Note: This method does NOT work when there are duplicate combinations of join keys and timestamp columns
-        in spine.
-
         Returns:
             A SQL query string with CTE structure for joining feature views.
         """
@@ -2659,11 +2688,17 @@ class FeatureStore:
             fv_join_keys = list({k for e in feature_view.entities for k in e.join_keys})
             join_keys_str = ", ".join(fv_join_keys)
 
-            # Build the JOIN condition using only this feature view's join keys
-            join_conditions = [f'SPINE."{col}" = FEATURE."{col}"' for col in fv_join_keys]
-
             # Use ASOF JOIN if both spine and feature view have timestamp columns, otherwise use LEFT JOIN
             if spine_timestamp_col is not None and feature_timestamp_col is not None:
+                # Build the deduplicated spine columns set (join keys + timestamp)
+                spine_dedup_cols_set = set(fv_join_keys)
+                if spine_timestamp_col not in spine_dedup_cols_set:
+                    spine_dedup_cols_set.add(spine_timestamp_col)
+                spine_dedup_cols_str = ", ".join(f'"{col}"' for col in spine_dedup_cols_set)
+
+                # Build the JOIN condition using only this feature view's join keys
+                join_conditions_dedup = [f'SPINE_DEDUP."{col}" = FEATURE."{col}"' for col in fv_join_keys]
+
                 if include_feature_view_timestamp_col:
                     f_ts_col_alias = identifier.concat_names(
                         [feature_view.name, "_", str(feature_view.version), "_", feature_timestamp_col]
@@ -2674,36 +2709,46 @@ class FeatureStore:
                 ctes.append(
                     f"""{cte_name} AS (
     SELECT
-        SPINE.*,
+        SPINE_DEDUP.*,
         {f_ts_col_str}
         FEATURE.* EXCLUDE ({join_keys_str}, {feature_timestamp_col})
-    FROM
-        SPINE
+    FROM (
+        SELECT DISTINCT {spine_dedup_cols_str}
+        FROM SPINE
+    ) SPINE_DEDUP
     ASOF JOIN (
         SELECT {join_keys_str}, {feature_timestamp_col}, {feature_columns[i]}
         FROM {feature_view.fully_qualified_name()}
     ) FEATURE
-    MATCH_CONDITION (SPINE."{spine_timestamp_col}" >= FEATURE."{feature_timestamp_col}")
-    ON {" AND ".join(join_conditions)}
+    MATCH_CONDITION (SPINE_DEDUP."{spine_timestamp_col}" >= FEATURE."{feature_timestamp_col}")
+    ON {" AND ".join(join_conditions_dedup)}
 )"""
                 )
             else:
+                # Build the deduplicated spine columns list (just join keys, no timestamp)
+                spine_dedup_cols_str = ", ".join(f'"{col}"' for col in fv_join_keys)
+
+                # Build the JOIN condition using only this feature view's join keys
+                join_conditions_dedup = [f'SPINE_DEDUP."{col}" = FEATURE."{col}"' for col in fv_join_keys]
+
                 ctes.append(
                     f"""{cte_name} AS (
     SELECT
-        SPINE.*,
+        SPINE_DEDUP.*,
         FEATURE.* EXCLUDE ({join_keys_str})
-    FROM
-        SPINE
+    FROM (
+        SELECT DISTINCT {spine_dedup_cols_str}
+        FROM SPINE
+    ) SPINE_DEDUP
     LEFT JOIN (
         SELECT {join_keys_str}, {feature_columns[i]}
         FROM {feature_view.fully_qualified_name()}
     ) FEATURE
-    ON {" AND ".join(join_conditions)}
+    ON {" AND ".join(join_conditions_dedup)}
 )"""
                 )
 
-        # Build final SELECT with individual joins to each FV CTE
+        # Build final SELECT with LEFT joins to each FV CTE
         select_columns = []
         join_clauses = []
 
@@ -2711,19 +2756,29 @@ class FeatureStore:
             feature_view = feature_views[i]
             fv_join_keys = list({k for e in feature_view.entities for k in e.join_keys})
             join_conditions = [f'SPINE."{col}" = {cte_name}."{col}"' for col in fv_join_keys]
-            if spine_timestamp_col is not None:
+            # Only include spine timestamp in join condition if both spine and FV have timestamps
+            if spine_timestamp_col is not None and feature_view.timestamp_col is not None:
                 join_conditions.append(f'SPINE."{spine_timestamp_col}" = {cte_name}."{spine_timestamp_col}"')
+
             if include_feature_view_timestamp_col and feature_view.timestamp_col is not None:
                 f_ts_col_alias = identifier.concat_names(
                     [feature_view.name, "_", str(feature_view.version), "_", feature_view.timestamp_col]
                 )
                 f_ts_col_str = f"{cte_name}.{f_ts_col_alias} AS {f_ts_col_alias}"
                 select_columns.append(f_ts_col_str)
-            select_columns.append(feature_columns[i])
+
+            # Select features from the CTE
+            # feature_columns[i] is already a comma-separated string of column names
+            feature_cols_from_cte = []
+            for col in feature_columns[i].split(", "):
+                col_clean = col.strip()
+                feature_cols_from_cte.append(f"{cte_name}.{col_clean}")
+            select_columns.extend(feature_cols_from_cte)
+
             # Create join condition using only this feature view's join keys
             join_clauses.append(
                 f"""
-    INNER JOIN {cte_name}
+    LEFT JOIN {cte_name}
     ON {" AND ".join(join_conditions)}"""
             )
 
@@ -3388,7 +3443,7 @@ FROM SPINE{' '.join(join_clauses)}
         online_table_name = FeatureView._get_online_table_name(feature_view_name)
 
         fully_qualified_online_name = self._get_fully_qualified_name(online_table_name)
-        source_table_name = feature_view_name
+        source_table_name = self._get_fully_qualified_name(feature_view_name)
 
         # Extract join keys for PRIMARY KEY (preserve order and ensure unique)
         ordered_join_keys: list[str] = []

{snowflake_ml_python-1.18.0 → snowflake_ml_python-1.19.0}/snowflake/ml/feature_store/feature_view.py

@@ -1,7 +1,7 @@
+"""Feature view module for Snowflake ML Feature Store."""
 from __future__ import annotations
 
 import json
-import logging
 import re
 import warnings
 from collections import OrderedDict
@@ -52,7 +52,7 @@ _RESULT_SCAN_QUERY_PATTERN = re.compile(
 class OnlineConfig:
     """Configuration for online feature storage."""
 
-    enable: bool = False
+    enable: Optional[bool] = None
     target_lag: Optional[str] = None
 
     def __post_init__(self) -> None:
@@ -248,6 +248,7 @@ class FeatureView(lineage_node.LineageNode):
                 - If `timestamp_col` is provided, it is added to the default clustering keys.
             online_config: Optional configuration for online storage. If provided with enable=True,
                 online storage will be enabled. Defaults to None (no online storage).
+                NOTE: this feature is currently in Public Preview.
             _kwargs: reserved kwargs for system generated args. NOTE: DO NOT USE.
 
         Example::
@@ -289,8 +290,6 @@ class FeatureView(lineage_node.LineageNode):
 
         # noqa: DAR401
         """
-        if online_config is not None:
-            logging.warning("'online_config' is in private preview since 1.12.0. Do not use it in production.")
 
         self._name: SqlIdentifier = SqlIdentifier(name)
         self._entities: list[Entity] = entities
@@ -533,8 +532,15 @@ class FeatureView(lineage_node.LineageNode):
         return self._feature_desc
 
     @property
-    def online(self) -> bool:
-        return self._online_config.enable if self._online_config else False
+    def online(self) -> bool:  # noqa: DAR101
+        """Check if online storage is enabled for this feature view.
+
+        Returns:
+            True if online storage is enabled, False otherwise.
+        """
+        if self._online_config and self._online_config.enable is True:
+            return True
+        return False
 
     @property
     def online_config(self) -> Optional[OnlineConfig]:

{snowflake_ml_python-1.18.0 → snowflake_ml_python-1.19.0}/snowflake/ml/fileset/stage_fs.py

@@ -1,5 +1,6 @@
 import inspect
 import logging
+import re
 import time
 from dataclasses import dataclass
 from typing import Any, Optional, Union, cast
@@ -27,6 +28,8 @@ _PRESIGNED_URL_LIFETIME_SEC = 14400
 # The threshold of when the presigned url should get refreshed before its expiration.
 _PRESIGNED_URL_HEADROOM_SEC = 3600
 
+# Regex pattern to match cloud storage prefixes (s3://, gcs://, azure://) and bucket/container name at start of string
+_CLOUD_PATH_PREFIX_PATTERN = re.compile(r"^(s3|gcs|azure)://[^/]+/", re.IGNORECASE)
 
 _PROJECT = "FileSet"
 
@@ -355,8 +358,16 @@ class SFStageFileSystem(fsspec.AbstractFileSystem):
 
         Returns:
             A string of the relative stage path.
+
+        Raises:
+            ValueError: If the stage path format is invalid.
         """
-        return stage_path[len(self._stage) + 1 :]
+        if stage_path.lower().startswith(self._stage.lower()):
+            return stage_path[len(self._stage) + 1 :]
+        elif match := _CLOUD_PATH_PREFIX_PATTERN.match(stage_path):
+            return stage_path[match.end() :]
+
+        raise ValueError(f"Invalid stage path: {stage_path}")
 
     def _add_file_info_helper(
         self,