Package: akernel
akernelA Python Jupyter kernel, with different flavors:concurrent cell execution,reactive programming,cell execution caching,multi-kernel emulation.Installpipinstallakernel# pip install akernel[react]  # if you want to be able to use reactive programming# pip install akernel[cache]  # if you want to be able to use cell execution cachingYou can parameterize akernel's execution mode:akernelinstall# default (chained cell execution mode)akernelinstallconcurrent# concurrent cell execution modeakernelinstallreact# reactive programming modeakernelinstallcache# cell execution caching  modeakernelinstallmulti# multi-kernel emulation modeakernelinstallcache-multi-react-concurrent# you can combine several modesMotivationipykerneloffers the ability torun asynchronous code from the REPL.
This means you canawaitat the top-level, outside of an async function. Unfortunately, this will still
block the kernel.akernel changes this behavior by launching each cell in a task. By default, cell tasks are chained, which
means that a cell will start executing after the previous one is done. You might wonder, is it not the same
as ipykernel then? Well, not quite. In ipykernel, when an async cell is executing, it also blocks the
processing ofComm messages, which
prevents the kernel from interacting with e.g. JupyterLab widgets (seehereandthere). In akernel, it will not be the case.If you want to go all the way and have cells execute concurrently, you can also do so (see below).FeaturesAsynchronous executionFirst, set the concurrent execution mode in order to have async cells execute concurrently
(you could also do that at install-time withakernel install concurrent):__unchain_execution__()# __chain_execution__()akernel allows for asynchronous code execution. What this means is that when used in a Jupyter
notebook, you can run cells concurrently if the code is cooperative. For instance, you can run a
cell with the following code:# cell 1foriinrange(10):print("cell 1:",i)awaitasyncio.sleep(1)Since this cell isasync(it has anawait), it will not block the execution of other cells.
So you can run another cell concurrently, provided that this cell is also cooperative:# cell 2forjinrange(10):print("cell 2:",j)awaitasyncio.sleep(1)If cell 2 was blocking, cell 1 would pause until cell 2 was finished. You can see that by changingawait asyncio.sleep(1)intotime.sleep(1)in cell 2.You can make a cell wait for the previous one to be finished with:# cell 3await__task__()# wait for cell 2 to be finishedprint("cell 2 has run")Reactive programmingOne feature other notebooks offer is the ability to have variables react to other variables'
changes.Observable notebooksare a
good example of this, and it can give a whole new user experience. For instance, you can run cells
out of order:# cell 1a=b+1# "b" is not defined yetaExecuting cell 1 won't result in an "undefined variable" error. Instead, theresultof the
operation is undefined, and the output of cell 1 isNone. You can then continue with the
definition ofb:# cell 2b=2# triggers the computation of "a" in cell 1Nowa, which depends onb, is automatically updated, and the output of cell 1 is3.You can of course define much more complex data flows, by defining variables on top of other ones.Cell execution cachingWith this mode, cell execution is cached so that the next time a cell is run, its outputs are retrieved from cache (if its inputs didn't change). Inputs and outputs are inferred from the cell code.Multi-kernel emulation modeThis mode emulates multiple kernels inside the same kernel. Kernel isolation is achieved by using the session ID of execution requests. You can thus connect multiple notebooks to the same kernel, and they won't share execution state.This is particularly useful if cells are async, because they won't block the kernel. The same kernel can thus be "shared" and used by potentially a lot of notebooks, greatly reducing resource usage.LimitationsIt is still a work in progress, in particular:stdout/stderrredirection to the cell output is only supported through theprintfunction.No rich representation for now, only the standard__repr__is supported. This means no
matplotlib figure yet :-( But since ipywidgets work, why not usingipympl? :-)