polars-df 0.25.1 → 0.26.1

data/lib/polars/binary_name_space.rb

@@ -226,6 +226,38 @@ module Polars
       super
     end
 
+    # Get the byte value at the given index.
+    #
+    # For example, index `0` would return the first byte of every binary value
+    # and index `-1` would return the last byte of every binary value.
+    # The behavior if an index is out of bounds is determined by the argument
+    # `null_on_oob`.
+    #
+    # @param index [Object]
+    #   Index to return per binary value
+    # @param null_on_oob [Boolean]
+    #   Behavior if an index is out of bounds:
+    #
+    #   * true -> set as null
+    #   * false -> raise an error
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", ["\x01\x02\x03".b, "".b, "\x04\x05".b])
+    #   s.bin.get(0, null_on_oob: true)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [u8]
+    #   # [
+    #   #         1
+    #   #         null
+    #   #         4
+    #   # ]
+    def get(index, null_on_oob: false)
+      super
+    end
+
     # Take the first `n` bytes of the binary values.
     #
     # @param n [Object]

data/lib/polars/data_frame.rb

@@ -771,7 +771,14 @@ module Polars
       s.get_index_signed(row)
     end
 
-    # no to_arrow
+    # Collect the underlying arrow arrays in an Arrow Table.
+    #
+    # @return [Nanoarrow::Array]
+    def to_arrow
+      require "nanoarrow"
+
+      Nanoarrow::Array.new(self)
+    end
 
     # Convert DataFrame to a hash mapping column name to values.
     #
@@ -810,6 +817,8 @@ module Polars
     #   df.to_numo.class
     #   # => Numo::RObject
     def to_numo
+      require "numo/narray"
+
       out = _df.to_numo
       if out.nil?
         Numo::NArray.vstack(width.times.map { |i| to_series(i).to_numo }).transpose
@@ -3808,6 +3817,57 @@ module Polars
       .collect(optimizations: QueryOptFlags._eager)
     end
 
+    # Selects rows from this DataFrame at the given indices.
+    #
+    # @note
+    #   This functionality is experimental. It may be
+    #   changed at any point without it being considered a breaking change.
+    #
+    # @param indices [Object]
+    #   The indices of the rows to select.
+    # @param null_on_oob [Boolean]
+    #   If true when an index is out-of-bounds a null row will be generated
+    #   instead of raising an error.
+    #
+    # @return [DataFrame]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"x" => [2, 1, 0], "s" => ["foo", "bar", "baz"]})
+    #   df.gather([2, 0, 0])
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────┬─────┐
+    #   # │ x   ┆ s   │
+    #   # │ --- ┆ --- │
+    #   # │ i64 ┆ str │
+    #   # ╞═════╪═════╡
+    #   # │ 0   ┆ baz │
+    #   # │ 2   ┆ foo │
+    #   # │ 2   ┆ foo │
+    #   # └─────┴─────┘
+    #
+    # @example
+    #   df.gather([0, 10, 1], null_on_oob: true)
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌──────┬──────┐
+    #   # │ x    ┆ s    │
+    #   # │ ---  ┆ ---  │
+    #   # │ i64  ┆ str  │
+    #   # ╞══════╪══════╡
+    #   # │ 2    ┆ foo  │
+    #   # │ null ┆ null │
+    #   # │ 1    ┆ bar  │
+    #   # └──────┴──────┘
+    def gather(
+      indices,
+      null_on_oob: false
+    )
+      lazy
+      .gather(indices, null_on_oob: null_on_oob)
+      .collect(optimizations: QueryOptFlags._eager)
+    end
+
     # Apply a custom/user-defined function (UDF) over the rows of the DataFrame.
     #
     # The UDF will receive each row as a tuple of values: `udf(row)`.
@@ -4527,6 +4587,8 @@ module Polars
     # @param separator [String]
     #   Used as separator/delimiter in generated column names in case of multiple
     #   `values` columns.
+    # @param column_naming ['auto', 'combine']
+    #   How resulting column names will be constructed.
     #
     # @return [DataFrame]
     #
@@ -4557,7 +4619,8 @@ module Polars
       aggregate_function: nil,
       maintain_order: true,
       sort_columns: false,
-      separator: "_"
+      separator: "_",
+      column_naming: "auto"
     )
       if on_columns.nil?
         cols = select(on).unique(maintain_order: true)
@@ -4577,7 +4640,8 @@ module Polars
         values: values,
         aggregate_function: aggregate_function,
         maintain_order: maintain_order,
-        separator: separator
+        separator: separator,
+        column_naming: column_naming
       )
       .collect(optimizations: QueryOptFlags._eager)
     end
@@ -4593,7 +4657,8 @@ module Polars
     #
     # @param on [Object]
     #   Column(s) or selector(s) to use as values variables; if `on`
-    #   is empty all columns that are not in `index` will be used.
+    #   is empty no columns will be used. If set to `nil` (default)
+    #   all columns that are not in `index` will be used.
     # @param index [Object]
     #   Column(s) or selector(s) to use as identifier variables.
     # @param variable_name [Object]
@@ -4627,7 +4692,7 @@ module Polars
     #   # │ z   ┆ c        ┆ 6     │
     #   # └─────┴──────────┴───────┘
     def unpivot(on = nil, index: nil, variable_name: nil, value_name: nil)
-      on = on.nil? ? [] : Utils._expand_selectors(self, on)
+      on = on.nil? ? nil : Utils._expand_selectors(self, on)
       index = index.nil? ? [] : Utils._expand_selectors(self, index)
 
       _from_rbdf(_df.unpivot(on, index, value_name, variable_name))
@@ -6488,7 +6553,7 @@ module Polars
     #   # │ foo    ┆ 1   ┆ a   ┆ true ┆ [1, 2]    ┆ baz   │
     #   # │ bar    ┆ 2   ┆ b   ┆ null ┆ [3]       ┆ womp  │
     #   # └────────┴─────┴─────┴──────┴───────────┴───────┘
-    def unnest(columns, *more_columns, separator: nil)
+    def unnest(columns = nil, *more_columns, separator: nil)
       lazy.unnest(columns, *more_columns, separator: separator).collect(optimizations: QueryOptFlags._eager)
     end
 
@@ -6504,6 +6569,10 @@ module Polars
     #   Other DataFrame that must be merged
     # @param key [String]
     #   Key that is sorted.
+    # @param maintain_order [Boolean]
+    #   If `true`, the output is guaranteed to have left-biased ordering
+    #   for equal keys: rows from the left frame appear before rows from
+    #   the right frame when their keys are equal.
     #
     # @return [DataFrame]
     #
@@ -6530,8 +6599,8 @@ module Polars
     #   # │ steve  ┆ 42  │
     #   # │ elise  ┆ 44  │
     #   # └────────┴─────┘
-    def merge_sorted(other, key)
-      lazy.merge_sorted(other.lazy, key).collect(optimizations: QueryOptFlags._eager)
+    def merge_sorted(other, key, maintain_order: false)
+      lazy.merge_sorted(other.lazy, key, maintain_order: maintain_order).collect(optimizations: QueryOptFlags._eager)
     end
 
     # Flag a column as sorted.
@@ -6545,14 +6614,17 @@ module Polars
     #   Column that is sorted.
     # @param descending [Boolean]
     #   Whether the column is sorted in descending order.
+    # @param nulls_last [Boolean]
+    #   Whether the nulls are at the end.
     #
     # @return [DataFrame]
     def set_sorted(
       column,
-      descending: false
+      descending: false,
+      nulls_last: false
     )
       lazy
-        .set_sorted(column, descending: descending)
+        .set_sorted(column, descending: descending, nulls_last: nulls_last)
         .collect(optimizations: QueryOptFlags._eager)
     end
 
@@ -7111,7 +7183,7 @@ module Polars
     end
 
     def _select_rows_by_slice(df, key)
-      return Slice.new(df).apply(key)
+      Slice.new(df).apply(key)
     end
 
     def _select_rows_by_index(df, key)

data/lib/polars/date_time_expr.rb

@@ -22,6 +22,8 @@ module Polars
     #   Which days of the week to count. The default is Monday to Friday.
     #   If you wanted to count only Monday to Thursday, you would pass
     #   `[true, true, true, true, false, false, false]`.
+    # @param holidays [Object]
+    #   Holidays to exclude from the count.
     # @param roll
     #   What to do when the start date lands on a non-business day. Options are:
     #
@@ -44,17 +46,67 @@ module Polars
     #   # │ 2020-01-01 ┆ 2020-01-08 │
     #   # │ 2020-01-02 ┆ 2020-01-09 │
     #   # └────────────┴────────────┘
+    #
+    # @example You can pass a custom weekend - for example, if you only take Sunday off:
+    #   week_mask = [true, true, true, true, true, true, false]
+    #   df.with_columns(
+    #     result: Polars.col("start").dt.add_business_days(5, week_mask: week_mask)
+    #   )
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌────────────┬────────────┐
+    #   # │ start      ┆ result     │
+    #   # │ ---        ┆ ---        │
+    #   # │ date       ┆ date       │
+    #   # ╞════════════╪════════════╡
+    #   # │ 2020-01-01 ┆ 2020-01-07 │
+    #   # │ 2020-01-02 ┆ 2020-01-08 │
+    #   # └────────────┴────────────┘
+    #
+    # @example You can also pass a list of holidays:
+    #   holidays = [Date.new(2020, 1, 3), Date.new(2020, 1, 6)]
+    #   df.with_columns(
+    #     result: Polars.col("start").dt.add_business_days(5, holidays: holidays)
+    #   )
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌────────────┬────────────┐
+    #   # │ start      ┆ result     │
+    #   # │ ---        ┆ ---        │
+    #   # │ date       ┆ date       │
+    #   # ╞════════════╪════════════╡
+    #   # │ 2020-01-01 ┆ 2020-01-10 │
+    #   # │ 2020-01-02 ┆ 2020-01-13 │
+    #   # └────────────┴────────────┘
+    #
+    # @example Roll all dates forwards to the next business day:
+    #   df = Polars::DataFrame.new({"start" => [Date.new(2020, 1, 5), Date.new(2020, 1, 6)]})
+    #   df.with_columns(
+    #     rolled_forwards: Polars.col("start").dt.add_business_days(0, roll: "forward")
+    #   )
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌────────────┬─────────────────┐
+    #   # │ start      ┆ rolled_forwards │
+    #   # │ ---        ┆ ---             │
+    #   # │ date       ┆ date            │
+    #   # ╞════════════╪═════════════════╡
+    #   # │ 2020-01-05 ┆ 2020-01-06      │
+    #   # │ 2020-01-06 ┆ 2020-01-06      │
+    #   # └────────────┴─────────────────┘
     def add_business_days(
       n,
       week_mask: [true, true, true, true, true, false, false],
+      holidays: [],
       roll: "raise"
     )
       n_rbexpr = Utils.parse_into_expression(n)
+      holidays_rbexpr = Utils._holidays_to_expr(holidays)
       Utils.wrap_expr(
         _rbexpr.dt_add_business_days(
           n_rbexpr,
           week_mask,
-          [],
+          holidays_rbexpr,
           roll
         )
       )
@@ -580,6 +632,8 @@ module Polars
     #   Which days of the week to count. The default is Monday to Friday.
     #   If you wanted to count only Monday to Thursday, you would pass
     #   `[true, true, true, true, false, false, false]`.
+    # @param holidays [Object]
+    #   Holidays to exclude from the count.
     #
     # @return [Expr]
     #
@@ -596,13 +650,47 @@ module Polars
     #   # │ 2020-01-03 ┆ true            │
     #   # │ 2020-01-05 ┆ false           │
     #   # └────────────┴─────────────────┘
+    #
+    # @example You can pass a custom weekend - for example, if you only take Sunday off:
+    #   week_mask = [true, true, true, true, true, true, false]
+    #   df.with_columns(
+    #     is_business_day: Polars.col("start").dt.is_business_day(week_mask: week_mask)
+    #   )
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌────────────┬─────────────────┐
+    #   # │ start      ┆ is_business_day │
+    #   # │ ---        ┆ ---             │
+    #   # │ date       ┆ bool            │
+    #   # ╞════════════╪═════════════════╡
+    #   # │ 2020-01-03 ┆ true            │
+    #   # │ 2020-01-05 ┆ false           │
+    #   # └────────────┴─────────────────┘
+    #
+    # @example You can also pass a list of holidays:
+    #   holidays = [Date.new(2020, 1, 3), Date.new(2020, 1, 6)]
+    #   df.with_columns(
+    #     is_business_day: Polars.col("start").dt.is_business_day(holidays: holidays)
+    #   )
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌────────────┬─────────────────┐
+    #   # │ start      ┆ is_business_day │
+    #   # │ ---        ┆ ---             │
+    #   # │ date       ┆ bool            │
+    #   # ╞════════════╪═════════════════╡
+    #   # │ 2020-01-03 ┆ false           │
+    #   # │ 2020-01-05 ┆ false           │
+    #   # └────────────┴─────────────────┘
     def is_business_day(
-      week_mask: [true, true, true, true, true, false, false]
+      week_mask: [true, true, true, true, true, false, false],
+      holidays: []
     )
+      holidays_rbexpr = Utils._holidays_to_expr(holidays)
       Utils.wrap_expr(
         _rbexpr.dt_is_business_day(
           week_mask,
-          []
+          holidays_rbexpr
         )
       )
     end

data/lib/polars/date_time_name_space.rb

@@ -31,6 +31,8 @@ module Polars
     #   Which days of the week to count. The default is Monday to Friday.
     #   If you wanted to count only Monday to Thursday, you would pass
     #   `[true, true, true, true, false, false, false]`.
+    # @param holidays [Object]
+    #   Holidays to exclude from the count.
     # roll
     #   What to do when the start date lands on a non-business day. Options are:
     #
@@ -75,6 +77,7 @@ module Polars
     def add_business_days(
       n,
       week_mask: [true, true, true, true, true, false, false],
+      holidays: [],
       roll: "raise"
     )
       super
@@ -263,6 +266,8 @@ module Polars
     #   Which days of the week to count. The default is Monday to Friday.
     #   If you wanted to count only Monday to Thursday, you would pass
     #   `[true, true, true, true, false, false, false]`.
+    # @param holidays [Object]
+    #   Holidays to exclude from the count.
     #
     # @return [Series]
     #
@@ -288,7 +293,8 @@ module Polars
     #   #         false
     #   # ]
     def is_business_day(
-      week_mask: [true, true, true, true, true, false, false]
+      week_mask: [true, true, true, true, true, false, false],
+      holidays: []
     )
       super
     end

data/lib/polars/expr.rb

@@ -252,6 +252,38 @@ module Polars
       wrap_expr(_rbexpr.all(ignore_nulls))
     end
 
+    # Return whether the column is empty.
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # @param ignore_nulls [Boolean]
+    #   If true a column containing only nulls will also be considered empty.
+    #   The default is false.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"x" => [nil, nil]})
+    #   df.select(
+    #     a: Polars.col("x").is_empty,
+    #     b: Polars.col("x").drop_nulls.is_empty,
+    #     c: Polars.col("x").is_empty(ignore_nulls: true)
+    #   )
+    #   # =>
+    #   # shape: (1, 3)
+    #   # ┌───────┬──────┬──────┐
+    #   # │ a     ┆ b    ┆ c    │
+    #   # │ ---   ┆ ---  ┆ ---  │
+    #   # │ bool  ┆ bool ┆ bool │
+    #   # ╞═══════╪══════╪══════╡
+    #   # │ false ┆ true ┆ true │
+    #   # └───────┴──────┴──────┘
+    def is_empty(ignore_nulls: false)
+      wrap_expr(_rbexpr.is_empty(ignore_nulls))
+    end
+
     # Return indices where expression evaluates `true`.
     #
     # @return [Expr]
@@ -1204,6 +1236,49 @@ module Polars
       wrap_expr(_rbexpr.round_sig_figs(digits))
     end
 
+    # Truncate numeric data toward zero to `decimals` number of decimal places.
+    #
+    # @param decimals [Integer]
+    #   Number of decimal places to truncate to.
+    #
+    # @return [Expr]
+    #
+    # @note
+    #   Truncation discards the fractional part beyond the given number of decimals.
+    #   For example, when rounding to 0 decimals 0.25, -0.25, 0.99, and -0.99 will
+    #   all round to 0. When rounding to 1 decimal 1.9999 rounds to 1.9 and -1.9999
+    #   rounds to -1.9. There is no tiebreak behaviour at midpoint values as there
+    #   is with :meth:`round` so 0.5 and -0.5 will also round to 0 when decimals=1.
+    #
+    # @note
+    #   This method performs numeric truncation. For truncating temporal
+    #   data (dates/datetimes), use :func:`Expr.dt.truncate` instead.
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"n" => [-9.9999, 0.12345, 1.0251, 8.8765]})
+    #   df.with_columns(
+    #     t0: Polars.col("n").truncate(0),
+    #     t1: Polars.col("n").truncate(1),
+    #     t2: Polars.col("n").truncate(2),
+    #     t3: Polars.col("n").truncate(3),
+    #     t4: Polars.col("n").truncate(4)
+    #   )
+    #   # =>
+    #   # shape: (4, 6)
+    #   # ┌─────────┬──────┬──────┬───────┬────────┬─────────┐
+    #   # │ n       ┆ t0   ┆ t1   ┆ t2    ┆ t3     ┆ t4      │
+    #   # │ ---     ┆ ---  ┆ ---  ┆ ---   ┆ ---    ┆ ---     │
+    #   # │ f64     ┆ f64  ┆ f64  ┆ f64   ┆ f64    ┆ f64     │
+    #   # ╞═════════╪══════╪══════╪═══════╪════════╪═════════╡
+    #   # │ -9.9999 ┆ -9.0 ┆ -9.9 ┆ -9.99 ┆ -9.999 ┆ -9.9999 │
+    #   # │ 0.12345 ┆ 0.0  ┆ 0.1  ┆ 0.12  ┆ 0.123  ┆ 0.1234  │
+    #   # │ 1.0251  ┆ 1.0  ┆ 1.0  ┆ 1.02  ┆ 1.025  ┆ 1.025   │
+    #   # │ 8.8765  ┆ 8.0  ┆ 8.8  ┆ 8.87  ┆ 8.876  ┆ 8.8765  │
+    #   # └─────────┴──────┴──────┴───────┴────────┴─────────┘
+    def truncate(decimals = 0)
+      Utils.wrap_expr(_rbexpr.truncate(decimals))
+    end
+
     # Compute the dot/inner product between two Expressions.
     #
     # @param other [Expr]
@@ -1887,6 +1962,11 @@ module Polars
     #
     # @param indices [Expr]
     #   An expression that leads to a `:u32` dtyped Series.
+    # @param null_on_oob [Boolean]
+    #   Behavior if an index is out of bounds:
+    #
+    #   - true  -> set the result to null
+    #   - false -> raise an error
     #
     # @return [Expr]
     #
@@ -1915,13 +1995,13 @@ module Polars
     #   # │ one   ┆ [2, 98]   │
     #   # │ two   ┆ [4, 99]   │
     #   # └───────┴───────────┘
-    def gather(indices)
+    def gather(indices, null_on_oob: false)
       if indices.is_a?(::Array)
         indices_lit_rbexpr = Polars.lit(Series.new("", indices, dtype: Int64))._rbexpr
       else
         indices_lit_rbexpr = Utils.parse_into_expression(indices)
       end
-      wrap_expr(_rbexpr.gather(indices_lit_rbexpr))
+      wrap_expr(_rbexpr.gather(indices_lit_rbexpr, null_on_oob))
     end
 
     # Return a single value by index.
@@ -3195,17 +3275,17 @@ module Polars
     #   )
     #   # =>
     #   # shape: (5, 2)
-    #   # ┌─────┬─────┐
-    #   # │ foo ┆ cut │
-    #   # │ --- ┆ --- │
-    #   # │ i64 ┆ cat │
-    #   # ╞═════╪═════╡
-    #   # │ -2  ┆ a   │
-    #   # │ -1  ┆ a   │
-    #   # │ 0   ┆ b   │
-    #   # │ 1   ┆ b   │
-    #   # │ 2   ┆ c   │
-    #   # └─────┴─────┘
+    #   # ┌─────┬──────┐
+    #   # │ foo ┆ cut  │
+    #   # │ --- ┆ ---  │
+    #   # │ i64 ┆ enum │
+    #   # ╞═════╪══════╡
+    #   # │ -2  ┆ a    │
+    #   # │ -1  ┆ a    │
+    #   # │ 0   ┆ b    │
+    #   # │ 1   ┆ b    │
+    #   # │ 2   ┆ c    │
+    #   # └─────┴──────┘
     #
     # @example Add both the category and the breakpoint.
     #   df.with_columns(
@@ -3216,7 +3296,7 @@ module Polars
     #   # ┌─────┬────────────┬────────────┐
     #   # │ foo ┆ breakpoint ┆ category   │
     #   # │ --- ┆ ---        ┆ ---        │
-    #   # │ i64 ┆ f64        ┆ cat        │
+    #   # │ i64 ┆ f64        ┆ enum       │
     #   # ╞═════╪════════════╪════════════╡
     #   # │ -2  ┆ -1.0       ┆ (-inf, -1] │
     #   # │ -1  ┆ -1.0       ┆ (-inf, -1] │
@@ -4566,13 +4646,18 @@ module Polars
       wrap_expr(_rbexpr._hash(k0, k1, k2, k3))
     end
 
-    # Reinterpret the underlying bits as a signed/unsigned integer.
+    # Reinterpret the underlying bits as a signed/unsigned integer or float.
+    #
+    # This operation is only allowed for numeric types of the same size.
+    # For lower bits numbers, you can safely use the cast operation.
     #
-    # This operation is only allowed for 64bit integers. For lower bits integers,
-    # you can safely use that cast operation.
+    # Either `signed` or `dtype` can be specified.
     #
     # @param signed [Boolean]
-    #   If true, reinterpret as `Polars::Int64`. Otherwise, reinterpret as `Polars::UInt64`.
+    #   If true, reinterpret as signed integer. Otherwise, reinterpret
+    #   as unsigned integer.
+    # @param dtype [Object]
+    #   DataType to reinterpret to.
     #
     # @return [Expr]
     #
@@ -4581,7 +4666,7 @@ module Polars
     #   df = Polars::DataFrame.new([s])
     #   df.select(
     #     [
-    #       Polars.col("a").reinterpret(signed: true).alias("reinterpreted"),
+    #       Polars.col("a").reinterpret(dtype: Polars::Int64).alias("reinterpreted"),
     #       Polars.col("a").alias("original")
     #     ]
     #   )
@@ -4596,14 +4681,13 @@ module Polars
     #   # │ 1             ┆ 1        │
     #   # │ 2             ┆ 2        │
     #   # └───────────────┴──────────┘
-    def reinterpret(signed: nil)
-      # TODO update
-      if signed.nil?
-        warn "The default `signed` for `reinterpret` method will change from `false` to `true` in a future version"
-        signed = false
+    def reinterpret(signed: nil, dtype: nil)
+      if signed.nil? == dtype.nil?
+        msg = "reinterpret requires exactly one of `signed` or `dtype` to be specified"
+        raise ArgumentError, msg
       end
 
-      wrap_expr(_rbexpr.reinterpret(signed))
+      wrap_expr(_rbexpr.reinterpret(signed, dtype))
     end
 
     # Print the value that this expression evaluates to and pass on the value.
@@ -5175,7 +5259,7 @@ module Polars
     def rolling_sum_by(
       by,
       window_size,
-      min_samples: 1,
+      min_samples: 0,
       closed: "right"
     )
       window_size = _prepare_rolling_by_window_args(window_size)
@@ -7362,17 +7446,11 @@ module Polars
     #   # └─────┘
     def sample(
       fraction: nil,
-      with_replacement: nil,
+      with_replacement: false,
       shuffle: false,
       seed: nil,
       n: nil
     )
-      # TODO update
-      if with_replacement.nil?
-        warn "The default `with_replacement` for `sample` method will change from `true` to `false` in a future version"
-        with_replacement = true
-      end
-
       if !n.nil? && !fraction.nil?
         raise ArgumentError, "cannot specify both `n` and `fraction`"
       end
@@ -7761,13 +7839,7 @@ module Polars
     #   # ╞═══════════╡
     #   # │ -6.754888 │
     #   # └───────────┘
-    def entropy(base: nil, normalize: true)
-      # TODO update (including param docs)
-      if base.nil?
-        warn "The default `base` for `entropy` method will change from `2` to `Math::E` in a future version"
-        base = 2
-      end
-
+    def entropy(base: Math::E, normalize: true)
       wrap_expr(_rbexpr.entropy(base, normalize))
     end
 
@@ -7823,6 +7895,8 @@ module Polars
     #
     # @param descending [Boolean]
     #   Whether the `Series` order is descending.
+    # @param nulls_last [Boolean]
+    #   Whether the nulls are at the end.
     #
     # @return [Expr]
     #
@@ -7842,12 +7916,16 @@ module Polars
     #   # ╞════════╡
     #   # │ 3      │
     #   # └────────┘
-    def set_sorted(descending: false)
-      wrap_expr(_rbexpr.set_sorted_flag(descending))
+    def set_sorted(descending: false, nulls_last: false)
+      wrap_expr(_rbexpr.set_sorted_flag(descending, nulls_last))
     end
 
     # Aggregate to list.
     #
+    # @param maintain_order [Boolean]
+    #   Whether to preserve the order of elements in the list. Setting this
+    #   to `false` can improve performance, especially within `group_by`.
+    #
     # @return [Expr]
     #
     # @example
@@ -7867,8 +7945,8 @@ module Polars
     #   # ╞═══════════╪═══════════╡
     #   # │ [1, 2, 3] ┆ [4, 5, 6] │
     #   # └───────────┴───────────┘
-    def implode
-      wrap_expr(_rbexpr.implode)
+    def implode(maintain_order: true)
+      wrap_expr(_rbexpr.implode(maintain_order))
     end
 
     # Bin values into buckets and count their occurrences.