polars-df 0.21.0 → 0.21.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f70a1d0c71919e3a30fdb634d0830b9fb1c10e1e7cffeef7ce708a231e0dd17
-  data.tar.gz: 58c9913f4fd47fbde9ad68ac7ddbdd64afc441941f623b3b407295783d14644c
+  metadata.gz: a19860350cc2b97401611c848072bace63f15188d8b43289cca12d6adcf7593c
+  data.tar.gz: 01565f74f8b41286214c22e2016f45e0da05a8c9ce610f7cb3dd3616292f185b
 SHA512:
-  metadata.gz: 71dd11888467ed867894e7990718fcd5535d433d64db2340442a9f0f84c082560a97bb4de0bfb609f3dfd1a2988c9b7dcff0aef85cfa78670af0ed3f34994840
-  data.tar.gz: 363d53b6257f4144dd341916d3d103d8197469886abc836c0c184281191d16cfe9140207d4643008adb6118aafd2bd6f8fefc99962f49642409720db79a4b114
+  metadata.gz: 391989a65c5a2c5b96ad05f9b9f0553c97153133a3f522ea8d77173b6f9fb3e9ca3838f453a2a750b158a8f0b86a0ffad62468789f84a993e16005342d6a8b14
+  data.tar.gz: cf846b8cfcd4f44085a583b133f935f636764f1a440dcf4cd3c98b52a510066036b8565cb8ac1089f5cdb433c4dcab05b9325772d97e3d48ad7ebd1de9aeadd8

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+## 0.21.1 (2025-08-18)
+
+- Added `read_parquet_metadata` method to `Polars`
+- Added more methods to `Series` and `Expr`
+- Added more methods to `DataFrame` and `LazyFrame`
+- Added more methods to `ArrayExpr` and `ArrayNameSpace`
+- Added more methods to `BinaryExpr` and `BinaryNameSpace`
+- Added more methods to `CatExpr` and `CatNameSpace`
+- Added more methods to `DateTimeExpr` ane `DateTimeNameSpace`
+- Added more methods to `ListExpr` and `ListNameSpace`
+- Added more methods to `MetaExpr`
+- Added more methods to `NameExpr`
+- Added more methods to `StringExpr` and `StringNameSpace`
+- Added more methods to `StructExpr` and `StructNameSpace`
+- Fixed `subset` option for `drop_nulls` method
+
 ## 0.21.0 (2025-08-03)
 
 - Updated Polars to 0.50.0

data/Cargo.lock

@@ -1654,7 +1654,7 @@ dependencies = [
 
 [[package]]
 name = "polars"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
  "ahash",
  "bytes",

data/ext/polars/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "polars"
-version = "0.21.0"
+version = "0.21.1"
 license = "MIT"
 authors = ["Andrew Kane <andrew@ankane.org>"]
 edition = "2024"
@@ -37,11 +37,13 @@ features = [
     "arg_where",
     "array_any_all",
     "array_count",
+    "array_to_struct",
     "asof_join",
     "avro",
     "aws",
     "azure",
     "binary_encoding",
+    "bitwise",
     "business",
     "cloud",
     "concat_str",
@@ -65,12 +67,16 @@ features = [
     "find_many",
     "fmt",
     "gcp",
+    "hist",
     "http",
+    "iejoin",
+    "index_of",
     "interpolate",
     "interpolate_by",
     "ipc",
     "ipc_streaming",
     "is_between",
+    "is_close",
     "is_first_distinct",
     "is_in",
     "is_last_distinct",

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

@@ -21,6 +21,7 @@ use polars::io::cloud::CloudOptions;
 use polars::prelude::deletion::DeletionFilesList;
 use polars::prelude::*;
 use polars::series::ops::NullBehavior;
+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;
@@ -30,6 +31,7 @@ use polars_utils::total_ord::{TotalEq, TotalHash};
 use crate::file::{RubyScanSourceInput, get_ruby_scan_source_input};
 use crate::object::OBJECT_NAME;
 use crate::rb_modules::series;
+use crate::utils::to_rb_err;
 use crate::{RbDataFrame, RbLazyFrame, RbPolarsErr, RbResult, RbSeries, RbTypeError, RbValueError};
 
 pub(crate) fn slice_extract_wrapped<T>(slice: &[Wrap<T>]) -> &[T] {
@@ -524,6 +526,12 @@ impl TryConvert for Wrap<Schema> {
     }
 }
 
+impl TryConvert for Wrap<ArrowSchema> {
+    fn try_convert(_ob: Value) -> RbResult<Self> {
+        todo!();
+    }
+}
+
 impl TryConvert for Wrap<ScanSources> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let list = RArray::try_convert(ob)?;
@@ -979,6 +987,22 @@ impl TryConvert for Wrap<RankMethod> {
     }
 }
 
+impl TryConvert for Wrap<Roll> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let parsed = match String::try_convert(ob)?.as_str() {
+            "raise" => Roll::Raise,
+            "forward" => Roll::Forward,
+            "backward" => Roll::Backward,
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "`roll` must be one of {{'raise', 'forward', 'backward'}}, got {v}",
+                )));
+            }
+        };
+        Ok(Wrap(parsed))
+    }
+}
+
 impl TryConvert for Wrap<TimeUnit> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let parsed = match String::try_convert(ob)?.as_str() {
@@ -1270,6 +1294,23 @@ impl TryConvert for RbCompatLevel {
     }
 }
 
+impl TryConvert for Wrap<UnicodeForm> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let parsed = match String::try_convert(ob)?.as_str() {
+            "NFC" => UnicodeForm::NFC,
+            "NFKC" => UnicodeForm::NFKC,
+            "NFD" => UnicodeForm::NFD,
+            "NFKD" => UnicodeForm::NFKD,
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "`form` must be one of {{'NFC', 'NFKC', 'NFD', 'NFKD'}}, got {v}",
+                )));
+            }
+        };
+        Ok(Wrap(parsed))
+    }
+}
+
 impl TryConvert for Wrap<Option<TimeZone>> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let tz = Option::<Wrap<PlSmallStr>>::try_convert(ob)?;
@@ -1313,13 +1354,60 @@ impl TryConvert for Wrap<MissingColumnsPolicy> {
 }
 
 impl TryConvert for Wrap<ColumnMapping> {
-    fn try_convert(_ob: Value) -> RbResult<Self> {
-        todo!()
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let (column_mapping_type, ob) = <(String, Value)>::try_convert(ob)?;
+
+        Ok(Wrap(match column_mapping_type.as_str() {
+            "iceberg-column-mapping" => {
+                let arrow_schema = Wrap::<ArrowSchema>::try_convert(ob)?;
+                ColumnMapping::Iceberg(Arc::new(
+                    IcebergSchema::from_arrow_schema(&arrow_schema.0).map_err(to_rb_err)?,
+                ))
+            }
+
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "unknown column mapping type: {v}"
+                )));
+            }
+        }))
     }
 }
 
 impl TryConvert for Wrap<DeletionFilesList> {
-    fn try_convert(_ob: Value) -> RbResult<Self> {
-        todo!();
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let (deletion_file_type, ob) = <(String, Value)>::try_convert(ob)?;
+
+        Ok(Wrap(match deletion_file_type.as_str() {
+            "iceberg-position-delete" => {
+                let dict = RHash::try_convert(ob)?;
+
+                let mut out = PlIndexMap::new();
+
+                dict.foreach(|k: usize, v: RArray| {
+                    let files = v
+                        .into_iter()
+                        .map(|x| {
+                            let x = String::try_convert(x)?;
+                            Ok(x)
+                        })
+                        .collect::<RbResult<Arc<[String]>>>()?;
+
+                    if !files.is_empty() {
+                        out.insert(k, files);
+                    }
+
+                    Ok(ForEach::Continue)
+                })?;
+
+                DeletionFilesList::IcebergPositionDelete(Arc::new(out))
+            }
+
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "unknown deletion file type: {v}"
+                )));
+            }
+        }))
     }
 }

data/ext/polars/src/exceptions.rs

@@ -20,5 +20,6 @@ macro_rules! create_exception {
 create_exception!(RbTypeError, exception::type_error());
 create_exception!(RbValueError, exception::arg_error());
 create_exception!(RbOverflowError, exception::range_error());
+create_exception!(RbIndexError, exception::index_error());
 create_exception!(ComputeError, rb_modules::compute_error());
 create_exception!(InvalidOperationError, rb_modules::invalid_operation_error());

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

@@ -1,20 +1,41 @@
+use magnus::Value;
 use polars::prelude::*;
 
-use crate::RbExpr;
+use crate::{RbExpr, RbPolarsErr, RbResult};
 
 impl RbExpr {
-    pub fn array_max(&self) -> Self {
+    pub fn arr_len(&self) -> Self {
+        self.inner.clone().arr().len().into()
+    }
+
+    pub fn arr_max(&self) -> Self {
         self.inner.clone().arr().max().into()
     }
 
-    pub fn array_min(&self) -> Self {
+    pub fn arr_min(&self) -> Self {
         self.inner.clone().arr().min().into()
     }
 
-    pub fn array_sum(&self) -> Self {
+    pub fn arr_sum(&self) -> Self {
         self.inner.clone().arr().sum().into()
     }
 
+    pub fn arr_std(&self, ddof: u8) -> Self {
+        self.inner.clone().arr().std(ddof).into()
+    }
+
+    pub fn arr_var(&self, ddof: u8) -> Self {
+        self.inner.clone().arr().var(ddof).into()
+    }
+
+    pub fn arr_mean(&self) -> Self {
+        self.inner.clone().arr().mean().into()
+    }
+
+    pub fn arr_median(&self) -> Self {
+        self.inner.clone().arr().median().into()
+    }
+
     pub fn arr_unique(&self, maintain_order: bool) -> Self {
         if maintain_order {
             self.inner.clone().arr().unique_stable().into()
@@ -23,6 +44,10 @@ impl RbExpr {
         }
     }
 
+    pub fn arr_n_unique(&self) -> Self {
+        self.inner.clone().arr().n_unique().into()
+    }
+
     pub fn arr_to_list(&self) -> Self {
         self.inner.clone().arr().to_list().into()
     }
@@ -90,4 +115,48 @@ impl RbExpr {
             .count_matches(expr.inner.clone())
             .into()
     }
+
+    pub fn arr_to_struct(&self, name_gen: Option<Value>) -> Self {
+        if name_gen.is_some() {
+            todo!();
+        }
+        self.inner.clone().arr().to_struct(None).into()
+    }
+
+    pub fn arr_slice(
+        &self,
+        offset: &RbExpr,
+        length: Option<&RbExpr>,
+        as_array: bool,
+    ) -> RbResult<Self> {
+        let length = match length {
+            Some(i) => i.inner.clone(),
+            None => lit(i64::MAX),
+        };
+        Ok(self
+            .inner
+            .clone()
+            .arr()
+            .slice(offset.inner.clone(), length, as_array)
+            .map_err(RbPolarsErr::from)?
+            .into())
+    }
+
+    pub fn arr_tail(&self, n: &RbExpr, as_array: bool) -> RbResult<Self> {
+        Ok(self
+            .inner
+            .clone()
+            .arr()
+            .tail(n.inner.clone(), as_array)
+            .map_err(RbPolarsErr::from)?
+            .into())
+    }
+
+    pub fn arr_shift(&self, n: &RbExpr) -> Self {
+        self.inner.clone().arr().shift(n.inner.clone()).into()
+    }
+
+    pub fn arr_explode(&self) -> Self {
+        self.inner.clone().arr().explode().into()
+    }
 }

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

@@ -1,4 +1,5 @@
-use crate::RbExpr;
+use crate::expr::datatype::RbDataTypeExpr;
+use crate::{RbExpr, RbResult};
 
 impl RbExpr {
     pub fn bin_contains(&self, lit: &RbExpr) -> Self {
@@ -40,4 +41,28 @@ impl RbExpr {
     pub fn bin_base64_encode(&self) -> Self {
         self.inner.clone().binary().base64_encode().into()
     }
+
+    pub fn bin_reinterpret(&self, dtype: &RbDataTypeExpr, kind: String) -> RbResult<Self> {
+        use crate::RbValueError;
+
+        let is_little_endian = match kind.to_lowercase().as_str() {
+            "little" => true,
+            "big" => false,
+            _ => {
+                return Err(RbValueError::new_err(format!(
+                    "Invalid endianness: {kind}. Valid values are \"little\" or \"big\"."
+                )));
+            }
+        };
+        Ok(self
+            .inner
+            .clone()
+            .binary()
+            .reinterpret(dtype.inner.clone(), is_little_endian)
+            .into())
+    }
+
+    pub fn bin_size_bytes(&self) -> Self {
+        self.inner.clone().binary().size_bytes().into()
+    }
 }

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

@@ -0,0 +1,39 @@
+use crate::RbExpr;
+
+impl RbExpr {
+    pub fn bitwise_count_ones(&self) -> Self {
+        self.inner.clone().bitwise_count_ones().into()
+    }
+
+    pub fn bitwise_count_zeros(&self) -> Self {
+        self.inner.clone().bitwise_count_zeros().into()
+    }
+
+    pub fn bitwise_leading_ones(&self) -> Self {
+        self.inner.clone().bitwise_leading_ones().into()
+    }
+
+    pub fn bitwise_leading_zeros(&self) -> Self {
+        self.inner.clone().bitwise_leading_zeros().into()
+    }
+
+    pub fn bitwise_trailing_ones(&self) -> Self {
+        self.inner.clone().bitwise_trailing_ones().into()
+    }
+
+    pub fn bitwise_trailing_zeros(&self) -> Self {
+        self.inner.clone().bitwise_trailing_zeros().into()
+    }
+
+    pub fn bitwise_and(&self) -> Self {
+        self.inner.clone().bitwise_and().into()
+    }
+
+    pub fn bitwise_or(&self) -> Self {
+        self.inner.clone().bitwise_or().into()
+    }
+
+    pub fn bitwise_xor(&self) -> Self {
+        self.inner.clone().bitwise_xor().into()
+    }
+}

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

@@ -4,4 +4,24 @@ impl RbExpr {
     pub fn cat_get_categories(&self) -> Self {
         self.inner.clone().cat().get_categories().into()
     }
+
+    pub fn cat_len_bytes(&self) -> Self {
+        self.inner.clone().cat().len_bytes().into()
+    }
+
+    pub fn cat_len_chars(&self) -> Self {
+        self.inner.clone().cat().len_chars().into()
+    }
+
+    pub fn cat_starts_with(&self, prefix: String) -> Self {
+        self.inner.clone().cat().starts_with(prefix).into()
+    }
+
+    pub fn cat_ends_with(&self, suffix: String) -> Self {
+        self.inner.clone().cat().ends_with(suffix).into()
+    }
+
+    pub fn cat_slice(&self, offset: i64, length: Option<usize>) -> Self {
+        self.inner.clone().cat().slice(offset, length).into()
+    }
 }

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

@@ -1,4 +1,8 @@
-use polars::prelude::DataTypeExpr;
+use magnus::{IntoValue, Value};
+use polars::prelude::{DataType, DataTypeExpr, Schema};
+
+use crate::prelude::Wrap;
+use crate::{RbExpr, RbPolarsErr, RbResult};
 
 #[magnus::wrap(class = "Polars::RbDataTypeExpr")]
 #[repr(transparent)]
@@ -12,3 +16,22 @@ impl From<DataTypeExpr> for RbDataTypeExpr {
         RbDataTypeExpr { inner: expr }
     }
 }
+
+impl RbDataTypeExpr {
+    pub fn from_dtype(datatype: Wrap<DataType>) -> Self {
+        DataTypeExpr::Literal(datatype.0).into()
+    }
+
+    pub fn of_expr(expr: &RbExpr) -> Self {
+        DataTypeExpr::OfExpr(Box::new(expr.inner.clone())).into()
+    }
+
+    pub fn collect_dtype(&self, schema: Wrap<Schema>) -> RbResult<Value> {
+        let dtype = self
+            .clone()
+            .inner
+            .into_datatype(&schema.0)
+            .map_err(RbPolarsErr::from)?;
+        Ok(Wrap(dtype).into_value())
+    }
+}

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

@@ -4,6 +4,20 @@ use crate::conversion::Wrap;
 use crate::{RbExpr, RbPolarsErr, RbResult};
 
 impl RbExpr {
+    pub fn dt_add_business_days(
+        &self,
+        n: &RbExpr,
+        week_mask: [bool; 7],
+        holidays: Vec<i32>,
+        roll: Wrap<Roll>,
+    ) -> Self {
+        self.inner
+            .clone()
+            .dt()
+            .add_business_days(n.inner.clone(), week_mask, holidays, roll.0)
+            .into()
+    }
+
     pub fn dt_to_string(&self, format: String) -> Self {
         self.inner.clone().dt().to_string(&format).into()
     }
@@ -90,6 +104,34 @@ impl RbExpr {
         self.inner.clone().dt().round(every.inner.clone()).into()
     }
 
+    #[allow(clippy::too_many_arguments)]
+    pub fn dt_replace(
+        &self,
+        year: &Self,
+        month: &Self,
+        day: &Self,
+        hour: &Self,
+        minute: &Self,
+        second: &Self,
+        microsecond: &Self,
+        ambiguous: &Self,
+    ) -> Self {
+        self.inner
+            .clone()
+            .dt()
+            .replace(
+                year.inner.clone(),
+                month.inner.clone(),
+                day.inner.clone(),
+                hour.inner.clone(),
+                minute.inner.clone(),
+                second.inner.clone(),
+                microsecond.inner.clone(),
+                ambiguous.inner.clone(),
+            )
+            .into()
+    }
+
     pub fn dt_combine(&self, time: &Self, time_unit: Wrap<TimeUnit>) -> Self {
         self.inner
             .clone()
@@ -98,10 +140,26 @@ impl RbExpr {
             .into()
     }
 
+    pub fn dt_millennium(&self) -> Self {
+        self.inner.clone().dt().millennium().into()
+    }
+
+    pub fn dt_century(&self) -> Self {
+        self.inner.clone().dt().century().into()
+    }
+
     pub fn dt_year(&self) -> Self {
         self.clone().inner.dt().year().into()
     }
 
+    pub fn dt_is_business_day(&self, week_mask: [bool; 7], holidays: Vec<i32>) -> Self {
+        self.inner
+            .clone()
+            .dt()
+            .is_business_day(week_mask, holidays)
+            .into()
+    }
+
     pub fn dt_is_leap_year(&self) -> Self {
         self.clone().inner.dt().is_leap_year().into()
     }