polars-df 0.23.0 → 0.24.0

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

@@ -1,251 +1,130 @@
-use crate::error::RbPolarsErr;
+use magnus::Ruby;
+
 use crate::prelude::*;
+use crate::utils::EnterPolarsExt;
 use crate::{RbResult, RbSeries};
 
 impl RbSeries {
-    pub fn eq(&self, rhs: &RbSeries) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .equal(&*rhs.series.borrow())
-            .map_err(RbPolarsErr::from)?;
-        Ok(Self::new(s.into_series()))
+    pub fn eq(rb: &Ruby, self_: &Self, rhs: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| self_.series.read().equal(&*rhs.series.read()))
     }
 
-    pub fn neq(&self, rhs: &RbSeries) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .not_equal(&*rhs.series.borrow())
-            .map_err(RbPolarsErr::from)?;
-        Ok(Self::new(s.into_series()))
+    pub fn neq(rb: &Ruby, self_: &Self, rhs: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| self_.series.read().not_equal(&*rhs.series.read()))
     }
 
-    pub fn gt(&self, rhs: &RbSeries) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .gt(&*rhs.series.borrow())
-            .map_err(RbPolarsErr::from)?;
-        Ok(Self::new(s.into_series()))
+    pub fn gt(rb: &Ruby, self_: &Self, rhs: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| self_.series.read().gt(&*rhs.series.read()))
     }
 
-    pub fn gt_eq(&self, rhs: &RbSeries) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .gt_eq(&*rhs.series.borrow())
-            .map_err(RbPolarsErr::from)?;
-        Ok(Self::new(s.into_series()))
+    pub fn gt_eq(rb: &Ruby, self_: &Self, rhs: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| self_.series.read().gt_eq(&*rhs.series.read()))
     }
 
-    pub fn lt(&self, rhs: &RbSeries) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .lt(&*rhs.series.borrow())
-            .map_err(RbPolarsErr::from)?;
-        Ok(Self::new(s.into_series()))
+    pub fn lt(rb: &Ruby, self_: &Self, rhs: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| self_.series.read().lt(&*rhs.series.read()))
     }
 
-    pub fn lt_eq(&self, rhs: &RbSeries) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .lt_eq(&*rhs.series.borrow())
-            .map_err(RbPolarsErr::from)?;
-        Ok(Self::new(s.into_series()))
+    pub fn lt_eq(rb: &Ruby, self_: &Self, rhs: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| self_.series.read().lt_eq(&*rhs.series.read()))
     }
 }
 
-macro_rules! impl_eq_num {
-    ($name:ident, $type:ty) => {
-        impl RbSeries {
-            pub fn $name(&self, rhs: $type) -> RbResult<Self> {
-                let s = self.series.borrow().equal(rhs).map_err(RbPolarsErr::from)?;
-                Ok(RbSeries::new(s.into_series()))
-            }
-        }
-    };
-}
-
-impl_eq_num!(eq_u8, u8);
-impl_eq_num!(eq_u16, u16);
-impl_eq_num!(eq_u32, u32);
-impl_eq_num!(eq_u64, u64);
-impl_eq_num!(eq_i8, i8);
-impl_eq_num!(eq_i16, i16);
-impl_eq_num!(eq_i32, i32);
-impl_eq_num!(eq_i64, i64);
-impl_eq_num!(eq_f32, f32);
-impl_eq_num!(eq_f64, f64);
-
-macro_rules! impl_neq_num {
-    ($name:ident, $type:ty) => {
-        impl RbSeries {
-            pub fn $name(&self, rhs: $type) -> RbResult<Self> {
-                let s = self
-                    .series
-                    .borrow()
-                    .not_equal(rhs)
-                    .map_err(RbPolarsErr::from)?;
-                Ok(RbSeries::new(s.into_series()))
-            }
-        }
-    };
-}
-
-impl_neq_num!(neq_u8, u8);
-impl_neq_num!(neq_u16, u16);
-impl_neq_num!(neq_u32, u32);
-impl_neq_num!(neq_u64, u64);
-impl_neq_num!(neq_i8, i8);
-impl_neq_num!(neq_i16, i16);
-impl_neq_num!(neq_i32, i32);
-impl_neq_num!(neq_i64, i64);
-impl_neq_num!(neq_f32, f32);
-impl_neq_num!(neq_f64, f64);
-
-macro_rules! impl_gt_num {
-    ($name:ident, $type:ty) => {
-        impl RbSeries {
-            pub fn $name(&self, rhs: $type) -> RbResult<Self> {
-                let s = self.series.borrow().gt(rhs).map_err(RbPolarsErr::from)?;
-                Ok(RbSeries::new(s.into_series()))
-            }
-        }
-    };
-}
-
-impl_gt_num!(gt_u8, u8);
-impl_gt_num!(gt_u16, u16);
-impl_gt_num!(gt_u32, u32);
-impl_gt_num!(gt_u64, u64);
-impl_gt_num!(gt_i8, i8);
-impl_gt_num!(gt_i16, i16);
-impl_gt_num!(gt_i32, i32);
-impl_gt_num!(gt_i64, i64);
-impl_gt_num!(gt_f32, f32);
-impl_gt_num!(gt_f64, f64);
-
-macro_rules! impl_gt_eq_num {
-    ($name:ident, $type:ty) => {
+macro_rules! impl_op {
+    ($op:ident, $name:ident, $type:ty) => {
         impl RbSeries {
-            pub fn $name(&self, rhs: $type) -> RbResult<Self> {
-                let s = self.series.borrow().gt_eq(rhs).map_err(RbPolarsErr::from)?;
-                Ok(RbSeries::new(s.into_series()))
+            pub fn $name(rb: &Ruby, self_: &Self, rhs: $type) -> RbResult<Self> {
+                rb.enter_polars_series(|| self_.series.read().$op(rhs))
             }
         }
     };
 }
 
-impl_gt_eq_num!(gt_eq_u8, u8);
-impl_gt_eq_num!(gt_eq_u16, u16);
-impl_gt_eq_num!(gt_eq_u32, u32);
-impl_gt_eq_num!(gt_eq_u64, u64);
-impl_gt_eq_num!(gt_eq_i8, i8);
-impl_gt_eq_num!(gt_eq_i16, i16);
-impl_gt_eq_num!(gt_eq_i32, i32);
-impl_gt_eq_num!(gt_eq_i64, i64);
-impl_gt_eq_num!(gt_eq_f32, f32);
-impl_gt_eq_num!(gt_eq_f64, f64);
-
-macro_rules! impl_lt_num {
-    ($name:ident, $type:ty) => {
+impl_op!(equal, eq_u8, u8);
+impl_op!(equal, eq_u16, u16);
+impl_op!(equal, eq_u32, u32);
+impl_op!(equal, eq_u64, u64);
+impl_op!(equal, eq_i8, i8);
+impl_op!(equal, eq_i16, i16);
+impl_op!(equal, eq_i32, i32);
+impl_op!(equal, eq_i64, i64);
+impl_op!(equal, eq_i128, i128);
+impl_op!(equal, eq_f32, f32);
+impl_op!(equal, eq_f64, f64);
+
+impl_op!(not_equal, neq_u8, u8);
+impl_op!(not_equal, neq_u16, u16);
+impl_op!(not_equal, neq_u32, u32);
+impl_op!(not_equal, neq_u64, u64);
+impl_op!(not_equal, neq_i8, i8);
+impl_op!(not_equal, neq_i16, i16);
+impl_op!(not_equal, neq_i32, i32);
+impl_op!(not_equal, neq_i64, i64);
+impl_op!(not_equal, neq_i128, i128);
+impl_op!(not_equal, neq_f32, f32);
+impl_op!(not_equal, neq_f64, f64);
+
+impl_op!(gt, gt_u8, u8);
+impl_op!(gt, gt_u16, u16);
+impl_op!(gt, gt_u32, u32);
+impl_op!(gt, gt_u64, u64);
+impl_op!(gt, gt_i8, i8);
+impl_op!(gt, gt_i16, i16);
+impl_op!(gt, gt_i32, i32);
+impl_op!(gt, gt_i64, i64);
+impl_op!(gt, gt_i128, i128);
+impl_op!(gt, gt_f32, f32);
+impl_op!(gt, gt_f64, f64);
+
+impl_op!(gt_eq, gt_eq_u8, u8);
+impl_op!(gt_eq, gt_eq_u16, u16);
+impl_op!(gt_eq, gt_eq_u32, u32);
+impl_op!(gt_eq, gt_eq_u64, u64);
+impl_op!(gt_eq, gt_eq_i8, i8);
+impl_op!(gt_eq, gt_eq_i16, i16);
+impl_op!(gt_eq, gt_eq_i32, i32);
+impl_op!(gt_eq, gt_eq_i64, i64);
+impl_op!(gt_eq, gt_eq_i128, i128);
+impl_op!(gt_eq, gt_eq_f32, f32);
+impl_op!(gt_eq, gt_eq_f64, f64);
+
+impl_op!(lt, lt_u8, u8);
+impl_op!(lt, lt_u16, u16);
+impl_op!(lt, lt_u32, u32);
+impl_op!(lt, lt_u64, u64);
+impl_op!(lt, lt_i8, i8);
+impl_op!(lt, lt_i16, i16);
+impl_op!(lt, lt_i32, i32);
+impl_op!(lt, lt_i64, i64);
+impl_op!(lt, lt_i128, i128);
+impl_op!(lt, lt_f32, f32);
+impl_op!(lt, lt_f64, f64);
+
+impl_op!(lt_eq, lt_eq_u8, u8);
+impl_op!(lt_eq, lt_eq_u16, u16);
+impl_op!(lt_eq, lt_eq_u32, u32);
+impl_op!(lt_eq, lt_eq_u64, u64);
+impl_op!(lt_eq, lt_eq_i8, i8);
+impl_op!(lt_eq, lt_eq_i16, i16);
+impl_op!(lt_eq, lt_eq_i32, i32);
+impl_op!(lt_eq, lt_eq_i64, i64);
+impl_op!(lt_eq, lt_eq_i128, i128);
+impl_op!(lt_eq, lt_eq_f32, f32);
+impl_op!(lt_eq, lt_eq_f64, f64);
+
+macro_rules! impl_str {
+    ($name:ident, $method:ident) => {
         impl RbSeries {
-            pub fn $name(&self, rhs: $type) -> RbResult<RbSeries> {
-                let s = self.series.borrow().lt(rhs).map_err(RbPolarsErr::from)?;
-                Ok(RbSeries::new(s.into_series()))
+            pub fn $name(rb: &Ruby, self_: &Self, rhs: String) -> RbResult<Self> {
+                rb.enter_polars_series(|| self_.series.read().$method(rhs.as_str()))
             }
         }
     };
 }
 
-impl_lt_num!(lt_u8, u8);
-impl_lt_num!(lt_u16, u16);
-impl_lt_num!(lt_u32, u32);
-impl_lt_num!(lt_u64, u64);
-impl_lt_num!(lt_i8, i8);
-impl_lt_num!(lt_i16, i16);
-impl_lt_num!(lt_i32, i32);
-impl_lt_num!(lt_i64, i64);
-impl_lt_num!(lt_f32, f32);
-impl_lt_num!(lt_f64, f64);
-
-macro_rules! impl_lt_eq_num {
-    ($name:ident, $type:ty) => {
-        impl RbSeries {
-            pub fn $name(&self, rhs: $type) -> RbResult<Self> {
-                let s = self.series.borrow().lt_eq(rhs).map_err(RbPolarsErr::from)?;
-                Ok(RbSeries::new(s.into_series()))
-            }
-        }
-    };
-}
-
-impl_lt_eq_num!(lt_eq_u8, u8);
-impl_lt_eq_num!(lt_eq_u16, u16);
-impl_lt_eq_num!(lt_eq_u32, u32);
-impl_lt_eq_num!(lt_eq_u64, u64);
-impl_lt_eq_num!(lt_eq_i8, i8);
-impl_lt_eq_num!(lt_eq_i16, i16);
-impl_lt_eq_num!(lt_eq_i32, i32);
-impl_lt_eq_num!(lt_eq_i64, i64);
-impl_lt_eq_num!(lt_eq_f32, f32);
-impl_lt_eq_num!(lt_eq_f64, f64);
-
-impl RbSeries {
-    pub fn eq_str(&self, rhs: String) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .equal(rhs.as_str())
-            .map_err(RbPolarsErr::from)?;
-        Ok(RbSeries::new(s.into_series()))
-    }
-
-    pub fn neq_str(&self, rhs: String) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .not_equal(rhs.as_str())
-            .map_err(RbPolarsErr::from)?;
-        Ok(RbSeries::new(s.into_series()))
-    }
-
-    pub fn gt_str(&self, rhs: String) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .gt(rhs.as_str())
-            .map_err(RbPolarsErr::from)?;
-        Ok(RbSeries::new(s.into_series()))
-    }
-
-    pub fn gt_eq_str(&self, rhs: String) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .gt_eq(rhs.as_str())
-            .map_err(RbPolarsErr::from)?;
-        Ok(RbSeries::new(s.into_series()))
-    }
-
-    pub fn lt_str(&self, rhs: String) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .lt(rhs.as_str())
-            .map_err(RbPolarsErr::from)?;
-        Ok(RbSeries::new(s.into_series()))
-    }
-
-    pub fn lt_eq_str(&self, rhs: String) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .lt_eq(rhs.as_str())
-            .map_err(RbPolarsErr::from)?;
-        Ok(RbSeries::new(s.into_series()))
-    }
-}
+impl_str!(eq_str, equal);
+impl_str!(neq_str, not_equal);
+impl_str!(gt_str, gt);
+impl_str!(gt_eq_str, gt_eq);
+impl_str!(lt_str, lt);
+impl_str!(lt_eq_str, lt_eq);

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

@@ -4,7 +4,6 @@ use polars_core::prelude::*;
 use crate::any_value::rb_object_to_any_value;
 use crate::conversion::{Wrap, slice_extract_wrapped, vec_extract_wrapped};
 use crate::prelude::ObjectValue;
-use crate::series::to_series;
 use crate::{RbPolarsErr, RbResult, RbSeries, RbTypeError, RbValueError};
 
 impl RbSeries {
@@ -190,9 +189,23 @@ impl RbSeries {
         Ok(s.into())
     }
 
-    pub fn new_series_list(name: String, val: RArray, _strict: bool) -> RbResult<Self> {
-        let series_vec = to_series(val)?;
-        Ok(Series::new(name.into(), &series_vec).into())
+    pub fn new_series_list(name: String, values: RArray, _strict: bool) -> RbResult<Self> {
+        let series: Vec<_> = values
+            .into_iter()
+            .map(|ops| {
+                Option::<&RbSeries>::try_convert(ops)
+                    .unwrap()
+                    .map(|ps| ps.clone().series.into_inner())
+            })
+            .collect();
+        if let Some(s) = series.iter().flatten().next()
+            && s.dtype().is_object()
+        {
+            return Err(RbValueError::new_err(
+                "list of objects isn't supported; try building a 'object' only series",
+            ));
+        }
+        Ok(Series::new(name.into(), series).into())
     }
 
     pub fn new_array(
@@ -224,18 +237,4 @@ impl RbSeries {
     pub fn new_decimal(name: String, values: RArray, strict: bool) -> RbResult<Self> {
         Self::new_from_any_values(name, values, strict)
     }
-
-    pub fn repeat(
-        name: String,
-        val: Wrap<AnyValue>,
-        n: usize,
-        dtype: Wrap<DataType>,
-    ) -> RbResult<Self> {
-        let av = val.0;
-        Ok(Series::new(name.into(), &[av])
-            .cast(&dtype.0)
-            .map_err(RbPolarsErr::from)?
-            .new_from_index(0, n)
-            .into())
-    }
 }

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

@@ -8,7 +8,7 @@ impl RbSeries {
     /// Convert this Series to a Ruby array.
     /// This operation copies data.
     pub fn to_a(&self) -> Value {
-        let series = &self.series.borrow();
+        let series = &self.series.read();
 
         fn to_a_recursive(series: &Series) -> Value {
             let ruby = Ruby::get().unwrap();