polars-df 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df03134e7edf09e86b5a4f4f9ae9a926bac4c9c0804a29c3422c32675f478825
-  data.tar.gz: e0338be1aa96d0ad082ebf8fe27e608b2906b243dd49fa837aceb7f8186947d8
+  metadata.gz: a07e6dd4bee3bef4020d7818a060c6f28aaedb7264b206e35a485e575cd8a695
+  data.tar.gz: c586e0ec898aab7642f49d49b54c614121b9cb1f748eb7c98d76611ae2ad56a2
 SHA512:
-  metadata.gz: 75a139d30f9fdebaa84a21fa45cec8a199da76eb295e7099ceb849646a93fbc7ed80ffed18aaa8eb7bbfc53a32792b2e47101485ad31d727a47ed67d8d7e8110
-  data.tar.gz: 589f7fbc1300aadc05568308700f6a94b934e63c40bd1be0a3e7b6f564c0d55f256e2e45e926c128d80453d0e7d200b057f640b02cd6fb9aaddf5bf55dd89754
+  metadata.gz: ff035a9b60966342ca16dc5eea3b0abd0c4a08f5db8a0fc3c4d6ef206dd20ad56becbcd3a7ecdb5c328de6f9a52d53531eeb44c75078170d451bc39197553570
+  data.tar.gz: 48c7334a56339fb0feda046c415839ece39e2c92cf807ed422026d00787d687bbda2ba1198d612434379a2de92830841f0798109920f76d730205e612ab72cb1

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.2.3 (2023-01-22)
+
+- Fixed error with precompiled gem on Mac ARM
+- Fixed issue with structs
+
 ## 0.2.2 (2023-01-20)
 
 - Added support for strings to `read_sql` method

data/Cargo.lock

@@ -1367,7 +1367,7 @@ dependencies = [
 
 [[package]]
 name = "polars"
-version = "0.2.2"
+version = "0.2.3"
 dependencies = [
  "ahash",
  "jemallocator",

data/README.md

@@ -56,6 +56,8 @@ From Active Record
 
 ```ruby
 Polars.read_sql(User.all)
+# or
+Polars.read_sql("SELECT * FROM users")
 ```
 
 From a hash
@@ -287,13 +289,13 @@ CSV
 ```ruby
 df.to_csv
 # or
-df.write_csv("data.csv")
+df.write_csv("file.csv")
 ```
 
 Parquet
 
 ```ruby
-df.write_parquet("data.parquet")
+df.write_parquet("file.parquet")
 ```
 
 ## Types

data/ext/polars/Cargo.toml

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

data/ext/polars/src/conversion.rs

@@ -144,7 +144,7 @@ impl From<Wrap<AnyValue<'_>>> for Value {
 
 impl From<Wrap<DataType>> for Value {
     fn from(w: Wrap<DataType>) -> Self {
-        let pl = crate::module();
+        let pl = crate::rb_modules::polars();
 
         match &w.0 {
             DataType::Int8 => pl.const_get::<_, Value>("Int8").unwrap(),
@@ -278,6 +278,22 @@ impl<'s> TryConvert for Wrap<AnyValue<'s>> {
             Ok(AnyValue::Int64(v).into())
         } else if let Ok(v) = ob.try_convert::<f64>() {
             Ok(AnyValue::Float64(v).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();
+            let len = dict.len();
+            let mut keys = Vec::with_capacity(len);
+            let mut vals = Vec::with_capacity(len);
+            dict.foreach(|k: Value, v: Value| {
+                let key = k.try_convert::<String>()?;
+                let val = v.try_convert::<Wrap<AnyValue>>()?.0;
+                let dtype = DataType::from(&val);
+                keys.push(Field::new(&key, dtype));
+                vals.push(val);
+                Ok(ForEach::Continue)
+            })?;
+            Ok(Wrap(AnyValue::StructOwned(Box::new((vals, keys)))))
         } else {
             Err(RbPolarsErr::other(format!(
                 "object type not supported {:?}",
@@ -287,6 +303,141 @@ impl<'s> TryConvert for Wrap<AnyValue<'s>> {
     }
 }
 
+impl<'s> TryConvert for Wrap<Row<'s>> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let mut vals: Vec<Wrap<AnyValue<'s>>> = Vec::new();
+        for item in ob.try_convert::<RArray>()?.each() {
+            vals.push(item?.try_convert::<Wrap<AnyValue<'s>>>()?);
+        }
+        let vals: Vec<AnyValue> = unsafe { std::mem::transmute(vals) };
+        Ok(Wrap(Row(vals)))
+    }
+}
+
+impl TryConvert for Wrap<Schema> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let dict = ob.try_convert::<RHash>()?;
+
+        let mut schema = Vec::new();
+        dict.foreach(|key: String, val: Wrap<DataType>| {
+            schema.push(Field::new(&key, val.0));
+            Ok(ForEach::Continue)
+        })
+        .unwrap();
+
+        Ok(Wrap(schema.into_iter().into()))
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct ObjectValue {
+    pub inner: Value,
+}
+
+impl Hash for ObjectValue {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        let h = self
+            .inner
+            .funcall::<_, _, isize>("hash", ())
+            .expect("should be hashable");
+        state.write_isize(h)
+    }
+}
+
+impl Eq for ObjectValue {}
+
+impl PartialEq for ObjectValue {
+    fn eq(&self, other: &Self) -> bool {
+        self.inner.eql(&other.inner).unwrap_or(false)
+    }
+}
+
+impl Display for ObjectValue {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.inner)
+    }
+}
+
+impl PolarsObject for ObjectValue {
+    fn type_name() -> &'static str {
+        "object"
+    }
+}
+
+impl From<Value> for ObjectValue {
+    fn from(v: Value) -> Self {
+        Self { inner: v }
+    }
+}
+
+impl TryConvert for ObjectValue {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        Ok(ObjectValue { inner: ob })
+    }
+}
+
+impl From<&dyn PolarsObjectSafe> for &ObjectValue {
+    fn from(val: &dyn PolarsObjectSafe) -> Self {
+        unsafe { &*(val as *const dyn PolarsObjectSafe as *const ObjectValue) }
+    }
+}
+
+// TODO remove
+impl ObjectValue {
+    pub fn to_object(&self) -> Value {
+        self.inner
+    }
+}
+
+impl From<ObjectValue> for Value {
+    fn from(val: ObjectValue) -> Self {
+        val.inner
+    }
+}
+
+impl Default for ObjectValue {
+    fn default() -> Self {
+        ObjectValue { inner: *QNIL }
+    }
+}
+
+pub(crate) fn dicts_to_rows(
+    records: &Value,
+    infer_schema_len: usize,
+) -> RbResult<(Vec<Row>, Vec<String>)> {
+    let (dicts, len) = get_rbseq(*records)?;
+
+    let mut key_names = PlIndexSet::new();
+    for d in dicts.each().take(infer_schema_len) {
+        let d = d?;
+        let d = d.try_convert::<RHash>()?;
+
+        d.foreach(|name: String, _value: Value| {
+            key_names.insert(name);
+            Ok(ForEach::Continue)
+        })?;
+    }
+
+    let mut rows = Vec::with_capacity(len);
+
+    for d in dicts.each() {
+        let d = d?;
+        let d = d.try_convert::<RHash>()?;
+
+        let mut row = Vec::with_capacity(key_names.len());
+
+        for k in key_names.iter() {
+            let val = match d.get(k.clone()) {
+                None => AnyValue::Null,
+                Some(val) => val.try_convert::<Wrap<AnyValue>>()?.0,
+            };
+            row.push(val)
+        }
+        rows.push(Row(row))
+    }
+    Ok((rows, key_names.into_iter().collect()))
+}
+
 impl TryConvert for Wrap<AsofStrategy> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let parsed = match ob.try_convert::<String>()?.as_str() {
@@ -641,101 +792,3 @@ pub fn parse_parquet_compression(
     };
     Ok(parsed)
 }
-
-impl<'s> TryConvert for Wrap<Row<'s>> {
-    fn try_convert(ob: Value) -> RbResult<Self> {
-        let mut vals: Vec<Wrap<AnyValue<'s>>> = Vec::new();
-        for item in ob.try_convert::<RArray>()?.each() {
-            vals.push(item?.try_convert::<Wrap<AnyValue<'s>>>()?);
-        }
-        let vals: Vec<AnyValue> = unsafe { std::mem::transmute(vals) };
-        Ok(Wrap(Row(vals)))
-    }
-}
-
-impl TryConvert for Wrap<Schema> {
-    fn try_convert(ob: Value) -> RbResult<Self> {
-        let dict = ob.try_convert::<RHash>()?;
-
-        let mut schema = Vec::new();
-        dict.foreach(|key: String, val: Wrap<DataType>| {
-            schema.push(Field::new(&key, val.0));
-            Ok(ForEach::Continue)
-        })
-        .unwrap();
-
-        Ok(Wrap(schema.into_iter().into()))
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct ObjectValue {
-    pub inner: Value,
-}
-
-impl Hash for ObjectValue {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        let h = self
-            .inner
-            .funcall::<_, _, isize>("hash", ())
-            .expect("should be hashable");
-        state.write_isize(h)
-    }
-}
-
-impl Eq for ObjectValue {}
-
-impl PartialEq for ObjectValue {
-    fn eq(&self, other: &Self) -> bool {
-        self.inner.eql(&other.inner).unwrap_or(false)
-    }
-}
-
-impl Display for ObjectValue {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.inner)
-    }
-}
-
-impl PolarsObject for ObjectValue {
-    fn type_name() -> &'static str {
-        "object"
-    }
-}
-
-impl From<Value> for ObjectValue {
-    fn from(v: Value) -> Self {
-        Self { inner: v }
-    }
-}
-
-impl TryConvert for ObjectValue {
-    fn try_convert(ob: Value) -> RbResult<Self> {
-        Ok(ObjectValue { inner: ob })
-    }
-}
-
-impl From<&dyn PolarsObjectSafe> for &ObjectValue {
-    fn from(val: &dyn PolarsObjectSafe) -> Self {
-        unsafe { &*(val as *const dyn PolarsObjectSafe as *const ObjectValue) }
-    }
-}
-
-// TODO remove
-impl ObjectValue {
-    pub fn to_object(&self) -> Value {
-        self.inner
-    }
-}
-
-impl From<ObjectValue> for Value {
-    fn from(val: ObjectValue) -> Self {
-        val.inner
-    }
-}
-
-impl Default for ObjectValue {
-    fn default() -> Self {
-        ObjectValue { inner: *QNIL }
-    }
-}

data/ext/polars/src/dataframe.rs

@@ -1,4 +1,5 @@
 use magnus::{r_hash::ForEach, RArray, RHash, RString, Value};
+use polars::frame::row::{rows_to_schema_supertypes, Row};
 use polars::frame::NullStrategy;
 use polars::io::avro::AvroCompression;
 use polars::io::mmap::ReaderBytes;
@@ -15,8 +16,9 @@ use crate::apply::dataframe::{
 };
 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::{series, RbExpr, RbLazyFrame, RbPolarsErr, RbResult, RbSeries};
+use crate::{RbExpr, RbLazyFrame, RbPolarsErr, RbResult, RbSeries};
 
 #[magnus::wrap(class = "Polars::RbDataFrame")]
 pub struct RbDataFrame {
@@ -36,6 +38,45 @@ impl RbDataFrame {
         }
     }
 
+    fn finish_from_rows(
+        rows: Vec<Row>,
+        infer_schema_length: Option<usize>,
+        schema_overwrite: Option<Schema>,
+    ) -> RbResult<Self> {
+        // object builder must be registered.
+        crate::object::register_object_builder();
+
+        let schema =
+            rows_to_schema_supertypes(&rows, infer_schema_length).map_err(RbPolarsErr::from)?;
+        // replace inferred nulls with boolean
+        let fields = schema.iter_fields().map(|mut fld| match fld.data_type() {
+            DataType::Null => {
+                fld.coerce(DataType::Boolean);
+                fld
+            }
+            _ => fld,
+        });
+        let mut schema = Schema::from(fields);
+
+        if let Some(schema_overwrite) = schema_overwrite {
+            for (i, (name, dtype)) in schema_overwrite.into_iter().enumerate() {
+                if let Some((name_, dtype_)) = schema.get_index_mut(i) {
+                    *name_ = name;
+
+                    // if user sets dtype unknown, we use the inferred datatype
+                    if !matches!(dtype, DataType::Unknown) {
+                        *dtype_ = dtype;
+                    }
+                } else {
+                    schema.with_column(name, dtype)
+                }
+            }
+        }
+
+        let df = DataFrame::from_rows_and_schema(&rows, &schema).map_err(RbPolarsErr::from)?;
+        Ok(df.into())
+    }
+
     pub fn init(columns: RArray) -> RbResult<Self> {
         let mut cols = Vec::new();
         for i in columns.each() {
@@ -288,17 +329,45 @@ impl RbDataFrame {
     }
 
     pub fn read_hashes(
-        _dicts: Value,
-        _infer_schema_length: Option<usize>,
-        _schema_overwrite: Option<Wrap<Schema>>,
+        dicts: Value,
+        infer_schema_length: Option<usize>,
+        schema_overwrite: Option<Wrap<Schema>>,
     ) -> RbResult<Self> {
-        Err(RbPolarsErr::todo())
+        let (rows, mut names) = dicts_to_rows(&dicts, infer_schema_length.unwrap_or(50))?;
+
+        // ensure the new names are used
+        if let Some(schema) = &schema_overwrite {
+            for (new_name, name) in schema.0.iter_names().zip(names.iter_mut()) {
+                *name = new_name.clone();
+            }
+        }
+        let rbdf = Self::finish_from_rows(
+            rows,
+            infer_schema_length,
+            schema_overwrite.map(|wrap| wrap.0),
+        )?;
+
+        rbdf.df
+            .borrow_mut()
+            .get_columns_mut()
+            .iter_mut()
+            .zip(&names)
+            .for_each(|(s, name)| {
+                s.rename(name);
+            });
+        let length = names.len();
+        if names.into_iter().collect::<PlHashSet<_>>().len() != length {
+            let err = PolarsError::SchemaMisMatch("duplicate column names found".into());
+            Err(RbPolarsErr::from(err))?;
+        }
+
+        Ok(rbdf)
     }
 
     pub fn read_hash(data: RHash) -> RbResult<Self> {
         let mut cols: Vec<Series> = Vec::new();
         data.foreach(|name: String, values: Value| {
-            let obj: Value = series().funcall("new", (name, values))?;
+            let obj: Value = rb_modules::series().funcall("new", (name, values))?;
             let rbseries = obj.funcall::<_, _, &RbSeries>("_s", ())?;
             cols.push(rbseries.series.borrow().clone());
             Ok(ForEach::Continue)

data/ext/polars/src/lib.rs

@@ -6,6 +6,9 @@ mod error;
 mod file;
 mod lazy;
 mod list_construction;
+mod object;
+mod prelude;
+pub(crate) mod rb_modules;
 mod series;
 mod set;
 mod utils;
@@ -18,15 +21,13 @@ 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::{
-    define_module, function, memoize, method, prelude::*, Error, RArray, RClass, RHash, RModule,
-    Value,
-};
+use magnus::{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")]
@@ -45,17 +46,9 @@ static GLOBAL: MiMalloc = MiMalloc;
 
 type RbResult<T> = Result<T, Error>;
 
-fn module() -> RModule {
-    *memoize!(RModule: define_module("Polars").unwrap())
-}
-
-fn series() -> RClass {
-    *memoize!(RClass: module().define_class("Series", Default::default()).unwrap())
-}
-
 #[magnus::init]
 fn init() -> RbResult<()> {
-    let module = module();
+    let 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/object.rs

@@ -0,0 +1,30 @@
+use std::any::Any;
+use std::sync::Arc;
+
+use polars_core::chunked_array::object::builder::ObjectChunkedBuilder;
+use polars_core::chunked_array::object::registry;
+use polars_core::chunked_array::object::registry::AnonymousObjectBuilder;
+use polars_core::prelude::AnyValue;
+
+use crate::prelude::ObjectValue;
+use crate::Wrap;
+
+// pub(crate) const OBJECT_NAME: &str = "object";
+
+pub(crate) fn register_object_builder() {
+    if !registry::is_object_builder_registered() {
+        let object_builder = Box::new(|name: &str, capacity: usize| {
+            Box::new(ObjectChunkedBuilder::<ObjectValue>::new(name, capacity))
+                as Box<dyn AnonymousObjectBuilder>
+        });
+
+        let object_converter = Arc::new(|av: AnyValue| {
+            let object = ObjectValue {
+                inner: Wrap(av).into(),
+            };
+            Box::new(object) as Box<dyn Any>
+        });
+
+        registry::register_object_builder(object_builder, object_converter)
+    }
+}

data/ext/polars/src/prelude.rs

@@ -0,0 +1,3 @@
+pub use polars::prelude::*;
+
+pub use crate::conversion::*;

data/ext/polars/src/rb_modules.rs

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

data/lib/polars/data_frame.rb

@@ -4746,7 +4746,14 @@ module Polars
     end
 
     # @private
-    def self._unpack_columns(columns, lookup_names: nil, n_expected: nil)
+    def self.include_unknowns(schema, cols)
+      cols.to_h { |col| [col, schema.fetch(col, Unknown)] }
+    end
+
+    # @private
+    def self._unpack_columns(columns, schema_overrides: nil, lookup_names: nil, n_expected: nil)
+      raise Todo if schema_overrides
+
       if columns.is_a?(Hash)
         columns = columns.to_a
       end
@@ -4790,8 +4797,48 @@ module Polars
       end
     end
 
+    def self._post_apply_columns(rbdf, columns, structs: nil, schema_overrides: nil)
+      rbdf_columns = rbdf.columns
+      rbdf_dtypes = rbdf.dtypes
+      columns, dtypes = _unpack_columns(
+        (columns || rbdf_columns), schema_overrides: schema_overrides
+      )
+      column_subset = []
+      if columns != rbdf_columns
+        if columns.length < rbdf_columns.length && columns == rbdf_columns.first(columns.length)
+          column_subset = columns
+        else
+          rbdf.set_column_names(columns)
+        end
+      end
+
+      column_casts = []
+      columns.each do |col, i|
+        if dtypes[col] == Categorical # != rbdf_dtypes[i]
+          column_casts << Polars.col(col).cast(Categorical)._rbexpr
+        elsif structs.any? && structs.include?(col) && structs[col] != rbdf_dtypes[i]
+          column_casts << Polars.col(col).cast(structs[col])._rbexpr
+        elsif dtypes.include?(col) && dtypes[col] != rbdf_dtypes[i]
+          column_casts << Polars.col(col).cast(dtypes[col])._rbexpr
+        end
+      end
+
+      if column_casts.any? || column_subset.any?
+        rbdf = rbdf.lazy
+        if column_casts.any?
+          rbdf = rbdf.with_columns(column_casts)
+        end
+        if column_subset.any?
+          rbdf = rbdf.select(column_subset.map { |col| Polars.col(col)._rbexpr })
+        end
+        rbdf = rbdf.collect
+      end
+
+      rbdf
+    end
+
     # @private
-    def self.sequence_to_rbdf(data, columns: nil, orient: nil)
+    def self.sequence_to_rbdf(data, columns: nil, orient: nil, infer_schema_length: 50)
       if data.length == 0
         return hash_to_rbdf({}, columns: columns)
       end
@@ -4803,6 +4850,14 @@ module Polars
         data.each do |s|
           data_series << s._s
         end
+      elsif data[0].is_a?(Hash)
+        column_names, dtypes = _unpack_columns(columns)
+        schema_overrides = dtypes ? include_unknowns(dtypes, column_names) : nil
+        rbdf = RbDataFrame.read_hashes(data, infer_schema_length, schema_overrides)
+        if column_names
+          rbdf = _post_apply_columns(rbdf, column_names)
+        end
+        return rbdf
       elsif data[0].is_a?(Array)
         if orient.nil? && !columns.nil?
           orient = columns.length == data.length ? "col" : "row"

data/lib/polars/data_types.rb

@@ -3,44 +3,64 @@ module Polars
   class DataType
   end
 
+  # Base class for numeric data types.
+  class NumericType < DataType
+  end
+
+  # Base class for integral data types.
+  class IntegralType < NumericType
+  end
+
+  # Base class for fractional data types.
+  class FractionalType < NumericType
+  end
+
+  # Base class for temporal data types.
+  class TemporalType < DataType
+  end
+
+  # Base class for nested data types.
+  class NestedType < DataType
+  end
+
   # 8-bit signed integer type.
-  class Int8 < DataType
+  class Int8 < IntegralType
   end
 
   # 16-bit signed integer type.
-  class Int16 < DataType
+  class Int16 < IntegralType
   end
 
   # 32-bit signed integer type.
-  class Int32 < DataType
+  class Int32 < IntegralType
   end
 
   # 64-bit signed integer type.
-  class Int64 < DataType
+  class Int64 < IntegralType
   end
 
   # 8-bit unsigned integer type.
-  class UInt8 < DataType
+  class UInt8 < IntegralType
   end
 
   # 16-bit unsigned integer type.
-  class UInt16 < DataType
+  class UInt16 < IntegralType
   end
 
   # 32-bit unsigned integer type.
-  class UInt32 < DataType
+  class UInt32 < IntegralType
   end
 
   # 64-bit unsigned integer type.
-  class UInt64 < DataType
+  class UInt64 < IntegralType
   end
 
   # 32-bit floating point type.
-  class Float32 < DataType
+  class Float32 < FractionalType
   end
 
   # 64-bit floating point type.
-  class Float64 < DataType
+  class Float64 < FractionalType
   end
 
   # Boolean type.
@@ -51,31 +71,19 @@ module Polars
   class Utf8 < DataType
   end
 
-  # Binary type.
-  class Binary < DataType
-  end
-
-  # Type representing Null / None values.
-  class Null < DataType
-  end
-
-  # Type representing Datatype values that could not be determined statically.
-  class Unknown < DataType
-  end
-
   # Nested list/array type.
-  class List < DataType
+  class List < NestedType
     def initialize(inner)
       @inner = Utils.rb_type_to_dtype(inner)
     end
   end
 
   # Calendar date type.
-  class Date < DataType
+  class Date < TemporalType
   end
 
   # Calendar date and time type.
-  class Datetime < DataType
+  class Datetime < TemporalType
     def initialize(time_unit = "us", time_zone = nil)
       @tu = time_unit || "us"
       @time_zone = time_zone
@@ -83,14 +91,14 @@ module Polars
   end
 
   # Time duration/delta type.
-  class Duration < DataType
+  class Duration < TemporalType
     def initialize(time_unit = "us")
       @tu = time_unit
     end
   end
 
   # Time of day type.
-  class Time < DataType
+  class Time < TemporalType
   end
 
   # Type for wrapping arbitrary Ruby objects.
@@ -102,15 +110,24 @@ module Polars
   end
 
   # Definition of a single field within a `Struct` DataType.
-  class Field < DataType
+  class Field
+    attr_reader :name, :dtype
+
     def initialize(name, dtype)
       @name = name
       @dtype = Utils.rb_type_to_dtype(dtype)
     end
+
+    def inspect
+      class_name = self.class.name
+      "#{class_name}(#{@name}: #{@dtype})"
+    end
   end
 
   # Struct composite type.
-  class Struct < DataType
+  class Struct < NestedType
+    attr_reader :fields
+
     def initialize(fields)
       if fields.is_a?(Hash)
         @fields = fields.map { |n, d| Field.new(n, d) }
@@ -118,5 +135,26 @@ module Polars
         @fields = fields
       end
     end
+
+    def inspect
+      class_name = self.class.name
+      "#{class_name}(#{@fields})"
+    end
+
+    def to_schema
+      @fields.to_h { |f| [f.name, f.dtype] }
+    end
+  end
+
+  # Binary type.
+  class Binary < DataType
+  end
+
+  # Type representing Null / None values.
+  class Null < DataType
+  end
+
+  # Type representing Datatype values that could not be determined statically.
+  class Unknown < DataType
   end
 end

data/lib/polars/series.rb

@@ -3667,6 +3667,11 @@ module Polars
       rb_temporal_types << ::Time if defined?(::Time)
 
       value = _get_first_non_none(values)
+      if !value.nil?
+        if value.is_a?(Hash)
+          return DataFrame.new(values).to_struct(name)._s
+        end
+      end
 
       if !dtype.nil? && Utils.is_polars_dtype(dtype) && ruby_dtype.nil?
         constructor = polars_type_to_constructor(dtype)

data/lib/polars/utils.rb

@@ -160,11 +160,11 @@ module Polars
 
     def self.scale_bytes(sz, to:)
       scaling_factor = {
-          "b" => 1,
-          "k" => 1024,
-          "m" => 1024 ** 2,
-          "g" => 1024 ** 3,
-          "t" => 1024 ** 4,
+        "b" => 1,
+        "k" => 1024,
+        "m" => 1024 ** 2,
+        "g" => 1024 ** 3,
+        "t" => 1024 ** 4
       }[to[0]]
       if scaling_factor > 1
         sz / scaling_factor.to_f

data/lib/polars/version.rb

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

data/lib/polars-df.rb

@@ -1 +1 @@
-require "polars"
+require_relative "polars"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polars-df
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-21 00:00:00.000000000 Z
+date: 2023-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -55,6 +55,9 @@ files:
 - ext/polars/src/lazy/utils.rs
 - ext/polars/src/lib.rs
 - ext/polars/src/list_construction.rs
+- ext/polars/src/object.rs
+- ext/polars/src/prelude.rs
+- ext/polars/src/rb_modules.rs
 - ext/polars/src/series.rs
 - ext/polars/src/set.rs
 - ext/polars/src/utils.rs