polars-df 0.5.0 → 0.7.0

data/ext/polars/src/conversion.rs

@@ -1,11 +1,11 @@
-use std::fmt::{Display, Formatter};
+use std::fmt::{Debug, Display, Formatter};
 use std::hash::{Hash, Hasher};
 
+use magnus::encoding::{EncodingCapable, Index};
 use magnus::{
-    class, exception, r_hash::ForEach, ruby_handle::RubyHandle, Integer, IntoValue, Module, RArray,
-    RFloat, RHash, RString, Symbol, TryConvert, Value, QNIL,
+    class, exception, prelude::*, r_hash::ForEach, value::Opaque, Float, Integer, IntoValue,
+    Module, RArray, RHash, RString, Ruby, Symbol, TryConvert, Value,
 };
-use magnus::encoding::{EncodingCapable, Index};
 use polars::chunked_array::object::PolarsObjectSafe;
 use polars::chunked_array::ops::{FillNullLimit, FillNullStrategy};
 use polars::datatypes::AnyValue;
@@ -14,10 +14,12 @@ 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 smartstring::alias::String as SmartString;
 
+use crate::object::OBJECT_NAME;
 use crate::rb_modules::utils;
-use crate::{RbDataFrame, RbLazyFrame, RbPolarsErr, RbResult, RbSeries, RbValueError};
+use crate::{RbDataFrame, RbLazyFrame, RbPolarsErr, RbResult, RbSeries, RbTypeError, RbValueError};
 
 pub(crate) fn slice_to_wrapped<T>(slice: &[T]) -> &[Wrap<T>] {
     // Safety:
@@ -56,7 +58,7 @@ impl<T> From<T> for Wrap<T> {
 }
 
 pub(crate) fn get_rbseq(obj: Value) -> RbResult<(RArray, usize)> {
-    let seq: RArray = obj.try_convert()?;
+    let seq = RArray::try_convert(obj)?;
     let len = seq.len();
     Ok((seq, len))
 }
@@ -83,7 +85,7 @@ impl TryConvert for Wrap<Utf8Chunked> {
 
         for res in seq.each() {
             let item = res?;
-            match item.try_convert::<String>() {
+            match String::try_convert(item) {
                 Ok(val) => builder.append_value(&val),
                 Err(_) => builder.append_null(),
             }
@@ -99,7 +101,7 @@ impl TryConvert for Wrap<BinaryChunked> {
 
         for res in seq.each() {
             let item = res?;
-            match item.try_convert::<RString>() {
+            match RString::try_convert(item) {
                 Ok(val) => builder.append_value(unsafe { val.as_slice() }),
                 Err(_) => builder.append_null(),
             }
@@ -110,11 +112,11 @@ impl TryConvert for Wrap<BinaryChunked> {
 
 impl TryConvert for Wrap<NullValues> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        if let Ok(s) = ob.try_convert::<String>() {
+        if let Ok(s) = String::try_convert(ob) {
             Ok(Wrap(NullValues::AllColumnsSingle(s)))
-        } else if let Ok(s) = ob.try_convert::<Vec<String>>() {
+        } else if let Ok(s) = Vec::<String>::try_convert(ob) {
             Ok(Wrap(NullValues::AllColumns(s)))
-        } else if let Ok(s) = ob.try_convert::<Vec<(String, String)>>() {
+        } else if let Ok(s) = Vec::<(String, String)>::try_convert(ob) {
             Ok(Wrap(NullValues::Named(s)))
         } else {
             Err(RbPolarsErr::other(
@@ -133,86 +135,66 @@ fn struct_dict<'a>(vals: impl Iterator<Item = AnyValue<'a>>, flds: &[Field]) ->
 }
 
 impl IntoValue for Wrap<AnyValue<'_>> {
-    fn into_value_with(self, _: &RubyHandle) -> Value {
+    fn into_value_with(self, ruby: &Ruby) -> Value {
         match self.0 {
-            AnyValue::UInt8(v) => Value::from(v),
-            AnyValue::UInt16(v) => Value::from(v),
-            AnyValue::UInt32(v) => Value::from(v),
-            AnyValue::UInt64(v) => Value::from(v),
-            AnyValue::Int8(v) => Value::from(v),
-            AnyValue::Int16(v) => Value::from(v),
-            AnyValue::Int32(v) => Value::from(v),
-            AnyValue::Int64(v) => Value::from(v),
-            AnyValue::Float32(v) => Value::from(v),
-            AnyValue::Float64(v) => Value::from(v),
-            AnyValue::Null => *QNIL,
-            AnyValue::Boolean(v) => Value::from(v),
-            AnyValue::Utf8(v) => Value::from(v),
-            AnyValue::Utf8Owned(v) => Value::from(v.as_str()),
-            AnyValue::Categorical(_idx, _rev, _arr) => todo!(),
-            AnyValue::Date(v) => class::time()
-                .funcall::<_, _, Value>("at", (v * 86400,))
-                .unwrap()
-                .funcall::<_, _, Value>("utc", ())
-                .unwrap()
-                .funcall::<_, _, Value>("to_date", ())
-                .unwrap(),
-            AnyValue::Datetime(v, tu, tz) => {
-                let t = match tu {
-                    TimeUnit::Nanoseconds => {
-                        let sec = v / 1000000000;
-                        let subsec = v % 1000000000;
-                        class::time()
-                            .funcall::<_, _, Value>("at", (sec, subsec, Symbol::new("nsec")))
-                            .unwrap()
-                    }
-                    TimeUnit::Microseconds => {
-                        let sec = v / 1000000;
-                        let subsec = v % 1000000;
-                        class::time()
-                            .funcall::<_, _, Value>("at", (sec, subsec, Symbol::new("usec")))
-                            .unwrap()
-                    }
-                    TimeUnit::Milliseconds => {
-                        let sec = v / 1000;
-                        let subsec = v % 1000;
-                        class::time()
-                            .funcall::<_, _, Value>("at", (sec, subsec, Symbol::new("millisecond")))
-                            .unwrap()
-                    }
-                };
-
-                if tz.is_some() {
-                    todo!();
+            AnyValue::UInt8(v) => ruby.into_value(v),
+            AnyValue::UInt16(v) => ruby.into_value(v),
+            AnyValue::UInt32(v) => ruby.into_value(v),
+            AnyValue::UInt64(v) => ruby.into_value(v),
+            AnyValue::Int8(v) => ruby.into_value(v),
+            AnyValue::Int16(v) => ruby.into_value(v),
+            AnyValue::Int32(v) => ruby.into_value(v),
+            AnyValue::Int64(v) => ruby.into_value(v),
+            AnyValue::Float32(v) => ruby.into_value(v),
+            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::Categorical(idx, rev, arr) => {
+                let s = if arr.is_null() {
+                    rev.get(idx)
                 } else {
-                    t.funcall::<_, _, Value>("utc", ()).unwrap()
-                }
+                    unsafe { arr.deref_unchecked().value(idx as usize) }
+                };
+                s.into_value()
+            }
+            AnyValue::Date(v) => utils().funcall("_to_ruby_date", (v,)).unwrap(),
+            AnyValue::Datetime(v, time_unit, time_zone) => {
+                let time_unit = time_unit.to_ascii();
+                utils()
+                    .funcall("_to_ruby_datetime", (v, time_unit, time_zone.clone()))
+                    .unwrap()
             }
-            AnyValue::Duration(v, tu) => {
-                let tu = tu.to_ascii();
-                utils().funcall("_to_ruby_duration", (v, tu)).unwrap()
+            AnyValue::Duration(v, time_unit) => {
+                let time_unit = time_unit.to_ascii();
+                utils()
+                    .funcall("_to_ruby_duration", (v, time_unit))
+                    .unwrap()
             }
-            AnyValue::Time(_v) => todo!(),
-            AnyValue::List(v) => RbSeries::new(v).to_a().into_value(),
+            AnyValue::Time(v) => utils().funcall("_to_ruby_time", (v,)).unwrap(),
+            AnyValue::Array(v, _) | AnyValue::List(v) => RbSeries::new(v).to_a().into_value(),
             ref av @ AnyValue::Struct(_, _, flds) => struct_dict(av._iter_struct_av(), flds),
             AnyValue::StructOwned(payload) => struct_dict(payload.0.into_iter(), &payload.1),
             AnyValue::Object(v) => {
                 let object = v.as_any().downcast_ref::<ObjectValue>().unwrap();
-                object.inner
+                object.to_object()
             }
             AnyValue::ObjectOwned(v) => {
                 let object = v.0.as_any().downcast_ref::<ObjectValue>().unwrap();
-                object.inner
+                object.to_object()
             }
             AnyValue::Binary(v) => RString::from_slice(v).into_value(),
             AnyValue::BinaryOwned(v) => RString::from_slice(&v).into_value(),
-            AnyValue::Decimal(_v, _scale) => todo!(),
+            AnyValue::Decimal(v, scale) => utils()
+                .funcall("_to_ruby_decimal", (v.to_string(), -(scale as i32)))
+                .unwrap(),
         }
     }
 }
 
 impl IntoValue for Wrap<DataType> {
-    fn into_value_with(self, _: &RubyHandle) -> Value {
+    fn into_value_with(self, _: &Ruby) -> Value {
         let pl = crate::rb_modules::polars();
 
         match self.0 {
@@ -226,10 +208,22 @@ impl IntoValue for Wrap<DataType> {
             DataType::UInt64 => pl.const_get::<_, Value>("UInt64").unwrap(),
             DataType::Float32 => pl.const_get::<_, Value>("Float32").unwrap(),
             DataType::Float64 => pl.const_get::<_, Value>("Float64").unwrap(),
-            DataType::Decimal(_precision, _scale) => todo!(),
+            DataType::Decimal(precision, scale) => {
+                let decimal_class = pl.const_get::<_, Value>("Decimal").unwrap();
+                decimal_class
+                    .funcall::<_, _, Value>("new", (precision, scale))
+                    .unwrap()
+            }
             DataType::Boolean => pl.const_get::<_, Value>("Boolean").unwrap(),
             DataType::Utf8 => pl.const_get::<_, Value>("Utf8").unwrap(),
             DataType::Binary => pl.const_get::<_, Value>("Binary").unwrap(),
+            DataType::Array(inner, size) => {
+                let inner = Wrap(*inner);
+                let list_class = pl.const_get::<_, Value>("Array").unwrap();
+                list_class
+                    .funcall::<_, _, Value>("new", (size, inner))
+                    .unwrap()
+            }
             DataType::List(inner) => {
                 let inner = Wrap(*inner);
                 let list_class = pl.const_get::<_, Value>("List").unwrap();
@@ -273,7 +267,7 @@ impl IntoValue for Wrap<DataType> {
 }
 
 impl IntoValue for Wrap<TimeUnit> {
-    fn into_value_with(self, _: &RubyHandle) -> Value {
+    fn into_value_with(self, _: &Ruby) -> Value {
         let tu = match self.0 {
             TimeUnit::Nanoseconds => "ns",
             TimeUnit::Microseconds => "us",
@@ -284,14 +278,14 @@ impl IntoValue for Wrap<TimeUnit> {
 }
 
 impl IntoValue for Wrap<&Utf8Chunked> {
-    fn into_value_with(self, _: &RubyHandle) -> Value {
+    fn into_value_with(self, _: &Ruby) -> Value {
         let iter = self.0.into_iter();
         RArray::from_iter(iter).into_value()
     }
 }
 
 impl IntoValue for Wrap<&BinaryChunked> {
-    fn into_value_with(self, _: &RubyHandle) -> Value {
+    fn into_value_with(self, _: &Ruby) -> Value {
         let iter = self
             .0
             .into_iter()
@@ -301,7 +295,7 @@ impl IntoValue for Wrap<&BinaryChunked> {
 }
 
 impl IntoValue for Wrap<&StructChunked> {
-    fn into_value_with(self, _: &RubyHandle) -> Value {
+    fn into_value_with(self, _: &Ruby) -> Value {
         let s = self.0.clone().into_series();
         // todo! iterate its chunks and flatten.
         // make series::iter() accept a chunk index.
@@ -319,13 +313,64 @@ impl IntoValue for Wrap<&StructChunked> {
 }
 
 impl IntoValue for Wrap<&DurationChunked> {
-    fn into_value_with(self, _: &RubyHandle) -> Value {
+    fn into_value_with(self, _: &Ruby) -> Value {
+        let utils = utils();
+        let time_unit = Wrap(self.0.time_unit()).into_value();
+        let iter = self.0.into_iter().map(|opt_v| {
+            opt_v.map(|v| {
+                utils
+                    .funcall::<_, _, Value>("_to_ruby_duration", (v, time_unit))
+                    .unwrap()
+            })
+        });
+        RArray::from_iter(iter).into_value()
+    }
+}
+
+impl IntoValue for Wrap<&DatetimeChunked> {
+    fn into_value_with(self, _: &Ruby) -> Value {
+        let utils = utils();
+        let time_unit = Wrap(self.0.time_unit()).into_value();
+        let time_zone = self.0.time_zone().clone().into_value();
+        let iter = self.0.into_iter().map(|opt_v| {
+            opt_v.map(|v| {
+                utils
+                    .funcall::<_, _, Value>("_to_ruby_datetime", (v, time_unit, time_zone))
+                    .unwrap()
+            })
+        });
+        RArray::from_iter(iter).into_value()
+    }
+}
+
+impl IntoValue for Wrap<&TimeChunked> {
+    fn into_value_with(self, _: &Ruby) -> Value {
+        let utils = utils();
+        let iter = self.0.into_iter().map(|opt_v| {
+            opt_v.map(|v| utils.funcall::<_, _, Value>("_to_ruby_time", (v,)).unwrap())
+        });
+        RArray::from_iter(iter).into_value()
+    }
+}
+
+impl IntoValue for Wrap<&DateChunked> {
+    fn into_value_with(self, _: &Ruby) -> Value {
+        let utils = utils();
+        let iter = self.0.into_iter().map(|opt_v| {
+            opt_v.map(|v| utils.funcall::<_, _, Value>("_to_ruby_date", (v,)).unwrap())
+        });
+        RArray::from_iter(iter).into_value()
+    }
+}
+
+impl IntoValue for Wrap<&DecimalChunked> {
+    fn into_value_with(self, _: &Ruby) -> Value {
         let utils = utils();
-        let tu = Wrap(self.0.time_unit()).into_value();
+        let rb_scale = (-(self.0.scale() as i32)).into_value();
         let iter = self.0.into_iter().map(|opt_v| {
             opt_v.map(|v| {
                 utils
-                    .funcall::<_, _, Value>("_to_ruby_duration", (v, tu))
+                    .funcall::<_, _, Value>("_to_ruby_decimal", (v.to_string(), rb_scale))
                     .unwrap()
             })
         });
@@ -333,6 +378,13 @@ impl IntoValue for Wrap<&DurationChunked> {
     }
 }
 
+fn abs_decimal_from_digits(digits: String, exp: i32) -> Option<(i128, usize)> {
+    match digits.parse::<i128>() {
+        Ok(v) => Some((v, ((digits.len() as i32) - exp) as usize)),
+        Err(_) => None,
+    }
+}
+
 impl TryConvert for Wrap<Field> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let name: String = ob.funcall("name", ())?;
@@ -362,10 +414,11 @@ impl TryConvert for Wrap<DataType> {
                 "Polars::Datetime" => DataType::Datetime(TimeUnit::Microseconds, None),
                 "Polars::Time" => DataType::Time,
                 "Polars::Duration" => DataType::Duration(TimeUnit::Microseconds),
+                "Polars::Decimal" => DataType::Decimal(None, None),
                 "Polars::Float32" => DataType::Float32,
                 "Polars::Float64" => DataType::Float64,
-                // "Polars::Object" => DataType::Object(OBJECT_NAME),
-                "Polars::List" => DataType::List(Box::new(DataType::Boolean)),
+                "Polars::Object" => DataType::Object(OBJECT_NAME),
+                "Polars::List" => DataType::List(Box::new(DataType::Null)),
                 "Polars::Null" => DataType::Null,
                 "Polars::Unknown" => DataType::Unknown,
                 dt => {
@@ -375,21 +428,47 @@ impl TryConvert for Wrap<DataType> {
                 }
             }
         // TODO improve
-        } else if ob.try_convert::<String>().is_err() {
+        } else if String::try_convert(ob).is_err() {
             let name = unsafe { ob.class().name() }.into_owned();
             match name.as_str() {
+                "Polars::Duration" => {
+                    let time_unit: Value = ob.funcall("time_unit", ()).unwrap();
+                    let time_unit = Wrap::<TimeUnit>::try_convert(time_unit)?.0;
+                    DataType::Duration(time_unit)
+                }
+                "Polars::Datetime" => {
+                    let time_unit: Value = ob.funcall("time_unit", ()).unwrap();
+                    let time_unit = Wrap::<TimeUnit>::try_convert(time_unit)?.0;
+                    let time_zone = ob.funcall("time_zone", ())?;
+                    DataType::Datetime(time_unit, time_zone)
+                }
+                "Polars::Decimal" => {
+                    let precision = ob.funcall("precision", ())?;
+                    let scale = ob.funcall("scale", ())?;
+                    DataType::Decimal(precision, Some(scale))
+                }
+                "Polars::List" => {
+                    let inner: Value = ob.funcall("inner", ()).unwrap();
+                    let inner = Wrap::<DataType>::try_convert(inner)?;
+                    DataType::List(Box::new(inner.0))
+                }
                 "Polars::Struct" => {
                     let arr: RArray = ob.funcall("fields", ())?;
                     let mut fields = Vec::with_capacity(arr.len());
                     for v in arr.each() {
-                        fields.push(v?.try_convert::<Wrap<Field>>()?.0);
+                        fields.push(Wrap::<Field>::try_convert(v?)?.0);
                     }
                     DataType::Struct(fields)
                 }
-                _ => todo!(),
+                dt => {
+                    return Err(RbTypeError::new_err(format!(
+                        "A {dt} object is not a correct polars DataType. \
+                        Hint: use the class without instantiating it.",
+                    )))
+                }
             }
         } else {
-            match ob.try_convert::<String>()?.as_str() {
+            match String::try_convert(ob)?.as_str() {
                 "u8" => DataType::UInt8,
                 "u16" => DataType::UInt16,
                 "u32" => DataType::UInt32,
@@ -408,7 +487,7 @@ impl TryConvert for Wrap<DataType> {
                 "time" => DataType::Time,
                 "dur" => DataType::Duration(TimeUnit::Microseconds),
                 "f64" => DataType::Float64,
-                // "obj" => DataType::Object(OBJECT_NAME),
+                "obj" => DataType::Object(OBJECT_NAME),
                 "list" => DataType::List(Box::new(DataType::Boolean)),
                 "null" => DataType::Null,
                 "unk" => DataType::Unknown,
@@ -427,10 +506,10 @@ impl TryConvert for Wrap<DataType> {
 impl<'s> TryConvert for Wrap<AnyValue<'s>> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         if ob.is_kind_of(class::true_class()) || ob.is_kind_of(class::false_class()) {
-            Ok(AnyValue::Boolean(ob.try_convert::<bool>()?).into())
+            Ok(AnyValue::Boolean(bool::try_convert(ob)?).into())
         } else if let Some(v) = Integer::from_value(ob) {
             Ok(AnyValue::Int64(v.to_i64()?).into())
-        } else if let Some(v) = RFloat::from_value(ob) {
+        } else if let Some(v) = Float::from_value(ob) {
             Ok(AnyValue::Float64(v.to_f64()).into())
         } else if let Some(v) = RString::from_value(ob) {
             if v.enc_get() == Index::utf8() {
@@ -443,7 +522,8 @@ impl<'s> TryConvert for Wrap<AnyValue<'s>> {
             let sec = ob.funcall::<_, _, i64>("to_i", ())?;
             let nsec = ob.funcall::<_, _, i64>("nsec", ())?;
             let v = sec * 1_000_000_000 + nsec;
-            // TODO support time zone
+            // TODO support time zone when possible
+            // https://github.com/pola-rs/polars/issues/9103
             Ok(AnyValue::Datetime(v, TimeUnit::Nanoseconds, &None).into())
         } else if ob.is_nil() {
             Ok(AnyValue::Null.into())
@@ -452,8 +532,8 @@ impl<'s> TryConvert for Wrap<AnyValue<'s>> {
             let mut keys = Vec::with_capacity(len);
             let mut vals = Vec::with_capacity(len);
             dict.foreach(|k: Value, v: Value| {
-                let key = k.try_convert::<String>()?;
-                let val = v.try_convert::<Wrap<AnyValue>>()?.0;
+                let key = String::try_convert(k)?;
+                let val = Wrap::<AnyValue>::try_convert(v)?.0;
                 let dtype = DataType::from(&val);
                 keys.push(Field::new(&key, dtype));
                 vals.push(val);
@@ -464,13 +544,23 @@ impl<'s> TryConvert for Wrap<AnyValue<'s>> {
             if v.is_empty() {
                 Ok(Wrap(AnyValue::List(Series::new_empty("", &DataType::Null))))
             } else {
-                let avs = v.try_convert::<Wrap<Row>>()?.0 .0;
-                // use first `n` values to infer datatype
-                // this value is not too large as this will be done with every
-                // anyvalue that has to be converted, which can be many
-                let n = 25;
-                let dtype = any_values_to_dtype(&avs[..std::cmp::min(avs.len(), n)])
-                    .map_err(RbPolarsErr::from)?;
+                let list = v;
+
+                let mut avs = Vec::with_capacity(25);
+                let mut iter = list.each();
+
+                for item in (&mut iter).take(25) {
+                    avs.push(Wrap::<AnyValue>::try_convert(item?)?.0)
+                }
+
+                let (dtype, _n_types) = any_values_to_dtype(&avs).map_err(RbPolarsErr::from)?;
+
+                // push the rest
+                avs.reserve(list.len());
+                for item in iter {
+                    avs.push(Wrap::<AnyValue>::try_convert(item?)?.0)
+                }
+
                 let s = Series::from_any_values_and_dtype("", &avs, &dtype, true)
                     .map_err(RbPolarsErr::from)?;
                 Ok(Wrap(AnyValue::List(s)))
@@ -478,7 +568,11 @@ impl<'s> TryConvert for Wrap<AnyValue<'s>> {
         } else if ob.is_kind_of(crate::rb_modules::datetime()) {
             let sec: i64 = ob.funcall("to_i", ())?;
             let nsec: i64 = ob.funcall("nsec", ())?;
-            Ok(Wrap(AnyValue::Datetime(sec * 1_000_000_000 + nsec, TimeUnit::Nanoseconds, &None)))
+            Ok(Wrap(AnyValue::Datetime(
+                sec * 1_000_000_000 + nsec,
+                TimeUnit::Nanoseconds,
+                &None,
+            )))
         } else if ob.is_kind_of(crate::rb_modules::date()) {
             // convert to DateTime for UTC
             let v = ob
@@ -486,6 +580,16 @@ impl<'s> TryConvert for Wrap<AnyValue<'s>> {
                 .funcall::<_, _, Value>("to_time", ())?
                 .funcall::<_, _, i64>("to_i", ())?;
             Ok(Wrap(AnyValue::Date((v / 86400) as i32)))
+        } else if ob.is_kind_of(crate::rb_modules::bigdecimal()) {
+            let (sign, digits, _, exp): (i8, String, i32, i32) = ob.funcall("split", ()).unwrap();
+            let (mut v, scale) = abs_decimal_from_digits(digits, exp).ok_or_else(|| {
+                RbPolarsErr::other("BigDecimal is too large to fit in Decimal128".into())
+            })?;
+            if sign < 0 {
+                // TODO better error
+                v = v.checked_neg().unwrap();
+            }
+            Ok(Wrap(AnyValue::Decimal(v, scale)))
         } else {
             Err(RbPolarsErr::other(format!(
                 "object type not supported {:?}",
@@ -498,8 +602,8 @@ impl<'s> TryConvert for Wrap<AnyValue<'s>> {
 impl<'s> TryConvert for Wrap<Row<'s>> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let mut vals: Vec<Wrap<AnyValue<'s>>> = Vec::new();
-        for item in ob.try_convert::<RArray>()?.each() {
-            vals.push(item?.try_convert::<Wrap<AnyValue<'s>>>()?);
+        for item in RArray::try_convert(ob)?.each() {
+            vals.push(Wrap::<AnyValue<'s>>::try_convert(item?)?);
         }
         let vals: Vec<AnyValue> = unsafe { std::mem::transmute(vals) };
         Ok(Wrap(Row(vals)))
@@ -508,7 +612,7 @@ impl<'s> TryConvert for Wrap<Row<'s>> {
 
 impl TryConvert for Wrap<Schema> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        let dict = ob.try_convert::<RHash>()?;
+        let dict = RHash::try_convert(ob)?;
 
         let mut schema = Vec::new();
         dict.foreach(|key: String, val: Wrap<DataType>| {
@@ -521,15 +625,23 @@ impl TryConvert for Wrap<Schema> {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub struct ObjectValue {
-    pub inner: Value,
+    pub inner: Opaque<Value>,
+}
+
+impl Debug for ObjectValue {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ObjectValue")
+            .field("inner", &self.to_object())
+            .finish()
+    }
 }
 
 impl Hash for ObjectValue {
     fn hash<H: Hasher>(&self, state: &mut H) {
         let h = self
-            .inner
+            .to_object()
             .funcall::<_, _, isize>("hash", ())
             .expect("should be hashable");
         state.write_isize(h)
@@ -540,13 +652,19 @@ impl Eq for ObjectValue {}
 
 impl PartialEq for ObjectValue {
     fn eq(&self, other: &Self) -> bool {
-        self.inner.eql(&other.inner).unwrap_or(false)
+        self.to_object().eql(other.to_object()).unwrap_or(false)
+    }
+}
+
+impl TotalEq for ObjectValue {
+    fn tot_eq(&self, other: &Self) -> bool {
+        self == other
     }
 }
 
 impl Display for ObjectValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.inner)
+        write!(f, "{}", self.to_object())
     }
 }
 
@@ -558,13 +676,13 @@ impl PolarsObject for ObjectValue {
 
 impl From<Value> for ObjectValue {
     fn from(v: Value) -> Self {
-        Self { inner: v }
+        Self { inner: v.into() }
     }
 }
 
 impl TryConvert for ObjectValue {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        Ok(ObjectValue { inner: ob })
+        Ok(ObjectValue { inner: ob.into() })
     }
 }
 
@@ -577,19 +695,21 @@ impl From<&dyn PolarsObjectSafe> for &ObjectValue {
 // TODO remove
 impl ObjectValue {
     pub fn to_object(&self) -> Value {
-        self.inner
+        Ruby::get().unwrap().get_inner(self.inner)
     }
 }
 
 impl IntoValue for ObjectValue {
-    fn into_value_with(self, _: &RubyHandle) -> Value {
-        self.inner
+    fn into_value_with(self, _: &Ruby) -> Value {
+        self.to_object()
     }
 }
 
 impl Default for ObjectValue {
     fn default() -> Self {
-        ObjectValue { inner: *QNIL }
+        ObjectValue {
+            inner: Ruby::get().unwrap().qnil().as_value().into(),
+        }
     }
 }
 
@@ -602,13 +722,13 @@ pub(crate) fn dicts_to_rows(
     let mut key_names = PlIndexSet::new();
     for d in dicts.each().take(infer_schema_len) {
         let d = d?;
-        let d = d.try_convert::<RHash>()?;
+        let d = RHash::try_convert(d)?;
 
         d.foreach(|name: Value, _value: Value| {
             if let Some(v) = Symbol::from_value(name) {
                 key_names.insert(v.name()?.into());
             } else {
-                key_names.insert(name.try_convert::<String>()?);
+                key_names.insert(String::try_convert(name)?);
             };
             Ok(ForEach::Continue)
         })?;
@@ -618,7 +738,7 @@ pub(crate) fn dicts_to_rows(
 
     for d in dicts.each() {
         let d = d?;
-        let d = d.try_convert::<RHash>()?;
+        let d = RHash::try_convert(d)?;
 
         let mut row = Vec::with_capacity(key_names.len());
 
@@ -626,7 +746,7 @@ pub(crate) fn dicts_to_rows(
             // TODO improve performance
             let val = match d.get(k.clone()).or_else(|| d.get(Symbol::new(k))) {
                 None => AnyValue::Null,
-                Some(val) => val.try_convert::<Wrap<AnyValue>>()?.0,
+                Some(val) => Wrap::<AnyValue>::try_convert(val)?.0,
             };
             row.push(val)
         }
@@ -637,7 +757,7 @@ pub(crate) fn dicts_to_rows(
 
 impl TryConvert for Wrap<AsofStrategy> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        let parsed = match ob.try_convert::<String>()?.as_str() {
+        let parsed = match String::try_convert(ob)?.as_str() {
             "backward" => AsofStrategy::Backward,
             "forward" => AsofStrategy::Forward,
             v => {
@@ -653,7 +773,7 @@ impl TryConvert for Wrap<AsofStrategy> {
 
 impl TryConvert for Wrap<InterpolationMethod> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        let parsed = match ob.try_convert::<String>()?.as_str() {
+        let parsed = match String::try_convert(ob)?.as_str() {
             "linear" => InterpolationMethod::Linear,
             "nearest" => InterpolationMethod::Nearest,
             v => {
@@ -668,7 +788,7 @@ impl TryConvert for Wrap<InterpolationMethod> {
 
 impl TryConvert for Wrap<Option<AvroCompression>> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        let parsed = match ob.try_convert::<String>()?.as_str() {
+        let parsed = match String::try_convert(ob)?.as_str() {
             "uncompressed" => None,
             "snappy" => Some(AvroCompression::Snappy),
             "deflate" => Some(AvroCompression::Deflate),
@@ -685,7 +805,7 @@ impl TryConvert for Wrap<Option<AvroCompression>> {
 
 impl TryConvert for Wrap<CategoricalOrdering> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        let parsed = match ob.try_convert::<String>()?.as_str() {
+        let parsed = match String::try_convert(ob)?.as_str() {
             "physical" => CategoricalOrdering::Physical,
             "lexical" => CategoricalOrdering::Lexical,
             v => {
@@ -701,7 +821,7 @@ impl TryConvert for Wrap<CategoricalOrdering> {
 
 impl TryConvert for Wrap<StartBy> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        let parsed = match ob.try_convert::<String>()?.as_str() {
+        let parsed = match String::try_convert(ob)?.as_str() {
             "window" => StartBy::WindowBound,
             "datapoint" => StartBy::DataPoint,
             "monday" => StartBy::Monday,
@@ -717,7 +837,7 @@ impl TryConvert for Wrap<StartBy> {
 
 impl TryConvert for Wrap<ClosedWindow> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        let parsed = match ob.try_convert::<String>()?.as_str() {
+        let parsed = match String::try_convert(ob)?.as_str() {
             "left" => ClosedWindow::Left,
             "right" => ClosedWindow::Right,
             "both" => ClosedWindow::Both,
@@ -735,7 +855,7 @@ impl TryConvert for Wrap<ClosedWindow> {
 
 impl TryConvert for Wrap<CsvEncoding> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        let parsed = match ob.try_convert::<String>()?.as_str() {
+        let parsed = match String::try_convert(ob)?.as_str() {
             "utf8" => CsvEncoding::Utf8,
             "utf8-lossy" => CsvEncoding::LossyUtf8,
             v => {
@@ -751,7 +871,7 @@ impl TryConvert for Wrap<CsvEncoding> {
 
 impl TryConvert for Wrap<Option<IpcCompression>> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        let parsed = match ob.try_convert::<String>()?.as_str() {
+        let parsed = match String::try_convert(ob)?.as_str() {
             "uncompressed" => None,
             "lz4" => Some(IpcCompression::LZ4),
             "zstd" => Some(IpcCompression::ZSTD),
@@ -768,7 +888,7 @@ impl TryConvert for Wrap<Option<IpcCompression>> {
 
 impl TryConvert for Wrap<JoinType> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        let parsed = match ob.try_convert::<String>()?.as_str() {
+        let parsed = match String::try_convert(ob)?.as_str() {
             "inner" => JoinType::Inner,
             "left" => JoinType::Left,
             "outer" => JoinType::Outer,
@@ -787,9 +907,25 @@ impl TryConvert for Wrap<JoinType> {
     }
 }
 
+impl TryConvert for Wrap<Label> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let parsed = match String::try_convert(ob)?.as_str() {
+            "left" => Label::Left,
+            "right" => Label::Right,
+            "datapoint" => Label::DataPoint,
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "`label` must be one of {{'left', 'right', 'datapoint'}}, got {v}",
+                )))
+            }
+        };
+        Ok(Wrap(parsed))
+    }
+}
+
 impl TryConvert for Wrap<ListToStructWidthStrategy> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        let parsed = match ob.try_convert::<String>()?.as_str() {
+        let parsed = match String::try_convert(ob)?.as_str() {
             "first_non_null" => ListToStructWidthStrategy::FirstNonNull,
             "max_width" => ListToStructWidthStrategy::MaxWidth,
             v => {
@@ -805,7 +941,7 @@ impl TryConvert for Wrap<ListToStructWidthStrategy> {
 
 impl TryConvert for Wrap<NullBehavior> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        let parsed = match ob.try_convert::<String>()?.as_str() {
+        let parsed = match String::try_convert(ob)?.as_str() {
             "drop" => NullBehavior::Drop,
             "ignore" => NullBehavior::Ignore,
             v => {
@@ -821,7 +957,7 @@ impl TryConvert for Wrap<NullBehavior> {
 
 impl TryConvert for Wrap<NullStrategy> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        let parsed = match ob.try_convert::<String>()?.as_str() {
+        let parsed = match String::try_convert(ob)?.as_str() {
             "ignore" => NullStrategy::Ignore,
             "propagate" => NullStrategy::Propagate,
             v => {
@@ -837,7 +973,7 @@ impl TryConvert for Wrap<NullStrategy> {
 
 impl TryConvert for Wrap<ParallelStrategy> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        let parsed = match ob.try_convert::<String>()?.as_str() {
+        let parsed = match String::try_convert(ob)?.as_str() {
             "auto" => ParallelStrategy::Auto,
             "columns" => ParallelStrategy::Columns,
             "row_groups" => ParallelStrategy::RowGroups,
@@ -855,7 +991,7 @@ impl TryConvert for Wrap<ParallelStrategy> {
 
 impl TryConvert for Wrap<QuantileInterpolOptions> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        let parsed = match ob.try_convert::<String>()?.as_str() {
+        let parsed = match String::try_convert(ob)?.as_str() {
             "lower" => QuantileInterpolOptions::Lower,
             "higher" => QuantileInterpolOptions::Higher,
             "nearest" => QuantileInterpolOptions::Nearest,
@@ -874,7 +1010,7 @@ impl TryConvert for Wrap<QuantileInterpolOptions> {
 
 impl TryConvert for Wrap<RankMethod> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        let parsed = match ob.try_convert::<String>()?.as_str() {
+        let parsed = match String::try_convert(ob)?.as_str() {
             "min" => RankMethod::Min,
             "max" => RankMethod::Max,
             "average" => RankMethod::Average,
@@ -894,7 +1030,7 @@ impl TryConvert for Wrap<RankMethod> {
 
 impl TryConvert for Wrap<TimeUnit> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        let parsed = match ob.try_convert::<String>()?.as_str() {
+        let parsed = match String::try_convert(ob)?.as_str() {
             "ns" => TimeUnit::Nanoseconds,
             "us" => TimeUnit::Microseconds,
             "ms" => TimeUnit::Milliseconds,
@@ -911,7 +1047,7 @@ impl TryConvert for Wrap<TimeUnit> {
 
 impl TryConvert for Wrap<UniqueKeepStrategy> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        let parsed = match ob.try_convert::<String>()?.as_str() {
+        let parsed = match String::try_convert(ob)?.as_str() {
             "first" => UniqueKeepStrategy::First,
             "last" => UniqueKeepStrategy::Last,
             v => {
@@ -927,7 +1063,7 @@ impl TryConvert for Wrap<UniqueKeepStrategy> {
 
 impl TryConvert for Wrap<SearchSortedSide> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        let parsed = match ob.try_convert::<String>()?.as_str() {
+        let parsed = match String::try_convert(ob)?.as_str() {
             "any" => SearchSortedSide::Any,
             "left" => SearchSortedSide::Left,
             "right" => SearchSortedSide::Right,