polars_python/lazyframe/visitor/

expr_nodes.rs

#[cfg(feature = "iejoin")]
use polars::prelude::InequalityOperator;
use polars::series::ops::NullBehavior;
use polars_compute::rolling::{QuantileMethod, RollingFnParams};
use polars_core::chunked_array::ops::FillNullStrategy;
#[cfg(feature = "string_normalize")]
use polars_ops::chunked_array::UnicodeForm;
use polars_ops::prelude::RankMethod;
#[cfg(feature = "search_sorted")]
use polars_ops::series::SearchSortedSide;
use polars_ops::series::{ClosedInterval, InterpolationMethod};
use polars_plan::dsl::DateRangeArgs;
use polars_plan::plans::{
    DynListLiteralValue, DynLiteralValue, FusedOperator, IRArrayFunction, IRBitwiseFunction,
    IRBooleanFunction, IRCorrelationMethod, IRFunctionExpr, IRListFunction, IRPowFunction,
    IRRandomMethod, IRRangeFunction, IRRollingFunction, IRRollingFunctionBy, IRStringFunction,
    IRStructFunction, IRTemporalFunction,
};
use polars_plan::prelude::{
    AExpr, GroupbyOptions, IRAggExpr, LiteralValue, Operator, PlanCallback, WindowMapping,
};
use polars_time::prelude::RollingGroupOptions;
use polars_time::{ClosedWindow, Duration, DynamicGroupOptions};
use polars_utils::itertools::Itertools;
use pyo3::IntoPyObjectExt;
use pyo3::exceptions::PyNotImplementedError;
use pyo3::prelude::*;
use pyo3::types::{PyBytes, PyInt, PyList, PyTuple};

use crate::Wrap;
use crate::lazyframe::visit::PyExprIR;
use crate::series::PySeries;

#[pyclass(frozen)]
pub struct Alias {
    #[pyo3(get)]
    expr: usize,
    #[pyo3(get)]
    name: Py<PyAny>,
}

#[pyclass(frozen)]
pub struct Column {
    #[pyo3(get)]
    name: Py<PyAny>,
}

#[pyclass(frozen)]
pub struct Literal {
    #[pyo3(get)]
    value: Py<PyAny>,
    #[pyo3(get)]
    dtype: Py<PyAny>,
}

#[pyclass(name = "Operator", eq, frozen, skip_from_py_object)]
#[derive(Copy, Clone, PartialEq)]
pub enum PyOperator {
    Eq,
    EqValidity,
    NotEq,
    NotEqValidity,
    Lt,
    LtEq,
    Gt,
    GtEq,
    Plus,
    Minus,
    Multiply,
    Divide,
    TrueDivide,
    FloorDivide,
    Modulus,
    And,
    Or,
    Xor,
    LogicalAnd,
    LogicalOr,
}

#[pymethods]
impl PyOperator {
    fn __hash__(&self) -> isize {
        *self as isize
    }
}

impl<'py> IntoPyObject<'py> for Wrap<Operator> {
    type Target = PyOperator;
    type Output = Bound<'py, Self::Target>;
    type Error = PyErr;

    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
        match self.0 {
            Operator::Eq => PyOperator::Eq,
            Operator::EqValidity => PyOperator::EqValidity,
            Operator::NotEq => PyOperator::NotEq,
            Operator::NotEqValidity => PyOperator::NotEqValidity,
            Operator::Lt => PyOperator::Lt,
            Operator::LtEq => PyOperator::LtEq,
            Operator::Gt => PyOperator::Gt,
            Operator::GtEq => PyOperator::GtEq,
            Operator::Plus => PyOperator::Plus,
            Operator::Minus => PyOperator::Minus,
            Operator::Multiply => PyOperator::Multiply,
            Operator::RustDivide => PyOperator::Divide,
            Operator::TrueDivide => PyOperator::TrueDivide,
            Operator::FloorDivide => PyOperator::FloorDivide,
            Operator::Modulus => PyOperator::Modulus,
            Operator::And => PyOperator::And,
            Operator::Or => PyOperator::Or,
            Operator::Xor => PyOperator::Xor,
            Operator::LogicalAnd => PyOperator::LogicalAnd,
            Operator::LogicalOr => PyOperator::LogicalOr,
        }
        .into_pyobject(py)
    }
}

#[cfg(feature = "iejoin")]
impl<'py> IntoPyObject<'py> for Wrap<InequalityOperator> {
    type Target = PyOperator;
    type Output = Bound<'py, Self::Target>;
    type Error = PyErr;

    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
        match self.0 {
            InequalityOperator::Lt => PyOperator::Lt,
            InequalityOperator::LtEq => PyOperator::LtEq,
            InequalityOperator::Gt => PyOperator::Gt,
            InequalityOperator::GtEq => PyOperator::GtEq,
        }
        .into_pyobject(py)
    }
}

#[pyclass(name = "StringFunction", eq, frozen, skip_from_py_object)]
#[derive(Copy, Clone, PartialEq)]
pub enum PyStringFunction {
    ConcatHorizontal,
    ConcatVertical,
    Contains,
    CountMatches,
    EndsWith,
    Extract,
    ExtractAll,
    ExtractGroups,
    Find,
    ToInteger,
    LenBytes,
    LenChars,
    Lowercase,
    JsonDecode,
    JsonPathMatch,
    Replace,
    Reverse,
    PadStart,
    PadEnd,
    Slice,
    Head,
    Tail,
    HexEncode,
    HexDecode,
    Base64Encode,
    Base64Decode,
    StartsWith,
    StripChars,
    StripCharsStart,
    StripCharsEnd,
    StripPrefix,
    StripSuffix,
    SplitExact,
    SplitN,
    Strptime,
    Split,
    SplitRegex,
    ToDecimal,
    Titlecase,
    Uppercase,
    ZFill,
    ContainsAny,
    ReplaceMany,
    EscapeRegex,
    Normalize,
    Format,
    ExtractMany,
    FindMany,
}

#[pymethods]
impl PyStringFunction {
    fn __hash__(&self) -> isize {
        *self as isize
    }
}

#[pyclass(name = "BooleanFunction", eq, frozen, skip_from_py_object)]
#[derive(Copy, Clone, PartialEq)]
pub enum PyBooleanFunction {
    Any,
    All,
    IsEmpty,
    HasNulls,
    IsNull,
    IsNotNull,
    IsFinite,
    IsInfinite,
    IsNan,
    IsNotNan,
    IsFirstDistinct,
    IsLastDistinct,
    IsUnique,
    IsDuplicated,
    IsBetween,
    IsIn,
    IsClose,
    IsSorted,
    AllHorizontal,
    AnyHorizontal,
    Not,
}

#[pymethods]
impl PyBooleanFunction {
    fn __hash__(&self) -> isize {
        *self as isize
    }
}

#[pyclass(name = "TemporalFunction", eq, frozen, skip_from_py_object)]
#[derive(Copy, Clone, PartialEq)]
pub enum PyTemporalFunction {
    Millennium,
    Century,
    Year,
    IsLeapYear,
    IsoYear,
    Quarter,
    Month,
    DaysInMonth,
    Week,
    WeekDay,
    Day,
    OrdinalDay,
    Time,
    Date,
    Datetime,
    Duration,
    Hour,
    Minute,
    Second,
    Millisecond,
    Microsecond,
    Nanosecond,
    TotalDays,
    TotalHours,
    TotalMinutes,
    TotalSeconds,
    TotalMilliseconds,
    TotalMicroseconds,
    TotalNanoseconds,
    ToString,
    CastTimeUnit,
    WithTimeUnit,
    ConvertTimeZone,
    TimeStamp,
    Truncate,
    OffsetBy,
    MonthStart,
    MonthEnd,
    BaseUtcOffset,
    DSTOffset,
    Round,
    Replace,
    ReplaceTimeZone,
    Combine,
    DatetimeFunction,
}

#[pymethods]
impl PyTemporalFunction {
    fn __hash__(&self) -> isize {
        *self as isize
    }
}

#[pyclass(name = "StructFunction", eq, frozen, skip_from_py_object)]
#[derive(Copy, Clone, PartialEq)]
pub enum PyStructFunction {
    FieldByName,
    RenameFields,
    DropFields,
    PrefixFields,
    SuffixFields,
    JsonEncode,
    WithFields,
    MapFieldNames,
}

#[pymethods]
impl PyStructFunction {
    fn __hash__(&self) -> isize {
        *self as isize
    }
}

#[pyclass(name = "ListFunction", eq, frozen, skip_from_py_object)]
#[derive(Copy, Clone, PartialEq)]
pub enum PyListFunction {
    Concat,
    Contains,
    DropNulls,
    Get,
    Length,
    Sort,
    SetOperation,
    Sample,
    Slice,
    Shift,
    Gather,
    GatherEvery,
    CountMatches,
    Sum,
    Max,
    Min,
    Mean,
    Median,
    Std,
    Var,
    ArgMin,
    ArgMax,
    Diff,
    Join,
    ToArray,
    ToStruct,
}

#[pymethods]
impl PyListFunction {
    fn __hash__(&self) -> isize {
        *self as isize
    }
}

#[pyclass(name = "ArrayFunction", eq, frozen, skip_from_py_object)]
#[derive(Copy, Clone, PartialEq)]
pub enum PyArrayFunction {
    Length,
    Min,
    Max,
    Sum,
    ToList,
    Std,
    Var,
    Mean,
    Median,
    Sort,
    ArgMin,
    ArgMax,
    Get,
    Join,
    Contains,
    CountMatches,
    Shift,
    Explode,
    Concat,
    Slice,
    ToStruct,
}

#[pymethods]
impl PyArrayFunction {
    fn __hash__(&self) -> isize {
        *self as isize
    }
}

#[pyclass(name = "RollingFunction", eq, frozen, skip_from_py_object)]
#[derive(Copy, Clone, PartialEq)]
pub enum PyRollingFunction {
    Min,
    Max,
    Mean,
    Sum,
    Quantile,
    Var,
    Std,
    Rank,
    Skew,
    Kurtosis,
    CorrCov,
}

#[pymethods]
impl PyRollingFunction {
    fn __hash__(&self) -> isize {
        *self as isize
    }
}

#[pyclass(name = "EwmFunction", eq, frozen, skip_from_py_object)]
#[derive(Copy, Clone, PartialEq)]
pub enum PyEwmFunction {
    Mean,
    Sum,
    Std,
    Var,
    MeanBy,
    SumBy,
}

#[pymethods]
impl PyEwmFunction {
    fn __hash__(&self) -> isize {
        *self as isize
    }
}

#[pyclass(name = "RollingFunctionBy", eq, frozen, skip_from_py_object)]
#[derive(Copy, Clone, PartialEq)]
pub enum PyRollingFunctionBy {
    MinBy,
    MaxBy,
    MeanBy,
    SumBy,
    QuantileBy,
    VarBy,
    StdBy,
    RankBy,
}

#[pymethods]
impl PyRollingFunctionBy {
    fn __hash__(&self) -> isize {
        *self as isize
    }
}

#[pyclass(name = "BitwiseFunction", eq, frozen, skip_from_py_object)]
#[derive(Copy, Clone, PartialEq)]
pub enum PyBitwiseFunction {
    CountOnes,
    CountZeros,
    LeadingOnes,
    LeadingZeros,
    TrailingOnes,
    TrailingZeros,
    And,
    Or,
    Xor,
}

#[pymethods]
impl PyBitwiseFunction {
    fn __hash__(&self) -> isize {
        *self as isize
    }
}

#[pyclass(name = "RangeFunction", eq, frozen, skip_from_py_object)]
#[derive(Copy, Clone, PartialEq)]
pub enum PyRangeFunction {
    IntRange,
    IntRanges,
    LinearSpace,
    LinearSpaces,
    DateRange,
    DateRanges,
    DatetimeRange,
    DatetimeRanges,
    TimeRange,
    TimeRanges,
}

#[pymethods]
impl PyRangeFunction {
    fn __hash__(&self) -> isize {
        *self as isize
    }
}

#[pyclass(frozen)]
pub struct BinaryExpr {
    #[pyo3(get)]
    left: usize,
    #[pyo3(get)]
    op: Py<PyAny>,
    #[pyo3(get)]
    right: usize,
}

#[pyclass(frozen)]
pub struct Cast {
    #[pyo3(get)]
    expr: usize,
    #[pyo3(get)]
    dtype: Py<PyAny>,
    // 0: strict
    // 1: non-strict
    // 2: overflow
    #[pyo3(get)]
    options: u8,
}

#[pyclass(frozen)]
pub struct Sort {
    #[pyo3(get)]
    expr: usize,
    #[pyo3(get)]
    /// maintain_order, nulls_last, descending
    options: (bool, bool, bool),
}

#[pyclass(frozen)]
pub struct Gather {
    #[pyo3(get)]
    expr: usize,
    #[pyo3(get)]
    idx: usize,
    #[pyo3(get)]
    scalar: bool,
}

#[pyclass(frozen)]
pub struct Filter {
    #[pyo3(get)]
    input: usize,
    #[pyo3(get)]
    by: usize,
}

#[pyclass(frozen)]
pub struct SortBy {
    #[pyo3(get)]
    expr: usize,
    #[pyo3(get)]
    by: Vec<usize>,
    #[pyo3(get)]
    /// maintain_order, nulls_last, descending
    sort_options: (bool, Vec<bool>, Vec<bool>),
}

#[pyclass(frozen)]
pub struct Agg {
    #[pyo3(get)]
    name: Py<PyAny>,
    #[pyo3(get)]
    arguments: Vec<usize>,
    #[pyo3(get)]
    // Arbitrary control options
    options: Py<PyAny>,
}

#[pyclass(frozen)]
pub struct Ternary {
    #[pyo3(get)]
    predicate: usize,
    #[pyo3(get)]
    truthy: usize,
    #[pyo3(get)]
    falsy: usize,
}

#[pyclass(frozen)]
pub struct Function {
    #[pyo3(get)]
    input: Vec<usize>,
    #[pyo3(get)]
    function_data: Py<PyAny>,
    #[pyo3(get)]
    options: Py<PyAny>,
}

#[pyclass(frozen)]
pub struct Slice {
    #[pyo3(get)]
    input: usize,
    #[pyo3(get)]
    offset: usize,
    #[pyo3(get)]
    length: usize,
}

#[pyclass(frozen)]
pub struct Len {}

#[pyclass(frozen)]
pub struct StructEval {
    #[pyo3(get)]
    expr: usize,
    #[pyo3(get)]
    evaluation: Vec<PyExprIR>,
}

#[pyclass(frozen)]
pub struct Explode {
    #[pyo3(get)]
    expr: usize,
    #[pyo3(get)]
    // empty_as_null, keep_nulls
    options: (bool, bool),
}

#[pyclass(frozen)]
pub struct Window {
    #[pyo3(get)]
    function: usize,
    #[pyo3(get)]
    partition_by: Vec<usize>,
    #[pyo3(get)]
    order_by: Option<usize>,
    #[pyo3(get)]
    order_by_descending: bool,
    #[pyo3(get)]
    order_by_nulls_last: bool,
    #[pyo3(get)]
    options: Py<PyAny>,
}

#[pyclass(frozen)]
pub struct Rolling {
    #[pyo3(get)]
    function: usize,
    #[pyo3(get)]
    index_column: usize,
    #[pyo3(get)]
    period: Py<PyAny>,
    #[pyo3(get)]
    offset: Py<PyAny>,
    #[pyo3(get)]
    closed_window: Py<PyAny>,
}

#[pyclass(name = "WindowMapping", frozen)]
pub struct PyWindowMapping {
    inner: WindowMapping,
}

#[pymethods]
impl PyWindowMapping {
    #[getter]
    fn kind(&self) -> &str {
        self.inner.into()
    }
}

impl<'py> IntoPyObject<'py> for Wrap<Duration> {
    type Target = PyTuple;
    type Output = Bound<'py, Self::Target>;
    type Error = PyErr;

    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
        (
            self.0.months(),
            self.0.weeks(),
            self.0.days(),
            self.0.nanoseconds(),
            self.0.parsed_int,
            self.0.negative(),
        )
            .into_pyobject(py)
    }
}

impl<'py> IntoPyObject<'py> for Wrap<ClosedWindow> {
    type Target = PyAny;
    type Output = Bound<'py, Self::Target>;
    type Error = PyErr;

    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
        let s = match self.0 {
            ClosedWindow::Left => "left",
            ClosedWindow::Right => "right",
            ClosedWindow::Both => "both",
            ClosedWindow::None => "none",
        };
        Ok(s.into_pyobject(py)?.into_any())
    }
}

#[pyclass(name = "RollingGroupOptions", frozen)]
pub struct PyRollingGroupOptions {
    inner: RollingGroupOptions,
}

#[pymethods]
impl PyRollingGroupOptions {
    #[getter]
    fn index_column(&self) -> &str {
        self.inner.index_column.as_str()
    }

    #[getter]
    fn period(&self) -> Wrap<Duration> {
        Wrap(self.inner.period)
    }

    #[getter]
    fn offset(&self) -> Wrap<Duration> {
        Wrap(self.inner.offset)
    }

    #[getter]
    fn closed_window(&self) -> &str {
        self.inner.closed_window.into()
    }
}

#[pyclass(name = "DynamicGroupOptions", frozen)]
pub struct PyDynamicGroupOptions {
    inner: DynamicGroupOptions,
}

#[pymethods]
impl PyDynamicGroupOptions {
    #[getter]
    fn index_column(&self) -> &str {
        self.inner.index_column.as_str()
    }

    #[getter]
    fn every(&self) -> Wrap<Duration> {
        Wrap(self.inner.every)
    }

    #[getter]
    fn period(&self) -> Wrap<Duration> {
        Wrap(self.inner.period)
    }

    #[getter]
    fn offset(&self) -> Wrap<Duration> {
        Wrap(self.inner.offset)
    }

    #[getter]
    fn label(&self) -> &str {
        self.inner.label.into()
    }

    #[getter]
    fn include_boundaries(&self) -> bool {
        self.inner.include_boundaries
    }

    #[getter]
    fn closed_window(&self) -> &str {
        self.inner.closed_window.into()
    }
    #[getter]
    fn start_by(&self) -> &str {
        self.inner.start_by.into()
    }
}

#[pyclass(name = "GroupbyOptions", frozen)]
pub struct PyGroupbyOptions {
    inner: GroupbyOptions,
}

impl PyGroupbyOptions {
    pub(crate) fn new(inner: GroupbyOptions) -> Self {
        Self { inner }
    }
}

#[pymethods]
impl PyGroupbyOptions {
    #[getter]
    fn slice(&self) -> Option<(i64, usize)> {
        self.inner.slice
    }

    #[getter]
    fn dynamic(&self) -> Option<PyDynamicGroupOptions> {
        self.inner
            .dynamic
            .as_ref()
            .map(|f| PyDynamicGroupOptions { inner: f.clone() })
    }

    #[getter]
    fn rolling(&self) -> Option<PyRollingGroupOptions> {
        self.inner
            .rolling
            .as_ref()
            .map(|f| PyRollingGroupOptions { inner: f.clone() })
    }
}

// Serialize the optional per-op rolling parameters into the flat tuple consumed by
// external engines (e.g., cudf-polars).
fn rolling_fn_params_into_py(
    py: Python<'_>,
    fn_params: &Option<RollingFnParams>,
) -> PyResult<Py<PyAny>> {
    match fn_params {
        None => ().into_py_any(py),
        Some(RollingFnParams::Quantile(q)) => {
            (q.prob, Into::<&str>::into(q.method)).into_py_any(py)
        },
        Some(RollingFnParams::Var(v)) => (v.ddof,).into_py_any(py),
        Some(RollingFnParams::Rank { method, seed }) => {
            let method = Into::<&str>::into(method);
            (method, *seed).into_py_any(py)
        },
        Some(RollingFnParams::Skew { bias }) => (*bias,).into_py_any(py),
        Some(RollingFnParams::Kurtosis { fisher, bias }) => (*fisher, *bias).into_py_any(py),
    }
}

fn closed_interval_into_py(closed: &ClosedInterval) -> &'static str {
    match closed {
        ClosedInterval::Both => "both",
        ClosedInterval::Left => "left",
        ClosedInterval::Right => "right",
        ClosedInterval::None => "none",
    }
}

fn date_range_args_into_py(arg_type: &DateRangeArgs) -> &'static str {
    match arg_type {
        DateRangeArgs::StartEndInterval => "start_end_interval",
        DateRangeArgs::StartEndSamples => "start_end_samples",
        DateRangeArgs::StartIntervalSamples => "start_interval_samples",
        DateRangeArgs::EndIntervalSamples => "end_interval_samples",
    }
}

// Recursively convert a nested dynamic list literal into Python lists.
fn dyn_list_literal_into_py(py: Python<'_>, value: &DynListLiteralValue) -> PyResult<Py<PyAny>> {
    match value {
        DynListLiteralValue::Str(values) => values
            .iter()
            .map(|v| v.as_ref().map(|s| s.as_str()))
            .collect::<Vec<_>>()
            .into_py_any(py),
        DynListLiteralValue::Int(values) => values.to_vec().into_py_any(py),
        DynListLiteralValue::Float(values) => values.to_vec().into_py_any(py),
        DynListLiteralValue::List(values) => {
            let out = PyList::new(py, [] as [Bound<'_, PyAny>; 0])?;
            for v in values.iter() {
                match v {
                    None => out.append(py.None())?,
                    Some(inner) => out.append(dyn_list_literal_into_py(py, inner)?)?,
                }
            }
            out.into_py_any(py)
        },
    }
}

pub(crate) fn into_py(py: Python<'_>, expr: &AExpr) -> PyResult<Py<PyAny>> {
    match expr {
        AExpr::Element => Err(PyNotImplementedError::new_err("element")),
        AExpr::Explode { expr, options } => Explode {
            expr: expr.0,
            options: (options.empty_as_null, options.keep_nulls),
        }
        .into_py_any(py),
        AExpr::Column(name) => Column {
            name: name.into_py_any(py)?,
        }
        .into_py_any(py),
        AExpr::StructField(_) => Err(PyNotImplementedError::new_err("field")),
        AExpr::Literal(lit) => {
            use polars_core::prelude::AnyValue;
            let dtype: Py<PyAny> = Wrap(lit.get_datatype()).into_py_any(py)?;
            let py_value = match lit {
                LiteralValue::Dyn(d) => match d {
                    DynLiteralValue::Int(v) => v.into_py_any(py)?,
                    DynLiteralValue::Float(v) => v.into_py_any(py)?,
                    DynLiteralValue::Str(v) => v.into_py_any(py)?,
                    DynLiteralValue::List(v) => dyn_list_literal_into_py(py, v)?,
                },
                LiteralValue::Scalar(sc) => {
                    match sc.as_any_value() {
                        // AnyValue conversion of duration to python's
                        // datetime.timedelta drops nanoseconds because
                        // there is no support for them. See
                        // https://github.com/python/cpython/issues/59648
                        AnyValue::Duration(delta, _) => delta.into_py_any(py)?,
                        any => Wrap(any).into_py_any(py)?,
                    }
                },
                LiteralValue::Range(range) => (range.low, range.high).into_py_any(py)?,
                LiteralValue::Series(s) => PySeries::new((**s).clone()).into_py_any(py)?,
            };

            Literal {
                value: py_value,
                dtype,
            }
        }
        .into_py_any(py),
        AExpr::BinaryExpr { left, op, right } => BinaryExpr {
            left: left.0,
            op: Wrap(*op).into_py_any(py)?,
            right: right.0,
        }
        .into_py_any(py),
        AExpr::Cast {
            expr,
            dtype,
            options,
        } => Cast {
            expr: expr.0,
            dtype: Wrap(dtype.clone()).into_py_any(py)?,
            options: *options as u8,
        }
        .into_py_any(py),
        AExpr::Sort { expr, options } => Sort {
            expr: expr.0,
            options: (
                options.maintain_order,
                options.nulls_last,
                options.descending,
            ),
        }
        .into_py_any(py),
        AExpr::Gather {
            expr,
            idx,
            returns_scalar,
            null_on_oob: _,
        } => Gather {
            expr: expr.0,
            idx: idx.0,
            scalar: *returns_scalar,
        }
        .into_py_any(py),
        AExpr::Filter { input, by } => Filter {
            input: input.0,
            by: by.0,
        }
        .into_py_any(py),
        AExpr::SortBy {
            expr,
            by,
            sort_options,
        } => SortBy {
            expr: expr.0,
            by: by.iter().map(|n| n.0).collect(),
            sort_options: (
                sort_options.maintain_order,
                sort_options.nulls_last.clone(),
                sort_options.descending.clone(),
            ),
        }
        .into_py_any(py),
        AExpr::Agg(aggexpr) => match aggexpr {
            IRAggExpr::Min {
                input,
                propagate_nans,
            } => Agg {
                name: "min".into_py_any(py)?,
                arguments: vec![input.0],
                options: propagate_nans.into_py_any(py)?,
            },
            IRAggExpr::Max {
                input,
                propagate_nans,
            } => Agg {
                name: "max".into_py_any(py)?,
                arguments: vec![input.0],
                options: propagate_nans.into_py_any(py)?,
            },
            IRAggExpr::Median(n) => Agg {
                name: "median".into_py_any(py)?,
                arguments: vec![n.0],
                options: py.None(),
            },
            IRAggExpr::NUnique(n) => Agg {
                name: "n_unique".into_py_any(py)?,
                arguments: vec![n.0],
                options: py.None(),
            },
            IRAggExpr::First(n) => Agg {
                name: "first".into_py_any(py)?,
                arguments: vec![n.0],
                options: py.None(),
            },
            IRAggExpr::FirstNonNull(n) => Agg {
                name: "first_non_null".into_py_any(py)?,
                arguments: vec![n.0],
                options: py.None(),
            },
            IRAggExpr::Last(n) => Agg {
                name: "last".into_py_any(py)?,
                arguments: vec![n.0],
                options: py.None(),
            },
            IRAggExpr::LastNonNull(n) => Agg {
                name: "last_non_null".into_py_any(py)?,
                arguments: vec![n.0],
                options: py.None(),
            },
            IRAggExpr::Item {
                input: n,
                allow_empty,
            } => Agg {
                name: "item".into_py_any(py)?,
                arguments: vec![n.0],
                options: allow_empty.into_py_any(py)?,
            },
            IRAggExpr::Mean(n) => Agg {
                name: "mean".into_py_any(py)?,
                arguments: vec![n.0],
                options: py.None(),
            },
            IRAggExpr::Implode {
                input: n,
                maintain_order,
            } => Agg {
                name: "implode".into_py_any(py)?,
                arguments: vec![n.0],
                options: maintain_order.into_py_any(py)?,
            },
            IRAggExpr::Sum(n) => Agg {
                name: "sum".into_py_any(py)?,
                arguments: vec![n.0],
                options: py.None(),
            },
            IRAggExpr::Count {
                input: n,
                include_nulls,
            } => Agg {
                name: "count".into_py_any(py)?,
                arguments: vec![n.0],
                options: include_nulls.into_py_any(py)?,
            },
            IRAggExpr::Std(n, ddof) => Agg {
                name: "std".into_py_any(py)?,
                arguments: vec![n.0],
                options: ddof.into_py_any(py)?,
            },
            IRAggExpr::Var(n, ddof) => Agg {
                name: "var".into_py_any(py)?,
                arguments: vec![n.0],
                options: ddof.into_py_any(py)?,
            },
            IRAggExpr::AggGroups(n) => Agg {
                name: "agg_groups".into_py_any(py)?,
                arguments: vec![n.0],
                options: py.None(),
            },
        }
        .into_py_any(py),
        AExpr::Ternary {
            predicate,
            truthy,
            falsy,
        } => Ternary {
            predicate: predicate.0,
            truthy: truthy.0,
            falsy: falsy.0,
        }
        .into_py_any(py),
        AExpr::AnonymousFunction { .. } => Err(PyNotImplementedError::new_err("anonymousfunction")),
        AExpr::AnonymousAgg { .. } => {
            Err(PyNotImplementedError::new_err("anonymous_streaming_agg"))
        },
        AExpr::Function {
            input,
            function,
            // TODO: expose options
            options: _,
        } => Function {
            input: input.iter().map(|n| n.node().0).collect(),
            function_data: match function {
                IRFunctionExpr::ArrayExpr(f) => match f {
                    IRArrayFunction::Length => (PyArrayFunction::Length,).into_py_any(py),
                    IRArrayFunction::Min => (PyArrayFunction::Min,).into_py_any(py),
                    IRArrayFunction::Max => (PyArrayFunction::Max,).into_py_any(py),
                    IRArrayFunction::Sum => (PyArrayFunction::Sum,).into_py_any(py),
                    IRArrayFunction::ToList => (PyArrayFunction::ToList,).into_py_any(py),
                    IRArrayFunction::Std(ddof) => (PyArrayFunction::Std, *ddof).into_py_any(py),
                    IRArrayFunction::Var(ddof) => (PyArrayFunction::Var, *ddof).into_py_any(py),
                    IRArrayFunction::Mean => (PyArrayFunction::Mean,).into_py_any(py),
                    IRArrayFunction::Median => (PyArrayFunction::Median,).into_py_any(py),
                    IRArrayFunction::Sort(options) => (
                        PyArrayFunction::Sort,
                        options.descending,
                        options.nulls_last,
                    )
                        .into_py_any(py),
                    IRArrayFunction::ArgMin => (PyArrayFunction::ArgMin,).into_py_any(py),
                    IRArrayFunction::ArgMax => (PyArrayFunction::ArgMax,).into_py_any(py),
                    IRArrayFunction::Get(null_on_oob) => {
                        (PyArrayFunction::Get, *null_on_oob).into_py_any(py)
                    },
                    IRArrayFunction::Join(ignore_nulls) => {
                        (PyArrayFunction::Join, *ignore_nulls).into_py_any(py)
                    },
                    #[cfg(feature = "is_in")]
                    IRArrayFunction::Contains { nulls_equal } => {
                        (PyArrayFunction::Contains, *nulls_equal).into_py_any(py)
                    },
                    #[cfg(feature = "array_count")]
                    IRArrayFunction::CountMatches => {
                        (PyArrayFunction::CountMatches,).into_py_any(py)
                    },
                    IRArrayFunction::Shift => (PyArrayFunction::Shift,).into_py_any(py),
                    IRArrayFunction::Explode(options) => (
                        PyArrayFunction::Explode,
                        options.empty_as_null,
                        options.keep_nulls,
                    )
                        .into_py_any(py),
                    IRArrayFunction::Concat => (PyArrayFunction::Concat,).into_py_any(py),
                    IRArrayFunction::Slice(offset, length) => {
                        (PyArrayFunction::Slice, *offset, *length).into_py_any(py)
                    },
                    // Callable name generators are deprecated in favor of explicit field names and
                    // cannot be represented in the typed view.
                    IRArrayFunction::ToStruct(name_generator) => match name_generator {
                        None => (PyArrayFunction::ToStruct, py.None()).into_py_any(py),
                        Some(_) => {
                            return Err(PyNotImplementedError::new_err(
                                "array to_struct with a name generator",
                            ));
                        },
                    },
                },
                IRFunctionExpr::BinaryExpr(_) => {
                    return Err(PyNotImplementedError::new_err("binary expr"));
                },
                IRFunctionExpr::Categorical(_) => {
                    return Err(PyNotImplementedError::new_err("categorical expr"));
                },
                IRFunctionExpr::Extension(_) => {
                    return Err(PyNotImplementedError::new_err("extension expr"));
                },
                IRFunctionExpr::ListExpr(listfun) => match listfun {
                    IRListFunction::Concat => (PyListFunction::Concat,).into_py_any(py),
                    #[cfg(feature = "is_in")]
                    IRListFunction::Contains { nulls_equal } => {
                        (PyListFunction::Contains, nulls_equal).into_py_any(py)
                    },
                    #[cfg(feature = "list_drop_nulls")]
                    IRListFunction::DropNulls => (PyListFunction::DropNulls,).into_py_any(py),
                    IRListFunction::Get(null_on_oob) => {
                        (PyListFunction::Get, null_on_oob).into_py_any(py)
                    },
                    IRListFunction::Length => (PyListFunction::Length,).into_py_any(py),
                    IRListFunction::Sort(options) => {
                        (PyListFunction::Sort, options.descending, options.nulls_last)
                            .into_py_any(py)
                    },
                    #[cfg(feature = "list_sets")]
                    IRListFunction::SetOperation(set_operation) => (
                        PyListFunction::SetOperation,
                        Into::<&str>::into(set_operation),
                    )
                        .into_py_any(py),
                    #[cfg(feature = "list_sample")]
                    IRListFunction::Sample {
                        is_fraction,
                        with_replacement,
                        shuffle,
                        seed,
                    } => (
                        PyListFunction::Sample,
                        is_fraction,
                        with_replacement,
                        shuffle,
                        seed,
                    )
                        .into_py_any(py),
                    IRListFunction::Slice => (PyListFunction::Slice,).into_py_any(py),
                    IRListFunction::Shift => (PyListFunction::Shift,).into_py_any(py),
                    #[cfg(feature = "list_gather")]
                    IRListFunction::Gather(null_on_oob) => {
                        (PyListFunction::Gather, null_on_oob).into_py_any(py)
                    },
                    #[cfg(feature = "list_gather")]
                    IRListFunction::GatherEvery => (PyListFunction::GatherEvery,).into_py_any(py),
                    #[cfg(feature = "list_count")]
                    IRListFunction::CountMatches => (PyListFunction::CountMatches,).into_py_any(py),
                    IRListFunction::Sum => (PyListFunction::Sum,).into_py_any(py),
                    IRListFunction::Max => (PyListFunction::Max,).into_py_any(py),
                    IRListFunction::Min => (PyListFunction::Min,).into_py_any(py),
                    IRListFunction::Mean => (PyListFunction::Mean,).into_py_any(py),
                    IRListFunction::Median => (PyListFunction::Median,).into_py_any(py),
                    IRListFunction::Std(ddof) => (PyListFunction::Std, ddof).into_py_any(py),
                    IRListFunction::Var(ddof) => (PyListFunction::Var, ddof).into_py_any(py),
                    IRListFunction::ArgMin => (PyListFunction::ArgMin,).into_py_any(py),
                    IRListFunction::ArgMax => (PyListFunction::ArgMax,).into_py_any(py),
                    IRListFunction::Diff { n, null_behavior } => (
                        PyListFunction::Diff,
                        n,
                        match null_behavior {
                            NullBehavior::Drop => "drop",
                            NullBehavior::Ignore => "ignore",
                        },
                    )
                        .into_py_any(py),
                    IRListFunction::Join(ignore_nulls) => {
                        (PyListFunction::Join, ignore_nulls).into_py_any(py)
                    },
                    #[cfg(feature = "dtype-array")]
                    IRListFunction::ToArray(width) => {
                        (PyListFunction::ToArray, width).into_py_any(py)
                    },
                    IRListFunction::ToStruct(names) => (
                        PyListFunction::ToStruct,
                        names.iter().map(|s| s.as_str()).collect::<Vec<_>>(),
                    )
                        .into_py_any(py),
                },
                IRFunctionExpr::Bitwise(bitwisefun) => {
                    let py_function = match bitwisefun {
                        IRBitwiseFunction::CountOnes => PyBitwiseFunction::CountOnes,
                        IRBitwiseFunction::CountZeros => PyBitwiseFunction::CountZeros,
                        IRBitwiseFunction::LeadingOnes => PyBitwiseFunction::LeadingOnes,
                        IRBitwiseFunction::LeadingZeros => PyBitwiseFunction::LeadingZeros,
                        IRBitwiseFunction::TrailingOnes => PyBitwiseFunction::TrailingOnes,
                        IRBitwiseFunction::TrailingZeros => PyBitwiseFunction::TrailingZeros,
                        IRBitwiseFunction::And => PyBitwiseFunction::And,
                        IRBitwiseFunction::Or => PyBitwiseFunction::Or,
                        IRBitwiseFunction::Xor => PyBitwiseFunction::Xor,
                    };
                    (py_function,).into_py_any(py)
                },
                IRFunctionExpr::StringExpr(strfun) => match strfun {
                    IRStringFunction::Format { format, insertions } => (
                        PyStringFunction::Format,
                        format.as_str(),
                        insertions.to_vec(),
                    )
                        .into_py_any(py),
                    IRStringFunction::ConcatHorizontal {
                        delimiter,
                        ignore_nulls,
                    } => (
                        PyStringFunction::ConcatHorizontal,
                        delimiter.as_str(),
                        ignore_nulls,
                    )
                        .into_py_any(py),
                    IRStringFunction::ConcatVertical {
                        delimiter,
                        ignore_nulls,
                    } => (
                        PyStringFunction::ConcatVertical,
                        delimiter.as_str(),
                        ignore_nulls,
                    )
                        .into_py_any(py),
                    #[cfg(feature = "regex")]
                    IRStringFunction::Contains { literal, strict } => {
                        (PyStringFunction::Contains, literal, strict).into_py_any(py)
                    },
                    IRStringFunction::CountMatches(literal) => {
                        (PyStringFunction::CountMatches, literal).into_py_any(py)
                    },
                    IRStringFunction::EndsWith => (PyStringFunction::EndsWith,).into_py_any(py),
                    IRStringFunction::Extract(group_index) => {
                        (PyStringFunction::Extract, group_index).into_py_any(py)
                    },
                    IRStringFunction::ExtractAll => (PyStringFunction::ExtractAll,).into_py_any(py),
                    #[cfg(feature = "extract_groups")]
                    IRStringFunction::ExtractGroups { dtype, pat } => (
                        PyStringFunction::ExtractGroups,
                        &Wrap(dtype.clone()),
                        pat.as_str(),
                    )
                        .into_py_any(py),
                    #[cfg(feature = "regex")]
                    IRStringFunction::Find { literal, strict } => {
                        (PyStringFunction::Find, literal, strict).into_py_any(py)
                    },
                    IRStringFunction::ToInteger { dtype: _, strict } => {
                        (PyStringFunction::ToInteger, strict).into_py_any(py)
                    },
                    IRStringFunction::LenBytes => (PyStringFunction::LenBytes,).into_py_any(py),
                    IRStringFunction::LenChars => (PyStringFunction::LenChars,).into_py_any(py),
                    IRStringFunction::Lowercase => (PyStringFunction::Lowercase,).into_py_any(py),
                    #[cfg(feature = "extract_jsonpath")]
                    IRStringFunction::JsonDecode(_) => {
                        (PyStringFunction::JsonDecode, <Option<usize>>::None).into_py_any(py)
                    },
                    #[cfg(feature = "extract_jsonpath")]
                    IRStringFunction::JsonPathMatch => {
                        (PyStringFunction::JsonPathMatch,).into_py_any(py)
                    },
                    #[cfg(feature = "regex")]
                    IRStringFunction::Replace { n, literal } => {
                        (PyStringFunction::Replace, n, literal).into_py_any(py)
                    },
                    #[cfg(feature = "string_normalize")]
                    IRStringFunction::Normalize { form } => (
                        PyStringFunction::Normalize,
                        match form {
                            UnicodeForm::NFC => "nfc",
                            UnicodeForm::NFKC => "nfkc",
                            UnicodeForm::NFD => "nfd",
                            UnicodeForm::NFKD => "nfkd",
                        },
                    )
                        .into_py_any(py),
                    IRStringFunction::Reverse => (PyStringFunction::Reverse,).into_py_any(py),
                    IRStringFunction::PadStart { fill_char } => {
                        (PyStringFunction::PadStart, fill_char).into_py_any(py)
                    },
                    IRStringFunction::PadEnd { fill_char } => {
                        (PyStringFunction::PadEnd, fill_char).into_py_any(py)
                    },
                    IRStringFunction::Slice => (PyStringFunction::Slice,).into_py_any(py),
                    IRStringFunction::Head => (PyStringFunction::Head,).into_py_any(py),
                    IRStringFunction::Tail => (PyStringFunction::Tail,).into_py_any(py),
                    IRStringFunction::HexEncode => (PyStringFunction::HexEncode,).into_py_any(py),
                    #[cfg(feature = "binary_encoding")]
                    IRStringFunction::HexDecode(strict) => {
                        (PyStringFunction::HexDecode, strict).into_py_any(py)
                    },
                    IRStringFunction::Base64Encode => {
                        (PyStringFunction::Base64Encode,).into_py_any(py)
                    },
                    #[cfg(feature = "binary_encoding")]
                    IRStringFunction::Base64Decode(strict) => {
                        (PyStringFunction::Base64Decode, strict).into_py_any(py)
                    },
                    IRStringFunction::StartsWith => (PyStringFunction::StartsWith,).into_py_any(py),
                    IRStringFunction::StripChars => (PyStringFunction::StripChars,).into_py_any(py),
                    IRStringFunction::StripCharsStart => {
                        (PyStringFunction::StripCharsStart,).into_py_any(py)
                    },
                    IRStringFunction::StripCharsEnd => {
                        (PyStringFunction::StripCharsEnd,).into_py_any(py)
                    },
                    IRStringFunction::StripPrefix => {
                        (PyStringFunction::StripPrefix,).into_py_any(py)
                    },
                    IRStringFunction::StripSuffix => {
                        (PyStringFunction::StripSuffix,).into_py_any(py)
                    },
                    IRStringFunction::SplitExact { n, inclusive } => {
                        (PyStringFunction::SplitExact, n, inclusive).into_py_any(py)
                    },
                    IRStringFunction::SplitN(n) => (PyStringFunction::SplitN, n).into_py_any(py),
                    IRStringFunction::Strptime(_, options) => (
                        PyStringFunction::Strptime,
                        options.format.as_ref().map(|s| s.as_str()),
                        options.strict,
                        options.exact,
                        options.cache,
                    )
                        .into_py_any(py),
                    IRStringFunction::Split(inclusive) => {
                        (PyStringFunction::Split, inclusive).into_py_any(py)
                    },
                    IRStringFunction::SplitRegex { inclusive, strict } => {
                        (PyStringFunction::SplitRegex, inclusive, strict).into_py_any(py)
                    },
                    IRStringFunction::ToDecimal { scale } => {
                        (PyStringFunction::ToDecimal, scale).into_py_any(py)
                    },
                    #[cfg(feature = "nightly")]
                    IRStringFunction::Titlecase => (PyStringFunction::Titlecase,).into_py_any(py),
                    IRStringFunction::Uppercase => (PyStringFunction::Uppercase,).into_py_any(py),
                    IRStringFunction::ZFill => (PyStringFunction::ZFill,).into_py_any(py),
                    #[cfg(feature = "find_many")]
                    IRStringFunction::ContainsAny {
                        ascii_case_insensitive,
                    } => (PyStringFunction::ContainsAny, ascii_case_insensitive).into_py_any(py),
                    #[cfg(feature = "find_many")]
                    IRStringFunction::ReplaceMany {
                        ascii_case_insensitive,
                        leftmost,
                    } => (
                        PyStringFunction::ReplaceMany,
                        ascii_case_insensitive,
                        leftmost,
                    )
                        .into_py_any(py),
                    #[cfg(feature = "find_many")]
                    IRStringFunction::ExtractMany {
                        ascii_case_insensitive,
                        overlapping,
                        leftmost,
                    } => (
                        PyStringFunction::ExtractMany,
                        ascii_case_insensitive,
                        overlapping,
                        leftmost,
                    )
                        .into_py_any(py),
                    #[cfg(feature = "find_many")]
                    IRStringFunction::FindMany {
                        ascii_case_insensitive,
                        overlapping,
                        leftmost,
                    } => (
                        PyStringFunction::FindMany,
                        ascii_case_insensitive,
                        overlapping,
                        leftmost,
                    )
                        .into_py_any(py),
                    #[cfg(feature = "regex")]
                    IRStringFunction::EscapeRegex => {
                        (PyStringFunction::EscapeRegex,).into_py_any(py)
                    },
                },
                IRFunctionExpr::StructExpr(fun) => match fun {
                    IRStructFunction::FieldByName(name) => {
                        (PyStructFunction::FieldByName, name.as_str()).into_py_any(py)
                    },
                    IRStructFunction::RenameFields(names) => (
                        PyStructFunction::RenameFields,
                        names.iter().map(|s| s.as_str()).collect_vec(),
                    )
                        .into_py_any(py),
                    IRStructFunction::DropFields(names, strict) => (
                        PyStructFunction::DropFields,
                        names.iter().map(|s| s.as_str()).collect_vec(),
                        strict,
                    )
                        .into_py_any(py),
                    IRStructFunction::PrefixFields(prefix) => {
                        (PyStructFunction::PrefixFields, prefix.as_str()).into_py_any(py)
                    },
                    IRStructFunction::SuffixFields(prefix) => {
                        (PyStructFunction::SuffixFields, prefix.as_str()).into_py_any(py)
                    },
                    #[cfg(feature = "json")]
                    IRStructFunction::JsonEncode => (PyStructFunction::JsonEncode,).into_py_any(py),
                    IRStructFunction::MapFieldNames(function) => match function {
                        PlanCallback::Python(lambda) => {
                            (PyStructFunction::MapFieldNames, lambda.0.clone_ref(py))
                                .into_py_any(py)
                        },
                        PlanCallback::Rust(_) => {
                            return Err(PyNotImplementedError::new_err(
                                "map_field_names with rust callback",
                            ));
                        },
                    },
                },
                IRFunctionExpr::TemporalExpr(fun) => match fun {
                    IRTemporalFunction::Millennium => {
                        (PyTemporalFunction::Millennium,).into_py_any(py)
                    },
                    IRTemporalFunction::Century => (PyTemporalFunction::Century,).into_py_any(py),
                    IRTemporalFunction::Year => (PyTemporalFunction::Year,).into_py_any(py),
                    IRTemporalFunction::IsLeapYear => {
                        (PyTemporalFunction::IsLeapYear,).into_py_any(py)
                    },
                    IRTemporalFunction::IsoYear => (PyTemporalFunction::IsoYear,).into_py_any(py),
                    IRTemporalFunction::Quarter => (PyTemporalFunction::Quarter,).into_py_any(py),
                    IRTemporalFunction::Month => (PyTemporalFunction::Month,).into_py_any(py),
                    IRTemporalFunction::Week => (PyTemporalFunction::Week,).into_py_any(py),
                    IRTemporalFunction::WeekDay => (PyTemporalFunction::WeekDay,).into_py_any(py),
                    IRTemporalFunction::Day => (PyTemporalFunction::Day,).into_py_any(py),
                    IRTemporalFunction::OrdinalDay => {
                        (PyTemporalFunction::OrdinalDay,).into_py_any(py)
                    },
                    IRTemporalFunction::Time => (PyTemporalFunction::Time,).into_py_any(py),
                    IRTemporalFunction::Date => (PyTemporalFunction::Date,).into_py_any(py),
                    IRTemporalFunction::Datetime => (PyTemporalFunction::Datetime,).into_py_any(py),
                    IRTemporalFunction::Duration(time_unit) => {
                        (PyTemporalFunction::Duration, Wrap(*time_unit)).into_py_any(py)
                    },
                    IRTemporalFunction::Hour => (PyTemporalFunction::Hour,).into_py_any(py),
                    IRTemporalFunction::Minute => (PyTemporalFunction::Minute,).into_py_any(py),
                    IRTemporalFunction::Second => (PyTemporalFunction::Second,).into_py_any(py),
                    IRTemporalFunction::Millisecond => {
                        (PyTemporalFunction::Millisecond,).into_py_any(py)
                    },
                    IRTemporalFunction::Microsecond => {
                        (PyTemporalFunction::Microsecond,).into_py_any(py)
                    },
                    IRTemporalFunction::Nanosecond => {
                        (PyTemporalFunction::Nanosecond,).into_py_any(py)
                    },
                    IRTemporalFunction::DaysInMonth => {
                        (PyTemporalFunction::DaysInMonth,).into_py_any(py)
                    },
                    IRTemporalFunction::TotalDays { fractional } => {
                        (PyTemporalFunction::TotalDays, fractional).into_py_any(py)
                    },
                    IRTemporalFunction::TotalHours { fractional } => {
                        (PyTemporalFunction::TotalHours, fractional).into_py_any(py)
                    },
                    IRTemporalFunction::TotalMinutes { fractional } => {
                        (PyTemporalFunction::TotalMinutes, fractional).into_py_any(py)
                    },
                    IRTemporalFunction::TotalSeconds { fractional } => {
                        (PyTemporalFunction::TotalSeconds, fractional).into_py_any(py)
                    },
                    IRTemporalFunction::TotalMilliseconds { fractional } => {
                        (PyTemporalFunction::TotalMilliseconds, fractional).into_py_any(py)
                    },
                    IRTemporalFunction::TotalMicroseconds { fractional } => {
                        (PyTemporalFunction::TotalMicroseconds, fractional).into_py_any(py)
                    },
                    IRTemporalFunction::TotalNanoseconds { fractional } => {
                        (PyTemporalFunction::TotalNanoseconds, fractional).into_py_any(py)
                    },
                    IRTemporalFunction::ToString(format) => {
                        (PyTemporalFunction::ToString, format).into_py_any(py)
                    },
                    IRTemporalFunction::CastTimeUnit(time_unit) => {
                        (PyTemporalFunction::CastTimeUnit, Wrap(*time_unit)).into_py_any(py)
                    },
                    IRTemporalFunction::WithTimeUnit(time_unit) => {
                        (PyTemporalFunction::WithTimeUnit, Wrap(*time_unit)).into_py_any(py)
                    },
                    #[cfg(feature = "timezones")]
                    IRTemporalFunction::ConvertTimeZone(time_zone) => {
                        (PyTemporalFunction::ConvertTimeZone, time_zone.as_str()).into_py_any(py)
                    },
                    IRTemporalFunction::TimeStamp(time_unit) => {
                        (PyTemporalFunction::TimeStamp, Wrap(*time_unit)).into_py_any(py)
                    },
                    IRTemporalFunction::Truncate => (PyTemporalFunction::Truncate,).into_py_any(py),
                    IRTemporalFunction::OffsetBy => (PyTemporalFunction::OffsetBy,).into_py_any(py),
                    IRTemporalFunction::MonthStart => {
                        (PyTemporalFunction::MonthStart,).into_py_any(py)
                    },
                    IRTemporalFunction::MonthEnd => (PyTemporalFunction::MonthEnd,).into_py_any(py),
                    #[cfg(feature = "timezones")]
                    IRTemporalFunction::BaseUtcOffset => {
                        (PyTemporalFunction::BaseUtcOffset,).into_py_any(py)
                    },
                    #[cfg(feature = "timezones")]
                    IRTemporalFunction::DSTOffset => {
                        (PyTemporalFunction::DSTOffset,).into_py_any(py)
                    },
                    IRTemporalFunction::Round => (PyTemporalFunction::Round,).into_py_any(py),
                    IRTemporalFunction::Replace => (PyTemporalFunction::Replace).into_py_any(py),
                    #[cfg(feature = "timezones")]
                    IRTemporalFunction::ReplaceTimeZone(time_zone, non_existent) => (
                        PyTemporalFunction::ReplaceTimeZone,
                        time_zone.as_ref().map(|s| s.as_str()),
                        Into::<&str>::into(non_existent),
                    )
                        .into_py_any(py),
                    IRTemporalFunction::Combine(time_unit) => {
                        (PyTemporalFunction::Combine, Wrap(*time_unit)).into_py_any(py)
                    },
                    IRTemporalFunction::DatetimeFunction {
                        time_unit,
                        time_zone,
                    } => (
                        PyTemporalFunction::DatetimeFunction,
                        Wrap(*time_unit),
                        time_zone.as_ref().map(|s| s.as_str()),
                    )
                        .into_py_any(py),
                },
                IRFunctionExpr::Boolean(boolfun) => match boolfun {
                    IRBooleanFunction::Any { ignore_nulls } => {
                        (PyBooleanFunction::Any, *ignore_nulls).into_py_any(py)
                    },
                    IRBooleanFunction::All { ignore_nulls } => {
                        (PyBooleanFunction::All, *ignore_nulls).into_py_any(py)
                    },
                    IRBooleanFunction::IsEmpty { ignore_nulls } => {
                        (PyBooleanFunction::IsEmpty, *ignore_nulls).into_py_any(py)
                    },
                    IRBooleanFunction::HasNulls => (PyBooleanFunction::HasNulls,).into_py_any(py),
                    IRBooleanFunction::IsNull => (PyBooleanFunction::IsNull,).into_py_any(py),
                    IRBooleanFunction::IsNotNull => (PyBooleanFunction::IsNotNull,).into_py_any(py),
                    IRBooleanFunction::IsFinite => (PyBooleanFunction::IsFinite,).into_py_any(py),
                    IRBooleanFunction::IsInfinite => {
                        (PyBooleanFunction::IsInfinite,).into_py_any(py)
                    },
                    IRBooleanFunction::IsNan => (PyBooleanFunction::IsNan,).into_py_any(py),
                    IRBooleanFunction::IsNotNan => (PyBooleanFunction::IsNotNan,).into_py_any(py),
                    IRBooleanFunction::IsFirstDistinct => {
                        (PyBooleanFunction::IsFirstDistinct,).into_py_any(py)
                    },
                    IRBooleanFunction::IsLastDistinct => {
                        (PyBooleanFunction::IsLastDistinct,).into_py_any(py)
                    },
                    IRBooleanFunction::IsUnique => (PyBooleanFunction::IsUnique,).into_py_any(py),
                    IRBooleanFunction::IsDuplicated => {
                        (PyBooleanFunction::IsDuplicated,).into_py_any(py)
                    },
                    IRBooleanFunction::IsBetween { closed } => {
                        (PyBooleanFunction::IsBetween, Into::<&str>::into(closed)).into_py_any(py)
                    },
                    #[cfg(feature = "is_in")]
                    IRBooleanFunction::IsIn { nulls_equal } => {
                        (PyBooleanFunction::IsIn, nulls_equal).into_py_any(py)
                    },
                    IRBooleanFunction::IsClose {
                        abs_tol,
                        rel_tol,
                        nans_equal,
                    } => (PyBooleanFunction::IsClose, abs_tol.0, rel_tol.0, nans_equal)
                        .into_py_any(py),
                    IRBooleanFunction::IsSorted {
                        descending,
                        nulls_last,
                    } => (PyBooleanFunction::IsSorted, *descending, *nulls_last).into_py_any(py),
                    IRBooleanFunction::AllHorizontal => {
                        (PyBooleanFunction::AllHorizontal,).into_py_any(py)
                    },
                    IRBooleanFunction::AnyHorizontal => {
                        (PyBooleanFunction::AnyHorizontal,).into_py_any(py)
                    },
                    IRBooleanFunction::Not => (PyBooleanFunction::Not,).into_py_any(py),
                },
                IRFunctionExpr::Abs => ("abs",).into_py_any(py),
                #[cfg(feature = "hist")]
                IRFunctionExpr::Hist {
                    bin_count,
                    include_category,
                    include_breakpoint,
                } => ("hist", bin_count, include_category, include_breakpoint).into_py_any(py),
                IRFunctionExpr::NullCount => ("null_count",).into_py_any(py),
                IRFunctionExpr::Pow(f) => match f {
                    IRPowFunction::Generic => ("pow",).into_py_any(py),
                    IRPowFunction::Sqrt => ("sqrt",).into_py_any(py),
                    IRPowFunction::Cbrt => ("cbrt",).into_py_any(py),
                },
                IRFunctionExpr::Hash(seed, seed_1, seed_2, seed_3) => {
                    ("hash", seed, seed_1, seed_2, seed_3).into_py_any(py)
                },
                IRFunctionExpr::ArgWhere => ("argwhere",).into_py_any(py),
                #[cfg(feature = "index_of")]
                IRFunctionExpr::IndexOf => ("index_of",).into_py_any(py),
                #[cfg(feature = "search_sorted")]
                IRFunctionExpr::SearchSorted { side, descending } => (
                    "search_sorted",
                    match side {
                        SearchSortedSide::Any => "any",
                        SearchSortedSide::Left => "left",
                        SearchSortedSide::Right => "right",
                    },
                    descending,
                )
                    .into_py_any(py),
                IRFunctionExpr::Range(rangefun) => match rangefun {
                    IRRangeFunction::IntRange { step, dtype } => {
                        (PyRangeFunction::IntRange, step, &Wrap(dtype.clone())).into_py_any(py)
                    },
                    IRRangeFunction::IntRanges { dtype } => {
                        (PyRangeFunction::IntRanges, &Wrap(dtype.clone())).into_py_any(py)
                    },
                    IRRangeFunction::LinearSpace { closed } => (
                        PyRangeFunction::LinearSpace,
                        closed_interval_into_py(closed),
                    )
                        .into_py_any(py),
                    IRRangeFunction::LinearSpaces {
                        closed,
                        array_width,
                    } => (
                        PyRangeFunction::LinearSpaces,
                        closed_interval_into_py(closed),
                        array_width,
                    )
                        .into_py_any(py),
                    IRRangeFunction::DateRange {
                        interval,
                        closed,
                        arg_type,
                    } => (
                        PyRangeFunction::DateRange,
                        interval
                            .as_ref()
                            .map_or_else(|| Ok(py.None()), |d| Wrap(*d).into_py_any(py))?,
                        Wrap(*closed).into_py_any(py)?,
                        date_range_args_into_py(arg_type),
                    )
                        .into_py_any(py),
                    IRRangeFunction::DateRanges {
                        interval,
                        closed,
                        arg_type,
                    } => (
                        PyRangeFunction::DateRanges,
                        interval
                            .as_ref()
                            .map_or_else(|| Ok(py.None()), |d| Wrap(*d).into_py_any(py))?,
                        Wrap(*closed).into_py_any(py)?,
                        date_range_args_into_py(arg_type),
                    )
                        .into_py_any(py),
                    IRRangeFunction::DatetimeRange {
                        interval,
                        closed,
                        time_unit,
                        time_zone,
                        arg_type,
                    } => (
                        PyRangeFunction::DatetimeRange,
                        interval
                            .as_ref()
                            .map_or_else(|| Ok(py.None()), |d| Wrap(*d).into_py_any(py))?,
                        Wrap(*closed).into_py_any(py)?,
                        time_unit.map_or_else(|| Ok(py.None()), |tu| Wrap(tu).into_py_any(py))?,
                        time_zone.as_ref().map(|s| s.as_str()),
                        date_range_args_into_py(arg_type),
                    )
                        .into_py_any(py),
                    IRRangeFunction::DatetimeRanges {
                        interval,
                        closed,
                        time_unit,
                        time_zone,
                        arg_type,
                    } => (
                        PyRangeFunction::DatetimeRanges,
                        interval
                            .as_ref()
                            .map_or_else(|| Ok(py.None()), |d| Wrap(*d).into_py_any(py))?,
                        Wrap(*closed).into_py_any(py)?,
                        time_unit.map_or_else(|| Ok(py.None()), |tu| Wrap(tu).into_py_any(py))?,
                        time_zone.as_ref().map(|s| s.as_str()),
                        date_range_args_into_py(arg_type),
                    )
                        .into_py_any(py),
                    IRRangeFunction::TimeRange { interval, closed } => (
                        PyRangeFunction::TimeRange,
                        Wrap(*interval).into_py_any(py)?,
                        Wrap(*closed).into_py_any(py)?,
                    )
                        .into_py_any(py),
                    IRRangeFunction::TimeRanges { interval, closed } => (
                        PyRangeFunction::TimeRanges,
                        Wrap(*interval).into_py_any(py)?,
                        Wrap(*closed).into_py_any(py)?,
                    )
                        .into_py_any(py),
                },
                #[cfg(feature = "trigonometry")]
                IRFunctionExpr::Trigonometry(trigfun) => {
                    use polars_plan::plans::IRTrigonometricFunction;

                    match trigfun {
                        IRTrigonometricFunction::Cos => ("cos",),
                        IRTrigonometricFunction::Cot => ("cot",),
                        IRTrigonometricFunction::Sin => ("sin",),
                        IRTrigonometricFunction::Tan => ("tan",),
                        IRTrigonometricFunction::ArcCos => ("arccos",),
                        IRTrigonometricFunction::ArcSin => ("arcsin",),
                        IRTrigonometricFunction::ArcTan => ("arctan",),
                        IRTrigonometricFunction::Cosh => ("cosh",),
                        IRTrigonometricFunction::Sinh => ("sinh",),
                        IRTrigonometricFunction::Tanh => ("tanh",),
                        IRTrigonometricFunction::ArcCosh => ("arccosh",),
                        IRTrigonometricFunction::ArcSinh => ("arcsinh",),
                        IRTrigonometricFunction::ArcTanh => ("arctanh",),
                        IRTrigonometricFunction::Degrees => ("degrees",),
                        IRTrigonometricFunction::Radians => ("radians",),
                    }
                    .into_py_any(py)
                },
                #[cfg(feature = "trigonometry")]
                IRFunctionExpr::Atan2 => ("atan2",).into_py_any(py),
                #[cfg(feature = "sign")]
                IRFunctionExpr::Sign => ("sign",).into_py_any(py),
                IRFunctionExpr::FillNull => ("fill_null",).into_py_any(py),
                IRFunctionExpr::RollingExpr { function, options } => match function {
                    IRRollingFunction::CorrCov {
                        corr_cov_options,
                        is_corr,
                    } => {
                        // Tuple consumed by external engines (e.g., cudf-polars):
                        // (RollingFunction, window_size, min_periods, ddof, is_corr)
                        (
                            PyRollingFunction::CorrCov,
                            corr_cov_options.window_size,
                            corr_cov_options.min_periods,
                            corr_cov_options.ddof,
                            is_corr,
                        )
                            .into_py_any(py)
                    },
                    IRRollingFunction::Map(_) => {
                        return Err(PyNotImplementedError::new_err("rolling map"));
                    },
                    _ => {
                        let py_function = match function {
                            IRRollingFunction::Min => PyRollingFunction::Min,
                            IRRollingFunction::Max => PyRollingFunction::Max,
                            IRRollingFunction::Mean => PyRollingFunction::Mean,
                            IRRollingFunction::Sum => PyRollingFunction::Sum,
                            IRRollingFunction::Quantile => PyRollingFunction::Quantile,
                            IRRollingFunction::Var => PyRollingFunction::Var,
                            IRRollingFunction::Std => PyRollingFunction::Std,
                            IRRollingFunction::Rank => PyRollingFunction::Rank,
                            IRRollingFunction::Skew => PyRollingFunction::Skew,
                            IRRollingFunction::Kurtosis => PyRollingFunction::Kurtosis,
                            IRRollingFunction::CorrCov { .. } | IRRollingFunction::Map(_) => {
                                unreachable!()
                            },
                        };
                        let fn_params = rolling_fn_params_into_py(py, &options.fn_params)?;
                        // Tuple consumed by external engines (e.g., cudf-polars):
                        // (RollingFunction, window_size, min_periods, weights, center, fn_params)
                        (
                            py_function,
                            options.window_size,
                            options.min_periods,
                            &options.weights,
                            options.center,
                            fn_params,
                        )
                            .into_py_any(py)
                    },
                },
                IRFunctionExpr::RollingExprBy {
                    function_by,
                    options,
                } => {
                    let py_function = match function_by {
                        IRRollingFunctionBy::MinBy => PyRollingFunctionBy::MinBy,
                        IRRollingFunctionBy::MaxBy => PyRollingFunctionBy::MaxBy,
                        IRRollingFunctionBy::MeanBy => PyRollingFunctionBy::MeanBy,
                        IRRollingFunctionBy::SumBy => PyRollingFunctionBy::SumBy,
                        IRRollingFunctionBy::QuantileBy => PyRollingFunctionBy::QuantileBy,
                        IRRollingFunctionBy::VarBy => PyRollingFunctionBy::VarBy,
                        IRRollingFunctionBy::StdBy => PyRollingFunctionBy::StdBy,
                        IRRollingFunctionBy::RankBy => PyRollingFunctionBy::RankBy,
                    };
                    let fn_params = rolling_fn_params_into_py(py, &options.fn_params)?;
                    // Tuple consumed by external engines (e.g., cudf-polars):
                    // (RollingFunctionBy, window_size, min_periods, closed_window, fn_params)
                    (
                        py_function,
                        Wrap(options.window_size),
                        options.min_periods,
                        Wrap(options.closed_window),
                        fn_params,
                    )
                        .into_py_any(py)
                },
                IRFunctionExpr::Rechunk => ("rechunk",).into_py_any(py),
                IRFunctionExpr::ShiftAndFill => ("shift_and_fill",).into_py_any(py),
                IRFunctionExpr::Shift => ("shift",).into_py_any(py),
                IRFunctionExpr::DropNans => ("drop_nans",).into_py_any(py),
                IRFunctionExpr::DropNulls => ("drop_nulls",).into_py_any(py),
                IRFunctionExpr::Quantile { method } => {
                    let method = match method {
                        QuantileMethod::Nearest => "nearest",
                        QuantileMethod::Lower => "lower",
                        QuantileMethod::Higher => "higher",
                        QuantileMethod::Midpoint => "midpoint",
                        QuantileMethod::Linear => "linear",
                        QuantileMethod::Equiprobable => "equiprobable",
                    };
                    ("quantile", method).into_py_any(py)
                },
                IRFunctionExpr::Mode { maintain_order } => {
                    ("mode", *maintain_order).into_py_any(py)
                },
                IRFunctionExpr::Skew(bias) => ("skew", bias).into_py_any(py),
                IRFunctionExpr::Kurtosis(fisher, bias) => {
                    ("kurtosis", fisher, bias).into_py_any(py)
                },
                IRFunctionExpr::Reshape(_) => {
                    return Err(PyNotImplementedError::new_err("reshape"));
                },
                #[cfg(feature = "repeat_by")]
                IRFunctionExpr::RepeatBy => ("repeat_by",).into_py_any(py),
                IRFunctionExpr::ArgUnique => ("arg_unique",).into_py_any(py),
                IRFunctionExpr::ArgMin => ("arg_min",).into_py_any(py),
                IRFunctionExpr::ArgMax => ("arg_max",).into_py_any(py),
                IRFunctionExpr::MinBy => ("min_by",).into_py_any(py),
                IRFunctionExpr::MaxBy => ("max_by",).into_py_any(py),
                IRFunctionExpr::ArgSort {
                    descending,
                    nulls_last,
                } => ("arg_max", descending, nulls_last).into_py_any(py),
                IRFunctionExpr::Product => ("product",).into_py_any(py),
                IRFunctionExpr::Repeat => ("repeat",).into_py_any(py),
                IRFunctionExpr::Rank { options, seed } => {
                    let method = match options.method {
                        RankMethod::Average => "average",
                        RankMethod::Min => "min",
                        RankMethod::Max => "max",
                        RankMethod::Dense => "dense",
                        RankMethod::Ordinal => "ordinal",
                        RankMethod::Random => "random",
                    };
                    ("rank", method, options.descending, seed.map(|s| s as i64)).into_py_any(py)
                },
                IRFunctionExpr::Clip { has_min, has_max } => {
                    ("clip", has_min, has_max).into_py_any(py)
                },
                IRFunctionExpr::AsList => ("as_list",).into_py_any(py),
                IRFunctionExpr::AsStruct => ("as_struct",).into_py_any(py),
                #[cfg(feature = "top_k")]
                IRFunctionExpr::TopK { descending } => ("top_k", descending).into_py_any(py),
                IRFunctionExpr::CumCount { reverse } => ("cum_count", reverse).into_py_any(py),
                IRFunctionExpr::CumSum { reverse } => ("cum_sum", reverse).into_py_any(py),
                IRFunctionExpr::CumProd { reverse } => ("cum_prod", reverse).into_py_any(py),
                IRFunctionExpr::CumMin { reverse } => ("cum_min", reverse).into_py_any(py),
                IRFunctionExpr::CumMax { reverse } => ("cum_max", reverse).into_py_any(py),
                IRFunctionExpr::Reverse => ("reverse",).into_py_any(py),
                IRFunctionExpr::ValueCounts {
                    sort,
                    parallel,
                    name,
                    normalize,
                } => ("value_counts", sort, parallel, name.as_str(), normalize).into_py_any(py),
                IRFunctionExpr::UniqueCounts => ("unique_counts",).into_py_any(py),
                IRFunctionExpr::ApproxNUnique => ("approx_n_unique",).into_py_any(py),
                IRFunctionExpr::Coalesce => ("coalesce",).into_py_any(py),
                IRFunctionExpr::Diff(null_behaviour) => (
                    "diff",
                    match null_behaviour {
                        NullBehavior::Drop => "drop",
                        NullBehavior::Ignore => "ignore",
                    },
                )
                    .into_py_any(py),
                #[cfg(feature = "pct_change")]
                IRFunctionExpr::PctChange => ("pct_change",).into_py_any(py),
                IRFunctionExpr::Interpolate(method) => (
                    "interpolate",
                    match method {
                        InterpolationMethod::Linear => "linear",
                        InterpolationMethod::Nearest => "nearest",
                    },
                )
                    .into_py_any(py),
                IRFunctionExpr::InterpolateBy => ("interpolate_by",).into_py_any(py),
                IRFunctionExpr::Entropy { base, normalize } => {
                    ("entropy", base, normalize).into_py_any(py)
                },
                IRFunctionExpr::Log => ("log",).into_py_any(py),
                IRFunctionExpr::Log1p => ("log1p",).into_py_any(py),
                IRFunctionExpr::Exp => ("exp",).into_py_any(py),
                IRFunctionExpr::Unique(maintain_order) => {
                    ("unique", maintain_order).into_py_any(py)
                },
                IRFunctionExpr::Round { decimals, mode } => {
                    ("round", decimals, Into::<&str>::into(mode)).into_py_any(py)
                },
                IRFunctionExpr::RoundSF { digits } => ("round_sig_figs", digits).into_py_any(py),
                IRFunctionExpr::Truncate { decimals } => ("truncate", decimals).into_py_any(py),
                IRFunctionExpr::Floor => ("floor",).into_py_any(py),
                IRFunctionExpr::Ceil => ("ceil",).into_py_any(py),
                IRFunctionExpr::Fused(op) => {
                    let op_name = match op {
                        FusedOperator::MultiplyAdd => "fma",
                        FusedOperator::SubMultiply => "fsm",
                        FusedOperator::MultiplySub => "fms",
                    };
                    ("fused", op_name).into_py_any(py)
                },
                IRFunctionExpr::ConcatExpr { rechunk } => ("concat", rechunk).into_py_any(py),
                IRFunctionExpr::Correlation { method } => match method {
                    IRCorrelationMethod::Pearson => ("corr", "pearson").into_py_any(py),
                    IRCorrelationMethod::SpearmanRank(propagate_nans) => {
                        ("corr", "spearman_rank", propagate_nans).into_py_any(py)
                    },
                    IRCorrelationMethod::Covariance(ddof) => {
                        ("corr", "covariance", ddof).into_py_any(py)
                    },
                },
                #[cfg(feature = "peaks")]
                IRFunctionExpr::PeakMin => ("peak_max",).into_py_any(py),
                #[cfg(feature = "peaks")]
                IRFunctionExpr::PeakMax => ("peak_min",).into_py_any(py),
                #[cfg(feature = "cutqcut")]
                IRFunctionExpr::Cut {
                    breaks,
                    labels,
                    left_closed,
                    include_breaks,
                } => (
                    "cut",
                    breaks,
                    labels
                        .as_ref()
                        .map(|l| l.iter().map(|s| s.as_str()).collect::<Vec<_>>()),
                    left_closed,
                    include_breaks,
                )
                    .into_py_any(py),
                #[cfg(feature = "cutqcut")]
                IRFunctionExpr::QCut {
                    probs,
                    labels,
                    left_closed,
                    allow_duplicates,
                    include_breaks,
                } => (
                    "qcut",
                    probs,
                    labels
                        .as_ref()
                        .map(|l| l.iter().map(|s| s.as_str()).collect::<Vec<_>>()),
                    left_closed,
                    allow_duplicates,
                    include_breaks,
                )
                    .into_py_any(py),
                #[cfg(feature = "rle")]
                IRFunctionExpr::RLE => ("rle",).into_py_any(py),
                #[cfg(feature = "rle")]
                IRFunctionExpr::RLEID => ("rle_id",).into_py_any(py),
                IRFunctionExpr::ToPhysical => ("to_physical",).into_py_any(py),
                IRFunctionExpr::Random { method, seed } => match method {
                    IRRandomMethod::Shuffle => ("shuffle", seed).into_py_any(py),
                    IRRandomMethod::Sample {
                        is_fraction,
                        with_replacement,
                        shuffle,
                    } => ("sample", is_fraction, with_replacement, shuffle, seed).into_py_any(py),
                },
                IRFunctionExpr::SetSortedFlag(sorted) => {
                    ("set_sorted", sorted.descending, sorted.nulls_last).into_py_any(py)
                },
                #[cfg(feature = "ffi_plugin")]
                IRFunctionExpr::FfiPlugin {
                    flags,
                    lib,
                    symbol,
                    kwargs,
                } => (
                    "ffi_plugin",
                    lib.as_str(),
                    symbol.as_str(),
                    PyBytes::new(py, kwargs.as_ref()),
                    flags.is_elementwise(),
                )
                    .into_py_any(py),
                IRFunctionExpr::FoldHorizontal { .. } => {
                    Err(PyNotImplementedError::new_err("fold"))
                },
                IRFunctionExpr::ReduceHorizontal { .. } => {
                    Err(PyNotImplementedError::new_err("reduce"))
                },
                IRFunctionExpr::CumReduceHorizontal { .. } => {
                    Err(PyNotImplementedError::new_err("cum_reduce"))
                },
                IRFunctionExpr::CumFoldHorizontal { .. } => {
                    Err(PyNotImplementedError::new_err("cum_fold"))
                },
                IRFunctionExpr::SumHorizontal { ignore_nulls } => {
                    ("sum_horizontal", ignore_nulls).into_py_any(py)
                },
                IRFunctionExpr::MaxHorizontal => ("max_horizontal",).into_py_any(py),
                IRFunctionExpr::MeanHorizontal { ignore_nulls } => {
                    ("mean_horizontal", ignore_nulls).into_py_any(py)
                },
                IRFunctionExpr::MinHorizontal => ("min_horizontal",).into_py_any(py),
                // Tuples consumed by external engines (e.g., cudf-polars):
                // Mean/Std/Var: (EwmFunction, alpha, adjust, bias, min_periods, ignore_nulls)
                // Sum: (EwmFunction, alpha, min_periods, ignore_nulls)
                IRFunctionExpr::EwmMean { options } => (
                    PyEwmFunction::Mean,
                    options.alpha,
                    options.adjust,
                    options.bias,
                    options.min_periods,
                    options.ignore_nulls,
                )
                    .into_py_any(py),
                IRFunctionExpr::EwmSum { options } => (
                    PyEwmFunction::Sum,
                    options.alpha,
                    options.min_periods,
                    options.ignore_nulls,
                )
                    .into_py_any(py),
                IRFunctionExpr::EwmStd { options } => (
                    PyEwmFunction::Std,
                    options.alpha,
                    options.adjust,
                    options.bias,
                    options.min_periods,
                    options.ignore_nulls,
                )
                    .into_py_any(py),
                IRFunctionExpr::EwmVar { options } => (
                    PyEwmFunction::Var,
                    options.alpha,
                    options.adjust,
                    options.bias,
                    options.min_periods,
                    options.ignore_nulls,
                )
                    .into_py_any(py),
                IRFunctionExpr::Replace => ("replace",).into_py_any(py),
                IRFunctionExpr::ReplaceStrict { return_dtype: _ } => {
                    // Can ignore the return dtype because it is encoded in the schema.
                    ("replace_strict",).into_py_any(py)
                },
                IRFunctionExpr::Negate => ("negate",).into_py_any(py),
                IRFunctionExpr::FillNullWithStrategy(strategy) => {
                    let (strategy_str, py_limit): (&str, Py<PyAny>) = match strategy {
                        FillNullStrategy::Forward(limit) => {
                            let py_limit = limit
                                .map(|v| PyInt::new(py, v).into())
                                .unwrap_or_else(|| py.None());
                            ("forward", py_limit)
                        },
                        FillNullStrategy::Backward(limit) => {
                            let py_limit = limit
                                .map(|v| PyInt::new(py, v).into())
                                .unwrap_or_else(|| py.None());
                            ("backward", py_limit)
                        },
                        FillNullStrategy::Min => ("min", py.None()),
                        FillNullStrategy::Max => ("max", py.None()),
                        FillNullStrategy::Mean => ("mean", py.None()),
                        FillNullStrategy::Zero => ("zero", py.None()),
                        FillNullStrategy::One => ("one", py.None()),
                    };

                    ("fill_null_with_strategy", strategy_str, py_limit).into_py_any(py)
                },
                IRFunctionExpr::GatherEvery { n, offset } => {
                    ("gather_every", offset, n).into_py_any(py)
                },
                IRFunctionExpr::Reinterpret(dtype) => {
                    ("reinterpret", &Wrap(dtype.clone())).into_py_any(py)
                },
                IRFunctionExpr::ExtendConstant => ("extend_constant",).into_py_any(py),
                IRFunctionExpr::Business(_) => {
                    return Err(PyNotImplementedError::new_err("business"));
                },
                #[cfg(feature = "top_k")]
                IRFunctionExpr::TopKBy { descending } => ("top_k_by", descending).into_py_any(py),
                IRFunctionExpr::EwmMeanBy { half_life } => {
                    (PyEwmFunction::MeanBy, Wrap(*half_life)).into_py_any(py)
                },
                IRFunctionExpr::EwmSumBy { half_life } => {
                    (PyEwmFunction::SumBy, Wrap(*half_life)).into_py_any(py)
                },
                IRFunctionExpr::RowEncode(..) => {
                    return Err(PyNotImplementedError::new_err("row_encode"));
                },
                IRFunctionExpr::RowDecode(..) => {
                    return Err(PyNotImplementedError::new_err("row_decode"));
                },
                IRFunctionExpr::DynamicPred { pred } => {
                    ("dynamic_pred", pred.id().map(|u| u.as_u128())).into_py_any(py)
                },
            }?,
            options: py.None(),
        }
        .into_py_any(py),
        AExpr::Rolling {
            function,
            index_column,
            period,
            offset,
            closed_window,
        } => Rolling {
            function: function.0,
            index_column: index_column.0,
            period: Wrap(*period).into_py_any(py)?,
            offset: Wrap(*offset).into_py_any(py)?,
            closed_window: Wrap(*closed_window).into_py_any(py)?,
        }
        .into_py_any(py),
        AExpr::Over {
            function,
            partition_by,
            order_by,
            mapping,
        } => {
            let function = function.0;
            let partition_by = partition_by.iter().map(|n| n.0).collect();
            let order_by_descending = order_by
                .map(|(_, options)| options.descending)
                .unwrap_or(false);
            let order_by_nulls_last = order_by
                .map(|(_, options)| options.nulls_last)
                .unwrap_or(false);
            let order_by = order_by.map(|(n, _)| n.0);

            let options = PyWindowMapping { inner: *mapping }.into_py_any(py)?;
            Window {
                function,
                partition_by,
                order_by,
                order_by_descending,
                order_by_nulls_last,
                options,
            }
            .into_py_any(py)
        },
        AExpr::Slice {
            input,
            offset,
            length,
        } => Slice {
            input: input.0,
            offset: offset.0,
            length: length.0,
        }
        .into_py_any(py),
        AExpr::Len => Len {}.into_py_any(py),
        AExpr::Eval { .. } => Err(PyNotImplementedError::new_err("list.eval")),
        AExpr::StructEval { expr, evaluation } => StructEval {
            expr: expr.0,
            evaluation: evaluation.iter().map(|e| e.into()).collect(),
        }
        .into_py_any(py),
    }
}