Automated commit of generated code

Author: github-actions[bot]

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/unfold.kt

@@ -6,28 +6,23 @@ import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.annotations.AccessApiOverload
-import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.annotations.Refine
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
-import org.jetbrains.kotlinx.dataframe.impl.api.canBeUnfolded
-import org.jetbrains.kotlinx.dataframe.impl.api.createDataFrameImpl
-import org.jetbrains.kotlinx.dataframe.typeClass
+import org.jetbrains.kotlinx.dataframe.impl.api.unfoldImpl
+import kotlin.reflect.KCallable
 import kotlin.reflect.KProperty
 
-public inline fun <reified T> DataColumn<T>.unfold(): AnyCol =
-    when (kind()) {
-        ColumnKind.Group, ColumnKind.Frame -> this
+public inline fun <reified T> DataColumn<T>.unfold(vararg roots: KCallable<*>, maxDepth: Int = 0): AnyCol =
+    unfoldImpl { properties(roots = roots, maxDepth) }
 
-        else -> when {
-            !typeClass.canBeUnfolded -> this
-
-            else -> values()
-                .createDataFrameImpl(typeClass) { (this as CreateDataFrameDsl<T>).properties() }
-                .asColumnGroup(name())
-                .asDataColumn()
-        }
-    }
-
-public fun <T> DataFrame<T>.unfold(columns: ColumnsSelector<T, *>): DataFrame<T> = replace(columns).with { it.unfold() }
+@Refine
+@Interpretable("DataFrameUnfold")
+public fun <T> DataFrame<T>.unfold(
+    vararg roots: KCallable<*>,
+    maxDepth: Int = 0,
+    columns: ColumnsSelector<T, *>,
+): DataFrame<T> = replace(columns).with { it.unfoldImpl { properties(roots = roots, maxDepth) } }
 
 public fun <T> DataFrame<T>.unfold(vararg columns: String): DataFrame<T> = unfold { columns.toColumnSet() }
 

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/unfold.kt

@@ -0,0 +1,24 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.api.CreateDataFrameDsl
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.asDataColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.typeClass
+
+@PublishedApi
+internal fun <T> DataColumn<T>.unfoldImpl(body: CreateDataFrameDsl<T>.() -> Unit): AnyCol =
+    when (kind()) {
+        ColumnKind.Group, ColumnKind.Frame -> this
+
+        else -> when {
+            !typeClass.canBeUnfolded -> this
+
+            else -> values()
+                .createDataFrameImpl(typeClass) { (this as CreateDataFrameDsl<T>).body() }
+                .asColumnGroup(name())
+                .asDataColumn()
+        }
+    }

core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/unfold.kt

@@ -0,0 +1,68 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.types.shouldBeInstanceOf
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class UnfoldTests {
+    @Test
+    fun unfold() {
+        val df = dataFrameOf(
+            "col" to listOf(A("123", 321)),
+        )
+
+        val res = df.unfold { col("col") }
+        res[pathOf("col", "str")][0] shouldBe "123"
+        res[pathOf("col", "i")][0] shouldBe 321
+    }
+
+    @Test
+    fun `unfold deep`() {
+        val df1 = dataFrameOf(
+            "col" to listOf(
+                Group(
+                    "1",
+                    listOf(
+                        Person("Alice", "Cooper", 15, "London"),
+                        Person("Bob", "Dylan", 45, "Dubai"),
+                    ),
+                ),
+                Group(
+                    "2",
+                    listOf(
+                        Person("Charlie", "Daniels", 20, "Moscow"),
+                        Person("Charlie", "Chaplin", 40, "Milan"),
+                    ),
+                ),
+            ),
+        )
+
+        df1.unfold { col("col") }[pathOf("col", "participants")].type() shouldBe typeOf<List<Person>>()
+
+        df1.unfold(maxDepth = 2) { col("col") }[pathOf("col", "participants")][0].shouldBeInstanceOf<AnyFrame> {
+            it["firstName"][0] shouldBe "Alice"
+        }
+    }
+
+    @Test
+    fun `keep value type`() {
+        val values = listOf(1, 2, 3, 4)
+        val df2 = dataFrameOf("int" to values)
+        val column = df2.unfold { col("int") }["int"]
+        column.type() shouldBe typeOf<Int>()
+        column.values() shouldBe values
+    }
+
+    data class A(val str: String, val i: Int)
+
+    data class Person(
+        val firstName: String,
+        val lastName: String,
+        val age: Int,
+        val city: String?,
+    )
+
+    data class Group(val id: String, val participants: List<Person>)
+}