polars-df 0.2.1-x86_64-darwin → 0.2.3-x86_64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee93a61f42e0acf492693c5516582437239b66b29a411d49a61e43ee2c640bf0
-  data.tar.gz: e79a6954afbf9e66bb1b73410abdc750fd5ee7bdca289ae7aa31607608c120f1
+  metadata.gz: a67aba6106276247072fe14bcd35b3381e890844ea50321c443cbcc815b84ca3
+  data.tar.gz: c5c3388ed010e8946903b7d8ed30fc24ddbf2a34b9eba23d1c178b476faebc7a
 SHA512:
-  metadata.gz: 6679b43359387e0f6688c3d96337ffb7408e58296f16524708748feb4c57ff396b439d3a24a79f0c913dd252f920fb3f42be1bc5a0be364ee6aa66c094107ccf
-  data.tar.gz: 80f69ce23c42d4dd3345bd8364f689af571284ba95770d32be4760a99a9b0eb7cb7b21892c326321c0db33b6bffc57e4a19c989b8044878ef7e42aeffe3d7f68
+  metadata.gz: 1343d81460555ed4baa13962ff7316814b64e3c7c6c363c6d3d7b01221bd83abd9ad62b9bd8dffb4bd7dbb30716bae5d5fc20d7830e157631767ac186638bd24
+  data.tar.gz: f02495aea654767675444e57ea764cb44e5e34123049cdf541c3b2b47df9d7ddc1dd9bb0499ddda6ee360e3983b0184f35bc6e5fcc28f93e49af3476960770eb

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 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
+- Improved indexing
+- Fixed error with precompiled gem on Mac ARM
+
 ## 0.2.1 (2023-01-18)
 
 - Added `read_sql` method

data/Cargo.lock

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

data/LICENSE-THIRD-PARTY.txt

@@ -1640,6 +1640,33 @@ OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
 IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 DEALINGS IN THE SOFTWARE.
 
+================================================================================
+array-init-cursor LICENSE-MIT
+================================================================================
+
+MIT License
+
+Copyright (c) 2021 The Planus Project Developers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
 ================================================================================
 array-init-cursor LICENSE-APACHE
 ================================================================================
@@ -1822,33 +1849,6 @@ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 END OF TERMS AND CONDITIONS
 
 
-================================================================================
-array-init-cursor LICENSE-MIT
-================================================================================
-
-MIT License
-
-Copyright (c) 2021 The Planus Project Developers
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
-
 ================================================================================
 arrow-format LICENSE
 ================================================================================
@@ -27103,6 +27103,33 @@ OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
 IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 DEALINGS IN THE SOFTWARE.
 
+================================================================================
+planus LICENSE-MIT
+================================================================================
+
+MIT License
+
+Copyright (c) 2021 The Planus Project Developers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
 ================================================================================
 planus LICENSE-APACHE
 ================================================================================
@@ -27285,33 +27312,6 @@ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 END OF TERMS AND CONDITIONS
 
 
-================================================================================
-planus LICENSE-MIT
-================================================================================
-
-MIT License
-
-Copyright (c) 2021 The Planus Project Developers
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
-
 ================================================================================
 polars LICENSE
 ================================================================================
@@ -30064,6 +30064,32 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 
+================================================================================
+rb-sys-env LICENSE-MIT
+================================================================================
+
+The MIT License (MIT)
+
+Copyright (c) 2021-2022 Ian Ker-Seymer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
 ================================================================================
 rb-sys-env LICENSE-APACHE
 ================================================================================
@@ -30259,32 +30285,6 @@ rb-sys-env LICENSE-APACHE
    See the License for the specific language governing permissions and
    limitations under the License.
 
-================================================================================
-rb-sys-env LICENSE-MIT
-================================================================================
-
-The MIT License (MIT)
-
-Copyright (c) 2021-2022 Ian Ker-Seymer
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
 ================================================================================
 regex LICENSE-APACHE
 ================================================================================

data/README.md

@@ -41,6 +41,9 @@ From a CSV
 
 ```ruby
 Polars.read_csv("file.csv")
+
+# or lazily with
+Polars.scan_csv("file.csv")
 ```
 
 From Parquet
@@ -53,6 +56,8 @@ From Active Record
 
 ```ruby
 Polars.read_sql(User.all)
+# or
+Polars.read_sql("SELECT * FROM users")
 ```
 
 From a hash
@@ -135,9 +140,9 @@ df[Polars.col("a") <= 2]
 And, or, and exclusive or
 
 ```ruby
-df[(Polars.col("a") > 100) & (Polars.col("b") == "one")] # and
-df[(Polars.col("a") > 100) | (Polars.col("b") == "one")] # or
-df[(Polars.col("a") > 100) ^ (Polars.col("b") == "one")] # xor
+df[(Polars.col("a") > 1) & (Polars.col("b") == "two")] # and
+df[(Polars.col("a") > 1) | (Polars.col("b") == "two")] # or
+df[(Polars.col("a") > 1) ^ (Polars.col("b") == "two")] # xor
 ```
 
 ## Operations
@@ -284,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/lib/polars/data_frame.rb

@@ -277,6 +277,7 @@ module Polars
       _df.height
     end
     alias_method :count, :height
+    alias_method :length, :height
 
     # Get the width of the DataFrame.
     #
@@ -541,7 +542,7 @@ module Polars
 
         if col_selection.is_a?(Array)
           # df[.., [1, 2]]
-          if is_int_sequence(col_selection)
+          if Utils.is_int_sequence(col_selection)
             series_list = col_selection.map { |i| to_series(i) }
             df = self.class.new(series_list)
             return df[row_selection]
@@ -574,6 +575,23 @@ module Polars
           # df[["foo", "bar"]]
           return _from_rbdf(_df.select(item))
         end
+
+        if Utils.is_int_sequence(item)
+          item = Series.new("", item)
+        end
+
+        if item.is_a?(Series)
+          dtype = item.dtype
+          if dtype == Utf8
+            return _from_rbdf(_df.select(item))
+          elsif dtype == UInt32
+            return _from_rbdf(_df.take_with_series(item._s))
+          elsif [UInt8, UInt16, UInt64, Int8, Int16, Int32, Int64].include?(dtype)
+            return _from_rbdf(
+              _df.take_with_series(_pos_idxs(item, 0)._s)
+            )
+          end
+        end
       end
 
       # Ruby-specific
@@ -4662,8 +4680,53 @@ module Polars
       end
     end
 
-    # def _pos_idxs
-    # end
+    def _pos_idxs(idxs, dim)
+      idx_type = Polars._get_idx_type
+
+      if idxs.is_a?(Series)
+        if idxs.dtype == idx_type
+          return idxs
+        end
+        if [UInt8, UInt16, idx_type == UInt32 ? UInt64 : UInt32, Int8, Int16, Int32, Int64].include?(idxs.dtype)
+          if idx_type == UInt32
+            if [Int64, UInt64].include?(idxs.dtype)
+              if idxs.max >= 2**32
+                raise ArgumentError, "Index positions should be smaller than 2^32."
+              end
+            end
+            if idxs.dtype == Int64
+              if idxs.min < -(2**32)
+                raise ArgumentError, "Index positions should be bigger than -2^32 + 1."
+              end
+            end
+          end
+          if [Int8, Int16, Int32, Int64].include?(idxs.dtype)
+            if idxs.min < 0
+              if idx_type == UInt32
+                if [Int8, Int16].include?(idxs.dtype)
+                  idxs = idxs.cast(Int32)
+                end
+              else
+                if [Int8, Int16, Int32].include?(idxs.dtype)
+                  idxs = idxs.cast(Int64)
+                end
+              end
+
+              idxs =
+                Polars.select(
+                  Polars.when(Polars.lit(idxs) < 0)
+                    .then(shape[dim] + Polars.lit(idxs))
+                    .otherwise(Polars.lit(idxs))
+                ).to_series
+            end
+          end
+
+          return idxs.cast(idx_type)
+        end
+      end
+
+      raise ArgumentError, "Unsupported idxs datatype."
+    end
 
     # @private
     def self.hash_to_rbdf(data, columns: nil)
@@ -4683,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
@@ -4727,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
@@ -4740,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/io.rb

@@ -606,8 +606,10 @@ module Polars
           sql
         elsif sql.is_a?(ActiveRecord::Relation)
           sql.connection.select_all(sql.to_sql)
+        elsif sql.is_a?(String)
+          ActiveRecord::Base.connection.select_all(sql)
         else
-          raise ArgumentError, "Expected ActiveRecord::Relation or ActiveRecord::Result"
+          raise ArgumentError, "Expected ActiveRecord::Relation, ActiveRecord::Result, or String"
         end
       data = {}
       result.columns.each_with_index do |k, i|

data/lib/polars/series.rb

@@ -263,6 +263,10 @@ module Polars
     #
     # @return [Object]
     def [](item)
+      if item.is_a?(Series) && [UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64].include?(item.dtype)
+        return Utils.wrap_s(_s.take_with_series(_pos_idxs(item)._s))
+      end
+
       if item.is_a?(Integer)
         return _s.get_idx(item)
       end
@@ -271,6 +275,10 @@ module Polars
         return Slice.new(self).apply(item)
       end
 
+      if Utils.is_int_sequence(item)
+        return Utils.wrap_s(_s.take_with_series(_pos_idxs(Series.new("", item))._s))
+      end
+
       raise ArgumentError, "Cannot get item of type: #{item.class.name}"
     end
 
@@ -287,24 +295,23 @@ module Polars
       end
 
       if key.is_a?(Series)
-        if key.dtype == :bool
+        if key.dtype == Boolean
           self._s = set(key, value)._s
-        elsif key.dtype == :u64
-          self._s = set_at_idx(key.cast(:u32), value)._s
-        elsif key.dtype == :u32
+        elsif key.dtype == UInt64
+          self._s = set_at_idx(key.cast(UInt32), value)._s
+        elsif key.dtype == UInt32
           self._s = set_at_idx(key, value)._s
         else
           raise Todo
         end
-      end
-
-      if key.is_a?(Array)
-        s = Utils.wrap_s(sequence_to_rbseries("", key, dtype: :u32))
+      elsif key.is_a?(Array)
+        s = Utils.wrap_s(sequence_to_rbseries("", key, dtype: UInt32))
+        self[s] = value
+      elsif key.is_a?(Range)
+        s = Series.new("", key, dtype: UInt32)
         self[s] = value
       elsif key.is_a?(Integer)
-        # TODO fix
-        # self[[key]] = value
-        set_at_idx(key, value)
+        self[[key]] = value
       else
         raise ArgumentError, "cannot use #{key} for indexing"
       end
@@ -3527,6 +3534,59 @@ module Polars
       end
     end
 
+    def _pos_idxs(idxs)
+      idx_type = Polars._get_idx_type
+
+      if idxs.is_a?(Series)
+        if idxs.dtype == idx_type
+          return idxs
+        end
+        if [UInt8, UInt16, idx_type == UInt32 ? UInt64 : UInt32, Int8, Int16, Int32, Int64].include?(idxs.dtype)
+          if idx_type == UInt32
+            if [Int64, UInt64].include?(idxs.dtype)
+              if idxs.max >= 2**32
+                raise ArgumentError, "Index positions should be smaller than 2^32."
+              end
+            end
+            if idxs.dtype == Int64
+              if idxs.min < -(2**32)
+                raise ArgumentError, "Index positions should be bigger than -2^32 + 1."
+              end
+            end
+          end
+          if [Int8, Int16, Int32, Int64].include?(idxs.dtype)
+            if idxs.min < 0
+              if idx_type == UInt32
+                if [Int8, Int16].include?(idxs.dtype)
+                  idxs = idxs.cast(Int32)
+                end
+              else
+                if [Int8, Int16, Int32].include?(idxs.dtype)
+                  idxs = idxs.cast(Int64)
+                end
+              end
+
+              # Update negative indexes to absolute indexes.
+              return (
+                idxs.to_frame
+                .select(
+                  Polars.when(Polars.col(idxs.name) < 0)
+                    .then(len + Polars.col(idxs.name))
+                    .otherwise(Polars.col(idxs.name))
+                    .cast(idx_type)
+                )
+                .to_series(0)
+              )
+            end
+          end
+
+          return idxs.cast(idx_type)
+        end
+      end
+
+      raise ArgumentError, "Unsupported idxs datatype."
+    end
+
     def _comp(other, op)
       if other.is_a?(Series)
         return Utils.wrap_s(_s.send(op, other._s))
@@ -3607,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/slice.rb

@@ -56,7 +56,7 @@ module Polars
     # Normalize slice bounds, identify unbounded and/or zero-length slices.
     def _slice_setup(s)
       # can normalize slice indices as we know object size
-      obj_len = @obj.len
+      obj_len = @obj.length
       start = if s.begin
         if s.begin < 0
           [s.begin + obj_len, 0].max

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
@@ -181,6 +181,26 @@ module Polars
       val.all? { |x| x.is_a?(eltype) }
     end
 
+    def self.is_bool_sequence(val)
+      val.is_a?(Array) && val.all? { |x| x == true || x == false }
+    end
+
+    def self.is_dtype_sequence(val)
+      val.is_a?(Array) && val.all? { |x| is_polars_dtype(x) }
+    end
+
+    def self.is_int_sequence(val)
+      val.is_a?(Array) && _is_iterable_of(val, Integer)
+    end
+
+    def self.is_expr_sequence(val)
+      val.is_a?(Array) && _is_iterable_of(val, Expr)
+    end
+
+    def self.is_rbexpr_sequence(val)
+      val.is_a?(Array) && _is_iterable_of(val, RbExpr)
+    end
+
     def self.is_str_sequence(val, allow_str: false)
       if allow_str == false && val.is_a?(String)
         false

data/lib/polars/version.rb

@@ -1,4 +1,4 @@
 module Polars
   # @private
-  VERSION = "0.2.1"
+  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.1
+  version: 0.2.3
 platform: x86_64-darwin
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-18 00:00:00.000000000 Z
+date: 2023-01-22 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: andrew@ankane.org
@@ -82,7 +82,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.3
+rubygems_version: 3.4.4
 signing_key: 
 specification_version: 4
 summary: Blazingly fast DataFrames for Ruby