polars-df 0.11.0 → 0.12.0

data/ext/polars/src/lib.rs

@@ -60,12 +60,15 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("read_csv", function!(RbDataFrame::read_csv, -1))?;
     class.define_singleton_method("read_parquet", function!(RbDataFrame::read_parquet, 9))?;
     class.define_singleton_method("read_ipc", function!(RbDataFrame::read_ipc, 6))?;
-    class.define_singleton_method("read_ipc_stream", function!(RbDataFrame::read_ipc_stream, 6))?;
+    class.define_singleton_method(
+        "read_ipc_stream",
+        function!(RbDataFrame::read_ipc_stream, 6),
+    )?;
     class.define_singleton_method("read_avro", function!(RbDataFrame::read_avro, 4))?;
     class.define_singleton_method("from_rows", function!(RbDataFrame::from_rows, 3))?;
     class.define_singleton_method("from_hashes", function!(RbDataFrame::from_hashes, 5))?;
-    class.define_singleton_method("read_json", function!(RbDataFrame::read_json, 1))?;
-    class.define_singleton_method("read_ndjson", function!(RbDataFrame::read_ndjson, 1))?;
+    class.define_singleton_method("read_json", function!(RbDataFrame::read_json, 4))?;
+    class.define_singleton_method("read_ndjson", function!(RbDataFrame::read_ndjson, 4))?;
     class.define_method("estimated_size", method!(RbDataFrame::estimated_size, 0))?;
     class.define_method("dtype_strings", method!(RbDataFrame::dtype_strings, 0))?;
     class.define_method("write_avro", method!(RbDataFrame::write_avro, 2))?;
@@ -135,7 +138,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("equals", method!(RbDataFrame::equals, 2))?;
     class.define_method("with_row_index", method!(RbDataFrame::with_row_index, 2))?;
     class.define_method("_clone", method!(RbDataFrame::clone, 0))?;
-    class.define_method("melt", method!(RbDataFrame::melt, 4))?;
+    class.define_method("unpivot", method!(RbDataFrame::unpivot, 4))?;
     class.define_method("pivot_expr", method!(RbDataFrame::pivot_expr, 7))?;
     class.define_method("partition_by", method!(RbDataFrame::partition_by, 3))?;
     class.define_method("lazy", method!(RbDataFrame::lazy, 0))?;
@@ -149,7 +152,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("shrink_to_fit", method!(RbDataFrame::shrink_to_fit, 0))?;
     class.define_method("hash_rows", method!(RbDataFrame::hash_rows, 4))?;
     class.define_method("transpose", method!(RbDataFrame::transpose, 2))?;
-    class.define_method("upsample", method!(RbDataFrame::upsample, 5))?;
+    class.define_method("upsample", method!(RbDataFrame::upsample, 4))?;
     class.define_method("to_struct", method!(RbDataFrame::to_struct, 1))?;
     class.define_method("unnest", method!(RbDataFrame::unnest, 1))?;
     class.define_method("clear", method!(RbDataFrame::clear, 0))?;
@@ -202,20 +205,23 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("agg_groups", method!(RbExpr::agg_groups, 0))?;
     class.define_method("count", method!(RbExpr::count, 0))?;
     class.define_method("len", method!(RbExpr::len, 0))?;
-    class.define_method("value_counts", method!(RbExpr::value_counts, 2))?;
+    class.define_method("value_counts", method!(RbExpr::value_counts, 4))?;
     class.define_method("unique_counts", method!(RbExpr::unique_counts, 0))?;
     class.define_method("null_count", method!(RbExpr::null_count, 0))?;
     class.define_method("cast", method!(RbExpr::cast, 2))?;
     class.define_method("sort_with", method!(RbExpr::sort_with, 2))?;
     class.define_method("arg_sort", method!(RbExpr::arg_sort, 2))?;
-    class.define_method("top_k", method!(RbExpr::top_k, 3))?;
-    class.define_method("bottom_k", method!(RbExpr::bottom_k, 3))?;
+    class.define_method("top_k", method!(RbExpr::top_k, 1))?;
+    class.define_method("top_k_by", method!(RbExpr::top_k_by, 3))?;
+    class.define_method("bottom_k", method!(RbExpr::bottom_k, 1))?;
+    class.define_method("bottom_k_by", method!(RbExpr::bottom_k_by, 3))?;
     class.define_method("peak_min", method!(RbExpr::peak_min, 0))?;
     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("gather", method!(RbExpr::gather, 1))?;
+    class.define_method("get", method!(RbExpr::get, 1))?;
     class.define_method("sort_by", method!(RbExpr::sort_by, 5))?;
     class.define_method("backward_fill", method!(RbExpr::backward_fill, 1))?;
     class.define_method("forward_fill", method!(RbExpr::forward_fill, 1))?;
@@ -233,6 +239,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("std", method!(RbExpr::std, 1))?;
     class.define_method("var", method!(RbExpr::var, 1))?;
     class.define_method("is_unique", method!(RbExpr::is_unique, 0))?;
+    class.define_method("is_between", method!(RbExpr::is_between, 3))?;
     class.define_method("approx_n_unique", method!(RbExpr::approx_n_unique, 0))?;
     class.define_method("is_first_distinct", method!(RbExpr::is_first_distinct, 0))?;
     class.define_method("is_last_distinct", method!(RbExpr::is_last_distinct, 0))?;
@@ -290,7 +297,6 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("str_strip_prefix", method!(RbExpr::str_strip_prefix, 1))?;
     class.define_method("str_strip_suffix", method!(RbExpr::str_strip_suffix, 1))?;
     class.define_method("str_slice", method!(RbExpr::str_slice, 2))?;
-    class.define_method("str_explode", method!(RbExpr::str_explode, 0))?;
     class.define_method("str_to_uppercase", method!(RbExpr::str_to_uppercase, 0))?;
     class.define_method("str_to_lowercase", method!(RbExpr::str_to_lowercase, 0))?;
     class.define_method("str_len_bytes", method!(RbExpr::str_len_bytes, 0))?;
@@ -364,24 +370,24 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("list_len", method!(RbExpr::list_len, 0))?;
     class.define_method("list_contains", method!(RbExpr::list_contains, 1))?;
     class.define_method("list_count_matches", method!(RbExpr::list_count_matches, 1))?;
-    class.define_method("year", method!(RbExpr::dt_year, 0))?;
+    class.define_method("dt_year", method!(RbExpr::dt_year, 0))?;
     class.define_method("dt_is_leap_year", method!(RbExpr::dt_is_leap_year, 0))?;
-    class.define_method("iso_year", method!(RbExpr::dt_iso_year, 0))?;
-    class.define_method("quarter", method!(RbExpr::dt_quarter, 0))?;
-    class.define_method("month", method!(RbExpr::dt_month, 0))?;
-    class.define_method("week", method!(RbExpr::dt_week, 0))?;
-    class.define_method("weekday", method!(RbExpr::dt_weekday, 0))?;
-    class.define_method("day", method!(RbExpr::dt_day, 0))?;
-    class.define_method("ordinal_day", method!(RbExpr::dt_ordinal_day, 0))?;
+    class.define_method("dt_iso_year", method!(RbExpr::dt_iso_year, 0))?;
+    class.define_method("dt_quarter", method!(RbExpr::dt_quarter, 0))?;
+    class.define_method("dt_month", method!(RbExpr::dt_month, 0))?;
+    class.define_method("dt_week", method!(RbExpr::dt_week, 0))?;
+    class.define_method("dt_weekday", method!(RbExpr::dt_weekday, 0))?;
+    class.define_method("dt_day", method!(RbExpr::dt_day, 0))?;
+    class.define_method("dt_ordinal_day", method!(RbExpr::dt_ordinal_day, 0))?;
     class.define_method("dt_time", method!(RbExpr::dt_time, 0))?;
     class.define_method("dt_date", method!(RbExpr::dt_date, 0))?;
     class.define_method("dt_datetime", method!(RbExpr::dt_datetime, 0))?;
-    class.define_method("hour", method!(RbExpr::dt_hour, 0))?;
-    class.define_method("minute", method!(RbExpr::dt_minute, 0))?;
-    class.define_method("second", method!(RbExpr::dt_second, 0))?;
-    class.define_method("millisecond", method!(RbExpr::dt_millisecond, 0))?;
-    class.define_method("microsecond", method!(RbExpr::dt_microsecond, 0))?;
-    class.define_method("nanosecond", method!(RbExpr::dt_nanosecond, 0))?;
+    class.define_method("dt_hour", method!(RbExpr::dt_hour, 0))?;
+    class.define_method("dt_minute", method!(RbExpr::dt_minute, 0))?;
+    class.define_method("dt_second", method!(RbExpr::dt_second, 0))?;
+    class.define_method("dt_millisecond", method!(RbExpr::dt_millisecond, 0))?;
+    class.define_method("dt_microsecond", method!(RbExpr::dt_microsecond, 0))?;
+    class.define_method("dt_nanosecond", method!(RbExpr::dt_nanosecond, 0))?;
     class.define_method("dt_total_days", method!(RbExpr::dt_total_days, 0))?;
     class.define_method("dt_total_hours", method!(RbExpr::dt_total_hours, 0))?;
     class.define_method("dt_total_minutes", method!(RbExpr::dt_total_minutes, 0))?;
@@ -398,7 +404,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "dt_total_milliseconds",
         method!(RbExpr::dt_total_milliseconds, 0),
     )?;
-    class.define_method("timestamp", method!(RbExpr::dt_timestamp, 1))?;
+    class.define_method("dt_timestamp", method!(RbExpr::dt_timestamp, 1))?;
+    class.define_method("dt_to_string", method!(RbExpr::dt_to_string, 1))?;
     class.define_method("dt_offset_by", method!(RbExpr::dt_offset_by, 1))?;
     class.define_method("dt_epoch_seconds", method!(RbExpr::dt_epoch_seconds, 0))?;
     class.define_method("dt_with_time_unit", method!(RbExpr::dt_with_time_unit, 1))?;
@@ -411,12 +418,12 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "dt_replace_time_zone",
         method!(RbExpr::dt_replace_time_zone, 3),
     )?;
-    class.define_method("dt_truncate", method!(RbExpr::dt_truncate, 2))?;
+    class.define_method("dt_truncate", method!(RbExpr::dt_truncate, 1))?;
     class.define_method("dt_month_start", method!(RbExpr::dt_month_start, 0))?;
     class.define_method("dt_month_end", method!(RbExpr::dt_month_end, 0))?;
     class.define_method("dt_base_utc_offset", method!(RbExpr::dt_base_utc_offset, 0))?;
     class.define_method("dt_dst_offset", method!(RbExpr::dt_dst_offset, 0))?;
-    class.define_method("dt_round", method!(RbExpr::dt_round, 2))?;
+    class.define_method("dt_round", method!(RbExpr::dt_round, 1))?;
     class.define_method("dt_combine", method!(RbExpr::dt_combine, 2))?;
     class.define_method("map_batches", method!(RbExpr::map_batches, 4))?;
     class.define_method("dot", method!(RbExpr::dot, 1))?;
@@ -479,8 +486,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("pct_change", method!(RbExpr::pct_change, 1))?;
     class.define_method("skew", method!(RbExpr::skew, 1))?;
     class.define_method("kurtosis", method!(RbExpr::kurtosis, 2))?;
-    class.define_method("str_concat", method!(RbExpr::str_concat, 2))?;
-    class.define_method("cat_set_ordering", method!(RbExpr::cat_set_ordering, 1))?;
+    class.define_method("str_join", method!(RbExpr::str_join, 2))?;
     class.define_method("cat_get_categories", method!(RbExpr::cat_get_categories, 0))?;
     class.define_method("reshape", method!(RbExpr::reshape, 1))?;
     class.define_method("cum_count", method!(RbExpr::cum_count, 1))?;
@@ -512,7 +518,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("entropy", method!(RbExpr::entropy, 2))?;
     class.define_method("_hash", method!(RbExpr::hash, 4))?;
     class.define_method("set_sorted_flag", method!(RbExpr::set_sorted_flag, 1))?;
-    class.define_method("replace", method!(RbExpr::replace, 4))?;
+    class.define_method("replace", method!(RbExpr::replace, 2))?;
+    class.define_method("replace_strict", method!(RbExpr::replace_strict, 4))?;
 
     // meta
     class.define_method("meta_pop", method!(RbExpr::meta_pop, 0))?;
@@ -545,7 +552,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
 
     // maybe add to different class
     let class = module.define_module("Plr")?;
-    class.define_singleton_method("dtype_cols", function!(functions::lazy::dtype_cols2, 1))?;
+    class.define_singleton_method("dtype_cols", function!(functions::lazy::dtype_cols, 1))?;
+    class.define_singleton_method("index_cols", function!(functions::lazy::index_cols, 1))?;
     class.define_singleton_method("col", function!(functions::lazy::col, 1))?;
     class.define_singleton_method("len", function!(functions::lazy::len, 0))?;
     class.define_singleton_method("first", function!(functions::lazy::first, 0))?;
@@ -624,8 +632,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         function!(functions::io::read_parquet_schema, 1),
     )?;
     class.define_singleton_method("collect_all", function!(functions::lazy::collect_all, 1))?;
-    class.define_singleton_method("date_range", function!(functions::range::date_range, 6))?;
-    class.define_singleton_method("date_ranges", function!(functions::range::date_ranges, 6))?;
+    class.define_singleton_method("date_range", function!(functions::range::date_range, 4))?;
+    class.define_singleton_method("date_ranges", function!(functions::range::date_ranges, 4))?;
     class.define_singleton_method(
         "datetime_range",
         function!(functions::range::datetime_range, 6),
@@ -714,7 +722,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("new_from_csv", function!(RbLazyFrame::new_from_csv, -1))?;
     class.define_singleton_method(
         "new_from_parquet",
-        function!(RbLazyFrame::new_from_parquet, 12),
+        function!(RbLazyFrame::new_from_parquet, 13),
     )?;
     class.define_singleton_method("new_from_ipc", function!(RbLazyFrame::new_from_ipc, 6))?;
     class.define_method("write_json", method!(RbLazyFrame::write_json, 1))?;
@@ -733,17 +741,17 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("collect", method!(RbLazyFrame::collect, 0))?;
     class.define_method("sink_parquet", method!(RbLazyFrame::sink_parquet, 7))?;
     class.define_method("sink_ipc", method!(RbLazyFrame::sink_ipc, 3))?;
-    class.define_method("sink_csv", method!(RbLazyFrame::sink_csv, 14))?;
+    class.define_method("sink_csv", method!(RbLazyFrame::sink_csv, 15))?;
     class.define_method("sink_json", method!(RbLazyFrame::sink_json, 2))?;
     class.define_method("fetch", method!(RbLazyFrame::fetch, 1))?;
     class.define_method("filter", method!(RbLazyFrame::filter, 1))?;
     class.define_method("select", method!(RbLazyFrame::select, 1))?;
     class.define_method("select_seq", method!(RbLazyFrame::select_seq, 1))?;
     class.define_method("group_by", method!(RbLazyFrame::group_by, 2))?;
-    class.define_method("rolling", method!(RbLazyFrame::rolling, 6))?;
+    class.define_method("rolling", method!(RbLazyFrame::rolling, 5))?;
     class.define_method(
         "group_by_dynamic",
-        method!(RbLazyFrame::group_by_dynamic, 10),
+        method!(RbLazyFrame::group_by_dynamic, 9),
     )?;
     class.define_method("with_context", method!(RbLazyFrame::with_context, 1))?;
     class.define_method("join_asof", method!(RbLazyFrame::join_asof, 11))?;
@@ -772,16 +780,13 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("drop_nulls", method!(RbLazyFrame::drop_nulls, 1))?;
     class.define_method("slice", method!(RbLazyFrame::slice, 2))?;
     class.define_method("tail", method!(RbLazyFrame::tail, 1))?;
-    class.define_method("melt", method!(RbLazyFrame::melt, 5))?;
+    class.define_method("unpivot", method!(RbLazyFrame::unpivot, 5))?;
     class.define_method("with_row_index", method!(RbLazyFrame::with_row_index, 2))?;
     class.define_method("drop", method!(RbLazyFrame::drop, 1))?;
     class.define_method("cast_all", method!(RbLazyFrame::cast_all, 2))?;
     class.define_method("_clone", method!(RbLazyFrame::clone, 0))?;
-    class.define_method("columns", method!(RbLazyFrame::columns, 0))?;
-    class.define_method("dtypes", method!(RbLazyFrame::dtypes, 0))?;
-    class.define_method("schema", method!(RbLazyFrame::schema, 0))?;
+    class.define_method("collect_schema", method!(RbLazyFrame::collect_schema, 0))?;
     class.define_method("unnest", method!(RbLazyFrame::unnest, 1))?;
-    class.define_method("width", method!(RbLazyFrame::width, 0))?;
     class.define_method("count", method!(RbLazyFrame::count, 0))?;
     class.define_method("merge_sorted", method!(RbLazyFrame::merge_sorted, 2))?;
 
@@ -803,8 +808,12 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("new_opt_f32", function!(RbSeries::new_opt_f32, 3))?;
     class.define_singleton_method("new_opt_f64", function!(RbSeries::new_opt_f64, 3))?;
     class.define_singleton_method(
-        "new_from_anyvalues",
-        function!(RbSeries::new_from_anyvalues, 3),
+        "new_from_any_values",
+        function!(RbSeries::new_from_any_values, 3),
+    )?;
+    class.define_singleton_method(
+        "new_from_any_values_and_dtype",
+        function!(RbSeries::new_from_any_values_and_dtype, 4),
     )?;
     class.define_singleton_method("new_str", function!(RbSeries::new_str, 3))?;
     class.define_singleton_method("new_binary", function!(RbSeries::new_binary, 3))?;
@@ -861,7 +870,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("div", method!(RbSeries::div, 1))?;
     class.define_method("rem", method!(RbSeries::rem, 1))?;
     class.define_method("sort", method!(RbSeries::sort, 3))?;
-    class.define_method("value_counts", method!(RbSeries::value_counts, 1))?;
+    class.define_method("value_counts", method!(RbSeries::value_counts, 4))?;
+    class.define_method("slice", method!(RbSeries::slice, 2))?;
     class.define_method("any", method!(RbSeries::any, 1))?;
     class.define_method("all", method!(RbSeries::all, 1))?;
     class.define_method("arg_min", method!(RbSeries::arg_min, 0))?;
@@ -871,7 +881,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("has_validity", method!(RbSeries::has_validity, 0))?;
     class.define_method("sample_n", method!(RbSeries::sample_n, 4))?;
     class.define_method("sample_frac", method!(RbSeries::sample_frac, 4))?;
-    class.define_method("equals", method!(RbSeries::equals, 3))?;
+    class.define_method("equals", method!(RbSeries::equals, 4))?;
     class.define_method("eq", method!(RbSeries::eq, 1))?;
     class.define_method("neq", method!(RbSeries::neq, 1))?;
     class.define_method("gt", method!(RbSeries::gt, 1))?;

data/ext/polars/src/map/dataframe.rs

@@ -255,8 +255,8 @@ pub fn apply_lambda_with_rows_output<'a>(
                 match RArray::try_convert(val).ok() {
                     Some(tuple) => {
                         row_buf.0.clear();
-                        for v in tuple.each() {
-                            let v = Wrap::<AnyValue>::try_convert(v.unwrap()).unwrap().0;
+                        for v in tuple.into_iter() {
+                            let v = Wrap::<AnyValue>::try_convert(v).unwrap().0;
                             row_buf.0.push(v);
                         }
                         let ptr = &row_buf as *const Row;

data/ext/polars/src/rb_modules.rs

@@ -1,4 +1,4 @@
-use magnus::{value::Lazy, Module, RClass, RModule, Ruby};
+use magnus::{value::Lazy, ExceptionClass, Module, RClass, RModule, Ruby};
 
 static POLARS: Lazy<RModule> = Lazy::new(|ruby| ruby.class_object().const_get("Polars").unwrap());
 
@@ -38,3 +38,27 @@ static DATETIME: Lazy<RClass> =
 pub(crate) fn datetime() -> RClass {
     Ruby::get().unwrap().get_inner(&DATETIME)
 }
+
+static ERROR: Lazy<ExceptionClass> =
+    Lazy::new(|ruby| ruby.get_inner(&POLARS).const_get("Error").unwrap());
+
+pub(crate) fn error() -> ExceptionClass {
+    Ruby::get().unwrap().get_inner(&ERROR)
+}
+
+static COMPUTE_ERROR: Lazy<ExceptionClass> =
+    Lazy::new(|ruby| ruby.get_inner(&POLARS).const_get("ComputeError").unwrap());
+
+pub(crate) fn compute_error() -> ExceptionClass {
+    Ruby::get().unwrap().get_inner(&COMPUTE_ERROR)
+}
+
+static INVALID_OPERATION_ERROR: Lazy<ExceptionClass> = Lazy::new(|ruby| {
+    ruby.get_inner(&POLARS)
+        .const_get("InvalidOperationError")
+        .unwrap()
+});
+
+pub(crate) fn invalid_operation_error() -> ExceptionClass {
+    Ruby::get().unwrap().get_inner(&INVALID_OPERATION_ERROR)
+}

data/ext/polars/src/series/aggregation.rs

@@ -54,7 +54,8 @@ impl RbSeries {
                     .as_any_value(),
             )
             .into_value()),
-            DataType::Datetime(_, _) | DataType::Duration(_) | DataType::Time => {
+            // For non-numeric output types we require mean_reduce.
+            dt if dt.is_temporal() => {
                 Ok(Wrap(self.series.borrow().mean_reduce().as_any_value()).into_value())
             }
             _ => Ok(self.series.borrow().mean().into_value()),
@@ -73,7 +74,8 @@ impl RbSeries {
                     .as_any_value(),
             )
             .into_value()),
-            DataType::Datetime(_, _) | DataType::Duration(_) | DataType::Time => Ok(Wrap(
+            // For non-numeric output types we require median_reduce.
+            dt if dt.is_temporal() => Ok(Wrap(
                 self.series
                     .borrow()
                     .median_reduce()

data/ext/polars/src/series/arithmetic.rs

@@ -1,24 +1,34 @@
-use crate::{RbResult, RbSeries};
+use crate::{RbPolarsErr, RbResult, RbSeries};
 
 impl RbSeries {
-    pub fn add(&self, other: &RbSeries) -> Self {
-        (&*self.series.borrow() + &*other.series.borrow()).into()
+    pub fn add(&self, other: &RbSeries) -> RbResult<Self> {
+        (&*self.series.borrow() + &*other.series.borrow())
+            .map(Into::into)
+            .map_err(RbPolarsErr::from)
     }
 
-    pub fn sub(&self, other: &RbSeries) -> Self {
-        (&*self.series.borrow() - &*other.series.borrow()).into()
+    pub fn sub(&self, other: &RbSeries) -> RbResult<Self> {
+        (&*self.series.borrow() - &*other.series.borrow())
+            .map(Into::into)
+            .map_err(RbPolarsErr::from)
     }
 
-    pub fn mul(&self, other: &RbSeries) -> Self {
-        (&*self.series.borrow() * &*other.series.borrow()).into()
+    pub fn mul(&self, other: &RbSeries) -> RbResult<Self> {
+        (&*self.series.borrow() * &*other.series.borrow())
+            .map(Into::into)
+            .map_err(RbPolarsErr::from)
     }
 
-    pub fn div(&self, other: &RbSeries) -> Self {
-        (&*self.series.borrow() / &*other.series.borrow()).into()
+    pub fn div(&self, other: &RbSeries) -> RbResult<Self> {
+        (&*self.series.borrow() / &*other.series.borrow())
+            .map(Into::into)
+            .map_err(RbPolarsErr::from)
     }
 
-    pub fn rem(&self, other: &RbSeries) -> Self {
-        (&*self.series.borrow() % &*other.series.borrow()).into()
+    pub fn rem(&self, other: &RbSeries) -> RbResult<Self> {
+        (&*self.series.borrow() % &*other.series.borrow())
+            .map(Into::into)
+            .map_err(RbPolarsErr::from)
     }
 }
 

data/ext/polars/src/series/construction.rs

@@ -1,10 +1,11 @@
 use magnus::{prelude::*, RArray};
 use polars_core::prelude::*;
 
+use crate::any_value::rb_object_to_any_value;
 use crate::conversion::{slice_extract_wrapped, vec_extract_wrapped, Wrap};
 use crate::prelude::ObjectValue;
 use crate::series::to_series_collection;
-use crate::{RbPolarsErr, RbResult, RbSeries, RbValueError};
+use crate::{RbPolarsErr, RbResult, RbSeries, RbTypeError, RbValueError};
 
 impl RbSeries {
     pub fn new_opt_bool(name: String, obj: RArray, strict: bool) -> RbResult<RbSeries> {
@@ -35,36 +36,28 @@ impl RbSeries {
     }
 }
 
-fn new_primitive<T>(name: &str, obj: RArray, strict: bool) -> RbResult<RbSeries>
+fn new_primitive<T>(name: &str, values: RArray, _strict: bool) -> RbResult<RbSeries>
 where
     T: PolarsNumericType,
     ChunkedArray<T>: IntoSeries,
     T::Native: magnus::TryConvert,
 {
-    let len = obj.len();
+    let len = values.len();
     let mut builder = PrimitiveChunkedBuilder::<T>::new(name, len);
 
-    unsafe {
-        for item in obj.as_slice().iter() {
-            if item.is_nil() {
-                builder.append_null()
-            } else {
-                match T::Native::try_convert(*item) {
-                    Ok(val) => builder.append_value(val),
-                    Err(e) => {
-                        if strict {
-                            return Err(e);
-                        }
-                        builder.append_null()
-                    }
-                }
-            }
+    for res in values.into_iter() {
+        let value = res;
+        if value.is_nil() {
+            builder.append_null()
+        } else {
+            let v = <T::Native>::try_convert(value)?;
+            builder.append_value(v)
         }
     }
-    let ca = builder.finish();
 
+    let ca = builder.finish();
     let s = ca.into_series();
-    Ok(RbSeries::new(s))
+    Ok(s.into())
 }
 
 // Init with lists that can contain Nones
@@ -91,18 +84,50 @@ init_method_opt!(new_opt_f64, Float64Type, f64);
 
 fn vec_wrap_any_value<'s>(arr: RArray) -> RbResult<Vec<Wrap<AnyValue<'s>>>> {
     let mut val = Vec::with_capacity(arr.len());
-    for v in arr.each() {
-        val.push(Wrap::<AnyValue<'s>>::try_convert(v?)?);
+    for v in arr.into_iter() {
+        val.push(Wrap::<AnyValue<'s>>::try_convert(v)?);
     }
     Ok(val)
 }
 
 impl RbSeries {
-    pub fn new_from_anyvalues(name: String, val: RArray, strict: bool) -> RbResult<Self> {
-        let val = vec_wrap_any_value(val)?;
-        let avs = slice_extract_wrapped(&val);
+    pub fn new_from_any_values(name: String, values: RArray, strict: bool) -> RbResult<Self> {
+        let any_values_result = vec_wrap_any_value(values);
         // from anyvalues is fallible
-        let s = Series::from_any_values(&name, avs, strict).map_err(RbPolarsErr::from)?;
+        let result = any_values_result.and_then(|avs| {
+            let avs = slice_extract_wrapped(&avs);
+            let s = Series::from_any_values(&name, avs, strict).map_err(|e| {
+                RbTypeError::new_err(format!(
+                    "{e}\n\nHint: Try setting `strict: false` to allow passing data with mixed types."
+                ))
+            })?;
+            Ok(s.into())
+        });
+
+        // Fall back to Object type for non-strict construction.
+        if !strict && result.is_err() {
+            return Self::new_object(name, values, strict);
+        }
+
+        result
+    }
+
+    pub fn new_from_any_values_and_dtype(
+        name: String,
+        values: RArray,
+        dtype: Wrap<DataType>,
+        strict: bool,
+    ) -> RbResult<Self> {
+        let any_values = values
+            .into_iter()
+            .map(|v| rb_object_to_any_value(v, strict))
+            .collect::<RbResult<Vec<AnyValue>>>()?;
+        let s = Series::from_any_values_and_dtype(&name, any_values.as_slice(), &dtype.0, strict)
+            .map_err(|e| {
+            RbTypeError::new_err(format!(
+                "{e}\n\nHint: Try setting `strict: false` to allow passing data with mixed types."
+            ))
+        })?;
         Ok(s.into())
     }
 
@@ -125,9 +150,9 @@ impl RbSeries {
 
     pub fn new_object(name: String, val: RArray, _strict: bool) -> RbResult<Self> {
         let val = val
-            .each()
-            .map(|v| v.map(ObjectValue::from))
-            .collect::<RbResult<Vec<ObjectValue>>>()?;
+            .into_iter()
+            .map(ObjectValue::from)
+            .collect::<Vec<ObjectValue>>();
         let s = ObjectChunked::<ObjectValue>::new_from_vec(&name, val).into_series();
         Ok(s.into())
     }
@@ -163,15 +188,8 @@ impl RbSeries {
         }
     }
 
-    pub fn new_decimal(name: String, val: RArray, strict: bool) -> RbResult<Self> {
-        let val = vec_wrap_any_value(val)?;
-        // TODO: do we have to respect 'strict' here? it's possible if we want to
-        let avs = slice_extract_wrapped(&val);
-        // create a fake dtype with a placeholder "none" scale, to be inferred later
-        let dtype = DataType::Decimal(None, None);
-        let s = Series::from_any_values_and_dtype(&name, avs, &dtype, strict)
-            .map_err(RbPolarsErr::from)?;
-        Ok(s.into())
+    pub fn new_decimal(name: String, values: RArray, strict: bool) -> RbResult<Self> {
+        Self::new_from_any_values(name, values, strict)
     }
 
     pub fn repeat(

data/ext/polars/src/series/export.rs

@@ -40,7 +40,7 @@ impl RbSeries {
                 DataType::List(_) => {
                     let v = RArray::new();
                     let ca = series.list().unwrap();
-                    for opt_s in unsafe { ca.amortized_iter() } {
+                    for opt_s in ca.amortized_iter() {
                         match opt_s {
                             None => {
                                 v.push(qnil()).unwrap();

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

@@ -36,8 +36,8 @@ impl RbSeries {
 
 pub fn to_series_collection(rs: RArray) -> RbResult<Vec<Series>> {
     let mut series = Vec::new();
-    for item in rs.each() {
-        series.push(<&RbSeries>::try_convert(item?)?.series.borrow().clone());
+    for item in rs.into_iter() {
+        series.push(<&RbSeries>::try_convert(item)?.series.borrow().clone());
     }
     Ok(series)
 }
@@ -247,13 +247,24 @@ impl RbSeries {
             .into())
     }
 
-    pub fn value_counts(&self, sorted: bool) -> RbResult<RbDataFrame> {
-        let df = self
+    pub fn value_counts(
+        &self,
+        sort: bool,
+        parallel: bool,
+        name: String,
+        normalize: bool,
+    ) -> RbResult<RbDataFrame> {
+        let out = self
             .series
             .borrow()
-            .value_counts(true, sorted)
+            .value_counts(sort, parallel, name, normalize)
             .map_err(RbPolarsErr::from)?;
-        Ok(df.into())
+        Ok(out.into())
+    }
+
+    pub fn slice(&self, offset: i64, length: Option<usize>) -> Self {
+        let length = length.unwrap_or_else(|| self.series.borrow().len());
+        self.series.borrow().slice(offset, length).into()
     }
 
     pub fn take_with_series(&self, indices: &RbSeries) -> RbResult<Self> {
@@ -301,10 +312,20 @@ impl RbSeries {
         Ok(s.into())
     }
 
-    pub fn equals(&self, other: &RbSeries, null_equal: bool, strict: bool) -> bool {
-        if strict {
-            self.series.borrow().eq(&other.series.borrow())
-        } else if null_equal {
+    pub fn equals(
+        &self,
+        other: &RbSeries,
+        check_dtypes: bool,
+        check_names: bool,
+        null_equal: bool,
+    ) -> bool {
+        if check_dtypes && (self.series.borrow().dtype() != other.series.borrow().dtype()) {
+            return false;
+        }
+        if check_names && (self.series.borrow().name() != other.series.borrow().name()) {
+            return false;
+        }
+        if null_equal {
             self.series.borrow().equals_missing(&other.series.borrow())
         } else {
             self.series.borrow().equals(&other.series.borrow())

data/ext/polars/src/sql.rs

@@ -37,7 +37,9 @@ impl RbSQLContext {
     }
 
     pub fn register(&self, name: String, lf: &RbLazyFrame) {
-        self.context.borrow_mut().register(&name, lf.ldf.clone())
+        self.context
+            .borrow_mut()
+            .register(&name, lf.ldf.borrow().clone())
     }
 
     pub fn unregister(&self, name: String) {

data/lib/polars/array_expr.rb

@@ -358,7 +358,7 @@ module Polars
     #   # │ [7, 8, 9]     ┆ 4   ┆ null │
     #   # └───────────────┴─────┴──────┘
     def get(index, null_on_oob: true)
-      index = Utils.parse_as_expression(index)
+      index = Utils.parse_into_expression(index)
       Utils.wrap_expr(_rbexpr.arr_get(index, null_on_oob))
     end
 
@@ -446,7 +446,7 @@ module Polars
     #   # │ ["x", "y"]    ┆ _         ┆ x_y  │
     #   # └───────────────┴───────────┴──────┘
     def join(separator, ignore_nulls: true)
-      separator = Utils.parse_as_expression(separator, str_as_lit: true)
+      separator = Utils.parse_into_expression(separator, str_as_lit: true)
       Utils.wrap_expr(_rbexpr.arr_join(separator, ignore_nulls))
     end
 
@@ -502,7 +502,7 @@ module Polars
     #   # │ ["a", "c"]    ┆ true     │
     #   # └───────────────┴──────────┘
     def contains(item)
-      item = Utils.parse_as_expression(item, str_as_lit: true)
+      item = Utils.parse_into_expression(item, str_as_lit: true)
       Utils.wrap_expr(_rbexpr.arr_contains(item))
     end
 
@@ -530,7 +530,7 @@ module Polars
     #   # │ [2, 2]        ┆ 2              │
     #   # └───────────────┴────────────────┘
     def count_matches(element)
-      element = Utils.parse_as_expression(element, str_as_lit: true)
+      element = Utils.parse_into_expression(element, str_as_lit: true)
       Utils.wrap_expr(_rbexpr.arr_count_matches(element))
     end
   end