polars-df 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14ccd76535033a1f3d848fcddc415c655b7e1396549739a76b7cd475bc4bf1b9
-  data.tar.gz: cf3459dfc3a000dacfef73859ac3a613fd73416644c2887f9aa08c84d1f0eede
+  metadata.gz: c85781858b193df5bb1bf3156b6ff14cee0d31ba9d70a14e0830c473d1cca589
+  data.tar.gz: b4333da25d4d575f1ef84a39b673244b088b346520b2b7e65d51e899e73e27b5
 SHA512:
-  metadata.gz: b87a95fdff40f17fd5bc1f286b4f8f1ff906675c07c84769b08ecfe97347c2e15fcb61d6a93d2ba7ae7556bb937d0ddf90dbc188cee75ecf00f481a97db0bb7e
-  data.tar.gz: c93504de6f9071e45529f7c3898100e5c9341b2f2a3f527aa8fdee6cc195055230c0c08b9a7383684489ae25c00acf7e136d8a3516b6e20b5a1d1445b55efca5
+  metadata.gz: 86b867790e1cde10fc813eceb2baf26912700d2db7501f670c5fae5156fcd1ce56b494d178f488d0e84a74220f3b87446df94e1822c44b3c6a869392f805c5ee
+  data.tar.gz: 7afe9f2b39be4045ce4fc95c1619db0fadad80eed5c4d9b25f2434379ee1aae61a87c956ec92e16cfd15bec0c780b5bf25fefe84bb858083874971bfc47860fd

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.3.1 (2023-02-21)
+
+- Added `to_numo` method to `Series` and `DataFrame`
+- Added `plot` method to `DataFrame`
+- Fixed `is_datelike` method for `Datetime` and `Duration`
+
 ## 0.3.0 (2023-02-15)
 
 - Updated Polars to 0.27.1

data/Cargo.lock

@@ -1430,7 +1430,7 @@ dependencies = [
 
 [[package]]
 name = "polars"
-version = "0.3.0"
+version = "0.3.1"
 dependencies = [
  "ahash",
  "jemallocator",

data/README.md

@@ -282,10 +282,10 @@ df.to_dummies
 
 ## Conversion
 
-Array of rows
+Array of hashes
 
 ```ruby
-df.rows
+df.rows(named: true)
 ```
 
 Hash of series
@@ -308,6 +308,12 @@ Parquet
 df.write_parquet("file.parquet")
 ```
 
+Numo array
+
+```ruby
+df.to_numo
+```
+
 ## Types
 
 You can specify column types when creating a data frame
@@ -343,6 +349,38 @@ Cast a column
 df["a"].cast(Polars::Int32)
 ```
 
+## Visualization
+
+Add [Vega](https://github.com/ankane/vega-ruby) to your application’s Gemfile:
+
+```ruby
+gem "vega"
+```
+
+And use:
+
+```ruby
+df.plot("a", "b")
+```
+
+Specify the chart type (`line`, `pie`, `column`, `bar`, `area`, or `scatter`)
+
+```ruby
+df.plot("a", "b", type: "pie")
+```
+
+Group data
+
+```ruby
+df.groupby("c").plot("a", "b")
+```
+
+Stacked columns or bars
+
+```ruby
+df.groupby("c").plot("a", "b", stacked: true)
+```
+
 ## History
 
 View the [changelog](CHANGELOG.md)

data/ext/polars/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "polars"
-version = "0.3.0"
+version = "0.3.1"
 license = "MIT"
 authors = ["Andrew Kane <andrew@ankane.org>"]
 edition = "2021"

data/ext/polars/src/conversion.rs

@@ -125,7 +125,13 @@ impl IntoValue for Wrap<AnyValue<'_>> {
                 .unwrap(),
             AnyValue::Datetime(v, tu, tz) => {
                 let t = match tu {
-                    TimeUnit::Nanoseconds => todo!(),
+                    TimeUnit::Nanoseconds => {
+                        let sec = v / 1000000000;
+                        let subsec = v % 1000000000;
+                        class::time()
+                            .funcall::<_, _, Value>("at", (sec, subsec, Symbol::new("nsec")))
+                            .unwrap()
+                    }
                     TimeUnit::Microseconds => {
                         let sec = v / 1000000;
                         let subsec = v % 1000000;
@@ -133,7 +139,13 @@ impl IntoValue for Wrap<AnyValue<'_>> {
                             .funcall::<_, _, Value>("at", (sec, subsec, Symbol::new("usec")))
                             .unwrap()
                     }
-                    TimeUnit::Milliseconds => todo!(),
+                    TimeUnit::Milliseconds => {
+                        let sec = v / 1000;
+                        let subsec = v % 1000;
+                        class::time()
+                            .funcall::<_, _, Value>("at", (sec, subsec, Symbol::new("millisecond")))
+                            .unwrap()
+                    }
                 };
 
                 if tz.is_some() {
@@ -175,7 +187,7 @@ impl IntoValue for Wrap<DataType> {
             DataType::Utf8 => pl.const_get::<_, Value>("Utf8").unwrap(),
             DataType::Binary => pl.const_get::<_, Value>("Binary").unwrap(),
             DataType::List(inner) => {
-                let inner = Wrap(*inner.clone());
+                let inner = Wrap(*inner);
                 let list_class = pl.const_get::<_, Value>("List").unwrap();
                 list_class.funcall::<_, _, Value>("new", (inner,)).unwrap()
             }
@@ -183,7 +195,7 @@ 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.clone()))
+                    .funcall::<_, _, Value>("new", (tu.to_ascii(), tz))
                     .unwrap()
             }
             DataType::Duration(tu) => {

data/ext/polars/src/dataframe.rs

@@ -6,6 +6,7 @@ use polars::io::mmap::ReaderBytes;
 use polars::io::RowCount;
 use polars::prelude::pivot::{pivot, pivot_stable};
 use polars::prelude::*;
+use polars_core::utils::try_get_supertype;
 use std::cell::RefCell;
 use std::io::{BufWriter, Cursor};
 use std::ops::Deref;
@@ -493,6 +494,25 @@ impl RbDataFrame {
         .into()
     }
 
+    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?;
+
+        match st {
+            // TODO
+            _ => None,
+        }
+    }
+
     pub fn write_parquet(
         &self,
         rb_f: Value,

data/ext/polars/src/error.rs

@@ -43,3 +43,11 @@ impl ComputeError {
         Error::new(exception::runtime_error(), message)
     }
 }
+
+#[macro_export]
+macro_rules! raise_err(
+    ($msg:expr, $err:ident) => {{
+        Err(PolarsError::$err($msg.into())).map_err(RbPolarsErr::from)?;
+        unreachable!()
+    }}
+);

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;
@@ -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))?;
@@ -783,6 +785,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

@@ -489,40 +489,52 @@ 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::Decimal128(_) => todo!(),
+                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::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/data_frame.rb

@@ -1,6 +1,8 @@
 module Polars
   # Two-dimensional data structure representing data as a table with rows and columns.
   class DataFrame
+    include Plot
+
     # @private
     attr_accessor :_df
 
@@ -604,10 +606,10 @@ module Polars
           return Slice.new(self).apply(item)
         end
 
-        if Utils.is_str_sequence(item, allow_str: false)
+        if item.is_a?(Array) && item.all? { |v| Utils.strlike?(v) }
           # select multiple columns
           # df[["foo", "bar"]]
-          return _from_rbdf(_df.select(item))
+          return _from_rbdf(_df.select(item.map(&:to_s)))
         end
 
         if Utils.is_int_sequence(item)
@@ -689,7 +691,8 @@ module Polars
     # @example
     #   df = Polars::DataFrame.new({"foo" => [1, 2, 3], "bar" => [4, 5, 6]})
     #   df.to_hashes
-    #   [{'foo': 1, 'bar': 4}, {'foo': 2, 'bar': 5}, {'foo': 3, 'bar': 6}]
+    #   # =>
+    #   # [{"foo"=>1, "bar"=>4}, {"foo"=>2, "bar"=>5}, {"foo"=>3, "bar"=>6}]
     def to_hashes
       rbdf = _df
       names = columns
@@ -699,8 +702,26 @@ module Polars
       end
     end
 
-    # def to_numo
-    # end
+    # Convert DataFrame to a 2D Numo array.
+    #
+    # This operation clones data.
+    #
+    # @return [Numo::NArray]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {"foo" => [1, 2, 3], "bar" => [6, 7, 8], "ham" => ["a", "b", "c"]}
+    #   )
+    #   df.to_numo.class
+    #   # => Numo::RObject
+    def to_numo
+      out = _df.to_numo
+      if out.nil?
+        Numo::NArray.vstack(width.times.map { |i| to_series(i).to_numo }).transpose
+      else
+        out
+      end
+    end
 
     # no to_pandas
 

data/lib/polars/data_types.rb

@@ -84,6 +84,8 @@ module Polars
 
   # Calendar date and time type.
   class Datetime < TemporalType
+    attr_reader :tu
+
     def initialize(time_unit = "us", time_zone = nil)
       @tu = time_unit || "us"
       @time_zone = time_zone
@@ -92,6 +94,8 @@ module Polars
 
   # Time duration/delta type.
   class Duration < TemporalType
+    attr_reader :tu
+
     def initialize(time_unit = "us")
       @tu = time_unit
     end

data/lib/polars/group_by.rb

@@ -571,5 +571,16 @@ module Polars
     def agg_list
       agg(Polars.all.list)
     end
+
+    # Plot data.
+    #
+    # @return [Vega::LiteChart]
+    def plot(*args, **options)
+      raise ArgumentError, "Multiple groups not supported" if by.is_a?(Array) && by.size > 1
+      # same message as Ruby
+      raise ArgumentError, "unknown keyword: :group" if options.key?(:group)
+
+      Utils.wrap_df(_df).plot(*args, **options, group: by)
+    end
   end
 end

data/lib/polars/plot.rb

@@ -0,0 +1,109 @@
+module Polars
+  module Plot
+    # Plot data.
+    #
+    # @return [Vega::LiteChart]
+    def plot(x = nil, y = nil, type: nil, group: nil, stacked: nil)
+      require "vega"
+
+      raise ArgumentError, "Must specify columns" if columns.size != 2 && (!x || !y)
+      x ||= columns[0]
+      y ||= columns[1]
+      type ||= begin
+        if self[x].numeric? && self[y].numeric?
+          "scatter"
+        elsif self[x].utf8? && self[y].numeric?
+          "column"
+        elsif (self[x].dtype == Date || self[x].dtype.is_a?(Datetime)) && self[y].numeric?
+          "line"
+        else
+          raise "Cannot determine type. Use the type option."
+        end
+      end
+      df = self[(group.nil? ? [x, y] : [x, y, group]).map(&:to_s).uniq]
+      data = df.rows(named: true)
+
+      case type
+      when "line", "area"
+        x_type =
+          if df[x].numeric?
+            "quantitative"
+          elsif df[x].datelike?
+            "temporal"
+          else
+            "nominal"
+          end
+
+        scale = x_type == "temporal" ? {type: "utc"} : {}
+        encoding = {
+          x: {field: x, type: x_type, scale: scale},
+          y: {field: y, type: "quantitative"}
+        }
+        encoding[:color] = {field: group} if group
+
+        Vega.lite
+          .data(data)
+          .mark(type: type, tooltip: true, interpolate: "cardinal", point: {size: 60})
+          .encoding(encoding)
+          .config(axis: {labelFontSize: 12})
+      when "pie"
+        raise ArgumentError, "Cannot use group option with pie chart" unless group.nil?
+
+        Vega.lite
+          .data(data)
+          .mark(type: "arc", tooltip: true)
+          .encoding(
+            color: {field: x, type: "nominal", sort: "none", axis: {title: nil}, legend: {labelFontSize: 12}},
+            theta: {field: y, type: "quantitative"}
+          )
+          .view(stroke: nil)
+      when "column"
+        encoding = {
+          x: {field: x, type: "nominal", sort: "none", axis: {labelAngle: 0}},
+          y: {field: y, type: "quantitative"}
+        }
+        if group
+          encoding[:color] = {field: group}
+          encoding[:xOffset] = {field: group} unless stacked
+        end
+
+        Vega.lite
+          .data(data)
+          .mark(type: "bar", tooltip: true)
+          .encoding(encoding)
+          .config(axis: {labelFontSize: 12})
+      when "bar"
+        encoding = {
+          # TODO determine label angle
+          y: {field: x, type: "nominal", sort: "none", axis: {labelAngle: 0}},
+          x: {field: y, type: "quantitative"}
+        }
+        if group
+          encoding[:color] = {field: group}
+          encoding[:yOffset] = {field: group} unless stacked
+        end
+
+        Vega.lite
+          .data(data)
+          .mark(type: "bar", tooltip: true)
+          .encoding(encoding)
+          .config(axis: {labelFontSize: 12})
+      when "scatter"
+        encoding = {
+          x: {field: x, type: "quantitative", scale: {zero: false}},
+          y: {field: y, type: "quantitative", scale: {zero: false}},
+          size: {value: 60}
+        }
+        encoding[:color] = {field: group} if group
+
+        Vega.lite
+          .data(data)
+          .mark(type: "circle", tooltip: true)
+          .encoding(encoding)
+          .config(axis: {labelFontSize: 12})
+      else
+        raise ArgumentError, "Invalid type: #{type}"
+      end
+    end
+  end
+end

data/lib/polars/series.rb

@@ -1776,8 +1776,9 @@ module Polars
     #   s.is_datelike
     #   # => true
     def is_datelike
-      [Date, Datetime, Duration, Time].include?(dtype)
+      [Date, Time].include?(dtype) || dtype.is_a?(Datetime) || dtype.is_a?(Duration)
     end
+    alias_method :datelike?, :is_datelike
 
     # Check if this Series has floating point numbers.
     #
@@ -1823,8 +1824,45 @@ module Polars
     # def view
     # end
 
-    # def to_numo
-    # end
+    # Convert this Series to a Numo array. This operation clones data but is completely safe.
+    #
+    # @return [Numo::NArray]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, 3])
+    #   s.to_numo
+    #   # =>
+    #   # Numo::Int64#shape=[3]
+    #   # [1, 2, 3]
+    def to_numo
+      if !has_validity
+        if is_datelike
+          Numo::RObject.cast(to_a)
+        elsif is_numeric
+          # TODO make more efficient
+          {
+            UInt8 => Numo::UInt8,
+            UInt16 => Numo::UInt16,
+            UInt32 => Numo::UInt32,
+            UInt64 => Numo::UInt64,
+            Int8 => Numo::Int8,
+            Int16 => Numo::Int16,
+            Int32 => Numo::Int32,
+            Int64 => Numo::Int64,
+            Float32 => Numo::SFloat,
+            Float64 => Numo::DFloat
+          }.fetch(dtype).cast(to_a)
+        elsif is_boolean
+          Numo::Bit.cast(to_a)
+        else
+          _s.to_numo
+        end
+      elsif is_datelike
+        Numo::RObject.cast(to_a)
+      else
+        _s.to_numo
+      end
+    end
 
     # Set masked values.
     #

data/lib/polars/version.rb

@@ -1,4 +1,4 @@
 module Polars
   # @private
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

data/lib/polars.rb

@@ -15,6 +15,7 @@ require_relative "polars/batched_csv_reader"
 require_relative "polars/cat_expr"
 require_relative "polars/cat_name_space"
 require_relative "polars/convert"
+require_relative "polars/plot"
 require_relative "polars/data_frame"
 require_relative "polars/data_types"
 require_relative "polars/date_time_expr"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polars-df
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-16 00:00:00.000000000 Z
+date: 2023-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -55,6 +55,7 @@ files:
 - ext/polars/src/lazy/utils.rs
 - ext/polars/src/lib.rs
 - ext/polars/src/list_construction.rs
+- ext/polars/src/numo.rs
 - ext/polars/src/object.rs
 - ext/polars/src/prelude.rs
 - ext/polars/src/rb_modules.rs
@@ -84,6 +85,7 @@ files:
 - lib/polars/list_expr.rb
 - lib/polars/list_name_space.rb
 - lib/polars/meta_expr.rb
+- lib/polars/plot.rb
 - lib/polars/rolling_group_by.rb
 - lib/polars/series.rb
 - lib/polars/slice.rb