is this...it?

Author: MarcoGorelli

pandas/core/interchange/buffer.py

@@ -76,3 +76,57 @@ def __repr__(self) -> str:
             )
             + ")"
         )
+
+
+class PandasPyarrowBackedBuffer(Buffer):
+    """
+    Data in the buffer is guaranteed to be contiguous in memory.
+    """
+
+    def __init__(self, x: Any, allow_copy: bool = True) -> None:
+        """
+        Handle only regular columns (= numpy arrays) for now.
+        """
+
+        # Store the numpy array in which the data resides as a private
+        # attribute, so we can use it to retrieve the public attributes
+        self._x = x
+
+    @property
+    def bufsize(self) -> int:
+        """
+        Buffer size in bytes.
+        """
+        return self._x.size
+
+    @property
+    def ptr(self) -> int:
+        """
+        Pointer to start of the buffer as an integer.
+        """
+        return self._x.address
+
+    def __dlpack__(self) -> Any:
+        """
+        Represent this structure as DLPack interface.
+        """
+        return self._x.__dlpack__()
+
+    def __dlpack_device__(self) -> tuple[DlpackDeviceType, int | None]:
+        """
+        Device type and device ID for where the data in the buffer resides.
+        """
+        return (DlpackDeviceType.CPU, None)
+
+    # def __repr__(self) -> str:
+    #     return (
+    #         "PandasBuffer("
+    #         + str(
+    #             {
+    #                 "bufsize": self.bufsize,
+    #                 "ptr": self.ptr,
+    #                 "device": self.__dlpack_device__()[0].name,
+    #             }
+    #         )
+    #         + ")"
+    #     )

pandas/core/interchange/column.py

@@ -17,7 +17,10 @@
 
 import pandas as pd
 from pandas.api.types import is_string_dtype
-from pandas.core.interchange.buffer import PandasBuffer
+from pandas.core.interchange.buffer import (
+    PandasBuffer,
+    PandasPyarrowBackedBuffer,
+)
 from pandas.core.interchange.dataframe_protocol import (
     Column,
     ColumnBuffers,
@@ -195,6 +198,17 @@ def describe_null(self):
             null_value = 1
             return column_null_dtype, null_value
         kind = self.dtype[0]
+        if isinstance(self._col.dtype, ArrowDtype):
+            column_null_dtype = ColumnNullType.USE_BITMASK
+            null_value = 0
+            if ~self._col.isna().any():
+                try:
+                    null, value = _NULL_DESCRIPTION[kind]
+                except KeyError as err:
+                    raise NotImplementedError(f"Data type {kind} not yet supported") from err
+
+                return null, value
+            return column_null_dtype, null_value
         try:
             null, value = _NULL_DESCRIPTION[kind]
         except KeyError as err:
@@ -282,6 +296,16 @@ def _get_data_buffer(
         """
         Return the buffer containing the data and the buffer's associated dtype.
         """
+        if isinstance(self._col.dtype, ArrowDtype):
+            arr = self._col.array
+            buffer = PandasPyarrowBackedBuffer(arr._pa_array.chunks[0].buffers()[1])
+            dtype = (
+                DtypeKind.BOOL,
+                8,
+                ArrowCTypes.BOOL,
+                Endianness.NATIVE,
+            )  # note: currently only support native endianness
+            return buffer, dtype
         if self.dtype[0] == DtypeKind.DATETIME:
             # self.dtype[2] is an ArrowCTypes.TIMESTAMP where the tz will make
             # it longer than 4 characters
@@ -305,8 +329,6 @@ def _get_data_buffer(
             arr = self._col.array
             if isinstance(self._col.dtype, BaseMaskedDtype):
                 np_arr = arr._data  # type: ignore[attr-defined]
-            elif isinstance(self._col.dtype, ArrowDtype):
-                raise NotImplementedError("ArrowDtype not handled yet")
             else:
                 np_arr = arr._ndarray  # type: ignore[attr-defined]
             buffer = PandasBuffer(np_arr, allow_copy=self._allow_copy)
@@ -351,6 +373,15 @@ def _get_validity_buffer(self) -> tuple[PandasBuffer, Any]:
         """
         null, invalid = self.describe_null
 
+        if isinstance(self._col.dtype, ArrowDtype):
+            arr = self._col.array
+            buf = arr._pa_array.chunks[0].buffers()[0]
+            dtype = (DtypeKind.BOOL, 1, ArrowCTypes.BOOL, Endianness.NATIVE)
+            if buf is None:
+                return buf, dtype
+            buffer = PandasPyarrowBackedBuffer(buf)
+            return buffer, dtype
+
         if isinstance(self._col.dtype, BaseMaskedDtype):
             mask = self._col.array._mask  # type: ignore[attr-defined]
             buffer = PandasBuffer(mask)