polars-df 0.10.0-x86_64-darwin → 0.11.0-x86_64-darwin

data/lib/polars/expr.rb

@@ -1345,9 +1345,9 @@ module Polars
     #   # │ 3     ┆ 4        │
     #   # │ 2     ┆ 98       │
     #   # └───────┴──────────┘
-    def top_k(k: 5)
+    def top_k(k: 5, nulls_last: false, multithreaded: true)
       k = Utils.parse_as_expression(k)
-      _from_rbexpr(_rbexpr.top_k(k))
+      _from_rbexpr(_rbexpr.top_k(k, nulls_last, multithreaded))
     end
 
     # Return the `k` smallest elements.
@@ -1384,9 +1384,9 @@ module Polars
     #   # │ 3     ┆ 4        │
     #   # │ 2     ┆ 98       │
     #   # └───────┴──────────┘
-    def bottom_k(k: 5)
+    def bottom_k(k: 5, nulls_last: false, multithreaded: true)
       k = Utils.parse_as_expression(k)
-      _from_rbexpr(_rbexpr.bottom_k(k))
+      _from_rbexpr(_rbexpr.bottom_k(k, nulls_last, multithreaded))
     end
 
     # Get the index values that would sort this column.
@@ -2764,6 +2764,9 @@ module Polars
     #   Dtype of the output Series.
     # @param agg_list [Boolean]
     #   Aggregate list.
+    # @param is_elementwise [Boolean]
+    #   If set to true this can run in the streaming engine, but may yield
+    #   incorrect results in group-by. Ensure you know what you are doing!
     #
     # @return [Expr]
     #
@@ -2784,12 +2787,21 @@ module Polars
     #   # ╞══════╪════════╡
     #   # │ 1    ┆ 0      │
     #   # └──────┴────────┘
-    # def map(return_dtype: nil, agg_list: false, &f)
+    # def map_batches(return_dtype: nil, agg_list: false, is_elementwise: false, &f)
     #   if !return_dtype.nil?
     #     return_dtype = Utils.rb_type_to_dtype(return_dtype)
     #   end
-    #   _from_rbexpr(_rbexpr.map(f, return_dtype, agg_list))
+    #   _from_rbexpr(
+    #     _rbexpr.map_batches(
+    #       # TODO _map_batches_wrapper
+    #       f,
+    #       return_dtype,
+    #       agg_list,
+    #       is_elementwise
+    #     )
+    #   )
     # end
+    # alias_method :map, :map_batches
 
     # Apply a custom/user-defined function (UDF) in a GroupBy or Projection context.
     #
@@ -2831,7 +2843,7 @@ module Polars
     #
     # @example In a selection context, the function is applied by row.
     #   df.with_column(
-    #     Polars.col("a").apply { |x| x * 2 }.alias("a_times_2")
+    #     Polars.col("a").map_elements { |x| x * 2 }.alias("a_times_2")
     #   )
     #   # =>
     #   # shape: (4, 3)
@@ -2851,7 +2863,7 @@ module Polars
     #     .group_by("b", maintain_order: true)
     #     .agg(
     #       [
-    #         Polars.col("a").apply { |x| x.sum }
+    #         Polars.col("a").map_elements { |x| x.sum }
     #       ]
     #     )
     #     .collect
@@ -2866,12 +2878,23 @@ module Polars
     #   # │ b   ┆ 2   │
     #   # │ c   ┆ 4   │
     #   # └─────┴─────┘
-    # def apply(return_dtype: nil, &f)
-    #   wrap_f = lambda do |x|
-    #     x.apply(return_dtype: return_dtype, &f)
+    # def map_elements(
+    #   return_dtype: nil,
+    #   skip_nulls: true,
+    #   pass_name: false,
+    #   strategy: "thread_local",
+    #   &f
+    # )
+    #   if pass_name
+    #     raise Todo
+    #   else
+    #     wrap_f = lambda do |x|
+    #       x.map_elements(return_dtype: return_dtype, skip_nulls: skip_nulls, &f)
+    #     end
     #   end
-    #   map(agg_list: true, return_dtype: return_dtype, &wrap_f)
+    #   map_batches(agg_list: true, return_dtype: return_dtype, &wrap_f)
     # end
+    # alias_method :apply, :map_elements
 
     # Explode a list or utf8 Series. This means that every item is expanded to a new
     # row.
@@ -3857,6 +3880,1002 @@ module Polars
       _from_rbexpr(_rbexpr.interpolate(method))
     end
 
+    # Apply a rolling min based on another column.
+    #
+    # @param by [String]
+    #   This column must be of dtype Datetime or Date.
+    # @param window_size [String]
+    #   The length of the window. Can be a dynamic temporal
+    #   size indicated by a timedelta or the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 calendar day)
+    #   - 1w    (1 calendar week)
+    #   - 1mo   (1 calendar month)
+    #   - 1q    (1 calendar quarter)
+    #   - 1y    (1 calendar year)
+    #
+    #   By "calendar day", we mean the corresponding time on the next day
+    #   (which may not be 24 hours, due to daylight savings). Similarly for
+    #   "calendar week", "calendar month", "calendar quarter", and
+    #   "calendar year".
+    # @param min_periods [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result.
+    # @param closed ['left', 'right', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive),
+    #   defaults to `'right'`.
+    # @param warn_if_unsorted [Boolean]
+    #   Warn if data is not known to be sorted by `by` column.
+    #
+    # @return [Expr]
+    #
+    # @note
+    #   If you want to compute multiple aggregation statistics over the same dynamic
+    #   window, consider using `rolling` - this method can cache the window size
+    #   computation.
+    #
+    # @example Create a DataFrame with a datetime column and a row number column
+    #   start = DateTime.new(2001, 1, 1)
+    #   stop = DateTime.new(2001, 1, 2)
+    #   df_temporal = Polars::DataFrame.new(
+    #     {"date" => Polars.datetime_range(start, stop, "1h", eager: true)}
+    #   ).with_row_index
+    #   # =>
+    #   # shape: (25, 2)
+    #   # ┌───────┬─────────────────────┐
+    #   # │ index ┆ date                │
+    #   # │ ---   ┆ ---                 │
+    #   # │ u32   ┆ datetime[ns]        │
+    #   # ╞═══════╪═════════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 │
+    #   # │ …     ┆ …                   │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 │
+    #   # └───────┴─────────────────────┘
+    #
+    # @example Compute the rolling min with the temporal windows closed on the right (default)
+    #   df_temporal.with_columns(
+    #     rolling_row_min: Polars.col("index").rolling_min_by("date", "2h")
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬─────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_min │
+    #   # │ ---   ┆ ---                 ┆ ---             │
+    #   # │ u32   ┆ datetime[ns]        ┆ u32             │
+    #   # ╞═══════╪═════════════════════╪═════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ 0               │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 0               │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 1               │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 2               │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 3               │
+    #   # │ …     ┆ …                   ┆ …               │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 19              │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 20              │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 21              │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 22              │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 23              │
+    #   # └───────┴─────────────────────┴─────────────────┘
+    def rolling_min_by(
+      by,
+      window_size,
+      min_periods: 1,
+      closed: "right",
+      warn_if_unsorted: nil
+    )
+      window_size = _prepare_rolling_by_window_args(window_size)
+      by = Utils.parse_as_expression(by)
+      _from_rbexpr(
+        _rbexpr.rolling_min_by(by, window_size, min_periods, closed)
+      )
+    end
+
+    # Apply a rolling max based on another column.
+    #
+    # @param by [String]
+    #   This column must be of dtype Datetime or Date.
+    # @param window_size [String]
+    #   The length of the window. Can be a dynamic temporal
+    #   size indicated by a timedelta or the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 calendar day)
+    #   - 1w    (1 calendar week)
+    #   - 1mo   (1 calendar month)
+    #   - 1q    (1 calendar quarter)
+    #   - 1y    (1 calendar year)
+    #
+    #   By "calendar day", we mean the corresponding time on the next day
+    #   (which may not be 24 hours, due to daylight savings). Similarly for
+    #   "calendar week", "calendar month", "calendar quarter", and
+    #   "calendar year".
+    # @param min_periods [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result.
+    # @param closed ['left', 'right', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive),
+    #   defaults to `'right'`.
+    # @param warn_if_unsorted [Boolean]
+    #   Warn if data is not known to be sorted by `by` column.
+    #
+    # @return [Expr]
+    #
+    # @note
+    #   If you want to compute multiple aggregation statistics over the same dynamic
+    #   window, consider using `rolling` - this method can cache the window size
+    #   computation.
+    #
+    # @example Create a DataFrame with a datetime column and a row number column
+    #   start = DateTime.new(2001, 1, 1)
+    #   stop = DateTime.new(2001, 1, 2)
+    #   df_temporal = Polars::DataFrame.new(
+    #       {"date" => Polars.datetime_range(start, stop, "1h", eager: true)}
+    #   ).with_row_index
+    #   # =>
+    #   # shape: (25, 2)
+    #   # ┌───────┬─────────────────────┐
+    #   # │ index ┆ date                │
+    #   # │ ---   ┆ ---                 │
+    #   # │ u32   ┆ datetime[ns]        │
+    #   # ╞═══════╪═════════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 │
+    #   # │ …     ┆ …                   │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 │
+    #   # └───────┴─────────────────────┘
+    #
+    # @example Compute the rolling max with the temporal windows closed on the right (default)
+    #   df_temporal.with_columns(
+    #     rolling_row_max: Polars.col("index").rolling_max_by("date", "2h")
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬─────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_max │
+    #   # │ ---   ┆ ---                 ┆ ---             │
+    #   # │ u32   ┆ datetime[ns]        ┆ u32             │
+    #   # ╞═══════╪═════════════════════╪═════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ 0               │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 1               │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 2               │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 3               │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 4               │
+    #   # │ …     ┆ …                   ┆ …               │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 20              │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 21              │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 22              │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 23              │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 24              │
+    #   # └───────┴─────────────────────┴─────────────────┘
+    #
+    # @example Compute the rolling max with the closure of windows on both sides
+    #   df_temporal.with_columns(
+    #     rolling_row_max: Polars.col("index").rolling_max_by(
+    #       "date", "2h", closed: "both"
+    #     )
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬─────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_max │
+    #   # │ ---   ┆ ---                 ┆ ---             │
+    #   # │ u32   ┆ datetime[ns]        ┆ u32             │
+    #   # ╞═══════╪═════════════════════╪═════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ 0               │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 1               │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 2               │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 3               │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 4               │
+    #   # │ …     ┆ …                   ┆ …               │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 20              │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 21              │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 22              │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 23              │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 24              │
+    #   # └───────┴─────────────────────┴─────────────────┘
+    def rolling_max_by(
+      by,
+      window_size,
+      min_periods: 1,
+      closed: "right",
+      warn_if_unsorted: nil
+    )
+      window_size = _prepare_rolling_by_window_args(window_size)
+      by = Utils.parse_as_expression(by)
+      _from_rbexpr(
+        _rbexpr.rolling_max_by(by, window_size, min_periods, closed)
+      )
+    end
+
+    # Apply a rolling mean based on another column.
+    #
+    # @param by [String]
+    #   This column must be of dtype Datetime or Date.
+    # @param window_size [String]
+    #   The length of the window. Can be a dynamic temporal
+    #   size indicated by a timedelta or the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 calendar day)
+    #   - 1w    (1 calendar week)
+    #   - 1mo   (1 calendar month)
+    #   - 1q    (1 calendar quarter)
+    #   - 1y    (1 calendar year)
+    #
+    #   By "calendar day", we mean the corresponding time on the next day
+    #   (which may not be 24 hours, due to daylight savings). Similarly for
+    #   "calendar week", "calendar month", "calendar quarter", and
+    #   "calendar year".
+    # @param min_periods [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result.
+    # @param closed ['left', 'right', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive),
+    #   defaults to `'right'`.
+    # @param warn_if_unsorted [Boolean]
+    #   Warn if data is not known to be sorted by `by` column.
+    #
+    # @return [Expr]
+    #
+    # @note
+    #   If you want to compute multiple aggregation statistics over the same dynamic
+    #   window, consider using `rolling` - this method can cache the window size
+    #   computation.
+    #
+    # @example Create a DataFrame with a datetime column and a row number column
+    #   start = DateTime.new(2001, 1, 1)
+    #   stop = DateTime.new(2001, 1, 2)
+    #   df_temporal = Polars::DataFrame.new(
+    #       {"date" => Polars.datetime_range(start, stop, "1h", eager: true)}
+    #   ).with_row_index
+    #   # =>
+    #   # shape: (25, 2)
+    #   # ┌───────┬─────────────────────┐
+    #   # │ index ┆ date                │
+    #   # │ ---   ┆ ---                 │
+    #   # │ u32   ┆ datetime[ns]        │
+    #   # ╞═══════╪═════════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 │
+    #   # │ …     ┆ …                   │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 │
+    #   # └───────┴─────────────────────┘
+    #
+    # @example Compute the rolling mean with the temporal windows closed on the right (default)
+    #   df_temporal.with_columns(
+    #     rolling_row_mean: Polars.col("index").rolling_mean_by(
+    #       "date", "2h"
+    #     )
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬──────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_mean │
+    #   # │ ---   ┆ ---                 ┆ ---              │
+    #   # │ u32   ┆ datetime[ns]        ┆ f64              │
+    #   # ╞═══════╪═════════════════════╪══════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ 0.0              │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 0.5              │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 1.5              │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 2.5              │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 3.5              │
+    #   # │ …     ┆ …                   ┆ …                │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 19.5             │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 20.5             │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 21.5             │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 22.5             │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 23.5             │
+    #   # └───────┴─────────────────────┴──────────────────┘
+    #
+    # @example Compute the rolling mean with the closure of windows on both sides
+    #   df_temporal.with_columns(
+    #     rolling_row_mean: Polars.col("index").rolling_mean_by(
+    #       "date", "2h", closed: "both"
+    #     )
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬──────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_mean │
+    #   # │ ---   ┆ ---                 ┆ ---              │
+    #   # │ u32   ┆ datetime[ns]        ┆ f64              │
+    #   # ╞═══════╪═════════════════════╪══════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ 0.0              │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 0.5              │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 1.0              │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 2.0              │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 3.0              │
+    #   # │ …     ┆ …                   ┆ …                │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 19.0             │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 20.0             │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 21.0             │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 22.0             │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 23.0             │
+    #   # └───────┴─────────────────────┴──────────────────┘
+    def rolling_mean_by(
+      by,
+      window_size,
+      min_periods: 1,
+      closed: "right",
+      warn_if_unsorted: nil
+    )
+      window_size = _prepare_rolling_by_window_args(window_size)
+      by = Utils.parse_as_expression(by)
+      _from_rbexpr(
+        _rbexpr.rolling_mean_by(
+          by,
+          window_size,
+          min_periods,
+          closed
+        )
+      )
+    end
+
+    # Apply a rolling sum based on another column.
+    #
+    # @param by [String]
+    #   This column must of dtype `{Date, Datetime}`
+    # @param window_size [String]
+    #   The length of the window. Can be a dynamic temporal
+    #   size indicated by a timedelta or the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 calendar day)
+    #   - 1w    (1 calendar week)
+    #   - 1mo   (1 calendar month)
+    #   - 1q    (1 calendar quarter)
+    #   - 1y    (1 calendar year)
+    #
+    #   By "calendar day", we mean the corresponding time on the next day
+    #   (which may not be 24 hours, due to daylight savings). Similarly for
+    #   "calendar week", "calendar month", "calendar quarter", and
+    #   "calendar year".
+    # @param min_periods [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result.
+    # @param closed ['left', 'right', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive),
+    #   defaults to `'right'`.
+    # @param warn_if_unsorted [Boolean]
+    #   Warn if data is not known to be sorted by `by` column.
+    #
+    # @return [Expr]
+    #
+    # @note
+    #   If you want to compute multiple aggregation statistics over the same dynamic
+    #   window, consider using `rolling` - this method can cache the window size
+    #   computation.
+    #
+    # @example Create a DataFrame with a datetime column and a row number column
+    #   start = DateTime.new(2001, 1, 1)
+    #   stop = DateTime.new(2001, 1, 2)
+    #   df_temporal = Polars::DataFrame.new(
+    #       {"date" => Polars.datetime_range(start, stop, "1h", eager: true)}
+    #   ).with_row_index
+    #   # =>
+    #   # shape: (25, 2)
+    #   # ┌───────┬─────────────────────┐
+    #   # │ index ┆ date                │
+    #   # │ ---   ┆ ---                 │
+    #   # │ u32   ┆ datetime[ns]        │
+    #   # ╞═══════╪═════════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 │
+    #   # │ …     ┆ …                   │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 │
+    #   # └───────┴─────────────────────┘
+    #
+    # @example Compute the rolling sum with the temporal windows closed on the right (default)
+    #   df_temporal.with_columns(
+    #     rolling_row_sum: Polars.col("index").rolling_sum_by("date", "2h")
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬─────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_sum │
+    #   # │ ---   ┆ ---                 ┆ ---             │
+    #   # │ u32   ┆ datetime[ns]        ┆ u32             │
+    #   # ╞═══════╪═════════════════════╪═════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ 0               │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 1               │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 3               │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 5               │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 7               │
+    #   # │ …     ┆ …                   ┆ …               │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 39              │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 41              │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 43              │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 45              │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 47              │
+    #   # └───────┴─────────────────────┴─────────────────┘
+    #
+    # @example Compute the rolling sum with the closure of windows on both sides
+    #   df_temporal.with_columns(
+    #     rolling_row_sum: Polars.col("index").rolling_sum_by(
+    #       "date", "2h", closed: "both"
+    #     )
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬─────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_sum │
+    #   # │ ---   ┆ ---                 ┆ ---             │
+    #   # │ u32   ┆ datetime[ns]        ┆ u32             │
+    #   # ╞═══════╪═════════════════════╪═════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ 0               │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 1               │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 3               │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 6               │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 9               │
+    #   # │ …     ┆ …                   ┆ …               │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 57              │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 60              │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 63              │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 66              │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 69              │
+    #   # └───────┴─────────────────────┴─────────────────┘
+    def rolling_sum_by(
+      by,
+      window_size,
+      min_periods: 1,
+      closed: "right",
+      warn_if_unsorted: nil
+    )
+      window_size = _prepare_rolling_by_window_args(window_size)
+      by = Utils.parse_as_expression(by)
+      _from_rbexpr(
+        _rbexpr.rolling_sum_by(by, window_size, min_periods, closed)
+      )
+    end
+
+    # Compute a rolling standard deviation based on another column.
+    #
+    # @param by [String]
+    #   This column must be of dtype Datetime or Date.
+    # @param window_size [String]
+    #   The length of the window. Can be a dynamic temporal
+    #   size indicated by a timedelta or the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 calendar day)
+    #   - 1w    (1 calendar week)
+    #   - 1mo   (1 calendar month)
+    #   - 1q    (1 calendar quarter)
+    #   - 1y    (1 calendar year)
+    #
+    #   By "calendar day", we mean the corresponding time on the next day
+    #   (which may not be 24 hours, due to daylight savings). Similarly for
+    #   "calendar week", "calendar month", "calendar quarter", and
+    #   "calendar year".
+    # @param min_periods [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result.
+    # @param closed ['left', 'right', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive),
+    #   defaults to `'right'`.
+    # @param ddof [Integer]
+    #   "Delta Degrees of Freedom": The divisor for a length N window is N - ddof
+    # @param warn_if_unsorted [Boolean]
+    #   Warn if data is not known to be sorted by `by` column.
+    #
+    # @return [Expr]
+    #
+    # @note
+    #   If you want to compute multiple aggregation statistics over the same dynamic
+    #   window, consider using `rolling` - this method can cache the window size
+    #   computation.
+    #
+    # @example Create a DataFrame with a datetime column and a row number column
+    #   start = DateTime.new(2001, 1, 1)
+    #   stop = DateTime.new(2001, 1, 2)
+    #   df_temporal = Polars::DataFrame.new(
+    #       {"date" => Polars.datetime_range(start, stop, "1h", eager: true)}
+    #   ).with_row_index
+    #   # =>
+    #   # shape: (25, 2)
+    #   # ┌───────┬─────────────────────┐
+    #   # │ index ┆ date                │
+    #   # │ ---   ┆ ---                 │
+    #   # │ u32   ┆ datetime[ns]        │
+    #   # ╞═══════╪═════════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 │
+    #   # │ …     ┆ …                   │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 │
+    #   # └───────┴─────────────────────┘
+    #
+    # @example Compute the rolling std with the temporal windows closed on the right (default)
+    #   df_temporal.with_columns(
+    #     rolling_row_std: Polars.col("index").rolling_std_by("date", "2h")
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬─────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_std │
+    #   # │ ---   ┆ ---                 ┆ ---             │
+    #   # │ u32   ┆ datetime[ns]        ┆ f64             │
+    #   # ╞═══════╪═════════════════════╪═════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ null            │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 0.707107        │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 0.707107        │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 0.707107        │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 0.707107        │
+    #   # │ …     ┆ …                   ┆ …               │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 0.707107        │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 0.707107        │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 0.707107        │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 0.707107        │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 0.707107        │
+    #   # └───────┴─────────────────────┴─────────────────┘
+    #
+    # @example Compute the rolling std with the closure of windows on both sides
+    #   df_temporal.with_columns(
+    #     rolling_row_std: Polars.col("index").rolling_std_by(
+    #       "date", "2h", closed: "both"
+    #     )
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬─────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_std │
+    #   # │ ---   ┆ ---                 ┆ ---             │
+    #   # │ u32   ┆ datetime[ns]        ┆ f64             │
+    #   # ╞═══════╪═════════════════════╪═════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ null            │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 0.707107        │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 1.0             │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 1.0             │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 1.0             │
+    #   # │ …     ┆ …                   ┆ …               │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 1.0             │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 1.0             │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 1.0             │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 1.0             │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 1.0             │
+    #   # └───────┴─────────────────────┴─────────────────┘
+    def rolling_std_by(
+      by,
+      window_size,
+      min_periods: 1,
+      closed: "right",
+      ddof: 1,
+      warn_if_unsorted: nil
+    )
+      window_size = _prepare_rolling_by_window_args(window_size)
+      by = Utils.parse_as_expression(by)
+      _from_rbexpr(
+        _rbexpr.rolling_std_by(
+          by,
+          window_size,
+          min_periods,
+          closed,
+          ddof
+        )
+      )
+    end
+
+    # Compute a rolling variance based on another column.
+    #
+    # @param by [String]
+    #   This column must be of dtype Datetime or Date.
+    # @param window_size [String]
+    #   The length of the window. Can be a dynamic temporal
+    #   size indicated by a timedelta or the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 calendar day)
+    #   - 1w    (1 calendar week)
+    #   - 1mo   (1 calendar month)
+    #   - 1q    (1 calendar quarter)
+    #   - 1y    (1 calendar year)
+    #
+    #   By "calendar day", we mean the corresponding time on the next day
+    #   (which may not be 24 hours, due to daylight savings). Similarly for
+    #   "calendar week", "calendar month", "calendar quarter", and
+    #   "calendar year".
+    # @param min_periods [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result.
+    # @param closed ['left', 'right', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive),
+    #   defaults to `'right'`.
+    # @param ddof [Integer]
+    #   "Delta Degrees of Freedom": The divisor for a length N window is N - ddof
+    # @param warn_if_unsorted [Boolean]
+    #   Warn if data is not known to be sorted by `by` column.
+    #
+    # @return [Expr]
+    #
+    # @note
+    #   If you want to compute multiple aggregation statistics over the same dynamic
+    #   window, consider using `rolling` - this method can cache the window size
+    #   computation.
+    #
+    # @example Create a DataFrame with a datetime column and a row number column
+    #   start = DateTime.new(2001, 1, 1)
+    #   stop = DateTime.new(2001, 1, 2)
+    #   df_temporal = Polars::DataFrame.new(
+    #       {"date" => Polars.datetime_range(start, stop, "1h", eager: true)}
+    #   ).with_row_index
+    #   # =>
+    #   # shape: (25, 2)
+    #   # ┌───────┬─────────────────────┐
+    #   # │ index ┆ date                │
+    #   # │ ---   ┆ ---                 │
+    #   # │ u32   ┆ datetime[ns]        │
+    #   # ╞═══════╪═════════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 │
+    #   # │ …     ┆ …                   │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 │
+    #   # └───────┴─────────────────────┘
+    #
+    # @example Compute the rolling var with the temporal windows closed on the right (default)
+    #   df_temporal.with_columns(
+    #     rolling_row_var: Polars.col("index").rolling_var_by("date", "2h")
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬─────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_var │
+    #   # │ ---   ┆ ---                 ┆ ---             │
+    #   # │ u32   ┆ datetime[ns]        ┆ f64             │
+    #   # ╞═══════╪═════════════════════╪═════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ null            │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 0.5             │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 0.5             │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 0.5             │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 0.5             │
+    #   # │ …     ┆ …                   ┆ …               │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 0.5             │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 0.5             │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 0.5             │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 0.5             │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 0.5             │
+    #   # └───────┴─────────────────────┴─────────────────┘
+    #
+    # @example Compute the rolling var with the closure of windows on both sides
+    #   df_temporal.with_columns(
+    #     rolling_row_var: Polars.col("index").rolling_var_by(
+    #       "date", "2h", closed: "both"
+    #     )
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬─────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_var │
+    #   # │ ---   ┆ ---                 ┆ ---             │
+    #   # │ u32   ┆ datetime[ns]        ┆ f64             │
+    #   # ╞═══════╪═════════════════════╪═════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ null            │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 0.5             │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 1.0             │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 1.0             │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 1.0             │
+    #   # │ …     ┆ …                   ┆ …               │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 1.0             │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 1.0             │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 1.0             │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 1.0             │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 1.0             │
+    #   # └───────┴─────────────────────┴─────────────────┘
+    def rolling_var_by(
+      by,
+      window_size,
+      min_periods: 1,
+      closed: "right",
+      ddof: 1,
+      warn_if_unsorted: nil
+    )
+      window_size = _prepare_rolling_by_window_args(window_size)
+      by = Utils.parse_as_expression(by)
+      _from_rbexpr(
+        _rbexpr.rolling_var_by(
+          by,
+          window_size,
+          min_periods,
+          closed,
+          ddof
+        )
+      )
+    end
+
+    # Compute a rolling median based on another column.
+    #
+    # @param by [String]
+    #     This column must be of dtype Datetime or Date.
+    # @param window_size [String]
+    #   The length of the window. Can be a dynamic temporal
+    #   size indicated by a timedelta or the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 calendar day)
+    #   - 1w    (1 calendar week)
+    #   - 1mo   (1 calendar month)
+    #   - 1q    (1 calendar quarter)
+    #   - 1y    (1 calendar year)
+    #
+    #   By "calendar day", we mean the corresponding time on the next day
+    #   (which may not be 24 hours, due to daylight savings). Similarly for
+    #   "calendar week", "calendar month", "calendar quarter", and
+    #   "calendar year".
+    # @param min_periods [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result.
+    # @param closed ['left', 'right', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive),
+    #   defaults to `'right'`.
+    # @param warn_if_unsorted [Boolean]
+    #   Warn if data is not known to be sorted by `by` column.
+    #
+    # @return [Expr]
+    #
+    # @note
+    #   If you want to compute multiple aggregation statistics over the same dynamic
+    #   window, consider using `rolling` - this method can cache the window size
+    #   computation.
+    #
+    # @example Create a DataFrame with a datetime column and a row number column
+    #   start = DateTime.new(2001, 1, 1)
+    #   stop = DateTime.new(2001, 1, 2)
+    #   df_temporal = Polars::DataFrame.new(
+    #     {"date" => Polars.datetime_range(start, stop, "1h", eager: true)}
+    #   ).with_row_index
+    #   # =>
+    #   # shape: (25, 2)
+    #   # ┌───────┬─────────────────────┐
+    #   # │ index ┆ date                │
+    #   # │ ---   ┆ ---                 │
+    #   # │ u32   ┆ datetime[ns]        │
+    #   # ╞═══════╪═════════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 │
+    #   # │ …     ┆ …                   │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 │
+    #   # └───────┴─────────────────────┘
+    #
+    # @example Compute the rolling median with the temporal windows closed on the right:
+    #   df_temporal.with_columns(
+    #     rolling_row_median: Polars.col("index").rolling_median_by(
+    #       "date", "2h"
+    #     )
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬────────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_median │
+    #   # │ ---   ┆ ---                 ┆ ---                │
+    #   # │ u32   ┆ datetime[ns]        ┆ f64                │
+    #   # ╞═══════╪═════════════════════╪════════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ 0.0                │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 0.5                │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 1.5                │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 2.5                │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 3.5                │
+    #   # │ …     ┆ …                   ┆ …                  │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 19.5               │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 20.5               │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 21.5               │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 22.5               │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 23.5               │
+    #   # └───────┴─────────────────────┴────────────────────┘
+    def rolling_median_by(
+      by,
+      window_size,
+      min_periods: 1,
+      closed: "right",
+      warn_if_unsorted: nil
+    )
+      window_size = _prepare_rolling_by_window_args(window_size)
+      by = Utils.parse_as_expression(by)
+      _from_rbexpr(
+        _rbexpr.rolling_median_by(by, window_size, min_periods, closed)
+      )
+    end
+
+    # Compute a rolling quantile based on another column.
+    #
+    # @param by [String]
+    #   This column must be of dtype Datetime or Date.
+    # @param quantile [Float]
+    #   Quantile between 0.0 and 1.0.
+    # @param interpolation ['nearest', 'higher', 'lower', 'midpoint', 'linear']
+    #   Interpolation method.
+    # @param window_size  [String]
+    #   The length of the window. Can be a dynamic
+    #   temporal size indicated by a timedelta or the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 calendar day)
+    #   - 1w    (1 calendar week)
+    #   - 1mo   (1 calendar month)
+    #   - 1q    (1 calendar quarter)
+    #   - 1y    (1 calendar year)
+    #
+    #   By "calendar day", we mean the corresponding time on the next day
+    #   (which may not be 24 hours, due to daylight savings). Similarly for
+    #   "calendar week", "calendar month", "calendar quarter", and
+    #   "calendar year".
+    # @param min_periods [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result.
+    # @param closed ['left', 'right', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive),
+    #   defaults to `'right'`.
+    # @param warn_if_unsorted [Boolean]
+    #   Warn if data is not known to be sorted by `by` column.
+    #
+    # @return [Expr]
+    #
+    # @note
+    #   If you want to compute multiple aggregation statistics over the same dynamic
+    #   window, consider using `rolling` - this method can cache the window size
+    #   computation.
+    #
+    # @example Create a DataFrame with a datetime column and a row number column
+    #   start = DateTime.new(2001, 1, 1)
+    #   stop = DateTime.new(2001, 1, 2)
+    #   df_temporal = Polars::DataFrame.new(
+    #       {"date" => Polars.datetime_range(start, stop, "1h", eager: true)}
+    #   ).with_row_index
+    #   # =>
+    #   # shape: (25, 2)
+    #   # ┌───────┬─────────────────────┐
+    #   # │ index ┆ date                │
+    #   # │ ---   ┆ ---                 │
+    #   # │ u32   ┆ datetime[ns]        │
+    #   # ╞═══════╪═════════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 │
+    #   # │ …     ┆ …                   │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 │
+    #   # └───────┴─────────────────────┘
+    #
+    # @example Compute the rolling quantile with the temporal windows closed on the right:
+    #   df_temporal.with_columns(
+    #     rolling_row_quantile: Polars.col("index").rolling_quantile_by(
+    #       "date", "2h", quantile: 0.3
+    #     )
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬──────────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_quantile │
+    #   # │ ---   ┆ ---                 ┆ ---                  │
+    #   # │ u32   ┆ datetime[ns]        ┆ f64                  │
+    #   # ╞═══════╪═════════════════════╪══════════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ 0.0                  │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 0.0                  │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 1.0                  │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 2.0                  │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 3.0                  │
+    #   # │ …     ┆ …                   ┆ …                    │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 19.0                 │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 20.0                 │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 21.0                 │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 22.0                 │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 23.0                 │
+    #   # └───────┴─────────────────────┴──────────────────────┘
+    def rolling_quantile_by(
+      by,
+      window_size,
+      quantile:,
+      interpolation: "nearest",
+      min_periods: 1,
+      closed: "right",
+      warn_if_unsorted: nil
+    )
+      window_size = _prepare_rolling_by_window_args(window_size)
+      by = Utils.parse_as_expression(by)
+      _from_rbexpr(
+        _rbexpr.rolling_quantile_by(
+          by,
+          quantile,
+          interpolation,
+          window_size,
+          min_periods,
+          closed,
+        )
+      )
+    end
+
     # Apply a rolling min (moving min) over the values in this array.
     #
     # A window of length `window_size` will traverse the array. The values that fill
@@ -3939,9 +4958,20 @@ module Polars
       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, by, closed
+          window_size, weights, min_periods, center
         )
       )
     end
@@ -4028,9 +5058,20 @@ module Polars
       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, by, closed
+          window_size, weights, min_periods, center
         )
       )
     end
@@ -4117,9 +5158,20 @@ module Polars
       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, by, closed
+          window_size, weights, min_periods, center
         )
       )
     end
@@ -4206,9 +5258,20 @@ module Polars
       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, by, closed
+          window_size, weights, min_periods, center
         )
       )
     end
@@ -4297,9 +5360,21 @@ module Polars
       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, by, closed, ddof, warn_if_unsorted
+          window_size, weights, min_periods, center, ddof
         )
       )
     end
@@ -4388,9 +5463,21 @@ module Polars
       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, by, closed, ddof, warn_if_unsorted
+          window_size, weights, min_periods, center, ddof
         )
       )
     end
@@ -4474,9 +5561,20 @@ module Polars
       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, by, closed, warn_if_unsorted
+          window_size, weights, min_periods, center
         )
       )
     end
@@ -4566,9 +5664,21 @@ module Polars
       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, by, closed, warn_if_unsorted
+          quantile, interpolation, window_size, weights, min_periods, center
         )
       )
     end
@@ -6101,5 +7211,9 @@ module Polars
       end
       [window_size, min_periods]
     end
+
+    def _prepare_rolling_by_window_args(window_size)
+      window_size
+    end
   end
 end