chore: enable more Ruff rules (RET505, A005, ISC001, PD003) (#2923)

Author: EdAbati

narwhals/__init__.py

@@ -181,6 +181,5 @@ def __getattr__(name: _t.Literal["__version__"]) -> str:  # type: ignore[misc]
 
         __version__ = metadata.version(__name__)
         return __version__
-    else:
-        msg = f"module {__name__!r} has no attribute {name!r}"
-        raise AttributeError(msg)
+    msg = f"module {__name__!r} has no attribute {name!r}"
+    raise AttributeError(msg)

narwhals/_arrow/dataframe.py

@@ -497,11 +497,10 @@ def head(self, n: int) -> Self:
         df = self.native
         if n >= 0:
             return self._with_native(df.slice(0, n), validate_column_names=False)
-        else:
-            num_rows = df.num_rows
-            return self._with_native(
-                df.slice(0, max(0, num_rows + n)), validate_column_names=False
-            )
+        num_rows = df.num_rows
+        return self._with_native(
+            df.slice(0, max(0, num_rows + n)), validate_column_names=False
+        )
 
     def tail(self, n: int) -> Self:
         df = self.native
@@ -510,13 +509,12 @@ def tail(self, n: int) -> Self:
             return self._with_native(
                 df.slice(max(0, num_rows - n)), validate_column_names=False
             )
-        else:
-            return self._with_native(df.slice(abs(n)), validate_column_names=False)
+        return self._with_native(df.slice(abs(n)), validate_column_names=False)
 
     def lazy(self, *, backend: Implementation | None = None) -> CompliantLazyFrameAny:
         if backend is None:
             return self
-        elif backend is Implementation.DUCKDB:
+        if backend is Implementation.DUCKDB:
             import duckdb  # ignore-banned-import
 
             from narwhals._duckdb.dataframe import DuckDBLazyFrame
@@ -525,7 +523,7 @@ def lazy(self, *, backend: Implementation | None = None) -> CompliantLazyFrameAn
             return DuckDBLazyFrame(
                 duckdb.table("df"), validate_backend_version=True, version=self._version
             )
-        elif backend is Implementation.POLARS:
+        if backend is Implementation.POLARS:
             import polars as pl  # ignore-banned-import
 
             from narwhals._polars.dataframe import PolarsLazyFrame
@@ -535,7 +533,7 @@ def lazy(self, *, backend: Implementation | None = None) -> CompliantLazyFrameAn
                 validate_backend_version=True,
                 version=self._version,
             )
-        elif backend is Implementation.DASK:
+        if backend is Implementation.DASK:
             import dask.dataframe as dd  # ignore-banned-import
 
             from narwhals._dask.dataframe import DaskLazyFrame
@@ -545,7 +543,7 @@ def lazy(self, *, backend: Implementation | None = None) -> CompliantLazyFrameAn
                 validate_backend_version=True,
                 version=self._version,
             )
-        elif backend.is_ibis():
+        if backend.is_ibis():
             import ibis  # ignore-banned-import
 
             from narwhals._ibis.dataframe import IbisLazyFrame
@@ -609,7 +607,7 @@ def item(self, row: int | None, column: int | str | None) -> Any:
                 raise ValueError(msg)
             return maybe_extract_py_scalar(self.native[0][0], return_py_scalar=True)
 
-        elif row is None or column is None:
+        if row is None or column is None:
             msg = "cannot call `.item()` with only one of `row` or `column`"
             raise ValueError(msg)
 

narwhals/_arrow/series.py

@@ -380,29 +380,27 @@ def skew(self, *, _return_py_scalar: bool = True) -> float | None:
         ser_not_null = self.native.drop_null()
         if len(ser_not_null) == 0:
             return None
-        elif len(ser_not_null) == 1:
+        if len(ser_not_null) == 1:
             return float("nan")
-        elif len(ser_not_null) == 2:
+        if len(ser_not_null) == 2:
             return 0.0
-        else:
-            m = pc.subtract(ser_not_null, pc.mean(ser_not_null))
-            m2 = pc.mean(pc.power(m, lit(2)))
-            m3 = pc.mean(pc.power(m, lit(3)))
-            biased_population_skewness = pc.divide(m3, pc.power(m2, lit(1.5)))
-            return maybe_extract_py_scalar(biased_population_skewness, _return_py_scalar)
+        m = pc.subtract(ser_not_null, pc.mean(ser_not_null))
+        m2 = pc.mean(pc.power(m, lit(2)))
+        m3 = pc.mean(pc.power(m, lit(3)))
+        biased_population_skewness = pc.divide(m3, pc.power(m2, lit(1.5)))
+        return maybe_extract_py_scalar(biased_population_skewness, _return_py_scalar)
 
     def kurtosis(self, *, _return_py_scalar: bool = True) -> float | None:
         ser_not_null = self.native.drop_null()
         if len(ser_not_null) == 0:
             return None
-        elif len(ser_not_null) == 1:
+        if len(ser_not_null) == 1:
             return float("nan")
-        else:
-            m = pc.subtract(ser_not_null, pc.mean(ser_not_null))
-            m2 = pc.mean(pc.power(m, lit(2)))
-            m4 = pc.mean(pc.power(m, lit(4)))
-            k = pc.subtract(pc.divide(m4, pc.power(m2, lit(2))), lit(3))
-            return maybe_extract_py_scalar(k, _return_py_scalar)
+        m = pc.subtract(ser_not_null, pc.mean(ser_not_null))
+        m2 = pc.mean(pc.power(m, lit(2)))
+        m4 = pc.mean(pc.power(m, lit(4)))
+        k = pc.subtract(pc.divide(m4, pc.power(m2, lit(2))), lit(3))
+        return maybe_extract_py_scalar(k, _return_py_scalar)
 
     def count(self, *, _return_py_scalar: bool = True) -> int:
         return maybe_extract_py_scalar(pc.count(self.native), _return_py_scalar)
@@ -563,16 +561,14 @@ def null_count(self, *, _return_py_scalar: bool = True) -> int:
     def head(self, n: int) -> Self:
         if n >= 0:
             return self._with_native(self.native.slice(0, n))
-        else:
-            num_rows = len(self)
-            return self._with_native(self.native.slice(0, max(0, num_rows + n)))
+        num_rows = len(self)
+        return self._with_native(self.native.slice(0, max(0, num_rows + n)))
 
     def tail(self, n: int) -> Self:
         if n >= 0:
             num_rows = len(self)
             return self._with_native(self.native.slice(max(0, num_rows - n)))
-        else:
-            return self._with_native(self.native.slice(abs(n)))
+        return self._with_native(self.native.slice(abs(n)))
 
     def is_in(self, other: Any) -> Self:
         if self._is_native(other):

narwhals/_arrow/series_dt.py

@@ -98,13 +98,12 @@ def timestamp(self, time_unit: TimeUnit) -> ArrowSeries:
                 msg = f"unexpected time unit {current}, please report an issue at https://github.com/narwhals-dev/narwhals"
                 raise AssertionError(msg)
             return self.with_native(result)
-        elif isinstance(ser.dtype, dtypes.Date):
+        if isinstance(ser.dtype, dtypes.Date):
             time_s = pc.multiply(self.native.cast(pa.int32()), lit(SECONDS_PER_DAY))
             factor = self._TIMESTAMP_DATE_FACTOR[time_unit]
             return self.with_native(pc.multiply(time_s, lit(factor)))
-        else:
-            msg = "Input should be either of Date or Datetime type"
-            raise TypeError(msg)
+        msg = "Input should be either of Date or Datetime type"
+        raise TypeError(msg)
 
     def date(self) -> ArrowSeries:
         return self.with_native(self.native.cast(pa.date32()))

narwhals/_arrow/utils.py

@@ -88,8 +88,7 @@ def chunked_array(
         return arr
     if isinstance(arr, list):
         return pa.chunked_array(arr, dtype)
-    else:
-        return pa.chunked_array([arr], arr.type)
+    return pa.chunked_array([arr], arr.type)
 
 
 def nulls_like(n: int, series: ArrowSeries) -> ArrayAny:
@@ -381,7 +380,7 @@ def _parse_date_format(arr: pc.StringArray) -> str:
         matches = pc.extract_regex(arr, pattern=date_rgx)
         if date_fmt == "%Y%m%d" and pc.all(matches.is_valid()).as_py():
             return date_fmt
-        elif (
+        if (
             pc.all(matches.is_valid()).as_py()
             and pc.count(pc.unique(sep1 := matches.field("sep1"))).as_py() == 1
             and pc.count(pc.unique(sep2 := matches.field("sep2"))).as_py() == 1

narwhals/_compliant/group_by.py

@@ -81,8 +81,7 @@ def _parse_keys(
         if is_sequence_of(keys, str):
             keys_str = list(keys)
             return compliant_frame, keys_str, keys_str.copy()
-        else:
-            return self._parse_expr_keys(compliant_frame, keys=keys)
+        return self._parse_expr_keys(compliant_frame, keys=keys)
 
     @staticmethod
     def _parse_expr_keys(

narwhals/_compliant/namespace.py

@@ -135,9 +135,8 @@ def _lazyframe(self) -> type[CompliantLazyFrameT]: ...
     def from_native(self, data: NativeFrameT_co | Any, /) -> CompliantLazyFrameT:
         if self._lazyframe._is_native(data):
             return self._lazyframe.from_native(data, context=self)
-        else:  # pragma: no cover
-            msg = f"Unsupported type: {type(data).__name__!r}"
-            raise TypeError(msg)
+        msg = f"Unsupported type: {type(data).__name__!r}"  # pragma: no cover
+        raise TypeError(msg)
 
 
 class EagerNamespace(
@@ -165,7 +164,7 @@ def from_native(
     ) -> EagerDataFrameT | EagerSeriesT:
         if self._dataframe._is_native(data):
             return self._dataframe.from_native(data, context=self)
-        elif self._series._is_native(data):
+        if self._series._is_native(data):
             return self._series.from_native(data, context=self)
         msg = f"Unsupported type: {type(data).__name__!r}"
         raise TypeError(msg)

narwhals/_compliant/series.py

@@ -352,12 +352,11 @@ def _gather_slice(self, rows: _SliceIndex | range) -> Self: ...
     def __getitem__(self, item: MultiIndexSelector[Self]) -> Self:
         if isinstance(item, (slice, range)):
             return self._gather_slice(item)
-        elif is_compliant_series(item):
+        if is_compliant_series(item):
             return self._gather(item.native)
-        elif is_sized_multi_index_selector(item):
+        elif is_sized_multi_index_selector(item):  # noqa: RET505
             return self._gather(item)
-        else:
-            assert_never(item)
+        assert_never(item)
 
     @property
     def str(self) -> EagerSeriesStringNamespace[Self, NativeSeriesT]: ...

narwhals/_dask/dataframe.py

@@ -219,19 +219,14 @@ def with_row_index(self, name: str, order_by: Sequence[str] | None) -> Self:
         # https://stackoverflow.com/questions/60831518/in-dask-how-does-one-add-a-range-of-integersauto-increment-to-a-new-column/60852409#60852409
         if order_by is None:
             return self._with_native(add_row_index(self.native, name))
-        else:
-            plx = self.__narwhals_namespace__()
-            columns = self.columns
-            const_expr = (
-                plx.lit(value=1, dtype=None).alias(name).broadcast(ExprKind.LITERAL)
-            )
-            row_index_expr = (
-                plx.col(name)
-                .cum_sum(reverse=False)
-                .over(partition_by=[], order_by=order_by)
-                - 1
-            )
-            return self.with_columns(const_expr).select(row_index_expr, plx.col(*columns))
+        plx = self.__narwhals_namespace__()
+        columns = self.columns
+        const_expr = plx.lit(value=1, dtype=None).alias(name).broadcast(ExprKind.LITERAL)
+        row_index_expr = (
+            plx.col(name).cum_sum(reverse=False).over(partition_by=[], order_by=order_by)
+            - 1
+        )
+        return self.with_columns(const_expr).select(row_index_expr, plx.col(*columns))
 
     def rename(self, mapping: Mapping[str, str]) -> Self:
         return self._with_native(self.native.rename(columns=mapping))
@@ -450,9 +445,10 @@ def tail(self, n: int) -> Self:  # pragma: no cover
 
         if n_partitions == 1:
             return self._with_native(self.native.tail(n=n, compute=False))
-        else:
-            msg = "`LazyFrame.tail` is not supported for Dask backend with multiple partitions."
-            raise NotImplementedError(msg)
+        msg = (
+            "`LazyFrame.tail` is not supported for Dask backend with multiple partitions."
+        )
+        raise NotImplementedError(msg)
 
     def gather_every(self, n: int, offset: int) -> Self:
         row_index_token = generate_temporary_column_name(n_bytes=8, columns=self.columns)

narwhals/_dask/expr.py

@@ -397,9 +397,8 @@ def rolling_var(
                 ).var(),
                 "rolling_var",
             )
-        else:
-            msg = "Dask backend only supports `ddof=1` for `rolling_var`"
-            raise NotImplementedError(msg)
+        msg = "Dask backend only supports `ddof=1` for `rolling_var`"
+        raise NotImplementedError(msg)
 
     def rolling_std(
         self, window_size: int, *, min_samples: int, center: bool, ddof: int
@@ -411,9 +410,8 @@ def rolling_std(
                 ).std(),
                 "rolling_std",
             )
-        else:
-            msg = "Dask backend only supports `ddof=1` for `rolling_std`"
-            raise NotImplementedError(msg)
+        msg = "Dask backend only supports `ddof=1` for `rolling_std`"
+        raise NotImplementedError(msg)
 
     def sum(self) -> Self:
         return self._with_callable(lambda expr: expr.sum().to_series(), "sum")
@@ -520,9 +518,8 @@ def func(expr: dx.Series, quantile: float) -> dx.Series:
                 ).to_series()  # pragma: no cover
 
             return self._with_callable(func, "quantile", quantile=quantile)
-        else:
-            msg = "`higher`, `lower`, `midpoint`, `nearest` - interpolation methods are not supported by Dask. Please use `linear` instead."
-            raise NotImplementedError(msg)
+        msg = "`higher`, `lower`, `midpoint`, `nearest` - interpolation methods are not supported by Dask. Please use `linear` instead."
+        raise NotImplementedError(msg)
 
     def is_first_distinct(self) -> Self:
         def func(expr: dx.Series) -> dx.Series: