polars-df 0.11.0-x86_64-darwin → 0.12.0-x86_64-darwin

data/lib/polars/expr.rb

@@ -82,8 +82,8 @@ module Polars
     #
     # @return [Expr]
     def **(power)
-      exponent = Utils.expr_to_lit_or_expr(power)
-      _from_rbexpr(_rbexpr.pow(exponent._rbexpr))
+      exponent = Utils.parse_into_expression(power)
+      _from_rbexpr(_rbexpr.pow(exponent))
     end
 
     # Greater than or equal.
@@ -811,8 +811,8 @@ module Polars
     #   # │ 10  ┆ 4    │
     #   # └─────┴──────┘
     def append(other, upcast: true)
-      other = Utils.expr_to_lit_or_expr(other)
-      _from_rbexpr(_rbexpr.append(other._rbexpr, upcast))
+      other = Utils.parse_into_expression(other)
+      _from_rbexpr(_rbexpr.append(other, upcast))
     end
 
     # Create a single chunk of memory for this Series.
@@ -1165,8 +1165,8 @@ module Polars
     #   # │ 44  │
     #   # └─────┘
     def dot(other)
-      other = Utils.expr_to_lit_or_expr(other, str_to_lit: false)
-      _from_rbexpr(_rbexpr.dot(other._rbexpr))
+      other = Utils.parse_into_expression(other, str_as_lit: false)
+      _from_rbexpr(_rbexpr.dot(other))
     end
 
     # Compute the most occurring value(s).
@@ -1252,12 +1252,12 @@ module Polars
     #   df = Polars::DataFrame.new(
     #     {
     #       "group" => [
-    #           "one",
-    #           "one",
-    #           "one",
-    #           "two",
-    #           "two",
-    #           "two"
+    #         "one",
+    #         "one",
+    #         "one",
+    #         "two",
+    #         "two",
+    #         "two"
     #       ],
     #       "value" => [1, 98, 2, 3, 99, 4]
     #     }
@@ -1345,9 +1345,9 @@ module Polars
     #   # │ 3     ┆ 4        │
     #   # │ 2     ┆ 98       │
     #   # └───────┴──────────┘
-    def top_k(k: 5, nulls_last: false, multithreaded: true)
-      k = Utils.parse_as_expression(k)
-      _from_rbexpr(_rbexpr.top_k(k, nulls_last, multithreaded))
+    def top_k(k: 5)
+      k = Utils.parse_into_expression(k)
+      _from_rbexpr(_rbexpr.top_k(k))
     end
 
     # Return the `k` smallest elements.
@@ -1384,9 +1384,9 @@ module Polars
     #   # │ 3     ┆ 4        │
     #   # │ 2     ┆ 98       │
     #   # └───────┴──────────┘
-    def bottom_k(k: 5, nulls_last: false, multithreaded: true)
-      k = Utils.parse_as_expression(k)
-      _from_rbexpr(_rbexpr.bottom_k(k, nulls_last, multithreaded))
+    def bottom_k(k: 5)
+      k = Utils.parse_into_expression(k)
+      _from_rbexpr(_rbexpr.bottom_k(k))
     end
 
     # Get the index values that would sort this column.
@@ -1498,8 +1498,8 @@ module Polars
     #   # │ 0    ┆ 2     ┆ 4   │
     #   # └──────┴───────┴─────┘
     def search_sorted(element, side: "any")
-      element = Utils.expr_to_lit_or_expr(element, str_to_lit: false)
-      _from_rbexpr(_rbexpr.search_sorted(element._rbexpr, side))
+      element = Utils.parse_into_expression(element, str_as_lit: false)
+      _from_rbexpr(_rbexpr.search_sorted(element, side))
     end
 
     # Sort this column by the ordering of another column, or multiple other columns.
@@ -1545,13 +1545,14 @@ module Polars
     #   # │ two   │
     #   # └───────┘
     def sort_by(by, *more_by, reverse: false, nulls_last: false, multithreaded: true, maintain_order: false)
-      by = Utils.parse_as_list_of_expressions(by, *more_by)
-      if !reverse.is_a?(::Array)
-        reverse = [reverse]
-      elsif by.length != reverse.length
-        raise ArgumentError, "the length of `reverse` (#{reverse.length}) does not match the length of `by` (#{by.length})"
-      end
-      _from_rbexpr(_rbexpr.sort_by(by, reverse, nulls_last, multithreaded, maintain_order))
+      by = Utils.parse_into_list_of_expressions(by, *more_by)
+      reverse = Utils.extend_bool(reverse, by.length, "reverse", "by")
+      nulls_last = Utils.extend_bool(nulls_last, by.length, "nulls_last", "by")
+      _from_rbexpr(
+        _rbexpr.sort_by(
+          by, reverse, nulls_last, multithreaded, maintain_order
+        )
+      )
     end
 
     # Take values by index.
@@ -1588,14 +1589,51 @@ module Polars
     #   # └───────┴───────────┘
     def gather(indices)
       if indices.is_a?(::Array)
-        indices_lit = Polars.lit(Series.new("", indices, dtype: :u32))
+        indices_lit = Polars.lit(Series.new("", indices, dtype: :u32))._rbexpr
       else
-        indices_lit = Utils.expr_to_lit_or_expr(indices, str_to_lit: false)
+        indices_lit = Utils.parse_into_expression(indices, str_as_lit: false)
       end
-      _from_rbexpr(_rbexpr.gather(indices_lit._rbexpr))
+      _from_rbexpr(_rbexpr.gather(indices_lit))
     end
     alias_method :take, :gather
 
+    # Return a single value by index.
+    #
+    # @param index [Object]
+    #   An expression that leads to a UInt32 index.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "group" => [
+    #         "one",
+    #         "one",
+    #         "one",
+    #         "two",
+    #         "two",
+    #         "two"
+    #       ],
+    #       "value" => [1, 98, 2, 3, 99, 4]
+    #     }
+    #   )
+    #   df.group_by("group", maintain_order: true).agg(Polars.col("value").get(1))
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌───────┬───────┐
+    #   # │ group ┆ value │
+    #   # │ ---   ┆ ---   │
+    #   # │ str   ┆ i64   │
+    #   # ╞═══════╪═══════╡
+    #   # │ one   ┆ 98    │
+    #   # │ two   ┆ 99    │
+    #   # └───────┴───────┘
+    def get(index)
+      index_lit = Utils.parse_into_expression(index)
+      _from_rbexpr(_rbexpr.get(index_lit))
+    end
+
     # Shift the values by a given period.
     #
     # @param n [Integer]
@@ -1622,9 +1660,9 @@ module Polars
     #   # └──────┘
     def shift(n = 1, fill_value: nil)
       if !fill_value.nil?
-        fill_value = Utils.parse_as_expression(fill_value, str_as_lit: true)
+        fill_value = Utils.parse_into_expression(fill_value, str_as_lit: true)
       end
-      n = Utils.parse_as_expression(n)
+      n = Utils.parse_into_expression(n)
       _from_rbexpr(_rbexpr.shift(n, fill_value))
     end
 
@@ -1727,8 +1765,8 @@ module Polars
       end
 
       if !value.nil?
-        value = Utils.expr_to_lit_or_expr(value, str_to_lit: true)
-        _from_rbexpr(_rbexpr.fill_null(value._rbexpr))
+        value = Utils.parse_into_expression(value, str_as_lit: true)
+        _from_rbexpr(_rbexpr.fill_null(value))
       else
         _from_rbexpr(_rbexpr.fill_null_with_strategy(strategy, limit))
       end
@@ -1758,8 +1796,8 @@ module Polars
     #   # │ zero ┆ 6.0  │
     #   # └──────┴──────┘
     def fill_nan(fill_value)
-      fill_value = Utils.expr_to_lit_or_expr(fill_value, str_to_lit: true)
-      _from_rbexpr(_rbexpr.fill_nan(fill_value._rbexpr))
+      fill_value = Utils.parse_into_expression(fill_value, str_as_lit: true)
+      _from_rbexpr(_rbexpr.fill_nan(fill_value))
     end
 
     # Fill missing values with the latest seen values.
@@ -2275,7 +2313,7 @@ module Polars
     #   # │ 4      │
     #   # └────────┘
     def over(expr)
-      rbexprs = Utils.selection_to_rbexpr_list(expr)
+      rbexprs = Utils.parse_into_list_of_expressions(expr)
       _from_rbexpr(_rbexpr.over(rbexprs))
     end
 
@@ -2470,8 +2508,8 @@ module Polars
     #   # │ 1.5 │
     #   # └─────┘
     def quantile(quantile, interpolation: "nearest")
-      quantile = Utils.expr_to_lit_or_expr(quantile, str_to_lit: false)
-      _from_rbexpr(_rbexpr.quantile(quantile._rbexpr, interpolation))
+      quantile = Utils.parse_into_expression(quantile, str_as_lit: false)
+      _from_rbexpr(_rbexpr.quantile(quantile, interpolation))
     end
 
     # Bin continuous values into discrete categories.
@@ -2515,17 +2553,17 @@ module Polars
     #   ).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]   │
-    #   # └─────┴──────┴────────────┘
+    #   # ┌─────┬────────────┬────────────┐
+    #   # │ foo ┆ breakpoint ┆ category   │
+    #   # │ --- ┆ ---        ┆ ---        │
+    #   # │ 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)
       _from_rbexpr(_rbexpr.cut(breaks, labels, left_closed, include_breaks))
     end
@@ -2596,17 +2634,17 @@ module Polars
     #   ).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]   │
-    #   # └─────┴──────┴────────────┘
+    #   # ┌─────┬────────────┬────────────┐
+    #   # │ foo ┆ breakpoint ┆ category   │
+    #   # │ --- ┆ ---        ┆ ---        │
+    #   # │ 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(
@@ -2630,18 +2668,18 @@ module Polars
     #   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      │
-    #   # └─────────┴────────┘
+    #   # ┌─────┬───────┐
+    #   # │ len ┆ value │
+    #   # │ --- ┆ ---   │
+    #   # │ u32 ┆ i64   │
+    #   # ╞═════╪═══════╡
+    #   # │ 2   ┆ 1     │
+    #   # │ 1   ┆ 2     │
+    #   # │ 1   ┆ 1     │
+    #   # │ 1   ┆ null  │
+    #   # │ 1   ┆ 1     │
+    #   # │ 2   ┆ 3     │
+    #   # └─────┴───────┘
     def rle
       _from_rbexpr(_rbexpr.rle)
     end
@@ -3104,7 +3142,7 @@ module Polars
     #   # │ null ┆ null ┆ null   ┆ true           │
     #   # └──────┴──────┴────────┴────────────────┘
     def eq_missing(other)
-      other = Utils.parse_as_expression(other, str_as_lit: true)
+      other = Utils.parse_into_expression(other, str_as_lit: true)
       _from_rbexpr(_rbexpr.eq_missing(other))
     end
 
@@ -3308,7 +3346,7 @@ module Polars
     #   # │ null ┆ null ┆ null   ┆ false          │
     #   # └──────┴──────┴────────┴────────────────┘
     def ne_missing(other)
-      other = Utils.parse_as_expression(other, str_as_lit: true)
+      other = Utils.parse_into_expression(other, str_as_lit: true)
       _from_rbexpr(_rbexpr.neq_missing(other))
     end
 
@@ -3611,14 +3649,14 @@ module Polars
     def is_in(other)
       if other.is_a?(::Array)
         if other.length == 0
-          other = Polars.lit(nil)
+          other = Polars.lit(nil)._rbexpr
         else
-          other = Polars.lit(Series.new(other))
+          other = Polars.lit(Series.new(other))._rbexpr
         end
       else
-        other = Utils.expr_to_lit_or_expr(other, str_to_lit: false)
+        other = Utils.parse_into_expression(other, str_as_lit: false)
       end
-      _from_rbexpr(_rbexpr.is_in(other._rbexpr))
+      _from_rbexpr(_rbexpr.is_in(other))
     end
     alias_method :in?, :is_in
 
@@ -3653,15 +3691,15 @@ module Polars
     #   # │ ["z", "z", "z"] │
     #   # └─────────────────┘
     def repeat_by(by)
-      by = Utils.expr_to_lit_or_expr(by, str_to_lit: false)
-      _from_rbexpr(_rbexpr.repeat_by(by._rbexpr))
+      by = Utils.parse_into_expression(by, str_as_lit: false)
+      _from_rbexpr(_rbexpr.repeat_by(by))
     end
 
     # Check if this expression is between start and end.
     #
-    # @param start [Object]
+    # @param lower_bound [Object]
     #   Lower bound as primitive type or datetime.
-    # @param _end [Object]
+    # @param upper_bound [Object]
     #   Upper bound as primitive type or datetime.
     # @param closed ["both", "left", "right", "none"]
     #   Define which sides of the interval are closed (inclusive).
@@ -3723,22 +3761,13 @@ module Polars
     #   # │ d   ┆ false      │
     #   # │ e   ┆ false      │
     #   # └─────┴────────────┘
-    def is_between(start, _end, closed: "both")
-      start = Utils.expr_to_lit_or_expr(start, str_to_lit: false)
-      _end = Utils.expr_to_lit_or_expr(_end, str_to_lit: false)
-
-      case closed
-      when "none"
-        (self > start) & (self < _end)
-      when "both"
-        (self >= start) & (self <= _end)
-      when "right"
-        (self > start) & (self <= _end)
-      when "left"
-        (self >= start) & (self < _end)
-      else
-        raise ArgumentError, "closed must be one of 'left', 'right', 'both', or 'none'"
-      end
+    def is_between(lower_bound, upper_bound, closed: "both")
+      lower_bound = Utils.parse_into_expression(lower_bound)
+      upper_bound = Utils.parse_into_expression(upper_bound)
+
+      _from_rbexpr(
+        _rbexpr.is_between(lower_bound, upper_bound, closed)
+      )
     end
 
     # Hash the elements in the selection.
@@ -3977,7 +4006,7 @@ module Polars
       warn_if_unsorted: nil
     )
       window_size = _prepare_rolling_by_window_args(window_size)
-      by = Utils.parse_as_expression(by)
+      by = Utils.parse_into_expression(by)
       _from_rbexpr(
         _rbexpr.rolling_min_by(by, window_size, min_periods, closed)
       )
@@ -4106,7 +4135,7 @@ module Polars
       warn_if_unsorted: nil
     )
       window_size = _prepare_rolling_by_window_args(window_size)
-      by = Utils.parse_as_expression(by)
+      by = Utils.parse_into_expression(by)
       _from_rbexpr(
         _rbexpr.rolling_max_by(by, window_size, min_periods, closed)
       )
@@ -4237,7 +4266,7 @@ module Polars
       warn_if_unsorted: nil
     )
       window_size = _prepare_rolling_by_window_args(window_size)
-      by = Utils.parse_as_expression(by)
+      by = Utils.parse_into_expression(by)
       _from_rbexpr(
         _rbexpr.rolling_mean_by(
           by,
@@ -4371,7 +4400,7 @@ module Polars
       warn_if_unsorted: nil
     )
       window_size = _prepare_rolling_by_window_args(window_size)
-      by = Utils.parse_as_expression(by)
+      by = Utils.parse_into_expression(by)
       _from_rbexpr(
         _rbexpr.rolling_sum_by(by, window_size, min_periods, closed)
       )
@@ -4503,7 +4532,7 @@ module Polars
       warn_if_unsorted: nil
     )
       window_size = _prepare_rolling_by_window_args(window_size)
-      by = Utils.parse_as_expression(by)
+      by = Utils.parse_into_expression(by)
       _from_rbexpr(
         _rbexpr.rolling_std_by(
           by,
@@ -4641,7 +4670,7 @@ module Polars
       warn_if_unsorted: nil
     )
       window_size = _prepare_rolling_by_window_args(window_size)
-      by = Utils.parse_as_expression(by)
+      by = Utils.parse_into_expression(by)
       _from_rbexpr(
         _rbexpr.rolling_var_by(
           by,
@@ -4752,7 +4781,7 @@ module Polars
       warn_if_unsorted: nil
     )
       window_size = _prepare_rolling_by_window_args(window_size)
-      by = Utils.parse_as_expression(by)
+      by = Utils.parse_into_expression(by)
       _from_rbexpr(
         _rbexpr.rolling_median_by(by, window_size, min_periods, closed)
       )
@@ -4863,7 +4892,7 @@ module Polars
       warn_if_unsorted: nil
     )
       window_size = _prepare_rolling_by_window_args(window_size)
-      by = Utils.parse_as_expression(by)
+      by = Utils.parse_into_expression(by)
       _from_rbexpr(
         _rbexpr.rolling_quantile_by(
           by,
@@ -4908,12 +4937,6 @@ module Polars
     #   a result. If None, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
-    # @param by [String]
-    #   If the `window_size` is temporal for instance `"5h"` or `"3s`, you must
-    #   set the column that will be used to determine the windows. This column must
-    #   be of dtype `{Date, Datetime}`
-    # @param closed ["left", "right", "both", "none"]
-    #   Define whether the temporal window interval is closed or not.
     #
     # @note
     #   This functionality is experimental and may change without it being considered a
@@ -4951,24 +4974,8 @@ module Polars
       window_size,
       weights: nil,
       min_periods: nil,
-      center: false,
-      by: nil,
-      closed: nil
+      center: false
     )
-      window_size, min_periods = _prepare_rolling_window_args(
-        window_size, min_periods
-      )
-      if !by.nil?
-        Utils.validate_rolling_by_aggs_arguments(weights, center: center)
-        return rolling_min_by(
-          by,
-          window_size,
-          min_periods: min_periods,
-          closed: closed || "right",
-          warn_if_unsorted: warn_if_unsorted
-        )
-      end
-      window_size = Utils.validate_rolling_aggs_arguments(window_size, closed)
       _from_rbexpr(
         _rbexpr.rolling_min(
           window_size, weights, min_periods, center
@@ -5008,12 +5015,6 @@ module Polars
     #   a result. If None, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
-    # @param by [String]
-    #   If the `window_size` is temporal for instance `"5h"` or `"3s`, you must
-    #   set the column that will be used to determine the windows. This column must
-    #   be of dtype `{Date, Datetime}`
-    # @param closed ["left", "right", "both", "none"]
-    #   Define whether the temporal window interval is closed or not.
     #
     # @note
     #   This functionality is experimental and may change without it being considered a
@@ -5051,24 +5052,8 @@ module Polars
       window_size,
       weights: nil,
       min_periods: nil,
-      center: false,
-      by: nil,
-      closed: nil
+      center: false
     )
-      window_size, min_periods = _prepare_rolling_window_args(
-        window_size, min_periods
-      )
-      if !by.nil?
-        Utils.validate_rolling_by_aggs_arguments(weights, center: center)
-        return rolling_max_by(
-          by,
-          window_size,
-          min_periods: min_periods,
-          closed: closed || "right",
-          warn_if_unsorted: warn_if_unsorted
-        )
-      end
-      window_size = Utils.validate_rolling_aggs_arguments(window_size, closed)
       _from_rbexpr(
         _rbexpr.rolling_max(
           window_size, weights, min_periods, center
@@ -5108,12 +5093,6 @@ module Polars
     #   a result. If None, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
-    # @param by [String]
-    #   If the `window_size` is temporal for instance `"5h"` or `"3s`, you must
-    #   set the column that will be used to determine the windows. This column must
-    #   be of dtype `{Date, Datetime}`
-    # @param closed ["left", "right", "both", "none"]
-    #   Define whether the temporal window interval is closed or not.
     #
     # @note
     #   This functionality is experimental and may change without it being considered a
@@ -5151,24 +5130,8 @@ module Polars
       window_size,
       weights: nil,
       min_periods: nil,
-      center: false,
-      by: nil,
-      closed: nil
+      center: false
     )
-      window_size, min_periods = _prepare_rolling_window_args(
-        window_size, min_periods
-      )
-      if !by.nil?
-        Utils.validate_rolling_by_aggs_arguments(weights, center: center)
-        return rolling_mean_by(
-          by,
-          window_size,
-          min_periods: min_periods,
-          closed: closed || "right",
-          warn_if_unsorted: warn_if_unsorted
-        )
-      end
-      window_size = Utils.validate_rolling_aggs_arguments(window_size, closed)
       _from_rbexpr(
         _rbexpr.rolling_mean(
           window_size, weights, min_periods, center
@@ -5208,12 +5171,6 @@ module Polars
     #   a result. If None, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
-    # @param by [String]
-    #   If the `window_size` is temporal for instance `"5h"` or `"3s`, you must
-    #   set the column that will be used to determine the windows. This column must
-    #   be of dtype `{Date, Datetime}`
-    # @param closed ["left", "right", "both", "none"]
-    #   Define whether the temporal window interval is closed or not.
     #
     # @note
     #   This functionality is experimental and may change without it being considered a
@@ -5251,24 +5208,8 @@ module Polars
       window_size,
       weights: nil,
       min_periods: nil,
-      center: false,
-      by: nil,
-      closed: nil
+      center: false
     )
-      window_size, min_periods = _prepare_rolling_window_args(
-        window_size, min_periods
-      )
-      if !by.nil?
-        Utils.validate_rolling_by_aggs_arguments(weights, center: center)
-        return rolling_sum_by(
-          by,
-          window_size,
-          min_periods: min_periods,
-          closed: closed || "right",
-          warn_if_unsorted: warn_if_unsorted
-        )
-      end
-      window_size = Utils.validate_rolling_aggs_arguments(window_size, closed)
       _from_rbexpr(
         _rbexpr.rolling_sum(
           window_size, weights, min_periods, center
@@ -5308,12 +5249,6 @@ module Polars
     #   a result. If None, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
-    # @param by [String]
-    #   If the `window_size` is temporal for instance `"5h"` or `"3s`, you must
-    #   set the column that will be used to determine the windows. This column must
-    #   be of dtype `{Date, Datetime}`
-    # @param closed ["left", "right", "both", "none"]
-    #   Define whether the temporal window interval is closed or not.
     #
     # @note
     #   This functionality is experimental and may change without it being considered a
@@ -5352,26 +5287,8 @@ module Polars
       weights: nil,
       min_periods: nil,
       center: false,
-      by: nil,
-      closed: nil,
-      ddof: 1,
-      warn_if_unsorted: true
+      ddof: 1
     )
-      window_size, min_periods = _prepare_rolling_window_args(
-        window_size, min_periods
-      )
-      if !by.nil?
-        Utils.validate_rolling_by_aggs_arguments(weights, center: center)
-        return rolling_std_by(
-          by,
-          window_size,
-          min_periods: min_periods,
-          closed: closed || "right",
-          ddof: ddof,
-          warn_if_unsorted: warn_if_unsorted
-        )
-      end
-      window_size = Utils.validate_rolling_aggs_arguments(window_size, closed)
       _from_rbexpr(
         _rbexpr.rolling_std(
           window_size, weights, min_periods, center, ddof
@@ -5411,12 +5328,6 @@ module Polars
     #   a result. If None, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
-    # @param by [String]
-    #   If the `window_size` is temporal for instance `"5h"` or `"3s`, you must
-    #   set the column that will be used to determine the windows. This column must
-    #   be of dtype `{Date, Datetime}`
-    # @param closed ["left", "right", "both", "none"]
-    #   Define whether the temporal window interval is closed or not.
     #
     # @note
     #   This functionality is experimental and may change without it being considered a
@@ -5455,26 +5366,8 @@ module Polars
       weights: nil,
       min_periods: nil,
       center: false,
-      by: nil,
-      closed: nil,
-      ddof: 1,
-      warn_if_unsorted: true
+      ddof: 1
     )
-      window_size, min_periods = _prepare_rolling_window_args(
-        window_size, min_periods
-      )
-      if !by.nil?
-        Utils.validate_rolling_by_aggs_arguments(weights, center: center)
-        return rolling_var_by(
-          by,
-          window_size,
-          min_periods: min_periods,
-          closed: closed || "right",
-          ddof: ddof,
-          warn_if_unsorted: warn_if_unsorted
-        )
-      end
-      window_size = Utils.validate_rolling_aggs_arguments(window_size, closed)
       _from_rbexpr(
         _rbexpr.rolling_var(
           window_size, weights, min_periods, center, ddof
@@ -5510,12 +5403,6 @@ module Polars
     #   a result. If None, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
-    # @param by [String]
-    #   If the `window_size` is temporal for instance `"5h"` or `"3s`, you must
-    #   set the column that will be used to determine the windows. This column must
-    #   be of dtype `{Date, Datetime}`
-    # @param closed ["left", "right", "both", "none"]
-    #   Define whether the temporal window interval is closed or not.
     #
     # @note
     #   This functionality is experimental and may change without it being considered a
@@ -5553,25 +5440,8 @@ module Polars
       window_size,
       weights: nil,
       min_periods: nil,
-      center: false,
-      by: nil,
-      closed: nil,
-      warn_if_unsorted: true
+      center: false
     )
-      window_size, min_periods = _prepare_rolling_window_args(
-        window_size, min_periods
-      )
-      if !by.nil?
-        Utils.validate_rolling_by_aggs_arguments(weights, center: center)
-        return rolling_median_by(
-          by,
-          window_size,
-          min_periods: min_periods,
-          closed: closed || "right",
-          warn_if_unsorted: warn_if_unsorted
-        )
-      end
-      window_size = Utils.validate_rolling_aggs_arguments(window_size, closed)
       _from_rbexpr(
         _rbexpr.rolling_median(
           window_size, weights, min_periods, center
@@ -5611,12 +5481,6 @@ module Polars
     #   a result. If None, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
-    # @param by [String]
-    #   If the `window_size` is temporal for instance `"5h"` or `"3s`, you must
-    #   set the column that will be used to determine the windows. This column must
-    #   be of dtype `{Date, Datetime}`
-    # @param closed ["left", "right", "both", "none"]
-    #   Define whether the temporal window interval is closed or not.
     #
     # @note
     #   This functionality is experimental and may change without it being considered a
@@ -5656,26 +5520,8 @@ module Polars
       window_size: 2,
       weights: nil,
       min_periods: nil,
-      center: false,
-      by: nil,
-      closed: nil,
-      warn_if_unsorted: true
+      center: false
     )
-      window_size, min_periods = _prepare_rolling_window_args(
-        window_size, min_periods
-      )
-      if !by.nil?
-        Utils.validate_rolling_by_aggs_arguments(weights, center: center)
-        return rolling_quantile_by(
-          by,
-          window_size,
-          min_periods: min_periods,
-          closed: closed || "right",
-          warn_if_unsorted: warn_if_unsorted,
-          quantile: quantile
-        )
-      end
-      window_size = Utils.validate_rolling_aggs_arguments(window_size, closed)
       _from_rbexpr(
         _rbexpr.rolling_quantile(
           quantile, interpolation, window_size, weights, min_periods, center
@@ -5947,7 +5793,7 @@ module Polars
     #   # │ 12   ┆ 0.0        │
     #   # └──────┴────────────┘
     def pct_change(n: 1)
-      n = Utils.parse_as_expression(n)
+      n = Utils.parse_into_expression(n)
       _from_rbexpr(_rbexpr.pct_change(n))
     end
 
@@ -6039,12 +5885,12 @@ module Polars
     #   # │ null ┆ null        │
     #   # │ 50   ┆ 10          │
     #   # └──────┴─────────────┘
-    def clip(lower_bound, upper_bound)
+    def clip(lower_bound = nil, upper_bound = nil)
       if !lower_bound.nil?
-        lower_bound = Utils.parse_as_expression(lower_bound, str_as_lit: true)
+        lower_bound = Utils.parse_into_expression(lower_bound)
       end
       if !upper_bound.nil?
-        upper_bound = Utils.parse_as_expression(upper_bound, str_as_lit: true)
+        upper_bound = Utils.parse_into_expression(upper_bound)
       end
       _from_rbexpr(_rbexpr.clip(lower_bound, upper_bound))
     end
@@ -6431,18 +6277,38 @@ module Polars
     #
     # @example
     #   df = Polars::DataFrame.new({"foo" => [1, 2, 3, 4, 5, 6, 7, 8, 9]})
-    #   df.select(Polars.col("foo").reshape([3, 3]))
+    #   square = df.select(Polars.col("foo").reshape([3, 3]))
     #   # =>
     #   # shape: (3, 1)
-    #   # ┌───────────┐
-    #   # │ foo       │
-    #   # │ ---       │
-    #   # │ list[i64] │
-    #   # ╞═══════════╡
-    #   # │ [1, 2, 3] │
-    #   # │ [4, 5, 6] │
-    #   # │ [7, 8, 9] │
-    #   # └───────────┘
+    #   # ┌───────────────┐
+    #   # │ foo           │
+    #   # │ ---           │
+    #   # │ array[i64, 3] │
+    #   # ╞═══════════════╡
+    #   # │ [1, 2, 3]     │
+    #   # │ [4, 5, 6]     │
+    #   # │ [7, 8, 9]     │
+    #   # └───────────────┘
+    #
+    # @example
+    #   square.select(Polars.col("foo").reshape([9]))
+    #   # =>
+    #   # shape: (9, 1)
+    #   # ┌─────┐
+    #   # │ foo │
+    #   # │ --- │
+    #   # │ i64 │
+    #   # ╞═════╡
+    #   # │ 1   │
+    #   # │ 2   │
+    #   # │ 3   │
+    #   # │ 4   │
+    #   # │ 5   │
+    #   # │ 6   │
+    #   # │ 7   │
+    #   # │ 8   │
+    #   # │ 9   │
+    #   # └─────┘
     def reshape(dims)
       _from_rbexpr(_rbexpr.reshape(dims))
     end
@@ -6518,14 +6384,14 @@ module Polars
       end
 
       if !n.nil? && frac.nil?
-        n = Utils.parse_as_expression(n)
+        n = Utils.parse_into_expression(n)
         return _from_rbexpr(_rbexpr.sample_n(n, with_replacement, shuffle, seed))
       end
 
       if frac.nil?
         frac = 1.0
       end
-      frac = Utils.parse_as_expression(frac)
+      frac = Utils.parse_into_expression(frac)
       _from_rbexpr(
         _rbexpr.sample_frac(frac, with_replacement, shuffle, seed)
       )
@@ -6658,11 +6524,17 @@ module Polars
 
     # Count all unique values and create a struct mapping value to count.
     #
-    # @param multithreaded [Boolean]
-    #   Better to turn this off in the aggregation context, as it can lead to
-    #   contention.
     # @param sort [Boolean]
-    #   Ensure the output is sorted from most values to least.
+    #   Sort the output by count in descending order.
+    #   If set to `false` (default), the order of the output is random.
+    # @param parallel [Boolean]
+    #   Execute the computation in parallel.
+    # @param name [String]
+    #   Give the resulting count column a specific name;
+    #   if `normalize` is true defaults to "count",
+    #   otherwise defaults to "proportion".
+    # @param normalize [Boolean]
+    #   If true gives relative frequencies of the unique values
     #
     # @return [Expr]
     #
@@ -6688,8 +6560,22 @@ module Polars
     #   # │ {"b",2}   │
     #   # │ {"a",1}   │
     #   # └───────────┘
-    def value_counts(multithreaded: false, sort: false)
-      _from_rbexpr(_rbexpr.value_counts(multithreaded, sort))
+    def value_counts(
+      sort: false,
+      parallel: false,
+      name: nil,
+      normalize: false
+    )
+      if name.nil?
+        if normalize
+          name = "proportion"
+        else
+          name = "count"
+        end
+      end
+      _from_rbexpr(
+        _rbexpr.value_counts(sort, parallel, name, normalize)
+      )
     end
 
     # Return a count of the unique values in the order of appearance.
@@ -7064,6 +6950,10 @@ module Polars
     #   # │ 3   ┆ 1.0 ┆ 10.0     │
     #   # └─────┴─────┴──────────┘
     def replace(old, new = NO_DEFAULT, default: NO_DEFAULT, return_dtype: nil)
+      if !default.eql?(NO_DEFAULT)
+        return replace_strict(old, new, default: default, return_dtype: return_dtype)
+      end
+
       if new.eql?(NO_DEFAULT) && old.is_a?(Hash)
         new = Series.new(old.values)
         old = Series.new(old.keys)
@@ -7076,17 +6966,164 @@ module Polars
         end
       end
 
-      old = Utils.parse_as_expression(old, str_as_lit: true)
-      new = Utils.parse_as_expression(new, str_as_lit: true)
+      old = Utils.parse_into_expression(old, str_as_lit: true)
+      new = Utils.parse_into_expression(new, str_as_lit: true)
 
-      default =
-        if default.eql?(NO_DEFAULT)
-          nil
-        else
-          Utils.parse_as_expression(default, str_as_lit: true)
-        end
+      result = _from_rbexpr(_rbexpr.replace(old, new))
+
+      if !return_dtype.nil?
+        result = result.cast(return_dtype)
+      end
+
+      result
+    end
+
+    # Replace all values by different values.
+    #
+    # @param old [Object]
+    #   Value or sequence of values to replace.
+    #   Accepts expression input. Sequences are parsed as Series,
+    #   other non-expression inputs are parsed as literals.
+    #   Also accepts a mapping of values to their replacement as syntactic sugar for
+    #   `replace_all(old: Series.new(mapping.keys), new: Serie.new(mapping.values))`.
+    # @param new [Object]
+    #   Value or sequence of values to replace by.
+    #   Accepts expression input. Sequences are parsed as Series,
+    #   other non-expression inputs are parsed as literals.
+    #   Length must match the length of `old` or have length 1.
+    # @param default [Object]
+    #   Set values that were not replaced to this value. If no default is specified,
+    #   (default), an error is raised if any values were not replaced.
+    #   Accepts expression input. Non-expression inputs are parsed as literals.
+    # @param return_dtype [Object]
+    #   The data type of the resulting expression. If set to `nil` (default),
+    #   the data type is determined automatically based on the other inputs.
+    #
+    # @return [Expr]
+    #
+    # @note
+    #   The global string cache must be enabled when replacing categorical values.
+    #
+    # @example Replace values by passing sequences to the `old` and `new` parameters.
+    #   df = Polars::DataFrame.new({"a" => [1, 2, 2, 3]})
+    #   df.with_columns(
+    #     replaced: Polars.col("a").replace_strict([1, 2, 3], [100, 200, 300])
+    #   )
+    #   # =>
+    #   # shape: (4, 2)
+    #   # ┌─────┬──────────┐
+    #   # │ a   ┆ replaced │
+    #   # │ --- ┆ ---      │
+    #   # │ i64 ┆ i64      │
+    #   # ╞═════╪══════════╡
+    #   # │ 1   ┆ 100      │
+    #   # │ 2   ┆ 200      │
+    #   # │ 2   ┆ 200      │
+    #   # │ 3   ┆ 300      │
+    #   # └─────┴──────────┘
+    #
+    # @example By default, an error is raised if any non-null values were not replaced. Specify a default to set all values that were not matched.
+    #   mapping = {2 => 200, 3 => 300}
+    #   df.with_columns(replaced: Polars.col("a").replace_strict(mapping, default: -1))
+    #   # =>
+    #   # shape: (4, 2)
+    #   # ┌─────┬──────────┐
+    #   # │ a   ┆ replaced │
+    #   # │ --- ┆ ---      │
+    #   # │ i64 ┆ i64      │
+    #   # ╞═════╪══════════╡
+    #   # │ 1   ┆ -1       │
+    #   # │ 2   ┆ 200      │
+    #   # │ 2   ┆ 200      │
+    #   # │ 3   ┆ 300      │
+    #   # └─────┴──────────┘
+    #
+    # @example Replacing by values of a different data type sets the return type based on a combination of the `new` data type and the `default` data type.
+    #   df = Polars::DataFrame.new({"a" => ["x", "y", "z"]})
+    #   mapping = {"x" => 1, "y" => 2, "z" => 3}
+    #   df.with_columns(replaced: Polars.col("a").replace_strict(mapping))
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────┬──────────┐
+    #   # │ a   ┆ replaced │
+    #   # │ --- ┆ ---      │
+    #   # │ str ┆ i64      │
+    #   # ╞═════╪══════════╡
+    #   # │ x   ┆ 1        │
+    #   # │ y   ┆ 2        │
+    #   # │ z   ┆ 3        │
+    #   # └─────┴──────────┘
+    #
+    # @example
+    #   df.with_columns(replaced: Polars.col("a").replace_strict(mapping, default: "x"))
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────┬──────────┐
+    #   # │ a   ┆ replaced │
+    #   # │ --- ┆ ---      │
+    #   # │ str ┆ str      │
+    #   # ╞═════╪══════════╡
+    #   # │ x   ┆ 1        │
+    #   # │ y   ┆ 2        │
+    #   # │ z   ┆ 3        │
+    #   # └─────┴──────────┘
+    #
+    # @example Set the `return_dtype` parameter to control the resulting data type directly.
+    #   df.with_columns(
+    #     replaced: Polars.col("a").replace_strict(mapping, return_dtype: Polars::UInt8)
+    #   )
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────┬──────────┐
+    #   # │ a   ┆ replaced │
+    #   # │ --- ┆ ---      │
+    #   # │ str ┆ u8       │
+    #   # ╞═════╪══════════╡
+    #   # │ x   ┆ 1        │
+    #   # │ y   ┆ 2        │
+    #   # │ z   ┆ 3        │
+    #   # └─────┴──────────┘
+    #
+    # @example Expression input is supported for all parameters.
+    #   df = Polars::DataFrame.new({"a" => [1, 2, 2, 3], "b" => [1.5, 2.5, 5.0, 1.0]})
+    #   df.with_columns(
+    #     replaced: Polars.col("a").replace_strict(
+    #       Polars.col("a").max,
+    #       Polars.col("b").sum,
+    #       default: Polars.col("b")
+    #     )
+    #   )
+    #   # =>
+    #   # shape: (4, 3)
+    #   # ┌─────┬─────┬──────────┐
+    #   # │ a   ┆ b   ┆ replaced │
+    #   # │ --- ┆ --- ┆ ---      │
+    #   # │ i64 ┆ f64 ┆ f64      │
+    #   # ╞═════╪═════╪══════════╡
+    #   # │ 1   ┆ 1.5 ┆ 1.5      │
+    #   # │ 2   ┆ 2.5 ┆ 2.5      │
+    #   # │ 2   ┆ 5.0 ┆ 5.0      │
+    #   # │ 3   ┆ 1.0 ┆ 10.0     │
+    #   # └─────┴─────┴──────────┘
+    def replace_strict(
+      old,
+      new = NO_DEFAULT,
+      default: NO_DEFAULT,
+      return_dtype: nil
+    )
+      if new.eql?(NO_DEFAULT) && old.is_a?(Hash)
+        new = Series.new(old.values)
+        old = Series.new(old.keys)
+      end
 
-      _from_rbexpr(_rbexpr.replace(old, new, default, return_dtype))
+      old = Utils.parse_into_expression(old, str_as_lit: true, list_as_series: true)
+      new = Utils.parse_into_expression(new, str_as_lit: true, list_as_series: true)
+
+      default = default.eql?(NO_DEFAULT) ? nil : Utils.parse_into_expression(default, str_as_lit: true)
+
+      _from_rbexpr(
+        _rbexpr.replace_strict(old, new, default, return_dtype)
+      )
     end
 
     # Create an object namespace of all list related methods.
@@ -7163,7 +7200,7 @@ module Polars
     end
 
     def _to_expr(other)
-      other.is_a?(Expr) ? other : Utils.lit(other)
+      other.is_a?(Expr) ? other : F.lit(other)
     end
 
     def _prepare_alpha(com, span, half_life, alpha)