** What is this?
An Emacs library that allows Org mode to evaluate code blocks using a Jupyter kernel (Python by default).
** Screenshot
[[./screenshot.jpg]]
** How do I install this?
*** First, you need IPython
Before installing, you'll need Jupyter (>= 1.0) and IPython (>=
5.0) installed and working. You will also need the [[http://jupyter.readthedocs.org/en/latest/install.html][Jupyter]] console
and client (~jupyter_console~, ~jupyter_client~) libraries. All of
this should be trivially installable using pip.*** Install the Emacs plugin
This package is in MELPA. I recommend installing from there.
Otherwise, for manual installation, you'll need the following
elisp dependencies first:
* https://github.com/magnars/dash.el
* Including dash-functional
* https://github.com/magnars/s.el
* https://github.com/rejeep/f.el
Then just drop this somewhere in your load path and ~(require
'ob-ipython)~.
Lastly, activate ~ipython~ in Org-Babel:
#+BEGIN_SRC emacs-lisp
(org-babel-do-load-languages
'org-babel-load-languages
'((ipython . t)
;; other languages..
))
#+END_SRC** How do I use it?
Open an org file, add a SRC block and evaluate as you would any Org SRC block (usually =C-c C-c=). Here I will run through some example blocks.
This is the most basic ipython block. You must provide a session argument. You can name the session if you wish to separate state. You can also pass a connection json of an existing ipython session as a session name in order to connect to it.
The result returned by ob-ipython should be renderable by org so it's recommended to always use ~:results raw drawer~.
,#+BEGIN_SRC ipython :session :results raw drawer
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
,#+END_SRCHere we evaluate some code with a function definition using a named session.
,#+BEGIN_SRC ipython :session mysession :exports both :results raw drawer
def foo(x):
return x + 9
[foo(x) + 7 for x in range(7)]
,#+END_SRC
,#+RESULTS:
: [16, 17, 18, 19, 20, 21, 22]To get a graphic out, you must ensure that you have evaluated ~%matplotlib inline~ first. A file will be generated for you (see the ~ob-ipython-resources-dir~ custom var if you want to change the path).
,#+BEGIN_SRC ipython :session :exports both :results raw drawer
plt.hist(np.random.randn(20000), bins=200)
,#+END_SRCIf you provide an ipyfile argument, this filename will be used instead of generating one.
,#+BEGIN_SRC ipython :session :ipyfile /tmp/image.png :exports both :results raw drawer
plt.hist(np.random.randn(20000), bins=200)
,#+END_SRCIn order to make an svg graphic rather than a png, you may specify the output format globally to IPython.
%config InlineBackend.figure_format = 'svg'If you wish to use a specific Jupyter kernel, you may pass the kernel option. This enables you to use ob-ipython with languages other than Python. You need to have the Jupyter kernel installed and working before you can use this.
When mixing code from different languages you will need to make use of the session argument.
,#+BEGIN_SRC ipython :session :kernel clojure
(+ 1 2)
,#+END_SRC
,#+RESULTS:
: 3ob-ipython supports providing variables and even tables to code.
,#+TBLNAME: data_table
| a | 1 | 2 |
| b | 2 | 3 |
| c | 3 | 4 |
,#+BEGIN_SRC ipython :session :exports both :var x=2 :var data=data_table
(x, data)
,#+END_SRC
,#+RESULTS:
: (2, [['a', 1, 2], ['b', 2, 3], ['c', 3, 4]])Asynchronous execution is supported. Use the ~:async t~ option.
,#+BEGIN_SRC ipython :session :ipyfile /tmp/image.png :exports both :async t :results raw drawer
import time
time.sleep(3)
plt.hist(np.random.randn(20000), bins=200)
,#+END_SRC** Experimental: Jupyter kernel support
This package is starting to transition from the original ipython-only support to full jupyter support.
If you have other kernels installed, you should be able to evaluate blocks by providing jupyter-X as the language, where X is the language name recognised by jupyter. For example, you can do something like this:
,#+BEGIN_SRC jupyter-R :results raw drawer
x <- 3
x
,#+END_SRCNotice, when providing languages like this, you do not need to (although you may) provide a session argument. A default session is created per language. This should also try to provide support for per-language modes when editing.
** Working with a remote session
First, follow the instructions [[https://github.com/ipython/ipython/wiki/Cookbook:-Connecting-to-a-remote-kernel-via-ssh][here]] to get access to a remote kernel. You can then pass the name of the local json file as a session arg to use this tunnel.
Essentially the instructions boil down to
** What features are there outside of Org SRC block evaluation?
You can ask the running IPython kernel for documentation. Open a SRC block, place the point on the thing you're interested in and run =M-x ob-ipython-inspect=. I recommend you bind this to a key.
~ob-ipython-completions~ queries the kernel for completions at a position. You may use this to hook up any completion mechanism. We already provide a company backend. With company installed, add ~(add-to-list 'company-backends 'company-ob-ipython)~ somewhere in your config. This should then work while editing a src block.
It's often easier to play with code using a REPL. With the point in an ipython SRC block, you can open a REPL connected to the current kernel by running =C-c C-v C-z=.
If evaluated code produces an error, this will be displayed nicely in a buffer using IPython's traceback support.
Stdout/err from code evaluation is displayed in a popup buffer. This is great for debugging or getting verbose output that is best left out of documents (e.g progress updates). If you wish to capture output in your document use the =:results output= SRC block header.
You can interrupt or kill a running kernel. This is helpful if things get stuck or really broken. See =M-x ob-ipython-interrupt-kernel= and =M-x ob-ipython-kill-kernel=, respectively.
** Tips and tricks
Here are a few things I have setup to make life better. These aren't provided with ob-ipython, but are recommended.
Be sure to use ~%matplotlib inline~, otherwise graphics won't work.
I use yasnippet to create src blocks. Here is the snippet I use. It takes care of generating unique file names (when I want one) so I don't have to think about this.
,#+BEGIN_SRC ipython :session ${1::ipyfile ${2:$$(let ((temporary-file-directory "./")) (make-temp-file "py" nil ".png"))} }:exports ${3:both} $0 ,#+END_SRC
These days I use this more often:
,#+BEGIN_SRC ipython :session :exports both :results raw drawer $0 ,#+END_SRC
I use the following Org settings:
(setq org-confirm-babel-evaluate nil) ;don't prompt me to confirm everytime I want to evaluate a block
;;; display/update images in the buffer after I evaluate (add-hook 'org-babel-after-execute-hook 'org-display-inline-images 'append)
Export with the =LaTeX= backend using the =minted= package for source block highlighting fails for =ipython= blocks by default with the error : Error: no lexer for alias 'ipython' found
To use the =python= lexer for =ipython= blocks, add this setting:
(add-to-list 'org-latex-minted-langs '(ipython "python"))
ob-ipython will display anything back from ipython with the mime type 'text/org' verbatim. This allows you and others to create [[https://www.safaribooksonline.com/blog/2014/02/11/altering-display-existing-classes-ipython/][formatters]] that output raw org. For example, drop this in your ipython startup file to have arrays and dataframes rendered as org tables:
import IPython from tabulate import tabulate
class OrgFormatter(IPython.core.formatters.BaseFormatter): def call(self, obj): try: return tabulate(obj, headers='keys', tablefmt='orgtbl', showindex='always') except: return None
ip = get_ipython() ip.display_formatter.formatters['text/org'] = OrgFormatter()
** Help, it doesn't work
First thing to do is check that you have all of the required dependencies. Several common problems have been resolved in the project's issues, so take a look there to see if your problem has a quick fix. Otherwise feel free to cut an issue - I'll do my best to help.
** Alternatives *** Why not use IPython notebook?
I tried using the IPython notebook but quickly became frustrated
with trying to write code in a web browser. This provides another
option for creating documents containing executable Python code,
but in Emacs - with everything that entails.*** Why not use [[https://millejoh.github.io/emacs-ipython-notebook/][EIN]]?
EIN is really great. It kept me happy for quite a while but I
started to feel constrained by the cell format of IPython
notebooks. What I really wanted was to embed code in Org
documents. It's hard to compete with Org mode! A few key points in
favour of Org:
* In my opinion, Org's markup is better than Markdown.
* Org's organisational, editing and navigation facilities are much
better than EIN.
* Org's tables...
* Org can export to multiple formats.
* I like how Org opens a new buffer when editing code so that you
can use a Python major mode rather than trying to handle
multiple major modes in one.
I also found myself hitting bugs in EIN where evaluation and doc
lookup would just stop working. I regularly had to kill and reopen
buffers or restart the IPython kernel and this was getting
frustrating.*** How does this compare to regular Org Python integration (ob-python)?
I think this is more robust. The executed code is sent to a
running IPython kernel which has an architecture designed for this
purpose. The way ob-python works feels like a bit of a hack. I ran
in to race conditions using ob-python where the Org buffer would
update its results before the Python REPL had finished evaluating
the code block. This is what eventually drove me to write this.
It's easier to get plots and images out of this. I also provide
several features I missed when using plain ob-python, such as
looking up documentation and getting IPython-style tracebacks when
things go wrong.
You can also use IPython-specific features such as ~%timeit~.