polars-df 0.23.0 → 0.24.0

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

@@ -1,23 +1,22 @@
-use magnus::{Error, IntoValue, RArray, Ruby, Value, value::ReprValue};
+use magnus::{IntoValue, RArray, Ruby, Value, value::ReprValue};
 use polars::prelude::*;
 use polars::series::IsSorted;
+use polars_core::chunked_array::cast::CastOptions;
 use polars_core::utils::flatten::flatten_series;
 
 use crate::conversion::*;
-use crate::exceptions::RbIndexError;
-use crate::rb_modules;
+use crate::exceptions::{RbIndexError, RbRuntimeError, RbValueError};
+use crate::prelude::*;
+use crate::utils::{EnterPolarsExt, RubyAttach};
 use crate::{RbDataFrame, RbErr, RbPolarsErr, RbResult, RbSeries};
 
 impl RbSeries {
-    pub fn struct_unnest(&self) -> RbResult<RbDataFrame> {
-        let binding = self.series.borrow();
-        let ca = binding.struct_().map_err(RbPolarsErr::from)?;
-        let df: DataFrame = ca.clone().unnest();
-        Ok(df.into())
+    pub fn struct_unnest(rb: &Ruby, self_: &Self) -> RbResult<RbDataFrame> {
+        rb.enter_polars_df(|| Ok(self_.series.read().struct_()?.clone().unnest()))
     }
 
     pub fn struct_fields(&self) -> RbResult<Vec<String>> {
-        let binding = self.series.borrow();
+        let binding = self.series.read();
         let ca = binding.struct_().map_err(RbPolarsErr::from)?;
         Ok(ca
             .struct_fields()
@@ -27,15 +26,15 @@ impl RbSeries {
     }
 
     pub fn is_sorted_ascending_flag(&self) -> bool {
-        matches!(self.series.borrow().is_sorted_flag(), IsSorted::Ascending)
+        matches!(self.series.read().is_sorted_flag(), IsSorted::Ascending)
     }
 
     pub fn is_sorted_descending_flag(&self) -> bool {
-        matches!(self.series.borrow().is_sorted_flag(), IsSorted::Descending)
+        matches!(self.series.read().is_sorted_flag(), IsSorted::Descending)
     }
 
     pub fn can_fast_explode_flag(&self) -> bool {
-        match self.series.borrow().list() {
+        match self.series.read().list() {
             Err(_) => false,
             Ok(list) => list._can_fast_explode(),
         }
@@ -54,12 +53,21 @@ impl RbSeries {
     }
 
     pub fn estimated_size(&self) -> usize {
-        self.series.borrow().estimated_size()
+        self.series.read().estimated_size()
+    }
+
+    pub fn reshape(rb: &Ruby, self_: &Self, dims: Vec<i64>) -> RbResult<Self> {
+        let dims = dims
+            .into_iter()
+            .map(ReshapeDimension::new)
+            .collect::<Vec<_>>();
+
+        rb.enter_polars_series(|| self_.series.read().reshape_array(&dims))
     }
 
     pub fn get_fmt(&self, index: usize, str_lengths: usize) -> String {
-        let val = format!("{}", self.series.borrow().get(index).unwrap());
-        if let DataType::String | DataType::Categorical(_, _) = self.series.borrow().dtype() {
+        let val = format!("{}", self.series.read().get(index).unwrap());
+        if let DataType::String | DataType::Categorical(_, _) = self.series.read().dtype() {
             let v_trunc = &val[..val
                 .char_indices()
                 .take(str_lengths)
@@ -76,18 +84,18 @@ impl RbSeries {
         }
     }
 
-    pub fn rechunk(&self, in_place: bool) -> Option<Self> {
-        let series = self.series.borrow_mut().rechunk();
+    pub fn rechunk(rb: &Ruby, self_: &Self, in_place: bool) -> RbResult<Option<Self>> {
+        let series = rb.enter_polars_ok(|| self_.series.read().rechunk())?;
         if in_place {
-            *self.series.borrow_mut() = series;
-            None
+            *self_.series.write() = series;
+            Ok(None)
         } else {
-            Some(series.into())
+            Ok(Some(series.into()))
         }
     }
 
-    pub fn get_index(ruby: &Ruby, rb_self: &Self, index: usize) -> RbResult<Value> {
-        let binding = rb_self.series.borrow();
+    pub fn get_index(ruby: &Ruby, self_: &Self, index: usize) -> RbResult<Value> {
+        let binding = self_.series.read();
         let av = match binding.get(index) {
             Ok(v) => v,
             Err(PolarsError::OutOfBounds(err)) => {
@@ -99,70 +107,58 @@ impl RbSeries {
         match av {
             AnyValue::List(s) | AnyValue::Array(s, _) => {
                 let rbseries = RbSeries::new(s);
-                rb_modules::pl_utils().funcall("wrap_s", (rbseries,))
+                rb_modules::pl_utils(ruby).funcall("wrap_s", (rbseries,))
             }
             _ => Ok(Wrap(av).into_value_with(ruby)),
         }
     }
 
-    pub fn get_index_signed(ruby: &Ruby, rb_self: &Self, index: isize) -> RbResult<Value> {
+    pub fn get_index_signed(ruby: &Ruby, self_: &Self, index: isize) -> RbResult<Value> {
         let index = if index < 0 {
-            match rb_self.len().checked_sub(index.unsigned_abs()) {
+            match self_.len().checked_sub(index.unsigned_abs()) {
                 Some(v) => v,
                 None => {
                     return Err(RbIndexError::new_err(
-                        polars_err!(oob = index, rb_self.len()).to_string(),
+                        polars_err!(oob = index, self_.len()).to_string(),
                     ));
                 }
             }
         } else {
             usize::try_from(index).unwrap()
         };
-        Self::get_index(ruby, rb_self, index)
+        Self::get_index(ruby, self_, index)
     }
 
-    pub fn bitand(&self, other: &RbSeries) -> RbResult<Self> {
-        let out = (&*self.series.borrow() & &*other.series.borrow()).map_err(RbPolarsErr::from)?;
-        Ok(out.into())
+    pub fn bitand(rb: &Ruby, self_: &Self, other: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| &*self_.series.read() & &*other.series.read())
     }
 
-    pub fn bitor(&self, other: &RbSeries) -> RbResult<Self> {
-        let out = (&*self.series.borrow() | &*other.series.borrow()).map_err(RbPolarsErr::from)?;
-        Ok(out.into())
+    pub fn bitor(rb: &Ruby, self_: &Self, other: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| &*self_.series.read() | &*other.series.read())
     }
 
-    pub fn bitxor(&self, other: &RbSeries) -> RbResult<Self> {
-        let out = (&*self.series.borrow() ^ &*other.series.borrow()).map_err(RbPolarsErr::from)?;
-        Ok(out.into())
+    pub fn bitxor(rb: &Ruby, self_: &Self, other: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| &*self_.series.read() ^ &*other.series.read())
     }
 
     pub fn chunk_lengths(&self) -> Vec<usize> {
-        self.series.borrow().chunk_lengths().collect()
+        self.series.read().chunk_lengths().collect()
     }
 
     pub fn name(&self) -> String {
-        self.series.borrow().name().to_string()
+        self.series.read().name().to_string()
     }
 
     pub fn rename(&self, name: String) {
-        self.series.borrow_mut().rename(name.into());
+        self.series.write().rename(name.into());
     }
 
-    pub fn dtype(ruby: &Ruby, rb_self: &Self) -> Value {
-        Wrap(rb_self.series.borrow().dtype().clone()).into_value_with(ruby)
-    }
-
-    pub fn inner_dtype(ruby: &Ruby, rb_self: &Self) -> Option<Value> {
-        rb_self
-            .series
-            .borrow()
-            .dtype()
-            .inner_dtype()
-            .map(|dt| Wrap(dt.clone()).into_value_with(ruby))
+    pub fn dtype(rb: &Ruby, self_: &Self) -> Value {
+        Wrap(self_.series.read().dtype().clone()).into_value_with(rb)
     }
 
     pub fn set_sorted_flag(&self, descending: bool) -> Self {
-        let mut out = self.series.borrow().clone();
+        let mut out = self.series.read().clone();
         if descending {
             out.set_sorted_flag(IsSorted::Descending);
         } else {
@@ -172,284 +168,207 @@ impl RbSeries {
     }
 
     pub fn n_chunks(&self) -> usize {
-        self.series.borrow().n_chunks()
+        self.series.read().n_chunks()
     }
 
-    pub fn append(ruby: &Ruby, rb_self: &Self, other: &RbSeries) -> RbResult<()> {
-        let mut binding = rb_self.series.borrow_mut();
-        let res = binding.append(&other.series.borrow());
-        if let Err(e) = res {
-            Err(Error::new(ruby.exception_runtime_error(), e.to_string()))
-        } else {
-            Ok(())
-        }
+    pub fn append(rb: &Ruby, self_: &Self, other: &RbSeries) -> RbResult<()> {
+        rb.enter_polars(|| {
+            // Prevent self-append deadlocks.
+            let other = other.series.read().clone();
+            let mut s = self_.series.write();
+            s.append(&other)?;
+            PolarsResult::Ok(())
+        })
     }
 
-    pub fn extend(&self, other: &RbSeries) -> RbResult<()> {
-        self.series
-            .borrow_mut()
-            .extend(&other.series.borrow())
-            .map_err(RbPolarsErr::from)?;
-        Ok(())
+    pub fn extend(rb: &Ruby, self_: &Self, other: &RbSeries) -> RbResult<()> {
+        rb.enter_polars(|| {
+            // Prevent self-extend deadlocks.
+            let other = other.series.read().clone();
+            let mut s = self_.series.write();
+            s.extend(&other)?;
+            PolarsResult::Ok(())
+        })
     }
 
-    pub fn new_from_index(
-        ruby: &Ruby,
-        rb_self: &Self,
-        index: usize,
-        length: usize,
-    ) -> RbResult<Self> {
-        if index >= rb_self.series.borrow().len() {
-            Err(Error::new(
-                ruby.exception_arg_error(),
-                "index is out of bounds",
-            ))
+    pub fn new_from_index(rb: &Ruby, self_: &Self, index: usize, length: usize) -> RbResult<Self> {
+        let s = self_.series.read();
+        if index >= s.len() {
+            Err(RbValueError::new_err("index is out of bounds"))
         } else {
-            Ok(rb_self.series.borrow().new_from_index(index, length).into())
+            rb.enter_polars_series(|| Ok(s.new_from_index(index, length)))
         }
     }
 
-    pub fn filter(ruby: &Ruby, rb_self: &Self, filter: &RbSeries) -> RbResult<Self> {
-        let filter_series = &filter.series.borrow();
+    pub fn filter(rb: &Ruby, self_: &Self, filter: &RbSeries) -> RbResult<Self> {
+        let filter_series = &filter.series.read();
         if let Ok(ca) = filter_series.bool() {
-            let series = rb_self.series.borrow().filter(ca).unwrap();
-            Ok(series.into())
+            rb.enter_polars_series(|| self_.series.read().filter(ca))
         } else {
-            Err(Error::new(
-                ruby.exception_runtime_error(),
-                "Expected a boolean mask".to_string(),
-            ))
+            Err(RbRuntimeError::new_err("Expected a boolean mask"))
         }
     }
 
-    pub fn sort(&self, descending: bool, nulls_last: bool, multithreaded: bool) -> RbResult<Self> {
-        Ok(self
-            .series
-            .borrow_mut()
-            .sort(
+    pub fn sort(
+        rb: &Ruby,
+        self_: &Self,
+        descending: bool,
+        nulls_last: bool,
+        multithreaded: bool,
+    ) -> RbResult<Self> {
+        rb.enter_polars_series(|| {
+            self_.series.read().sort(
                 SortOptions::default()
                     .with_order_descending(descending)
                     .with_nulls_last(nulls_last)
                     .with_multithreaded(multithreaded),
             )
-            .map_err(RbPolarsErr::from)?
-            .into())
-    }
-
-    pub fn value_counts(
-        &self,
-        sort: bool,
-        parallel: bool,
-        name: String,
-        normalize: bool,
-    ) -> RbResult<RbDataFrame> {
-        let out = self
-            .series
-            .borrow()
-            .value_counts(sort, parallel, name.into(), normalize)
-            .map_err(RbPolarsErr::from)?;
-        Ok(out.into())
+        })
     }
 
-    pub fn slice(&self, offset: i64, length: Option<usize>) -> Self {
-        let length = length.unwrap_or_else(|| self.series.borrow().len());
-        self.series.borrow().slice(offset, length).into()
-    }
-
-    pub fn take_with_series(&self, indices: &RbSeries) -> RbResult<Self> {
-        let binding = indices.series.borrow();
-        let idx = binding.idx().map_err(RbPolarsErr::from)?;
-        let take = self.series.borrow().take(idx).map_err(RbPolarsErr::from)?;
-        Ok(RbSeries::new(take))
+    pub fn gather_with_series(rb: &Ruby, self_: &Self, indices: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| self_.series.read().take(indices.series.read().idx()?))
     }
 
     pub fn null_count(&self) -> RbResult<usize> {
-        Ok(self.series.borrow().null_count())
+        Ok(self.series.read().null_count())
     }
 
     pub fn has_nulls(&self) -> bool {
-        self.series.borrow().has_nulls()
-    }
-
-    pub fn sample_n(
-        &self,
-        n: usize,
-        with_replacement: bool,
-        shuffle: bool,
-        seed: Option<u64>,
-    ) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .sample_n(n, with_replacement, shuffle, seed)
-            .map_err(RbPolarsErr::from)?;
-        Ok(s.into())
-    }
-
-    pub fn sample_frac(
-        &self,
-        frac: f64,
-        with_replacement: bool,
-        shuffle: bool,
-        seed: Option<u64>,
-    ) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .sample_frac(frac, with_replacement, shuffle, seed)
-            .map_err(RbPolarsErr::from)?;
-        Ok(s.into())
+        self.series.read().has_nulls()
     }
 
     pub fn equals(
-        &self,
+        rb: &Ruby,
+        self_: &Self,
         other: &RbSeries,
         check_dtypes: bool,
         check_names: bool,
         null_equal: bool,
-    ) -> bool {
-        if check_dtypes && (self.series.borrow().dtype() != other.series.borrow().dtype()) {
-            return false;
+    ) -> RbResult<bool> {
+        let s = self_.series.read();
+        let o = other.series.read();
+        if check_dtypes && (s.dtype() != o.dtype()) {
+            return Ok(false);
         }
-        if check_names && (self.series.borrow().name() != other.series.borrow().name()) {
-            return false;
+        if check_names && (s.name() != o.name()) {
+            return Ok(false);
         }
         if null_equal {
-            self.series.borrow().equals_missing(&other.series.borrow())
+            rb.enter_polars_ok(|| s.equals_missing(&o))
         } else {
-            self.series.borrow().equals(&other.series.borrow())
+            rb.enter_polars_ok(|| s.equals(&o))
         }
     }
 
-    pub fn not_(&self) -> RbResult<Self> {
-        let binding = self.series.borrow();
-        let bool = binding.bool().map_err(RbPolarsErr::from)?;
-        Ok((!bool).into_series().into())
-    }
-
-    pub fn shrink_dtype(&self) -> RbResult<Self> {
-        self.series
-            .borrow()
-            .shrink_type()
-            .map(Into::into)
-            .map_err(RbPolarsErr::from)
-            .map_err(RbErr::from)
-    }
-
-    pub fn str_to_decimal_infer(&self, inference_length: usize) -> RbResult<Self> {
-        let s = self.series.borrow();
-        let ca = s.str().map_err(RbPolarsErr::from)?;
-        ca.to_decimal_infer(inference_length)
-            .map(Into::into)
-            .map_err(RbPolarsErr::from)
-            .map_err(RbErr::from)
-    }
-
-    pub fn str_json_decode(&self, infer_schema_length: Option<usize>) -> RbResult<Self> {
-        let lock = self.series.borrow();
-        lock.str()
-            .map_err(RbPolarsErr::from)?
-            .json_decode(None, infer_schema_length)
-            .map(|s| s.with_name(lock.name().clone()))
-            .map(Into::into)
-            .map_err(RbPolarsErr::from)
-            .map_err(RbErr::from)
-    }
-
-    pub fn to_s(&self) -> String {
-        format!("{}", self.series.borrow())
+    pub fn as_str(&self) -> String {
+        format!("{:?}", self.series.read())
     }
 
     pub fn len(&self) -> usize {
-        self.series.borrow().len()
+        self.series.read().len()
     }
 
     pub fn clone(&self) -> Self {
-        RbSeries::new(self.series.borrow().clone())
+        Clone::clone(self)
     }
 
-    pub fn zip_with(&self, mask: &RbSeries, other: &RbSeries) -> RbResult<Self> {
-        let binding = mask.series.borrow();
-        let mask = binding.bool().map_err(RbPolarsErr::from)?;
-        let s = self
-            .series
-            .borrow()
-            .zip_with(mask, &other.series.borrow())
-            .map_err(RbPolarsErr::from)?;
-        Ok(RbSeries::new(s))
+    pub fn zip_with(rb: &Ruby, self_: &Self, mask: &RbSeries, other: &RbSeries) -> RbResult<Self> {
+        let ms = mask.series.read();
+        let mask = ms.bool().map_err(RbPolarsErr::from)?;
+        rb.enter_polars_series(|| self_.series.read().zip_with(mask, &other.series.read()))
     }
 
     pub fn to_dummies(
-        &self,
-        sep: Option<String>,
+        rb: &Ruby,
+        self_: &Self,
+        separator: Option<String>,
         drop_first: bool,
         drop_nulls: bool,
     ) -> RbResult<RbDataFrame> {
-        let df = self
-            .series
-            .borrow()
-            .to_dummies(sep.as_deref(), drop_first, drop_nulls)
-            .map_err(RbPolarsErr::from)?;
-        Ok(df.into())
+        rb.enter_polars_df(|| {
+            self_
+                .series
+                .read()
+                .to_dummies(separator.as_deref(), drop_first, drop_nulls)
+        })
     }
 
-    pub fn n_unique(&self) -> RbResult<usize> {
-        let n = self.series.borrow().n_unique().map_err(RbPolarsErr::from)?;
-        Ok(n)
+    pub fn n_unique(rb: &Ruby, self_: &Self) -> RbResult<usize> {
+        rb.enter_polars(|| self_.series.read().n_unique())
     }
 
-    pub fn floor(&self) -> RbResult<Self> {
-        let s = self.series.borrow().floor().map_err(RbPolarsErr::from)?;
-        Ok(s.into())
+    pub fn floor(rb: &Ruby, self_: &Self) -> RbResult<Self> {
+        rb.enter_polars_series(|| self_.series.read().floor())
     }
 
-    pub fn shrink_to_fit(&self) {
-        self.series.borrow_mut().shrink_to_fit();
+    pub fn shrink_to_fit(rb: &Ruby, self_: &Self) -> RbResult<()> {
+        rb.enter_polars_ok(|| self_.series.write().shrink_to_fit())
     }
 
-    pub fn dot(&self, other: &RbSeries) -> RbResult<f64> {
-        let out = self
-            .series
-            .borrow()
-            .dot(&other.series.borrow())
-            .map_err(RbPolarsErr::from)?;
-        Ok(out)
+    pub fn dot(rb: &Ruby, self_: &Self, other: &RbSeries) -> RbResult<Value> {
+        let s = &*self_.series.read();
+        let o = &*other.series.read();
+        let lhs_dtype = s.dtype();
+        let rhs_dtype = o.dtype();
+
+        if !lhs_dtype.is_primitive_numeric() {
+            return Err(RbPolarsErr::from(polars_err!(opq = dot, lhs_dtype)).into());
+        };
+        if !rhs_dtype.is_primitive_numeric() {
+            return Err(RbPolarsErr::from(polars_err!(opq = dot, rhs_dtype)).into());
+        }
+
+        let result: Value = if lhs_dtype.is_float() || rhs_dtype.is_float() {
+            rb.enter_polars(|| (s * o)?.sum::<f64>())?
+                .into_value_with(rb)
+        } else {
+            rb.enter_polars(|| (s * o)?.sum::<i64>())?
+                .into_value_with(rb)
+        };
+
+        Ok(result)
     }
 
-    pub fn skew(&self, bias: bool) -> RbResult<Option<f64>> {
-        let out = self.series.borrow().skew(bias).map_err(RbPolarsErr::from)?;
-        Ok(out)
+    pub fn skew(rb: &Ruby, self_: &Self, bias: bool) -> RbResult<Option<f64>> {
+        rb.enter_polars(|| self_.series.read().skew(bias))
     }
 
-    pub fn kurtosis(&self, fisher: bool, bias: bool) -> RbResult<Option<f64>> {
-        let out = self
-            .series
-            .borrow()
-            .kurtosis(fisher, bias)
-            .map_err(RbPolarsErr::from)?;
-        Ok(out)
+    pub fn kurtosis(rb: &Ruby, self_: &Self, fisher: bool, bias: bool) -> RbResult<Option<f64>> {
+        rb.enter_polars(|| self_.series.read().kurtosis(fisher, bias))
     }
 
-    pub fn cast(&self, dtype: Wrap<DataType>, strict: bool) -> RbResult<Self> {
-        let dtype = dtype.0;
-        let out = if strict {
-            self.series.borrow().strict_cast(&dtype)
+    pub fn cast(
+        rb: &Ruby,
+        self_: &Self,
+        dtype: Wrap<DataType>,
+        strict: bool,
+        wrap_numerical: bool,
+    ) -> RbResult<Self> {
+        let options = if wrap_numerical {
+            CastOptions::Overflowing
+        } else if strict {
+            CastOptions::Strict
         } else {
-            self.series.borrow().cast(&dtype)
+            CastOptions::NonStrict
         };
-        let out = out.map_err(RbPolarsErr::from)?;
-        Ok(out.into())
+        rb.enter_polars_series(|| self_.series.read().cast_with_options(&dtype.0, options))
     }
 
-    pub fn get_chunks(ruby: &Ruby, rb_self: &Self) -> RbResult<RArray> {
-        ruby.ary_try_from_iter(
-            flatten_series(&rb_self.series.borrow())
-                .into_iter()
-                .map(|s| rb_modules::pl_utils().funcall::<_, _, Value>("wrap_s", (Self::new(s),))),
-        )
+    pub fn get_chunks(&self) -> RbResult<RArray> {
+        Ruby::attach(|rb| {
+            rb.ary_try_from_iter(flatten_series(&self.series.read()).into_iter().map(|s| {
+                rb_modules::pl_utils(rb).funcall::<_, _, Value>("wrap_s", (Self::new(s),))
+            }))
+        })
     }
 
-    pub fn is_sorted(&self, descending: bool, nulls_last: bool) -> RbResult<bool> {
+    pub fn is_sorted(
+        rb: &Ruby,
+        self_: &Self,
+        descending: bool,
+        nulls_last: bool,
+    ) -> RbResult<bool> {
         let options = SortOptions {
             descending,
             nulls_last,
@@ -457,30 +376,85 @@ impl RbSeries {
             maintain_order: false,
             limit: None,
         };
-        Ok(self
-            .series
-            .borrow()
-            .is_sorted(options)
-            .map_err(RbPolarsErr::from)?)
+        rb.enter_polars(|| self_.series.read().is_sorted(options))
     }
 
     pub fn clear(&self) -> Self {
-        self.series.borrow().clear().into()
+        self.series.read().clear().into()
     }
 
-    pub fn time_unit(&self) -> Option<String> {
-        if let DataType::Datetime(tu, _) | DataType::Duration(tu) = self.series.borrow().dtype() {
-            Some(
-                match tu {
-                    TimeUnit::Nanoseconds => "ns",
-                    TimeUnit::Microseconds => "us",
-                    TimeUnit::Milliseconds => "ms",
-                }
-                .to_string(),
-            )
-        } else {
-            None
-        }
+    pub fn head(rb: &Ruby, self_: &Self, n: usize) -> RbResult<Self> {
+        rb.enter_polars_series(|| Ok(self_.series.read().head(Some(n))))
+    }
+
+    pub fn tail(rb: &Ruby, self_: &Self, n: usize) -> RbResult<Self> {
+        rb.enter_polars_series(|| Ok(self_.series.read().tail(Some(n))))
+    }
+
+    pub fn value_counts(
+        rb: &Ruby,
+        self_: &Self,
+        sort: bool,
+        parallel: bool,
+        name: String,
+        normalize: bool,
+    ) -> RbResult<RbDataFrame> {
+        rb.enter_polars_df(|| {
+            self_
+                .series
+                .read()
+                .value_counts(sort, parallel, name.into(), normalize)
+        })
+    }
+
+    pub fn slice(&self, offset: i64, length: Option<usize>) -> Self {
+        let s = self.series.read();
+        let length = length.unwrap_or_else(|| s.len());
+        s.slice(offset, length).into()
+    }
+
+    pub fn not_(rb: &Ruby, self_: &Self) -> RbResult<Self> {
+        rb.enter_polars_series(|| polars_ops::series::negate_bitwise(&self_.series.read()))
+    }
+
+    pub fn shrink_dtype(rb: &Ruby, self_: &Self) -> RbResult<Self> {
+        rb.enter_polars(|| {
+            self_
+                .series
+                .read()
+                .shrink_type()
+                .map(Into::into)
+                .map_err(RbPolarsErr::from)
+                .map_err(RbErr::from)
+        })
+    }
+
+    pub fn str_to_decimal_infer(
+        rb: &Ruby,
+        self_: &Self,
+        inference_length: usize,
+    ) -> RbResult<Self> {
+        rb.enter_polars_series(|| {
+            let s = self_.series.read();
+            let ca = s.str()?;
+            ca.to_decimal_infer(inference_length)
+        })
+    }
+
+    pub fn str_json_decode(
+        rb: &Ruby,
+        self_: &Self,
+        infer_schema_length: Option<usize>,
+    ) -> RbResult<Self> {
+        rb.enter_polars(|| {
+            let lock = self_.series.read();
+            lock.str()?
+                .json_decode(None, infer_schema_length)
+                .map(|s| s.with_name(lock.name().clone()))
+        })
+        .map(Into::into)
+        .map_err(RbPolarsErr::from)
+        .map_err(RbErr::from)
     }
 }
 
@@ -491,7 +465,7 @@ macro_rules! impl_set_with_mask {
             filter: &RbSeries,
             value: Option<$native>,
         ) -> PolarsResult<Series> {
-            let binding = filter.series.borrow();
+            let binding = filter.series.read();
             let mask = binding.bool()?;
             let ca = series.$cast()?;
             let new = ca.set(mask, value)?;
@@ -499,10 +473,13 @@ macro_rules! impl_set_with_mask {
         }
 
         impl RbSeries {
-            pub fn $name(&self, filter: &RbSeries, value: Option<$native>) -> RbResult<Self> {
-                let series =
-                    $name(&self.series.borrow(), filter, value).map_err(RbPolarsErr::from)?;
-                Ok(Self::new(series))
+            pub fn $name(
+                rb: &Ruby,
+                self_: &Self,
+                filter: &RbSeries,
+                value: Option<$native>,
+            ) -> RbResult<Self> {
+                rb.enter_polars_series(|| $name(&self_.series.read(), filter, value))
             }
         }
     };
@@ -520,15 +497,3 @@ impl_set_with_mask!(set_with_mask_i16, i16, i16, Int16);
 impl_set_with_mask!(set_with_mask_i32, i32, i32, Int32);
 impl_set_with_mask!(set_with_mask_i64, i64, i64, Int64);
 impl_set_with_mask!(set_with_mask_bool, bool, bool, Boolean);
-
-impl RbSeries {
-    pub fn extend_constant(&self, value: Wrap<AnyValue>, n: usize) -> RbResult<Self> {
-        Ok(self
-            .series
-            .borrow()
-            .clone()
-            .extend_constant(value.0, n)
-            .map_err(RbPolarsErr::from)?
-            .into())
-    }
-}