polars-df 0.23.0 → 0.24.0

data/ext/polars/src/timeout.rs

@@ -0,0 +1,105 @@
+//! A global process-aborting timeout system, mainly intended for testing.
+
+use std::cmp::Reverse;
+use std::collections::BinaryHeap;
+use std::sync::LazyLock;
+use std::sync::mpsc::{Receiver, RecvTimeoutError, Sender, channel};
+use std::time::Duration;
+
+use polars::prelude::{InitHashMaps, PlHashSet};
+use polars_utils::priority::Priority;
+use polars_utils::relaxed_cell::RelaxedCell;
+
+static TIMEOUT_REQUEST_HANDLER: LazyLock<Sender<TimeoutRequest>> = LazyLock::new(|| {
+    let (send, recv) = channel();
+    std::thread::Builder::new()
+        .name("polars-timeout".to_string())
+        .spawn(move || timeout_thread(recv))
+        .unwrap();
+    send
+});
+
+enum TimeoutRequest {
+    Start(Duration, u64),
+    Cancel(u64),
+}
+
+pub fn get_timeout() -> Option<Duration> {
+    static TIMEOUT_DISABLED: RelaxedCell<bool> = RelaxedCell::new_bool(false);
+
+    // Fast path so we don't have to keep checking environment variables. Make
+    // sure that if you want to use POLARS_TIMEOUT_MS it is set before the first
+    // polars call.
+    if TIMEOUT_DISABLED.load() {
+        return None;
+    }
+
+    let Ok(timeout) = std::env::var("POLARS_TIMEOUT_MS") else {
+        TIMEOUT_DISABLED.store(true);
+        return None;
+    };
+
+    match timeout.parse() {
+        Ok(ms) => Some(Duration::from_millis(ms)),
+        Err(e) => {
+            eprintln!("failed to parse POLARS_TIMEOUT_MS: {e:?}");
+            None
+        }
+    }
+}
+
+fn timeout_thread(recv: Receiver<TimeoutRequest>) {
+    let mut active_timeouts: PlHashSet<u64> = PlHashSet::new();
+    let mut shortest_timeout: BinaryHeap<Priority<Reverse<Duration>, u64>> = BinaryHeap::new();
+    loop {
+        // Remove cancelled requests.
+        while let Some(Priority(_, id)) = shortest_timeout.peek() {
+            if active_timeouts.contains(id) {
+                break;
+            }
+            shortest_timeout.pop();
+        }
+
+        let request = if let Some(Priority(timeout, _)) = shortest_timeout.peek() {
+            match recv.recv_timeout(timeout.0) {
+                Err(RecvTimeoutError::Timeout) => {
+                    eprintln!("exiting the process, POLARS_TIMEOUT_MS exceeded");
+                    std::thread::sleep(Duration::from_secs_f64(1.0));
+                    std::process::exit(1);
+                }
+                r => r.unwrap(),
+            }
+        } else {
+            recv.recv().unwrap()
+        };
+
+        match request {
+            TimeoutRequest::Start(duration, id) => {
+                shortest_timeout.push(Priority(Reverse(duration), id));
+                active_timeouts.insert(id);
+            }
+            TimeoutRequest::Cancel(id) => {
+                active_timeouts.remove(&id);
+            }
+        }
+    }
+}
+
+pub fn schedule_polars_timeout() -> Option<u64> {
+    static TIMEOUT_ID: RelaxedCell<u64> = RelaxedCell::new_u64(0);
+
+    let timeout = get_timeout()?;
+    let id = TIMEOUT_ID.fetch_add(1);
+    TIMEOUT_REQUEST_HANDLER
+        .send(TimeoutRequest::Start(timeout, id))
+        .unwrap();
+    Some(id)
+}
+
+pub fn cancel_polars_timeout(opt_id: Option<u64>) {
+    if let Some(id) = opt_id {
+        TIMEOUT_REQUEST_HANDLER
+            .send(TimeoutRequest::Cancel(id))
+            .unwrap();
+    }
+}

data/ext/polars/src/utils.rs

@@ -1,4 +1,16 @@
-use crate::{RbErr, RbPolarsErr};
+use std::os::raw::c_void;
+use std::panic::AssertUnwindSafe;
+
+use magnus::Ruby;
+use polars::frame::DataFrame;
+use polars::series::IntoSeries;
+use polars_error::PolarsResult;
+use polars_error::signals::{KeyboardInterrupt, catch_keyboard_interrupt};
+use rb_sys::{rb_thread_call_with_gvl, rb_thread_call_without_gvl};
+
+use crate::exceptions::RbKeyboardInterrupt;
+use crate::timeout::{cancel_polars_timeout, schedule_polars_timeout};
+use crate::{RbDataFrame, RbErr, RbPolarsErr, RbResult, RbSeries};
 
 #[macro_export]
 macro_rules! apply_method_all_arrow_series2 {
@@ -10,14 +22,17 @@ macro_rules! apply_method_all_arrow_series2 {
             DataType::UInt16 => $self.u16().unwrap().$method($($args),*),
             DataType::UInt32 => $self.u32().unwrap().$method($($args),*),
             DataType::UInt64 => $self.u64().unwrap().$method($($args),*),
+            DataType::UInt128 => $self.u128().unwrap().$method($($args),*),
             DataType::Int8 => $self.i8().unwrap().$method($($args),*),
             DataType::Int16 => $self.i16().unwrap().$method($($args),*),
             DataType::Int32 => $self.i32().unwrap().$method($($args),*),
             DataType::Int64 => $self.i64().unwrap().$method($($args),*),
+            DataType::Int128 => $self.i128().unwrap().$method($($args),*),
             DataType::Float32 => $self.f32().unwrap().$method($($args),*),
             DataType::Float64 => $self.f64().unwrap().$method($($args),*),
             DataType::Date => $self.date().unwrap().physical().$method($($args),*),
             DataType::Datetime(_, _) => $self.datetime().unwrap().physical().$method($($args),*),
+            // TODO implement
             // DataType::List(_) => $self.list().unwrap().$method($($args),*),
             DataType::Struct(_) => $self.struct_().unwrap().$method($($args),*),
             dt => panic!("dtype {:?} not supported", dt)
@@ -30,3 +45,146 @@ macro_rules! apply_method_all_arrow_series2 {
 pub(crate) fn to_rb_err<E: Into<RbPolarsErr>>(e: E) -> RbErr {
     e.into().into()
 }
+
+pub trait EnterPolarsExt {
+    fn enter_polars<T, E, F>(self, f: F) -> RbResult<T>
+    where
+        F: FnOnce() -> Result<T, E>,
+        E: Into<RbPolarsErr>;
+
+    #[inline(always)]
+    fn enter_polars_ok<T, F>(self, f: F) -> RbResult<T>
+    where
+        Self: Sized,
+        F: FnOnce() -> T,
+    {
+        self.enter_polars(move || RbResult::Ok(f()))
+    }
+
+    #[inline(always)]
+    fn enter_polars_df<F>(self, f: F) -> RbResult<RbDataFrame>
+    where
+        Self: Sized,
+        F: FnOnce() -> PolarsResult<DataFrame>,
+    {
+        self.enter_polars(f).map(RbDataFrame::new)
+    }
+
+    #[inline(always)]
+    fn enter_polars_series<T, F>(self, f: F) -> RbResult<RbSeries>
+    where
+        Self: Sized,
+        T: IntoSeries,
+        F: FnOnce() -> PolarsResult<T>,
+    {
+        self.enter_polars(f).map(|s| RbSeries::new(s.into_series()))
+    }
+
+    fn detach<T, F>(self, f: F) -> T
+    where
+        Self: Sized,
+        F: FnOnce() -> T,
+    {
+        if std::env::var("POLARS_GVL").is_ok() {
+            f()
+        } else {
+            let mut data = CallbackData {
+                func: Some(f),
+                result: None,
+            };
+
+            unsafe {
+                rb_thread_call_without_gvl(
+                    Some(call_without_gvl::<F, T>),
+                    &mut data as *mut _ as *mut c_void,
+                    None,
+                    std::ptr::null_mut(),
+                );
+            }
+
+            data.result.unwrap()
+        }
+    }
+}
+
+impl EnterPolarsExt for &Ruby {
+    fn enter_polars<T, E, F>(self, f: F) -> RbResult<T>
+    where
+        F: FnOnce() -> Result<T, E>,
+        E: Into<RbPolarsErr>,
+    {
+        let timeout = schedule_polars_timeout();
+        let ret = self.detach(|| catch_keyboard_interrupt(AssertUnwindSafe(f)));
+        cancel_polars_timeout(timeout);
+        match ret {
+            Ok(Ok(ret)) => Ok(ret),
+            Ok(Err(err)) => Err(RbErr::from(err.into())),
+            Err(KeyboardInterrupt) => Err(RbKeyboardInterrupt::new_err("")),
+        }
+    }
+}
+
+pub trait RubyAttach {
+    fn attach<T, F>(f: F) -> T
+    where
+        F: FnOnce(&Ruby) -> T;
+}
+
+unsafe extern "C" {
+    fn ruby_thread_has_gvl_p() -> std::ffi::c_int;
+}
+
+impl RubyAttach for Ruby {
+    fn attach<T, F>(f: F) -> T
+    where
+        F: FnOnce(&Ruby) -> T,
+    {
+        // recheck GVL state since cached value can be incorrect
+        // https://github.com/matsadler/magnus/pull/161
+        if let Ok(rb) = Ruby::get()
+            && unsafe { ruby_thread_has_gvl_p() } != 0
+        {
+            f(&rb)
+        } else {
+            let mut data = CallbackData {
+                func: Some(f),
+                result: None,
+            };
+
+            unsafe {
+                rb_thread_call_with_gvl(
+                    Some(call_with_gvl::<F, T>),
+                    &mut data as *mut _ as *mut c_void,
+                );
+            }
+
+            data.result.unwrap()
+        }
+    }
+}
+
+struct CallbackData<F, T> {
+    func: Option<F>,
+    result: Option<T>,
+}
+
+extern "C" fn call_without_gvl<F, T>(data: *mut c_void) -> *mut c_void
+where
+    F: FnOnce() -> T,
+{
+    let data = unsafe { &mut *(data as *mut CallbackData<F, T>) };
+    let func = data.func.take().unwrap();
+    data.result = Some(func());
+    std::ptr::null_mut()
+}
+
+extern "C" fn call_with_gvl<F, T>(data: *mut c_void) -> *mut c_void
+where
+    F: FnOnce(&Ruby) -> T,
+{
+    let rb = Ruby::get().unwrap();
+    let data = unsafe { &mut *(data as *mut CallbackData<F, T>) };
+    let func = data.func.take().unwrap();
+    data.result = Some(func(&rb));
+    std::ptr::null_mut()
+}

data/lib/polars/array_expr.rb

@@ -191,7 +191,7 @@ module Polars
     # @example
     #   df = Polars::DataFrame.new(
     #     {"a" => [[1, 2], [4, 3]]},
-    #     schema: {"a" => Polars::Array.new(2, Polars::Int64)}
+    #     schema: {"a" => Polars::Array.new(Polars::Int64, 2)}
     #   )
     #   df.select(Polars.col("a").arr.min)
     #   # =>
@@ -215,7 +215,7 @@ module Polars
     # @example
     #   df = Polars::DataFrame.new(
     #     {"a" => [[1, 2], [4, 3]]},
-    #     schema: {"a" => Polars::Array.new(2, Polars::Int64)}
+    #     schema: {"a" => Polars::Array.new(Polars::Int64, 2)}
     #   )
     #   df.select(Polars.col("a").arr.max)
     #   # =>
@@ -239,7 +239,7 @@ module Polars
     # @example
     #   df = Polars::DataFrame.new(
     #     {"a" => [[1, 2], [4, 3]]},
-    #     schema: {"a" => Polars::Array.new(2, Polars::Int64)}
+    #     schema: {"a" => Polars::Array.new(Polars::Int64, 2)}
     #   )
     #   df.select(Polars.col("a").arr.sum)
     #   # =>
@@ -263,7 +263,7 @@ module Polars
     # @example
     #   df = Polars::DataFrame.new(
     #     {"a" => [[1, 2], [4, 3]]},
-    #     schema: {"a" => Polars::Array.new(2, Polars::Int64)}
+    #     schema: {"a" => Polars::Array.new(Polars::Int64, 2)}
     #   )
     #   df.select(Polars.col("a").arr.std)
     #   # =>
@@ -287,7 +287,7 @@ module Polars
     # @example
     #   df = Polars::DataFrame.new(
     #     {"a" => [[1, 2], [4, 3]]},
-    #     schema: {"a" => Polars::Array.new(2, Polars::Int64)}
+    #     schema: {"a" => Polars::Array.new(Polars::Int64, 2)}
     #   )
     #   df.select(Polars.col("a").arr.var)
     #   # =>
@@ -335,7 +335,7 @@ module Polars
     # @example
     #   df = Polars::DataFrame.new(
     #     {"a" => [[1, 2], [4, 3]]},
-    #     schema: {"a" => Polars::Array.new(2, Polars::Int64)}
+    #     schema: {"a" => Polars::Array.new(Polars::Int64, 2)}
     #   )
     #   df.select(Polars.col("a").arr.median)
     #   # =>
@@ -437,7 +437,7 @@ module Polars
     # @example
     #   df = Polars::DataFrame.new(
     #     {
-    #       "a": [
+    #       "a" => [
     #         [true, true],
     #         [false, true],
     #         [false, false],
@@ -472,7 +472,7 @@ module Polars
     # @example
     #   df = Polars::DataFrame.new(
     #     {
-    #       "a": [
+    #       "a" => [
     #         [true, true],
     #         [false, true],
     #         [false, false],
@@ -642,7 +642,7 @@ module Polars
     #     {"arr" => [[1, 2, 3], [4, 5, 6], [7, 8, 9]], "idx" => [1, -2, 4]},
     #     schema: {"arr" => Polars::Array.new(Polars::Int32, 3), "idx" => Polars::Int32}
     #   )
-    #   df.with_columns(get: Polars.col("arr").arr.get("idx"))
+    #   df.with_columns(get: Polars.col("arr").arr.get("idx", null_on_oob: true))
     #   # =>
     #   # shape: (3, 3)
     #   # ┌───────────────┬─────┬──────┐
@@ -654,7 +654,7 @@ module Polars
     #   # │ [4, 5, 6]     ┆ -2  ┆ 5    │
     #   # │ [7, 8, 9]     ┆ 4   ┆ null │
     #   # └───────────────┴─────┴──────┘
-    def get(index, null_on_oob: true)
+    def get(index, null_on_oob: false)
       index = Utils.parse_into_expression(index)
       Utils.wrap_expr(_rbexpr.arr_get(index, null_on_oob))
     end
@@ -681,7 +681,7 @@ module Polars
     #   # │ [7, 8, 9]     ┆ 7     │
     #   # └───────────────┴───────┘
     def first
-      get(0)
+      get(0, null_on_oob: true)
     end
 
     # Get the last value of the sub-arrays.
@@ -706,7 +706,7 @@ module Polars
     #   # │ [7, 8, 9]     ┆ 9    │
     #   # └───────────────┴──────┘
     def last
-      get(-1)
+      get(-1, null_on_oob: true)
     end
 
     # Join all string items in a sub-array and place a separator between them.
@@ -914,5 +914,74 @@ module Polars
       n = Utils.parse_into_expression(n)
       Utils.wrap_expr(_rbexpr.arr_shift(n))
     end
+
+    # Run any polars expression against the arrays' elements.
+    #
+    # @param expr [Expr]
+    #   Expression to run. Note that you can select an element with `Polars.element`
+    # @param as_list [Boolean]
+    #   Collect the resulting data as a list. This allows for expressions which
+    #   output a variable amount of data.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [1, 8, 3], "b" => [4, 5, 2]})
+    #   df.with_columns(rank: Polars.concat_arr("a", "b").arr.eval(Polars.element.rank))
+    #   # =>
+    #   # shape: (3, 3)
+    #   # ┌─────┬─────┬───────────────┐
+    #   # │ a   ┆ b   ┆ rank          │
+    #   # │ --- ┆ --- ┆ ---           │
+    #   # │ i64 ┆ i64 ┆ array[f64, 2] │
+    #   # ╞═════╪═════╪═══════════════╡
+    #   # │ 1   ┆ 4   ┆ [1.0, 2.0]    │
+    #   # │ 8   ┆ 5   ┆ [2.0, 1.0]    │
+    #   # │ 3   ┆ 2   ┆ [2.0, 1.0]    │
+    #   # └─────┴─────┴───────────────┘
+    def eval(expr, as_list: false)
+      Utils.wrap_expr(_rbexpr.arr_eval(expr._rbexpr, as_list))
+    end
+
+    # Run any polars aggregation expression against the arrays' elements.
+    #
+    # @param expr [Expr]
+    #   Expression to run. Note that you can select an element with `Polars.element`.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::Series.new(
+    #     "a", [[1, nil], [42, 13], [nil, nil]], dtype: Polars::Array.new(Polars::Int64, 2)
+    #   ).to_frame
+    #   df.with_columns(null_count: Polars.col("a").arr.agg(Polars.element.null_count))
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌───────────────┬────────────┐
+    #   # │ a             ┆ null_count │
+    #   # │ ---           ┆ ---        │
+    #   # │ array[i64, 2] ┆ u32        │
+    #   # ╞═══════════════╪════════════╡
+    #   # │ [1, null]     ┆ 1          │
+    #   # │ [42, 13]      ┆ 0          │
+    #   # │ [null, null]  ┆ 2          │
+    #   # └───────────────┴────────────┘
+    #
+    # @example
+    #   df.with_columns(no_nulls: Polars.col("a").arr.agg(Polars.element.drop_nulls))
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌───────────────┬───────────┐
+    #   # │ a             ┆ no_nulls  │
+    #   # │ ---           ┆ ---       │
+    #   # │ array[i64, 2] ┆ list[i64] │
+    #   # ╞═══════════════╪═══════════╡
+    #   # │ [1, null]     ┆ [1]       │
+    #   # │ [42, 13]      ┆ [42, 13]  │
+    #   # │ [null, null]  ┆ []        │
+    #   # └───────────────┴───────────┘
+    def agg(expr)
+      Utils.wrap_expr(_rbexpr.arr_agg(expr._rbexpr))
+    end
   end
 end

data/lib/polars/array_name_space.rb

@@ -16,7 +16,7 @@ module Polars
     #
     # @example
     #   s = Polars::Series.new(
-    #     "a", [[1, 2], [4, 3]], dtype: Polars::Array.new(2, Polars::Int64)
+    #     "a", [[1, 2], [4, 3]], dtype: Polars::Array.new(Polars::Int64, 2)
     #   )
     #   s.arr.min
     #   # =>
@@ -36,7 +36,7 @@ module Polars
     #
     # @example
     #   s = Polars::Series.new(
-    #     "a", [[1, 2], [4, 3]], dtype: Polars::Array.new(2, Polars::Int64)
+    #     "a", [[1, 2], [4, 3]], dtype: Polars::Array.new(Polars::Int64, 2)
     #   )
     #   s.arr.max
     #   # =>
@@ -57,7 +57,7 @@ module Polars
     # @example
     #   df = Polars::DataFrame.new(
     #     {"a" => [[1, 2], [4, 3]]},
-    #     schema: {"a" => Polars::Array.new(2, Polars::Int64)}
+    #     schema: {"a" => Polars::Array.new(Polars::Int64, 2)}
     #   )
     #   df.select(Polars.col("a").arr.sum)
     #   # =>
@@ -477,6 +477,10 @@ module Polars
     #
     # @param index [Integer]
     #   Index to return per sublist
+    # @param null_on_oob [Boolean]
+    #   Behavior if an index is out of bounds:
+    #   true -> set as null
+    #   false -> raise an error
     #
     # @return [Series]
     #
@@ -484,7 +488,7 @@ module Polars
     #   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]))
+    #   s.arr.get(Polars::Series.new([1, -2, 4]), null_on_oob: true)
     #   # =>
     #   # shape: (3,)
     #   # Series: 'a' [i32]
@@ -493,7 +497,7 @@ module Polars
     #   #         5
     #   #         null
     #   # ]
-    def get(index)
+    def get(index, null_on_oob: false)
       super
     end
 
@@ -548,7 +552,7 @@ module Polars
     # @param ignore_nulls [Boolean]
     #   Ignore null values (default).
     #
-    #   If set to `False`, null values will be propagated.
+    #   If set to `false`, null values will be propagated.
     #   If the sub-list contains any null values, the output is `nil`.
     #
     # @return [Series]
@@ -593,6 +597,8 @@ module Polars
     #
     # @param item [Object]
     #   Item that will be checked for membership
+    # @param nulls_equal [Boolean]
+    #   If true, treat null as a distinct value. Null values will not propagate.
     #
     # @return [Series]
     #
@@ -609,7 +615,7 @@ module Polars
     #   #         true
     #   #         false
     #   # ]
-    def contains(item)
+    def contains(item, nulls_equal: true)
       super
     end
 
@@ -700,5 +706,66 @@ module Polars
     def shift(n = 1)
       super
     end
+
+    # Run any polars expression against the arrays' elements.
+    #
+    # @param expr [Expr]
+    #   Expression to run. Note that you can select an element with `pl.element()`
+    # @param as_list [Boolean]
+    #   Collect the resulting data as a list. This allows for expressions which
+    #   output a variable amount of data.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [[1, 4], [8, 5], [3, 2]], dtype: Polars::Array.new(Polars::Int64, 2))
+    #   s.arr.eval(Polars.element.rank)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [array[f64, 2]]
+    #   # [
+    #   #         [1.0, 2.0]
+    #   #         [2.0, 1.0]
+    #   #         [2.0, 1.0]
+    #   # ]
+    def eval(expr, as_list: false)
+      s = Utils.wrap_s(_s)
+      s.to_frame.select(F.col(s.name).arr.eval(expr, as_list: as_list)).to_series
+    end
+
+    # Run any polars aggregation expression against the arrays' elements.
+    #
+    # @param expr [Expr]
+    #   Expression to run. Note that you can select an element with `Polars.element`.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new(
+    #     "a", [[1, nil], [42, 13], [nil, nil]], dtype: Polars::Array.new(Polars::Int64, 2)
+    #   )
+    #   s.arr.agg(Polars.element.null_count)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [u32]
+    #   # [
+    #   #         1
+    #   #         0
+    #   #         2
+    #   # ]
+    #
+    # @example
+    #   s.arr.agg(Polars.element.drop_nulls)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [list[i64]]
+    #   # [
+    #   #         [1]
+    #   #         [42, 13]
+    #   #         []
+    #   # ]
+    def agg(expr)
+      super
+    end
   end
 end

data/lib/polars/batched_csv_reader.rb

@@ -4,18 +4,19 @@ module Polars
     attr_accessor :_reader, :new_columns
 
     def initialize(
-      file,
+      source,
       has_header: true,
       columns: nil,
-      sep: ",",
-      comment_char: nil,
+      separator: ",",
+      comment_prefix: nil,
       quote_char: '"',
       skip_rows: 0,
-      dtypes: nil,
+      skip_lines: 0,
+      schema_overrides: nil,
       null_values: nil,
       missing_utf8_is_empty_string: false,
       ignore_errors: false,
-      parse_dates: false,
+      try_parse_dates: false,
       n_threads: nil,
       infer_schema_length: 100,
       batch_size: 50_000,
@@ -24,30 +25,28 @@ module Polars
       low_memory: false,
       rechunk: true,
       skip_rows_after_header: 0,
-      row_count_name: nil,
-      row_count_offset: 0,
+      row_index_name: nil,
+      row_index_offset: 0,
       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
+      path = Utils.normalize_filepath(source)
 
       dtype_list = nil
       dtype_slice = nil
-      if !dtypes.nil?
-        if dtypes.is_a?(Hash)
+      if !schema_overrides.nil?
+        if schema_overrides.is_a?(Hash)
           dtype_list = []
-          dtypes.each do |k, v|
-            dtype_list << [k, Utils.rb_type_to_dtype(v)]
+          schema_overrides.each do |k, v|
+            dtype_list << [k, Utils.parse_into_dtype(v)]
           end
-        elsif dtypes.is_a?(::Array)
-          dtype_slice = dtypes
+        elsif schema_overrides.is_a?(::Array)
+          dtype_slice = schema_overrides
         else
-          raise ArgumentError, "dtype arg should be list or dict"
+          raise TypeError, "dtype arg should be array or hash"
         end
       end
 
@@ -61,8 +60,9 @@ module Polars
         ignore_errors,
         n_rows,
         skip_rows,
+        skip_lines,
         projection,
-        sep,
+        separator,
         rechunk,
         columns,
         encoding,
@@ -71,13 +71,13 @@ module Polars
         dtype_list,
         dtype_slice,
         low_memory,
-        comment_char,
+        comment_prefix,
         quote_char,
         processed_null_values,
         missing_utf8_is_empty_string,
-        parse_dates,
+        try_parse_dates,
         skip_rows_after_header,
-        Utils.parse_row_index_args(row_count_name, row_count_offset),
+        Utils.parse_row_index_args(row_index_name, row_index_offset),
         eol_char,
         raise_if_empty,
         truncate_ragged_lines,