polars-df 0.3.1 → 0.4.0

data/ext/polars/src/lazy/dsl.rs

@@ -10,7 +10,7 @@ use crate::conversion::*;
 use crate::lazy::apply::*;
 use crate::lazy::utils::rb_exprs_to_exprs;
 use crate::utils::reinterpret;
-use crate::{RbResult, RbSeries};
+use crate::{RbPolarsErr, RbResult, RbSeries};
 
 #[magnus::wrap(class = "Polars::RbExpr")]
 #[derive(Clone)]
@@ -715,6 +715,18 @@ impl RbExpr {
             .into()
     }
 
+    pub fn binary_contains(&self, lit: Vec<u8>) -> Self {
+        self.inner.clone().binary().contains_literal(lit).into()
+    }
+
+    pub fn binary_ends_with(&self, sub: Vec<u8>) -> Self {
+        self.inner.clone().binary().ends_with(sub).into()
+    }
+
+    pub fn binary_starts_with(&self, sub: Vec<u8>) -> Self {
+        self.inner.clone().binary().starts_with(sub).into()
+    }
+
     pub fn str_hex_encode(&self) -> Self {
         self.clone()
             .inner
@@ -763,6 +775,58 @@ impl RbExpr {
             .into()
     }
 
+    pub fn binary_hex_encode(&self) -> Self {
+        self.clone()
+            .inner
+            .map(
+                move |s| s.binary().map(|s| Some(s.hex_encode().into_series())),
+                GetOutput::same_type(),
+            )
+            .with_fmt("binary.hex_encode")
+            .into()
+    }
+
+    pub fn binary_hex_decode(&self, strict: bool) -> Self {
+        self.clone()
+            .inner
+            .map(
+                move |s| {
+                    s.binary()?
+                        .hex_decode(strict)
+                        .map(|s| Some(s.into_series()))
+                },
+                GetOutput::same_type(),
+            )
+            .with_fmt("binary.hex_decode")
+            .into()
+    }
+
+    pub fn binary_base64_encode(&self) -> Self {
+        self.clone()
+            .inner
+            .map(
+                move |s| s.binary().map(|s| Some(s.base64_encode().into_series())),
+                GetOutput::same_type(),
+            )
+            .with_fmt("binary.base64_encode")
+            .into()
+    }
+
+    pub fn binary_base64_decode(&self, strict: bool) -> Self {
+        self.clone()
+            .inner
+            .map(
+                move |s| {
+                    s.binary()?
+                        .base64_decode(strict)
+                        .map(|s| Some(s.into_series()))
+                },
+                GetOutput::same_type(),
+            )
+            .with_fmt("binary.base64_decode")
+            .into()
+    }
+
     pub fn str_json_path_match(&self, pat: String) -> Self {
         let function = move |s: Series| {
             let ca = s.utf8()?;
@@ -1654,9 +1718,9 @@ pub fn cov(a: &RbExpr, b: &RbExpr) -> RbExpr {
     polars::lazy::dsl::cov(a.inner.clone(), b.inner.clone()).into()
 }
 
-pub fn argsort_by(by: RArray, reverse: Vec<bool>) -> RbResult<RbExpr> {
+pub fn arg_sort_by(by: RArray, reverse: Vec<bool>) -> RbResult<RbExpr> {
     let by = rb_exprs_to_exprs(by)?;
-    Ok(polars::lazy::dsl::argsort_by(by, &reverse).into())
+    Ok(polars::lazy::dsl::arg_sort_by(by, &reverse).into())
 }
 
 #[magnus::wrap(class = "Polars::RbWhen")]
@@ -1706,5 +1770,6 @@ pub fn concat_str(s: RArray, sep: String) -> RbResult<RbExpr> {
 
 pub fn concat_lst(s: RArray) -> RbResult<RbExpr> {
     let s = rb_exprs_to_exprs(s)?;
-    Ok(dsl::concat_lst(s).into())
+    let expr = dsl::concat_lst(s).map_err(RbPolarsErr::from)?;
+    Ok(expr.into())
 }

data/ext/polars/src/lib.rs

@@ -73,7 +73,7 @@ fn init() -> RbResult<()> {
     let class = module.define_class("RbDataFrame", Default::default())?;
     class.define_singleton_method("new", function!(RbDataFrame::init, 1))?;
     class.define_singleton_method("read_csv", function!(RbDataFrame::read_csv, -1))?;
-    class.define_singleton_method("read_parquet", function!(RbDataFrame::read_parquet, 7))?;
+    class.define_singleton_method("read_parquet", function!(RbDataFrame::read_parquet, 9))?;
     class.define_singleton_method("read_ipc", function!(RbDataFrame::read_ipc, 6))?;
     class.define_singleton_method("read_avro", function!(RbDataFrame::read_avro, 4))?;
     class.define_singleton_method("read_hashes", function!(RbDataFrame::read_hashes, 3))?;
@@ -151,7 +151,6 @@ fn init() -> RbResult<()> {
     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))?;
     class.define_method("lazy", method!(RbDataFrame::lazy, 0))?;
     class.define_method("max", method!(RbDataFrame::max, 0))?;
     class.define_method("min", method!(RbDataFrame::min, 0))?;
@@ -304,10 +303,23 @@ fn init() -> RbResult<()> {
     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("binary_contains", method!(RbExpr::binary_contains, 1))?;
+    class.define_method("binary_ends_with", method!(RbExpr::binary_ends_with, 1))?;
+    class.define_method("binary_starts_with", method!(RbExpr::binary_starts_with, 1))?;
     class.define_method("str_hex_encode", method!(RbExpr::str_hex_encode, 0))?;
     class.define_method("str_hex_decode", method!(RbExpr::str_hex_decode, 1))?;
     class.define_method("str_base64_encode", method!(RbExpr::str_base64_encode, 0))?;
     class.define_method("str_base64_decode", method!(RbExpr::str_base64_decode, 1))?;
+    class.define_method("binary_hex_encode", method!(RbExpr::binary_hex_encode, 0))?;
+    class.define_method("binary_hex_decode", method!(RbExpr::binary_hex_decode, 1))?;
+    class.define_method(
+        "binary_base64_encode",
+        method!(RbExpr::binary_base64_encode, 0),
+    )?;
+    class.define_method(
+        "binary_base64_decode",
+        method!(RbExpr::binary_base64_decode, 1),
+    )?;
     class.define_method(
         "str_json_path_match",
         method!(RbExpr::str_json_path_match, 1),
@@ -473,7 +485,7 @@ fn init() -> RbResult<()> {
         function!(crate::lazy::dsl::spearman_rank_corr, 4),
     )?;
     class.define_singleton_method("cov", function!(crate::lazy::dsl::cov, 2))?;
-    class.define_singleton_method("argsort_by", function!(crate::lazy::dsl::argsort_by, 2))?;
+    class.define_singleton_method("arg_sort_by", function!(crate::lazy::dsl::arg_sort_by, 2))?;
     class.define_singleton_method("when", function!(crate::lazy::dsl::when, 1))?;
     class.define_singleton_method("concat_str", function!(crate::lazy::dsl::concat_str, 2))?;
     class.define_singleton_method("concat_lst", function!(crate::lazy::dsl::concat_lst, 1))?;
@@ -487,7 +499,7 @@ fn init() -> RbResult<()> {
     class.define_singleton_method("new_from_csv", function!(RbLazyFrame::new_from_csv, -1))?;
     class.define_singleton_method(
         "new_from_parquet",
-        function!(RbLazyFrame::new_from_parquet, 7),
+        function!(RbLazyFrame::new_from_parquet, 8),
     )?;
     class.define_singleton_method("new_from_ipc", function!(RbLazyFrame::new_from_ipc, 6))?;
     class.define_method("write_json", method!(RbLazyFrame::write_json, 1))?;
@@ -504,6 +516,7 @@ fn init() -> RbResult<()> {
     class.define_method("sort_by_exprs", method!(RbLazyFrame::sort_by_exprs, 3))?;
     class.define_method("cache", method!(RbLazyFrame::cache, 0))?;
     class.define_method("collect", method!(RbLazyFrame::collect, 0))?;
+    class.define_method("sink_parquet", method!(RbLazyFrame::sink_parquet, 7))?;
     class.define_method("fetch", method!(RbLazyFrame::fetch, 1))?;
     class.define_method("filter", method!(RbLazyFrame::filter, 1))?;
     class.define_method("select", method!(RbLazyFrame::select, 1))?;
@@ -532,7 +545,7 @@ fn init() -> RbResult<()> {
     class.define_method("drop_nulls", method!(RbLazyFrame::drop_nulls, 1))?;
     class.define_method("slice", method!(RbLazyFrame::slice, 2))?;
     class.define_method("tail", method!(RbLazyFrame::tail, 1))?;
-    class.define_method("melt", method!(RbLazyFrame::melt, 4))?;
+    class.define_method("melt", method!(RbLazyFrame::melt, 5))?;
     class.define_method("with_row_count", method!(RbLazyFrame::with_row_count, 2))?;
     class.define_method("drop_columns", method!(RbLazyFrame::drop_columns, 1))?;
     class.define_method("_clone", method!(RbLazyFrame::clone, 0))?;
@@ -560,6 +573,7 @@ fn init() -> RbResult<()> {
     class.define_singleton_method("new_opt_f32", function!(RbSeries::new_opt_f32, 3))?;
     class.define_singleton_method("new_opt_f64", function!(RbSeries::new_opt_f64, 3))?;
     class.define_singleton_method("new_str", function!(RbSeries::new_str, 3))?;
+    class.define_singleton_method("new_binary", function!(RbSeries::new_binary, 3))?;
     class.define_singleton_method("new_object", function!(RbSeries::new_object, 3))?;
     class.define_singleton_method("new_list", function!(RbSeries::new_list, 3))?;
     class.define_singleton_method("new_opt_date", function!(RbSeries::new_opt_date, 3))?;

data/ext/polars/src/series.rs

@@ -125,6 +125,12 @@ impl RbSeries {
         RbSeries::new(s)
     }
 
+    pub fn new_binary(name: String, val: Wrap<BinaryChunked>, _strict: bool) -> Self {
+        let mut s = val.0.into_series();
+        s.rename(&name);
+        RbSeries::new(s)
+    }
+
     pub fn new_object(name: String, val: RArray, _strict: bool) -> RbResult<Self> {
         let val = val
             .each()
@@ -504,7 +510,6 @@ impl RbSeries {
                 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())
                 }
@@ -526,6 +531,13 @@ impl RbSeries {
                     let ca = series.utf8().unwrap();
                     return RArray::from_iter(ca);
                 }
+                DataType::Binary => {
+                    let a = RArray::with_capacity(series.len());
+                    for v in series.iter() {
+                        a.push::<Value>(Wrap(v).into_value()).unwrap();
+                    }
+                    return a;
+                }
                 DataType::Null | DataType::Unknown => {
                     panic!("to_a not implemented for null/unknown")
                 }

data/lib/polars/batched_csv_reader.rb

@@ -30,7 +30,7 @@ module Polars
       new_columns: nil
     )
       if Utils.pathlike?(file)
-        path = Utils.format_path(file)
+        path = Utils.normalise_filepath(file)
       end
 
       dtype_list = nil

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/data_frame.rb

@@ -97,7 +97,7 @@ module Polars
       eol_char: "\n"
     )
       if Utils.pathlike?(file)
-        path = Utils.format_path(file)
+        path = Utils.normalise_filepath(file)
       else
         path = nil
         # if defined?(StringIO) && file.is_a?(StringIO)
@@ -196,32 +196,56 @@ module Polars
 
     # @private
     def self._read_parquet(
-      file,
+      source,
       columns: nil,
       n_rows: nil,
       parallel: "auto",
       row_count_name: nil,
       row_count_offset: 0,
-      low_memory: false
+      low_memory: false,
+      use_statistics: true,
+      rechunk: true
     )
-      if Utils.pathlike?(file)
-        file = Utils.format_path(file)
+      if Utils.pathlike?(source)
+        source = Utils.normalise_filepath(source)
+      end
+      if columns.is_a?(String)
+        columns = [columns]
       end
 
-      if file.is_a?(String) && file.include?("*")
-        raise Todo
+      if source.is_a?(String) && source.include?("*") && Utils.local_file?(source)
+        scan =
+          Polars.scan_parquet(
+            source,
+            n_rows: n_rows,
+            rechunk: true,
+            parallel: parallel,
+            row_count_name: row_count_name,
+            row_count_offset: row_count_offset,
+            low_memory: low_memory
+          )
+
+        if columns.nil?
+          return self._from_rbdf(scan.collect._df)
+        elsif Utils.is_str_sequence(columns, allow_str: false)
+          return self._from_rbdf(scan.select(columns).collect._df)
+        else
+          raise ArgumentError, "cannot use glob patterns and integer based projection as `columns` argument; Use columns: Array[String]"
+        end
       end
 
       projection, columns = Utils.handle_projection_columns(columns)
       _from_rbdf(
         RbDataFrame.read_parquet(
-          file,
+          source,
           columns,
           projection,
           n_rows,
           parallel,
           Utils._prepare_row_count_args(row_count_name, row_count_offset),
-          low_memory
+          low_memory,
+          use_statistics,
+          rechunk
         )
       )
     end
@@ -229,7 +253,7 @@ module Polars
     # @private
     def self._read_avro(file, columns: nil, n_rows: nil)
       if Utils.pathlike?(file)
-        file = Utils.format_path(file)
+        file = Utils.normalise_filepath(file)
       end
       projection, columns = Utils.handle_projection_columns(columns)
       _from_rbdf(RbDataFrame.read_avro(file, columns, projection, n_rows))
@@ -246,7 +270,7 @@ module Polars
       memory_map: true
     )
       if Utils.pathlike?(file)
-        file = Utils.format_path(file)
+        file = Utils.normalise_filepath(file)
       end
       if columns.is_a?(String)
         columns = [columns]
@@ -272,7 +296,7 @@ module Polars
     # @private
     def self._read_json(file)
       if Utils.pathlike?(file)
-        file = Utils.format_path(file)
+        file = Utils.normalise_filepath(file)
       end
 
       _from_rbdf(RbDataFrame.read_json(file))
@@ -281,7 +305,7 @@ module Polars
     # @private
     def self._read_ndjson(file)
       if Utils.pathlike?(file)
-        file = Utils.format_path(file)
+        file = Utils.normalise_filepath(file)
       end
 
       _from_rbdf(RbDataFrame.read_ndjson(file))
@@ -774,7 +798,7 @@ module Polars
       row_oriented: false
     )
       if Utils.pathlike?(file)
-        file = Utils.format_path(file)
+        file = Utils.normalise_filepath(file)
       end
 
       _df.write_json(file, pretty, row_oriented)
@@ -789,7 +813,7 @@ module Polars
     # @return [nil]
     def write_ndjson(file)
       if Utils.pathlike?(file)
-        file = Utils.format_path(file)
+        file = Utils.normalise_filepath(file)
       end
 
       _df.write_ndjson(file)
@@ -879,7 +903,7 @@ module Polars
       end
 
       if Utils.pathlike?(file)
-        file = Utils.format_path(file)
+        file = Utils.normalise_filepath(file)
       end
 
       _df.write_csv(
@@ -917,7 +941,7 @@ module Polars
         compression = "uncompressed"
       end
       if Utils.pathlike?(file)
-        file = Utils.format_path(file)
+        file = Utils.normalise_filepath(file)
       end
 
       _df.write_avro(file, compression)
@@ -936,7 +960,7 @@ module Polars
         compression = "uncompressed"
       end
       if Utils.pathlike?(file)
-        file = Utils.format_path(file)
+        file = Utils.normalise_filepath(file)
       end
 
       _df.write_ipc(file, compression)
@@ -978,7 +1002,7 @@ module Polars
         compression = "uncompressed"
       end
       if Utils.pathlike?(file)
-        file = Utils.format_path(file)
+        file = Utils.normalise_filepath(file)
       end
 
       _df.write_parquet(
@@ -3042,24 +3066,28 @@ module Polars
       if aggregate_fn.is_a?(String)
         case aggregate_fn
         when "first"
-          aggregate_fn = Polars.element.first
+          aggregate_expr = Polars.element.first._rbexpr
         when "sum"
-          aggregate_fn = Polars.element.sum
+          aggregate_expr = Polars.element.sum._rbexpr
         when "max"
-          aggregate_fn = Polars.element.max
+          aggregate_expr = Polars.element.max._rbexpr
         when "min"
-          aggregate_fn = Polars.element.min
+          aggregate_expr = Polars.element.min._rbexpr
         when "mean"
-          aggregate_fn = Polars.element.mean
+          aggregate_expr = Polars.element.mean._rbexpr
         when "median"
-          aggregate_fn = Polars.element.median
+          aggregate_expr = Polars.element.median._rbexpr
         when "last"
-          aggregate_fn = Polars.element.last
+          aggregate_expr = Polars.element.last._rbexpr
         when "count"
-          aggregate_fn = Polars.count
+          aggregate_expr = Polars.count._rbexpr
         else
           raise ArgumentError, "Argument aggregate fn: '#{aggregate_fn}' was not expected."
         end
+      elsif aggregate_fn.nil?
+        aggregate_expr = nil
+      else
+        aggregate_expr = aggregate_function._rbexpr
       end
 
       _from_rbdf(
@@ -3067,9 +3095,9 @@ module Polars
           values,
           index,
           columns,
-          aggregate_fn._rbexpr,
           maintain_order,
           sort_columns,
+          aggregate_expr,
           separator
         )
       )
@@ -3174,7 +3202,7 @@ module Polars
     #   # │ B    ┆ 1    │
     #   # │ C    ┆ 2    │
     #   # │ D    ┆ 3    │
-    #   # │ ...  ┆ ...  │
+    #   # │ …    ┆ …    │
     #   # │ F    ┆ 5    │
     #   # │ G    ┆ 6    │
     #   # │ H    ┆ 7    │
@@ -4053,15 +4081,12 @@ module Polars
     #   # │ 5   ┆ 3.0 ┆ true  │
     #   # └─────┴─────┴───────┘
     def unique(maintain_order: true, subset: nil, keep: "first")
-      if !subset.nil?
-        if subset.is_a?(String)
-          subset = [subset]
-        elsif !subset.is_a?(Array)
-          subset = subset.to_a
-        end
-      end
-
-      _from_rbdf(_df.unique(maintain_order, subset, keep))
+      self._from_rbdf(
+        lazy
+          .unique(maintain_order: maintain_order, subset: subset, keep: keep)
+          .collect(no_optimization: true)
+          ._df
+      )
     end
 
     # Return the number of unique rows, or the number of unique row-subsets.

data/lib/polars/date_time_expr.rb

@@ -1130,7 +1130,7 @@ module Polars
     #     ]
     #   )
     #   # =>
-    #   # shape: (1001, 2)
+    #   # shape: (1_001, 2)
     #   # ┌─────────────────────────┬───────────────────┐
     #   # │ date                    ┆ milliseconds_diff │
     #   # │ ---                     ┆ ---               │
@@ -1140,7 +1140,7 @@ module Polars
     #   # │ 2020-01-01 00:00:00.001 ┆ 1                 │
     #   # │ 2020-01-01 00:00:00.002 ┆ 1                 │
     #   # │ 2020-01-01 00:00:00.003 ┆ 1                 │
-    #   # │ ...                     ┆ ...               │
+    #   # │ …                       ┆ …                 │
     #   # │ 2020-01-01 00:00:00.997 ┆ 1                 │
     #   # │ 2020-01-01 00:00:00.998 ┆ 1                 │
     #   # │ 2020-01-01 00:00:00.999 ┆ 1                 │
@@ -1169,7 +1169,7 @@ module Polars
     #     ]
     #   )
     #   # =>
-    #   # shape: (1001, 2)
+    #   # shape: (1_001, 2)
     #   # ┌─────────────────────────┬───────────────────┐
     #   # │ date                    ┆ microseconds_diff │
     #   # │ ---                     ┆ ---               │
@@ -1179,7 +1179,7 @@ module Polars
     #   # │ 2020-01-01 00:00:00.001 ┆ 1000              │
     #   # │ 2020-01-01 00:00:00.002 ┆ 1000              │
     #   # │ 2020-01-01 00:00:00.003 ┆ 1000              │
-    #   # │ ...                     ┆ ...               │
+    #   # │ …                       ┆ …                 │
     #   # │ 2020-01-01 00:00:00.997 ┆ 1000              │
     #   # │ 2020-01-01 00:00:00.998 ┆ 1000              │
     #   # │ 2020-01-01 00:00:00.999 ┆ 1000              │
@@ -1208,7 +1208,7 @@ module Polars
     #     ]
     #   )
     #   # =>
-    #   # shape: (1001, 2)
+    #   # shape: (1_001, 2)
     #   # ┌─────────────────────────┬──────────────────┐
     #   # │ date                    ┆ nanoseconds_diff │
     #   # │ ---                     ┆ ---              │
@@ -1218,7 +1218,7 @@ module Polars
     #   # │ 2020-01-01 00:00:00.001 ┆ 1000000          │
     #   # │ 2020-01-01 00:00:00.002 ┆ 1000000          │
     #   # │ 2020-01-01 00:00:00.003 ┆ 1000000          │
-    #   # │ ...                     ┆ ...              │
+    #   # │ …                       ┆ …                │
     #   # │ 2020-01-01 00:00:00.997 ┆ 1000000          │
     #   # │ 2020-01-01 00:00:00.998 ┆ 1000000          │
     #   # │ 2020-01-01 00:00:00.999 ┆ 1000000          │