Automated commit of generated code

Author: github-actions[bot]

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

@@ -587,7 +587,7 @@ public inline fun <T, C, reified R> Convert<T, C>.with(
  * df.convert { name }.asFrame { it.add("fullName") { "$firstName $lastName" } }
  * ```
  *
- * @param [expression] The [Data Frame Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenDataFrame.DataFrameExpression] to replace the selected column group with.
+ * @param [expression] The [DataFrame Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenDataFrame.DataFrameExpression] to replace the selected column group with.
  */
 @Refine
 @Interpretable("ConvertAsFrame")

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

@@ -168,12 +168,12 @@ public fun <C> ColumnMatch(left: ColumnReference<C>, right: ColumnReference<C>):
 public typealias JoinColumnsSelector<A, B> = JoinDsl<A, B>.(ColumnsContainer<A>) -> ColumnsResolver<*>
 
 public enum class JoinType {
-    Left, // all data from left data frame, nulls for mismatches in right data frame
-    Right, // all data from right data frame, nulls for mismatches in left data frame
-    Inner, // only matched data from right and left data frame
-    Filter, // only matched data from left data frame
-    Full, // all data from left and from right data frame, nulls for any mismatches
-    Exclude, // mismatched rows from left data frame
+    Left, // all data from left dataframe, nulls for mismatches in right dataframe
+    Right, // all data from right dataframe, nulls for mismatches in left dataframe
+    Inner, // only matched data from right and left dataframe
+    Filter, // only matched data from left dataframe
+    Full, // all data from left and from right dataframe, nulls for any mismatches
+    Exclude, // mismatched rows from left dataframe
 }
 
 internal val JoinType.addNewColumns: Boolean

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

@@ -496,13 +496,13 @@ public inline fun <T, C, R : C?> Update<T, C>.with(crossinline expression: Updat
  *
  * Updates selected [column group][ColumnGroup] as a [DataFrame] with the given [expression].
  *
- * Provide a new value for every selected data frame using a [dataframe expression][org.jetbrains.kotlinx.dataframe.DataFrameExpression].
+ * Provide a new value for every selected dataframe using a [dataframe expression][org.jetbrains.kotlinx.dataframe.DataFrameExpression].
  *
  * For example:
  *
  * `df.`[update][update]` { name }.`[asFrame][asFrame]` { `[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { lastName } }`
  *
- * @param [expression] The [Data Frame Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenDataFrame.DataFrameExpression] to replace the selected column group with.
+ * @param [expression] The [DataFrame Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenDataFrame.DataFrameExpression] to replace the selected column group with.
  */
 public fun <T, C, R> Update<T, DataRow<C>>.asFrame(expression: DataFrameExpression<C, DataFrame<R>>): DataFrame<T> =
     asFrameImpl(expression)

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt

@@ -3,9 +3,9 @@ package org.jetbrains.kotlinx.dataframe.documentation
 /**
  * ## Access APIs
  *
- * By nature, data frames are dynamic objects, column labels depend on the input source and also new columns could be added
+ * By nature, dataframes are dynamic objects, column labels depend on the input source and also new columns could be added
  * or deleted while wrangling. Kotlin, in contrast, is a statically typed language and all types are defined and verified
- * ahead of execution. That's why creating a flexible, handy, and, at the same time, safe API to a data frame is tricky.
+ * ahead of execution. That's why creating a flexible, handy, and, at the same time, safe API to a dataframe is tricky.
  *
  * In `Kotlin DataFrame` we provide four different ways to access columns, and, while they're essentially different, they
  * look pretty similar in the data wrangling DSL. These include:

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

@@ -105,34 +105,34 @@ internal fun <A, B> DataFrame<A>.joinImpl(
             leftCol.path to allRightJoinColumns[colNumber].path
         }.toMap()
 
-    // compute pairs of join key to row index from right data frame
+    // compute pairs of join key to row index from right dataframe
     val rightJoinKeyToIndex = other
         .indices()
         .map { index -> allRightJoinColumns.map { it.data[index] } to index }
 
-    // group row indices by key from right data frame
+    // group row indices by key from right dataframe
     val groupedRight = when (joinType) {
         JoinType.Exclude -> rightJoinKeyToIndex.associate { it.first to emptyList() }
         else -> rightJoinKeyToIndex.groupBy({ it.first }) { it.second }
     }
 
     var outputRowsCount = 0
 
-    // for every row index from left data frame compute a list of matched indices from right data frame
+    // for every row index from left dataframe compute a list of matched indices from right dataframe
     val leftToRightMapping = indices.map { leftIndex ->
         val leftKey = allLeftJoinColumns.map { it.data[leftIndex] }
         val rightIndices = groupedRight[leftKey]
         outputRowsCount += rightIndices?.size ?: if (joinType.allowRightNulls) 1 else 0
         rightIndices
     }
 
-    // for every row index in right data frame store a flag indicating whether this row was matched by some row in left data frame
+    // for every row index in right dataframe store a flag indicating whether this row was matched by some row in left dataframe
     val rightMatched = BooleanArray(other.nrow) { false }
 
-    // number of rows in right data frame that were not matched by any row in left data frame. Used for correct allocation of an output array
+    // number of rows in right dataframe that were not matched by any row in left dataframe. Used for correct allocation of an output array
     var rightUnmatchedCount = other.nrow
 
-    // compute matched indices from right data frame and number of rows in output data frame
+    // compute matched indices from right dataframe and number of rows in output dataframe
     if (joinType.allowLeftNulls) {
         leftToRightMapping.forEach { rightIndices ->
             rightIndices?.forEach { i ->

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/ReplCodeGeneratorImpl.kt

@@ -59,12 +59,12 @@ internal class ReplCodeGeneratorImpl : ReplCodeGenerator {
                 ?.takeIf { it.findAnnotation<DataSchema>() != null }
                 ?.let { registeredMarkers[it] ?: MarkersExtractor.get(it) }
             if (currentMarker != null) {
-                // we need to make sure that the property's marker type is open in order to let derived data frames be assignable to it
+                // we need to make sure that the property's marker type is open in order to let derived dataframes be assignable to it
                 if (currentMarker.isOpen) {
                     val columnSchema = currentMarker.schema
-                    // for mutable properties we do strong typing only at the first processing, after that we allow its type to be more general than actual data frame type
+                    // for mutable properties we do strong typing only at the first processing, after that we allow its type to be more general than actual dataframe type
                     if (wasProcessedBefore || columnSchema == targetSchema) {
-                        // property scheme is valid for current data frame, but we should also check that all compatible open markers are implemented by it
+                        // property scheme is valid for current dataframe, but we should also check that all compatible open markers are implemented by it
                         val requiredBaseMarkers = registeredMarkers.values.filterRequiredForSchema(columnSchema)
                         if (requiredBaseMarkers.any() && requiredBaseMarkers.all { currentMarker.implements(it) }) {
                             return CodeWithTypeCastGenerator.EMPTY

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/SchemaReader.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
 import java.net.URL
 
 /**
- * Reader that can read a data frame from a URL. It tries to guess the format based on the given [formats] and returns
+ * Reader that can read a dataframe from a URL. It tries to guess the format based on the given [formats] and returns
  * [DfReadResult.Success], or returns [DfReadResult.Error] if it fails.
  */
 public val CodeGenerator.Companion.urlDfReader: (url: URL, formats: List<SupportedFormat>) -> DfReadResult

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/string.kt

@@ -32,7 +32,7 @@ internal fun AnyFrame.renderToString(
 
     // title
     if (title) {
-        sb.appendLine("Data Frame [${size()}]")
+        sb.appendLine("DataFrame [${size()}]")
         sb.appendLine()
     }
 

core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeGenerationTests.kt

@@ -153,7 +153,7 @@ class CodeGenerationTests : BaseTest() {
     }
 
     @Test
-    fun `generate marker interface for nested data frame`() {
+    fun `generate marker interface for nested dataframe`() {
         val property = ::df
         val grouped = df.move { name and city }.under("nameAndCity")
         val generated = ReplCodeGenerator.create().process(grouped, property)

core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ShortNamesRenderingTest.kt

@@ -77,7 +77,7 @@ internal class ShortNamesRenderingTest : TypeRenderingStrategy by ShortNames {
     }
 
     @Test
-    fun `data frame`() {
+    fun `dataframe`() {
         fields.keys.asClue {
             fields["f"]!!.renderAccessorFieldType() shouldBe
                 "DataFrame<org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.Marker>"
@@ -125,7 +125,7 @@ internal class ShortNamesRenderingTest : TypeRenderingStrategy by ShortNames {
     }
 
     @Test
-    fun `data frame column`() {
+    fun `dataframe column`() {
         fields.keys.asClue {
             fields["f"]!!.renderColumnType() shouldBe
                 "DataColumn<DataFrame<org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.Marker>>"