Merge pull request #1714 from Kotlin/importDataSchema-fix1

`importDataSchema()` notebooks fix

Author: Jolanrensen

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/importDataSchema.kt

@@ -19,44 +19,3 @@ public fun importDataSchema(path: String): ImportDataSchema = ImportDataSchema(p
 public fun importDataSchema(path: Path): ImportDataSchema = ImportDataSchema(path)
 
 public fun importDataSchema(file: File): ImportDataSchema = ImportDataSchema(file)
-
-@Language("kts")
-internal val importDataSchema =
-    """
-    /** Import the type-only data schema from [url]. */
-    fun importDataSchema(url: URL, name: String) {
-        val formats = listOfNotNull(
-            if (dataFrameConfig.enableExperimentalOpenApi) OpenApi() else null,
-        )
-        
-        require(formats.isNotEmpty()) { 
-            "importDataSchema() did not find any supported type-only data schema generation providers (`SupportedCodeGenerationFormat`). If you were looking for OpenAPI 3.0.0 types, set `%use dataframe(..., enableExperimentalOpenApi=true)`." 
-        }   
-        
-        val codeGenResult = org.jetbrains.dataframe.impl.codeGen.CodeGenerator.urlCodeGenReader(url, formats)
-        when (codeGenResult) {
-            is org.jetbrains.kotlinx.dataframe.impl.codeGen.CodeGenerationReadResult.Success -> {
-                val readDfMethod = codeGenResult.getReadDfMethod(url.toExternalForm())
-                val code = readDfMethod.additionalImports.joinToString("\n") + 
-                    "\n" + 
-                    codeGenResult.code.converter(name)
-
-                EXECUTE(code)
-                DISPLAY("Data schema successfully imported as ${'$'}name")
-            }
-
-            is org.jetbrains.kotlinx.dataframe.impl.codeGen.CodeGenerationReadResult.Error -> {
-                DISPLAY("Failed to read data schema from ${'$'}url: ${'$'}{codeGenResult.reason}")
-            }
-        }
-    }
-
-    /** Import the type-only data schema from [path]. */
-    fun importDataSchema(path: String, name: String): Unit = importDataSchema(URI(path).toURL(), name)
-
-    /** Import the type-only data schema from [path]. */
-    fun importDataSchema(path: Path, name: String): Unit = importDataSchema(path.toUri().toURL(), name)
-
-    /** Import the type-only data schema from [file]. */
-    fun importDataSchema(file: File, name: String): Unit = importDataSchema(file.toURI().toURL(), name)
-    """.trimIndent()

dataframe-jdbc/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/Jdbc.kt

@@ -21,13 +21,10 @@ public class Jdbc :
         stream: InputStream,
         name: String,
         generateHelperCompanionObject: Boolean,
-    ): Code {
-        TODO("Not yet implemented")
-    }
+    ): Code = throw IllegalStateException("Jdbc.readCodeForGeneration() is not yet implemented: Issue #450")
 
-    override fun readCodeForGeneration(file: File, name: String, generateHelperCompanionObject: Boolean): Code {
-        TODO("Not yet implemented")
-    }
+    override fun readCodeForGeneration(file: File, name: String, generateHelperCompanionObject: Boolean): Code =
+        throw IllegalStateException("Jdbc.readCodeForGeneration() is not yet implemented: Issue #450")
 
     override fun acceptsExtension(ext: String): Boolean = ext == "jdbc"
 

dataframe-jupyter/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/Integration.kt

@@ -76,6 +76,9 @@ internal class Integration(private val notebook: Notebook, private val options:
         property: KProperty<*>,
     ): VariableName? {
         val formats = supportedFormats.filterIsInstance<SupportedCodeGenerationFormat>()
+        require(formats.isNotEmpty()) {
+            "importDataSchema() did not find any supported type-only data schema generation providers (`SupportedCodeGenerationFormat`). If you were looking for OpenAPI 3.0.0 types, set `%use dataframe(..., enableExperimentalOpenApi=true)`."
+        }
         val name = property.name + "DataSchema"
         return when (
             val codeGenResult = CodeGenerator.urlCodeGenReader(importDataSchema.url, name, formats, true)
@@ -87,14 +90,40 @@ internal class Integration(private val notebook: Notebook, private val options:
                     codeGenResult.code
 
                 execute(code)
-                execute("""DISPLAY("Data schema successfully imported as ${property.name}: $name")""")
+                display("Data schema successfully imported as ${property.name}: $name", null)
 
                 name
             }
 
             is CodeGenerationReadResult.Error -> {
-                execute(
-                    """DISPLAY("Failed to read data schema from ${importDataSchema.url}: ${codeGenResult.reason}")""",
+                display(
+                    buildString {
+                        appendLine(
+                            """
+                            Failed to read data schema from ${importDataSchema.url}.
+                            
+                            Cause: ${codeGenResult.reason},
+                            
+                            Available formats: ${formats.map { it::class.qualifiedName ?: it }}
+                            
+                            """.trimIndent(),
+                        )
+
+                        if (formats.none { it::class.simpleName?.lowercase()?.contains("openapi") == true }) {
+                            appendLine(
+                                "If you were looking for OpenAPI 3.0.0 types, set `%use dataframe(..., enableExperimentalOpenApi=true)`.",
+                            )
+                        }
+
+                        appendLine(
+                            """
+                                |
+                                |StackTrace:
+                                |${codeGenResult.reason.stackTrace.joinToString("\n|")}
+                            """.trimMargin(),
+                        )
+                    },
+                    null,
                 )
                 null
             }