polars-df 0.25.1 → 0.26.1

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

@@ -16,6 +16,7 @@ use magnus::{
 use polars::chunked_array::object::PolarsObjectSafe;
 use polars::chunked_array::ops::{FillNullLimit, FillNullStrategy};
 use polars::datatypes::AnyValue;
+use polars::frame::PivotColumnNaming;
 use polars::frame::row::Row;
 use polars::io::avro::AvroCompression;
 use polars::prelude::default_values::{
@@ -36,6 +37,9 @@ use polars_utils::total_ord::{TotalEq, TotalHash};
 use crate::file::{RubyScanSourceInput, get_ruby_scan_source_input};
 use crate::object::OBJECT_NAME;
 use crate::rb_modules::pl_series;
+use crate::ruby::gvl::GvlExt;
+use crate::ruby::utils::TryIntoValue;
+use crate::series::import_schema_rbcapsule;
 use crate::utils::to_rb_err;
 use crate::{
     RbDataFrame, RbExpr, RbLazyFrame, RbPolarsErr, RbResult, RbSeries, RbTypeError, RbValueError,
@@ -80,11 +84,9 @@ pub(crate) fn get_series(obj: Value) -> RbResult<Series> {
     Ok(rbs.series.read().clone())
 }
 
-pub(crate) fn to_series(rb: &Ruby, s: RbSeries) -> Value {
+pub(crate) fn to_series(rb: &Ruby, s: RbSeries) -> RbResult<Value> {
     let series = pl_series(rb);
-    series
-        .funcall::<_, _, Value>("_from_rbseries", (s,))
-        .unwrap()
+    series.funcall::<_, _, Value>("_from_rbseries", (s,))
 }
 
 impl TryConvert for Wrap<PlSmallStr> {
@@ -116,140 +118,135 @@ impl TryConvert for Wrap<NullValues> {
     }
 }
 
-fn struct_dict<'a>(ruby: &Ruby, vals: impl Iterator<Item = AnyValue<'a>>, flds: &[Field]) -> Value {
+fn struct_dict<'a>(
+    ruby: &Ruby,
+    vals: impl Iterator<Item = AnyValue<'a>>,
+    flds: &[Field],
+) -> RbResult<Value> {
     let dict = ruby.hash_new();
     for (fld, val) in flds.iter().zip(vals) {
-        dict.aset(fld.name().as_str(), Wrap(val)).unwrap()
+        dict.aset(fld.name().as_str(), Wrap(val).try_into_value_with(ruby)?)?;
     }
-    dict.as_value()
+    Ok(dict.as_value())
 }
 
-impl IntoValue for Wrap<Series> {
-    fn into_value_with(self, ruby: &Ruby) -> Value {
+impl TryIntoValue for Wrap<Series> {
+    fn try_into_value_with(self, ruby: &Ruby) -> RbResult<Value> {
         to_series(ruby, RbSeries::new(self.0))
     }
 }
 
-impl IntoValue for Wrap<DataType> {
-    fn into_value_with(self, ruby: &Ruby) -> Value {
+impl TryIntoValue for Wrap<DataType> {
+    fn try_into_value_with(self, ruby: &Ruby) -> RbResult<Value> {
         let pl = crate::rb_modules::polars(ruby);
 
         match self.0 {
             DataType::Int8 => {
-                let class = pl.const_get::<_, Value>("Int8").unwrap();
-                class.funcall("new", ()).unwrap()
+                let class = pl.const_get::<_, Value>("Int8")?;
+                class.funcall("new", ())
             }
             DataType::Int16 => {
-                let class = pl.const_get::<_, Value>("Int16").unwrap();
-                class.funcall("new", ()).unwrap()
+                let class = pl.const_get::<_, Value>("Int16")?;
+                class.funcall("new", ())
             }
             DataType::Int32 => {
-                let class = pl.const_get::<_, Value>("Int32").unwrap();
-                class.funcall("new", ()).unwrap()
+                let class = pl.const_get::<_, Value>("Int32")?;
+                class.funcall("new", ())
             }
             DataType::Int64 => {
-                let class = pl.const_get::<_, Value>("Int64").unwrap();
-                class.funcall("new", ()).unwrap()
+                let class = pl.const_get::<_, Value>("Int64")?;
+                class.funcall("new", ())
             }
             DataType::Int128 => {
-                let class = pl.const_get::<_, Value>("Int128").unwrap();
-                class.funcall("new", ()).unwrap()
+                let class = pl.const_get::<_, Value>("Int128")?;
+                class.funcall("new", ())
             }
             DataType::UInt8 => {
-                let class = pl.const_get::<_, Value>("UInt8").unwrap();
-                class.funcall("new", ()).unwrap()
+                let class = pl.const_get::<_, Value>("UInt8")?;
+                class.funcall("new", ())
             }
             DataType::UInt16 => {
-                let class = pl.const_get::<_, Value>("UInt16").unwrap();
-                class.funcall("new", ()).unwrap()
+                let class = pl.const_get::<_, Value>("UInt16")?;
+                class.funcall("new", ())
             }
             DataType::UInt32 => {
-                let class = pl.const_get::<_, Value>("UInt32").unwrap();
-                class.funcall("new", ()).unwrap()
+                let class = pl.const_get::<_, Value>("UInt32")?;
+                class.funcall("new", ())
             }
             DataType::UInt64 => {
-                let class = pl.const_get::<_, Value>("UInt64").unwrap();
-                class.funcall("new", ()).unwrap()
+                let class = pl.const_get::<_, Value>("UInt64")?;
+                class.funcall("new", ())
             }
             DataType::UInt128 => {
-                let class = pl.const_get::<_, Value>("UInt128").unwrap();
-                class.funcall("new", ()).unwrap()
+                let class = pl.const_get::<_, Value>("UInt128")?;
+                class.funcall("new", ())
             }
             DataType::Float16 => {
-                let class = pl.const_get::<_, Value>("Float16").unwrap();
-                class.funcall("new", ()).unwrap()
+                let class = pl.const_get::<_, Value>("Float16")?;
+                class.funcall("new", ())
             }
             DataType::Float32 => {
-                let class = pl.const_get::<_, Value>("Float32").unwrap();
-                class.funcall("new", ()).unwrap()
+                let class = pl.const_get::<_, Value>("Float32")?;
+                class.funcall("new", ())
             }
             DataType::Float64 | DataType::Unknown(UnknownKind::Float) => {
-                let class = pl.const_get::<_, Value>("Float64").unwrap();
-                class.funcall("new", ()).unwrap()
+                let class = pl.const_get::<_, Value>("Float64")?;
+                class.funcall("new", ())
             }
             DataType::Decimal(precision, scale) => {
-                let class = pl.const_get::<_, Value>("Decimal").unwrap();
-                class
-                    .funcall::<_, _, Value>("new", (precision, scale))
-                    .unwrap()
+                let class = pl.const_get::<_, Value>("Decimal")?;
+                class.funcall::<_, _, Value>("new", (precision, scale))
             }
             DataType::Boolean => {
-                let class = pl.const_get::<_, Value>("Boolean").unwrap();
-                class.funcall("new", ()).unwrap()
+                let class = pl.const_get::<_, Value>("Boolean")?;
+                class.funcall("new", ())
             }
             DataType::String | DataType::Unknown(UnknownKind::Str) => {
-                let class = pl.const_get::<_, Value>("String").unwrap();
-                class.funcall("new", ()).unwrap()
+                let class = pl.const_get::<_, Value>("String")?;
+                class.funcall("new", ())
             }
             DataType::Binary => {
-                let class = pl.const_get::<_, Value>("Binary").unwrap();
-                class.funcall("new", ()).unwrap()
+                let class = pl.const_get::<_, Value>("Binary")?;
+                class.funcall("new", ())
             }
             DataType::Array(inner, size) => {
-                let class = pl.const_get::<_, Value>("Array").unwrap();
-                let inner = Wrap(*inner);
+                let class = pl.const_get::<_, Value>("Array")?;
+                let inner = Wrap(*inner).try_into_value_with(ruby)?;
                 let args = (inner, size);
-                class.funcall::<_, _, Value>("new", args).unwrap()
+                class.funcall::<_, _, Value>("new", args)
             }
             DataType::List(inner) => {
-                let class = pl.const_get::<_, Value>("List").unwrap();
-                let inner = Wrap(*inner);
-                class.funcall::<_, _, Value>("new", (inner,)).unwrap()
+                let class = pl.const_get::<_, Value>("List")?;
+                let inner = Wrap(*inner).try_into_value_with(ruby)?;
+                class.funcall::<_, _, Value>("new", (inner,))
             }
             DataType::Date => {
-                let class = pl.const_get::<_, Value>("Date").unwrap();
-                class.funcall("new", ()).unwrap()
+                let class = pl.const_get::<_, Value>("Date")?;
+                class.funcall("new", ())
             }
             DataType::Datetime(tu, tz) => {
-                let datetime_class = pl.const_get::<_, Value>("Datetime").unwrap();
-                datetime_class
-                    .funcall::<_, _, Value>(
-                        "new",
-                        (tu.to_ascii(), tz.as_deref().map(|x| x.as_str())),
-                    )
-                    .unwrap()
+                let datetime_class = pl.const_get::<_, Value>("Datetime")?;
+                datetime_class.funcall::<_, _, Value>(
+                    "new",
+                    (tu.to_ascii(), tz.as_deref().map(|x| x.as_str())),
+                )
             }
             DataType::Duration(tu) => {
-                let duration_class = pl.const_get::<_, Value>("Duration").unwrap();
-                duration_class
-                    .funcall::<_, _, Value>("new", (tu.to_ascii(),))
-                    .unwrap()
+                let duration_class = pl.const_get::<_, Value>("Duration")?;
+                duration_class.funcall::<_, _, Value>("new", (tu.to_ascii(),))
             }
             DataType::Object(_) => {
-                let class = pl.const_get::<_, Value>("Object").unwrap();
-                class.funcall("new", ()).unwrap()
+                let class = pl.const_get::<_, Value>("Object")?;
+                class.funcall("new", ())
             }
             DataType::Categorical(cats, _) => {
-                let categories_class = pl.const_get::<_, Value>("Categories").unwrap();
-                let categorical_class = pl.const_get::<_, Value>("Categorical").unwrap();
+                let categories_class = pl.const_get::<_, Value>("Categories")?;
+                let categorical_class = pl.const_get::<_, Value>("Categorical")?;
                 let categories: Value = categories_class
-                    .funcall("_from_rb_categories", (RbCategories::from(cats.clone()),))
-                    .unwrap();
+                    .funcall("_from_rb_categories", (RbCategories::from(cats.clone()),))?;
                 let kwargs = ruby.hash_new();
-                kwargs
-                    .aset(ruby.to_symbol("categories"), categories)
-                    .unwrap();
-                categorical_class.funcall("new", (kwargs,)).unwrap()
+                kwargs.aset(ruby.to_symbol("categories"), categories)?;
+                categorical_class.funcall("new", (kwargs,))
             }
             DataType::Enum(_, mapping) => {
                 let categories = unsafe {
@@ -258,42 +255,38 @@ impl IntoValue for Wrap<DataType> {
                         vec![mapping.to_arrow(true)],
                     )
                 };
-                let class = pl.const_get::<_, Value>("Enum").unwrap();
-                let series = to_series(ruby, categories.into_series().into());
-                class.funcall::<_, _, Value>("new", (series,)).unwrap()
+                let class = pl.const_get::<_, Value>("Enum")?;
+                let series = to_series(ruby, categories.into_series().into())?;
+                class.funcall::<_, _, Value>("new", (series,))
             }
             DataType::Time => {
-                let class = pl.const_get::<_, Value>("Time").unwrap();
-                class.funcall("new", ()).unwrap()
+                let class = pl.const_get::<_, Value>("Time")?;
+                class.funcall("new", ())
             }
             DataType::Struct(fields) => {
-                let field_class = pl.const_get::<_, Value>("Field").unwrap();
+                let field_class = pl.const_get::<_, Value>("Field")?;
                 let iter = fields.iter().map(|fld| {
                     let name = fld.name().as_str();
-                    let dtype = Wrap(fld.dtype().clone());
-                    field_class
-                        .funcall::<_, _, Value>("new", (name, dtype))
-                        .unwrap()
+                    let dtype = Wrap(fld.dtype().clone()).try_into_value_with(ruby);
+                    dtype.and_then(|dt| field_class.funcall::<_, _, Value>("new", (name, dt)))
                 });
-                let fields = ruby.ary_from_iter(iter);
-                let struct_class = pl.const_get::<_, Value>("Struct").unwrap();
-                struct_class
-                    .funcall::<_, _, Value>("new", (fields,))
-                    .unwrap()
+                let fields = ruby.ary_try_from_iter(iter)?;
+                let struct_class = pl.const_get::<_, Value>("Struct")?;
+                struct_class.funcall::<_, _, Value>("new", (fields,))
             }
             DataType::Null => {
-                let class = pl.const_get::<_, Value>("Null").unwrap();
-                class.funcall("new", ()).unwrap()
+                let class = pl.const_get::<_, Value>("Null")?;
+                class.funcall("new", ())
             }
             DataType::Extension(_typ, _storage) => {
                 todo!();
             }
             DataType::Unknown(UnknownKind::Int(v)) => {
-                Wrap(materialize_dyn_int(v).dtype()).into_value_with(ruby)
+                Wrap(materialize_dyn_int(v).dtype()).try_into_value_with(ruby)
             }
             DataType::Unknown(_) => {
-                let class = pl.const_get::<_, Value>("Unknown").unwrap();
-                class.funcall("new", ()).unwrap()
+                let class = pl.const_get::<_, Value>("Unknown")?;
+                class.funcall("new", ())
             }
             DataType::BinaryOffset => {
                 unimplemented!()
@@ -399,13 +392,12 @@ impl TryConvert for Wrap<DataType> {
                 "Polars::String" => DataType::String,
                 "Polars::Binary" => DataType::Binary,
                 "Polars::Categorical" => {
-                    let categories: Value = ob.funcall("categories", ()).unwrap();
-                    let rb_categories: &RbCategories =
-                        categories.funcall("_categories", ()).unwrap();
+                    let categories: Value = ob.funcall("categories", ())?;
+                    let rb_categories: &RbCategories = categories.funcall("_categories", ())?;
                     DataType::from_categories(rb_categories.categories().clone())
                 }
                 "Polars::Enum" => {
-                    let categories: Value = ob.funcall("categories", ()).unwrap();
+                    let categories: Value = ob.funcall("categories", ())?;
                     let s = get_series(categories)?;
                     let ca = s.str().map_err(RbPolarsErr::from)?;
                     let categories = ca.downcast_iter().next().unwrap().clone();
@@ -417,7 +409,7 @@ impl TryConvert for Wrap<DataType> {
                 "Polars::Date" => DataType::Date,
                 "Polars::Time" => DataType::Time,
                 "Polars::Datetime" => {
-                    let time_unit: Value = ob.funcall("time_unit", ()).unwrap();
+                    let time_unit: Value = ob.funcall("time_unit", ())?;
                     let time_unit = Wrap::<TimeUnit>::try_convert(time_unit)?.0;
                     let time_zone: Option<String> = ob.funcall("time_zone", ())?;
                     DataType::Datetime(
@@ -426,7 +418,7 @@ impl TryConvert for Wrap<DataType> {
                     )
                 }
                 "Polars::Duration" => {
-                    let time_unit: Value = ob.funcall("time_unit", ()).unwrap();
+                    let time_unit: Value = ob.funcall("time_unit", ())?;
                     let time_unit = Wrap::<TimeUnit>::try_convert(time_unit)?.0;
                     DataType::Duration(time_unit)
                 }
@@ -437,13 +429,13 @@ impl TryConvert for Wrap<DataType> {
                     DataType::Decimal(precision, scale)
                 }
                 "Polars::List" => {
-                    let inner: Value = ob.funcall("inner", ()).unwrap();
+                    let inner: Value = ob.funcall("inner", ())?;
                     let inner = Wrap::<DataType>::try_convert(inner)?;
                     DataType::List(Box::new(inner.0))
                 }
                 "Polars::Array" => {
-                    let inner: Value = ob.funcall("inner", ()).unwrap();
-                    let size: Value = ob.funcall("size", ()).unwrap();
+                    let inner: Value = ob.funcall("inner", ())?;
+                    let size: Value = ob.funcall("size", ())?;
                     let inner = Wrap::<DataType>::try_convert(inner)?;
                     let size = usize::try_convert(size)?;
                     DataType::Array(Box::new(inner.0), size)
@@ -524,7 +516,28 @@ impl TryConvert for Wrap<Schema> {
 impl TryConvert for Wrap<ArrowSchema> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let ruby = Ruby::get_with(ob);
-        // TODO improve
+
+        if let Ok(schema_capsule) = ob.funcall::<_, _, Value>("arrow_c_schema", ()) {
+            let field = import_schema_rbcapsule(schema_capsule)?;
+
+            let ArrowDataType::Struct(fields) = field.dtype else {
+                return Err(RbValueError::new_err(format!(
+                    "arrow_c_schema of object did not return struct dtype: \
+                    object: {:?}, dtype: {:?}",
+                    ob, &field.dtype
+                )));
+            };
+
+            let mut schema = ArrowSchema::from_iter_check_duplicates(fields).unwrap();
+
+            if let Some(md) = field.metadata {
+                *schema.metadata_mut() = Arc::unwrap_or_clone(md);
+            }
+
+            return Ok(Wrap(schema));
+        }
+
+        // TODO remove in 0.27.0
         let ob = RHash::try_convert(ob)?;
         let fields: RArray = ob.aref(ruby.to_symbol("fields"))?;
         let mut arrow_schema = ArrowSchema::with_capacity(fields.len());
@@ -555,6 +568,33 @@ impl TryConvert for Wrap<ArrowSchema> {
                 "binary_view" => ArrowDataType::BinaryView,
                 "string_view" => ArrowDataType::Utf8View,
                 "unknown" => ArrowDataType::Unknown,
+                "timestamp" => {
+                    let time_unit: String = f.aref(ruby.to_symbol("time_unit"))?;
+                    let time_zone: Option<String> = f.aref(ruby.to_symbol("time_zone"))?;
+                    let arrow_time_unit = match time_unit.as_str() {
+                        "us" => ArrowTimeUnit::Microsecond,
+                        "ns" => ArrowTimeUnit::Nanosecond,
+                        _ => todo!(),
+                    };
+                    ArrowDataType::Timestamp(arrow_time_unit, time_zone.map(|v| v.into()))
+                }
+                "time64" => {
+                    let time_unit: String = f.aref(ruby.to_symbol("time_unit"))?;
+                    let arrow_time_unit = match time_unit.as_str() {
+                        "us" => ArrowTimeUnit::Microsecond,
+                        _ => todo!(),
+                    };
+                    ArrowDataType::Time64(arrow_time_unit)
+                }
+                "decimal" => {
+                    let precision: usize = f.aref(ruby.to_symbol("precision"))?;
+                    let scale: usize = f.aref(ruby.to_symbol("scale"))?;
+                    ArrowDataType::Decimal(precision, scale)
+                }
+                "fixed_size_binary" => {
+                    let limit: usize = f.aref(ruby.to_symbol("limit"))?;
+                    ArrowDataType::FixedSizeBinary(limit)
+                }
                 _ => todo!(),
             };
             let is_nullable = f.aref(ruby.to_symbol("nullable"))?;
@@ -638,13 +678,13 @@ impl TryConvert for Wrap<ScanSources> {
     }
 }
 
-impl IntoValue for Wrap<Schema> {
-    fn into_value_with(self, ruby: &Ruby) -> Value {
+impl TryIntoValue for Wrap<Schema> {
+    fn try_into_value_with(self, ruby: &Ruby) -> RbResult<Value> {
         let dict = ruby.hash_new();
         for (k, v) in self.0.iter() {
-            dict.aset(k.as_str(), Wrap(v.clone())).unwrap();
+            dict.aset(k.as_str(), Wrap(v.clone()).try_into_value_with(ruby)?)?;
         }
-        dict.as_value()
+        Ok(dict.as_value())
     }
 }
 
@@ -655,18 +695,17 @@ pub struct ObjectValue {
 
 impl Debug for ObjectValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("ObjectValue")
-            .field("inner", &self.to_value())
-            .finish()
+        write!(f, "{}", self)
     }
 }
 
 impl Hash for ObjectValue {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        let h = self
-            .to_value()
-            .funcall::<_, _, isize>("hash", ())
-            .expect("should be hashable");
+        let h = Ruby::attach(|rb| {
+            rb.get_inner(self.inner)
+                .funcall::<_, _, isize>("hash", ())
+                .expect("should be hashable")
+        });
         state.write_isize(h)
     }
 }
@@ -675,7 +714,11 @@ impl Eq for ObjectValue {}
 
 impl PartialEq for ObjectValue {
     fn eq(&self, other: &Self) -> bool {
-        self.to_value().eql(other.to_value()).unwrap_or(false)
+        Ruby::attach(|ruby| {
+            ruby.get_inner(self.inner)
+                .eql(ruby.get_inner(other.inner))
+                .unwrap_or(false)
+        })
     }
 }
 
@@ -696,7 +739,10 @@ impl TotalHash for ObjectValue {
 
 impl Display for ObjectValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.to_value())
+        Ruby::attach(|rb| {
+            let v = rb.get_inner(self.inner);
+            write!(f, "{}", v)
+        })
     }
 }
 
@@ -724,12 +770,6 @@ impl From<&dyn PolarsObjectSafe> for &ObjectValue {
     }
 }
 
-impl ObjectValue {
-    pub fn to_value(&self) -> Value {
-        self.clone().into_value_with(&Ruby::get().unwrap())
-    }
-}
-
 impl IntoValue for ObjectValue {
     fn into_value_with(self, ruby: &Ruby) -> Value {
         ruby.get_inner(self.inner)
@@ -738,9 +778,9 @@ impl IntoValue for ObjectValue {
 
 impl Default for ObjectValue {
     fn default() -> Self {
-        ObjectValue {
-            inner: Ruby::get().unwrap().qnil().as_value().into(),
-        }
+        Ruby::attach(|rb| ObjectValue {
+            inner: rb.qnil().as_value().into(),
+        })
     }
 }
 
@@ -1125,6 +1165,21 @@ impl TryConvert for Wrap<SearchSortedSide> {
     }
 }
 
+impl TryConvert for Wrap<PivotColumnNaming> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let parsed = match String::try_convert(ob)?.as_str() {
+            "auto" => PivotColumnNaming::Auto,
+            "combine" => PivotColumnNaming::Combine,
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "`column_naming` must be one of {{'auto', 'combine'}}, got {v}",
+                )));
+            }
+        };
+        Ok(Wrap(parsed))
+    }
+}
+
 impl TryConvert for Wrap<ClosedInterval> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let parsed = match String::try_convert(ob)?.as_str() {
@@ -1234,15 +1289,25 @@ impl TryConvert for Wrap<CastColumnsPolicy> {
             return Ok(out);
         }
 
-        let integer_upcast = match &*ob.funcall::<_, _, String>("integer_cast", ())? {
-            "upcast" => true,
-            "forbid" => false,
-            v => {
-                return Err(RbValueError::new_err(format!(
-                    "unknown option for integer_cast: {v}"
-                )));
+        let mut integer_upcast = false;
+        let mut integer_to_float_cast = false;
+
+        let integer_cast_object: Value = ob.funcall("integer_cast", ())?;
+
+        parse_multiple_options("integer_cast", integer_cast_object, |v| {
+            match v {
+                "upcast" => integer_upcast = true,
+                "allow-float" => integer_to_float_cast = true,
+                "forbid" => {}
+                v => {
+                    return Err(RbValueError::new_err(format!(
+                        "unknown option for integer_cast: {v}"
+                    )));
+                }
             }
-        };
+
+            Ok(())
+        })?;
 
         let mut float_upcast = false;
         let mut float_downcast = false;
@@ -1318,6 +1383,7 @@ impl TryConvert for Wrap<CastColumnsPolicy> {
 
         return Ok(Wrap(CastColumnsPolicy {
             integer_upcast,
+            integer_to_float_cast,
             float_upcast,
             float_downcast,
             datetime_nanoseconds_downcast,
@@ -1364,12 +1430,9 @@ pub fn parse_fill_null_strategy(
         "zero" => FillNullStrategy::Zero,
         "one" => FillNullStrategy::One,
         e => {
-            return Err(magnus::Error::new(
-                Ruby::get().unwrap().exception_runtime_error(),
-                format!(
-                    "strategy must be one of {{'forward', 'backward', 'min', 'max', 'mean', 'zero', 'one'}}, got {e}",
-                ),
-            ));
+            return Err(RbValueError::new_err(format!(
+                "`strategy` must be one of {{'forward', 'backward', 'min', 'max', 'mean', 'zero', 'one'}}, got {e}",
+            )));
         }
     };
     Ok(parsed)

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

@@ -1,39 +1,42 @@
-use magnus::{IntoValue, Ruby, Value, prelude::*};
+use magnus::{Ruby, Value, prelude::*};
 
 use super::*;
 use crate::RbResult;
 use crate::conversion::{ObjectValue, Wrap};
 use crate::interop::arrow::to_rb::dataframe_to_stream;
+use crate::ruby::utils::TryIntoValue;
 
 impl RbDataFrame {
-    pub fn row_tuple(ruby: &Ruby, self_: &Self, idx: i64) -> Value {
+    pub fn row_tuple(ruby: &Ruby, self_: &Self, idx: i64) -> RbResult<Value> {
         let idx = if idx < 0 {
             (self_.df.read().height() as i64 + idx) as usize
         } else {
             idx as usize
         };
-        ruby.ary_from_iter(self_.df.read().columns().iter().map(|s| match s.dtype() {
+        ruby.ary_try_from_iter(self_.df.read().columns().iter().map(|s| match s.dtype() {
             DataType::Object(_) => {
                 let obj: Option<&ObjectValue> = s.get_object(idx).map(|any| any.into());
-                obj.unwrap().to_value()
+                // TODO remove unwrap and clone
+                obj.unwrap().clone().try_into_value_with(ruby)
             }
-            _ => Wrap(s.get(idx).unwrap()).into_value_with(ruby),
+            _ => Wrap(s.get(idx).unwrap()).try_into_value_with(ruby),
         }))
-        .as_value()
+        .map(|v| v.as_value())
     }
 
-    pub fn row_tuples(ruby: &Ruby, self_: &Self) -> Value {
+    pub fn row_tuples(ruby: &Ruby, self_: &Self) -> RbResult<Value> {
         let df = &self_.df;
-        ruby.ary_from_iter((0..df.read().height()).map(|idx| {
-            ruby.ary_from_iter(self_.df.read().columns().iter().map(|s| match s.dtype() {
+        ruby.ary_try_from_iter((0..df.read().height()).map(|idx| {
+            ruby.ary_try_from_iter(self_.df.read().columns().iter().map(|s| match s.dtype() {
                 DataType::Object(_) => {
                     let obj: Option<&ObjectValue> = s.get_object(idx).map(|any| any.into());
-                    obj.unwrap().to_value()
+                    // TODO remove unwrap and clone
+                    obj.unwrap().clone().try_into_value_with(ruby)
                 }
-                _ => Wrap(s.get(idx).unwrap()).into_value_with(ruby),
+                _ => Wrap(s.get(idx).unwrap()).try_into_value_with(ruby),
             }))
         }))
-        .as_value()
+        .map(|v| v.as_value())
     }
 
     pub fn __arrow_c_stream__(ruby: &Ruby, self_: &Self) -> RbResult<Value> {