polars-df 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a07e6dd4bee3bef4020d7818a060c6f28aaedb7264b206e35a485e575cd8a695
-  data.tar.gz: c586e0ec898aab7642f49d49b54c614121b9cb1f748eb7c98d76611ae2ad56a2
+  metadata.gz: 5afa804963fc59154e8adde6034e07d1a2a90c077b8e0b72d2ad3ca49af34e8e
+  data.tar.gz: b2291436080973ad43595ef25559cdc81669b07986a6779c85c4c372e220e39a
 SHA512:
-  metadata.gz: ff035a9b60966342ca16dc5eea3b0abd0c4a08f5db8a0fc3c4d6ef206dd20ad56becbcd3a7ecdb5c328de6f9a52d53531eeb44c75078170d451bc39197553570
-  data.tar.gz: 48c7334a56339fb0feda046c415839ece39e2c92cf807ed422026d00787d687bbda2ba1198d612434379a2de92830841f0798109920f76d730205e612ab72cb1
+  metadata.gz: 7d7aa73d12e9a322de83db5f69b4ab0f5e9605b737776a83476f917cf32ad1ef6770c79e80a810be68a9144206fef6c3931af3285763741232b8ba87871d0a06
+  data.tar.gz: 2f9daceaba3edd0671a650ab1a2da6ddc6591f768e52a4c8a8f01d7e3fd573320c4464d0081762daeb75d41475bb4e87e298b426b507ef6c7bb9d3164149e7e6

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.2.4 (2023-01-29)
+
+- Added support for more types when creating a data frame from an array of hashes
+
 ## 0.2.3 (2023-01-22)
 
 - Fixed error with precompiled gem on Mac ARM

data/Cargo.lock

@@ -1367,7 +1367,7 @@ dependencies = [
 
 [[package]]
 name = "polars"
-version = "0.2.3"
+version = "0.2.4"
 dependencies = [
  "ahash",
  "jemallocator",
@@ -1653,18 +1653,18 @@ dependencies = [
 
 [[package]]
 name = "rb-sys"
-version = "0.9.56"
+version = "0.9.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef82428221475c6f9e7893fe30b88d45ac86bdb12e58e7c92055ba4bceb78a69"
+checksum = "0158f5115e1ad04a2ee231f597e86306af96f36a8b93ac0c01f8852d0ba89278"
 dependencies = [
  "rb-sys-build",
 ]
 
 [[package]]
 name = "rb-sys-build"
-version = "0.9.56"
+version = "0.9.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "950bfc239d2e7704576abe4d37b008876bbfd70a99196a188c5caeae2ba7344a"
+checksum = "6c27b779db4a2863db74ddad0011f0d0c55c528e9601126d4613ad688063bc05"
 dependencies = [
  "bindgen",
  "regex",
@@ -1673,9 +1673,9 @@ dependencies = [
 
 [[package]]
 name = "rb-sys-env"
-version = "0.1.1"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74c38752410925faeb82c400c06ba2fd9ee6aa8f719dd33994c9e53f5242d25f"
+checksum = "a35802679f07360454b418a5d1735c89716bde01d35b1560fc953c1415a0b3bb"
 
 [[package]]
 name = "redox_syscall"

data/README.md

@@ -69,6 +69,16 @@ Polars::DataFrame.new({
 })
 ```
 
+From an array of hashes
+
+```ruby
+Polars::DataFrame.new([
+  {"a" => 1, "b" => "one"},
+  {"a" => 2, "b" => "two"},
+  {"a" => 3, "b" => "three"}
+])
+```
+
 From an array of series
 
 ```ruby

data/ext/polars/Cargo.toml

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

data/ext/polars/src/conversion.rs

@@ -1,8 +1,11 @@
-use magnus::{class, r_hash::ForEach, Module, RArray, RHash, Symbol, TryConvert, Value, QNIL};
+use magnus::{
+    class, r_hash::ForEach, Integer, Module, RArray, RFloat, RHash, RString, Symbol, TryConvert,
+    Value, QNIL,
+};
 use polars::chunked_array::object::PolarsObjectSafe;
 use polars::chunked_array::ops::{FillNullLimit, FillNullStrategy};
 use polars::datatypes::AnyValue;
-use polars::frame::row::Row;
+use polars::frame::row::{any_values_to_dtype, Row};
 use polars::frame::NullStrategy;
 use polars::io::avro::AvroCompression;
 use polars::prelude::*;
@@ -273,15 +276,24 @@ impl TryConvert for Wrap<DataType> {
 
 impl<'s> TryConvert for Wrap<AnyValue<'s>> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        // TODO improve
-        if let Ok(v) = ob.try_convert::<i64>() {
-            Ok(AnyValue::Int64(v).into())
-        } else if let Ok(v) = ob.try_convert::<f64>() {
-            Ok(AnyValue::Float64(v).into())
+        if ob.is_kind_of(class::true_class()) || ob.is_kind_of(class::false_class()) {
+            Ok(AnyValue::Boolean(ob.try_convert::<bool>()?).into())
+        } else if let Some(v) = Integer::from_value(ob) {
+            Ok(AnyValue::Int64(v.to_i64()?).into())
+        } else if let Some(v) = RFloat::from_value(ob) {
+            Ok(AnyValue::Float64(v.to_f64()).into())
+        } else if let Some(v) = RString::from_value(ob) {
+            Ok(AnyValue::Utf8Owned(v.to_string()?.into()).into())
+        // call is_a? for ActiveSupport::TimeWithZone
+        } else if ob.funcall::<_, _, bool>("is_a?", (class::time(),))? {
+            let sec = ob.funcall::<_, _, i64>("to_i", ())?;
+            let nsec = ob.funcall::<_, _, i64>("nsec", ())?;
+            let v = sec * 1_000_000_000 + nsec;
+            // TODO support time zone
+            Ok(AnyValue::Datetime(v, TimeUnit::Nanoseconds, &None).into())
         } else if ob.is_nil() {
             Ok(AnyValue::Null.into())
-        } else if ob.is_kind_of(class::hash()) {
-            let dict = ob.try_convert::<RHash>().unwrap();
+        } else if let Some(dict) = RHash::from_value(ob) {
             let len = dict.len();
             let mut keys = Vec::with_capacity(len);
             let mut vals = Vec::with_capacity(len);
@@ -294,6 +306,28 @@ impl<'s> TryConvert for Wrap<AnyValue<'s>> {
                 Ok(ForEach::Continue)
             })?;
             Ok(Wrap(AnyValue::StructOwned(Box::new((vals, keys)))))
+        } else if let Some(v) = RArray::from_value(ob) {
+            if v.is_empty() {
+                Ok(Wrap(AnyValue::List(Series::new_empty("", &DataType::Null))))
+            } else {
+                let avs = v.try_convert::<Wrap<Row>>()?.0 .0;
+                // use first `n` values to infer datatype
+                // this value is not too large as this will be done with every
+                // anyvalue that has to be converted, which can be many
+                let n = 25;
+                let dtype = any_values_to_dtype(&avs[..std::cmp::min(avs.len(), n)])
+                    .map_err(RbPolarsErr::from)?;
+                let s = Series::from_any_values_and_dtype("", &avs, &dtype)
+                    .map_err(RbPolarsErr::from)?;
+                Ok(Wrap(AnyValue::List(s)))
+            }
+        } else if ob.is_kind_of(crate::rb_modules::date()) {
+            // convert to DateTime for UTC
+            let v = ob
+                .funcall::<_, _, Value>("to_datetime", ())?
+                .funcall::<_, _, Value>("to_time", ())?
+                .funcall::<_, _, i64>("to_i", ())?;
+            Ok(Wrap(AnyValue::Date((v / 86400) as i32)))
         } else {
             Err(RbPolarsErr::other(format!(
                 "object type not supported {:?}",
@@ -412,8 +446,12 @@ pub(crate) fn dicts_to_rows(
         let d = d?;
         let d = d.try_convert::<RHash>()?;
 
-        d.foreach(|name: String, _value: Value| {
-            key_names.insert(name);
+        d.foreach(|name: Value, _value: Value| {
+            if let Some(v) = Symbol::from_value(name) {
+                key_names.insert(v.name()?.into());
+            } else {
+                key_names.insert(name.try_convert::<String>()?);
+            };
             Ok(ForEach::Continue)
         })?;
     }
@@ -427,7 +465,8 @@ pub(crate) fn dicts_to_rows(
         let mut row = Vec::with_capacity(key_names.len());
 
         for k in key_names.iter() {
-            let val = match d.get(k.clone()) {
+            // TODO improve performance
+            let val = match d.get(k.clone()).or_else(|| d.get(Symbol::new(k))) {
                 None => AnyValue::Null,
                 Some(val) => val.try_convert::<Wrap<AnyValue>>()?.0,
             };

data/ext/polars/src/lib.rs

@@ -21,13 +21,12 @@ use file::get_file_like;
 use lazy::dataframe::{RbLazyFrame, RbLazyGroupBy};
 use lazy::dsl::{RbExpr, RbWhen, RbWhenThen};
 use lazy::utils::rb_exprs_to_exprs;
-use magnus::{function, method, prelude::*, Error, RArray, RHash, Value};
+use magnus::{define_module, function, method, prelude::*, Error, RArray, RHash, Value};
 use polars::datatypes::{DataType, TimeUnit, IDX_DTYPE};
 use polars::error::PolarsResult;
 use polars::frame::DataFrame;
 use polars::functions::{diag_concat_df, hor_concat_df};
 use polars::prelude::{ClosedWindow, Duration, DurationArgs, IntoSeries, TimeZone};
-use rb_modules::polars;
 use series::RbSeries;
 
 #[cfg(target_os = "linux")]
@@ -48,7 +47,7 @@ type RbResult<T> = Result<T, Error>;
 
 #[magnus::init]
 fn init() -> RbResult<()> {
-    let module = polars();
+    let module = define_module("Polars")?;
     module.define_singleton_method("_dtype_cols", function!(dtype_cols, 1))?;
     module.define_singleton_method("_rb_duration", function!(rb_duration, 8))?;
     module.define_singleton_method("_concat_df", function!(concat_df, 1))?;

data/ext/polars/src/rb_modules.rs

@@ -1,9 +1,13 @@
-use magnus::{define_module, memoize, Module, RClass, RModule};
+use magnus::{class, memoize, Module, RClass, RModule};
 
 pub(crate) fn polars() -> RModule {
-    *memoize!(RModule: define_module("Polars").unwrap())
+    *memoize!(RModule: class::object().const_get("Polars").unwrap())
 }
 
 pub(crate) fn series() -> RClass {
-    *memoize!(RClass: polars().define_class("Series", Default::default()).unwrap())
+    *memoize!(RClass: polars().const_get("Series").unwrap())
+}
+
+pub(crate) fn date() -> RClass {
+    *memoize!(RClass: class::object().const_get("Date").unwrap())
 }

data/ext/polars/src/series.rs

@@ -1109,11 +1109,13 @@ impl RbSeries {
                 builder.append_null();
             } else {
                 // convert to DateTime for UTC
-                let v: Value = v.funcall("to_datetime", ())?;
-                let v: Value = v.funcall("to_time", ())?;
-                let v: Value = v.funcall("to_i", ())?;
+                let v = v
+                    .funcall::<_, _, Value>("to_datetime", ())?
+                    .funcall::<_, _, Value>("to_time", ())?
+                    .funcall::<_, _, i64>("to_i", ())?;
+
                 // TODO use strict
-                builder.append_value(v.try_convert::<i32>()? / 86400);
+                builder.append_value((v / 86400) as i32);
             }
         }
         let ca: ChunkedArray<Int32Type> = builder.finish();

data/lib/polars/version.rb

@@ -1,4 +1,4 @@
 module Polars
   # @private
-  VERSION = "0.2.3"
+  VERSION = "0.2.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polars-df
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-22 00:00:00.000000000 Z
+date: 2023-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys