polars-df 0.17.1 → 0.19.0

data/ext/polars/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "polars"
-version = "0.17.1"
+version = "0.19.0"
 license = "MIT"
 authors = ["Andrew Kane <andrew@ankane.org>"]
 edition = "2021"
-rust-version = "1.80.0"
+rust-version = "1.85.0"
 publish = false
 
 [lib]
@@ -12,22 +12,22 @@ crate-type = ["cdylib"]
 
 [dependencies]
 ahash = "0.8"
-arrow = { package = "polars-arrow", version = "=0.46.0" }
+arrow = { package = "polars-arrow", version = "=0.48.0" }
 bytes = "1"
 chrono = "0.4"
 either = "1.8"
 magnus = "0.7"
 num-traits = "0.2"
-polars-core = "=0.46.0"
-polars-plan = "=0.46.0"
-polars-parquet = "=0.46.0"
-polars-utils = "=0.46.0"
+polars-core = "=0.48.0"
+polars-plan = "=0.48.0"
+polars-parquet = "=0.48.0"
+polars-utils = "=0.48.0"
 rayon = "1.9"
 regex = "1"
 serde_json = "1"
 
 [dependencies.polars]
-version = "=0.46.0"
+version = "=0.48.0"
 features = [
     "abs",
     "approx_unique",

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

@@ -173,7 +173,7 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
     }
 
     fn get_struct(ob: Value, _strict: bool) -> RbResult<AnyValue<'static>> {
-        let dict = RHash::from_value(ob).unwrap();
+        let dict = RHash::try_convert(ob)?;
         let len = dict.len();
         let mut keys = Vec::with_capacity(len);
         let mut vals = Vec::with_capacity(len);

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

@@ -21,7 +21,7 @@ use polars::prelude::*;
 use polars::series::ops::NullBehavior;
 use polars_core::utils::arrow::array::Array;
 use polars_core::utils::materialize_dyn_int;
-use polars_plan::plans::ScanSources;
+use polars_plan::dsl::ScanSources;
 use polars_utils::mmap::MemSlice;
 use polars_utils::total_ord::{TotalEq, TotalHash};
 
@@ -210,7 +210,10 @@ impl IntoValue for Wrap<DataType> {
             DataType::Datetime(tu, tz) => {
                 let datetime_class = pl.const_get::<_, Value>("Datetime").unwrap();
                 datetime_class
-                    .funcall::<_, _, Value>("new", (tu.to_ascii(), tz.as_deref()))
+                    .funcall::<_, _, Value>(
+                        "new",
+                        (tu.to_ascii(), tz.as_deref().map(|x| x.as_str())),
+                    )
                     .unwrap()
             }
             DataType::Duration(tu) => {
@@ -219,7 +222,7 @@ impl IntoValue for Wrap<DataType> {
                     .funcall::<_, _, Value>("new", (tu.to_ascii(),))
                     .unwrap()
             }
-            DataType::Object(_, _) => {
+            DataType::Object(_) => {
                 let class = pl.const_get::<_, Value>("Object").unwrap();
                 class.funcall("new", ()).unwrap()
             }
@@ -332,7 +335,7 @@ impl TryConvert for Wrap<DataType> {
                 "Polars::Array" => DataType::Array(Box::new(DataType::Null), 0),
                 "Polars::Struct" => DataType::Struct(vec![]),
                 "Polars::Null" => DataType::Null,
-                "Polars::Object" => DataType::Object(OBJECT_NAME, None),
+                "Polars::Object" => DataType::Object(OBJECT_NAME),
                 "Polars::Unknown" => DataType::Unknown(Default::default()),
                 dt => {
                     return Err(RbValueError::new_err(format!(
@@ -375,7 +378,10 @@ impl TryConvert for Wrap<DataType> {
                     let time_unit: Value = ob.funcall("time_unit", ()).unwrap();
                     let time_unit = Wrap::<TimeUnit>::try_convert(time_unit)?.0;
                     let time_zone: Option<String> = ob.funcall("time_zone", ())?;
-                    DataType::Datetime(time_unit, time_zone.as_deref().map(|x| x.into()))
+                    DataType::Datetime(
+                        time_unit,
+                        TimeZone::opt_try_new(time_zone.as_deref()).map_err(RbPolarsErr::from)?,
+                    )
                 }
                 "Polars::Duration" => {
                     let time_unit: Value = ob.funcall("time_unit", ()).unwrap();
@@ -408,7 +414,7 @@ impl TryConvert for Wrap<DataType> {
                     DataType::Struct(fields)
                 }
                 "Polars::Null" => DataType::Null,
-                "Object" => DataType::Object(OBJECT_NAME, None),
+                "Object" => DataType::Object(OBJECT_NAME),
                 "Polars::Unknown" => DataType::Unknown(Default::default()),
                 dt => {
                     return Err(RbTypeError::new_err(format!(
@@ -437,7 +443,7 @@ impl TryConvert for Wrap<DataType> {
                 "time" => DataType::Time,
                 "dur" => DataType::Duration(TimeUnit::Microseconds),
                 "f64" => DataType::Float64,
-                "obj" => DataType::Object(OBJECT_NAME, None),
+                "obj" => DataType::Object(OBJECT_NAME),
                 "list" => DataType::List(Box::new(DataType::Boolean)),
                 "null" => DataType::Null,
                 "unk" => DataType::Unknown(Default::default()),
@@ -761,6 +767,21 @@ impl TryConvert for Wrap<ClosedWindow> {
     }
 }
 
+impl TryConvert for Wrap<RoundMode> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let parsed = match String::try_convert(ob)?.as_str() {
+            "half_to_even" => RoundMode::HalfToEven,
+            "half_away_from_zero" => RoundMode::HalfAwayFromZero,
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "`mode` must be one of {{'half_to_even', 'half_away_from_zero'}}, got {v}",
+                )));
+            }
+        };
+        Ok(Wrap(parsed))
+    }
+}
+
 impl TryConvert for Wrap<CsvEncoding> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let parsed = match String::try_convert(ob)?.as_str() {
@@ -1214,3 +1235,13 @@ impl TryConvert for RbCompatLevel {
         }))
     }
 }
+
+impl TryConvert for Wrap<Option<TimeZone>> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let tz = Option::<Wrap<PlSmallStr>>::try_convert(ob)?;
+
+        let tz = tz.map(|x| x.0);
+
+        Ok(Wrap(TimeZone::opt_try_new(tz).map_err(RbPolarsErr::from)?))
+    }
+}

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

@@ -18,7 +18,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_value()
                     }
@@ -37,7 +37,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_value()
                         }

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

@@ -1,3 +1,5 @@
+use std::hash::BuildHasher;
+
 use either::Either;
 use magnus::{prelude::*, typed_data::Obj, IntoValue, RArray, Value};
 use polars::prelude::pivot::{pivot, pivot_stable};
@@ -494,7 +496,8 @@ impl RbDataFrame {
     }
 
     pub fn hash_rows(&self, k0: u64, k1: u64, k2: u64, k3: u64) -> RbResult<RbSeries> {
-        let hb = ahash::RandomState::with_seeds(k0, k1, k2, k3);
+        let seed = PlFixedStateQuality::default().hash_one((k0, k1, k2, k3));
+        let hb = PlSeedableRandomStateQuality::seed_from_u64(seed);
         let hash = self
             .df
             .borrow_mut()

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

@@ -75,11 +75,11 @@ impl RbExpr {
             .into()
     }
 
-    pub fn arr_contains(&self, other: &RbExpr) -> Self {
+    pub fn arr_contains(&self, other: &RbExpr, nulls_equal: bool) -> Self {
         self.inner
             .clone()
             .arr()
-            .contains(other.inner.clone())
+            .contains(other.inner.clone(), nulls_equal)
             .into()
     }
 

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

@@ -1,7 +1,7 @@
 use polars::prelude::*;
 
 use crate::conversion::Wrap;
-use crate::RbExpr;
+use crate::{RbExpr, RbPolarsErr, RbResult};
 
 impl RbExpr {
     pub fn dt_to_string(&self, format: String) -> Self {
@@ -30,12 +30,17 @@ impl RbExpr {
         self.inner.clone().dt().with_time_unit(tu.0).into()
     }
 
-    pub fn dt_convert_time_zone(&self, time_zone: String) -> Self {
-        self.inner
+    pub fn dt_convert_time_zone(&self, time_zone: String) -> RbResult<Self> {
+        Ok(self
+            .inner
             .clone()
             .dt()
-            .convert_time_zone(time_zone.into())
-            .into()
+            .convert_time_zone(
+                TimeZone::opt_try_new(Some(PlSmallStr::from(time_zone)))
+                    .map_err(RbPolarsErr::from)?
+                    .unwrap_or(TimeZone::UTC),
+            )
+            .into())
     }
 
     pub fn dt_cast_time_unit(&self, tu: Wrap<TimeUnit>) -> Self {
@@ -47,16 +52,18 @@ impl RbExpr {
         time_zone: Option<String>,
         ambiguous: &Self,
         non_existent: Wrap<NonExistent>,
-    ) -> Self {
-        self.inner
+    ) -> RbResult<Self> {
+        Ok(self
+            .inner
             .clone()
             .dt()
             .replace_time_zone(
-                time_zone.map(|x| x.into()),
+                TimeZone::opt_try_new(time_zone.map(PlSmallStr::from_string))
+                    .map_err(RbPolarsErr::from)?,
                 ambiguous.inner.clone(),
                 non_existent.0,
             )
-            .into()
+            .into())
     }
 
     pub fn dt_truncate(&self, every: &Self) -> Self {

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

@@ -371,14 +371,6 @@ impl RbExpr {
             .into())
     }
 
-    pub fn backward_fill(&self, limit: FillNullLimit) -> Self {
-        self.inner.clone().backward_fill(limit).into()
-    }
-
-    pub fn forward_fill(&self, limit: FillNullLimit) -> Self {
-        self.inner.clone().forward_fill(limit).into()
-    }
-
     pub fn shift(&self, n: &Self, fill_value: Option<&Self>) -> Self {
         let expr = self.inner.clone();
         let out = match fill_value {
@@ -497,8 +489,8 @@ impl RbExpr {
             .into()
     }
 
-    pub fn round(&self, decimals: u32) -> Self {
-        self.inner.clone().round(decimals).into()
+    pub fn round(&self, decimals: u32, mode: Wrap<RoundMode>) -> Self {
+        self.inner.clone().round(decimals, mode.0).into()
     }
 
     pub fn floor(&self) -> Self {
@@ -597,8 +589,11 @@ impl RbExpr {
         self.inner.clone().or(expr.inner.clone()).into()
     }
 
-    pub fn is_in(&self, expr: &Self) -> Self {
-        self.inner.clone().is_in(expr.inner.clone()).into()
+    pub fn is_in(&self, expr: &Self, nulls_equal: bool) -> Self {
+        self.inner
+            .clone()
+            .is_in(expr.inner.clone(), nulls_equal)
+            .into()
     }
 
     pub fn repeat_by(&self, by: &Self) -> Self {
@@ -698,8 +693,11 @@ impl RbExpr {
         self.inner.clone().rank(options, seed).into()
     }
 
-    pub fn diff(&self, n: i64, null_behavior: Wrap<NullBehavior>) -> Self {
-        self.inner.clone().diff(n, null_behavior.0).into()
+    pub fn diff(&self, n: &Self, null_behavior: Wrap<NullBehavior>) -> Self {
+        self.inner
+            .clone()
+            .diff(n.inner.clone(), null_behavior.0)
+            .into()
     }
 
     pub fn pct_change(&self, n: &Self) -> Self {

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

@@ -23,11 +23,11 @@ impl RbExpr {
         self.inner.clone().list().arg_min().into()
     }
 
-    pub fn list_contains(&self, other: &RbExpr) -> Self {
+    pub fn list_contains(&self, other: &RbExpr, nulls_equal: bool) -> Self {
         self.inner
             .clone()
             .list()
-            .contains(other.inner.clone())
+            .contains(other.inner.clone(), nulls_equal)
             .into()
     }
 
@@ -180,7 +180,7 @@ impl RbExpr {
         &self,
         width_strat: Wrap<ListToStructWidthStrategy>,
         name_gen: Option<Value>,
-        upper_bound: usize,
+        upper_bound: Option<usize>,
     ) -> RbResult<Self> {
         let name_gen = name_gen.map(|lambda| {
             let lambda = Opaque::from(lambda);

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

@@ -319,7 +319,22 @@ impl RbExpr {
             .into()
     }
 
-    pub fn rolling_skew(&self, window_size: usize, bias: bool) -> Self {
-        self.inner.clone().rolling_skew(window_size, bias).into()
+    pub fn rolling_skew(
+        &self,
+        window_size: usize,
+        bias: bool,
+        min_periods: Option<usize>,
+        center: bool,
+    ) -> Self {
+        let min_periods = min_periods.unwrap_or(window_size);
+        let options = RollingOptionsFixedWindow {
+            window_size,
+            weights: None,
+            min_periods,
+            center,
+            fn_params: Some(RollingFnParams::Skew { bias }),
+        };
+
+        self.inner.clone().rolling_skew(options).into()
     }
 }

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

@@ -35,14 +35,14 @@ impl RbExpr {
         &self,
         format: Option<String>,
         time_unit: Option<Wrap<TimeUnit>>,
-        time_zone: Option<Wrap<TimeZone>>,
+        time_zone: Wrap<Option<TimeZone>>,
         strict: bool,
         exact: bool,
         cache: bool,
         ambiguous: &Self,
     ) -> Self {
         let format = format.map(|x| x.into());
-        let time_zone = time_zone.map(|x| x.0);
+        let time_zone = time_zone.0;
 
         let options = StrptimeOptions {
             format,

data/ext/polars/src/file.rs

@@ -3,9 +3,12 @@ use std::io;
 use std::io::{Cursor, Read, Seek, SeekFrom, Write};
 use std::path::PathBuf;
 
-use magnus::{exception, prelude::*, Error, RString, Value};
+use magnus::{exception, prelude::*, value::Opaque, Error, RString, Ruby, Value};
 use polars::io::cloud::CloudOptions;
 use polars::io::mmap::MmapBytesReader;
+use polars::prelude::file::DynWriteable;
+use polars::prelude::sync_on_close::SyncOnCloseType;
+use polars_utils::file::ClosableFile;
 use polars_utils::mmap::MemSlice;
 
 use crate::error::RbPolarsErr;
@@ -14,7 +17,22 @@ use crate::RbResult;
 
 #[derive(Clone)]
 pub struct RbFileLikeObject {
-    inner: Value,
+    inner: Opaque<Value>,
+}
+
+impl DynWriteable for RbFileLikeObject {
+    fn as_dyn_write(&self) -> &(dyn io::Write + Send + 'static) {
+        self as _
+    }
+    fn as_mut_dyn_write(&mut self) -> &mut (dyn io::Write + Send + 'static) {
+        self as _
+    }
+    fn close(self: Box<Self>) -> io::Result<()> {
+        Ok(())
+    }
+    fn sync_on_close(&mut self, _sync_on_close: SyncOnCloseType) -> io::Result<()> {
+        Ok(())
+    }
 }
 
 /// Wraps a `Value`, and implements read, seek, and write for it.
@@ -23,7 +41,9 @@ impl RbFileLikeObject {
     /// To assert the object has the required methods methods,
     /// instantiate it with `RbFileLikeObject::require`
     pub fn new(object: Value) -> Self {
-        RbFileLikeObject { inner: object }
+        RbFileLikeObject {
+            inner: object.into(),
+        }
     }
 
     pub fn as_bytes(&self) -> bytes::Bytes {
@@ -31,8 +51,9 @@ impl RbFileLikeObject {
     }
 
     pub fn as_file_buffer(&self) -> Cursor<Vec<u8>> {
-        let bytes = self
-            .inner
+        let bytes = Ruby::get()
+            .unwrap()
+            .get_inner(self.inner)
             .funcall::<_, _, RString>("read", ())
             .expect("no read method found");
 
@@ -77,8 +98,9 @@ fn rberr_to_io_err(e: Error) -> io::Error {
 
 impl Read for RbFileLikeObject {
     fn read(&mut self, mut buf: &mut [u8]) -> Result<usize, io::Error> {
-        let bytes = self
-            .inner
+        let bytes = Ruby::get()
+            .unwrap()
+            .get_inner(self.inner)
             .funcall::<_, _, RString>("read", (buf.len(),))
             .map_err(rberr_to_io_err)?;
 
@@ -92,8 +114,9 @@ impl Write for RbFileLikeObject {
     fn write(&mut self, buf: &[u8]) -> Result<usize, io::Error> {
         let rbbytes = RString::from_slice(buf);
 
-        let number_bytes_written = self
-            .inner
+        let number_bytes_written = Ruby::get()
+            .unwrap()
+            .get_inner(self.inner)
             .funcall::<_, _, usize>("write", (rbbytes,))
             .map_err(rberr_to_io_err)?;
 
@@ -101,7 +124,9 @@ impl Write for RbFileLikeObject {
     }
 
     fn flush(&mut self) -> Result<(), io::Error> {
-        self.inner
+        Ruby::get()
+            .unwrap()
+            .get_inner(self.inner)
             .funcall::<_, _, Value>("flush", ())
             .map_err(rberr_to_io_err)?;
 
@@ -117,8 +142,9 @@ impl Seek for RbFileLikeObject {
             SeekFrom::End(i) => (2, i),
         };
 
-        let new_position = self
-            .inner
+        let new_position = Ruby::get()
+            .unwrap()
+            .get_inner(self.inner)
             .funcall("seek", (offset, whence))
             .map_err(rberr_to_io_err)?;
 
@@ -129,11 +155,12 @@ impl Seek for RbFileLikeObject {
 pub trait FileLike: Read + Write + Seek {}
 
 impl FileLike for File {}
+impl FileLike for ClosableFile {}
 impl FileLike for RbFileLikeObject {}
 
 pub enum EitherRustRubyFile {
     Rb(RbFileLikeObject),
-    Rust(File),
+    Rust(ClosableFile),
 }
 
 impl EitherRustRubyFile {
@@ -144,6 +171,13 @@ impl EitherRustRubyFile {
         }
     }
 
+    pub(crate) fn into_writeable(self) -> Box<dyn DynWriteable> {
+        match self {
+            Self::Rb(f) => Box::new(f),
+            Self::Rust(f) => Box::new(f),
+        }
+    }
+
     pub fn into_dyn_writeable(self) -> Box<dyn Write> {
         match self {
             EitherRustRubyFile::Rb(f) => Box::new(f),
@@ -159,6 +193,14 @@ pub enum RubyScanSourceInput {
     File(File),
 }
 
+pub(crate) fn try_get_rbfile(
+    rb_f: Value,
+    write: bool,
+) -> RbResult<(EitherRustRubyFile, Option<PathBuf>)> {
+    let f = RbFileLikeObject::with_requirements(rb_f, !write, write, !write)?;
+    Ok((EitherRustRubyFile::Rb(f), None))
+}
+
 pub fn get_ruby_scan_source_input(rb_f: Value, write: bool) -> RbResult<RubyScanSourceInput> {
     if let Ok(file_path) = PathBuf::try_convert(rb_f) {
         // TODO resolve_homedir
@@ -184,7 +226,7 @@ pub fn get_either_file(rb_f: Value, truncate: bool) -> RbResult<EitherRustRubyFi
         } else {
             polars_utils::open_file(&file_path).map_err(RbPolarsErr::from)?
         };
-        Ok(EitherRustRubyFile::Rust(f))
+        Ok(EitherRustRubyFile::Rust(f.into()))
     } else {
         let f = RbFileLikeObject::with_requirements(rb_f, !truncate, truncate, !truncate)?;
         Ok(EitherRustRubyFile::Rb(f))

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

@@ -278,7 +278,13 @@ pub fn first() -> RbExpr {
     dsl::first().into()
 }
 
-pub fn fold(acc: &RbExpr, lambda: Value, exprs: RArray) -> RbResult<RbExpr> {
+pub fn fold(
+    acc: &RbExpr,
+    lambda: Value,
+    exprs: RArray,
+    returns_scalar: bool,
+    return_dtype: Option<Wrap<DataType>>,
+) -> RbResult<RbExpr> {
     let exprs = rb_exprs_to_exprs(exprs)?;
     let lambda = Opaque::from(lambda);
 
@@ -290,14 +296,21 @@ pub fn fold(acc: &RbExpr, lambda: Value, exprs: RArray) -> RbResult<RbExpr> {
         )
         .map(|v| v.map(Column::from))
     };
-    Ok(dsl::fold_exprs(acc.inner.clone(), func, exprs).into())
+    Ok(dsl::fold_exprs(
+        acc.inner.clone(),
+        func,
+        exprs,
+        returns_scalar,
+        return_dtype.map(|w| w.0),
+    )
+    .into())
 }
 
 pub fn last() -> RbExpr {
     dsl::last().into()
 }
 
-pub fn lit(value: Value, allow_object: bool) -> RbResult<RbExpr> {
+pub fn lit(value: Value, allow_object: bool, is_scalar: bool) -> RbResult<RbExpr> {
     if value.is_kind_of(class::true_class()) || value.is_kind_of(class::false_class()) {
         Ok(dsl::lit(bool::try_convert(value)?).into())
     } else if let Some(v) = Integer::from_value(value) {
@@ -323,7 +336,16 @@ pub fn lit(value: Value, allow_object: bool) -> RbResult<RbExpr> {
             Ok(dsl::lit(unsafe { v.as_slice() }).into())
         }
     } else if let Ok(series) = Obj::<RbSeries>::try_convert(value) {
-        Ok(dsl::lit(series.series.borrow().clone()).into())
+        let s = series.series.borrow();
+        if is_scalar {
+            let av = s
+                .get(0)
+                .map_err(|_| RbValueError::new_err("expected at least 1 value"))?;
+            let av = av.into_static();
+            Ok(dsl::lit(Scalar::new(s.dtype().clone(), av)).into())
+        } else {
+            Ok(dsl::lit(s.clone()).into())
+        }
     } else if value.is_nil() {
         Ok(dsl::lit(Null {}).into())
     } else if allow_object {

data/ext/polars/src/functions/range.rs

@@ -56,14 +56,14 @@ pub fn datetime_range(
     every: String,
     closed: Wrap<ClosedWindow>,
     time_unit: Option<Wrap<TimeUnit>>,
-    time_zone: Option<Wrap<TimeZone>>,
+    time_zone: Wrap<Option<TimeZone>>,
 ) -> RbExpr {
     let start = start.inner.clone();
     let end = end.inner.clone();
     let every = Duration::parse(&every);
     let closed = closed.0;
     let time_unit = time_unit.map(|x| x.0);
-    let time_zone = time_zone.map(|x| x.0);
+    let time_zone = time_zone.0;
     dsl::datetime_range(start, end, every, closed, time_unit, time_zone).into()
 }
 
@@ -73,14 +73,14 @@ pub fn datetime_ranges(
     every: String,
     closed: Wrap<ClosedWindow>,
     time_unit: Option<Wrap<TimeUnit>>,
-    time_zone: Option<Wrap<TimeZone>>,
+    time_zone: Wrap<Option<TimeZone>>,
 ) -> RbExpr {
     let start = start.inner.clone();
     let end = end.inner.clone();
     let every = Duration::parse(&every);
     let closed = closed.0;
     let time_unit = time_unit.map(|x| x.0);
-    let time_zone = time_zone.map(|x| x.0);
+    let time_zone = time_zone.0;
     dsl::datetime_ranges(start, end, every, closed, time_unit, time_zone).into()
 }