Automated commit of generated code

Author: github-actions[bot]

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

@@ -190,6 +190,10 @@ internal interface ConvertDocs {
      * * [LocalDateTime], [LocalDate], [LocalTime],
      *   `Instant` ([kotlinx.datetime][DeprecatedInstant], [kotlin.time][StdlibInstant], and [java.time]),
      * * [URL], [IMG], [IFRAME].
+     *
+     * __NOTE__: Conversion between [Int] and [Char] is done by UTF-16 [Char.code].
+     *   To convert [Char]->[Int] the way it is written, use [parse()][parse] instead, or,
+     *   in either case, use [String] as intermediary type.
      */
     interface SupportedTypes
 
@@ -501,7 +505,7 @@ public class Convert<T, out C>(
      * preserving their original names and positions within the [DataFrame].
      *
      * The target type is provided as a reified type argument.
-     * For the full list of supported types, see [ConvertDocs.SupportedTypes].
+     * For the full list of supported types, see [SupportedTypes][ConvertDocs.SupportedTypes].
      *
      * For more information: [See `convert` on the documentation website.](https://kotlin.github.io/dataframe/convert.html)
      *
@@ -529,7 +533,7 @@ public class Convert<T, out C>(
  * preserving their original names and positions within the [DataFrame].
  *
  * The target type is provided as a [KType].
- * For the full list of supported types, see [ConvertDocs.SupportedTypes].
+ * For the full list of supported types, see [SupportedTypes][ConvertDocs.SupportedTypes].
  *
  * For more information: [See `convert` on the documentation website.](https://kotlin.github.io/dataframe/convert.html)
  *
@@ -687,7 +691,7 @@ public inline fun <T, C, reified R> Convert<T, C>.perRowCol(
  *
  * The target type is provided as a reified type argument.
  *
- * For the full list of supported types, see [ConvertDocs.SupportedTypes].
+ * For the full list of supported types, see [SupportedTypes][ConvertDocs.SupportedTypes].
  *
  * @param [C] The target type to convert values to.
  * @return A new [DataColumn] with the values converted to type [C].
@@ -697,7 +701,7 @@ public inline fun <reified C> AnyCol.convertTo(): DataColumn<C> = convertTo(type
 /**
  * Converts values in this column to the specified [type].
  *
- * For the full list of supported types, see [ConvertDocs.SupportedTypes].
+ * For the full list of supported types, see [SupportedTypes][ConvertDocs.SupportedTypes].
  *
  * @param type The target type, provided as a [KType], to convert values to.
  * @return A new [DataColumn] with the values converted to [type].

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

@@ -52,7 +52,7 @@ public class ConverterScope(public val fromType: KType, public val toSchema: Col
  * df.convertTo<SomeSchema> {
  *     // defines how to convert Int? -> String
  *     convert<Int?>().with { it?.toString() ?: "No input given" }
- *     // defines how to convert String -> SomeType
+ *     // defines how to convert String/Char -> SomeType
  *     parser { SomeType(it) }
  *     // fill missing column `sum` with expression `a+b`
  *     fill { sum }.with { a + b }
@@ -102,6 +102,10 @@ public fun <T, C> ConvertToFill<T, C>.with(expr: RowExpression<T, C>) {
 
 /**
  * Defines how to convert `String` values into given type [C].
+ *
+ * This method is a shortcut for `convert<String>().with { }`.
+ *
+ * If no converter is defined for `Char` values, this converter will be used for them as well.
  */
 public inline fun <reified C> ConvertSchemaDsl<*>.parser(noinline parser: (String) -> C): Unit =
     convert<String>().with(parser)

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

@@ -12,15 +12,13 @@ import org.jetbrains.kotlinx.dataframe.impl.api.StringParser
 import org.jetbrains.kotlinx.dataframe.impl.api.parseImpl
 import org.jetbrains.kotlinx.dataframe.impl.api.tryParseImpl
 import org.jetbrains.kotlinx.dataframe.impl.io.FastDoubleParser
-import org.jetbrains.kotlinx.dataframe.typeClass
 import org.jetbrains.kotlinx.dataframe.util.DEPRECATED_ACCESS_API
 import org.jetbrains.kotlinx.dataframe.util.PARSER_OPTIONS
 import org.jetbrains.kotlinx.dataframe.util.PARSER_OPTIONS_COPY
 import java.time.format.DateTimeFormatter
 import java.util.Locale
 import kotlin.reflect.KProperty
 import kotlin.reflect.KType
-import kotlin.reflect.typeOf
 import kotlin.uuid.ExperimentalUuidApi
 import kotlin.uuid.Uuid
 
@@ -327,13 +325,8 @@ public fun DataColumn<String?>.tryParse(options: ParserOptions? = null): DataCol
  * @return a new column with parsed values
  */
 @JvmName("tryParseChar")
-public fun DataColumn<Char?>.tryParse(options: ParserOptions? = null): DataColumn<*> {
-    // skip the Char parser, as we're trying to parse away from Char
-    val providedSkipTypes = options?.skipTypes ?: DataFrame.parser.skipTypes
-    val parserOptions = (options ?: ParserOptions()).copy(skipTypes = providedSkipTypes + typeOf<Char>())
-
-    return map { it?.toString() }.tryParse(parserOptions)
-}
+public fun DataColumn<Char?>.tryParse(options: ParserOptions? = null): DataColumn<*> =
+    map { it?.toString() }.tryParseImpl(options)
 
 public fun <T> DataFrame<T>.parse(options: ParserOptions? = null): DataFrame<T> =
     parse(options) {
@@ -356,15 +349,16 @@ public fun <T> DataFrame<T>.parse(options: ParserOptions? = null): DataFrame<T>
  * @return a new column with parsed values
  */
 public fun DataColumn<String?>.parse(options: ParserOptions? = null): DataColumn<*> =
-    tryParse(options).also { if (it.typeClass == String::class) error("Can't guess column type") }
+    tryParse(options).also { if (it.isSubtypeOf<String?>()) error("Can't guess column type") }
 
 /**
  * Tries to parse a column of chars as strings into a column of a different type.
  * Each parser in [Parsers] is run in order until a valid parser is found,
  * a.k.a. that parser was able to parse all values in the column successfully. If a parser
  * fails to parse any value, the next parser is tried.
  *
- * If all fail, the column is returned as `String`, this can never fail.
+ * If all fail [IllegalStateException] is thrown. If you don't want this exception to be thrown,
+ * use [tryParse] instead.
  *
  * Parsers that are [covered by][StringParser.coveredBy] other parsers are skipped.
  *
@@ -373,7 +367,9 @@ public fun DataColumn<String?>.parse(options: ParserOptions? = null): DataColumn
  */
 @JvmName("parseChar")
 public fun DataColumn<Char?>.parse(options: ParserOptions? = null): DataColumn<*> =
-    tryParse(options) // no need to throw an exception, as Char can always be parsed as String
+    map { it?.toString() }
+        .tryParse(options)
+        .also { if (it.isSubtypeOf<Char?>() || it.isSubtypeOf<String?>()) error("Can't guess column type") }
 
 @JvmName("parseAnyFrameNullable")
 public fun DataColumn<AnyFrame?>.parse(options: ParserOptions? = null): DataColumn<AnyFrame?> =

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

@@ -230,6 +230,8 @@ internal fun getConverter(from: KType, to: KType, options: ParserOptions? = null
 
 internal typealias TypeConverter = (Any) -> Any?
 
+private val TypeConverterIdentity: TypeConverter = { it }
+
 internal fun Any.convertTo(type: KType): Any? {
     val clazz = javaClass.kotlin
     if (clazz.isSubclassOf(type.jvmErasure)) return this
@@ -242,6 +244,7 @@ internal inline fun <T> convert(crossinline converter: (T) -> Any?): TypeConvert
 
 private enum class DummyEnum
 
+@Suppress("UNCHECKED_CAST")
 internal fun createConverter(from: KType, to: KType, options: ParserOptions? = null): TypeConverter? {
     if (from.arguments.isNotEmpty() || to.arguments.isNotEmpty()) return null
     if (from.isMarkedNullable) {
@@ -250,25 +253,24 @@ internal fun createConverter(from: KType, to: KType, options: ParserOptions? = n
     }
     val fromClass = from.jvmErasure
     val toClass = to.jvmErasure
+    return when {
+        fromClass == toClass -> TypeConverterIdentity
 
-    if (fromClass == toClass) return { it }
-
-    if (toClass.isValue) {
-        val constructor =
-            toClass.primaryConstructor ?: error("Value type $toClass doesn't have primary constructor")
-        val underlyingType = constructor.parameters.single().type
-        val converter = getConverter(from, underlyingType)
-            ?: throw TypeConverterNotFoundException(from, underlyingType, null)
-        return convert<Any> {
-            val converted = converter(it)
-            if (converted == null && !underlyingType.isMarkedNullable) {
-                throw TypeConversionException(it, from, underlyingType, null)
+        toClass.isValue -> {
+            val constructor =
+                toClass.primaryConstructor ?: error("Value type $toClass doesn't have primary constructor")
+            val underlyingType = constructor.parameters.single().type
+            val converter = getConverter(from, underlyingType)
+                ?: throw TypeConverterNotFoundException(from, underlyingType, null)
+            return convert<Any> {
+                val converted = converter(it)
+                if (converted == null && !underlyingType.isMarkedNullable) {
+                    throw TypeConversionException(it, from, underlyingType, null)
+                }
+                constructor.call(converted)
             }
-            constructor.call(converted)
         }
-    }
 
-    return when {
         fromClass == String::class -> {
             val parser = Parsers[to.withNullability(false)]
             when {

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

@@ -45,8 +45,10 @@ import org.jetbrains.kotlinx.dataframe.schema.ColumnSchema
 import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
 import org.jetbrains.kotlinx.dataframe.size
 import kotlin.reflect.KType
+import kotlin.reflect.full.isSubtypeOf
 import kotlin.reflect.full.withNullability
 import kotlin.reflect.jvm.jvmErasure
+import kotlin.reflect.typeOf
 
 private val logger = KotlinLogging.logger {}
 
@@ -144,6 +146,25 @@ internal fun AnyFrame.convertToImpl(
                         val from = originalColumn.type()
                         val to = targetSchema.type
                         val converter = dsl.getConverter(from, targetSchema)
+                            ?: run {
+                                // Special case for Char columns:
+                                // If there is no explicit Char converter,
+                                // check if we have any converters for String -> target
+                                // if so, we can convert Char -> String -> target
+                                // this allows `parser {}` to work both for Strings and Chars :)
+
+                                if (!from.isSubtypeOf(typeOf<Char?>())) return@run null
+
+                                val stringConverter = dsl.getConverter(
+                                    fromType = typeOf<String>().withNullability(from.isMarkedNullable),
+                                    toSchema = targetSchema,
+                                ) ?: return@run null
+
+                                Converter(
+                                    transform = { stringConverter.transform(this, (it as Char?)?.toString()) },
+                                    skipNulls = stringConverter.skipNulls,
+                                )
+                            }
 
                         val convertedColumn = if (converter != null) {
                             val nullsAllowed = to.isMarkedNullable

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

@@ -730,6 +730,10 @@ internal fun <T> DataFrame<T>.parseImpl(options: ParserOptions?, columns: Column
                     .asColumnGroup(col.name())
                     .asDataColumn()
 
+            // Base case, parse the column if it's a `Char?` column
+            col.isSubtypeOf<Char?>() ->
+                col.map { it?.toString() }.tryParseImpl(options)
+
             // Base case, parse the column if it's a `String?` column
             col.isSubtypeOf<String?>() ->
                 col.cast<String?>().tryParseImpl(options)

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

@@ -51,6 +51,38 @@ class ConvertToTests {
         df.convertTo<Schema> { parser { A(it.toInt()) } }
             .single()
             .a.value shouldBe 1
+
+        // shortcut for:
+        df.convertTo<Schema> { convert<String>().with { A(it.toInt()) } }
+            .single()
+            .a.value shouldBe 1
+    }
+
+    @Test
+    fun `convert from char with parser`() {
+        val df = dataFrameOf("a")('1')
+
+        shouldThrow<TypeConverterNotFoundException> {
+            df.convertTo<Schema>()
+        }
+
+        // Char -> String -> Target
+        df.convertTo<Schema> { parser { A(it.toInt()) } }
+            .single()
+            .a.value shouldBe 1
+
+        // shortcut for:
+        df.convertTo<Schema> { convert<String>().with { A(it.toInt()) } }
+            .single()
+            .a.value shouldBe 1
+
+        // Char -> Target
+        df.convertTo<Schema> {
+            parser<A> { error("should not be triggered if convert<Char>() is present") }
+            convert<String>().with<_, A> { error("should not be triggered if convert<Char>() is present") }
+
+            convert<Char>().with { A(it.digitToInt()) }
+        }.single().a.value shouldBe 1
     }
 
     @Test
@@ -335,4 +367,31 @@ class ConvertToTests {
             DataFrame.emptyOf<Entry>(),
         )
     }
+
+    enum class SimpleEnum { A, B }
+
+    @DataSchema
+    interface SchemaWithNullableEnum {
+        val a: SimpleEnum?
+    }
+
+    @Test
+    fun `convert Char to Enum`() {
+        val df = dataFrameOf("a")('A', 'B', null)
+
+        val converted = df.convertTo<SchemaWithNullableEnum>()
+        converted["a"].type() shouldBe typeOf<SimpleEnum?>()
+        converted shouldBe dataFrameOf("a")(SimpleEnum.A, SimpleEnum.B, null)
+    }
+
+    @Test
+    fun `convert Char to Enum custom charParser`() {
+        val df = dataFrameOf("a")('a', 'b', null)
+
+        val converted = df.convertTo<SchemaWithNullableEnum> {
+            parser { SimpleEnum.valueOf(it.uppercase()) }
+        }
+        converted["a"].type() shouldBe typeOf<SimpleEnum?>()
+        converted shouldBe dataFrameOf("a")(SimpleEnum.A, SimpleEnum.B, null)
+    }
 }

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

@@ -1,5 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
+import io.kotest.assertions.throwables.shouldThrow
 import io.kotest.matchers.should
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.shouldNotBe
@@ -42,9 +43,10 @@ class ParseTests {
     @Test
     fun `parse to chars`() {
         val char = columnOf('a', 'b', 'c')
-        char.parse() shouldBe char
+        shouldThrow<IllegalStateException> { char.parse() }
         char.tryParse() shouldBe char
         char.convertToString().parse() shouldBe char
+        char.convertToString().tryParse() shouldBe char
     }
 
     @Test

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

@@ -3,6 +3,7 @@
 package org.jetbrains.kotlinx.dataframe.samples.api
 
 import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.AnyFrame
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.alsoDebug
@@ -1100,11 +1101,17 @@ class Modify : TestBase() {
     @TransformDataFrameExpressions
     fun customConverters() {
         // SampleStart
-        val df = dataFrameOf("a", "b")(1, "2")
+        val df: AnyFrame = dataFrameOf(
+            "a" to columnOf(1, 2, 3),
+            "b" to columnOf("1", "2", "3"),
+        )
         df.convertTo<MySchema> {
-            convert<Int>().with { MyType(it) } // converts `a` from Int to MyType
-            parser { MyType(it.toInt()) } // converts `b` from String to MyType
-            fill { c }.with { a.value + b.value } // computes missing column `c`
+            // providing the converter: Int -> MyType, so column `a` can be converted
+            convert<Int>().with { MyType(it) }
+            // providing the parser: String -> MyType, so column `b` can be converted
+            parser { MyType(it.toInt()) }
+            // providing the filler for `c`, as it's missing in `df`
+            fill { c }.with { a.value + b.value }
         }
         // SampleEnd
     }