polars-df 0.10.0 → 0.12.0

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

@@ -25,6 +25,48 @@ pub fn int_ranges(start: &RbExpr, end: &RbExpr, step: &RbExpr, dtype: Wrap<DataT
 }
 
 pub fn date_range(
+    start: &RbExpr,
+    end: &RbExpr,
+    interval: String,
+    closed: Wrap<ClosedWindow>,
+) -> RbExpr {
+    let start = start.inner.clone();
+    let end = end.inner.clone();
+    let interval = Duration::parse(&interval);
+    let closed = closed.0;
+    dsl::date_range(start, end, interval, closed).into()
+}
+
+pub fn date_ranges(
+    start: &RbExpr,
+    end: &RbExpr,
+    interval: String,
+    closed: Wrap<ClosedWindow>,
+) -> RbExpr {
+    let start = start.inner.clone();
+    let end = end.inner.clone();
+    let interval = Duration::parse(&interval);
+    let closed = closed.0;
+    dsl::date_ranges(start, end, interval, closed).into()
+}
+
+pub fn datetime_range(
+    start: &RbExpr,
+    end: &RbExpr,
+    every: String,
+    closed: Wrap<ClosedWindow>,
+    time_unit: Option<Wrap<TimeUnit>>,
+    time_zone: 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);
+    dsl::datetime_range(start, end, every, closed, time_unit, time_zone).into()
+}
+
+pub fn datetime_ranges(
     start: &RbExpr,
     end: &RbExpr,
     every: String,
@@ -37,5 +79,31 @@ pub fn date_range(
     let every = Duration::parse(&every);
     let closed = closed.0;
     let time_unit = time_unit.map(|x| x.0);
-    dsl::date_range(start, end, every, closed, time_unit, time_zone).into()
+    dsl::datetime_ranges(start, end, every, closed, time_unit, time_zone).into()
+}
+
+pub fn time_range(
+    start: &RbExpr,
+    end: &RbExpr,
+    every: String,
+    closed: Wrap<ClosedWindow>,
+) -> RbExpr {
+    let start = start.inner.clone();
+    let end = end.inner.clone();
+    let every = Duration::parse(&every);
+    let closed = closed.0;
+    dsl::time_range(start, end, every, closed).into()
+}
+
+pub fn time_ranges(
+    start: &RbExpr,
+    end: &RbExpr,
+    every: String,
+    closed: Wrap<ClosedWindow>,
+) -> RbExpr {
+    let start = start.inner.clone();
+    let end = end.inner.clone();
+    let every = Duration::parse(&every);
+    let closed = closed.0;
+    dsl::time_ranges(start, end, every, closed).into()
 }

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

@@ -0,0 +1 @@
+pub mod numo;

data/ext/polars/src/interop/numo/mod.rs

@@ -0,0 +1,2 @@
+pub mod to_numo_df;
+pub mod to_numo_series;

data/ext/polars/src/interop/numo/to_numo_df.rs

@@ -0,0 +1,23 @@
+use magnus::Value;
+use polars_core::utils::try_get_supertype;
+
+use crate::dataframe::RbDataFrame;
+
+impl RbDataFrame {
+    pub fn to_numo(&self) -> Option<Value> {
+        let mut st = None;
+        for s in self.df.borrow().iter() {
+            let dt_i = s.dtype();
+            match st {
+                None => st = Some(dt_i.clone()),
+                Some(ref mut st) => {
+                    *st = try_get_supertype(st, dt_i).ok()?;
+                }
+            }
+        }
+        let _st = st?;
+
+        // TODO
+        None
+    }
+}

data/ext/polars/src/interop/numo/to_numo_series.rs

@@ -0,0 +1,61 @@
+use magnus::{class, prelude::*, Module, RArray, RClass, RModule, Value};
+use polars::series::BitRepr;
+use polars_core::prelude::*;
+
+use crate::error::RbPolarsErr;
+use crate::raise_err;
+use crate::series::RbSeries;
+use crate::RbResult;
+
+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::String => {
+                let ca = s.str().unwrap();
+
+                // TODO make more efficient
+                let np_arr = RArray::from_iter(ca);
+                class::object()
+                    .const_get::<_, RModule>("Numo")?
+                    .const_get::<_, RClass>("RObject")?
+                    .funcall("cast", (np_arr,))
+            }
+            dt if dt.is_numeric() => {
+                if let Some(BitRepr::Large(_)) = s.bit_repr() {
+                    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
+                );
+            }
+        }
+    }
+}