\n "
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"USE {\n",
" repositories {\n",
" // Any additional repositories. Maven central is already included\n",
" // maven(\"
\")\n",
" }\n",
" dependencies {\n",
" // Here we add kandy plotting library\n",
" implementation(\"org.jetbrains.kotlinx:kandy-lets-plot:0.4.3\")\n",
" }\n",
"\n",
" // Sometimes library integration are loaded transitively and you don't want them to do it.\n",
" discardIntegrationTypeNameIf {\n",
" it.startsWith(\"org.jetbrains.kotlinx.dataframe.\")\n",
" }\n",
"}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Renderers and other integration features\n",
"\n",
"Let's try to conduct an experiment: we'll throw 50 dices and count the sum of points on them.\n",
"Then, we'll repeat this experiment some reasonable number of times and plot the distribution using kandy library we've just loaded."
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:25:45.532895800Z",
"start_time": "2023-07-01T16:25:41.881901100Z"
}
},
"outputs": [
{
"data": {
"text/html": " \n \n \n \n ",
"application/plot+json": {
"output_type": "lets_plot_spec",
"output": {
"mapping": {},
"data": {
"x": [
124.0,
127.0,
128.0,
129.0,
130.0,
131.0,
132.0,
133.0,
134.0,
135.0,
136.0,
137.0,
138.0,
139.0,
140.0,
141.0,
142.0,
143.0,
144.0,
145.0,
146.0,
147.0,
148.0,
149.0,
150.0,
151.0,
152.0,
153.0,
154.0,
155.0,
156.0,
157.0,
158.0,
159.0,
160.0,
161.0,
162.0,
163.0,
164.0,
165.0,
166.0,
167.0,
168.0,
169.0,
170.0,
171.0,
172.0,
173.0,
174.0,
175.0,
176.0,
177.0,
178.0,
179.0,
180.0,
181.0,
182.0,
183.0,
184.0,
185.0,
186.0,
187.0,
188.0,
189.0,
190.0,
191.0,
192.0,
193.0,
194.0,
195.0,
196.0,
197.0,
198.0,
199.0,
200.0,
201.0,
202.0,
203.0,
204.0,
205.0,
206.0,
207.0,
208.0,
209.0,
210.0,
211.0,
212.0,
213.0,
214.0,
215.0,
216.0,
217.0,
218.0,
219.0,
220.0,
221.0,
222.0,
223.0,
226.0,
228.0
],
"y": [
1.0,
1.0,
2.0,
5.0,
1.0,
2.0,
7.0,
7.0,
2.0,
16.0,
13.0,
29.0,
30.0,
33.0,
40.0,
49.0,
77.0,
102.0,
116.0,
179.0,
178.0,
235.0,
266.0,
327.0,
359.0,
453.0,
567.0,
675.0,
705.0,
870.0,
928.0,
1051.0,
1230.0,
1353.0,
1496.0,
1765.0,
1852.0,
2041.0,
2244.0,
2324.0,
2381.0,
2687.0,
2763.0,
2935.0,
3074.0,
3045.0,
3262.0,
3193.0,
3239.0,
3263.0,
3222.0,
3241.0,
3177.0,
3150.0,
3113.0,
2834.0,
2838.0,
2666.0,
2449.0,
2421.0,
2223.0,
2066.0,
1830.0,
1706.0,
1597.0,
1424.0,
1226.0,
1066.0,
958.0,
816.0,
716.0,
643.0,
532.0,
495.0,
385.0,
322.0,
272.0,
245.0,
164.0,
143.0,
128.0,
101.0,
93.0,
58.0,
63.0,
37.0,
16.0,
23.0,
15.0,
13.0,
10.0,
9.0,
4.0,
5.0,
6.0,
2.0,
1.0,
1.0,
1.0,
1.0
]
},
"kind": "plot",
"scales": [
{
"aesthetic": "x",
"limits": [
null,
null
]
},
{
"aesthetic": "y",
"limits": [
null,
null
]
}
],
"layers": [
{
"mapping": {
"x": "x",
"y": "y"
},
"stat": "identity",
"sampling": "none",
"position": "dodge",
"geom": "bar"
}
]
},
"apply_color_scheme": true,
"swing_enabled": true
}
},
"execution_count": 25,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import kotlin.random.Random\n",
"\n",
"fun diceNTimesSum(n: Int): Int {\n",
" return (1..n).sumOf { Random.nextInt(1, 7) }\n",
"}\n",
"\n",
"val experimentData = (1..100000).map { diceNTimesSum(50) }.groupBy { it }.mapValues { it.value.size }.entries.sortedBy { it.key }\n",
"val experimentX = experimentData.map { it.key }\n",
"val experimentY = experimentData.map { it.value }\n",
"\n",
"val gaussPlot = plot {\n",
" bars {\n",
" x(experimentX)\n",
" y(experimentY)\n",
" }\n",
"}\n",
"gaussPlot"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:25:46.133896700Z",
"start_time": "2023-07-01T16:25:45.479975700Z"
}
},
"outputs": [
{
"data": {
"text/plain": "class org.jetbrains.kotlinx.kandy.ir.Plot"
},
"execution_count": 26,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"gaussPlot::class"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As you can see kandy's `Plot` object was rendered to some image. That's because `kandy` library defines a **renderer** for this type of objects. We also can define renderers ourselves."
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:03.095894200Z",
"start_time": "2023-07-01T16:25:45.742906200Z"
}
},
"outputs": [],
"source": [
"%use dataframe"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:03.180935500Z",
"start_time": "2023-07-01T16:26:02.956908Z"
}
},
"outputs": [
{
"data": {
"text/plain": "Line_23_jupyter$User@26989de3"
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"val bob = User(\"Bob\", \"Brown\")\n",
"bob"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"`User` isn't a data class, that's why it was rendered this way."
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:04.125939100Z",
"start_time": "2023-07-01T16:26:03.111033100Z"
}
},
"outputs": [],
"source": [
"USE {\n",
" // Match is based on runtime type here, beware of type erasure\n",
" render { listOf(it).toDataFrame() }\n",
"}"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:04.212895400Z",
"start_time": "2023-07-01T16:26:03.492908100Z"
}
},
"outputs": [
{
"data": {
"text/html": " \n ",
"application/kotlindataframe+json": "{\"nrow\":1,\"ncol\":2,\"columns\":[\"firstName\",\"lastName\"],\"kotlin_dataframe\":[{\"firstName\":\"Bob\",\"lastName\":\"Brown\"}]}"
},
"execution_count": 30,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"bob"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can also use full syntax for defining renderers. It's verbose but let you do many things"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:04.348896900Z",
"start_time": "2023-07-01T16:26:03.831944200Z"
}
},
"outputs": [],
"source": [
"class User2(val name: String)"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:05.346896200Z",
"start_time": "2023-07-01T16:26:03.935910Z"
}
},
"outputs": [],
"source": [
"USE {\n",
" addRenderer(object : RendererHandler {\n",
" override fun replaceVariables(mapping: Map): RendererHandler {\n",
" return this\n",
" }\n",
"\n",
" override val execution: ResultHandlerExecution\n",
" get() = ResultHandlerExecution { host, res ->\n",
" FieldValue(\"Value of ${res.name} is a user with name ${(res.value as User2).name}\", null)\n",
" }\n",
"\n",
" override fun accepts(value: Any?): Boolean {\n",
" return value != null && value::class == User2::class\n",
" }\n",
" })\n",
"}"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:05.785010200Z",
"start_time": "2023-07-01T16:26:04.733895900Z"
}
},
"outputs": [
{
"data": {
"text/plain": "Value of res42 is a user with name Felix"
},
"execution_count": 33,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"User2(\"Felix\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"What do the libraries bring except for dependencies and renderers? First of all, default imports.\n",
"These imports are implicitly added to all subsequent cells."
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:06.100904600Z",
"start_time": "2023-07-01T16:26:04.905012700Z"
}
},
"outputs": [],
"source": [
"fun loadFileFromGitHub(repositoryUrl: String, filePath: String): String {\n",
" val rawUrl = \"$repositoryUrl/raw/master/$filePath\"\n",
" val url = URL(rawUrl)\n",
" val connection = url.openConnection()\n",
" connection.setRequestProperty(\"Accept\", \"application/vnd.github.v3.raw\")\n",
"\n",
" val inputStream = connection.getInputStream()\n",
" val content = inputStream.bufferedReader().use { it.readText() }\n",
"\n",
" return content\n",
"}\n",
"\n",
"fun loadDescriptor(name: String) {\n",
" val text = loadFileFromGitHub(\"https://github.com/Kotlin/kotlin-jupyter-libraries\", \"$name.json\")\n",
" DISPLAY(MIME(\n",
" \"text/markdown\" to \"```json\\n$text```\"\n",
" ))\n",
"}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Notice `imports` section in the following descriptor:"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:06.711895700Z",
"start_time": "2023-07-01T16:26:05.632909600Z"
}
},
"outputs": [
{
"data": {
"text/markdown": "```json\n{\n \"link\": \"https://github.com/breandan/kaliningraph\",\n \"description\": \"Graph library with a DSL for constructing graphs and visualizing the behavior of graph algorithms\",\n \"dependencies\": [\n \"com.github.breandan:kaliningraph:0.1.4\"\n ],\n \"imports\": [\n \"edu.mcgill.kaliningraph.*\",\n \"edu.mcgill.kaliningraph.matrix.*\",\n \"edu.mcgill.kaliningraph.circuits.*\",\n \"org.ejml.data.*\",\n \"org.ejml.kotlin.*\"\n ],\n \"renderers\": {\n \"edu.mcgill.kaliningraph.LabeledGraph\": \"HTML(($it as edu.mcgill.kaliningraph.Graph<*, *, *>).html())\",\n \"edu.mcgill.kaliningraph.circuits.Gate\": \"HTML(($it as edu.mcgill.kaliningraph.circuits.Gate).graph.html())\",\n \"edu.mcgill.kaliningraph.circuits.NFunction\": \"HTML(($it as edu.mcgill.kaliningraph.circuits.NFunction).graph.html())\",\n \"edu.mcgill.kaliningraph.circuits.ComputationGraph\": \"HTML(($it as edu.mcgill.kaliningraph.Graph<*, *, *>).html())\",\n \"edu.mcgill.kaliningraph.matrix.BMat\": \"HTML(\\\"![](\\\\\\\"${($it)
\\\")\",\n \"edu.mcgill.kaliningraph.matrix.BSqMat\": \"HTML(\\\"\\\")\"\n }\n}\n```"
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"loadDescriptor(\"kaliningraph\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You might have noticed that almost every descriptor in `Kotlin/kotlin-jupyter-libraries` contains link and description.\n",
"They are used to build `:help` command output and [our README](https://github.com/Kotlin/kotlin-jupyter#list-of-supported-libraries)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Creating an integration"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"So, we learned the concept of the integration. It is a wrapper on top of the usual Kotlin library that simplifies and elevates the experience of using this library in the notebook.\n",
"Comprehensive guide to writing library integrations can be found [here](). To inspire you, there is an example of the `dataframe` integration below."
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:14.046897300Z",
"start_time": "2023-07-01T16:26:06.491895300Z"
}
},
"outputs": [],
"source": [
"%use dataframe"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:16.898989Z",
"start_time": "2023-07-01T16:26:14.024900100Z"
}
},
"outputs": [],
"source": [
"val df = DataFrame.read(\"https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's try to investigate the data that we have just read."
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:17.314907100Z",
"start_time": "2023-07-01T16:26:16.825895800Z"
}
},
"outputs": [
{
"data": {
"text/html": " \n ",
"application/kotlindataframe+json": "{\"nrow\":150,\"ncol\":1,\"columns\":[\"petal_length\"],\"kotlin_dataframe\":[{\"petal_length\":1.4},{\"petal_length\":1.4},{\"petal_length\":1.3},{\"petal_length\":1.5},{\"petal_length\":1.4},{\"petal_length\":1.7},{\"petal_length\":1.4},{\"petal_length\":1.5},{\"petal_length\":1.4},{\"petal_length\":1.5},{\"petal_length\":1.5},{\"petal_length\":1.6},{\"petal_length\":1.4},{\"petal_length\":1.1},{\"petal_length\":1.2},{\"petal_length\":1.5},{\"petal_length\":1.3},{\"petal_length\":1.4},{\"petal_length\":1.7},{\"petal_length\":1.5}]}"
},
"execution_count": 38,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"df.petal_length"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:19.919905400Z",
"start_time": "2023-07-01T16:26:17.097895900Z"
}
},
"outputs": [
{
"data": {
"text/html": " \n ",
"application/kotlindataframe+json": "{\"nrow\":1,\"ncol\":5,\"columns\":[\"sepal_length\",\"sepal_width\",\"petal_length\",\"petal_width\",\"species\"],\"kotlin_dataframe\":[{\"sepal_length\":5.9,\"sepal_width\":3.0,\"petal_length\":4.2,\"petal_width\":1.5,\"species\":\"versicolor\"}]}"
},
"execution_count": 39,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"df.filter { petal_width >= 1.5 && petal_length < 4.5 }"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"There is also a special variable in the integration to manage display options. For example, we can limit number of displayed rows."
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:20.048901400Z",
"start_time": "2023-07-01T16:26:17.569046600Z"
}
},
"outputs": [],
"source": [
"dataFrameConfig.display.rowsLimit = 5"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:20.813895800Z",
"start_time": "2023-07-01T16:26:17.765896100Z"
}
},
"outputs": [
{
"data": {
"text/html": " \n ",
"application/kotlindataframe+json": "{\"nrow\":150,\"ncol\":5,\"columns\":[\"sepal_length\",\"sepal_width\",\"petal_length\",\"petal_width\",\"species\"],\"kotlin_dataframe\":[{\"sepal_length\":5.1,\"sepal_width\":3.5,\"petal_length\":1.4,\"petal_width\":0.2,\"species\":\"setosa\"},{\"sepal_length\":4.9,\"sepal_width\":3.0,\"petal_length\":1.4,\"petal_width\":0.2,\"species\":\"setosa\"},{\"sepal_length\":4.7,\"sepal_width\":3.2,\"petal_length\":1.3,\"petal_width\":0.2,\"species\":\"setosa\"},{\"sepal_length\":4.6,\"sepal_width\":3.1,\"petal_length\":1.5,\"petal_width\":0.2,\"species\":\"setosa\"},{\"sepal_length\":5.0,\"sepal_width\":3.6,\"petal_length\":1.4,\"petal_width\":0.2,\"species\":\"setosa\"}]}"
},
"execution_count": 41,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"df"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's now see what's happening there under the hood. First, we enable debugging logging that will print the code that is executed under the hood."
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:20.826898500Z",
"start_time": "2023-07-01T16:26:17.976898300Z"
}
},
"outputs": [],
"source": [
"%trackExecution"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Then, we define some other dataframe."
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:22.598896Z",
"start_time": "2023-07-01T16:26:18.109896400Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Executing:\n",
"val df1 = dataFrameOf(\"A\", \"B\", \"C\")(1, \"Str1\", null, 2, \"Str2\", 3)\n",
"\r\n",
"Executing:\n",
"@DataSchema\n",
"interface _DataFrameType1\n",
"\n",
"val ColumnsContainer<_DataFrameType1>.A: DataColumn @JvmName(\"_DataFrameType1_A\") get() = this[\"A\"] as DataColumn\n",
"val DataRow<_DataFrameType1>.A: Int @JvmName(\"_DataFrameType1_A\") get() = this[\"A\"] as Int\n",
"val ColumnsContainer<_DataFrameType1?>.A: DataColumn @JvmName(\"Nullable_DataFrameType1_A\") get() = this[\"A\"] as DataColumn\n",
"val DataRow<_DataFrameType1?>.A: Int? @JvmName(\"Nullable_DataFrameType1_A\") get() = this[\"A\"] as Int?\n",
"val ColumnsContainer<_DataFrameType1>.B: DataColumn @JvmName(\"_DataFrameType1_B\") get() = this[\"B\"] as DataColumn\n",
"val DataRow<_DataFrameType1>.B: String @JvmName(\"_DataFrameType1_B\") get() = this[\"B\"] as String\n",
"val ColumnsContainer<_DataFrameType1?>.B: DataColumn @JvmName(\"Nullable_DataFrameType1_B\") get() = this[\"B\"] as DataColumn\n",
"val DataRow<_DataFrameType1?>.B: String? @JvmName(\"Nullable_DataFrameType1_B\") get() = this[\"B\"] as String?\n",
"val ColumnsContainer<_DataFrameType1>.C: DataColumn @JvmName(\"_DataFrameType1_C\") get() = this[\"C\"] as DataColumn\n",
"val DataRow<_DataFrameType1>.C: Int? @JvmName(\"_DataFrameType1_C\") get() = this[\"C\"] as Int?\n",
"val ColumnsContainer<_DataFrameType1?>.C: DataColumn @JvmName(\"Nullable_DataFrameType1_C\") get() = this[\"C\"] as DataColumn\n",
"val DataRow<_DataFrameType1?>.C: Int? @JvmName(\"Nullable_DataFrameType1_C\") get() = this[\"C\"] as Int?\n",
"df1.cast<_DataFrameType1>()\r\n",
"Executing:\n",
"val df1 = res54\r\n"
]
}
],
"source": [
"val df1 = dataFrameOf(\"A\", \"B\", \"C\")(1, \"Str1\", null, 2, \"Str2\", 3)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As you can see, a marker interface `_DataFrameType1` is created and property accessors are generated for it. Let's check what's the type of `df1` now:"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:22.896913600Z",
"start_time": "2023-07-01T16:26:19.412895300Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Executing:\n",
"::df1\n",
"\r\n"
]
},
{
"data": {
"text/plain": "val Line_55_jupyter.df1: org.jetbrains.kotlinx.dataframe.DataFrame"
},
"execution_count": 44,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"::df1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"So, `df1` now is not simply a `DataFrame<*>`, it's `DataFrame<_DataFrameType1>`. That's exactly what allows us to statically resolve defined property accessors on it."
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:22.899897600Z",
"start_time": "2023-07-01T16:26:19.694009700Z"
}
},
"outputs": [],
"source": [
"%trackExecution off"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"API that DataFrame uses to achieve all of these is open, and you can try it yourself! The code of the integration is available [here](https://github.com/Kotlin/dataframe/blob/master/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/Integration.kt)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Inter-cell API"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To use Kotlin Notebook API you don't necessarily need to create a separate file with integration. As it was shown above, you can place in `USE { }` call the same integration that you would\n",
"place in the standalone library or JSON descriptor. However, notebook offers API to get some information about the current notebook session and to set it up.\n",
"\n",
"The main entry point is `notebook`: it allows you to investigate what cells were already executed, what libraries were loaded, what renderers and variable processors are loaded and gives the ability to unload them.\n",
"Read the documentation of the `Notebook` interface for reliable and actual information about this API"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:23.056895600Z",
"start_time": "2023-07-01T16:26:19.711907100Z"
}
},
"outputs": [
{
"data": {
"text/plain": "> 2 + 2\n\n> val result = 3 * 14\n\n> result\n\n> (Out[3] as Int) / 2\n\n> val a1: Int = 1\nval a2: Int? = 2\nval a3: Int? = null\n"
},
"execution_count": 46,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"notebook.cellsList.take(5).map { \"> \" + it.code }.joinToString(\"\\n\")"
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:23.292899900Z",
"start_time": "2023-07-01T16:26:20.125896500Z"
}
},
"outputs": [
{
"data": {
"text/plain": "0.11.0.381"
},
"execution_count": 47,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"notebook.kernelVersion"
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:23.338896200Z",
"start_time": "2023-07-01T16:26:20.302896300Z"
}
},
"outputs": [
{
"data": {
"text/plain": "{0=[], 1=[result], 2=[result], 3=[result], 4=[a1, a3, result], -1=[___a2, a2, kandyConfig, dataFrameConfig, df, df1, height, width], 5=[result, a1, a2], 7=[result, a1, a2], 9=[result, a1, a2], 10=[kotlinMascot, result, a1, a2], 11=[result, a1, a2], 12=[result, a1, a2], 13=[graphics, height, image, width, result, a1, a2], 14=[result, a1, a2, height, width], 15=[a1, a2, height, width], 16=[a1, a2, height, width], 17=[a1, a2, height, width], 20=[a2, height, width], 21=[height, width], 22=[height, width], 23=[height, width], 24=[experimentData, experimentX, experimentY, gaussPlot, height, width], 25=[height, width], 27=[bob, height, width], 28=[height, width], 29=[height, width], 30=[height, width], 31=[height, width], 32=[height, width], 33=[height, width], 34=[height, width], 36=[height, width], 37=[height, width], 38=[height, width], 39=[height, width], 40=[height, width], 42=[height, width], 43=[height, width], 45=[height, width], 46=[height, width], 47=[height, width]}"
},
"execution_count": 48,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"notebook.cellVariables"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Also, a couple of options is available with `SessionOptions` object."
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:23.354896700Z",
"start_time": "2023-07-01T16:26:20.468007400Z"
}
},
"outputs": [
{
"data": {
"text/plain": "true"
},
"execution_count": 49,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"SessionOptions.resolveSources // could be switched off to speed up dependencies loading process"
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:23.377895300Z",
"start_time": "2023-07-01T16:26:20.696900200Z"
}
},
"outputs": [
{
"data": {
"text/plain": "false"
},
"execution_count": 50,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"SessionOptions.resolveMpp // could be switched on to resolve MPP libraries such as kotlinx-serialization from \"universal\" Maven coordinates"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Sharing the notebooks\n",
"\n",
"Essentially, Kotlin notebooks are Jupyter notebooks. It means they could be opened, edited and run with any Jupyter client such as [Jupyter Notebook](https://jupyter.org/),\n",
"[Jupyter Lab](https://jupyterlab.readthedocs.io/en/latest/) and [Datalore](https://www.jetbrains.com/datalore/). [We plan](https://youtrack.jetbrains.com/issue/KTNB-291/Datalore-Share-action) to integrate with Datalore better in the future.\n",
"The only limitation is that project dependencies will be not included into the notebook in other clients. However, you can build the logic based on Jupyter client type:"
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:23.386896200Z",
"start_time": "2023-07-01T16:26:20.915897500Z"
}
},
"outputs": [],
"source": [
"if (notebook.jupyterClientType != JupyterClientType.KOTLIN_NOTEBOOK) {\n",
" // load substitutive dependencies\n",
"}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Notebooks could be also loaded and viewed on GitHub (including gists). Limitation there is that JS isn't executed in the outputs.\n",
"To overcome it in `kandy`, we [add extra SVG output that is hidden from JS](https://github.com/Kotlin/kandy/blob/main/kandy-lets-plot/src/main/kotlin/org/jetbrains/kotlinx/kandy/letsplot/util/rendering.kt#L46).\n",
"\n",
"Kotlin Notebooks could be also converted to some other format using [nbconvert tool](https://nbconvert.readthedocs.io/en/latest/)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## What's next?\n",
"\n",
"Kotlin Notebook project is experimental and actively developed. Use the latest version of plugin to be in sync.\n",
"We eagerly need your stories and feedback: share them in the dedicated [#notebooks](https://kotlinlang.slack.com/archives/C05333T208Y) Slack channel or in our [issue tracker](https://youtrack.jetbrains.com/issues/KTNB).\n",
"\n",
"See you in the next cell!"
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {
"ExecuteTime": {
"end_time": "2023-07-01T16:26:23.388895Z",
"start_time": "2023-07-01T16:26:21.279905600Z"
}
},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Kotlin",
"language": "kotlin",
"name": "kotlin"
},
"ktnbPluginMetadata": {
"isAddProjectLibrariesToClasspath": false
},
"language_info": {
"codemirror_mode": "text/x-kotlin",
"file_extension": ".kt",
"mimetype": "text/x-kotlin",
"name": "kotlin",
"nbconvert_exporter": "",
"pygments_lexer": "kotlin",
"version": "1.8.20"
}
},
"nbformat": 4,
"nbformat_minor": 1
}
![](\"https://kotlinlang.org/docs/images/kotlin-logo.png\"){kind=logo}
"
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"Image(\"https://kotlinlang.org/docs/images/kotlin-logo.png\", embed = false).withWidth(300)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can also embed images. In this case they will stay in the notebook forever"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"text/html": "