Merge branch 'main' into feat/with-row-index-by

FBruzzesi · FBruzzesi · commit fe5c3174c6ed · 2025-06-22T09:09:16.000+02:00
diff --git a/narwhals/_arrow/utils.py b/narwhals/_arrow/utils.py
@@ -237,15 +237,11 @@ def extract_native(
     If one of the two sides has a `_broadcast` flag, then extract the scalar
     underneath it so that PyArrow can do its own broadcasting.
     """
-    from narwhals._arrow.dataframe import ArrowDataFrame
     from narwhals._arrow.series import ArrowSeries
 
     if rhs is None:  # pragma: no cover
         return lhs.native, lit(None, type=lhs._type)
 
-    if isinstance(rhs, ArrowDataFrame):
-        return NotImplemented
-
     if isinstance(rhs, ArrowSeries):
         if lhs._broadcast and not rhs._broadcast:
             return lhs.native[0], rhs.native
diff --git a/narwhals/_dask/utils.py b/narwhals/_dask/utils.py
@@ -144,19 +144,19 @@ def narwhals_to_native_dtype(dtype: IntoDType, version: Version) -> Any:  # noqa
         return "timedelta64[ns]"
     if isinstance_or_issubclass(dtype, dtypes.List):  # pragma: no cover
         msg = "Converting to List dtype is not supported yet"
-        return NotImplementedError(msg)
+        raise NotImplementedError(msg)
     if isinstance_or_issubclass(dtype, dtypes.Struct):  # pragma: no cover
         msg = "Converting to Struct dtype is not supported yet"
-        return NotImplementedError(msg)
+        raise NotImplementedError(msg)
     if isinstance_or_issubclass(dtype, dtypes.Array):  # pragma: no cover
         msg = "Converting to Array dtype is not supported yet"
-        return NotImplementedError(msg)
+        raise NotImplementedError(msg)
     if isinstance_or_issubclass(dtype, dtypes.Time):  # pragma: no cover
         msg = "Converting to Time dtype is not supported yet"
-        return NotImplementedError(msg)
+        raise NotImplementedError(msg)
     if isinstance_or_issubclass(dtype, dtypes.Binary):  # pragma: no cover
         msg = "Converting to Binary dtype is not supported yet"
-        return NotImplementedError(msg)
+        raise NotImplementedError(msg)
 
     msg = f"Unknown dtype: {dtype}"  # pragma: no cover
     raise AssertionError(msg)
diff --git a/narwhals/_duckdb/namespace.py b/narwhals/_duckdb/namespace.py
@@ -49,7 +49,7 @@ def _expr(self) -> type[DuckDBExpr]:
     def _lazyframe(self) -> type[DuckDBLazyFrame]:
         return DuckDBLazyFrame
 
-    def _with_elementwise(
+    def _expr_from_elementwise(
         self, func: Callable[[Iterable[Expression]], Expression], *exprs: DuckDBExpr
     ) -> DuckDBExpr:
         def call(df: DuckDBLazyFrame) -> list[Expression]:
@@ -119,31 +119,31 @@ def all_horizontal(self, *exprs: DuckDBExpr) -> DuckDBExpr:
         def func(cols: Iterable[Expression]) -> Expression:
             return reduce(operator.and_, cols)
 
-        return self._with_elementwise(func, *exprs)
+        return self._expr_from_elementwise(func, *exprs)
 
     def any_horizontal(self, *exprs: DuckDBExpr) -> DuckDBExpr:
         def func(cols: Iterable[Expression]) -> Expression:
             return reduce(operator.or_, cols)
 
-        return self._with_elementwise(func, *exprs)
+        return self._expr_from_elementwise(func, *exprs)
 
     def max_horizontal(self, *exprs: DuckDBExpr) -> DuckDBExpr:
         def func(cols: Iterable[Expression]) -> Expression:
             return FunctionExpression("greatest", *cols)
 
-        return self._with_elementwise(func, *exprs)
+        return self._expr_from_elementwise(func, *exprs)
 
     def min_horizontal(self, *exprs: DuckDBExpr) -> DuckDBExpr:
         def func(cols: Iterable[Expression]) -> Expression:
             return FunctionExpression("least", *cols)
 
-        return self._with_elementwise(func, *exprs)
+        return self._expr_from_elementwise(func, *exprs)
 
     def sum_horizontal(self, *exprs: DuckDBExpr) -> DuckDBExpr:
         def func(cols: Iterable[Expression]) -> Expression:
             return reduce(operator.add, (CoalesceOperator(col, lit(0)) for col in cols))
 
-        return self._with_elementwise(func, *exprs)
+        return self._expr_from_elementwise(func, *exprs)
 
     def mean_horizontal(self, *exprs: DuckDBExpr) -> DuckDBExpr:
         def func(cols: Iterable[Expression]) -> Expression:
@@ -152,7 +152,7 @@ def func(cols: Iterable[Expression]) -> Expression:
                 operator.add, (CoalesceOperator(col, lit(0)) for col in cols)
             ) / reduce(operator.add, (col.isnotnull().cast(BIGINT) for col in cols))
 
-        return self._with_elementwise(func, *exprs)
+        return self._expr_from_elementwise(func, *exprs)
 
     def when(self, predicate: DuckDBExpr) -> DuckDBWhen:
         return DuckDBWhen.from_expr(predicate, context=self)
diff --git a/narwhals/_ibis/namespace.py b/narwhals/_ibis/namespace.py
@@ -3,7 +3,7 @@
 import operator
 from functools import reduce
 from itertools import chain
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any, Callable, cast
 
 import ibis
 import ibis.expr.types as ir
@@ -33,6 +33,21 @@ def __init__(self, *, backend_version: tuple[int, ...], version: Version) -> Non
         self._backend_version = backend_version
         self._version = version
 
+    def _expr_from_callable(
+        self, func: Callable[[Iterable[ir.Value]], ir.Value], *exprs: IbisExpr
+    ) -> IbisExpr:
+        def call(df: IbisLazyFrame) -> list[ir.Value]:
+            cols = (col for _expr in exprs for col in _expr(df))
+            return [func(cols)]
+
+        return self._expr(
+            call=call,
+            evaluate_output_names=combine_evaluate_output_names(*exprs),
+            alias_output_names=combine_alias_output_names(*exprs),
+            backend_version=self._backend_version,
+            version=self._version,
+        )
+
     @property
     def selectors(self) -> IbisSelectorNamespace:
         return IbisSelectorNamespace.from_namespace(self)
@@ -86,94 +101,44 @@ def func(df: IbisLazyFrame) -> list[ir.Value]:
         )
 
     def all_horizontal(self, *exprs: IbisExpr) -> IbisExpr:
-        def func(df: IbisLazyFrame) -> list[ir.Value]:
-            cols = chain.from_iterable(expr(df) for expr in exprs)
-            return [reduce(operator.and_, cols)]
+        def func(cols: Iterable[ir.Value]) -> ir.Value:
+            return reduce(operator.and_, cols)
 
-        return self._expr(
-            call=func,
-            evaluate_output_names=combine_evaluate_output_names(*exprs),
-            alias_output_names=combine_alias_output_names(*exprs),
-            backend_version=self._backend_version,
-            version=self._version,
-        )
+        return self._expr_from_callable(func, *exprs)
 
     def any_horizontal(self, *exprs: IbisExpr) -> IbisExpr:
-        def func(df: IbisLazyFrame) -> list[ir.Value]:
-            cols = chain.from_iterable(expr(df) for expr in exprs)
-            return [reduce(operator.or_, cols)]
+        def func(cols: Iterable[ir.Value]) -> ir.Value:
+            return reduce(operator.or_, cols)
 
-        return self._expr(
-            call=func,
-            evaluate_output_names=combine_evaluate_output_names(*exprs),
-            alias_output_names=combine_alias_output_names(*exprs),
-            backend_version=self._backend_version,
-            version=self._version,
-        )
+        return self._expr_from_callable(func, *exprs)
 
     def max_horizontal(self, *exprs: IbisExpr) -> IbisExpr:
-        def func(df: IbisLazyFrame) -> list[ir.Value]:
-            cols = chain.from_iterable(expr(df) for expr in exprs)
-            return [ibis.greatest(*cols)]
+        def func(cols: Iterable[ir.Value]) -> ir.Value:
+            return ibis.greatest(*cols)
 
-        return self._expr(
-            call=func,
-            evaluate_output_names=combine_evaluate_output_names(*exprs),
-            alias_output_names=combine_alias_output_names(*exprs),
-            backend_version=self._backend_version,
-            version=self._version,
-        )
+        return self._expr_from_callable(func, *exprs)
 
     def min_horizontal(self, *exprs: IbisExpr) -> IbisExpr:
-        def func(df: IbisLazyFrame) -> list[ir.Value]:
-            cols = chain.from_iterable(expr(df) for expr in exprs)
-            return [ibis.least(*cols)]
+        def func(cols: Iterable[ir.Value]) -> ir.Value:
+            return ibis.least(*cols)
 
-        return self._expr(
-            call=func,
-            evaluate_output_names=combine_evaluate_output_names(*exprs),
-            alias_output_names=combine_alias_output_names(*exprs),
-            backend_version=self._backend_version,
-            version=self._version,
-        )
+        return self._expr_from_callable(func, *exprs)
 
     def sum_horizontal(self, *exprs: IbisExpr) -> IbisExpr:
-        def func(df: IbisLazyFrame) -> list[ir.Value]:
-            cols = [e.fill_null(lit(0)) for _expr in exprs for e in _expr(df)]
-            return [reduce(operator.add, cols)]
+        def func(cols: Iterable[ir.Value]) -> ir.Value:
+            cols = (col.fill_null(lit(0)) for col in cols)
+            return reduce(operator.add, cols)
 
-        return self._expr(
-            call=func,
-            evaluate_output_names=combine_evaluate_output_names(*exprs),
-            alias_output_names=combine_alias_output_names(*exprs),
-            backend_version=self._backend_version,
-            version=self._version,
-        )
+        return self._expr_from_callable(func, *exprs)
 
     def mean_horizontal(self, *exprs: IbisExpr) -> IbisExpr:
-        def func(df: IbisLazyFrame) -> list[ir.Value]:
-            expr = (
-                cast("ir.NumericColumn", e.fill_null(lit(0)))
-                for _expr in exprs
-                for e in _expr(df)
-            )
-            non_null = (
-                cast("ir.NumericColumn", e.isnull().ifelse(lit(0), lit(1)))
-                for _expr in exprs
-                for e in _expr(df)
+        def func(cols: Iterable[ir.Value]) -> ir.Value:
+            cols = list(cols)
+            return reduce(operator.add, (col.fill_null(lit(0)) for col in cols)) / reduce(
+                operator.add, (col.isnull().ifelse(lit(0), lit(1)) for col in cols)
             )
 
-            return [
-                (reduce(lambda x, y: x + y, expr) / reduce(lambda x, y: x + y, non_null))
-            ]
-
-        return self._expr(
-            call=func,
-            evaluate_output_names=combine_evaluate_output_names(*exprs),
-            alias_output_names=combine_alias_output_names(*exprs),
-            backend_version=self._backend_version,
-            version=self._version,
-        )
+        return self._expr_from_callable(func, *exprs)
 
     @requires.backend_version((10, 0))
     def when(self, predicate: IbisExpr) -> IbisWhen:
diff --git a/narwhals/_pandas_like/series.py b/narwhals/_pandas_like/series.py
@@ -229,10 +229,7 @@ def _align_full_broadcast(cls, *series: Self) -> Sequence[Self]:
         for s in series:
             if s._broadcast:
                 native = Series(
-                    np.repeat(s.native.iloc[0], max_length),
-                    index=idx,
-                    name=s.name,
-                    dtype=s.native.dtype,
+                    s.native.iloc[0], index=idx, name=s.name, dtype=s.native.dtype
                 )
                 compliant = s._with_native(native)
             elif s.native.index is not idx:
diff --git a/narwhals/_pandas_like/utils.py b/narwhals/_pandas_like/utils.py
@@ -93,14 +93,10 @@ def align_and_extract_native(
     If the comparison isn't supported, return `NotImplemented` so that the
     "right-hand-side" operation (e.g. `__radd__`) can be tried.
     """
-    from narwhals._pandas_like.dataframe import PandasLikeDataFrame
     from narwhals._pandas_like.series import PandasLikeSeries
 
     lhs_index = lhs.native.index
 
-    if isinstance(rhs, PandasLikeDataFrame):
-        return NotImplemented
-
     if lhs._broadcast and isinstance(rhs, PandasLikeSeries) and not rhs._broadcast:
         return lhs.native.iloc[0], rhs.native
 
diff --git a/narwhals/_spark_like/namespace.py b/narwhals/_spark_like/namespace.py
@@ -73,7 +73,7 @@ def _native_dtypes(self):  # type: ignore[no-untyped-def] # noqa: ANN202
         else:
             return import_native_dtypes(self._implementation)
 
-    def _with_elementwise(
+    def _expr_from_callable(
         self, func: Callable[[Iterable[Column]], Column], *exprs: SparkLikeExpr
     ) -> SparkLikeExpr:
         def call(df: SparkLikeLazyFrame) -> list[Column]:
@@ -135,33 +135,33 @@ def all_horizontal(self, *exprs: SparkLikeExpr) -> SparkLikeExpr:
         def func(cols: Iterable[Column]) -> Column:
             return reduce(operator.and_, cols)
 
-        return self._with_elementwise(func, *exprs)
+        return self._expr_from_callable(func, *exprs)
 
     def any_horizontal(self, *exprs: SparkLikeExpr) -> SparkLikeExpr:
         def func(cols: Iterable[Column]) -> Column:
             return reduce(operator.or_, cols)
 
-        return self._with_elementwise(func, *exprs)
+        return self._expr_from_callable(func, *exprs)
 
     def max_horizontal(self, *exprs: SparkLikeExpr) -> SparkLikeExpr:
         def func(cols: Iterable[Column]) -> Column:
             return self._F.greatest(*cols)
 
-        return self._with_elementwise(func, *exprs)
+        return self._expr_from_callable(func, *exprs)
 
     def min_horizontal(self, *exprs: SparkLikeExpr) -> SparkLikeExpr:
         def func(cols: Iterable[Column]) -> Column:
             return self._F.least(*cols)
 
-        return self._with_elementwise(func, *exprs)
+        return self._expr_from_callable(func, *exprs)
 
     def sum_horizontal(self, *exprs: SparkLikeExpr) -> SparkLikeExpr:
         def func(cols: Iterable[Column]) -> Column:
             return reduce(
                 operator.add, (self._F.coalesce(col, self._F.lit(0)) for col in cols)
             )
 
-        return self._with_elementwise(func, *exprs)
+        return self._expr_from_callable(func, *exprs)
 
     def mean_horizontal(self, *exprs: SparkLikeExpr) -> SparkLikeExpr:
         def func(cols: Iterable[Column]) -> Column:
@@ -182,7 +182,7 @@ def func(cols: Iterable[Column]) -> Column:
                 ),
             )
 
-        return self._with_elementwise(func, *exprs)
+        return self._expr_from_callable(func, *exprs)
 
     def concat(
         self, items: Iterable[SparkLikeLazyFrame], *, how: ConcatMethod
diff --git a/narwhals/_utils.py b/narwhals/_utils.py
@@ -1770,7 +1770,8 @@ def __get__(
         # NOTE: Prefer not exposing the actual class we're defining in
         # `_implementation` may not be available everywhere
         who = getattr(instance, "_implementation", self._name_owner)
-        raise _not_implemented_error(self._name, who)
+        _raise_not_implemented_error(self._name, who)
+        return None  # pragma: no cover
 
     def __call__(self, *args: Any, **kwds: Any) -> Any:
         # NOTE: Purely to duck-type as assignable to **any** instance method
@@ -1793,13 +1794,13 @@ def deprecated(cls, message: LiteralString, /) -> Self:
         return deprecated(message)(obj)
 
 
-def _not_implemented_error(what: str, who: str, /) -> NotImplementedError:
+def _raise_not_implemented_error(what: str, who: str, /) -> NotImplementedError:
     msg = (
         f"{what!r} is not implemented for: {who!r}.\n\n"
         "If you would like to see this functionality in `narwhals`, "
         "please open an issue at: https://github.com/narwhals-dev/narwhals/issues"
     )
-    return NotImplementedError(msg)
+    raise NotImplementedError(msg)
 
 
 class requires:  # noqa: N801
diff --git a/tests/expr_and_series/arithmetic_test.py b/tests/expr_and_series/arithmetic_test.py
