Giter Site home page Giter Site logo

akernel's Introduction

Build Status Code style: black Binder

akernel

An asynchronous Python Jupyter kernel, with different flavors:

  • reactive programming,
  • cell execution caching,
  • multi-kernel emulation.

Install

pip install akernel
# 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 caching

You can parameterize akernel's execution mode:

akernel install  # default (async)
akernel install react  # reactive programming mode
akernel install cache  # cell execution caching  mode
akernel install multi  # multi-kernel emulation mode
akernel install cache-multi-react  # you can combine several modes

Motivation

ipykernel offers the ability to run asynchronous code from the REPL. This means you can await at 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.

akernel now also supports reactive programming, although it is still experimental!

Features

Asynchronous 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 1
for i in range(10):
    print("cell 1:", i)
    await asyncio.sleep(1)

Since this cell is async (it has an await), it will not block the execution of other cells. So you can run another cell concurrently, provided that this cell is also cooperative:

# cell 2
for j in range(10):
    print("cell 2:", j)
    await asyncio.sleep(1)

If cell 2 was blocking, cell 1 would pause until cell 2 was finished. You can see that by changing await asyncio.sleep(1) into time.sleep(1) in cell 2.

You can make a cell wait for the previous one to be finished with:

# cell 3
await __task__()  # wait for cell 2 to be finished
print("cell 2 has run")

Reactive programming

One feature other notebooks offer is the ability to have variables react to other variables' changes. Observable notebooks are a good example of this, and it can give a whole new user experience. For instance, you can run cells out of order:

# cell 1
a = b + 1  # "b" is not defined yet
a

Executing cell 1 won't result in an "undefined variable" error. Instead, the result of the operation is undefined, and the output of cell 1 is None. You can then continue with the definition of b:

# cell 2
b = 2  # triggers the computation of "a" in cell 1

Now a, which depends on b, is automatically updated, and the output of cell 1 is 3.

You can of course define much more complex data flows, by defining variables on top of other ones.

screencast

Cell execution caching

With 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 mode

This 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.

Limitations

It is still a work in progress, in particular:

  • stdout/stderr redirection to the cell output is only supported through the print function.
  • No rich representation for now, only the standard __repr__ is supported. This means no matplotlib figure yet :-( But since ipywidgets work, why not using ipympl? :-)

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    ๐Ÿ–– Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. ๐Ÿ“Š๐Ÿ“ˆ๐ŸŽ‰

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google โค๏ธ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.