feat: validate library minimum version in compliant objects

narwhals/_arrow/dataframe.py

@@ -22,6 +22,7 @@
 from narwhals.utils import is_sequence_but_not_str
 from narwhals.utils import parse_columns_to_drop
 from narwhals.utils import scale_bytes
+from narwhals.utils import validate_backend_version
 
 if TYPE_CHECKING:
     from types import ModuleType
@@ -56,6 +57,7 @@ def __init__(
         self._implementation = Implementation.PYARROW
         self._backend_version = backend_version
         self._version = version
+        validate_backend_version(self._implementation, self._backend_version)
 
     def __narwhals_namespace__(self: Self) -> ArrowNamespace:
         from narwhals._arrow.namespace import ArrowNamespace

narwhals/_arrow/series.py

@@ -18,6 +18,7 @@
 from narwhals.utils import Implementation
 from narwhals.utils import generate_temporary_column_name
 from narwhals.utils import import_dtypes_module
+from narwhals.utils import validate_backend_version
 
 if TYPE_CHECKING:
     from types import ModuleType
@@ -54,6 +55,7 @@ def __init__(
         self._implementation = Implementation.PYARROW
         self._backend_version = backend_version
         self._version = version
+        validate_backend_version(self._implementation, self._backend_version)
 
     def _change_version(self: Self, version: Version) -> Self:
         return self.__class__(

narwhals/_dask/dataframe.py

@@ -11,11 +11,13 @@
 from narwhals._dask.utils import parse_exprs_and_named_exprs
 from narwhals._pandas_like.utils import native_to_narwhals_dtype
 from narwhals._pandas_like.utils import select_columns_by_name
+from narwhals.typing import CompliantLazyFrame
 from narwhals.utils import Implementation
 from narwhals.utils import flatten
 from narwhals.utils import generate_temporary_column_name
 from narwhals.utils import parse_columns_to_drop
 from narwhals.utils import parse_version
+from narwhals.utils import validate_backend_version
 
 if TYPE_CHECKING:
     from types import ModuleType
@@ -29,7 +31,6 @@
     from narwhals._dask.typing import IntoDaskExpr
     from narwhals.dtypes import DType
     from narwhals.utils import Version
-from narwhals.typing import CompliantLazyFrame
 
 
 class DaskLazyFrame(CompliantLazyFrame):
@@ -44,6 +45,7 @@ def __init__(
         self._backend_version = backend_version
         self._implementation = Implementation.DASK
         self._version = version
+        validate_backend_version(self._implementation, self._backend_version)
 
     def __native_namespace__(self: Self) -> ModuleType:
         if self._implementation is Implementation.DASK:

narwhals/_duckdb/dataframe.py

@@ -6,8 +6,10 @@
 from typing import Any
 
 from narwhals.dependencies import get_duckdb
+from narwhals.utils import Implementation
 from narwhals.utils import import_dtypes_module
 from narwhals.utils import parse_version
+from narwhals.utils import validate_backend_version
 
 if TYPE_CHECKING:
     from types import ModuleType
@@ -82,9 +84,15 @@ def native_to_narwhals_dtype(duckdb_dtype: str, version: Version) -> DType:
 
 
 class DuckDBInterchangeFrame:
-    def __init__(self, df: Any, version: Version) -> None:
+    _implementation = Implementation.DUCKDB
+
+    def __init__(
+        self, df: Any, *, backend_version: tuple[int, ...], version: Version
+    ) -> None:
         self._native_frame = df
         self._version = version
+        self._backend_version = backend_version
+        validate_backend_version(self._implementation, self._backend_version)
 
     def __narwhals_dataframe__(self) -> Any:
         return self
@@ -147,10 +155,14 @@ def to_arrow(self: Self) -> pa.Table:
         return self._native_frame.arrow()
 
     def _change_version(self: Self, version: Version) -> Self:
-        return self.__class__(self._native_frame, version=version)
+        return self.__class__(
+            self._native_frame, version=version, backend_version=self._backend_version
+        )
 
     def _from_native_frame(self: Self, df: Any) -> Self:
-        return self.__class__(df, version=self._version)
+        return self.__class__(
+            df, version=self._version, backend_version=self._backend_version
+        )
 
     def collect_schema(self) -> dict[str, DType]:
         return {

narwhals/_ibis/dataframe.py

@@ -5,7 +5,9 @@
 from typing import Any
 
 from narwhals.dependencies import get_ibis
+from narwhals.utils import Implementation
 from narwhals.utils import import_dtypes_module
+from narwhals.utils import validate_backend_version
 
 if TYPE_CHECKING:
     from types import ModuleType
@@ -69,9 +71,15 @@ def native_to_narwhals_dtype(ibis_dtype: Any, version: Version) -> DType:
 
 
 class IbisInterchangeFrame:
-    def __init__(self, df: Any, version: Version) -> None:
+    _implementation = Implementation.IBIS
+
+    def __init__(
+        self, df: Any, *, backend_version: tuple[int, ...], version: Version
+    ) -> None:
         self._native_frame = df
         self._version = version
+        self._backend_version = backend_version
+        validate_backend_version(self._implementation, self._backend_version)
 
     def __narwhals_dataframe__(self) -> Any:
         return self
@@ -125,10 +133,14 @@ def __getattr__(self, attr: str) -> Any:
         raise NotImplementedError(msg)
 
     def _change_version(self: Self, version: Version) -> Self:
-        return self.__class__(self._native_frame, version=version)
+        return self.__class__(
+            self._native_frame, version=version, backend_version=self._backend_version
+        )
 
     def _from_native_frame(self: Self, df: Any) -> Self:
-        return self.__class__(df, version=self._version)
+        return self.__class__(
+            df, version=self._version, backend_version=self._backend_version
+        )
 
     def collect_schema(self) -> dict[str, DType]:
         return {

narwhals/_pandas_like/dataframe.py

@@ -27,6 +27,7 @@
 from narwhals.utils import is_sequence_but_not_str
 from narwhals.utils import parse_columns_to_drop
 from narwhals.utils import scale_bytes
+from narwhals.utils import validate_backend_version
 
 if TYPE_CHECKING:
     from types import ModuleType
@@ -59,6 +60,7 @@ def __init__(
         self._implementation = implementation
         self._backend_version = backend_version
         self._version = version
+        validate_backend_version(self._implementation, self._backend_version)
 
     def __narwhals_dataframe__(self) -> Self:
         return self

narwhals/_pandas_like/series.py

@@ -24,6 +24,7 @@
 from narwhals.typing import CompliantSeries
 from narwhals.utils import Implementation
 from narwhals.utils import import_dtypes_module
+from narwhals.utils import validate_backend_version
 
 if TYPE_CHECKING:
     from types import ModuleType
@@ -94,6 +95,7 @@ def __init__(
         self._implementation = implementation
         self._backend_version = backend_version
         self._version = version
+        validate_backend_version(self._implementation, self._backend_version)
 
     def __native_namespace__(self: Self) -> ModuleType:
         if self._implementation in {

narwhals/_polars/dataframe.py

@@ -15,6 +15,7 @@
 from narwhals.utils import Implementation
 from narwhals.utils import is_sequence_but_not_str
 from narwhals.utils import parse_columns_to_drop
+from narwhals.utils import validate_backend_version
 
 if TYPE_CHECKING:
     from types import ModuleType
@@ -45,6 +46,7 @@ def __init__(
         self._backend_version = backend_version
         self._implementation = Implementation.POLARS
         self._version = version
+        validate_backend_version(self._implementation, self._backend_version)
 
     def __repr__(self: Self) -> str:  # pragma: no cover
         return "PolarsDataFrame"
@@ -343,6 +345,7 @@ def __init__(
         self._backend_version = backend_version
         self._implementation = Implementation.POLARS
         self._version = version
+        validate_backend_version(self._implementation, self._backend_version)
 
     def __repr__(self: Self) -> str:  # pragma: no cover
         return "PolarsLazyFrame"

narwhals/_polars/series.py

@@ -10,6 +10,7 @@
 from narwhals._polars.utils import narwhals_to_native_dtype
 from narwhals._polars.utils import native_to_narwhals_dtype
 from narwhals.utils import Implementation
+from narwhals.utils import validate_backend_version
 
 if TYPE_CHECKING:
     from types import ModuleType
@@ -38,6 +39,7 @@ def __init__(
         self._backend_version = backend_version
         self._implementation = Implementation.POLARS
         self._version = version
+        validate_backend_version(self._implementation, self._backend_version)
 
     def __repr__(self: Self) -> str:  # pragma: no cover
         return "PolarsSeries"

narwhals/_spark_like/dataframe.py

@@ -12,6 +12,7 @@
 from narwhals.utils import flatten
 from narwhals.utils import parse_columns_to_drop
 from narwhals.utils import parse_version
+from narwhals.utils import validate_backend_version
 
 if TYPE_CHECKING:
     from pyspark.sql import DataFrame
@@ -37,6 +38,7 @@ def __init__(
         self._backend_version = backend_version
         self._implementation = Implementation.PYSPARK
         self._version = version
+        validate_backend_version(self._implementation, self._backend_version)
 
     def __native_namespace__(self) -> Any:  # pragma: no cover
         if self._implementation is Implementation.PYSPARK:

narwhals/dependencies.py

@@ -87,16 +87,16 @@ def get_duckdb() -> Any:
     return sys.modules.get("duckdb", None)
 
 
-def get_dask_expr() -> Any:
-    """Get dask_expr module (if already imported - else return None)."""
-    return sys.modules.get("dask_expr", None)
-
-
 def get_ibis() -> Any:
     """Get ibis module (if already imported - else return None)."""
     return sys.modules.get("ibis", None)
 
 
+def get_dask_expr() -> Any:
+    """Get dask_expr module (if already imported - else return None)."""
+    return sys.modules.get("dask_expr", None)
+
+
 def get_pyspark() -> Any:  # pragma: no cover
     """Get pyspark module (if already imported - else return None)."""
     return sys.modules.get("pyspark", None)

narwhals/translate.py

@@ -709,8 +709,13 @@ def _from_native_impl(  # noqa: PLR0915
             else:
                 return native_object
             raise TypeError(msg)
+        import duckdb  # ignore-banned-import
+
+        backend_version = parse_version(duckdb.__version__)
         return DataFrame(
-            DuckDBInterchangeFrame(native_object, version=version),
+            DuckDBInterchangeFrame(
+                native_object, version=version, backend_version=backend_version
+            ),
             level="interchange",
         )
 
@@ -726,8 +731,13 @@ def _from_native_impl(  # noqa: PLR0915
                 )
                 raise TypeError(msg)
             return native_object
+        import ibis  # ignore-banned-import
+
+        backend_version = parse_version(ibis.__version__)
         return DataFrame(
-            IbisInterchangeFrame(native_object, version=version),
+            IbisInterchangeFrame(
+                native_object, version=version, backend_version=backend_version
+            ),
             level="interchange",
         )
 

narwhals/utils.py

@@ -16,6 +16,8 @@
 
 from narwhals.dependencies import get_cudf
 from narwhals.dependencies import get_dask_dataframe
+from narwhals.dependencies import get_duckdb
+from narwhals.dependencies import get_ibis
 from narwhals.dependencies import get_modin
 from narwhals.dependencies import get_pandas
 from narwhals.dependencies import get_polars
@@ -73,6 +75,10 @@ class Implementation(Enum):
     """Polars implementation."""
     DASK = auto()
     """Dask implementation."""
+    DUCKDB = auto()
+    """DuckDB implementation."""
+    IBIS = auto()
+    """Ibis implementation."""
 
     UNKNOWN = auto()
     """Unknown implementation."""
@@ -97,6 +103,8 @@ def from_native_namespace(
             get_pyspark_sql(): Implementation.PYSPARK,
             get_polars(): Implementation.POLARS,
             get_dask_dataframe(): Implementation.DASK,
+            get_duckdb(): Implementation.DUCKDB,
+            get_ibis(): Implementation.IBIS,
         }
         return mapping.get(native_namespace, Implementation.UNKNOWN)
 
@@ -245,6 +253,59 @@ def is_dask(self) -> bool:
         """
         return self is Implementation.DASK  # pragma: no cover
 
+    def is_duckdb(self) -> bool:
+        """Return whether implementation is DuckDB.
+
+        Returns:
+            Boolean.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame({"a": [1, 2, 3]})
+            >>> df = nw.from_native(df_native)
+            >>> df.implementation.is_duckdb()
+            False
+        """
+        return self is Implementation.DUCKDB  # pragma: no cover
+
+    def is_ibis(self) -> bool:
+        """Return whether implementation is Ibis.
+
+        Returns:
+            Boolean.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame({"a": [1, 2, 3]})
+            >>> df = nw.from_native(df_native)
+            >>> df.implementation.is_ibis()
+            False
+        """
+        return self is Implementation.IBIS  # pragma: no cover
+
+
+MIN_VERSIONS: dict[Implementation, tuple[int, ...]] = {
+    Implementation.PANDAS: (0, 25, 3),
+    Implementation.MODIN: (0, 25, 3),
+    Implementation.CUDF: (24, 10),
+    Implementation.PYARROW: (11,),
+    Implementation.PYSPARK: (3, 3),
+    Implementation.POLARS: (0, 20, 3),
+    Implementation.DASK: (2024, 10),
+    Implementation.DUCKDB: (1,),
+    Implementation.IBIS: (6,),
+}
+
+
+def validate_backend_version(
+    implementation: Implementation, backend_version: tuple[int, ...]
+) -> None:
+    if backend_version < (min_version := MIN_VERSIONS[implementation]):
+        msg = f"Minimum version of {implementation} supported by Narwhals is {min_version}, found: {backend_version}"
+        raise ValueError(msg)
+
 
 def import_dtypes_module(version: Version) -> DTypes:
     if version is Version.V1: