#+TITLE: Readme ** 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 org ,#+BEGIN_SRC ipython :session :results raw drawer %matplotlib inline import matplotlib.pyplot as plt import numpy as np ,#+END_SRC #+END_SRC Here we evaluate some code with a function definition using a named session. #+BEGIN_SRC org ,#+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] #+END_SRC 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 org ,#+BEGIN_SRC ipython :session :exports both :results raw drawer plt.hist(np.random.randn(20000), bins=200) ,#+END_SRC #+END_SRC If you provide an ipyfile argument, this filename will be used instead of generating one. #+BEGIN_SRC org ,#+BEGIN_SRC ipython :session :ipyfile /tmp/image.png :exports both :results raw drawer plt.hist(np.random.randn(20000), bins=200) ,#+END_SRC #+END_SRC In order to make an svg graphic rather than a png, you may specify the output format globally to IPython. #+BEGIN_EXAMPLE %config InlineBackend.figure_format = 'svg' #+END_EXAMPLE 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 org ,#+BEGIN_SRC ipython :session :kernel clojure (+ 1 2) ,#+END_SRC ,#+RESULTS: : 3 #+END_SRC ob-ipython supports providing variables and even tables to code. #+BEGIN_SRC org ,#+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]]) #+END_SRC Asynchronous execution is supported. Use the ~:async t~ option. #+BEGIN_SRC org ,#+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 #+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 org ,#+BEGIN_SRC jupyter-R :results raw drawer x <- 3 x ,#+END_SRC #+END_SRC Notice, 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 - scp the remote json file over (will be in =/run/user/*/jupyter/=) - use =jupyter console --existing ./kernel-remote.json --ssh remote-host= to connect locally. This will give you a prompt that should allow you to evaluate expressions locally but have them run on the remote machine. - use the newly created local config file printed by the previous step as the argument to =:session=. Be sure to include the =.json= suffix so that ob-ipython knows to use this as the config rather than spawning a new session. ** 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 snippet # -*- mode: snippet -*- # name: ipython block # key: py # -- ,#+BEGIN_SRC ipython :session ${1::ipyfile ${2:$$(let ((temporary-file-directory "./")) (make-temp-file "py" nil ".png"))} }:exports ${3:both} $0 ,#+END_SRC #+END_SRC These days I use this more often: #+BEGIN_SRC snippet ,#+BEGIN_SRC ipython :session :exports both :results raw drawer $0 ,#+END_SRC #+END_SRC * I use the following Org settings: #+BEGIN_SRC emacs-lisp (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) #+END_SRC * 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: #+BEGIN_SRC emacs-lisp (add-to-list 'org-latex-minted-langs '(ipython "python")) #+END_SRC # * Install pandoc and anything ipython renders as html will be # converted to org. This is mostly useful for getting nice tables # automatically. * 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: #+BEGIN_SRC python 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() #+END_SRC ** 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~.