From fbb0829bbc872507ddd4a5b9f3b4b136c3f8d24c Mon Sep 17 00:00:00 2001
From: Carol Willing <carolcode@willingconsulting.com>
Date: Tue, 22 Mar 2016 18:28:43 -0700
Subject: [PATCH] Remove rst versions of nb

---
 docs/source/conf.py                           |   3 +-
 .../Connecting with the Qt Console.rst        |  67 ---
 .../rstversions/Custom Keyboard Shortcuts.rst |  71 ----
 .../Examples and Tutorials Index.rst          |  34 --
 .../rstversions/Importing Notebooks.rst       | 286 -------------
 .../JavaScript Notebook Extensions.rst        | 389 ------------------
 .../Notebook/rstversions/Notebook Basics.rst  | 266 ------------
 .../Notebook/rstversions/Running Code.rst     | 154 -------
 .../rstversions/Typesetting Equations.rst     | 290 -------------
 .../What is the Jupyter Notebook.rst          | 136 ------
 .../Working With Markdown Cells.rst           | 313 --------------
 .../examples/Notebook/rstversions/index.rst   |  37 --
 docs/source/index.rst                         |  11 +-
 13 files changed, 12 insertions(+), 2045 deletions(-)
 delete mode 100644 docs/source/examples/Notebook/rstversions/Connecting with the Qt Console.rst
 delete mode 100644 docs/source/examples/Notebook/rstversions/Custom Keyboard Shortcuts.rst
 delete mode 100644 docs/source/examples/Notebook/rstversions/Examples and Tutorials Index.rst
 delete mode 100644 docs/source/examples/Notebook/rstversions/Importing Notebooks.rst
 delete mode 100644 docs/source/examples/Notebook/rstversions/JavaScript Notebook Extensions.rst
 delete mode 100644 docs/source/examples/Notebook/rstversions/Notebook Basics.rst
 delete mode 100644 docs/source/examples/Notebook/rstversions/Running Code.rst
 delete mode 100644 docs/source/examples/Notebook/rstversions/Typesetting Equations.rst
 delete mode 100644 docs/source/examples/Notebook/rstversions/What is the Jupyter Notebook.rst
 delete mode 100644 docs/source/examples/Notebook/rstversions/Working With Markdown Cells.rst
 delete mode 100644 docs/source/examples/Notebook/rstversions/index.rst

diff --git a/docs/source/conf.py b/docs/source/conf.py
index 43783f5df..17e917bc1 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -70,6 +70,7 @@ extensions = [
     'sphinx.ext.mathjax',
     'IPython.sphinxext.ipython_console_highlighting',
     'sphinxcontrib.spelling',
+    'nbsphinx',
 ]
 
 # Add any paths that contain templates here, relative to this directory.
@@ -78,7 +79,7 @@ templates_path = ['_templates']
 # The suffix(es) of source filenames.
 # You can specify multiple suffix as a list of string:
 # source_suffix = ['.rst', '.md']
-source_suffix = '.rst'
+source_suffix = ['.rst', '.ipynb']
 
 # The encoding of source files.
 #source_encoding = 'utf-8-sig'
diff --git a/docs/source/examples/Notebook/rstversions/Connecting with the Qt Console.rst b/docs/source/examples/Notebook/rstversions/Connecting with the Qt Console.rst
deleted file mode 100644
index 906b2548a..000000000
--- a/docs/source/examples/Notebook/rstversions/Connecting with the Qt Console.rst	
+++ /dev/null
@@ -1,67 +0,0 @@
-
-`View the original notebook on nbviewer <http://nbviewer.jupyter.org/github/jupyter/notebook/blob/master/docs/source/examples/Notebook/Connecting%20with%20the%20Qt%20Console.ipynb>`__
-
-Connecting to an existing IPython kernel using the Qt Console
-=============================================================
-
-The Frontend/Kernel Model
--------------------------
-
-The traditional IPython (``ipython``) consists of a single process that
-combines a terminal based UI with the process that runs the users code.
-
-While this traditional application still exists, the modern Jupyter
-consists of two processes:
-
--  Kernel: this is the process that runs the users code.
--  Frontend: this is the process that provides the user interface where
-   the user types code and sees results.
-
-Jupyter currently has 3 frontends:
-
--  Terminal Console (``ipython console``)
--  Qt Console (``ipython qtconsole``)
--  Notebook (``ipython notebook``)
-
-The Kernel and Frontend communicate over a ZeroMQ/JSON based messaging
-protocol, which allows multiple Frontends (even of different types) to
-communicate with a single Kernel. This opens the door for all sorts of
-interesting things, such as connecting a Console or Qt Console to a
-Notebook's Kernel. For example, you may want to connect a Qt console to
-your Notebook's Kernel and use it as a help browser, calling ``??`` on
-objects in the Qt console (whose pager is more flexible than the one in
-the notebook).
-
-This Notebook describes how you would connect another Frontend to a
-Kernel that is associated with a Notebook.
-
-Manual connection
------------------
-
-To connect another Frontend to a Kernel manually, you first need to find
-out the connection information for the Kernel using the
-``%connect_info`` magic:
-
-.. code:: python
-
-    %connect_info
-
-You can see that this magic displays everything you need to connect to
-this Notebook's Kernel.
-
-Automatic connection using a new Qt Console
--------------------------------------------
-
-You can also start a new Qt Console connected to your current Kernel by
-using the ``%qtconsole`` magic. This will detect the necessary
-connection information and start the Qt Console for you automatically.
-
-.. code:: python
-
-    a = 10
-
-.. code:: python
-
-    %qtconsole
-
-`View the original notebook on nbviewer <http://nbviewer.jupyter.org/github/jupyter/notebook/blob/master/docs/source/examples/Notebook/Connecting%20with%20the%20Qt%20Console.ipynb>`__
diff --git a/docs/source/examples/Notebook/rstversions/Custom Keyboard Shortcuts.rst b/docs/source/examples/Notebook/rstversions/Custom Keyboard Shortcuts.rst
deleted file mode 100644
index 6cf95e22d..000000000
--- a/docs/source/examples/Notebook/rstversions/Custom Keyboard Shortcuts.rst	
+++ /dev/null
@@ -1,71 +0,0 @@
-
-`View the original notebook on nbviewer <http://nbviewer.jupyter.org/github/jupyter/notebook/blob/master/docs/source/examples/Notebook/Custom%20Keyboard%20Shortcuts.ipynb>`__
-
-Keyboard Shortcut Customization
-===============================
-
-Starting with IPython 2.0 keyboard shortcuts in command and edit mode
-are fully customizable. These customizations are made using the Jupyter
-JavaScript API. Here is an example that makes the ``r`` key available
-for running a cell:
-
-.. code:: python
-
-    %%javascript
-    
-    Jupyter.keyboard_manager.command_shortcuts.add_shortcut('r', {
-        help : 'run cell',
-        help_index : 'zz',
-        handler : function (event) {
-            IPython.notebook.execute_cell();
-            return false;
-        }}
-    );
-
-"By default the keypress ``r``, while in command mode, changes the type
-of the selected cell to ``raw``. This shortcut is overridden by the code
-in the previous cell, and thus the action no longer be available via the
-keypress ``r``."
-
-There are a couple of points to mention about this API:
-
--  The ``help_index`` field is used to sort the shortcuts in the
-   Keyboard Shortcuts help dialog. It defaults to ``zz``.
--  When a handler returns ``false`` it indicates that the event should
-   stop propagating and the default action should not be performed. For
-   further details about the ``event`` object or event handling, see the
-   jQuery docs.
--  If you don't need a ``help`` or ``help_index`` field, you can simply
-   pass a function as the second argument to ``add_shortcut``.
-
-.. code:: python
-
-    %%javascript
-    
-    Jupyter.keyboard_manager.command_shortcuts.add_shortcut('r', function (event) {
-        IPython.notebook.execute_cell();
-        return false;
-    });
-
-Likewise, to remove a shortcut, use ``remove_shortcut``:
-
-.. code:: python
-
-    %%javascript
-    
-    Jupyter.keyboard_manager.command_shortcuts.remove_shortcut('r');
-
-If you want your keyboard shortcuts to be active for all of your
-notebooks, put the above API calls into your ``custom.js`` file.
-
-Of course we provide name for majority of existing action so that you do
-not have to re-write everything, here is for example how to bind ``r``
-back to it's initial behavior:
-
-.. code:: python
-
-    %%javascript
-    
-    Jupyter.keyboard_manager.command_shortcuts.add_shortcut('r', 'jupyter-notebook:change-cell-to-raw');
-
-`View the original notebook on nbviewer <http://nbviewer.jupyter.org/github/jupyter/notebook/blob/master/docs/source/examples/Notebook/Custom%20Keyboard%20Shortcuts.ipynb>`__
diff --git a/docs/source/examples/Notebook/rstversions/Examples and Tutorials Index.rst b/docs/source/examples/Notebook/rstversions/Examples and Tutorials Index.rst
deleted file mode 100644
index 5c1dd4caa..000000000
--- a/docs/source/examples/Notebook/rstversions/Examples and Tutorials Index.rst	
+++ /dev/null
@@ -1,34 +0,0 @@
-
-`View the original notebook on nbviewer <http://nbviewer.jupyter.org/github/jupyter/notebook/blob/master/docs/source/examples/Notebook/Examples%20and%20Tutorials%20Index.ipynb>`__
-
-
-
-Examples and Tutorials
-======================
-
-This portion of the documentation was generated from notebook files. You
-can download the original interactive notebook files using the links at
-the tops and bottoms of the pages.
-
-Tutorials
----------
-
--  `What is the Jupyter
-   Notebook <What%20is%20the%20Jupyter%20Notebook.html>`__
--  `Notebook Basics <Notebook%20Basics.html>`__
--  `Running Code <Running%20Code.html>`__
--  `Working With Markdown
-   Cells <Working%20With%20Markdown%20Cells.html>`__
--  `Custom Keyboard Shortcuts <Custom%20Keyboard%20Shortcuts.html>`__
--  `JavaScript Notebook
-   Extensions <JavaScript%20Notebook%20Extensions.html>`__
-
-Examples
---------
-
--  `Importing Notebooks <Importing%20Notebooks.html>`__
--  `Connecting with the Qt
-   Console <Connecting%20with%20the%20Qt%20Console.html>`__
--  `Typesetting Equations <Typesetting%20Equations.html>`__
-
-`View the original notebook on nbviewer <http://nbviewer.jupyter.org/github/jupyter/notebook/blob/master/docs/source/examples/Notebook/Examples%20and%20Tutorials%20Index.ipynb>`__
diff --git a/docs/source/examples/Notebook/rstversions/Importing Notebooks.rst b/docs/source/examples/Notebook/rstversions/Importing Notebooks.rst
deleted file mode 100644
index 390ae9953..000000000
--- a/docs/source/examples/Notebook/rstversions/Importing Notebooks.rst	
+++ /dev/null
@@ -1,286 +0,0 @@
-
-`View the original notebook on nbviewer <http://nbviewer.jupyter.org/github/jupyter/notebook/blob/master/docs/source/examples/Notebook/Importing%20Notebooks.ipynb>`__
-
-Importing Jupyter Notebooks as Modules
-======================================
-
-It is a common problem that people want to import code from Jupyter
-Notebooks. This is made difficult by the fact that Notebooks are not
-plain Python files, and thus cannot be imported by the regular Python
-machinery.
-
-Fortunately, Python provides some fairly sophisticated
-`hooks <http://www.python.org/dev/peps/pep-0302/>`__ into the import
-machinery, so we can actually make Jupyter notebooks importable without
-much difficulty, and only using public APIs.
-
-.. code:: python
-
-    import io, os, sys, types
-
-.. code:: python
-
-    from IPython import get_ipython
-    from IPython.nbformat import current
-    from IPython.core.interactiveshell import InteractiveShell
-
-Import hooks typically take the form of two objects:
-
-1. a Module **Loader**, which takes a module name (e.g.
-   ``'IPython.display'``), and returns a Module
-2. a Module **Finder**, which figures out whether a module might exist,
-   and tells Python what **Loader** to use
-
-.. code:: python
-
-    def find_notebook(fullname, path=None):
-        """find a notebook, given its fully qualified name and an optional path
-        
-        This turns "foo.bar" into "foo/bar.ipynb"
-        and tries turning "Foo_Bar" into "Foo Bar" if Foo_Bar
-        does not exist.
-        """
-        name = fullname.rsplit('.', 1)[-1]
-        if not path:
-            path = ['']
-        for d in path:
-            nb_path = os.path.join(d, name + ".ipynb")
-            if os.path.isfile(nb_path):
-                return nb_path
-            # let import Notebook_Name find "Notebook Name.ipynb"
-            nb_path = nb_path.replace("_", " ")
-            if os.path.isfile(nb_path):
-                return nb_path
-                
-
-Notebook Loader
----------------
-
-Here we have our Notebook Loader. It's actually quite simple - once we
-figure out the filename of the module, all it does is:
-
-1. load the notebook document into memory
-2. create an empty Module
-3. execute every cell in the Module namespace
-
-Since IPython cells can have extended syntax, the IPython transform is
-applied to turn each of these cells into their pure-Python counterparts
-before executing them. If all of your notebook cells are pure-Python,
-this step is unnecessary.
-
-.. code:: python
-
-    class NotebookLoader(object):
-        """Module Loader for Jupyter Notebooks"""
-        def __init__(self, path=None):
-            self.shell = InteractiveShell.instance()
-            self.path = path
-        
-        def load_module(self, fullname):
-            """import a notebook as a module"""
-            path = find_notebook(fullname, self.path)
-            
-            print ("importing Jupyter notebook from %s" % path)
-                                           
-            # load the notebook object
-            with io.open(path, 'r', encoding='utf-8') as f:
-                nb = current.read(f, 'json')
-            
-            
-            # create the module and add it to sys.modules
-            # if name in sys.modules:
-            #    return sys.modules[name]
-            mod = types.ModuleType(fullname)
-            mod.__file__ = path
-            mod.__loader__ = self
-            mod.__dict__['get_ipython'] = get_ipython
-            sys.modules[fullname] = mod
-            
-            # extra work to ensure that magics that would affect the user_ns
-            # actually affect the notebook module's ns
-            save_user_ns = self.shell.user_ns
-            self.shell.user_ns = mod.__dict__
-            
-            try:
-              for cell in nb.worksheets[0].cells:
-                if cell.cell_type == 'code' and cell.language == 'python':
-                    # transform the input to executable Python
-                    code = self.shell.input_transformer_manager.transform_cell(cell.input)
-                    # run the code in themodule
-                    exec(code, mod.__dict__)
-            finally:
-                self.shell.user_ns = save_user_ns
-            return mod
-
-
-The Module Finder
------------------
-
-The finder is a simple object that tells you whether a name can be
-imported, and returns the appropriate loader. All this one does is
-check, when you do:
-
-.. code:: python
-
-    import mynotebook
-
-it checks whether ``mynotebook.ipynb`` exists. If a notebook is found,
-then it returns a NotebookLoader.
-
-Any extra logic is just for resolving paths within packages.
-
-.. code:: python
-
-    class NotebookFinder(object):
-        """Module finder that locates Jupyter Notebooks"""
-        def __init__(self):
-            self.loaders = {}
-        
-        def find_module(self, fullname, path=None):
-            nb_path = find_notebook(fullname, path)
-            if not nb_path:
-                return
-            
-            key = path
-            if path:
-                # lists aren't hashable
-                key = os.path.sep.join(path)
-            
-            if key not in self.loaders:
-                self.loaders[key] = NotebookLoader(path)
-            return self.loaders[key]
-
-
-Register the hook
------------------
-
-Now we register the ``NotebookFinder`` with ``sys.meta_path``
-
-.. code:: python
-
-    sys.meta_path.append(NotebookFinder())
-
-After this point, my notebooks should be importable.
-
-Let's look at what we have in the CWD:
-
-.. code:: python
-
-    ls nbpackage
-
-So I should be able to ``import nbimp.mynotebook``.
-
-Aside: displaying notebooks
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Here is some simple code to display the contents of a notebook with
-syntax highlighting, etc.
-
-.. code:: python
-
-    from pygments import highlight
-    from pygments.lexers import PythonLexer
-    from pygments.formatters import HtmlFormatter
-    
-    from IPython.display import display, HTML
-    
-    formatter = HtmlFormatter()
-    lexer = PythonLexer()
-    
-    # publish the CSS for pygments highlighting
-    display(HTML("""
-    <style type='text/css'>
-    %s
-    </style>
-    """ % formatter.get_style_defs()
-    ))
-
-.. code:: python
-
-    def show_notebook(fname):
-        """display a short summary of the cells of a notebook"""
-        with io.open(fname, 'r', encoding='utf-8') as f:
-            nb = current.read(f, 'json')
-        html = []
-        for cell in nb.worksheets[0].cells:
-            html.append("<h4>%s cell</h4>" % cell.cell_type)
-            if cell.cell_type == 'code':
-                html.append(highlight(cell.input, lexer, formatter))
-            else:
-                html.append("<pre>%s</pre>" % cell.source)
-        display(HTML('\n'.join(html)))
-    
-    show_notebook(os.path.join("nbpackage", "mynotebook.ipynb"))
-
-So my notebook has a heading cell and some code cells, one of which
-contains some IPython syntax.
-
-Let's see what happens when we import it
-
-.. code:: python
-
-    from nbpackage import mynotebook
-
-Hooray, it imported! Does it work?
-
-.. code:: python
-
-    mynotebook.foo()
-
-Hooray again!
-
-Even the function that contains IPython syntax works:
-
-.. code:: python
-
-    mynotebook.has_ip_syntax()
-
-Notebooks in packages
----------------------
-
-We also have a notebook inside the ``nb`` package, so let's make sure
-that works as well.
-
-.. code:: python
-
-    ls nbpackage/nbs
-
-Note that the ``__init__.py`` is necessary for ``nb`` to be considered a
-package, just like usual.
-
-.. code:: python
-
-    show_notebook(os.path.join("nbpackage", "nbs", "other.ipynb"))
-
-.. code:: python
-
-    from nbpackage.nbs import other
-    other.bar(5)
-
-So now we have importable notebooks, from both the local directory and
-inside packages.
-
-I can even put a notebook inside IPython, to further demonstrate that
-this is working properly:
-
-.. code:: python
-
-    import shutil
-    from IPython.utils.path import get_ipython_package_dir
-    
-    utils = os.path.join(get_ipython_package_dir(), 'utils')
-    shutil.copy(os.path.join("nbpackage", "mynotebook.ipynb"),
-                os.path.join(utils, "inside_ipython.ipynb")
-    )
-
-and import the notebook from ``IPython.utils``
-
-.. code:: python
-
-    from IPython.utils import inside_ipython
-    inside_ipython.whatsmyname()
-
-This approach can even import functions and classes that are defined in
-a notebook using the ``%%cython`` magic.
-
-`View the original notebook on nbviewer <http://nbviewer.jupyter.org/github/jupyter/notebook/blob/master/docs/source/examples/Notebook/Importing%20Notebooks.ipynb>`__
diff --git a/docs/source/examples/Notebook/rstversions/JavaScript Notebook Extensions.rst b/docs/source/examples/Notebook/rstversions/JavaScript Notebook Extensions.rst
deleted file mode 100644
index 5a465cbc2..000000000
--- a/docs/source/examples/Notebook/rstversions/JavaScript Notebook Extensions.rst	
+++ /dev/null
@@ -1,389 +0,0 @@
-
-`View the original notebook on nbviewer <http://nbviewer.jupyter.org/github/jupyter/notebook/blob/master/docs/source/examples/Notebook/JavaScript%20Notebook%20Extensions.ipynb>`__
-
-Embracing web standards
-=======================
-
-One of the main reasons why we developed the current notebook web
-application was to embrace the web technology.
-
-By being a pure web application using HTML, Javascript, and CSS, the
-Notebook can get all the web technology improvement for free. Thus, as
-browser support for different media extend, the notebook web app should
-be able to be compatible without modification.
-
-This is also true with performance of the User Interface as the speed of
-Javascript VM increases.
-
-The other advantage of using only web technology is that the code of the
-interface is fully accessible to the end user and is modifiable live.
-Even if this task is not always easy, we strive to keep our code as
-accessible and reusable as possible. This should allow us - with minimum
-effort - development of small extensions that customize the behavior of
-the web interface.
-
-Tampering with the Notebook application
----------------------------------------
-
-The first tool that is available to you and that you should be aware of
-are browser "developers tool". The exact naming can change across
-browser and might require the installation of extensions. But basically
-they can allow you to inspect/modify the DOM, and interact with the
-javascript code that runs the frontend.
-
--  In Chrome and Safari, Developer tools are in the menu
-   ``View > Developer > Javascript Console``
--  In Firefox you might need to install
-   `Firebug <http://getfirebug.com/>`__
-
-Those will be your best friends to debug and try different approaches
-for your extensions.
-
-Injecting JS
-~~~~~~~~~~~~
-
-Using magics
-^^^^^^^^^^^^
-
-The above tools can be tedious for editing edit long JavaScript files.
-Therefore we provide the ``%%javascript`` magic. This allows you to
-quickly inject JavaScript into the notebook. Still the javascript
-injected this way will not survive reloading. Hence, it is a good tool
-for testing an refining a script.
-
-You might see here and there people modifying css and injecting js into
-the notebook by reading file(s) and publishing them into the notebook.
-Not only does this often break the flow of the notebook and make the
-re-execution of the notebook broken, but it also means that you need to
-execute those cells in the entire notebook every time you need to update
-the code.
-
-This can still be useful in some cases, like the ``%autosave`` magic
-that allows you to control the time between each save. But this can be
-replaced by a JavaScript dropdown menu to select the save interval.
-
-.. code:: python
-
-    ## you can inspect the autosave code to see what it does.
-    %autosave??
-
-custom.js
-^^^^^^^^^
-
-To inject Javascript we provide an entry point: ``custom.js`` that
-allows the user to execute and load other resources into the notebook.
-Javascript code in ``custom.js`` will be executed when the notebook app
-starts and can then be used to customize almost anything in the UI and
-in the behavior of the notebook.
-
-``custom.js`` can be found in the Jupyter dir. You can share your
-custom.js with others.
-
-Back to theory
-''''''''''''''
-
-.. code:: python
-
-    from jupyter_core.paths import jupyter_config_dir
-    jupyter_dir = jupyter_config_dir()
-    jupyter_dir
-
-and custom js is in
-
-.. code:: python
-
-    import os.path
-    custom_js_path = os.path.join(jupyter_dir, 'custom', 'custom.js')
-
-.. code:: python
-
-    #  my custom js
-    if os.path.isfile(custom_js_path):
-        with open(custom_js_path) as f:
-            print(f.read())
-    else:
-        print("You don't have a custom.js file")  
-
-Note that ``custom.js`` is meant to be modified by user. When writing a
-script, you can define it in a separate file and add a line of
-configuration into ``custom.js`` that will fetch and execute the file.
-
-**Warning** : even if modification of ``custom.js`` takes effect
-immediately after browser refresh (except if browser cache is
-aggressive), *creating* a file in ``static/`` directory needs a **server
-restart**.
-
-Exercise :
-----------
-
--  Create a ``custom.js`` in the right location with the following
-   content:
-
-   .. code:: javascript
-
-       alert("hello world from custom.js")
-
--  Restart your server and open any notebook.
--  Be greeted by custom.js
-
-Have a look at `default
-custom.js <https://github.com/jupyter/notebook/blob/4.0.x/notebook/static/custom/custom.js>`__,
-to see it's content and for more explanation.
-
-For the quick ones :
-~~~~~~~~~~~~~~~~~~~~
-
-We've seen above that you can change the autosave rate by using a magic.
-This is typically something I don't want to type every time, and that I
-don't like to embed into my workflow and documents. (readers don't care
-what my autosave time is). Let's build an extension that allows us to do
-it.
-
-Create a dropdown element in the toolbar (DOM
-``Jupyter.toolbar.element``), you will need
-
--  ``Jupyter.notebook.set_autosave_interval(miliseconds)``
--  know that 1 min = 60 sec, and 1 sec = 1000 ms
-
-.. code:: javascript
-
-
-    var label = jQuery('<label/>').text('AutoScroll Limit:');
-    var select = jQuery('<select/>')
-         //.append(jQuery('<option/>').attr('value', '2').text('2min (default)'))
-         .append(jQuery('<option/>').attr('value', undefined).text('disabled'))
-
-         // TODO:
-         //the_toolbar_element.append(label)
-         //the_toolbar_element.append(select);
-         
-    select.change(function() {
-         var val = jQuery(this).val() // val will be the value in [2]
-         // TODO
-         // this will be called when dropdown changes
-
-    });
-
-    var time_m = [1,5,10,15,30];
-    for (var i=0; i < time_m.length; i++) {
-         var ts = time_m[i];
-                                              //[2]   ____ this will be `val` on [1]  
-                                              //     | 
-                                              //     v 
-         select.append($('<option/>').attr('value', ts).text(thr+'min'));
-         // this will fill up the dropdown `select` with
-         // 1 min
-         // 5 min
-         // 10 min
-         // 10 min
-         // ...
-    }
-
-A non-interactive example first
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-I like my cython to be nicely highlighted
-
-.. code:: javascript
-
-    Jupyter.config.cell_magic_highlight['magic_text/x-cython'] = {}
-    Jupyter.config.cell_magic_highlight['magic_text/x-cython'].reg = [/^%%cython/]
-
-``text/x-cython`` is the name of CodeMirror mode name, ``magic_`` prefix
-will just patch the mode so that the first line that contains a magic
-does not screw up the highlighting. ``reg``\ is a list or regular
-expression that will trigger the change of mode.
-
-Get more documentation
-^^^^^^^^^^^^^^^^^^^^^^
-
-Sadly, you will have to read the js source file (but there are lots of
-comments) and/or build the JavaScript documentation using yuidoc. If you
-have ``node`` and ``yui-doc`` installed:
-
-.. code:: bash
-
-    $ cd ~/jupyter/notebook/notebook/static/notebook/js/
-    $ yuidoc . --server
-    warn: (yuidoc): Failed to extract port, setting to the default :3000
-    info: (yuidoc): Starting YUIDoc@0.3.45 using YUI@3.9.1 with NodeJS@0.10.15
-    info: (yuidoc): Scanning for yuidoc.json file.
-    info: (yuidoc): Starting YUIDoc with the following options:
-    info: (yuidoc):
-    { port: 3000,
-      nocode: false,
-      paths: [ '.' ],
-      server: true,
-      outdir: './out' }
-    info: (yuidoc): Scanning for yuidoc.json file.
-    info: (server): Starting server: http://127.0.0.1:3000
-
-and browse http://127.0.0.1:3000 to get documentation
-
-Some convenience methods
-^^^^^^^^^^^^^^^^^^^^^^^^
-
-By browsing the documentation you will see that we have some convenience
-methods that allows us to avoid re-inventing the UI every time :
-
-.. code:: javascript
-
-    Jupyter.toolbar.add_buttons_group([
-            {
-                 'label'   : 'run qtconsole',
-                 'icon'    : 'icon-terminal', // select your icon from 
-                                              // http://fortawesome.github.io/Font-Awesome/icons/
-                 'callback': function(){Jupyter.notebook.kernel.execute('%qtconsole')}
-            }
-            // add more button here if needed.
-            ]);
-
-with a `lot of
-icons <http://fortawesome.github.io/Font-Awesome/icons/>`__ you can
-select from.
-
-Cell Metadata
--------------
-
-The most requested feature is generally to be able to distinguish an
-individual cell in the notebook, or run a specific action with them. To
-do so, you can either use ``Jupyter.notebook.get_selected_cell()``, or
-rely on ``CellToolbar``. This allows you to register a set of actions
-and graphical elements that will be attached to individual cells.
-
-Cell Toolbar
-~~~~~~~~~~~~
-
-You can see some example of what can be done by toggling the
-``Cell Toolbar`` selector in the toolbar on top of the notebook. It
-provides two default ``presets`` that are ``Default`` and ``slideshow``.
-Default allows the user to edit the metadata attached to each cell
-manually.
-
-First we define a function that takes at first parameter an element on
-the DOM in which to inject UI element. The second element is the cell
-this element wis registered with. Then we will need to register that
-function and give it a name.
-
-Register a callback
-^^^^^^^^^^^^^^^^^^^
-
-.. code:: python
-
-    %%javascript
-    var CellToolbar = Jupyter.CellToolbar
-    var toggle =  function(div, cell) {
-         var button_container = $(div)
-    
-         // let's create a button that shows the current value of the metadata
-         var button = $('<button/>').addClass('btn btn-mini').text(String(cell.metadata.foo));
-    
-         // On click, change the metadata value and update the button label
-         button.click(function(){
-                     var v = cell.metadata.foo;
-                     cell.metadata.foo = !v;
-                     button.text(String(!v));
-                 })
-    
-         // add the button to the DOM div.
-         button_container.append(button);
-    }
-    
-     // now we register the callback under the name foo to give the
-     // user the ability to use it later
-     CellToolbar.register_callback('tuto.foo', toggle);
-
-Registering a preset
-^^^^^^^^^^^^^^^^^^^^
-
-This function can now be part of many ``preset`` of the CellToolBar.
-
-.. code:: python
-
-    %%javascript
-    Jupyter.CellToolbar.register_preset('Tutorial 1',['tuto.foo','default.rawedit'])
-    Jupyter.CellToolbar.register_preset('Tutorial 2',['slideshow.select','tuto.foo'])
-
-You should now have access to two presets :
-
--  Tutorial 1
--  Tutorial 2
-
-And check that the buttons you defined share state when you toggle
-preset. Also check that the metadata of the cell is modified when you
-click the button, and that when saved on reloaded the metadata is still
-available.
-
-Exercise:
-^^^^^^^^^
-
-Try to wrap the all code in a file, put this file in
-``{profile}/static/custom/<a-name>.js``, and add
-
-::
-
-    require(['custom/<a-name>']);
-
-in ``custom.js`` to have this script automatically loaded in all your
-notebooks.
-
-``require`` is provided by a `javascript
-library <http://requirejs.org/>`__ that allow you to express dependency.
-For simple extension like the previous one we directly mute the global
-namespace, but for more complex extension you could pass a callback to
-``require([...], <callback>)`` call, to allow the user to pass
-configuration information to your plugin.
-
-In Python lang,
-
-.. code:: javascript
-
-    require(['a/b', 'c/d'], function( e, f){
-        e.something()
-        f.something()
-    })
-
-could be read as
-
-.. code:: python
-
-    import a.b as e
-    import c.d as f
-    e.something()
-    f.something()
-
-See for example @damianavila `"ZenMode"
-plugin <https://github.com/ipython-contrib/IPython-notebook-extensions/blob/master/custom.example.js#L34>`__
-:
-
-.. code:: javascript
-
-
-    // read that as
-    // import custom.zenmode.main as zenmode
-    require(['custom/zenmode/main'],function(zenmode){
-        zenmode.background('images/back12.jpg');
-    })
-
-For the quickest
-^^^^^^^^^^^^^^^^
-
-Try to use `the
-following <https://github.com/ipython/ipython/blob/1.x/IPython/html/static/notebook/js/celltoolbar.js#L367>`__
-to bind a dropdown list to ``cell.metadata.difficulty.select``.
-
-It should be able to take the 4 following values :
-
--  ``<None>``
--  ``Easy``
--  ``Medium``
--  ``Hard``
-
-We will use it to customiZe the output of the converted notebook
-depending on the tag on each cell
-
-.. code:: python
-
-    %load soln/celldiff.js
-
-`View the original notebook on nbviewer <http://nbviewer.jupyter.org/github/jupyter/notebook/blob/master/docs/source/examples/Notebook/JavaScript%20Notebook%20Extensions.ipynb>`__
diff --git a/docs/source/examples/Notebook/rstversions/Notebook Basics.rst b/docs/source/examples/Notebook/rstversions/Notebook Basics.rst
deleted file mode 100644
index 67b4324aa..000000000
--- a/docs/source/examples/Notebook/rstversions/Notebook Basics.rst	
+++ /dev/null
@@ -1,266 +0,0 @@
-
-`View the original notebook on nbviewer <http://nbviewer.jupyter.org/github/jupyter/notebook/blob/master/docs/source/examples/Notebook/Notebook%20Basics.ipynb>`__
-
-Notebook Basics
-===============
-
-Running the Notebook Server
----------------------------
-
-The Jupyter notebook server is a custom web server that runs the
-notebook web application. Most of the time, users run the notebook
-server on their local computer using the command line interface.
-
-Starting the notebook server using the command line
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-You can start the notebook server from the command line (Terminal on
-Mac/Linux, CMD prompt on Windows) by running the following command:
-
-::
-
-    jupyter notebook
-
-This will print some information about the notebook server in your
-terminal, including the URL of the web application (by default,
-``http://127.0.0.1:8888``). It will then open your default web browser
-to this URL.
-
-When the notebook opens, you will see the **notebook dashboard**, which
-will show a list of the notebooks, files, and subdirectories in the
-directory where the notebook server was started (as seen in the next
-section, below). Most of the time, you will want to start a notebook
-server in the highest directory in your filesystem where notebooks can
-be found. Often this will be your home directory.
-
-Additional options
-~~~~~~~~~~~~~~~~~~
-
-By default, the notebook server starts on port 8888. If port 8888 is
-unavailable, the notebook server searchs the next available port.
-
-You can also specify the port manually:
-
-::
-
-    jupyter notebook --port 9999
-
-Or start notebook server without opening a web browser.
-
-::
-
-    jupyter notebook --no-browser
-
-The notebook server has a number of other command line arguments that
-can be displayed with the ``--help`` flag:
-
-::
-
-    jupyter notebook --help
-
-The Notebook dashboard
-----------------------
-
-When you first start the notebook server, your browser will open to the
-notebook dashboard. The dashboard serves as a home page for the
-notebook. Its main purpose is to display the notebooks and files in the
-current directory. For example, here is a screenshot of the dashboard
-page for the ``examples`` directory in the Jupyter repository:
-
-The top of the notebook list displays clickable breadcrumbs of the
-current directory. By clicking on these breadcrumbs or on
-sub-directories in the notebook list, you can navigate your file system.
-
-To create a new notebook, click on the "New" button at the top of the
-list and select a kernel from the dropdown (as seen below). Which
-kernels are listed depend on what's installed on the server. Some of the
-kernels in the screenshot below may not exist as an option to you.
-
-Notebooks and files can be uploaded to the current directory by dragging
-a notebook file onto the notebook list or by the "click here" text above
-the list.
-
-The notebook list shows green "Running" text and a green notebook icon
-next to running notebooks (as seen below). Notebooks remain running
-until you explicitly shut them down; closing the notebook's page is not
-sufficient.
-
-To shutdown, delete, duplicate, or rename a notebook check the checkbox
-next to it and an array of controls will appear at the top of the
-notebook list (as seen below). You can also use the same operations on
-directories and files when applicable.
-
-To see all of your running notebooks along with their directories, click
-on the "Running" tab:
-
-This view provides a convenient way to track notebooks that you start as
-you navigate the file system in a long running notebook server.
-
-Overview of the Notebook UI
----------------------------
-
-If you create a new notebook or open an existing one, you will be taken
-to the notebook user interface (UI). This UI allows you to run code and
-author notebook documents interactively. The notebook UI has the
-following main areas:
-
--  Menu
--  Toolbar
--  Notebook area and cells
-
-The notebook has an interactive tour of these elements that can be
-started in the "Help:User Interface Tour" menu item.
-
-Modal editor
-------------
-
-Starting with IPython 2.0, the Jupyter Notebook has a modal user
-interface. This means that the keyboard does different things depending
-on which mode the Notebook is in. There are two modes: edit mode and
-command mode.
-
-Edit mode
-~~~~~~~~~
-
-Edit mode is indicated by a green cell border and a prompt showing in
-the editor area:
-
-When a cell is in edit mode, you can type into the cell, like a normal
-text editor.
-
-.. raw:: html
-
-   <div class="alert alert-success">
-
-Enter edit mode by pressing ``Enter`` or using the mouse to click on a
-cell's editor area.
-
-.. raw:: html
-
-   </div>
-
-Command mode
-~~~~~~~~~~~~
-
-Command mode is indicated by a grey cell border with a blue left margin:
-
-When you are in command mode, you are able to edit the notebook as a
-whole, but not type into individual cells. Most importantly, in command
-mode, the keyboard is mapped to a set of shortcuts that let you perform
-notebook and cell actions efficiently. For example, if you are in
-command mode and you press ``c``, you will copy the current cell - no
-modifier is needed.
-
-.. raw:: html
-
-   <div class="alert alert-error">
-
-Don't try to type into a cell in command mode; unexpected things will
-happen!
-
-.. raw:: html
-
-   </div>
-
-.. raw:: html
-
-   <div class="alert alert-success">
-
-Enter command mode by pressing ``Esc`` or using the mouse to click
-*outside* a cell's editor area.
-
-.. raw:: html
-
-   </div>
-
-Mouse navigation
-----------------
-
-All navigation and actions in the Notebook are available using the mouse
-through the menubar and toolbar, which are both above the main Notebook
-area:
-
-The first idea of mouse based navigation is that **cells can be selected
-by clicking on them.** The currently selected cell gets a grey or green
-border depending on whether the notebook is in edit or command mode. If
-you click inside a cell's editor area, you will enter edit mode. If you
-click on the prompt or output area of a cell you will enter command
-mode.
-
-If you are running this notebook in a live session (not on
-http://nbviewer.jupyter.org) try selecting different cells and going
-between edit and command mode. Try typing into a cell.
-
-The second idea of mouse based navigation is that **cell actions usually
-apply to the currently selected cell**. Thus if you want to run the code
-in a cell, you would select it and click the
-
-.. raw:: html
-
-   <button class="btn btn-default btn-xs">
-
-.. raw:: html
-
-   </button>
-
-button in the toolbar or the "Cell:Run" menu item. Similarly, to copy a
-cell you would select it and click the
-
-.. raw:: html
-
-   <button class="btn btn-default btn-xs">
-
-.. raw:: html
-
-   </button>
-
-button in the toolbar or the "Edit:Copy" menu item. With this simple
-pattern, you should be able to do most everything you need with the
-mouse.
-
-Markdown and heading cells have one other state that can be modified
-with the mouse. These cells can either be rendered or unrendered. When
-they are rendered, you will see a nice formatted representation of the
-cell's contents. When they are unrendered, you will see the raw text
-source of the cell. To render the selected cell with the mouse, click
-the
-
-.. raw:: html
-
-   <button class="btn btn-default btn-xs">
-
-.. raw:: html
-
-   </button>
-
-button in the toolbar or the "Cell:Run" menu item. To unrender the
-selected cell, double click on the cell.
-
-Keyboard Navigation
--------------------
-
-The modal user interface of the Jupyter Notebook has been optimized for
-efficient keyboard usage. This is made possible by having two different
-sets of keyboard shortcuts: one set that is active in edit mode and
-another in command mode.
-
-The most important keyboard shortcuts are ``Enter``, which enters edit
-mode, and ``Esc``, which enters command mode.
-
-In edit mode, most of the keyboard is dedicated to typing into the
-cell's editor. Thus, in edit mode there are relatively few shortcuts. In
-command mode, the entire keyboard is available for shortcuts, so there
-are many more. The ``Help``->``Keyboard Shortcuts`` dialog lists the
-available shortcuts.
-
-We recommend learning the command mode shortcuts in the following rough
-order:
-
-1. Basic navigation: ``enter``, ``shift-enter``, ``up/k``, ``down/j``
-2. Saving the notebook: ``s``
-3. Change Cell types: ``y``, ``m``, ``1-6``, ``t``
-4. Cell creation: ``a``, ``b``
-5. Cell editing: ``x``, ``c``, ``v``, ``d``, ``z``
-6. Kernel operations: ``i``, ``0`` (press twice)
-
-`View the original notebook on nbviewer <http://nbviewer.jupyter.org/github/jupyter/notebook/blob/master/docs/source/examples/Notebook/Notebook%20Basics.ipynb>`__
diff --git a/docs/source/examples/Notebook/rstversions/Running Code.rst b/docs/source/examples/Notebook/rstversions/Running Code.rst
deleted file mode 100644
index c76ecc655..000000000
--- a/docs/source/examples/Notebook/rstversions/Running Code.rst	
+++ /dev/null
@@ -1,154 +0,0 @@
-
-`View the original notebook on nbviewer <http://nbviewer.jupyter.org/github/jupyter/notebook/blob/master/docs/source/examples/Notebook/Running%20Code.ipynb>`__
-
-Running Code
-============
-
-First and foremost, the Jupyter Notebook is an interactive environment
-for writing and running code. The notebook is capable of running code in
-a wide range of languages. However, each notebook is associated with a
-single kernel. This notebook is associated with the IPython kernel,
-therefor runs Python code.
-
-Code cells allow you to enter and run code
-------------------------------------------
-
-Run a code cell using ``Shift-Enter`` or pressing the
-
-.. raw:: html
-
-   <button class="btn btn-default btn-xs">
-
-.. raw:: html
-
-   </button>
-
-button in the toolbar above:
-
-.. code:: python
-
-    a = 10
-
-.. code:: python
-
-    print(a)
-
-There are two other keyboard shortcuts for running code:
-
--  ``Alt-Enter`` runs the current cell and inserts a new one below.
--  ``Ctrl-Enter`` run the current cell and enters command mode.
-
-Managing the Kernel
--------------------
-
-Code is run in a separate process called the Kernel. The Kernel can be
-interrupted or restarted. Try running the following cell and then hit
-the
-
-.. raw:: html
-
-   <button class="btn btn-default btn-xs">
-
-.. raw:: html
-
-   </button>
-
-button in the toolbar above.
-
-.. code:: python
-
-    import time
-    time.sleep(10)
-
-If the Kernel dies you will be prompted to restart it. Here we call the
-low-level system libc.time routine with the wrong argument via ctypes to
-segfault the Python interpreter:
-
-.. code:: python
-
-    import sys
-    from ctypes import CDLL
-    # This will crash a Linux or Mac system
-    # equivalent calls can be made on Windows
-    dll = 'dylib' if sys.platform == 'darwin' else 'so.6'
-    libc = CDLL("libc.%s" % dll) 
-    libc.time(-1)  # BOOM!!
-
-Cell menu
----------
-
-The "Cell" menu has a number of menu items for running code in different
-ways. These includes:
-
--  Run and Select Below
--  Run and Insert Below
--  Run All
--  Run All Above
--  Run All Below
-
-Restarting the kernels
-----------------------
-
-The kernel maintains the state of a notebook's computations. You can
-reset this state by restarting the kernel. This is done by clicking on
-the
-
-.. raw:: html
-
-   <button class="btn btn-default btn-xs">
-
-.. raw:: html
-
-   </button>
-
-in the toolbar above.
-
-sys.stdout and sys.stderr
--------------------------
-
-The stdout and stderr streams are displayed as text in the output area.
-
-.. code:: python
-
-    print("hi, stdout")
-
-.. code:: python
-
-    from __future__ import print_function
-    print('hi, stderr', file=sys.stderr)
-
-Output is asynchronous
-----------------------
-
-All output is displayed asynchronously as it is generated in the Kernel.
-If you execute the next cell, you will see the output one piece at a
-time, not all at the end.
-
-.. code:: python
-
-    import time, sys
-    for i in range(8):
-        print(i)
-        time.sleep(0.5)
-
-Large outputs
--------------
-
-To better handle large outputs, the output area can be collapsed. Run
-the following cell and then single- or double- click on the active area
-to the left of the output:
-
-.. code:: python
-
-    for i in range(50):
-        print(i)
-
-Beyond a certain point, output will scroll automatically:
-
-.. code:: python
-
-    for i in range(500):
-        print(2**i - 1)
-
-
-`View the original notebook on nbviewer <http://nbviewer.jupyter.org/github/jupyter/notebook/blob/master/docs/source/examples/Notebook/Running%20Code.ipynb>`__
diff --git a/docs/source/examples/Notebook/rstversions/Typesetting Equations.rst b/docs/source/examples/Notebook/rstversions/Typesetting Equations.rst
deleted file mode 100644
index adf889da7..000000000
--- a/docs/source/examples/Notebook/rstversions/Typesetting Equations.rst	
+++ /dev/null
@@ -1,290 +0,0 @@
-
-`View the original notebook on nbviewer <http://nbviewer.jupyter.org/github/jupyter/notebook/blob/master/docs/source/examples/Notebook/Typesetting%20Equations.ipynb>`__
-
-The Markdown parser included in the Jupyter Notebook is MathJax-aware.
-This means that you can freely mix in mathematical expressions using the
-`MathJax subset of Tex and
-LaTeX <http://docs.mathjax.org/en/latest/tex.html#tex-support>`__. `Some
-examples from the MathJax
-site <http://www.mathjax.org/demos/tex-samples/>`__ are reproduced
-below, as well as the Markdown+TeX source.
-
-Motivating Examples
-===================
-
-The Lorenz Equations
---------------------
-
-Source
-~~~~~~
-
-::
-
-    \begin{align}
-    \dot{x} & = \sigma(y-x) \\
-    \dot{y} & = \rho x - y - xz \\
-    \dot{z} & = -\beta z + xy
-    \end{align}
-
-Display
-~~~~~~~
-
-.. raw:: latex
-
-   \begin{align}
-   \dot{x} & = \sigma(y-x) \\
-   \dot{y} & = \rho x - y - xz \\
-   \dot{z} & = -\beta z + xy
-   \end{align}
-
-The Cauchy-Schwarz Inequality
------------------------------
-
-Source
-~~~~~~
-
-::
-
-    \begin{equation*}
-    \left( \sum_{k=1}^n a_k b_k \right)^2 \leq \left( \sum_{k=1}^n a_k^2 \right) \left( \sum_{k=1}^n b_k^2 \right)
-    \end{equation*}
-
-Display
-~~~~~~~
-
-.. raw:: latex
-
-   \begin{equation*}
-   \left( \sum_{k=1}^n a_k b_k \right)^2 \leq \left( \sum_{k=1}^n a_k^2 \right) \left( \sum_{k=1}^n b_k^2 \right)
-   \end{equation*}
-
-A Cross Product Formula
------------------------
-
-Source
-~~~~~~
-
-::
-
-    \begin{equation*}
-    \mathbf{V}_1 \times \mathbf{V}_2 =  \begin{vmatrix}
-    \mathbf{i} & \mathbf{j} & \mathbf{k} \\
-    \frac{\partial X}{\partial u} &  \frac{\partial Y}{\partial u} & 0 \\
-    \frac{\partial X}{\partial v} &  \frac{\partial Y}{\partial v} & 0
-    \end{vmatrix}  
-    \end{equation*}
-
-Display
-~~~~~~~
-
-.. raw:: latex
-
-   \begin{equation*}
-   \mathbf{V}_1 \times \mathbf{V}_2 =  \begin{vmatrix}
-   \mathbf{i} & \mathbf{j} & \mathbf{k} \\
-   \frac{\partial X}{\partial u} &  \frac{\partial Y}{\partial u} & 0 \\
-   \frac{\partial X}{\partial v} &  \frac{\partial Y}{\partial v} & 0
-   \end{vmatrix}  
-   \end{equation*}
-
-The probability of getting (k) heads when flipping (n) coins is
----------------------------------------------------------------
-
-Source
-~~~~~~
-
-::
-
-    \begin{equation*}
-    P(E)   = {n \choose k} p^k (1-p)^{ n-k} 
-    \end{equation*}
-
-Display
-~~~~~~~
-
-.. raw:: latex
-
-   \begin{equation*}
-   P(E)   = {n \choose k} p^k (1-p)^{ n-k} 
-   \end{equation*}
-
-An Identity of Ramanujan
-------------------------
-
-Source
-~~~~~~
-
-::
-
-    \begin{equation*}
-    \frac{1}{\Bigl(\sqrt{\phi \sqrt{5}}-\phi\Bigr) e^{\frac25 \pi}} =
-    1+\frac{e^{-2\pi}} {1+\frac{e^{-4\pi}} {1+\frac{e^{-6\pi}}
-    {1+\frac{e^{-8\pi}} {1+\ldots} } } } 
-    \end{equation*}
-
-Display
-~~~~~~~
-
-.. raw:: latex
-
-   \begin{equation*}
-   \frac{1}{\Bigl(\sqrt{\phi \sqrt{5}}-\phi\Bigr) e^{\frac25 \pi}} =
-   1+\frac{e^{-2\pi}} {1+\frac{e^{-4\pi}} {1+\frac{e^{-6\pi}}
-   {1+\frac{e^{-8\pi}} {1+\ldots} } } } 
-   \end{equation*}
-
-A Rogers-Ramanujan Identity
----------------------------
-
-Source
-~~~~~~
-
-::
-
-    \begin{equation*}
-    1 +  \frac{q^2}{(1-q)}+\frac{q^6}{(1-q)(1-q^2)}+\cdots =
-    \prod_{j=0}^{\infty}\frac{1}{(1-q^{5j+2})(1-q^{5j+3})},
-    \quad\quad \text{for $|q|<1$}. 
-    \end{equation*}
-
-Display
-~~~~~~~
-
-.. raw:: latex
-
-   \begin{equation*}
-   1 + \frac{q^2}{(1-q)}+\frac{q^6}{(1-q)(1-q^2)}+\cdots =
-   \prod_{j=0}^{\infty}\frac{1}{(1-q^{5j+2})(1-q^{5j+3})},
-   \quad\quad \text{for $|q|<1$}. 
-   \end{equation*}
-
-Maxwell's Equations
--------------------
-
-Source
-~~~~~~
-
-::
-
-    \begin{align}
-    \nabla \times \vec{\mathbf{B}} -\, \frac1c\, \frac{\partial\vec{\mathbf{E}}}{\partial t} & = \frac{4\pi}{c}\vec{\mathbf{j}} \\   \nabla \cdot \vec{\mathbf{E}} & = 4 \pi \rho \\
-    \nabla \times \vec{\mathbf{E}}\, +\, \frac1c\, \frac{\partial\vec{\mathbf{B}}}{\partial t} & = \vec{\mathbf{0}} \\
-    \nabla \cdot \vec{\mathbf{B}} & = 0 
-    \end{align}
-
-Display
-~~~~~~~
-
-.. raw:: latex
-
-   \begin{align}
-   \nabla \times \vec{\mathbf{B}} -\, \frac1c\, \frac{\partial\vec{\mathbf{E}}}{\partial t} & = \frac{4\pi}{c}\vec{\mathbf{j}} \\   \nabla \cdot \vec{\mathbf{E}} & = 4 \pi \rho \\
-   \nabla \times \vec{\mathbf{E}}\, +\, \frac1c\, \frac{\partial\vec{\mathbf{B}}}{\partial t} & = \vec{\mathbf{0}} \\
-   \nabla \cdot \vec{\mathbf{B}} & = 0 
-   \end{align}
-
-Equation Numbering and References
-=================================
-
-Equation numbering and referencing will be available in a future version
-of the Jupyter notebook.
-
-Inline Typesetting (Mixing Markdown and TeX)
---------------------------------------------
-
-While display equations look good for a page of samples, the ability to
-mix math and *formatted* **text** in a paragraph is also important.
-
-Source
-~~~~~~
-
-::
-
-    This expression $\sqrt{3x-1}+(1+x)^2$ is an example of a TeX inline equation in a [Markdown-formatted](http://daringfireball.net/projects/markdown/) sentence.  
-
-Display
-~~~~~~~
-
-This expression :math:`\sqrt{3x-1}+(1+x)^2` is an example of a TeX
-inline equation in a
-`Markdown-formatted <http://daringfireball.net/projects/markdown/>`__
-sentence.
-
-Other Syntax
-============
-
-You will notice in other places on the web that ``$$`` are needed
-explicitly to begin and end MathJax typesetting. This is **not**
-required if you will be using TeX environments, but the Jupyter notebook
-will accept this syntax on legacy notebooks.
-
-Source
-------
-
-::
-
-    $$
-    \begin{array}{c}
-    y_1 \\\
-    y_2 \mathtt{t}_i \\\
-    z_{3,4}
-    \end{array}
-    $$
-
-::
-
-    $$
-    \begin{array}{c}
-    y_1 \cr
-    y_2 \mathtt{t}_i \cr
-    y_{3}
-    \end{array}
-    $$
-
-::
-
-    $$\begin{eqnarray} 
-    x' &=& &x \sin\phi &+& z \cos\phi \\
-    z' &=& - &x \cos\phi &+& z \sin\phi \\
-    \end{eqnarray}$$
-
-::
-
-    $$
-    x=4
-    $$
-
-Display
--------
-
-.. math::
-
-
-   \begin{array}{c}
-   y_1 \\\
-   y_2 \mathtt{t}_i \\\
-   z_{3,4}
-   \end{array}
-
-.. math::
-
-
-   \begin{array}{c}
-   y_1 \cr
-   y_2 \mathtt{t}_i \cr
-   y_{3}
-   \end{array}
-
-.. math::
-
-   \begin{eqnarray} 
-   x' &=& &x \sin\phi &+& z \cos\phi \\
-   z' &=& - &x \cos\phi &+& z \sin\phi \\
-   \end{eqnarray}
-
-.. math::
-
-
-   x=4
-
-`View the original notebook on nbviewer <http://nbviewer.jupyter.org/github/jupyter/notebook/blob/master/docs/source/examples/Notebook/Typesetting%20Equations.ipynb>`__
diff --git a/docs/source/examples/Notebook/rstversions/What is the Jupyter Notebook.rst b/docs/source/examples/Notebook/rstversions/What is the Jupyter Notebook.rst
deleted file mode 100644
index b014e0384..000000000
--- a/docs/source/examples/Notebook/rstversions/What is the Jupyter Notebook.rst	
+++ /dev/null
@@ -1,136 +0,0 @@
-
-`View the original notebook on nbviewer <http://nbviewer.jupyter.org/github/jupyter/notebook/blob/master/docs/source/examples/Notebook/What%20is%20the%20Jupyter%20Notebook.ipynb>`__
-
-What is the Jupyter Notebook?
-=============================
-
-Introduction
-------------
-
-The Jupyter Notebook is an **interactive computing environment** that
-enables users to author notebook documents that include: - Live code -
-Interactive widgets - Plots - Narrative text - Equations - Images -
-Video
-
-These documents provide a **complete and self-contained record of a
-computation** that can be converted to various formats and shared with
-others using email, `Dropbox <http://dropbox.com>`__, version control
-systems (like git/\ `GitHub <http://github.com>`__) or
-`nbviewer.jupyter.org <http://nbviewer.jupyter.org>`__.
-
-Components
-~~~~~~~~~~
-
-The Jupyter Notebook combines three components:
-
--  **The notebook web application**: An interactive web application for
-   writing and running code interactively and authoring notebook
-   documents.
--  **Kernels**: Separate processes started by the notebook web
-   application that runs users' code in a given language and returns
-   output back to the notebook web application. The kernel also handles
-   things like computations for interactive widgets, tab completion and
-   introspection.
--  **Notebook documents**: Self-contained documents that contain a
-   representation of all content visible in the notebook web
-   application, including inputs and outputs of the computations,
-   narrative text, equations, images, and rich media representations of
-   objects. Each notebook document has its own kernel.
-
-Notebook web application
-------------------------
-
-The notebook web application enables users to:
-
--  **Edit code in the browser**, with automatic syntax highlighting,
-   indentation, and tab completion/introspection.
--  **Run code from the browser**, with the results of computations
-   attached to the code which generated them.
--  See the results of computations with **rich media representations**,
-   such as HTML, LaTeX, PNG, SVG, PDF, etc.
--  Create and use **interactive JavaScript widgets**, which bind
-   interactive user interface controls and visualizations to reactive
-   kernel side computations.
--  Author **narrative text** using the
-   `Markdown <https://daringfireball.net/projects/markdown/>`__ markup
-   language.
--  Build **hierarchical documents** that are organized into sections
-   with different levels of headings.
--  Include mathematical equations using **LaTeX syntax in Markdown**,
-   which are rendered in-browser by
-   `MathJax <http://www.mathjax.org/>`__.
-
-Kernels
--------
-
-Through Jupyter's kernel and messaging architecture, the Notebook allows
-code to be run in a range of different programming languages. For each
-notebook document that a user opens, the web application starts a kernel
-that runs the code for that notebook. Each kernel is capable of running
-code in a single programming language and there are kernels available in
-the following languages:
-
--  Python(https://github.com/ipython/ipython)
--  Julia (https://github.com/JuliaLang/IJulia.jl)
--  R (https://github.com/takluyver/IRkernel)
--  Ruby (https://github.com/minrk/iruby)
--  Haskell (https://github.com/gibiansky/IHaskell)
--  Scala (https://github.com/Bridgewater/scala-notebook)
--  node.js (https://gist.github.com/Carreau/4279371)
--  Go (https://github.com/takluyver/igo)
-
-The default kernel runs Python code. The notebook provides a simple way
-for users to pick which of these kernels is used for a given notebook.
-
-Each of these kernels communicate with the notebook web application and
-web browser using a JSON over ZeroMQ/WebSockets message protocol that is
-described
-`here <http://ipython.org/ipython-doc/dev/development/messaging.html>`__.
-Most users don't need to know about these details, but it helps to
-understand that "kernels run code."
-
-Notebook documents
-------------------
-
-Notebook documents contain the **inputs and outputs** of an interactive
-session as well as **narrative text** that accompanies the code but is
-not meant for execution. **Rich output** generated by running code,
-including HTML, images, video, and plots, is embeddeed in the notebook,
-which makes it a complete and self-contained record of a computation.
-
-When you run the notebook web application on your computer, notebook
-documents are just **files on your local filesystem with a ``.ipynb``
-extension**. This allows you to use familiar workflows for organizing
-your notebooks into folders and sharing them with others.
-
-Notebooks consist of a **linear sequence of cells**. There are four
-basic cell types:
-
--  **Code cells:** Input and output of live code that is run in the
-   kernel
--  **Markdown cells:** Narrative text with embedded LaTeX equations
--  **Heading cells:** 6 levels of hierarchical organization and
-   formatting
--  **Raw cells:** Unformatted text that is included, without
-   modification, when notebooks are converted to different formats using
-   nbconvert
-
-Internally, notebook documents are
-**`JSON <http://en.wikipedia.org/wiki/JSON>`__ data** with **binary
-values `base64 <http://en.wikipedia.org/wiki/Base64>`__** encoded. This
-allows them to be **read and manipulated programmatically** by any
-programming language. Because JSON is a text format, notebook documents
-are version control friendly.
-
-**Notebooks can be exported** to different static formats including
-HTML, reStructeredText, LaTeX, PDF, and slide shows
-(`reveal.js <http://lab.hakim.se/reveal-js/#/>`__) using Jupyter's
-``nbconvert`` utility.
-
-Furthermore, any notebook document available from a **public URL on or
-GitHub can be shared** via `nbviewer <http://nbviewer.ipython.org>`__.
-This service loads the notebook document from the URL and renders it as
-a static web page. The resulting web page may thus be shared with others
-**without their needing to install the Jupyter Notebook**.
-
-`View the original notebook on nbviewer <http://nbviewer.jupyter.org/github/jupyter/notebook/blob/master/docs/source/examples/Notebook/What%20is%20the%20Jupyter%20Notebook.ipynb>`__
diff --git a/docs/source/examples/Notebook/rstversions/Working With Markdown Cells.rst b/docs/source/examples/Notebook/rstversions/Working With Markdown Cells.rst
deleted file mode 100644
index b87404a9f..000000000
--- a/docs/source/examples/Notebook/rstversions/Working With Markdown Cells.rst	
+++ /dev/null
@@ -1,313 +0,0 @@
-
-`View the original notebook on nbviewer <http://nbviewer.jupyter.org/github/jupyter/notebook/blob/master/docs/source/examples/Notebook/Working%20With%20Markdown%20Cells.ipynb>`__
-
-Markdown Cells
-==============
-
-Text can be added to Jupyter Notebooks using Markdown cells. Markdown is
-a popular markup language that is a superset of HTML. Its specification
-can be found here:
-
-http://daringfireball.net/projects/markdown/
-
-Markdown basics
----------------
-
-You can make text *italic* or **bold**.
-
-You can build nested itemized or enumerated lists:
-
--  One
-
-   -  Sublist
-
-      -  This
-
--  Sublist - That - The other thing
--  Two
--  Sublist
--  Three
--  Sublist
-
-Now another list:
-
-1. Here we go
-
-   1. Sublist
-   2. Sublist
-
-2. There we go
-3. Now this
-
-You can add horizontal rules:
-
---------------
-
-Here is a blockquote:
-
-    Beautiful is better than ugly. Explicit is better than implicit.
-    Simple is better than complex. Complex is better than complicated.
-    Flat is better than nested. Sparse is better than dense. Readability
-    counts. Special cases aren't special enough to break the rules.
-    Although practicality beats purity. Errors should never pass
-    silently. Unless explicitly silenced. In the face of ambiguity,
-    refuse the temptation to guess. There should be one-- and preferably
-    only one --obvious way to do it. Although that way may not be
-    obvious at first unless you're Dutch. Now is better than never.
-    Although never is often better than *right* now. If the
-    implementation is hard to explain, it's a bad idea. If the
-    implementation is easy to explain, it may be a good idea. Namespaces
-    are one honking great idea -- let's do more of those!
-
-And shorthand for links:
-
-`Jupyter's website <http://jupyter.org>`__
-
-Headings
---------
-
-You can add headings by starting a line with one (or multiple) ``#``
-followed by a space, as in the following example:
-
-Heading 1
-=========
-
-Heading 2
-=========
-
-Heading 2.1
------------
-
-Heading 2.2
------------
-
-Embedded code
--------------
-
-You can embed code meant for illustration instead of execution in
-Python:
-
-::
-
-    def f(x):
-        """a docstring"""
-        return x**2
-
-or other languages:
-
-::
-
-    if (i=0; i<n; i++) {
-      printf("hello %d\n", i);
-      x += 4;
-    }
-
-LaTeX equations
----------------
-
-Courtesy of MathJax, you can include mathematical expressions both
-inline: :math:`e^{i\pi} + 1 = 0` and displayed:
-
-.. math:: e^x=\sum_{i=0}^\infty \frac{1}{i!}x^i
-
-Inline expressions can be added by surrounding the latex code with
-``$``:
-
-::
-
-    $e^{i\pi} + 1 = 0$
-
-Expressions on their own line are surrounded by ``$$``:
-
-.. code:: latex
-
-    $$e^x=\sum_{i=0}^\infty \frac{1}{i!}x^i$$
-
-Github flavored markdown (GFM)
-------------------------------
-
-The Notebook webapp support Github flavored markdown meaning that you
-can use triple backticks for code blocks
-
-.. raw:: html
-
-   <pre>
-   ```python
-   print "Hello World"
-   ```
-
-   ```javascript
-   console.log("Hello World")
-   ```
-   </pre>
-
-Gives
-
-.. code:: python
-
-    print "Hello World"
-
-.. code:: javascript
-
-    console.log("Hello World")
-
-And a table like this :
-
-.. raw:: html
-
-   <pre>
-   | This | is   |
-   |------|------|
-   |   a  | table| 
-   </pre>
-
-A nice Html Table
-
-+--------+---------+
-| This   | is      |
-+========+=========+
-| a      | table   |
-+--------+---------+
-
-General HTML
-------------
-
-Because Markdown is a superset of HTML you can even add things like HTML
-tables:
-
-.. raw:: html
-
-   <table>
-
-.. raw:: html
-
-   <tr>
-
-.. raw:: html
-
-   <th>
-
-Header 1
-
-.. raw:: html
-
-   </th>
-
-.. raw:: html
-
-   <th>
-
-Header 2
-
-.. raw:: html
-
-   </th>
-
-.. raw:: html
-
-   </tr>
-
-.. raw:: html
-
-   <tr>
-
-.. raw:: html
-
-   <td>
-
-row 1, cell 1
-
-.. raw:: html
-
-   </td>
-
-.. raw:: html
-
-   <td>
-
-row 1, cell 2
-
-.. raw:: html
-
-   </td>
-
-.. raw:: html
-
-   </tr>
-
-.. raw:: html
-
-   <tr>
-
-.. raw:: html
-
-   <td>
-
-row 2, cell 1
-
-.. raw:: html
-
-   </td>
-
-.. raw:: html
-
-   <td>
-
-row 2, cell 2
-
-.. raw:: html
-
-   </td>
-
-.. raw:: html
-
-   </tr>
-
-.. raw:: html
-
-   </table>
-
-Local files
------------
-
-If you have local files in your Notebook directory, you can refer to
-these files in Markdown cells directly:
-
-::
-
-    [subdirectory/]<filename>
-
-For example, in the images folder, we have the Python logo:
-
-::
-
-    <img src="../images/python_logo.svg" />
-
-and a video with the HTML5 video tag:
-
-::
-
-    <video controls src="images/animation.m4v" />
-
-.. raw:: html
-
-   <video controls src="images/animation.m4v" />
-
-These do not embed the data into the notebook file, and require that the
-files exist when you are viewing the notebook.
-
-Security of local files
-~~~~~~~~~~~~~~~~~~~~~~~
-
-Note that this means that the Jupyter notebook server also acts as a
-generic file server for files inside the same tree as your notebooks.
-Access is not granted outside the notebook folder so you have strict
-control over what files are visible, but for this reason it is highly
-recommended that you do not run the notebook server with a notebook
-directory at a high level in your filesystem (e.g. your home directory).
-
-When you run the notebook in a password-protected manner, local file
-access is restricted to authenticated users unless read-only views are
-active.
-
-`View the original notebook on nbviewer <http://nbviewer.jupyter.org/github/jupyter/notebook/blob/master/docs/source/examples/Notebook/Working%20With%20Markdown%20Cells.ipynb>`__
diff --git a/docs/source/examples/Notebook/rstversions/index.rst b/docs/source/examples/Notebook/rstversions/index.rst
deleted file mode 100644
index 512437d78..000000000
--- a/docs/source/examples/Notebook/rstversions/index.rst
+++ /dev/null
@@ -1,37 +0,0 @@
-
-`View the original notebook on nbviewer <http://nbviewer.jupyter.org/github/jupyter/notebook/blob/master/docs/source/examples/Notebook/Examples%20and%20Tutorials%20Index.ipynb>`__
-
-
-
-Examples and Tutorials
-======================
-
-This portion of the documentation was generated from notebook files. You
-can download the original interactive notebook files using the links at
-the tops and bottoms of the pages.
-
-Tutorials
----------
-
-.. toctree::
-   :maxdepth: 1
-
-   What is the Jupyter Notebook
-   Notebook Basics
-   Running Code
-   Working With Markdown Cells
-   Custom Keyboard Shortcuts
-   JavaScript Notebook Extensions
-
-Examples
---------
-
-.. toctree::
-   :maxdepth: 1
-
-   Importing Notebooks
-   Connecting with the Qt Console
-   Typesetting Equations
-
-
-`View the original notebook on nbviewer <http://nbviewer.jupyter.org/github/jupyter/notebook/blob/master/docs/source/examples/Notebook/Examples%20and%20Tutorials%20Index.ipynb>`__
diff --git a/docs/source/index.rst b/docs/source/index.rst
index 08c3ac69e..85cceaed8 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -51,7 +51,16 @@ The Jupyter notebook
    :maxdepth: 1
    :caption: Community documentation
 
-   examples/Notebook/rstversions/Examples and Tutorials Index
+   examples/Notebook/Examples and Tutorials Index
+   examples/Notebook/What is the Jupyter Notebook
+   examples/Notebook/Notebook Basics
+   examples/Notebook/Running Code
+   examples/Notebook/Working With Markdown Cells
+   examples/Notebook/Custom Keyboard Shortcuts
+   examples/Notebook/JavaScript Notebook Extensions
+   examples/Notebook/Importing Notebooks
+   examples/Notebook/Connecting with the Qt Console
+   examples/Notebook/Typesetting Equations
 
 .. toctree::
    :maxdepth: 2