polars-df 0.10.0-x86_64-linux-musl

data/lib/polars/name_expr.rb

@@ -0,0 +1,198 @@
+module Polars
+  # Namespace for expressions that operate on expression names.
+  class NameExpr
+    # @private
+    attr_accessor :_rbexpr
+
+    # @private
+    def initialize(expr)
+      self._rbexpr = expr._rbexpr
+    end
+
+    # Keep the original root name of the expression.
+    #
+    # @note
+    #   Due to implementation constraints, this method can only be called as the last
+    #   expression in a chain.
+    #
+    # @return [Expr]
+    #
+    # @example Prevent errors due to potential duplicate column names.
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [1, 2],
+    #       "b" => [3, 4]
+    #     }
+    #   )
+    #   df.select((Polars.lit(10) / Polars.all).name.keep)
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌──────┬──────────┐
+    #   # │ a    ┆ b        │
+    #   # │ ---  ┆ ---      │
+    #   # │ f64  ┆ f64      │
+    #   # ╞══════╪══════════╡
+    #   # │ 10.0 ┆ 3.333333 │
+    #   # │ 5.0  ┆ 2.5      │
+    #   # └──────┴──────────┘
+    #
+    # @example Undo an alias operation.
+    #   df.with_columns((Polars.col("a") * 9).alias("c").name.keep)
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌─────┬─────┐
+    #   # │ a   ┆ b   │
+    #   # │ --- ┆ --- │
+    #   # │ i64 ┆ i64 │
+    #   # ╞═════╪═════╡
+    #   # │ 9   ┆ 3   │
+    #   # │ 18  ┆ 4   │
+    #   # └─────┴─────┘
+    def keep
+      Utils.wrap_expr(_rbexpr.name_keep)
+    end
+
+    # Rename the output of an expression by mapping a function over the root name.
+    #
+    # @return [Expr]
+    #
+    # @example Remove a common suffix and convert to lower case.
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "A_reverse" => [3, 2, 1],
+    #       "B_reverse" => ["z", "y", "x"]
+    #     }
+    #   )
+    #   df.with_columns(
+    #     Polars.all.reverse.name.map { |c| c.delete_suffix("_reverse").downcase }
+    #   )
+    #   # =>
+    #   # shape: (3, 4)
+    #   # ┌───────────┬───────────┬─────┬─────┐
+    #   # │ A_reverse ┆ B_reverse ┆ a   ┆ b   │
+    #   # │ ---       ┆ ---       ┆ --- ┆ --- │
+    #   # │ i64       ┆ str       ┆ i64 ┆ str │
+    #   # ╞═══════════╪═══════════╪═════╪═════╡
+    #   # │ 3         ┆ z         ┆ 1   ┆ x   │
+    #   # │ 2         ┆ y         ┆ 2   ┆ y   │
+    #   # │ 1         ┆ x         ┆ 3   ┆ z   │
+    #   # └───────────┴───────────┴─────┴─────┘
+    def map(&f)
+      Utils.wrap_expr(_rbexpr.name_map(f))
+    end
+
+    # Add a prefix to the root column name of the expression.
+    #
+    # @param prefix [Object]
+    #   Prefix to add to the root column name.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [1, 2, 3],
+    #       "b" => ["x", "y", "z"]
+    #     }
+    #   )
+    #   df.with_columns(Polars.all.reverse.name.prefix("reverse_"))
+    #   # =>
+    #   # shape: (3, 4)
+    #   # ┌─────┬─────┬───────────┬───────────┐
+    #   # │ a   ┆ b   ┆ reverse_a ┆ reverse_b │
+    #   # │ --- ┆ --- ┆ ---       ┆ ---       │
+    #   # │ i64 ┆ str ┆ i64       ┆ str       │
+    #   # ╞═════╪═════╪═══════════╪═══════════╡
+    #   # │ 1   ┆ x   ┆ 3         ┆ z         │
+    #   # │ 2   ┆ y   ┆ 2         ┆ y         │
+    #   # │ 3   ┆ z   ┆ 1         ┆ x         │
+    #   # └─────┴─────┴───────────┴───────────┘
+    def prefix(prefix)
+      Utils.wrap_expr(_rbexpr.name_prefix(prefix))
+    end
+
+    # Add a suffix to the root column name of the expression.
+    #
+    # @param suffix [Object]
+    #   Suffix to add to the root column name.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [1, 2, 3],
+    #       "b" => ["x", "y", "z"]
+    #     }
+    #   )
+    #   df.with_columns(Polars.all.reverse.name.suffix("_reverse"))
+    #   # =>
+    #   # shape: (3, 4)
+    #   # ┌─────┬─────┬───────────┬───────────┐
+    #   # │ a   ┆ b   ┆ a_reverse ┆ b_reverse │
+    #   # │ --- ┆ --- ┆ ---       ┆ ---       │
+    #   # │ i64 ┆ str ┆ i64       ┆ str       │
+    #   # ╞═════╪═════╪═══════════╪═══════════╡
+    #   # │ 1   ┆ x   ┆ 3         ┆ z         │
+    #   # │ 2   ┆ y   ┆ 2         ┆ y         │
+    #   # │ 3   ┆ z   ┆ 1         ┆ x         │
+    #   # └─────┴─────┴───────────┴───────────┘
+    def suffix(suffix)
+      Utils.wrap_expr(_rbexpr.name_suffix(suffix))
+    end
+
+    # Make the root column name lowercase.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "ColX" => [1, 2, 3],
+    #       "ColY" => ["x", "y", "z"],
+    #     }
+    #   )
+    #   df.with_columns(Polars.all.name.to_lowercase)
+    #   # =>
+    #   # shape: (3, 4)
+    #   # ┌──────┬──────┬──────┬──────┐
+    #   # │ ColX ┆ ColY ┆ colx ┆ coly │
+    #   # │ ---  ┆ ---  ┆ ---  ┆ ---  │
+    #   # │ i64  ┆ str  ┆ i64  ┆ str  │
+    #   # ╞══════╪══════╪══════╪══════╡
+    #   # │ 1    ┆ x    ┆ 1    ┆ x    │
+    #   # │ 2    ┆ y    ┆ 2    ┆ y    │
+    #   # │ 3    ┆ z    ┆ 3    ┆ z    │
+    #   # └──────┴──────┴──────┴──────┘
+    def to_lowercase
+      Utils.wrap_expr(_rbexpr.name_to_lowercase)
+    end
+
+    # Make the root column name uppercase.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "ColX" => [1, 2, 3],
+    #       "ColY" => ["x", "y", "z"]
+    #     }
+    #   )
+    #   df.with_columns(Polars.all.name.to_uppercase)
+    #   # =>
+    #   # shape: (3, 4)
+    #   # ┌──────┬──────┬──────┬──────┐
+    #   # │ ColX ┆ ColY ┆ COLX ┆ COLY │
+    #   # │ ---  ┆ ---  ┆ ---  ┆ ---  │
+    #   # │ i64  ┆ str  ┆ i64  ┆ str  │
+    #   # ╞══════╪══════╪══════╪══════╡
+    #   # │ 1    ┆ x    ┆ 1    ┆ x    │
+    #   # │ 2    ┆ y    ┆ 2    ┆ y    │
+    #   # │ 3    ┆ z    ┆ 3    ┆ z    │
+    #   # └──────┴──────┴──────┴──────┘
+    def to_uppercase
+      Utils.wrap_expr(_rbexpr.name_to_uppercase)
+    end
+  end
+end

data/lib/polars/plot.rb

@@ -0,0 +1,109 @@
+module Polars
+  module Plot
+    # Plot data.
+    #
+    # @return [Vega::LiteChart]
+    def plot(x = nil, y = nil, type: nil, group: nil, stacked: nil)
+      require "vega"
+
+      raise ArgumentError, "Must specify columns" if columns.size != 2 && (!x || !y)
+      x ||= columns[0]
+      y ||= columns[1]
+      type ||= begin
+        if self[x].numeric? && self[y].numeric?
+          "scatter"
+        elsif self[x].utf8? && self[y].numeric?
+          "column"
+        elsif (self[x].dtype == Date || self[x].dtype.is_a?(Datetime)) && self[y].numeric?
+          "line"
+        else
+          raise "Cannot determine type. Use the type option."
+        end
+      end
+      df = self[(group.nil? ? [x, y] : [x, y, group]).map(&:to_s).uniq]
+      data = df.rows(named: true)
+
+      case type
+      when "line", "area"
+        x_type =
+          if df[x].numeric?
+            "quantitative"
+          elsif df[x].datelike?
+            "temporal"
+          else
+            "nominal"
+          end
+
+        scale = x_type == "temporal" ? {type: "utc"} : {}
+        encoding = {
+          x: {field: x, type: x_type, scale: scale},
+          y: {field: y, type: "quantitative"}
+        }
+        encoding[:color] = {field: group} if group
+
+        Vega.lite
+          .data(data)
+          .mark(type: type, tooltip: true, interpolate: "cardinal", point: {size: 60})
+          .encoding(encoding)
+          .config(axis: {labelFontSize: 12})
+      when "pie"
+        raise ArgumentError, "Cannot use group option with pie chart" unless group.nil?
+
+        Vega.lite
+          .data(data)
+          .mark(type: "arc", tooltip: true)
+          .encoding(
+            color: {field: x, type: "nominal", sort: "none", axis: {title: nil}, legend: {labelFontSize: 12}},
+            theta: {field: y, type: "quantitative"}
+          )
+          .view(stroke: nil)
+      when "column"
+        encoding = {
+          x: {field: x, type: "nominal", sort: "none", axis: {labelAngle: 0}},
+          y: {field: y, type: "quantitative"}
+        }
+        if group
+          encoding[:color] = {field: group}
+          encoding[:xOffset] = {field: group} unless stacked
+        end
+
+        Vega.lite
+          .data(data)
+          .mark(type: "bar", tooltip: true)
+          .encoding(encoding)
+          .config(axis: {labelFontSize: 12})
+      when "bar"
+        encoding = {
+          # TODO determine label angle
+          y: {field: x, type: "nominal", sort: "none", axis: {labelAngle: 0}},
+          x: {field: y, type: "quantitative"}
+        }
+        if group
+          encoding[:color] = {field: group}
+          encoding[:yOffset] = {field: group} unless stacked
+        end
+
+        Vega.lite
+          .data(data)
+          .mark(type: "bar", tooltip: true)
+          .encoding(encoding)
+          .config(axis: {labelFontSize: 12})
+      when "scatter"
+        encoding = {
+          x: {field: x, type: "quantitative", scale: {zero: false}},
+          y: {field: y, type: "quantitative", scale: {zero: false}},
+          size: {value: 60}
+        }
+        encoding[:color] = {field: group} if group
+
+        Vega.lite
+          .data(data)
+          .mark(type: "circle", tooltip: true)
+          .encoding(encoding)
+          .config(axis: {labelFontSize: 12})
+      else
+        raise ArgumentError, "Invalid type: #{type}"
+      end
+    end
+  end
+end

data/lib/polars/rolling_group_by.rb

@@ -0,0 +1,37 @@
+module Polars
+  # A rolling grouper.
+  #
+  # This has an `.agg` method which will allow you to run all polars expressions in a
+  # group by context.
+  class RollingGroupBy
+    def initialize(
+      df,
+      index_column,
+      period,
+      offset,
+      closed,
+      by,
+      check_sorted
+    )
+      period = Utils._timedelta_to_pl_duration(period)
+      offset = Utils._timedelta_to_pl_duration(offset)
+
+      @df = df
+      @time_column = index_column
+      @period = period
+      @offset = offset
+      @closed = closed
+      @by = by
+      @check_sorted = check_sorted
+    end
+
+    def agg(aggs)
+      @df.lazy
+        .group_by_rolling(
+          index_column: @time_column, period: @period, offset: @offset, closed: @closed, by: @by, check_sorted: @check_sorted
+        )
+        .agg(aggs)
+        .collect(no_optimization: true, string_cache: false)
+    end
+  end
+end