polars-df 0.6.0-x86_64-darwin → 0.8.0-x86_64-darwin

data/lib/polars/sql_context.rb

@@ -0,0 +1,194 @@
+module Polars
+  # Run SQL queries against DataFrame/LazyFrame data.
+  class SQLContext
+    # @private
+    attr_accessor :_ctxt, :_eager_execution
+
+    # Initialize a new `SQLContext`.
+    def initialize(frames = nil, eager_execution: false, **named_frames)
+      self._ctxt = RbSQLContext.new
+      self._eager_execution = eager_execution
+
+      frames = (frames || {}).to_h
+
+      if frames.any? || named_frames.any?
+        register_many(frames, **named_frames)
+      end
+    end
+
+    # Parse the given SQL query and execute it against the registered frame data.
+    #
+    # @param query [String]
+    #   A valid string SQL query.
+    # @param eager [Boolean]
+    #   Apply the query eagerly, returning `DataFrame` instead of `LazyFrame`.
+    #   If unset, the value of the init-time parameter "eager_execution" will be
+    #   used. (Note that the query itself is always executed in lazy-mode; this
+    #   parameter only impacts the type of the returned frame).
+    #
+    # @return [Object]
+    #
+    # @example Execute a SQL query against the registered frame data:
+    #   df = Polars::DataFrame.new(
+    #     [
+    #       ["The Godfather", 1972, 6_000_000, 134_821_952, 9.2],
+    #       ["The Dark Knight", 2008, 185_000_000, 533_316_061, 9.0],
+    #       ["Schindler's List", 1993, 22_000_000, 96_067_179, 8.9],
+    #       ["Pulp Fiction", 1994, 8_000_000, 107_930_000, 8.9],
+    #       ["The Shawshank Redemption", 1994, 25_000_000, 28_341_469, 9.3],
+    #     ],
+    #     schema: ["title", "release_year", "budget", "gross", "imdb_score"]
+    #   )
+    #   ctx = Polars::SQLContext.new(films: df)
+    #   ctx.execute(
+    #     "
+    #     SELECT title, release_year, imdb_score
+    #     FROM films
+    #     WHERE release_year > 1990
+    #     ORDER BY imdb_score DESC
+    #     ",
+    #     eager: true
+    #   )
+    #   # =>
+    #   # shape: (4, 3)
+    #   # ┌──────────────────────────┬──────────────┬────────────┐
+    #   # │ title                    ┆ release_year ┆ imdb_score │
+    #   # │ ---                      ┆ ---          ┆ ---        │
+    #   # │ str                      ┆ i64          ┆ f64        │
+    #   # ╞══════════════════════════╪══════════════╪════════════╡
+    #   # │ The Shawshank Redemption ┆ 1994         ┆ 9.3        │
+    #   # │ The Dark Knight          ┆ 2008         ┆ 9.0        │
+    #   # │ Schindler's List         ┆ 1993         ┆ 8.9        │
+    #   # │ Pulp Fiction             ┆ 1994         ┆ 8.9        │
+    #   # └──────────────────────────┴──────────────┴────────────┘
+    #
+    # @example Execute a GROUP BY query:
+    #   ctx.execute(
+    #     "
+    #     SELECT
+    #         MAX(release_year / 10) * 10 AS decade,
+    #         SUM(gross) AS total_gross,
+    #         COUNT(title) AS n_films,
+    #     FROM films
+    #     GROUP BY (release_year / 10) -- decade
+    #     ORDER BY total_gross DESC
+    #     ",
+    #     eager: true
+    #   )
+    #   # =>
+    #   # shape: (3, 3)
+    #   # ┌────────┬─────────────┬─────────┐
+    #   # │ decade ┆ total_gross ┆ n_films │
+    #   # │ ---    ┆ ---         ┆ ---     │
+    #   # │ i64    ┆ i64         ┆ u32     │
+    #   # ╞════════╪═════════════╪═════════╡
+    #   # │ 2000   ┆ 533316061   ┆ 1       │
+    #   # │ 1990   ┆ 232338648   ┆ 3       │
+    #   # │ 1970   ┆ 134821952   ┆ 1       │
+    #   # └────────┴─────────────┴─────────┘
+    def execute(query, eager: nil)
+      res = Utils.wrap_ldf(_ctxt.execute(query))
+      eager || _eager_execution ? res.collect : res
+    end
+
+    # Register a single frame as a table, using the given name.
+    #
+    # @param name [String]
+    #   Name of the table.
+    # @param frame [Object]
+    #   eager/lazy frame to associate with this table name.
+    #
+    # @return [SQLContext]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"hello" => ["world"]})
+    #   ctx = Polars::SQLContext.new
+    #   ctx.register("frame_data", df).execute("SELECT * FROM frame_data").collect
+    #   # =>
+    #   # shape: (1, 1)
+    #   # ┌───────┐
+    #   # │ hello │
+    #   # │ ---   │
+    #   # │ str   │
+    #   # ╞═══════╡
+    #   # │ world │
+    #   # └───────┘
+    def register(name, frame)
+      if frame.is_a?(DataFrame)
+        frame = frame.lazy
+      end
+      _ctxt.register(name.to_s, frame._ldf)
+      self
+    end
+
+    # Register multiple eager/lazy frames as tables, using the associated names.
+    #
+    # @param frames [Hash]
+    #   A `{name:frame, ...}` mapping.
+    # @param named_frames [Object]
+    #   Named eager/lazy frames, provided as kwargs.
+    #
+    # @return [SQLContext]
+    def register_many(frames, **named_frames)
+      frames = (frames || {}).to_h
+      frames = frames.merge(named_frames)
+      frames.each do |name, frame|
+        register(name, frame)
+      end
+      self
+    end
+
+    # Unregister one or more eager/lazy frames by name.
+    #
+    # @param names [Object]
+    #   Names of the tables to unregister.
+    #
+    # @return [SQLContext]
+    #
+    # @example Register with a SQLContext object:
+    #   df0 = Polars::DataFrame.new({"ints" => [9, 8, 7, 6, 5]})
+    #   lf1 = Polars::LazyFrame.new({"text" => ["a", "b", "c"]})
+    #   lf2 = Polars::LazyFrame.new({"misc" => ["testing1234"]})
+    #   ctx = Polars::SQLContext.new(test1: df0, test2: lf1, test3: lf2)
+    #   ctx.tables
+    #   # => ["test1", "test2", "test3"]
+    #
+    # @example Unregister one or more of the tables:
+    #   ctx.unregister(["test1", "test3"]).tables
+    #   # => ["test2"]
+    def unregister(names)
+      if names.is_a?(::String)
+        names = [names]
+      end
+      names.each do |nm|
+        _ctxt.unregister(nm)
+      end
+      self
+    end
+
+    # Return a list of the registered table names.
+    #
+    # @return [Array]
+    #
+    # @example Executing as SQL:
+    #   frame_data = Polars::DataFrame.new({"hello" => ["world"]})
+    #   ctx = Polars::SQLContext.new(hello_world: frame_data)
+    #   ctx.execute("SHOW TABLES", eager: true)
+    #   # =>
+    #   # shape: (1, 1)
+    #   # ┌─────────────┐
+    #   # │ name        │
+    #   # │ ---         │
+    #   # │ str         │
+    #   # ╞═════════════╡
+    #   # │ hello_world │
+    #   # └─────────────┘
+    #
+    # @example Calling the method:
+    #   ctx.tables
+    #   # => ["hello_world"]
+    def tables
+      _ctxt.get_tables.sort
+    end
+  end
+end

data/lib/polars/string_expr.rb

@@ -82,9 +82,13 @@ module Polars
       time_zone: nil,
       strict: true,
       exact: true,
-      cache: true
+      cache: true,
+      use_earliest: nil,
+      ambiguous: "raise"
     )
       _validate_format_argument(format)
+      ambiguous = Utils.rename_use_earliest_to_ambiguous(use_earliest, ambiguous)
+      ambiguous = Polars.lit(ambiguous) unless ambiguous.is_a?(Expr)
       Utils.wrap_expr(
         self._rbexpr.str_to_datetime(
           format,
@@ -92,7 +96,8 @@ module Polars
           time_zone,
           strict,
           exact,
-          cache
+          cache,
+          ambiguous._rbexpr
         )
       )
     end
@@ -235,7 +240,7 @@ module Polars
     #   # │ 東京 ┆ 6      ┆ 2      │
     #   # └──────┴────────┴────────┘
     def lengths
-      Utils.wrap_expr(_rbexpr.str_lengths)
+      Utils.wrap_expr(_rbexpr.str_len_bytes)
     end
 
     # Get length of the strings as `:u32` (as number of chars).
@@ -267,13 +272,15 @@ module Polars
     #   # │ 東京 ┆ 6      ┆ 2      │
     #   # └──────┴────────┴────────┘
     def n_chars
-      Utils.wrap_expr(_rbexpr.str_n_chars)
+      Utils.wrap_expr(_rbexpr.str_len_chars)
     end
 
     # Vertically concat the values in the Series to a single string value.
     #
     # @param delimiter [String]
     #   The delimiter to insert between consecutive string values.
+    # @param ignore_nulls [Boolean]
+    #   Ignore null values (default).
     #
     # @return [Expr]
     #
@@ -282,15 +289,28 @@ module Polars
     #   df.select(Polars.col("foo").str.concat("-"))
     #   # =>
     #   # shape: (1, 1)
-    #   # ┌──────────┐
-    #   # │ foo      │
-    #   # │ ---      │
-    #   # │ str      │
-    #   # ╞══════════╡
-    #   # │ 1-null-2 │
-    #   # └──────────┘
-    def concat(delimiter = "-")
-      Utils.wrap_expr(_rbexpr.str_concat(delimiter))
+    #   # ┌─────┐
+    #   # │ foo │
+    #   # │ --- │
+    #   # │ str │
+    #   # ╞═════╡
+    #   # │ 1-2 │
+    #   # └─────┘
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"foo" => [1, nil, 2]})
+    #   df.select(Polars.col("foo").str.concat("-", ignore_nulls: false))
+    #   # =>
+    #   # shape: (1, 1)
+    #   # ┌──────┐
+    #   # │ foo  │
+    #   # │ ---  │
+    #   # │ str  │
+    #   # ╞══════╡
+    #   # │ null │
+    #   # └──────┘
+    def concat(delimiter = "-", ignore_nulls: true)
+      Utils.wrap_expr(_rbexpr.str_concat(delimiter, ignore_nulls))
     end
 
     # Transform to uppercase variant.
@@ -337,7 +357,7 @@ module Polars
 
     # Remove leading and trailing whitespace.
     #
-    # @param matches [String, nil]
+    # @param characters [String, nil]
     #   An optional single character that should be trimmed.
     #
     # @return [Expr]
@@ -356,16 +376,15 @@ module Polars
     #   # │ trail │
     #   # │ both  │
     #   # └───────┘
-    def strip(matches = nil)
-      if !matches.nil? && matches.length > 1
-        raise ArgumentError, "matches should contain a single character"
-      end
-      Utils.wrap_expr(_rbexpr.str_strip(matches))
+    def strip_chars(characters = nil)
+      characters = Utils.parse_as_expression(characters, str_as_lit: true)
+      Utils.wrap_expr(_rbexpr.str_strip_chars(characters))
     end
+    alias_method :strip, :strip_chars
 
     # Remove leading whitespace.
     #
-    # @param matches [String, nil]
+    # @param characters [String, nil]
     #   An optional single character that should be trimmed.
     #
     # @return [Expr]
@@ -384,16 +403,15 @@ module Polars
     #   # │ trail  │
     #   # │ both   │
     #   # └────────┘
-    def lstrip(matches = nil)
-      if !matches.nil? && matches.length > 1
-        raise ArgumentError, "matches should contain a single character"
-      end
-      Utils.wrap_expr(_rbexpr.str_lstrip(matches))
+    def strip_chars_start(characters = nil)
+      characters = Utils.parse_as_expression(characters, str_as_lit: true)
+      Utils.wrap_expr(_rbexpr.str_strip_chars_start(characters))
     end
+    alias_method :lstrip, :strip_chars_start
 
     # Remove trailing whitespace.
     #
-    # @param matches [String, nil]
+    # @param characters [String, nil]
     #   An optional single character that should be trimmed.
     #
     # @return [Expr]
@@ -412,12 +430,11 @@ module Polars
     #   # │ trail │
     #   # │  both │
     #   # └───────┘
-    def rstrip(matches = nil)
-      if !matches.nil? && matches.length > 1
-        raise ArgumentError, "matches should contain a single character"
-      end
-      Utils.wrap_expr(_rbexpr.str_rstrip(matches))
+    def strip_chars_end(characters = nil)
+      characters = Utils.parse_as_expression(characters, str_as_lit: true)
+      Utils.wrap_expr(_rbexpr.str_strip_chars_end(characters))
     end
+    alias_method :rstrip, :strip_chars_end
 
     # Fills the string with zeroes.
     #
@@ -461,13 +478,13 @@ module Polars
       Utils.wrap_expr(_rbexpr.str_zfill(alignment))
     end
 
-    # Return the string left justified in a string of length `width`.
+    # Return the string left justified in a string of length `length`.
     #
     # Padding is done using the specified `fillchar`.
-    # The original string is returned if `width` is less than or equal to
+    # The original string is returned if `length` is less than or equal to
     # `s.length`.
     #
-    # @param width [Integer]
+    # @param length [Integer]
     #   Justify left to this length.
     # @param fillchar [String]
     #   Fill with this ASCII character.
@@ -489,17 +506,18 @@ module Polars
     #   # │ null         │
     #   # │ hippopotamus │
     #   # └──────────────┘
-    def ljust(width, fillchar = " ")
-      Utils.wrap_expr(_rbexpr.str_ljust(width, fillchar))
+    def ljust(length, fillchar = " ")
+      Utils.wrap_expr(_rbexpr.str_pad_end(length, fillchar))
     end
+    alias_method :pad_end, :ljust
 
-    # Return the string right justified in a string of length `width`.
+    # Return the string right justified in a string of length `length`.
     #
     # Padding is done using the specified `fillchar`.
-    # The original string is returned if `width` is less than or equal to
+    # The original string is returned if `length` is less than or equal to
     # `s.length`.
     #
-    # @param width [Integer]
+    # @param length [Integer]
     #   Justify right to this length.
     # @param fillchar [String]
     #   Fill with this ASCII character.
@@ -521,9 +539,10 @@ module Polars
     #   # │ null         │
     #   # │ hippopotamus │
     #   # └──────────────┘
-    def rjust(width, fillchar = " ")
-      Utils.wrap_expr(_rbexpr.str_rjust(width, fillchar))
+    def rjust(length, fillchar = " ")
+      Utils.wrap_expr(_rbexpr.str_pad_start(length, fillchar))
     end
+    alias_method :pad_start, :rjust
 
     # Check if string contains a substring that matches a regex.
     #
@@ -864,9 +883,11 @@ module Polars
     #   # │ 5            │
     #   # │ 6            │
     #   # └──────────────┘
-    def count_match(pattern)
-      Utils.wrap_expr(_rbexpr.count_match(pattern))
+    def count_matches(pattern, literal: false)
+      pattern = Utils.parse_as_expression(pattern, str_as_lit: true)
+      Utils.wrap_expr(_rbexpr.str_count_matches(pattern, literal))
     end
+    alias_method :count_match, :count_matches
 
     # Split the string by a substring.
     #
@@ -892,6 +913,7 @@ module Polars
     #   # │ ["foo", "bar", "baz"] │
     #   # └───────────────────────┘
     def split(by, inclusive: false)
+      by = Utils.parse_as_expression(by, str_as_lit: true)
       if inclusive
         Utils.wrap_expr(_rbexpr.str_split_inclusive(by))
       else
@@ -934,6 +956,7 @@ module Polars
     #   # │ {"d","4"}   │
     #   # └─────────────┘
     def split_exact(by, n, inclusive: false)
+      by = Utils.parse_as_expression(by, str_as_lit: true)
       if inclusive
         Utils.wrap_expr(_rbexpr.str_split_exact_inclusive(by, n))
       else
@@ -970,6 +993,7 @@ module Polars
     #   # │ {"foo","bar baz"} │
     #   # └───────────────────┘
     def splitn(by, n)
+      by = Utils.parse_as_expression(by, str_as_lit: true)
       Utils.wrap_expr(_rbexpr.str_splitn(by, n))
     end
 
@@ -1091,6 +1115,52 @@ module Polars
       Utils.wrap_expr(_rbexpr.str_explode)
     end
 
+    # Convert an Utf8 column into an Int64 column with base radix.
+    #
+    # @param base [Integer]
+    #   Positive integer which is the base of the string we are parsing.
+    #   Default: 10.
+    # @param strict [Boolean]
+    #   Bool, default=true will raise any ParseError or overflow as ComputeError.
+    #   false silently convert to Null.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"bin" => ["110", "101", "010", "invalid"]})
+    #   df.with_columns(Polars.col("bin").str.to_integer(base: 2, strict: false).alias("parsed"))
+    #   # =>
+    #   # shape: (4, 2)
+    #   # ┌─────────┬────────┐
+    #   # │ bin     ┆ parsed │
+    #   # │ ---     ┆ ---    │
+    #   # │ str     ┆ i64    │
+    #   # ╞═════════╪════════╡
+    #   # │ 110     ┆ 6      │
+    #   # │ 101     ┆ 5      │
+    #   # │ 010     ┆ 2      │
+    #   # │ invalid ┆ null   │
+    #   # └─────────┴────────┘
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"hex" => ["fa1e", "ff00", "cafe", nil]})
+    #   df.with_columns(Polars.col("hex").str.to_integer(base: 16, strict: true).alias("parsed"))
+    #   # =>
+    #   # shape: (4, 2)
+    #   # ┌──────┬────────┐
+    #   # │ hex  ┆ parsed │
+    #   # │ ---  ┆ ---    │
+    #   # │ str  ┆ i64    │
+    #   # ╞══════╪════════╡
+    #   # │ fa1e ┆ 64030  │
+    #   # │ ff00 ┆ 65280  │
+    #   # │ cafe ┆ 51966  │
+    #   # │ null ┆ null   │
+    #   # └──────┴────────┘
+    def to_integer(base: 10, strict: true)
+      Utils.wrap_expr(_rbexpr.str_to_integer(base, strict))
+    end
+
     # Parse integers with base radix from strings.
     #
     # By default base 2. ParseError/Overflows become Nulls.
@@ -1119,24 +1189,8 @@ module Polars
     #   # │ 2    │
     #   # │ null │
     #   # └──────┘
-    #
-    # @example
-    #   df = Polars::DataFrame.new({"hex" => ["fa1e", "ff00", "cafe", nil]})
-    #   df.select(Polars.col("hex").str.parse_int(16, strict: true))
-    #   # =>
-    #   # shape: (4, 1)
-    #   # ┌───────┐
-    #   # │ hex   │
-    #   # │ ---   │
-    #   # │ i32   │
-    #   # ╞═══════╡
-    #   # │ 64030 │
-    #   # │ 65280 │
-    #   # │ 51966 │
-    #   # │ null  │
-    #   # └───────┘
     def parse_int(radix = 2, strict: true)
-      Utils.wrap_expr(_rbexpr.str_parse_int(radix, strict))
+      to_integer(base: 2, strict: strict).cast(Int32, strict: strict)
     end
 
     private

data/lib/polars/string_name_space.rb

@@ -82,7 +82,8 @@ module Polars
       time_zone: nil,
       strict: true,
       exact: true,
-      cache: true
+      cache: true,
+      use_earliest: nil
     )
       super
     end
@@ -232,9 +233,23 @@ module Polars
     # @return [Series]
     #
     # @example
-    #   Polars::Series.new([1, nil, 2]).str.concat("-")[0]
-    #   # => "1-null-2"
-    def concat(delimiter = "-")
+    #   Polars::Series.new([1, nil, 2]).str.concat("-")
+    #   # =>
+    #   # shape: (1,)
+    #   # Series: '' [str]
+    #   # [
+    #   #         "1-2"
+    #   # ]
+    #
+    # @example
+    #   Polars::Series.new([1, nil, 2]).str.concat("-", ignore_nulls: false)
+    #   # =>
+    #   # shape: (1,)
+    #   # Series: '' [str]
+    #   # [
+    #   #         null
+    #   # ]
+    def concat(delimiter = "-", ignore_nulls: true)
       super
     end
 

data/lib/polars/struct_expr.rb

@@ -13,7 +13,7 @@ module Polars
     #
     # @return [Expr]
     def [](item)
-      if item.is_a?(String)
+      if item.is_a?(::String)
         field(item)
       elsif item.is_a?(Integer)
         Utils.wrap_expr(_rbexpr.struct_field_by_index(item))

data/lib/polars/struct_name_space.rb

@@ -16,7 +16,7 @@ module Polars
     def [](item)
       if item.is_a?(Integer)
         field(fields[item])
-      elsif item.is_a?(String)
+      elsif item.is_a?(::String)
         field(item)
       else
         raise ArgumentError, "expected type Integer or String, got #{item.class.name}"

data/lib/polars/utils.rb

@@ -27,7 +27,7 @@ module Polars
       if obj.is_a?(Range)
         # size only works for numeric ranges
         obj.to_a.length
-      elsif obj.is_a?(String)
+      elsif obj.is_a?(::String)
         nil
       else
         obj.length
@@ -116,7 +116,7 @@ module Polars
     end
 
     def self.selection_to_rbexpr_list(exprs)
-      if exprs.is_a?(String) || exprs.is_a?(Symbol) || exprs.is_a?(Expr) || exprs.is_a?(Series)
+      if exprs.is_a?(::String) || exprs.is_a?(Symbol) || exprs.is_a?(Expr) || exprs.is_a?(Series)
         exprs = [exprs]
       end
 
@@ -124,9 +124,9 @@ module Polars
     end
 
     def self.expr_to_lit_or_expr(expr, str_to_lit: true)
-      if (expr.is_a?(String) || expr.is_a?(Symbol)) && !str_to_lit
+      if (expr.is_a?(::String) || expr.is_a?(Symbol)) && !str_to_lit
         col(expr)
-      elsif expr.is_a?(Integer) || expr.is_a?(Float) || expr.is_a?(String) || expr.is_a?(Symbol) || expr.is_a?(Series) || expr.nil?
+      elsif expr.is_a?(Integer) || expr.is_a?(Float) || expr.is_a?(::String) || expr.is_a?(Symbol) || expr.is_a?(Series) || expr.nil?
         lit(expr)
       elsif expr.is_a?(Expr)
         expr
@@ -152,7 +152,7 @@ module Polars
       if data_type == Unknown
         return include_unknown
       end
-      data_type.is_a?(Symbol) || data_type.is_a?(String) || data_type.is_a?(DataType) || (data_type.is_a?(Class) && data_type < DataType)
+      data_type.is_a?(Symbol) || data_type.is_a?(::String) || data_type.is_a?(DataType) || (data_type.is_a?(Class) && data_type < DataType)
     end
 
     def self.map_rb_type_to_dtype(ruby_dtype)
@@ -160,7 +160,7 @@ module Polars
         Float64
       elsif ruby_dtype == Integer
         Int64
-      elsif ruby_dtype == String
+      elsif ruby_dtype == ::String
         Utf8
       elsif ruby_dtype == TrueClass || ruby_dtype == FalseClass
         Boolean
@@ -211,7 +211,7 @@ module Polars
       projection = nil
       if columns
         raise Todo
-        # if columns.is_a?(String) || columns.is_a?(Symbol)
+        # if columns.is_a?(::String) || columns.is_a?(Symbol)
         #   columns = [columns]
         # elsif is_int_sequence(columns)
         #   projection = columns.to_a
@@ -243,11 +243,11 @@ module Polars
     end
 
     def self.strlike?(value)
-      value.is_a?(String) || value.is_a?(Symbol)
+      value.is_a?(::String) || value.is_a?(Symbol)
     end
 
     def self.pathlike?(value)
-      value.is_a?(String) || (defined?(Pathname) && value.is_a?(Pathname))
+      value.is_a?(::String) || (defined?(Pathname) && value.is_a?(Pathname))
     end
 
     def self._is_iterable_of(val, eltype)
@@ -275,10 +275,10 @@ module Polars
     end
 
     def self.is_str_sequence(val, allow_str: false)
-      if allow_str == false && val.is_a?(String)
+      if allow_str == false && val.is_a?(::String)
         false
       else
-        val.is_a?(::Array) && _is_iterable_of(val, String)
+        val.is_a?(::Array) && _is_iterable_of(val, ::String)
       end
     end
 
@@ -289,10 +289,10 @@ module Polars
     def self.parse_as_expression(input, str_as_lit: false, structify: false)
       if input.is_a?(Expr)
         expr = input
-      elsif input.is_a?(String) && !str_as_lit
+      elsif input.is_a?(::String) && !str_as_lit
         expr = Polars.col(input)
         structify = false
-      elsif [Integer, Float, String, Series, ::Date, ::Time, ::DateTime].any? { |cls| input.is_a?(cls) } || input.nil?
+      elsif [Integer, Float, ::String, Series, ::Date, ::Time, ::DateTime].any? { |cls| input.is_a?(cls) } || input.nil?
         expr = Polars.lit(input)
         structify = false
       elsif input.is_a?(Array)
@@ -308,5 +308,17 @@ module Polars
 
       expr._rbexpr
     end
+
+    USE_EARLIEST_TO_AMBIGUOUS = {
+      true => "earliest",
+      false => "latest"
+    }
+
+    def self.rename_use_earliest_to_ambiguous(use_earliest, ambiguous)
+      unless use_earliest.nil?
+        ambiguous = USE_EARLIEST_TO_AMBIGUOUS.fetch(use_earliest)
+      end
+      ambiguous
+    end
   end
 end

data/lib/polars/version.rb

@@ -1,4 +1,4 @@
 module Polars
   # @private
-  VERSION = "0.6.0"
+  VERSION = "0.8.0"
 end