polars-df 0.3.0 → 0.4.0

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

@@ -4,6 +4,7 @@ use polars::lazy::frame::{LazyFrame, LazyGroupBy};
 use polars::prelude::*;
 use std::cell::RefCell;
 use std::io::{BufWriter, Read};
+use std::path::PathBuf;
 
 use crate::conversion::*;
 use crate::file::get_file_like;
@@ -118,7 +119,7 @@ impl RbLazyFrame {
         let skip_rows_after_header: usize = arguments[15].try_convert()?;
         let encoding: Wrap<CsvEncoding> = arguments[16].try_convert()?;
         let row_count: Option<(String, IdxSize)> = arguments[17].try_convert()?;
-        let parse_dates: bool = arguments[18].try_convert()?;
+        let try_parse_dates: bool = arguments[18].try_convert()?;
         let eol_char: String = arguments[19].try_convert()?;
         // end arguments
 
@@ -153,7 +154,7 @@ impl RbLazyFrame {
             .with_skip_rows_after_header(skip_rows_after_header)
             .with_encoding(encoding.0)
             .with_row_count(row_count)
-            .with_parse_dates(parse_dates)
+            .with_try_parse_dates(try_parse_dates)
             .with_null_values(null_values);
 
         if let Some(_lambda) = with_schema_modify {
@@ -163,6 +164,7 @@ impl RbLazyFrame {
         Ok(r.finish().map_err(RbPolarsErr::from)?.into())
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn new_from_parquet(
         path: String,
         n_rows: Option<usize>,
@@ -171,6 +173,7 @@ impl RbLazyFrame {
         rechunk: bool,
         row_count: Option<(String, IdxSize)>,
         low_memory: bool,
+        use_statistics: bool,
     ) -> RbResult<Self> {
         let row_count = row_count.map(|(name, offset)| RowCount { name, offset });
         let args = ScanArgsParquet {
@@ -182,6 +185,7 @@ impl RbLazyFrame {
             low_memory,
             // TODO support cloud options
             cloud_options: None,
+            use_statistics,
         };
         let lf = LazyFrame::scan_parquet(path, args).map_err(RbPolarsErr::from)?;
         Ok(lf.into())
@@ -284,6 +288,32 @@ impl RbLazyFrame {
         Ok(df.into())
     }
 
+    #[allow(clippy::too_many_arguments)]
+    pub fn sink_parquet(
+        &self,
+        path: PathBuf,
+        compression: String,
+        compression_level: Option<i32>,
+        statistics: bool,
+        row_group_size: Option<usize>,
+        data_pagesize_limit: Option<usize>,
+        maintain_order: bool,
+    ) -> RbResult<()> {
+        let compression = parse_parquet_compression(&compression, compression_level)?;
+
+        let options = ParquetWriteOptions {
+            compression,
+            statistics,
+            row_group_size,
+            data_pagesize_limit,
+            maintain_order,
+        };
+
+        let ldf = self.ldf.clone();
+        ldf.sink_parquet(path, options).map_err(RbPolarsErr::from)?;
+        Ok(())
+    }
+
     pub fn fetch(&self, n_rows: usize) -> RbResult<RbDataFrame> {
         let ldf = self.ldf.clone();
         let df = ldf.fetch(n_rows).map_err(RbPolarsErr::from)?;
@@ -328,7 +358,7 @@ impl RbLazyFrame {
         let lazy_gb = ldf.groupby_rolling(
             by,
             RollingGroupOptions {
-                index_column,
+                index_column: index_column.into(),
                 period: Duration::parse(&period),
                 offset: Duration::parse(&offset),
                 closed_window,
@@ -359,7 +389,7 @@ impl RbLazyFrame {
         let lazy_gb = ldf.groupby_dynamic(
             by,
             DynamicGroupOptions {
-                index_column,
+                index_column: index_column.into(),
                 every: Duration::parse(&every),
                 period: Duration::parse(&period),
                 offset: Duration::parse(&offset),
@@ -415,10 +445,10 @@ impl RbLazyFrame {
             .force_parallel(force_parallel)
             .how(JoinType::AsOf(AsOfOptions {
                 strategy: strategy.0,
-                left_by,
-                right_by,
+                left_by: left_by.map(strings_to_smartstrings),
+                right_by: right_by.map(strings_to_smartstrings),
                 tolerance: tolerance.map(|t| t.0.into_static().unwrap()),
-                tolerance_str,
+                tolerance_str: tolerance_str.map(|s| s.into()),
             }))
             .suffix(suffix)
             .finish()
@@ -570,12 +600,14 @@ impl RbLazyFrame {
         value_vars: Vec<String>,
         value_name: Option<String>,
         variable_name: Option<String>,
+        streamable: bool,
     ) -> Self {
         let args = MeltArgs {
-            id_vars,
-            value_vars,
-            value_name,
-            variable_name,
+            id_vars: strings_to_smartstrings(id_vars),
+            value_vars: strings_to_smartstrings(value_vars),
+            value_name: value_name.map(|s| s.into()),
+            variable_name: variable_name.map(|s| s.into()),
+            streamable,
         };
 
         let ldf = self.ldf.clone();
@@ -596,8 +628,10 @@ impl RbLazyFrame {
         self.ldf.clone().into()
     }
 
-    pub fn columns(&self) -> RbResult<Vec<String>> {
-        Ok(self.get_schema()?.iter_names().cloned().collect())
+    pub fn columns(&self) -> RbResult<RArray> {
+        let schema = self.get_schema()?;
+        let iter = schema.iter_names().map(|s| s.as_str());
+        Ok(RArray::from_iter(iter))
     }
 
     pub fn dtypes(&self) -> RbResult<RArray> {
@@ -614,7 +648,7 @@ impl RbLazyFrame {
             // TODO remove unwrap
             schema_dict
                 .aset::<String, Value>(
-                    fld.name().clone(),
+                    fld.name().to_string(),
                     Wrap(fld.data_type().clone()).into_value(),
                 )
                 .unwrap();

data/ext/polars/src/lazy/dsl.rs

@@ -10,7 +10,7 @@ use crate::conversion::*;
 use crate::lazy::apply::*;
 use crate::lazy::utils::rb_exprs_to_exprs;
 use crate::utils::reinterpret;
-use crate::{RbResult, RbSeries};
+use crate::{RbPolarsErr, RbResult, RbSeries};
 
 #[magnus::wrap(class = "Polars::RbExpr")]
 #[derive(Clone)]
@@ -715,6 +715,18 @@ impl RbExpr {
             .into()
     }
 
+    pub fn binary_contains(&self, lit: Vec<u8>) -> Self {
+        self.inner.clone().binary().contains_literal(lit).into()
+    }
+
+    pub fn binary_ends_with(&self, sub: Vec<u8>) -> Self {
+        self.inner.clone().binary().ends_with(sub).into()
+    }
+
+    pub fn binary_starts_with(&self, sub: Vec<u8>) -> Self {
+        self.inner.clone().binary().starts_with(sub).into()
+    }
+
     pub fn str_hex_encode(&self) -> Self {
         self.clone()
             .inner
@@ -763,6 +775,58 @@ impl RbExpr {
             .into()
     }
 
+    pub fn binary_hex_encode(&self) -> Self {
+        self.clone()
+            .inner
+            .map(
+                move |s| s.binary().map(|s| Some(s.hex_encode().into_series())),
+                GetOutput::same_type(),
+            )
+            .with_fmt("binary.hex_encode")
+            .into()
+    }
+
+    pub fn binary_hex_decode(&self, strict: bool) -> Self {
+        self.clone()
+            .inner
+            .map(
+                move |s| {
+                    s.binary()?
+                        .hex_decode(strict)
+                        .map(|s| Some(s.into_series()))
+                },
+                GetOutput::same_type(),
+            )
+            .with_fmt("binary.hex_decode")
+            .into()
+    }
+
+    pub fn binary_base64_encode(&self) -> Self {
+        self.clone()
+            .inner
+            .map(
+                move |s| s.binary().map(|s| Some(s.base64_encode().into_series())),
+                GetOutput::same_type(),
+            )
+            .with_fmt("binary.base64_encode")
+            .into()
+    }
+
+    pub fn binary_base64_decode(&self, strict: bool) -> Self {
+        self.clone()
+            .inner
+            .map(
+                move |s| {
+                    s.binary()?
+                        .base64_decode(strict)
+                        .map(|s| Some(s.into_series()))
+                },
+                GetOutput::same_type(),
+            )
+            .with_fmt("binary.base64_decode")
+            .into()
+    }
+
     pub fn str_json_path_match(&self, pat: String) -> Self {
         let function = move |s: Series| {
             let ca = s.utf8()?;
@@ -1654,9 +1718,9 @@ pub fn cov(a: &RbExpr, b: &RbExpr) -> RbExpr {
     polars::lazy::dsl::cov(a.inner.clone(), b.inner.clone()).into()
 }
 
-pub fn argsort_by(by: RArray, reverse: Vec<bool>) -> RbResult<RbExpr> {
+pub fn arg_sort_by(by: RArray, reverse: Vec<bool>) -> RbResult<RbExpr> {
     let by = rb_exprs_to_exprs(by)?;
-    Ok(polars::lazy::dsl::argsort_by(by, &reverse).into())
+    Ok(polars::lazy::dsl::arg_sort_by(by, &reverse).into())
 }
 
 #[magnus::wrap(class = "Polars::RbWhen")]
@@ -1706,5 +1770,6 @@ pub fn concat_str(s: RArray, sep: String) -> RbResult<RbExpr> {
 
 pub fn concat_lst(s: RArray) -> RbResult<RbExpr> {
     let s = rb_exprs_to_exprs(s)?;
-    Ok(dsl::concat_lst(s).into())
+    let expr = dsl::concat_lst(s).map_err(RbPolarsErr::from)?;
+    Ok(expr.into())
 }

data/ext/polars/src/lib.rs

@@ -6,6 +6,7 @@ mod error;
 mod file;
 mod lazy;
 mod list_construction;
+mod numo;
 mod object;
 mod prelude;
 pub(crate) mod rb_modules;
@@ -72,7 +73,7 @@ fn init() -> RbResult<()> {
     let class = module.define_class("RbDataFrame", Default::default())?;
     class.define_singleton_method("new", function!(RbDataFrame::init, 1))?;
     class.define_singleton_method("read_csv", function!(RbDataFrame::read_csv, -1))?;
-    class.define_singleton_method("read_parquet", function!(RbDataFrame::read_parquet, 7))?;
+    class.define_singleton_method("read_parquet", function!(RbDataFrame::read_parquet, 9))?;
     class.define_singleton_method("read_ipc", function!(RbDataFrame::read_ipc, 6))?;
     class.define_singleton_method("read_avro", function!(RbDataFrame::read_avro, 4))?;
     class.define_singleton_method("read_hashes", function!(RbDataFrame::read_hashes, 3))?;
@@ -87,6 +88,7 @@ fn init() -> RbResult<()> {
     class.define_method("write_ipc", method!(RbDataFrame::write_ipc, 2))?;
     class.define_method("row_tuple", method!(RbDataFrame::row_tuple, 1))?;
     class.define_method("row_tuples", method!(RbDataFrame::row_tuples, 0))?;
+    class.define_method("to_numo", method!(RbDataFrame::to_numo, 0))?;
     class.define_method("write_parquet", method!(RbDataFrame::write_parquet, 5))?;
     class.define_method("add", method!(RbDataFrame::add, 1))?;
     class.define_method("sub", method!(RbDataFrame::sub, 1))?;
@@ -149,7 +151,6 @@ fn init() -> RbResult<()> {
     class.define_method("pivot_expr", method!(RbDataFrame::pivot_expr, 7))?;
     class.define_method("partition_by", method!(RbDataFrame::partition_by, 2))?;
     class.define_method("shift", method!(RbDataFrame::shift, 1))?;
-    class.define_method("unique", method!(RbDataFrame::unique, 3))?;
     class.define_method("lazy", method!(RbDataFrame::lazy, 0))?;
     class.define_method("max", method!(RbDataFrame::max, 0))?;
     class.define_method("min", method!(RbDataFrame::min, 0))?;
@@ -302,10 +303,23 @@ fn init() -> RbResult<()> {
     class.define_method("str_contains", method!(RbExpr::str_contains, 3))?;
     class.define_method("str_ends_with", method!(RbExpr::str_ends_with, 1))?;
     class.define_method("str_starts_with", method!(RbExpr::str_starts_with, 1))?;
+    class.define_method("binary_contains", method!(RbExpr::binary_contains, 1))?;
+    class.define_method("binary_ends_with", method!(RbExpr::binary_ends_with, 1))?;
+    class.define_method("binary_starts_with", method!(RbExpr::binary_starts_with, 1))?;
     class.define_method("str_hex_encode", method!(RbExpr::str_hex_encode, 0))?;
     class.define_method("str_hex_decode", method!(RbExpr::str_hex_decode, 1))?;
     class.define_method("str_base64_encode", method!(RbExpr::str_base64_encode, 0))?;
     class.define_method("str_base64_decode", method!(RbExpr::str_base64_decode, 1))?;
+    class.define_method("binary_hex_encode", method!(RbExpr::binary_hex_encode, 0))?;
+    class.define_method("binary_hex_decode", method!(RbExpr::binary_hex_decode, 1))?;
+    class.define_method(
+        "binary_base64_encode",
+        method!(RbExpr::binary_base64_encode, 0),
+    )?;
+    class.define_method(
+        "binary_base64_decode",
+        method!(RbExpr::binary_base64_decode, 1),
+    )?;
     class.define_method(
         "str_json_path_match",
         method!(RbExpr::str_json_path_match, 1),
@@ -471,7 +485,7 @@ fn init() -> RbResult<()> {
         function!(crate::lazy::dsl::spearman_rank_corr, 4),
     )?;
     class.define_singleton_method("cov", function!(crate::lazy::dsl::cov, 2))?;
-    class.define_singleton_method("argsort_by", function!(crate::lazy::dsl::argsort_by, 2))?;
+    class.define_singleton_method("arg_sort_by", function!(crate::lazy::dsl::arg_sort_by, 2))?;
     class.define_singleton_method("when", function!(crate::lazy::dsl::when, 1))?;
     class.define_singleton_method("concat_str", function!(crate::lazy::dsl::concat_str, 2))?;
     class.define_singleton_method("concat_lst", function!(crate::lazy::dsl::concat_lst, 1))?;
@@ -485,7 +499,7 @@ fn init() -> RbResult<()> {
     class.define_singleton_method("new_from_csv", function!(RbLazyFrame::new_from_csv, -1))?;
     class.define_singleton_method(
         "new_from_parquet",
-        function!(RbLazyFrame::new_from_parquet, 7),
+        function!(RbLazyFrame::new_from_parquet, 8),
     )?;
     class.define_singleton_method("new_from_ipc", function!(RbLazyFrame::new_from_ipc, 6))?;
     class.define_method("write_json", method!(RbLazyFrame::write_json, 1))?;
@@ -502,6 +516,7 @@ fn init() -> RbResult<()> {
     class.define_method("sort_by_exprs", method!(RbLazyFrame::sort_by_exprs, 3))?;
     class.define_method("cache", method!(RbLazyFrame::cache, 0))?;
     class.define_method("collect", method!(RbLazyFrame::collect, 0))?;
+    class.define_method("sink_parquet", method!(RbLazyFrame::sink_parquet, 7))?;
     class.define_method("fetch", method!(RbLazyFrame::fetch, 1))?;
     class.define_method("filter", method!(RbLazyFrame::filter, 1))?;
     class.define_method("select", method!(RbLazyFrame::select, 1))?;
@@ -530,7 +545,7 @@ fn init() -> RbResult<()> {
     class.define_method("drop_nulls", method!(RbLazyFrame::drop_nulls, 1))?;
     class.define_method("slice", method!(RbLazyFrame::slice, 2))?;
     class.define_method("tail", method!(RbLazyFrame::tail, 1))?;
-    class.define_method("melt", method!(RbLazyFrame::melt, 4))?;
+    class.define_method("melt", method!(RbLazyFrame::melt, 5))?;
     class.define_method("with_row_count", method!(RbLazyFrame::with_row_count, 2))?;
     class.define_method("drop_columns", method!(RbLazyFrame::drop_columns, 1))?;
     class.define_method("_clone", method!(RbLazyFrame::clone, 0))?;
@@ -558,6 +573,7 @@ fn init() -> RbResult<()> {
     class.define_singleton_method("new_opt_f32", function!(RbSeries::new_opt_f32, 3))?;
     class.define_singleton_method("new_opt_f64", function!(RbSeries::new_opt_f64, 3))?;
     class.define_singleton_method("new_str", function!(RbSeries::new_str, 3))?;
+    class.define_singleton_method("new_binary", function!(RbSeries::new_binary, 3))?;
     class.define_singleton_method("new_object", function!(RbSeries::new_object, 3))?;
     class.define_singleton_method("new_list", function!(RbSeries::new_list, 3))?;
     class.define_singleton_method("new_opt_date", function!(RbSeries::new_opt_date, 3))?;
@@ -783,6 +799,9 @@ fn init() -> RbResult<()> {
     class.define_method("lt_eq_f64", method!(RbSeries::lt_eq_f64, 1))?;
     // class.define_method("lt_eq_str", method!(RbSeries::lt_eq_str, 1))?;
 
+    // npy
+    class.define_method("to_numo", method!(RbSeries::to_numo, 0))?;
+
     let class = module.define_class("RbWhen", Default::default())?;
     class.define_method("_then", method!(RbWhen::then, 1))?;
 

data/ext/polars/src/numo.rs

@@ -0,0 +1,57 @@
+use magnus::{class, Module, RArray, RClass, RModule, Value};
+use polars_core::prelude::*;
+
+use crate::{raise_err, RbPolarsErr, RbResult, RbSeries};
+
+impl RbSeries {
+    /// For numeric types, this should only be called for Series with null types.
+    /// This will cast to floats so that `nil = NAN`
+    pub fn to_numo(&self) -> RbResult<Value> {
+        let s = &self.series.borrow();
+        match s.dtype() {
+            DataType::Utf8 => {
+                let ca = s.utf8().unwrap();
+
+                // TODO make more efficient
+                let np_arr = RArray::from_iter(ca.into_iter());
+                class::object()
+                    .const_get::<_, RModule>("Numo")?
+                    .const_get::<_, RClass>("RObject")?
+                    .funcall("cast", (np_arr,))
+            }
+            dt if dt.is_numeric() => {
+                if s.bit_repr_is_large() {
+                    let s = s.cast(&DataType::Float64).unwrap();
+                    let ca = s.f64().unwrap();
+                    // TODO make more efficient
+                    let np_arr = RArray::from_iter(ca.into_iter().map(|opt_v| match opt_v {
+                        Some(v) => v,
+                        None => f64::NAN,
+                    }));
+                    class::object()
+                        .const_get::<_, RModule>("Numo")?
+                        .const_get::<_, RClass>("DFloat")?
+                        .funcall("cast", (np_arr,))
+                } else {
+                    let s = s.cast(&DataType::Float32).unwrap();
+                    let ca = s.f32().unwrap();
+                    // TODO make more efficient
+                    let np_arr = RArray::from_iter(ca.into_iter().map(|opt_v| match opt_v {
+                        Some(v) => v,
+                        None => f32::NAN,
+                    }));
+                    class::object()
+                        .const_get::<_, RModule>("Numo")?
+                        .const_get::<_, RClass>("SFloat")?
+                        .funcall("cast", (np_arr,))
+                }
+            }
+            dt => {
+                raise_err!(
+                    format!("'to_numo' not supported for dtype: {dt:?}"),
+                    ComputeError
+                );
+            }
+        }
+    }
+}

data/ext/polars/src/series.rs

@@ -125,6 +125,12 @@ impl RbSeries {
         RbSeries::new(s)
     }
 
+    pub fn new_binary(name: String, val: Wrap<BinaryChunked>, _strict: bool) -> Self {
+        let mut s = val.0.into_series();
+        s.rename(&name);
+        RbSeries::new(s)
+    }
+
     pub fn new_object(name: String, val: RArray, _strict: bool) -> RbResult<Self> {
         let val = val
             .each()
@@ -489,40 +495,58 @@ impl RbSeries {
     }
 
     pub fn to_a(&self) -> RArray {
-        let series = self.series.borrow();
-        if let Ok(s) = series.f32() {
-            s.into_iter().collect()
-        } else if let Ok(s) = series.f64() {
-            s.into_iter().collect()
-        } else if let Ok(s) = series.i8() {
-            s.into_iter().collect()
-        } else if let Ok(s) = series.i16() {
-            s.into_iter().collect()
-        } else if let Ok(s) = series.i32() {
-            s.into_iter().collect()
-        } else if let Ok(s) = series.i64() {
-            s.into_iter().collect()
-        } else if let Ok(s) = series.u8() {
-            s.into_iter().collect()
-        } else if let Ok(s) = series.u16() {
-            s.into_iter().collect()
-        } else if let Ok(s) = series.u32() {
-            s.into_iter().collect()
-        } else if let Ok(s) = series.u64() {
-            s.into_iter().collect()
-        } else if let Ok(s) = series.bool() {
-            s.into_iter().collect()
-        } else if let Ok(s) = series.utf8() {
-            s.into_iter().collect()
-        } else if let Ok(_s) = series.date() {
-            let a = RArray::with_capacity(series.len());
-            for v in series.iter() {
-                a.push::<Value>(Wrap(v).into_value()).unwrap();
-            }
-            a
-        } else {
-            unimplemented!();
+        let series = &self.series.borrow();
+
+        fn to_list_recursive(series: &Series) -> RArray {
+            let rblist = match series.dtype() {
+                DataType::Boolean => RArray::from_iter(series.bool().unwrap()),
+                DataType::UInt8 => RArray::from_iter(series.u8().unwrap()),
+                DataType::UInt16 => RArray::from_iter(series.u16().unwrap()),
+                DataType::UInt32 => RArray::from_iter(series.u32().unwrap()),
+                DataType::UInt64 => RArray::from_iter(series.u64().unwrap()),
+                DataType::Int8 => RArray::from_iter(series.i8().unwrap()),
+                DataType::Int16 => RArray::from_iter(series.i16().unwrap()),
+                DataType::Int32 => RArray::from_iter(series.i32().unwrap()),
+                DataType::Int64 => RArray::from_iter(series.i64().unwrap()),
+                DataType::Float32 => RArray::from_iter(series.f32().unwrap()),
+                DataType::Float64 => RArray::from_iter(series.f64().unwrap()),
+                DataType::Categorical(_) => {
+                    RArray::from_iter(series.categorical().unwrap().iter_str())
+                }
+                DataType::Date => {
+                    let a = RArray::with_capacity(series.len());
+                    for v in series.iter() {
+                        a.push::<Value>(Wrap(v).into_value()).unwrap();
+                    }
+                    return a;
+                }
+                DataType::Datetime(_, _) => {
+                    let a = RArray::with_capacity(series.len());
+                    for v in series.iter() {
+                        a.push::<Value>(Wrap(v).into_value()).unwrap();
+                    }
+                    return a;
+                }
+                DataType::Utf8 => {
+                    let ca = series.utf8().unwrap();
+                    return RArray::from_iter(ca);
+                }
+                DataType::Binary => {
+                    let a = RArray::with_capacity(series.len());
+                    for v in series.iter() {
+                        a.push::<Value>(Wrap(v).into_value()).unwrap();
+                    }
+                    return a;
+                }
+                DataType::Null | DataType::Unknown => {
+                    panic!("to_a not implemented for null/unknown")
+                }
+                _ => todo!(),
+            };
+            rblist
         }
+
+        to_list_recursive(series)
     }
 
     pub fn median(&self) -> Option<f64> {

data/lib/polars/batched_csv_reader.rb

@@ -30,7 +30,7 @@ module Polars
       new_columns: nil
     )
       if Utils.pathlike?(file)
-        path = Utils.format_path(file)
+        path = Utils.normalise_filepath(file)
       end
 
       dtype_list = nil

data/lib/polars/binary_expr.rb

@@ -0,0 +1,77 @@
+module Polars
+  # Namespace for binary related expressions.
+  class BinaryExpr
+    # @private
+    attr_accessor :_rbexpr
+
+    # @private
+    def initialize(expr)
+      self._rbexpr = expr._rbexpr
+    end
+
+    # Check if binaries in Series contain a binary substring.
+    #
+    # @param lit [String]
+    #   The binary substring to look for
+    #
+    # @return [Expr]
+    def contains(lit)
+      Utils.wrap_expr(_rbexpr.binary_contains(lit))
+    end
+
+    # Check if string values end with a binary substring.
+    #
+    # @param sub [String]
+    #   Suffix substring.
+    #
+    # @return [Expr]
+    def ends_with(sub)
+      Utils.wrap_expr(_rbexpr.binary_ends_with(sub))
+    end
+
+    # Check if values start with a binary substring.
+    #
+    # @param sub [String]
+    #   Prefix substring.
+    #
+    # @return [Expr]
+    def starts_with(sub)
+      Utils.wrap_expr(_rbexpr.binary_starts_with(sub))
+    end
+
+    # Decode a value using the provided encoding.
+    #
+    # @param encoding ["hex", "base64"]
+    #   The encoding to use.
+    # @param strict [Boolean]
+    #   Raise an error if the underlying value cannot be decoded,
+    #   otherwise mask out with a null value.
+    #
+    # @return [Expr]
+    def decode(encoding, strict: true)
+      if encoding == "hex"
+        Utils.wrap_expr(_rbexpr.binary_hex_decode(strict))
+      elsif encoding == "base64"
+        Utils.wrap_expr(_rbexpr.binary_base64_decode(strict))
+      else
+        raise ArgumentError, "encoding must be one of {{'hex', 'base64'}}, got #{encoding}"
+      end
+    end
+
+    # Encode a value using the provided encoding.
+    #
+    # @param encoding ["hex", "base64"]
+    #   The encoding to use.
+    #
+    # @return [Expr]
+    def encode(encoding)
+      if encoding == "hex"
+        Utils.wrap_expr(_rbexpr.binary_hex_encode)
+      elsif encoding == "base64"
+        Utils.wrap_expr(_rbexpr.binary_base64_encode)
+      else
+        raise ArgumentError, "encoding must be one of {{'hex', 'base64'}}, got #{encoding}"
+      end
+    end
+  end
+end

data/lib/polars/binary_name_space.rb

@@ -0,0 +1,66 @@
+module Polars
+  # Series.bin namespace.
+  class BinaryNameSpace
+    include ExprDispatch
+
+    self._accessor = "bin"
+
+    # @private
+    def initialize(series)
+      self._s = series._s
+    end
+
+    # Check if binaries in Series contain a binary substring.
+    #
+    # @param lit [String]
+    #   The binary substring to look for
+    #
+    # @return [Series]
+    def contains(lit)
+      super
+    end
+
+    # Check if string values end with a binary substring.
+    #
+    # @param sub [String]
+    #   Suffix substring.
+    #
+    # @return [Series]
+    def ends_with(sub)
+      super
+    end
+
+    # Check if values start with a binary substring.
+    #
+    # @param sub [String]
+    #   Prefix substring.
+    #
+    # @return [Series]
+    def starts_with(sub)
+      super
+    end
+
+    # Decode a value using the provided encoding.
+    #
+    # @param encoding ["hex", "base64"]
+    #   The encoding to use.
+    # @param strict [Boolean]
+    #   Raise an error if the underlying value cannot be decoded,
+    #   otherwise mask out with a null value.
+    #
+    # @return [Series]
+    def decode(encoding, strict: true)
+      super
+    end
+
+    # Encode a value using the provided encoding.
+    #
+    # @param encoding ["hex", "base64"]
+    #   The encoding to use.
+    #
+    # @return [Series]
+    def encode(encoding)
+      super
+    end
+  end
+end