polars-df 0.7.0 → 0.8.0

data/ext/polars/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "polars"
-version = "0.7.0"
+version = "0.8.0"
 license = "MIT"
 authors = ["Andrew Kane <andrew@ankane.org>"]
 edition = "2021"
@@ -15,13 +15,14 @@ ahash = "0.8"
 chrono = "0.4"
 either = "1.8"
 magnus = "0.6"
-polars-core = "=0.35.2"
-polars-parquet = "=0.35.2"
+polars-core = "=0.36.2"
+polars-parquet = "=0.36.2"
+polars-utils = "=0.36.2"
 serde_json = "1"
 smartstring = "1"
 
 [dependencies.polars]
-version = "=0.35.2"
+version = "=0.36.2"
 features = [
     "abs",
     "approx_unique",
@@ -35,6 +36,7 @@ features = [
     "csv",
     "cum_agg",
     "cumulative_eval",
+    "cutqcut",
     "dataframe_arithmetic",
     "date_offset",
     "diagonal_concat",
@@ -77,6 +79,7 @@ features = [
     "range",
     "reinterpret",
     "repeat_by",
+    "rle",
     "rolling_window",
     "round_series",
     "row_hash",

data/ext/polars/src/batched_csv.rs

@@ -41,7 +41,7 @@ impl RbBatchedCsv {
         // TODO fix
         let overwrite_dtype_slice = Option::<Vec<Wrap<DataType>>>::None; // Option::<Vec<Wrap<DataType>>>::try_convert(arguments[14])?;
         let low_memory = bool::try_convert(arguments[15])?;
-        let comment_char = Option::<String>::try_convert(arguments[16])?;
+        let comment_prefix = Option::<String>::try_convert(arguments[16])?;
         let quote_char = Option::<String>::try_convert(arguments[17])?;
         let null_values = Option::<Wrap<NullValues>>::try_convert(arguments[18])?;
         let try_parse_dates = bool::try_convert(arguments[19])?;
@@ -52,7 +52,6 @@ impl RbBatchedCsv {
         // end arguments
 
         let null_values = null_values.map(|w| w.0);
-        let comment_char = comment_char.map(|s| s.as_bytes()[0]);
         let eol_char = eol_char.as_bytes()[0];
 
         let row_count = row_count.map(|(name, offset)| RowCount { name, offset });
@@ -101,7 +100,7 @@ impl RbBatchedCsv {
             .with_n_threads(n_threads)
             .with_dtypes_slice(overwrite_dtype_slice.as_deref())
             .low_memory(low_memory)
-            .with_comment_char(comment_char)
+            .with_comment_prefix(comment_prefix.as_deref())
             .with_null_values(null_values)
             .with_try_parse_dates(try_parse_dates)
             .with_quote_char(quote_char)

data/ext/polars/src/conversion.rs

@@ -14,7 +14,7 @@ use polars::frame::NullStrategy;
 use polars::io::avro::AvroCompression;
 use polars::prelude::*;
 use polars::series::ops::NullBehavior;
-use polars_core::utils::arrow::util::total_ord::TotalEq;
+use polars_utils::total_ord::TotalEq;
 use smartstring::alias::String as SmartString;
 
 use crate::object::OBJECT_NAME;
@@ -78,10 +78,10 @@ pub(crate) fn get_series(obj: Value) -> RbResult<Series> {
     Ok(rbs.series.borrow().clone())
 }
 
-impl TryConvert for Wrap<Utf8Chunked> {
+impl TryConvert for Wrap<StringChunked> {
     fn try_convert(obj: Value) -> RbResult<Self> {
         let (seq, len) = get_rbseq(obj)?;
-        let mut builder = Utf8ChunkedBuilder::new("", len, len * 25);
+        let mut builder = StringChunkedBuilder::new("", len, len * 25);
 
         for res in seq.each() {
             let item = res?;
@@ -149,8 +149,8 @@ impl IntoValue for Wrap<AnyValue<'_>> {
             AnyValue::Float64(v) => ruby.into_value(v),
             AnyValue::Null => ruby.qnil().as_value(),
             AnyValue::Boolean(v) => ruby.into_value(v),
-            AnyValue::Utf8(v) => ruby.into_value(v),
-            AnyValue::Utf8Owned(v) => ruby.into_value(v.as_str()),
+            AnyValue::String(v) => ruby.into_value(v),
+            AnyValue::StringOwned(v) => ruby.into_value(v.as_str()),
             AnyValue::Categorical(idx, rev, arr) => {
                 let s = if arr.is_null() {
                     rev.get(idx)
@@ -215,7 +215,7 @@ impl IntoValue for Wrap<DataType> {
                     .unwrap()
             }
             DataType::Boolean => pl.const_get::<_, Value>("Boolean").unwrap(),
-            DataType::Utf8 => pl.const_get::<_, Value>("Utf8").unwrap(),
+            DataType::String => pl.const_get::<_, Value>("String").unwrap(),
             DataType::Binary => pl.const_get::<_, Value>("Binary").unwrap(),
             DataType::Array(inner, size) => {
                 let inner = Wrap(*inner);
@@ -242,8 +242,8 @@ impl IntoValue for Wrap<DataType> {
                     .funcall::<_, _, Value>("new", (tu.to_ascii(),))
                     .unwrap()
             }
-            DataType::Object(_) => pl.const_get::<_, Value>("Object").unwrap(),
-            DataType::Categorical(_) => pl.const_get::<_, Value>("Categorical").unwrap(),
+            DataType::Object(_, _) => pl.const_get::<_, Value>("Object").unwrap(),
+            DataType::Categorical(_, _) => pl.const_get::<_, Value>("Categorical").unwrap(),
             DataType::Time => pl.const_get::<_, Value>("Time").unwrap(),
             DataType::Struct(fields) => {
                 let field_class = pl.const_get::<_, Value>("Field").unwrap();
@@ -277,7 +277,7 @@ impl IntoValue for Wrap<TimeUnit> {
     }
 }
 
-impl IntoValue for Wrap<&Utf8Chunked> {
+impl IntoValue for Wrap<&StringChunked> {
     fn into_value_with(self, _: &Ruby) -> Value {
         let iter = self.0.into_iter();
         RArray::from_iter(iter).into_value()
@@ -406,10 +406,10 @@ impl TryConvert for Wrap<DataType> {
                 "Polars::Int16" => DataType::Int16,
                 "Polars::Int32" => DataType::Int32,
                 "Polars::Int64" => DataType::Int64,
-                "Polars::Utf8" => DataType::Utf8,
+                "Polars::String" => DataType::String,
                 "Polars::Binary" => DataType::Binary,
                 "Polars::Boolean" => DataType::Boolean,
-                "Polars::Categorical" => DataType::Categorical(None),
+                "Polars::Categorical" => DataType::Categorical(None, Default::default()),
                 "Polars::Date" => DataType::Date,
                 "Polars::Datetime" => DataType::Datetime(TimeUnit::Microseconds, None),
                 "Polars::Time" => DataType::Time,
@@ -417,7 +417,7 @@ impl TryConvert for Wrap<DataType> {
                 "Polars::Decimal" => DataType::Decimal(None, None),
                 "Polars::Float32" => DataType::Float32,
                 "Polars::Float64" => DataType::Float64,
-                "Polars::Object" => DataType::Object(OBJECT_NAME),
+                "Polars::Object" => DataType::Object(OBJECT_NAME, None),
                 "Polars::List" => DataType::List(Box::new(DataType::Null)),
                 "Polars::Null" => DataType::Null,
                 "Polars::Unknown" => DataType::Unknown,
@@ -477,17 +477,17 @@ impl TryConvert for Wrap<DataType> {
                 "i16" => DataType::Int16,
                 "i32" => DataType::Int32,
                 "i64" => DataType::Int64,
-                "str" => DataType::Utf8,
+                "str" => DataType::String,
                 "bin" => DataType::Binary,
                 "bool" => DataType::Boolean,
-                "cat" => DataType::Categorical(None),
+                "cat" => DataType::Categorical(None, Default::default()),
                 "date" => DataType::Date,
                 "datetime" => DataType::Datetime(TimeUnit::Microseconds, None),
                 "f32" => DataType::Float32,
                 "time" => DataType::Time,
                 "dur" => DataType::Duration(TimeUnit::Microseconds),
                 "f64" => DataType::Float64,
-                "obj" => DataType::Object(OBJECT_NAME),
+                "obj" => DataType::Object(OBJECT_NAME, None),
                 "list" => DataType::List(Box::new(DataType::Boolean)),
                 "null" => DataType::Null,
                 "unk" => DataType::Unknown,
@@ -513,7 +513,7 @@ impl<'s> TryConvert for Wrap<AnyValue<'s>> {
             Ok(AnyValue::Float64(v.to_f64()).into())
         } else if let Some(v) = RString::from_value(ob) {
             if v.enc_get() == Index::utf8() {
-                Ok(AnyValue::Utf8Owned(v.to_string()?.into()).into())
+                Ok(AnyValue::StringOwned(v.to_string()?.into()).into())
             } else {
                 Ok(AnyValue::BinaryOwned(unsafe { v.as_slice() }.to_vec()).into())
             }
@@ -891,7 +891,8 @@ impl TryConvert for Wrap<JoinType> {
         let parsed = match String::try_convert(ob)?.as_str() {
             "inner" => JoinType::Inner,
             "left" => JoinType::Left,
-            "outer" => JoinType::Outer,
+            "outer" => JoinType::Outer { coalesce: false },
+            "outer_coalesce" => JoinType::Outer { coalesce: true },
             "semi" => JoinType::Semi,
             "anti" => JoinType::Anti,
             // #[cfg(feature = "cross_join")]

data/ext/polars/src/dataframe.rs

@@ -48,7 +48,7 @@ impl RbDataFrame {
         schema_overwrite: Option<Schema>,
     ) -> RbResult<Self> {
         // object builder must be registered.
-        crate::object::register_object_builder();
+        crate::on_startup::register_object_builder();
 
         let schema =
             rows_to_schema_supertypes(&rows, infer_schema_length.map(|n| std::cmp::max(1, n)))
@@ -120,7 +120,7 @@ impl RbDataFrame {
         // TODO fix
         let overwrite_dtype_slice = Option::<Vec<Wrap<DataType>>>::None; // Option::<Vec<Wrap<DataType>>>::try_convert(arguments[15])?;
         let low_memory = bool::try_convert(arguments[16])?;
-        let comment_char = Option::<String>::try_convert(arguments[17])?;
+        let comment_prefix = Option::<String>::try_convert(arguments[17])?;
         let quote_char = Option::<String>::try_convert(arguments[18])?;
         let null_values = Option::<Wrap<NullValues>>::try_convert(arguments[19])?;
         let try_parse_dates = bool::try_convert(arguments[20])?;
@@ -131,7 +131,6 @@ impl RbDataFrame {
         // end arguments
 
         let null_values = null_values.map(|w| w.0);
-        let comment_char = comment_char.map(|s| s.as_bytes()[0]);
         let eol_char = eol_char.as_bytes()[0];
 
         let row_count = row_count.map(|(name, offset)| RowCount { name, offset });
@@ -181,7 +180,7 @@ impl RbDataFrame {
             .with_dtypes(overwrite_dtype.map(Arc::new))
             .with_dtypes_slice(overwrite_dtype_slice.as_deref())
             .low_memory(low_memory)
-            .with_comment_char(comment_char)
+            .with_comment_prefix(comment_prefix.as_deref())
             .with_null_values(null_values)
             .with_try_parse_dates(try_parse_dates)
             .with_quote_char(quote_char)
@@ -297,12 +296,18 @@ impl RbDataFrame {
             Ok(df) => Ok(df.into()),
             // try arrow json reader instead
             // this is row oriented
-            Err(_) => {
-                let out = JsonReader::new(mmap_bytes_r)
-                    .with_json_format(JsonFormat::Json)
-                    .finish()
-                    .map_err(|e| RbPolarsErr::other(format!("{:?}", e)))?;
-                Ok(out.into())
+            Err(e) => {
+                let msg = format!("{e}");
+                if msg.contains("successful parse invalid data") {
+                    let e = RbPolarsErr::from(PolarsError::ComputeError(msg.into()));
+                    Err(e)
+                } else {
+                    let out = JsonReader::new(mmap_bytes_r)
+                        .with_json_format(JsonFormat::Json)
+                        .finish()
+                        .map_err(|e| RbPolarsErr::other(format!("{:?}", e)))?;
+                    Ok(out.into())
+                }
             }
         }
     }
@@ -504,7 +509,7 @@ impl RbDataFrame {
                 .get_columns()
                 .iter()
                 .map(|s| match s.dtype() {
-                    DataType::Object(_) => {
+                    DataType::Object(_, _) => {
                         let obj: Option<&ObjectValue> = s.get_object(idx).map(|any| any.into());
                         obj.unwrap().to_object()
                     }
@@ -523,7 +528,7 @@ impl RbDataFrame {
                     .get_columns()
                     .iter()
                     .map(|s| match s.dtype() {
-                        DataType::Object(_) => {
+                        DataType::Object(_, _) => {
                             let obj: Option<&ObjectValue> = s.get_object(idx).map(|any| any.into());
                             obj.unwrap().to_object()
                         }
@@ -785,8 +790,8 @@ impl RbDataFrame {
             .map(|s| RbSeries::new(s.clone()))
     }
 
-    pub fn find_idx_by_name(&self, name: String) -> Option<usize> {
-        self.df.borrow().find_idx_by_name(&name)
+    pub fn get_column_index(&self, name: String) -> Option<usize> {
+        self.df.borrow().get_column_index(&name)
     }
 
     // TODO remove clone
@@ -828,18 +833,18 @@ impl RbDataFrame {
         Ok(())
     }
 
-    pub fn replace_at_idx(&self, index: usize, new_col: &RbSeries) -> RbResult<()> {
+    pub fn replace_column(&self, index: usize, new_col: &RbSeries) -> RbResult<()> {
         self.df
             .borrow_mut()
-            .replace_at_idx(index, new_col.series.borrow().clone())
+            .replace_column(index, new_col.series.borrow().clone())
             .map_err(RbPolarsErr::from)?;
         Ok(())
     }
 
-    pub fn insert_at_idx(&self, index: usize, new_col: &RbSeries) -> RbResult<()> {
+    pub fn insert_column(&self, index: usize, new_col: &RbSeries) -> RbResult<()> {
         self.df
             .borrow_mut()
-            .insert_at_idx(index, new_col.series.borrow().clone())
+            .insert_column(index, new_col.series.borrow().clone())
             .map_err(RbPolarsErr::from)?;
         Ok(())
     }
@@ -874,11 +879,11 @@ impl RbDataFrame {
         Ok(mask.into_series().into())
     }
 
-    pub fn frame_equal(&self, other: &RbDataFrame, null_equal: bool) -> bool {
+    pub fn equals(&self, other: &RbDataFrame, null_equal: bool) -> bool {
         if null_equal {
-            self.df.borrow().frame_equal_missing(&other.df.borrow())
+            self.df.borrow().equals_missing(&other.df.borrow())
         } else {
-            self.df.borrow().frame_equal(&other.df.borrow())
+            self.df.borrow().equals(&other.df.borrow())
         }
     }
 
@@ -966,34 +971,6 @@ impl RbDataFrame {
         self.df.borrow().clone().lazy().into()
     }
 
-    pub fn max(&self) -> Self {
-        self.df.borrow().max().into()
-    }
-
-    pub fn min(&self) -> Self {
-        self.df.borrow().min().into()
-    }
-
-    pub fn sum(&self) -> Self {
-        self.df.borrow().sum().into()
-    }
-
-    pub fn mean(&self) -> Self {
-        self.df.borrow().mean().into()
-    }
-
-    pub fn std(&self, ddof: u8) -> Self {
-        self.df.borrow().std(ddof).into()
-    }
-
-    pub fn var(&self, ddof: u8) -> Self {
-        self.df.borrow().var(ddof).into()
-    }
-
-    pub fn median(&self) -> Self {
-        self.df.borrow().median().into()
-    }
-
     pub fn max_horizontal(&self) -> RbResult<Option<RbSeries>> {
         let s = self
             .df
@@ -1040,19 +1017,6 @@ impl RbDataFrame {
         Ok(s.map(|s| s.into()))
     }
 
-    pub fn quantile(
-        &self,
-        quantile: f64,
-        interpolation: Wrap<QuantileInterpolOptions>,
-    ) -> RbResult<Self> {
-        let df = self
-            .df
-            .borrow()
-            .quantile(quantile, interpolation.0)
-            .map_err(RbPolarsErr::from)?;
-        Ok(df.into())
-    }
-
     pub fn to_dummies(
         &self,
         columns: Option<Vec<String>>,
@@ -1124,7 +1088,7 @@ impl RbDataFrame {
                     .into_datetime(tu, tz)
                     .into_series()
             }
-            Some(DataType::Utf8) => {
+            Some(DataType::String) => {
                 apply_lambda_with_utf8_out_type(df, lambda, 0, None).into_series()
             }
             _ => return apply_lambda_unknown(df, lambda, inference_size),

data/ext/polars/src/expr/categorical.rs

@@ -5,6 +5,13 @@ use crate::RbExpr;
 
 impl RbExpr {
     pub fn cat_set_ordering(&self, ordering: Wrap<CategoricalOrdering>) -> Self {
-        self.inner.clone().cat().set_ordering(ordering.0).into()
+        self.inner
+            .clone()
+            .cast(DataType::Categorical(None, ordering.0))
+            .into()
+    }
+
+    pub fn cat_get_categories(&self) -> Self {
+        self.inner.clone().cat().get_categories().into()
     }
 }

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

@@ -162,12 +162,71 @@ impl RbExpr {
             .into()
     }
 
+    pub fn cut(
+        &self,
+        breaks: Vec<f64>,
+        labels: Option<Vec<String>>,
+        left_closed: bool,
+        include_breaks: bool,
+    ) -> Self {
+        self.inner
+            .clone()
+            .cut(breaks, labels, left_closed, include_breaks)
+            .into()
+    }
+
+    pub fn qcut(
+        &self,
+        probs: Vec<f64>,
+        labels: Option<Vec<String>>,
+        left_closed: bool,
+        allow_duplicates: bool,
+        include_breaks: bool,
+    ) -> Self {
+        self.inner
+            .clone()
+            .qcut(probs, labels, left_closed, allow_duplicates, include_breaks)
+            .into()
+    }
+
+    pub fn qcut_uniform(
+        &self,
+        n_bins: usize,
+        labels: Option<Vec<String>>,
+        left_closed: bool,
+        allow_duplicates: bool,
+        include_breaks: bool,
+    ) -> Self {
+        self.inner
+            .clone()
+            .qcut_uniform(
+                n_bins,
+                labels,
+                left_closed,
+                allow_duplicates,
+                include_breaks,
+            )
+            .into()
+    }
+
+    pub fn rle(&self) -> Self {
+        self.inner.clone().rle().into()
+    }
+
+    pub fn rle_id(&self) -> Self {
+        self.inner.clone().rle_id().into()
+    }
+
     pub fn agg_groups(&self) -> Self {
-        self.clone().inner.agg_groups().into()
+        self.inner.clone().agg_groups().into()
     }
 
     pub fn count(&self) -> Self {
-        self.clone().inner.count().into()
+        self.inner.clone().count().into()
+    }
+
+    pub fn len(&self) -> Self {
+        self.inner.clone().len().into()
     }
 
     pub fn value_counts(&self, multithreaded: bool, sorted: bool) -> Self {
@@ -345,11 +404,11 @@ impl RbExpr {
         self.clone().inner.explode().into()
     }
 
-    pub fn gather_every(&self, n: usize) -> Self {
+    pub fn gather_every(&self, n: usize, offset: usize) -> Self {
         self.clone()
             .inner
             .map(
-                move |s: Series| Ok(Some(s.gather_every(n))),
+                move |s: Series| Ok(Some(s.gather_every(n, offset))),
                 GetOutput::same_type(),
             )
             .with_fmt("gather_every")

data/ext/polars/src/expr/rolling.rs

@@ -100,6 +100,7 @@ impl RbExpr {
         by: Option<String>,
         closed: Option<Wrap<ClosedWindow>>,
         ddof: u8,
+        warn_if_unsorted: bool,
     ) -> Self {
         let options = RollingOptions {
             window_size: Duration::parse(&window_size),
@@ -109,6 +110,7 @@ impl RbExpr {
             by,
             closed_window: closed.map(|c| c.0),
             fn_params: Some(Arc::new(RollingVarParams { ddof }) as Arc<dyn Any + Send + Sync>),
+            warn_if_unsorted,
         };
 
         self.inner.clone().rolling_std(options).into()
@@ -124,6 +126,7 @@ impl RbExpr {
         by: Option<String>,
         closed: Option<Wrap<ClosedWindow>>,
         ddof: u8,
+        warn_if_unsorted: bool,
     ) -> Self {
         let options = RollingOptions {
             window_size: Duration::parse(&window_size),
@@ -133,6 +136,7 @@ impl RbExpr {
             by,
             closed_window: closed.map(|c| c.0),
             fn_params: Some(Arc::new(RollingVarParams { ddof }) as Arc<dyn Any + Send + Sync>),
+            warn_if_unsorted,
         };
 
         self.inner.clone().rolling_var(options).into()
@@ -146,6 +150,7 @@ impl RbExpr {
         center: bool,
         by: Option<String>,
         closed: Option<Wrap<ClosedWindow>>,
+        warn_if_unsorted: bool,
     ) -> Self {
         let options = RollingOptions {
             window_size: Duration::parse(&window_size),
@@ -154,12 +159,10 @@ impl RbExpr {
             center,
             by,
             closed_window: closed.map(|c| c.0),
-            fn_params: Some(Arc::new(RollingQuantileParams {
-                prob: 0.5,
-                interpol: QuantileInterpolOptions::Linear,
-            }) as Arc<dyn Any + Send + Sync>),
+            fn_params: None,
+            warn_if_unsorted,
         };
-        self.inner.clone().rolling_quantile(options).into()
+        self.inner.clone().rolling_median(options).into()
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -173,6 +176,7 @@ impl RbExpr {
         center: bool,
         by: Option<String>,
         closed: Option<Wrap<ClosedWindow>>,
+        warn_if_unsorted: bool,
     ) -> Self {
         let options = RollingOptions {
             window_size: Duration::parse(&window_size),
@@ -181,13 +185,14 @@ impl RbExpr {
             center,
             by,
             closed_window: closed.map(|c| c.0),
-            fn_params: Some(Arc::new(RollingQuantileParams {
-                prob: quantile,
-                interpol: interpolation.0,
-            }) as Arc<dyn Any + Send + Sync>),
+            fn_params: None,
+            warn_if_unsorted,
         };
 
-        self.inner.clone().rolling_quantile(options).into()
+        self.inner
+            .clone()
+            .rolling_quantile(interpolation.0, quantile, options)
+            .into()
     }
 
     pub fn rolling_skew(&self, window_size: usize, bias: bool) -> Self {

data/ext/polars/src/expr/string.rs

@@ -192,7 +192,7 @@ impl RbExpr {
         self.clone()
             .inner
             .map(
-                move |s| s.utf8().map(|s| Some(s.hex_encode().into_series())),
+                move |s| s.str().map(|s| Some(s.hex_encode().into_series())),
                 GetOutput::same_type(),
             )
             .with_fmt("str.hex_encode")
@@ -203,7 +203,7 @@ impl RbExpr {
         self.clone()
             .inner
             .map(
-                move |s| s.utf8()?.hex_decode(strict).map(|s| Some(s.into_series())),
+                move |s| s.str()?.hex_decode(strict).map(|s| Some(s.into_series())),
                 GetOutput::same_type(),
             )
             .with_fmt("str.hex_decode")
@@ -214,7 +214,7 @@ impl RbExpr {
         self.clone()
             .inner
             .map(
-                move |s| s.utf8().map(|s| Some(s.base64_encode().into_series())),
+                move |s| s.str().map(|s| Some(s.base64_encode().into_series())),
                 GetOutput::same_type(),
             )
             .with_fmt("str.base64_encode")
@@ -226,7 +226,7 @@ impl RbExpr {
             .inner
             .map(
                 move |s| {
-                    s.utf8()?
+                    s.str()?
                         .base64_decode(strict)
                         .map(|s| Some(s.into_series()))
                 },
@@ -258,8 +258,8 @@ impl RbExpr {
         };
 
         let function = move |s: Series| {
-            let ca = s.utf8()?;
-            match ca.json_extract(dtype.clone(), infer_schema_len) {
+            let ca = s.str()?;
+            match ca.json_decode(dtype.clone(), infer_schema_len) {
                 Ok(ca) => Ok(Some(ca.into_series())),
                 Err(e) => Err(PolarsError::ComputeError(format!("{e:?}").into())),
             }
@@ -268,13 +268,13 @@ impl RbExpr {
         self.clone()
             .inner
             .map(function, output_type)
-            .with_fmt("str.json_extract")
+            .with_fmt("str.json_decode")
             .into()
     }
 
     pub fn str_json_path_match(&self, pat: String) -> Self {
         let function = move |s: Series| {
-            let ca = s.utf8()?;
+            let ca = s.str()?;
             match ca.json_path_match(&pat) {
                 Ok(ca) => Ok(Some(ca.into_series())),
                 Err(e) => Err(PolarsError::ComputeError(format!("{:?}", e).into())),
@@ -282,7 +282,7 @@ impl RbExpr {
         };
         self.clone()
             .inner
-            .map(function, GetOutput::from_type(DataType::Utf8))
+            .map(function, GetOutput::from_type(DataType::String))
             .with_fmt("str.json_path_match")
             .into()
     }

data/ext/polars/src/functions/range.rs

@@ -6,21 +6,16 @@ use crate::prelude::*;
 use crate::RbExpr;
 
 pub fn int_range(start: &RbExpr, end: &RbExpr, step: i64, dtype: Wrap<DataType>) -> RbExpr {
+    let start = start.inner.clone();
+    let end = end.inner.clone();
     let dtype = dtype.0;
-
-    let mut result = dsl::int_range(start.inner.clone(), end.inner.clone(), step);
-
-    if dtype != DataType::Int64 {
-        result = result.cast(dtype)
-    }
-
-    result.into()
+    dsl::int_range(start, end, step, dtype).into()
 }
 
-pub fn int_ranges(start: &RbExpr, end: &RbExpr, step: i64, dtype: Wrap<DataType>) -> RbExpr {
+pub fn int_ranges(start: &RbExpr, end: &RbExpr, step: &RbExpr, dtype: Wrap<DataType>) -> RbExpr {
     let dtype = dtype.0;
 
-    let mut result = dsl::int_ranges(start.inner.clone(), end.inner.clone(), step);
+    let mut result = dsl::int_ranges(start.inner.clone(), end.inner.clone(), step.inner.clone());
 
     if dtype != DataType::Int64 {
         result = result.cast(DataType::List(Box::new(dtype)))