polars-df 0.23.0 → 0.24.0

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

@@ -12,7 +12,7 @@ fn to_series(v: Value, name: &str) -> PolarsResult<Series> {
         _ => {
             let data = ruby.ary_new();
             data.push(v).unwrap();
-            let res = pl_series().funcall::<_, _, Value>("new", (name.to_string(), data));
+            let res = pl_series(&ruby).funcall::<_, _, Value>("new", (name.to_string(), data));
 
             match res {
                 Ok(ruby_s) => ruby_s.funcall::<_, _, &RbSeries>("_s", ()).unwrap(),
@@ -26,17 +26,19 @@ fn to_series(v: Value, name: &str) -> PolarsResult<Series> {
         }
     };
     // Finally get the actual Series
-    Ok(rb_rbseries.series.borrow().clone())
+    Ok(rb_rbseries.series.read().clone())
 }
 
 pub fn binary_lambda(lambda: Value, a: Series, b: Series) -> PolarsResult<Option<Series>> {
+    let ruby = Ruby::get_with(lambda);
+
     // create a RbSeries struct/object for Ruby
     let rbseries_a = RbSeries::new(a);
     let rbseries_b = RbSeries::new(b);
 
     // Wrap this RbSeries object in the Ruby side Series wrapper
-    let ruby_series_wrapper_a: Value = pl_utils().funcall("wrap_s", (rbseries_a,)).unwrap();
-    let ruby_series_wrapper_b: Value = pl_utils().funcall("wrap_s", (rbseries_b,)).unwrap();
+    let ruby_series_wrapper_a: Value = pl_utils(&ruby).funcall("wrap_s", (rbseries_a,)).unwrap();
+    let ruby_series_wrapper_b: Value = pl_utils(&ruby).funcall("wrap_s", (rbseries_b,)).unwrap();
 
     // call the lambda and get a Ruby side Series wrapper
     let result_series_wrapper: Value =
@@ -64,7 +66,7 @@ pub fn binary_lambda(lambda: Value, a: Series, b: Series) -> PolarsResult<Option
     };
 
     // Finally get the actual Series
-    let binding = rbseries.series.borrow();
+    let binding = rbseries.series.read();
     Ok(Some(binding.clone()))
 }
 

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

@@ -2,13 +2,14 @@ pub mod dataframe;
 pub mod lazy;
 pub mod series;
 
-use magnus::{RHash, Value, prelude::*};
+use magnus::{RHash, Ruby, Value, prelude::*};
 use polars::chunked_array::builder::get_list_builder;
 use polars::prelude::*;
 use polars_core::POOL;
 use polars_core::utils::CustomIterTools;
 use rayon::prelude::*;
 
+use crate::utils::EnterPolarsExt;
 use crate::{ObjectValue, RbPolarsErr, RbResult, RbSeries, RbValueError, Wrap};
 
 pub trait RbPolarsNumericType: PolarsNumericType {}
@@ -17,10 +18,12 @@ impl RbPolarsNumericType for UInt8Type {}
 impl RbPolarsNumericType for UInt16Type {}
 impl RbPolarsNumericType for UInt32Type {}
 impl RbPolarsNumericType for UInt64Type {}
+impl RbPolarsNumericType for UInt128Type {}
 impl RbPolarsNumericType for Int8Type {}
 impl RbPolarsNumericType for Int16Type {}
 impl RbPolarsNumericType for Int32Type {}
 impl RbPolarsNumericType for Int64Type {}
+impl RbPolarsNumericType for Int128Type {}
 impl RbPolarsNumericType for Float32Type {}
 impl RbPolarsNumericType for Float64Type {}
 
@@ -41,6 +44,8 @@ fn iterator_to_struct(
     name: PlSmallStr,
     capacity: usize,
 ) -> RbResult<RbSeries> {
+    let rb = Ruby::get().unwrap();
+
     let (vals, flds) = match &first_value {
         av @ AnyValue::Struct(_, _, flds) => (av._iter_struct_av().collect::<Vec<_>>(), &**flds),
         AnyValue::StructOwned(payload) => (payload.0.clone(), &*payload.1),
@@ -97,13 +102,15 @@ fn iterator_to_struct(
         }
     }
 
-    let fields = POOL.install(|| {
-        items
-            .par_iter()
-            .zip(flds)
-            .map(|(av, fld)| Series::new(fld.name().clone(), av))
-            .collect::<Vec<_>>()
-    });
+    let fields = rb.enter_polars_ok(|| {
+        POOL.install(|| {
+            items
+                .par_iter()
+                .zip(flds)
+                .map(|(av, fld)| Series::new(fld.name().clone(), av))
+                .collect::<Vec<_>>()
+        })
+    })?;
 
     Ok(
         StructChunked::from_series(name, fields[0].len(), fields.iter())

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

@@ -34,7 +34,7 @@ fn infer_and_finish<'a, A: ApplyLambda<'a>>(
             .map(|ca| ca.into_series().into())
     } else if out.respond_to("_s", true)? {
         let rb_rbseries: &RbSeries = out.funcall("_s", ()).unwrap();
-        let series = rb_rbseries.series.borrow();
+        let series = rb_rbseries.series.read();
         let dt = series.dtype();
         applyer
             .apply_lambda_with_list_out_type(lambda, null_count, &series, dt)
@@ -153,8 +153,8 @@ where
     T: IntoValue,
 {
     let out: Value = lambda.funcall("call", (in_val,))?;
-    let py_series: Obj<RbSeries> = out.funcall("_s", ())?;
-    let tmp = py_series.series.borrow();
+    let rb_series: Obj<RbSeries> = out.funcall("_s", ())?;
+    let tmp = rb_series.series.read();
     Ok(tmp.clone())
 }
 

data/ext/polars/src/on_startup.rs

@@ -9,20 +9,24 @@ use polars_core::chunked_array::object::registry;
 use polars_core::chunked_array::object::registry::AnonymousObjectBuilder;
 use polars_core::prelude::AnyValue;
 use polars_error::PolarsWarning;
+use polars_error::signals::register_polars_keyboard_interrupt_hook;
 
 use crate::Wrap;
 use crate::prelude::ObjectValue;
 use crate::rb_modules::pl_utils;
+use crate::utils::RubyAttach;
 
 fn warning_function(msg: &str, _warning: PolarsWarning) {
-    if let Err(e) = pl_utils().funcall::<_, _, Value>("_polars_warn", (msg.to_string(),)) {
-        eprintln!("{e}")
-    }
+    Ruby::attach(|rb| {
+        if let Err(e) = pl_utils(rb).funcall::<_, _, Value>("_polars_warn", (msg.to_string(),)) {
+            eprintln!("{e}")
+        }
+    })
 }
 
 static POLARS_REGISTRY_INIT_LOCK: OnceLock<()> = OnceLock::new();
 
-pub(crate) fn register_startup_deps() {
+pub(crate) fn register_startup_deps(catch_keyboard_interrupt: bool) {
     POLARS_REGISTRY_INIT_LOCK.get_or_init(|| {
         let object_builder = Box::new(|name: PlSmallStr, capacity: usize| {
             Box::new(ObjectChunkedBuilder::<ObjectValue>::new(name, capacity))
@@ -30,13 +34,13 @@ pub(crate) fn register_startup_deps() {
         });
 
         let object_converter = Arc::new(|av: AnyValue| {
-            let object = ObjectValue {
-                inner: Wrap(av).into_value_with(&Ruby::get().unwrap()).into(),
-            };
+            let object = Ruby::attach(|rb| ObjectValue {
+                inner: Wrap(av).into_value_with(rb).into(),
+            });
             Box::new(object) as Box<dyn Any>
         });
         let rbobject_converter = Arc::new(|av: AnyValue| {
-            let object = Wrap(av).into_value_with(&Ruby::get().unwrap());
+            let object = Ruby::attach(|rb| Wrap(av).into_value_with(rb));
             Box::new(object) as Box<dyn Any>
         });
 
@@ -50,5 +54,9 @@ pub(crate) fn register_startup_deps() {
         );
         // Register warning function for `polars_warn!`.
         polars_error::set_warning_function(warning_function);
+
+        if catch_keyboard_interrupt {
+            register_polars_keyboard_interrupt_hook();
+        }
     });
 }

data/ext/polars/src/prelude.rs

@@ -1,3 +1,4 @@
 pub use polars::prelude::*;
 
 pub use crate::conversion::*;
+pub(crate) use crate::rb_modules;

data/ext/polars/src/rb_modules.rs

@@ -1,64 +1,34 @@
-use magnus::{ExceptionClass, Module, RClass, RModule, Ruby, value::Lazy};
+use magnus::{Module, RClass, RModule, Ruby, value::Lazy};
 
-static POLARS: Lazy<RModule> = Lazy::new(|ruby| ruby.class_object().const_get("Polars").unwrap());
+static POLARS: Lazy<RModule> = Lazy::new(|rb| rb.class_object().const_get("Polars").unwrap());
+static UTILS: Lazy<RModule> = Lazy::new(|rb| rb.get_inner(&POLARS).const_get("Utils").unwrap());
+static SERIES: Lazy<RClass> = Lazy::new(|rb| rb.get_inner(&POLARS).const_get("Series").unwrap());
 
-pub(crate) fn polars() -> RModule {
-    Ruby::get().unwrap().get_inner(&POLARS)
+pub(crate) fn polars(rb: &Ruby) -> RModule {
+    rb.get_inner(&POLARS)
 }
 
-static SERIES: Lazy<RClass> =
-    Lazy::new(|ruby| ruby.get_inner(&POLARS).const_get("Series").unwrap());
-
-pub(crate) fn pl_series() -> RClass {
-    Ruby::get().unwrap().get_inner(&SERIES)
+pub(crate) fn pl_utils(rb: &Ruby) -> RModule {
+    rb.get_inner(&UTILS)
 }
 
-static UTILS: Lazy<RModule> = Lazy::new(|ruby| ruby.get_inner(&POLARS).const_get("Utils").unwrap());
-
-pub(crate) fn pl_utils() -> RModule {
-    Ruby::get().unwrap().get_inner(&UTILS)
+pub(crate) fn pl_series(rb: &Ruby) -> RClass {
+    rb.get_inner(&SERIES)
 }
 
 static BIGDECIMAL: Lazy<RClass> =
-    Lazy::new(|ruby| ruby.class_object().const_get("BigDecimal").unwrap());
+    Lazy::new(|rb| rb.class_object().const_get("BigDecimal").unwrap());
+static DATE: Lazy<RClass> = Lazy::new(|rb| rb.class_object().const_get("Date").unwrap());
+static DATETIME: Lazy<RClass> = Lazy::new(|rb| rb.class_object().const_get("DateTime").unwrap());
 
-pub(crate) fn bigdecimal() -> RClass {
-    Ruby::get().unwrap().get_inner(&BIGDECIMAL)
+pub(crate) fn bigdecimal(rb: &Ruby) -> RClass {
+    rb.get_inner(&BIGDECIMAL)
 }
 
-static DATE: Lazy<RClass> = Lazy::new(|ruby| ruby.class_object().const_get("Date").unwrap());
-
-pub(crate) fn date() -> RClass {
-    Ruby::get().unwrap().get_inner(&DATE)
+pub(crate) fn date(rb: &Ruby) -> RClass {
+    rb.get_inner(&DATE)
 }
 
-static DATETIME: Lazy<RClass> =
-    Lazy::new(|ruby| ruby.class_object().const_get("DateTime").unwrap());
-
-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)
+pub(crate) fn datetime(rb: &Ruby) -> RClass {
+    rb.get_inner(&DATETIME)
 }

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

@@ -1,185 +1,124 @@
-use crate::error::RbPolarsErr;
+use DataType::*;
+use magnus::{IntoValue, Ruby, Value};
+use polars::prelude::*;
+
 use crate::prelude::*;
-use crate::utils::to_rb_err;
+use crate::utils::EnterPolarsExt;
 use crate::{RbResult, RbSeries};
-use magnus::{IntoValue, Ruby, Value};
 
-fn scalar_to_rb(scalar: RbResult<Scalar>) -> RbResult<Value> {
-    let ruby = Ruby::get().unwrap();
-    Ok(Wrap(scalar?.as_any_value()).into_value_with(&ruby))
+fn scalar_to_rb(scalar: RbResult<Scalar>, rb: &Ruby) -> RbResult<Value> {
+    Ok(Wrap(scalar?.as_any_value()).into_value_with(rb))
 }
 
 impl RbSeries {
-    pub fn any(&self, ignore_nulls: bool) -> RbResult<Option<bool>> {
-        let binding = self.series.borrow();
-        let s = binding.bool().map_err(RbPolarsErr::from)?;
-        Ok(if ignore_nulls {
-            Some(s.any())
-        } else {
-            s.any_kleene()
+    pub fn any(rb: &Ruby, self_: &Self, ignore_nulls: bool) -> RbResult<Option<bool>> {
+        rb.enter_polars(|| {
+            let s = self_.series.read();
+            let s = s.bool()?;
+            PolarsResult::Ok(if ignore_nulls {
+                Some(s.any())
+            } else {
+                s.any_kleene()
+            })
         })
     }
 
-    pub fn all(&self, ignore_nulls: bool) -> RbResult<Option<bool>> {
-        let binding = self.series.borrow();
-        let s = binding.bool().map_err(RbPolarsErr::from)?;
-        Ok(if ignore_nulls {
-            Some(s.all())
-        } else {
-            s.all_kleene()
+    pub fn all(rb: &Ruby, self_: &Self, ignore_nulls: bool) -> RbResult<Option<bool>> {
+        rb.enter_polars(|| {
+            let s = self_.series.read();
+            let s = s.bool()?;
+            PolarsResult::Ok(if ignore_nulls {
+                Some(s.all())
+            } else {
+                s.all_kleene()
+            })
         })
     }
 
-    pub fn arg_max(&self) -> Option<usize> {
-        self.series.borrow().arg_max()
+    pub fn arg_max(rb: &Ruby, self_: &Self) -> RbResult<Option<usize>> {
+        rb.enter_polars_ok(|| self_.series.read().arg_max())
     }
 
-    pub fn arg_min(&self) -> Option<usize> {
-        self.series.borrow().arg_min()
+    pub fn arg_min(rb: &Ruby, self_: &Self) -> RbResult<Option<usize>> {
+        rb.enter_polars_ok(|| self_.series.read().arg_min())
     }
 
-    pub fn max(ruby: &Ruby, rb_self: &Self) -> RbResult<Value> {
-        Ok(Wrap(
-            rb_self
-                .series
-                .borrow()
-                .max_reduce()
-                .map_err(RbPolarsErr::from)?
-                .as_any_value(),
-        )
-        .into_value_with(ruby))
+    pub fn min(rb: &Ruby, self_: &Self) -> RbResult<Value> {
+        scalar_to_rb(rb.enter_polars(|| self_.series.read().min_reduce()), rb)
     }
 
-    pub fn mean(ruby: &Ruby, rb_self: &Self) -> RbResult<Value> {
-        match rb_self.series.borrow().dtype() {
-            DataType::Boolean => Ok(Wrap(
-                rb_self
-                    .series
-                    .borrow()
-                    .cast(&DataType::UInt8)
-                    .unwrap()
-                    .mean_reduce()
-                    .map_err(to_rb_err)?
-                    .as_any_value(),
-            )
-            .into_value_with(ruby)),
+    pub fn max(rb: &Ruby, self_: &Self) -> RbResult<Value> {
+        scalar_to_rb(rb.enter_polars(|| self_.series.read().max_reduce()), rb)
+    }
+
+    pub fn mean(rb: &Ruby, self_: &Self) -> RbResult<Value> {
+        let s = self_.series.read();
+        match s.dtype() {
+            Boolean => scalar_to_rb(
+                rb.enter_polars(|| s.cast(&DataType::UInt8).unwrap().mean_reduce()),
+                rb,
+            ),
             // For non-numeric output types we require mean_reduce.
-            dt if dt.is_temporal() => Ok(Wrap(
-                rb_self
-                    .series
-                    .borrow()
-                    .mean_reduce()
-                    .map_err(to_rb_err)?
-                    .as_any_value(),
-            )
-            .into_value_with(ruby)),
-            _ => Ok(rb_self.series.borrow().mean().into_value_with(ruby)),
+            dt if dt.is_temporal() => scalar_to_rb(rb.enter_polars(|| s.mean_reduce()), rb),
+            _ => Ok(s.mean().into_value_with(rb)),
         }
     }
 
-    pub fn median(ruby: &Ruby, rb_self: &Self) -> RbResult<Value> {
-        match rb_self.series.borrow().dtype() {
-            DataType::Boolean => Ok(Wrap(
-                rb_self
-                    .series
-                    .borrow()
-                    .cast(&DataType::UInt8)
-                    .unwrap()
-                    .median_reduce()
-                    .map_err(RbPolarsErr::from)?
-                    .as_any_value(),
-            )
-            .into_value_with(ruby)),
+    pub fn median(rb: &Ruby, self_: &Self) -> RbResult<Value> {
+        let s = self_.series.read();
+        match s.dtype() {
+            Boolean => scalar_to_rb(
+                rb.enter_polars(|| s.cast(&DataType::UInt8).unwrap().median_reduce()),
+                rb,
+            ),
             // For non-numeric output types we require median_reduce.
-            dt if dt.is_temporal() => Ok(Wrap(
-                rb_self
-                    .series
-                    .borrow()
-                    .median_reduce()
-                    .map_err(RbPolarsErr::from)?
-                    .as_any_value(),
-            )
-            .into_value_with(ruby)),
-            _ => Ok(rb_self.series.borrow().median().into_value_with(ruby)),
+            dt if dt.is_temporal() => scalar_to_rb(rb.enter_polars(|| s.median_reduce()), rb),
+            _ => Ok(s.median().into_value_with(rb)),
         }
     }
 
-    pub fn min(ruby: &Ruby, rb_self: &Self) -> RbResult<Value> {
-        Ok(Wrap(
-            rb_self
-                .series
-                .borrow()
-                .min_reduce()
-                .map_err(RbPolarsErr::from)?
-                .as_any_value(),
-        )
-        .into_value_with(ruby))
-    }
-
     pub fn quantile(
-        ruby: &Ruby,
-        rb_self: &Self,
+        rb: &Ruby,
+        self_: &Self,
         quantile: f64,
         interpolation: Wrap<QuantileMethod>,
     ) -> RbResult<Value> {
-        let bind = rb_self
-            .series
-            .borrow()
-            .quantile_reduce(quantile, interpolation.0);
-        let sc = bind.map_err(RbPolarsErr::from)?;
-
-        Ok(Wrap(sc.as_any_value()).into_value_with(ruby))
-    }
-
-    pub fn sum(ruby: &Ruby, rb_self: &Self) -> RbResult<Value> {
-        Ok(Wrap(
-            rb_self
-                .series
-                .borrow()
-                .sum_reduce()
-                .map_err(RbPolarsErr::from)?
-                .as_any_value(),
+        scalar_to_rb(
+            rb.enter_polars(|| {
+                self_
+                    .series
+                    .read()
+                    .quantile_reduce(quantile, interpolation.0)
+            }),
+            rb,
         )
-        .into_value_with(ruby))
     }
 
-    pub fn first(&self) -> RbResult<Value> {
-        scalar_to_rb(Ok(self.series.borrow().first()))
+    pub fn sum(rb: &Ruby, self_: &Self) -> RbResult<Value> {
+        scalar_to_rb(rb.enter_polars(|| self_.series.read().sum_reduce()), rb)
+    }
+
+    pub fn first(rb: &Ruby, self_: &Self) -> RbResult<Value> {
+        scalar_to_rb(rb.enter_polars_ok(|| self_.series.read().first()), rb)
     }
 
-    pub fn last(&self) -> RbResult<Value> {
-        scalar_to_rb(Ok(self.series.borrow().last()))
+    pub fn last(rb: &Ruby, self_: &Self) -> RbResult<Value> {
+        scalar_to_rb(rb.enter_polars_ok(|| self_.series.read().last()), rb)
     }
 
-    pub fn approx_n_unique(&self) -> RbResult<IdxSize> {
-        Ok(self
-            .series
-            .borrow()
-            .approx_n_unique()
-            .map_err(RbPolarsErr::from)?)
+    pub fn approx_n_unique(rb: &Ruby, self_: &Self) -> RbResult<IdxSize> {
+        rb.enter_polars(|| self_.series.read().approx_n_unique())
     }
 
-    pub fn bitwise_and(&self) -> RbResult<Value> {
-        scalar_to_rb(Ok(self
-            .series
-            .borrow()
-            .and_reduce()
-            .map_err(RbPolarsErr::from)?))
+    pub fn bitwise_and(rb: &Ruby, self_: &Self) -> RbResult<Value> {
+        scalar_to_rb(rb.enter_polars(|| self_.series.read().and_reduce()), rb)
     }
 
-    pub fn bitwise_or(&self) -> RbResult<Value> {
-        scalar_to_rb(Ok(self
-            .series
-            .borrow()
-            .or_reduce()
-            .map_err(RbPolarsErr::from)?))
+    pub fn bitwise_or(rb: &Ruby, self_: &Self) -> RbResult<Value> {
+        scalar_to_rb(rb.enter_polars(|| self_.series.read().or_reduce()), rb)
     }
 
-    pub fn bitwise_xor(&self) -> RbResult<Value> {
-        scalar_to_rb(Ok(self
-            .series
-            .borrow()
-            .xor_reduce()
-            .map_err(RbPolarsErr::from)?))
+    pub fn bitwise_xor(rb: &Ruby, self_: &Self) -> RbResult<Value> {
+        scalar_to_rb(rb.enter_polars(|| self_.series.read().xor_reduce()), rb)
     }
 }

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

@@ -1,34 +1,28 @@
-use crate::{RbPolarsErr, RbResult, RbSeries};
+use magnus::Ruby;
+
+use super::RbSeries;
+use crate::RbResult;
+use crate::utils::EnterPolarsExt;
 
 impl RbSeries {
-    pub fn add(&self, other: &RbSeries) -> RbResult<Self> {
-        Ok((&*self.series.borrow() + &*other.series.borrow())
-            .map(Into::into)
-            .map_err(RbPolarsErr::from)?)
+    pub fn add(rb: &Ruby, self_: &Self, other: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| &*self_.series.read() + &*other.series.read())
     }
 
-    pub fn sub(&self, other: &RbSeries) -> RbResult<Self> {
-        Ok((&*self.series.borrow() - &*other.series.borrow())
-            .map(Into::into)
-            .map_err(RbPolarsErr::from)?)
+    pub fn sub(rb: &Ruby, self_: &Self, other: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| &*self_.series.read() - &*other.series.read())
     }
 
-    pub fn mul(&self, other: &RbSeries) -> RbResult<Self> {
-        Ok((&*self.series.borrow() * &*other.series.borrow())
-            .map(Into::into)
-            .map_err(RbPolarsErr::from)?)
+    pub fn mul(rb: &Ruby, self_: &Self, other: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| &*self_.series.read() * &*other.series.read())
     }
 
-    pub fn div(&self, other: &RbSeries) -> RbResult<Self> {
-        Ok((&*self.series.borrow() / &*other.series.borrow())
-            .map(Into::into)
-            .map_err(RbPolarsErr::from)?)
+    pub fn div(rb: &Ruby, self_: &Self, other: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| &*self_.series.read() / &*other.series.read())
     }
 
-    pub fn rem(&self, other: &RbSeries) -> RbResult<Self> {
-        Ok((&*self.series.borrow() % &*other.series.borrow())
-            .map(Into::into)
-            .map_err(RbPolarsErr::from)?)
+    pub fn rem(rb: &Ruby, self_: &Self, other: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| &*self_.series.read() % &*other.series.read())
     }
 }
 
@@ -36,7 +30,7 @@ macro_rules! impl_arithmetic {
     ($name:ident, $type:ty, $operand:tt) => {
         impl RbSeries {
             pub fn $name(&self, other: $type) -> RbResult<Self> {
-                Ok(RbSeries::new(&*self.series.borrow() $operand other))
+                Ok(RbSeries::new(&*self.series.read() $operand other))
             }
         }
     };