gitlabds 2.4.4__tar.gz → 2.4.5__tar.gz

{gitlabds-2.4.4 → gitlabds-2.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitlabds
-Version: 2.4.4
+Version: 2.4.5
 Summary: GitLab Data Science Tools
 Author-email: Kevin Dietz <kdietz@gitlab.com>
 License-Expression: MIT
@@ -1402,7 +1402,7 @@ Serve features from Snowflake Feature Store with per-call UDF parameters and ret
 - **Schema:** view and UDF names are qualified with the feature view's database and schema, so a `USE SCHEMA` in your session doesn't change what is served.
 - **Redeploying in the same session:** the temporary views last until the session closes, so a session that serves and then redeploys the permanent `_DYNAMIC` view keeps reading its temporary view until the next `serve_features` call. Use a fresh session to read the redeployed defaults.
 - **Concurrency:** calls sharing one session object run one at a time. Open one session per thread for real parallelism.
-- **Feature-date check:** when `feature_date` is set, the served date is verified and a mismatch raises `ValueError`. With `spine_timestamp_col` and `include_feature_view_timestamp_col=True` the returned `{FV}_{version}_FEATURE_DATE` column is checked; otherwise the session's temporary view is queried before retrieval, which may run the whole UDF.
+- **Feature-date check:** when `feature_date` is set, the served date is checked and a mismatch raises a warning, not an error: some feature views use a timestamp other than the snapshot date (e.g. a refresh week), so a mismatch isn't always wrong. With `spine_timestamp_col` and `include_feature_view_timestamp_col=True` the returned `{FV}_{version}_FEATURE_DATE` column is checked; otherwise the session's temporary view is queried before retrieval, which may run the whole UDF.
 - **Spine timestamps earlier than `feature_date`** match no feature rows in the point-in-time join and return all-null features. A warning is raised when this happens.
 
 `gitlabds.serve_features(session, feature_store, feature_views_dict, spine_df=None, feature_date=None, spine_timestamp_col=None, include_feature_view_timestamp_col=False, lookback_window_value=None, lookback_window_unit=None, lock_timeout_seconds=None, max_fetch_retries=3, fetch_retry_backoff_seconds=30):`

{gitlabds-2.4.4 → gitlabds-2.4.5}/README.md

@@ -1366,7 +1366,7 @@ Serve features from Snowflake Feature Store with per-call UDF parameters and ret
 - **Schema:** view and UDF names are qualified with the feature view's database and schema, so a `USE SCHEMA` in your session doesn't change what is served.
 - **Redeploying in the same session:** the temporary views last until the session closes, so a session that serves and then redeploys the permanent `_DYNAMIC` view keeps reading its temporary view until the next `serve_features` call. Use a fresh session to read the redeployed defaults.
 - **Concurrency:** calls sharing one session object run one at a time. Open one session per thread for real parallelism.
-- **Feature-date check:** when `feature_date` is set, the served date is verified and a mismatch raises `ValueError`. With `spine_timestamp_col` and `include_feature_view_timestamp_col=True` the returned `{FV}_{version}_FEATURE_DATE` column is checked; otherwise the session's temporary view is queried before retrieval, which may run the whole UDF.
+- **Feature-date check:** when `feature_date` is set, the served date is checked and a mismatch raises a warning, not an error: some feature views use a timestamp other than the snapshot date (e.g. a refresh week), so a mismatch isn't always wrong. With `spine_timestamp_col` and `include_feature_view_timestamp_col=True` the returned `{FV}_{version}_FEATURE_DATE` column is checked; otherwise the session's temporary view is queried before retrieval, which may run the whole UDF.
 - **Spine timestamps earlier than `feature_date`** match no feature rows in the point-in-time join and return all-null features. A warning is raised when this happens.
 
 `gitlabds.serve_features(session, feature_store, feature_views_dict, spine_df=None, feature_date=None, spine_timestamp_col=None, include_feature_view_timestamp_col=False, lookback_window_value=None, lookback_window_unit=None, lock_timeout_seconds=None, max_fetch_retries=3, fetch_retry_backoff_seconds=30):`

{gitlabds-2.4.4 → gitlabds-2.4.5}/gitlabds/serving_features.py

@@ -74,28 +74,29 @@ def _check_dynamic_view_feature_date(
     dynamic_view: str,
     timestamp_col: str,
     feature_date: str,
-) -> None:
-    """Raise if the session's dynamic view does not return the requested feature_date."""
+    mismatches: List[str],
+) -> bool:
+    """Check the session's dynamic view serves feature_date; append to mismatches if not."""
     rows = session.sql(f"SELECT {timestamp_col} FROM {dynamic_view} LIMIT 1").collect()
     if not rows:
         warnings.warn(
             f"{dynamic_view} returned no rows; could not verify feature_date {feature_date}"
         )
-        return
+        return False
     actual = rows[0][0]
     if actual is None or _to_date(actual) != _to_date(feature_date):
-        raise ValueError(
-            f"{dynamic_view} returned {timestamp_col} {actual}, expected {feature_date}. "
-            f"The session's temporary view is not serving the requested parameters."
-        )
+        mismatches.append(f"{dynamic_view} returned {timestamp_col} {actual}, expected {feature_date}")
+        return False
+    return True
 
 
 def _check_retrieved_feature_date(
     features_df: pd.DataFrame,
     feature_date_col: str,
     feature_date: str,
-) -> None:
-    """Raise if a retrieved feature-date column holds any date other than feature_date."""
+    mismatches: List[str],
+) -> bool:
+    """Check a retrieved feature-date column holds only feature_date; append to mismatches if not."""
     values = features_df[feature_date_col].dropna()
     if values.empty:
         warnings.warn(
@@ -103,14 +104,26 @@ def _check_retrieved_feature_date(
             f"null. A spine timestamp earlier than feature_date {feature_date} matches no "
             f"feature rows in the point-in-time join."
         )
-        return
+        return False
     expected = _to_date(feature_date)
     mismatched = sorted({d for d in values.map(_to_date) if d != expected})
     if mismatched:
-        raise ValueError(
-            f"{feature_date_col} returned {mismatched}, expected {feature_date}. "
-            f"The session's temporary view is not serving the requested parameters."
-        )
+        mismatches.append(f"{feature_date_col} returned {mismatched}, expected {feature_date}")
+        return False
+    return True
+
+
+def _warn_feature_date_mismatches(mismatches: List[str]) -> None:
+    """Raise one warning listing every feature_date mismatch, with the explanation once."""
+    if not mismatches:
+        return
+    listed = "\n".join(f"  - {m}" for m in mismatches)
+    warnings.warn(
+        f"feature_date mismatch in {len(mismatches)} feature view(s):\n{listed}\n"
+        f"Some feature views use a timestamp other than the snapshot date (e.g. a refresh "
+        f"week), in which case this is expected; otherwise the features may not be for the "
+        f"requested date."
+    )
 
 
 def _warn_spine_before_feature_date(
@@ -265,7 +278,10 @@ def serve_features(
     Calls sharing one session object run one at a time: a process-local lock per session
     is held for the whole call. Open one session per thread for real parallelism.
 
-    When ``feature_date`` is set, the served feature date is verified. With
+    When ``feature_date`` is set, the served feature date is checked, and a mismatch warns:
+    some feature views use a timestamp other than the snapshot date
+    (e.g. a refresh week), so a mismatch is not always an error. All mismatches are
+    reported together in one warning after retrieval. With
     ``spine_timestamp_col`` and ``include_feature_view_timestamp_col=True`` the returned
     ``{FV}_{version}_{timestamp_col}`` column is checked; otherwise the session's temporary view is
     queried before retrieval (``SELECT {timestamp_col} ... LIMIT 1``), which may run the
@@ -319,8 +335,8 @@ def serve_features(
     TypeError
         When spine_df or feature_views_dict has the wrong type.
     ValueError
-        When spine_df is None, feature_views_dict is empty, session is not the feature
-        store's session, or the served feature date does not match ``feature_date``.
+        When spine_df is None, feature_views_dict is empty, or session is not the feature
+        store's session.
 
     Examples
     --------
@@ -376,6 +392,7 @@ def serve_features(
     try:
         feature_views_list = []
         feature_date_cols = {}
+        date_mismatches: List[str] = []
 
         for fv_name, version in feature_views_dict.items():
             fv = feature_store.get_feature_view(fv_name, version)
@@ -416,8 +433,10 @@ def serve_features(
                     timestamp_col,
                 )
             else:
-                _check_dynamic_view_feature_date(session, dynamic_view, timestamp_col, feature_date)
-                print(f"  [{call_id}] Verified {dynamic_view} serves {timestamp_col} {feature_date}")
+                if _check_dynamic_view_feature_date(
+                    session, dynamic_view, timestamp_col, feature_date, date_mismatches
+                ):
+                    print(f"  [{call_id}] Verified {dynamic_view} serves {timestamp_col} {feature_date}")
 
         if isinstance(spine_df, str):
             snowpark_spine_df = session.sql(spine_df)
@@ -467,10 +486,17 @@ def serve_features(
         returned_cols = {c.upper(): c for c in combined_features.columns}
         for col, (dynamic_view, timestamp_col) in feature_date_cols.items():
             if col in returned_cols:
-                _check_retrieved_feature_date(combined_features, returned_cols[col], feature_date)
+                matched = _check_retrieved_feature_date(
+                    combined_features, returned_cols[col], feature_date, date_mismatches
+                )
             else:
-                _check_dynamic_view_feature_date(session, dynamic_view, timestamp_col, feature_date)
-            print(f"[{call_id}] Verified {col} matches feature_date {feature_date}")
+                matched = _check_dynamic_view_feature_date(
+                    session, dynamic_view, timestamp_col, feature_date, date_mismatches
+                )
+            if matched:
+                print(f"[{call_id}] Verified {col} matches feature_date {feature_date}")
+
+        _warn_feature_date_mismatches(date_mismatches)
 
         if spine_timestamp_col is not None and feature_date:
             _warn_spine_before_feature_date(combined_features, spine_timestamp_col, feature_date)

{gitlabds-2.4.4 → gitlabds-2.4.5}/gitlabds.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitlabds
-Version: 2.4.4
+Version: 2.4.5
 Summary: GitLab Data Science Tools
 Author-email: Kevin Dietz <kdietz@gitlab.com>
 License-Expression: MIT
@@ -1402,7 +1402,7 @@ Serve features from Snowflake Feature Store with per-call UDF parameters and ret
 - **Schema:** view and UDF names are qualified with the feature view's database and schema, so a `USE SCHEMA` in your session doesn't change what is served.
 - **Redeploying in the same session:** the temporary views last until the session closes, so a session that serves and then redeploys the permanent `_DYNAMIC` view keeps reading its temporary view until the next `serve_features` call. Use a fresh session to read the redeployed defaults.
 - **Concurrency:** calls sharing one session object run one at a time. Open one session per thread for real parallelism.
-- **Feature-date check:** when `feature_date` is set, the served date is verified and a mismatch raises `ValueError`. With `spine_timestamp_col` and `include_feature_view_timestamp_col=True` the returned `{FV}_{version}_FEATURE_DATE` column is checked; otherwise the session's temporary view is queried before retrieval, which may run the whole UDF.
+- **Feature-date check:** when `feature_date` is set, the served date is checked and a mismatch raises a warning, not an error: some feature views use a timestamp other than the snapshot date (e.g. a refresh week), so a mismatch isn't always wrong. With `spine_timestamp_col` and `include_feature_view_timestamp_col=True` the returned `{FV}_{version}_FEATURE_DATE` column is checked; otherwise the session's temporary view is queried before retrieval, which may run the whole UDF.
 - **Spine timestamps earlier than `feature_date`** match no feature rows in the point-in-time join and return all-null features. A warning is raised when this happens.
 
 `gitlabds.serve_features(session, feature_store, feature_views_dict, spine_df=None, feature_date=None, spine_timestamp_col=None, include_feature_view_timestamp_col=False, lookback_window_value=None, lookback_window_unit=None, lock_timeout_seconds=None, max_fetch_retries=3, fetch_retry_backoff_seconds=30):`

{gitlabds-2.4.4 → gitlabds-2.4.5}/tests/test_serving_features.py

@@ -128,30 +128,46 @@ def test_same_session_calls_are_serialized():
     assert active["max"] == 1
 
 
-def test_temp_view_feature_date_mismatch_raises_before_retrieval():
+def test_temp_view_feature_date_mismatch_warns_and_still_serves():
     session = FakeSession(served_date="2024-10-05")
     store = FakeFeatureStore(session)
-    with pytest.raises(ValueError, match="expected 2025-01-01"):
+    with pytest.warns(UserWarning, match="expected 2025-01-01"):
         sf.serve_features(
             session, store, {"a": "1.0"}, spine_df=SPINE,
             feature_date="2025-01-01",
         )
-    assert not store.retrieved
+    assert store.retrieved
 
 
-def test_returned_feature_date_mismatch_raises():
+def test_mismatches_across_views_warn_once():
+    session = FakeSession(served_date="2024-10-05")
+    with pytest.warns(UserWarning) as record:
+        sf.serve_features(
+            session, FakeFeatureStore(session), {"a": "1.0", "b": "1.0"}, spine_df=SPINE,
+            feature_date="2025-01-01",
+        )
+    mismatch_warnings = [str(w.message) for w in record if "feature_date mismatch" in str(w.message)]
+    assert len(mismatch_warnings) == 1
+    message = mismatch_warnings[0]
+    assert "FS_DB.FS_SCHEMA.A_DYNAMIC returned" in message
+    assert "FS_DB.FS_SCHEMA.B_DYNAMIC returned" in message
+    assert message.count("Some feature views use a timestamp") == 1
+
+
+def test_returned_feature_date_mismatch_warns():
     result = pd.DataFrame({
         "ACCOUNT_ID": [1, 2],
         "SNAPSHOT_DATE": pd.to_datetime(["2025-01-15"] * 2),
         "A_1.0_FEATURE_DATE": pd.to_datetime(["2024-10-05"] * 2),
     })
     session = FakeSession(served_date="2025-01-01")
-    with pytest.raises(ValueError, match="expected 2025-01-01"):
-        sf.serve_features(
+    with pytest.warns(UserWarning, match="A_1.0_FEATURE_DATE returned"):
+        out = sf.serve_features(
             session, FakeFeatureStore(session, result_df=result), {"a": "1.0"}, spine_df=SPINE,
             feature_date="2025-01-01", spine_timestamp_col="SNAPSHOT_DATE",
             include_feature_view_timestamp_col=True,
         )
+    assert len(out) == 2
 
 
 def test_session_other_than_feature_store_session_raises():