polars-python 0.52.0

Enable running Polars workloads in Python
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

use polars::prelude::*;
use polars_utils::python_function::PythonObject;
use pyo3::prelude::*;
use pyo3::pymethods;

use crate::error::PyPolarsErr;
use crate::expr::PyExpr;

#[pymethods]
impl PyExpr {
    fn arr_len(&self) -> Self {
        self.inner.clone().arr().len().into()
    }

    fn arr_max(&self) -> Self {
        self.inner.clone().arr().max().into()
    }

    fn arr_min(&self) -> Self {
        self.inner.clone().arr().min().into()
    }

    fn arr_sum(&self) -> Self {
        self.inner.clone().arr().sum().into()
    }

    fn arr_std(&self, ddof: u8) -> Self {
        self.inner.clone().arr().std(ddof).into()
    }

    fn arr_var(&self, ddof: u8) -> Self {
        self.inner.clone().arr().var(ddof).into()
    }

    fn arr_mean(&self) -> Self {
        self.inner.clone().arr().mean().into()
    }

    fn arr_median(&self) -> Self {
        self.inner.clone().arr().median().into()
    }

    fn arr_unique(&self, maintain_order: bool) -> Self {
        if maintain_order {
            self.inner.clone().arr().unique_stable().into()
        } else {
            self.inner.clone().arr().unique().into()
        }
    }

    fn arr_n_unique(&self) -> Self {
        self.inner.clone().arr().n_unique().into()
    }

    fn arr_to_list(&self) -> Self {
        self.inner.clone().arr().to_list().into()
    }

    fn arr_all(&self) -> Self {
        self.inner.clone().arr().all().into()
    }

    fn arr_any(&self) -> Self {
        self.inner.clone().arr().any().into()
    }

    fn arr_sort(&self, descending: bool, nulls_last: bool) -> Self {
        self.inner
            .clone()
            .arr()
            .sort(SortOptions {
                descending,
                nulls_last,
                ..Default::default()
            })
            .into()
    }

    fn arr_reverse(&self) -> Self {
        self.inner.clone().arr().reverse().into()
    }

    fn arr_arg_min(&self) -> Self {
        self.inner.clone().arr().arg_min().into()
    }

    fn arr_arg_max(&self) -> Self {
        self.inner.clone().arr().arg_max().into()
    }

    fn arr_get(&self, index: PyExpr, null_on_oob: bool) -> Self {
        self.inner
            .clone()
            .arr()
            .get(index.inner, null_on_oob)
            .into()
    }

    fn arr_join(&self, separator: PyExpr, ignore_nulls: bool) -> Self {
        self.inner
            .clone()
            .arr()
            .join(separator.inner, ignore_nulls)
            .into()
    }

    #[cfg(feature = "is_in")]
    fn arr_contains(&self, other: PyExpr, nulls_equal: bool) -> Self {
        self.inner
            .clone()
            .arr()
            .contains(other.inner, nulls_equal)
            .into()
    }

    #[cfg(feature = "array_count")]
    fn arr_count_matches(&self, expr: PyExpr) -> Self {
        self.inner.clone().arr().count_matches(expr.inner).into()
    }

    #[pyo3(signature = (name_gen))]
    fn arr_to_struct(&self, name_gen: Option<Py<PyAny>>) -> Self {
        let name_gen = name_gen.map(|o| PlanCallback::new_python(PythonObject(o)));
        self.inner.clone().arr().to_struct(name_gen).into()
    }

    fn arr_slice(&self, offset: PyExpr, length: Option<PyExpr>, as_array: bool) -> PyResult<Self> {
        let length = match length {
            Some(i) => i.inner,
            None => lit(i64::MAX),
        };
        Ok(self
            .inner
            .clone()
            .arr()
            .slice(offset.inner, length, as_array)
            .map_err(PyPolarsErr::from)?
            .into())
    }

    fn arr_tail(&self, n: PyExpr, as_array: bool) -> PyResult<Self> {
        Ok(self
            .inner
            .clone()
            .arr()
            .tail(n.inner, as_array)
            .map_err(PyPolarsErr::from)?
            .into())
    }

    fn arr_shift(&self, n: PyExpr) -> Self {
        self.inner.clone().arr().shift(n.inner).into()
    }

    fn arr_explode(&self) -> Self {
        self.inner.clone().arr().explode().into()
    }

    fn arr_eval(&self, expr: PyExpr, as_list: bool) -> Self {
        self.inner.clone().arr().eval(expr.inner, as_list).into()
    }

    fn arr_agg(&self, expr: PyExpr) -> Self {
        self.inner.clone().arr().agg(expr.inner).into()
    }
}