"compliant" -> "interchange"

Author: honno

tests/conftest.py

@@ -38,7 +38,8 @@ def pytest_configure(config):
 
 
 ci_failing_ids = [
-    # dataframe objects return the interchange dataframe, not a dict
+    # dataframe objects return the interchange dataframe, not a dict, although
+    # this behaviour might be in the spec soon.
     "test_dataframe_object.py::test_toplevel_dunder_dataframe[pandas]",
     "test_dataframe_object.py::test_toplevel_dunder_dataframe[vaex]",
     "test_dataframe_object.py::test_toplevel_dunder_dataframe[modin]",

tests/test_dataframe_object.py

@@ -1,60 +1,36 @@
-from typing import Callable, Iterable
+from typing import Iterable
 
-import numpy as np
-import pytest
 from hypothesis import assume, given
 from hypothesis import strategies as st
 
-from .strategies import MockColumn, MockDataFrame, NominalDtype, mock_dataframes
+from .strategies import mock_dataframes
 from .wrappers import LibraryInfo
 
 
-def test_library_supports_zero_cols(libinfo: LibraryInfo):
-    if not libinfo.allow_zero_cols:
-        pytest.xfail("library doesn't support zero cols")
-    mock_df = MockDataFrame({})
-    df = libinfo.mock_to_toplevel(mock_df)
-    # Just initialising a dataframe might not catch that a library doesn't
-    # support zero-column dataframes - using a method like repr might!
-    repr(df)
-
-
-def test_library_supports_zero_rows(libinfo: LibraryInfo):
-    if not libinfo.allow_zero_rows:
-        pytest.xfail("library doesn't support zero rows")
-    mock_df = MockDataFrame(
-        {"foo_col": MockColumn(np.asarray([], dtype=np.int64), NominalDtype.INT64)}
-    )
-    df = libinfo.mock_to_toplevel(mock_df)
-    # See above comment
-    repr(df)
-
-
-def _test_dunder_dataframe(df):
+@given(data=st.data())
+def test_toplevel_dunder_dataframe(libinfo: LibraryInfo, data: st.DataObject):
+    df = data.draw(libinfo.toplevel_dataframes(), label="df")
     assert hasattr(df, "__dataframe__")
-    assert isinstance(df.__dataframe__, Callable)
     out = df.__dataframe__()
     assert isinstance(out, dict)
     assert hasattr(out, "dataframe")
     assert hasattr(out, "version")
 
 
-@given(data=st.data())
-def test_toplevel_dunder_dataframe(libinfo: LibraryInfo, data: st.DataObject):
-    df = data.draw(libinfo.toplevel_dataframes(), label="df")
-    _test_dunder_dataframe(df)
-
-
 @given(data=st.data())
 def test_dunder_dataframe(libinfo: LibraryInfo, data: st.DataObject):
-    df = data.draw(libinfo.compliant_dataframes(), label="df")
-    _test_dunder_dataframe(df)
+    df = data.draw(libinfo.interchange_dataframes(), label="df")
+    assert hasattr(df, "__dataframe__")
+    out = df.__dataframe__()
+    assert isinstance(out, dict)
+    assert hasattr(out, "dataframe")
+    assert hasattr(out, "version")
 
 
 @given(data=st.data())
 def test_num_columns(libinfo: LibraryInfo, data: st.DataObject):
     mock_df = data.draw(libinfo.mock_dataframes(), label="mock_df")
-    df = libinfo.mock_to_compliant(mock_df)
+    df = libinfo.mock_to_interchange(mock_df)
     out = df.num_columns()
     assert isinstance(out, int)
     assert out == mock_df.num_columns()
@@ -66,7 +42,7 @@ def test_num_rows(libinfo: LibraryInfo, data: st.DataObject):
         mock_dataframes(**{**libinfo.mock_dataframes_kwargs, "allow_zero_cols": False}),
         label="mock_df",
     )
-    df = libinfo.mock_to_compliant(mock_df)
+    df = libinfo.mock_to_interchange(mock_df)
     out = df.num_rows()
     assume(out is not None)
     assert isinstance(out, int)
@@ -76,7 +52,7 @@ def test_num_rows(libinfo: LibraryInfo, data: st.DataObject):
 @given(data=st.data())
 def test_num_chunks(libinfo: LibraryInfo, data: st.DataObject):
     mock_df = data.draw(libinfo.mock_dataframes(), label="mock_df")
-    df = libinfo.mock_to_compliant(mock_df)
+    df = libinfo.mock_to_interchange(mock_df)
     out = df.num_chunks()
     assert isinstance(out, int)
     # result is implementation-dependant
@@ -85,7 +61,7 @@ def test_num_chunks(libinfo: LibraryInfo, data: st.DataObject):
 @given(data=st.data())
 def test_column_names(libinfo: LibraryInfo, data: st.DataObject):
     mock_df = data.draw(libinfo.mock_dataframes(), label="mock_df")
-    df = libinfo.mock_to_compliant(mock_df)
+    df = libinfo.mock_to_interchange(mock_df)
     out = df.column_names()
     assert isinstance(out, Iterable)
     assert len(list(out)) == len(mock_df)
@@ -100,7 +76,7 @@ def test_get_column(libinfo: LibraryInfo, data: st.DataObject):
         mock_dataframes(**{**libinfo.mock_dataframes_kwargs, "allow_zero_cols": False}),
         label="mock_df",
     )
-    df = libinfo.mock_to_compliant(mock_df)
+    df = libinfo.mock_to_interchange(mock_df)
     for i in range(len(mock_df)):
         df.get_column(i)
 
@@ -111,7 +87,7 @@ def test_select_columns(libinfo: LibraryInfo, data: st.DataObject):
         mock_dataframes(**{**libinfo.mock_dataframes_kwargs, "allow_zero_cols": False}),
         label="mock_df",
     )
-    df = libinfo.mock_to_compliant(mock_df)
+    df = libinfo.mock_to_interchange(mock_df)
     indices = data.draw(
         st.lists(st.integers(0, len(mock_df) - 1), min_size=1, unique=True),
         label="indices",
@@ -125,7 +101,7 @@ def test_select_columns_by_name(libinfo: LibraryInfo, data: st.DataObject):
         mock_dataframes(**{**libinfo.mock_dataframes_kwargs, "allow_zero_cols": False}),
         label="mock_df",
     )
-    df = libinfo.mock_to_compliant(mock_df)
+    df = libinfo.mock_to_interchange(mock_df)
     names = data.draw(
         st.lists(st.sampled_from(list(mock_df.keys())), min_size=1, unique=True),
         label="names",
@@ -135,7 +111,7 @@ def test_select_columns_by_name(libinfo: LibraryInfo, data: st.DataObject):
 
 @given(data=st.data())
 def test_get_chunks(libinfo: LibraryInfo, data: st.DataObject):
-    df = data.draw(libinfo.compliant_dataframes(), label="df")
+    df = data.draw(libinfo.interchange_dataframes(), label="df")
     _n_chunks = df.num_chunks()
     assert isinstance(_n_chunks, int)  # sanity check
     n_chunks = data.draw(

tests/test_meta.py

@@ -16,7 +16,7 @@ def test_mock_dataframes(_):
 
 
 @pytest.mark.parametrize(
-    "func_name", ["mock_dataframes", "toplevel_dataframes", "compliant_dataframes"]
+    "func_name", ["mock_dataframes", "toplevel_dataframes", "interchange_dataframes"]
 )
 @given(data=st.data())
 def test_strategy(libinfo: LibraryInfo, func_name: str, data: st.DataObject):

tests/test_signatures.py

@@ -91,7 +91,7 @@ def test_toplevel_dataframe_dunder_dataframe(libinfo: LibraryInfo, data: st.Data
 def test_dataframe_method(
     libinfo: LibraryInfo, stub: FunctionType, data: st.DataObject
 ):
-    df = data.draw(libinfo.compliant_dataframes(), label="df")
+    df = data.draw(libinfo.interchange_dataframes(), label="df")
     assert hasattr(df, stub.__name__)
     method = getattr(df, stub.__name__)
     assert isinstance(method, Callable)  # type: ignore
@@ -108,7 +108,7 @@ def test_dataframe_method(
 @given(data=st.data())
 @settings(max_examples=1)
 def test_column_method(libinfo: LibraryInfo, stub: FunctionType, data: st.DataObject):
-    df = data.draw(libinfo.compliant_dataframes(), label="df")
+    df = data.draw(libinfo.interchange_dataframes(), label="df")
     assume(df.num_columns() > 0)
     col = df.get_column(0)
     note(f"{col=}")
@@ -128,7 +128,7 @@ def test_column_method(libinfo: LibraryInfo, stub: FunctionType, data: st.DataOb
 @given(data=st.data())
 @settings(max_examples=1)
 def test_buffer_method(libinfo: LibraryInfo, stub: FunctionType, data: st.DataObject):
-    df = data.draw(libinfo.compliant_dataframes(), label="df")
+    df = data.draw(libinfo.interchange_dataframes(), label="df")
     assume(df.num_columns() > 0)
     col = df.get_column(0)
     note(f"{col=}")

tests/wrappers.py

@@ -19,15 +19,15 @@ class LibraryInfo(NamedTuple):
     mock_to_toplevel: Callable[[MockDataFrame], TopLevelDataFrame]
     from_dataframe: Callable[[TopLevelDataFrame], DataFrame]
     frame_equal: Callable[[TopLevelDataFrame, DataFrame], bool]
-    toplevel_to_compliant: Callable[[TopLevelDataFrame], DataFrame] = lambda df: (
+    toplevel_to_interchange: Callable[[TopLevelDataFrame], DataFrame] = lambda df: (
         df.__dataframe__()["dataframe"]
     )
     exclude_dtypes: List[NominalDtype] = []
     allow_zero_cols: bool = True
     allow_zero_rows: bool = True
 
-    def mock_to_compliant(self, mock_dataframe: MockDataFrame) -> DataFrame:
-        return self.toplevel_to_compliant(self.mock_to_toplevel(mock_dataframe))
+    def mock_to_interchange(self, mock_dataframe: MockDataFrame) -> DataFrame:
+        return self.toplevel_to_interchange(self.mock_to_toplevel(mock_dataframe))
 
     @property
     def mock_dataframes_kwargs(self) -> Dict[str, Any]:
@@ -43,8 +43,8 @@ def mock_dataframes(self) -> st.SearchStrategy[MockDataFrame]:
     def toplevel_dataframes(self) -> st.SearchStrategy[TopLevelDataFrame]:
         return self.mock_dataframes().map(self.mock_to_toplevel)
 
-    def compliant_dataframes(self) -> st.SearchStrategy[TopLevelDataFrame]:
-        return self.toplevel_dataframes().map(self.toplevel_to_compliant)
+    def interchange_dataframes(self) -> st.SearchStrategy[TopLevelDataFrame]:
+        return self.toplevel_dataframes().map(self.toplevel_to_interchange)
 
     def __repr__(self) -> str:
         return f"LibraryInfo(<{self.name}>)"
@@ -82,7 +82,7 @@ def pandas_mock_to_toplevel(mock_df: MockDataFrame) -> pd.DataFrame:
         mock_to_toplevel=pandas_mock_to_toplevel,
         from_dataframe=pandas_from_dataframe,
         frame_equal=lambda df1, df2: df1.equals(df2),
-        toplevel_to_compliant=lambda df: df.__dataframe__(),
+        toplevel_to_interchange=lambda df: df.__dataframe__(),
         exclude_dtypes=[NominalDtype.DATETIME64NS],
     )
     libinfo_params.append(pytest.param(pandas_libinfo, id=pandas_libinfo.name))
@@ -140,7 +140,7 @@ def vaex_frame_equal(df1, df2) -> bool:
         mock_to_toplevel=vaex_mock_to_toplevel,
         from_dataframe=vaex_from_dataframe,
         frame_equal=vaex_frame_equal,
-        toplevel_to_compliant=lambda df: df.__dataframe__(),
+        toplevel_to_interchange=lambda df: df.__dataframe__(),
         exclude_dtypes=[NominalDtype.DATETIME64NS],
         # https://github.com/vaexio/vaex/issues/2094
         allow_zero_cols=False,
@@ -220,7 +220,7 @@ def modin_frame_equal(df1: mpd.DataFrame, df2: mpd.DataFrame) -> bool:
         mock_to_toplevel=modin_mock_to_toplevel,
         from_dataframe=modin_from_dataframe,
         frame_equal=modin_frame_equal,
-        toplevel_to_compliant=lambda df: df.__dataframe__(),
+        toplevel_to_interchange=lambda df: df.__dataframe__(),
         # https://github.com/modin-project/modin/issues/4654
         # https://github.com/modin-project/modin/issues/4652
         exclude_dtypes=[
@@ -292,7 +292,7 @@ def cudf_mock_to_toplevel(mock_df: MockDataFrame) -> cudf.DataFrame:
         mock_to_toplevel=cudf_mock_to_toplevel,
         from_dataframe=cudf_from_dataframe,
         frame_equal=lambda df1, df2: df1.equals(df2),  # NaNs considered equal
-        toplevel_to_compliant=lambda df: df.__dataframe__(),
+        toplevel_to_interchange=lambda df: df.__dataframe__(),
     )
     libinfo_params.append(pytest.param(cupy_libinfo, id=cupy_libinfo.name))