polars-df 0.21.1 → 0.23.0

data/ext/polars/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "polars"
-version = "0.21.1"
+version = "0.23.0"
 license = "MIT"
 authors = ["Andrew Kane <andrew@ankane.org>"]
 edition = "2024"
-rust-version = "1.85.0"
+rust-version = "1.89.0"
 publish = false
 
 [lib]
@@ -12,25 +12,27 @@ crate-type = ["cdylib"]
 
 [dependencies]
 ahash = "0.8"
-arrow = { package = "polars-arrow", version = "=0.50.0" }
+arrow = { package = "polars-arrow", version = "=0.52.0" }
 bytes = "1"
 chrono = "0.4"
 either = "1.8"
-magnus = { git = "https://github.com/matsadler/magnus.git", rev = "4125ee2ab5a405d17aa6d7503961c1ecdbe499ef", features = ["chrono"] }
+magnus = { version = "0.8", features = ["chrono"] }
 num-traits = "0.2"
-polars-core = "=0.50.0"
-polars-dtype = "=0.50.0"
-polars-io = "=0.50.0"
-polars-lazy = { version = "=0.50.0", features = ["catalog"] }
-polars-plan = "=0.50.0"
-polars-parquet = "=0.50.0"
-polars-utils = "=0.50.0"
+polars-compute = "=0.52.0"
+polars-core = "=0.52.0"
+polars-dtype = "=0.52.0"
+polars-error = "=0.52.0"
+polars-io = "=0.52.0"
+polars-lazy = { version = "=0.52.0", features = ["catalog"] }
+polars-plan = "=0.52.0"
+polars-parquet = "=0.52.0"
+polars-utils = "=0.52.0"
 rayon = "1.9"
 regex = "1"
 serde_json = "1"
 
 [dependencies.polars]
-version = "=0.50.0"
+version = "=0.52.0"
 features = [
     "abs",
     "approx_unique",
@@ -141,3 +143,7 @@ jemallocator = { version = "0.5", features = ["disable_initial_exec_tls"] }
 
 [target.'cfg(not(any(target_os = "linux", target_os = "windows")))'.dependencies]
 mimalloc = { version = "0.1", default-features = false }
+
+[features]
+default = []
+serialize_binary = []

data/ext/polars/src/batched_csv.rs

@@ -2,7 +2,7 @@ use std::cell::RefCell;
 use std::path::PathBuf;
 use std::sync::Mutex;
 
-use magnus::{RArray, Value, prelude::*};
+use magnus::{RArray, Ruby, Value, prelude::*};
 use polars::io::RowIndex;
 use polars::io::csv::read::OwnedBatchedCsvReader;
 use polars::io::mmap::MmapBytesReader;
@@ -124,8 +124,8 @@ impl RbBatchedCsv {
         })
     }
 
-    pub fn next_batches(&self, n: usize) -> RbResult<Option<RArray>> {
-        let reader = &self.reader;
+    pub fn next_batches(ruby: &Ruby, rb_self: &Self, n: usize) -> RbResult<Option<RArray>> {
+        let reader = &rb_self.reader;
         let batches = reader
             .borrow()
             .lock()
@@ -133,6 +133,6 @@ impl RbBatchedCsv {
             .next_batches(n)
             .map_err(RbPolarsErr::from)?;
 
-        Ok(batches.map(|batches| RArray::from_iter(batches.into_iter().map(RbDataFrame::from))))
+        Ok(batches.map(|batches| ruby.ary_from_iter(batches.into_iter().map(RbDataFrame::from))))
     }
 }

data/ext/polars/src/catalog/unity.rs

@@ -1,7 +1,7 @@
 use std::str::FromStr;
 
 use magnus::value::{Lazy, ReprValue};
-use magnus::{IntoValue, Module, RArray, RClass, RHash, RModule, Ruby, Value};
+use magnus::{IntoValue, Module, RClass, RHash, RModule, Ruby, Value};
 use polars::prelude::{PlHashMap, PlSmallStr, Schema};
 use polars_io::catalog::unity::client::{CatalogClient, CatalogClientBuilder};
 use polars_io::catalog::unity::models::{
@@ -85,15 +85,15 @@ impl RbCatalogClient {
         builder.build().map(RbCatalogClient).map_err(to_rb_err)
     }
 
-    pub fn list_catalogs(&self) -> RbResult<Value> {
+    pub fn list_catalogs(ruby: &Ruby, rb_self: &Self) -> RbResult<Value> {
         let v = pl_async::get_runtime()
-            .block_in_place_on(self.client().list_catalogs())
+            .block_in_place_on(rb_self.client().list_catalogs())
             .map_err(to_rb_err)?;
 
         let mut opt_err = None;
 
-        let out = RArray::from_iter(v.into_iter().map(|x| {
-            let v = catalog_info_to_rbobject(x);
+        let out = ruby.ary_from_iter(v.into_iter().map(|x| {
+            let v = catalog_info_to_rbobject(ruby, x);
             if let Ok(v) = v {
                 Some(v)
             } else {
@@ -104,18 +104,18 @@ impl RbCatalogClient {
 
         opt_err.transpose()?;
 
-        Ok(out.into_value())
+        Ok(out.as_value())
     }
 
-    pub fn list_namespaces(&self, catalog_name: String) -> RbResult<Value> {
+    pub fn list_namespaces(ruby: &Ruby, rb_self: &Self, catalog_name: String) -> RbResult<Value> {
         let v = pl_async::get_runtime()
-            .block_in_place_on(self.client().list_namespaces(&catalog_name))
+            .block_in_place_on(rb_self.client().list_namespaces(&catalog_name))
             .map_err(to_rb_err)?;
 
         let mut opt_err = None;
 
-        let out = RArray::from_iter(v.into_iter().map(|x| {
-            let v = namespace_info_to_rbobject(x);
+        let out = ruby.ary_from_iter(v.into_iter().map(|x| {
+            let v = namespace_info_to_rbobject(ruby, x);
             match v {
                 Ok(v) => Some(v),
                 Err(_) => {
@@ -127,27 +127,33 @@ impl RbCatalogClient {
 
         opt_err.transpose()?;
 
-        Ok(out.into_value())
+        Ok(out.as_value())
     }
 
-    pub fn list_tables(&self, catalog_name: String, namespace: String) -> RbResult<Value> {
+    pub fn list_tables(
+        ruby: &Ruby,
+        rb_self: &Self,
+        catalog_name: String,
+        namespace: String,
+    ) -> RbResult<Value> {
         let v = pl_async::get_runtime()
-            .block_in_place_on(self.client().list_tables(&catalog_name, &namespace))
+            .block_in_place_on(rb_self.client().list_tables(&catalog_name, &namespace))
             .map_err(to_rb_err)?;
 
         let mut opt_err = None;
 
-        let out = RArray::from_iter(v.into_iter().map(|table_info| {
-            let v = table_info_to_rbobject(table_info);
+        let out = ruby
+            .ary_from_iter(v.into_iter().map(|table_info| {
+                let v = table_info_to_rbobject(ruby, table_info);
 
-            if let Ok(v) = v {
-                Some(v)
-            } else {
-                opt_err.replace(v);
-                None
-            }
-        }))
-        .into_value();
+                if let Ok(v) = v {
+                    Some(v)
+                } else {
+                    opt_err.replace(v);
+                    None
+                }
+            }))
+            .as_value();
 
         opt_err.transpose()?;
 
@@ -155,36 +161,39 @@ impl RbCatalogClient {
     }
 
     pub fn get_table_info(
-        &self,
+        ruby: &Ruby,
+        rb_self: &Self,
         table_name: String,
         catalog_name: String,
         namespace: String,
     ) -> RbResult<Value> {
         let table_info = pl_async::get_runtime()
-            .block_in_place_on(
-                self.client()
-                    .get_table_info(&table_name, &catalog_name, &namespace),
-            )
+            .block_in_place_on(rb_self.client().get_table_info(
+                &table_name,
+                &catalog_name,
+                &namespace,
+            ))
             .map_err(to_rb_err)?;
 
-        table_info_to_rbobject(table_info)
+        table_info_to_rbobject(ruby, table_info)
     }
 
     pub fn create_catalog(
-        &self,
+        ruby: &Ruby,
+        rb_self: &Self,
         catalog_name: String,
         comment: Option<String>,
         storage_root: Option<String>,
     ) -> RbResult<Value> {
         let catalog_info = pl_async::get_runtime()
-            .block_in_place_on(self.client().create_catalog(
+            .block_in_place_on(rb_self.client().create_catalog(
                 &catalog_name,
                 comment.as_deref(),
                 storage_root.as_deref(),
             ))
             .map_err(to_rb_err)?;
 
-        catalog_info_to_rbobject(catalog_info)
+        catalog_info_to_rbobject(ruby, catalog_info)
     }
 
     pub fn delete_catalog(&self, catalog_name: String, force: bool) -> RbResult<()> {
@@ -194,14 +203,15 @@ impl RbCatalogClient {
     }
 
     pub fn create_namespace(
-        &self,
+        ruby: &Ruby,
+        rb_self: &Self,
         catalog_name: String,
         namespace: String,
         comment: Option<String>,
         storage_root: Option<String>,
     ) -> RbResult<Value> {
         let namespace_info = pl_async::get_runtime()
-            .block_in_place_on(self.client().create_namespace(
+            .block_in_place_on(rb_self.client().create_namespace(
                 &catalog_name,
                 &namespace,
                 comment.as_deref(),
@@ -209,7 +219,7 @@ impl RbCatalogClient {
             ))
             .map_err(to_rb_err)?;
 
-        namespace_info_to_rbobject(namespace_info)
+        namespace_info_to_rbobject(ruby, namespace_info)
     }
 
     pub fn delete_namespace(
@@ -228,7 +238,8 @@ impl RbCatalogClient {
 
     #[allow(clippy::too_many_arguments)]
     pub fn create_table(
-        &self,
+        ruby: &Ruby,
+        rb_self: &Self,
         catalog_name: String,
         namespace: String,
         table_name: String,
@@ -241,7 +252,7 @@ impl RbCatalogClient {
     ) -> RbResult<Value> {
         let table_info = pl_async::get_runtime()
             .block_in_place_on(
-                self.client().create_table(
+                rb_self.client().create_table(
                     &catalog_name,
                     &namespace,
                     &table_name,
@@ -261,7 +272,7 @@ impl RbCatalogClient {
             )
             .map_err(to_rb_err)?;
 
-        table_info_to_rbobject(table_info)
+        table_info_to_rbobject(ruby, table_info)
     }
 
     pub fn delete_table(
@@ -278,8 +289,8 @@ impl RbCatalogClient {
             .map_err(to_rb_err)
     }
 
-    pub fn type_json_to_polars_type(type_json: String) -> RbResult<Value> {
-        Ok(Wrap(parse_type_json_str(&type_json).map_err(to_rb_err)?).into_value())
+    pub fn type_json_to_polars_type(ruby: &Ruby, type_json: String) -> RbResult<Value> {
+        Ok(Wrap(parse_type_json_str(&type_json).map_err(to_rb_err)?).into_value_with(ruby))
     }
 }
 
@@ -290,6 +301,7 @@ impl RbCatalogClient {
 }
 
 fn catalog_info_to_rbobject(
+    ruby: &Ruby,
     CatalogInfo {
         name,
         comment,
@@ -302,10 +314,10 @@ fn catalog_info_to_rbobject(
         updated_by,
     }: CatalogInfo,
 ) -> RbResult<Value> {
-    let dict = RHash::new();
+    let dict = ruby.hash_new();
 
-    let properties = properties_to_rbobject(properties);
-    let options = properties_to_rbobject(options);
+    let properties = properties_to_rbobject(ruby, properties);
+    let options = properties_to_rbobject(ruby, options);
 
     rbdict_insert_keys!(dict, {
         name,
@@ -319,13 +331,11 @@ fn catalog_info_to_rbobject(
         updated_by
     });
 
-    Ruby::get()
-        .unwrap()
-        .get_inner(&CATALOG_INFO_CLS)
-        .funcall("new", (dict,))
+    ruby.get_inner(&CATALOG_INFO_CLS).funcall("new", (dict,))
 }
 
 fn namespace_info_to_rbobject(
+    ruby: &Ruby,
     NamespaceInfo {
         name,
         comment,
@@ -337,9 +347,9 @@ fn namespace_info_to_rbobject(
         updated_by,
     }: NamespaceInfo,
 ) -> RbResult<Value> {
-    let dict = RHash::new();
+    let dict = ruby.hash_new();
 
-    let properties = properties_to_rbobject(properties);
+    let properties = properties_to_rbobject(ruby, properties);
 
     rbdict_insert_keys!(dict, {
         name,
@@ -352,13 +362,10 @@ fn namespace_info_to_rbobject(
         updated_by
     });
 
-    Ruby::get()
-        .unwrap()
-        .get_inner(&NAMESPACE_INFO_CLS)
-        .funcall("new", (dict,))
+    ruby.get_inner(&NAMESPACE_INFO_CLS).funcall("new", (dict,))
 }
 
-fn table_info_to_rbobject(table_info: TableInfo) -> RbResult<Value> {
+fn table_info_to_rbobject(ruby: &Ruby, table_info: TableInfo) -> RbResult<Value> {
     let TableInfo {
         name,
         table_id,
@@ -374,49 +381,47 @@ fn table_info_to_rbobject(table_info: TableInfo) -> RbResult<Value> {
         updated_by,
     } = table_info;
 
-    let column_info_cls = Ruby::get().unwrap().get_inner(&COLUMN_INFO_CLS);
+    let column_info_cls = ruby.get_inner(&COLUMN_INFO_CLS);
 
     let columns = columns
         .map(|columns| {
-            Ruby::get()
-                .unwrap()
-                .ary_try_from_iter(columns.into_iter().map(
-                    |ColumnInfo {
-                         name,
-                         type_name,
-                         type_text,
-                         type_json,
-                         position,
-                         comment,
-                         partition_index,
-                     }| {
-                        let dict = RHash::new();
-
-                        let name = name.as_str();
-                        let type_name = type_name.as_str();
-                        let type_text = type_text.as_str();
-
-                        rbdict_insert_keys!(dict, {
-                            name,
-                            type_name,
-                            type_text,
-                            type_json,
-                            position,
-                            comment,
-                            partition_index,
-                        });
-
-                        column_info_cls.funcall::<_, _, Value>("new", (dict,))
-                    },
-                ))
+            ruby.ary_try_from_iter(columns.into_iter().map(
+                |ColumnInfo {
+                     name,
+                     type_name,
+                     type_text,
+                     type_json,
+                     position,
+                     comment,
+                     partition_index,
+                 }| {
+                    let dict = ruby.hash_new();
+
+                    let name = name.as_str();
+                    let type_name = type_name.as_str();
+                    let type_text = type_text.as_str();
+
+                    rbdict_insert_keys!(dict, {
+                        name,
+                        type_name,
+                        type_text,
+                        type_json,
+                        position,
+                        comment,
+                        partition_index,
+                    });
+
+                    column_info_cls.funcall::<_, _, Value>("new", (dict,))
+                },
+            ))
         })
         .transpose()?;
 
-    let dict = RHash::new();
+    let dict = ruby.hash_new();
 
     let data_source_format = data_source_format.map(|x| x.to_string());
     let table_type = table_type.to_string();
-    let properties = properties_to_rbobject(properties);
+    let properties = properties_to_rbobject(ruby, properties);
 
     rbdict_insert_keys!(dict, {
         name,
@@ -433,14 +438,11 @@ fn table_info_to_rbobject(table_info: TableInfo) -> RbResult<Value> {
         updated_by,
     });
 
-    Ruby::get()
-        .unwrap()
-        .get_inner(&TABLE_INFO_CLS)
-        .funcall("new", (dict,))
+    ruby.get_inner(&TABLE_INFO_CLS).funcall("new", (dict,))
 }
 
-fn properties_to_rbobject(properties: PlHashMap<PlSmallStr, String>) -> RHash {
-    let dict = RHash::new();
+fn properties_to_rbobject(ruby: &Ruby, properties: PlHashMap<PlSmallStr, String>) -> RHash {
+    let dict = ruby.hash_new();
 
     for (key, value) in properties.into_iter() {
         dict.aset(key.as_str(), value).unwrap();

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

@@ -1,14 +1,16 @@
-use magnus::encoding::{EncodingCapable, Index};
+use magnus::encoding::EncodingCapable;
 use magnus::{
-    IntoValue, RArray, RHash, RString, Ruby, TryConvert, Value, class, prelude::*, r_hash::ForEach,
+    IntoValue, RArray, RHash, RString, Ruby, TryConvert, Value, prelude::*, r_hash::ForEach,
 };
 use polars::prelude::*;
+use polars_compute::decimal::{DEC128_MAX_PREC, DecimalFmtBuffer, dec128_fits};
 use polars_core::utils::any_values_to_supertype_and_n_dtypes;
 
+use super::datetime::datetime_to_rb_object;
 use super::{ObjectValue, Wrap, struct_dict};
 
 use crate::exceptions::RbOverflowError;
-use crate::rb_modules::utils;
+use crate::rb_modules::pl_utils;
 use crate::{RbErr, RbPolarsErr, RbResult, RbSeries};
 
 impl IntoValue for Wrap<AnyValue<'_>> {
@@ -29,11 +31,12 @@ pub(crate) fn any_value_into_rb_object(av: AnyValue, ruby: &Ruby) -> Value {
         AnyValue::UInt16(v) => ruby.into_value(v),
         AnyValue::UInt32(v) => ruby.into_value(v),
         AnyValue::UInt64(v) => ruby.into_value(v),
+        AnyValue::UInt128(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::Int128(_v) => todo!(),
+        AnyValue::Int128(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(),
@@ -41,12 +44,12 @@ pub(crate) fn any_value_into_rb_object(av: AnyValue, ruby: &Ruby) -> Value {
         AnyValue::String(v) => ruby.into_value(v),
         AnyValue::StringOwned(v) => ruby.into_value(v.as_str()),
         AnyValue::Categorical(cat, map) | AnyValue::Enum(cat, map) => unsafe {
-            map.cat_to_str_unchecked(cat).into_value()
+            map.cat_to_str_unchecked(cat).into_value_with(ruby)
         },
         AnyValue::CategoricalOwned(cat, map) | AnyValue::EnumOwned(cat, map) => unsafe {
-            map.cat_to_str_unchecked(cat).into_value()
+            map.cat_to_str_unchecked(cat).into_value_with(ruby)
         },
-        AnyValue::Date(v) => utils().funcall("_to_ruby_date", (v,)).unwrap(),
+        AnyValue::Date(v) => pl_utils().funcall("_to_ruby_date", (v,)).unwrap(),
         AnyValue::Datetime(v, time_unit, time_zone) => {
             datetime_to_rb_object(v, time_unit, time_zone)
         }
@@ -55,14 +58,14 @@ pub(crate) fn any_value_into_rb_object(av: AnyValue, ruby: &Ruby) -> Value {
         }
         AnyValue::Duration(v, time_unit) => {
             let time_unit = time_unit.to_ascii();
-            utils()
+            pl_utils()
                 .funcall("_to_ruby_duration", (v, time_unit))
                 .unwrap()
         }
-        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::Time(v) => pl_utils().funcall("_to_ruby_time", (v,)).unwrap(),
+        AnyValue::Array(v, _) | AnyValue::List(v) => RbSeries::new(v).to_a().as_value(),
+        ref av @ AnyValue::Struct(_, _, flds) => struct_dict(ruby, av._iter_struct_av(), flds),
+        AnyValue::StructOwned(payload) => struct_dict(ruby, payload.0.into_iter(), &payload.1),
         AnyValue::Object(v) => {
             let object = v.as_any().downcast_ref::<ObjectValue>().unwrap();
             object.to_value()
@@ -71,21 +74,16 @@ pub(crate) fn any_value_into_rb_object(av: AnyValue, ruby: &Ruby) -> Value {
             let object = v.0.as_any().downcast_ref::<ObjectValue>().unwrap();
             object.to_value()
         }
-        AnyValue::Binary(v) => RString::from_slice(v).into_value(),
-        AnyValue::BinaryOwned(v) => RString::from_slice(&v).into_value(),
-        AnyValue::Decimal(v, scale) => utils()
-            .funcall("_to_ruby_decimal", (v.to_string(), -(scale as i32)))
-            .unwrap(),
+        AnyValue::Binary(v) => ruby.str_from_slice(v).as_value(),
+        AnyValue::BinaryOwned(v) => ruby.str_from_slice(&v).as_value(),
+        AnyValue::Decimal(v, prec, scale) => {
+            let mut buf = DecimalFmtBuffer::new();
+            let s = buf.format_dec128(v, scale, false, false);
+            pl_utils().funcall("_to_ruby_decimal", (prec, s)).unwrap()
+        }
     }
 }
 
-fn datetime_to_rb_object(v: i64, tu: TimeUnit, tz: Option<&TimeZone>) -> Value {
-    let tu = tu.to_ascii();
-    utils()
-        .funcall("_to_ruby_datetime", (v, tu, tz.map(|v| v.to_string())))
-        .unwrap()
-}
-
 pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<AnyValue<'s>> {
     // Conversion functions.
     fn get_null(_ob: Value, _strict: bool) -> RbResult<AnyValue<'static>> {
@@ -100,8 +98,12 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
     fn get_int(ob: Value, strict: bool) -> RbResult<AnyValue<'static>> {
         if let Ok(v) = i64::try_convert(ob) {
             Ok(AnyValue::Int64(v))
+        } else if let Ok(v) = i128::try_convert(ob) {
+            Ok(AnyValue::Int128(v))
         } else if let Ok(v) = u64::try_convert(ob) {
             Ok(AnyValue::UInt64(v))
+        } else if let Ok(v) = u128::try_convert(ob) {
+            Ok(AnyValue::UInt128(v))
         } else if !strict {
             let f = f64::try_convert(ob)?;
             Ok(AnyValue::Float64(f))
@@ -117,8 +119,9 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
     }
 
     fn get_str(ob: Value, _strict: bool) -> RbResult<AnyValue<'static>> {
+        let ruby = Ruby::get_with(ob);
         let v = RString::from_value(ob).unwrap();
-        if v.enc_get() == Index::utf8() {
+        if v.enc_get() == ruby.utf8_encindex() {
             Ok(AnyValue::StringOwned(v.to_string()?.into()))
         } else {
             Ok(AnyValue::BinaryOwned(unsafe { v.as_slice() }.to_vec()))
@@ -211,14 +214,12 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
             match digits.parse::<i128>() {
                 Ok(mut v) => {
                     let scale = if exp > 0 {
-                        v = 10_i128
-                            .checked_pow(exp as u32)
-                            .and_then(|factor| v.checked_mul(factor))?;
+                        v = 10_i128.checked_pow(exp as u32)?.checked_mul(v)?;
                         0
                     } else {
                         (-exp) as usize
                     };
-                    Some((v, scale))
+                    dec128_fits(v, DEC128_MAX_PREC).then_some((v, scale))
                 }
                 Err(_) => None,
             }
@@ -234,27 +235,28 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
             // TODO better error
             v = v.checked_neg().unwrap();
         }
-        Ok(AnyValue::Decimal(v, scale))
+        Ok(AnyValue::Decimal(v, DEC128_MAX_PREC, scale))
     }
 
+    let ruby = Ruby::get_with(ob);
     if ob.is_nil() {
         get_null(ob, strict)
-    } else if ob.is_kind_of(class::true_class()) || ob.is_kind_of(class::false_class()) {
+    } else if ob.is_kind_of(ruby.class_true_class()) || ob.is_kind_of(ruby.class_false_class()) {
         get_bool(ob, strict)
-    } else if ob.is_kind_of(class::integer()) {
+    } else if ob.is_kind_of(ruby.class_integer()) {
         get_int(ob, strict)
-    } else if ob.is_kind_of(class::float()) {
+    } else if ob.is_kind_of(ruby.class_float()) {
         get_float(ob, strict)
-    } else if ob.is_kind_of(class::string()) {
+    } else if ob.is_kind_of(ruby.class_string()) {
         get_str(ob, strict)
-    } else if ob.is_kind_of(class::array()) {
+    } else if ob.is_kind_of(ruby.class_array()) {
         get_list(ob, strict)
-    } else if ob.is_kind_of(class::hash()) {
+    } else if ob.is_kind_of(ruby.class_hash()) {
         get_struct(ob, strict)
     } else if ob.respond_to("_s", true)? {
         get_list_from_series(ob, strict)
     // call is_a? for ActiveSupport::TimeWithZone
-    } else if ob.funcall::<_, _, bool>("is_a?", (class::time(),))? {
+    } else if ob.funcall::<_, _, bool>("is_a?", (ruby.class_time(),))? {
         get_time(ob, strict)
     } else if ob.is_kind_of(crate::rb_modules::datetime()) {
         get_datetime(ob, strict)