polars-df 0.10.0 → 0.12.0

data/ext/polars/src/lib.rs

@@ -5,6 +5,7 @@ mod error;
 mod expr;
 mod file;
 mod functions;
+mod interop;
 mod lazyframe;
 mod lazygroupby;
 mod map;
@@ -59,18 +60,26 @@ 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_avro", function!(RbDataFrame::read_avro, 4))?;
-    class.define_singleton_method("read_rows", function!(RbDataFrame::read_rows, 3))?;
-    class.define_singleton_method("read_hashes", function!(RbDataFrame::read_hashes, 4))?;
-    class.define_singleton_method("read_hash", function!(RbDataFrame::read_hash, 1))?;
-    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("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, 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))?;
     class.define_method("write_json", method!(RbDataFrame::write_json, 3))?;
     class.define_method("write_ndjson", method!(RbDataFrame::write_ndjson, 1))?;
     class.define_method("write_csv", method!(RbDataFrame::write_csv, 10))?;
     class.define_method("write_ipc", method!(RbDataFrame::write_ipc, 2))?;
+    class.define_method(
+        "write_ipc_stream",
+        method!(RbDataFrame::write_ipc_stream, 2),
+    )?;
     class.define_method("row_tuple", method!(RbDataFrame::row_tuple, 1))?;
     class.define_method("row_tuples", method!(RbDataFrame::row_tuples, 0))?;
     class.define_method("to_numo", method!(RbDataFrame::to_numo, 0))?;
@@ -88,7 +97,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("sample_n", method!(RbDataFrame::sample_n, 4))?;
     class.define_method("sample_frac", method!(RbDataFrame::sample_frac, 4))?;
     class.define_method("rechunk", method!(RbDataFrame::rechunk, 0))?;
-    class.define_method("to_s", method!(RbDataFrame::to_s, 0))?;
+    class.define_method("to_s", method!(RbDataFrame::as_str, 0))?;
     class.define_method("get_columns", method!(RbDataFrame::get_columns, 0))?;
     class.define_method("columns", method!(RbDataFrame::columns, 0))?;
     class.define_method(
@@ -106,8 +115,6 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("vstack_mut", method!(RbDataFrame::vstack_mut, 1))?;
     class.define_method("vstack", method!(RbDataFrame::vstack, 1))?;
     class.define_method("drop_in_place", method!(RbDataFrame::drop_in_place, 1))?;
-    class.define_method("drop_nulls", method!(RbDataFrame::drop_nulls, 1))?;
-    class.define_method("drop", method!(RbDataFrame::drop, 1))?;
     class.define_method("select_at_idx", method!(RbDataFrame::select_at_idx, 1))?;
     class.define_method(
         "get_column_index",
@@ -115,7 +122,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     )?;
     class.define_method("get_column", method!(RbDataFrame::get_column, 1))?;
     class.define_method("select", method!(RbDataFrame::select, 1))?;
-    class.define_method("take", method!(RbDataFrame::take, 1))?;
+    class.define_method("take", method!(RbDataFrame::gather, 1))?;
     class.define_method(
         "take_with_series",
         method!(RbDataFrame::take_with_series, 1),
@@ -131,10 +138,9 @@ 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("shift", method!(RbDataFrame::shift, 1))?;
     class.define_method("lazy", method!(RbDataFrame::lazy, 0))?;
     class.define_method("mean_horizontal", method!(RbDataFrame::mean_horizontal, 1))?;
     class.define_method("max_horizontal", method!(RbDataFrame::max_horizontal, 0))?;
@@ -142,11 +148,11 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("sum_horizontal", method!(RbDataFrame::sum_horizontal, 1))?;
     class.define_method("to_dummies", method!(RbDataFrame::to_dummies, 3))?;
     class.define_method("null_count", method!(RbDataFrame::null_count, 0))?;
-    class.define_method("apply", method!(RbDataFrame::apply, 3))?;
+    class.define_method("map_rows", method!(RbDataFrame::map_rows, 3))?;
     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))?;
@@ -199,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, 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))?;
@@ -230,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))?;
@@ -287,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))?;
@@ -361,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))?;
@@ -395,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))?;
@@ -408,27 +418,38 @@ 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", method!(RbExpr::map, 3))?;
+    class.define_method("map_batches", method!(RbExpr::map_batches, 4))?;
     class.define_method("dot", method!(RbExpr::dot, 1))?;
     class.define_method("reinterpret", method!(RbExpr::reinterpret, 1))?;
     class.define_method("mode", method!(RbExpr::mode, 0))?;
     class.define_method("exclude", method!(RbExpr::exclude, 1))?;
     class.define_method("interpolate", method!(RbExpr::interpolate, 1))?;
-    class.define_method("rolling_sum", method!(RbExpr::rolling_sum, 6))?;
-    class.define_method("rolling_min", method!(RbExpr::rolling_min, 6))?;
-    class.define_method("rolling_max", method!(RbExpr::rolling_max, 6))?;
-    class.define_method("rolling_mean", method!(RbExpr::rolling_mean, 6))?;
-    class.define_method("rolling_std", method!(RbExpr::rolling_std, 8))?;
-    class.define_method("rolling_var", method!(RbExpr::rolling_var, 8))?;
-    class.define_method("rolling_median", method!(RbExpr::rolling_median, 7))?;
-    class.define_method("rolling_quantile", method!(RbExpr::rolling_quantile, 9))?;
+    class.define_method("rolling_sum", method!(RbExpr::rolling_sum, 4))?;
+    class.define_method("rolling_sum_by", method!(RbExpr::rolling_sum_by, 4))?;
+    class.define_method("rolling_min", method!(RbExpr::rolling_min, 4))?;
+    class.define_method("rolling_min_by", method!(RbExpr::rolling_min_by, 4))?;
+    class.define_method("rolling_max", method!(RbExpr::rolling_max, 4))?;
+    class.define_method("rolling_max_by", method!(RbExpr::rolling_max_by, 4))?;
+    class.define_method("rolling_mean", method!(RbExpr::rolling_mean, 4))?;
+    class.define_method("rolling_mean_by", method!(RbExpr::rolling_mean_by, 4))?;
+    class.define_method("rolling_std", method!(RbExpr::rolling_std, 5))?;
+    class.define_method("rolling_std_by", method!(RbExpr::rolling_std_by, 5))?;
+    class.define_method("rolling_var", method!(RbExpr::rolling_var, 5))?;
+    class.define_method("rolling_var_by", method!(RbExpr::rolling_var_by, 5))?;
+    class.define_method("rolling_median", method!(RbExpr::rolling_median, 4))?;
+    class.define_method("rolling_median_by", method!(RbExpr::rolling_median_by, 4))?;
+    class.define_method("rolling_quantile", method!(RbExpr::rolling_quantile, 6))?;
+    class.define_method(
+        "rolling_quantile_by",
+        method!(RbExpr::rolling_quantile_by, 6),
+    )?;
     class.define_method("rolling_skew", method!(RbExpr::rolling_skew, 2))?;
     class.define_method("lower_bound", method!(RbExpr::lower_bound, 0))?;
     class.define_method("upper_bound", method!(RbExpr::upper_bound, 0))?;
@@ -465,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))?;
@@ -498,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))?;
@@ -531,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))?;
@@ -610,7 +632,18 @@ 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_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),
+    )?;
+    class.define_singleton_method(
+        "datetime_ranges",
+        function!(functions::range::datetime_ranges, 6),
+    )?;
+    class.define_singleton_method("time_range", function!(functions::range::time_range, 4))?;
+    class.define_singleton_method("time_ranges", function!(functions::range::time_ranges, 4))?;
     class.define_singleton_method(
         "dtype_str_repr",
         function!(functions::misc::dtype_str_repr, 1),
@@ -689,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, 11),
+        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))?;
@@ -708,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))?;
@@ -747,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))?;
 
@@ -778,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))?;
@@ -836,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))?;
@@ -846,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/map/lazy.rs

@@ -8,31 +8,11 @@ pub fn binary_lambda(_lambda: Value, _a: Series, _b: Series) -> PolarsResult<Opt
 }
 
 pub fn map_single(
-    rbexpr: &RbExpr,
+    _rbexpr: &RbExpr,
     _lambda: Value,
-    output_type: Option<Wrap<DataType>>,
-    agg_list: bool,
+    _output_type: Option<Wrap<DataType>>,
+    _agg_list: bool,
+    _is_elementwise: bool,
 ) -> RbExpr {
-    let output_type = output_type.map(|wrap| wrap.0);
-
-    let output_type2 = output_type.clone();
-    let function = move |_s: Series| {
-        let _output_type = output_type2.clone().unwrap_or(DataType::Unknown);
-
-        todo!();
-    };
-
-    let output_map = GetOutput::map_field(move |fld| match output_type {
-        Some(ref dt) => Field::new(fld.name(), dt.clone()),
-        None => {
-            let mut fld = fld.clone();
-            fld.coerce(DataType::Unknown);
-            fld
-        }
-    });
-    if agg_list {
-        rbexpr.clone().inner.map_list(function, output_map).into()
-    } else {
-        rbexpr.clone().inner.map(function, output_map).into()
-    }
+    todo!();
 }

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

@@ -33,7 +33,12 @@ fn infer_and_finish<'a, A: ApplyLambda<'a>>(
             .apply_lambda_with_utf8_out_type(lambda, null_count, Some(first_value.as_str()))
             .map(|ca| ca.into_series().into())
     } else if out.respond_to("_s", true)? {
-        todo!()
+        let rb_rbseries: &RbSeries = out.funcall("_s", ()).unwrap();
+        let series = rb_rbseries.series.borrow();
+        let dt = series.dtype();
+        applyer
+            .apply_lambda_with_list_out_type(lambda, null_count, &series, dt)
+            .map(|ca| ca.into_series().into())
     } else if out.is_kind_of(class::array()) {
         todo!()
     } else if out.is_kind_of(class::hash()) {
@@ -66,6 +71,7 @@ pub trait ApplyLambda<'a> {
     fn apply_lambda_unknown(&'a self, _lambda: Value) -> RbResult<RbSeries>;
 
     /// Apply a lambda that doesn't change output types
+    #[allow(dead_code)]
     fn apply_lambda(&'a self, _lambda: Value) -> RbResult<RbSeries>;
 
     // Used to store a struct type

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

@@ -1,6 +1,6 @@
 use crate::error::RbPolarsErr;
 use crate::prelude::*;
-use crate::{RbResult, RbSeries, RbValueError};
+use crate::{RbResult, RbSeries};
 use magnus::{IntoValue, Value};
 
 impl RbSeries {
@@ -36,31 +36,54 @@ impl RbSeries {
         Ok(Wrap(
             self.series
                 .borrow()
-                .max_as_series()
+                .max_reduce()
                 .map_err(RbPolarsErr::from)?
-                .get(0)
-                .map_err(RbPolarsErr::from)?,
+                .as_any_value(),
         )
         .into_value())
     }
 
-    pub fn mean(&self) -> Option<f64> {
+    pub fn mean(&self) -> RbResult<Value> {
         match self.series.borrow().dtype() {
-            DataType::Boolean => {
-                let s = self.series.borrow().cast(&DataType::UInt8).unwrap();
-                s.mean()
+            DataType::Boolean => Ok(Wrap(
+                self.series
+                    .borrow()
+                    .cast(&DataType::UInt8)
+                    .unwrap()
+                    .mean_reduce()
+                    .as_any_value(),
+            )
+            .into_value()),
+            // 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())
             }
-            _ => self.series.borrow().mean(),
+            _ => Ok(self.series.borrow().mean().into_value()),
         }
     }
 
-    pub fn median(&self) -> Option<f64> {
+    pub fn median(&self) -> RbResult<Value> {
         match self.series.borrow().dtype() {
-            DataType::Boolean => {
-                let s = self.series.borrow().cast(&DataType::UInt8).unwrap();
-                s.median()
-            }
-            _ => self.series.borrow().median(),
+            DataType::Boolean => Ok(Wrap(
+                self.series
+                    .borrow()
+                    .cast(&DataType::UInt8)
+                    .unwrap()
+                    .median_reduce()
+                    .map_err(RbPolarsErr::from)?
+                    .as_any_value(),
+            )
+            .into_value()),
+            // For non-numeric output types we require median_reduce.
+            dt if dt.is_temporal() => Ok(Wrap(
+                self.series
+                    .borrow()
+                    .median_reduce()
+                    .map_err(RbPolarsErr::from)?
+                    .as_any_value(),
+            )
+            .into_value()),
+            _ => Ok(self.series.borrow().median().into_value()),
         }
     }
 
@@ -68,10 +91,9 @@ impl RbSeries {
         Ok(Wrap(
             self.series
                 .borrow()
-                .min_as_series()
+                .min_reduce()
                 .map_err(RbPolarsErr::from)?
-                .get(0)
-                .map_err(RbPolarsErr::from)?,
+                .as_any_value(),
         )
         .into_value())
     }
@@ -81,25 +103,22 @@ impl RbSeries {
         quantile: f64,
         interpolation: Wrap<QuantileInterpolOptions>,
     ) -> RbResult<Value> {
-        Ok(Wrap(
-            self.series
-                .borrow()
-                .quantile_as_series(quantile, interpolation.0)
-                .map_err(|_| RbValueError::new_err("invalid quantile".into()))?
-                .get(0)
-                .unwrap_or(AnyValue::Null),
-        )
-        .into_value())
+        let bind = self
+            .series
+            .borrow()
+            .quantile_reduce(quantile, interpolation.0);
+        let sc = bind.map_err(RbPolarsErr::from)?;
+
+        Ok(Wrap(sc.as_any_value()).into_value())
     }
 
     pub fn sum(&self) -> RbResult<Value> {
         Ok(Wrap(
             self.series
                 .borrow()
-                .sum_as_series()
+                .sum_reduce()
                 .map_err(RbPolarsErr::from)?
-                .get(0)
-                .map_err(RbPolarsErr::from)?,
+                .as_any_value(),
         )
         .into_value())
     }

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)
     }
 }