Initialize DataFrames from series (chitralverma#92)

* suppress linting for java generics

* introduce dataframes from series

* fmt fix

* add doc strings

* fix scopes for LazyFrame and Series

Author: chitralverma

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

@@ -1,5 +1,6 @@
 package org.polars.scala.polars.api
 
+import java.util
 import java.util.Collections
 
 import scala.annotation.varargs
@@ -170,4 +171,69 @@ class DataFrame private (private[polars] val ptr: Long) {
 object DataFrame {
 
   private[polars] def withPtr(ptr: Long) = new DataFrame(ptr)
+
+  /** Initialize new [[org.polars.scala.polars.api.DataFrame]] from one or more
+    * [[org.polars.scala.polars.api.Series]]. The name of a series is used as column name and its
+    * values are the values of this column.
+    *
+    * @param series
+    *   Series
+    * @param more
+    *   Series as a scala or java array
+    *
+    * @return
+    *   [[org.polars.scala.polars.api.DataFrame]] formed from the provided
+    *   [[org.polars.scala.polars.api.Series]]
+    */
+  def fromSeries(series: Series, more: Array[Series]): DataFrame =
+    DataFrame.withPtr(data_frame.fromSeries(more.+:(series).map(_.ptr)))
+
+  /** Initialize new [[org.polars.scala.polars.api.DataFrame]] from one or more
+    * [[org.polars.scala.polars.api.Series]]. The name of a series is used as column name and its
+    * values are the values of this column.
+    *
+    * @param series
+    *   Series
+    * @param more
+    *   Series as a scala iterable
+    *
+    * @return
+    *   [[org.polars.scala.polars.api.DataFrame]] formed from the provided
+    *   [[org.polars.scala.polars.api.Series]]
+    */
+  def fromSeries(series: Series, more: Iterable[Series]): DataFrame =
+    fromSeries(series, more.toArray)
+
+  /** Initialize new [[org.polars.scala.polars.api.DataFrame]] from one or more
+    * [[org.polars.scala.polars.api.Series]]. The name of a series is used as column name and its
+    * values are the values of this column.
+    *
+    * @param series
+    *   Series
+    * @param more
+    *   Series as a java iterable
+    *
+    * @return
+    *   [[org.polars.scala.polars.api.DataFrame]] formed from the provided
+    *   [[org.polars.scala.polars.api.Series]]
+    */
+  def fromSeries(series: Series, more: java.lang.Iterable[Series]): DataFrame =
+    fromSeries(series, more.asScala)
+
+  /** Initialize new [[org.polars.scala.polars.api.DataFrame]] from one or more
+    * [[org.polars.scala.polars.api.Series]]. The name of a series is used as column name and its
+    * values are the values of this column.
+    *
+    * @param series
+    *   Series
+    * @param more
+    *   Series as scala varargs
+    *
+    * @return
+    *   [[org.polars.scala.polars.api.DataFrame]] formed from the provided
+    *   [[org.polars.scala.polars.api.Series]]
+    */
+  def fromSeries(series: Series, more: Series*): DataFrame =
+    fromSeries(series, more)
+
 }

core/src/main/scala/org/polars/scala/polars/api/JSeries.java

@@ -16,6 +16,7 @@
 class JSeries {
     final static String EmptyString = "";
 
+    @SuppressWarnings({ "unchecked", "rawtypes" })
     static Series ofList(String name, Iterable<Iterable> values) {
         Iterator<Iterable> valuesIter = values.iterator();
         List<Series> sList = new ArrayList<>();

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

@@ -262,5 +262,5 @@ class LazyFrame private (private[polars] val ptr: Long) {
 
 object LazyFrame {
 
-  def withPtr(ptr: Long) = new LazyFrame(ptr)
+  private[polars] def withPtr(ptr: Long) = new LazyFrame(ptr)
 }

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

@@ -469,45 +469,45 @@ object Series {
     * @param name
     *   Name of Series
     * @param values
-    *   Values of Series as a scala or java array
+    *   Values of Series as a java iterable
     *
     * @return
     *   Nested Series of provided type. If `values` is empty, empty series is returned retaining
     *   type. Nested collections in `values` must not be empty or this will result in
     *   [[java.lang.ArrayIndexOutOfBoundsException]].
     */
-  def ofList[T](name: String, values: Array[Array[T]]): Series =
-    Series.ofList(name, values.map(_.toSeq).toSeq)
+  def ofList(name: String, values: java.lang.Iterable[java.lang.Iterable[_]]): Series =
+    JSeries.ofList(name, values)
 
   /** Initialize new nested series by name and values of provided type.
     *
     * @param name
     *   Name of Series
     * @param values
-    *   Values of Series as a java iterable
+    *   Values of Series as a scala iterable
     *
     * @return
     *   Nested Series of provided type. If `values` is empty, empty series is returned retaining
     *   type. Nested collections in `values` must not be empty or this will result in
     *   [[java.lang.ArrayIndexOutOfBoundsException]].
     */
-  def ofList(name: String, values: java.lang.Iterable[java.lang.Iterable[_]]): Series =
-    JSeries.ofList(name, values)
+  def ofList(name: String, values: Iterable[Iterable[_]]): Series =
+    Series.ofList(name, values.map(_.asJava.asInstanceOf[java.lang.Iterable[_]]).asJava)
 
   /** Initialize new nested series by name and values of provided type.
     *
     * @param name
     *   Name of Series
     * @param values
-    *   Values of Series as a scala iterable
+    *   Values of Series as a scala or java array
     *
     * @return
     *   Nested Series of provided type. If `values` is empty, empty series is returned retaining
     *   type. Nested collections in `values` must not be empty or this will result in
     *   [[java.lang.ArrayIndexOutOfBoundsException]].
     */
-  def ofList(name: String, values: Iterable[Iterable[_]]): Series =
-    Series.ofList(name, values.map(_.asJava.asInstanceOf[java.lang.Iterable[_]]).asJava)
+  def ofList[T](name: String, values: Array[Array[T]]): Series =
+    Series.ofList(name, values.map(_.toSeq).toSeq)
 
-  def withPtr(ptr: Long) = new Series(ptr)
+  private[polars] def withPtr(ptr: Long) = new Series(ptr)
 }

core/src/main/scala/org/polars/scala/polars/internal/jni/data_frame.scala

@@ -16,4 +16,6 @@ private[polars] object data_frame extends Natively {
 
   @native def tail(ptr: Long, n: Long): Long
 
+  @native def fromSeries(ptrs: Array[Long]): Long
+
 }

examples/src/main/java/examples/java/InstantiateDataFrame.java

@@ -0,0 +1,54 @@
+package examples.java;
+
+import java.util.Arrays;
+import org.polars.scala.polars.api.DataFrame;
+import org.polars.scala.polars.api.Series;
+
+public class InstantiateDataFrame {
+  public static void main(String[] args) {
+
+    /* Values as Java array(s) */
+
+    DataFrame.fromSeries(
+            Series.ofInt("i32_col", new int[] {1, 2, 3}),
+            new Series[] {
+              Series.ofLong("i64_col", new long[] {1L, 2L, 3L}),
+              Series.ofBoolean("bool_col", new boolean[] {true, false, true}),
+              Series.ofList(
+                  "nested_str_col",
+                  new String[][] {{"a", "b", "c"}, {"a", "b", "c"}, {"a", "b", "c"}})
+            })
+        .show();
+
+    DataFrame.fromSeries(
+            Series.ofInt("i32_col", new Integer[] {1, 2, 3}),
+            new Series[] {
+              Series.ofLong("i64_col", new Long[] {1L, 2L, 3L}),
+              Series.ofBoolean("bool_col", new Boolean[] {true, false, true}),
+              Series.ofFloat("f32_col", new Float[] {1F, 2F, 3F})
+            })
+        .show();
+
+    /* Values as Java lists(s) */
+
+    DataFrame.fromSeries(
+            Series.ofInt("i32_col", Arrays.asList(1, 2, 3)),
+            new Series[] {
+              Series.ofLong("i64_col", Arrays.asList(1L, 2L, 3L)),
+              Series.ofBoolean("bool_col", Arrays.asList(true, false, true)),
+              Series.ofFloat("f32_col", Arrays.asList(1F, 2F, 3F))
+            })
+        .show();
+
+    /* Values as a mix of Java lists(s) and array(s) */
+
+    DataFrame.fromSeries(
+            Series.ofInt("i32_col", Arrays.asList(1, 2, 3)),
+            new Series[] {
+              Series.ofLong("i64_col", new Long[] {1L, 2L, 3L}),
+              Series.ofBoolean("bool_col", new Boolean[] {true, false, true}),
+              Series.ofFloat("f32_col", Arrays.asList(1F, 2F, 3F))
+            })
+        .show();
+  }
+}

examples/src/main/scala/examples/scala/InstantiateDataFrame.scala

@@ -0,0 +1,64 @@
+package examples.scala
+
+import org.polars.scala.polars.api.{DataFrame, Series}
+
+object InstantiateDataFrame {
+
+  def main(args: Array[String]): Unit = {
+    DataFrame.fromSeries(Series.ofBoolean("bool_col", Array[Boolean](true, false, true))).show()
+
+    DataFrame
+      .fromSeries(
+        Series.ofInt("i32_col", Array[Int](1, 2, 3)),
+        Series.ofLong("i64_col", Array[Long](1L, 2L, 3L)),
+        Series.ofBoolean("bool_col", Array[Boolean](true, false, true)),
+        Series.ofList(
+          "nested_str_col",
+          Array[Array[String]](Array("a", "b", "c"), Array("a", "b", "c"), Array("a", "b", "c"))
+        )
+      )
+      .show()
+
+    /* Values as Scala array(s) */
+    DataFrame
+      .fromSeries(
+        Series.ofInt("i32_col", Array[Int](1, 2, 3)),
+        Array[Series](
+          Series.ofLong("i64_col", Array[Long](1L, 2L, 3L)),
+          Series.ofBoolean("bool_col", Array[Boolean](true, false, true)),
+          Series.ofList(
+            "nested_str_col",
+            Array[Array[String]](Array("a", "b", "c"), Array("a", "b", "c"), Array("a", "b", "c"))
+          )
+        )
+      )
+      .show()
+
+    /* Values as scala lists(s) */
+
+    DataFrame
+      .fromSeries(
+        Series.ofInt("i32_col", Seq(1, 2, 3)),
+        Array[Series](
+          Series.ofLong("i64_col", Seq(1L, 2L, 3L)),
+          Series.ofBoolean("bool_col", Seq(true, false, true)),
+          Series.ofFloat("f32_col", Seq(1f, 2f, 3f))
+        )
+      )
+      .show()
+
+    /* Values as a mix of Scala lists(s) and array(s) */
+
+    DataFrame
+      .fromSeries(
+        Series.ofInt("i32_col", Seq(1, 2, 3)),
+        Array[Series](
+          Series.ofLong("i64_col", Array[Long](1L, 2L, 3L)),
+          Series.ofBoolean("bool_col", Array[Boolean](true, false, true)),
+          Series.ofFloat("f32_col", Seq(1f, 2f, 3f))
+        )
+      )
+      .show()
+  }
+
+}

native/src/internal_jni/frame.rs

@@ -11,6 +11,7 @@ use polars_core::utils::concat_df;
 
 use crate::internal_jni::utils::*;
 use crate::j_data_frame::JDataFrame;
+use crate::j_series::JSeries;
 
 #[jni_fn("org.polars.scala.polars.internal.jni.data_frame$")]
 pub fn schemaString(mut _env: JNIEnv, _object: JObject, ldf_ptr: jlong) -> jstring {
@@ -76,3 +77,22 @@ pub fn tail(mut env: JNIEnv, object: JObject, ptr: jlong, n: jlong) -> jlong {
 
     j_df.tail(&mut env, object, n as usize)
 }
+
+#[jni_fn("org.polars.scala.polars.internal.jni.data_frame$")]
+pub fn fromSeries(mut env: JNIEnv, callback_obj: JObject, ptrs: JLongArray) -> jlong {
+    let arr = unsafe { env.get_array_elements(&ptrs, NoCopyBack).unwrap() };
+    let data: Vec<Series> = unsafe {
+        std::slice::from_raw_parts(arr.as_ptr(), arr.len())
+            .to_vec()
+            .iter()
+            .map(|p| p.to_i64().unwrap())
+            .map(|ptr| {
+                let j_series = &mut *(ptr as *mut JSeries);
+                j_series.to_owned().series
+            })
+            .collect()
+    };
+
+    let df = DataFrame::new(data);
+    df_to_ptr(&mut env, callback_obj, df)
+}