polars-df 0.11.0-x86_64-linux → 0.12.0-x86_64-linux

data/lib/polars/lazy_frame.rb

@@ -63,7 +63,7 @@ module Polars
     #   df.columns
     #   # => ["foo", "bar"]
     def columns
-      _ldf.columns
+      _ldf.collect_schema.keys
     end
 
     # Get dtypes of columns in LazyFrame.
@@ -81,7 +81,7 @@ module Polars
     #   lf.dtypes
     #   # => [Polars::Int64, Polars::Float64, Polars::String]
     def dtypes
-      _ldf.dtypes
+      _ldf.collect_schema.values
     end
 
     # Get the schema.
@@ -99,7 +99,7 @@ module Polars
     #   lf.schema
     #   # => {"foo"=>Polars::Int64, "bar"=>Polars::Float64, "ham"=>Polars::String}
     def schema
-      _ldf.schema
+      _ldf.collect_schema
     end
 
     # Get the width of the LazyFrame.
@@ -111,7 +111,7 @@ module Polars
     #   lf.width
     #   # => 2
     def width
-      _ldf.width
+      _ldf.collect_schema.length
     end
 
     # Check if LazyFrame includes key.
@@ -261,16 +261,23 @@ module Polars
     #   # │ 2   ┆ 7.0 ┆ b   │
     #   # │ 1   ┆ 6.0 ┆ a   │
     #   # └─────┴─────┴─────┘
-    def sort(by, reverse: false, nulls_last: false, maintain_order: false, multithreaded: true)
-      if by.is_a?(::String)
-        return _from_rbldf(_ldf.sort(by, reverse, nulls_last, maintain_order, multithreaded))
-      end
-      if Utils.bool?(reverse)
-        reverse = [reverse]
+    def sort(by, *more_by, reverse: false, nulls_last: false, maintain_order: false, multithreaded: true)
+      if by.is_a?(::String) && more_by.empty?
+        return _from_rbldf(
+          _ldf.sort(
+            by, reverse, nulls_last, maintain_order, multithreaded
+          )
+        )
       end
 
-      by = Utils.selection_to_rbexpr_list(by)
-      _from_rbldf(_ldf.sort_by_exprs(by, reverse, nulls_last, maintain_order, multithreaded))
+      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_rbldf(
+        _ldf.sort_by_exprs(
+          by, reverse, nulls_last, maintain_order, multithreaded
+        )
+      )
     end
 
     # def profile
@@ -415,7 +422,7 @@ module Polars
       path,
       compression: "zstd",
       compression_level: nil,
-      statistics: false,
+      statistics: true,
       row_group_size: nil,
       data_pagesize_limit: nil,
       maintain_order: true,
@@ -435,6 +442,24 @@ module Polars
         no_optimization: no_optimization
       )
 
+      if statistics == true
+        statistics = {
+          min: true,
+          max: true,
+          distinct_count: false,
+          null_count: true
+        }
+      elsif statistics == false
+        statistics = {}
+      elsif statistics == "full"
+        statistics = {
+          min: true,
+          max: true,
+          distinct_count: true,
+          null_count: true
+        }
+      end
+
       lf.sink_parquet(
         path,
         compression,
@@ -589,6 +614,7 @@ module Polars
       datetime_format: nil,
       date_format: nil,
       time_format: nil,
+      float_scientific: nil,
       float_precision: nil,
       null_value: nil,
       quote_style: nil,
@@ -623,6 +649,7 @@ module Polars
         datetime_format,
         date_format,
         time_format,
+        float_scientific,
         float_precision,
         null_value,
         quote_style,
@@ -907,7 +934,7 @@ module Polars
     def filter(predicate)
       _from_rbldf(
         _ldf.filter(
-          Utils.expr_to_lit_or_expr(predicate, str_to_lit: false)._rbexpr
+          Utils.parse_into_expression(predicate, str_as_lit: false)
         )
       )
     end
@@ -1003,7 +1030,7 @@ module Polars
     def select(*exprs, **named_exprs)
       structify = ENV.fetch("POLARS_AUTO_STRUCTIFY", "0") != "0"
 
-      rbexprs = Utils.parse_as_list_of_expressions(
+      rbexprs = Utils.parse_into_list_of_expressions(
         *exprs, **named_exprs, __structify: structify
       )
       _from_rbldf(_ldf.select(rbexprs))
@@ -1011,12 +1038,14 @@ module Polars
 
     # Start a group by operation.
     #
-    # @param by [Object]
+    # @param by [Array]
     #   Column(s) to group by.
     # @param maintain_order [Boolean]
     #   Make sure that the order of the groups remain consistent. This is more
     #   expensive than a default group by.
-    #
+    # @param named_by [Hash]
+    #   Additional columns to group by, specified as keyword arguments.
+    #   The columns will be renamed to the keyword used.
     # @return [LazyGroupBy]
     #
     # @example
@@ -1039,9 +1068,9 @@ module Polars
     #   # │ b   ┆ 11  │
     #   # │ c   ┆ 6   │
     #   # └─────┴─────┘
-    def group_by(by, maintain_order: false)
-      rbexprs_by = Utils.selection_to_rbexpr_list(by)
-      lgb = _ldf.group_by(rbexprs_by, maintain_order)
+    def group_by(*by, maintain_order: false, **named_by)
+      exprs = Utils.parse_into_list_of_expressions(*by, **named_by)
+      lgb = _ldf.group_by(exprs, maintain_order)
       LazyGroupBy.new(lgb)
     end
     alias_method :groupby, :group_by
@@ -1095,12 +1124,6 @@ module Polars
     #   Define whether the temporal window interval is closed or not.
     # @param by [Object]
     #   Also group by this column/these columns.
-    # @param check_sorted [Boolean]
-    #   When the `by` argument is given, polars can not check sortedness
-    #   by the metadata and has to do a full scan on the index column to
-    #   verify data is sorted. This is expensive. If you are sure the
-    #   data within the by groups is sorted, you can set this to `false`.
-    #   Doing so incorrectly will lead to incorrect output
     #
     # @return [LazyFrame]
     #
@@ -1142,21 +1165,20 @@ module Polars
       period:,
       offset: nil,
       closed: "right",
-      by: nil,
-      check_sorted: true
+      by: nil
     )
-      index_column = Utils.parse_as_expression(index_column)
+      index_column = Utils.parse_into_expression(index_column)
       if offset.nil?
-        offset = "-#{period}"
+        offset = Utils.negate_duration_string(Utils.parse_as_duration_string(period))
       end
 
-      rbexprs_by = by.nil? ? [] : Utils.selection_to_rbexpr_list(by)
-      period = Utils._timedelta_to_pl_duration(period)
-      offset = Utils._timedelta_to_pl_duration(offset)
-
-      lgb = _ldf.rolling(
-        index_column, period, offset, closed, rbexprs_by, check_sorted
+      rbexprs_by = (
+        !by.nil? ? Utils.parse_into_list_of_expressions(by) : []
       )
+      period = Utils.parse_as_duration_string(period)
+      offset = Utils.parse_as_duration_string(offset)
+
+      lgb = _ldf.rolling(index_column, period, offset, closed, rbexprs_by)
       LazyGroupBy.new(lgb)
     end
     alias_method :group_by_rolling, :rolling
@@ -1224,22 +1246,18 @@ module Polars
     #   Define whether the temporal window interval is closed or not.
     # @param by [Object]
     #   Also group by this column/these columns
-    # @param check_sorted [Boolean]
-    #   When the `by` argument is given, polars can not check sortedness
-    #   by the metadata and has to do a full scan on the index column to
-    #   verify data is sorted. This is expensive. If you are sure the
-    #   data within the by groups is sorted, you can set this to `false`.
-    #   Doing so incorrectly will lead to incorrect output.
     #
     # @return [DataFrame]
     #
     # @example
     #   df = Polars::DataFrame.new(
     #     {
-    #       "time" => Polars.date_range(
+    #       "time" => Polars.datetime_range(
     #         DateTime.new(2021, 12, 16),
     #         DateTime.new(2021, 12, 16, 3),
-    #         "30m"
+    #         "30m",
+    #         time_unit: "us",
+    #         eager: true
     #       ),
     #       "n" => 0..6
     #     }
@@ -1338,10 +1356,12 @@ module Polars
     # @example Dynamic group bys can also be combined with grouping on normal keys.
     #   df = Polars::DataFrame.new(
     #     {
-    #       "time" => Polars.date_range(
+    #       "time" => Polars.datetime_range(
     #         DateTime.new(2021, 12, 16),
     #         DateTime.new(2021, 12, 16, 3),
-    #         "30m"
+    #         "30m",
+    #         time_unit: "us",
+    #         eager: true
     #       ),
     #       "groups" => ["a", "a", "a", "b", "b", "a", "a"]
     #     }
@@ -1405,14 +1425,13 @@ module Polars
       closed: "left",
       label: "left",
       by: nil,
-      start_by: "window",
-      check_sorted: true
+      start_by: "window"
     )
       if !truncate.nil?
         label = truncate ? "left" : "datapoint"
       end
 
-      index_column = Utils.expr_to_lit_or_expr(index_column, str_to_lit: false)
+      index_column = Utils.parse_into_expression(index_column, str_as_lit: false)
       if offset.nil?
         offset = period.nil? ? "-#{every}" : "0ns"
       end
@@ -1421,13 +1440,13 @@ module Polars
         period = every
       end
 
-      period = Utils._timedelta_to_pl_duration(period)
-      offset = Utils._timedelta_to_pl_duration(offset)
-      every = Utils._timedelta_to_pl_duration(every)
+      period = Utils.parse_as_duration_string(period)
+      offset = Utils.parse_as_duration_string(offset)
+      every = Utils.parse_as_duration_string(every)
 
-      rbexprs_by = by.nil? ? [] : Utils.selection_to_rbexpr_list(by)
+      rbexprs_by = by.nil? ? [] : Utils.parse_into_list_of_expressions(by)
       lgb = _ldf.group_by_dynamic(
-        index_column._rbexpr,
+        index_column,
         every,
         period,
         offset,
@@ -1435,8 +1454,7 @@ module Polars
         include_boundaries,
         closed,
         rbexprs_by,
-        start_by,
-        check_sorted
+        start_by
       )
       LazyGroupBy.new(lgb)
     end
@@ -1587,7 +1605,7 @@ module Polars
     # @param on Object
     #   Join column of both DataFrames. If set, `left_on` and `right_on` should be
     #   None.
-    # @param how ["inner", "left", "outer", "semi", "anti", "cross"]
+    # @param how ["inner", "left", "full", "semi", "anti", "cross"]
     #   Join strategy.
     # @param suffix [String]
     #   Suffix to append to columns with a duplicate name.
@@ -1629,7 +1647,7 @@ module Polars
     #   # └─────┴─────┴─────┴───────┘
     #
     # @example
-    #   df.join(other_df, on: "ham", how: "outer").collect
+    #   df.join(other_df, on: "ham", how: "full").collect
     #   # =>
     #   # shape: (4, 5)
     #   # ┌──────┬──────┬──────┬───────┬───────────┐
@@ -1696,7 +1714,9 @@ module Polars
         raise ArgumentError, "Expected a `LazyFrame` as join table, got #{other.class.name}"
       end
 
-      if how == "cross"
+      if how == "outer"
+        how = "full"
+      elsif how == "cross"
         return _from_rbldf(
           _ldf.join(
             other._ldf, [], [], allow_parallel, join_nulls, force_parallel, how, suffix
@@ -1705,12 +1725,12 @@ module Polars
       end
 
       if !on.nil?
-        rbexprs = Utils.selection_to_rbexpr_list(on)
+        rbexprs = Utils.parse_into_list_of_expressions(on)
         rbexprs_left = rbexprs
         rbexprs_right = rbexprs
       elsif !left_on.nil? && !right_on.nil?
-        rbexprs_left = Utils.selection_to_rbexpr_list(left_on)
-        rbexprs_right = Utils.selection_to_rbexpr_list(right_on)
+        rbexprs_left = Utils.parse_into_list_of_expressions(left_on)
+        rbexprs_right = Utils.parse_into_list_of_expressions(right_on)
       else
         raise ArgumentError, "must specify `on` OR `left_on` and `right_on`"
       end
@@ -1765,7 +1785,8 @@ module Polars
     #   # └─────┴──────┴───────┴─────┴──────┴───────┘
     def with_columns(*exprs, **named_exprs)
       structify = ENV.fetch("POLARS_AUTO_STRUCTIFY", "0") != "0"
-      rbexprs = Utils.parse_as_list_of_expressions(*exprs, **named_exprs, __structify: structify)
+
+      rbexprs = Utils.parse_into_list_of_expressions(*exprs, **named_exprs, __structify: structify)
 
       _from_rbldf(_ldf.with_columns(rbexprs))
     end
@@ -1926,9 +1947,9 @@ module Polars
     #   # └──────┴──────┘
     def shift(n, 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_rbldf(_ldf.shift(n, fill_value))
     end
 
@@ -2125,7 +2146,7 @@ module Polars
     #   # │ 3   ┆ 7   │
     #   # └─────┴─────┘
     def take_every(n)
-      select(Utils.col("*").take_every(n))
+      select(F.col("*").take_every(n))
     end
 
     # Fill null values using the specified value or strategy.
@@ -2168,7 +2189,7 @@ module Polars
     #   # └──────┴──────┘
     def fill_nan(fill_value)
       if !fill_value.is_a?(Expr)
-        fill_value = Utils.lit(fill_value)
+        fill_value = F.lit(fill_value)
       end
       _from_rbldf(_ldf.fill_nan(fill_value._rbexpr))
     end
@@ -2359,8 +2380,8 @@ module Polars
     #   # │ 3.0 ┆ 1.0 │
     #   # └─────┴─────┘
     def quantile(quantile, interpolation: "nearest")
-      quantile = Utils.expr_to_lit_or_expr(quantile, str_to_lit: false)
-      _from_rbldf(_ldf.quantile(quantile._rbexpr, interpolation))
+      quantile = Utils.parse_into_expression(quantile, str_as_lit: false)
+      _from_rbldf(_ldf.quantile(quantile, interpolation))
     end
 
     # Explode lists to long format.
@@ -2392,7 +2413,7 @@ module Polars
     #   # │ c       ┆ 8       │
     #   # └─────────┴─────────┘
     def explode(columns)
-      columns = Utils.selection_to_rbexpr_list(columns)
+      columns = Utils.parse_into_list_of_expressions(columns)
       _from_rbldf(_ldf.explode(columns))
     end
 
@@ -2455,35 +2476,35 @@ module Polars
     # Optionally leaves identifiers set.
     #
     # This function is useful to massage a DataFrame into a format where one or more
-    # columns are identifier variables (id_vars), while all other columns, considered
-    # measured variables (value_vars), are "unpivoted" to the row axis, leaving just
+    # columns are identifier variables (index) while all other columns, considered
+    # measured variables (on), are "unpivoted" to the row axis leaving just
     # two non-identifier columns, 'variable' and 'value'.
     #
-    # @param id_vars [Object]
-    #   Columns to use as identifier variables.
-    # @param value_vars [Object]
-    #   Values to use as identifier variables.
-    #   If `value_vars` is empty all columns that are not in `id_vars` will be used.
+    # @param on [Object]
+    #   Column(s) or selector(s) to use as values variables; if `on`
+    #   is empty all columns that are not in `index` will be used.
+    # @param index [Object]
+    #   Column(s) or selector(s) to use as identifier variables.
     # @param variable_name [String]
-    #   Name to give to the `value` column. Defaults to "variable"
+    #   Name to give to the `variable` column. Defaults to "variable"
     # @param value_name [String]
     #   Name to give to the `value` column. Defaults to "value"
     # @param streamable [Boolean]
     #   Allow this node to run in the streaming engine.
-    #   If this runs in streaming, the output of the melt operation
+    #   If this runs in streaming, the output of the unpivot operation
     #   will not have a stable ordering.
     #
     # @return [LazyFrame]
     #
     # @example
-    #   df = Polars::DataFrame.new(
+    #   lf = Polars::LazyFrame.new(
     #     {
     #       "a" => ["x", "y", "z"],
     #       "b" => [1, 3, 5],
     #       "c" => [2, 4, 6]
     #     }
-    #   ).lazy
-    #   df.melt(id_vars: "a", value_vars: ["b", "c"]).collect
+    #   )
+    #   lf.unpivot(Polars::Selectors.numeric, index: "a").collect
     #   # =>
     #   # shape: (6, 3)
     #   # ┌─────┬──────────┬───────┐
@@ -2498,23 +2519,21 @@ module Polars
     #   # │ y   ┆ c        ┆ 4     │
     #   # │ z   ┆ c        ┆ 6     │
     #   # └─────┴──────────┴───────┘
-    def melt(id_vars: nil, value_vars: nil, variable_name: nil, value_name: nil, streamable: true)
-      if value_vars.is_a?(::String)
-        value_vars = [value_vars]
-      end
-      if id_vars.is_a?(::String)
-        id_vars = [id_vars]
-      end
-      if value_vars.nil?
-        value_vars = []
-      end
-      if id_vars.nil?
-        id_vars = []
-      end
+    def unpivot(
+      on,
+      index: nil,
+      variable_name: nil,
+      value_name: nil,
+      streamable: true
+    )
+      on = on.nil? ? [] : Utils._expand_selectors(self, on)
+      index = index.nil? ? [] : Utils._expand_selectors(self, index)
+
       _from_rbldf(
-        _ldf.melt(id_vars, value_vars, value_name, variable_name, streamable)
+        _ldf.unpivot(on, index, value_name, variable_name, streamable)
       )
     end
+    alias_method :melt, :unpivot
 
     # def map
     # end
@@ -2545,7 +2564,7 @@ module Polars
     #   # │ 10.0 ┆ null ┆ 9.0      │
     #   # └──────┴──────┴──────────┘
     def interpolate
-      select(Utils.col("*").interpolate)
+      select(F.col("*").interpolate)
     end
 
     # Decompose a struct into its fields.
@@ -2652,24 +2671,19 @@ module Polars
     #
     # @param column [Object]
     #   Columns that are sorted
-    # @param more_columns [Object]
-    #   Additional columns that are sorted, specified as positional arguments.
     # @param descending [Boolean]
     #   Whether the columns are sorted in descending order.
     #
     # @return [LazyFrame]
     def set_sorted(
       column,
-      *more_columns,
       descending: false
     )
-      columns = Utils.selection_to_rbexpr_list(column)
-      if more_columns.any?
-        columns.concat(Utils.selection_to_rbexpr_list(more_columns))
+      if !Utils.strlike?(column)
+        msg = "expected a 'str' for argument 'column' in 'set_sorted'"
+        raise TypeError, msg
       end
-      with_columns(
-        columns.map { |e| Utils.wrap_expr(e).set_sorted(descending: descending) }
-      )
+      with_columns(F.col(column).set_sorted(descending: descending))
     end
 
     # TODO

data/lib/polars/lazy_group_by.rb

@@ -107,7 +107,7 @@ module Polars
     #   # │ b   ┆ 5     ┆ 10.0           │
     #   # └─────┴───────┴────────────────┘
     def agg(*aggs, **named_aggs)
-      rbexprs = Utils.parse_as_list_of_expressions(*aggs, **named_aggs)
+      rbexprs = Utils.parse_into_list_of_expressions(*aggs, **named_aggs)
       Utils.wrap_ldf(@lgb.agg(rbexprs))
     end
 

data/lib/polars/list_expr.rb

@@ -146,7 +146,7 @@ module Polars
       end
 
       if !fraction.nil?
-        fraction = Utils.parse_as_expression(fraction)
+        fraction = Utils.parse_into_expression(fraction)
         return Utils.wrap_expr(
           _rbexpr.list_sample_fraction(
             fraction, with_replacement, shuffle, seed
@@ -155,7 +155,7 @@ module Polars
       end
 
       n = 1 if n.nil?
-      n = Utils.parse_as_expression(n)
+      n = Utils.parse_into_expression(n)
       Utils.wrap_expr(_rbexpr.list_sample_n(n, with_replacement, shuffle, seed))
     end
 
@@ -387,7 +387,7 @@ module Polars
     #   # │ 1    │
     #   # └──────┘
     def get(index, null_on_oob: true)
-      index = Utils.parse_as_expression(index)
+      index = Utils.parse_into_expression(index)
       Utils.wrap_expr(_rbexpr.list_get(index, null_on_oob))
     end
 
@@ -431,7 +431,7 @@ module Polars
       if index.is_a?(::Array)
         index = Series.new(index)
       end
-      index = Utils.expr_to_lit_or_expr(index, str_to_lit: false)._rbexpr
+      index = Utils.parse_into_expression(index, str_as_lit: false)
       Utils.wrap_expr(_rbexpr.list_gather(index, null_on_oob))
     end
     alias_method :take, :gather
@@ -502,7 +502,7 @@ module Polars
     #   # │ true  │
     #   # └───────┘
     def contains(item)
-      Utils.wrap_expr(_rbexpr.list_contains(Utils.expr_to_lit_or_expr(item)._rbexpr))
+      Utils.wrap_expr(_rbexpr.list_contains(Utils.parse_into_expression(item)))
     end
 
     # Join all string items in a sublist and place a separator between them.
@@ -530,7 +530,7 @@ module Polars
     #   # │ x y   │
     #   # └───────┘
     def join(separator, ignore_nulls: true)
-      separator = Utils.parse_as_expression(separator, str_as_lit: true)
+      separator = Utils.parse_into_expression(separator, str_as_lit: true)
       Utils.wrap_expr(_rbexpr.list_join(separator, ignore_nulls))
     end
 
@@ -625,7 +625,7 @@ module Polars
     #   #         [null, 10, 2]
     #   # ]
     def shift(n = 1)
-      n = Utils.parse_as_expression(n)
+      n = Utils.parse_into_expression(n)
       Utils.wrap_expr(_rbexpr.list_shift(n))
     end
 
@@ -650,8 +650,8 @@ module Polars
     #   #         [2, 1]
     #   # ]
     def slice(offset, length = nil)
-      offset = Utils.expr_to_lit_or_expr(offset, str_to_lit: false)._rbexpr
-      length = Utils.expr_to_lit_or_expr(length, str_to_lit: false)._rbexpr
+      offset = Utils.parse_into_expression(offset, str_as_lit: false)
+      length = Utils.parse_into_expression(length, str_as_lit: false)
       Utils.wrap_expr(_rbexpr.list_slice(offset, length))
     end
 
@@ -694,7 +694,7 @@ module Polars
     #   #         [2, 1]
     #   # ]
     def tail(n = 5)
-      n = Utils.parse_as_expression(n)
+      n = Utils.parse_into_expression(n)
       Utils.wrap_expr(_rbexpr.list_tail(n))
     end
 
@@ -722,7 +722,7 @@ module Polars
     #   # │ 0              │
     #   # └────────────────┘
     def count_matches(element)
-      Utils.wrap_expr(_rbexpr.list_count_matches(Utils.expr_to_lit_or_expr(element)._rbexpr))
+      Utils.wrap_expr(_rbexpr.list_count_matches(Utils.parse_into_expression(element)))
     end
     alias_method :count_match, :count_matches
 

data/lib/polars/list_name_space.rb

@@ -197,9 +197,13 @@ module Polars
     #
     # @param index [Integer]
     #   Index to return per sublist
+    # @param null_on_oob [Boolean]
+    #   Behavior if an index is out of bounds:
+    #   true -> set as null
+    #   false -> raise an error
     #
     # @return [Series]
-    def get(index)
+    def get(index, null_on_oob: false)
       super
     end
 

data/lib/polars/rolling_group_by.rb

@@ -10,25 +10,23 @@ module Polars
       period,
       offset,
       closed,
-      by,
-      check_sorted
+      group_by
     )
-      period = Utils._timedelta_to_pl_duration(period)
-      offset = Utils._timedelta_to_pl_duration(offset)
+      period = Utils.parse_as_duration_string(period)
+      offset = Utils.parse_as_duration_string(offset)
 
       @df = df
       @time_column = index_column
       @period = period
       @offset = offset
       @closed = closed
-      @by = by
-      @check_sorted = check_sorted
+      @group_by = group_by
     end
 
     def agg(*aggs, **named_aggs)
       @df.lazy
         .group_by_rolling(
-          index_column: @time_column, period: @period, offset: @offset, closed: @closed, by: @by, check_sorted: @check_sorted
+          index_column: @time_column, period: @period, offset: @offset, closed: @closed, by: @group_by
         )
         .agg(*aggs, **named_aggs)
         .collect(no_optimization: true, string_cache: false)