polars-df 0.6.0 → 0.8.0

data/ext/polars/src/dataframe.rs

@@ -1,4 +1,7 @@
-use magnus::{r_hash::ForEach, IntoValue, RArray, RHash, RString, Value};
+use either::Either;
+use magnus::{
+    prelude::*, r_hash::ForEach, typed_data::Obj, IntoValue, RArray, RHash, RString, Value,
+};
 use polars::frame::row::{rows_to_schema_supertypes, Row};
 use polars::frame::NullStrategy;
 use polars::io::avro::AvroCompression;
@@ -11,12 +14,12 @@ use std::cell::RefCell;
 use std::io::{BufWriter, Cursor};
 use std::ops::Deref;
 
-use crate::apply::dataframe::{
+use crate::conversion::*;
+use crate::file::{get_file_like, get_mmap_bytes_reader};
+use crate::map::dataframe::{
     apply_lambda_unknown, apply_lambda_with_bool_out_type, apply_lambda_with_primitive_out_type,
     apply_lambda_with_utf8_out_type,
 };
-use crate::conversion::*;
-use crate::file::{get_file_like, get_mmap_bytes_reader};
 use crate::rb_modules;
 use crate::series::{to_rbseries_collection, to_series_collection};
 use crate::{RbExpr, RbLazyFrame, RbPolarsErr, RbResult, RbSeries};
@@ -45,7 +48,7 @@ impl RbDataFrame {
         schema_overwrite: Option<Schema>,
     ) -> RbResult<Self> {
         // object builder must be registered.
-        crate::object::register_object_builder();
+        crate::on_startup::register_object_builder();
 
         let schema =
             rows_to_schema_supertypes(&rows, infer_schema_length.map(|n| std::cmp::max(1, n)))
@@ -53,7 +56,7 @@ impl RbDataFrame {
         // replace inferred nulls with boolean
         let fields = schema.iter_fields().map(|mut fld| match fld.data_type() {
             DataType::Null => {
-                fld.coerce(DataType::Boolean);
+                // fld.coerce(DataType::Boolean);
                 fld
             }
             DataType::Decimal(_, _) => {
@@ -86,7 +89,7 @@ impl RbDataFrame {
     pub fn init(columns: RArray) -> RbResult<Self> {
         let mut cols = Vec::new();
         for i in columns.each() {
-            cols.push(i?.try_convert::<&RbSeries>()?.series.borrow().clone());
+            cols.push(<&RbSeries>::try_convert(i?)?.series.borrow().clone());
         }
         let df = DataFrame::new(cols).map_err(RbPolarsErr::from)?;
         Ok(RbDataFrame::new(df))
@@ -99,36 +102,35 @@ impl RbDataFrame {
     pub fn read_csv(arguments: &[Value]) -> RbResult<Self> {
         // start arguments
         // this pattern is needed for more than 16
-        let rb_f: Value = arguments[0].try_convert()?;
-        let infer_schema_length: Option<usize> = arguments[1].try_convert()?;
-        let chunk_size: usize = arguments[2].try_convert()?;
-        let has_header: bool = arguments[3].try_convert()?;
-        let ignore_errors: bool = arguments[4].try_convert()?;
-        let n_rows: Option<usize> = arguments[5].try_convert()?;
-        let skip_rows: usize = arguments[6].try_convert()?;
-        let projection: Option<Vec<usize>> = arguments[7].try_convert()?;
-        let sep: String = arguments[8].try_convert()?;
-        let rechunk: bool = arguments[9].try_convert()?;
-        let columns: Option<Vec<String>> = arguments[10].try_convert()?;
-        let encoding: Wrap<CsvEncoding> = arguments[11].try_convert()?;
-        let n_threads: Option<usize> = arguments[12].try_convert()?;
-        let path: Option<String> = arguments[13].try_convert()?;
-        let overwrite_dtype: Option<Vec<(String, Wrap<DataType>)>> = arguments[14].try_convert()?;
+        let rb_f = arguments[0];
+        let infer_schema_length = Option::<usize>::try_convert(arguments[1])?;
+        let chunk_size = usize::try_convert(arguments[2])?;
+        let has_header = bool::try_convert(arguments[3])?;
+        let ignore_errors = bool::try_convert(arguments[4])?;
+        let n_rows = Option::<usize>::try_convert(arguments[5])?;
+        let skip_rows = usize::try_convert(arguments[6])?;
+        let projection = Option::<Vec<usize>>::try_convert(arguments[7])?;
+        let separator = String::try_convert(arguments[8])?;
+        let rechunk = bool::try_convert(arguments[9])?;
+        let columns = Option::<Vec<String>>::try_convert(arguments[10])?;
+        let encoding = Wrap::<CsvEncoding>::try_convert(arguments[11])?;
+        let n_threads = Option::<usize>::try_convert(arguments[12])?;
+        let path = Option::<String>::try_convert(arguments[13])?;
+        let overwrite_dtype = Option::<Vec<(String, Wrap<DataType>)>>::try_convert(arguments[14])?;
         // TODO fix
-        let overwrite_dtype_slice: Option<Vec<Wrap<DataType>>> = None; // arguments[15].try_convert()?;
-        let low_memory: bool = arguments[16].try_convert()?;
-        let comment_char: Option<String> = arguments[17].try_convert()?;
-        let quote_char: Option<String> = arguments[18].try_convert()?;
-        let null_values: Option<Wrap<NullValues>> = arguments[19].try_convert()?;
-        let try_parse_dates: bool = arguments[20].try_convert()?;
-        let skip_rows_after_header: usize = arguments[21].try_convert()?;
-        let row_count: Option<(String, IdxSize)> = arguments[22].try_convert()?;
-        let sample_size: usize = arguments[23].try_convert()?;
-        let eol_char: String = arguments[24].try_convert()?;
+        let overwrite_dtype_slice = Option::<Vec<Wrap<DataType>>>::None; // Option::<Vec<Wrap<DataType>>>::try_convert(arguments[15])?;
+        let low_memory = bool::try_convert(arguments[16])?;
+        let comment_prefix = Option::<String>::try_convert(arguments[17])?;
+        let quote_char = Option::<String>::try_convert(arguments[18])?;
+        let null_values = Option::<Wrap<NullValues>>::try_convert(arguments[19])?;
+        let try_parse_dates = bool::try_convert(arguments[20])?;
+        let skip_rows_after_header = usize::try_convert(arguments[21])?;
+        let row_count = Option::<(String, IdxSize)>::try_convert(arguments[22])?;
+        let sample_size = usize::try_convert(arguments[23])?;
+        let eol_char = String::try_convert(arguments[24])?;
         // end arguments
 
         let null_values = null_values.map(|w| w.0);
-        let comment_char = comment_char.map(|s| s.as_bytes()[0]);
         let eol_char = eol_char.as_bytes()[0];
 
         let row_count = row_count.map(|(name, offset)| RowCount { name, offset });
@@ -165,7 +167,7 @@ impl RbDataFrame {
             .infer_schema(infer_schema_length)
             .has_header(has_header)
             .with_n_rows(n_rows)
-            .with_delimiter(sep.as_bytes()[0])
+            .with_separator(separator.as_bytes()[0])
             .with_skip_rows(skip_rows)
             .with_ignore_errors(ignore_errors)
             .with_projection(projection)
@@ -178,7 +180,7 @@ impl RbDataFrame {
             .with_dtypes(overwrite_dtype.map(Arc::new))
             .with_dtypes_slice(overwrite_dtype_slice.as_deref())
             .low_memory(low_memory)
-            .with_comment_char(comment_char)
+            .with_comment_prefix(comment_prefix.as_deref())
             .with_null_values(null_values)
             .with_try_parse_dates(try_parse_dates)
             .with_quote_char(quote_char)
@@ -265,7 +267,7 @@ impl RbDataFrame {
     ) -> RbResult<()> {
         use polars::io::avro::AvroWriter;
 
-        if let Ok(s) = rb_f.try_convert::<String>() {
+        if let Ok(s) = String::try_convert(rb_f) {
             let f = std::fs::File::create(s).unwrap();
             AvroWriter::new(f)
                 .with_compression(compression.0)
@@ -294,12 +296,18 @@ impl RbDataFrame {
             Ok(df) => Ok(df.into()),
             // try arrow json reader instead
             // this is row oriented
-            Err(_) => {
-                let out = JsonReader::new(mmap_bytes_r)
-                    .with_json_format(JsonFormat::Json)
-                    .finish()
-                    .map_err(|e| RbPolarsErr::other(format!("{:?}", e)))?;
-                Ok(out.into())
+            Err(e) => {
+                let msg = format!("{e}");
+                if msg.contains("successful parse invalid data") {
+                    let e = RbPolarsErr::from(PolarsError::ComputeError(msg.into()));
+                    Err(e)
+                } else {
+                    let out = JsonReader::new(mmap_bytes_r)
+                        .with_json_format(JsonFormat::Json)
+                        .finish()
+                        .map_err(|e| RbPolarsErr::other(format!("{:?}", e)))?;
+                    Ok(out.into())
+                }
             }
         }
     }
@@ -341,6 +349,27 @@ impl RbDataFrame {
         Ok(())
     }
 
+    pub fn read_rows(
+        rb_rows: RArray,
+        infer_schema_length: Option<usize>,
+        schema_overwrite: Option<Wrap<Schema>>,
+    ) -> RbResult<Self> {
+        let mut rows = Vec::with_capacity(rb_rows.len());
+        for v in rb_rows.each() {
+            let rb_row = RArray::try_convert(v?)?;
+            let mut row = Vec::with_capacity(rb_row.len());
+            for val in rb_row.each() {
+                row.push(Wrap::<AnyValue>::try_convert(val?)?.0);
+            }
+            rows.push(Row(row));
+        }
+        Self::finish_from_rows(
+            rows,
+            infer_schema_length,
+            schema_overwrite.map(|wrap| wrap.0),
+        )
+    }
+
     pub fn read_hashes(
         dicts: Value,
         infer_schema_length: Option<usize>,
@@ -395,9 +424,9 @@ impl RbDataFrame {
     pub fn write_csv(
         &self,
         rb_f: Value,
-        has_header: bool,
-        sep: u8,
-        quote: u8,
+        include_header: bool,
+        separator: u8,
+        quote_char: u8,
         batch_size: usize,
         datetime_format: Option<String>,
         date_format: Option<String>,
@@ -407,13 +436,13 @@ impl RbDataFrame {
     ) -> RbResult<()> {
         let null = null_value.unwrap_or_default();
 
-        if let Ok(s) = rb_f.try_convert::<String>() {
+        if let Ok(s) = String::try_convert(rb_f) {
             let f = std::fs::File::create(s).unwrap();
             // no need for a buffered writer, because the csv writer does internal buffering
             CsvWriter::new(f)
-                .has_header(has_header)
-                .with_delimiter(sep)
-                .with_quoting_char(quote)
+                .include_header(include_header)
+                .with_separator(separator)
+                .with_quote_char(quote_char)
                 .with_batch_size(batch_size)
                 .with_datetime_format(datetime_format)
                 .with_date_format(date_format)
@@ -425,9 +454,9 @@ impl RbDataFrame {
         } else {
             let mut buf = Cursor::new(Vec::new());
             CsvWriter::new(&mut buf)
-                .has_header(has_header)
-                .with_delimiter(sep)
-                .with_quoting_char(quote)
+                .include_header(include_header)
+                .with_separator(separator)
+                .with_quote_char(quote_char)
                 .with_batch_size(batch_size)
                 .with_datetime_format(datetime_format)
                 .with_date_format(date_format)
@@ -449,7 +478,7 @@ impl RbDataFrame {
         rb_f: Value,
         compression: Wrap<Option<IpcCompression>>,
     ) -> RbResult<()> {
-        if let Ok(s) = rb_f.try_convert::<String>() {
+        if let Ok(s) = String::try_convert(rb_f) {
             let f = std::fs::File::create(s).unwrap();
             IpcWriter::new(f)
                 .with_compression(compression.0)
@@ -480,14 +509,14 @@ impl RbDataFrame {
                 .get_columns()
                 .iter()
                 .map(|s| match s.dtype() {
-                    DataType::Object(_) => {
+                    DataType::Object(_, _) => {
                         let obj: Option<&ObjectValue> = s.get_object(idx).map(|any| any.into());
                         obj.unwrap().to_object()
                     }
                     _ => Wrap(s.get(idx).unwrap()).into_value(),
                 }),
         )
-        .into()
+        .as_value()
     }
 
     pub fn row_tuples(&self) -> Value {
@@ -499,7 +528,7 @@ impl RbDataFrame {
                     .get_columns()
                     .iter()
                     .map(|s| match s.dtype() {
-                        DataType::Object(_) => {
+                        DataType::Object(_, _) => {
                             let obj: Option<&ObjectValue> = s.get_object(idx).map(|any| any.into());
                             obj.unwrap().to_object()
                         }
@@ -507,7 +536,7 @@ impl RbDataFrame {
                     }),
             )
         }))
-        .into()
+        .as_value()
     }
 
     pub fn to_numo(&self) -> Option<Value> {
@@ -537,7 +566,7 @@ impl RbDataFrame {
     ) -> RbResult<()> {
         let compression = parse_parquet_compression(&compression, compression_level)?;
 
-        if let Ok(s) = rb_f.try_convert::<String>() {
+        if let Ok(s) = String::try_convert(rb_f) {
             let f = std::fs::File::create(s).unwrap();
             ParquetWriter::new(f)
                 .with_compression(compression)
@@ -604,7 +633,7 @@ impl RbDataFrame {
 
     pub fn sample_n(
         &self,
-        n: usize,
+        n: &RbSeries,
         with_replacement: bool,
         shuffle: bool,
         seed: Option<u64>,
@@ -612,14 +641,14 @@ impl RbDataFrame {
         let df = self
             .df
             .borrow()
-            .sample_n(n, with_replacement, shuffle, seed)
+            .sample_n(&n.series.borrow(), with_replacement, shuffle, seed)
             .map_err(RbPolarsErr::from)?;
         Ok(df.into())
     }
 
     pub fn sample_frac(
         &self,
-        frac: f64,
+        frac: &RbSeries,
         with_replacement: bool,
         shuffle: bool,
         seed: Option<u64>,
@@ -627,7 +656,7 @@ impl RbDataFrame {
         let df = self
             .df
             .borrow()
-            .sample_frac(frac, with_replacement, shuffle, seed)
+            .sample_frac(&frac.series.borrow(), with_replacement, shuffle, seed)
             .map_err(RbPolarsErr::from)?;
         Ok(df.into())
     }
@@ -761,8 +790,8 @@ impl RbDataFrame {
             .map(|s| RbSeries::new(s.clone()))
     }
 
-    pub fn find_idx_by_name(&self, name: String) -> Option<usize> {
-        self.df.borrow().find_idx_by_name(&name)
+    pub fn get_column_index(&self, name: String) -> Option<usize> {
+        self.df.borrow().get_column_index(&name)
     }
 
     // TODO remove clone
@@ -804,18 +833,18 @@ impl RbDataFrame {
         Ok(())
     }
 
-    pub fn replace_at_idx(&self, index: usize, new_col: &RbSeries) -> RbResult<()> {
+    pub fn replace_column(&self, index: usize, new_col: &RbSeries) -> RbResult<()> {
         self.df
             .borrow_mut()
-            .replace_at_idx(index, new_col.series.borrow().clone())
+            .replace_column(index, new_col.series.borrow().clone())
             .map_err(RbPolarsErr::from)?;
         Ok(())
     }
 
-    pub fn insert_at_idx(&self, index: usize, new_col: &RbSeries) -> RbResult<()> {
+    pub fn insert_column(&self, index: usize, new_col: &RbSeries) -> RbResult<()> {
         self.df
             .borrow_mut()
-            .insert_at_idx(index, new_col.series.borrow().clone())
+            .insert_column(index, new_col.series.borrow().clone())
             .map_err(RbPolarsErr::from)?;
         Ok(())
     }
@@ -850,11 +879,11 @@ impl RbDataFrame {
         Ok(mask.into_series().into())
     }
 
-    pub fn frame_equal(&self, other: &RbDataFrame, null_equal: bool) -> bool {
+    pub fn equals(&self, other: &RbDataFrame, null_equal: bool) -> bool {
         if null_equal {
-            self.df.borrow().frame_equal_missing(&other.df.borrow())
+            self.df.borrow().equals_missing(&other.df.borrow())
         } else {
-            self.df.borrow().frame_equal(&other.df.borrow())
+            self.df.borrow().equals(&other.df.borrow())
         }
     }
 
@@ -942,73 +971,50 @@ impl RbDataFrame {
         self.df.borrow().clone().lazy().into()
     }
 
-    pub fn max(&self) -> Self {
-        self.df.borrow().max().into()
-    }
-
-    pub fn min(&self) -> Self {
-        self.df.borrow().min().into()
-    }
-
-    pub fn sum(&self) -> Self {
-        self.df.borrow().sum().into()
-    }
-
-    pub fn mean(&self) -> Self {
-        self.df.borrow().mean().into()
-    }
-
-    pub fn std(&self, ddof: u8) -> Self {
-        self.df.borrow().std(ddof).into()
-    }
-
-    pub fn var(&self, ddof: u8) -> Self {
-        self.df.borrow().var(ddof).into()
-    }
-
-    pub fn median(&self) -> Self {
-        self.df.borrow().median().into()
-    }
-
-    pub fn hmean(&self, null_strategy: Wrap<NullStrategy>) -> RbResult<Option<RbSeries>> {
+    pub fn max_horizontal(&self) -> RbResult<Option<RbSeries>> {
         let s = self
             .df
             .borrow()
-            .hmean(null_strategy.0)
+            .max_horizontal()
             .map_err(RbPolarsErr::from)?;
         Ok(s.map(|s| s.into()))
     }
 
-    pub fn hmax(&self) -> RbResult<Option<RbSeries>> {
-        let s = self.df.borrow().hmax().map_err(RbPolarsErr::from)?;
-        Ok(s.map(|s| s.into()))
-    }
-
-    pub fn hmin(&self) -> RbResult<Option<RbSeries>> {
-        let s = self.df.borrow().hmin().map_err(RbPolarsErr::from)?;
+    pub fn min_horizontal(&self) -> RbResult<Option<RbSeries>> {
+        let s = self
+            .df
+            .borrow()
+            .min_horizontal()
+            .map_err(RbPolarsErr::from)?;
         Ok(s.map(|s| s.into()))
     }
 
-    pub fn hsum(&self, null_strategy: Wrap<NullStrategy>) -> RbResult<Option<RbSeries>> {
+    pub fn sum_horizontal(&self, ignore_nulls: bool) -> RbResult<Option<RbSeries>> {
+        let null_strategy = if ignore_nulls {
+            NullStrategy::Ignore
+        } else {
+            NullStrategy::Propagate
+        };
         let s = self
             .df
             .borrow()
-            .hsum(null_strategy.0)
+            .sum_horizontal(null_strategy)
             .map_err(RbPolarsErr::from)?;
         Ok(s.map(|s| s.into()))
     }
 
-    pub fn quantile(
-        &self,
-        quantile: f64,
-        interpolation: Wrap<QuantileInterpolOptions>,
-    ) -> RbResult<Self> {
-        let df = self
+    pub fn mean_horizontal(&self, ignore_nulls: bool) -> RbResult<Option<RbSeries>> {
+        let null_strategy = if ignore_nulls {
+            NullStrategy::Ignore
+        } else {
+            NullStrategy::Propagate
+        };
+        let s = self
             .df
             .borrow()
-            .quantile(quantile, interpolation.0)
+            .mean_horizontal(null_strategy)
             .map_err(RbPolarsErr::from)?;
-        Ok(df.into())
+        Ok(s.map(|s| s.into()))
     }
 
     pub fn to_dummies(
@@ -1082,13 +1088,13 @@ impl RbDataFrame {
                     .into_datetime(tu, tz)
                     .into_series()
             }
-            Some(DataType::Utf8) => {
+            Some(DataType::String) => {
                 apply_lambda_with_utf8_out_type(df, lambda, 0, None).into_series()
             }
             _ => return apply_lambda_unknown(df, lambda, inference_size),
         };
 
-        Ok((RbSeries::from(out).into(), false))
+        Ok((Obj::wrap(RbSeries::from(out)).as_value(), false))
     }
 
     pub fn shrink_to_fit(&self) {
@@ -1105,17 +1111,20 @@ impl RbDataFrame {
         Ok(hash.into_series().into())
     }
 
-    pub fn transpose(&self, include_header: bool, names: String) -> RbResult<Self> {
-        let mut df = self.df.borrow().transpose().map_err(RbPolarsErr::from)?;
-        if include_header {
-            let s = Utf8Chunked::from_iter_values(
-                &names,
-                self.df.borrow().get_columns().iter().map(|s| s.name()),
-            )
-            .into_series();
-            df.insert_at_idx(0, s).unwrap();
-        }
-        Ok(df.into())
+    pub fn transpose(&self, keep_names_as: Option<String>, column_names: Value) -> RbResult<Self> {
+        let new_col_names = if let Ok(name) = <Vec<String>>::try_convert(column_names) {
+            Some(Either::Right(name))
+        } else if let Ok(name) = String::try_convert(column_names) {
+            Some(Either::Left(name))
+        } else {
+            None
+        };
+        Ok(self
+            .df
+            .borrow()
+            .transpose(keep_names_as.as_deref(), new_col_names)
+            .map_err(RbPolarsErr::from)?
+            .into())
     }
 
     pub fn upsample(

data/ext/polars/src/error.rs

@@ -1,6 +1,5 @@
 use magnus::exception;
 use magnus::Error;
-use polars::error::ArrowError;
 use polars::prelude::PolarsError;
 
 pub struct RbPolarsErr {}
@@ -11,10 +10,6 @@ impl RbPolarsErr {
         Error::new(exception::runtime_error(), e.to_string())
     }
 
-    pub fn arrow(e: ArrowError) -> Error {
-        Error::new(exception::runtime_error(), e.to_string())
-    }
-
     pub fn io(e: std::io::Error) -> Error {
         Error::new(exception::runtime_error(), e.to_string())
     }

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

@@ -3,16 +3,28 @@ use polars::prelude::*;
 use crate::RbExpr;
 
 impl RbExpr {
-    pub fn bin_contains(&self, lit: Vec<u8>) -> Self {
-        self.inner.clone().binary().contains_literal(lit).into()
+    pub fn bin_contains(&self, lit: &RbExpr) -> Self {
+        self.inner
+            .clone()
+            .binary()
+            .contains_literal(lit.inner.clone())
+            .into()
     }
 
-    pub fn bin_ends_with(&self, sub: Vec<u8>) -> Self {
-        self.inner.clone().binary().ends_with(sub).into()
+    pub fn bin_ends_with(&self, sub: &RbExpr) -> Self {
+        self.inner
+            .clone()
+            .binary()
+            .ends_with(sub.inner.clone())
+            .into()
     }
 
-    pub fn bin_starts_with(&self, sub: Vec<u8>) -> Self {
-        self.inner.clone().binary().starts_with(sub).into()
+    pub fn bin_starts_with(&self, sub: &RbExpr) -> Self {
+        self.inner
+            .clone()
+            .binary()
+            .starts_with(sub.inner.clone())
+            .into()
     }
 
     pub fn bin_hex_decode(&self, strict: bool) -> Self {

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

@@ -5,6 +5,13 @@ use crate::RbExpr;
 
 impl RbExpr {
     pub fn cat_set_ordering(&self, ordering: Wrap<CategoricalOrdering>) -> Self {
-        self.inner.clone().cat().set_ordering(ordering.0).into()
+        self.inner
+            .clone()
+            .cast(DataType::Categorical(None, ordering.0))
+            .into()
+    }
+
+    pub fn cat_get_categories(&self) -> Self {
+        self.inner.clone().cat().get_categories().into()
     }
 }

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

@@ -8,9 +8,8 @@ impl RbExpr {
         self.inner.clone().dt().to_string(&format).into()
     }
 
-    pub fn dt_offset_by(&self, by: String) -> Self {
-        let by = Duration::parse(&by);
-        self.inner.clone().dt().offset_by(by).into()
+    pub fn dt_offset_by(&self, by: &RbExpr) -> Self {
+        self.inner.clone().dt().offset_by(by.inner.clone()).into()
     }
 
     pub fn dt_epoch_seconds(&self) -> Self {
@@ -38,21 +37,20 @@ impl RbExpr {
         self.inner.clone().dt().cast_time_unit(tu.0).into()
     }
 
-    pub fn dt_replace_time_zone(&self, tz: Option<String>, use_earliest: Option<bool>) -> Self {
+    pub fn dt_replace_time_zone(&self, time_zone: Option<String>, ambiguous: &Self) -> Self {
         self.inner
             .clone()
             .dt()
-            .replace_time_zone(tz, use_earliest)
+            .replace_time_zone(time_zone, ambiguous.inner.clone())
             .into()
     }
 
-    #[allow(deprecated)]
-    pub fn dt_tz_localize(&self, tz: String) -> Self {
-        self.inner.clone().dt().tz_localize(tz).into()
-    }
-
-    pub fn dt_truncate(&self, every: String, offset: String) -> Self {
-        self.inner.clone().dt().truncate(&every, &offset).into()
+    pub fn dt_truncate(&self, every: &Self, offset: String) -> Self {
+        self.inner
+            .clone()
+            .dt()
+            .truncate(every.inner.clone(), offset)
+            .into()
     }
 
     pub fn dt_month_start(&self) -> Self {