polars-df 0.25.1 → 0.26.0

data/LICENSE.txt

@@ -1,5 +1,5 @@
 Copyright (c) 2025 Ritchie Vink
-Copyright (c) 2022-2025 Andrew Kane
+Copyright (c) 2022-2026 Andrew Kane
 Some portions Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy

data/README.md

@@ -32,9 +32,7 @@ You can follow [Polars tutorials](https://docs.pola.rs/user-guide/getting-starte
 - [DataFrame](https://www.rubydoc.info/gems/polars-df/Polars/DataFrame)
 - [LazyFrame](https://www.rubydoc.info/gems/polars-df/Polars/LazyFrame)
 
-## Examples
-
-### Creating DataFrames
+## Creating DataFrames
 
 From a CSV
 

data/ext/polars/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "polars-ruby"
-version = "0.25.1"
+version = "0.26.0"
 license = "MIT"
 authors = ["Andrew Kane <andrew@ankane.org>"]
 edition = "2024"
@@ -13,37 +13,38 @@ crate-type = ["cdylib"]
 
 [dependencies]
 ahash = "0.8"
-arrow = { package = "polars-arrow", version = "=0.53.0" }
+arrow = { package = "polars-arrow", version = "=0.54.4" }
 bytes = "1"
 chrono = "0.4"
+chrono-tz = "0.10"
 either = "1.8"
 magnus = { version = "0.8", features = ["chrono"] }
 num-traits = "0.2"
 parking_lot = "0.12"
-polars-buffer = "=0.53.0"
-polars-compute = "=0.53.0"
-polars-core = "=0.53.0"
-polars-dtype = "=0.53.0"
-polars-error = "=0.53.0"
-polars-io = "=0.53.0"
-polars-lazy = { version = "=0.53.0", features = ["catalog"] }
-polars-ops = "=0.53.0"
-polars-plan = "=0.53.0"
-polars-parquet = "=0.53.0"
-polars-testing = "=0.53.0"
-polars-utils = "=0.53.0"
+polars-buffer = "=0.54.4"
+polars-compute = "=0.54.4"
+polars-config = "=0.54.4"
+polars-core = "=0.54.4"
+polars-dtype = "=0.54.4"
+polars-error = "=0.54.4"
+polars-io = "=0.54.4"
+polars-lazy = { version = "=0.54.4", features = ["catalog"] }
+polars-ops = "=0.54.4"
+polars-plan = "=0.54.4"
+polars-parquet = "=0.54.4"
+polars-testing = "=0.54.4"
+polars-utils = "=0.54.4"
 rayon = "1.9"
 rb-sys = "0.9"
 regex = "1"
 serde_json = "1"
 
 [dependencies.polars]
-version = "=0.53.0"
+version = "=0.54.4"
 features = [
     "abs",
     "approx_unique",
     "arg_where",
-    "array_any_all",
     "array_count",
     "array_to_struct",
     "asof_join",
@@ -93,7 +94,6 @@ features = [
     "is_unique",
     "json",
     "lazy",
-    "list_any_all",
     "list_count",
     "list_drop_nulls",
     "list_eval",
@@ -154,7 +154,7 @@ features = [
 mimalloc = { version = "0.1", default-features = false }
 
 [target.'cfg(target_os = "linux")'.dependencies]
-tikv-jemallocator = { version = "0.6", features = ["disable_initial_exec_tls"] }
+tikv-jemallocator = { version = "0.7", features = ["disable_initial_exec_tls"] }
 
 [features]
 default = []

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

@@ -1,17 +1,18 @@
 use std::str::FromStr;
 
 use magnus::value::{Lazy, ReprValue};
-use magnus::{IntoValue, Module, RClass, RHash, RModule, Ruby, Value};
+use magnus::{Module, RClass, RHash, RModule, Ruby, Value};
 use polars::prelude::{PlHashMap, PlSmallStr, PolarsError, Schema};
+use polars_core::runtime::ASYNC;
 use polars_io::catalog::unity::client::{CatalogClient, CatalogClientBuilder};
 use polars_io::catalog::unity::models::{
     CatalogInfo, ColumnInfo, DataSourceFormat, NamespaceInfo, TableInfo, TableType,
 };
 use polars_io::catalog::unity::schema::parse_type_json_str;
-use polars_io::pl_async;
 
 use crate::rb_modules::polars;
 use crate::ruby::gvl::GvlExt;
+use crate::ruby::utils::TryIntoValue;
 use crate::utils::EnterPolarsExt;
 use crate::utils::to_rb_err;
 use crate::{RbResult, Wrap};
@@ -88,9 +89,7 @@ impl RbCatalogClient {
     }
 
     pub fn list_catalogs(rb: &Ruby, self_: &Self) -> RbResult<Value> {
-        let v = rb.enter_polars(|| {
-            pl_async::get_runtime().block_in_place_on(self_.client().list_catalogs())
-        })?;
+        let v = rb.enter_polars(|| ASYNC.block_in_place_on(self_.client().list_catalogs()))?;
 
         let mut opt_err = None;
 
@@ -111,7 +110,7 @@ impl RbCatalogClient {
 
     pub fn list_namespaces(rb: &Ruby, self_: &Self, catalog_name: String) -> RbResult<Value> {
         let v = rb.enter_polars(|| {
-            pl_async::get_runtime().block_in_place_on(self_.client().list_namespaces(&catalog_name))
+            ASYNC.block_in_place_on(self_.client().list_namespaces(&catalog_name))
         })?;
 
         let mut opt_err = None;
@@ -139,8 +138,7 @@ impl RbCatalogClient {
         namespace: String,
     ) -> RbResult<Value> {
         let v = rb.enter_polars(|| {
-            pl_async::get_runtime()
-                .block_in_place_on(self_.client().list_tables(&catalog_name, &namespace))
+            ASYNC.block_in_place_on(self_.client().list_tables(&catalog_name, &namespace))
         })?;
 
         let mut opt_err = None;
@@ -172,7 +170,7 @@ impl RbCatalogClient {
     ) -> RbResult<Value> {
         let table_info = rb
             .enter_polars(|| {
-                pl_async::get_runtime().block_in_place_on(self_.client().get_table_info(
+                ASYNC.block_in_place_on(self_.client().get_table_info(
                     &table_name,
                     &catalog_name,
                     &namespace,
@@ -192,7 +190,7 @@ impl RbCatalogClient {
     ) -> RbResult<Value> {
         let catalog_info = rb
             .detach(|| {
-                pl_async::get_runtime().block_in_place_on(self_.client().create_catalog(
+                ASYNC.block_in_place_on(self_.client().create_catalog(
                     &catalog_name,
                     comment.as_deref(),
                     storage_root.as_deref(),
@@ -209,11 +207,8 @@ impl RbCatalogClient {
         catalog_name: String,
         force: bool,
     ) -> RbResult<()> {
-        rb.detach(|| {
-            pl_async::get_runtime()
-                .block_in_place_on(self_.client().delete_catalog(&catalog_name, force))
-        })
-        .map_err(to_rb_err)
+        rb.detach(|| ASYNC.block_in_place_on(self_.client().delete_catalog(&catalog_name, force)))
+            .map_err(to_rb_err)
     }
 
     pub fn create_namespace(
@@ -226,7 +221,7 @@ impl RbCatalogClient {
     ) -> RbResult<Value> {
         let namespace_info = rb
             .detach(|| {
-                pl_async::get_runtime().block_in_place_on(self_.client().create_namespace(
+                ASYNC.block_in_place_on(self_.client().create_namespace(
                     &catalog_name,
                     &namespace,
                     comment.as_deref(),
@@ -246,7 +241,7 @@ impl RbCatalogClient {
         force: bool,
     ) -> RbResult<()> {
         rb.detach(|| {
-            pl_async::get_runtime().block_in_place_on(self_.client().delete_namespace(
+            ASYNC.block_in_place_on(self_.client().delete_namespace(
                 &catalog_name,
                 &namespace,
                 force,
@@ -270,7 +265,7 @@ impl RbCatalogClient {
     ) -> RbResult<Value> {
         let table_info = rb
             .detach(|| {
-                pl_async::get_runtime().block_in_place_on(
+                ASYNC.block_in_place_on(
                     self_.client().create_table(
                         &catalog_name,
                         &namespace,
@@ -303,7 +298,7 @@ impl RbCatalogClient {
         table_name: String,
     ) -> RbResult<()> {
         rb.detach(|| {
-            pl_async::get_runtime().block_in_place_on(self_.client().delete_table(
+            ASYNC.block_in_place_on(self_.client().delete_table(
                 &catalog_name,
                 &namespace,
                 &table_name,
@@ -313,7 +308,7 @@ impl RbCatalogClient {
     }
 
     pub fn type_json_to_polars_type(rb: &Ruby, type_json: String) -> RbResult<Value> {
-        Ok(Wrap(parse_type_json_str(&type_json).map_err(to_rb_err)?).into_value_with(rb))
+        Wrap(parse_type_json_str(&type_json).map_err(to_rb_err)?).try_into_value_with(rb)
     }
 }
 

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

@@ -14,10 +14,11 @@ use super::{ObjectValue, Wrap, struct_dict};
 
 use crate::rb_modules::pl_utils;
 use crate::ruby::exceptions::RbOverflowError;
+use crate::ruby::utils::TryIntoValue;
 use crate::{RbErr, RbPolarsErr, RbResult, RbSeries, RbValueError};
 
-impl IntoValue for Wrap<AnyValue<'_>> {
-    fn into_value_with(self, ruby: &Ruby) -> Value {
+impl TryIntoValue for Wrap<AnyValue<'_>> {
+    fn try_into_value_with(self, ruby: &Ruby) -> RbResult<Value> {
         any_value_into_rb_object(self.0, ruby)
     }
 }
@@ -28,8 +29,8 @@ impl TryConvert for Wrap<AnyValue<'_>> {
     }
 }
 
-pub(crate) fn any_value_into_rb_object(av: AnyValue, ruby: &Ruby) -> Value {
-    match av {
+pub(crate) fn any_value_into_rb_object(av: AnyValue, ruby: &Ruby) -> RbResult<Value> {
+    let rb_object = match av {
         AnyValue::UInt8(v) => ruby.into_value(v),
         AnyValue::UInt16(v) => ruby.into_value(v),
         AnyValue::UInt32(v) => ruby.into_value(v),
@@ -53,41 +54,38 @@ pub(crate) fn any_value_into_rb_object(av: AnyValue, ruby: &Ruby) -> Value {
         AnyValue::CategoricalOwned(cat, map) | AnyValue::EnumOwned(cat, map) => unsafe {
             map.cat_to_str_unchecked(cat).into_value_with(ruby)
         },
-        AnyValue::Date(v) => pl_utils(ruby).funcall("_to_ruby_date", (v,)).unwrap(),
+        AnyValue::Date(v) => pl_utils(ruby).funcall("_to_ruby_date", (v,))?,
         AnyValue::Datetime(v, time_unit, time_zone) => {
-            datetime_to_rb_object(v, time_unit, time_zone)
+            datetime_to_rb_object(ruby, v, time_unit, time_zone)?
         }
         AnyValue::DatetimeOwned(v, time_unit, time_zone) => {
-            datetime_to_rb_object(v, time_unit, time_zone.as_ref().map(AsRef::as_ref))
+            datetime_to_rb_object(ruby, v, time_unit, time_zone.as_ref().map(AsRef::as_ref))?
         }
         AnyValue::Duration(v, time_unit) => {
             let time_unit = time_unit.to_ascii();
-            pl_utils(ruby)
-                .funcall("_to_ruby_duration", (v, time_unit))
-                .unwrap()
+            pl_utils(ruby).funcall("_to_ruby_duration", (v, time_unit))?
         }
-        AnyValue::Time(v) => pl_utils(ruby).funcall("_to_ruby_time", (v,)).unwrap(),
-        AnyValue::Array(v, _) | AnyValue::List(v) => RbSeries::new(v).to_a().unwrap().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::Time(v) => pl_utils(ruby).funcall("_to_ruby_time", (v,))?,
+        AnyValue::Array(v, _) | AnyValue::List(v) => RbSeries::to_a(ruby, &RbSeries::new(v))?,
+        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()
+            object.clone().into_value_with(ruby)
         }
         AnyValue::ObjectOwned(v) => {
             let object = v.0.as_any().downcast_ref::<ObjectValue>().unwrap();
-            object.to_value()
+            object.clone().into_value_with(ruby)
         }
         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(ruby)
-                .funcall("_to_ruby_decimal", (prec, s))
-                .unwrap()
+            pl_utils(ruby).funcall("_to_ruby_decimal", (prec, s))?
         }
-    }
+    };
+    Ok(rb_object)
 }
 
 pub(crate) fn rb_object_to_any_value<'s>(
@@ -130,7 +128,7 @@ pub(crate) fn rb_object_to_any_value<'s>(
 
     fn get_str(ob: Value, _strict: bool) -> RbResult<AnyValue<'static>> {
         let ruby = Ruby::get_with(ob);
-        let v = RString::from_value(ob).unwrap();
+        let v = RString::try_convert(ob)?;
         if v.enc_get() == ruby.utf8_encindex() {
             Ok(AnyValue::StringOwned(v.to_string()?.into()))
         } else {
@@ -139,7 +137,7 @@ pub(crate) fn rb_object_to_any_value<'s>(
     }
 
     fn get_list(ob: Value, _strict: bool) -> RbResult<AnyValue<'static>> {
-        let v = RArray::from_value(ob).unwrap();
+        let v = RArray::try_convert(ob)?;
         if v.is_empty() {
             Ok(AnyValue::List(Series::new_empty(
                 PlSmallStr::EMPTY,
@@ -242,7 +240,7 @@ pub(crate) fn rb_object_to_any_value<'s>(
             }
         }
 
-        let (sign, digits, _, exp): (i8, String, i32, i32) = ob.funcall("split", ()).unwrap();
+        let (sign, digits, _, exp): (i8, String, i32, i32) = ob.funcall("split", ())?;
         let (mut v, scale) = abs_decimal_from_digits(digits, exp).ok_or_else(|| {
             RbErr::from(RbPolarsErr::Other(
                 "BigDecimal is too large to fit in Decimal128".into(),
@@ -279,7 +277,10 @@ pub(crate) fn rb_object_to_any_value<'s>(
         get_datetime(ob, strict)
     } else if ob.is_kind_of(crate::ruby::rb_modules::date(&ruby)) {
         get_date(ob, strict)
-    } else if ob.is_kind_of(crate::ruby::rb_modules::bigdecimal(&ruby)) {
+    } else if crate::ruby::rb_modules::bigdecimal(&ruby)
+        .map(|cls| ob.is_kind_of(cls))
+        .unwrap_or(false)
+    {
         get_decimal(ob, strict)
     } else {
         if allow_object {

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

@@ -1,11 +1,13 @@
-use magnus::{IntoValue, RString, Ruby, TryConvert, Value, prelude::*};
+use magnus::{IntoValue, RArray, RString, Ruby, TryConvert, Value, prelude::*};
 use polars::prelude::*;
 use polars_compute::decimal::DecimalFmtBuffer;
 
+use super::datetime::datetime_to_rb_object;
 use super::{Wrap, get_rbseq, struct_dict};
 
 use crate::RbResult;
 use crate::rb_modules::pl_utils;
+use crate::ruby::utils::TryIntoValue;
 
 impl TryConvert for Wrap<StringChunked> {
     fn try_convert(obj: Value) -> RbResult<Self> {
@@ -41,7 +43,7 @@ impl TryConvert for Wrap<BinaryChunked> {
 
 impl IntoValue for Wrap<&StringChunked> {
     fn into_value_with(self, ruby: &Ruby) -> Value {
-        let iter = self.0.into_iter();
+        let iter = self.0.iter();
         ruby.ary_from_iter(iter).as_value()
     }
 }
@@ -50,96 +52,96 @@ impl IntoValue for Wrap<&BinaryChunked> {
     fn into_value_with(self, ruby: &Ruby) -> Value {
         let iter = self
             .0
-            .into_iter()
+            .iter()
             .map(|opt_bytes| opt_bytes.map(|v| ruby.str_from_slice(v)));
         ruby.ary_from_iter(iter).as_value()
     }
 }
 
-impl IntoValue for Wrap<&StructChunked> {
-    fn into_value_with(self, ruby: &Ruby) -> Value {
+impl TryIntoValue for Wrap<&StructChunked> {
+    fn try_into_value_with(self, ruby: &Ruby) -> RbResult<Value> {
         let s = self.0.clone().into_series();
         // todo! iterate its chunks and flatten.
         // make series::iter() accept a chunk index.
         let s = s.rechunk();
         let iter = s.iter().map(|av| match av {
             AnyValue::Struct(_, _, flds) => struct_dict(ruby, av._iter_struct_av(), flds),
-            AnyValue::Null => ruby.qnil().as_value(),
+            AnyValue::Null => Ok(ruby.qnil().as_value()),
             _ => unreachable!(),
         });
 
-        ruby.ary_from_iter(iter).as_value()
+        ruby.ary_try_from_iter(iter).map(|v| v.as_value())
     }
 }
 
-impl IntoValue for Wrap<&DurationChunked> {
-    fn into_value_with(self, ruby: &Ruby) -> Value {
+impl TryIntoValue for Wrap<&DurationChunked> {
+    fn try_into_value_with(self, ruby: &Ruby) -> RbResult<Value> {
         let utils = pl_utils(ruby);
         let time_unit = Wrap(self.0.time_unit()).into_value_with(ruby);
-        let iter = self.0.physical().into_iter().map(|opt_v| {
-            opt_v.map(|v| {
-                utils
-                    .funcall::<_, _, Value>("_to_ruby_duration", (v, time_unit))
-                    .unwrap()
-            })
+        let iter = self.0.physical().iter().map(|opt_v| {
+            opt_v
+                .map(|v| utils.funcall::<_, _, Value>("_to_ruby_duration", (v, time_unit)))
+                .transpose()
         });
-        ruby.ary_from_iter(iter).as_value()
+        ruby.ary_try_from_iter(iter).map(|v| v.as_value())
     }
 }
 
-impl IntoValue for Wrap<&DatetimeChunked> {
-    fn into_value_with(self, ruby: &Ruby) -> Value {
-        let utils = pl_utils(ruby);
-        let time_unit = Wrap(self.0.time_unit()).into_value_with(ruby);
-        let time_zone = self
-            .0
-            .time_zone()
-            .as_deref()
-            .map(|v| v.into_value_with(ruby));
-        let iter = self.0.physical().into_iter().map(|opt_v| {
-            opt_v.map(|v| {
-                utils
-                    .funcall::<_, _, Value>("_to_ruby_datetime", (v, time_unit, time_zone))
-                    .unwrap()
-            })
+impl TryIntoValue for Wrap<&DatetimeChunked> {
+    fn try_into_value_with(self, ruby: &Ruby) -> RbResult<Value> {
+        let time_zone = self.0.time_zone().as_ref();
+        let time_unit = self.0.time_unit();
+        let iter = self.0.physical().iter().map(|opt_v| {
+            opt_v
+                .map(|v| datetime_to_rb_object(ruby, v, time_unit, time_zone))
+                .transpose()
         });
-        ruby.ary_from_iter(iter).as_value()
+        ruby.ary_try_from_iter(iter).map(|v| v.as_value())
     }
 }
 
-impl IntoValue for Wrap<&TimeChunked> {
-    fn into_value_with(self, ruby: &Ruby) -> Value {
+impl TryIntoValue for Wrap<&TimeChunked> {
+    fn try_into_value_with(self, ruby: &Ruby) -> RbResult<Value> {
         let utils = pl_utils(ruby);
-        let iter = self.0.physical().into_iter().map(|opt_v| {
-            opt_v.map(|v| utils.funcall::<_, _, Value>("_to_ruby_time", (v,)).unwrap())
+        let iter = self.0.physical().iter().map(|opt_v| {
+            opt_v
+                .map(|v| utils.funcall::<_, _, Value>("_to_ruby_time", (v,)))
+                .transpose()
         });
-        ruby.ary_from_iter(iter).as_value()
+        ruby.ary_try_from_iter(iter).map(|v| v.as_value())
     }
 }
 
-impl IntoValue for Wrap<&DateChunked> {
-    fn into_value_with(self, ruby: &Ruby) -> Value {
+impl TryIntoValue for Wrap<&DateChunked> {
+    fn try_into_value_with(self, ruby: &Ruby) -> RbResult<Value> {
         let utils = pl_utils(ruby);
-        let iter = self.0.physical().into_iter().map(|opt_v| {
-            opt_v.map(|v| utils.funcall::<_, _, Value>("_to_ruby_date", (v,)).unwrap())
+        let iter = self.0.physical().iter().map(|opt_v| {
+            opt_v
+                .map(|v| utils.funcall::<_, _, Value>("_to_ruby_date", (v,)))
+                .transpose()
         });
-        ruby.ary_from_iter(iter).as_value()
+        ruby.ary_try_from_iter(iter).map(|v| v.as_value())
     }
 }
 
-impl IntoValue for Wrap<&DecimalChunked> {
-    fn into_value_with(self, ruby: &Ruby) -> Value {
-        let utils = pl_utils(ruby);
-        let rb_precision = self.0.precision().into_value_with(ruby);
-        let mut buf = DecimalFmtBuffer::new();
-        let iter = self.0.physical().into_iter().map(|opt_v| {
-            opt_v.map(|v| {
-                let s = buf.format_dec128(v, self.0.scale(), false, false);
-                utils
-                    .funcall::<_, _, Value>("_to_ruby_decimal", (rb_precision, s))
-                    .unwrap()
-            })
-        });
-        ruby.ary_from_iter(iter).as_value()
+impl TryIntoValue for Wrap<&DecimalChunked> {
+    fn try_into_value_with(self, ruby: &Ruby) -> RbResult<Value> {
+        let iter = decimal_to_rbobject_iter(ruby, self.0)?;
+        Ok(iter.as_value())
     }
 }
+
+pub(crate) fn decimal_to_rbobject_iter(ruby: &Ruby, ca: &DecimalChunked) -> RbResult<RArray> {
+    let utils = pl_utils(ruby);
+    let rb_precision = ca.precision().into_value_with(ruby);
+    let mut buf = DecimalFmtBuffer::new();
+    let iter = ca.physical().iter().map(move |opt_v| {
+        opt_v
+            .map(|v| {
+                let s = buf.format_dec128(v, ca.scale(), false, false);
+                utils.funcall::<_, _, Value>("_to_ruby_decimal", (rb_precision, s))
+            })
+            .transpose()
+    });
+    ruby.ary_try_from_iter(iter)
+}

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

@@ -1,12 +1,63 @@
-use magnus::{Ruby, Value, prelude::*};
+//! Utilities for converting dates, times, datetimes, and so on.
+
+use std::str::FromStr;
+
+use chrono::{DateTime, Datelike, FixedOffset, NaiveDateTime, TimeDelta, TimeZone as _};
+use chrono_tz::Tz;
+use magnus::{IntoValue, Ruby, Value, prelude::*};
 use polars::prelude::*;
 
 use crate::rb_modules::pl_utils;
+use crate::{RbPolarsErr, RbResult};
+
+pub fn elapsed_offset_to_timedelta(elapsed: i64, time_unit: TimeUnit) -> TimeDelta {
+    let (in_second, nano_multiplier) = match time_unit {
+        TimeUnit::Nanoseconds => (1_000_000_000, 1),
+        TimeUnit::Microseconds => (1_000_000, 1_000),
+        TimeUnit::Milliseconds => (1_000, 1_000_000),
+    };
+    let mut elapsed_sec = elapsed / in_second;
+    let mut elapsed_nanos = nano_multiplier * (elapsed % in_second);
+    if elapsed_nanos < 0 {
+        // TimeDelta expects nanos to always be positive.
+        elapsed_sec -= 1;
+        elapsed_nanos += 1_000_000_000;
+    }
+    TimeDelta::new(elapsed_sec, elapsed_nanos as u32).unwrap()
+}
+
+/// Convert time-units-since-epoch to a more structured object.
+pub fn timestamp_to_naive_datetime(since_epoch: i64, time_unit: TimeUnit) -> NaiveDateTime {
+    DateTime::UNIX_EPOCH.naive_utc() + elapsed_offset_to_timedelta(since_epoch, time_unit)
+}
 
-pub fn datetime_to_rb_object(v: i64, tu: TimeUnit, tz: Option<&TimeZone>) -> Value {
-    let ruby = Ruby::get().unwrap();
-    let tu = tu.to_ascii();
-    pl_utils(&ruby)
-        .funcall("_to_ruby_datetime", (v, tu, tz.map(|v| v.to_string())))
-        .unwrap()
+pub fn datetime_to_rb_object(
+    ruby: &Ruby,
+    v: i64,
+    tu: TimeUnit,
+    tz: Option<&TimeZone>,
+) -> RbResult<Value> {
+    if let Some(time_zone) = tz {
+        if let Ok(tz) = Tz::from_str(time_zone) {
+            let utc_datetime = DateTime::UNIX_EPOCH + elapsed_offset_to_timedelta(v, tu);
+            if utc_datetime.year() >= 2100 {
+                // chrono-tz does not support dates after 2100
+                // https://github.com/chronotope/chrono-tz/issues/135
+                pl_utils(ruby).funcall("_to_ruby_datetime", (v, tu.to_ascii(), time_zone.as_str()))
+            } else {
+                let datetime = utc_datetime.with_timezone(&tz);
+                Ok(datetime.fixed_offset().into_value_with(ruby))
+            }
+        } else if let Ok(tz) = FixedOffset::from_str(time_zone) {
+            let naive_datetime = timestamp_to_naive_datetime(v, tu);
+            let datetime = tz.from_utc_datetime(&naive_datetime);
+            Ok(datetime.into_value_with(ruby))
+        } else {
+            Err(RbPolarsErr::Other(format!("Could not parse timezone: {time_zone}")).into())
+        }
+    } else {
+        Ok(timestamp_to_naive_datetime(v, tu)
+            .and_utc()
+            .into_value_with(ruby))
+    }
 }