polars-df 0.26.1 → 0.27.0

data/LICENSE.txt

@@ -1,6 +1,6 @@
 Copyright (c) 2025 Ritchie Vink
 Copyright (c) 2022-2026 Andrew Kane
-Some portions Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+Copyright (c) 2024 (Some portions) NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/ext/polars/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "polars-ruby"
-version = "0.26.1"
+version = "0.27.0"
 license = "MIT"
 authors = ["Andrew Kane <andrew@ankane.org>"]
 edition = "2024"
@@ -13,7 +13,7 @@ crate-type = ["cdylib"]
 
 [dependencies]
 ahash = "0.8"
-arrow = { package = "polars-arrow", version = "=0.54.4" }
+arrow = { package = "polars-arrow", version = "=0.55.1" }
 bytes = "1"
 chrono = "0.4"
 chrono-tz = "0.10"
@@ -21,26 +21,26 @@ either = "1.8"
 magnus = { version = "0.8", features = ["chrono"] }
 num-traits = "0.2"
 parking_lot = "0.12"
-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"
+polars-buffer = "=0.55.1"
+polars-compute = "=0.55.1"
+polars-config = "=0.55.1"
+polars-core = "=0.55.1"
+polars-dtype = "=0.55.1"
+polars-error = "=0.55.1"
+polars-io = "=0.55.1"
+polars-lazy = { version = "=0.55.1", features = ["catalog"] }
+polars-ops = "=0.55.1"
+polars-plan = "=0.55.1"
+polars-parquet = "=0.55.1"
+polars-testing = "=0.55.1"
+polars-utils = "=0.55.1"
 rayon = "1.9"
 rb-sys = "0.9"
 regex = "1"
 serde_json = "1"
 
 [dependencies.polars]
-version = "=0.54.4"
+version = "=0.55.1"
 features = [
     "abs",
     "approx_unique",

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

@@ -3,7 +3,6 @@ mod categorical;
 mod chunked_array;
 mod datetime;
 
-use std::collections::BTreeMap;
 use std::fmt::{Debug, Display, Formatter};
 use std::fs::File;
 use std::hash::{Hash, Hasher};
@@ -19,9 +18,7 @@ use polars::datatypes::AnyValue;
 use polars::frame::PivotColumnNaming;
 use polars::frame::row::Row;
 use polars::io::avro::AvroCompression;
-use polars::prelude::default_values::{
-    DefaultFieldValues, IcebergIdentityTransformedPartitionFields,
-};
+use polars::prelude::default_values::DefaultFieldValues;
 use polars::prelude::deletion::DeletionFilesList;
 use polars::prelude::*;
 use polars::series::ops::NullBehavior;
@@ -31,6 +28,7 @@ use polars_core::schema::iceberg::IcebergSchema;
 use polars_core::utils::arrow::array::Array;
 use polars_core::utils::materialize_dyn_int;
 use polars_plan::dsl::ScanSources;
+use polars_plan::dsl::default_values::IcebergDefaultFieldValues;
 use polars_utils::compression::{BrotliLevel, GzipLevel, ZstdLevel};
 use polars_utils::total_ord::{TotalEq, TotalHash};
 
@@ -515,103 +513,25 @@ impl TryConvert for Wrap<Schema> {
 
 impl TryConvert for Wrap<ArrowSchema> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        let ruby = Ruby::get_with(ob);
+        let schema_capsule: Value = ob.funcall("arrow_c_schema", ())?;
 
-        if let Ok(schema_capsule) = ob.funcall::<_, _, Value>("arrow_c_schema", ()) {
-            let field = import_schema_rbcapsule(schema_capsule)?;
+        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();
+        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
+            )));
+        };
 
-            if let Some(md) = field.metadata {
-                *schema.metadata_mut() = Arc::unwrap_or_clone(md);
-            }
+        let mut schema = ArrowSchema::from_iter_check_duplicates(fields).unwrap();
 
-            return Ok(Wrap(schema));
+        if let Some(md) = field.metadata {
+            *schema.metadata_mut() = Arc::unwrap_or_clone(md);
         }
 
-        // 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());
-        for f in fields {
-            let f = RHash::try_convert(f)?;
-            let name: String = f.aref(ruby.to_symbol("name"))?;
-            let rb_dtype: String = f.aref(ruby.to_symbol("type"))?;
-            let dtype = match rb_dtype.as_str() {
-                "null" => ArrowDataType::Null,
-                "boolean" => ArrowDataType::Boolean,
-                "int8" => ArrowDataType::Int8,
-                "int16" => ArrowDataType::Int16,
-                "int32" => ArrowDataType::Int32,
-                "int64" => ArrowDataType::Int64,
-                "uint8" => ArrowDataType::UInt8,
-                "uint16" => ArrowDataType::UInt16,
-                "uint32" => ArrowDataType::UInt32,
-                "uint64" => ArrowDataType::UInt64,
-                "float16" => ArrowDataType::Float16,
-                "float32" => ArrowDataType::Float32,
-                "float64" => ArrowDataType::Float64,
-                "date32" => ArrowDataType::Date32,
-                "date64" => ArrowDataType::Date64,
-                "binary" => ArrowDataType::Binary,
-                "large_binary" => ArrowDataType::LargeBinary,
-                "string" => ArrowDataType::Utf8,
-                "large_string" => ArrowDataType::LargeUtf8,
-                "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"))?;
-            let rb_metadata: RHash = f.aref(ruby.to_symbol("metadata"))?;
-            let mut metadata = BTreeMap::new();
-            rb_metadata.foreach(|k: String, v: String| {
-                metadata.insert(k.into(), v.into());
-                Ok(ForEach::Continue)
-            })?;
-            arrow_schema
-                .try_insert(
-                    name.clone().into(),
-                    ArrowField::new(name.into(), dtype, is_nullable).with_metadata(metadata),
-                )
-                .map_err(to_rb_err)?;
-        }
-        Ok(Wrap(arrow_schema))
+        Ok(Wrap(schema))
     }
 }
 
@@ -1330,6 +1250,9 @@ impl TryConvert for Wrap<CastColumnsPolicy> {
         })?;
 
         let mut datetime_nanoseconds_downcast = false;
+        let mut datetime_microseconds_downcast = false;
+        let mut datetime_milliseconds_upcast = false;
+        let mut datetime_microseconds_upcast = false;
         let mut datetime_convert_timezone = false;
 
         let datetime_cast_object: Value = ob.funcall("datetime_cast", ())?;
@@ -1338,6 +1261,9 @@ impl TryConvert for Wrap<CastColumnsPolicy> {
             match v {
                 "forbid" => {}
                 "nanosecond-downcast" => datetime_nanoseconds_downcast = true,
+                "microsecond-downcast" => datetime_microseconds_downcast = true,
+                "millisecond-upcast" => datetime_milliseconds_upcast = true,
+                "microsecond-upcast" => datetime_microseconds_upcast = true,
                 "convert-timezone" => datetime_convert_timezone = true,
                 v => {
                     return Err(RbValueError::new_err(format!(
@@ -1387,7 +1313,9 @@ impl TryConvert for Wrap<CastColumnsPolicy> {
             float_upcast,
             float_downcast,
             datetime_nanoseconds_downcast,
-            datetime_microseconds_downcast: false,
+            datetime_microseconds_downcast,
+            datetime_milliseconds_upcast,
+            datetime_microseconds_upcast,
             datetime_convert_timezone,
             null_upcast: true,
             categorical_to_string,
@@ -1685,11 +1613,13 @@ impl TryConvert for Wrap<DefaultFieldValues> {
 
         Ok(Wrap(match &*default_values_type {
             "iceberg" => {
-                let dict = RHash::try_convert(ob)?;
+                let (identity_transformed_partition_values, initial_defaults) =
+                    <(RHash, RHash)>::try_convert(ob)?;
 
-                let mut out = PlIndexMap::new();
+                let mut converted_identity_transformed_partition_values = PlIndexMap::new();
+                let mut converted_initial_defaults = PlIndexMap::new();
 
-                dict.foreach(|k: u32, v: Value| {
+                identity_transformed_partition_values.foreach(|k: u32, v: Value| {
                     let v: Result<Column, String> = if let Ok(s) = get_series(v) {
                         Ok(s.into_column())
                     } else {
@@ -1697,14 +1627,28 @@ impl TryConvert for Wrap<DefaultFieldValues> {
                         Err(err_msg)
                     };
 
-                    out.insert(k, v);
+                    converted_identity_transformed_partition_values.insert(k, v);
+
+                    Ok(ForEach::Continue)
+                })?;
+
+                initial_defaults.foreach(|k: u32, v: Value| {
+                    let v = get_series(v)?;
+                    let v = Scalar::new(
+                        v.dtype().clone(),
+                        v.get(0).map_err(to_rb_err)?.into_static(),
+                    );
+                    converted_initial_defaults.insert(k, v);
 
                     Ok(ForEach::Continue)
                 })?;
 
-                DefaultFieldValues::Iceberg(Arc::new(IcebergIdentityTransformedPartitionFields(
-                    out,
-                )))
+                DefaultFieldValues::Iceberg(Arc::new(IcebergDefaultFieldValues {
+                    identity_transformed_partition_fields: PlIndexMapHashable(
+                        converted_identity_transformed_partition_values,
+                    ),
+                    initial_defaults: PlIndexMapHashable(converted_initial_defaults),
+                }))
             }
 
             v => {

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

@@ -84,7 +84,7 @@ impl RbDataFrame {
         self_: &Self,
         n: &RbSeries,
         with_replacement: bool,
-        shuffle: bool,
+        shuffle: Option<bool>,
         seed: Option<u64>,
     ) -> RbResult<Self> {
         rb.enter_polars_df(|| {
@@ -100,7 +100,7 @@ impl RbDataFrame {
         self_: &Self,
         frac: &RbSeries,
         with_replacement: bool,
-        shuffle: bool,
+        shuffle: Option<bool>,
         seed: Option<u64>,
     ) -> RbResult<Self> {
         rb.enter_polars_df(|| {
@@ -310,6 +310,19 @@ impl RbDataFrame {
         rb.enter_polars_series(|| self_.df.read().is_duplicated())
     }
 
+    pub fn is_sorted(
+        rb: &Ruby,
+        self_: &Self,
+        by: Vec<String>,
+        descending: Vec<bool>,
+        nulls_last: Vec<bool>,
+    ) -> RbResult<bool> {
+        rb.enter_polars(|| {
+            let by = strings_to_pl_smallstr(by);
+            self_.df.read().is_sorted(&by, &descending, &nulls_last)
+        })
+    }
+
     pub fn equals(
         rb: &Ruby,
         self_: &Self,

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

@@ -1,4 +1,4 @@
-use magnus::{Value, prelude::*};
+use magnus::{Ruby, Value, prelude::*};
 use polars::io::RowIndex;
 use polars::io::avro::AvroCompression;
 use polars::prelude::*;
@@ -6,14 +6,15 @@ use std::io::BufWriter;
 use std::num::NonZeroUsize;
 
 use super::*;
+use crate::RbResult;
 use crate::conversion::*;
 use crate::file::{
     get_file_like, get_mmap_bytes_reader, get_mmap_bytes_reader_and_path, read_if_bytesio,
 };
-use crate::{RbPolarsErr, RbResult};
+use crate::utils::EnterPolarsExt;
 
 impl RbDataFrame {
-    pub fn read_csv(arguments: &[Value]) -> RbResult<Self> {
+    pub fn read_csv(rb: &Ruby, arguments: &[Value]) -> RbResult<Self> {
         // start arguments
         // this pattern is needed for more than 16
         let rb_f = arguments[0];
@@ -83,46 +84,47 @@ impl RbDataFrame {
 
         let rb_f = read_if_bytesio(rb_f);
         let mmap_bytes_r = get_mmap_bytes_reader(&rb_f)?;
-        let df = CsvReadOptions::default()
-            .with_path(path)
-            .with_infer_schema_length(infer_schema_length)
-            .with_has_header(has_header)
-            .with_n_rows(n_rows)
-            .with_skip_rows(skip_rows)
-            .with_skip_lines(skip_lines)
-            .with_ignore_errors(ignore_errors)
-            .with_projection(projection.map(Arc::new))
-            .with_rechunk(rechunk)
-            .with_chunk_size(chunk_size)
-            .with_columns(columns.map(|x| x.into_iter().map(|x| x.into()).collect()))
-            .with_n_threads(n_threads)
-            .with_schema_overwrite(overwrite_dtype.map(Arc::new))
-            .with_dtype_overwrite(overwrite_dtype_slice.map(Arc::new))
-            .with_schema(schema.map(|schema| Arc::new(schema.0)))
-            .with_low_memory(low_memory)
-            .with_skip_rows_after_header(skip_rows_after_header)
-            .with_row_index(row_index)
-            .with_raise_if_empty(raise_if_empty)
-            .with_parse_options(
-                CsvParseOptions::default()
-                    .with_separator(separator.as_bytes()[0])
-                    .with_encoding(encoding.0)
-                    .with_missing_is_null(!missing_utf8_is_empty_string)
-                    .with_comment_prefix(comment_prefix.as_deref())
-                    .with_null_values(null_values)
-                    .with_try_parse_dates(try_parse_dates)
-                    .with_quote_char(quote_char)
-                    .with_eol_char(eol_char)
-                    .with_truncate_ragged_lines(truncate_ragged_lines)
-                    .with_decimal_comma(decimal_comma),
-            )
-            .into_reader_with_file_handle(mmap_bytes_r)
-            .finish()
-            .map_err(RbPolarsErr::from)?;
-        Ok(df.into())
+        rb.enter_polars_df(move || {
+            CsvReadOptions::default()
+                .with_path(path)
+                .with_infer_schema_length(infer_schema_length)
+                .with_has_header(has_header)
+                .with_n_rows(n_rows)
+                .with_skip_rows(skip_rows)
+                .with_skip_lines(skip_lines)
+                .with_ignore_errors(ignore_errors)
+                .with_projection(projection.map(Arc::new))
+                .with_rechunk(rechunk)
+                .with_chunk_size(chunk_size)
+                .with_columns(columns.map(|x| x.into_iter().map(|x| x.into()).collect()))
+                .with_n_threads(n_threads)
+                .with_schema_overwrite(overwrite_dtype.map(Arc::new))
+                .with_dtype_overwrite(overwrite_dtype_slice.map(Arc::new))
+                .with_schema(schema.map(|schema| Arc::new(schema.0)))
+                .with_low_memory(low_memory)
+                .with_skip_rows_after_header(skip_rows_after_header)
+                .with_row_index(row_index)
+                .with_raise_if_empty(raise_if_empty)
+                .with_parse_options(
+                    CsvParseOptions::default()
+                        .with_separator(separator.as_bytes()[0])
+                        .with_encoding(encoding.0)
+                        .with_missing_is_null(!missing_utf8_is_empty_string)
+                        .with_comment_prefix(comment_prefix.as_deref())
+                        .with_null_values(null_values)
+                        .with_try_parse_dates(try_parse_dates)
+                        .with_quote_char(quote_char)
+                        .with_eol_char(eol_char)
+                        .with_truncate_ragged_lines(truncate_ragged_lines)
+                        .with_decimal_comma(decimal_comma),
+                )
+                .into_reader_with_file_handle(mmap_bytes_r)
+                .finish()
+        })
     }
 
     pub fn read_json(
+        rb: &Ruby,
         rb_f: Value,
         infer_schema_length: Option<usize>,
         schema: Option<Wrap<Schema>>,
@@ -131,23 +133,25 @@ impl RbDataFrame {
         let rb_f = read_if_bytesio(rb_f);
         let mmap_bytes_r = get_mmap_bytes_reader(&rb_f)?;
 
-        let mut builder = JsonReader::new(mmap_bytes_r)
-            .with_json_format(JsonFormat::Json)
-            .infer_schema_len(infer_schema_length.and_then(NonZeroUsize::new));
+        rb.enter_polars_df(move || {
+            let mut reader = JsonReader::new(mmap_bytes_r)
+                .with_json_format(JsonFormat::Json)
+                .infer_schema_len(infer_schema_length.and_then(NonZeroUsize::new));
 
-        if let Some(schema) = schema {
-            builder = builder.with_schema(Arc::new(schema.0));
-        }
+            if let Some(schema) = schema {
+                reader = reader.with_schema(Arc::new(schema.0));
+            }
 
-        if let Some(schema) = schema_overrides.as_ref() {
-            builder = builder.with_schema_overwrite(&schema.0);
-        }
+            if let Some(schema) = schema_overrides.as_ref() {
+                reader = reader.with_schema_overwrite(&schema.0);
+            }
 
-        let out = builder.finish().map_err(RbPolarsErr::from)?;
-        Ok(out.into())
+            reader.finish()
+        })
     }
 
     pub fn read_ipc(
+        rb: &Ruby,
         rb_f: Value,
         columns: Option<Vec<String>>,
         projection: Option<Vec<usize>>,
@@ -163,18 +167,19 @@ impl RbDataFrame {
         let (mmap_bytes_r, mmap_path) = get_mmap_bytes_reader_and_path(&rb_f)?;
 
         let mmap_path = if memory_map { mmap_path } else { None };
-        let df = IpcReader::new(mmap_bytes_r)
-            .with_projection(projection)
-            .with_columns(columns)
-            .with_n_rows(n_rows)
-            .with_row_index(row_index)
-            .memory_mapped(mmap_path)
-            .finish()
-            .map_err(RbPolarsErr::from)?;
-        Ok(RbDataFrame::new(df))
+        rb.enter_polars_df(move || unsafe {
+            IpcReader::new(mmap_bytes_r)
+                .with_projection(projection)
+                .with_columns(columns)
+                .with_n_rows(n_rows)
+                .with_row_index(row_index)
+                .memory_mapped(mmap_path)
+                .finish()
+        })
     }
 
     pub fn read_ipc_stream(
+        rb: &Ruby,
         rb_f: Value,
         columns: Option<Vec<String>>,
         projection: Option<Vec<usize>>,
@@ -188,18 +193,19 @@ impl RbDataFrame {
         });
         let rb_f = read_if_bytesio(rb_f);
         let mmap_bytes_r = get_mmap_bytes_reader(&rb_f)?;
-        let df = IpcStreamReader::new(mmap_bytes_r)
-            .with_projection(projection)
-            .with_columns(columns)
-            .with_n_rows(n_rows)
-            .with_row_index(row_index)
-            .set_rechunk(rechunk)
-            .finish()
-            .map_err(RbPolarsErr::from)?;
-        Ok(RbDataFrame::new(df))
+        rb.enter_polars_df(move || {
+            IpcStreamReader::new(mmap_bytes_r)
+                .with_projection(projection)
+                .with_columns(columns)
+                .with_n_rows(n_rows)
+                .with_row_index(row_index)
+                .set_rechunk(rechunk)
+                .finish()
+        })
     }
 
     pub fn read_avro(
+        rb: &Ruby,
         rb_f: Value,
         columns: Option<Vec<String>>,
         projection: Option<Vec<usize>>,
@@ -208,53 +214,54 @@ impl RbDataFrame {
         use polars::io::avro::AvroReader;
 
         let file = get_file_like(rb_f, false)?;
-        let df = AvroReader::new(file)
-            .with_projection(projection)
-            .with_columns(columns)
-            .with_n_rows(n_rows)
-            .finish()
-            .map_err(RbPolarsErr::from)?;
-        Ok(RbDataFrame::new(df))
+        rb.enter_polars_df(move || {
+            AvroReader::new(file)
+                .with_projection(projection)
+                .with_columns(columns)
+                .with_n_rows(n_rows)
+                .finish()
+        })
     }
 
-    pub fn write_json(&self, rb_f: Value) -> RbResult<()> {
+    pub fn write_json(rb: &Ruby, self_: &Self, rb_f: Value) -> RbResult<()> {
         let file = BufWriter::new(get_file_like(rb_f, true)?);
-
-        JsonWriter::new(file)
-            .with_json_format(JsonFormat::Json)
-            .finish(&mut self.df.write())
-            .map_err(RbPolarsErr::from)?;
-        Ok(())
+        rb.enter_polars(|| {
+            JsonWriter::new(file)
+                .with_json_format(JsonFormat::Json)
+                .finish(&mut self_.df.write())
+        })
     }
 
     pub fn write_ipc_stream(
-        &self,
+        rb: &Ruby,
+        self_: &Self,
         rb_f: Value,
         compression: Wrap<Option<IpcCompression>>,
         compat_level: RbCompatLevel,
     ) -> RbResult<()> {
         let mut buf = get_file_like(rb_f, true)?;
-        IpcStreamWriter::new(&mut buf)
-            .with_compression(compression.0)
-            .with_compat_level(compat_level.0)
-            .finish(&mut self.df.write())
-            .map_err(RbPolarsErr::from)?;
-        Ok(())
+        rb.enter_polars(|| {
+            IpcStreamWriter::new(&mut buf)
+                .with_compression(compression.0)
+                .with_compat_level(compat_level.0)
+                .finish(&mut self_.df.write())
+        })
     }
 
     pub fn write_avro(
-        &self,
+        rb: &Ruby,
+        self_: &Self,
         rb_f: Value,
         compression: Wrap<Option<AvroCompression>>,
         name: String,
     ) -> RbResult<()> {
         use polars::io::avro::AvroWriter;
         let mut buf = get_file_like(rb_f, true)?;
-        AvroWriter::new(&mut buf)
-            .with_compression(compression.0)
-            .with_name(name)
-            .finish(&mut self.df.write())
-            .map_err(RbPolarsErr::from)?;
-        Ok(())
+        rb.enter_polars(|| {
+            AvroWriter::new(&mut buf)
+                .with_compression(compression.0)
+                .with_name(name)
+                .finish(&mut self_.df.write())
+        })
     }
 }

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

@@ -473,6 +473,10 @@ impl RbExpr {
             .into()
     }
 
+    pub fn is_sorted(&self, descending: Option<bool>, nulls_last: Option<bool>) -> Self {
+        self.inner.clone().is_sorted(descending, nulls_last).into()
+    }
+
     pub fn approx_n_unique(&self) -> Self {
         self.inner.clone().approx_n_unique().into()
     }
@@ -815,7 +819,7 @@ impl RbExpr {
         &self,
         n: &Self,
         with_replacement: bool,
-        shuffle: bool,
+        shuffle: Option<bool>,
         seed: Option<u64>,
     ) -> Self {
         self.inner
@@ -828,7 +832,7 @@ impl RbExpr {
         &self,
         frac: &Self,
         with_replacement: bool,
-        shuffle: bool,
+        shuffle: Option<bool>,
         seed: Option<u64>,
     ) -> Self {
         self.inner

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

@@ -143,7 +143,7 @@ impl RbExpr {
         &self,
         n: &RbExpr,
         with_replacement: bool,
-        shuffle: bool,
+        shuffle: Option<bool>,
         seed: Option<u64>,
     ) -> Self {
         self.inner
@@ -157,7 +157,7 @@ impl RbExpr {
         &self,
         fraction: &RbExpr,
         with_replacement: bool,
-        shuffle: bool,
+        shuffle: Option<bool>,
         seed: Option<u64>,
     ) -> Self {
         self.inner