polars-df 0.13.0-x64-mingw-ucrt

data/lib/polars/functions/len.rb

@@ -0,0 +1,49 @@
+module Polars
+  module Functions
+    # Return the number of rows in the context.
+    #
+    # This is similar to `COUNT(*)` in SQL.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [1, 2, nil],
+    #       "b" => [3, nil, nil],
+    #       "c" => ["foo", "bar", "foo"]
+    #     }
+    #   )
+    #   df.select(Polars.len)
+    #   # =>
+    #   # shape: (1, 1)
+    #   # ┌─────┐
+    #   # │ len │
+    #   # │ --- │
+    #   # │ u32 │
+    #   # ╞═════╡
+    #   # │ 3   │
+    #   # └─────┘
+    #
+    # @example Generate an index column by using `len` in conjunction with `int_range`.
+    #   df.select([
+    #     Polars.int_range(Polars.len, dtype: Polars::UInt32).alias("index"),
+    #     Polars.all
+    #   ])
+    #   # =>
+    #   # shape: (3, 4)
+    #   # ┌───────┬──────┬──────┬─────┐
+    #   # │ index ┆ a    ┆ b    ┆ c   │
+    #   # │ ---   ┆ ---  ┆ ---  ┆ --- │
+    #   # │ u32   ┆ i64  ┆ i64  ┆ str │
+    #   # ╞═══════╪══════╪══════╪═════╡
+    #   # │ 0     ┆ 1    ┆ 3    ┆ foo │
+    #   # │ 1     ┆ 2    ┆ null ┆ bar │
+    #   # │ 2     ┆ null ┆ null ┆ foo │
+    #   # └───────┴──────┴──────┴─────┘
+    def len
+      Utils.wrap_expr(Plr.len)
+    end
+    alias_method :length, :len
+  end
+end

data/lib/polars/functions/lit.rb

@@ -0,0 +1,35 @@
+module Polars
+  module Functions
+    # Return an expression representing a literal value.
+    #
+    # @return [Expr]
+    def lit(value, dtype: nil, allow_object: nil)
+      if value.is_a?(::Time) || value.is_a?(::DateTime)
+        time_unit = dtype&.time_unit || "ns"
+        time_zone = dtype.&time_zone
+        e = lit(Utils.datetime_to_int(value, time_unit)).cast(Datetime.new(time_unit))
+        if time_zone
+          return e.dt.replace_time_zone(time_zone.to_s)
+        else
+          return e
+        end
+      elsif value.is_a?(::Date)
+        return lit(::Time.utc(value.year, value.month, value.day)).cast(Date)
+      elsif value.is_a?(Polars::Series)
+        name = value.name
+        value = value._s
+        e = Utils.wrap_expr(Plr.lit(value, allow_object))
+        if name == ""
+          return e
+        end
+        return e.alias(name)
+      elsif (defined?(Numo::NArray) && value.is_a?(Numo::NArray)) || value.is_a?(::Array)
+        return lit(Series.new("", value))
+      elsif dtype
+        return Utils.wrap_expr(Plr.lit(value, allow_object)).cast(dtype)
+      end
+
+      Utils.wrap_expr(Plr.lit(value, allow_object))
+    end
+  end
+end

data/lib/polars/functions/random.rb

@@ -0,0 +1,16 @@
+module Polars
+  module Functions
+    # Set the global random seed for Polars.
+    #
+    # This random seed is used to determine things such as shuffle ordering.
+    #
+    # @param seed [Integer]
+    #   A non-negative integer < 2**64 used to seed the internal global
+    #   random number generator.
+    #
+    # @return [nil]
+    def set_random_seed(seed)
+      Plr.set_random_seed(seed)
+    end
+  end
+end

data/lib/polars/functions/range/date_range.rb

@@ -0,0 +1,136 @@
+module Polars
+  module Functions
+    # Create a range of type `Datetime` (or `Date`).
+    #
+    # @param start [Object]
+    #   Lower bound of the date range.
+    # @param stop [Object]
+    #   Upper bound of the date range.
+    # @param interval [Object]
+    #   Interval periods. It can be a polars duration string, such as `3d12h4m25s`
+    #   representing 3 days, 12 hours, 4 minutes, and 25 seconds.
+    # @param closed ["both", "left", "right", "none"]
+    #   Define whether the temporal window interval is closed or not.
+    # @param eager [Boolean]
+    #   Evaluate immediately and return a `Series`.
+    #   If set to `false` (default), return an expression instead.
+    #
+    # @return [Object]
+    #
+    # @note
+    #   If both `low` and `high` are passed as date types (not datetime), and the
+    #   interval granularity is no finer than 1d, the returned range is also of
+    #   type date. All other permutations return a datetime Series.
+    #
+    # @example Using polars duration string to specify the interval
+    #   Polars.date_range(Date.new(2022, 1, 1), Date.new(2022, 3, 1), "1mo", eager: true).alias(
+    #     "date"
+    #   )
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'date' [date]
+    #   # [
+    #   #         2022-01-01
+    #   #         2022-02-01
+    #   #         2022-03-01
+    #   # ]
+    def date_range(
+      start,
+      stop,
+      interval = "1d",
+      closed: "both",
+      eager: false
+    )
+      interval = Utils.parse_interval_argument(interval)
+
+      start_rbexpr = Utils.parse_into_expression(start)
+      end_rbexpr = Utils.parse_into_expression(stop)
+
+      result = Utils.wrap_expr(
+        Plr.date_range(start_rbexpr, end_rbexpr, interval, closed)
+      )
+
+      if eager
+        return F.select(result).to_series
+      end
+
+      result
+    end
+
+    # Create a column of date ranges.
+    #
+    # @param start [Object]
+    #   Lower bound of the date range.
+    # @param stop [Object]
+    #   Upper bound of the date range.
+    # @param interval [Object]
+    #   Interval of the range periods, specified using the Polars duration string language (see "Notes" section below).
+    # @param closed ["both", "left", "right", "none"]
+    #   Define which sides of the range are closed (inclusive).
+    # @param eager [Boolean]
+    #   Evaluate immediately and return a `Series`.
+    #   If set to `false` (default), return an expression instead.
+    #
+    # @return [Object]
+    #
+    # @note
+    #   `interval` is created according to 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)
+    #
+    #   Or combine them:
+    #   "3d12h4m25s" # 3 days, 12 hours, 4 minutes, and 25 seconds
+    #
+    #   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".
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "start" => [Date.new(2022, 1, 1), Date.new(2022, 1, 2)],
+    #       "end" => Date.new(2022, 1, 3)
+    #     }
+    #   )
+    #   df.with_columns(date_range: Polars.date_ranges("start", "end"))
+    #   # =>
+    #   # shape: (2, 3)
+    #   # ┌────────────┬────────────┬─────────────────────────────────┐
+    #   # │ start      ┆ end        ┆ date_range                      │
+    #   # │ ---        ┆ ---        ┆ ---                             │
+    #   # │ date       ┆ date       ┆ list[date]                      │
+    #   # ╞════════════╪════════════╪═════════════════════════════════╡
+    #   # │ 2022-01-01 ┆ 2022-01-03 ┆ [2022-01-01, 2022-01-02, 2022-… │
+    #   # │ 2022-01-02 ┆ 2022-01-03 ┆ [2022-01-02, 2022-01-03]        │
+    #   # └────────────┴────────────┴─────────────────────────────────┘
+    def date_ranges(
+      start,
+      stop,
+      interval = "1d",
+      closed: "both",
+      eager: false
+    )
+      interval = Utils.parse_interval_argument(interval)
+      start_rbexpr = Utils.parse_into_expression(start)
+      end_rbexpr = Utils.parse_into_expression(stop)
+
+      result = Utils.wrap_expr(Plr.date_ranges(start_rbexpr, end_rbexpr, interval, closed))
+
+      if eager
+        return F.select(result).to_series
+      end
+
+      result
+    end
+  end
+end

data/lib/polars/functions/range/datetime_range.rb

@@ -0,0 +1,149 @@
+module Polars
+  module Functions
+    # Generate a datetime range.
+    #
+    # @param start [Object]
+    #   Lower bound of the datetime range.
+    # @param stop [Object]
+    #   Upper bound of the datetime range.
+    # @param interval [String]
+    #   Interval of the range periods, specified using the Polars duration string language.
+    # @param closed ['both', 'left', 'right', 'none']
+    #   Define which sides of the range are closed (inclusive).
+    # @param time_unit [nil, 'ns', 'us', 'ms']
+    #   Time unit of the resulting `Datetime` data type.
+    # @param time_zone [String]
+    #   Time zone of the resulting `Datetime` data type.
+    # @param eager [Boolean]
+    #   Evaluate immediately and return a `Series`.
+    #   If set to `false` (default), return an expression instead.
+    #
+    # @return [Object]
+    #
+    # @example Using Polars duration string to specify the interval:
+    #   Polars.datetime_range(
+    #     DateTime.new(2022, 1, 1), DateTime.new(2022, 3, 1), "1mo", eager: true
+    #   ).alias("datetime")
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'datetime' [datetime[ns]]
+    #   # [
+    #   #         2022-01-01 00:00:00
+    #   #         2022-02-01 00:00:00
+    #   #         2022-03-01 00:00:00
+    #   # ]
+    #
+    # @example Specifying a time zone:
+    #   Polars.datetime_range(
+    #     DateTime.new(2022, 1, 1),
+    #     DateTime.new(2022, 3, 1),
+    #     "1mo",
+    #     time_zone: "America/New_York",
+    #     eager: true
+    #   ).alias("datetime")
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'datetime' [datetime[ns, America/New_York]]
+    #   # [
+    #   #         2022-01-01 00:00:00 EST
+    #   #         2022-02-01 00:00:00 EST
+    #   #         2022-03-01 00:00:00 EST
+    #   # ]
+    def datetime_range(
+      start,
+      stop,
+      interval = "1d",
+      closed: "both",
+      time_unit: nil,
+      time_zone: nil,
+      eager: false
+    )
+      interval = Utils.parse_interval_argument(interval)
+      if time_unit.nil? && interval.include?("ns")
+        time_unit = "ns"
+      end
+
+      start_rbexpr = Utils.parse_into_expression(start)
+      end_rbexpr = Utils.parse_into_expression(stop)
+      result = Utils.wrap_expr(
+        Plr.datetime_range(
+          start_rbexpr, end_rbexpr, interval, closed, time_unit, time_zone
+        )
+      )
+
+      if eager
+        return Polars.select(result).to_series
+      end
+
+      result
+    end
+
+    # Create a column of datetime ranges.
+    #
+    # @param start [Object]
+    #   Lower bound of the datetime range.
+    # @param stop [Object]
+    #   Upper bound of the datetime range.
+    # @param interval [String]
+    #   Interval of the range periods, specified using the Polars duration string language.
+    # @param closed ['both', 'left', 'right', 'none']
+    #   Define which sides of the range are closed (inclusive).
+    # @param time_unit [nil, 'ns', 'us', 'ms']
+    #   Time unit of the resulting `Datetime` data type.
+    # @param time_zone [String]
+    #   Time zone of the resulting `Datetime` data type.
+    # @param eager [Boolean]
+    #   Evaluate immediately and return a `Series`.
+    #   If set to `false` (default), return an expression instead.
+    #
+    # @return [Object]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "start" => [DateTime.new(2022, 1, 1), DateTime.new(2022, 1, 2)],
+    #       "end" => DateTime.new(2022, 1, 3),
+    #     }
+    #   )
+    #   df.select(datetime_range: Polars.datetime_ranges("start", "end"))
+    #   # =>
+    #   # shape: (2, 1)
+    #   # ┌─────────────────────────────────┐
+    #   # │ datetime_range                  │
+    #   # │ ---                             │
+    #   # │ list[datetime[ns]]              │
+    #   # ╞═════════════════════════════════╡
+    #   # │ [2022-01-01 00:00:00, 2022-01-… │
+    #   # │ [2022-01-02 00:00:00, 2022-01-… │
+    #   # └─────────────────────────────────┘
+    def datetime_ranges(
+      start,
+      stop,
+      interval: "1d",
+      closed: "both",
+      time_unit: nil,
+      time_zone: nil,
+      eager: false
+    )
+      interval = Utils.parse_interval_argument(interval)
+      if time_unit.nil? && interval.include?("ns")
+        time_unit = "ns"
+      end
+
+      start_rbexpr = Utils.parse_into_expression(start)
+      end_rbexpr = Utils.parse_into_expression(stop)
+
+      result = Utils.wrap_expr(
+        Plr.datetime_ranges(
+          start_rbexpr, end_rbexpr, interval, closed, time_unit, time_zone
+        )
+      )
+
+      if eager
+        return Polars.select(result).to_series
+      end
+
+      result
+    end
+  end
+end

data/lib/polars/functions/range/int_range.rb

@@ -0,0 +1,51 @@
+module Polars
+  module Functions
+    # Create a range expression (or Series).
+    #
+    # This can be used in a `select`, `with_column`, etc. Be sure that the resulting
+    # range size is equal to the length of the DataFrame you are collecting.
+    #
+    # @param start [Integer, Expr, Series]
+    #   Lower bound of range.
+    # @param stop [Integer, Expr, Series]
+    #   Upper bound of range.
+    # @param step [Integer]
+    #   Step size of the range.
+    # @param eager [Boolean]
+    #   If eager evaluation is `True`, a Series is returned instead of an Expr.
+    # @param dtype [Symbol]
+    #   Apply an explicit integer dtype to the resulting expression (default is `Int64`).
+    #
+    # @return [Expr, Series]
+    #
+    # @example
+    #   Polars.arange(0, 3, eager: true)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'arange' [i64]
+    #   # [
+    #   #         0
+    #   #         1
+    #   #         2
+    #   # ]
+    def int_range(start, stop = nil, step: 1, eager: false, dtype: nil)
+      if stop.nil?
+        stop = start
+        start = 0
+      end
+
+      start = Utils.parse_into_expression(start)
+      stop = Utils.parse_into_expression(stop)
+      dtype ||= Int64
+      dtype = dtype.to_s if dtype.is_a?(Symbol)
+      result = Utils.wrap_expr(Plr.int_range(start, stop, step, dtype)).alias("arange")
+
+      if eager
+        return select(result).to_series
+      end
+
+      result
+    end
+    alias_method :arange, :int_range
+  end
+end

data/lib/polars/functions/range/time_range.rb

@@ -0,0 +1,141 @@
+module Polars
+  module Functions
+    # Generate a time range.
+    #
+    # @param start [Object]
+    #   Lower bound of the time range.
+    # @param stop [Object]
+    #   Upper bound of the time range.
+    # @param interval [String]
+    #   Interval of the range periods, specified using the Polars duration string language.
+    # @param closed ['both', 'left', 'right', 'none']
+    #   Define which sides of the range are closed (inclusive).
+    # @param eager [Boolean]
+    #   Evaluate immediately and return a `Series`.
+    #   If set to `False` (default), return an expression instead.
+    #
+    # @return [Object]
+    #
+    # @example
+    #   Polars.time_range(
+    #     time(14, 0),
+    #     nil,
+    #     "3h15m",
+    #     eager: true
+    #   ).alias("time")
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: 'time' [time]
+    #   # [
+    #   #         14:00:00
+    #   #         17:15:00
+    #   #         20:30:00
+    #   #         23:45:00
+    #   # ]
+    def time_range(
+      start = nil,
+      stop = nil,
+      interval = "1h",
+      closed: "both",
+      eager: false
+    )
+      interval = Utils.parse_interval_argument(interval)
+      ["y", "mo", "w", "d"].each do |unit|
+        if interval.include?(unit)
+          msg = "invalid interval unit for time_range: found #{unit.inspect}"
+          raise ArgumentError, msg
+        end
+      end
+
+      if start.nil?
+        # start = time(0, 0, 0)
+        raise Todo
+      end
+      if stop.nil?
+        # stop = time(23, 59, 59, 999999)
+        raise Todo
+      end
+
+      start_rbexpr = Utils.parse_into_expression(start)
+      end_rbexpr = Utils.parse_into_expression(stop)
+
+      result = Utils.wrap_expr(Plr.time_range(start_rbexpr, end_rbexpr, interval, closed))
+
+      if eager
+        return Polars.select(result).to_series
+      end
+
+      result
+    end
+
+    # Create a column of time ranges.
+    #
+    # @param start [Object]
+    #   Lower bound of the time range.
+    # @param stop [Object]
+    #   Upper bound of the time range.
+    # @param interval [Integer]
+    #   Interval of the range periods, specified using the Polars duration string language.
+    # @param closed ['both', 'left', 'right', 'none']
+    #   Define which sides of the range are closed (inclusive).
+    # @param eager [Boolean]
+    #   Evaluate immediately and return a `Series`.
+    #   If set to `false` (default), return an expression instead.
+    #
+    # @return [Object]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "start" => [time(9, 0), time(10, 0)],
+    #       "end" => time(11, 0)
+    #     }
+    #   )
+    #   df.with_columns(time_range: Polars.time_ranges("start", "end"))
+    #   # =>
+    #   # shape: (2, 3)
+    #   # ┌──────────┬──────────┬────────────────────────────────┐
+    #   # │ start    ┆ end      ┆ time_range                     │
+    #   # │ ---      ┆ ---      ┆ ---                            │
+    #   # │ time     ┆ time     ┆ list[time]                     │
+    #   # ╞══════════╪══════════╪════════════════════════════════╡
+    #   # │ 09:00:00 ┆ 11:00:00 ┆ [09:00:00, 10:00:00, 11:00:00] │
+    #   # │ 10:00:00 ┆ 11:00:00 ┆ [10:00:00, 11:00:00]           │
+    #   # └──────────┴──────────┴────────────────────────────────┘
+    def time_ranges(
+      start = nil,
+      stop = nil,
+      interval = "1h",
+      closed: "both",
+      eager: false
+    )
+      interval = Utils.parse_interval_argument(interval)
+      ["y", "mo", "w", "d"].each do |unit|
+        if interval.include?(unit)
+          msg = "invalid interval unit for time_range: found #{unit.inspect}"
+          raise ArgumentError, msg
+        end
+      end
+
+      if start.nil?
+        # start = time(0, 0, 0)
+        raise Todo
+      end
+      if stop.nil?
+        # stop = time(23, 59, 59, 999999)
+        raise Todo
+      end
+
+      start_rbexpr = Utils.parse_into_expression(start)
+      end_rbexpr = Utils.parse_into_expression(stop)
+
+      result = Utils.wrap_expr(Plr.time_ranges(start_rbexpr, end_rbexpr, interval, closed))
+
+      if eager
+        return Polars.select(result).to_series
+      end
+
+      result
+    end
+  end
+end