polars-df 0.4.0 → 0.6.0

data/ext/polars/src/lib.rs

@@ -3,31 +3,27 @@ mod batched_csv;
 mod conversion;
 mod dataframe;
 mod error;
+mod expr;
 mod file;
-mod lazy;
-mod list_construction;
-mod numo;
+mod functions;
+mod lazyframe;
+mod lazygroupby;
 mod object;
 mod prelude;
 pub(crate) mod rb_modules;
 mod series;
-mod set;
 mod utils;
 
 use batched_csv::RbBatchedCsv;
 use conversion::*;
 use dataframe::RbDataFrame;
-use error::{RbPolarsErr, RbValueError};
-use file::get_file_like;
-use lazy::dataframe::{RbLazyFrame, RbLazyGroupBy};
-use lazy::dsl::{RbExpr, RbWhen, RbWhenThen};
-use lazy::utils::rb_exprs_to_exprs;
-use magnus::{define_module, function, method, prelude::*, Error, IntoValue, RArray, RHash, Value};
-use polars::datatypes::{DataType, TimeUnit, IDX_DTYPE};
-use polars::error::PolarsResult;
-use polars::frame::DataFrame;
-use polars::functions::{diag_concat_df, hor_concat_df};
-use polars::prelude::{ClosedWindow, Duration, DurationArgs, IntoSeries, TimeZone};
+use error::{RbPolarsErr, RbTypeError, RbValueError};
+use expr::rb_exprs_to_exprs;
+use expr::RbExpr;
+use functions::whenthen::{RbWhen, RbWhenThen};
+use lazyframe::RbLazyFrame;
+use lazygroupby::RbLazyGroupBy;
+use magnus::{define_module, function, method, prelude::*, Error};
 use series::RbSeries;
 
 #[cfg(target_os = "linux")]
@@ -49,22 +45,70 @@ type RbResult<T> = Result<T, Error>;
 #[magnus::init]
 fn init() -> RbResult<()> {
     let module = define_module("Polars")?;
-    module.define_singleton_method("_dtype_cols", function!(dtype_cols, 1))?;
-    module.define_singleton_method("_rb_duration", function!(rb_duration, 8))?;
-    module.define_singleton_method("_concat_df", function!(concat_df, 1))?;
-    module.define_singleton_method("_concat_lf", function!(concat_lf, 3))?;
-    module.define_singleton_method("_diag_concat_df", function!(rb_diag_concat_df, 1))?;
-    module.define_singleton_method("_hor_concat_df", function!(rb_hor_concat_df, 1))?;
-    module.define_singleton_method("_concat_series", function!(concat_series, 1))?;
-    module.define_singleton_method("_ipc_schema", function!(ipc_schema, 1))?;
-    module.define_singleton_method("_parquet_schema", function!(parquet_schema, 1))?;
-    module.define_singleton_method("_collect_all", function!(collect_all, 1))?;
-    module.define_singleton_method("_rb_date_range", function!(rb_date_range, 7))?;
-    module.define_singleton_method("_coalesce_exprs", function!(coalesce_exprs, 1))?;
-    module.define_singleton_method("_sum_exprs", function!(sum_exprs, 1))?;
-    module.define_singleton_method("_as_struct", function!(as_struct, 1))?;
-    module.define_singleton_method("_arg_where", function!(arg_where, 1))?;
-    module.define_singleton_method("_get_idx_type", function!(get_idx_type, 0))?;
+    module.define_singleton_method(
+        "_dtype_cols",
+        function!(crate::functions::lazy::dtype_cols2, 1),
+    )?;
+    module.define_singleton_method(
+        "_rb_duration",
+        function!(crate::functions::lazy::duration, 8),
+    )?;
+    module.define_singleton_method(
+        "_concat_df",
+        function!(crate::functions::eager::concat_df, 1),
+    )?;
+    module.define_singleton_method(
+        "_concat_lf",
+        function!(crate::functions::lazy::concat_lf, 4),
+    )?;
+    module.define_singleton_method(
+        "_diag_concat_df",
+        function!(crate::functions::eager::diag_concat_df, 1),
+    )?;
+    module.define_singleton_method(
+        "_hor_concat_df",
+        function!(crate::functions::eager::hor_concat_df, 1),
+    )?;
+    module.define_singleton_method(
+        "_concat_series",
+        function!(crate::functions::eager::concat_series, 1),
+    )?;
+    module.define_singleton_method(
+        "_ipc_schema",
+        function!(crate::functions::io::read_ipc_schema, 1),
+    )?;
+    module.define_singleton_method(
+        "_parquet_schema",
+        function!(crate::functions::io::read_parquet_schema, 1),
+    )?;
+    module.define_singleton_method(
+        "_collect_all",
+        function!(crate::functions::lazy::collect_all, 1),
+    )?;
+    module.define_singleton_method(
+        "_rb_date_range",
+        function!(crate::functions::eager::date_range, 7),
+    )?;
+    module.define_singleton_method(
+        "_coalesce_exprs",
+        function!(crate::functions::lazy::coalesce, 1),
+    )?;
+    module.define_singleton_method(
+        "_sum_exprs",
+        function!(crate::functions::lazy::sum_exprs, 1),
+    )?;
+    module.define_singleton_method(
+        "_as_struct",
+        function!(crate::functions::lazy::as_struct, 1),
+    )?;
+    module.define_singleton_method(
+        "_arg_where",
+        function!(crate::functions::lazy::arg_where, 1),
+    )?;
+    module.define_singleton_method(
+        "_get_idx_type",
+        function!(crate::functions::meta::get_idx_type, 0),
+    )?;
 
     let class = module.define_class("RbBatchedCsv", Default::default())?;
     class.define_singleton_method("new", function!(RbBatchedCsv::new, -1))?;
@@ -135,7 +179,6 @@ fn init() -> RbResult<()> {
         "take_with_series",
         method!(RbDataFrame::take_with_series, 1),
     )?;
-    class.define_method("sort", method!(RbDataFrame::sort, 3))?;
     class.define_method("replace", method!(RbDataFrame::replace, 2))?;
     class.define_method("replace_at_idx", method!(RbDataFrame::replace_at_idx, 2))?;
     class.define_method("insert_at_idx", method!(RbDataFrame::insert_at_idx, 2))?;
@@ -149,7 +192,7 @@ fn init() -> RbResult<()> {
     class.define_method("_clone", method!(RbDataFrame::clone, 0))?;
     class.define_method("melt", method!(RbDataFrame::melt, 4))?;
     class.define_method("pivot_expr", method!(RbDataFrame::pivot_expr, 7))?;
-    class.define_method("partition_by", method!(RbDataFrame::partition_by, 2))?;
+    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("max", method!(RbDataFrame::max, 0))?;
@@ -164,7 +207,7 @@ fn init() -> RbResult<()> {
     class.define_method("hmin", method!(RbDataFrame::hmin, 0))?;
     class.define_method("hsum", method!(RbDataFrame::hsum, 1))?;
     class.define_method("quantile", method!(RbDataFrame::quantile, 2))?;
-    class.define_method("to_dummies", method!(RbDataFrame::to_dummies, 2))?;
+    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("shrink_to_fit", method!(RbDataFrame::shrink_to_fit, 0))?;
@@ -209,7 +252,7 @@ fn init() -> RbResult<()> {
     class.define_method("unique_stable", method!(RbExpr::unique_stable, 0))?;
     class.define_method("first", method!(RbExpr::first, 0))?;
     class.define_method("last", method!(RbExpr::last, 0))?;
-    class.define_method("list", method!(RbExpr::list, 0))?;
+    class.define_method("implode", method!(RbExpr::implode, 0))?;
     class.define_method("quantile", method!(RbExpr::quantile, 2))?;
     class.define_method("agg_groups", method!(RbExpr::agg_groups, 0))?;
     class.define_method("count", method!(RbExpr::count, 0))?;
@@ -219,7 +262,8 @@ fn init() -> RbResult<()> {
     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, 2))?;
+    class.define_method("top_k", method!(RbExpr::top_k, 1))?;
+    class.define_method("bottom_k", method!(RbExpr::bottom_k, 1))?;
     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))?;
@@ -242,6 +286,7 @@ fn init() -> 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("approx_unique", method!(RbExpr::approx_unique, 0))?;
     class.define_method("is_first", method!(RbExpr::is_first, 0))?;
     class.define_method("explode", method!(RbExpr::explode, 0))?;
     class.define_method("take_every", method!(RbExpr::take_every, 1))?;
@@ -284,18 +329,19 @@ fn init() -> RbResult<()> {
     class.define_method("cumprod", method!(RbExpr::cumprod, 1))?;
     class.define_method("product", method!(RbExpr::product, 0))?;
     class.define_method("shrink_dtype", method!(RbExpr::shrink_dtype, 0))?;
-    class.define_method("str_parse_date", method!(RbExpr::str_parse_date, 4))?;
-    class.define_method("str_parse_datetime", method!(RbExpr::str_parse_datetime, 6))?;
-    class.define_method("str_parse_time", method!(RbExpr::str_parse_time, 4))?;
+    class.define_method("str_to_date", method!(RbExpr::str_to_date, 4))?;
+    class.define_method("str_to_datetime", method!(RbExpr::str_to_datetime, 6))?;
+    class.define_method("str_to_time", method!(RbExpr::str_to_time, 3))?;
     class.define_method("str_strip", method!(RbExpr::str_strip, 1))?;
     class.define_method("str_rstrip", method!(RbExpr::str_rstrip, 1))?;
     class.define_method("str_lstrip", method!(RbExpr::str_lstrip, 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_lengths", method!(RbExpr::str_lengths, 0))?;
     class.define_method("str_n_chars", method!(RbExpr::str_n_chars, 0))?;
-    class.define_method("str_replace", method!(RbExpr::str_replace, 3))?;
+    class.define_method("str_replace_n", method!(RbExpr::str_replace_n, 4))?;
     class.define_method("str_replace_all", method!(RbExpr::str_replace_all, 3))?;
     class.define_method("str_zfill", method!(RbExpr::str_zfill, 1))?;
     class.define_method("str_ljust", method!(RbExpr::str_ljust, 2))?;
@@ -303,22 +349,27 @@ fn init() -> RbResult<()> {
     class.define_method("str_contains", method!(RbExpr::str_contains, 3))?;
     class.define_method("str_ends_with", method!(RbExpr::str_ends_with, 1))?;
     class.define_method("str_starts_with", method!(RbExpr::str_starts_with, 1))?;
-    class.define_method("binary_contains", method!(RbExpr::binary_contains, 1))?;
-    class.define_method("binary_ends_with", method!(RbExpr::binary_ends_with, 1))?;
-    class.define_method("binary_starts_with", method!(RbExpr::binary_starts_with, 1))?;
+    class.define_method("array_max", method!(RbExpr::array_max, 0))?;
+    class.define_method("array_min", method!(RbExpr::array_min, 0))?;
+    class.define_method("array_sum", method!(RbExpr::array_sum, 0))?;
+    class.define_method("binary_contains", method!(RbExpr::bin_contains, 1))?;
+    class.define_method("binary_ends_with", method!(RbExpr::bin_ends_with, 1))?;
+    class.define_method("binary_starts_with", method!(RbExpr::bin_starts_with, 1))?;
     class.define_method("str_hex_encode", method!(RbExpr::str_hex_encode, 0))?;
     class.define_method("str_hex_decode", method!(RbExpr::str_hex_decode, 1))?;
     class.define_method("str_base64_encode", method!(RbExpr::str_base64_encode, 0))?;
     class.define_method("str_base64_decode", method!(RbExpr::str_base64_decode, 1))?;
-    class.define_method("binary_hex_encode", method!(RbExpr::binary_hex_encode, 0))?;
-    class.define_method("binary_hex_decode", method!(RbExpr::binary_hex_decode, 1))?;
+    class.define_method("str_parse_int", method!(RbExpr::str_parse_int, 2))?;
+    class.define_method("str_json_extract", method!(RbExpr::str_json_extract, 2))?;
+    class.define_method("binary_hex_encode", method!(RbExpr::bin_hex_encode, 0))?;
+    class.define_method("binary_hex_decode", method!(RbExpr::bin_hex_decode, 1))?;
     class.define_method(
         "binary_base64_encode",
-        method!(RbExpr::binary_base64_encode, 0),
+        method!(RbExpr::bin_base64_encode, 0),
     )?;
     class.define_method(
         "binary_base64_decode",
-        method!(RbExpr::binary_base64_decode, 1),
+        method!(RbExpr::bin_base64_decode, 1),
     )?;
     class.define_method(
         "str_json_path_match",
@@ -326,8 +377,8 @@ fn init() -> RbResult<()> {
     )?;
     class.define_method("str_extract", method!(RbExpr::str_extract, 2))?;
     class.define_method("str_extract_all", method!(RbExpr::str_extract_all, 1))?;
-    class.define_method("count_match", method!(RbExpr::count_match, 1))?;
-    class.define_method("strftime", method!(RbExpr::strftime, 1))?;
+    class.define_method("count_match", method!(RbExpr::str_count_match, 1))?;
+    class.define_method("strftime", method!(RbExpr::dt_to_string, 1))?;
     class.define_method("str_split", method!(RbExpr::str_split, 1))?;
     class.define_method(
         "str_split_inclusive",
@@ -339,22 +390,27 @@ fn init() -> RbResult<()> {
         method!(RbExpr::str_split_exact_inclusive, 2),
     )?;
     class.define_method("str_splitn", method!(RbExpr::str_splitn, 2))?;
-    class.define_method("arr_lengths", method!(RbExpr::arr_lengths, 0))?;
-    class.define_method("arr_contains", method!(RbExpr::arr_contains, 1))?;
-    class.define_method("year", method!(RbExpr::year, 0))?;
-    class.define_method("iso_year", method!(RbExpr::iso_year, 0))?;
-    class.define_method("quarter", method!(RbExpr::quarter, 0))?;
-    class.define_method("month", method!(RbExpr::month, 0))?;
-    class.define_method("week", method!(RbExpr::week, 0))?;
-    class.define_method("weekday", method!(RbExpr::weekday, 0))?;
-    class.define_method("day", method!(RbExpr::day, 0))?;
-    class.define_method("ordinal_day", method!(RbExpr::ordinal_day, 0))?;
-    class.define_method("hour", method!(RbExpr::hour, 0))?;
-    class.define_method("minute", method!(RbExpr::minute, 0))?;
-    class.define_method("second", method!(RbExpr::second, 0))?;
-    class.define_method("millisecond", method!(RbExpr::millisecond, 0))?;
-    class.define_method("microsecond", method!(RbExpr::microsecond, 0))?;
-    class.define_method("nanosecond", method!(RbExpr::nanosecond, 0))?;
+    class.define_method("list_lengths", method!(RbExpr::list_lengths, 0))?;
+    class.define_method("list_contains", method!(RbExpr::list_contains, 1))?;
+    class.define_method("list_count_match", method!(RbExpr::list_count_match, 1))?;
+    class.define_method("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_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("duration_days", method!(RbExpr::duration_days, 0))?;
     class.define_method("duration_hours", method!(RbExpr::duration_hours, 0))?;
     class.define_method("duration_minutes", method!(RbExpr::duration_minutes, 0))?;
@@ -371,7 +427,7 @@ fn init() -> RbResult<()> {
         "duration_milliseconds",
         method!(RbExpr::duration_milliseconds, 0),
     )?;
-    class.define_method("timestamp", method!(RbExpr::timestamp, 1))?;
+    class.define_method("timestamp", method!(RbExpr::dt_timestamp, 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))?;
@@ -382,11 +438,14 @@ fn init() -> RbResult<()> {
     class.define_method("dt_cast_time_unit", method!(RbExpr::dt_cast_time_unit, 1))?;
     class.define_method(
         "dt_replace_time_zone",
-        method!(RbExpr::dt_replace_time_zone, 1),
+        method!(RbExpr::dt_replace_time_zone, 2),
     )?;
     class.define_method("dt_tz_localize", method!(RbExpr::dt_tz_localize, 1))?;
     class.define_method("dt_truncate", method!(RbExpr::dt_truncate, 2))?;
+    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_round", method!(RbExpr::dt_round, 2))?;
+    class.define_method("dt_combine", method!(RbExpr::dt_combine, 2))?;
     class.define_method("map", method!(RbExpr::map, 3))?;
     class.define_method("dot", method!(RbExpr::dot, 1))?;
     class.define_method("reinterpret", method!(RbExpr::reinterpret, 1))?;
@@ -401,31 +460,32 @@ fn init() -> RbResult<()> {
     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, 6))?;
-    class.define_method("rolling_var", method!(RbExpr::rolling_var, 6))?;
+    class.define_method("rolling_std", method!(RbExpr::rolling_std, 7))?;
+    class.define_method("rolling_var", method!(RbExpr::rolling_var, 7))?;
     class.define_method("rolling_median", method!(RbExpr::rolling_median, 6))?;
     class.define_method("rolling_quantile", method!(RbExpr::rolling_quantile, 8))?;
     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))?;
-    class.define_method("lst_max", method!(RbExpr::lst_max, 0))?;
-    class.define_method("lst_min", method!(RbExpr::lst_min, 0))?;
-    class.define_method("lst_sum", method!(RbExpr::lst_sum, 0))?;
-    class.define_method("lst_mean", method!(RbExpr::lst_mean, 0))?;
-    class.define_method("lst_sort", method!(RbExpr::lst_sort, 1))?;
-    class.define_method("lst_reverse", method!(RbExpr::lst_reverse, 0))?;
-    class.define_method("lst_unique", method!(RbExpr::lst_unique, 0))?;
-    class.define_method("lst_get", method!(RbExpr::lst_get, 1))?;
-    class.define_method("lst_join", method!(RbExpr::lst_join, 1))?;
-    class.define_method("lst_arg_min", method!(RbExpr::lst_arg_min, 0))?;
-    class.define_method("lst_arg_max", method!(RbExpr::lst_arg_max, 0))?;
-    class.define_method("lst_diff", method!(RbExpr::lst_diff, 2))?;
-    class.define_method("lst_shift", method!(RbExpr::lst_shift, 1))?;
-    class.define_method("lst_slice", method!(RbExpr::lst_slice, 2))?;
-    class.define_method("lst_eval", method!(RbExpr::lst_eval, 2))?;
+    class.define_method("list_max", method!(RbExpr::list_max, 0))?;
+    class.define_method("list_min", method!(RbExpr::list_min, 0))?;
+    class.define_method("list_sum", method!(RbExpr::list_sum, 0))?;
+    class.define_method("list_take", method!(RbExpr::list_take, 2))?;
+    class.define_method("list_mean", method!(RbExpr::list_mean, 0))?;
+    class.define_method("list_sort", method!(RbExpr::list_sort, 1))?;
+    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, 1))?;
+    class.define_method("list_join", method!(RbExpr::list_join, 1))?;
+    class.define_method("list_arg_min", method!(RbExpr::list_arg_min, 0))?;
+    class.define_method("list_arg_max", method!(RbExpr::list_arg_max, 0))?;
+    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("lst_to_struct", method!(RbExpr::lst_to_struct, 3))?;
-    class.define_method("rank", method!(RbExpr::rank, 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))?;
     class.define_method("pct_change", method!(RbExpr::pct_change, 1))?;
     class.define_method("skew", method!(RbExpr::skew, 1))?;
@@ -435,9 +495,9 @@ fn init() -> RbResult<()> {
     class.define_method("reshape", method!(RbExpr::reshape, 1))?;
     class.define_method("cumcount", method!(RbExpr::cumcount, 1))?;
     class.define_method("to_physical", method!(RbExpr::to_physical, 0))?;
-    class.define_method("shuffle", method!(RbExpr::shuffle, 1))?;
-    class.define_method("sample_n", method!(RbExpr::sample_n, 4))?;
-    class.define_method("sample_frac", method!(RbExpr::sample_frac, 4))?;
+    class.define_method("shuffle", method!(RbExpr::shuffle, 2))?;
+    class.define_method("sample_n", method!(RbExpr::sample_n, 5))?;
+    class.define_method("sample_frac", method!(RbExpr::sample_frac, 5))?;
     class.define_method("ewm_mean", method!(RbExpr::ewm_mean, 4))?;
     class.define_method("ewm_std", method!(RbExpr::ewm_std, 5))?;
     class.define_method("ewm_var", method!(RbExpr::ewm_var, 5))?;
@@ -460,35 +520,56 @@ fn init() -> RbResult<()> {
     class.define_method("exp", method!(RbExpr::exp, 0))?;
     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))?;
 
     // meta
     class.define_method("meta_pop", method!(RbExpr::meta_pop, 0))?;
     class.define_method("meta_eq", method!(RbExpr::meta_eq, 1))?;
-    class.define_method("meta_roots", method!(RbExpr::meta_roots, 0))?;
+    class.define_method("meta_roots", method!(RbExpr::meta_root_names, 0))?;
     class.define_method("meta_output_name", method!(RbExpr::meta_output_name, 0))?;
     class.define_method("meta_undo_aliases", method!(RbExpr::meta_undo_aliases, 0))?;
+    class.define_method(
+        "meta_has_multiple_outputs",
+        method!(RbExpr::meta_has_multiple_outputs, 0),
+    )?;
+    class.define_method(
+        "meta_is_regex_projection",
+        method!(RbExpr::meta_is_regex_projection, 0),
+    )?;
 
     // maybe add to different class
-    class.define_singleton_method("col", function!(crate::lazy::dsl::col, 1))?;
-    class.define_singleton_method("count", function!(crate::lazy::dsl::count, 0))?;
-    class.define_singleton_method("first", function!(crate::lazy::dsl::first, 0))?;
-    class.define_singleton_method("last", function!(crate::lazy::dsl::last, 0))?;
-    class.define_singleton_method("cols", function!(crate::lazy::dsl::cols, 1))?;
-    class.define_singleton_method("fold", function!(crate::lazy::dsl::fold, 3))?;
-    class.define_singleton_method("cumfold", function!(crate::lazy::dsl::cumfold, 4))?;
-    class.define_singleton_method("lit", function!(crate::lazy::dsl::lit, 1))?;
-    class.define_singleton_method("arange", function!(crate::lazy::dsl::arange, 3))?;
-    class.define_singleton_method("repeat", function!(crate::lazy::dsl::repeat, 2))?;
-    class.define_singleton_method("pearson_corr", function!(crate::lazy::dsl::pearson_corr, 3))?;
+    class.define_singleton_method("col", function!(crate::functions::lazy::col, 1))?;
+    class.define_singleton_method("count", function!(crate::functions::lazy::count, 0))?;
+    class.define_singleton_method("first", function!(crate::functions::lazy::first, 0))?;
+    class.define_singleton_method("last", function!(crate::functions::lazy::last, 0))?;
+    class.define_singleton_method("cols", function!(crate::functions::lazy::cols, 1))?;
+    class.define_singleton_method("fold", function!(crate::functions::lazy::fold, 3))?;
+    class.define_singleton_method("cumfold", function!(crate::functions::lazy::cumfold, 4))?;
+    class.define_singleton_method("lit", function!(crate::functions::lazy::lit, 2))?;
+    class.define_singleton_method("arange", function!(crate::functions::lazy::arange, 3))?;
+    class.define_singleton_method("repeat", function!(crate::functions::lazy::repeat, 3))?;
+    class.define_singleton_method(
+        "pearson_corr",
+        function!(crate::functions::lazy::pearson_corr, 3),
+    )?;
     class.define_singleton_method(
         "spearman_rank_corr",
-        function!(crate::lazy::dsl::spearman_rank_corr, 4),
+        function!(crate::functions::lazy::spearman_rank_corr, 4),
+    )?;
+    class.define_singleton_method("cov", function!(crate::functions::lazy::cov, 2))?;
+    class.define_singleton_method(
+        "arg_sort_by",
+        function!(crate::functions::lazy::arg_sort_by, 2),
+    )?;
+    class.define_singleton_method("when", function!(crate::functions::whenthen::when, 1))?;
+    class.define_singleton_method(
+        "concat_str",
+        function!(crate::functions::lazy::concat_str, 2),
+    )?;
+    class.define_singleton_method(
+        "concat_lst",
+        function!(crate::functions::lazy::concat_lst, 1),
     )?;
-    class.define_singleton_method("cov", function!(crate::lazy::dsl::cov, 2))?;
-    class.define_singleton_method("arg_sort_by", function!(crate::lazy::dsl::arg_sort_by, 2))?;
-    class.define_singleton_method("when", function!(crate::lazy::dsl::when, 1))?;
-    class.define_singleton_method("concat_str", function!(crate::lazy::dsl::concat_str, 2))?;
-    class.define_singleton_method("concat_lst", function!(crate::lazy::dsl::concat_lst, 1))?;
 
     let class = module.define_class("RbLazyFrame", Default::default())?;
     class.define_singleton_method("read_json", function!(RbLazyFrame::read_json, 1))?;
@@ -512,8 +593,8 @@ fn init() -> RbResult<()> {
         "optimization_toggle",
         method!(RbLazyFrame::optimization_toggle, 7),
     )?;
-    class.define_method("sort", method!(RbLazyFrame::sort, 3))?;
-    class.define_method("sort_by_exprs", method!(RbLazyFrame::sort_by_exprs, 3))?;
+    class.define_method("sort", method!(RbLazyFrame::sort, 4))?;
+    class.define_method("sort_by_exprs", method!(RbLazyFrame::sort_by_exprs, 4))?;
     class.define_method("cache", method!(RbLazyFrame::cache, 0))?;
     class.define_method("collect", method!(RbLazyFrame::collect, 0))?;
     class.define_method("sink_parquet", method!(RbLazyFrame::sink_parquet, 7))?;
@@ -521,7 +602,7 @@ fn init() -> RbResult<()> {
     class.define_method("filter", method!(RbLazyFrame::filter, 1))?;
     class.define_method("select", method!(RbLazyFrame::select, 1))?;
     class.define_method("groupby", method!(RbLazyFrame::groupby, 2))?;
-    class.define_method("groupby_rolling", method!(RbLazyFrame::groupby_rolling, 5))?;
+    class.define_method("groupby_rolling", method!(RbLazyFrame::groupby_rolling, 6))?;
     class.define_method("groupby_dynamic", method!(RbLazyFrame::groupby_dynamic, 9))?;
     class.define_method("with_context", method!(RbLazyFrame::with_context, 1))?;
     class.define_method("join_asof", method!(RbLazyFrame::join_asof, 11))?;
@@ -572,16 +653,30 @@ fn init() -> RbResult<()> {
     class.define_singleton_method("new_opt_i64", function!(RbSeries::new_opt_i64, 3))?;
     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),
+    )?;
     class.define_singleton_method("new_str", function!(RbSeries::new_str, 3))?;
     class.define_singleton_method("new_binary", function!(RbSeries::new_binary, 3))?;
+    class.define_singleton_method("new_null", function!(RbSeries::new_null, 3))?;
     class.define_singleton_method("new_object", function!(RbSeries::new_object, 3))?;
-    class.define_singleton_method("new_list", function!(RbSeries::new_list, 3))?;
-    class.define_singleton_method("new_opt_date", function!(RbSeries::new_opt_date, 3))?;
-    class.define_singleton_method("new_opt_datetime", function!(RbSeries::new_opt_datetime, 3))?;
-    class.define_method("is_sorted_flag", method!(RbSeries::is_sorted_flag, 0))?;
+    class.define_singleton_method("new_series_list", function!(RbSeries::new_series_list, 3))?;
+    class.define_singleton_method("new_array", function!(RbSeries::new_array, 5))?;
+    class.define_singleton_method("new_decimal", function!(RbSeries::new_decimal, 3))?;
+    class.define_singleton_method("repeat", function!(RbSeries::repeat, 4))?;
+    class.define_method("struct_unnest", method!(RbSeries::struct_unnest, 0))?;
+    class.define_method(
+        "is_sorted_flag",
+        method!(RbSeries::is_sorted_ascending_flag, 0),
+    )?;
     class.define_method(
         "is_sorted_reverse_flag",
-        method!(RbSeries::is_sorted_reverse_flag, 0),
+        method!(RbSeries::is_sorted_descending_flag, 0),
+    )?;
+    class.define_method(
+        "can_fast_explode_flag",
+        method!(RbSeries::can_fast_explode_flag, 0),
     )?;
     class.define_method("estimated_size", method!(RbSeries::estimated_size, 0))?;
     class.define_method("get_fmt", method!(RbSeries::get_fmt, 2))?;
@@ -595,7 +690,7 @@ fn init() -> RbResult<()> {
     class.define_method("rename", method!(RbSeries::rename, 1))?;
     class.define_method("dtype", method!(RbSeries::dtype, 0))?;
     class.define_method("inner_dtype", method!(RbSeries::inner_dtype, 0))?;
-    class.define_method("set_sorted", method!(RbSeries::set_sorted, 1))?;
+    class.define_method("set_sorted", method!(RbSeries::set_sorted_flag, 1))?;
     class.define_method("mean", method!(RbSeries::mean, 0))?;
     class.define_method("max", method!(RbSeries::max, 0))?;
     class.define_method("min", method!(RbSeries::min, 0))?;
@@ -635,7 +730,7 @@ fn init() -> RbResult<()> {
     class.define_method("_clone", method!(RbSeries::clone, 0))?;
     class.define_method("apply_lambda", method!(RbSeries::apply_lambda, 3))?;
     class.define_method("zip_with", method!(RbSeries::zip_with, 2))?;
-    class.define_method("to_dummies", method!(RbSeries::to_dummies, 1))?;
+    class.define_method("to_dummies", method!(RbSeries::to_dummies, 2))?;
     class.define_method("peak_max", method!(RbSeries::peak_max, 0))?;
     class.define_method("peak_min", method!(RbSeries::peak_min, 0))?;
     class.define_method("n_unique", method!(RbSeries::n_unique, 0))?;
@@ -732,7 +827,6 @@ fn init() -> RbResult<()> {
     class.define_method("eq_i64", method!(RbSeries::eq_i64, 1))?;
     class.define_method("eq_f32", method!(RbSeries::eq_f32, 1))?;
     class.define_method("eq_f64", method!(RbSeries::eq_f64, 1))?;
-    // class.define_method("eq_str", method!(RbSeries::eq_str, 1))?;
 
     // neq
     class.define_method("neq_u8", method!(RbSeries::neq_u8, 1))?;
@@ -745,7 +839,6 @@ fn init() -> RbResult<()> {
     class.define_method("neq_i64", method!(RbSeries::neq_i64, 1))?;
     class.define_method("neq_f32", method!(RbSeries::neq_f32, 1))?;
     class.define_method("neq_f64", method!(RbSeries::neq_f64, 1))?;
-    // class.define_method("neq_str", method!(RbSeries::neq_str, 1))?;
 
     // gt
     class.define_method("gt_u8", method!(RbSeries::gt_u8, 1))?;
@@ -758,7 +851,6 @@ fn init() -> RbResult<()> {
     class.define_method("gt_i64", method!(RbSeries::gt_i64, 1))?;
     class.define_method("gt_f32", method!(RbSeries::gt_f32, 1))?;
     class.define_method("gt_f64", method!(RbSeries::gt_f64, 1))?;
-    // class.define_method("gt_str", method!(RbSeries::gt_str, 1))?;
 
     // gt_eq
     class.define_method("gt_eq_u8", method!(RbSeries::gt_eq_u8, 1))?;
@@ -771,7 +863,6 @@ fn init() -> RbResult<()> {
     class.define_method("gt_eq_i64", method!(RbSeries::gt_eq_i64, 1))?;
     class.define_method("gt_eq_f32", method!(RbSeries::gt_eq_f32, 1))?;
     class.define_method("gt_eq_f64", method!(RbSeries::gt_eq_f64, 1))?;
-    // class.define_method("gt_eq_str", method!(RbSeries::gt_eq_str, 1))?;
 
     // lt
     class.define_method("lt_u8", method!(RbSeries::lt_u8, 1))?;
@@ -784,7 +875,6 @@ fn init() -> RbResult<()> {
     class.define_method("lt_i64", method!(RbSeries::lt_i64, 1))?;
     class.define_method("lt_f32", method!(RbSeries::lt_f32, 1))?;
     class.define_method("lt_f64", method!(RbSeries::lt_f64, 1))?;
-    // class.define_method("lt_str", method!(RbSeries::lt_str, 1))?;
 
     // lt_eq
     class.define_method("lt_eq_u8", method!(RbSeries::lt_eq_u8, 1))?;
@@ -797,11 +887,21 @@ fn init() -> RbResult<()> {
     class.define_method("lt_eq_i64", method!(RbSeries::lt_eq_i64, 1))?;
     class.define_method("lt_eq_f32", method!(RbSeries::lt_eq_f32, 1))?;
     class.define_method("lt_eq_f64", method!(RbSeries::lt_eq_f64, 1))?;
-    // class.define_method("lt_eq_str", method!(RbSeries::lt_eq_str, 1))?;
+
+    // str comp
+    class.define_method("eq_str", method!(RbSeries::eq_str, 1))?;
+    class.define_method("neq_str", method!(RbSeries::neq_str, 1))?;
+    class.define_method("gt_str", method!(RbSeries::gt_str, 1))?;
+    class.define_method("gt_eq_str", method!(RbSeries::gt_eq_str, 1))?;
+    class.define_method("lt_str", method!(RbSeries::lt_str, 1))?;
+    class.define_method("lt_eq_str", method!(RbSeries::lt_eq_str, 1))?;
 
     // npy
     class.define_method("to_numo", method!(RbSeries::to_numo, 0))?;
 
+    // extra
+    class.define_method("extend_constant", method!(RbSeries::extend_constant, 2))?;
+
     let class = module.define_class("RbWhen", Default::default())?;
     class.define_method("_then", method!(RbWhen::then, 1))?;
 
@@ -810,196 +910,3 @@ fn init() -> RbResult<()> {
 
     Ok(())
 }
-
-fn dtype_cols(dtypes: RArray) -> RbResult<RbExpr> {
-    let dtypes = dtypes
-        .each()
-        .map(|v| v?.try_convert::<Wrap<DataType>>())
-        .collect::<RbResult<Vec<Wrap<DataType>>>>()?;
-    let dtypes = vec_extract_wrapped(dtypes);
-    Ok(crate::lazy::dsl::dtype_cols(dtypes))
-}
-
-#[allow(clippy::too_many_arguments)]
-fn rb_duration(
-    days: Option<&RbExpr>,
-    seconds: Option<&RbExpr>,
-    nanoseconds: Option<&RbExpr>,
-    microseconds: Option<&RbExpr>,
-    milliseconds: Option<&RbExpr>,
-    minutes: Option<&RbExpr>,
-    hours: Option<&RbExpr>,
-    weeks: Option<&RbExpr>,
-) -> RbExpr {
-    let args = DurationArgs {
-        days: days.map(|e| e.inner.clone()),
-        seconds: seconds.map(|e| e.inner.clone()),
-        nanoseconds: nanoseconds.map(|e| e.inner.clone()),
-        microseconds: microseconds.map(|e| e.inner.clone()),
-        milliseconds: milliseconds.map(|e| e.inner.clone()),
-        minutes: minutes.map(|e| e.inner.clone()),
-        hours: hours.map(|e| e.inner.clone()),
-        weeks: weeks.map(|e| e.inner.clone()),
-    };
-
-    polars::lazy::dsl::duration(args).into()
-}
-
-fn concat_df(seq: RArray) -> RbResult<RbDataFrame> {
-    let mut iter = seq.each();
-    let first = iter.next().unwrap()?;
-
-    let first_rdf = get_df(first)?;
-    let identity_df = first_rdf.slice(0, 0);
-
-    let mut rdfs: Vec<PolarsResult<DataFrame>> = vec![Ok(first_rdf)];
-
-    for item in iter {
-        let rdf = get_df(item?)?;
-        rdfs.push(Ok(rdf));
-    }
-
-    let identity = Ok(identity_df);
-
-    let df = rdfs
-        .into_iter()
-        .fold(identity, |acc: PolarsResult<DataFrame>, df| {
-            let mut acc = acc?;
-            acc.vstack_mut(&df?)?;
-            Ok(acc)
-        })
-        .map_err(RbPolarsErr::from)?;
-
-    Ok(df.into())
-}
-
-fn concat_lf(lfs: Value, rechunk: bool, parallel: bool) -> RbResult<RbLazyFrame> {
-    let (seq, len) = get_rbseq(lfs)?;
-    let mut lfs = Vec::with_capacity(len);
-
-    for res in seq.each() {
-        let item = res?;
-        let lf = get_lf(item)?;
-        lfs.push(lf);
-    }
-
-    let lf = polars::lazy::dsl::concat(lfs, rechunk, parallel).map_err(RbPolarsErr::from)?;
-    Ok(lf.into())
-}
-
-fn rb_diag_concat_df(seq: RArray) -> RbResult<RbDataFrame> {
-    let mut dfs = Vec::new();
-    for item in seq.each() {
-        dfs.push(get_df(item?)?);
-    }
-    let df = diag_concat_df(&dfs).map_err(RbPolarsErr::from)?;
-    Ok(df.into())
-}
-
-fn rb_hor_concat_df(seq: RArray) -> RbResult<RbDataFrame> {
-    let mut dfs = Vec::new();
-    for item in seq.each() {
-        dfs.push(get_df(item?)?);
-    }
-    let df = hor_concat_df(&dfs).map_err(RbPolarsErr::from)?;
-    Ok(df.into())
-}
-
-fn concat_series(seq: RArray) -> RbResult<RbSeries> {
-    let mut iter = seq.each();
-    let first = iter.next().unwrap()?;
-
-    let mut s = get_series(first)?;
-
-    for res in iter {
-        let item = res?;
-        let item = get_series(item)?;
-        s.append(&item).map_err(RbPolarsErr::from)?;
-    }
-    Ok(s.into())
-}
-
-fn ipc_schema(rb_f: Value) -> RbResult<Value> {
-    use polars::export::arrow::io::ipc::read::read_file_metadata;
-    let mut r = get_file_like(rb_f, false)?;
-    let metadata = read_file_metadata(&mut r).map_err(RbPolarsErr::arrow)?;
-
-    let dict = RHash::new();
-    for field in metadata.schema.fields {
-        let dt: Wrap<DataType> = Wrap((&field.data_type).into());
-        dict.aset(field.name, dt)?;
-    }
-    Ok(dict.into())
-}
-
-fn parquet_schema(rb_f: Value) -> RbResult<Value> {
-    use polars::export::arrow::io::parquet::read::{infer_schema, read_metadata};
-
-    let mut r = get_file_like(rb_f, false)?;
-    let metadata = read_metadata(&mut r).map_err(RbPolarsErr::arrow)?;
-    let arrow_schema = infer_schema(&metadata).map_err(RbPolarsErr::arrow)?;
-
-    let dict = RHash::new();
-    for field in arrow_schema.fields {
-        let dt: Wrap<DataType> = Wrap((&field.data_type).into());
-        dict.aset(field.name, dt)?;
-    }
-    Ok(dict.into())
-}
-
-fn collect_all(lfs: RArray) -> RbResult<RArray> {
-    let lfs = lfs
-        .each()
-        .map(|v| v?.try_convert::<&RbLazyFrame>())
-        .collect::<RbResult<Vec<&RbLazyFrame>>>()?;
-
-    Ok(RArray::from_iter(lfs.iter().map(|lf| {
-        let df = lf.ldf.clone().collect().unwrap();
-        RbDataFrame::new(df)
-    })))
-}
-
-fn rb_date_range(
-    start: i64,
-    stop: i64,
-    every: String,
-    closed: Wrap<ClosedWindow>,
-    name: String,
-    tu: Wrap<TimeUnit>,
-    tz: Option<TimeZone>,
-) -> RbResult<RbSeries> {
-    let date_range = polars::time::date_range_impl(
-        &name,
-        start,
-        stop,
-        Duration::parse(&every),
-        closed.0,
-        tu.0,
-        tz.as_ref(),
-    )
-    .map_err(RbPolarsErr::from)?;
-    Ok(date_range.into_series().into())
-}
-
-fn coalesce_exprs(exprs: RArray) -> RbResult<RbExpr> {
-    let exprs = rb_exprs_to_exprs(exprs)?;
-    Ok(polars::lazy::dsl::coalesce(&exprs).into())
-}
-
-fn sum_exprs(exprs: RArray) -> RbResult<RbExpr> {
-    let exprs = rb_exprs_to_exprs(exprs)?;
-    Ok(polars::lazy::dsl::sum_exprs(exprs).into())
-}
-
-fn as_struct(exprs: RArray) -> RbResult<RbExpr> {
-    let exprs = rb_exprs_to_exprs(exprs)?;
-    Ok(polars::lazy::dsl::as_struct(&exprs).into())
-}
-
-fn arg_where(condition: &RbExpr) -> RbExpr {
-    polars::lazy::dsl::arg_where(condition.inner.clone()).into()
-}
-
-fn get_idx_type() -> Value {
-    Wrap(IDX_DTYPE).into_value()
-}