Refactor writers and update dependencies (chitralverma#130)

* Update versions

* fixes for update

* null_last for top_k and sort accepts an array of bools

* redo writers

* new writer for json

* lint fix

* new writer for csv

* docs for writers

* remaining updates

* remaining writer docs

Author: chitralverma

.gitignore

@@ -13,4 +13,4 @@ coverage.xml
 target/
 .classpath
 .project
-.settings/
+.settings/

.scalafmt.conf

@@ -1,4 +1,4 @@
-version = 3.8.1
+version = 3.8.3
 runner.dialect = scala213
 project.git = true
 maxColumn = 98

core/src/main/scala/org/polars/scala/polars/api/DataFrame.scala

@@ -38,7 +38,7 @@ class DataFrame private (private[polars] val ptr: Long) {
   def sort(
       cols: Array[String],
       descending: Array[Boolean],
-      nullLast: Boolean,
+      nullLast: Array[Boolean],
       maintainOrder: Boolean
   ): DataFrame =
     toLazy.sort(cols, descending, nullLast, maintainOrder).collect(noOptimization = true)
@@ -53,17 +53,21 @@ class DataFrame private (private[polars] val ptr: Long) {
       .sort(
         cols = Array(expr),
         descending = Array(descending),
-        nullLast = nullLast,
+        nullLast = Array(nullLast),
         maintainOrder = maintainOrder
       )
       .collect(noOptimization = true)
 
-  def sort(exprs: Array[Expression], null_last: Boolean, maintain_order: Boolean): DataFrame =
+  def sort(
+      exprs: Array[Expression],
+      null_last: Array[Boolean],
+      maintain_order: Boolean
+  ): DataFrame =
     toLazy.sort(exprs, null_last, maintain_order).collect(noOptimization = true)
 
   def sort(expr: Expression, null_last: Boolean, maintain_order: Boolean): DataFrame =
     toLazy
-      .sort(Array(expr), null_last = null_last, maintainOrder = maintain_order)
+      .sort(Array(expr), Array(null_last), maintainOrder = maintain_order)
       .collect(noOptimization = true)
 
   def set_sorted(mapping: Map[String, Boolean]): DataFrame =
@@ -76,7 +80,7 @@ class DataFrame private (private[polars] val ptr: Long) {
       k: Int,
       cols: Array[String],
       descending: Array[Boolean],
-      nullLast: Boolean,
+      nullLast: Array[Boolean],
       maintainOrder: Boolean
   ): DataFrame =
     toLazy
@@ -95,15 +99,15 @@ class DataFrame private (private[polars] val ptr: Long) {
         k = k,
         cols = Array(expr),
         descending = Array(descending),
-        nullLast = nullLast,
+        nullLast = Array(nullLast),
         maintainOrder = maintainOrder
       )
       .collect(projectionPushdown = false, predicatePushdown = false, commSubplanElim = false)
 
   def top_k(
       k: Int,
       exprs: Array[Expression],
-      null_last: Boolean,
+      null_last: Array[Boolean],
       maintain_order: Boolean
   ): DataFrame =
     toLazy
@@ -112,7 +116,7 @@ class DataFrame private (private[polars] val ptr: Long) {
 
   def top_k(k: Int, expr: Expression, null_last: Boolean, maintain_order: Boolean): DataFrame =
     toLazy
-      .top_k(k, Array(expr), null_last = null_last, maintainOrder = maintain_order)
+      .top_k(k, Array(expr), Array(null_last), maintainOrder = maintain_order)
       .collect(projectionPushdown = false, predicatePushdown = false, commSubplanElim = false)
 
   def limit(n: Long): DataFrame = DataFrame.withPtr(data_frame.limit(ptr, n))

core/src/main/scala/org/polars/scala/polars/api/LazyFrame.scala

@@ -43,7 +43,7 @@ class LazyFrame private (private[polars] val ptr: Long) {
   def sort(
       cols: Array[String],
       descending: Array[Boolean],
-      nullLast: Boolean,
+      nullLast: Array[Boolean],
       maintainOrder: Boolean
   ): LazyFrame = {
     assert(
@@ -56,7 +56,7 @@ class LazyFrame private (private[polars] val ptr: Long) {
       Expression.withPtr(column_expr.sort_column_by_name(column, bool))
     }
 
-    sort(exprs, null_last = nullLast, maintainOrder = maintainOrder)
+    sort(exprs, nullLast, maintainOrder = maintainOrder)
   }
 
   def sort(
@@ -65,17 +65,27 @@ class LazyFrame private (private[polars] val ptr: Long) {
       nullLast: Boolean,
       maintainOrder: Boolean
   ): LazyFrame =
-    sort(Array(col), Array(descending), nullLast = nullLast, maintainOrder = maintainOrder)
+    sort(Array(col), Array(descending), Array(nullLast), maintainOrder = maintainOrder)
+
+  def sort(
+      exprs: Array[Expression],
+      null_last: Array[Boolean],
+      maintainOrder: Boolean
+  ): LazyFrame = {
+    assert(
+      exprs.length == null_last.length,
+      s"Length of provided expressions (${exprs.length}) and their " +
+        s"null_last (${null_last.length}) is not equal."
+    )
 
-  def sort(exprs: Array[Expression], null_last: Boolean, maintainOrder: Boolean): LazyFrame = {
     val ldfPtr =
       lazy_frame.sortFromExprs(ptr, exprs.map(_.ptr).distinct, null_last, maintainOrder)
 
     LazyFrame.withPtr(ldfPtr)
   }
 
   def sort(expr: Expression, nullLast: Boolean, maintainOrder: Boolean): LazyFrame =
-    sort(Array(expr), null_last = nullLast, maintainOrder = maintainOrder)
+    sort(Array(expr), Array(nullLast), maintainOrder = maintainOrder)
 
   def set_sorted(mapping: Map[String, Boolean]): LazyFrame =
     set_sorted(mapping.asJava)
@@ -89,29 +99,34 @@ class LazyFrame private (private[polars] val ptr: Long) {
   def top_k(
       k: Int,
       exprs: Array[Expression],
-      null_last: Boolean,
+      null_last: Array[Boolean],
       maintainOrder: Boolean
   ): LazyFrame = {
+    assert(
+      exprs.length == null_last.length,
+      s"Length of provided expressions (${exprs.length}) and their " +
+        s"null_last (${null_last.length}) is not equal."
+    )
     val ldfPtr =
       lazy_frame.topKFromExprs(ptr, k, exprs.map(_.ptr).distinct, null_last, maintainOrder)
 
     LazyFrame.withPtr(ldfPtr)
   }
 
   def top_k(k: Int, expr: Expression, nullLast: Boolean, maintainOrder: Boolean): LazyFrame =
-    top_k(k, Array(expr), null_last = nullLast, maintainOrder = maintainOrder)
+    top_k(k, Array(expr), Array(nullLast), maintainOrder = maintainOrder)
 
   def top_k(
       k: Int,
       cols: Array[String],
       descending: Array[Boolean],
-      nullLast: Boolean,
+      nullLast: Array[Boolean],
       maintainOrder: Boolean
   ): LazyFrame = {
     assert(
       cols.length == descending.length,
-      s"Length of provided list columns(${cols.length}) and their " +
-        s"sorting directions((${descending.length})) is not equal."
+      s"Length of provided list columns (${cols.length}) and their " +
+        s"sorting directions (${descending.length}) is not equal."
     )
 
     val exprs = cols.zip(descending).map { case (column, bool) =>
@@ -128,7 +143,7 @@ class LazyFrame private (private[polars] val ptr: Long) {
       nullLast: Boolean,
       maintainOrder: Boolean
   ): LazyFrame =
-    top_k(k, Array(col), Array(descending), nullLast = nullLast, maintainOrder = maintainOrder)
+    top_k(k, Array(col), Array(descending), Array(nullLast), maintainOrder = maintainOrder)
 
   def limit(n: Long): LazyFrame = LazyFrame.withPtr(lazy_frame.limit(ptr, n))