polars-df 0.18.0 → 0.20.0

data/ext/polars/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "polars"
-version = "0.18.0"
+version = "0.20.0"
 license = "MIT"
 authors = ["Andrew Kane <andrew@ankane.org>"]
 edition = "2021"
@@ -12,22 +12,22 @@ crate-type = ["cdylib"]
 
 [dependencies]
 ahash = "0.8"
-arrow = { package = "polars-arrow", version = "=0.47.1" }
+arrow = { package = "polars-arrow", version = "=0.49.1" }
 bytes = "1"
 chrono = "0.4"
 either = "1.8"
 magnus = "0.7"
 num-traits = "0.2"
-polars-core = "=0.47.1"
-polars-plan = "=0.47.1"
-polars-parquet = "=0.47.1"
-polars-utils = "=0.47.1"
+polars-core = "=0.49.1"
+polars-plan = "=0.49.1"
+polars-parquet = "=0.49.1"
+polars-utils = "=0.49.1"
 rayon = "1.9"
 regex = "1"
 serde_json = "1"
 
 [dependencies.polars]
-version = "=0.47.1"
+version = "=0.49.1"
 features = [
     "abs",
     "approx_unique",

data/ext/polars/src/conversion/any_value.rs

@@ -173,7 +173,7 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
     }
 
     fn get_struct(ob: Value, _strict: bool) -> RbResult<AnyValue<'static>> {
-        let dict = RHash::from_value(ob).unwrap();
+        let dict = RHash::try_convert(ob)?;
         let len = dict.len();
         let mut keys = Vec::with_capacity(len);
         let mut vals = Vec::with_capacity(len);

data/ext/polars/src/conversion/mod.rs

@@ -210,7 +210,10 @@ impl IntoValue for Wrap<DataType> {
             DataType::Datetime(tu, tz) => {
                 let datetime_class = pl.const_get::<_, Value>("Datetime").unwrap();
                 datetime_class
-                    .funcall::<_, _, Value>("new", (tu.to_ascii(), tz.as_deref()))
+                    .funcall::<_, _, Value>(
+                        "new",
+                        (tu.to_ascii(), tz.as_deref().map(|x| x.as_str())),
+                    )
                     .unwrap()
             }
             DataType::Duration(tu) => {
@@ -375,7 +378,10 @@ impl TryConvert for Wrap<DataType> {
                     let time_unit: Value = ob.funcall("time_unit", ()).unwrap();
                     let time_unit = Wrap::<TimeUnit>::try_convert(time_unit)?.0;
                     let time_zone: Option<String> = ob.funcall("time_zone", ())?;
-                    DataType::Datetime(time_unit, time_zone.as_deref().map(|x| x.into()))
+                    DataType::Datetime(
+                        time_unit,
+                        TimeZone::opt_try_new(time_zone.as_deref()).map_err(RbPolarsErr::from)?,
+                    )
                 }
                 "Polars::Duration" => {
                     let time_unit: Value = ob.funcall("time_unit", ()).unwrap();
@@ -1229,3 +1235,13 @@ impl TryConvert for RbCompatLevel {
         }))
     }
 }
+
+impl TryConvert for Wrap<Option<TimeZone>> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let tz = Option::<Wrap<PlSmallStr>>::try_convert(ob)?;
+
+        let tz = tz.map(|x| x.0);
+
+        Ok(Wrap(TimeZone::opt_try_new(tz).map_err(RbPolarsErr::from)?))
+    }
+}

data/ext/polars/src/expr/array.rs

@@ -75,11 +75,11 @@ impl RbExpr {
             .into()
     }
 
-    pub fn arr_contains(&self, other: &RbExpr) -> Self {
+    pub fn arr_contains(&self, other: &RbExpr, nulls_equal: bool) -> Self {
         self.inner
             .clone()
             .arr()
-            .contains(other.inner.clone())
+            .contains(other.inner.clone(), nulls_equal)
             .into()
     }
 

data/ext/polars/src/expr/datetime.rs

@@ -1,7 +1,7 @@
 use polars::prelude::*;
 
 use crate::conversion::Wrap;
-use crate::RbExpr;
+use crate::{RbExpr, RbPolarsErr, RbResult};
 
 impl RbExpr {
     pub fn dt_to_string(&self, format: String) -> Self {
@@ -30,12 +30,17 @@ impl RbExpr {
         self.inner.clone().dt().with_time_unit(tu.0).into()
     }
 
-    pub fn dt_convert_time_zone(&self, time_zone: String) -> Self {
-        self.inner
+    pub fn dt_convert_time_zone(&self, time_zone: String) -> RbResult<Self> {
+        Ok(self
+            .inner
             .clone()
             .dt()
-            .convert_time_zone(time_zone.into())
-            .into()
+            .convert_time_zone(
+                TimeZone::opt_try_new(Some(PlSmallStr::from(time_zone)))
+                    .map_err(RbPolarsErr::from)?
+                    .unwrap_or(TimeZone::UTC),
+            )
+            .into())
     }
 
     pub fn dt_cast_time_unit(&self, tu: Wrap<TimeUnit>) -> Self {
@@ -47,16 +52,18 @@ impl RbExpr {
         time_zone: Option<String>,
         ambiguous: &Self,
         non_existent: Wrap<NonExistent>,
-    ) -> Self {
-        self.inner
+    ) -> RbResult<Self> {
+        Ok(self
+            .inner
             .clone()
             .dt()
             .replace_time_zone(
-                time_zone.map(|x| x.into()),
+                TimeZone::opt_try_new(time_zone.map(PlSmallStr::from_string))
+                    .map_err(RbPolarsErr::from)?,
                 ambiguous.inner.clone(),
                 non_existent.0,
             )
-            .into()
+            .into())
     }
 
     pub fn dt_truncate(&self, every: &Self) -> Self {

data/ext/polars/src/expr/general.rs

@@ -1,6 +1,6 @@
 use std::ops::Neg;
 
-use magnus::{prelude::*, value::Opaque, IntoValue, RArray, Ruby, Value};
+use magnus::{RArray, Value};
 use polars::lazy::dsl;
 use polars::prelude::*;
 use polars::series::ops::NullBehavior;
@@ -331,10 +331,15 @@ impl RbExpr {
         self.inner.clone().arg_min().into()
     }
 
-    pub fn search_sorted(&self, element: &Self, side: Wrap<SearchSortedSide>) -> Self {
+    pub fn search_sorted(
+        &self,
+        element: &Self,
+        side: Wrap<SearchSortedSide>,
+        descending: bool,
+    ) -> Self {
         self.inner
             .clone()
-            .search_sorted(element.inner.clone(), side.0)
+            .search_sorted(element.inner.clone(), side.0, descending)
             .into()
     }
 
@@ -389,16 +394,8 @@ impl RbExpr {
         strategy: String,
         limit: FillNullLimit,
     ) -> RbResult<Self> {
-        let strat = parse_fill_null_strategy(&strategy, limit)?;
-        Ok(self
-            .inner
-            .clone()
-            .apply(
-                move |s| s.fill_null(strat).map(Some),
-                GetOutput::same_type(),
-            )
-            .with_fmt("fill_null_with_strategy")
-            .into())
+        let strategy = parse_fill_null_strategy(&strategy, limit)?;
+        Ok(self.inner.clone().fill_null_with_strategy(strategy).into())
     }
 
     pub fn fill_nan(&self, expr: &Self) -> Self {
@@ -678,10 +675,10 @@ impl RbExpr {
         self.inner.clone().upper_bound().into()
     }
 
-    pub fn cumulative_eval(&self, expr: &Self, min_periods: usize, parallel: bool) -> Self {
+    pub fn cumulative_eval(&self, expr: &Self, min_samples: usize) -> Self {
         self.inner
             .clone()
-            .cumulative_eval(expr.inner.clone(), min_periods, parallel)
+            .cumulative_eval(expr.inner.clone(), min_samples)
             .into()
     }
 
@@ -807,20 +804,10 @@ impl RbExpr {
         self.inner.clone().ewm_var(options).into()
     }
 
-    pub fn extend_constant(&self, value: Wrap<AnyValue>, n: usize) -> Self {
-        let value = value.into_value();
-        let value = Opaque::from(value);
+    pub fn extend_constant(&self, value: &Self, n: &Self) -> Self {
         self.inner
             .clone()
-            .apply(
-                move |s| {
-                    let value = Ruby::get().unwrap().get_inner(value);
-                    let value = Wrap::<AnyValue>::try_convert(value).unwrap().0;
-                    s.extend_constant(value, n).map(Some)
-                },
-                GetOutput::same_type(),
-            )
-            .with_fmt("extend")
+            .extend_constant(value.inner.clone(), n.inner.clone())
             .into()
     }
 

data/ext/polars/src/expr/list.rs

@@ -23,11 +23,11 @@ impl RbExpr {
         self.inner.clone().list().arg_min().into()
     }
 
-    pub fn list_contains(&self, other: &RbExpr) -> Self {
+    pub fn list_contains(&self, other: &RbExpr, nulls_equal: bool) -> Self {
         self.inner
             .clone()
             .list()
-            .contains(other.inner.clone())
+            .contains(other.inner.clone(), nulls_equal)
             .into()
     }
 
@@ -43,12 +43,8 @@ impl RbExpr {
         Ok(self.inner.clone().list().diff(n, null_behavior.0).into())
     }
 
-    pub fn list_eval(&self, expr: &RbExpr, parallel: bool) -> Self {
-        self.inner
-            .clone()
-            .list()
-            .eval(expr.inner.clone(), parallel)
-            .into()
+    pub fn list_eval(&self, expr: &RbExpr) -> Self {
+        self.inner.clone().list().eval(expr.inner.clone()).into()
     }
 
     pub fn list_get(&self, index: &RbExpr, null_on_oob: bool) -> Self {
@@ -76,12 +72,7 @@ impl RbExpr {
     }
 
     pub fn list_mean(&self) -> Self {
-        self.inner
-            .clone()
-            .list()
-            .mean()
-            .with_fmt("list.mean")
-            .into()
+        self.inner.clone().list().mean().into()
     }
 
     pub fn list_min(&self) -> Self {
@@ -116,20 +107,20 @@ impl RbExpr {
         self.inner.clone().list().tail(n.inner.clone()).into()
     }
 
-    pub fn list_sort(&self, reverse: bool) -> Self {
+    pub fn list_sort(&self, descending: bool, nulls_last: bool) -> Self {
         self.inner
             .clone()
             .list()
-            .sort(SortOptions {
-                descending: reverse,
-                ..Default::default()
-            })
-            .with_fmt("list.sort")
+            .sort(
+                SortOptions::default()
+                    .with_order_descending(descending)
+                    .with_nulls_last(nulls_last),
+            )
             .into()
     }
 
     pub fn list_sum(&self) -> Self {
-        self.inner.clone().list().sum().with_fmt("list.sum").into()
+        self.inner.clone().list().sum().into()
     }
 
     pub fn list_drop_nulls(&self) -> Self {
@@ -180,7 +171,7 @@ impl RbExpr {
         &self,
         width_strat: Wrap<ListToStructWidthStrategy>,
         name_gen: Option<Value>,
-        upper_bound: usize,
+        upper_bound: Option<usize>,
     ) -> RbResult<Self> {
         let name_gen = name_gen.map(|lambda| {
             let lambda = Opaque::from(lambda);

data/ext/polars/src/expr/meta.rs

@@ -1,14 +1,21 @@
 use magnus::RArray;
+use polars::prelude::Schema;
 
-use crate::{RbExpr, RbPolarsErr, RbResult};
+use crate::{RbExpr, RbPolarsErr, RbResult, Wrap};
 
 impl RbExpr {
     pub fn meta_eq(&self, other: &RbExpr) -> bool {
         self.inner == other.inner
     }
 
-    pub fn meta_pop(&self) -> RbResult<RArray> {
-        let exprs = self.inner.clone().meta().pop().map_err(RbPolarsErr::from)?;
+    pub fn meta_pop(&self, schema: Option<Wrap<Schema>>) -> RbResult<RArray> {
+        let schema = schema.as_ref().map(|s| &s.0);
+        let exprs = self
+            .inner
+            .clone()
+            .meta()
+            .pop(schema)
+            .map_err(RbPolarsErr::from)?;
         Ok(RArray::from_iter(
             exprs.iter().map(|e| RbExpr::from(e.clone())),
         ))
@@ -84,17 +91,21 @@ impl RbExpr {
         self.inner.clone().meta()._into_selector().into()
     }
 
-    fn compute_tree_format(&self, display_as_dot: bool) -> RbResult<String> {
+    fn compute_tree_format(
+        &self,
+        display_as_dot: bool,
+        schema: Option<Wrap<Schema>>,
+    ) -> RbResult<String> {
         let e = self
             .inner
             .clone()
             .meta()
-            .into_tree_formatter(display_as_dot)
+            .into_tree_formatter(display_as_dot, schema.as_ref().map(|s| &s.0))
             .map_err(RbPolarsErr::from)?;
         Ok(format!("{e}"))
     }
 
-    pub fn meta_tree_format(&self) -> RbResult<String> {
-        self.compute_tree_format(false)
+    pub fn meta_tree_format(&self, schema: Option<Wrap<Schema>>) -> RbResult<String> {
+        self.compute_tree_format(false, schema)
     }
 }

data/ext/polars/src/expr/string.rs

@@ -35,14 +35,14 @@ impl RbExpr {
         &self,
         format: Option<String>,
         time_unit: Option<Wrap<TimeUnit>>,
-        time_zone: Option<Wrap<TimeZone>>,
+        time_zone: Wrap<Option<TimeZone>>,
         strict: bool,
         exact: bool,
         cache: bool,
         ambiguous: &Self,
     ) -> Self {
         let format = format.map(|x| x.into());
-        let time_zone = time_zone.map(|x| x.0);
+        let time_zone = time_zone.0;
 
         let options = StrptimeOptions {
             format,
@@ -225,7 +225,6 @@ impl RbExpr {
             .clone()
             .str()
             .to_integer(base.inner.clone(), strict)
-            .with_fmt("str.to_integer")
             .into()
     }
 

data/ext/polars/src/file.rs

@@ -93,7 +93,7 @@ impl RbFileLikeObject {
 
 /// Extracts a string repr from, and returns an IO error to send back to rust.
 fn rberr_to_io_err(e: Error) -> io::Error {
-    io::Error::new(io::ErrorKind::Other, e.to_string())
+    io::Error::other(e.to_string())
 }
 
 impl Read for RbFileLikeObject {

data/ext/polars/src/functions/lazy.rs

@@ -310,7 +310,7 @@ pub fn last() -> RbExpr {
     dsl::last().into()
 }
 
-pub fn lit(value: Value, allow_object: bool) -> RbResult<RbExpr> {
+pub fn lit(value: Value, allow_object: bool, is_scalar: bool) -> RbResult<RbExpr> {
     if value.is_kind_of(class::true_class()) || value.is_kind_of(class::false_class()) {
         Ok(dsl::lit(bool::try_convert(value)?).into())
     } else if let Some(v) = Integer::from_value(value) {
@@ -336,7 +336,16 @@ pub fn lit(value: Value, allow_object: bool) -> RbResult<RbExpr> {
             Ok(dsl::lit(unsafe { v.as_slice() }).into())
         }
     } else if let Ok(series) = Obj::<RbSeries>::try_convert(value) {
-        Ok(dsl::lit(series.series.borrow().clone()).into())
+        let s = series.series.borrow();
+        if is_scalar {
+            let av = s
+                .get(0)
+                .map_err(|_| RbValueError::new_err("expected at least 1 value"))?;
+            let av = av.into_static();
+            Ok(dsl::lit(Scalar::new(s.dtype().clone(), av)).into())
+        } else {
+            Ok(dsl::lit(s.clone()).into())
+        }
     } else if value.is_nil() {
         Ok(dsl::lit(Null {}).into())
     } else if allow_object {

data/ext/polars/src/functions/range.rs

@@ -3,7 +3,7 @@ use polars_core::datatypes::{TimeUnit, TimeZone};
 
 use crate::conversion::Wrap;
 use crate::prelude::*;
-use crate::RbExpr;
+use crate::{RbExpr, RbResult};
 
 pub fn int_range(start: &RbExpr, end: &RbExpr, step: i64, dtype: Wrap<DataType>) -> RbExpr {
     let start = start.inner.clone();
@@ -12,16 +12,20 @@ pub fn int_range(start: &RbExpr, end: &RbExpr, step: i64, dtype: Wrap<DataType>)
     dsl::int_range(start, end, step, dtype).into()
 }
 
-pub fn int_ranges(start: &RbExpr, end: &RbExpr, step: &RbExpr, dtype: Wrap<DataType>) -> RbExpr {
+pub fn int_ranges(
+    start: &RbExpr,
+    end: &RbExpr,
+    step: &RbExpr,
+    dtype: Wrap<DataType>,
+) -> RbResult<RbExpr> {
     let dtype = dtype.0;
-
-    let mut result = dsl::int_ranges(start.inner.clone(), end.inner.clone(), step.inner.clone());
-
-    if dtype != DataType::Int64 {
-        result = result.cast(DataType::List(Box::new(dtype)))
-    }
-
-    result.into()
+    Ok(dsl::int_ranges(
+        start.inner.clone(),
+        end.inner.clone(),
+        step.inner.clone(),
+        dtype,
+    )
+    .into())
 }
 
 pub fn date_range(
@@ -56,14 +60,14 @@ pub fn datetime_range(
     every: String,
     closed: Wrap<ClosedWindow>,
     time_unit: Option<Wrap<TimeUnit>>,
-    time_zone: Option<Wrap<TimeZone>>,
+    time_zone: Wrap<Option<TimeZone>>,
 ) -> RbExpr {
     let start = start.inner.clone();
     let end = end.inner.clone();
     let every = Duration::parse(&every);
     let closed = closed.0;
     let time_unit = time_unit.map(|x| x.0);
-    let time_zone = time_zone.map(|x| x.0);
+    let time_zone = time_zone.0;
     dsl::datetime_range(start, end, every, closed, time_unit, time_zone).into()
 }
 
@@ -73,14 +77,14 @@ pub fn datetime_ranges(
     every: String,
     closed: Wrap<ClosedWindow>,
     time_unit: Option<Wrap<TimeUnit>>,
-    time_zone: Option<Wrap<TimeZone>>,
+    time_zone: Wrap<Option<TimeZone>>,
 ) -> RbExpr {
     let start = start.inner.clone();
     let end = end.inner.clone();
     let every = Duration::parse(&every);
     let closed = closed.0;
     let time_unit = time_unit.map(|x| x.0);
-    let time_zone = time_zone.map(|x| x.0);
+    let time_zone = time_zone.0;
     dsl::datetime_ranges(start, end, every, closed, time_unit, time_zone).into()
 }
 

data/ext/polars/src/lazyframe/general.rs

@@ -305,7 +305,7 @@ impl RbLazyFrame {
             .with_predicate_pushdown(predicate_pushdown)
             .with_simplify_expr(simplify_expr)
             .with_slice_pushdown(slice_pushdown)
-            .with_streaming(allow_streaming)
+            .with_new_streaming(allow_streaming)
             ._with_eager(_eager)
             .with_projection_pushdown(projection_pushdown);
 
@@ -392,6 +392,8 @@ impl RbLazyFrame {
             statistics: statistics.0,
             row_group_size,
             data_page_size,
+            key_value_metadata: None,
+            field_overwrites: Vec::new(),
         };
 
         let cloud_options = match target.base_path() {

data/ext/polars/src/lib.rs

@@ -217,7 +217,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("peak_max", method!(RbExpr::peak_max, 0))?;
     class.define_method("arg_max", method!(RbExpr::arg_max, 0))?;
     class.define_method("arg_min", method!(RbExpr::arg_min, 0))?;
-    class.define_method("search_sorted", method!(RbExpr::search_sorted, 2))?;
+    class.define_method("search_sorted", method!(RbExpr::search_sorted, 3))?;
     class.define_method("gather", method!(RbExpr::gather, 1))?;
     class.define_method("get", method!(RbExpr::get, 1))?;
     class.define_method("sort_by", method!(RbExpr::sort_by, 5))?;
@@ -320,7 +320,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("arr_arg_max", method!(RbExpr::arr_arg_max, 0))?;
     class.define_method("arr_get", method!(RbExpr::arr_get, 2))?;
     class.define_method("arr_join", method!(RbExpr::arr_join, 2))?;
-    class.define_method("arr_contains", method!(RbExpr::arr_contains, 1))?;
+    class.define_method("arr_contains", method!(RbExpr::arr_contains, 2))?;
     class.define_method("arr_count_matches", method!(RbExpr::arr_count_matches, 1))?;
     class.define_method("binary_contains", method!(RbExpr::bin_contains, 1))?;
     class.define_method("binary_ends_with", method!(RbExpr::bin_ends_with, 1))?;
@@ -365,7 +365,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("str_contains_any", method!(RbExpr::str_contains_any, 2))?;
     class.define_method("str_replace_many", method!(RbExpr::str_replace_many, 3))?;
     class.define_method("list_len", method!(RbExpr::list_len, 0))?;
-    class.define_method("list_contains", method!(RbExpr::list_contains, 1))?;
+    class.define_method("list_contains", method!(RbExpr::list_contains, 2))?;
     class.define_method("list_count_matches", method!(RbExpr::list_count_matches, 1))?;
     class.define_method("dt_year", method!(RbExpr::dt_year, 0))?;
     class.define_method("dt_is_leap_year", method!(RbExpr::dt_is_leap_year, 0))?;
@@ -464,7 +464,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("list_to_array", method!(RbExpr::list_to_array, 1))?;
     class.define_method("list_mean", method!(RbExpr::list_mean, 0))?;
     class.define_method("list_tail", method!(RbExpr::list_tail, 1))?;
-    class.define_method("list_sort", method!(RbExpr::list_sort, 1))?;
+    class.define_method("list_sort", method!(RbExpr::list_sort, 2))?;
     class.define_method("list_reverse", method!(RbExpr::list_reverse, 0))?;
     class.define_method("list_unique", method!(RbExpr::list_unique, 1))?;
     class.define_method("list_get", method!(RbExpr::list_get, 2))?;
@@ -476,8 +476,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("list_diff", method!(RbExpr::list_diff, 2))?;
     class.define_method("list_shift", method!(RbExpr::list_shift, 1))?;
     class.define_method("list_slice", method!(RbExpr::list_slice, 2))?;
-    class.define_method("list_eval", method!(RbExpr::list_eval, 2))?;
-    class.define_method("cumulative_eval", method!(RbExpr::cumulative_eval, 3))?;
+    class.define_method("list_eval", method!(RbExpr::list_eval, 1))?;
+    class.define_method("cumulative_eval", method!(RbExpr::cumulative_eval, 2))?;
     class.define_method("list_to_struct", method!(RbExpr::list_to_struct, 3))?;
     class.define_method("rank", method!(RbExpr::rank, 3))?;
     class.define_method("diff", method!(RbExpr::diff, 2))?;
@@ -520,7 +520,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("replace_strict", method!(RbExpr::replace_strict, 4))?;
 
     // meta
-    class.define_method("meta_pop", method!(RbExpr::meta_pop, 0))?;
+    class.define_method("meta_pop", method!(RbExpr::meta_pop, 1))?;
     class.define_method("meta_eq", method!(RbExpr::meta_eq, 1))?;
     class.define_method("meta_roots", method!(RbExpr::meta_root_names, 0))?;
     class.define_method("meta_output_name", method!(RbExpr::meta_output_name, 0))?;
@@ -538,7 +538,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("_meta_selector_sub", method!(RbExpr::_meta_selector_sub, 1))?;
     class.define_method("_meta_selector_and", method!(RbExpr::_meta_selector_and, 1))?;
     class.define_method("_meta_as_selector", method!(RbExpr::_meta_as_selector, 0))?;
-    class.define_method("meta_tree_format", method!(RbExpr::meta_tree_format, 0))?;
+    class.define_method("meta_tree_format", method!(RbExpr::meta_tree_format, 1))?;
 
     // name
     class.define_method("name_keep", method!(RbExpr::name_keep, 0))?;
@@ -559,7 +559,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("cols", function!(functions::lazy::cols, 1))?;
     class.define_singleton_method("fold", function!(functions::lazy::fold, 5))?;
     class.define_singleton_method("cum_fold", function!(functions::lazy::cum_fold, 4))?;
-    class.define_singleton_method("lit", function!(functions::lazy::lit, 2))?;
+    class.define_singleton_method("lit", function!(functions::lazy::lit, 3))?;
     class.define_singleton_method("int_range", function!(functions::range::int_range, 4))?;
     class.define_singleton_method("int_ranges", function!(functions::range::int_ranges, 4))?;
     class.define_singleton_method("repeat", function!(functions::lazy::repeat, 3))?;

data/lib/polars/array_expr.rb

@@ -481,6 +481,8 @@ module Polars
     #
     # @param item [Object]
     #   Item that will be checked for membership
+    # @param nulls_equal [Boolean]
+    #   If true, treat null as a distinct value. Null values will not propagate.
     #
     # @return [Expr]
     #
@@ -501,9 +503,9 @@ module Polars
     #   # │ ["x", "y"]    ┆ false    │
     #   # │ ["a", "c"]    ┆ true     │
     #   # └───────────────┴──────────┘
-    def contains(item)
+    def contains(item, nulls_equal: true)
       item = Utils.parse_into_expression(item, str_as_lit: true)
-      Utils.wrap_expr(_rbexpr.arr_contains(item))
+      Utils.wrap_expr(_rbexpr.arr_contains(item, nulls_equal))
     end
 
     # Count how often the value produced by `element` occurs.