fix: synchronize stacklevel for deprecation warnings in TableProvider

Author: kosiew

python/datafusion/table_provider.py

@@ -26,6 +26,9 @@
 
 _InternalTableProvider = df_internal.TableProvider
 
+# Keep in sync with ``datafusion._internal.TableProvider.from_view``.
+_FROM_VIEW_WARN_STACKLEVEL = 2
+
 
 class TableProvider:
     """High level wrapper around :mod:`datafusion._internal.TableProvider`."""
@@ -53,10 +56,9 @@ def from_dataframe(cls, df: Any) -> TableProvider:
         """Create a :class:`TableProvider` from a :class:`DataFrame`."""
         from datafusion.dataframe import DataFrame as DataFrameWrapper
 
-        if isinstance(df, DataFrameWrapper):
-            dataframe = df
-        else:
-            dataframe = DataFrameWrapper(df)
+        dataframe = (
+            df if isinstance(df, DataFrameWrapper) else DataFrameWrapper(df)
+        )
 
         provider = dataframe.into_view()
         if isinstance(provider, cls):
@@ -78,8 +80,8 @@ def from_view(cls, df: Any) -> TableProvider:
         warnings.warn(
             "TableProvider.from_view is deprecated; use DataFrame.into_view or "
             "TableProvider.from_dataframe instead.",
-            DeprecationWarning,
-            stacklevel=2,
+            category=DeprecationWarning,
+            stacklevel=_FROM_VIEW_WARN_STACKLEVEL,
         )
         return cls(provider)
 

python/tests/test_context.py

@@ -16,14 +16,16 @@
 # under the License.
 import datetime as dt
 import gzip
+import inspect
 import pathlib
+import warnings
 
 import pyarrow as pa
 import pyarrow.dataset as ds
 import pytest
 from datafusion import (
-    DataFrame,
     EXPECTED_PROVIDER_MSG,
+    DataFrame,
     RuntimeEnvBuilder,
     SessionConfig,
     SessionContext,
@@ -358,6 +360,46 @@ def test_table_provider_from_dataframe(ctx):
     assert [b.to_pydict() for b in result] == [{"a": [1, 2]}]
 
 
+def test_table_provider_from_view_warning_origin(ctx):
+    from datafusion.table_provider import TableProvider as WrapperTableProvider
+
+    wrapper_df = ctx.from_pydict({"a": [1]})
+    test_path = pathlib.Path(__file__).resolve()
+
+    with warnings.catch_warnings(record=True) as caught:
+        warnings.simplefilter("always")
+        call_lineno = inspect.currentframe().f_lineno + 1
+        WrapperTableProvider.from_view(wrapper_df)
+
+    assert len(caught) >= 1
+
+    rust_warning = next(
+        (
+            warning
+            for warning in caught
+            if "PyTableProvider.from_view()" in str(warning.message)
+        ),
+        None,
+    )
+    assert rust_warning is not None
+    assert issubclass(rust_warning.category, DeprecationWarning)
+    assert pathlib.Path(rust_warning.filename).resolve() == test_path
+    assert rust_warning.lineno == call_lineno
+
+    py_warning = next(
+        (
+            warning
+            for warning in caught
+            if "TableProvider.from_view is deprecated" in str(warning.message)
+        ),
+        None,
+    )
+    assert py_warning is not None
+    assert issubclass(py_warning.category, DeprecationWarning)
+    assert pathlib.Path(py_warning.filename).resolve() == test_path
+    assert py_warning.lineno == call_lineno
+
+
 def test_register_table_capsule_direct(ctx):
     df = ctx.from_pydict({"a": [1, 2]})
     provider = df.into_view()

src/table.rs

@@ -91,7 +91,8 @@ impl PyTableProvider {
     #[staticmethod]
     pub fn from_view(py: Python<'_>, df: &PyDataFrame) -> PyDataFusionResult<Self> {
         let kwargs = PyDict::new(py);
-        kwargs.set_item("stacklevel", 3)?;
+        // Keep stack level consistent with python/datafusion/table_provider.py
+        kwargs.set_item("stacklevel", 2)?;
         py.import("warnings")?.call_method(
             "warn",
             (