polars-df 0.5.0-x86_64-darwin → 0.6.0-x86_64-darwin

data/lib/polars/list_name_space.rb

@@ -1,9 +1,9 @@
 module Polars
-  # Series.arr namespace.
+  # Series.list namespace.
   class ListNameSpace
     include ExprDispatch
 
-    self._accessor = "arr"
+    self._accessor = "list"
 
     # @private
     def initialize(series)
@@ -16,7 +16,7 @@ module Polars
     #
     # @example
     #   s = Polars::Series.new([[1, 2, 3], [5]])
-    #   s.arr.lengths
+    #   s.list.lengths
     #   # =>
     #   # shape: (2,)
     #   # Series: '' [u32]
@@ -119,13 +119,13 @@ module Polars
     #
     # @example
     #   s = Polars::Series.new([["foo", "bar"], ["hello", "world"]])
-    #   s.arr.join("-")
+    #   s.list.join("-")
     #   # =>
     #   # shape: (2,)
     #   # Series: '' [str]
     #   # [
-    #   #     "foo-bar"
-    #   #     "hello-world"
+    #   #         "foo-bar"
+    #   #         "hello-world"
     #   # ]
     def join(separator)
       super
@@ -180,7 +180,7 @@ module Polars
     #
     # @example
     #   s = Polars::Series.new("a", [[1, 2, 3, 4], [10, 2, 1]])
-    #   s.arr.diff
+    #   s.list.diff
     #   # =>
     #   # shape: (2,)
     #   # Series: 'a' [list[i64]]
@@ -201,7 +201,7 @@ module Polars
     #
     # @example
     #   s = Polars::Series.new("a", [[1, 2, 3, 4], [10, 2, 1]])
-    #   s.arr.shift
+    #   s.list.shift
     #   # =>
     #   # shape: (2,)
     #   # Series: 'a' [list[i64]]
@@ -225,7 +225,7 @@ module Polars
     #
     # @example
     #   s = Polars::Series.new("a", [[1, 2, 3, 4], [10, 2, 1]])
-    #   s.arr.slice(1, 2)
+    #   s.list.slice(1, 2)
     #   # =>
     #   # shape: (2,)
     #   # Series: 'a' [list[i64]]
@@ -246,7 +246,7 @@ module Polars
     #
     # @example
     #   s = Polars::Series.new("a", [[1, 2, 3, 4], [10, 2, 1]])
-    #   s.arr.head(2)
+    #   s.list.head(2)
     #   # =>
     #   # shape: (2,)
     #   # Series: 'a' [list[i64]]
@@ -267,7 +267,7 @@ module Polars
     #
     # @example
     #   s = Polars::Series.new("a", [[1, 2, 3, 4], [10, 2, 1]])
-    #   s.arr.tail(2)
+    #   s.list.tail(2)
     #   # =>
     #   # shape: (2,)
     #   # Series: 'a' [list[i64]]
@@ -291,7 +291,7 @@ module Polars
     #
     # @example
     #   df = Polars::DataFrame.new({"a" => [[1, 2, 3], [1, 2]]})
-    #   df.select([Polars.col("a").arr.to_struct])
+    #   df.select([Polars.col("a").list.to_struct])
     #   # =>
     #   # shape: (2, 1)
     #   # ┌────────────┐
@@ -323,7 +323,7 @@ module Polars
     # @example
     #   df = Polars::DataFrame.new({"a" => [1, 8, 3], "b" => [4, 5, 2]})
     #   df.with_column(
-    #     Polars.concat_list(["a", "b"]).arr.eval(Polars.element.rank).alias("rank")
+    #     Polars.concat_list(["a", "b"]).list.eval(Polars.element.rank).alias("rank")
     #   )
     #   # =>
     #   # shape: (3, 3)

data/lib/polars/rolling_group_by.rb

@@ -10,7 +10,8 @@ module Polars
       period,
       offset,
       closed,
-      by
+      by,
+      check_sorted
     )
       period = Utils._timedelta_to_pl_duration(period)
       offset = Utils._timedelta_to_pl_duration(offset)
@@ -21,12 +22,13 @@ module Polars
       @offset = offset
       @closed = closed
       @by = by
+      @check_sorted = check_sorted
     end
 
     def agg(aggs)
       @df.lazy
         .groupby_rolling(
-          index_column: @time_column, period: @period, offset: @offset, closed: @closed, by: @by
+          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)

data/lib/polars/series.rb

@@ -65,7 +65,7 @@ module Polars
           )
           .rename(name, in_place: true)
           ._s
-      elsif values.is_a?(Array)
+      elsif values.is_a?(::Array)
         self._s = sequence_to_rbseries(name, values, dtype: dtype, strict: strict, dtype_if_empty: dtype_if_empty)
       elsif defined?(Numo::NArray) && values.is_a?(Numo::NArray)
         self._s = numo_to_rbseries(name, values, strict: strict, nan_to_null: nan_to_null)
@@ -317,6 +317,10 @@ module Polars
       end
 
       if item.is_a?(Integer)
+        if item < 0
+          item = len + item
+        end
+
         return _s.get_idx(item)
       end
 
@@ -335,7 +339,7 @@ module Polars
     #
     # @return [Object]
     def []=(key, value)
-      if value.is_a?(Array)
+      if value.is_a?(::Array)
         if is_numeric || is_datelike
           set_at_idx(key, value)
           return
@@ -353,7 +357,7 @@ module Polars
         else
           raise Todo
         end
-      elsif key.is_a?(Array)
+      elsif key.is_a?(::Array)
         s = Utils.wrap_s(sequence_to_rbseries("", key, dtype: UInt32))
         self[s] = value
       elsif key.is_a?(Range)
@@ -715,8 +719,8 @@ module Polars
     #   # │ 0   ┆ 1   ┆ 0   │
     #   # │ 0   ┆ 0   ┆ 1   │
     #   # └─────┴─────┴─────┘
-    def to_dummies(separator: "_")
-      Utils.wrap_df(_s.to_dummies(separator))
+    def to_dummies(separator: "_", drop_first: false)
+      Utils.wrap_df(_s.to_dummies(separator, drop_first))
     end
 
     # Count the unique values in a Series.
@@ -1124,7 +1128,7 @@ module Polars
     #   #         3
     #   # ]
     def filter(predicate)
-      if predicate.is_a?(Array)
+      if predicate.is_a?(::Array)
         predicate = Series.new("", predicate)
       end
       Utils.wrap_s(_s.filter(predicate._s))
@@ -2813,7 +2817,8 @@ module Polars
       window_size,
       weights: nil,
       min_periods: nil,
-      center: false
+      center: false,
+      ddof: 1
     )
       to_frame
         .select(
@@ -2821,7 +2826,8 @@ module Polars
             window_size,
             weights: weights,
             min_periods: min_periods,
-            center: center
+            center: center,
+            ddof: ddof
           )
         )
         .to_series
@@ -2864,7 +2870,8 @@ module Polars
       window_size,
       weights: nil,
       min_periods: nil,
-      center: false
+      center: false,
+      ddof: 1
     )
       to_frame
         .select(
@@ -2872,7 +2879,8 @@ module Polars
             window_size,
             weights: weights,
             min_periods: min_periods,
-            center: center
+            center: center,
+            ddof: ddof
           )
         )
         .to_series
@@ -3581,10 +3589,17 @@ module Polars
     # Create an object namespace of all list related methods.
     #
     # @return [ListNameSpace]
-    def arr
+    def list
       ListNameSpace.new(self)
     end
 
+    # Create an object namespace of all array related methods.
+    #
+    # @return [ArrayNameSpace]
+    def arr
+      ArrayNameSpace.new(self)
+    end
+
     # Create an object namespace of all binary related methods.
     #
     # @return [BinaryNameSpace]
@@ -3824,9 +3839,12 @@ module Polars
 
       if (values.nil? || values.empty?) && dtype.nil?
         dtype = dtype_if_empty || Float32
+      elsif dtype == List
+        ruby_dtype = ::Array
       end
 
       rb_temporal_types = [::Date, ::DateTime, ::Time]
+      rb_temporal_types << ActiveSupport::TimeWithZone if defined?(ActiveSupport::TimeWithZone)
 
       value = _get_first_non_none(values)
       if !value.nil?
@@ -3835,9 +3853,20 @@ module Polars
         end
       end
 
-      if !dtype.nil? && Utils.is_polars_dtype(dtype) && ruby_dtype.nil?
+      if !dtype.nil? && ![List, Unknown].include?(dtype) && Utils.is_polars_dtype(dtype) && ruby_dtype.nil?
+        if dtype == Array && !dtype.is_a?(Array) && value.is_a?(::Array)
+          dtype = Array.new(value.size)
+        end
+
         constructor = polars_type_to_constructor(dtype)
         rbseries = constructor.call(name, values, strict)
+
+        base_type = dtype.is_a?(DataType) ? dtype.class : dtype
+        if [Date, Datetime, Duration, Time, Categorical, Boolean].include?(base_type)
+          if rbseries.dtype != dtype
+            rbseries = rbseries.cast(dtype, true)
+          end
+        end
         return rbseries
       else
         if ruby_dtype.nil?
@@ -3868,7 +3897,17 @@ module Polars
           return s._s
         elsif defined?(Numo::NArray) && value.is_a?(Numo::NArray) && value.shape.length == 1
           raise Todo
-        elsif ruby_dtype == Array
+        elsif ruby_dtype == ::Array
+          if dtype.is_a?(Object)
+            return RbSeries.new_object(name, values, strict)
+          end
+          if dtype
+            srs = sequence_from_anyvalue_or_object(name, values)
+            if dtype != srs.dtype
+              srs = srs.cast(dtype, strict: false)
+            end
+            return srs
+          end
           return sequence_from_anyvalue_or_object(name, values)
         elsif ruby_dtype == Series
           return RbSeries.new_series_list(name, values.map(&:_s), strict)
@@ -3910,9 +3949,17 @@ module Polars
       UInt16 => RbSeries.method(:new_opt_u16),
       UInt32 => RbSeries.method(:new_opt_u32),
       UInt64 => RbSeries.method(:new_opt_u64),
+      Decimal => RbSeries.method(:new_decimal),
+      Date => RbSeries.method(:new_from_anyvalues),
+      Datetime => RbSeries.method(:new_from_anyvalues),
+      Duration => RbSeries.method(:new_from_anyvalues),
+      Time => RbSeries.method(:new_from_anyvalues),
       Boolean => RbSeries.method(:new_opt_bool),
       Utf8 => RbSeries.method(:new_str),
-      Binary => RbSeries.method(:new_binary)
+      Object => RbSeries.method(:new_object),
+      Categorical => RbSeries.method(:new_str),
+      Binary => RbSeries.method(:new_binary),
+      Null => RbSeries.method(:new_null)
     }
 
     SYM_TYPE_TO_CONSTRUCTOR = {
@@ -3931,8 +3978,14 @@ module Polars
     }
 
     def polars_type_to_constructor(dtype)
-      if dtype.is_a?(Class) && dtype < DataType
+      if dtype.is_a?(Array)
+        lambda do |name, values, strict|
+          RbSeries.new_array(dtype.width, dtype.inner, name, values, strict)
+        end
+      elsif dtype.is_a?(Class) && dtype < DataType
         POLARS_TYPE_TO_CONSTRUCTOR.fetch(dtype)
+      elsif dtype.is_a?(DataType)
+        POLARS_TYPE_TO_CONSTRUCTOR.fetch(dtype.class)
       else
         SYM_TYPE_TO_CONSTRUCTOR.fetch(dtype.to_sym)
       end
@@ -3944,7 +3997,8 @@ module Polars
       Float => RbSeries.method(:new_opt_f64),
       Integer => RbSeries.method(:new_opt_i64),
       TrueClass => RbSeries.method(:new_opt_bool),
-      FalseClass => RbSeries.method(:new_opt_bool)
+      FalseClass => RbSeries.method(:new_opt_bool),
+      BigDecimal => RbSeries.method(:new_decimal)
     }
 
     def rb_type_to_constructor(dtype)

data/lib/polars/string_expr.rb

@@ -9,11 +9,129 @@ module Polars
       self._rbexpr = expr._rbexpr
     end
 
+    # Convert a Utf8 column into a Date column.
+    #
+    # @param format [String]
+    #   Format to use for conversion. Refer to the
+    #   [chrono crate documentation](https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
+    #   for the full specification. Example: `"%Y-%m-%d"`.
+    #   If set to nil (default), the format is inferred from the data.
+    # @param strict [Boolean]
+    #   Raise an error if any conversion fails.
+    # @param exact [Boolean]
+    #   Require an exact format match. If false, allow the format to match anywhere
+    #   in the target string.
+    # @param cache [Boolean]
+    #   Use a cache of unique, converted dates to apply the conversion.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   s = Polars::Series.new(["2020/01/01", "2020/02/01", "2020/03/01"])
+    #   s.str.to_date
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: '' [date]
+    #   # [
+    #   #         2020-01-01
+    #   #         2020-02-01
+    #   #         2020-03-01
+    #   # ]
+    def to_date(format = nil, strict: true, exact: true, cache: true)
+      _validate_format_argument(format)
+      Utils.wrap_expr(self._rbexpr.str_to_date(format, strict, exact, cache))
+    end
+
+    # Convert a Utf8 column into a Datetime column.
+    #
+    # @param format [String]
+    #   Format to use for conversion. Refer to the
+    #   [chrono crate documentation](https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
+    #   for the full specification. Example: `"%Y-%m-%d %H:%M:%S"`.
+    #   If set to nil (default), the format is inferred from the data.
+    # @param time_unit ["us", "ns", "ms"]
+    #   Unit of time for the resulting Datetime column. If set to nil (default),
+    #   the time unit is inferred from the format string if given, eg:
+    #   `"%F %T%.3f"` => `Datetime("ms")`. If no fractional second component is
+    #   found, the default is `"us"`.
+    # @param time_zone [String]
+    #   Time zone for the resulting Datetime column.
+    # @param strict [Boolean]
+    #   Raise an error if any conversion fails.
+    # @param exact [Boolean]
+    #   Require an exact format match. If false, allow the format to match anywhere
+    #   in the target string.
+    # @param cache [Boolean]
+    #   Use a cache of unique, converted datetimes to apply the conversion.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   s = Polars::Series.new(["2020-01-01 01:00Z", "2020-01-01 02:00Z"])
+    #   s.str.to_datetime("%Y-%m-%d %H:%M%#z")
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: '' [datetime[μs, UTC]]
+    #   # [
+    #   #         2020-01-01 01:00:00 UTC
+    #   #         2020-01-01 02:00:00 UTC
+    #   # ]
+    def to_datetime(
+      format = nil,
+      time_unit: nil,
+      time_zone: nil,
+      strict: true,
+      exact: true,
+      cache: true
+    )
+      _validate_format_argument(format)
+      Utils.wrap_expr(
+        self._rbexpr.str_to_datetime(
+          format,
+          time_unit,
+          time_zone,
+          strict,
+          exact,
+          cache
+        )
+      )
+    end
+
+    # Convert a Utf8 column into a Time column.
+    #
+    # @param format [String]
+    #   Format to use for conversion. Refer to the
+    #   [chrono crate documentation](https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
+    #   for the full specification. Example: `"%H:%M:%S"`.
+    #   If set to nil (default), the format is inferred from the data.
+    # @param strict [Boolean]
+    #   Raise an error if any conversion fails.
+    # @param cache [Boolean]
+    #   Use a cache of unique, converted times to apply the conversion.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   s = Polars::Series.new(["01:00", "02:00", "03:00"])
+    #   s.str.to_time("%H:%M")
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: '' [time]
+    #   # [
+    #   #         01:00:00
+    #   #         02:00:00
+    #   #         03:00:00
+    #   # ]
+    def to_time(format = nil, strict: true, cache: true)
+      _validate_format_argument(format)
+      Utils.wrap_expr(_rbexpr.str_to_time(format, strict, cache))
+    end
+
     # Parse a Utf8 expression to a Date/Datetime/Time type.
     #
     # @param dtype [Object]
     #   The data type to convert into. Can be either Date, Datetime, or Time.
-    # @param fmt [String]
+    # @param format [String]
     #   Format to use, refer to the
     #   [chrono strftime documentation](https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
     #   for specification. Example: `"%y-%m-%d"`.
@@ -38,10 +156,10 @@ module Polars
     #   s.str.strptime(Polars::Datetime, "%Y-%m-%d %H:%M%#z")
     #   # =>
     #   # shape: (2,)
-    #   # Series: '' [datetime[μs, +00:00]]
+    #   # Series: '' [datetime[μs, UTC]]
     #   # [
-    #   #         2020-01-01 01:00:00 +00:00
-    #   #         2020-01-01 02:00:00 +00:00
+    #   #         2020-01-01 01:00:00 UTC
+    #   #         2020-01-01 02:00:00 UTC
     #   # ]
     #
     # @example Dealing with different formats.
@@ -71,16 +189,18 @@ module Polars
     #   #         2022-01-31
     #   #         2001-07-08
     #   # ]
-    def strptime(dtype, fmt = nil, strict: true, exact: true, cache: true, tz_aware: false, utc: false)
+    def strptime(dtype, format = nil, strict: true, exact: true, cache: true, utc: false)
+      _validate_format_argument(format)
+
       if dtype == Date
-        Utils.wrap_expr(_rbexpr.str_parse_date(fmt, strict, exact, cache))
+        to_date(format, strict: strict, exact: exact, cache: cache)
       elsif dtype == Datetime || dtype.is_a?(Datetime)
         dtype = Datetime.new if dtype == Datetime
         time_unit = dtype.time_unit
         time_zone = dtype.time_zone
-        Utils.wrap_expr(_rbexpr.str_parse_datetime(fmt, time_unit, time_zone, strict, exact, cache, tz_aware, utc))
+        to_datetime(format, time_unit: time_unit, time_zone: time_zone, strict: strict, exact: exact, cache: cache)
       elsif dtype == Time
-        Utils.wrap_expr(_rbexpr.str_parse_time(fmt, strict, exact, cache))
+        to_time(format, strict: strict, cache: cache)
       else
         raise ArgumentError, "dtype should be of type {Date, Datetime, Time}"
       end
@@ -547,11 +667,11 @@ module Polars
     #   # │ {null,null} │
     #   # │ {2,false}   │
     #   # └─────────────┘
-    def json_extract(dtype = nil)
+    def json_extract(dtype = nil, infer_schema_length: 100)
       if !dtype.nil?
         dtype = Utils.rb_type_to_dtype(dtype)
       end
-      Utils.wrap_expr(_rbexpr.str_json_extract(dtype))
+      Utils.wrap_expr(_rbexpr.str_json_extract(dtype, infer_schema_length))
     end
 
     # Extract the first match of json string with provided JSONPath expression.
@@ -968,7 +1088,7 @@ module Polars
     #   # │ r   │
     #   # └─────┘
     def explode
-      Utils.wrap_expr(_rbexpr.explode)
+      Utils.wrap_expr(_rbexpr.str_explode)
     end
 
     # Parse integers with base radix from strings.
@@ -1018,5 +1138,11 @@ module Polars
     def parse_int(radix = 2, strict: true)
       Utils.wrap_expr(_rbexpr.str_parse_int(radix, strict))
     end
+
+    private
+
+    def _validate_format_argument(format)
+      # TODO
+    end
   end
 end