chore: Isolate interchange-level support

src/narwhals/_ibis/dataframe.py

@@ -27,28 +27,23 @@
     from types import ModuleType
     from typing import TypeAlias
 
-    import pandas as pd
-    import pyarrow as pa
     from ibis.expr.operations import Binary
     from typing_extensions import Self, TypeIs
 
     from narwhals._compliant.typing import CompliantDataFrameAny
     from narwhals._ibis.group_by import IbisGroupBy
     from narwhals._ibis.namespace import IbisNamespace
-    from narwhals._ibis.series import IbisInterchangeSeries
     from narwhals._typing import _EagerAllowedImpl
     from narwhals._utils import _LimitedContext
     from narwhals.dataframe import LazyFrame
     from narwhals.dtypes import DType
-    from narwhals.stable.v1 import DataFrame as DataFrameV1
     from narwhals.typing import AsofJoinStrategy, JoinStrategy, UniqueKeepStrategy
 
     JoinPredicates: TypeAlias = "Sequence[ir.BooleanColumn] | Sequence[str]"
 
 
 class IbisLazyFrame(
-    SQLLazyFrame["IbisExpr", "ir.Table", "LazyFrame[ir.Table] | DataFrameV1[ir.Table]"],
-    ValidateBackendVersion,
+    SQLLazyFrame["IbisExpr", "ir.Table", "LazyFrame[ir.Table]"], ValidateBackendVersion
 ):
     _implementation = Implementation.IBIS
 
@@ -70,20 +65,9 @@ def _is_native(obj: ir.Table | Any) -> TypeIs[ir.Table]:
     def from_native(cls, data: ir.Table, /, *, context: _LimitedContext) -> Self:
         return cls(data, version=context._version)
 
-    def to_narwhals(self) -> LazyFrame[ir.Table] | DataFrameV1[ir.Table]:
-        if self._version is Version.V1:
-            from narwhals.stable.v1 import DataFrame
-
-            return DataFrame(self)
+    def to_narwhals(self) -> LazyFrame[ir.Table]:
         return self._version.lazyframe(self)
 
-    def __narwhals_dataframe__(self) -> Self:  # pragma: no cover
-        # Keep around for backcompat.
-        if self._version is not Version.V1:
-            msg = "__narwhals_dataframe__ is not implemented for IbisLazyFrame"
-            raise AttributeError(msg)
-        return self
-
     def __narwhals_lazyframe__(self) -> Self:
         return self
 
@@ -95,11 +79,6 @@ def __narwhals_namespace__(self) -> IbisNamespace:
 
         return IbisNamespace(version=self._version)
 
-    def get_column(self, name: str) -> IbisInterchangeSeries:
-        from narwhals._ibis.series import IbisInterchangeSeries
-
-        return IbisInterchangeSeries(self.native.select(name), version=self._version)
-
     def _iter_columns(self) -> Iterator[ir.Expr]:
         for name in self.columns:
             yield self.native[name]
@@ -167,6 +146,7 @@ def drop(self, columns: Sequence[str], *, strict: bool) -> Self:
         selection = (col for col in self.columns if col not in columns_to_drop)
         return self._with_native(self.native.select(*selection))
 
+    # TODO @dangotbanned: Figure out if this is needed
     def lazy(self, backend: None = None, **_: None) -> Self:
         # The `backend`` argument has no effect but we keep it here for
         # backwards compatibility because in `narwhals.stable.v1`
@@ -207,14 +187,6 @@ def columns(self) -> list[str]:
             )
         return self._cached_columns
 
-    def to_pandas(self) -> pd.DataFrame:
-        # only if version is v1, keep around for backcompat
-        return self.native.to_pandas()
-
-    def to_arrow(self) -> pa.Table:
-        # only if version is v1, keep around for backcompat
-        return self.native.to_pyarrow()
-
     def _with_version(self, version: Version) -> Self:
         return self.__class__(self.native, version=version)
 

src/narwhals/_ibis/interchange.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from narwhals import _interchange
+from narwhals._ibis.utils import native_to_narwhals_dtype
+from narwhals._utils import Implementation
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    import ibis.expr.types as ir
+    import ibis.expr.types.dataframe_interchange as ibis_dfi
+    import pandas as pd
+    import pyarrow as pa
+    from typing_extensions import Self
+
+    from narwhals.dtypes import DType
+
+
+class IbisDataFrame(_interchange.InterchangeFrameV1["ir.Table"]):
+    _implementation = Implementation.IBIS
+
+    def __init__(self, df: ir.Table | ibis_dfi.IbisDataFrame) -> None:
+        self._dfi: ibis_dfi.IbisDataFrame = df.__dataframe__()
+
+    @classmethod
+    def from_dfi(cls, df: ibis_dfi.IbisDataFrame) -> Self:
+        self = cls.__new__(cls)
+        self._dfi = df
+        return self
+
+    @property
+    def native(self) -> ir.Table:
+        return self._dfi._table
+
+    @property
+    def _df(self) -> ir.Table:
+        return self.native
+
+    def to_pandas(self) -> pd.DataFrame:
+        return self.native.to_pandas()
+
+    def to_arrow(self) -> pa.Table:
+        return self.native.to_pyarrow()
+
+    def get_column(self, name: str) -> IbisSeries:
+        return IbisSeries(self.native.select(name))
+
+    def column_names(self) -> list[str]:
+        return list(self.native.columns)
+
+    def select_columns_by_name(self, names: Sequence[str]) -> Self:
+        return self.from_dfi(self._dfi.select_columns_by_name(names))
+
+    @property
+    def schema(self) -> dict[str, DType]:
+        return {
+            name: native_to_narwhals_dtype(dtype, self._version)
+            for name, dtype in self.native.schema().fields.items()
+        }
+
+
+class IbisSeries(_interchange.InterchangeSeriesV1["ir.Table"]):
+    _implementation = Implementation.IBIS
+
+    def __init__(self, df: ir.Table) -> None:
+        self._native_series: ir.Table = df
+
+    @property
+    def dtype(self) -> DType:
+        native = next(iter(self._native_series.schema().values()))
+        # NOTE: `Concrete` (base class for `DataType`) has two bases that define `__hash__ = None`,
+        # and then decides to implement `__hash__`? Okay ...
+        return native_to_narwhals_dtype(native, self._version)  # type: ignore[arg-type]

src/narwhals/_interchange/__init__.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from narwhals._interchange.dataframe import (
+    InterchangeFrameV1 as InterchangeFrameV1,
+    InterchangeSeriesV1 as InterchangeSeriesV1,
+)