polars-df 0.2.0-arm64-darwin → 0.2.2-arm64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0f6637d79970b4107c0c67e57d34a12ce12a59044a790d1df8401d66d93d6bb
-  data.tar.gz: 681510a7b5b2b0fc62ae441b1208bff040b752dd901d2552834790debeb54dc4
+  metadata.gz: 150683cf56be275cc1402ec229d5fd1c1ba0831bc08e0f6e22265e987ae8b5c7
+  data.tar.gz: 6cd2016e5ea8b09bb9812132a176c23970c5e1b205b12c7d0c94648b54f36879
 SHA512:
-  metadata.gz: c2cdcd59fb0998d0d4422a3b72e602485be29dbca26fca862629aa382aa908a6bd415d31c5b72262cc5d2856d65ecf95a08696542a83c2e2c17db08e83e5b5a8
-  data.tar.gz: e883089dd37a2616740577355a11cfba8ebad332345ea68a91a1d6f6b803538eaf103c161869344acedc1c02b874c2d41c4bc6c5aec7155362ebffff51735059
+  metadata.gz: 2d47f4040eb157a13fbc59bfbcfce3c7e4eea6eb944a7b1194564a6623af06fd99d7d4adcf3db867e962cb313208834107e05458cfac744ef2b76b28b71b2749
+  data.tar.gz: 11583170cab8559577cfff9be52466a4adddffe69c740b36604f2445d31ca0fea00535e05845d0a956de3c2012a99862d7f70d22177e6202a5a4e2d283377b56

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 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
+- Added `to_csv` method
+- Added support for symbol keys
+
 ## 0.2.0 (2023-01-14)
 
 - Updated Polars to 0.26.1

data/Cargo.lock

@@ -1367,7 +1367,7 @@ dependencies = [
 
 [[package]]
 name = "polars"
-version = "0.2.0"
+version = "0.2.2"
 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

@@ -25,7 +25,13 @@ Polars.read_csv("iris.csv")
   .collect
 ```
 
-You can follow [Polars tutorials](https://pola-rs.github.io/polars-book/user-guide/introduction.html) and convert the code to Ruby in many cases. Feel free to open an issue if you run into problems. Some methods are missing at the moment.
+You can follow [Polars tutorials](https://pola-rs.github.io/polars-book/user-guide/introduction.html) and convert the code to Ruby in many cases. Feel free to open an issue if you run into problems.
+
+## Reference
+
+- [Series](https://www.rubydoc.info/gems/polars-df/Polars/Series)
+- [DataFrame](https://www.rubydoc.info/gems/polars-df/Polars/DataFrame)
+- [LazyFrame](https://www.rubydoc.info/gems/polars-df/Polars/LazyFrame)
 
 ## Examples
 
@@ -35,6 +41,9 @@ From a CSV
 
 ```ruby
 Polars.read_csv("file.csv")
+
+# or lazily with
+Polars.scan_csv("file.csv")
 ```
 
 From Parquet
@@ -46,7 +55,7 @@ Polars.read_parquet("file.parquet")
 From Active Record
 
 ```ruby
-Polars::DataFrame.new(User.all)
+Polars.read_sql(User.all)
 ```
 
 From a hash
@@ -67,6 +76,261 @@ Polars::DataFrame.new([
 ])
 ```
 
+## Attributes
+
+Get number of rows
+
+```ruby
+df.height
+```
+
+Get column names
+
+```ruby
+df.columns
+```
+
+Check if a column exists
+
+```ruby
+df.include?(name)
+```
+
+## Selecting Data
+
+Select a column
+
+```ruby
+df["a"]
+```
+
+Select multiple columns
+
+```ruby
+df[["a", "b"]]
+```
+
+Select first rows
+
+```ruby
+df.head
+```
+
+Select last rows
+
+```ruby
+df.tail
+```
+
+## Filtering
+
+Filter on a condition
+
+```ruby
+df[Polars.col("a") == 2]
+df[Polars.col("a") != 2]
+df[Polars.col("a") > 2]
+df[Polars.col("a") >= 2]
+df[Polars.col("a") < 2]
+df[Polars.col("a") <= 2]
+```
+
+And, or, and exclusive or
+
+```ruby
+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
+
+Basic operations
+
+```ruby
+df["a"] + 5
+df["a"] - 5
+df["a"] * 5
+df["a"] / 5
+df["a"] % 5
+df["a"] ** 2
+df["a"].sqrt
+df["a"].abs
+```
+
+Rounding
+
+```ruby
+df["a"].round(2)
+df["a"].ceil
+df["a"].floor
+```
+
+Logarithm
+
+```ruby
+df["a"].log # natural log
+df["a"].log(10)
+```
+
+Exponentiation
+
+```ruby
+df["a"].exp
+```
+
+Trigonometric functions
+
+```ruby
+df["a"].sin
+df["a"].cos
+df["a"].tan
+df["a"].asin
+df["a"].acos
+df["a"].atan
+```
+
+Hyperbolic functions
+
+```ruby
+df["a"].sinh
+df["a"].cosh
+df["a"].tanh
+df["a"].asinh
+df["a"].acosh
+df["a"].atanh
+```
+
+Summary statistics
+
+```ruby
+df["a"].sum
+df["a"].mean
+df["a"].median
+df["a"].quantile(0.90)
+df["a"].min
+df["a"].max
+df["a"].std
+df["a"].var
+```
+
+## Grouping
+
+Group
+
+```ruby
+df.groupby("a").count
+```
+
+Works with all summary statistics
+
+```ruby
+df.groupby("a").max
+```
+
+Multiple groups
+
+```ruby
+df.groupby(["a", "b"]).count
+```
+
+## Combining Data Frames
+
+Add rows
+
+```ruby
+df.vstack(other_df)
+```
+
+Add columns
+
+```ruby
+df.hstack(other_df)
+```
+
+Inner join
+
+```ruby
+df.join(other_df, on: "a")
+```
+
+Left join
+
+```ruby
+df.join(other_df, on: "a", how: "left")
+```
+
+## Encoding
+
+One-hot encoding
+
+```ruby
+df.to_dummies
+```
+
+## Conversion
+
+Array of rows
+
+```ruby
+df.rows
+```
+
+Hash of series
+
+```ruby
+df.to_h
+```
+
+CSV
+
+```ruby
+df.to_csv
+# or
+df.write_csv("data.csv")
+```
+
+Parquet
+
+```ruby
+df.write_parquet("data.parquet")
+```
+
+## Types
+
+You can specify column types when creating a data frame
+
+```ruby
+Polars::DataFrame.new(data, columns: {"a" => Polars::Int32, "b" => Polars::Float32})
+```
+
+Supported types are:
+
+- boolean - `Boolean`
+- float - `Float64`, `Float32`
+- integer - `Int64`, `Int32`, `Int16`, `Int8`
+- unsigned integer - `UInt64`, `UInt32`, `UInt16`, `UInt8`
+- string - `Utf8`, `Categorical`
+- temporal - `Date`, `Datetime`, `Time`, `Duration`
+
+Get column types
+
+```ruby
+df.schema
+```
+
+For a specific column
+
+```ruby
+df["a"].dtype
+```
+
+Cast a column
+
+```ruby
+df["a"].cast(Polars::Int32)
+```
+
 ## History
 
 View the [changelog](CHANGELOG.md)

data/lib/polars/data_frame.rb

@@ -17,6 +17,7 @@ module Polars
     #   the orientation is inferred by matching the columns and data dimensions. If
     #   this does not yield conclusive results, column orientation is used.
     def initialize(data = nil, columns: nil, orient: nil)
+      # TODO deprecate in favor of read_sql
       if defined?(ActiveRecord) && (data.is_a?(ActiveRecord::Relation) || data.is_a?(ActiveRecord::Result))
         result = data.is_a?(ActiveRecord::Result) ? data : data.connection.select_all(data.to_sql)
         data = {}
@@ -275,6 +276,8 @@ module Polars
     def height
       _df.height
     end
+    alias_method :count, :height
+    alias_method :length, :height
 
     # Get the width of the DataFrame.
     #
@@ -521,13 +524,13 @@ module Polars
             return df.slice(row_selection, 1)
           end
           # df[2, "a"]
-          if col_selection.is_a?(String)
+          if col_selection.is_a?(String) || col_selection.is_a?(Symbol)
             return self[col_selection][row_selection]
           end
         end
 
         # column selection can be "a" and ["a", "b"]
-        if col_selection.is_a?(String)
+        if col_selection.is_a?(String) || col_selection.is_a?(Symbol)
           col_selection = [col_selection]
         end
 
@@ -539,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]
@@ -553,8 +556,8 @@ module Polars
 
         # select single column
         # df["foo"]
-        if item.is_a?(String)
-          return Utils.wrap_s(_df.column(item))
+        if item.is_a?(String) || item.is_a?(Symbol)
+          return Utils.wrap_s(_df.column(item.to_s))
         end
 
         # df[idx]
@@ -572,6 +575,28 @@ 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
+      if item.is_a?(Expr)
+        return filter(item)
       end
 
       raise ArgumentError, "Cannot get item of type: #{item.class.name}"
@@ -797,6 +822,13 @@ module Polars
       nil
     end
 
+    # Write to comma-separated values (CSV) string.
+    #
+    # @return [String]
+    def to_csv(**options)
+      write_csv(**options)
+    end
+
     # Write to Apache Avro file.
     #
     # @param file [String]
@@ -4648,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)

data/lib/polars/data_types.rb

@@ -93,7 +93,7 @@ module Polars
   class Time < DataType
   end
 
-  # Type for wrapping arbitrary Python objects.
+  # Type for wrapping arbitrary Ruby objects.
   class Object < DataType
   end
 

data/lib/polars/io.rb

@@ -590,8 +590,33 @@ module Polars
       DataFrame._read_ndjson(file)
     end
 
-    # def read_sql
-    # end
+    # Read a SQL query into a DataFrame.
+    #
+    # @param sql [Object]
+    #   ActiveRecord::Relation or ActiveRecord::Result.
+    #
+    # @return [DataFrame]
+    def read_sql(sql)
+      if !defined?(ActiveRecord)
+        raise Error, "Active Record not available"
+      end
+
+      result =
+        if sql.is_a?(ActiveRecord::Result)
+          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, ActiveRecord::Result, or String"
+        end
+      data = {}
+      result.columns.each_with_index do |k, i|
+        data[k] = result.rows.map { |r| r[i] }
+      end
+      DataFrame.new(data)
+    end
 
     # def read_excel
     # end

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
@@ -1647,6 +1654,7 @@ module Polars
     def len
       _s.len
     end
+    alias_method :count, :len
     alias_method :length, :len
 
     # Cast between data types.
@@ -2183,6 +2191,7 @@ module Polars
     def arcsin
       super
     end
+    alias_method :asin, :arcsin
 
     # Compute the element-wise value for the inverse cosine.
     #
@@ -2202,6 +2211,7 @@ module Polars
     def arccos
       super
     end
+    alias_method :acos, :arccos
 
     # Compute the element-wise value for the inverse tangent.
     #
@@ -2221,6 +2231,7 @@ module Polars
     def arctan
       super
     end
+    alias_method :atan, :arctan
 
     # Compute the element-wise value for the inverse hyperbolic sine.
     #
@@ -2240,6 +2251,7 @@ module Polars
     def arcsinh
       super
     end
+    alias_method :asinh, :arcsinh
 
     # Compute the element-wise value for the inverse hyperbolic cosine.
     #
@@ -2260,6 +2272,7 @@ module Polars
     def arccosh
       super
     end
+    alias_method :acosh, :arccosh
 
     # Compute the element-wise value for the inverse hyperbolic tangent.
     #
@@ -2283,6 +2296,7 @@ module Polars
     def arctanh
       super
     end
+    alias_method :atanh, :arctanh
 
     # Compute the element-wise value for the hyperbolic sine.
     #
@@ -3520,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))

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

@@ -70,7 +70,7 @@ module Polars
     end
 
     def self.selection_to_rbexpr_list(exprs)
-      if exprs.is_a?(String) || exprs.is_a?(Expr) || exprs.is_a?(Series)
+      if exprs.is_a?(String) || exprs.is_a?(Symbol) || exprs.is_a?(Expr) || exprs.is_a?(Series)
         exprs = [exprs]
       end
 
@@ -78,9 +78,9 @@ module Polars
     end
 
     def self.expr_to_lit_or_expr(expr, str_to_lit: true)
-      if expr.is_a?(String) && !str_to_lit
+      if (expr.is_a?(String) || expr.is_a?(Symbol)) && !str_to_lit
         col(expr)
-      elsif expr.is_a?(Integer) || expr.is_a?(Float) || expr.is_a?(String) || expr.is_a?(Series) || expr.nil?
+      elsif expr.is_a?(Integer) || expr.is_a?(Float) || expr.is_a?(String) || expr.is_a?(Symbol) || expr.is_a?(Series) || expr.nil?
         lit(expr)
       elsif expr.is_a?(Expr)
         expr
@@ -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.0"
+  VERSION = "0.2.2"
 end

data/lib/polars.rb

@@ -7,6 +7,7 @@ end
 
 # stdlib
 require "date"
+require "stringio"
 
 # modules
 require_relative "polars/expr_dispatch"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polars-df
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: arm64-darwin
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-15 00:00:00.000000000 Z
+date: 2023-01-20 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