polars-df 0.2.5 → 0.3.1

data/ext/polars/src/lib.rs

@@ -6,6 +6,7 @@ mod error;
 mod file;
 mod lazy;
 mod list_construction;
+mod numo;
 mod object;
 mod prelude;
 pub(crate) mod rb_modules;
@@ -21,7 +22,7 @@ use file::get_file_like;
 use lazy::dataframe::{RbLazyFrame, RbLazyGroupBy};
 use lazy::dsl::{RbExpr, RbWhen, RbWhenThen};
 use lazy::utils::rb_exprs_to_exprs;
-use magnus::{define_module, function, method, prelude::*, Error, RArray, RHash, Value};
+use magnus::{define_module, function, method, prelude::*, Error, IntoValue, RArray, RHash, Value};
 use polars::datatypes::{DataType, TimeUnit, IDX_DTYPE};
 use polars::error::PolarsResult;
 use polars::frame::DataFrame;
@@ -87,6 +88,7 @@ fn init() -> RbResult<()> {
     class.define_method("write_ipc", method!(RbDataFrame::write_ipc, 2))?;
     class.define_method("row_tuple", method!(RbDataFrame::row_tuple, 1))?;
     class.define_method("row_tuples", method!(RbDataFrame::row_tuples, 0))?;
+    class.define_method("to_numo", method!(RbDataFrame::to_numo, 0))?;
     class.define_method("write_parquet", method!(RbDataFrame::write_parquet, 5))?;
     class.define_method("add", method!(RbDataFrame::add, 1))?;
     class.define_method("sub", method!(RbDataFrame::sub, 1))?;
@@ -146,7 +148,7 @@ fn init() -> RbResult<()> {
     class.define_method("with_row_count", method!(RbDataFrame::with_row_count, 2))?;
     class.define_method("_clone", method!(RbDataFrame::clone, 0))?;
     class.define_method("melt", method!(RbDataFrame::melt, 4))?;
-    class.define_method("pivot_expr", method!(RbDataFrame::pivot_expr, 6))?;
+    class.define_method("pivot_expr", method!(RbDataFrame::pivot_expr, 7))?;
     class.define_method("partition_by", method!(RbDataFrame::partition_by, 2))?;
     class.define_method("shift", method!(RbDataFrame::shift, 1))?;
     class.define_method("unique", method!(RbDataFrame::unique, 3))?;
@@ -163,7 +165,7 @@ fn init() -> RbResult<()> {
     class.define_method("hmin", method!(RbDataFrame::hmin, 0))?;
     class.define_method("hsum", method!(RbDataFrame::hsum, 1))?;
     class.define_method("quantile", method!(RbDataFrame::quantile, 2))?;
-    class.define_method("to_dummies", method!(RbDataFrame::to_dummies, 1))?;
+    class.define_method("to_dummies", method!(RbDataFrame::to_dummies, 2))?;
     class.define_method("null_count", method!(RbDataFrame::null_count, 0))?;
     class.define_method("apply", method!(RbDataFrame::apply, 3))?;
     class.define_method("shrink_to_fit", method!(RbDataFrame::shrink_to_fit, 0))?;
@@ -221,7 +223,7 @@ fn init() -> RbResult<()> {
     class.define_method("top_k", method!(RbExpr::top_k, 2))?;
     class.define_method("arg_max", method!(RbExpr::arg_max, 0))?;
     class.define_method("arg_min", method!(RbExpr::arg_min, 0))?;
-    class.define_method("search_sorted", method!(RbExpr::search_sorted, 1))?;
+    class.define_method("search_sorted", method!(RbExpr::search_sorted, 2))?;
     class.define_method("take", method!(RbExpr::take, 1))?;
     class.define_method("sort_by", method!(RbExpr::sort_by, 2))?;
     class.define_method("backward_fill", method!(RbExpr::backward_fill, 1))?;
@@ -284,7 +286,7 @@ fn init() -> RbResult<()> {
     class.define_method("product", method!(RbExpr::product, 0))?;
     class.define_method("shrink_dtype", method!(RbExpr::shrink_dtype, 0))?;
     class.define_method("str_parse_date", method!(RbExpr::str_parse_date, 4))?;
-    class.define_method("str_parse_datetime", method!(RbExpr::str_parse_datetime, 5))?;
+    class.define_method("str_parse_datetime", method!(RbExpr::str_parse_datetime, 6))?;
     class.define_method("str_parse_time", method!(RbExpr::str_parse_time, 4))?;
     class.define_method("str_strip", method!(RbExpr::str_strip, 1))?;
     class.define_method("str_rstrip", method!(RbExpr::str_rstrip, 1))?;
@@ -299,7 +301,7 @@ fn init() -> RbResult<()> {
     class.define_method("str_zfill", method!(RbExpr::str_zfill, 1))?;
     class.define_method("str_ljust", method!(RbExpr::str_ljust, 2))?;
     class.define_method("str_rjust", method!(RbExpr::str_rjust, 2))?;
-    class.define_method("str_contains", method!(RbExpr::str_contains, 2))?;
+    class.define_method("str_contains", method!(RbExpr::str_contains, 3))?;
     class.define_method("str_ends_with", method!(RbExpr::str_ends_with, 1))?;
     class.define_method("str_starts_with", method!(RbExpr::str_starts_with, 1))?;
     class.define_method("str_hex_encode", method!(RbExpr::str_hex_encode, 0))?;
@@ -361,9 +363,15 @@ fn init() -> RbResult<()> {
     class.define_method("dt_offset_by", method!(RbExpr::dt_offset_by, 1))?;
     class.define_method("dt_epoch_seconds", method!(RbExpr::dt_epoch_seconds, 0))?;
     class.define_method("dt_with_time_unit", method!(RbExpr::dt_with_time_unit, 1))?;
-    class.define_method("dt_with_time_zone", method!(RbExpr::dt_with_time_zone, 1))?;
+    class.define_method(
+        "dt_convert_time_zone",
+        method!(RbExpr::dt_convert_time_zone, 1),
+    )?;
     class.define_method("dt_cast_time_unit", method!(RbExpr::dt_cast_time_unit, 1))?;
-    class.define_method("dt_cast_time_zone", method!(RbExpr::dt_cast_time_zone, 1))?;
+    class.define_method(
+        "dt_replace_time_zone",
+        method!(RbExpr::dt_replace_time_zone, 1),
+    )?;
     class.define_method("dt_tz_localize", method!(RbExpr::dt_tz_localize, 1))?;
     class.define_method("dt_truncate", method!(RbExpr::dt_truncate, 2))?;
     class.define_method("dt_round", method!(RbExpr::dt_round, 2))?;
@@ -418,9 +426,9 @@ fn init() -> RbResult<()> {
     class.define_method("shuffle", method!(RbExpr::shuffle, 1))?;
     class.define_method("sample_n", method!(RbExpr::sample_n, 4))?;
     class.define_method("sample_frac", method!(RbExpr::sample_frac, 4))?;
-    class.define_method("ewm_mean", method!(RbExpr::ewm_mean, 3))?;
-    class.define_method("ewm_std", method!(RbExpr::ewm_std, 4))?;
-    class.define_method("ewm_var", method!(RbExpr::ewm_var, 4))?;
+    class.define_method("ewm_mean", method!(RbExpr::ewm_mean, 4))?;
+    class.define_method("ewm_std", method!(RbExpr::ewm_std, 5))?;
+    class.define_method("ewm_var", method!(RbExpr::ewm_var, 5))?;
     class.define_method("extend_constant", method!(RbExpr::extend_constant, 2))?;
     class.define_method("any", method!(RbExpr::any, 0))?;
     class.define_method("all", method!(RbExpr::all, 0))?;
@@ -613,7 +621,7 @@ fn init() -> RbResult<()> {
     class.define_method("_clone", method!(RbSeries::clone, 0))?;
     class.define_method("apply_lambda", method!(RbSeries::apply_lambda, 3))?;
     class.define_method("zip_with", method!(RbSeries::zip_with, 2))?;
-    class.define_method("to_dummies", method!(RbSeries::to_dummies, 0))?;
+    class.define_method("to_dummies", method!(RbSeries::to_dummies, 1))?;
     class.define_method("peak_max", method!(RbSeries::peak_max, 0))?;
     class.define_method("peak_min", method!(RbSeries::peak_min, 0))?;
     class.define_method("n_unique", method!(RbSeries::n_unique, 0))?;
@@ -777,6 +785,9 @@ fn init() -> RbResult<()> {
     class.define_method("lt_eq_f64", method!(RbSeries::lt_eq_f64, 1))?;
     // class.define_method("lt_eq_str", method!(RbSeries::lt_eq_str, 1))?;
 
+    // npy
+    class.define_method("to_numo", method!(RbSeries::to_numo, 0))?;
+
     let class = module.define_class("RbWhen", Default::default())?;
     class.define_method("_then", method!(RbWhen::then, 1))?;
 
@@ -922,23 +933,16 @@ fn parquet_schema(rb_f: Value) -> RbResult<Value> {
     Ok(dict.into())
 }
 
-fn collect_all(lfs: RArray) -> RbResult<Vec<RbDataFrame>> {
-    use polars_core::utils::rayon::prelude::*;
-
+fn collect_all(lfs: RArray) -> RbResult<RArray> {
     let lfs = lfs
         .each()
         .map(|v| v?.try_convert::<&RbLazyFrame>())
         .collect::<RbResult<Vec<&RbLazyFrame>>>()?;
 
-    polars_core::POOL.install(|| {
-        lfs.par_iter()
-            .map(|lf| {
-                let df = lf.ldf.clone().collect()?;
-                Ok(RbDataFrame::new(df))
-            })
-            .collect::<polars_core::error::PolarsResult<Vec<_>>>()
-            .map_err(RbPolarsErr::from)
-    })
+    Ok(RArray::from_iter(lfs.iter().map(|lf| {
+        let df = lf.ldf.clone().collect().unwrap();
+        RbDataFrame::new(df)
+    })))
 }
 
 fn rb_date_range(
@@ -949,8 +953,8 @@ fn rb_date_range(
     name: String,
     tu: Wrap<TimeUnit>,
     tz: Option<TimeZone>,
-) -> RbSeries {
-    polars::time::date_range_impl(
+) -> RbResult<RbSeries> {
+    let date_range = polars::time::date_range_impl(
         &name,
         start,
         stop,
@@ -959,8 +963,8 @@ fn rb_date_range(
         tu.0,
         tz.as_ref(),
     )
-    .into_series()
-    .into()
+    .map_err(RbPolarsErr::from)?;
+    Ok(date_range.into_series().into())
 }
 
 fn coalesce_exprs(exprs: RArray) -> RbResult<RbExpr> {
@@ -983,5 +987,5 @@ fn arg_where(condition: &RbExpr) -> RbExpr {
 }
 
 fn get_idx_type() -> Value {
-    Wrap(IDX_DTYPE).into()
+    Wrap(IDX_DTYPE).into_value()
 }

data/ext/polars/src/numo.rs

@@ -0,0 +1,57 @@
+use magnus::{class, Module, RArray, RClass, RModule, Value};
+use polars_core::prelude::*;
+
+use crate::{raise_err, RbPolarsErr, RbResult, RbSeries};
+
+impl RbSeries {
+    /// For numeric types, this should only be called for Series with null types.
+    /// This will cast to floats so that `nil = NAN`
+    pub fn to_numo(&self) -> RbResult<Value> {
+        let s = &self.series.borrow();
+        match s.dtype() {
+            DataType::Utf8 => {
+                let ca = s.utf8().unwrap();
+
+                // TODO make more efficient
+                let np_arr = RArray::from_iter(ca.into_iter());
+                class::object()
+                    .const_get::<_, RModule>("Numo")?
+                    .const_get::<_, RClass>("RObject")?
+                    .funcall("cast", (np_arr,))
+            }
+            dt if dt.is_numeric() => {
+                if s.bit_repr_is_large() {
+                    let s = s.cast(&DataType::Float64).unwrap();
+                    let ca = s.f64().unwrap();
+                    // TODO make more efficient
+                    let np_arr = RArray::from_iter(ca.into_iter().map(|opt_v| match opt_v {
+                        Some(v) => v,
+                        None => f64::NAN,
+                    }));
+                    class::object()
+                        .const_get::<_, RModule>("Numo")?
+                        .const_get::<_, RClass>("DFloat")?
+                        .funcall("cast", (np_arr,))
+                } else {
+                    let s = s.cast(&DataType::Float32).unwrap();
+                    let ca = s.f32().unwrap();
+                    // TODO make more efficient
+                    let np_arr = RArray::from_iter(ca.into_iter().map(|opt_v| match opt_v {
+                        Some(v) => v,
+                        None => f32::NAN,
+                    }));
+                    class::object()
+                        .const_get::<_, RModule>("Numo")?
+                        .const_get::<_, RClass>("SFloat")?
+                        .funcall("cast", (np_arr,))
+                }
+            }
+            dt => {
+                raise_err!(
+                    format!("'to_numo' not supported for dtype: {dt:?}"),
+                    ComputeError
+                );
+            }
+        }
+    }
+}

data/ext/polars/src/object.rs

@@ -1,6 +1,7 @@
 use std::any::Any;
 use std::sync::Arc;
 
+use magnus::IntoValue;
 use polars_core::chunked_array::object::builder::ObjectChunkedBuilder;
 use polars_core::chunked_array::object::registry;
 use polars_core::chunked_array::object::registry::AnonymousObjectBuilder;
@@ -20,7 +21,7 @@ pub(crate) fn register_object_builder() {
 
         let object_converter = Arc::new(|av: AnyValue| {
             let object = ObjectValue {
-                inner: Wrap(av).into(),
+                inner: Wrap(av).into_value(),
             };
             Box::new(object) as Box<dyn Any>
         });

data/ext/polars/src/series.rs

@@ -1,5 +1,4 @@
-use magnus::exception::arg_error;
-use magnus::{Error, RArray, Value};
+use magnus::{exception, Error, IntoValue, RArray, Value};
 use polars::prelude::*;
 use polars::series::IsSorted;
 use std::cell::RefCell;
@@ -30,11 +29,11 @@ impl RbSeries {
     }
 
     pub fn is_sorted_flag(&self) -> bool {
-        matches!(self.series.borrow().is_sorted(), IsSorted::Ascending)
+        matches!(self.series.borrow().is_sorted_flag(), IsSorted::Ascending)
     }
 
     pub fn is_sorted_reverse_flag(&self) -> bool {
-        matches!(self.series.borrow().is_sorted(), IsSorted::Descending)
+        matches!(self.series.borrow().is_sorted_flag(), IsSorted::Descending)
     }
 
     pub fn new_opt_bool(name: String, obj: RArray, strict: bool) -> RbResult<RbSeries> {
@@ -173,7 +172,7 @@ impl RbSeries {
     }
 
     pub fn get_idx(&self, idx: usize) -> RbResult<Value> {
-        Ok(Wrap(self.series.borrow().get(idx).map_err(RbPolarsErr::from)?).into())
+        Ok(Wrap(self.series.borrow().get(idx).map_err(RbPolarsErr::from)?).into_value())
     }
 
     pub fn bitand(&self, other: &RbSeries) -> RbResult<Self> {
@@ -216,7 +215,7 @@ impl RbSeries {
     }
 
     pub fn dtype(&self) -> Value {
-        Wrap(self.series.borrow().dtype().clone()).into()
+        Wrap(self.series.borrow().dtype().clone()).into_value()
     }
 
     pub fn inner_dtype(&self) -> Option<Value> {
@@ -224,15 +223,15 @@ impl RbSeries {
             .borrow()
             .dtype()
             .inner_dtype()
-            .map(|dt| Wrap(dt.clone()).into())
+            .map(|dt| Wrap(dt.clone()).into_value())
     }
 
     pub fn set_sorted(&self, reverse: bool) -> Self {
         let mut out = self.series.borrow().clone();
         if reverse {
-            out.set_sorted(IsSorted::Descending);
+            out.set_sorted_flag(IsSorted::Descending);
         } else {
-            out.set_sorted(IsSorted::Ascending)
+            out.set_sorted_flag(IsSorted::Ascending)
         }
         out.into()
     }
@@ -255,7 +254,7 @@ impl RbSeries {
                 .get(0)
                 .map_err(RbPolarsErr::from)?,
         )
-        .into())
+        .into_value())
     }
 
     pub fn min(&self) -> RbResult<Value> {
@@ -266,7 +265,7 @@ impl RbSeries {
                 .get(0)
                 .map_err(RbPolarsErr::from)?,
         )
-        .into())
+        .into_value())
     }
 
     pub fn sum(&self) -> RbResult<Value> {
@@ -277,7 +276,7 @@ impl RbSeries {
                 .get(0)
                 .map_err(RbPolarsErr::from)?,
         )
-        .into())
+        .into_value())
     }
 
     pub fn n_chunks(&self) -> usize {
@@ -288,7 +287,7 @@ impl RbSeries {
         let mut binding = self.series.borrow_mut();
         let res = binding.append(&other.series.borrow());
         if let Err(e) = res {
-            Err(Error::runtime_error(e.to_string()))
+            Err(Error::new(exception::runtime_error(), e.to_string()))
         } else {
             Ok(())
         }
@@ -304,7 +303,7 @@ impl RbSeries {
 
     pub fn new_from_index(&self, index: usize, length: usize) -> RbResult<Self> {
         if index >= self.series.borrow().len() {
-            Err(Error::new(arg_error(), "index is out of bounds"))
+            Err(Error::new(exception::arg_error(), "index is out of bounds"))
         } else {
             Ok(self.series.borrow().new_from_index(index, length).into())
         }
@@ -316,7 +315,10 @@ impl RbSeries {
             let series = self.series.borrow().filter(ca).unwrap();
             Ok(series.into())
         } else {
-            Err(Error::runtime_error("Expected a boolean mask".to_string()))
+            Err(Error::new(
+                exception::runtime_error(),
+                "Expected a boolean mask".to_string(),
+            ))
         }
     }
 
@@ -487,40 +489,52 @@ impl RbSeries {
     }
 
     pub fn to_a(&self) -> RArray {
-        let series = self.series.borrow();
-        if let Ok(s) = series.f32() {
-            s.into_iter().collect()
-        } else if let Ok(s) = series.f64() {
-            s.into_iter().collect()
-        } else if let Ok(s) = series.i8() {
-            s.into_iter().collect()
-        } else if let Ok(s) = series.i16() {
-            s.into_iter().collect()
-        } else if let Ok(s) = series.i32() {
-            s.into_iter().collect()
-        } else if let Ok(s) = series.i64() {
-            s.into_iter().collect()
-        } else if let Ok(s) = series.u8() {
-            s.into_iter().collect()
-        } else if let Ok(s) = series.u16() {
-            s.into_iter().collect()
-        } else if let Ok(s) = series.u32() {
-            s.into_iter().collect()
-        } else if let Ok(s) = series.u64() {
-            s.into_iter().collect()
-        } else if let Ok(s) = series.bool() {
-            s.into_iter().collect()
-        } else if let Ok(s) = series.utf8() {
-            s.into_iter().collect()
-        } else if let Ok(_s) = series.date() {
-            let a = RArray::with_capacity(series.len());
-            for v in series.iter() {
-                a.push::<Value>(Wrap(v).into()).unwrap();
-            }
-            a
-        } else {
-            unimplemented!();
+        let series = &self.series.borrow();
+
+        fn to_list_recursive(series: &Series) -> RArray {
+            let rblist = match series.dtype() {
+                DataType::Boolean => RArray::from_iter(series.bool().unwrap()),
+                DataType::UInt8 => RArray::from_iter(series.u8().unwrap()),
+                DataType::UInt16 => RArray::from_iter(series.u16().unwrap()),
+                DataType::UInt32 => RArray::from_iter(series.u32().unwrap()),
+                DataType::UInt64 => RArray::from_iter(series.u64().unwrap()),
+                DataType::Int8 => RArray::from_iter(series.i8().unwrap()),
+                DataType::Int16 => RArray::from_iter(series.i16().unwrap()),
+                DataType::Int32 => RArray::from_iter(series.i32().unwrap()),
+                DataType::Int64 => RArray::from_iter(series.i64().unwrap()),
+                DataType::Float32 => RArray::from_iter(series.f32().unwrap()),
+                DataType::Float64 => RArray::from_iter(series.f64().unwrap()),
+                DataType::Decimal128(_) => todo!(),
+                DataType::Categorical(_) => {
+                    RArray::from_iter(series.categorical().unwrap().iter_str())
+                }
+                DataType::Date => {
+                    let a = RArray::with_capacity(series.len());
+                    for v in series.iter() {
+                        a.push::<Value>(Wrap(v).into_value()).unwrap();
+                    }
+                    return a;
+                }
+                DataType::Datetime(_, _) => {
+                    let a = RArray::with_capacity(series.len());
+                    for v in series.iter() {
+                        a.push::<Value>(Wrap(v).into_value()).unwrap();
+                    }
+                    return a;
+                }
+                DataType::Utf8 => {
+                    let ca = series.utf8().unwrap();
+                    return RArray::from_iter(ca);
+                }
+                DataType::Null | DataType::Unknown => {
+                    panic!("to_a not implemented for null/unknown")
+                }
+                _ => todo!(),
+            };
+            rblist
         }
+
+        to_list_recursive(series)
     }
 
     pub fn median(&self) -> Option<f64> {
@@ -546,7 +560,7 @@ impl RbSeries {
                 .get(0)
                 .unwrap_or(AnyValue::Null),
         )
-        .into())
+        .into_value())
     }
 
     pub fn clone(&self) -> Self {
@@ -756,11 +770,11 @@ impl RbSeries {
         Ok(RbSeries::new(s))
     }
 
-    pub fn to_dummies(&self) -> RbResult<RbDataFrame> {
+    pub fn to_dummies(&self, sep: Option<String>) -> RbResult<RbDataFrame> {
         let df = self
             .series
             .borrow()
-            .to_dummies()
+            .to_dummies(sep.as_deref())
             .map_err(RbPolarsErr::from)?;
         Ok(df.into())
     }
@@ -1095,8 +1109,8 @@ pub fn to_series_collection(rs: RArray) -> RbResult<Vec<Series>> {
     Ok(series)
 }
 
-pub fn to_rbseries_collection(s: Vec<Series>) -> Vec<RbSeries> {
-    s.into_iter().map(RbSeries::new).collect()
+pub fn to_rbseries_collection(s: Vec<Series>) -> RArray {
+    RArray::from_iter(s.into_iter().map(RbSeries::new))
 }
 
 impl RbSeries {

data/lib/polars/cat_expr.rb

@@ -36,13 +36,9 @@ module Polars
     #   # │ cat  ┆ i64  │
     #   # ╞══════╪══════╡
     #   # │ a    ┆ 2    │
-    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌╌┤
     #   # │ b    ┆ 3    │
-    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌╌┤
     #   # │ k    ┆ 2    │
-    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌╌┤
     #   # │ z    ┆ 1    │
-    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌╌┤
     #   # │ z    ┆ 3    │
     #   # └──────┴──────┘
     def set_ordering(ordering)

data/lib/polars/cat_name_space.rb

@@ -38,13 +38,9 @@ module Polars
     #   # │ cat  ┆ i64  │
     #   # ╞══════╪══════╡
     #   # │ a    ┆ 2    │
-    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌╌┤
     #   # │ b    ┆ 3    │
-    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌╌┤
     #   # │ k    ┆ 2    │
-    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌╌┤
     #   # │ z    ┆ 1    │
-    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌╌┤
     #   # │ z    ┆ 3    │
     #   # └──────┴──────┘
     def set_ordering(ordering)

data/lib/polars/convert.rb

@@ -24,7 +24,6 @@ module Polars
     #   # │ i64 ┆ i64 │
     #   # ╞═════╪═════╡
     #   # │ 1   ┆ 3   │
-    #   # ├╌╌╌╌╌┼╌╌╌╌╌┤
     #   # │ 2   ┆ 4   │
     #   # └─────┴─────┘
     def from_hash(data, columns: nil)
@@ -54,9 +53,7 @@ module Polars
     #   # │ i64 ┆ i64 │
     #   # ╞═════╪═════╡
     #   # │ 1   ┆ 4   │
-    #   # ├╌╌╌╌╌┼╌╌╌╌╌┤
     #   # │ 2   ┆ 5   │
-    #   # ├╌╌╌╌╌┼╌╌╌╌╌┤
     #   # │ 3   ┆ 6   │
     #   # └─────┴─────┘
     #
@@ -70,9 +67,7 @@ module Polars
     #   # │ i32 ┆ i64 │
     #   # ╞═════╪═════╡
     #   # │ 1   ┆ 4   │
-    #   # ├╌╌╌╌╌┼╌╌╌╌╌┤
     #   # │ 2   ┆ 5   │
-    #   # ├╌╌╌╌╌┼╌╌╌╌╌┤
     #   # │ 3   ┆ 6   │
     #   # └─────┴─────┘
     #
@@ -85,9 +80,7 @@ module Polars
     #   # │ i64 ┆ i64 ┆ i32  │
     #   # ╞═════╪═════╪══════╡
     #   # │ 1   ┆ 4   ┆ null │
-    #   # ├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌┤
     #   # │ 2   ┆ 5   ┆ null │
-    #   # ├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌┤
     #   # │ 3   ┆ 6   ┆ null │
     #   # └─────┴─────┴──────┘
     # def from_hashes(hashes, infer_schema_length: 50, schema: nil)