polars-df 0.19.0 → 0.21.0

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

@@ -1,15 +1,16 @@
 pub(crate) mod any_value;
+mod categorical;
 mod chunked_array;
 
 use std::fmt::{Debug, Display, Formatter};
 use std::fs::File;
 use std::hash::{Hash, Hasher};
 use std::num::NonZeroUsize;
-use std::path::PathBuf;
 
+pub use categorical::RbCategories;
 use magnus::{
-    class, exception, prelude::*, r_hash::ForEach, try_convert::TryConvertOwned, value::Opaque,
-    IntoValue, Module, RArray, RHash, Ruby, Symbol, TryConvert, Value,
+    IntoValue, Module, RArray, RHash, Ruby, Symbol, TryConvert, Value, class, exception,
+    prelude::*, r_hash::ForEach, try_convert::TryConvertOwned, value::Opaque,
 };
 use polars::chunked_array::object::PolarsObjectSafe;
 use polars::chunked_array::ops::{FillNullLimit, FillNullStrategy};
@@ -17,6 +18,7 @@ use polars::datatypes::AnyValue;
 use polars::frame::row::Row;
 use polars::io::avro::AvroCompression;
 use polars::io::cloud::CloudOptions;
+use polars::prelude::deletion::DeletionFilesList;
 use polars::prelude::*;
 use polars::series::ops::NullBehavior;
 use polars_core::utils::arrow::array::Array;
@@ -25,7 +27,7 @@ use polars_plan::dsl::ScanSources;
 use polars_utils::mmap::MemSlice;
 use polars_utils::total_ord::{TotalEq, TotalHash};
 
-use crate::file::{get_ruby_scan_source_input, RubyScanSourceInput};
+use crate::file::{RubyScanSourceInput, get_ruby_scan_source_input};
 use crate::object::OBJECT_NAME;
 use crate::rb_modules::series;
 use crate::{RbDataFrame, RbLazyFrame, RbPolarsErr, RbResult, RbSeries, RbTypeError, RbValueError};
@@ -226,18 +228,25 @@ impl IntoValue for Wrap<DataType> {
                 let class = pl.const_get::<_, Value>("Object").unwrap();
                 class.funcall("new", ()).unwrap()
             }
-            DataType::Categorical(_, ordering) => {
-                let class = pl.const_get::<_, Value>("Categorical").unwrap();
-                class.funcall("new", (Wrap(ordering),)).unwrap()
-            }
-            DataType::Enum(rev_map, _) => {
-                // we should always have an initialized rev_map coming from rust
-                let categories = rev_map.as_ref().unwrap().get_categories();
+            DataType::Categorical(cats, _) => {
+                let categories_class = pl.const_get::<_, Value>("Categories").unwrap();
+                let categorical_class = pl.const_get::<_, Value>("Categorical").unwrap();
+                let categories: Value = categories_class
+                    .funcall("_from_rb_categories", (RbCategories::from(cats.clone()),))
+                    .unwrap();
+                let kwargs = RHash::new();
+                kwargs.aset(Symbol::new("categories"), categories).unwrap();
+                categorical_class.funcall("new", (kwargs,)).unwrap()
+            }
+            DataType::Enum(_, mapping) => {
+                let categories = unsafe {
+                    StringChunked::from_chunks(
+                        PlSmallStr::from_static("category"),
+                        vec![mapping.to_arrow(true)],
+                    )
+                };
                 let class = pl.const_get::<_, Value>("Enum").unwrap();
-                let s =
-                    Series::from_arrow(PlSmallStr::from_static("category"), categories.to_boxed())
-                        .unwrap();
-                let series = to_series(s.into());
+                let series = to_series(categories.into_series().into());
                 class.funcall::<_, _, Value>("new", (series,)).unwrap()
             }
             DataType::Time => {
@@ -277,13 +286,13 @@ impl IntoValue for Wrap<DataType> {
     }
 }
 
+enum CategoricalOrdering {
+    Lexical,
+}
+
 impl IntoValue for Wrap<CategoricalOrdering> {
     fn into_value_with(self, _: &Ruby) -> Value {
-        let ordering = match self.0 {
-            CategoricalOrdering::Physical => "physical",
-            CategoricalOrdering::Lexical => "lexical",
-        };
-        ordering.into_value()
+        "lexical".into_value()
     }
 }
 
@@ -324,8 +333,10 @@ impl TryConvert for Wrap<DataType> {
                 "Polars::Boolean" => DataType::Boolean,
                 "Polars::String" => DataType::String,
                 "Polars::Binary" => DataType::Binary,
-                "Polars::Categorical" => DataType::Categorical(None, Default::default()),
-                "Polars::Enum" => DataType::Enum(None, Default::default()),
+                "Polars::Categorical" => DataType::from_categories(Categories::global()),
+                "Polars::Enum" => {
+                    DataType::from_frozen_categories(FrozenCategories::new([]).unwrap())
+                }
                 "Polars::Date" => DataType::Date,
                 "Polars::Time" => DataType::Time,
                 "Polars::Datetime" => DataType::Datetime(TimeUnit::Microseconds, None),
@@ -340,11 +351,12 @@ impl TryConvert for Wrap<DataType> {
                 dt => {
                     return Err(RbValueError::new_err(format!(
                         "{dt} is not a correct polars DataType.",
-                    )))
+                    )));
                 }
             }
         } else if String::try_convert(ob).is_err() {
-            let name = unsafe { ob.class().name() }.into_owned();
+            let cls = ob.class();
+            let name = unsafe { cls.name() }.into_owned();
             match name.as_str() {
                 "Polars::Int8" => DataType::Int8,
                 "Polars::Int16" => DataType::Int16,
@@ -360,17 +372,20 @@ impl TryConvert for Wrap<DataType> {
                 "Polars::String" => DataType::String,
                 "Polars::Binary" => DataType::Binary,
                 "Polars::Categorical" => {
-                    let ordering = ob
-                        .funcall::<_, _, Wrap<CategoricalOrdering>>("ordering", ())?
-                        .0;
-                    DataType::Categorical(None, ordering)
+                    let categories: Value = ob.funcall("categories", ()).unwrap();
+                    let rb_categories: &RbCategories =
+                        categories.funcall("_categories", ()).unwrap();
+                    DataType::from_categories(rb_categories.categories().clone())
                 }
                 "Polars::Enum" => {
-                    let categories = ob.funcall("categories", ()).unwrap();
+                    let categories: Value = ob.funcall("categories", ()).unwrap();
                     let s = get_series(categories)?;
                     let ca = s.str().map_err(RbPolarsErr::from)?;
                     let categories = ca.downcast_iter().next().unwrap().clone();
-                    create_enum_dtype(categories)
+                    assert!(!categories.has_nulls());
+                    DataType::from_frozen_categories(
+                        FrozenCategories::new(categories.values_iter()).unwrap(),
+                    )
                 }
                 "Polars::Date" => DataType::Date,
                 "Polars::Time" => DataType::Time,
@@ -420,7 +435,7 @@ impl TryConvert for Wrap<DataType> {
                     return Err(RbTypeError::new_err(format!(
                         "A {dt} object is not a correct polars DataType. \
                         Hint: use the class without instantiating it.",
-                    )))
+                    )));
                 }
             }
         } else {
@@ -436,7 +451,7 @@ impl TryConvert for Wrap<DataType> {
                 "str" => DataType::String,
                 "bin" => DataType::Binary,
                 "bool" => DataType::Boolean,
-                "cat" => DataType::Categorical(None, Default::default()),
+                "cat" => DataType::from_categories(Categories::global()),
                 "date" => DataType::Date,
                 "datetime" => DataType::Datetime(TimeUnit::Microseconds, None),
                 "f32" => DataType::Float32,
@@ -449,9 +464,8 @@ impl TryConvert for Wrap<DataType> {
                 "unk" => DataType::Unknown(Default::default()),
                 _ => {
                     return Err(RbValueError::new_err(format!(
-                        "{} is not a supported DataType.",
-                        ob
-                    )))
+                        "{ob} is not a supported DataType."
+                    )));
                 }
             }
         };
@@ -475,7 +489,7 @@ impl TryConvert for Wrap<StatisticsOptions> {
                 _ => {
                     return Err(RbTypeError::new_err(format!(
                         "'{key}' is not a valid statistic option",
-                    )))
+                    )));
                 }
             }
             Ok(ForEach::Continue)
@@ -519,7 +533,7 @@ impl TryConvert for Wrap<ScanSources> {
         }
 
         enum MutableSources {
-            Paths(Vec<PathBuf>),
+            Paths(Vec<PlPath>),
             Files(Vec<File>),
             Buffers(Vec<MemSlice>),
         }
@@ -560,7 +574,7 @@ impl TryConvert for Wrap<ScanSources> {
                     return Err(RbTypeError::new_err(
                         "Cannot combine in-memory bytes, paths and files for scan sources"
                             .to_string(),
-                    ))
+                    ));
                 }
             }
         }
@@ -678,7 +692,7 @@ impl TryConvert for Wrap<AsofStrategy> {
             v => {
                 return Err(RbValueError::new_err(format!(
                     "asof `strategy` must be one of {{'backward', 'forward', 'nearest'}}, got {v}",
-                )))
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -693,7 +707,7 @@ impl TryConvert for Wrap<InterpolationMethod> {
             v => {
                 return Err(RbValueError::new_err(format!(
                     "method must be one of {{'linear', 'nearest'}}, got {v}",
-                )))
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -708,9 +722,8 @@ impl TryConvert for Wrap<Option<AvroCompression>> {
             "deflate" => Some(AvroCompression::Deflate),
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "compression must be one of {{'uncompressed', 'snappy', 'deflate'}}, got {}",
-                    v
-                )))
+                    "compression must be one of {{'uncompressed', 'snappy', 'deflate'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -720,13 +733,18 @@ impl TryConvert for Wrap<Option<AvroCompression>> {
 impl TryConvert for Wrap<CategoricalOrdering> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let parsed = match String::try_convert(ob)?.as_str() {
-            "physical" => CategoricalOrdering::Physical,
             "lexical" => CategoricalOrdering::Lexical,
+            "physical" => {
+                polars_warn!(
+                    Deprecation,
+                    "physical ordering is deprecated, will use lexical ordering instead"
+                );
+                CategoricalOrdering::Lexical
+            }
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "ordering must be one of {{'physical', 'lexical'}}, got {}",
-                    v
-                )))
+                    "ordering must be one of {{'physical', 'lexical'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -742,7 +760,7 @@ impl TryConvert for Wrap<StartBy> {
             v => {
                 return Err(RbValueError::new_err(format!(
                     "closed must be one of {{'window', 'datapoint', 'monday'}}, got {v}",
-                )))
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -758,9 +776,8 @@ impl TryConvert for Wrap<ClosedWindow> {
             "none" => ClosedWindow::None,
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "closed must be one of {{'left', 'right', 'both', 'none'}}, got {}",
-                    v
-                )))
+                    "closed must be one of {{'left', 'right', 'both', 'none'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -789,9 +806,8 @@ impl TryConvert for Wrap<CsvEncoding> {
             "utf8-lossy" => CsvEncoding::LossyUtf8,
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "encoding must be one of {{'utf8', 'utf8-lossy'}}, got {}",
-                    v
-                )))
+                    "encoding must be one of {{'utf8', 'utf8-lossy'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -806,9 +822,8 @@ impl TryConvert for Wrap<Option<IpcCompression>> {
             "zstd" => Some(IpcCompression::ZSTD),
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "compression must be one of {{'uncompressed', 'lz4', 'zstd'}}, got {}",
-                    v
-                )))
+                    "compression must be one of {{'uncompressed', 'lz4', 'zstd'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -826,9 +841,8 @@ impl TryConvert for Wrap<JoinType> {
             "cross" => JoinType::Cross,
             v => {
                 return Err(RbValueError::new_err(format!(
-                "how must be one of {{'inner', 'left', 'full', 'semi', 'anti', 'cross'}}, got {}",
-                v
-            )))
+                    "how must be one of {{'inner', 'left', 'full', 'semi', 'anti', 'cross'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -844,7 +858,7 @@ impl TryConvert for Wrap<Label> {
             v => {
                 return Err(RbValueError::new_err(format!(
                     "`label` must be one of {{'left', 'right', 'datapoint'}}, got {v}",
-                )))
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -858,9 +872,8 @@ impl TryConvert for Wrap<ListToStructWidthStrategy> {
             "max_width" => ListToStructWidthStrategy::MaxWidth,
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "n_field_strategy must be one of {{'first_non_null', 'max_width'}}, got {}",
-                    v
-                )))
+                    "n_field_strategy must be one of {{'first_non_null', 'max_width'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -875,7 +888,7 @@ impl TryConvert for Wrap<NonExistent> {
             v => {
                 return Err(RbValueError::new_err(format!(
                     "`non_existent` must be one of {{'null', 'raise'}}, got {v}",
-                )))
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -889,9 +902,8 @@ impl TryConvert for Wrap<NullBehavior> {
             "ignore" => NullBehavior::Ignore,
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "null behavior must be one of {{'drop', 'ignore'}}, got {}",
-                    v
-                )))
+                    "null behavior must be one of {{'drop', 'ignore'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -905,9 +917,8 @@ impl TryConvert for Wrap<NullStrategy> {
             "propagate" => NullStrategy::Propagate,
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "null strategy must be one of {{'ignore', 'propagate'}}, got {}",
-                    v
-                )))
+                    "null strategy must be one of {{'ignore', 'propagate'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -923,9 +934,8 @@ impl TryConvert for Wrap<ParallelStrategy> {
             "none" => ParallelStrategy::None,
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "parallel must be one of {{'auto', 'columns', 'row_groups', 'none'}}, got {}",
-                    v
-                )))
+                    "parallel must be one of {{'auto', 'columns', 'row_groups', 'none'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -942,9 +952,8 @@ impl TryConvert for Wrap<QuantileMethod> {
             "midpoint" => QuantileMethod::Midpoint,
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "interpolation must be one of {{'lower', 'higher', 'nearest', 'linear', 'midpoint'}}, got {}",
-                    v
-                )))
+                    "interpolation must be one of {{'lower', 'higher', 'nearest', 'linear', 'midpoint'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -962,9 +971,8 @@ impl TryConvert for Wrap<RankMethod> {
             "random" => RankMethod::Random,
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "method must be one of {{'min', 'max', 'average', 'dense', 'ordinal', 'random'}}, got {}",
-                    v
-                )))
+                    "method must be one of {{'min', 'max', 'average', 'dense', 'ordinal', 'random'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -979,15 +987,16 @@ impl TryConvert for Wrap<TimeUnit> {
             "ms" => TimeUnit::Milliseconds,
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "time unit must be one of {{'ns', 'us', 'ms'}}, got {}",
-                    v
-                )))
+                    "time unit must be one of {{'ns', 'us', 'ms'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
     }
 }
 
+unsafe impl TryConvertOwned for Wrap<TimeUnit> {}
+
 impl TryConvert for Wrap<UniqueKeepStrategy> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let parsed = match String::try_convert(ob)?.as_str() {
@@ -995,9 +1004,8 @@ impl TryConvert for Wrap<UniqueKeepStrategy> {
             "last" => UniqueKeepStrategy::Last,
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "keep must be one of {{'first', 'last'}}, got {}",
-                    v
-                )))
+                    "keep must be one of {{'first', 'last'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -1011,9 +1019,8 @@ impl TryConvert for Wrap<IpcCompression> {
             "zstd" => IpcCompression::ZSTD,
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "compression must be one of {{'lz4', 'zstd'}}, got {}",
-                    v
-                )))
+                    "compression must be one of {{'lz4', 'zstd'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -1029,7 +1036,7 @@ impl TryConvert for Wrap<SearchSortedSide> {
             v => {
                 return Err(RbValueError::new_err(format!(
                     "side must be one of {{'any', 'left', 'right'}}, got {v}",
-                )))
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -1046,7 +1053,7 @@ impl TryConvert for Wrap<ClosedInterval> {
             v => {
                 return Err(RbValueError::new_err(format!(
                     "`closed` must be one of {{'both', 'left', 'right', 'none'}}, got {v}",
-                )))
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -1061,8 +1068,8 @@ impl TryConvert for Wrap<WindowMapping> {
             "explode" => WindowMapping::Explode,
             v => {
                 return Err(RbValueError::new_err(format!(
-                "`mapping_strategy` must be one of {{'group_to_rows', 'join', 'explode'}}, got {v}",
-            )))
+                    "`mapping_strategy` must be one of {{'group_to_rows', 'join', 'explode'}}, got {v}",
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -1079,7 +1086,7 @@ impl TryConvert for Wrap<JoinValidation> {
             v => {
                 return Err(RbValueError::new_err(format!(
                     "`validate` must be one of {{'m:m', 'm:1', '1:m', '1:1'}}, got {v}",
-                )))
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -1097,8 +1104,8 @@ impl TryConvert for Wrap<MaintainOrderJoin> {
             v => {
                 return Err(RbValueError::new_err(format!(
                     "`maintain_order` must be one of {{'none', 'left', 'right', 'left_right', 'right_left'}}, got {v}",
-                )))
-            },
+                )));
+            }
         };
         Ok(Wrap(parsed))
     }
@@ -1114,8 +1121,8 @@ impl TryConvert for Wrap<QuoteStyle> {
             v => {
                 return Err(RbValueError::new_err(format!(
                     "`quote_style` must be one of {{'always', 'necessary', 'non_numeric', 'never'}}, got {v}",
-                )))
-            },
+                )));
+            }
         };
         Ok(Wrap(parsed))
     }
@@ -1126,6 +1133,33 @@ pub(crate) fn parse_cloud_options(uri: &str, kv: Vec<(String, String)>) -> RbRes
     Ok(out)
 }
 
+impl TryConvert for Wrap<SetOperation> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let parsed = match String::try_convert(ob)?.as_str() {
+            "union" => SetOperation::Union,
+            "difference" => SetOperation::Difference,
+            "intersection" => SetOperation::Intersection,
+            "symmetric_difference" => SetOperation::SymmetricDifference,
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "set operation must be one of {{'union', 'difference', 'intersection', 'symmetric_difference'}}, got {v}",
+                )));
+            }
+        };
+        Ok(Wrap(parsed))
+    }
+}
+
+impl TryConvert for Wrap<CastColumnsPolicy> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        if ob.is_nil() {
+            let out = Wrap(CastColumnsPolicy::ERROR_ON_MISMATCH);
+            return Ok(out);
+        }
+        todo!();
+    }
+}
+
 pub fn parse_fill_null_strategy(
     strategy: &str,
     limit: FillNullLimit,
@@ -1139,10 +1173,12 @@ pub fn parse_fill_null_strategy(
         "zero" => FillNullStrategy::Zero,
         "one" => FillNullStrategy::One,
         e => {
-            return Err(magnus::Error::new(exception::runtime_error(), format!(
-                "strategy must be one of {{'forward', 'backward', 'min', 'max', 'mean', 'zero', 'one'}}, got {}",
-                e,
-            )))
+            return Err(magnus::Error::new(
+                exception::runtime_error(),
+                format!(
+                    "strategy must be one of {{'forward', 'backward', 'min', 'max', 'mean', 'zero', 'one'}}, got {e}",
+                ),
+            ));
         }
     };
     Ok(parsed)
@@ -1159,7 +1195,7 @@ pub fn parse_parquet_compression(
             compression_level
                 .map(|lvl| {
                     GzipLevel::try_new(lvl as u8)
-                        .map_err(|e| RbValueError::new_err(format!("{:?}", e)))
+                        .map_err(|e| RbValueError::new_err(format!("{e:?}")))
                 })
                 .transpose()?,
         ),
@@ -1168,7 +1204,7 @@ pub fn parse_parquet_compression(
             compression_level
                 .map(|lvl| {
                     BrotliLevel::try_new(lvl as u32)
-                        .map_err(|e| RbValueError::new_err(format!("{:?}", e)))
+                        .map_err(|e| RbValueError::new_err(format!("{e:?}")))
                 })
                 .transpose()?,
         ),
@@ -1176,16 +1212,14 @@ pub fn parse_parquet_compression(
         "zstd" => ParquetCompression::Zstd(
             compression_level
                 .map(|lvl| {
-                    ZstdLevel::try_new(lvl)
-                        .map_err(|e| RbValueError::new_err(format!("{:?}", e)))
+                    ZstdLevel::try_new(lvl).map_err(|e| RbValueError::new_err(format!("{e:?}")))
                 })
                 .transpose()?,
         ),
         e => {
             return Err(RbValueError::new_err(format!(
-                "compression must be one of {{'uncompressed', 'snappy', 'gzip', 'lzo', 'brotli', 'lz4', 'zstd'}}, got {}",
-                e
-            )))
+                "compression must be one of {{'uncompressed', 'snappy', 'gzip', 'lzo', 'brotli', 'lz4', 'zstd'}}, got {e}"
+            )));
         }
     };
     Ok(parsed)
@@ -1245,3 +1279,47 @@ impl TryConvert for Wrap<Option<TimeZone>> {
         Ok(Wrap(TimeZone::opt_try_new(tz).map_err(RbPolarsErr::from)?))
     }
 }
+
+unsafe impl TryConvertOwned for Wrap<Option<TimeZone>> {}
+
+impl TryConvert for Wrap<ExtraColumnsPolicy> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let parsed = match String::try_convert(ob)?.as_str() {
+            "ignore" => ExtraColumnsPolicy::Ignore,
+            "raise" => ExtraColumnsPolicy::Raise,
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "extra column/field parameter must be one of {{'ignore', 'raise'}}, got {v}",
+                )));
+            }
+        };
+        Ok(Wrap(parsed))
+    }
+}
+
+impl TryConvert for Wrap<MissingColumnsPolicy> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let parsed = match String::try_convert(ob)?.as_str() {
+            "insert" => MissingColumnsPolicy::Insert,
+            "raise" => MissingColumnsPolicy::Raise,
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "missing column/field parameter must be one of {{'insert', 'raise'}}, got {v}",
+                )));
+            }
+        };
+        Ok(Wrap(parsed))
+    }
+}
+
+impl TryConvert for Wrap<ColumnMapping> {
+    fn try_convert(_ob: Value) -> RbResult<Self> {
+        todo!()
+    }
+}
+
+impl TryConvert for Wrap<DeletionFilesList> {
+    fn try_convert(_ob: Value) -> RbResult<Self> {
+        todo!();
+    }
+}

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

@@ -1,5 +1,5 @@
-use magnus::{prelude::*, r_hash::ForEach, RArray, RHash, Symbol, Value};
-use polars::frame::row::{rows_to_schema_supertypes, rows_to_supertypes, Row};
+use magnus::{RArray, RHash, Symbol, Value, prelude::*, r_hash::ForEach};
+use polars::frame::row::{Row, rows_to_schema_supertypes, rows_to_supertypes};
 use polars::prelude::*;
 
 use super::*;

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

@@ -1,9 +1,9 @@
-use magnus::{prelude::*, IntoValue, RArray, Value};
+use magnus::{IntoValue, RArray, Value, prelude::*};
 
 use super::*;
+use crate::RbResult;
 use crate::conversion::{ObjectValue, Wrap};
 use crate::interop::arrow::to_ruby::dataframe_to_stream;
-use crate::RbResult;
 
 impl RbDataFrame {
     pub fn row_tuple(&self, idx: i64) -> Value {