chore: widen parse_version to accept packages

Little bit of #1942 When combined with another change, a lot of cases might become one-liners (#1657 (comment))
narwhals-dev · Feb 8, 2025 · a14fe62 · a14fe62
1 parent 62089ce
commit a14fe62
Show file tree

Hide file tree

Showing 16 changed files with 75 additions and 84 deletions.
diff --git a/narwhals/_arrow/dataframe.py b/narwhals/_arrow/dataframe.py
@@ -555,7 +555,7 @@ def lazy(self: Self, *, backend: Implementation | None = None) -> CompliantLazyF
             df = self._native_frame  # noqa: F841
             return DuckDBLazyFrame(
                 df=duckdb.table("df"),
-                backend_version=parse_version(duckdb.__version__),
+                backend_version=parse_version(duckdb),
                 version=self._version,
                 validate_column_names=False,
             )
@@ -566,7 +566,7 @@ def lazy(self: Self, *, backend: Implementation | None = None) -> CompliantLazyF
 
             return PolarsLazyFrame(
                 df=pl.from_arrow(self._native_frame).lazy(),  # type: ignore[union-attr]
-                backend_version=parse_version(pl.__version__),
+                backend_version=parse_version(pl),
                 version=self._version,
             )
         elif backend is Implementation.DASK:
@@ -577,7 +577,7 @@ def lazy(self: Self, *, backend: Implementation | None = None) -> CompliantLazyF
 
             return DaskLazyFrame(
                 native_dataframe=dd.from_pandas(self._native_frame.to_pandas()),
-                backend_version=parse_version(dask.__version__),
+                backend_version=parse_version(dask),
                 version=self._version,
                 validate_column_names=False,
             )
@@ -606,7 +606,7 @@ def collect(
             return PandasLikeDataFrame(
                 native_dataframe=self._native_frame.to_pandas(),
                 implementation=Implementation.PANDAS,
-                backend_version=parse_version(pd.__version__),
+                backend_version=parse_version(pd),
                 version=self._version,
                 validate_column_names=False,
             )
@@ -618,7 +618,7 @@ def collect(
 
             return PolarsDataFrame(
                 df=pl.from_arrow(self._native_frame),  # type: ignore[arg-type]
-                backend_version=parse_version(pl.__version__),
+                backend_version=parse_version(pl),
                 version=self._version,
             )
 

diff --git a/narwhals/_dask/dataframe.py b/narwhals/_dask/dataframe.py
@@ -106,7 +106,7 @@ def collect(
             return PandasLikeDataFrame(
                 result,
                 implementation=Implementation.PANDAS,
-                backend_version=parse_version(pd.__version__),
+                backend_version=parse_version(pd),
                 version=self._version,
                 validate_column_names=False,
             )
@@ -118,7 +118,7 @@ def collect(
 
             return PolarsDataFrame(
                 pl.from_pandas(result),
-                backend_version=parse_version(pl.__version__),
+                backend_version=parse_version(pl),
                 version=self._version,
             )
 
@@ -129,7 +129,7 @@ def collect(
 
             return ArrowDataFrame(
                 pa.Table.from_pandas(result),
-                backend_version=parse_version(pa.__version__),
+                backend_version=parse_version(pa),
                 version=self._version,
                 validate_column_names=False,
             )

diff --git a/narwhals/_dask/utils.py b/narwhals/_dask/utils.py
@@ -129,9 +129,7 @@ def narwhals_to_native_dtype(dtype: DType | type[DType], version: Version) -> An
     if isinstance_or_issubclass(dtype, dtypes.UInt8):
         return "uint8"
     if isinstance_or_issubclass(dtype, dtypes.String):
-        if (pd := get_pandas()) is not None and parse_version(
-            pd.__version__
-        ) >= parse_version("2.0.0"):
+        if (pd := get_pandas()) is not None and parse_version(pd) >= (2, 0, 0):
             if get_pyarrow() is not None:
                 return "string[pyarrow]"
             return "string[python]"  # pragma: no cover

diff --git a/narwhals/_duckdb/dataframe.py b/narwhals/_duckdb/dataframe.py
@@ -100,7 +100,7 @@ def collect(
 
             return ArrowDataFrame(
                 native_dataframe=self._native_frame.arrow(),
-                backend_version=parse_version(pa.__version__),
+                backend_version=parse_version(pa),
                 version=self._version,
                 validate_column_names=False,
             )
@@ -113,7 +113,7 @@ def collect(
             return PandasLikeDataFrame(
                 native_dataframe=self._native_frame.df(),
                 implementation=Implementation.PANDAS,
-                backend_version=parse_version(pd.__version__),
+                backend_version=parse_version(pd),
                 version=self._version,
                 validate_column_names=False,
             )
@@ -125,7 +125,7 @@ def collect(
 
             return PolarsDataFrame(
                 df=self._native_frame.pl(),
-                backend_version=parse_version(pl.__version__),
+                backend_version=parse_version(pl),
                 version=self._version,
             )
 
@@ -257,7 +257,7 @@ def to_pandas(self: Self) -> pd.DataFrame:
         # only if version is v1, keep around for backcompat
         import pandas as pd  # ignore-banned-import()
 
-        if parse_version(pd.__version__) >= parse_version("1.0.0"):
+        if parse_version(pd) >= (1, 0, 0):
             return self._native_frame.df()
         else:  # pragma: no cover
             msg = f"Conversion to pandas requires pandas>=1.0.0, found {pd.__version__}"

diff --git a/narwhals/_interchange/dataframe.py b/narwhals/_interchange/dataframe.py
@@ -115,7 +115,7 @@ def __getitem__(self: Self, item: str) -> InterchangeSeries:
     def to_pandas(self: Self) -> pd.DataFrame:
         import pandas as pd  # ignore-banned-import()
 
-        if parse_version(pd.__version__) >= parse_version("1.5.0"):
+        if parse_version(pd) >= (1, 5, 0):
             return pd.api.interchange.from_dataframe(self._interchange_frame)
         else:  # pragma: no cover
             msg = (

diff --git a/narwhals/_pandas_like/dataframe.py b/narwhals/_pandas_like/dataframe.py
@@ -565,7 +565,7 @@ def collect(
             return PandasLikeDataFrame(
                 self.to_pandas(),
                 implementation=Implementation.PANDAS,
-                backend_version=parse_version(pd.__version__),
+                backend_version=parse_version(pd),
                 version=self._version,
                 validate_column_names=False,
             )
@@ -577,7 +577,7 @@ def collect(
 
             return ArrowDataFrame(
                 native_dataframe=self.to_arrow(),
-                backend_version=parse_version(pa.__version__),
+                backend_version=parse_version(pa),
                 version=self._version,
                 validate_column_names=False,
             )
@@ -589,7 +589,7 @@ def collect(
 
             return PolarsDataFrame(
                 df=self.to_polars(),
-                backend_version=parse_version(pl.__version__),
+                backend_version=parse_version(pl),
                 version=self._version,
             )
 
@@ -810,7 +810,7 @@ def lazy(self: Self, *, backend: Implementation | None = None) -> CompliantLazyF
 
             return DuckDBLazyFrame(
                 df=duckdb.table("pandas_df"),
-                backend_version=parse_version(duckdb.__version__),
+                backend_version=parse_version(duckdb),
                 version=self._version,
                 validate_column_names=False,
             )
@@ -821,7 +821,7 @@ def lazy(self: Self, *, backend: Implementation | None = None) -> CompliantLazyF
 
             return PolarsLazyFrame(
                 df=pl.from_pandas(pandas_df).lazy(),
-                backend_version=parse_version(pl.__version__),
+                backend_version=parse_version(pl),
                 version=self._version,
             )
         elif backend is Implementation.DASK:
@@ -832,7 +832,7 @@ def lazy(self: Self, *, backend: Implementation | None = None) -> CompliantLazyF
 
             return DaskLazyFrame(
                 native_dataframe=dd.from_pandas(pandas_df),
-                backend_version=parse_version(dask.__version__),
+                backend_version=parse_version(dask),
                 version=self._version,
                 validate_column_names=False,
             )

diff --git a/narwhals/_polars/dataframe.py b/narwhals/_polars/dataframe.py
@@ -250,7 +250,7 @@ def lazy(self: Self, *, backend: Implementation | None = None) -> CompliantLazyF
             df = self._native_frame  # noqa: F841
             return DuckDBLazyFrame(
                 df=duckdb.table("df"),
-                backend_version=parse_version(duckdb.__version__),
+                backend_version=parse_version(duckdb),
                 version=self._version,
                 validate_column_names=False,
             )
@@ -262,7 +262,7 @@ def lazy(self: Self, *, backend: Implementation | None = None) -> CompliantLazyF
 
             return DaskLazyFrame(
                 native_dataframe=dd.from_pandas(self._native_frame.to_pandas()),
-                backend_version=parse_version(dask.__version__),
+                backend_version=parse_version(dask),
                 version=self._version,
                 validate_column_names=False,
             )
@@ -470,7 +470,7 @@ def collect(
             return PandasLikeDataFrame(
                 result.to_pandas(),
                 implementation=Implementation.PANDAS,
-                backend_version=parse_version(pd.__version__),
+                backend_version=parse_version(pd),
                 version=self._version,
                 validate_column_names=False,
             )
@@ -482,7 +482,7 @@ def collect(
 
             return ArrowDataFrame(
                 result.to_arrow(),
-                backend_version=parse_version(pa.__version__),
+                backend_version=parse_version(pa),
                 version=self._version,
                 validate_column_names=False,
             )

diff --git a/narwhals/_spark_like/dataframe.py b/narwhals/_spark_like/dataframe.py
@@ -125,7 +125,7 @@ def collect(
             return PandasLikeDataFrame(
                 native_dataframe=self._native_frame.toPandas(),
                 implementation=Implementation.PANDAS,
-                backend_version=parse_version(pd.__version__),
+                backend_version=parse_version(pd),
                 version=self._version,
                 validate_column_names=False,
             )
@@ -159,7 +159,7 @@ def collect(
                     raise
             return ArrowDataFrame(
                 native_pyarrow_frame,
-                backend_version=parse_version(pa.__version__),
+                backend_version=parse_version(pa),
                 version=self._version,
                 validate_column_names=False,
             )
@@ -174,7 +174,7 @@ def collect(
                 df=pl.from_arrow(  # type: ignore[arg-type]
                     pa.Table.from_batches(self._native_frame._collect_as_arrow())
                 ),
-                backend_version=parse_version(pl.__version__),
+                backend_version=parse_version(pl),
                 version=self._version,
             )
 

diff --git a/narwhals/_spark_like/expr.py b/narwhals/_spark_like/expr.py
@@ -350,7 +350,7 @@ def median(self: Self) -> Self:
         def _median(_input: Column) -> Column:
             import pyspark  # ignore-banned-import
 
-            if parse_version(pyspark.__version__) < (3, 4):
+            if parse_version(pyspark) < (3, 4):
                 # Use percentile_approx with default accuracy parameter (10000)
                 return self._F.percentile_approx(_input.cast("double"), 0.5)
 
@@ -377,12 +377,7 @@ def std(self: Self, ddof: int) -> Self:
 
         from narwhals._spark_like.utils import _std
 
-        func = partial(
-            _std,
-            ddof=ddof,
-            np_version=parse_version(np.__version__),
-            functions=self._F,
-        )
+        func = partial(_std, ddof=ddof, np_version=parse_version(np), functions=self._F)
 
         return self._from_call(func, "std", expr_kind=ExprKind.AGGREGATION)
 
@@ -393,12 +388,7 @@ def var(self: Self, ddof: int) -> Self:
 
         from narwhals._spark_like.utils import _var
 
-        func = partial(
-            _var,
-            ddof=ddof,
-            np_version=parse_version(np.__version__),
-            functions=self._F,
-        )
+        func = partial(_var, ddof=ddof, np_version=parse_version(np), functions=self._F)
 
         return self._from_call(func, "var", expr_kind=ExprKind.AGGREGATION)
 

diff --git a/narwhals/dataframe.py b/narwhals/dataframe.py
@@ -500,7 +500,7 @@ def __arrow_c_stream__(self: Self, requested_schema: object | None = None) -> ob
         except ModuleNotFoundError as exc:  # pragma: no cover
             msg = f"PyArrow>=14.0.0 is required for `DataFrame.__arrow_c_stream__` for object of type {type(native_frame)}"
             raise ModuleNotFoundError(msg) from exc
-        if parse_version(pa.__version__) < (14, 0):  # pragma: no cover
+        if parse_version(pa) < (14, 0):  # pragma: no cover
             msg = f"PyArrow>=14.0.0 is required for `DataFrame.__arrow_c_stream__` for object of type {type(native_frame)}"
             raise ModuleNotFoundError(msg) from None
         pa_table = self.to_arrow()

diff --git a/narwhals/functions.py b/narwhals/functions.py
@@ -344,7 +344,7 @@ def _new_series_impl(
                 narwhals_to_native_dtype as pandas_like_narwhals_to_native_dtype,
             )
 
-            backend_version = parse_version(native_namespace.__version__)
+            backend_version = parse_version(native_namespace)
             pd_dtype = pandas_like_narwhals_to_native_dtype(
                 dtype, None, implementation, backend_version, version
             )
@@ -740,7 +740,7 @@ def _from_numpy_impl(
                 narwhals_to_native_dtype as pandas_like_narwhals_to_native_dtype,
             )
 
-            backend_version = parse_version(native_namespace.__version__)
+            backend_version = parse_version(native_namespace)
             pd_schema = {
                 name: pandas_like_narwhals_to_native_dtype(
                     dtype=schema[name],
@@ -855,9 +855,7 @@ def from_arrow(
         raise TypeError(msg)
     implementation = Implementation.from_native_namespace(native_namespace)
 
-    if implementation is Implementation.POLARS and parse_version(
-        native_namespace.__version__
-    ) >= (1, 3):
+    if implementation.is_polars() and parse_version(native_namespace) >= (1, 3):
         native_frame = native_namespace.DataFrame(native_frame)
     elif implementation in {
         Implementation.PANDAS,
@@ -872,7 +870,7 @@ def from_arrow(
         except ModuleNotFoundError as exc:  # pragma: no cover
             msg = f"PyArrow>=14.0.0 is required for `from_arrow` for object of type {native_namespace}"
             raise ModuleNotFoundError(msg) from exc
-        if parse_version(pa.__version__) < (14, 0):  # pragma: no cover
+        if parse_version(pa) < (14, 0):  # pragma: no cover
             msg = f"PyArrow>=14.0.0 is required for `from_arrow` for object of type {native_namespace}"
             raise ModuleNotFoundError(msg) from None
 

diff --git a/narwhals/schema.py b/narwhals/schema.py
@@ -150,7 +150,7 @@ def to_pandas(
         to_native_dtype = partial(
             narwhals_to_native_dtype,
             implementation=Implementation.PANDAS,
-            backend_version=parse_version(pd.__version__),
+            backend_version=parse_version(pd),
             version=self._version,
         )
         if dtype_backend is None or isinstance(dtype_backend, str):
@@ -206,6 +206,6 @@ def to_polars(self: Self) -> pl.Schema:
             (name, narwhals_to_native_dtype(dtype, self._version))
             for name, dtype in self.items()
         )
-        if parse_version(pl.__version__) >= (1, 0, 0):
+        if parse_version(pl) >= (1, 0, 0):
             return pl.Schema(schema)
         return cast("pl.Schema", dict(schema))  # pragma: no cover
diff --git a/narwhals/series.py b/narwhals/series.py
@@ -219,7 +219,7 @@ def __arrow_c_stream__(self: Self, requested_schema: object | None = None) -> ob
         except ModuleNotFoundError as exc:  # pragma: no cover
             msg = f"PyArrow>=16.0.0 is required for `Series.__arrow_c_stream__` for object of type {type(native_series)}"
             raise ModuleNotFoundError(msg) from exc
-        if parse_version(pa.__version__) < (16, 0):  # pragma: no cover
+        if parse_version(pa) < (16, 0):  # pragma: no cover
             msg = f"PyArrow>=16.0.0 is required for `Series.__arrow_c_stream__` for object of type {type(native_series)}"
             raise ModuleNotFoundError(msg)
         ca = pa.chunked_array([self.to_arrow()])  # type: ignore[call-overload, unused-ignore]