Merge branch 'main' into more-dedup-1

Author: dangotbanned

narwhals/_arrow/dataframe.py

@@ -46,9 +46,9 @@
     from narwhals._arrow.namespace import ArrowNamespace
     from narwhals._arrow.series import ArrowSeries
     from narwhals._arrow.typing import ArrowChunkedArray
-    from narwhals._arrow.typing import Indices
-    from narwhals._arrow.typing import Mask
-    from narwhals._arrow.typing import Order
+    from narwhals._arrow.typing import Indices  # type: ignore[attr-defined]
+    from narwhals._arrow.typing import Mask  # type: ignore[attr-defined]
+    from narwhals._arrow.typing import Order  # type: ignore[attr-defined]
     from narwhals.dtypes import DType
     from narwhals.typing import SizeUnit
     from narwhals.typing import _1DArray

narwhals/_arrow/expr.py

@@ -113,7 +113,7 @@ def func(df: ArrowDataFrame) -> list[ArrowSeries]:
             func,
             depth=0,
             function_name="col",
-            evaluate_output_names=lambda _df: list(column_names),
+            evaluate_output_names=lambda _df: column_names,
             alias_output_names=None,
             backend_version=backend_version,
             version=version,

narwhals/_arrow/series.py

@@ -44,9 +44,9 @@
     from narwhals._arrow.typing import ArrowArray
     from narwhals._arrow.typing import ArrowChunkedArray
     from narwhals._arrow.typing import Incomplete
-    from narwhals._arrow.typing import Indices
+    from narwhals._arrow.typing import Indices  # type: ignore[attr-defined]
     from narwhals._arrow.typing import NullPlacement
-    from narwhals._arrow.typing import Order
+    from narwhals._arrow.typing import Order  # type: ignore[attr-defined]
     from narwhals._arrow.typing import TieBreaker
     from narwhals._arrow.typing import _AsPyType
     from narwhals._arrow.typing import _BasicDataType
@@ -164,19 +164,19 @@ def __ne__(self: Self, other: object) -> Self:  # type: ignore[override]
 
     def __ge__(self: Self, other: Any) -> Self:
         ser, other = extract_native(self, other)
-        return self._from_native_series(pc.greater_equal(ser, other))  # type: ignore[arg-type]
+        return self._from_native_series(pc.greater_equal(ser, other))
 
     def __gt__(self: Self, other: Any) -> Self:
         ser, other = extract_native(self, other)
-        return self._from_native_series(pc.greater(ser, other))  # type: ignore[arg-type]
+        return self._from_native_series(pc.greater(ser, other))
 
     def __le__(self: Self, other: Any) -> Self:
         ser, other = extract_native(self, other)
-        return self._from_native_series(pc.less_equal(ser, other))  # type: ignore[arg-type]
+        return self._from_native_series(pc.less_equal(ser, other))
 
     def __lt__(self: Self, other: Any) -> Self:
         ser, other = extract_native(self, other)
-        return self._from_native_series(pc.less(ser, other))  # type: ignore[arg-type]
+        return self._from_native_series(pc.less(ser, other))
 
     def __and__(self: Self, other: Any) -> Self:
         ser, other = extract_native(self, other)
@@ -196,24 +196,24 @@ def __ror__(self: Self, other: Any) -> Self:
 
     def __add__(self: Self, other: Any) -> Self:
         ser, other = extract_native(self, other)
-        return self._from_native_series(pc.add(ser, other))  # type: ignore[arg-type]
+        return self._from_native_series(pc.add(ser, other))
 
     def __radd__(self: Self, other: Any) -> Self:
-        return self + other  # type: ignore[no-any-return]
+        return self + other
 
     def __sub__(self: Self, other: Any) -> Self:
         ser, other = extract_native(self, other)
         return self._from_native_series(pc.subtract(ser, other))
 
     def __rsub__(self: Self, other: Any) -> Self:
-        return (self - other) * (-1)  # type: ignore[no-any-return]
+        return (self - other) * (-1)
 
     def __mul__(self: Self, other: Any) -> Self:
         ser, other = extract_native(self, other)
         return self._from_native_series(pc.multiply(ser, other))
 
     def __rmul__(self: Self, other: Any) -> Self:
-        return self * other  # type: ignore[no-any-return]
+        return self * other
 
     def __pow__(self: Self, other: Any) -> Self:
         ser, other = extract_native(self, other)
@@ -381,10 +381,12 @@ def __narwhals_series__(self: Self) -> Self:
     def __getitem__(self: Self, idx: int) -> Any: ...
 
     @overload
-    def __getitem__(self: Self, idx: slice | Sequence[int] | pa.ChunkedArray) -> Self: ...
+    def __getitem__(
+        self: Self, idx: slice | Sequence[int] | ArrowChunkedArray
+    ) -> Self: ...
 
     def __getitem__(
-        self: Self, idx: int | slice | Sequence[int] | pa.ChunkedArray
+        self: Self, idx: int | slice | Sequence[int] | ArrowChunkedArray
     ) -> Any | Self:
         if isinstance(idx, int):
             return maybe_extract_py_scalar(
@@ -630,7 +632,7 @@ def sample(
         rng = np.random.default_rng(seed=seed)
         idx = np.arange(0, num_rows)
         mask = rng.choice(idx, size=n, replace=with_replacement)
-        return self._from_native_series(ser.take(mask))
+        return self._from_native_series(ser.take(mask))  # pyright: ignore[reportArgumentType]
 
     def fill_null(
         self: Self,
@@ -690,7 +692,7 @@ def to_frame(self: Self) -> ArrowDataFrame:
             validate_column_names=False,
         )
 
-    def to_pandas(self: Self) -> pd.Series:
+    def to_pandas(self: Self) -> pd.Series[Any]:
         import pandas as pd  # ignore-banned-import()
 
         return pd.Series(self._native_series, name=self.name)  # pyright: ignore[reportArgumentType, reportCallIssue]

narwhals/_arrow/series_str.py

@@ -2,6 +2,7 @@
 
 import string
 from typing import TYPE_CHECKING
+from typing import Any
 
 import pyarrow.compute as pc
 
@@ -75,7 +76,7 @@ def to_datetime(self: Self, format: str | None) -> ArrowSeries:  # noqa: A002
         native = self._compliant_series._native_series
         format = parse_datetime_format(native) if format is None else format
         strptime: Incomplete = pc.strptime
-        timestamp_array: pa.Array[pa.TimestampScalar] = strptime(
+        timestamp_array: pa.Array[pa.TimestampScalar[Any, Any]] = strptime(
             native, format=format, unit="us"
         )
         return self._compliant_series._from_native_series(timestamp_array)

narwhals/_arrow/utils.py

@@ -179,7 +179,7 @@ def narwhals_to_native_dtype(dtype: DType | type[DType], version: Version) -> pa
     if isinstance_or_issubclass(dtype, dtypes.Categorical):
         return pa.dictionary(pa.uint32(), pa.string())
     if isinstance_or_issubclass(dtype, dtypes.Datetime):
-        return pa.timestamp(dtype.time_unit, tz=dtype.time_zone)  # type: ignore[arg-type]
+        return pa.timestamp(dtype.time_unit, tz=dtype.time_zone)  # pyright: ignore[reportArgumentType]
     if isinstance_or_issubclass(dtype, dtypes.Duration):
         return pa.duration(dtype.time_unit)
     if isinstance_or_issubclass(dtype, dtypes.Date):
@@ -222,7 +222,7 @@ def extract_native(
         return lhs._native_series, lit(None, type=lhs._native_series.type)
 
     if isinstance(rhs, ArrowDataFrame):
-        return NotImplemented  # type: ignore[no-any-return]
+        return NotImplemented
 
     if isinstance(rhs, ArrowSeries):
         if lhs._broadcast and not rhs._broadcast:

narwhals/_dask/expr.py

@@ -108,7 +108,7 @@ def func(df: DaskLazyFrame) -> list[dx.Series]:
             func,
             depth=0,
             function_name="col",
-            evaluate_output_names=lambda _df: list(column_names),
+            evaluate_output_names=lambda _df: column_names,
             alias_output_names=None,
             backend_version=backend_version,
             version=version,

narwhals/_duckdb/dataframe.py

@@ -282,7 +282,7 @@ def join(
                 raise NotImplementedError(msg)
             rel = self._native_frame.set_alias("lhs").cross(  # pragma: no cover
                 other._native_frame.set_alias("rhs")
-            )  # type: ignore[operator]
+            )
         else:
             # help mypy
             assert left_on is not None  # noqa: S101

narwhals/_duckdb/expr.py

@@ -87,7 +87,7 @@ def func(_: DuckDBLazyFrame) -> list[duckdb.Expression]:
         return cls(
             func,
             function_name="col",
-            evaluate_output_names=lambda _df: list(column_names),
+            evaluate_output_names=lambda _df: column_names,
             alias_output_names=None,
             backend_version=backend_version,
             version=version,
@@ -403,7 +403,7 @@ def var(self: Self, ddof: int) -> Self:
         def _var(_input: duckdb.Expression) -> duckdb.Expression:
             n_samples = FunctionExpression("count", _input)
             # NOTE: Not implemented Error: Unable to transform python value of type '<class 'duckdb.duckdb.Expression'>' to DuckDB LogicalType
-            return FunctionExpression("var_pop", _input) * n_samples / (n_samples - ddof)  # type: ignore[operator]
+            return FunctionExpression("var_pop", _input) * n_samples / (n_samples - ddof)  # type: ignore[operator, no-any-return]
 
         return self._from_call(_var, "var")
 

narwhals/_duckdb/utils.py

@@ -161,12 +161,12 @@ def narwhals_to_native_dtype(dtype: DType | type[DType], version: Version) -> st
     if isinstance_or_issubclass(dtype, dtypes.Date):  # pragma: no cover
         return "DATE"
     if isinstance_or_issubclass(dtype, dtypes.List):
-        inner = narwhals_to_native_dtype(dtype.inner, version)  # type: ignore[union-attr]
+        inner = narwhals_to_native_dtype(dtype.inner, version)
         return f"{inner}[]"
     if isinstance_or_issubclass(dtype, dtypes.Struct):  # pragma: no cover
         inner = ", ".join(
             f'"{field.name}" {narwhals_to_native_dtype(field.dtype, version)}'
-            for field in dtype.fields  # type: ignore[union-attr]
+            for field in dtype.fields
         )
         return f"STRUCT({inner})"
     if isinstance_or_issubclass(dtype, dtypes.Array):  # pragma: no cover

narwhals/_expression_parsing.py

@@ -476,7 +476,7 @@ def infer_kind(obj: IntoExpr | _1DArray | object, *, str_as_lit: bool) -> ExprKi
 
 
 def apply_n_ary_operation(
-    plx: CompliantNamespace,
+    plx: CompliantNamespace[Any, Any],
     function: Any,
     *comparands: IntoExpr,
     str_as_lit: bool,