polars-df 0.1.1 → 0.1.3

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

@@ -1,4 +1,4 @@
-use magnus::{RArray, RString, Value};
+use magnus::{class, RArray, RString, Value};
 use polars::chunked_array::ops::SortOptions;
 use polars::lazy::dsl;
 use polars::lazy::dsl::Operator;
@@ -6,8 +6,10 @@ use polars::prelude::*;
 use polars::series::ops::NullBehavior;
 
 use crate::conversion::*;
+use crate::lazy::apply::*;
 use crate::lazy::utils::rb_exprs_to_exprs;
-use crate::RbResult;
+use crate::utils::reinterpret;
+use crate::{RbResult, RbSeries};
 
 #[magnus::wrap(class = "Polars::RbExpr")]
 #[derive(Clone)]
@@ -885,6 +887,19 @@ impl RbExpr {
         self.inner.clone().dt().round(&every, &offset).into()
     }
 
+    pub fn reinterpret(&self, signed: bool) -> Self {
+        let function = move |s: Series| reinterpret(&s, signed);
+        let dt = if signed {
+            DataType::Int64
+        } else {
+            DataType::UInt64
+        };
+        self.clone()
+            .inner
+            .map(function, GetOutput::from_type(dt))
+            .into()
+    }
+
     pub fn mode(&self) -> Self {
         self.inner.clone().mode().into()
     }
@@ -901,6 +916,10 @@ impl RbExpr {
         self.inner.clone().suffix(&suffix).into()
     }
 
+    pub fn exclude(&self, columns: Vec<String>) -> Self {
+        self.inner.clone().exclude(columns).into()
+    }
+
     pub fn interpolate(&self) -> Self {
         self.inner.clone().interpolate().into()
     }
@@ -1300,6 +1319,21 @@ impl RbExpr {
         self.inner.clone().ewm_var(options).into()
     }
 
+    pub fn extend_constant(&self, value: Wrap<AnyValue>, n: usize) -> Self {
+        let value = Value::from(value);
+        self.inner
+            .clone()
+            .apply(
+                move |s| {
+                    let value = value.try_convert::<Wrap<AnyValue>>().unwrap().0;
+                    s.extend_constant(value, n)
+                },
+                GetOutput::same_type(),
+            )
+            .with_fmt("extend")
+            .into()
+    }
+
     pub fn any(&self) -> Self {
         self.inner.clone().any().into()
     }
@@ -1327,18 +1361,61 @@ impl RbExpr {
     pub fn exp(&self) -> Self {
         self.inner.clone().exp().into()
     }
+
+    pub fn entropy(&self, base: f64, normalize: bool) -> Self {
+        self.inner.clone().entropy(base, normalize).into()
+    }
 }
 
 pub fn col(name: String) -> RbExpr {
     dsl::col(&name).into()
 }
 
+pub fn count() -> RbExpr {
+    dsl::count().into()
+}
+
+pub fn first() -> RbExpr {
+    dsl::first().into()
+}
+
+pub fn last() -> RbExpr {
+    dsl::last().into()
+}
+
+pub fn cols(names: Vec<String>) -> RbExpr {
+    dsl::cols(names).into()
+}
+
+pub fn fold(acc: &RbExpr, lambda: Value, exprs: RArray) -> RbResult<RbExpr> {
+    let exprs = rb_exprs_to_exprs(exprs)?;
+
+    let func = move |a: Series, b: Series| binary_lambda(lambda, a, b);
+    Ok(polars::lazy::dsl::fold_exprs(acc.inner.clone(), func, exprs).into())
+}
+
 // TODO improve
 pub fn lit(value: Value) -> RbResult<RbExpr> {
     if value.is_nil() {
         Ok(dsl::lit(Null {}).into())
+    } else if let Ok(series) = value.try_convert::<&RbSeries>() {
+        Ok(dsl::lit(series.series.borrow().clone()).into())
     } else if let Some(v) = RString::from_value(value) {
         Ok(dsl::lit(v.try_convert::<String>()?).into())
+    } else if value.is_kind_of(class::integer()) {
+        match value.try_convert::<i64>() {
+            Ok(val) => {
+                if val > 0 && val < i32::MAX as i64 || val < 0 && val > i32::MIN as i64 {
+                    Ok(dsl::lit(val as i32).into())
+                } else {
+                    Ok(dsl::lit(val).into())
+                }
+            }
+            _ => {
+                let val = value.try_convert::<u64>()?;
+                Ok(dsl::lit(val).into())
+            }
+        }
     } else {
         Ok(dsl::lit(value.try_convert::<f64>()?).into())
     }
@@ -1348,6 +1425,14 @@ pub fn arange(low: &RbExpr, high: &RbExpr, step: usize) -> RbExpr {
     polars::lazy::dsl::arange(low.inner.clone(), high.inner.clone(), step).into()
 }
 
+pub fn repeat(value: Value, n_times: &RbExpr) -> RbResult<RbExpr> {
+    if value.is_nil() {
+        Ok(polars::lazy::dsl::repeat(Null {}, n_times.inner.clone()).into())
+    } else {
+        todo!();
+    }
+}
+
 #[magnus::wrap(class = "Polars::RbWhen")]
 #[derive(Clone)]
 pub struct RbWhen {
@@ -1387,3 +1472,13 @@ impl RbWhenThen {
 pub fn when(predicate: &RbExpr) -> RbWhen {
     dsl::when(predicate.inner.clone()).into()
 }
+
+pub fn concat_str(s: RArray, sep: String) -> RbResult<RbExpr> {
+    let s = rb_exprs_to_exprs(s)?;
+    Ok(dsl::concat_str(s, &sep).into())
+}
+
+pub fn concat_lst(s: RArray) -> RbResult<RbExpr> {
+    let s = rb_exprs_to_exprs(s)?;
+    Ok(dsl::concat_lst(s).into())
+}

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

@@ -7,7 +7,7 @@ impl RbExpr {
             .meta()
             .pop()
             .into_iter()
-            .map(|v| RbExpr::from(v))
+            .map(RbExpr::from)
             .collect()
     }
 

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

@@ -1,3 +1,4 @@
+pub mod apply;
 pub mod dataframe;
 pub mod dsl;
 pub mod meta;

data/ext/polars/src/lib.rs

@@ -1,21 +1,30 @@
+mod batched_csv;
 mod conversion;
 mod dataframe;
 mod error;
 mod file;
 mod lazy;
 mod series;
+mod set;
+mod utils;
 
-use conversion::get_df;
+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, memoize, method, prelude::*, Error, RArray, RClass, RModule,
+    define_module, function, memoize, method, prelude::*, Error, RArray, RClass, RHash, RModule,
+    Value,
 };
+use polars::datatypes::{DataType, TimeUnit};
 use polars::error::PolarsResult;
 use polars::frame::DataFrame;
 use polars::functions::{diag_concat_df, hor_concat_df};
+use polars::prelude::{ClosedWindow, Duration, IntoSeries, TimeZone};
 use series::RbSeries;
 
 type RbResult<T> = Result<T, Error>;
@@ -34,11 +43,22 @@ fn init() -> RbResult<()> {
     module.define_singleton_method("_concat_df", function!(concat_df, 1))?;
     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("_rb_date_range", function!(rb_date_range, 7))?;
+    module.define_singleton_method("_as_struct", function!(as_struct, 1))?;
+    module.define_singleton_method("_arg_where", function!(arg_where, 1))?;
+
+    let class = module.define_class("RbBatchedCsv", Default::default())?;
+    class.define_singleton_method("new", function!(RbBatchedCsv::new, -1))?;
+    class.define_method("next_batches", method!(RbBatchedCsv::next_batches, 1))?;
 
     let class = module.define_class("RbDataFrame", Default::default())?;
     class.define_singleton_method("new", function!(RbDataFrame::init, 1))?;
-    class.define_singleton_method("read_csv", function!(RbDataFrame::read_csv, 2))?;
-    class.define_singleton_method("read_parquet", function!(RbDataFrame::read_parquet, 1))?;
+    class.define_singleton_method("read_csv", function!(RbDataFrame::read_csv, -1))?;
+    class.define_singleton_method("read_parquet", function!(RbDataFrame::read_parquet, 7))?;
+    class.define_singleton_method("read_ipc", function!(RbDataFrame::read_ipc, 6))?;
     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))?;
@@ -46,7 +66,22 @@ fn init() -> RbResult<()> {
     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("row_tuple", method!(RbDataFrame::row_tuple, 1))?;
+    class.define_method("row_tuples", method!(RbDataFrame::row_tuples, 0))?;
     class.define_method("write_parquet", method!(RbDataFrame::write_parquet, 5))?;
+    class.define_method("add", method!(RbDataFrame::add, 1))?;
+    class.define_method("sub", method!(RbDataFrame::sub, 1))?;
+    class.define_method("div", method!(RbDataFrame::div, 1))?;
+    class.define_method("mul", method!(RbDataFrame::mul, 1))?;
+    class.define_method("rem", method!(RbDataFrame::rem, 1))?;
+    class.define_method("add_df", method!(RbDataFrame::add_df, 1))?;
+    class.define_method("sub_df", method!(RbDataFrame::sub_df, 1))?;
+    class.define_method("div_df", method!(RbDataFrame::div_df, 1))?;
+    class.define_method("mul_df", method!(RbDataFrame::mul_df, 1))?;
+    class.define_method("rem_df", method!(RbDataFrame::rem_df, 1))?;
+    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("get_columns", method!(RbDataFrame::get_columns, 0))?;
@@ -60,7 +95,19 @@ fn init() -> RbResult<()> {
     class.define_method("shape", method!(RbDataFrame::shape, 0))?;
     class.define_method("height", method!(RbDataFrame::height, 0))?;
     class.define_method("width", method!(RbDataFrame::width, 0))?;
+    class.define_method("hstack_mut", method!(RbDataFrame::hstack_mut, 1))?;
+    class.define_method("hstack", method!(RbDataFrame::hstack, 1))?;
+    class.define_method("extend", method!(RbDataFrame::extend, 1))?;
+    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(
+        "find_idx_by_name",
+        method!(RbDataFrame::find_idx_by_name, 1),
+    )?;
     class.define_method("column", method!(RbDataFrame::column, 1))?;
     class.define_method("select", method!(RbDataFrame::select, 1))?;
     class.define_method("take", method!(RbDataFrame::take, 1))?;
@@ -102,6 +149,7 @@ fn init() -> RbResult<()> {
     class.define_method("shrink_to_fit", method!(RbDataFrame::shrink_to_fit, 0))?;
     class.define_method("transpose", method!(RbDataFrame::transpose, 2))?;
     class.define_method("upsample", method!(RbDataFrame::upsample, 5))?;
+    class.define_method("to_struct", method!(RbDataFrame::to_struct, 1))?;
     class.define_method("unnest", method!(RbDataFrame::unnest, 1))?;
 
     let class = module.define_class("RbExpr", Default::default())?;
@@ -290,10 +338,12 @@ fn init() -> RbResult<()> {
     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_round", method!(RbExpr::dt_round, 2))?;
+    class.define_method("reinterpret", method!(RbExpr::reinterpret, 1))?;
     class.define_method("mode", method!(RbExpr::mode, 0))?;
     class.define_method("keep_name", method!(RbExpr::keep_name, 0))?;
     class.define_method("prefix", method!(RbExpr::prefix, 1))?;
     class.define_method("suffix", method!(RbExpr::suffix, 1))?;
+    class.define_method("exclude", method!(RbExpr::exclude, 1))?;
     class.define_method("interpolate", method!(RbExpr::interpolate, 0))?;
     class.define_method("rolling_sum", method!(RbExpr::rolling_sum, 6))?;
     class.define_method("rolling_min", method!(RbExpr::rolling_min, 6))?;
@@ -338,6 +388,7 @@ fn init() -> RbResult<()> {
     class.define_method("ewm_mean", method!(RbExpr::ewm_mean, 3))?;
     class.define_method("ewm_std", method!(RbExpr::ewm_std, 4))?;
     class.define_method("ewm_var", method!(RbExpr::ewm_var, 4))?;
+    class.define_method("extend_constant", method!(RbExpr::extend_constant, 2))?;
     class.define_method("any", method!(RbExpr::any, 0))?;
     class.define_method("all", method!(RbExpr::all, 0))?;
     class.define_method(
@@ -354,6 +405,7 @@ fn init() -> RbResult<()> {
     )?;
     class.define_method("log", method!(RbExpr::log, 1))?;
     class.define_method("exp", method!(RbExpr::exp, 0))?;
+    class.define_method("entropy", method!(RbExpr::entropy, 2))?;
 
     // meta
     class.define_method("meta_pop", method!(RbExpr::meta_pop, 0))?;
@@ -364,11 +416,29 @@ fn init() -> RbResult<()> {
 
     // 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("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("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(
+        "new_from_ndjson",
+        function!(RbLazyFrame::new_from_ndjson, 7),
+    )?;
+    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, 7),
+    )?;
+    class.define_singleton_method("new_from_ipc", function!(RbLazyFrame::new_from_ipc, 6))?;
     class.define_method("write_json", method!(RbLazyFrame::write_json, 1))?;
     class.define_method("describe_plan", method!(RbLazyFrame::describe_plan, 0))?;
     class.define_method(
@@ -437,6 +507,7 @@ fn init() -> 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_str", function!(RbSeries::new_str, 3))?;
+    class.define_singleton_method("new_opt_date", function!(RbSeries::new_opt_date, 3))?;
     class.define_method("is_sorted_flag", method!(RbSeries::is_sorted_flag, 0))?;
     class.define_method(
         "is_sorted_reverse_flag",
@@ -504,14 +575,85 @@ fn init() -> RbResult<()> {
     class.define_method("kurtosis", method!(RbSeries::kurtosis, 2))?;
     class.define_method("cast", method!(RbSeries::cast, 2))?;
     class.define_method("time_unit", method!(RbSeries::time_unit, 0))?;
-    // rest
-    class.define_method("cumsum", method!(RbSeries::cumsum, 1))?;
-    class.define_method("cummax", method!(RbSeries::cummax, 1))?;
-    class.define_method("cummin", method!(RbSeries::cummin, 1))?;
-    class.define_method("cumprod", method!(RbSeries::cumprod, 1))?;
-    class.define_method("slice", method!(RbSeries::slice, 2))?;
-    class.define_method("ceil", method!(RbSeries::ceil, 0))?;
-    class.define_method("round", method!(RbSeries::round, 1))?;
+    class.define_method("set_at_idx", method!(RbSeries::set_at_idx, 2))?;
+
+    // eq
+    class.define_method("eq_u8", method!(RbSeries::eq_u8, 1))?;
+    class.define_method("eq_u16", method!(RbSeries::eq_u16, 1))?;
+    class.define_method("eq_u32", method!(RbSeries::eq_u32, 1))?;
+    class.define_method("eq_u64", method!(RbSeries::eq_u64, 1))?;
+    class.define_method("eq_i8", method!(RbSeries::eq_i8, 1))?;
+    class.define_method("eq_i16", method!(RbSeries::eq_i16, 1))?;
+    class.define_method("eq_i32", method!(RbSeries::eq_i32, 1))?;
+    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))?;
+    class.define_method("neq_u16", method!(RbSeries::neq_u16, 1))?;
+    class.define_method("neq_u32", method!(RbSeries::neq_u32, 1))?;
+    class.define_method("neq_u64", method!(RbSeries::neq_u64, 1))?;
+    class.define_method("neq_i8", method!(RbSeries::neq_i8, 1))?;
+    class.define_method("neq_i16", method!(RbSeries::neq_i16, 1))?;
+    class.define_method("neq_i32", method!(RbSeries::neq_i32, 1))?;
+    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))?;
+    class.define_method("gt_u16", method!(RbSeries::gt_u16, 1))?;
+    class.define_method("gt_u32", method!(RbSeries::gt_u32, 1))?;
+    class.define_method("gt_u64", method!(RbSeries::gt_u64, 1))?;
+    class.define_method("gt_i8", method!(RbSeries::gt_i8, 1))?;
+    class.define_method("gt_i16", method!(RbSeries::gt_i16, 1))?;
+    class.define_method("gt_i32", method!(RbSeries::gt_i32, 1))?;
+    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))?;
+    class.define_method("gt_eq_u16", method!(RbSeries::gt_eq_u16, 1))?;
+    class.define_method("gt_eq_u32", method!(RbSeries::gt_eq_u32, 1))?;
+    class.define_method("gt_eq_u64", method!(RbSeries::gt_eq_u64, 1))?;
+    class.define_method("gt_eq_i8", method!(RbSeries::gt_eq_i8, 1))?;
+    class.define_method("gt_eq_i16", method!(RbSeries::gt_eq_i16, 1))?;
+    class.define_method("gt_eq_i32", method!(RbSeries::gt_eq_i32, 1))?;
+    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))?;
+    class.define_method("lt_u16", method!(RbSeries::lt_u16, 1))?;
+    class.define_method("lt_u32", method!(RbSeries::lt_u32, 1))?;
+    class.define_method("lt_u64", method!(RbSeries::lt_u64, 1))?;
+    class.define_method("lt_i8", method!(RbSeries::lt_i8, 1))?;
+    class.define_method("lt_i16", method!(RbSeries::lt_i16, 1))?;
+    class.define_method("lt_i32", method!(RbSeries::lt_i32, 1))?;
+    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))?;
+    class.define_method("lt_eq_u16", method!(RbSeries::lt_eq_u16, 1))?;
+    class.define_method("lt_eq_u32", method!(RbSeries::lt_eq_u32, 1))?;
+    class.define_method("lt_eq_u64", method!(RbSeries::lt_eq_u64, 1))?;
+    class.define_method("lt_eq_i8", method!(RbSeries::lt_eq_i8, 1))?;
+    class.define_method("lt_eq_i16", method!(RbSeries::lt_eq_i16, 1))?;
+    class.define_method("lt_eq_i32", method!(RbSeries::lt_eq_i32, 1))?;
+    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))?;
 
     let class = module.define_class("RbWhen", Default::default())?;
     class.define_method("_then", method!(RbWhen::then, 1))?;
@@ -567,3 +709,76 @@ fn rb_hor_concat_df(seq: RArray) -> RbResult<RbDataFrame> {
     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 rb_date_range(
+    start: i64,
+    stop: i64,
+    every: String,
+    closed: Wrap<ClosedWindow>,
+    name: String,
+    tu: Wrap<TimeUnit>,
+    tz: Option<TimeZone>,
+) -> RbSeries {
+    polars::time::date_range_impl(
+        &name,
+        start,
+        stop,
+        Duration::parse(&every),
+        closed.0,
+        tu.0,
+        tz,
+    )
+    .into_series()
+    .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()
+}