git clone --recurse-submodules https://github.com/Kotlin/kotlin-jupyter.git
cd kotlin-jupyter
./gradlew install
Default installation path is ~/.ipython/kernels/kotlin/.
To install to some other location use option -PinstallPath=, but note that Jupyter
looks for the kernel specs files only in predefined places. For more detailed info
see Jupyter docs.
Uninstall: ./gradlew uninstall
Troubleshooting
There could be a problem with kernel spec detection because of different
python environments and installation modes. If you are using pip or conda
to install the package, try running post-install fixup script:
python -m kotlin_kernel fix-kernelspec-location
This script replaces kernel specs to the "user" path where they are always detected.
Don't forget to re-run this script on the kernel update.
Usage
jupyter console --kernel=kotlin
jupyter notebook
jupyter lab
To start using kotlin kernel inside Jupyter Notebook or JupyterLab create a new notebook with kotlin kernel.
The default kernel will use the JDK pointed to by the environment variable KOTLIN_JUPYTER_JAVA_HOME,
or JAVA_HOME if the first is not set.
JVM arguments will be set from the environment variable KOTLIN_JUPYTER_JAVA_OPTS or JAVA_OPTS if the first is not set.
Additionally, arguments from KOTLIN_JUPYTER_JAVA_OPTS_EXTRA will be added.
Arguments are parsed using shlex.split.
Creating Kernels
To create a kernel for a specific JDK, JVM arguments, and environment variables, you can use the add-kernel script:
The command uses argparse, so --help, @argfile (you will need to escape the @ in powershell), and --opt=value are all supported. --jvm-arg=arg in particular
is needed when passing JVM arguments that start with -.
If jdk not specified, name is required. If name is not specified but jdk is the name will be
JDK $vendor $version detected from the JDK. Regardless, the actual name of the kernel will be Kotlin ($name),
and the directory will be kotlin_$name with the spaces in name replaced by underscores
(so make sure it's compatible with your file system).
JVM arguments are joined with a ' ', so multiple JVM arguments in the same argument are supported.
The arguments will be added to existing ones (see above section) unless --set-jvm-args is present, in which case they
will be set to KOTLIN_JUPYTER_JAVA_OPTS. Note that both adding and setting work fine alongside KOTLIN_JUPYTER_JAVA_OPTS_EXTRA.
While jupyter kernel environment variable substitutions are supported in env, note that if the used environment
variable doesn't exist, nothing will be replaced.
It is possible to add dynamic dependencies to the notebook using the following annotations:
@file:DependsOn(<coordinates>) - adds artifacts to classpath. Supports absolute and relative paths to class
directories or jars, ivy and maven artifacts represented by the colon separated string
@file:Repository(<absolute-path>) - adds a directory for relative path resolution or ivy/maven repository.
To specify Maven local, use @file:Repository("*mavenLocal").
Note that dependencies in remote repositories are resolved via Ivy resolver.
Caches are stored in ~/.ivy2/cache folder by default. Sometimes, due to network
issues or running several artifacts resolutions in parallel, caches may get corrupted.
If you have some troubles with artifacts resolution, please remove caches, restart kernel
and try again.
Default repositories
The following maven repositories are included by default:
%use - injects code for supported libraries: artifact resolution, default imports, initialization code, type renderers. Usage example: %use klaxon(5.5), lets-plot
%trackClasspath - logs any changes of current classpath. Useful for debugging artifact resolution failures. Usage example: %trackClasspath [on|off]
%trackExecution - logs pieces of code that are going to be executed. Useful for debugging of libraries support. Usage example: %trackExecution [all|generated|off]
%useLatestDescriptors - use latest versions of library descriptors available. By default, bundled descriptors are used. Usage example: %useLatestDescriptors [on|off]
When a library is included with %use keyword, the following functionality is added to the notebook:
repositories to search for library artifacts
artifact dependencies
default imports
library initialization code
renderers for special types, e.g. charts and data frames
This behavior is defined by json library descriptor. Descriptors for all supported libraries can be found in libraries repository.
A library descriptor may provide a set of properties with default values that can be overridden when library is included.
The major use case for library properties is to specify a particular version of library. If descriptor has only one property, it can be
defined without naming:
%use krangl(0.10)
If library descriptor defines more than one property, property names should be used:
%use spark(scala=2.11.10, spark=2.4.2)
Several libraries can be included in single %use statement, separated by ,:
%use lets-plot, krangl, mysql(8.0.15)
You can also specify the source of library descriptor. By default, it's taken from the libraries repository. If you want to try descriptor from another revision, use the following syntax:
// Specify some git tag from this repository
%use [email protected]
// Specify commit sha, with more verbose syntax
%use lets-plot@ref[24a040fe22335648885b106e2f4ddd63b4d49469]
// Specify git ref along with library arguments
%use krangl@dev(0.10)
Other options are resolving library descriptor from a local file or from remote URL:
// Load library from file
%use mylib@file[/home/user/lib.json]
// Load library from file: kernel will guess it's a file actually
%use @/home/user/libs/lib.json
// Or use another approach: specify a directory and file name without
// extension (it should be JSON in such case) before it
%use lib@/home/user/libs
// Load library descriptor from a remote URL
%use herlib@url[https://site.com/lib.json]
// If your URL responds with 200(OK), you may skip `url[]` part:
%use @https://site.com/lib.json
// You may omit library name for file and URL resolution:
%use @file[lib.json]
smile - Statistical Machine Intelligence and Learning Engine
spark - Kotlin API for Apache Spark: unified analytics engine for large-scale data processing
spark-streaming - Kotlin API for Apache Spark Streaming: scalable, high-throughput, fault-tolerant stream processing of live data streams
Rich output
By default, the return values from REPL statements are displayed in the text form. To use richer representations, e.g.
to display graphics or html, it is possible to send MIME-encoded result to the client using the MIME helper function:
MIME("text/html" to "<p>Some <em>HTML</em></p>", "text/plain" to "No HTML for text clients")
HTML outputs can also be rendered with HTML helper function:
funHTML(text:String): MimeTypedResult
Autocompletion
Press TAB to get the list of suggested items for completion. In Jupyter Notebook, you don't need to press TAB,
completion is requested automatically. Completion works for all globally defined symbols and for local symbols
which were loaded into notebook during cells evaluation.
Error analysis
If you use Jupyter Notebook as Jupyter client, you will also see that compilation errors and warnings are underlined in
red and in yellow correspondingly. This is achieved by kernel-level extension of Jupyter notebook which sends
error-analysis requests to kernel and renders their results. If you hover the cursor over underlined text, you will get
an error message which can help you to fix the error.
Debugging
Run ./gradlew installDebug. Debugger port is selected automatically.
Default port is 1044, consequent ports will be used if it's in use. If you want an exact port, specify -PdebugPort=<port> Gradle option.
Run jupyter notebook, open the desired notebook.
Attach a remote debugger to JVM with corresponding port (debug port number will be printed in terminal on kernel startup).
Adding new libraries
Read this article if you want to support new JVM library in the kernel.
Documentation
There is a site with rendered KDoc comments from the codebase.
If you are a library author you may be interested in api module
(see adding new libraries). There is also a lib module which contains entities
available from the Notebook cells and shared-compiler module which may be used for Jupyter REPL integration
into standalone application or IDEA plugin.
客服电话
APP下载
官方微信
请发表评论