Expressions#

def __abs__(self) -> Expression:
    """Absolute of a numeric expression."""
    return self.abs()

def __add__(self, other: object) -> Expression:
    """Adds two numeric expressions or concatenates two string expressions (``e1 + e2``)."""
    expr = Expression._to_expression(other)
    return Expression._from_pyexpr(self._expr + expr._expr)

def __and__(self, other: Expression) -> Expression:
    """Takes the logical AND of two boolean expressions, or bitwise AND of two integer expressions (``e1 & e2``)."""
    expr = Expression._to_expression(other)
    return Expression._from_pyexpr(self._expr & expr._expr)

def __bool__(self) -> bool:
    raise ValueError(
        "Expressions don't have a truth value. "
        "If you used Python keywords `and` `not` `or` on an expression, use `&` `~` `|` instead."
    )

def __eq__(self, other: Expression) -> Expression:  # type: ignore
    """Compares if an expression is equal to another (``e1 == e2``)."""
    expr = Expression._to_expression(other)
    return Expression._from_pyexpr(self._expr == expr._expr)

def __floordiv__(self, other: Expression) -> Expression:
    """Floor divides two numeric expressions (``e1 / e2``)."""
    expr = Expression._to_expression(other)
    return Expression._from_pyexpr(self._expr // expr._expr)

def __ge__(self, other: Expression) -> Expression:
    """Compares if an expression is greater than or equal to another (``e1 >= e2``)."""
    expr = Expression._to_expression(other)
    return Expression._from_pyexpr(self._expr >= expr._expr)

def __getitem__(self, key: builtins.str | int | slice) -> Expression:
    """Syntactic sugar for `daft.functions.get` for string and int, and `daft.functions.slice` for slice.

    Examples:
        Getting a single value:
        >>> import daft
        >>> df = daft.from_pydict({"struct": [{"x": 1, "y": 2}, {"x": 3, "y": 4}], "list": [[10, 20], [30, 40]]})
        >>> df = df.select(df["struct"]["x"], df["list"][0].alias("first"))
        >>> df.show()
        ╭───────┬───────╮
        │ x     ┆ first │
        │ ---   ┆ ---   │
        │ Int64 ┆ Int64 │
        ╞═══════╪═══════╡
        │ 1     ┆ 10    │
        ├╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┤
        │ 3     ┆ 30    │
        ╰───────┴───────╯
        <BLANKLINE>
        (Showing first 2 of 2 rows)

        Getting a slice:
        >>> df = daft.from_pydict({"x": [[1, 2, 3], [4, 5, 6, 7], [8]]})
        >>> df = df.select(df["x"][1:-1])
        >>> df.show()
        ╭─────────────╮
        │ x           │
        │ ---         │
        │ List[Int64] │
        ╞═════════════╡
        │ [2]         │
        ├╌╌╌╌╌╌╌╌╌╌╌╌╌┤
        │ [5, 6]      │
        ├╌╌╌╌╌╌╌╌╌╌╌╌╌┤
        │ []          │
        ╰─────────────╯
        <BLANKLINE>
        (Showing first 3 of 3 rows)

    Tip: See Also
        [`daft.functions.get`](https://docs.daft.ai/en/stable/api/functions/get/)
        [`daft.functions.slice`](https://docs.daft.ai/en/stable/api/functions/slice/)

    """
    if isinstance(key, builtins.slice):
        from daft.functions import slice

        if key.step is not None:
            raise ValueError(
                "`Expression.__getitem__` does not yet support slicing with step: `expr[start:stop:step]`"
            )

        start = key.start if key.start is not None else 0
        return slice(self, start, key.stop)
    else:
        from daft.functions import get

        return get(self, key)

def __gt__(self, other: Expression) -> Expression:
    """Compares if an expression is greater than another (``e1 > e2``)."""
    expr = Expression._to_expression(other)
    return Expression._from_pyexpr(self._expr > expr._expr)

def __hash__(self) -> int:
    return self._expr.__hash__()

def __invert__(self) -> Expression:
    """Inverts a boolean expression (``~e``)."""
    expr = self._expr.__invert__()
    return Expression._from_pyexpr(expr)

def __le__(self, other: Expression) -> Expression:
    """Compares if an expression is less than or equal to another (``e1 <= e2``)."""
    expr = Expression._to_expression(other)
    return Expression._from_pyexpr(self._expr <= expr._expr)

def __lshift__(self, other: Expression) -> Expression:
    """Shifts the bits of an integer expression to the left (``e1 << e2``).

    Args:
        other: The number of bits to shift the expression to the left
    """
    expr = Expression._to_expression(other)
    return Expression._from_pyexpr(self._expr << expr._expr)

def __lt__(self, other: Expression) -> Expression:
    """Compares if an expression is less than another (``e1 < e2``)."""
    expr = Expression._to_expression(other)
    return Expression._from_pyexpr(self._expr < expr._expr)

def __mod__(self, other: Expression) -> Expression:
    """Takes the mod of two numeric expressions (``e1 % e2``)."""
    expr = Expression._to_expression(other)
    return Expression._from_pyexpr(self._expr % expr._expr)

def __mul__(self, other: object) -> Expression:
    """Multiplies two numeric expressions (``e1 * e2``)."""
    expr = Expression._to_expression(other)
    return Expression._from_pyexpr(self._expr * expr._expr)

def __ne__(self, other: Expression) -> Expression:  # type: ignore
    """Compares if an expression is not equal to another (``e1 != e2``)."""
    expr = Expression._to_expression(other)
    return Expression._from_pyexpr(self._expr != expr._expr)

def __or__(self, other: Expression) -> Expression:
    """Takes the logical OR of two boolean or integer expressions, or bitwise OR of two integer expressions (``e1 | e2``)."""
    expr = Expression._to_expression(other)
    return Expression._from_pyexpr(self._expr | expr._expr)

def __radd__(self, other: object) -> Expression:
    expr = Expression._to_expression(other)
    return Expression._from_pyexpr(expr._expr + self._expr)

def __rand__(self, other: Expression) -> Expression:
    """Takes the logical reverse AND of two boolean expressions (``e1 & e2``)."""
    expr = Expression._to_expression(other)
    return Expression._from_pyexpr(expr._expr & self._expr)

def __reduce__(self) -> tuple[Callable[[_PyExpr], Expression], tuple[_PyExpr]]:
    return Expression._from_pyexpr, (self._expr,)

def __repr__(self) -> builtins.str:
    return repr(self._expr)

def __rfloordiv__(self, other: object) -> Expression:
    """Reverse floor divides two numeric expressions (``e2 / e1``)."""
    expr = Expression._to_expression(other)
    return Expression._from_pyexpr(expr._expr // self._expr)

def __rmod__(self, other: Expression) -> Expression:
    """Takes the mod of two numeric expressions (``e1 % e2``)."""
    expr = Expression._to_expression(other)
    return Expression._from_pyexpr(expr._expr % self._expr)

def __rmul__(self, other: object) -> Expression:
    expr = Expression._to_expression(other)
    return Expression._from_pyexpr(expr._expr * self._expr)

def __ror__(self, other: Expression) -> Expression:
    """Takes the logical reverse OR of two boolean expressions (``e1 | e2``)."""
    expr = Expression._to_expression(other)
    return Expression._from_pyexpr(expr._expr | self._expr)

def __rshift__(self, other: Expression) -> Expression:
    """Shifts the bits of an integer expression to the right (``e1 >> e2``).

    .. NOTE::

        For unsigned integers, this expression perform a logical right shift.
        For signed integers, this expression perform an arithmetic right shift.

    Args:
        other: The number of bits to shift the expression to the right
    """
    expr = Expression._to_expression(other)
    return Expression._from_pyexpr(self._expr >> expr._expr)

def __rsub__(self, other: object) -> Expression:
    expr = Expression._to_expression(other)
    return Expression._from_pyexpr(expr._expr - self._expr)

def __rtruediv__(self, other: object) -> Expression:
    expr = Expression._to_expression(other)
    return Expression._from_pyexpr(expr._expr / self._expr)

def __sub__(self, other: object) -> Expression:
    """Subtracts two numeric expressions (``e1 - e2``)."""
    expr = Expression._to_expression(other)
    return Expression._from_pyexpr(self._expr - expr._expr)

def __truediv__(self, other: object) -> Expression:
    """True divides two numeric expressions (``e1 / e2``)."""
    expr = Expression._to_expression(other)
    return Expression._from_pyexpr(self._expr / expr._expr)

def __xor__(self, other: Expression) -> Expression:
    """Takes the logical XOR of two boolean or integer expressions, or bitwise XOR of two integer expressions (``e1 ^ e2``)."""
    expr = Expression._to_expression(other)
    return Expression._from_pyexpr(self._expr ^ expr._expr)

def abs(self) -> Expression:
    """Absolute of a numeric expression.

    Tip: See Also
        [`daft.functions.abs`](https://docs.daft.ai/en/stable/api/functions/abs/)
    """
    from daft.functions import abs

    return abs(self)

def alias(self, name: builtins.str) -> Expression:
    """Gives the expression a new name.

    Args:
        name: New name for expression

    Returns:
        Expression: Renamed expression

    Examples:
        >>> import daft
        >>> df = daft.from_pydict({"x": [1, 2, 3]})
        >>> df = df.select(col("x").alias("y"))
        >>> df.show()
        ╭───────╮
        │ y     │
        │ ---   │
        │ Int64 │
        ╞═══════╡
        │ 1     │
        ├╌╌╌╌╌╌╌┤
        │ 2     │
        ├╌╌╌╌╌╌╌┤
        │ 3     │
        ╰───────╯
        <BLANKLINE>
        (Showing first 3 of 3 rows)

    """
    assert isinstance(name, str)
    expr = self._expr.alias(name)
    return Expression._from_pyexpr(expr)

def any_value(self, ignore_nulls: bool = False) -> Expression:
    """Returns any value in the expression.

    Tip: See Also
        [`daft.functions.any_value`](https://docs.daft.ai/en/stable/api/functions/any_value/)
    """
    from daft.functions import any_value

    return any_value(self, ignore_nulls=ignore_nulls)

def apply(self, func: Callable[..., Any], return_dtype: DataTypeLike) -> Expression:
    """Apply a function on each value in a given expression.

    Args:
        func: Function to run per value of the expression
        return_dtype: Return datatype of the function that was ran

    Returns:
        Expression: New expression after having run the function on the expression

    Note:
        This is just syntactic sugar on top of a UDF and is convenient to use when your function only operates
        on a single column, and does not benefit from executing on batches. For either of those other use-cases,
        use a UDF instead.

    Examples:
        >>> import daft
        >>> df = daft.from_pydict({"x": ["1", "2", "tim"]})
        >>> def f(x_val: str) -> int:
        ...     if x_val.isnumeric():
        ...         return int(x_val)
        ...     else:
        ...         return 0
        >>> df.with_column("num_x", df["x"].apply(f, return_dtype=daft.DataType.int64())).collect()
        ╭────────┬───────╮
        │ x      ┆ num_x │
        │ ---    ┆ ---   │
        │ String ┆ Int64 │
        ╞════════╪═══════╡
        │ 1      ┆ 1     │
        ├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┤
        │ 2      ┆ 2     │
        ├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┤
        │ tim    ┆ 0     │
        ╰────────┴───────╯
        <BLANKLINE>
        (Showing first 3 of 3 rows)

    """
    from daft.udf import UDF

    inferred_return_dtype = DataType._infer(return_dtype)

    def batch_func(self_series: Series) -> list[Any]:
        return [func(x) for x in self_series]

    name = getattr(func, "__module__", "")
    if name:
        name = name + "."
    if hasattr(func, "__qualname__"):
        name = name + getattr(func, "__qualname__")
    elif hasattr(func, "__class__"):
        name = name + func.__class__.__name__
    else:
        name = name + func.__name__

    return UDF(
        inner=batch_func,
        name=name,
        return_dtype=inferred_return_dtype,
    )(self)

def approx_count_distinct(self) -> Expression:
    """Calculates the approximate number of non-`NULL` distinct values in the expression.

    Tip: See Also
          [`daft.functions.approx_count_distinct`](https://docs.daft.ai/en/stable/api/functions/approx_count_distinct/)
    """
    from daft.functions import approx_count_distinct

    return approx_count_distinct(self)

def approx_percentiles(self, percentiles: builtins.float | builtins.list[builtins.float]) -> Expression:
    """Calculates the approximate percentile(s) for a column of numeric values.

    Tip: See Also
        [`daft.functions.approx_percentiles`](https://docs.daft.ai/en/stable/api/functions/approx_percentiles/)
    """
    from daft.functions import approx_percentiles

    return approx_percentiles(self, percentiles)

def arccos(self) -> Expression:
    """The elementwise arc cosine of a numeric expression.

    Tip: See Also
        [`daft.functions.arccos`](https://docs.daft.ai/en/stable/api/functions/arccos/)
    """
    from daft.functions import arccos

    return arccos(self)

def arccosh(self) -> Expression:
    """The elementwise inverse hyperbolic cosine of a numeric expression.

    Tip: See Also
        [`daft.functions.arccosh`](https://docs.daft.ai/en/stable/api/functions/arccosh/)
    """
    from daft.functions import arccosh

    return arccosh(self)

def arcsin(self) -> Expression:
    """The elementwise arc sine of a numeric expression.

    Tip: See Also
        [`daft.functions.arcsin`](https://docs.daft.ai/en/stable/api/functions/arcsin/)
    """
    from daft.functions import arcsin

    return arcsin(self)

def arcsinh(self) -> Expression:
    """The elementwise inverse hyperbolic sine of a numeric expression.

    Tip: See Also
        [`daft.functions.arcsinh`](https://docs.daft.ai/en/stable/api/functions/arcsinh/)
    """
    from daft.functions import arcsinh

    return arcsinh(self)

def arctan(self) -> Expression:
    """The elementwise arc tangent of a numeric expression.

    Tip: See Also
        [`daft.functions.arctan`](https://docs.daft.ai/en/stable/api/functions/arctan/)
    """
    from daft.functions import arctan

    return arctan(self)

def arctan2(self, other: Expression) -> Expression:
    """Calculates the four quadrant arctangent of coordinates (y, x), in radians.

    Tip: See Also
        [`daft.functions.arctan2`](https://docs.daft.ai/en/stable/api/functions/arctan2/)
    """
    from daft.functions import arctan2

    return arctan2(self, other)

def arctanh(self) -> Expression:
    """The elementwise inverse hyperbolic tangent of a numeric expression.

    Tip: See Also
        [`daft.functions.arctanh`](https://docs.daft.ai/en/stable/api/functions/arctanh/)
    """
    from daft.functions import arctanh

    return arctanh(self)

def as_binary(self) -> Expression: ...

def as_bool(self) -> Expression: ...

def as_date(self) -> Expression: ...

def as_decimal128(self, precision: int, scale: int) -> Expression: ...

def as_duration(self, timeunit: TimeUnit | str) -> Expression: ...

def as_embedding(self, dtype: DataType, size: int) -> Expression: ...

def as_extension(self, name: str, storage_dtype: DataType, metadata: str | None = ...) -> Expression: ...

def as_file(self, media_type: MediaType = ...) -> Expression: ...

def as_fixed_size_binary(self, size: int) -> Expression: ...

def as_fixed_size_list(self, dtype: DataType, size: int) -> Expression: ...

def as_float32(self) -> Expression: ...

def as_float64(self) -> Expression: ...

def as_image(
    self, mode: str | ImageMode | None = ..., height: int | None = ..., width: int | None = ...
) -> Expression: ...

def as_int16(self) -> Expression: ...

def as_int32(self) -> Expression: ...