polars-df 0.13.0-aarch64-linux-musl

data/lib/polars/array_name_space.rb

@@ -0,0 +1,423 @@
+module Polars
+  # Series.arr namespace.
+  class ArrayNameSpace
+    include ExprDispatch
+
+    self._accessor = "arr"
+
+    # @private
+    def initialize(series)
+      self._s = series._s
+    end
+
+    # Compute the min values of the sub-arrays.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new(
+    #     "a", [[1, 2], [4, 3]], dtype: Polars::Array.new(2, Polars::Int64)
+    #   )
+    #   s.arr.min
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         1
+    #   #         3
+    #   # ]
+    def min
+      super
+    end
+
+    # Compute the max values of the sub-arrays.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new(
+    #     "a", [[1, 2], [4, 3]], dtype: Polars::Array.new(2, Polars::Int64)
+    #   )
+    #   s.arr.max
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         2
+    #   #         4
+    #   # ]
+    def max
+      super
+    end
+
+    # Compute the sum values of the sub-arrays.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {"a" => [[1, 2], [4, 3]]},
+    #     schema: {"a" => Polars::Array.new(2, Polars::Int64)}
+    #   )
+    #   df.select(Polars.col("a").arr.sum)
+    #   # =>
+    #   # shape: (2, 1)
+    #   # ┌─────┐
+    #   # │ a   │
+    #   # │ --- │
+    #   # │ i64 │
+    #   # ╞═════╡
+    #   # │ 3   │
+    #   # │ 7   │
+    #   # └─────┘
+    def sum
+      super
+    end
+
+    # Get the unique/distinct values in the array.
+    #
+    # @param maintain_order [Boolean]
+    #   Maintain order of data. This requires more work.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [[1, 1, 2]]
+    #     },
+    #     schema_overrides: {"a" => Polars::Array.new(Polars::Int64, 3)}
+    #   )
+    #   df.select(Polars.col("a").arr.unique)
+    #   # =>
+    #   # shape: (1, 1)
+    #   # ┌───────────┐
+    #   # │ a         │
+    #   # │ ---       │
+    #   # │ list[i64] │
+    #   # ╞═══════════╡
+    #   # │ [1, 2]    │
+    #   # └───────────┘
+    def unique(maintain_order: false)
+      super
+    end
+
+    # Convert an Array column into a List column with the same inner data type.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new([[1, 2], [3, 4]], dtype: Polars::Array.new(Polars::Int8, 2))
+    #   s.arr.to_list
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: '' [list[i8]]
+    #   # [
+    #   #         [1, 2]
+    #   #         [3, 4]
+    #   # ]
+    def to_list
+      super
+    end
+
+    # Evaluate whether any boolean value is true for every subarray.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new(
+    #     [[true, true], [false, true], [false, false], [nil, nil], nil],
+    #     dtype: Polars::Array.new(Polars::Boolean, 2)
+    #   )
+    #   s.arr.any
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: '' [bool]
+    #   # [
+    #   #         true
+    #   #         true
+    #   #         false
+    #   #         false
+    #   #         null
+    #   # ]
+    def any
+      super
+    end
+
+    # Evaluate whether all boolean values are true for every subarray.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new(
+    #     [[true, true], [false, true], [false, false], [nil, nil], nil],
+    #     dtype: Polars::Array.new(Polars::Boolean, 2)
+    #   )
+    #   s.arr.all
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: '' [bool]
+    #   # [
+    #   #         true
+    #   #         false
+    #   #         false
+    #   #         true
+    #   #         null
+    #   # ]
+    def all
+      super
+    end
+
+    # Sort the arrays in this column.
+    #
+    # @param descending [Boolean]
+    #   Sort in descending order.
+    # @param nulls_last [Boolean]
+    #   Place null values last.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [[3, 2, 1], [9, 1, 2]], dtype: Polars::Array.new(Polars::Int64, 3))
+    #   s.arr.sort
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: 'a' [array[i64, 3]]
+    #   # [
+    #   #         [1, 2, 3]
+    #   #         [1, 2, 9]
+    #   # ]
+    #
+    # @example
+    #   s.arr.sort(descending: true)
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: 'a' [array[i64, 3]]
+    #   # [
+    #   #         [3, 2, 1]
+    #   #         [9, 2, 1]
+    #   # ]
+    def sort(descending: false, nulls_last: false)
+      super
+    end
+
+    # Reverse the arrays in this column.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [[3, 2, 1], [9, 1, 2]], dtype: Polars::Array.new(Polars::Int64, 3))
+    #   s.arr.reverse
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: 'a' [array[i64, 3]]
+    #   # [
+    #   #         [1, 2, 3]
+    #   #         [2, 1, 9]
+    #   # ]
+    def reverse
+      super
+    end
+
+    # Retrieve the index of the minimal value in every sub-array.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [[3, 2, 1], [9, 1, 2]], dtype: Polars::Array.new(Polars::Int64, 3))
+    #   s.arr.arg_min
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: 'a' [u32]
+    #   # [
+    #   #         2
+    #   #         1
+    #   # ]
+    def arg_min
+      super
+    end
+
+    # Retrieve the index of the maximum value in every sub-array.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [[0, 9, 3], [9, 1, 2]], dtype: Polars::Array.new(Polars::Int64, 3))
+    #   s.arr.arg_max
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: 'a' [u32]
+    #   # [
+    #   #         1
+    #   #         0
+    #   # ]
+    def arg_max
+      super
+    end
+
+    # Get the value by index in the sub-arrays.
+    #
+    # So index `0` would return the first item of every sublist
+    # and index `-1` would return the last item of every sublist
+    # if an index is out of bounds, it will return a `nil`.
+    #
+    # @param index [Integer]
+    #   Index to return per sublist
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new(
+    #     "a", [[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype: Polars::Array.new(Polars::Int32, 3)
+    #   )
+    #   s.arr.get(Polars::Series.new([1, -2, 4]))
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [i32]
+    #   # [
+    #   #         2
+    #   #         5
+    #   #         null
+    #   # ]
+    def get(index)
+      super
+    end
+
+    # Get the first value of the sub-arrays.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new(
+    #     "a", [[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype: Polars::Array.new(Polars::Int32, 3)
+    #   )
+    #   s.arr.first
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [i32]
+    #   # [
+    #   #         1
+    #   #         4
+    #   #         7
+    #   # ]
+    def first
+      super
+    end
+
+    # Get the last value of the sub-arrays.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new(
+    #     "a", [[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype: Polars::Array.new(Polars::Int32, 3)
+    #   )
+    #   s.arr.last
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [i32]
+    #   # [
+    #   #         3
+    #   #         6
+    #   #         9
+    #   # ]
+    def last
+      super
+    end
+
+    # Join all string items in a sub-array and place a separator between them.
+    #
+    # This errors if inner type of array `!= String`.
+    #
+    # @param separator [String]
+    #   string to separate the items with
+    # @param ignore_nulls [Boolean]
+    #   Ignore null values (default).
+    #
+    #   If set to `False`, null values will be propagated.
+    #   If the sub-list contains any null values, the output is `nil`.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new([["x", "y"], ["a", "b"]], dtype: Polars::Array.new(Polars::String, 2))
+    #   s.arr.join("-")
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: '' [str]
+    #   # [
+    #   #         "x-y"
+    #   #         "a-b"
+    #   # ]
+    def join(separator, ignore_nulls: true)
+      super
+    end
+
+    # Returns a column with a separate row for every array element.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [[1, 2, 3], [4, 5, 6]], dtype: Polars::Array.new(Polars::Int64, 3))
+    #   s.arr.explode
+    #   # =>
+    #   # shape: (6,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         1
+    #   #         2
+    #   #         3
+    #   #         4
+    #   #         5
+    #   #         6
+    #   # ]
+    def explode
+      super
+    end
+
+    # Check if sub-arrays contain the given item.
+    #
+    # @param item [Object]
+    #   Item that will be checked for membership
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new(
+    #     "a", [[3, 2, 1], [1, 2, 3], [4, 5, 6]], dtype: Polars::Array.new(Polars::Int32, 3)
+    #   )
+    #   s.arr.contains(1)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [bool]
+    #   # [
+    #   #         true
+    #   #         true
+    #   #         false
+    #   # ]
+    def contains(item)
+      super
+    end
+
+    # Count how often the value produced by `element` occurs.
+    #
+    # @param element [Object]
+    #   An expression that produces a single value
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [[1, 2, 3], [2, 2, 2]], dtype: Polars::Array.new(Polars::Int64, 3))
+    #   s.arr.count_matches(2)
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: 'a' [u32]
+    #   # [
+    #   #         1
+    #   #         3
+    #   # ]
+    def count_matches(element)
+      super
+    end
+  end
+end

data/lib/polars/batched_csv_reader.rb

@@ -0,0 +1,104 @@
+module Polars
+  # @private
+  class BatchedCsvReader
+    attr_accessor :_reader, :new_columns
+
+    def initialize(
+      file,
+      has_header: true,
+      columns: nil,
+      sep: ",",
+      comment_char: nil,
+      quote_char: '"',
+      skip_rows: 0,
+      dtypes: nil,
+      null_values: nil,
+      missing_utf8_is_empty_string: false,
+      ignore_errors: false,
+      parse_dates: false,
+      n_threads: nil,
+      infer_schema_length: 100,
+      batch_size: 50_000,
+      n_rows: nil,
+      encoding: "utf8",
+      low_memory: false,
+      rechunk: true,
+      skip_rows_after_header: 0,
+      row_count_name: nil,
+      row_count_offset: 0,
+      sample_size: 1024,
+      eol_char: "\n",
+      new_columns: nil,
+      raise_if_empty: true,
+      truncate_ragged_lines: false,
+      decimal_comma: false
+    )
+      if Utils.pathlike?(file)
+        path = Utils.normalize_filepath(file)
+      end
+
+      dtype_list = nil
+      dtype_slice = nil
+      if !dtypes.nil?
+        if dtypes.is_a?(Hash)
+          dtype_list = []
+          dtypes.each do |k, v|
+            dtype_list << [k, Utils.rb_type_to_dtype(v)]
+          end
+        elsif dtypes.is_a?(::Array)
+          dtype_slice = dtypes
+        else
+          raise ArgumentError, "dtype arg should be list or dict"
+        end
+      end
+
+      processed_null_values = Utils._process_null_values(null_values)
+      projection, columns = Utils.handle_projection_columns(columns)
+
+      self._reader = RbBatchedCsv.new(
+        infer_schema_length,
+        batch_size,
+        has_header,
+        ignore_errors,
+        n_rows,
+        skip_rows,
+        projection,
+        sep,
+        rechunk,
+        columns,
+        encoding,
+        n_threads,
+        path,
+        dtype_list,
+        dtype_slice,
+        low_memory,
+        comment_char,
+        quote_char,
+        processed_null_values,
+        missing_utf8_is_empty_string,
+        parse_dates,
+        skip_rows_after_header,
+        Utils.parse_row_index_args(row_count_name, row_count_offset),
+        sample_size,
+        eol_char,
+        raise_if_empty,
+        truncate_ragged_lines,
+        decimal_comma
+      )
+      self.new_columns = new_columns
+    end
+
+    def next_batches(n)
+      batches = _reader.next_batches(n)
+      if !batches.nil?
+        if new_columns
+          batches.map { |df| Utils._update_columns(Utils.wrap_df(df), new_columns) }
+        else
+          batches.map { |df| Utils.wrap_df(df) }
+        end
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/polars/binary_expr.rb

@@ -0,0 +1,77 @@
+module Polars
+  # Namespace for binary related expressions.
+  class BinaryExpr
+    # @private
+    attr_accessor :_rbexpr
+
+    # @private
+    def initialize(expr)
+      self._rbexpr = expr._rbexpr
+    end
+
+    # Check if binaries in Series contain a binary substring.
+    #
+    # @param lit [String]
+    #   The binary substring to look for
+    #
+    # @return [Expr]
+    def contains(lit)
+      Utils.wrap_expr(_rbexpr.binary_contains(lit))
+    end
+
+    # Check if string values end with a binary substring.
+    #
+    # @param sub [String]
+    #   Suffix substring.
+    #
+    # @return [Expr]
+    def ends_with(sub)
+      Utils.wrap_expr(_rbexpr.binary_ends_with(sub))
+    end
+
+    # Check if values start with a binary substring.
+    #
+    # @param sub [String]
+    #   Prefix substring.
+    #
+    # @return [Expr]
+    def starts_with(sub)
+      Utils.wrap_expr(_rbexpr.binary_starts_with(sub))
+    end
+
+    # Decode a value using the provided encoding.
+    #
+    # @param encoding ["hex", "base64"]
+    #   The encoding to use.
+    # @param strict [Boolean]
+    #   Raise an error if the underlying value cannot be decoded,
+    #   otherwise mask out with a null value.
+    #
+    # @return [Expr]
+    def decode(encoding, strict: true)
+      if encoding == "hex"
+        Utils.wrap_expr(_rbexpr.binary_hex_decode(strict))
+      elsif encoding == "base64"
+        Utils.wrap_expr(_rbexpr.binary_base64_decode(strict))
+      else
+        raise ArgumentError, "encoding must be one of {{'hex', 'base64'}}, got #{encoding}"
+      end
+    end
+
+    # Encode a value using the provided encoding.
+    #
+    # @param encoding ["hex", "base64"]
+    #   The encoding to use.
+    #
+    # @return [Expr]
+    def encode(encoding)
+      if encoding == "hex"
+        Utils.wrap_expr(_rbexpr.binary_hex_encode)
+      elsif encoding == "base64"
+        Utils.wrap_expr(_rbexpr.binary_base64_encode)
+      else
+        raise ArgumentError, "encoding must be one of {{'hex', 'base64'}}, got #{encoding}"
+      end
+    end
+  end
+end

data/lib/polars/binary_name_space.rb

@@ -0,0 +1,66 @@
+module Polars
+  # Series.bin namespace.
+  class BinaryNameSpace
+    include ExprDispatch
+
+    self._accessor = "bin"
+
+    # @private
+    def initialize(series)
+      self._s = series._s
+    end
+
+    # Check if binaries in Series contain a binary substring.
+    #
+    # @param lit [String]
+    #   The binary substring to look for
+    #
+    # @return [Series]
+    def contains(lit)
+      super
+    end
+
+    # Check if string values end with a binary substring.
+    #
+    # @param sub [String]
+    #   Suffix substring.
+    #
+    # @return [Series]
+    def ends_with(sub)
+      super
+    end
+
+    # Check if values start with a binary substring.
+    #
+    # @param sub [String]
+    #   Prefix substring.
+    #
+    # @return [Series]
+    def starts_with(sub)
+      super
+    end
+
+    # Decode a value using the provided encoding.
+    #
+    # @param encoding ["hex", "base64"]
+    #   The encoding to use.
+    # @param strict [Boolean]
+    #   Raise an error if the underlying value cannot be decoded,
+    #   otherwise mask out with a null value.
+    #
+    # @return [Series]
+    def decode(encoding, strict: true)
+      super
+    end
+
+    # Encode a value using the provided encoding.
+    #
+    # @param encoding ["hex", "base64"]
+    #   The encoding to use.
+    #
+    # @return [Series]
+    def encode(encoding)
+      super
+    end
+  end
+end

data/lib/polars/cat_expr.rb

@@ -0,0 +1,36 @@
+module Polars
+  # Namespace for categorical related expressions.
+  class CatExpr
+    # @private
+    attr_accessor :_rbexpr
+
+    # @private
+    def initialize(expr)
+      self._rbexpr = expr._rbexpr
+    end
+
+    # Get the categories stored in this data type.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::Series.new(
+    #     "cats", ["foo", "bar", "foo", "foo", "ham"], dtype: Polars::Categorical
+    #   ).to_frame
+    #   df.select(Polars.col("cats").cat.get_categories)
+    #   # =>
+    #   # shape: (3, 1)
+    #   # ┌──────┐
+    #   # │ cats │
+    #   # │ ---  │
+    #   # │ str  │
+    #   # ╞══════╡
+    #   # │ foo  │
+    #   # │ bar  │
+    #   # │ ham  │
+    #   # └──────┘
+    def get_categories
+      Utils.wrap_expr(_rbexpr.cat_get_categories)
+    end
+  end
+end