polars-df 0.7.0 → 0.8.0

data/lib/polars/expr.rb

@@ -366,7 +366,7 @@ module Polars
     #   # │ 3   ┆ 1.5  │
     #   # └─────┴──────┘
     def exclude(columns)
-      if columns.is_a?(String)
+      if columns.is_a?(::String)
         columns = [columns]
         return wrap_expr(_rbexpr.exclude(columns))
       elsif !columns.is_a?(::Array)
@@ -374,11 +374,11 @@ module Polars
         return wrap_expr(_rbexpr.exclude_dtype(columns))
       end
 
-      if !columns.all? { |a| a.is_a?(String) } || !columns.all? { |a| Utils.is_polars_dtype(a) }
+      if !columns.all? { |a| a.is_a?(::String) } || !columns.all? { |a| Utils.is_polars_dtype(a) }
         raise ArgumentError, "input should be all string or all DataType"
       end
 
-      if columns[0].is_a?(String)
+      if columns[0].is_a?(::String)
         wrap_expr(_rbexpr.exclude(columns))
       else
         wrap_expr(_rbexpr.exclude_dtype(columns))
@@ -721,13 +721,13 @@ module Polars
     #   # │ 3   ┆ 3   │
     #   # └─────┴─────┘
     def count
-      wrap_expr(_rbexpr.count)
+      warn "`Expr#count` will exclude null values in 0.9.0. Use `Expr#length` instead."
+      # wrap_expr(_rbexpr.count)
+      wrap_expr(_rbexpr.len)
     end
 
     # Count the number of values in this expression.
     #
-    # Alias for {#count}.
-    #
     # @return [Expr]
     #
     # @example
@@ -743,8 +743,9 @@ module Polars
     #   # │ 3   ┆ 3   │
     #   # └─────┴─────┘
     def len
-      count
+      wrap_expr(_rbexpr.len)
     end
+    alias_method :length, :len
 
     # Get a slice of this expression.
     #
@@ -2423,7 +2424,7 @@ module Polars
     #   # │ --- │
     #   # │ f64 │
     #   # ╞═════╡
-    #   # │ 1.0 │
+    #   # │ 2.0 │
     #   # └─────┘
     #
     # @example
@@ -2478,6 +2479,206 @@ module Polars
       wrap_expr(_rbexpr.quantile(quantile._rbexpr, interpolation))
     end
 
+    # Bin continuous values into discrete categories.
+    #
+    # @param breaks [Array]
+    #   List of unique cut points.
+    # @param labels [Array]
+    #   Names of the categories. The number of labels must be equal to the number
+    #   of cut points plus one.
+    # @param left_closed [Boolean]
+    #   Set the intervals to be left-closed instead of right-closed.
+    # @param include_breaks [Boolean]
+    #   Include a column with the right endpoint of the bin each observation falls
+    #   in. This will change the data type of the output from a
+    #   `Categorical` to a `Struct`.
+    #
+    # @return [Expr]
+    #
+    # @example Divide a column into three categories.
+    #   df = Polars::DataFrame.new({"foo" => [-2, -1, 0, 1, 2]})
+    #   df.with_columns(
+    #     Polars.col("foo").cut([-1, 1], labels: ["a", "b", "c"]).alias("cut")
+    #   )
+    #   # =>
+    #   # shape: (5, 2)
+    #   # ┌─────┬─────┐
+    #   # │ foo ┆ cut │
+    #   # │ --- ┆ --- │
+    #   # │ i64 ┆ cat │
+    #   # ╞═════╪═════╡
+    #   # │ -2  ┆ a   │
+    #   # │ -1  ┆ a   │
+    #   # │ 0   ┆ b   │
+    #   # │ 1   ┆ b   │
+    #   # │ 2   ┆ c   │
+    #   # └─────┴─────┘
+    #
+    # @example Add both the category and the breakpoint.
+    #   df.with_columns(
+    #     Polars.col("foo").cut([-1, 1], include_breaks: true).alias("cut")
+    #   ).unnest("cut")
+    #   # =>
+    #   # shape: (5, 3)
+    #   # ┌─────┬──────┬────────────┐
+    #   # │ foo ┆ brk  ┆ foo_bin    │
+    #   # │ --- ┆ ---  ┆ ---        │
+    #   # │ i64 ┆ f64  ┆ cat        │
+    #   # ╞═════╪══════╪════════════╡
+    #   # │ -2  ┆ -1.0 ┆ (-inf, -1] │
+    #   # │ -1  ┆ -1.0 ┆ (-inf, -1] │
+    #   # │ 0   ┆ 1.0  ┆ (-1, 1]    │
+    #   # │ 1   ┆ 1.0  ┆ (-1, 1]    │
+    #   # │ 2   ┆ inf  ┆ (1, inf]   │
+    #   # └─────┴──────┴────────────┘
+    def cut(breaks, labels: nil, left_closed: false, include_breaks: false)
+      wrap_expr(_rbexpr.cut(breaks, labels, left_closed, include_breaks))
+    end
+
+    # Bin continuous values into discrete categories based on their quantiles.
+    #
+    # @param quantiles [Array]
+    #   Either a list of quantile probabilities between 0 and 1 or a positive
+    #   integer determining the number of bins with uniform probability.
+    # @param labels [Array]
+    #   Names of the categories. The number of labels must be equal to the number
+    #   of categories.
+    # @param left_closed [Boolean]
+    #   Set the intervals to be left-closed instead of right-closed.
+    # @param allow_duplicates [Boolean]
+    #   If set to `true`, duplicates in the resulting quantiles are dropped,
+    #   rather than raising a `DuplicateError`. This can happen even with unique
+    #   probabilities, depending on the data.
+    # @param include_breaks [Boolean]
+    #   Include a column with the right endpoint of the bin each observation falls
+    #   in. This will change the data type of the output from a
+    #   `Categorical` to a `Struct`.
+    #
+    # @return [Expr]
+    #
+    # @example Divide a column into three categories according to pre-defined quantile probabilities.
+    #   df = Polars::DataFrame.new({"foo" => [-2, -1, 0, 1, 2]})
+    #   df.with_columns(
+    #     Polars.col("foo").qcut([0.25, 0.75], labels: ["a", "b", "c"]).alias("qcut")
+    #   )
+    #   # =>
+    #   # shape: (5, 2)
+    #   # ┌─────┬──────┐
+    #   # │ foo ┆ qcut │
+    #   # │ --- ┆ ---  │
+    #   # │ i64 ┆ cat  │
+    #   # ╞═════╪══════╡
+    #   # │ -2  ┆ a    │
+    #   # │ -1  ┆ a    │
+    #   # │ 0   ┆ b    │
+    #   # │ 1   ┆ b    │
+    #   # │ 2   ┆ c    │
+    #   # └─────┴──────┘
+    #
+    # @example Divide a column into two categories using uniform quantile probabilities.
+    #   df.with_columns(
+    #     Polars.col("foo")
+    #       .qcut(2, labels: ["low", "high"], left_closed: true)
+    #       .alias("qcut")
+    #   )
+    #   # =>
+    #   # shape: (5, 2)
+    #   # ┌─────┬──────┐
+    #   # │ foo ┆ qcut │
+    #   # │ --- ┆ ---  │
+    #   # │ i64 ┆ cat  │
+    #   # ╞═════╪══════╡
+    #   # │ -2  ┆ low  │
+    #   # │ -1  ┆ low  │
+    #   # │ 0   ┆ high │
+    #   # │ 1   ┆ high │
+    #   # │ 2   ┆ high │
+    #   # └─────┴──────┘
+    #
+    # @example Add both the category and the breakpoint.
+    #   df.with_columns(
+    #     Polars.col("foo").qcut([0.25, 0.75], include_breaks: true).alias("qcut")
+    #   ).unnest("qcut")
+    #   # =>
+    #   # shape: (5, 3)
+    #   # ┌─────┬──────┬────────────┐
+    #   # │ foo ┆ brk  ┆ foo_bin    │
+    #   # │ --- ┆ ---  ┆ ---        │
+    #   # │ i64 ┆ f64  ┆ cat        │
+    #   # ╞═════╪══════╪════════════╡
+    #   # │ -2  ┆ -1.0 ┆ (-inf, -1] │
+    #   # │ -1  ┆ -1.0 ┆ (-inf, -1] │
+    #   # │ 0   ┆ 1.0  ┆ (-1, 1]    │
+    #   # │ 1   ┆ 1.0  ┆ (-1, 1]    │
+    #   # │ 2   ┆ inf  ┆ (1, inf]   │
+    #   # └─────┴──────┴────────────┘
+    def qcut(quantiles, labels: nil, left_closed: false, allow_duplicates: false, include_breaks: false)
+      if quantiles.is_a?(Integer)
+        rbexpr = _rbexpr.qcut_uniform(
+          quantiles, labels, left_closed, allow_duplicates, include_breaks
+        )
+      else
+        rbexpr = _rbexpr.qcut(
+          quantiles, labels, left_closed, allow_duplicates, include_breaks
+        )
+      end
+
+      wrap_expr(rbexpr)
+    end
+
+    # Get the lengths of runs of identical values.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(Polars::Series.new("s", [1, 1, 2, 1, nil, 1, 3, 3]))
+    #   df.select(Polars.col("s").rle).unnest("s")
+    #   # =>
+    #   # shape: (6, 2)
+    #   # ┌─────────┬────────┐
+    #   # │ lengths ┆ values │
+    #   # │ ---     ┆ ---    │
+    #   # │ i32     ┆ i64    │
+    #   # ╞═════════╪════════╡
+    #   # │ 2       ┆ 1      │
+    #   # │ 1       ┆ 2      │
+    #   # │ 1       ┆ 1      │
+    #   # │ 1       ┆ null   │
+    #   # │ 1       ┆ 1      │
+    #   # │ 2       ┆ 3      │
+    #   # └─────────┴────────┘
+    def rle
+      wrap_expr(_rbexpr.rle)
+    end
+
+    # Map values to run IDs.
+    #
+    # Similar to RLE, but it maps each value to an ID corresponding to the run into
+    # which it falls. This is especially useful when you want to define groups by
+    # runs of identical values rather than the values themselves.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [1, 2, 1, 1, 1], "b" => ["x", "x", nil, "y", "y"]})
+    #   df.with_columns([Polars.col("a").rle_id.alias("a_r"), Polars.struct(["a", "b"]).rle_id.alias("ab_r")])
+    #   # =>
+    #   # shape: (5, 4)
+    #   # ┌─────┬──────┬─────┬──────┐
+    #   # │ a   ┆ b    ┆ a_r ┆ ab_r │
+    #   # │ --- ┆ ---  ┆ --- ┆ ---  │
+    #   # │ i64 ┆ str  ┆ u32 ┆ u32  │
+    #   # ╞═════╪══════╪═════╪══════╡
+    #   # │ 1   ┆ x    ┆ 0   ┆ 0    │
+    #   # │ 2   ┆ x    ┆ 1   ┆ 1    │
+    #   # │ 1   ┆ null ┆ 2   ┆ 2    │
+    #   # │ 1   ┆ y    ┆ 2   ┆ 3    │
+    #   # │ 1   ┆ y    ┆ 2   ┆ 3    │
+    #   # └─────┴──────┴─────┴──────┘
+    def rle_id
+      wrap_expr(_rbexpr.rle_id)
+    end
+
     # Filter a single column.
     #
     # Mostly useful in an aggregation context. If you want to filter on a DataFrame
@@ -2751,8 +2952,8 @@ module Polars
     #   # │ 4   │
     #   # │ 7   │
     #   # └─────┘
-    def gather_every(n)
-      wrap_expr(_rbexpr.gather_every(n))
+    def gather_every(n, offset = 0)
+      wrap_expr(_rbexpr.gather_every(n, offset))
     end
     alias_method :take_every, :gather_every
 
@@ -3571,14 +3772,15 @@ module Polars
       center: false,
       by: nil,
       closed: "left",
-      ddof: 1
+      ddof: 1,
+      warn_if_unsorted: true
     )
       window_size, min_periods = _prepare_rolling_window_args(
         window_size, min_periods
       )
       wrap_expr(
         _rbexpr.rolling_std(
-          window_size, weights, min_periods, center, by, closed, ddof
+          window_size, weights, min_periods, center, by, closed, ddof, warn_if_unsorted
         )
       )
     end
@@ -3661,14 +3863,15 @@ module Polars
       center: false,
       by: nil,
       closed: "left",
-      ddof: 1
+      ddof: 1,
+      warn_if_unsorted: true
     )
       window_size, min_periods = _prepare_rolling_window_args(
         window_size, min_periods
       )
       wrap_expr(
         _rbexpr.rolling_var(
-          window_size, weights, min_periods, center, by, closed, ddof
+          window_size, weights, min_periods, center, by, closed, ddof, warn_if_unsorted
         )
       )
     end
@@ -3746,14 +3949,15 @@ module Polars
       min_periods: nil,
       center: false,
       by: nil,
-      closed: "left"
+      closed: "left",
+      warn_if_unsorted: true
     )
       window_size, min_periods = _prepare_rolling_window_args(
         window_size, min_periods
       )
       wrap_expr(
         _rbexpr.rolling_median(
-          window_size, weights, min_periods, center, by, closed
+          window_size, weights, min_periods, center, by, closed, warn_if_unsorted
         )
       )
     end
@@ -3837,14 +4041,15 @@ module Polars
       min_periods: nil,
       center: false,
       by: nil,
-      closed: "left"
+      closed: "left",
+      warn_if_unsorted: true
     )
       window_size, min_periods = _prepare_rolling_window_args(
         window_size, min_periods
       )
       wrap_expr(
         _rbexpr.rolling_quantile(
-          quantile, interpolation, window_size, weights, min_periods, center, by, closed
+          quantile, interpolation, window_size, weights, min_periods, center, by, closed, warn_if_unsorted
         )
       )
     end

data/lib/polars/group_by.rb

@@ -47,7 +47,7 @@ module Polars
 
       # When grouping by a single column, group name is a single value
       # When grouping by multiple columns, group name is a tuple of values
-      if @by.is_a?(String) || @by.is_a?(Expr)
+      if @by.is_a?(::String) || @by.is_a?(Expr)
         _group_names = group_names.to_series.each
       else
         _group_names = group_names.iter_rows

data/lib/polars/io.rb

@@ -616,7 +616,7 @@ module Polars
           query
         elsif query.is_a?(ActiveRecord::Relation)
           query.connection.select_all(query.to_sql)
-        elsif query.is_a?(String)
+        elsif query.is_a?(::String)
           ActiveRecord::Base.connection.select_all(query)
         else
           raise ArgumentError, "Expected ActiveRecord::Relation, ActiveRecord::Result, or String"
@@ -652,7 +652,7 @@ module Polars
           when :integer
             Int64
           when :string, :text
-            Utf8
+            String
           when :time
             Time
           end
@@ -856,7 +856,7 @@ module Polars
     private
 
     def _prepare_file_arg(file)
-      if file.is_a?(String) && file =~ /\Ahttps?:\/\//
+      if file.is_a?(::String) && file =~ /\Ahttps?:\/\//
         raise ArgumentError, "use URI(...) for remote files"
       end
 
@@ -870,7 +870,7 @@ module Polars
     end
 
     def _check_arg_is_1byte(arg_name, arg, can_be_empty = false)
-      if arg.is_a?(String)
+      if arg.is_a?(::String)
         arg_byte_length = arg.bytesize
         if can_be_empty
           if arg_byte_length > 1

data/lib/polars/lazy_frame.rb

@@ -218,7 +218,7 @@ module Polars
     #     }
     #   ).lazy
     #   lf.dtypes
-    #   # => [Polars::Int64, Polars::Float64, Polars::Utf8]
+    #   # => [Polars::Int64, Polars::Float64, Polars::String]
     def dtypes
       _ldf.dtypes
     end
@@ -236,7 +236,7 @@ module Polars
     #     }
     #   ).lazy
     #   lf.schema
-    #   # => {"foo"=>Polars::Int64, "bar"=>Polars::Float64, "ham"=>Polars::Utf8}
+    #   # => {"foo"=>Polars::Int64, "bar"=>Polars::Float64, "ham"=>Polars::String}
     def schema
       _ldf.schema
     end
@@ -399,7 +399,7 @@ module Polars
     #   # │ 1   ┆ 6.0 ┆ a   │
     #   # └─────┴─────┴─────┘
     def sort(by, reverse: false, nulls_last: false, maintain_order: false)
-      if by.is_a?(String)
+      if by.is_a?(::String)
         return _from_rbldf(_ldf.sort(by, reverse, nulls_last, maintain_order))
       end
       if Utils.bool?(reverse)
@@ -1371,7 +1371,7 @@ module Polars
         raise ArgumentError, "Expected a `LazyFrame` as join table, got #{other.class.name}"
       end
 
-      if on.is_a?(String)
+      if on.is_a?(::String)
         left_on = on
         right_on = on
       end
@@ -1380,19 +1380,19 @@ module Polars
         raise ArgumentError, "You should pass the column to join on as an argument."
       end
 
-      if by_left.is_a?(String) || by_left.is_a?(Expr)
+      if by_left.is_a?(::String) || by_left.is_a?(Expr)
         by_left_ = [by_left]
       else
         by_left_ = by_left
       end
 
-      if by_right.is_a?(String) || by_right.is_a?(Expr)
+      if by_right.is_a?(::String) || by_right.is_a?(Expr)
         by_right_ = [by_right]
       else
         by_right_ = by_right
       end
 
-      if by.is_a?(String)
+      if by.is_a?(::String)
         by_left_ = [by]
         by_right_ = [by]
       elsif by.is_a?(::Array)
@@ -1402,7 +1402,7 @@ module Polars
 
       tolerance_str = nil
       tolerance_num = nil
-      if tolerance.is_a?(String)
+      if tolerance.is_a?(::String)
         tolerance_str = tolerance
       else
         tolerance_num = tolerance
@@ -1478,17 +1478,17 @@ module Polars
     # @example
     #   df.join(other_df, on: "ham", how: "outer").collect
     #   # =>
-    #   # shape: (4, 4)
-    #   # ┌──────┬──────┬─────┬───────┐
-    #   # │ foo  ┆ bar  ┆ ham ┆ apple │
-    #   # │ ---  ┆ ---  ┆ --- ┆ ---   │
-    #   # │ i64  ┆ f64  ┆ str ┆ str   │
-    #   # ╞══════╪══════╪═════╪═══════╡
-    #   # │ 1    ┆ 6.0  ┆ a   ┆ x     │
-    #   # │ 2    ┆ 7.0  ┆ b   ┆ y     │
-    #   # │ null ┆ null ┆ d   ┆ z     │
-    #   # │ 3    ┆ 8.0  ┆ c   ┆ null  │
-    #   # └──────┴──────┴─────┴───────┘
+    #   # shape: (4, 5)
+    #   # ┌──────┬──────┬──────┬───────┬───────────┐
+    #   # │ foo  ┆ bar  ┆ ham  ┆ apple ┆ ham_right │
+    #   # │ ---  ┆ ---  ┆ ---  ┆ ---   ┆ ---       │
+    #   # │ i64  ┆ f64  ┆ str  ┆ str   ┆ str       │
+    #   # ╞══════╪══════╪══════╪═══════╪═══════════╡
+    #   # │ 1    ┆ 6.0  ┆ a    ┆ x     ┆ a         │
+    #   # │ 2    ┆ 7.0  ┆ b    ┆ y     ┆ b         │
+    #   # │ null ┆ null ┆ null ┆ z     ┆ d         │
+    #   # │ 3    ┆ 8.0  ┆ c    ┆ null  ┆ null      │
+    #   # └──────┴──────┴──────┴───────┴───────────┘
     #
     # @example
     #   df.join(other_df, on: "ham", how: "left").collect
@@ -1722,7 +1722,7 @@ module Polars
     #
     # @return [LazyFrame]
     def drop(columns)
-      if columns.is_a?(String)
+      if columns.is_a?(::String)
         columns = [columns]
       end
       _from_rbldf(_ldf.drop_columns(columns))
@@ -2363,10 +2363,10 @@ module Polars
     #   # │ z   ┆ c        ┆ 6     │
     #   # └─────┴──────────┴───────┘
     def melt(id_vars: nil, value_vars: nil, variable_name: nil, value_name: nil, streamable: true)
-      if value_vars.is_a?(String)
+      if value_vars.is_a?(::String)
         value_vars = [value_vars]
       end
-      if id_vars.is_a?(String)
+      if id_vars.is_a?(::String)
         id_vars = [id_vars]
       end
       if value_vars.nil?
@@ -2464,7 +2464,7 @@ module Polars
     #   # │ bar    ┆ 2   ┆ b   ┆ null ┆ [3]       ┆ womp  │
     #   # └────────┴─────┴─────┴──────┴───────────┴───────┘
     def unnest(names)
-      if names.is_a?(String)
+      if names.is_a?(::String)
         names = [names]
       end
       _from_rbldf(_ldf.unnest(names))

data/lib/polars/lazy_functions.rb

@@ -107,44 +107,28 @@ module Polars
     # Get the maximum value.
     #
     # @param column [Object]
-    #   Column(s) to be used in aggregation. Will lead to different behavior based on
-    #   the input:
-    #
-    #   - [String, Series] -> aggregate the maximum value of that column.
-    #   - [Array<Expr>] -> aggregate the maximum value horizontally.
+    #   Column(s) to be used in aggregation.
     #
     # @return [Expr, Object]
     def max(column)
       if column.is_a?(Series)
         column.max
-      elsif Utils.strlike?(column)
-        col(column).max
       else
-        exprs = Utils.selection_to_rbexpr_list(column)
-        # TODO
-        Utils.wrap_expr(_max_exprs(exprs))
+        col(column).max
       end
     end
 
     # Get the minimum value.
     #
     # @param column [Object]
-    #   Column(s) to be used in aggregation. Will lead to different behavior based on
-    #   the input:
-    #
-    #   - [String, Series] -> aggregate the minimum value of that column.
-    #   - [Array<Expr>] -> aggregate the minimum value horizontally.
+    #   Column(s) to be used in aggregation.
     #
     # @return [Expr, Object]
     def min(column)
       if column.is_a?(Series)
         column.min
-      elsif Utils.strlike?(column)
-        col(column).min
       else
-        exprs = Utils.selection_to_rbexpr_list(column)
-        # TODO
-        Utils.wrap_expr(_min_exprs(exprs))
+        col(column).min
       end
     end