chore: rename _input to expr in _duckdb (#2580)

chore: _input -> expr

Author: MarcoGorelli

narwhals/_duckdb/expr.py

@@ -290,95 +290,93 @@ def _alias_native(cls, expr: Expression, name: str) -> Expression:
         return expr.alias(name)
 
     def __and__(self, other: DuckDBExpr) -> Self:
-        return self._with_callable(lambda _input, other: _input & other, other=other)
+        return self._with_callable(lambda expr, other: expr & other, other=other)
 
     def __or__(self, other: DuckDBExpr) -> Self:
-        return self._with_callable(lambda _input, other: _input | other, other=other)
+        return self._with_callable(lambda expr, other: expr | other, other=other)
 
     def __add__(self, other: DuckDBExpr) -> Self:
-        return self._with_callable(lambda _input, other: _input + other, other=other)
+        return self._with_callable(lambda expr, other: expr + other, other=other)
 
     def __truediv__(self, other: DuckDBExpr) -> Self:
-        return self._with_callable(lambda _input, other: _input / other, other=other)
+        return self._with_callable(lambda expr, other: expr / other, other=other)
 
     def __rtruediv__(self, other: DuckDBExpr) -> Self:
         return self._with_callable(
-            lambda _input, other: other.__truediv__(_input), other=other
+            lambda expr, other: other.__truediv__(expr), other=other
         ).alias("literal")
 
     def __floordiv__(self, other: DuckDBExpr) -> Self:
         return self._with_callable(
-            lambda _input, other: _input.__floordiv__(other), other=other
+            lambda expr, other: expr.__floordiv__(other), other=other
         )
 
     def __rfloordiv__(self, other: DuckDBExpr) -> Self:
         return self._with_callable(
-            lambda _input, other: other.__floordiv__(_input), other=other
+            lambda expr, other: other.__floordiv__(expr), other=other
         ).alias("literal")
 
     def __mod__(self, other: DuckDBExpr) -> Self:
-        return self._with_callable(
-            lambda _input, other: _input.__mod__(other), other=other
-        )
+        return self._with_callable(lambda expr, other: expr.__mod__(other), other=other)
 
     def __rmod__(self, other: DuckDBExpr) -> Self:
         return self._with_callable(
-            lambda _input, other: other.__mod__(_input), other=other
+            lambda expr, other: other.__mod__(expr), other=other
         ).alias("literal")
 
     def __sub__(self, other: DuckDBExpr) -> Self:
-        return self._with_callable(lambda _input, other: _input - other, other=other)
+        return self._with_callable(lambda expr, other: expr - other, other=other)
 
     def __rsub__(self, other: DuckDBExpr) -> Self:
         return self._with_callable(
-            lambda _input, other: other.__sub__(_input), other=other
+            lambda expr, other: other.__sub__(expr), other=other
         ).alias("literal")
 
     def __mul__(self, other: DuckDBExpr) -> Self:
-        return self._with_callable(lambda _input, other: _input * other, other=other)
+        return self._with_callable(lambda expr, other: expr * other, other=other)
 
     def __pow__(self, other: DuckDBExpr) -> Self:
-        return self._with_callable(lambda _input, other: _input**other, other=other)
+        return self._with_callable(lambda expr, other: expr**other, other=other)
 
     def __rpow__(self, other: DuckDBExpr) -> Self:
         return self._with_callable(
-            lambda _input, other: other.__pow__(_input), other=other
+            lambda expr, other: other.__pow__(expr), other=other
         ).alias("literal")
 
     def __lt__(self, other: DuckDBExpr) -> Self:
-        return self._with_callable(lambda _input, other: _input < other, other=other)
+        return self._with_callable(lambda expr, other: expr < other, other=other)
 
     def __gt__(self, other: DuckDBExpr) -> Self:
-        return self._with_callable(lambda _input, other: _input > other, other=other)
+        return self._with_callable(lambda expr, other: expr > other, other=other)
 
     def __le__(self, other: DuckDBExpr) -> Self:
-        return self._with_callable(lambda _input, other: _input <= other, other=other)
+        return self._with_callable(lambda expr, other: expr <= other, other=other)
 
     def __ge__(self, other: DuckDBExpr) -> Self:
-        return self._with_callable(lambda _input, other: _input >= other, other=other)
+        return self._with_callable(lambda expr, other: expr >= other, other=other)
 
     def __eq__(self, other: DuckDBExpr) -> Self:  # type: ignore[override]
-        return self._with_callable(lambda _input, other: _input == other, other=other)
+        return self._with_callable(lambda expr, other: expr == other, other=other)
 
     def __ne__(self, other: DuckDBExpr) -> Self:  # type: ignore[override]
-        return self._with_callable(lambda _input, other: _input != other, other=other)
+        return self._with_callable(lambda expr, other: expr != other, other=other)
 
     def __invert__(self) -> Self:
         invert = cast("Callable[..., Expression]", operator.invert)
         return self._with_callable(invert)
 
     def abs(self) -> Self:
-        return self._with_callable(lambda _input: FunctionExpression("abs", _input))
+        return self._with_callable(lambda expr: FunctionExpression("abs", expr))
 
     def mean(self) -> Self:
-        return self._with_callable(lambda _input: FunctionExpression("mean", _input))
+        return self._with_callable(lambda expr: FunctionExpression("mean", expr))
 
     def skew(self) -> Self:
-        def func(_input: Expression) -> Expression:
-            count = FunctionExpression("count", _input)
+        def func(expr: Expression) -> Expression:
+            count = FunctionExpression("count", expr)
             # Adjust population skewness by correction factor to get sample skewness
             sample_skewness = (
-                FunctionExpression("skewness", _input)
+                FunctionExpression("skewness", expr)
                 * (count - lit(2))
                 / FunctionExpression("sqrt", count * (count - lit(1)))
             )
@@ -391,20 +389,20 @@ def func(_input: Expression) -> Expression:
         return self._with_callable(func)
 
     def median(self) -> Self:
-        return self._with_callable(lambda _input: FunctionExpression("median", _input))
+        return self._with_callable(lambda expr: FunctionExpression("median", expr))
 
     def all(self) -> Self:
-        return self._with_callable(lambda _input: FunctionExpression("bool_and", _input))
+        return self._with_callable(lambda expr: FunctionExpression("bool_and", expr))
 
     def any(self) -> Self:
-        return self._with_callable(lambda _input: FunctionExpression("bool_or", _input))
+        return self._with_callable(lambda expr: FunctionExpression("bool_or", expr))
 
     def quantile(
         self, quantile: float, interpolation: RollingInterpolationMethod
     ) -> Self:
-        def func(_input: Expression) -> Expression:
+        def func(expr: Expression) -> Expression:
             if interpolation == "linear":
-                return FunctionExpression("quantile_cont", _input, lit(quantile))
+                return FunctionExpression("quantile_cont", expr, lit(quantile))
             msg = "Only linear interpolation methods are supported for DuckDB quantile."
             raise NotImplementedError(msg)
 
@@ -415,17 +413,17 @@ def clip(
         lower_bound: Self | NumericLiteral | TemporalLiteral | None,
         upper_bound: Self | NumericLiteral | TemporalLiteral | None,
     ) -> Self:
-        def _clip_lower(_input: Expression, lower_bound: Any) -> Expression:
-            return FunctionExpression("greatest", _input, lower_bound)
+        def _clip_lower(expr: Expression, lower_bound: Any) -> Expression:
+            return FunctionExpression("greatest", expr, lower_bound)
 
-        def _clip_upper(_input: Expression, upper_bound: Any) -> Expression:
-            return FunctionExpression("least", _input, upper_bound)
+        def _clip_upper(expr: Expression, upper_bound: Any) -> Expression:
+            return FunctionExpression("least", expr, upper_bound)
 
         def _clip_both(
-            _input: Expression, lower_bound: Any, upper_bound: Any
+            expr: Expression, lower_bound: Any, upper_bound: Any
         ) -> Expression:
             return FunctionExpression(
-                "greatest", FunctionExpression("least", _input, upper_bound), lower_bound
+                "greatest", FunctionExpression("least", expr, upper_bound), lower_bound
             )
 
         if lower_bound is None:
@@ -437,39 +435,39 @@ def _clip_both(
         )
 
     def sum(self) -> Self:
-        return self._with_callable(lambda _input: FunctionExpression("sum", _input))
+        return self._with_callable(lambda expr: FunctionExpression("sum", expr))
 
     def n_unique(self) -> Self:
-        def func(_input: Expression) -> Expression:
+        def func(expr: Expression) -> Expression:
             # https://stackoverflow.com/a/79338887/4451315
             return FunctionExpression(
-                "array_unique", FunctionExpression("array_agg", _input)
+                "array_unique", FunctionExpression("array_agg", expr)
             ) + FunctionExpression(
-                "max", when(_input.isnotnull(), lit(0)).otherwise(lit(1))
+                "max", when(expr.isnotnull(), lit(0)).otherwise(lit(1))
             )
 
         return self._with_callable(func)
 
     def count(self) -> Self:
-        return self._with_callable(lambda _input: FunctionExpression("count", _input))
+        return self._with_callable(lambda expr: FunctionExpression("count", expr))
 
     def len(self) -> Self:
-        return self._with_callable(lambda _input: FunctionExpression("count"))
+        return self._with_callable(lambda _expr: FunctionExpression("count"))
 
     def std(self, ddof: int) -> Self:
         if ddof == 0:
             return self._with_callable(
-                lambda _input: FunctionExpression("stddev_pop", _input)
+                lambda expr: FunctionExpression("stddev_pop", expr)
             )
         if ddof == 1:
             return self._with_callable(
-                lambda _input: FunctionExpression("stddev_samp", _input)
+                lambda expr: FunctionExpression("stddev_samp", expr)
             )
 
-        def _std(_input: Expression) -> Expression:
-            n_samples = FunctionExpression("count", _input)
+        def _std(expr: Expression) -> Expression:
+            n_samples = FunctionExpression("count", expr)
             return (
-                FunctionExpression("stddev_pop", _input)
+                FunctionExpression("stddev_pop", expr)
                 * FunctionExpression("sqrt", n_samples)
                 / (FunctionExpression("sqrt", (n_samples - lit(ddof))))
             )
@@ -478,33 +476,27 @@ def _std(_input: Expression) -> Expression:
 
     def var(self, ddof: int) -> Self:
         if ddof == 0:
-            return self._with_callable(
-                lambda _input: FunctionExpression("var_pop", _input)
-            )
+            return self._with_callable(lambda expr: FunctionExpression("var_pop", expr))
         if ddof == 1:
-            return self._with_callable(
-                lambda _input: FunctionExpression("var_samp", _input)
-            )
+            return self._with_callable(lambda expr: FunctionExpression("var_samp", expr))
 
-        def _var(_input: Expression) -> Expression:
-            n_samples = FunctionExpression("count", _input)
+        def _var(expr: Expression) -> Expression:
+            n_samples = FunctionExpression("count", expr)
             return (
-                FunctionExpression("var_pop", _input)
-                * n_samples
-                / (n_samples - lit(ddof))
+                FunctionExpression("var_pop", expr) * n_samples / (n_samples - lit(ddof))
             )
 
         return self._with_callable(_var)
 
     def max(self) -> Self:
-        return self._with_callable(lambda _input: FunctionExpression("max", _input))
+        return self._with_callable(lambda expr: FunctionExpression("max", expr))
 
     def min(self) -> Self:
-        return self._with_callable(lambda _input: FunctionExpression("min", _input))
+        return self._with_callable(lambda expr: FunctionExpression("min", expr))
 
     def null_count(self) -> Self:
         return self._with_callable(
-            lambda _input: FunctionExpression("sum", _input.isnull().cast("int")),
+            lambda expr: FunctionExpression("sum", expr.isnull().cast("int")),
         )
 
     @requires.backend_version((1, 3))
@@ -548,22 +540,22 @@ def func(df: DuckDBLazyFrame) -> list[Expression]:
         )
 
     def is_null(self) -> Self:
-        return self._with_callable(lambda _input: _input.isnull())
+        return self._with_callable(lambda expr: expr.isnull())
 
     def is_nan(self) -> Self:
-        return self._with_callable(lambda _input: FunctionExpression("isnan", _input))
+        return self._with_callable(lambda expr: FunctionExpression("isnan", expr))
 
     def is_finite(self) -> Self:
-        return self._with_callable(lambda _input: FunctionExpression("isfinite", _input))
+        return self._with_callable(lambda expr: FunctionExpression("isfinite", expr))
 
     def is_in(self, other: Sequence[Any]) -> Self:
         return self._with_callable(
-            lambda _input: FunctionExpression("contains", lit(other), _input)
+            lambda expr: FunctionExpression("contains", lit(other), expr)
         )
 
     def round(self, decimals: int) -> Self:
         return self._with_callable(
-            lambda _input: FunctionExpression("round", _input, lit(decimals))
+            lambda expr: FunctionExpression("round", expr, lit(decimals))
         )
 
     @requires.backend_version((1, 3))
@@ -734,22 +726,22 @@ def _fill_with_strategy(window_inputs: WindowInputs) -> Expression:
 
             return self._with_window_function(_fill_with_strategy)
 
-        def _fill_constant(_input: Expression, value: Any) -> Expression:
-            return CoalesceOperator(_input, value)
+        def _fill_constant(expr: Expression, value: Any) -> Expression:
+            return CoalesceOperator(expr, value)
 
         return self._with_callable(_fill_constant, value=value)
 
     def cast(self, dtype: DType | type[DType]) -> Self:
-        def func(_input: Expression) -> Expression:
+        def func(expr: Expression) -> Expression:
             native_dtype = narwhals_to_native_dtype(dtype, self._version)
-            return _input.cast(DuckDBPyType(native_dtype))
+            return expr.cast(DuckDBPyType(native_dtype))
 
         return self._with_callable(func)
 
     @requires.backend_version((1, 3))
     def is_unique(self) -> Self:
-        def func(_input: Expression) -> Expression:
-            sql = f"count(*) over (partition by {_input})"
+        def func(expr: Expression) -> Expression:
+            sql = f"count(*) over (partition by {expr})"
             return SQLExpression(sql) == lit(1)  # type: ignore[no-any-return, unused-ignore]
 
         return self._with_callable(func)
@@ -764,39 +756,39 @@ def rank(self, method: RankMethod, *, descending: bool) -> Self:
             func = FunctionExpression("row_number")
 
         def _rank(
-            _input: Expression,
+            expr: Expression,
             *,
             descending: bool,
             partition_by: Sequence[str | Expression] | None = None,
         ) -> Expression:
             order_by_sql = (
-                f"order by {_input} desc nulls last"
+                f"order by {expr} desc nulls last"
                 if descending
-                else f"order by {_input} asc nulls last"
+                else f"order by {expr} asc nulls last"
             )
             count_expr = FunctionExpression("count", StarExpression())
             if partition_by is not None:
                 window = f"{generate_partition_by_sql(*partition_by)} {order_by_sql}"
-                count_window = f"{generate_partition_by_sql(*partition_by, _input)}"
+                count_window = f"{generate_partition_by_sql(*partition_by, expr)}"
             else:
                 window = order_by_sql
-                count_window = generate_partition_by_sql(_input)
+                count_window = generate_partition_by_sql(expr)
             if method == "max":
-                expr = (
+                rank_expr = (
                     SQLExpression(f"{func} OVER ({window})")
                     + SQLExpression(f"{count_expr} over ({count_window})")
                     - lit(1)
                 )
             elif method == "average":
-                expr = SQLExpression(f"{func} OVER ({window})") + (
+                rank_expr = SQLExpression(f"{func} OVER ({window})") + (
                     SQLExpression(f"{count_expr} over ({count_window})") - lit(1)
                 ) / lit(2.0)
             else:
-                expr = SQLExpression(f"{func} OVER ({window})")
-            return when(_input.isnotnull(), expr)
+                rank_expr = SQLExpression(f"{func} OVER ({window})")
+            return when(expr.isnotnull(), rank_expr)
 
-        def _unpartitioned_rank(_input: Expression) -> Expression:
-            return _rank(_input, descending=descending)
+        def _unpartitioned_rank(expr: Expression) -> Expression:
+            return _rank(expr, descending=descending)
 
         def _partitioned_rank(
             window_inputs: UnorderableWindowInputs,
@@ -813,11 +805,11 @@ def _partitioned_rank(
         )
 
     def log(self, base: float) -> Self:
-        def _log(_input: Expression) -> Expression:
-            log = FunctionExpression("log", _input)
+        def _log(expr: Expression) -> Expression:
+            log = FunctionExpression("log", expr)
             return (
-                when(_input < lit(0), lit(float("nan")))
-                .when(_input == lit(0), lit(float("-inf")))
+                when(expr < lit(0), lit(float("nan")))
+                .when(expr == lit(0), lit(float("-inf")))
                 .otherwise(log / FunctionExpression("log", lit(base)))
             )