Fix undefined labels in docs #2

docs/source/interactive/python-ipython-diff.rst

@@ -1,249 +1,249 b''
 =================
 Python vs IPython
 =================
 
 This document is meant to highlight the main differences between the Python
 language and what are the specific construct you can do only in IPython.
 
 Unless expressed otherwise all of the construct you will see here will raise a
 ``SyntaxError`` if run in a pure Python shell, or if executing in a Python
 script.
 
 Each of these features are describe more in details in further part of the documentation.
 
 
 Quick overview:
 ===============
 
 
 All the following construct are valid IPython syntax:
 
 .. code-block:: ipython
 
     In [1]: ?
 
 .. code-block:: ipython
 
     In [1]: ?object
 
 
 .. code-block:: ipython
 
     In [1]: object?
 
 .. code-block:: ipython
 
     In [1]: *pattern*?
 
 .. code-block:: ipython
 
     In [1]: %shell like --syntax
 
 .. code-block:: ipython
 
     In [1]: !ls
 
 .. code-block:: ipython
 
     In [1]: my_files =! ls ~/
     In [1]: for i,file in enumerate(my_file):
        ...:     raw = !echo $file
        ...:     !echo {files[0].upper()} $raw
 
 
 .. code-block:: ipython
 
     In [1]: %%perl magic --function
        ...: @months = ("July", "August", "September");
        ...: print $months[0];
 
 
 Each of these construct is compile by IPython into valid python code and will
 do most of the time what you expect it will do. Let see each of these example
 in more detail.
 
 
 Accessing help
 ==============
 
 As IPython is mostly an interactive shell, the question mark is a simple
 shortcut to get help. A question mark alone will bring up the IPython help:
 
 .. code-block:: ipython
 
     In [1]: ?
 
     IPython -- An enhanced Interactive Python
     =========================================
 
     IPython offers a combination of convenient shell features, special commands
     and a history mechanism for both input (command history) and output (results
     caching, similar to Mathematica). It is intended to be a fully compatible
     replacement for the standard Python interpreter, while offering vastly
     improved functionality and flexibility.
 
     At your system command line, type 'ipython -h' to see the command line
     options available. This document only describes interactive features.
 
     MAIN FEATURES
     -------------
     ...
 
 A single question mark before, or after an object available in current
 namespace will show help relative to this object:
 
 .. code-block:: ipython
 
     In [6]: object?
     Docstring: The most base type
     Type:      type
 
 
 A double question mark will try to pull out more information about the object,
 and if possible display the python source code of this object.
 
 .. code-block:: ipython
 
     In[1]: import collections
     In[2]: collection.Counter??
 
     Init signature: collections.Counter(*args, **kwds)
     Source:
     class Counter(dict):
         '''Dict subclass for counting hashable items.  Sometimes called a bag
         or multiset.  Elements are stored as dictionary keys and their counts
         are stored as dictionary values.
 
         >>> c = Counter('abcdeabcdabcaba')  # count elements from a string
 
         >>> c.most_common(3)                # three most common elements
         [('a', 5), ('b', 4), ('c', 3)]
         >>> sorted(c)                       # list all unique elements
         ['a', 'b', 'c', 'd', 'e']
         >>> ''.join(sorted(c.elements()))   # list elements with repetitions
         'aaaaabbbbcccdde'
         ...
 
 
 
 If you are looking for an object, the use of wildcards ``*`` in conjunction
 with question mark will allow you to search current namespace for object with
 matching names:
 
 .. code-block:: ipython
 
     In [24]: *int*?
     FloatingPointError
     int
     print
 
 
 Shell Assignment
 ================
 
 
 When doing interactive computing it is common to need to access the underlying shell.
 This is doable through the use of the exclamation mark ``!`` (or bang).
 
 This allow to execute simple command when present in beginning of line:
 
 .. code-block:: ipython
 
     In[1]: !pwd
     /User/home/
 
 Change directory:
 
 .. code-block:: ipython
 
     In[1]: !cd /var/etc
 
 Or edit file:
 
 .. code-block:: ipython
 
     In[1]: !mvim myfile.txt
 
 
 The line after the bang can call any program installed in the underlying
 shell, and support variable expansion in the form of ``$variable`` or ``{variable}``.
 The later form of expansion supports arbitrary python expression:
 
 .. code-block:: ipython
 
     In[1]: file = 'myfile.txt'
 
     In[2]: !mv $file {file.upper()}
 
 
 The bang can also be present in the right hand side of an assignment, just
 after the equal sign, or separated from it by a white space. In which case the
 standard output of the command after the bang ``!`` will be split out into lines
-in a list-like object (:ref:`IPython Slist`) and assign to the left hand side.
+in a list-like object and assign to the left hand side.
 
 This allow you for example to put the list of files of the current working directory in a variable:
 
 .. code-block:: ipython
 
     In[1]: my_files != ls
 
 
 You can combine the different possibilities in for loops, condition, functions...:
 
 .. code-block:: ipython
 
     my_files =! ls ~/
     b = "backup file"
     for i,file in enumerate(my_file):
         raw = !echo $backup $file
         !cp $file {file.split('.')[0]+'.bak'}
 
 
 Magics
 ------
 
 Magics function are often present in the form of shell-like syntax, but are
 under the hood python function. The syntax and assignment possibility are
 similar to the one with the bang (``!``) syntax, but with more flexibility and
 power. Magic function start with a percent sign (``%``) or double percent (``%%``).
 
 A magic call with a sign percent will act only one line:
 
 .. code-block:: ipython
 
     In[1]: %xmode
     Exception reporting mode: Verbose
 
 And support assignment:
 
 .. code-block:: ipython
 
     In [1]: results = %timeit -r1 -n1 -o list(range(1000))
     1 loops, best of 1: 21.1 µs per loop
 
     In [2]: results
     Out[2]: <TimeitResult : 1 loops, best of 1: 21.1 µs per loop>
 
 Magic with two percent sign can spread over multiple lines, but do not support assignment:
 
 .. code-block:: ipython
 
     In[1]: %%bash
     ...  : echo "My shell is:" $SHELL
     ...  : echo "My disk usage is:"
     ...  : df -h
     My shell is: /usr/local/bin/bash
     My disk usage is:
     Filesystem      Size   Used  Avail Capacity  iused   ifree %iused  Mounted on
     /dev/disk1     233Gi  216Gi   16Gi    94% 56788108 4190706   93%   /
     devfs          190Ki  190Ki    0Bi   100%      656       0  100%   /dev
     map -hosts       0Bi    0Bi    0Bi   100%        0       0  100%   /net
     map auto_home    0Bi    0Bi    0Bi   100%        0       0  100%   /hom
 
 
 Combining it all
 ----------------
 
 ::
 
     find a snippet that combine all that into one thing!

docs/source/overview.rst

@@ -1,291 +1,291 b''
 .. _overview:
 
 ============
 Introduction
 ============
 
 Overview
 ========
 
 One of Python's most useful features is its interactive interpreter.
 It allows for very fast testing of ideas without the overhead of
 creating test files as is typical in most programming languages.
 However, the interpreter supplied with the standard Python distribution
 is somewhat limited for extended interactive use.
 
 The goal of IPython is to create a comprehensive environment for
 interactive and exploratory computing.  To support this goal, IPython
 has three main components:
 
 * An enhanced interactive Python shell.
 * A decoupled :ref:`two-process communication model <ipythonzmq>`, which
   allows for multiple clients to connect to a computation kernel, most notably
-  the web-based :ref:`notebook <htmlnotebook>`
+  the web-based notebook.
 * An architecture for interactive parallel computing.
 
 All of IPython is open source (released under the revised BSD license).
 
 Enhanced interactive Python shell
 =================================
 
 IPython's interactive shell (:command:`ipython`), has the following goals,
 amongst others:
 
 1. Provide an interactive shell superior to Python's default. IPython
    has many features for tab-completion, object introspection, system shell
    access, command history retrieval across sessions, and its own special
    command system for adding functionality when working interactively. It
    tries to be a very efficient environment both for Python code development
    and for exploration of problems using Python objects (in situations like
    data analysis).
   
 2. Serve as an embeddable, ready to use interpreter for your own
    programs. An interactive IPython shell can be started with a single call
    from inside another program, providing access to the current namespace.
    This can be very useful both for debugging purposes and for situations
    where a blend of batch-processing and interactive exploration are needed.
   
 3. Offer a flexible framework which can be used as the base
    environment for working with other systems, with Python as the underlying
    bridge language. Specifically scientific environments like Mathematica,
    IDL and Matlab inspired its design, but similar ideas can be
    useful in many fields.
   
 4. Allow interactive testing of threaded graphical toolkits. IPython
    has support for interactive, non-blocking control of GTK, Qt, WX, GLUT, and
    OS X applications via special threading flags. The normal Python
    shell can only do this for Tkinter applications.
 
 Main features of the interactive shell
 --------------------------------------
 
 * Dynamic object introspection. One can access docstrings, function
   definition prototypes, source code, source files and other details
   of any object accessible to the interpreter with a single
   keystroke (:samp:`?`, and using :samp:`??` provides additional detail).
   
 * Searching through modules and namespaces with :samp:`*` wildcards, both
   when using the :samp:`?` system and via the :samp:`%psearch` command.
 
 * Completion in the local namespace, by typing :kbd:`TAB` at the prompt.
   This works for keywords, modules, methods, variables and files in the
   current directory. This is supported via the readline library, and
   full access to configuring readline's behavior is provided. 
   Custom completers can be implemented easily for different purposes
   (system commands, magic arguments etc.)
 
 * Numbered input/output prompts with command history (persistent
   across sessions and tied to each profile), full searching in this
   history and caching of all input and output.
 
 * User-extensible 'magic' commands. A set of commands prefixed with
   :samp:`%` is available for controlling IPython itself and provides
   directory control, namespace information and many aliases to
   common system shell commands.
 
 * Alias facility for defining your own system aliases.
 
 * Complete system shell access. Lines starting with :samp:`!` are passed
   directly to the system shell, and using :samp:`!!` or :samp:`var = !cmd` 
   captures shell output into python variables for further use.
 
 * The ability to expand python variables when calling the system shell. In a
   shell command, any python variable prefixed with :samp:`$` is expanded. A
   double :samp:`$$` allows passing a literal :samp:`$` to the shell (for access
   to shell and environment variables like :envvar:`PATH`).
 
 * Filesystem navigation, via a magic :samp:`%cd` command, along with a
   persistent bookmark system (using :samp:`%bookmark`) for fast access to
   frequently visited directories.
 
 * A lightweight persistence framework via the :samp:`%store` command, which
   allows you to save arbitrary Python variables. These get restored
   when you run the :samp:`%store -r` command.
 
 * Automatic indentation (optional) of code as you type (through the
   readline library).
 
 * Macro system for quickly re-executing multiple lines of previous
   input with a single name via the :samp:`%macro` command. Macros can be
   stored persistently via :samp:`%store` and edited via :samp:`%edit`.
 
 * Session logging (you can then later use these logs as code in your
   programs). Logs can optionally timestamp all input, and also store
   session output (marked as comments, so the log remains valid
   Python source code).
 
 * Session restoring: logs can be replayed to restore a previous
   session to the state where you left it.
 
 * Verbose and colored exception traceback printouts. Easier to parse
   visually, and in verbose mode they produce a lot of useful
   debugging information (basically a terminal version of the cgitb
   module).
 
 * Auto-parentheses via the :samp:`%autocall` command: callable objects can be
   executed without parentheses: :samp:`sin 3` is automatically converted to
   :samp:`sin(3)`
 
 * Auto-quoting: using :samp:`,`, or :samp:`;` as the first character forces
   auto-quoting of the rest of the line: :samp:`,my_function a b` becomes
   automatically :samp:`my_function("a","b")`, while :samp:`;my_function a b`
   becomes :samp:`my_function("a b")`.
 
 * Extensible input syntax. You can define filters that pre-process
   user input to simplify input in special situations. This allows
   for example pasting multi-line code fragments which start with
   :samp:`>>>` or :samp:`...` such as those from other python sessions or the
   standard Python documentation.
 
 * Flexible :ref:`configuration system <config_overview>`. It uses a
   configuration file which allows permanent setting of all command-line
   options, module loading, code and file execution. The system allows
   recursive file inclusion, so you can have a base file with defaults and
   layers which load other customizations for particular projects.
 
 * Embeddable. You can call IPython as a python shell inside your own
   python programs. This can be used both for debugging code or for
   providing interactive abilities to your programs with knowledge
   about the local namespaces (very useful in debugging and data
   analysis situations).
 
 * Easy debugger access. You can set IPython to call up an enhanced version of
   the Python debugger (pdb) every time there is an uncaught exception. This
   drops you inside the code which triggered the exception with all the data
   live and it is possible to navigate the stack to rapidly isolate the source
   of a bug. The :samp:`%run` magic command (with the :samp:`-d` option) can run
   any script under pdb's control, automatically setting initial breakpoints for
   you.  This version of pdb has IPython-specific improvements, including
   tab-completion and traceback coloring support. For even easier debugger
   access, try :samp:`%debug` after seeing an exception.
 
 * Profiler support. You can run single statements (similar to
   :samp:`profile.run()`) or complete programs under the profiler's control.
   While this is possible with standard cProfile or profile modules,
   IPython wraps this functionality with magic commands (see :samp:`%prun`
   and :samp:`%run -p`) convenient for rapid interactive work.
 
 * Simple timing information. You can use the :samp:`%timeit` command to get
   the execution time of a Python statement or expression. This machinery is
   intelligent enough to do more repetitions for commands that finish very
   quickly in order to get a better estimate of their running time. 
 
 .. sourcecode:: ipython
 
     In [1]: %timeit 1+1
     10000000 loops, best of 3: 25.5 ns per loop
 
     In [2]: %timeit [math.sin(x) for x in range(5000)]
     1000 loops, best of 3: 719 µs per loop
 
 .. 
 
   To get the timing information for more than one expression, use the
   :samp:`%%timeit` cell magic command.
   
 
 * Doctest support. The special :samp:`%doctest_mode` command toggles a mode
   to use doctest-compatible prompts, so you can use IPython sessions as
   doctest code. By default, IPython also allows you to paste existing
   doctests, and strips out the leading :samp:`>>>` and :samp:`...` prompts in
   them.
 
 .. _ipythonzmq:
 
 Decoupled two-process model
 ==============================
 
 IPython has abstracted and extended the notion of a traditional
 *Read-Evaluate-Print Loop* (REPL) environment by decoupling the *evaluation*
 into its own process. We call this process a **kernel**: it receives execution
 instructions from clients and communicates the results back to them.
 
 This decoupling allows us to have several clients connected to the same
 kernel, and even allows clients and kernels to live on different machines.
 With the exclusion of the traditional single process terminal-based IPython
 (what you start if you run ``ipython`` without any subcommands), all
 other IPython machinery uses this two-process model. This includes ``ipython
 console``,  ``ipython qtconsole``, and ``ipython notebook``.
 
 As an example, this means that when you start ``ipython qtconsole``, you're
 really starting two processes, a kernel and a Qt-based client can send
 commands to and receive results from that kernel. If there is already a kernel
 running that you want to connect to, you can pass the  ``--existing`` flag
 which will skip initiating a new kernel and connect to the most recent kernel,
 instead. To connect to a specific kernel once you have several kernels
 running, use the ``%connect_info`` magic to get the unique connection file,
 which will be something like ``--existing kernel-19732.json`` but with
 different numbers which correspond to the Process ID of the kernel.
 
 You can read more about using `ipython qtconsole 
 <http://jupyter.org/qtconsole/>`_, and
 `ipython notebook <http://jupyter-notebook.readthedocs.io/en/latest/>`_. There 
 is also a :ref:`message spec <messaging>` which documents the protocol for 
 communication between kernels
 and clients.
 
 .. seealso::
     
     `Frontend/Kernel Model`_ example notebook
 
 
 Interactive parallel computing
 ==============================
 
 Increasingly, parallel computer hardware, such as multicore CPUs, clusters and
 supercomputers, is becoming ubiquitous. Over the last several years, we have
 developed an architecture within IPython that allows such hardware to be used
 quickly and easily from Python. Moreover, this architecture is designed to
 support interactive and collaborative parallel computing.
 
 The main features of this system are:
 
 * Quickly parallelize Python code from an interactive Python/IPython session.
 
 * A flexible and dynamic process model that be deployed on anything from 
   multicore workstations to supercomputers.
 
 * An architecture that supports many different styles of parallelism, from
   message passing to task farming.  And all of these styles can be handled
   interactively.
 
 * Both blocking and fully asynchronous interfaces.
 
 * High level APIs that enable many things to be parallelized in a few lines
   of code.
 
 * Write parallel code that will run unchanged on everything from multicore
   workstations to supercomputers.
 
 * Full integration with Message Passing libraries (MPI).
 
 * Capabilities based security model with full encryption of network connections.
 
 * Share live parallel jobs with other users securely.  We call this
   collaborative parallel computing.
 
 * Dynamically load balanced task farming system.
 
 * Robust error handling.  Python exceptions raised in parallel execution are
   gathered and presented to the top-level code.
 
 For more information, see our :ref:`overview <parallel_index>` of using IPython
 for parallel computing.
 
 Portability and Python requirements
 -----------------------------------
 
 As of the 2.0 release, IPython works with Python 2.7 and 3.3 or above.
 Version 1.0 additionally worked with Python 2.6 and 3.2.
 Version 0.12 was the first version to fully support Python 3.
 
 IPython is known to work on the following operating systems:
 
 	* Linux
 	* Most other Unix-like OSs (AIX, Solaris, BSD, etc.)
 	* Mac OS X
 	* Windows (CygWin, XP, Vista, etc.)
 
 See :ref:`here <install_index>` for instructions on how to install IPython.
 
 .. include:: links.txt

docs/source/whatsnew/version0.12.rst

@@ -1,370 +1,369 b''
 =============
  0.12 Series
 =============
 
 Release 0.12.1
 ==============
 
 IPython 0.12.1 is a bugfix release of 0.12, pulling only bugfixes and minor
 cleanup from 0.13, timed for the Ubuntu 12.04 LTS release.
 
 See the :ref:`list of fixed issues <issues_list_012>` for specific backported issues.
 
 
 Release 0.12
 ============
 
 IPython 0.12 contains several major new features, as well as a large amount of
 bug and regression fixes.  The 0.11 release brought with it a lot of new
 functionality and major refactorings of the codebase; by and large this has
 proven to be a success as the number of contributions to the project has
 increased dramatically, proving that the code is now much more approachable.
 But in the refactoring inevitably some bugs were introduced, and we have also
 squashed many of those as well as recovered some functionality that had been
 temporarily disabled due to the API changes.
 
 The following major new features appear in this version.
 
 
 An interactive browser-based Notebook with rich media support
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 A powerful new interface puts IPython in your browser. You can start it with
 the command ``ipython notebook``:
 
 .. figure:: ../_images/notebook_specgram.png
     :width: 400px
     :alt: The IPython notebook with embedded text, code, math and figures.
     :align: center
     :target: ../_images/notebook_specgram.png
 
     The new IPython notebook showing text, mathematical expressions in LaTeX,
     code, results and embedded figures created with Matplotlib.
 
 This new interface maintains all the features of IPython you are used to, as it
 is a new client that communicates with the same IPython kernels used by the
 terminal and Qt console.  But the web notebook provides for a different
 workflow where you can integrate, along with code execution, also text,
 mathematical expressions, graphics, video, and virtually any content that a
 modern browser is capable of displaying.
 
 You can save your work sessions as documents that retain all these elements and
 which can be version controlled, emailed to colleagues or saved as HTML or PDF
 files for printing or publishing statically on the web.  The internal storage
 format is a JSON file that can be easily manipulated for manual exporting to
 other formats.
 
 This Notebook is a major milestone for IPython, as for years we have tried to
 build this kind of system.  We were inspired originally by the excellent
 implementation in Mathematica, we made a number of attempts using older
 technologies in earlier Summer of Code projects in 2005 (both students and
 Robert Kern developed early prototypes), and in recent years we have seen the
 excellent implementation offered by the `Sage <http://sagemath.org>` system.
 But we continued to work on something that would be consistent with the rest of
 IPython's design, and it is clear now that the effort was worth it: based on
 the ZeroMQ communications architecture introduced in version 0.11, the notebook
 can now retain 100% of the features of the real IPython.  But it can also
 provide the rich media support and high quality Javascript libraries that were
 not available in browsers even one or two years ago (such as high-quality
 mathematical rendering or built-in video).
 
 The notebook has too many useful and important features to describe in these
 release notes; our documentation now contains a directory called
 ``examples/notebooks`` with several notebooks that illustrate various aspects
 of the system.  You should start by reading those named
 ``00_notebook_tour.ipynb`` and ``01_notebook_introduction.ipynb`` first, and
 then can proceed to read the others in any order you want.
 
 To start the notebook server, go to a directory containing the notebooks you
 want to open (or where you want to create new ones) and type::
 
   ipython notebook
 
 You can see all the relevant options with::
 
   ipython notebook --help
   ipython notebook --help-all  # even more
 
 and just like the Qt console, you can start the notebook server with pylab
 support by using::
   
   ipython notebook --pylab
 
 for floating matplotlib windows or::
   
   ipython notebook --pylab inline
 
 for plotting support with automatically inlined figures.  Note that it is now
 possible also to activate pylab support at runtime via ``%pylab``, so you do
 not need to make this decision when starting the server.
-  
-See :ref:`the Notebook docs <htmlnotebook>` for technical details.
+
 
 .. _two_process_console:
 
 Two-process terminal console
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Based on the same architecture as the notebook and the Qt console, we also have
 now a terminal-based console that can connect to an external IPython kernel
 (the same kernels used by the Qt console or the notebook, in fact).  While this
 client behaves almost identically to the usual IPython terminal application,
 this capability can be very useful to attach an interactive console to an
 existing kernel that was started externally.  It lets you use the interactive
 ``%debug`` facilities in a notebook, for example (the web browser can't
 interact directly with the debugger) or debug a third-party code where you may
 have embedded an IPython kernel.
 
 This is also something that we have wanted for a long time, and which is a
 culmination (as a team effort) of the work started last year during the 2010
 Google Summer of Code project.
   
 Tabbed QtConsole
 ~~~~~~~~~~~~~~~~
 
 The QtConsole now supports starting multiple kernels in tabs, and has a
 menubar, so it looks and behaves more like a real application.  Keyboard
 enthusiasts can disable the menubar with ctrl-shift-M (:ghpull:`887`).
 
 .. figure:: ../_images/qtconsole_tabbed.png
     :width: 400px
     :alt: Tabbed IPython Qt console with embedded plots and menus.
     :align: center
     :target: ../_images/qtconsole_tabbed.png
 
     The improved Qt console for IPython, now with tabs to control multiple
     kernels and full menu support.
 
 
 Full Python 3 compatibility
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 IPython can now be installed from a single codebase on Python 2 and
 Python 3. The installation process for Python 3 automatically runs 2to3. The
 same 'default' profile is now used for Python 2 and 3 (the previous version had
 a separate 'python3' profile).
 
 Standalone Kernel
 ~~~~~~~~~~~~~~~~~
 
 The ``ipython kernel`` subcommand has been added, to allow starting a
 standalone kernel, that can be used with various frontends.  You can then later
 connect a Qt console or a terminal console to this kernel by typing e.g.::
 
   ipython qtconsole --existing
 
 if it's the only one running, or by passing explicitly the connection
 parameters (printed by the kernel at startup).
 
 
 PyPy support
 ~~~~~~~~~~~~
 
 The terminal interface to IPython now runs under `PyPy <http://pypy.org/>`_.
 We will continue to monitor PyPy's progress, and hopefully before long at least
 we'll be able to also run the notebook.  The Qt console may take longer, as Qt
 is a very complex set of bindings to a huge C++ library, and that is currently
 the area where PyPy still lags most behind.  But for everyday interactive use
 at the terminal, with this release and PyPy 1.7, things seem to work quite well
 from our admittedly limited testing.
 
   
 Other important new features
 ----------------------------
 
 * **SSH Tunnels**: In 0.11, the :mod:`IPython.parallel` Client could tunnel its
-  connections to the Controller via ssh. Now, the QtConsole :ref:`supports
-  <ssh_tunnels>` ssh tunneling, as do parallel engines.
+  connections to the Controller via ssh. Now, the QtConsole supports ssh tunneling,
+  as do parallel engines.
 
 * **relaxed command-line parsing**: 0.11 was released with overly-strict
   command-line parsing, preventing the ability to specify arguments with spaces,
   e.g. ``ipython --pylab qt`` or ``ipython -c "print 'hi'"``. This has
   been fixed, by using argparse. The new parsing is a strict superset of 0.11, so
   any commands in 0.11 should still work in 0.12.
 
 * **HistoryAccessor**: The :class:`~IPython.core.history.HistoryManager` class
   for interacting with your IPython SQLite history database has been split,
   adding a parent :class:`~IPython.core.history.HistoryAccessor` class, so that
   users can write code to access and search their IPython history without being
   in an IPython session (:ghpull:`824`).
 
 * **kernel %gui and %pylab**: The ``%gui`` and ``%pylab`` magics have been
   restored to the IPython kernel (e.g. in the qtconsole or notebook). This
   allows activation of pylab-mode, or eventloop integration after starting the
   kernel, which was unavailable in 0.11.  Unlike in the terminal, this can be
   set only once, and cannot be changed.
 
 * **%config**: A new ``%config`` magic has been added, giving easy access to the
   IPython configuration system at runtime (:ghpull:`923`).
 
 * **Multiline History**: Multiline readline history has been restored to the
   Terminal frontend by default (:ghpull:`838`).
 
 * **%store**: The ``%store`` magic from earlier versions has been updated and
   re-enabled (:ref:`extensions_storemagic`; :ghpull:`1029`). To autorestore
   stored variables on startup, specify ``c.StoreMagic.autorestore = True`` in
   :file:`ipython_config.py`.
 
 
 Major Bugs fixed
 ----------------
 
 In this cycle, we have :ref:`closed over 500 issues <issues_list_012>`, but a
 few major ones merit special mention:
 
 * Simple configuration errors should no longer crash IPython. In 0.11, errors
   in config files, as well as invalid trait values, could crash IPython. Now,
   such errors are reported, and help is displayed.
 
 * Certain SyntaxErrors no longer crash IPython (e.g. just typing keywords, such
   as ``return``, ``break``, etc.). See :ghissue:`704`.
 
 * IPython path utils, such as :func:`~IPython.utils.path.get_ipython_dir` now
   check for write permissions, so IPython should function on systems where the
   default path resolution might point to a read-only location, such as
   ``HOMESHARE`` on Windows (:ghissue:`669`).
 
 * :func:`raw_input` now works in the kernel when multiple frontends are in
   use. The request will be sent to the frontend that made the request, and an
   exception is raised if that frontend does not support stdin requests
   (e.g. the notebook) (:ghissue:`673`).
 
 * :mod:`zmq` version detection no longer uses simple lexicographical comparison
   to check minimum version, which prevents 0.11 from working with pyzmq-2.1.10
   (:ghpull:`758`).
 
 * A bug in PySide < 1.0.7 caused crashes on OSX when tooltips were shown
   (:ghissue:`711`). these tooltips are now disabled on old PySide
   (:ghpull:`963`).
 
 * IPython no longer crashes when started on recent versions of Python 3 in
   Windows (:ghissue:`737`).
 
 * Instances of classes defined interactively can now be pickled (:ghissue:`29`;
   :ghpull:`648`). Note that pickling saves a reference to the class definition,
   so unpickling the instances will only work where the class has been defined.
 
 
 Backwards incompatible changes
 ------------------------------
 
 * IPython connection information is no longer specified via ip/port directly,
   rather via json connection files.  These files are stored in the security
   directory, and enable us to turn on HMAC message authentication by default,
   significantly improving the security of kernels.  Various utility functions
   have been added to :mod:`IPython.lib.kernel`, for easier connecting to existing
   kernels.
 
 * :class:`~IPython.zmq.kernelmanager.KernelManager` now has one ip, and several
   port traits, rather than several ip/port pair ``_addr`` traits. This better
   matches the rest of the code, where the ip cannot not be set separately for
   each channel.
 
 * Custom prompts are now configured using a new class,
   :class:`~IPython.core.prompts.PromptManager`, which has traits for
   :attr:`in_template`, :attr:`in2_template` (the ``...:`` continuation prompt),
   :attr:`out_template` and :attr:`rewrite_template`. This uses Python's string
   formatting system, so you can use ``{time}`` and ``{cwd}``, although we have
   preserved the abbreviations from previous versions, e.g. ``\#`` (prompt number)
   and ``\w`` (working directory). For the list of available fields, refer to the
   source of :file:`IPython/core/prompts.py`.
 
 * The class inheritance of the Launchers in
   :mod:`IPython.parallel.apps.launcher` used by ipcluster has changed, so that
   trait names are more consistent across batch systems. This may require a few
   renames in your config files, if you customized the command-line args for
   launching controllers and engines. The configurable names have also been
   changed to be clearer that they point to class names, and can now be
   specified by name only, rather than requiring the full import path of each
   class, e.g.::
 
     IPClusterEngines.engine_launcher = 'IPython.parallel.apps.launcher.MPIExecEngineSetLauncher'
     IPClusterStart.controller_launcher = 'IPython.parallel.apps.launcher.SSHControllerLauncher'
 
   would now be specified as::
 
     IPClusterEngines.engine_launcher_class = 'MPI'
     IPClusterStart.controller_launcher_class = 'SSH'
 
   The full path will still work, and is necessary for using custom launchers
   not in IPython's launcher module.
   
   Further, MPIExec launcher names are now prefixed with just MPI, to better match
   other batch launchers, and be generally more intuitive.  The MPIExec names are
   deprecated, but continue to work.
 
 * For embedding a shell, note that the parameters ``user_global_ns`` and
   ``global_ns`` have been deprectated in favour of ``user_module`` and
   ``module`` respsectively.  The new parameters expect a module-like object,
   rather than a namespace dict.  The old parameters remain for backwards
   compatibility, although ``user_global_ns`` is now ignored. The ``user_ns``
   parameter works the same way as before, and calling
   :func:`~IPython.frontend.terminal.embed.embed` with no arguments still works
   as before.
 
 
 Development summary and credits
 -------------------------------
 
 The previous version (IPython 0.11) was released on July 31 2011, so this
 release cycle was roughly 4 1/2 months long, we closed a total of 515 issues,
 257 pull requests and 258 regular issues (a :ref:`detailed list
 <issues_list_012>` is available).
 
 Many users and developers contributed code, features, bug reports and ideas to
 this release.  Please do not hesitate in contacting us if we've failed to
 acknowledge your contribution here.  In particular, for this release we have
 had commits from the following 45 contributors, a mix of new and regular names
 (in alphabetical order by first name):
 
 * Alcides <alcides-at-do-not-span-me.com>
 * Ben Edwards <bedwards-at-cs.unm.edu>
 * Benjamin Ragan-Kelley <benjaminrk-at-gmail.com>
 * Benjamin Thyreau <benjamin.thyreau-at-gmail.com>
 * Bernardo B. Marques <bernardo.fire-at-gmail.com>
 * Bernard Paulus <bprecyclebin-at-gmail.com>
 * Bradley M. Froehle <brad.froehle-at-gmail.com>
 * Brian E. Granger <ellisonbg-at-gmail.com>
 * Christian Boos <cboos-at-bct-technology.com>
 * Daniel Velkov <danielv-at-mylife.com>
 * Erik Tollerud <erik.tollerud-at-gmail.com>
 * Evan Patterson <epatters-at-enthought.com>
 * Felix Werner <Felix.Werner-at-kit.edu>
 * Fernando Perez <Fernando.Perez-at-berkeley.edu>
 * Gabriel <g2p.code-at-gmail.com>
 * Grahame Bowland <grahame-at-angrygoats.net>
 * Hannes Schulz <schulz-at-ais.uni-bonn.de>
 * Jens Hedegaard Nielsen <jenshnielsen-at-gmail.com>
 * Jonathan March <jmarch-at-enthought.com>
 * Jörgen Stenarson <jorgen.stenarson-at-bostream.nu>
 * Julian Taylor <jtaylor.debian-at-googlemail.com>
 * Kefu Chai <tchaikov-at-gmail.com>
 * macgyver <neil.rabinowitz-at-merton.ox.ac.uk>
 * Matt Cottingham <matt.cottingham-at-gmail.com>
 * Matthew Brett <matthew.brett-at-gmail.com>
 * Matthias BUSSONNIER <bussonniermatthias-at-gmail.com>
 * Michael Droettboom <mdboom-at-gmail.com>
 * Nicolas Rougier <Nicolas.Rougier-at-inria.fr>
 * Olivier Verdier <olivier.verdier-at-gmail.com>
 * Omar Andres Zapata Mesa <andresete.chaos-at-gmail.com>
 * Pablo Winant <pablo.winant-at-gmail.com>
 * Paul Ivanov <pivanov314-at-gmail.com>
 * Pauli Virtanen <pav-at-iki.fi>
 * Pete Aykroyd <aykroyd-at-gmail.com>
 * Prabhu Ramachandran <prabhu-at-enthought.com>
 * Puneeth Chaganti <punchagan-at-gmail.com>
 * Robert Kern <robert.kern-at-gmail.com>
 * Satrajit Ghosh <satra-at-mit.edu>
 * Stefan van der Walt <stefan-at-sun.ac.za>
 * Szabolcs Horvát <szhorvat-at-gmail.com>
 * Thomas Kluyver <takowl-at-gmail.com>
 * Thomas Spura <thomas.spura-at-gmail.com>
 * Timo Paulssen <timonator-at-perpetuum-immobile.de>
 * Valentin Haenel <valentin.haenel-at-gmx.de>
 * Yaroslav Halchenko <debian-at-onerussian.com>
    
 .. note::
 
     This list was generated with the output of
     ``git log rel-0.11..HEAD --format='* %aN <%aE>' | sed 's/@/\-at\-/' | sed 's/<>//' | sort -u``
     after some cleanup.  If you should be on this list, please add yourself.

docs/source/whatsnew/version1.0.rst

@@ -1,306 +1,302 b''
 ============
  1.0 Series
 ============
 
 Release 1.0.0: An Afternoon Hack
 ================================
 
 
 IPython 1.0 requires Python ≥ 2.6.5 or ≥ 3.2.1.
 It does not support Python 3.0, 3.1, or 2.5.
 
 This is a big release.  The principal milestone is the addition of :mod:`IPython.nbconvert`,
 but there has been a great deal of work improving all parts of IPython as well.
 
 The previous version (0.13) was released on June 30, 2012,
 and in this development cycle we had:
 
 - ~12 months of work.
 - ~700 pull requests merged.
 - ~600 issues closed (non-pull requests).
 - contributions from ~150 authors.
 - ~4000 commits.
 
 The amount of work included in this release is so large that we can only cover
 here the main highlights; please see our :ref:`detailed release statistics
 <issues_list_100>` for links to every issue and pull request closed on GitHub
 as well as a full list of individual contributors.
 It includes
 
 Reorganization
 --------------
 
 There have been two major reorganizations in IPython 1.0:
 
 - Added :mod:`IPython.kernel` for all kernel-related code.
   This means that :mod:`IPython.zmq` has been removed,
   and much of it is now in :mod:`IPython.kernel.zmq`,
   some of it being in the top-level :mod:`IPython.kernel`.
 - We have removed the `frontend` subpackage,
   as it caused unnecessary depth.  So what was :mod:`IPython.frontend.qt`
   is now :mod:`IPython.qt`, and so on.  The one difference is that
   the notebook has been further flattened, so that
   :mod:`IPython.frontend.html.notebook` is now just `IPython.html`.
   There is a shim module, so :mod:`IPython.frontend` is still
   importable in 1.0, but there will be a warning.
 - The IPython sphinx directives are now installed in :mod:`IPython.sphinx`,
   so they can be imported by other projects.
 
 
 Public APIs
 -----------
 
 For the first time since 0.10 (sorry, everyone),
 there is an official public API for starting IPython:
 
 .. sourcecode:: python
 
     from IPython import start_ipython
     start_ipython()
 
 This is what packages should use that start their own IPython session,
 but don't actually want embedded IPython (most cases).
 :func:`IPython.embed()` is used for embedding IPython into the calling namespace,
 similar to calling :func:`Pdb.set_trace`, whereas :func:`start_ipython`
 will start a plain IPython session, loading config and startup files as normal.
 
 We also have added:
 
 .. sourcecode:: python
 
     from IPython import get_ipython
 
 
 Which is a *library* function for getting the current IPython instance,
 and will return ``None`` if no IPython instance is running.
 This is the official way to check whether your code is called from inside an IPython session.
 If you want to check for IPython without unnecessarily importing IPython,
 use this function:
 
 .. sourcecode:: python
 
     def get_ipython():
         """return IPython instance if there is one, None otherwise"""
         import sys
         if "IPython" in sys.modules:
             import IPython
             return IPython.get_ipython()
 
 Core
 ----
 
 - The input transformation framework has been reworked. This fixes some corner
   cases, and adds more flexibility for projects which use IPython, like SymPy &
   SAGE. For more details, see :doc:`/config/inputtransforms`.
 - Exception types can now be displayed with a custom traceback, by defining a
   ``_render_traceback_()`` method which returns a list of strings, each
   containing one line of the traceback.
 - A new command, ``ipython history trim`` can be used to delete everything but
   the last 1000 entries in the history database.
 - ``__file__`` is defined in both config files at load time,
   and ``.ipy`` files executed with ``%run``.
 - ``%logstart`` and ``%logappend`` are no longer broken.
 - Add glob expansion for ``%run``, e.g. ``%run -g script.py *.txt``.
 - Expand variables (``$foo``) in Cell Magic argument line.
 - By default, :command:`iptest` will exclude various slow tests.
   All tests can be run with :command:`iptest --all`.
 - SQLite history can be disabled in the various cases that it does not behave well.
 - ``%edit`` works on interactively defined variables.
 - editor hooks have been restored from quarantine, enabling TextMate as editor,
   etc.
 - The env variable PYTHONSTARTUP is respected by IPython.
 - The ``%matplotlib`` magic was added, which is like the old ``%pylab`` magic,
   but it does not import anything to the interactive namespace.
   It is recommended that users switch to ``%matplotlib`` and explicit imports.
 - The ``--matplotlib`` command line flag was also added. It invokes the new
   ``%matplotlib`` magic and can be used in the same way as the old ``--pylab``
   flag. You can either use it by itself as a flag (``--matplotlib``), or you
   can also pass a backend explicitly (``--matplotlib qt`` or
   ``--matplotlib=wx``, etc).
 
 
 Backwards incompatible changes
 ******************************
 
 - Calling :meth:`InteractiveShell.prefilter` will no longer perform static
   transformations - the processing of escaped commands such as ``%magic`` and
   ``!system``, and stripping input prompts from code blocks. This functionality
   was duplicated in :mod:`IPython.core.inputsplitter`, and the latter version
   was already what IPython relied on. A new API to transform input will be ready
   before release.
 - Functions from :mod:`IPython.lib.inputhook` to control integration with GUI
   event loops are no longer exposed in the top level of :mod:`IPython.lib`.
   Code calling these should make sure to import them from
   :mod:`IPython.lib.inputhook`.
 - For all kernel managers, the ``sub_channel`` attribute has been renamed to
   ``iopub_channel``.
 - Users on Python versions before 2.6.6, 2.7.1 or 3.2 will now need to call
   :func:`IPython.utils.doctestreload.doctest_reload` to make doctests run 
   correctly inside IPython. Python releases since those versions are unaffected.
   For details, see :ghpull:`3068` and `Python issue 8048 <http://bugs.python.org/issue8048>`_.
 - The ``InteractiveShell.cache_main_mod()`` method has been removed, and
   :meth:`~IPython.core.interactiveshell.InteractiveShell.new_main_mod` has a
   different signature, expecting a filename where earlier versions expected
   a namespace. See :ghpull:`3555` for details.
 - The short-lived plugin system has been removed. Extensions are the way to go.
 
 
 .. _nbconvert1:
 
 NbConvert
 ---------
 
 The major milestone for IPython 1.0 is the addition of :mod:`IPython.nbconvert` - tools for converting
 IPython notebooks to various other formats.
 
 .. warning::
 
     nbconvert is α-level preview code in 1.0
 
 To use nbconvert to convert various file formats::
 
     ipython nbconvert --to html *.ipynb
 
 See ``ipython nbconvert --help`` for more information.
 nbconvert depends on `pandoc`_ for many of the translations to and from various formats.
 
-.. seealso::
-
-    :ref:`nbconvert`
-
 .. _pandoc: http://johnmacfarlane.net/pandoc/
 
 Notebook
 --------
 
 Major changes to the IPython Notebook in 1.0:
 
 - The notebook is now autosaved, by default at an interval of two minutes.
   When you press 'save' or Ctrl-S, a *checkpoint* is made, in a hidden folder.
   This checkpoint can be restored, so that the autosave model is strictly safer
   than traditional save. If you change nothing about your save habits,
   you will always have a checkpoint that you have written,
   and an autosaved file that is kept up to date.
 - The notebook supports :func:`raw_input` / :func:`input`, and thus also ``%debug``,
   and many other Python calls that expect user input.
 - You can load custom javascript and CSS in the notebook by editing the files
   :file:`$(ipython locate profile)/static/custom/custom.{js,css}`.
 - Add ``%%html``, ``%%svg``, ``%%javascript``, and ``%%latex`` cell magics
   for writing raw output in notebook cells.
 - add a redirect handler and anchors on heading cells, so you can link
   across notebooks, directly to heading cells in other notebooks.
 - Images support width and height metadata,
   and thereby 2x scaling (retina support).
 - ``_repr_foo_`` methods can return a tuple of (data, metadata),
   where metadata is a dict containing metadata about the displayed object.
   This is used to set size, etc. for retina graphics. To enable retina matplotlib figures,
   simply set ``InlineBackend.figure_format = 'retina'`` for 2x PNG figures,
   in your :ref:`IPython config file <config_overview>` or via the ``%config`` magic.
 - Add display.FileLink and FileLinks for quickly displaying HTML links to local files.
 - Cells have metadata, which can be edited via cell toolbars.
   This metadata can be used by external code (e.g. reveal.js or exporters),
   when examining the notebook.
 - Fix an issue parsing LaTeX in markdown cells, which required users to type ``\\\``,
   instead of ``\\``.
 - Notebook templates are rendered with Jinja instead of Tornado.
 - ``%%file`` has been renamed ``%%writefile`` (``%%file`` is deprecated).
 - ANSI (and VT100) color parsing has been improved in both performance and
   supported values.
 - The static files path can be found as ``IPython.html.DEFAULT_STATIC_FILES_PATH``,
   which may be changed by package managers.
 - IPython's CSS is installed in :file:`static/css/style.min.css`
   (all style, including bootstrap), and :file:`static/css/ipython.min.css`,
   which only has IPython's own CSS. The latter file should be useful for embedding
   IPython notebooks in other pages, blogs, etc.
 - The Print View has been removed. Users are encouraged to test :ref:`ipython
   nbconvert <nbconvert1>` to generate a static view.
 
 Javascript Components
 *********************
 
 The javascript components used in the notebook have been updated significantly.
 
 - updates to jQuery (2.0) and jQueryUI (1.10)
 - Update CodeMirror to 3.14
 - Twitter Bootstrap (2.3) for layout
 - Font-Awesome (3.1) for icons
 - highlight.js (7.3) for syntax highlighting
 - marked (0.2.8) for markdown rendering
 - require.js (2.1) for loading javascript
 
 Some relevant changes that are results of this:
 
 - Markdown cells now support GitHub-flavored Markdown (GFM),
   which includes `````python`` code blocks and tables.
 - Notebook UI behaves better on more screen sizes.
 - Various code cell input issues have been fixed.
 
 
 Kernel
 ------
 
 The kernel code has been substantially reorganized.
 
 New features in the kernel:
 
 - Kernels support ZeroMQ IPC transport, not just TCP
 - The message protocol has added a top-level metadata field,
   used for information about messages.
 - Add a `data_pub` message that functions much like `display_pub`,
   but publishes raw (usually pickled) data, rather than representations.
 - Ensure that ``sys.stdout.encoding`` is defined in Kernels.
 - Stdout from forked subprocesses should be forwarded to frontends (instead of crashing).
 
 IPEP 13
 *******
 
 The KernelManager has been split into a :class:`~.KernelManager` and a :class:`~.KernelClient`.
 The Manager owns a kernel and starts / signals / restarts it. There is always zero or one
 KernelManager per Kernel.  Clients communicate with Kernels via zmq channels,
 and there can be zero-to-many Clients connected to a Kernel at any given time.
 
 The KernelManager now automatically restarts the kernel when it dies,
 rather than requiring user input at the notebook or QtConsole UI
 (which may or may not exist at restart time).
 
 In-process kernels
 ******************
 
 The Python-language frontends, particularly the Qt console, may now communicate
 with in-process kernels, in addition to the traditional out-of-process
 kernels. An in-process kernel permits direct access to the kernel namespace,
 which is necessary in some applications. It should be understood, however, that
 the in-process kernel is not robust to bad user input and will block the main
 (GUI) thread while executing. Developers must decide on a case-by-case basis
 whether this tradeoff is appropriate for their application.
 
 
 
 Parallel
 --------
 
 IPython.parallel has had some refactoring as well.  
 There are many improvements and fixes, but these are the major changes:
 
 - Connections have been simplified. All ports and the serialization in use
   are written to the connection file, rather than the initial two-stage system.
 - Serialization has been rewritten, fixing many bugs and dramatically improving
   performance serializing large containers.
 - Load-balancing scheduler performance with large numbers of tasks has been dramatically improved.
 - There should be fewer (hopefully zero) false-positives for engine failures.
 - Increased compatibility with various use cases that produced serialization / argument errors
   with map, etc.
 - The controller can attempt to resume operation if it has crashed,
   by passing ``ipcontroller --restore``.
 - Engines can monitor the Hub heartbeat, and shutdown if the Hub disappears for too long.
 - add HTCondor support in launchers
 
 
 QtConsole
 ---------
 
 Various fixes, including improved performance with lots of text output,
 and better drag and drop support.
 The initial window size of the qtconsole is now configurable via ``IPythonWidget.width``
 and ``IPythonWidget.height``.
 

docs/source/whatsnew/version2.0.rst

@@ -1,384 +1,384 b''
 ============
  2.x Series
 ============
 
 Release 2.4
 ===========
 
 January, 2014
 
 .. note::
 
     Some of the patches marked for 2.4 were left out of 2.4.0.
     Please use 2.4.1.
 
 - backport read support for nbformat v4 from IPython 3
 - support for PyQt5 in the kernel (not QtConsole)
 - support for Pygments 2.0
 
 For more information on what fixes have been backported to 2.4,
 see our :ref:`detailed release info <issues_list_200>`.
 
 
 Release 2.3.1
 =============
 
 November, 2014
 
 - Fix CRCRLF line-ending bug in notebooks on Windows
 
 For more information on what fixes have been backported to 2.3.1,
 see our :ref:`detailed release info <issues_list_200>`.
 
 Release 2.3.0
 =============
 
 October, 2014
 
 - improve qt5 support
 - prevent notebook data loss with atomic writes
 
 For more information on what fixes have been backported to 2.3,
 see our :ref:`detailed release info <issues_list_200>`.
 
 Release 2.2.0
 =============
 
 August, 2014
 
 - Add CORS configuration
 
 For more information on what fixes have been backported to 2.2,
 see our :ref:`detailed release info <issues_list_200>`.
 
 Release 2.1.0
 =============
 
 May, 2014
 
 IPython 2.1 is the first bugfix release for 2.0.
 For more information on what fixes have been backported to 2.1,
 see our :ref:`detailed release info
 <issues_list_200>`.
 
 
 Release 2.0.0
 =============
 
 April, 2014
 
 IPython 2.0 requires Python ≥ 2.7.2 or ≥ 3.3.0.
 It does not support Python 3.0, 3.1, 3.2, 2.5, or 2.6.
 
 The principal milestones of 2.0 are:
 
 - interactive widgets for the notebook
 - directory navigation in the notebook dashboard
 - persistent URLs for notebooks
 - a new modal user interface in the notebook
 - a security model for notebooks
 
 Contribution summary since IPython 1.0 in August, 2013:
 
 - ~8 months of work
 - ~650 pull requests merged
 - ~400 issues closed (non-pull requests)
 - contributions from ~100 authors
 - ~4000 commits
 
 The amount of work included in this release is so large that we can only cover
 here the main highlights; please see our :ref:`detailed release statistics
 <issues_list_200>` for links to every issue and pull request closed on GitHub
 as well as a full list of individual contributors.
 
 New stuff in the IPython notebook
 ---------------------------------
 
 Directory navigation
 ********************
 
 .. image:: /_images/2.0/treeview.png
     :width: 392px
     :alt: Directory navigation
     :align: center
 
 The IPython notebook dashboard allows navigation into subdirectories.
 URLs are persistent based on the notebook's path and name,
 so no more random UUID URLs.
 
 Serving local files no longer needs the ``files/`` prefix.
 Relative links across notebooks and other files should work just as if notebooks were regular HTML files.
 
 Interactive widgets
 *******************
 
 .. image:: /_images/2.0/widgets.png
     :width: 392px
     :alt: Interactive widgets
     :align: center
 
 IPython 2.0 adds :mod:`IPython.html.widgets`, for manipulating
 Python objects in the kernel with GUI controls in the notebook.
 IPython comes with a few built-in widgets for simple data types,
 and an API designed for developers to build more complex widgets.
 See the `widget docs`_ for more information.
 
 .. _widget docs: http://nbviewer.ipython.org/github/ipython/ipython/blob/2.x/examples/Interactive%20Widgets/Index.ipynb
 
 
 Modal user interface
 ********************
 
 The notebook has added separate Edit and Command modes,
 allowing easier keyboard commands and making keyboard shortcut customization possible.
 See the new `User Interface notebook`_ for more information.
 
 .. _User Interface Notebook: http://nbviewer.ipython.org/github/ipython/ipython/blob/2.x/examples/Notebook/User%20Interface.ipynb
 
 
 You can familiarize yourself with the updated notebook user interface, including an
 explanation of Edit and Command modes, by going through the short guided tour
 which can be started from the Help menu.
 
 .. image:: /_images/2.0/user-interface.png
     :width: 392px
     :alt: Interface tour
     :align: center
 
 
 Security
 ********
 
-2.0 introduces a :ref:`security model <notebook_security>` for notebooks,
+2.0 introduces a security model for notebooks,
 to prevent untrusted code from executing on users' behalf when notebooks open.
 A quick summary of the model:
 
-- Trust is determined by :ref:`signing notebooks<signing_notebooks>`.
+- Trust is determined by signing notebooks.
 - Untrusted HTML output is sanitized.
 - Untrusted Javascript is never executed.
 - HTML and Javascript in Markdown are never trusted.
 
 Dashboard "Running" tab
 ***********************
 
 .. image:: /_images/2.0/running-crop.png
     :width: 392px
     :alt: Running tab
     :align: center
 
 The dashboard now has a "Running" tab which shows all of the running notebooks.
 
 Single codebase Python 3 support
 --------------------------------
 
 IPython previously supported Python 3 by running 2to3 during setup. We
 have now switched to a single codebase which runs natively on Python 2.7
 and 3.3.
 
 For notes on how to maintain this, see :doc:`/development/pycompat`.
 
 Selecting matplotlib figure formats
 -----------------------------------
 
 Deprecate single-format ``InlineBackend.figure_format``
 configurable in favor of ``InlineBackend.figure_formats``,
 which is a set, supporting multiple simultaneous figure formats (e.g. png, pdf).
 
 This is available at runtime with the new API function :func:`IPython.display.set_matplotlib_formats`.
 
 clear_output changes
 --------------------
 
 * There is no longer a 500ms delay when calling ``clear_output``.
 * The ability to clear stderr and stdout individually was removed.
 * A new ``wait`` flag that prevents ``clear_output`` from being executed until new
   output is available.  This eliminates animation flickering by allowing the
   user to double buffer the output.
 * The output div height is remembered when the ``wait=True`` flag is used.
 
 Extending configurable containers
 ---------------------------------
 
 Some configurable traits are containers (list, dict, set)
 Config objects now support calling ``extend``, ``update``, ``insert``, etc.
 on traits in config files, which will ultimately result in calling
 those methods on the original object.
 
 The effect being that you can now add to containers without having to copy/paste
 the initial value::
 
     c = get_config()
     c.InlineBackend.rc.update({ 'figure.figsize' : (6, 4) })
 
 Changes to hidden namespace on startup
 --------------------------------------
 
 Previously, all names declared in code run at startup
 (startup files, ``ipython -i script.py``, etc.)
 were added to the hidden namespace, which hides the names from tools like ``%whos``.
 There are two changes to this behavior:
 
 1. Scripts run on the command-line ``ipython -i script.py``now behave the same as if they were
    passed to ``%run``, so their variables are never hidden.
 2. A boolean config flag ``InteractiveShellApp.hide_initial_ns`` has been added to optionally
    disable the hidden behavior altogether. The default behavior is unchanged.
 
 Using dill to expand serialization support
 ------------------------------------------
 
 The new function :func:`~IPython.utils.pickleutil.use_dill` allows
 dill to extend serialization support in :mod:`IPython.parallel` (closures, etc.).
 A :meth:`DirectView.use_dill` convenience method was also added, to enable dill
 locally and on all engines with one call.
 
 New IPython console lexer
 -------------------------
 
 The IPython console lexer has been rewritten and now supports tracebacks
 and customized input/output prompts. See the :ref:`new lexer docs <console_lexer>`
 for details.
 
 DisplayFormatter changes
 ------------------------
 
 There was no official way to query or remove callbacks in the Formatter API.
 To remedy this, the following methods are added to :class:`BaseFormatter`:
 
 - ``lookup(instance)`` - return appropriate callback or a given object
 - ``lookup_by_type(type_or_str)`` - return appropriate callback for a given type or ``'mod.name'`` type string
 - ``pop(type_or_str)`` - remove a type (by type or string).
   Pass a second argument to avoid KeyError (like dict).
 
 All of the above methods raise a KeyError if no match is found.
 
 And the following methods are changed:
 
 - ``for_type(type_or_str)`` - behaves the same as before, only adding support for ``'mod.name'``
   type strings in addition to plain types. This removes the need for ``for_type_by_name()``,
   but it remains for backward compatibility.
 
 Formatters can now raise NotImplementedError in addition to returning None
 to indicate that they cannot format a given object.
 
 Exceptions and Warnings
 ***********************
 
 Exceptions are no longer silenced when formatters fail.
 Instead, these are turned into a :class:`~IPython.core.formatters.FormatterWarning`.
 A FormatterWarning will also be issued if a formatter returns data of an invalid type
 (e.g. an integer for 'image/png').
 
 
 Other changes
 -------------
 
 * `%%capture` cell magic now captures the rich display output, not just
   stdout/stderr
 
 * In notebook, Showing tooltip on tab has been disables to avoid conflict with
   completion, Shift-Tab could still be used to invoke tooltip when inside
   function signature and/or on selection.
 
 * ``object_info_request`` has been replaced by ``object_info`` for consistency in the javascript API.
   ``object_info`` is a simpler interface to register callback that is incompatible with ``object_info_request``.
 
 * Previous versions of IPython on Linux would use the XDG config directory,
   creating :file:`~/.config/ipython` by default. We have decided to go
   back to :file:`~/.ipython` for consistency among systems. IPython will
   issue a warning if it finds the XDG location, and will move it to the new
   location if there isn't already a directory there.
 
 * Equations, images and tables are now centered in Markdown cells.
 * Multiline equations are now centered in output areas; single line equations
   remain left justified.
 
 * IPython config objects can be loaded from and serialized to JSON.
   JSON config file have the same base name as their ``.py`` counterpart,
   and will be loaded with higher priority if found.
 
 * bash completion updated with support for all ipython subcommands and flags, including nbconvert
 
 * ``ipython history trim``: added ``--keep=<N>`` as an alias for the more verbose
   ``--HistoryTrim.keep=<N>``
 * New ``ipython history clear`` subcommand, which is the same as the newly supported
   ``ipython history trim --keep=0``
 
 * You can now run notebooks in an interactive session via ``%run notebook.ipynb``.
 
 * Print preview is back in the notebook menus, along with options to
   download the open notebook in various formats. This is powered by
   nbconvert.
 
 * :exc:`~IPython.nbconvert.utils.pandoc.PandocMissing` exceptions will be
   raised if Pandoc is unavailable, and warnings will be printed if the version
   found is too old. The recommended Pandoc version for use with nbconvert is
   1.12.1.
 
 * The InlineBackend.figure_format now supports JPEG output if PIL/Pillow is available.
 
 * Input transformers (see :doc:`/config/inputtransforms`) may now raise
   :exc:`SyntaxError` if they determine that input is invalid. The input
   transformation machinery in IPython will handle displaying the exception to
   the user and resetting state.
 
 * Calling ``container.show()`` on javascript display is deprecated and will
   trigger errors on future IPython notebook versions. ``container`` now show
   itself as soon as non-empty
 
 * Added ``InlineBackend.print_figure_kwargs`` to allow passing keyword arguments
   to matplotlib's ``Canvas.print_figure``. This can be used to change the value of
   ``bbox_inches``, which is 'tight' by default, or set the quality of JPEG figures.
 
 * A new callback system has been introduced. For details, see :doc:`/config/callbacks`.
 
 * jQuery and require.js are loaded from CDNs in the default HTML template,
   so javascript is available in static HTML export (e.g. nbviewer).
 
 Backwards incompatible changes
 ------------------------------
 
 * Python 2.6 and 3.2 are no longer supported: the minimum required
   Python versions are now 2.7 and 3.3.
 * The Transformer classes have been renamed to Preprocessor in nbconvert and
   their ``call`` methods have been renamed to ``preprocess``.
 * The ``call`` methods of nbconvert post-processsors have been renamed to
   ``postprocess``.
 
 * The module ``IPython.core.fakemodule`` has been removed.
 
 * The alias system has been reimplemented to use magic functions. There should be little
   visible difference while automagics are enabled, as they are by default, but parts of the
   :class:`~IPython.core.alias.AliasManager` API have been removed.
 
 * We fixed an issue with switching between matplotlib inline and GUI backends,
   but the fix requires matplotlib 1.1 or newer.  So from now on, we consider
   matplotlib 1.1 to be the minimally supported version for IPython. Older
   versions for the most part will work, but we make no guarantees about it.
 
 * The :command:`pycolor` command has been removed. We recommend the much more capable
   :command:`pygmentize` command from the `Pygments <http://pygments.org/>`_ project.
   If you need to keep the exact output of :command:`pycolor`, you can still use
   ``python -m IPython.utils.PyColorize foo.py``.
 
 * :mod:`IPython.lib.irunner` and its command-line entry point have been removed.
   It had fallen out of use long ago.
 
 * The ``input_prefilter`` hook has been removed, as it was never
   actually used by the code. The input transformer system offers much
   more powerful APIs to work with input code. See
   :doc:`/config/inputtransforms` for details.
 
 * :class:`IPython.core.inputsplitter.IPythonInputSplitter` no longer has a method
   ``source_raw_reset()``, but gains :meth:`~IPython.core.inputsplitter.IPythonInputSplitter.raw_reset`
   instead. Use of ``source_raw_reset`` can be replaced with::
 
       raw = isp.source_raw
       transformed = isp.source_reset()
 
 * The Azure notebook manager was removed as it was no longer compatible with the notebook storage scheme.
 
 * Simplifying configurable URLs
 
   - base_project_url is renamed to base_url (base_project_url is kept as a deprecated alias, for now)
   - base_kernel_url configurable is removed (use base_url)
   - websocket_url configurable is removed (use base_url)

docs/source/whatsnew/version3.rst

@@ -1,391 +1,391 b''
 ============
  3.x Series
 ============
 
 IPython 3.2.3
 =============
 
 Fixes compatibility with Python 3.4.4.
 
 IPython 3.2.2
 =============
 
 Address vulnerabilities when files have maliciously crafted filenames (CVE-2015-6938),
 or vulnerability when opening text files with malicious binary content (CVE pending).
 
 Users are **strongly** encouraged to upgrade immediately.
 There are also a few small unicode and nbconvert-related fixes.
 
 
 IPython 3.2.1
 =============
 
 IPython 3.2.1 is a small bugfix release, primarily for cross-site security fixes in the notebook.
 Users are **strongly** encouraged to upgrade immediately.
 There are also a few small unicode and nbconvert-related fixes.
 
 See :ref:`issues_list_3` for details.
 
 
 IPython 3.2
 ===========
 
 IPython 3.2 contains important security fixes. Users are **strongly** encouraged to upgrade immediately.
 
 Highlights:
 
 - Address cross-site scripting vulnerabilities CVE-2015-4706, CVE-2015-4707
 - A security improvement that set the secure attribute to login cookie to prevent them to be sent over http
 - Revert the face color of matplotlib axes in the inline backend to not be transparent.
 - Enable mathjax safe mode by default
 - Fix XSS vulnerability in JSON error messages
 - Various widget-related fixes
 
 See :ref:`issues_list_3` for details.
 
 
 IPython 3.1
 ===========
 
 Released April 3, 2015
 
 The first 3.x bugfix release, with 33 contributors and 344 commits.
 This primarily includes bugfixes to notebook layout and focus problems.
 
 
 Highlights:
 
 - Various focus jumping and scrolling fixes in the notebook.
 - Various message ordering and widget fixes in the notebook.
 - Images in markdown and output are confined to the notebook width.
   An `.unconfined` CSS class is added to disable this behavior per-image.
   The resize handle on output images is removed.
 - Improved ordering of tooltip content for Python functions, putting the signature at the top.
 - Fix UnicodeErrors when displaying some objects with unicode reprs on Python 2.
 - Set the kernel's working directory to the notebook directory when running ``nbconvert --execute``,
   so that behavior matches the live notebook.
 - Allow setting custom SSL options for the tornado server with ``NotebookApp.ssl_options``,
   and protect against POODLE with default settings by disabling SSLv3.
 - Fix memory leak in the IPython.parallel Controller on Python 3.
 
 
 See :ref:`issues_list_3` for details.
 
 
 Release 3.0
 ===========
 
 Released February 27, 2015
 
 This is a really big release. Over 150 contributors, and almost 6000 commits in a bit under a year.
 Support for languages other than Python is greatly improved,
 notebook UI has been significantly redesigned,
 and a lot of improvement has happened in the experimental interactive widgets.
 The message protocol and document format have both been updated,
 while maintaining better compatibility with previous versions than prior updates.
 The notebook webapp now enables editing of any text file, and even
 a web-based terminal (on Unix platforms).
 
 3.x will be the last monolithic release of IPython,
 as the next release cycle will see the growing project split into its Python-specific and language-agnostic components.
 Language-agnostic projects (notebook, qtconsole, etc.) will move under the umbrella of the new Project Jupyter name,
 while Python-specific projects (interactive Python shell, Python kernel, IPython.parallel)
 will remain under IPython, and be split into a few smaller packages.
 To reflect this, IPython is in a bit of a transition state.
 The logo on the notebook is now the Jupyter logo.
 When installing kernels system-wide, they go in a `jupyter` directory.
 We are going to do our best to ease this transition for users and developers.
 
 Big changes are ahead.
 
 
 Using different kernels
 -----------------------
 
 .. image:: ../_images/kernel_selector_screenshot.png
    :alt: Screenshot of 'new' dropdown showing different kernels
    :align: center
 
 You can now choose a kernel for a notebook within the user interface, rather
 than starting up a separate notebook server for each kernel you want to use. The
 syntax highlighting adapts to match the language you're working in.
 
 Information about the kernel is stored in the notebook file, so when you open a
 notebook, it will automatically start the correct kernel.
 
 It is also easier to use the Qt console and the terminal console with other
 kernels, using the --kernel flag::
 
     ipython qtconsole --kernel bash
     ipython console --kernel bash
 
     # To list available kernels
     ipython kernelspec list
 
 Kernel authors should see :ref:`kernelspecs` for how to register their kernels
 with IPython so that these mechanisms work.
 
 Typing unicode identifiers
 --------------------------
 
 .. image:: /_images/unicode_completion.png
 
 Complex expressions can be much cleaner when written with a wider choice of
 characters. Python 3 allows unicode identifiers, and IPython 3 makes it easier
 to type those, using a feature from Julia. Type a backslash followed by a LaTeX
 style short name, such as ``\alpha``. Press tab, and it will turn into α.
 
 Widget migration guide
 ----------------------
 The widget framework has a lot of backwards incompatible changes.
 For information about migrating widget notebooks and custom widgets to 3.0 refer
 to the :doc:`widget migration guide<version3_widget_migration>`.
 
 Other new features
 ------------------
 
 * :class:`~.TextWidget` and :class:`~.TextareaWidget` objects now include a
   ``placeholder`` attribute, for displaying placeholder text before the
   user has typed anything.
 
 * The :magic:`load` magic can now find the source for objects in the user namespace.
   To enable searching the namespace, use the ``-n`` option.
 
   .. sourcecode:: ipython
 
       In [1]: %load -n my_module.some_function
 
 * :class:`~.DirectView` objects have a new :meth:`~.DirectView.use_cloudpickle`
   method, which works like ``view.use_dill()``, but causes the ``cloudpickle``
   module from PiCloud's `cloud`__ library to be used rather than dill or the
   builtin pickle module.
 
   __ https://pypi.python.org/pypi/cloud
 
 * Added a .ipynb exporter to nbconvert.  It can be used by passing `--to notebook`
   as a commandline argument to nbconvert.
 
 * New nbconvert preprocessor called :class:`~.ClearOutputPreprocessor`. This
   clears the output from IPython notebooks.
 
 * New preprocessor for nbconvert that executes all the code cells in a notebook.
   To run a notebook and save its output in a new notebook::
 
       ipython nbconvert InputNotebook --ExecutePreprocessor.enabled=True --to notebook --output Executed
 
 * Consecutive stream (stdout/stderr) output is merged into a single output
   in the notebook document.
   Previously, all output messages were preserved as separate output fields in the JSON.
   Now, the same merge is applied to the stored output as the displayed output,
   improving document load time for notebooks with many small outputs.
 
 * ``NotebookApp.webapp_settings`` is deprecated and replaced with
   the more informatively named ``NotebookApp.tornado_settings``.
 
 * Using :magic:`timeit` prints warnings if there is atleast a 4x difference in timings
   between the slowest and fastest runs, since this might meant that the multiple
   runs are not independent of one another.
 
 * It's now possible to provide mechanisms to integrate IPython with other event
   loops, in addition to the ones we already support. This lets you run GUI code
   in IPython with an interactive prompt, and to embed the IPython
   kernel in GUI applications. See :doc:`/config/eventloops` for details. As part
   of this, the direct ``enable_*`` and ``disable_*`` functions for various GUIs
   in :mod:`IPython.lib.inputhook` have been deprecated in favour of
   :meth:`~.InputHookManager.enable_gui` and :meth:`~.InputHookManager.disable_gui`.
 
 * A ``ScrollManager`` was added to the notebook.  The ``ScrollManager`` controls how the notebook document is scrolled using keyboard.  Users can inherit from the ``ScrollManager`` or ``TargetScrollManager`` to customize how their notebook scrolls.  The default ``ScrollManager`` is the ``SlideScrollManager``, which tries to scroll to the nearest slide or sub-slide cell.
 
 * The function :func:`~IPython.html.widgets.interaction.interact_manual` has been
   added which behaves similarly to :func:`~IPython.html.widgets.interaction.interact`,
   but adds a button to explicitly run the interacted-with function, rather than
   doing it automatically for every change of the parameter widgets. This should
   be useful for long-running functions.
 
 * The ``%cython`` magic is now part of the Cython module. Use `%load_ext Cython` with a version of Cython >= 0.21 to have access to the magic now.
 
 * The Notebook application now offers integrated terminals on Unix platforms,
   intended for when it is used on a remote server. To enable these, install
   the ``terminado`` Python package.
 
 * The Notebook application can now edit any plain text files, via a full-page CodeMirror instance.
 
 * Setting the default highlighting language for nbconvert with the config option
   ``NbConvertBase.default_language`` is deprecated. Nbconvert now respects
   metadata stored in the :ref:`kernel spec <kernelspecs>`.
 
 * IPython can now be configured systemwide, with files in :file:`/etc/ipython`
   or :file:`/usr/local/etc/ipython` on Unix systems,
   or :file:`{%PROGRAMDATA%}\\ipython` on Windows.
 
 * Added support for configurable user-supplied `Jinja
   <http://jinja.pocoo.org/>`_ HTML templates for the notebook.  Paths to
   directories containing template files can be specified via
   ``NotebookApp.extra_template_paths``.  User-supplied template directories
   searched first by the notebook, making it possible to replace existing
   templates with your own files.
 
   For example, to replace the notebook's built-in ``error.html`` with your own,
   create a directory like ``/home/my_templates`` and put your override template
   at ``/home/my_templates/error.html``.  To start the notebook with your custom
   error page enabled, you would run::
 
       ipython notebook '--extra_template_paths=["/home/my_templates/"]'
 
   It's also possible to override a template while also `inheriting
   <http://jinja.pocoo.org/docs/dev/templates/#template-inheritance>`_ from that
   template, by prepending ``templates/`` to the ``{% extends %}`` target of
   your child template.  This is useful when you only want to override a
   specific block of a template.  For example, to add additional CSS to the
   built-in ``error.html``, you might create an override that looks like::
 
     {% extends "templates/error.html" %}
 
     {% block stylesheet %}
     {{super()}}
     <style type="text/css">
       /* My Awesome CSS */
     </style>
     {% endblock %}
 
 * Added a widget persistence API.  This allows you to persist your notebooks interactive widgets.
   Two levels of control are provided:
   1. Higher level- ``WidgetManager.set_state_callbacks`` allows you to register callbacks for loading and saving widget state.  The callbacks you register are automatically called when necessary.
   2. Lower level- the ``WidgetManager`` Javascript class now has ``get_state`` and ``set_state`` methods that allow you to get and set the state of the widget runtime.
 
   Example code for persisting your widget state to session data::
 
     %%javascript
     require(['widgets/js/manager'], function(manager) {
         manager.WidgetManager.set_state_callbacks(function() { // Load
             return JSON.parse(sessionStorage.widgets_state || '{}');
         }, function(state) { // Save
             sessionStorage.widgets_state = JSON.stringify(state);
         });
     });
 
 * Enhanced support for :magic:`env` magic.  As before, :magic:`env` with no
   arguments displays all environment variables and values.  Additionally,
   :magic:`env` can be used to get or set individual environment variables. To
   display an individual value, use the `%env var` syntax. To set a value, use
   `env var val` or `env var=val`. Python value expansion using `$` works as usual.
 
 
 Backwards incompatible changes
 ------------------------------
 
 * The :ref:`message protocol <messaging>` has been updated from version 4 to version 5.
   Adapters are included, so IPython frontends can still talk to kernels that
   implement protocol version 4.
 
-* The :ref:`notebook format <nbformat>` has been updated from version 3 to version 4.
+* The notebook format has been updated from version 3 to version 4.
   Read-only support for v4 notebooks has been backported to IPython 2.4.
   Notable changes:
   
   * heading cells are removed in favor or markdown headings
   * notebook outputs and output messages are more consistent with each other
   * use :func:`IPython.nbformat.read` and :func:`~IPython.nbformat.write`
     to read and write notebook files
     instead of the deprecated :mod:`IPython.nbformat.current` APIs.
 
   You can downgrade a notebook to v3 via ``nbconvert``::
   
       ipython nbconvert --to notebook --nbformat 3 <notebook>
   
   which will create :file:`notebook.v3.ipynb`, a copy of the notebook in v3 format.
 
 * :func:`IPython.core.oinspect.getsource` call specification has changed:
 
   * `oname` keyword argument has been added for property source formatting
   * `is_binary` keyword argument has been dropped, passing ``True`` had
     previously short-circuited the function to return ``None`` unconditionally
 
 * Removed the octavemagic extension: it is now available as ``oct2py.ipython``.
 
 * Creating PDFs with LaTeX no longer uses a post processor.
   Use `nbconvert --to pdf` instead of `nbconvert --to latex --post pdf`.
 
 * Used https://github.com/jdfreder/bootstrap2to3 to migrate the Notebook to Bootstrap 3.
 
   Additional changes:
 
   - Set `.tab-content .row` `0px;` left and right margin (bootstrap default is `-15px;`)
   - Removed `height: @btn_mini_height;` from `.list_header>div, .list_item>div` in `tree.less`
   - Set `#header` div `margin-bottom: 0px;`
   - Set `#menus` to `float: left;`
   - Set `#maintoolbar .navbar-text` to `float: none;`
   - Added no-padding convenience class.
   - Set border of #maintoolbar to 0px
 
 * Accessing the `container` DOM object when displaying javascript has been
   deprecated in IPython 2.0 in favor of accessing `element`. Starting with
   IPython 3.0 trying to access `container` will raise an error in browser
   javascript console.
 
 * ``IPython.utils.py3compat.open`` was removed: :func:`io.open` provides all
   the same functionality.
 
 * The NotebookManager and ``/api/notebooks`` service has been replaced by
   a more generic ContentsManager and ``/api/contents`` service,
   which supports all kinds of files.
 * The Dashboard now lists all files, not just notebooks and directories.
 * The ``--script`` hook for saving notebooks to Python scripts is removed,
   use :samp:`ipython nbconvert --to python {notebook}` instead.
 
 * The ``rmagic`` extension is deprecated, as it is now part of rpy2. See
   :mod:`rpy2.ipython.rmagic`.
 
 * :meth:`~.KernelManager.start_kernel` and :meth:`~.KernelManager.format_kernel_cmd`
   no longer accept a ``executable`` parameter. Use the kernelspec machinery instead.
 
 * The widget classes have been renamed from `*Widget` to `*`.  The old names are
   still functional, but are deprecated.  i.e. `IntSliderWidget` has been renamed
   to `IntSlider`.
 * The ContainerWidget was renamed to Box and no longer defaults as a flexible
   box in the web browser.  A new FlexBox widget was added, which allows you to
   use the flexible box model.
 
 * The notebook now uses a single websocket at `/kernels/<kernel-id>/channels` instead of separate
   `/kernels/<kernel-id>/{shell|iopub|stdin}` channels. Messages on each channel are identified by a
   `channel` key in the message dict, for both send and recv.
 
 
 Content Security Policy
 ```````````````````````
 
 The Content Security Policy is a web standard for adding a layer of security to
 detect and mitigate certain classes of attacks, including Cross Site Scripting
 (XSS) and data injection attacks. This was introduced into the notebook to
 ensure that the IPython Notebook and its APIs (by default) can only be embedded
 in an iframe on the same origin.
 
 Override ``headers['Content-Security-Policy']`` within your notebook
 configuration to extend for alternate domains and security settings.::
 
     c.NotebookApp.tornado_settings = {
         'headers': {
             'Content-Security-Policy': "frame-ancestors 'self'"
         }
     }
 
 Example policies::
 
     Content-Security-Policy: default-src 'self' https://*.jupyter.org
 
 Matches embeddings on any subdomain of jupyter.org, so long as they are served
 over SSL.
 
 There is a `report-uri <https://developer.mozilla.org/en-US/docs/Web/Security/CSP/CSP_policy_directives#report-uri>`_ endpoint available for logging CSP violations, located at
 ``/api/security/csp-report``. To use it, set ``report-uri`` as part of the CSP::
 
     c.NotebookApp.tornado_settings = {
         'headers': {
             'Content-Security-Policy': "frame-ancestors 'self'; report-uri /api/security/csp-report"
         }
     }
 
 It simply provides the CSP report as a warning in IPython's logs. The default
 CSP sets this report-uri relative to the ``base_url`` (not shown above).
 
 For a more thorough and accurate guide on Content Security Policies, check out
 `MDN's Using Content Security Policy <https://developer.mozilla.org/en-US/docs/Web/Security/CSP/Using_Content_Security_Policy>`_ for more examples.