Merge upstream changes

IPython/__main__.py

@@ -0,0 +1,14 b''
+# encoding: utf-8
+"""Terminal-based IPython entry point.
+"""
+#-----------------------------------------------------------------------------
+#  Copyright (c) 2012, IPython Development Team.
+#
+#  Distributed under the terms of the Modified BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+from IPython.frontend.terminal.ipapp import launch_new_instance
+
+launch_new_instance()

IPython/core/tests/print_argv.py

@@ -0,0 +1,2 b''
+import sys
+print sys.argv[1:]

IPython/core/tests/test_extension.py

@@ -0,0 +1,73 b''
+import os.path
+
+import nose.tools as nt
+
+import IPython.testing.tools as tt
+from IPython.utils.syspathcontext import prepended_to_syspath
+from IPython.utils.tempdir import TemporaryDirectory
+
+ext1_content = """
+def load_ipython_extension(ip):
+    print("Running ext1 load")
+
+def unload_ipython_extension(ip):
+    print("Running ext1 unload")
+"""
+
+ext2_content = """
+def load_ipython_extension(ip):
+    print("Running ext2 load")
+"""
+
+def test_extension_loading():
+    em = get_ipython().extension_manager
+    with TemporaryDirectory() as td:
+        ext1 = os.path.join(td, 'ext1.py')
+        with open(ext1, 'w') as f:
+            f.write(ext1_content)
+        
+        ext2 = os.path.join(td, 'ext2.py')
+        with open(ext2, 'w') as f:
+            f.write(ext2_content)
+        
+        with prepended_to_syspath(td):
+            assert 'ext1' not in em.loaded
+            assert 'ext2' not in em.loaded
+            
+            # Load extension
+            with tt.AssertPrints("Running ext1 load"):
+                assert em.load_extension('ext1') is None
+            assert 'ext1' in em.loaded
+            
+            # Should refuse to load it again
+            with tt.AssertNotPrints("Running ext1 load"):
+                assert em.load_extension('ext1') == 'already loaded'
+            
+            # Reload
+            with tt.AssertPrints("Running ext1 unload"):
+                with tt.AssertPrints("Running ext1 load", suppress=False):
+                    em.reload_extension('ext1')
+            
+            # Unload
+            with tt.AssertPrints("Running ext1 unload"):
+                assert em.unload_extension('ext1') is None
+            
+            # Can't unload again
+            with tt.AssertNotPrints("Running ext1 unload"):
+                assert em.unload_extension('ext1') == 'not loaded'
+            assert em.unload_extension('ext2') == 'not loaded'
+            
+            # Load extension 2
+            with tt.AssertPrints("Running ext2 load"):
+                assert em.load_extension('ext2') is None
+            
+            # Can't unload this
+            assert em.unload_extension('ext2') == 'no unload function'
+            
+            # But can reload it
+            with tt.AssertPrints("Running ext2 load"):
+                em.reload_extension('ext2')
+
+def test_non_extension():
+    em = get_ipython().extension_manager
+    nt.assert_equal(em.load_extension('sys'), "no load function")

IPython/frontend/html/notebook/static/js/config.js

@@ -0,0 +1,33 b''
+//----------------------------------------------------------------------------
+//  Copyright (C) 2012  The IPython Development Team
+//
+//  Distributed under the terms of the BSD License.  The full license is in
+//  the file COPYING, distributed as part of this software.
+//----------------------------------------------------------------------------
+
+//============================================================================
+// Notebook
+//============================================================================
+
+var IPython = (function (IPython) {
+
+    var config = {
+        cell_magic_highlight : {
+              'magic_javascript':{'reg':[/^%%javascript/]}
+             ,'magic_perl'      :{'reg':[/^%%perl/]}
+             ,'magic_ruby'      :{'reg':[/^%%ruby/]}
+             ,'magic_python'    :{'reg':[/^%%python3?/]}
+             ,'magic_shell'      :{'reg':[/^%%bash/]}
+             ,'magic_r'         :{'reg':[/^%%R/]}
+            },
+        raw_cell_highlight : {
+             'diff'         :{'reg':[/^diff/]}
+            }
+        };
+
+    IPython.config = config;
+
+    return IPython;
+
+}(IPython));
+

IPython/frontend/html/notebook/static/js/maintoolbar.js

@@ -0,0 +1,179 b''
+//----------------------------------------------------------------------------
+//  Copyright (C) 2011 The IPython Development Team
+//
+//  Distributed under the terms of the BSD License.  The full license is in
+//  the file COPYING, distributed as part of this software.
+//----------------------------------------------------------------------------
+
+//============================================================================
+// ToolBar
+//============================================================================
+
+var IPython = (function (IPython) {
+
+    var MainToolBar = function (selector) {
+        this.selector = selector;
+        IPython.ToolBar.apply(this, arguments);
+        this.construct();
+        this.add_drop_down_list();
+        this.bind_events();
+    };
+
+    MainToolBar.prototype = new IPython.ToolBar(); 
+
+    MainToolBar.prototype.construct = function () {
+        this.add_buttons_group([
+                {
+                    id : 'save_b',
+                    label : 'Save',
+                    icon : 'ui-icon-disk',
+                    callback : function () {
+                        IPython.notebook.save_notebook();
+                        }
+                }
+            ]);
+        this.add_buttons_group([
+                {
+                    id : 'cut_b',
+                    label : 'Cut Cell',
+                    icon : 'ui-icon-scissors',
+                    callback : function () {
+                        IPython.notebook.cut_cell();
+                        }
+                },
+                {
+                    id : 'copy_b',
+                    label : 'Copy Cell',
+                    icon : 'ui-icon-copy',
+                    callback : function () {
+                        IPython.notebook.copy_cell();
+                        }
+                },
+                {
+                    id : 'paste_b',
+                    label : 'Paste Cell Below',
+                    icon : 'ui-icon-clipboard',
+                    callback : function () {
+                        IPython.notebook.paste_cell_below();
+                        }
+                }
+            ],'cut_copy_paste');
+
+        this.add_buttons_group([
+                {
+                    id : 'move_up_b',
+                    label : 'Move Cell Up',
+                    icon : 'ui-icon-arrowthick-1-n',
+                    callback : function () {
+                        IPython.notebook.move_cell_up();
+                        }
+                },
+                {
+                    id : 'move_down_b',
+                    label : 'Move Cell Down',
+                    icon : 'ui-icon-arrowthick-1-s',
+                    callback : function () {
+                        IPython.notebook.move_cell_down();
+                        }
+                }
+            ],'move_up_down');
+        
+        this.add_buttons_group([
+                {
+                    id : 'insert_above_b',
+                    label : 'Insert Cell Above',
+                    icon : 'ui-icon-arrowthickstop-1-n',
+                    callback : function () {
+                        IPython.notebook.insert_cell_above('code');
+                        }
+                },
+                {
+                    id : 'insert_below_b',
+                    label : 'Insert Cell Below',
+                    icon : 'ui-icon-arrowthickstop-1-s',
+                    callback : function () {
+                        IPython.notebook.insert_cell_below('code');
+                        }
+                }
+            ],'insert_above_below');
+
+        this.add_buttons_group([
+                {
+                    id : 'run_b',
+                    label : 'Run Cell',
+                    icon : 'ui-icon-play',
+                    callback : function () {
+                    IPython.notebook.execute_selected_cell();
+                        }
+                },
+                {
+                    id : 'interrupt_b',
+                    label : 'Interrupt',
+                    icon : 'ui-icon-stop',
+                    callback : function () {
+                        IPython.notebook.kernel.interrupt();
+                        }
+                }
+            ],'run_int');
+
+
+    };
+
+    MainToolBar.prototype.add_drop_down_list = function () {
+        var select = $(this.selector)
+            .append($('<select/>')
+                .attr('id','cell_type')
+                .addClass('ui-widget ui-widget-content')
+                    .append($('<option/>').attr('value','code').text('Code'))
+                    .append($('<option/>').attr('value','markdown').text('Markdown'))
+                    .append($('<option/>').attr('value','raw').text('Raw Text'))
+                    .append($('<option/>').attr('value','heading1').text('Heading 1'))
+                    .append($('<option/>').attr('value','heading2').text('Heading 2'))
+                    .append($('<option/>').attr('value','heading3').text('Heading 3'))
+                    .append($('<option/>').attr('value','heading4').text('Heading 4'))
+                    .append($('<option/>').attr('value','heading5').text('Heading 5'))
+                    .append($('<option/>').attr('value','heading6').text('Heading 6'))
+                    .append($('<option/>').attr('value','heading7').text('Heading 7'))
+                    .append($('<option/>').attr('value','heading8').text('Heading 8'))
+                );
+    };
+
+    MainToolBar.prototype.bind_events = function () {
+        var that = this;
+        
+        this.element.find('#cell_type').change(function () {
+            var cell_type = $(this).val();
+            if (cell_type === 'code') {
+                IPython.notebook.to_code();
+            } else if (cell_type === 'markdown')  {
+                IPython.notebook.to_markdown();
+            } else if (cell_type === 'raw')  {
+                IPython.notebook.to_raw();
+            } else if (cell_type === 'heading1')  {
+                IPython.notebook.to_heading(undefined, 1);
+            } else if (cell_type === 'heading2')  {
+                IPython.notebook.to_heading(undefined, 2);
+            } else if (cell_type === 'heading3')  {
+                IPython.notebook.to_heading(undefined, 3);
+            } else if (cell_type === 'heading4')  {
+                IPython.notebook.to_heading(undefined, 4);
+            } else if (cell_type === 'heading5')  {
+                IPython.notebook.to_heading(undefined, 5);
+            } else if (cell_type === 'heading6')  {
+                IPython.notebook.to_heading(undefined, 6);
+            }
+        });
+        $([IPython.events]).on('selected_cell_type_changed.Notebook', function (event, data) {
+            if (data.cell_type === 'heading') {
+                that.element.find('#cell_type').val(data.cell_type+data.level);
+            } else {
+                that.element.find('#cell_type').val(data.cell_type);
+            }
+        });
+    };
+
+    IPython.MainToolBar = MainToolBar;
+
+    return IPython;
+
+}(IPython));

IPython/frontend/terminal/console/tests/test_image_handler.py

@@ -0,0 +1,95 b''
+#-----------------------------------------------------------------------------
+# Copyright (C) 2012 The IPython Development Team
+#
+# Distributed under the terms of the BSD License. The full license is in
+# the file COPYING, distributed as part of this software.
+#-----------------------------------------------------------------------------
+
+import os
+import sys
+import unittest
+import base64
+
+from IPython.zmq.kernelmanager import KernelManager
+from IPython.frontend.terminal.console.interactiveshell \
+    import ZMQTerminalInteractiveShell
+from IPython.utils.tempdir import TemporaryDirectory
+from IPython.testing.tools import monkeypatch
+from IPython.testing.decorators import skip_without
+from IPython.utils.ipstruct import Struct
+
+
+SCRIPT_PATH = os.path.join(
+    os.path.abspath(os.path.dirname(__file__)), 'writetofile.py')
+
+
+class ZMQTerminalInteractiveShellTestCase(unittest.TestCase):
+
+    def setUp(self):
+        km = KernelManager()
+        self.shell = ZMQTerminalInteractiveShell(kernel_manager=km)
+        self.raw = b'dummy data'
+        self.mime = 'image/png'
+        self.data = {self.mime: base64.encodestring(self.raw).decode('ascii')}
+
+    def test_no_call_by_default(self):
+        def raise_if_called(*args, **kwds):
+            assert False
+
+        shell = self.shell
+        shell.handle_image_PIL = raise_if_called
+        shell.handle_image_stream = raise_if_called
+        shell.handle_image_tempfile = raise_if_called
+        shell.handle_image_callable = raise_if_called
+
+        shell.handle_image(None, None)  # arguments are dummy
+
+    @skip_without('PIL')
+    def test_handle_image_PIL(self):
+        import PIL.Image
+
+        open_called_with = []
+        show_called_with = []
+
+        def fake_open(arg):
+            open_called_with.append(arg)
+            return Struct(show=lambda: show_called_with.append(None))
+
+        with monkeypatch(PIL.Image, 'open', fake_open):
+            self.shell.handle_image_PIL(self.data, self.mime)
+
+        self.assertEqual(len(open_called_with), 1)
+        self.assertEqual(len(show_called_with), 1)
+        self.assertEqual(open_called_with[0].getvalue(), self.raw)
+
+    def check_handler_with_file(self, inpath, handler):
+        shell = self.shell
+        configname = '{0}_image_handler'.format(handler)
+        funcname = 'handle_image_{0}'.format(handler)
+
+        assert hasattr(shell, configname)
+        assert hasattr(shell, funcname)
+
+        with TemporaryDirectory() as tmpdir:
+            outpath = os.path.join(tmpdir, 'data')
+            cmd = [sys.executable, SCRIPT_PATH, inpath, outpath]
+            setattr(shell, configname, cmd)
+            getattr(shell, funcname)(self.data, self.mime)
+            # cmd is called and file is closed.  So it's safe to open now.
+            with open(outpath, 'rb') as file:
+                transferred = file.read()
+
+        self.assertEqual(transferred, self.raw)
+
+    def test_handle_image_stream(self):
+        self.check_handler_with_file('-', 'stream')
+
+    def test_handle_image_tempfile(self):
+        self.check_handler_with_file('{file}', 'tempfile')
+
+    def test_handle_image_callable(self):
+        called_with = []
+        self.shell.callable_image_handler = called_with.append
+        self.shell.handle_image_callable(self.data, self.mime)
+        self.assertEqual(len(called_with), 1)
+        assert called_with[0] is self.data

IPython/frontend/terminal/console/tests/writetofile.py

@@ -0,0 +1,33 b''
+#-----------------------------------------------------------------------------
+# Copyright (C) 2012 The IPython Development Team
+#
+# Distributed under the terms of the BSD License. The full license is in
+# the file COPYING, distributed as part of this software.
+#-----------------------------------------------------------------------------
+
+"""
+Copy data from input file to output file for testing.
+
+Command line usage:
+
+    python writetofile.py INPUT OUTPUT
+
+Binary data from INPUT file is copied to OUTPUT file.
+If INPUT is '-', stdin is used.
+
+"""
+
+if __name__ == '__main__':
+    import sys
+    from IPython.utils.py3compat import PY3
+    (inpath, outpath) = sys.argv[1:]
+
+    if inpath == '-':
+        if PY3:
+            infile = sys.stdin.buffer
+        else:
+            infile = sys.stdin
+    else:
+        infile = open(inpath, 'rb')
+
+    open(outpath, 'w+b').write(infile.read())

IPython/utils/tests/test_tempdir.py

@@ -0,0 +1,20 b''
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2012-  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#-----------------------------------------------------------------------------
+
+import os
+
+from IPython.utils.tempdir import NamedFileInTemporaryDirectory
+
+
+def test_named_file_in_temporary_directory():
+    with NamedFileInTemporaryDirectory('filename') as file:
+        name = file.name
+        assert not file.closed
+        assert os.path.exists(name)
+        file.write(b'test')
+    assert file.closed
+    assert not os.path.exists(name)

IPython/utils/ulinecache.py

@@ -0,0 +1,45 b''
+"""Wrapper around linecache which decodes files to unicode according to PEP 263.
+
+This is only needed for Python 2 - linecache in Python 3 does the same thing
+itself.
+"""
+import functools
+import linecache
+import sys
+
+from IPython.utils import py3compat
+from IPython.utils import openpy
+
+if py3compat.PY3:
+    getline = linecache.getline
+    
+    # getlines has to be looked up at runtime, because doctests monkeypatch it.
+    @functools.wraps(linecache.getlines)
+    def getlines(filename, module_globals=None):
+        return linecache.getlines(filename, module_globals=module_globals)
+
+else:
+    def getlines(filename, module_globals=None):
+        """Get the lines (as unicode) for a file from the cache.
+        Update the cache if it doesn't contain an entry for this file already."""
+        filename = py3compat.cast_bytes(filename, sys.getfilesystemencoding())
+        lines = linecache.getlines(filename, module_globals=module_globals)
+        
+        # The bits we cache ourselves can be unicode.
+        if (not lines) or isinstance(lines[0], unicode):
+            return lines
+        
+        readline = openpy._list_readline(lines)
+        try:
+            encoding, _ = openpy.detect_encoding(readline)
+        except SyntaxError:
+            encoding = 'ascii'
+        return [l.decode(encoding, 'replace') for l in lines]
+
+    # This is a straight copy of linecache.getline
+    def getline(filename, lineno, module_globals=None):
+        lines = getlines(filename, module_globals)
+        if 1 <= lineno <= len(lines):
+            return lines[lineno-1]
+        else:
+            return ''

docs/examples/core/ipython-completion.bash

@@ -0,0 +1,106 b''
+# load with: . ipython-completion.bash
+
+_ipython_get_flags()
+{
+    local url=$1
+    local var=$2
+    local dash=$3
+    if [[ "$url $var" == $__ipython_complete_last ]]; then
+        opts=$__ipython_complete_last_res
+        return
+    fi
+    # pylab and profile don't need the = and the
+    # version without simplifies the special cased completion
+    opts=$(ipython ${url} --help-all | grep -E "^-{1,2}[^-]" | sed -e "s/<.*//" -e "s/[^=]$/& /" -e "s/^--pylab=$//" -e "s/^--profile=$/--profile /")
+    __ipython_complete_last="$url $var"
+    __ipython_complete_last_res="$opts"
+}
+
+_ipython()
+{
+    local cur=${COMP_WORDS[COMP_CWORD]}
+    local prev=${COMP_WORDS[COMP_CWORD - 1]}
+    local subcommands="notebook qtconsole console kernel profile locate"
+    local opts=""
+    if [ -z "$__ipython_complete_baseopts" ]; then
+        _ipython_get_flags baseopts
+        __ipython_complete_baseopts="${opts}"
+    fi
+    local baseopts="$__ipython_complete_baseopts"
+    local mode=""
+    for i in "${COMP_WORDS[@]}"; do
+        [ "$cur" = "$i" ] && break
+        if [[ ${subcommands} == *${i}* ]]; then
+            mode="$i"
+            break
+        elif [[ ${i} == "--"* ]]; then
+            mode="nosubcommand"
+            break
+        fi
+    done
+
+    if [[ $mode == "profile" ]]; then
+        opts="list create"
+        COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
+    elif [[ ${cur} == -* ]]; then
+        if [[ $mode == "notebook" ]]; then
+            _ipython_get_flags notebook
+            opts=$"${opts} ${baseopts}"
+        elif [[ $mode == "qtconsole" ]]; then
+            _ipython_get_flags qtconsole
+            opts="${opts} ${baseopts}"
+        elif [[ $mode == "console" ]]; then
+            _ipython_get_flags console
+        elif [[ $mode == "kernel" ]]; then
+            _ipython_get_flags kernel
+            opts="${opts} ${baseopts}"
+        elif [[ $mode == "locate" ]]; then
+            opts=""
+        else
+            opts=$baseopts
+        fi
+        # don't drop the trailing space
+        local IFS=$'\t\n'
+        COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
+        return 0
+    elif [[ ${prev} == "--pylab"* ]] || [[ ${prev} == "--gui"* ]]; then
+        if [ -z "$__ipython_complete_pylab" ]; then
+            __ipython_complete_pylab=`cat <<EOF | python -
+try:
+    import IPython.core.shellapp as mod;
+    for k in mod.InteractiveShellApp.pylab.values:
+        print "%s " % k
+except:
+    pass
+EOF
+        `
+        fi
+        local IFS=$'\t\n'
+        COMPREPLY=( $(compgen -W "${__ipython_complete_pylab}" -- ${cur}) )
+    elif [[ ${prev} == "--profile"* ]]; then
+        if [ -z  "$__ipython_complete_profiles" ]; then
+        __ipython_complete_profiles=`cat <<EOF | python -
+try:
+    import IPython.core.profileapp
+    for k in IPython.core.profileapp.list_bundled_profiles():
+        print "%s " % k
+    p = IPython.core.profileapp.ProfileList()
+    for k in IPython.core.profileapp.list_profiles_in(p.ipython_dir):
+        print "%s " % k
+except:
+    pass
+EOF
+        `
+        fi
+        local IFS=$'\t\n'
+        COMPREPLY=( $(compgen -W "${__ipython_complete_profiles}" -- ${cur}) )
+    else
+        if [ -z "$mode" ]; then
+            COMPREPLY=( $(compgen -f -W "${subcommands}" -- ${cur}) )
+        else
+            COMPREPLY=( $(compgen -f -- ${cur}) )
+        fi
+    fi
+
+}
+complete -o default -o nospace -F _ipython ipython

docs/examples/notebooks/Typesetting Math Using MathJax.ipynb

@@ -0,0 +1,259 b''
+{
+ "metadata": {
+  "name": "Typesetting Math Using MathJax"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "The Markdown parser included in IPython 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."
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "# Motivating Examples\n",
+      "\n",
+      "---\n",
+      "\n",
+      "## The Lorenz Equations\n",
+      "### Source\n",
+      "```\\begin{aligned}\n",
+      "\\dot{x} & = \\sigma(y-x) \\\\\n",
+      "\\dot{y} & = \\rho x - y - xz \\\\\n",
+      "\\dot{z} & = -\\beta z + xy\n",
+      "\\end{aligned}\n",
+      "```\n",
+      "### Display\n",
+      "\\begin{aligned}\n",
+      "\\dot{x} & = \\sigma(y-x) \\\\\n",
+      "\\dot{y} & = \\rho x - y - xz \\\\\n",
+      "\\dot{z} & = -\\beta z + xy\n",
+      "\\end{aligned}"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "## The Cauchy-Schwarz Inequality\n",
+      "### Source\n",
+      "```\\begin{equation*}\n",
+      "\\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)\n",
+      "\\end{equation*}\n",
+      "```\n",
+      "### Display\n",
+      "\\begin{equation*}\n",
+      "\\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)\n",
+      "\\end{equation*}"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "## A Cross Product Formula\n",
+      "### Source\n",
+      "```\\begin{equation*}\n",
+      "\\mathbf{V}_1 \\times \\mathbf{V}_2 =  \\begin{vmatrix}\n",
+      "\\mathbf{i} & \\mathbf{j} & \\mathbf{k} \\\\\n",
+      "\\frac{\\partial X}{\\partial u} &  \\frac{\\partial Y}{\\partial u} & 0 \\\\\n",
+      "\\frac{\\partial X}{\\partial v} &  \\frac{\\partial Y}{\\partial v} & 0\n",
+      "\\end{vmatrix}  \n",
+      "\\end{equation*}\n",
+      "```\n",
+      "### Display\n",
+      "\\begin{equation*}\n",
+      "\\mathbf{V}_1 \\times \\mathbf{V}_2 =  \\begin{vmatrix}\n",
+      "\\mathbf{i} & \\mathbf{j} & \\mathbf{k} \\\\\n",
+      "\\frac{\\partial X}{\\partial u} &  \\frac{\\partial Y}{\\partial u} & 0 \\\\\n",
+      "\\frac{\\partial X}{\\partial v} &  \\frac{\\partial Y}{\\partial v} & 0\n",
+      "\\end{vmatrix}  \n",
+      "\\end{equation*}"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "## The probability of getting \\(k\\) heads when flipping \\(n\\) coins is\n",
+      "### Source\n",
+      "```\\begin{equation*}\n",
+      "P(E)   = {n \\choose k} p^k (1-p)^{ n-k} \n",
+      "\\end{equation*}\n",
+      "```\n",
+      "### Display\n",
+      "\\begin{equation*}\n",
+      "P(E)   = {n \\choose k} p^k (1-p)^{ n-k} \n",
+      "\\end{equation*}"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "## An Identity of Ramanujan\n",
+      "### Source\n",
+      "```\\begin{equation*}\n",
+      "\\frac{1}{\\Bigl(\\sqrt{\\phi \\sqrt{5}}-\\phi\\Bigr) e^{\\frac25 \\pi}} =\n",
+      "1+\\frac{e^{-2\\pi}} {1+\\frac{e^{-4\\pi}} {1+\\frac{e^{-6\\pi}}\n",
+      "{1+\\frac{e^{-8\\pi}} {1+\\ldots} } } } \n",
+      "\\end{equation*}\n",
+      "```\n",
+      "### Display\n",
+      "\\begin{equation*}\n",
+      "\\frac{1}{\\Bigl(\\sqrt{\\phi \\sqrt{5}}-\\phi\\Bigr) e^{\\frac25 \\pi}} =\n",
+      "1+\\frac{e^{-2\\pi}} {1+\\frac{e^{-4\\pi}} {1+\\frac{e^{-6\\pi}}\n",
+      "{1+\\frac{e^{-8\\pi}} {1+\\ldots} } } } \n",
+      "\\end{equation*}"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "## A Rogers-Ramanujan Identity\n",
+      "### Source\n",
+      "```\\begin{equation*}\n",
+      "1 +  \\frac{q^2}{(1-q)}+\\frac{q^6}{(1-q)(1-q^2)}+\\cdots =\n",
+      "\\prod_{j=0}^{\\infty}\\frac{1}{(1-q^{5j+2})(1-q^{5j+3})},\n",
+      "\\quad\\quad \\text{for $|q|<1$}. \n",
+      "\\end{equation*}\n",
+      "```\n",
+      "### Display\n",
+      "\\begin{equation*}\n",
+      "1 + \\frac{q^2}{(1-q)}+\\frac{q^6}{(1-q)(1-q^2)}+\\cdots =\n",
+      "\\prod_{j=0}^{\\infty}\\frac{1}{(1-q^{5j+2})(1-q^{5j+3})},\n",
+      "\\quad\\quad \\text{for $|q|<1$}. \n",
+      "\\end{equation*}"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "## Maxwell's Equations\n",
+      "### Source\n",
+      "```\\begin{aligned}\n",
+      "\\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 \\\\\n",
+      "\\nabla \\times \\vec{\\mathbf{E}}\\, +\\, \\frac1c\\, \\frac{\\partial\\vec{\\mathbf{B}}}{\\partial t} & = \\vec{\\mathbf{0}} \\\\\n",
+      "\\nabla \\cdot \\vec{\\mathbf{B}} & = 0 \n",
+      "\\end{aligned}\n",
+      "```\n",
+      "### Display\n",
+      "\\begin{aligned}\n",
+      "\\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 \\\\\n",
+      "\\nabla \\times \\vec{\\mathbf{E}}\\, +\\, \\frac1c\\, \\frac{\\partial\\vec{\\mathbf{B}}}{\\partial t} & = \\vec{\\mathbf{0}} \\\\\n",
+      "\\nabla \\cdot \\vec{\\mathbf{B}} & = 0 \n",
+      "\\end{aligned}"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "# Equation Numbering and References\n",
+      "\n",
+      "---\n",
+      "\n",
+      "Equation numbering and referencing will be available in a future version of IPython."
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "# Inline Typesetting (Mixing Markdown and TeX)\n",
+      "\n",
+      "---\n",
+      "\n",
+      "While display equations look good for a page of samples, the ability to mix math and *formatted* **text** in a paragraph is also important.\n",
+      "\n",
+      "## Source\n",
+      "``` 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.  \n",
+      "```\n",
+      "## Display\n",
+      "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.  "
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "# Other Syntax\n",
+      "\n",
+      "---\n",
+      "\n",
+      "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 IPython notebook will accept this syntax on legacy notebooks.  \n",
+      "\n",
+      "### Source\n",
+      "```$$\n",
+      "\\begin{array}{c}\n",
+      "y_1 \\\\\\\n",
+      "y_2 \\mathtt{t}_i \\\\\\\n",
+      "z_{3,4}\n",
+      "\\end{array}\n",
+      "$$\n",
+      "```\n",
+      "\n",
+      "```\n",
+      "$$\n",
+      "\\begin{array}{c}\n",
+      "y_1 \\cr\n",
+      "y_2 \\mathtt{t}_i \\cr\n",
+      "y_{3}\n",
+      "\\end{array}\n",
+      "$$\n",
+      "```\n",
+      "\n",
+      "```\n",
+      "$$\\begin{eqnarray} \n",
+      "x' &=& &x \\sin\\phi &+& z \\cos\\phi \\\\\n",
+      "z' &=& - &x \\cos\\phi &+& z \\sin\\phi \\\\\n",
+      "\\end{eqnarray}$$\n",
+      "```\n",
+      "\n",
+      "```\n",
+      "$$\n",
+      "x=4\n",
+      "$$\n",
+      "```\n",
+      "\n",
+      "### Display\n",
+      "$$\n",
+      "\\begin{array}{c}\n",
+      "y_1 \\\\\\\n",
+      "y_2 \\mathtt{t}_i \\\\\\\n",
+      "z_{3,4}\n",
+      "\\end{array}\n",
+      "$$\n",
+      "\n",
+      "$$\n",
+      "\\begin{array}{c}\n",
+      "y_1 \\cr\n",
+      "y_2 \\mathtt{t}_i \\cr\n",
+      "y_{3}\n",
+      "\\end{array}\n",
+      "$$\n",
+      "\n",
+      "$$\\begin{eqnarray} \n",
+      "x' &=& &x \\sin\\phi &+& z \\cos\\phi \\\\\n",
+      "z' &=& - &x \\cos\\phi &+& z \\sin\\phi \\\\\n",
+      "\\end{eqnarray}$$\n",
+      "\n",
+      "$$\n",
+      "x=4\n",
+      "$$"
+     ]
+    }
+   ],
+   "metadata": {}
+  }
+ ]
+}
  No newline at end of file

tools/backport_pr.py

@@ -0,0 +1,90 b''
+#!/usr/bin/env python
+"""
+Backport pull requests to a particular branch.
+
+Usage: backport_pr.py branch PR
+
+e.g.:
+
+    backport_pr.py 0.13.1 123
+
+to backport PR #123 onto branch 0.13.1
+
+"""
+
+from __future__ import print_function
+
+import os
+import sys
+from subprocess import Popen, PIPE, check_call, check_output
+from urllib import urlopen
+
+from gh_api import get_pull_request
+
+def find_rejects(root='.'):
+    for dirname, dirs, files in os.walk(root):
+        for fname in files:
+            if fname.endswith('.rej'):
+                yield os.path.join(dirname, fname)
+
+def get_current_branch():
+    branches = check_output(['git', 'branch'])
+    for branch in branches.splitlines():
+        if branch.startswith('*'):
+            return branch[1:].strip()
+
+def backport_pr(branch, num, project='ipython/ipython'):
+    current_branch = get_current_branch()
+    if branch != current_branch:
+        check_call(['git', 'checkout', branch])
+    pr = get_pull_request(project, num)
+    patch_url = pr['patch_url']
+    title = pr['title']
+    description = pr['body']
+    fname = "PR%i.patch" % num
+    if os.path.exists(fname):
+        print("using patch from {fname}".format(**locals()))
+        with open(fname) as f:
+            patch = f.read()
+    else:
+        req = urlopen(patch_url)
+        patch = req.read()
+    
+    msg = "Backport PR #%i: %s" % (num, title) + '\n\n' + description
+    check = Popen(['git', 'apply', '--check', '--verbose'], stdin=PIPE)
+    a,b = check.communicate(patch)
+    
+    if check.returncode:
+        print("patch did not apply, saving to {fname}".format(**locals()))
+        print("edit {fname} until `cat {fname} | git apply --check` succeeds".format(**locals()))
+        print("then run tools/backport_pr.py {num} again".format(**locals()))
+        if not os.path.exists(fname):
+            with open(fname, 'wb') as f:
+                f.write(patch)
+        return 1
+    
+    p = Popen(['git', 'apply'], stdin=PIPE)
+    a,b = p.communicate(patch)
+
+    commit = Popen(['git', 'commit', '-a', '-m', msg])
+    commit.communicate()
+    if commit.returncode:
+        print("commit failed!")
+        return 1
+    else:
+        print("PR #%i applied, with msg:" % num)
+        print()
+        print(msg)
+        print()
+    
+    if branch != current_branch:
+        check_call(['git', 'checkout', current_branch])
+    
+    return 0
+
+if __name__ == '__main__':
+    if len(sys.argv) < 3:
+        print(__doc__)
+        sys.exit(1)
+    
+    sys.exit(backport_pr(sys.argv[1], int(sys.argv[2])))

.gitignore

@@ -7,6 +7,7 b' docs/source/api/generated'
 docs/gh-pages
 IPython/frontend/html/notebook/static/mathjax
 *.py[co]
+__pycache__
 build
 *.egg-info
 *~

IPython/__init__.py

@@ -57,6 +57,7 b' for author, email in release.authors.itervalues():'
     __author__ += author + ' <' + email + '>\n'
 __license__  = release.license
 __version__  = release.version
+version_info = release.version_info
 
 def embed_kernel(module=None, local_ns=None, **kwargs):
     """Embed and start an IPython kernel in a given scope.

IPython/core/application.py

@@ -181,7 +181,7 b' class BaseIPythonApplication(Application):'
             sys.path.remove(old)
         sys.path.append(os.path.abspath(new))
         if not os.path.isdir(new):
-            os.makedirs(new, mode=0777)
+            os.makedirs(new, mode=0o777)
         readme = os.path.join(new, 'README')
         if not os.path.exists(readme):
             path = os.path.join(get_ipython_package_dir(), u'config', u'profile')

IPython/core/completerlib.py

@@ -17,6 +17,7 b' from __future__ import print_function'
 
 # Stdlib imports
 import glob
+import imp
 import inspect
 import os
 import re
@@ -90,7 +91,8 b' def module_list(path):'
 
     # Now find actual path matches for packages or modules
     folder_list = [p for p in folder_list
-                   if isfile(pjoin(path, p,'__init__.py'))
+                   if any(isfile(pjoin(path, p, '__init__' + suffix[0])) for
+                       suffix in imp.get_suffixes())
                    or is_importable_file(p) ]
 
     return [basename(p).split('.')[0] for p in folder_list]

IPython/core/debugger.py

@@ -30,9 +30,9 b' import bdb'
 import linecache
 import sys
 
-from IPython.utils import PyColorize
+from IPython.utils import PyColorize, ulinecache
 from IPython.core import ipapi
-from IPython.utils import coloransi, io
+from IPython.utils import coloransi, io, openpy, py3compat
 from IPython.core.excolors import exception_colors
 
 # See if we can use pydb.
@@ -304,16 +304,16 b' class Pdb(OldPdb):'
         # vds: <<
 
     def format_stack_entry(self, frame_lineno, lprefix=': ', context = 3):
-        import linecache, repr
+        import repr
 
         ret = []
 
         Colors = self.color_scheme_table.active_colors
         ColorsNormal = Colors.Normal
-        tpl_link = '%s%%s%s' % (Colors.filenameEm, ColorsNormal)
-        tpl_call = '%s%%s%s%%s%s' % (Colors.vName, Colors.valEm, ColorsNormal)
-        tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
-        tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line,
+        tpl_link = u'%s%%s%s' % (Colors.filenameEm, ColorsNormal)
+        tpl_call = u'%s%%s%s%%s%s' % (Colors.vName, Colors.valEm, ColorsNormal)
+        tpl_line = u'%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
+        tpl_line_em = u'%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line,
                                             ColorsNormal)
 
         frame, lineno = frame_lineno
@@ -327,7 +327,7 b' class Pdb(OldPdb):'
 
         #s = filename + '(' + `lineno` + ')'
         filename = self.canonic(frame.f_code.co_filename)
-        link = tpl_link % filename
+        link = tpl_link % py3compat.cast_unicode(filename)
 
         if frame.f_code.co_name:
             func = frame.f_code.co_name
@@ -348,10 +348,10 b' class Pdb(OldPdb):'
             ret.append('> ')
         else:
             ret.append('  ')
-        ret.append('%s(%s)%s\n' % (link,lineno,call))
+        ret.append(u'%s(%s)%s\n' % (link,lineno,call))
 
         start = lineno - 1 - context//2
-        lines = linecache.getlines(filename)
+        lines = ulinecache.getlines(filename)
         start = max(start, 0)
         start = min(start, len(lines) - context)
         lines = lines[start : start + context]
@@ -364,7 +364,6 b' class Pdb(OldPdb):'
             ret.append(self.__format_line(linetpl, filename,
                                           start + 1 + i, line,
                                           arrow = show_arrow) )
-
         return ''.join(ret)
 
     def __format_line(self, tpl_line, filename, lineno, line, arrow = False):
@@ -422,8 +421,11 b' class Pdb(OldPdb):'
             tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
             tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line, ColorsNormal)
             src = []
+            if filename == "<string>" and hasattr(self, "_exec_filename"):
+                filename = self._exec_filename
+            
             for lineno in range(first, last+1):
-                line = linecache.getline(filename, lineno)
+                line = ulinecache.getline(filename, lineno)
                 if not line:
                     break
 
@@ -475,23 +477,51 b' class Pdb(OldPdb):'
     do_l = do_list
 
     def do_pdef(self, arg):
-        """The debugger interface to magic_pdef"""
+        """Print the call signature for any callable object.
+
+        The debugger interface to %pdef"""
         namespaces = [('Locals', self.curframe.f_locals),
                       ('Globals', self.curframe.f_globals)]
         self.shell.find_line_magic('pdef')(arg, namespaces=namespaces)
 
     def do_pdoc(self, arg):
-        """The debugger interface to magic_pdoc"""
+        """Print the docstring for an object.
+
+        The debugger interface to %pdoc."""
         namespaces = [('Locals', self.curframe.f_locals),
                       ('Globals', self.curframe.f_globals)]
         self.shell.find_line_magic('pdoc')(arg, namespaces=namespaces)
 
+    def do_pfile(self, arg):
+        """Print (or run through pager) the file where an object is defined.
+
+        The debugger interface to %pfile.
+        """
+        namespaces = [('Locals', self.curframe.f_locals),
+                      ('Globals', self.curframe.f_globals)]
+        self.shell.find_line_magic('pfile')(arg, namespaces=namespaces)
+
     def do_pinfo(self, arg):
-        """The debugger equivalant of ?obj"""
+        """Provide detailed information about an object.
+
+        The debugger interface to %pinfo, i.e., obj?."""
+        namespaces = [('Locals', self.curframe.f_locals),
+                      ('Globals', self.curframe.f_globals)]
+        self.shell.find_line_magic('pinfo')(arg, namespaces=namespaces)
+
+    def do_pinfo2(self, arg):
+        """Provide extra detailed information about an object.
+
+        The debugger interface to %pinfo2, i.e., obj??."""
+        namespaces = [('Locals', self.curframe.f_locals),
+                      ('Globals', self.curframe.f_globals)]
+        self.shell.find_line_magic('pinfo2')(arg, namespaces=namespaces)
+
+    def do_psource(self, arg):
+        """Print (or run through pager) the source code for an object."""
         namespaces = [('Locals', self.curframe.f_locals),
                       ('Globals', self.curframe.f_globals)]
-        self.shell.find_line_magic('pinfo')("pinfo %s" % arg,
-                                            namespaces=namespaces)
+        self.shell.find_line_magic('psource')(arg, namespaces=namespaces)
 
     def checkline(self, filename, lineno):
         """Check whether specified line seems to be executable.

IPython/core/displayhook.py

@@ -25,6 +25,9 b' from __future__ import print_function'
 
 import __builtin__
 
+import sys
+
+
 from IPython.config.configurable import Configurable
 from IPython.utils import io
 from IPython.utils.traitlets import Instance, List
@@ -266,5 +269,7 b' class DisplayHook(Configurable):'
             self.shell.user_ns.update({'_':None,'__':None, '___':None})
         import gc
         # TODO: Is this really needed?
-        gc.collect()
+        # IronPython blocks here forever
+        if sys.platform != "cli":
+            gc.collect()
 

IPython/core/extensions.py

@@ -23,8 +23,12 b' import sys'
 from urllib import urlretrieve
 from urlparse import urlparse
 
+from IPython.core.error import UsageError
 from IPython.config.configurable import Configurable
 from IPython.utils.traitlets import Instance
+from IPython.utils.py3compat import PY3
+if PY3:
+    from imp import reload
 
 #-----------------------------------------------------------------------------
 # Main class
@@ -44,10 +48,11 b' class ExtensionManager(Configurable):'
     the only argument.  You can do anything you want with IPython at
     that point, including defining new magic and aliases, adding new
     components, etc.
-
-    The :func:`load_ipython_extension` will be called again is you
-    load or reload the extension again.  It is up to the extension
-    author to add code to manage that.
+    
+    You can also optionaly define an :func:`unload_ipython_extension(ipython)`
+    function, which will be called if the user unloads or reloads the extension.
+    The extension manager will only call :func:`load_ipython_extension` again
+    if the extension is reloaded.
 
     You can put your extension modules anywhere you want, as long as
     they can be imported by Python's standard import mechanism.  However,
@@ -63,6 +68,7 b' class ExtensionManager(Configurable):'
         self.shell.on_trait_change(
             self._on_ipython_dir_changed, 'ipython_dir'
         )
+        self.loaded = set()
 
     def __del__(self):
         self.shell.on_trait_change(
@@ -75,31 +81,48 b' class ExtensionManager(Configurable):'
 
     def _on_ipython_dir_changed(self):
         if not os.path.isdir(self.ipython_extension_dir):
-            os.makedirs(self.ipython_extension_dir, mode = 0777)
+            os.makedirs(self.ipython_extension_dir, mode = 0o777)
 
     def load_extension(self, module_str):
         """Load an IPython extension by its module name.
 
-        If :func:`load_ipython_extension` returns anything, this function
-        will return that object.
+        Returns the string "already loaded" if the extension is already loaded,
+        "no load function" if the module doesn't have a load_ipython_extension
+        function, or None if it succeeded.
         """
+        if module_str in self.loaded:
+            return "already loaded"
+        
         from IPython.utils.syspathcontext import prepended_to_syspath
 
         if module_str not in sys.modules:
             with prepended_to_syspath(self.ipython_extension_dir):
                 __import__(module_str)
         mod = sys.modules[module_str]
-        return self._call_load_ipython_extension(mod)
+        if self._call_load_ipython_extension(mod):
+            self.loaded.add(module_str)
+        else:
+            return "no load function"
 
     def unload_extension(self, module_str):
         """Unload an IPython extension by its module name.
 
         This function looks up the extension's name in ``sys.modules`` and
         simply calls ``mod.unload_ipython_extension(self)``.
+        
+        Returns the string "no unload function" if the extension doesn't define
+        a function to unload itself, "not loaded" if the extension isn't loaded,
+        otherwise None.
         """
+        if module_str not in self.loaded:
+            return "not loaded"
+        
         if module_str in sys.modules:
             mod = sys.modules[module_str]
-            self._call_unload_ipython_extension(mod)
+            if self._call_unload_ipython_extension(mod):
+                self.loaded.discard(module_str)
+            else:
+                return "no unload function"
 
     def reload_extension(self, module_str):
         """Reload an IPython extension by calling reload.
@@ -111,21 +134,25 b' class ExtensionManager(Configurable):'
         """
         from IPython.utils.syspathcontext import prepended_to_syspath
 
-        with prepended_to_syspath(self.ipython_extension_dir):
-            if module_str in sys.modules:
-                mod = sys.modules[module_str]
+        if (module_str in self.loaded) and (module_str in sys.modules):
+            self.unload_extension(module_str)
+            mod = sys.modules[module_str]
+            with prepended_to_syspath(self.ipython_extension_dir):
                 reload(mod)
-                self._call_load_ipython_extension(mod)
-            else:
-                self.load_extension(module_str)
+            if self._call_load_ipython_extension(mod):
+                self.loaded.add(module_str)
+        else:
+            self.load_extension(module_str)
 
     def _call_load_ipython_extension(self, mod):
         if hasattr(mod, 'load_ipython_extension'):
-            return mod.load_ipython_extension(self.shell)
+            mod.load_ipython_extension(self.shell)
+            return True
 
     def _call_unload_ipython_extension(self, mod):
         if hasattr(mod, 'unload_ipython_extension'):
-            return mod.unload_ipython_extension(self.shell)
+            mod.unload_ipython_extension(self.shell)
+            return True
     
     def install_extension(self, url, filename=None):
         """Download and install an IPython extension. 
@@ -138,7 +165,7 b' class ExtensionManager(Configurable):'
         """
         # Ensure the extension directory exists
         if not os.path.isdir(self.ipython_extension_dir):
-            os.makedirs(self.ipython_extension_dir, mode = 0777)
+            os.makedirs(self.ipython_extension_dir, mode = 0o777)
         
         if os.path.isfile(url):
             src_filename = os.path.basename(url)

IPython/core/history.py

@@ -62,6 +62,37 b' def needs_sqlite(f, self, *a, **kw):'
         return f(self, *a, **kw)
 
 
+if sqlite3 is not None:
+    DatabaseError = sqlite3.DatabaseError
+else:
+    class DatabaseError(Exception):
+        "Dummy exception when sqlite could not be imported. Should never occur."
+
+@decorator
+def catch_corrupt_db(f, self, *a, **kw):
+    """A decorator which wraps HistoryAccessor method calls to catch errors from
+    a corrupt SQLite database, move the old database out of the way, and create
+    a new one.
+    """
+    try:
+        return f(self, *a, **kw)
+    except DatabaseError:
+        if os.path.isfile(self.hist_file):
+            # Try to move the file out of the way
+            base,ext = os.path.splitext(self.hist_file)
+            newpath = base + '-corrupt' + ext
+            os.rename(self.hist_file, newpath)
+            self.init_db()
+            print("ERROR! History file wasn't a valid SQLite database.",
+            "It was moved to %s" % newpath, "and a new file created.")
+            return []
+        
+        else:
+            # The hist_file is probably :memory: or something else.
+            raise
+        
+
+
 class HistoryAccessor(Configurable):
     """Access the history database without adding to it.
     
@@ -143,25 +174,7 b' class HistoryAccessor(Configurable):'
             warn("IPython History requires SQLite, your history will not be saved\n")
             self.enabled = False
         
-        if sqlite3 is not None:
-            DatabaseError = sqlite3.DatabaseError
-        else:
-            DatabaseError = Exception
-        
-        try:
-            self.init_db()
-        except DatabaseError:
-            if os.path.isfile(self.hist_file):
-                # Try to move the file out of the way
-                base,ext = os.path.splitext(self.hist_file)
-                newpath = base + '-corrupt' + ext
-                os.rename(self.hist_file, newpath)
-                print("ERROR! History file wasn't a valid SQLite database.",
-                "It was moved to %s" % newpath, "and a new file created.")
-                self.init_db()
-            else:
-                # The hist_file is probably :memory: or something else.
-                raise
+        self.init_db()
     
     def _get_hist_file_name(self, profile='default'):
         """Find the history file for the given profile name.
@@ -176,6 +189,7 b' class HistoryAccessor(Configurable):'
         """
         return os.path.join(locate_profile(profile), 'history.sqlite')
     
+    @catch_corrupt_db
     def init_db(self):
         """Connect to the database, and create tables if necessary."""
         if not self.enabled:
@@ -235,6 +249,7 b' class HistoryAccessor(Configurable):'
         return cur
 
     @needs_sqlite
+    @catch_corrupt_db
     def get_session_info(self, session=0):
         """get info about a session
 
@@ -262,6 +277,7 b' class HistoryAccessor(Configurable):'
         query = "SELECT * from sessions where session == ?"
         return self.db.execute(query, (session,)).fetchone()
 
+    @catch_corrupt_db
     def get_tail(self, n=10, raw=True, output=False, include_latest=False):
         """Get the last n lines from the history database.
 
@@ -289,8 +305,9 b' class HistoryAccessor(Configurable):'
             return reversed(list(cur)[1:])
         return reversed(list(cur))
 
+    @catch_corrupt_db
     def search(self, pattern="*", raw=True, search_raw=True,
-                                                        output=False):
+               output=False, n=None):
         """Search the database using unix glob-style matching (wildcards
         * and ?).
 
@@ -302,6 +319,9 b' class HistoryAccessor(Configurable):'
           If True, search the raw input, otherwise, the parsed input
         raw, output : bool
           See :meth:`get_range`
+        n : None or int
+          If an integer is given, it defines the limit of
+          returned entries.
 
         Returns
         -------
@@ -311,9 +331,17 b' class HistoryAccessor(Configurable):'
         if output:
             tosearch = "history." + tosearch
         self.writeout_cache()
-        return self._run_sql("WHERE %s GLOB ?" % tosearch, (pattern,),
-                                    raw=raw, output=output)
+        sqlform = "WHERE %s GLOB ?" % tosearch
+        params = (pattern,)
+        if n is not None:
+            sqlform += " ORDER BY session DESC, line DESC LIMIT ?"
+            params += (n,)
+        cur = self._run_sql(sqlform, params, raw=raw, output=output)
+        if n is not None:
+            return reversed(list(cur))
+        return cur
     
+    @catch_corrupt_db
     def get_range(self, session, start=1, stop=None, raw=True,output=False):
         """Retrieve input by session.
 
@@ -347,7 +375,7 b' class HistoryAccessor(Configurable):'
             lineclause = "line>=?"
             params = (session, start)
 
-        return self._run_sql("WHERE session==? AND %s""" % lineclause,
+        return self._run_sql("WHERE session==? AND %s" % lineclause,
                                     params, raw=raw, output=output)
 
     def get_range_by_str(self, rangestr, raw=True, output=False):

IPython/core/interactiveshell.py

@@ -29,17 +29,11 b' import runpy'
 import sys
 import tempfile
 import types
-
-# We need to use nested to support python 2.6, once we move to >=2.7, we can
-# use the with keyword's new builtin support for nested managers
-try:
-    from contextlib import nested
-except:
-    from IPython.utils.nested_context import nested
+import urllib
+from io import open as io_open
 
 from IPython.config.configurable import SingletonConfigurable
 from IPython.core import debugger, oinspect
-from IPython.core import history as ipcorehist
 from IPython.core import magic
 from IPython.core import page
 from IPython.core import prefilter
@@ -61,7 +55,6 b' from IPython.core.inputsplitter import IPythonInputSplitter, ESC_MAGIC, ESC_MAGI'
 from IPython.core.logger import Logger
 from IPython.core.macro import Macro
 from IPython.core.payload import PayloadManager
-from IPython.core.plugin import PluginManager
 from IPython.core.prefilter import PrefilterManager
 from IPython.core.profiledir import ProfileDir
 from IPython.core.pylabtools import pylab_activate
@@ -392,7 +385,6 b' class InteractiveShell(SingletonConfigurable):'
     builtin_trap = Instance('IPython.core.builtin_trap.BuiltinTrap')
     display_trap = Instance('IPython.core.display_trap.DisplayTrap')
     extension_manager = Instance('IPython.core.extensions.ExtensionManager')
-    plugin_manager = Instance('IPython.core.plugin.PluginManager')
     payload_manager = Instance('IPython.core.payload.PayloadManager')
     history_manager = Instance('IPython.core.history.HistoryManager')
     magics_manager = Instance('IPython.core.magic.MagicsManager')
@@ -492,7 +484,6 b' class InteractiveShell(SingletonConfigurable):'
         self.init_logstart()
         self.init_pdb()
         self.init_extension_manager()
-        self.init_plugin_manager()
         self.init_payload()
         self.hooks.late_startup_hook()
         atexit.register(self.atexit_operations)
@@ -507,7 +498,7 b' class InteractiveShell(SingletonConfigurable):'
 
     def _ipython_dir_changed(self, name, new):
         if not os.path.isdir(new):
-            os.makedirs(new, mode = 0777)
+            os.makedirs(new, mode = 0o777)
 
     def set_autoindent(self,value=None):
         """Set the autoindent flag, checking for readline support.
@@ -638,7 +629,7 b' class InteractiveShell(SingletonConfigurable):'
         # override sys.stdout and sys.stderr themselves, you need to do that
         # *before* instantiating this class, because io holds onto
         # references to the underlying streams.
-        if sys.platform == 'win32' and self.has_readline:
+        if (sys.platform == 'win32' or sys.platform == 'cli') and self.has_readline:
             io.stdout = io.stderr = io.IOStream(self.readline._outputfile)
         else:
             io.stdout = io.IOStream(sys.stdout)
@@ -1722,7 +1713,7 b' class InteractiveShell(SingletonConfigurable):'
                 self.write_err('No traceback available to show.\n')
                 return
             
-            if etype is SyntaxError:
+            if issubclass(etype, SyntaxError):
                 # Though this won't be called by syntax errors in the input
                 # line, there may be SyntaxError cases with imported code.
                 self.showsyntaxerror(filename)
@@ -1775,7 +1766,7 b' class InteractiveShell(SingletonConfigurable):'
         """
         etype, value, last_traceback = self._get_exc_info()
 
-        if filename and etype is SyntaxError:
+        if filename and issubclass(etype, SyntaxError):
             try:
                 value.filename = filename
             except:
@@ -2288,18 +2279,13 b' class InteractiveShell(SingletonConfigurable):'
         self.ns_table['alias'] = self.alias_manager.alias_table,
 
     #-------------------------------------------------------------------------
-    # Things related to extensions and plugins
+    # Things related to extensions
     #-------------------------------------------------------------------------
 
     def init_extension_manager(self):
         self.extension_manager = ExtensionManager(shell=self, config=self.config)
         self.configurables.append(self.extension_manager)
 
-    def init_plugin_manager(self):
-        self.plugin_manager = PluginManager(config=self.config)
-        self.configurables.append(self.plugin_manager)
-        
-
     #-------------------------------------------------------------------------
     # Things related to payloads
     #-------------------------------------------------------------------------
@@ -2461,9 +2447,6 b' class InteractiveShell(SingletonConfigurable):'
         dname = os.path.dirname(fname)
 
         with prepended_to_syspath(dname):
-            # Ensure that __file__ is always defined to match Python behavior
-            save_fname = self.user_ns.get('__file__',None)
-            self.user_ns['__file__'] = fname
             try:
                 py3compat.execfile(fname,*where)
             except SystemExit as status:
@@ -2484,8 +2467,6 b' class InteractiveShell(SingletonConfigurable):'
                 if kw['raise_exceptions']:
                     raise
                 self.showtraceback()
-            finally:
-                self.user_ns['__file__'] = save_fname
 
     def safe_execfile_ipy(self, fname):
         """Like safe_execfile, but for .ipy files with IPython syntax.
@@ -2512,9 +2493,6 b' class InteractiveShell(SingletonConfigurable):'
         dname = os.path.dirname(fname)
 
         with prepended_to_syspath(dname):
-            # Ensure that __file__ is always defined to match Python behavior
-            save_fname = self.user_ns.get('__file__',None)
-            self.user_ns['__file__'] = fname
             try:
                 with open(fname) as thefile:
                     # self.run_cell currently captures all exceptions
@@ -2525,8 +2503,6 b' class InteractiveShell(SingletonConfigurable):'
             except:
                 self.showtraceback()
                 warn('Unknown failure executing file: <%s>' % fname)
-            finally:
-                self.user_ns['__file__'] = save_fname
 
     def safe_run_module(self, mod_name, where):
         """A safe version of runpy.run_module().
@@ -2914,7 +2890,7 b' class InteractiveShell(SingletonConfigurable):'
         lines = self.history_manager.get_range_by_str(range_str, raw=raw)
         return "\n".join(x for _, _, x in lines)
 
-    def find_user_code(self, target, raw=True, py_only=False):
+    def find_user_code(self, target, raw=True, py_only=False, skip_encoding_cookie=True):
         """Get a code string from history, file, url, or a string or macro.
 
         This is mainly used by magic functions.
@@ -2951,7 +2927,7 b' class InteractiveShell(SingletonConfigurable):'
         utarget = unquote_filename(target)
         try:
             if utarget.startswith(('http://', 'https://')):
-                return openpy.read_py_url(utarget, skip_encoding_cookie=True)
+                return openpy.read_py_url(utarget, skip_encoding_cookie=skip_encoding_cookie)
         except UnicodeDecodeError:
             if not py_only :
                 response = urllib.urlopen(target)
@@ -2967,7 +2943,7 b' class InteractiveShell(SingletonConfigurable):'
         for tgt in potential_target :
             if os.path.isfile(tgt):                        # Read file
                 try :
-                    return openpy.read_py_file(tgt, skip_encoding_cookie=True)
+                    return openpy.read_py_file(tgt, skip_encoding_cookie=skip_encoding_cookie)
                 except UnicodeDecodeError :
                     if not py_only :
                         with io_open(tgt,'r', encoding='latin1') as f :

IPython/core/magic_arguments.py

@@ -66,7 +66,6 b' class MagicArgumentParser(argparse.ArgumentParser):'
                  usage=None,
                  description=None,
                  epilog=None,
-                 version=None,
                  parents=None,
                  formatter_class=MagicHelpFormatter,
                  prefix_chars='-',
@@ -76,7 +75,7 b' class MagicArgumentParser(argparse.ArgumentParser):'
         if parents is None:
             parents = []
         super(MagicArgumentParser, self).__init__(prog=prog, usage=usage,
-            description=description, epilog=epilog, version=version,
+            description=description, epilog=epilog,
             parents=parents, formatter_class=formatter_class,
             prefix_chars=prefix_chars, argument_default=argument_default,
             conflict_handler=conflict_handler, add_help=add_help)
@@ -174,11 +173,17 b' class magic_arguments(ArgDecorator):'
         return func
 
 
-class argument(ArgDecorator):
-    """ Store arguments and keywords to pass to add_argument().
+class ArgMethodWrapper(ArgDecorator):
+
+    """
+    Base class to define a wrapper for ArgumentParser method.
+
+    Child class must define either `_method_name` or `add_to_parser`.
 
-    Instances also serve to decorate command methods.
     """
+
+    _method_name = None
+
     def __init__(self, *args, **kwds):
         self.args = args
         self.kwds = kwds
@@ -188,18 +193,31 b' class argument(ArgDecorator):'
         """
         if group is not None:
             parser = group
-        parser.add_argument(*self.args, **self.kwds)
+        getattr(parser, self._method_name)(*self.args, **self.kwds)
         return None
 
 
-class argument_group(ArgDecorator):
+class argument(ArgMethodWrapper):
+    """ Store arguments and keywords to pass to add_argument().
+
+    Instances also serve to decorate command methods.
+    """
+    _method_name = 'add_argument'
+
+
+class defaults(ArgMethodWrapper):
+    """ Store arguments and keywords to pass to set_defaults().
+
+    Instances also serve to decorate command methods.
+    """
+    _method_name = 'set_defaults'
+
+
+class argument_group(ArgMethodWrapper):
     """ Store arguments and keywords to pass to add_argument_group().
 
     Instances also serve to decorate command methods.
     """
-    def __init__(self, *args, **kwds):
-        self.args = args
-        self.kwds = kwds
 
     def add_to_parser(self, parser, group):
         """ Add this object's information to the parser.

IPython/core/magics/basic.py

@@ -313,7 +313,8 b' Currently the magic system has the following functions:""",'
         import IPython.utils.rlineimpl as readline
 
         if not shell.colors_force and \
-                not readline.have_readline and sys.platform == "win32":
+                not readline.have_readline and \
+                (sys.platform == "win32" or sys.platform == "cli"):
             msg = """\
 Proper color support under MS Windows requires the pyreadline library.
 You can find it at:

IPython/core/magics/execution.py

@@ -44,10 +44,11 b' from IPython.utils import py3compat'
 from IPython.utils.io import capture_output
 from IPython.utils.ipstruct import Struct
 from IPython.utils.module_paths import find_mod
-from IPython.utils.path import get_py_filename, unquote_filename
+from IPython.utils.path import get_py_filename, unquote_filename, shellglob
 from IPython.utils.timing import clock, clock2
 from IPython.utils.warn import warn, error
 
+
 #-----------------------------------------------------------------------------
 # Magic implementation classes
 #-----------------------------------------------------------------------------
@@ -324,7 +325,7 b' python-profiler package from non-free.""")'
         """Run the named file inside IPython as a program.
 
         Usage:\\
-          %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
+          %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options] -G] file [args]
 
         Parameters after the filename are passed as command-line arguments to
         the program (put in sys.argv). Then, control returns to IPython's
@@ -345,6 +346,13 b' python-profiler package from non-free.""")'
         and sys.argv). This allows for very convenient loading of code for
         interactive work, while giving each program a 'clean sheet' to run in.
 
+        Arguments are expanded using shell-like glob match.  Patterns
+        '*', '?', '[seq]' and '[!seq]' can be used.  Additionally,
+        tilde '~' will be expanded into user's home directory.  Unlike
+        real shells, quotation does not suppress expansions.  Use
+        *two* back slashes (e.g., '\\\\*') to suppress expansions.
+        To completely disable these expansions, you can use -G flag.
+
         Options:
 
         -n: __name__ is NOT set to '__main__', but to the running file's name
@@ -439,10 +447,13 b' python-profiler package from non-free.""")'
 
         will run the example module.
 
+        -G: disable shell-like glob expansion of arguments.
+
         """
 
         # get arguments and set sys.argv for program to be run.
-        opts, arg_lst = self.parse_options(parameter_s, 'nidtN:b:pD:l:rs:T:em:',
+        opts, arg_lst = self.parse_options(parameter_s,
+                                           'nidtN:b:pD:l:rs:T:em:G',
                                            mode='list', list_all=1)
         if "m" in opts:
             modulename = opts["m"][0]
@@ -476,8 +487,11 b' python-profiler package from non-free.""")'
         # were run from a system shell.
         save_argv = sys.argv # save it for later restoring
 
-        # simulate shell expansion on arguments, at least tilde expansion
-        args = [ os.path.expanduser(a) for a in arg_lst[1:] ]
+        if 'G' in opts:
+            args = arg_lst[1:]
+        else:
+            # tilde and glob expansion
+            args = shellglob(map(os.path.expanduser,  arg_lst[1:]))
 
         sys.argv = [filename] + args  # put in the proper filename
         # protect sys.argv from potential unicode strings on Python 2:
@@ -549,11 +563,18 b' python-profiler package from non-free.""")'
                                 return
                         # if we find a good linenumber, set the breakpoint
                         deb.do_break('%s:%s' % (filename, bp))
+
+                        # Mimic Pdb._runscript(...)
+                        deb._wait_for_mainpyfile = True
+                        deb.mainpyfile = deb.canonic(filename)
+
                         # Start file run
                         print "NOTE: Enter 'c' at the",
                         print "%s prompt to start your script." % deb.prompt
                         ns = {'execfile': py3compat.execfile, 'prog_ns': prog_ns}
                         try:
+                            #save filename so it can be used by methods on the deb object
+                            deb._exec_filename = filename
                             deb.run('execfile("%s", prog_ns)' % filename, ns)
 
                         except:

IPython/core/magics/extension.py

@@ -59,14 +59,30 b' class ExtensionMagics(Magics):'
         """Load an IPython extension by its module name."""
         if not module_str:
             raise UsageError('Missing module name.')
-        return self.shell.extension_manager.load_extension(module_str)
+        res = self.shell.extension_manager.load_extension(module_str)
+        
+        if res == 'already loaded':
+            print "The %s extension is already loaded. To reload it, use:" % module_str
+            print "  %reload_ext", module_str
+        elif res == 'no load function':
+            print "The %s module is not an IPython extension." % module_str
 
     @line_magic
     def unload_ext(self, module_str):
-        """Unload an IPython extension by its module name."""
+        """Unload an IPython extension by its module name.
+        
+        Not all extensions can be unloaded, only those which define an
+        ``unload_ipython_extension`` function.
+        """
         if not module_str:
             raise UsageError('Missing module name.')
-        self.shell.extension_manager.unload_extension(module_str)
+        
+        res = self.shell.extension_manager.unload_extension(module_str)
+        
+        if res == 'no unload function':
+            print "The %s extension doesn't define how to unload it." % module_str
+        elif res == "not loaded":
+            print "The %s extension is not loaded." % module_str
 
     @line_magic
     def reload_ext(self, module_str):

IPython/core/magics/history.py

@@ -16,10 +16,13 b' from __future__ import print_function'
 # Stdlib
 import os
 from io import open as io_open
+from IPython.external.argparse import Action
 
 # Our own packages
 from IPython.core.error import StdinNotImplementedError
 from IPython.core.magic import Magics, magics_class, line_magic
+from IPython.core.magic_arguments import (argument, magic_arguments,
+                                          parse_argstring)
 from IPython.testing.skipdoctest import skip_doctest
 from IPython.utils import io
 
@@ -27,16 +30,71 b' from IPython.utils import io'
 # Magics class implementation
 #-----------------------------------------------------------------------------
 
+
+_unspecified = object()
+
+
 @magics_class
 class HistoryMagics(Magics):
 
+    @magic_arguments()
+    @argument(
+        '-n', dest='print_nums', action='store_true', default=False,
+        help="""
+        print line numbers for each input.
+        This feature is only available if numbered prompts are in use.
+        """)
+    @argument(
+        '-o', dest='get_output', action='store_true', default=False,
+        help="also print outputs for each input.")
+    @argument(
+        '-p', dest='pyprompts', action='store_true', default=False,
+        help="""
+        print classic '>>>' python prompts before each input.
+        This is useful for making documentation, and in conjunction
+        with -o, for producing doctest-ready output.
+        """)
+    @argument(
+        '-t', dest='raw', action='store_false', default=True,
+        help="""
+        print the 'translated' history, as IPython understands it.
+        IPython filters your input and converts it all into valid Python
+        source before executing it (things like magics or aliases are turned
+        into function calls, for example). With this option, you'll see the
+        native history instead of the user-entered version: '%%cd /' will be
+        seen as 'get_ipython().magic("%%cd /")' instead of '%%cd /'.
+        """)
+    @argument(
+        '-f', dest='filename',
+        help="""
+        FILENAME: instead of printing the output to the screen, redirect
+        it to the given file.  The file is always overwritten, though *when
+        it can*, IPython asks for confirmation first. In particular, running
+        the command 'history -f FILENAME' from the IPython Notebook
+        interface will replace FILENAME even if it already exists *without*
+        confirmation.
+        """)
+    @argument(
+        '-g', dest='pattern', nargs='*', default=None,
+        help="""
+        treat the arg as a glob pattern to search for in (full) history.
+        This includes the saved history (almost all commands ever written).
+        The pattern may contain '?' to match one unknown character and '*'
+        to match any number of unknown characters. Use '%%hist -g' to show
+        full saved history (may be very long).
+        """)
+    @argument(
+        '-l', dest='limit', type=int, nargs='?', default=_unspecified,
+        help="""
+        get the last n lines from all sessions. Specify n as a single
+        arg, or the default is the last 10 lines.
+        """)
+    @argument('range', nargs='*')
     @skip_doctest
     @line_magic
     def history(self, parameter_s = ''):
         """Print input history (_i<n> variables), with most recent last.
 
-        %history [-o -p -t -n] [-f filename] [range | -g pattern | -l number]
-
         By default, input history is printed without line numbers so it can be
         directly pasted into an editor. Use -n to show them.
 
@@ -52,43 +110,6 b' class HistoryMagics(Magics):'
 
         The same syntax is used by %macro, %save, %edit, %rerun
 
-        Options:
-
-          -n: print line numbers for each input.
-          This feature is only available if numbered prompts are in use.
-
-          -o: also print outputs for each input.
-
-          -p: print classic '>>>' python prompts before each input.  This is
-           useful for making documentation, and in conjunction with -o, for
-           producing doctest-ready output.
-
-          -r: (default) print the 'raw' history, i.e. the actual commands you
-           typed.
-
-          -t: print the 'translated' history, as IPython understands it.
-          IPython filters your input and converts it all into valid Python
-          source before executing it (things like magics or aliases are turned
-          into function calls, for example). With this option, you'll see the
-          native history instead of the user-entered version: '%cd /' will be
-          seen as 'get_ipython().magic("%cd /")' instead of '%cd /'.
-
-          -g: treat the arg as a pattern to grep for in (full) history.
-          This includes the saved history (almost all commands ever written).
-          The pattern may contain '?' to match one unknown character and '*'
-          to match any number of unknown characters. Use '%hist -g' to show
-          full saved history (may be very long).
-
-          -l: get the last n lines from all sessions. Specify n as a single
-          arg, or the default is the last 10 lines.
-
-          -f FILENAME: instead of printing the output to the screen, redirect
-           it to the given file.  The file is always overwritten, though *when
-           it can*, IPython asks for confirmation first. In particular, running
-           the command 'history -f FILENAME' from the IPython Notebook
-           interface will replace FILENAME even if it already exists *without*
-           confirmation.
-
         Examples
         --------
         ::
@@ -100,11 +121,7 b' class HistoryMagics(Magics):'
 
         """
 
-        if not self.shell.displayhook.do_full_cache:
-            print('This feature is only available if numbered prompts '
-                  'are in use.')
-            return
-        opts,args = self.parse_options(parameter_s,'noprtglf:',mode='string')
+        args = parse_argstring(self.history, parameter_s)
 
         # For brevity
         history_manager = self.shell.history_manager
@@ -116,9 +133,8 b' class HistoryMagics(Magics):'
             return "%s/%s" % (session, line)
 
         # Check if output to specific file was requested.
-        try:
-            outfname = opts['f']
-        except KeyError:
+        outfname = args.filename
+        if not outfname:
             outfile = io.stdout  # default
             # We don't want to close stdout at the end!
             close_at_end = False
@@ -135,27 +151,29 b' class HistoryMagics(Magics):'
             outfile = io_open(outfname, 'w', encoding='utf-8')
             close_at_end = True
 
-        print_nums = 'n' in opts
-        get_output = 'o' in opts
-        pyprompts = 'p' in opts
-        # Raw history is the default
-        raw = not('t' in opts)
+        print_nums = args.print_nums
+        get_output = args.get_output
+        pyprompts = args.pyprompts
+        raw = args.raw
 
         pattern = None
+        limit = None if args.limit is _unspecified else args.limit
 
-        if 'g' in opts:         # Glob search
-            pattern = "*" + args + "*" if args else "*"
-            hist = history_manager.search(pattern, raw=raw, output=get_output)
+        if args.pattern is not None:
+            if args.pattern:
+                pattern = "*" + " ".join(args.pattern) + "*"
+            else:
+                pattern = "*"
+            hist = history_manager.search(pattern, raw=raw, output=get_output,
+                                          n=limit)
             print_nums = True
-        elif 'l' in opts:       # Get 'tail'
-            try:
-                n = int(args)
-            except (ValueError, IndexError):
-                n = 10
+        elif args.limit is not _unspecified:
+            n = 10 if limit is None else limit
             hist = history_manager.get_tail(n, raw=raw, output=get_output)
         else:
-            if args:            # Get history by ranges
-                hist = history_manager.get_range_by_str(args, raw, get_output)
+            if args.range:      # Get history by ranges
+                hist = history_manager.get_range_by_str(" ".join(args.range),
+                                                        raw, get_output)
             else:               # Just get history for the current session
                 hist = history_manager.get_range(raw=raw, output=get_output)
 

IPython/core/magics/namespace.py

@@ -23,6 +23,7 b' from IPython.core.error import StdinNotImplementedError, UsageError'
 from IPython.core.magic import Magics, magics_class, line_magic
 from IPython.testing.skipdoctest import skip_doctest
 from IPython.utils.encoding import DEFAULT_ENCODING
+from IPython.utils.openpy import read_py_file
 from IPython.utils.path import get_py_filename
 
 #-----------------------------------------------------------------------------
@@ -68,7 +69,7 b' class NamespaceMagics(Magics):'
     @skip_doctest
     @line_magic
     def pdef(self, parameter_s='', namespaces=None):
-        """Print the definition header for any callable object.
+        """Print the call signature for any callable object.
 
         If the object is a class, print the constructor information.
 
@@ -97,7 +98,7 b' class NamespaceMagics(Magics):'
         self.shell._inspect('psource',parameter_s, namespaces)
 
     @line_magic
-    def pfile(self, parameter_s=''):
+    def pfile(self, parameter_s='', namespaces=None):
         """Print (or run through pager) the file where an object is defined.
 
         The file opens at the line where the object definition begins. IPython
@@ -110,7 +111,7 b' class NamespaceMagics(Magics):'
         viewer."""
 
         # first interpret argument as an object name
-        out = self.shell._inspect('pfile',parameter_s)
+        out = self.shell._inspect('pfile',parameter_s, namespaces)
         # if not, try the input as a filename
         if out == 'not found':
             try:
@@ -118,7 +119,7 b' class NamespaceMagics(Magics):'
             except IOError as msg:
                 print msg
                 return
-            page.page(self.shell.inspector.format(open(filename).read()))
+            page.page(self.shell.pycolorize(read_py_file(filename, skip_encoding_cookie=False)))
 
     @line_magic
     def psearch(self, parameter_s=''):

IPython/core/magics/osm.py

@@ -32,6 +32,7 b' from IPython.core.magic import ('
 )
 from IPython.testing.skipdoctest import skip_doctest
 from IPython.utils.io import file_read, nlprint
+from IPython.utils.openpy import source_to_unicode
 from IPython.utils.path import get_py_filename, unquote_filename
 from IPython.utils.process import abbrev_cwd
 from IPython.utils.terminal import set_term_title
@@ -686,12 +687,12 b' class OSMagics(Magics):'
                              'or macro.')
 
         try :
-            cont = self.shell.find_user_code(parameter_s)
+            cont = self.shell.find_user_code(parameter_s, skip_encoding_cookie=False)
         except (ValueError, IOError):
             print "Error: no such file, variable, URL, history range or macro"
             return
 
-        page.page(self.shell.pycolorize(cont))
+        page.page(self.shell.pycolorize(source_to_unicode(cont)))
 
     @magic_arguments.magic_arguments()
     @magic_arguments.argument(

IPython/core/magics/script.py

@@ -12,6 +12,7 b''
 #-----------------------------------------------------------------------------
 
 # Stdlib
+import errno
 import os
 import re
 import sys
@@ -30,7 +31,7 b' from IPython.core.magic import ('
 from IPython.lib.backgroundjobs import BackgroundJobManager
 from IPython.testing.skipdoctest import skip_doctest
 from IPython.utils import py3compat
-from IPython.utils.process import find_cmd, FindCmdError, arg_split
+from IPython.utils.process import arg_split
 from IPython.utils.traitlets import List, Dict
 
 #-----------------------------------------------------------------------------
@@ -90,36 +91,23 b' class ScriptMagics(Magics, Configurable):'
         """,
     )
     def _script_magics_default(self):
-        """default to a common list of programs if we find them"""
+        """default to a common list of programs"""
         
-        defaults = []
-        to_try = []
-        if os.name == 'nt':
-            defaults.append('cmd')
-            to_try.append('powershell')
-        to_try.extend([
+        defaults = [
             'sh',
             'bash',
             'perl',
             'ruby',
+            'python',
             'python3',
             'pypy',
-        ])
+        ]
+        if os.name == 'nt':
+            defaults.extend([
+                'cmd',
+                'powershell',
+            ])
         
-        for cmd in to_try:
-            if cmd in self.script_paths:
-                defaults.append(cmd)
-            else:
-                try:
-                    find_cmd(cmd)
-                except FindCmdError:
-                    # command not found, ignore it
-                    pass
-                except ImportError:
-                    # Windows without pywin32, find_cmd doesn't work
-                    pass
-                else:
-                    defaults.append(cmd)
         return defaults
     
     script_paths = Dict(config=True,
@@ -197,8 +185,15 b' class ScriptMagics(Magics, Configurable):'
         """
         argv = arg_split(line, posix = not sys.platform.startswith('win'))
         args, cmd = self.shebang.parser.parse_known_args(argv)
-
-        p = Popen(cmd, stdout=PIPE, stderr=PIPE, stdin=PIPE)
+        
+        try:
+            p = Popen(cmd, stdout=PIPE, stderr=PIPE, stdin=PIPE)
+        except OSError as e:
+            if e.errno == errno.ENOENT:
+                print "Couldn't find program: %r" % cmd[0]
+                return
+            else:
+                raise
         
         cell = cell.encode('utf8', 'replace')
         if args.bg:

IPython/core/oinspect.py

@@ -24,6 +24,8 b' import linecache'
 import os
 import sys
 import types
+import io as stdlib_io
+
 from collections import namedtuple
 try:
     from itertools import izip_longest
@@ -35,10 +37,12 b' from IPython.core import page'
 from IPython.testing.skipdoctest import skip_doctest_py3
 from IPython.utils import PyColorize
 from IPython.utils import io
+from IPython.utils import openpy
 from IPython.utils import py3compat
 from IPython.utils.text import indent
 from IPython.utils.wildcard import list_namespace
 from IPython.utils.coloransi import *
+from IPython.utils.py3compat import cast_unicode
 
 #****************************************************************************
 # Builtin color schemes
@@ -90,6 +94,29 b' def object_info(**kw):'
     return infodict
 
 
+def get_encoding(obj):
+    """Get encoding for python source file defining obj
+
+    Returns None if obj is not defined in a sourcefile.
+    """
+    ofile = find_file(obj)
+    # run contents of file through pager starting at line where the object
+    # is defined, as long as the file isn't binary and is actually on the
+    # filesystem.
+    if ofile is None:
+        return None
+    elif ofile.endswith(('.so', '.dll', '.pyd')):
+        return None
+    elif not os.path.isfile(ofile):
+        return None
+    else:
+        # Print only text files, not extension binaries.  Note that
+        # getsourcelines returns lineno with 1-offset and page() uses
+        # 0-offset, so we must adjust.
+        buffer = stdlib_io.open(ofile, 'rb')   # Tweaked to use io.open for Python 2
+        encoding, lines = openpy.detect_encoding(buffer.readline)
+        return encoding
+
 def getdoc(obj):
     """Stable wrapper around inspect.getdoc.
 
@@ -109,10 +136,13 b' def getdoc(obj):'
             return inspect.cleandoc(ds)
     
     try:
-        return inspect.getdoc(obj)
+        docstr = inspect.getdoc(obj)
+        encoding = get_encoding(obj)
+        return py3compat.cast_unicode(docstr, encoding=encoding)
     except Exception:
         # Harden against an inspect failure, which can occur with
         # SWIG-wrapped extensions.
+        raise
         return None
 
 
@@ -143,7 +173,8 b' def getsource(obj,is_binary=False):'
         except TypeError:
             if hasattr(obj,'__class__'):
                 src = inspect.getsource(obj.__class__)
-        return src
+        encoding = get_encoding(obj)
+        return cast_unicode(src, encoding=encoding)
 
 def getargspec(obj):
     """Get the names and default values of a function's arguments.
@@ -313,15 +344,14 b' class Inspector:'
         self.set_active_scheme(scheme)
 
     def _getdef(self,obj,oname=''):
-        """Return the definition header for any callable object.
+        """Return the call signature for any callable object.
 
         If any exception is generated, None is returned instead and the
         exception is suppressed."""
 
         try:
-            # We need a plain string here, NOT unicode!
             hdef = oname + inspect.formatargspec(*getargspec(obj))
-            return py3compat.unicode_to_str(hdef, 'ascii')
+            return cast_unicode(hdef)
         except:
             return None
 
@@ -343,7 +373,7 b' class Inspector:'
             print()
 
     def pdef(self, obj, oname=''):
-        """Print the definition header for any callable object.
+        """Print the call signature for any callable object.
 
         If the object is a class, print the constructor information."""
 
@@ -435,7 +465,7 b' class Inspector:'
         except:
             self.noinfo('source',oname)
         else:
-            page.page(self.format(py3compat.unicode_to_str(src)))
+            page.page(self.format(src))
 
     def pfile(self, obj, oname=''):
         """Show the whole file where an object was defined."""
@@ -457,7 +487,7 b' class Inspector:'
             # Print only text files, not extension binaries.  Note that
             # getsourcelines returns lineno with 1-offset and page() uses
             # 0-offset, so we must adjust.
-            page.page(self.format(open(ofile).read()), lineno-1)
+            page.page(self.format(openpy.read_py_file(ofile, skip_encoding_cookie=False)), lineno - 1)
 
     def _format_fields(self, fields, title_width=12):
         """Formats a list of fields for display.
@@ -476,7 +506,7 b' class Inspector:'
                 title = header(title + ":") + "\n"
             else:
                 title = header((title+":").ljust(title_width))
-            out.append(title + content)
+            out.append(cast_unicode(title) + cast_unicode(content))
         return "\n".join(out)
 
     # The fields to be displayed by pinfo: (fancy_name, key_in_info_dict)
@@ -536,7 +566,8 b' class Inspector:'
         # Source or docstring, depending on detail level and whether
         # source found.
         if detail_level > 0 and info['source'] is not None:
-            displayfields.append(("Source", self.format(py3compat.cast_bytes_py2(info['source']))))
+            displayfields.append(("Source", 
+                                  self.format(cast_unicode(info['source']))))
         elif info['docstring'] is not None:
             displayfields.append(("Docstring", info["docstring"]))
 

IPython/core/profiledir.py

@@ -110,10 +110,10 b' class ProfileDir(LoggingConfigurable):'
 
     def check_security_dir(self):
         if not os.path.isdir(self.security_dir):
-            os.mkdir(self.security_dir, 0700)
+            os.mkdir(self.security_dir, 0o700)
         else:
             try:
-                os.chmod(self.security_dir, 0700)
+                os.chmod(self.security_dir, 0o700)
             except OSError:
                 self.log.warn("Could not set security dir permissions to private.")
 
@@ -122,10 +122,10 b' class ProfileDir(LoggingConfigurable):'
 
     def check_pid_dir(self):
         if not os.path.isdir(self.pid_dir):
-            os.mkdir(self.pid_dir, 0700)
+            os.mkdir(self.pid_dir, 0o700)
         else:
             try:
-                os.chmod(self.pid_dir, 0700)
+                os.chmod(self.pid_dir, 0o700)
             except OSError:
                 self.log.warn("Could not set pid dir permissions to private.")
 

IPython/core/release.py

@@ -21,7 +21,7 b" name = 'ipython'"
 # version
 _version_major = 0
 _version_minor = 14
-_version_micro = ''  # use '' for first of series, number for 1 and above
+_version_micro = 0  # use 0 for first of series, number for 1 and above
 _version_extra = 'dev'
 #_version_extra = 'rc1'
 # _version_extra = ''  # Uncomment this for full releases
@@ -36,6 +36,7 b' if _version_extra:'
 __version__ = '.'.join(map(str, _ver))
 
 version = __version__  # backwards compatibility name
+version_info = (_version_major, _version_minor, _version_micro, _version_extra)
 
 description = "IPython: Productive Interactive Computing"
 

IPython/core/shellapp.py

@@ -277,12 +277,20 b' class InteractiveShellApp(Configurable):'
             sys.argv = [ py3compat.cast_bytes(a) for a in sys.argv ]
         try:
             if os.path.isfile(full_filename):
-                self.log.info("Running file in user namespace: %s" % full_filename)
                 if full_filename.endswith('.ipy'):
+                    self.log.info("Running file in user namespace: %s" %
+                                  full_filename)
                     self.shell.safe_execfile_ipy(full_filename)
                 else:
                     # default to python, even without extension
-                    self.shell.safe_execfile(full_filename, self.shell.user_ns)
+                    self.log.info("Running file in user namespace: %s" %
+                                  full_filename)
+                    # Ensure that __file__ is always defined to match Python behavior
+                    self.shell.user_ns['__file__'] = fname
+                    try:
+                        self.shell.safe_execfile(full_filename, self.shell.user_ns)
+                    finally:
+                        del self.shell.user_ns['__file__']
         finally:
             sys.argv = save_argv
 

IPython/core/tests/test_history.py

@@ -87,6 +87,18 b' def test_history():'
             # Check get_hist_search
             gothist = ip.history_manager.search("*test*")
             nt.assert_equal(list(gothist), [(1,2,hist[1])] )
+            gothist = ip.history_manager.search("*=*")
+            nt.assert_equal(list(gothist),
+                            [(1, 1, hist[0]),
+                             (1, 2, hist[1]),
+                             (1, 3, hist[2]),
+                             (2, 1, newcmds[0]),
+                             (2, 3, newcmds[2])])
+            gothist = ip.history_manager.search("*=*", n=3)
+            nt.assert_equal(list(gothist),
+                            [(1, 3, hist[2]),
+                             (2, 1, newcmds[0]),
+                             (2, 3, newcmds[2])])
             gothist = ip.history_manager.search("b*", output=True)
             nt.assert_equal(list(gothist), [(1,3,(hist[2],"spam"))] )
 

IPython/core/tests/test_run.py

@@ -86,6 +86,56 b' def doctest_run_builtins():'
        ....:
     """
 
+
+def doctest_run_option_parser():
+    r"""Test option parser in %run.
+
+    In [1]: %run print_argv.py
+    []
+
+    In [2]: %run print_argv.py print*.py
+    ['print_argv.py']
+
+    In [3]: %run -G print_argv.py print*.py
+    ['print*.py']
+
+    """
+
+
[e-mail]_win32
+def doctest_run_option_parser_for_posix():
+    r"""Test option parser in %run (Linux/OSX specific).
+
+    You need double quote to escape glob in POSIX systems:
+
+    In [1]: %run print_argv.py print\\*.py
+    ['print*.py']
+
+    You can't use quote to escape glob in POSIX systems:
+
+    In [2]: %run print_argv.py 'print*.py'
+    ['print_argv.py']
+
+    """
+
+
[e-mail]_if_not_win32
+def doctest_run_option_parser_for_windows():
+    r"""Test option parser in %run (Windows specific).
+
+    In Windows, you can't escape ``*` `by backslash:
+
+    In [1]: %run print_argv.py print\\*.py
+    ['print\\*.py']
+
+    You can use quote to escape glob:
+
+    In [2]: %run print_argv.py 'print*.py'
+    ['print*.py']
+
+    """
+
+
 @py3compat.doctest_refactor_print
 def doctest_reset_del():
     """Test that resetting doesn't cause errors in __del__ methods.

IPython/core/tests/test_ultratb.py

@@ -1,6 +1,7 b''
+# encoding: utf-8
 """Tests for IPython.core.ultratb
 """
-
+import io
 import os.path
 import unittest
 
@@ -49,3 +50,52 b' class ChangedPyFileTest(unittest.TestCase):'
                     ip.run_cell("foo.f()")
                 with tt.AssertPrints("ZeroDivisionError"):
                     ip.run_cell("foo.f()")
+
+iso_8859_5_file = u'''# coding: iso-8859-5
+
+def fail():
+    """дбИЖ"""
+    1/0     # дбИЖ
+'''
+
+class NonAsciiTest(unittest.TestCase):
+    def test_iso8859_5(self):
+        # Non-ascii directory name as well.
+        with TemporaryDirectory(suffix=u'é') as td:
+            fname = os.path.join(td, 'dfghjkl.py')
+
+            with io.open(fname, 'w', encoding='iso-8859-5') as f:
+                f.write(iso_8859_5_file)
+            
+            with prepended_to_syspath(td):
+                ip.run_cell("from dfghjkl import fail")
+            
+            with tt.AssertPrints("ZeroDivisionError"):
+                with tt.AssertPrints(u'дбИЖ', suppress=False):
+                    ip.run_cell('fail()')
+
+indentationerror_file = """if True:
+zoon()
+"""
+
+class IndentationErrorTest(unittest.TestCase):
+    def test_indentationerror_shows_line(self):
+        # See issue gh-2398
+        with tt.AssertPrints("IndentationError"):
+            with tt.AssertPrints("zoon()", suppress=False):
+                ip.run_cell(indentationerror_file)
+        
+        with TemporaryDirectory() as td:
+            fname = os.path.join(td, "foo.py")
+            with open(fname, "w") as f:
+                f.write(indentationerror_file)
+            
+            with tt.AssertPrints("IndentationError"):
+                with tt.AssertPrints("zoon()", suppress=False):
+                    ip.magic('run %s' % fname)
+
+class SyntaxErrorTest(unittest.TestCase):
+    def test_syntaxerror_without_lineno(self):
+        with tt.AssertNotPrints("TypeError"):
+            with tt.AssertPrints("line unknown"):
+                ip.run_cell("raise SyntaxError()")

IPython/core/ultratb.py

@@ -69,7 +69,7 b' possible inclusion in future releases.'
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from __future__ import with_statement
+from __future__ import unicode_literals
 
 import inspect
 import keyword
@@ -99,9 +99,12 b' from IPython.core.display_trap import DisplayTrap'
 from IPython.core.excolors import exception_colors
 from IPython.utils import PyColorize
 from IPython.utils import io
+from IPython.utils import path as util_path
 from IPython.utils import py3compat
 from IPython.utils import pyfile
+from IPython.utils import ulinecache
 from IPython.utils.data import uniq_stable
+from IPython.utils.openpy import read_py_file
 from IPython.utils.warn import info, error
 
 # Globals
@@ -229,7 +232,6 b' def fix_frame_records_filenames(records):'
 
 
 def _fixed_getinnerframes(etb, context=1,tb_offset=0):
-    import linecache
     LNUM_POS, LINES_POS, INDEX_POS =  2, 4, 5
 
     records  = fix_frame_records_filenames(inspect.getinnerframes(etb, context))
@@ -251,7 +253,7 b' def _fixed_getinnerframes(etb, context=1,tb_offset=0):'
         maybeStart = lnum-1 - context//2
         start =  max(maybeStart, 0)
         end   = start + context
-        lines = linecache.getlines(file)[start:end]
+        lines = ulinecache.getlines(file)[start:end]
         buf = list(records[i])
         buf[LNUM_POS] = lnum
         buf[INDEX_POS] = lnum - 1 - start
@@ -282,12 +284,7 b' def _format_traceback_lines(lnum, index, lines, Colors, lvals=None,scheme=None):'
     _line_format = _parser.format2
 
     for line in lines:
-        # FIXME: we need to ensure the source is a pure string at this point,
-        # else the coloring code makes a  royal mess.  This is in need of a
-        # serious refactoring, so that all of the ultratb and PyColorize code
-        # is unicode-safe.  So for now this is rather an ugly hack, but
-        # necessary to at least have readable tracebacks. Improvements welcome!
-        line = py3compat.cast_bytes_py2(line, 'utf-8')
+        line = py3compat.cast_unicode(line)
 
         new_line, err = _line_format(line, 'str', scheme)
         if not err: line = new_line
@@ -547,33 +544,41 b' class ListTB(TBTools):'
 
         Also lifted nearly verbatim from traceback.py
         """
-
         have_filedata = False
         Colors = self.Colors
         list = []
         stype = Colors.excName + etype.__name__ + Colors.Normal
         if value is None:
             # Not sure if this can still happen in Python 2.6 and above
-            list.append( str(stype) + '\n')
+            list.append( py3compat.cast_unicode(stype) + '\n')
         else:
-            if etype is SyntaxError:
+            if issubclass(etype, SyntaxError):
                 have_filedata = True
                 #print 'filename is',filename  # dbg
                 if not value.filename: value.filename = "<string>"
-                list.append('%s  File %s"%s"%s, line %s%d%s\n' % \
+                if value.lineno:
+                    lineno = value.lineno
+                    textline = ulinecache.getline(value.filename, value.lineno)
+                else:
+                    lineno = 'unknown'
+                    textline = ''
+                list.append('%s  File %s"%s"%s, line %s%s%s\n' % \
                         (Colors.normalEm,
-                         Colors.filenameEm, value.filename, Colors.normalEm,
-                         Colors.linenoEm, value.lineno, Colors.Normal  ))
-                if value.text is not None:
+                         Colors.filenameEm, py3compat.cast_unicode(value.filename), Colors.normalEm,
+                         Colors.linenoEm, lineno, Colors.Normal  ))
+                if textline == '':
+                    textline = py3compat.cast_unicode(value.text, "utf-8")
+
+                if textline is not None:
                     i = 0
-                    while i < len(value.text) and value.text[i].isspace():
+                    while i < len(textline) and textline[i].isspace():
                         i += 1
                     list.append('%s    %s%s\n' % (Colors.line,
-                                                  value.text.strip(),
+                                                  textline.strip(),
                                                   Colors.Normal))
                     if value.offset is not None:
                         s = '    '
-                        for c in value.text[i:value.offset-1]:
+                        for c in textline[i:value.offset-1]:
                             if c.isspace():
                                 s += c
                             else:
@@ -779,10 +784,9 b' class VerboseTB(TBTools):'
         abspath = os.path.abspath
         for frame, file, lnum, func, lines, index in records:
             #print '*** record:',file,lnum,func,lines,index  # dbg
-
             if not file:
                 file = '?'
-            elif not(file.startswith("<") and file.endswith(">")):
+            elif not(file.startswith(str("<")) and file.endswith(str(">"))):
                 # Guess that filenames like <string> aren't real filenames, so
                 # don't call abspath on them.                    
                 try:
@@ -791,7 +795,7 b' class VerboseTB(TBTools):'
                     # Not sure if this can still happen: abspath now works with
                     # file names like <string>
                     pass
-
+            file = py3compat.cast_unicode(file, util_path.fs_encoding)
             link = tpl_link % file
             args, varargs, varkw, locals = inspect.getargvalues(frame)
 
@@ -831,7 +835,7 b' class VerboseTB(TBTools):'
                 # Look up the corresponding source file.
                 file = pyfile.source_from_cache(file)
 
-            def linereader(file=file, lnum=[lnum], getline=linecache.getline):
+            def linereader(file=file, lnum=[lnum], getline=ulinecache.getline):
                 line = getline(file, lnum[0])
                 lnum[0] += 1
                 return line
@@ -926,7 +930,7 b' class VerboseTB(TBTools):'
             etype_str,evalue_str = map(str,(etype,evalue))
         # ... and format it
         exception = ['%s%s%s: %s' % (Colors.excName, etype_str,
-                                     ColorsNormal, evalue_str)]
+                                     ColorsNormal, py3compat.cast_unicode(evalue_str))]
         if (not py3compat.PY3) and type(evalue) is types.InstanceType:
             try:
                 names = [w for w in dir(evalue) if isinstance(w, basestring)]
@@ -938,7 +942,7 b' class VerboseTB(TBTools):'
                 exception.append(_m % (Colors.excName,ColorsNormal))
                 etype_str,evalue_str = map(str,sys.exc_info()[:2])
                 exception.append('%s%s%s: %s' % (Colors.excName,etype_str,
-                                     ColorsNormal, evalue_str))
+                                     ColorsNormal, py3compat.cast_unicode(evalue_str)))
                 names = []
             for name in names:
                 value = text_repr(getattr(evalue, name))

IPython/extensions/autoreload.py

@@ -106,13 +106,10 b' skip_doctest = True'
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
-import atexit
+
 import imp
-import inspect
 import os
 import sys
-import threading
-import time
 import traceback
 import types
 import weakref
@@ -409,7 +406,6 b' def superreload(module, reload=reload, old_objects={}):'
 
 from IPython.core.hooks import TryNext
 from IPython.core.magic import Magics, magics_class, line_magic
-from IPython.core.plugin import Plugin
 
 @magics_class
 class AutoreloadMagics(Magics):
@@ -518,21 +514,8 b' class AutoreloadMagics(Magics):'
             pass
 
 
-class AutoreloadPlugin(Plugin):
-    def __init__(self, shell=None, config=None):
-        super(AutoreloadPlugin, self).__init__(shell=shell, config=config)
-        self.auto_magics = AutoreloadMagics(shell)
-        shell.register_magics(self.auto_magics)
-        shell.set_hook('pre_run_code_hook', self.auto_magics.pre_run_code_hook)
-
-
-_loaded = False
-
-
 def load_ipython_extension(ip):
     """Load the extension in IPython."""
-    global _loaded
-    if not _loaded:
-        plugin = AutoreloadPlugin(shell=ip, config=ip.config)
-        ip.plugin_manager.register_plugin('autoreload', plugin)
-        _loaded = True
+    auto_reload = AutoreloadMagics(ip)
+    ip.register_magics(auto_reload)
+    ip.set_hook('pre_run_code_hook', auto_reload.pre_run_code_hook)

IPython/extensions/cythonmagic.py

@@ -125,6 +125,11 b' class CythonMagics(Magics):'
              "multiple times)."
     )
     @magic_arguments.argument(
+        '-L', dest='library_dirs', metavar='dir', action='append', default=[],
+        help="Add a path to the list of libary directories (can be specified "
+             "multiple times)."
+    )
+    @magic_arguments.argument(
         '-I', '--include', action='append', default=[],
         help="Add a path to the list of include directories (can be specified "
              "multiple times)."
@@ -195,6 +200,7 b' class CythonMagics(Magics):'
                 name = module_name,
                 sources = [pyx_file],
                 include_dirs = c_include_dirs,
+                library_dirs = args.library_dirs,
                 extra_compile_args = args.compile_args,
                 extra_link_args = args.link_args,
                 libraries = args.lib,
@@ -267,11 +273,7 b' class CythonMagics(Magics):'
         html = '\n'.join(l for l in html.splitlines() if not r.match(l))
         return html
 
-_loaded = False
 
 def load_ipython_extension(ip):
     """Load the extension in IPython."""
-    global _loaded
-    if not _loaded:
-        ip.register_magics(CythonMagics)
-        _loaded = True
+    ip.register_magics(CythonMagics)

IPython/extensions/octavemagic.py

@@ -362,10 +362,6 b' __doc__ = __doc__.format('
     )
 
 
-_loaded = False
 def load_ipython_extension(ip):
     """Load the extension in IPython."""
-    global _loaded
-    if not _loaded:
-        ip.register_magics(OctaveMagics)
-        _loaded = True
+    ip.register_magics(OctaveMagics)

IPython/extensions/rmagic.py

@@ -588,10 +588,6 b' __doc__ = __doc__.format('
 )
 
 
-_loaded = False
 def load_ipython_extension(ip):
     """Load the extension in IPython."""
-    global _loaded
-    if not _loaded:
-        ip.register_magics(RMagics)
-        _loaded = True
+    ip.register_magics(RMagics)

IPython/extensions/storemagic.py

@@ -28,9 +28,7 b' import inspect, os, sys, textwrap'
 from IPython.core.error import UsageError
 from IPython.core.fakemodule import FakeModule
 from IPython.core.magic import Magics, magics_class, line_magic
-from IPython.core.plugin import Plugin
 from IPython.testing.skipdoctest import skip_doctest
-from IPython.utils.traitlets import Bool, Instance
 
 #-----------------------------------------------------------------------------
 # Functions and classes
@@ -211,24 +209,6 b' class StoreMagics(Magics):'
                 print "Stored '%s' (%s)" % (args[0], obj.__class__.__name__)
 
 
-class StoreMagic(Plugin):
-    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
-    autorestore = Bool(False, config=True)
-    
-    def __init__(self, shell, config):
-        super(StoreMagic, self).__init__(shell=shell, config=config)
-        shell.register_magics(StoreMagics)
-        
-        if self.autorestore:
-            restore_data(shell)
-
-
-_loaded = False
-
 def load_ipython_extension(ip):
     """Load the extension in IPython."""
-    global _loaded
-    if not _loaded:
-        plugin = StoreMagic(shell=ip, config=ip.config)
-        ip.plugin_manager.register_plugin('storemagic', plugin)
-        _loaded = True
+    ip.register_magics(StoreMagics)

IPython/extensions/sympyprinting.py

@@ -9,6 +9,11 b' Usage'
 Once the extension is loaded, Sympy Basic objects are automatically
 pretty-printed.
 
+As of SymPy 0.7.2, maintenance of this extension has moved to SymPy under
+sympy.interactive.ipythonprinting, any modifications to account for changes to
+SymPy should be submitted to SymPy rather than changed here. This module is
+maintained here for backwards compatablitiy with old SymPy versions.
+
 """
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
@@ -30,6 +35,8 b' try:'
 except ImportError:
     pass
 
+import warnings
+
 #-----------------------------------------------------------------------------
 # Definitions of special display functions for use with IPython
 #-----------------------------------------------------------------------------
@@ -101,6 +108,19 b' _loaded = False'
 def load_ipython_extension(ip):
     """Load the extension in IPython."""
     import sympy
+
+    # sympyprinting extension has been moved to SymPy as of 0.7.2, if it
+    # exists there, warn the user and import it
+    try:
+        import sympy.interactive.ipythonprinting
+    except ImportError:
+        pass
+    else:
+        warnings.warn("The sympyprinting extension in IPython is deprecated, "
+            "use sympy.interactive.ipythonprinting")
+        ip.extension_manager.load_extension('sympy.interactive.ipythonprinting')
+        return
+
     global _loaded
     if not _loaded:
         plaintext_formatter = ip.display_formatter.formatters['text/plain']

IPython/extensions/tests/test_autoreload.py

@@ -23,7 +23,7 b' from StringIO import StringIO'
 import nose.tools as nt
 import IPython.testing.tools as tt
 
-from IPython.extensions.autoreload import AutoreloadPlugin
+from IPython.extensions.autoreload import AutoreloadMagics
 from IPython.core.hooks import TryNext
 
 #-----------------------------------------------------------------------------
@@ -35,13 +35,13 b' noop = lambda *a, **kw: None'
 class FakeShell(object):
     def __init__(self):
         self.ns = {}
-        self.reloader = AutoreloadPlugin(shell=self)
+        self.auto_magics = AutoreloadMagics(shell=self)
 
     register_magics = set_hook = noop
 
     def run_code(self, code):
         try:
-            self.reloader.auto_magics.pre_run_code_hook(self)
+            self.auto_magics.pre_run_code_hook(self)
         except TryNext:
             pass
         exec code in self.ns
@@ -50,10 +50,10 b' class FakeShell(object):'
         self.ns.update(items)
 
     def magic_autoreload(self, parameter):
-        self.reloader.auto_magics.autoreload(parameter)
+        self.auto_magics.autoreload(parameter)
 
     def magic_aimport(self, parameter, stream=None):
-        self.reloader.auto_magics.aimport(parameter, stream=stream)
+        self.auto_magics.aimport(parameter, stream=stream)
 
 
 class Fixture(object):
@@ -72,7 +72,6 b' class Fixture(object):'
     def tearDown(self):
         shutil.rmtree(self.test_dir)
         sys.path = self.old_sys_path
-        self.shell.reloader.enabled = False
 
         self.test_dir = None
         self.old_sys_path = None

IPython/external/path/_path.py

@@ -860,10 +860,10 b' class path(unicode):'
 
     # --- Create/delete operations on directories
 
-    def mkdir(self, mode=0777):
+    def mkdir(self, mode=0o777):
         os.mkdir(self, mode)
 
-    def makedirs(self, mode=0777):
+    def makedirs(self, mode=0o777):
         os.makedirs(self, mode)
 
     def rmdir(self):
@@ -879,7 +879,7 b' class path(unicode):'
         """ Set the access/modified times of this file to the current time.
         Create the file if it does not exist.
         """
-        fd = os.open(self, os.O_WRONLY | os.O_CREAT, 0666)
+        fd = os.open(self, os.O_WRONLY | os.O_CREAT, 0o666)
         os.close(fd)
         os.utime(self, None)
 

IPython/external/ssh/tunnel.py

@@ -22,6 +22,7 b' Authors'
 from __future__ import print_function
 
 import os,sys, atexit
+import signal
 import socket
 from multiprocessing import Process
 from getpass import getpass, getuser
@@ -331,9 +332,10 b' def _paramiko_tunnel(lport, rport, server, remoteip, keyfile=None, password=None'
     except Exception as e:
         print ('*** Failed to connect to %s:%d: %r' % (server, port, e))
         sys.exit(1)
-
-    # print ('Now forwarding port %d to %s:%d ...' % (lport, server, rport))
-
+    
+    # Don't let SIGINT kill the tunnel subprocess
+    signal.signal(signal.SIGINT, signal.SIG_IGN)
+    
     try:
         forward_tunnel(lport, remoteip, rport, client.get_transport())
     except KeyboardInterrupt:

IPython/frontend/consoleapp.py

@@ -24,6 +24,7 b' Authors:'
 import atexit
 import json
 import os
+import shutil
 import signal
 import sys
 import uuid
@@ -38,7 +39,7 b' from IPython.zmq.blockingkernelmanager import BlockingKernelManager'
 from IPython.utils.path import filefind
 from IPython.utils.py3compat import str_to_bytes
 from IPython.utils.traitlets import (
-    Dict, List, Unicode, CUnicode, Int, CBool, Any
+    Dict, List, Unicode, CUnicode, Int, CBool, Any, CaselessStrEnum
 )
 from IPython.zmq.ipkernel import (
     flags as ipkernel_flags,
@@ -151,12 +152,27 b' class IPythonConsoleApp(Configurable):'
     # create requested profiles by default, if they don't exist:
     auto_create = CBool(True)
     # connection info:
-    ip = Unicode(LOCALHOST, config=True,
+    
+    transport = CaselessStrEnum(['tcp', 'ipc'], default_value='tcp', config=True)
+    
+    ip = Unicode(config=True,
         help="""Set the kernel\'s IP address [default localhost].
         If the IP address is something other than localhost, then
         Consoles on other machines will be able to connect
         to the Kernel, so be careful!"""
     )
+    def _ip_default(self):
+        if self.transport == 'tcp':
+            return LOCALHOST
+        else:
+            # this can fire early if ip is given,
+            # in which case our return value is meaningless
+            if not hasattr(self, 'profile_dir'):
+                return ''
+            ipcdir = os.path.join(self.profile_dir.security_dir, 'kernel-%s' % os.getpid())
+            os.makedirs(ipcdir)
+            atexit.register(lambda : shutil.rmtree(ipcdir))
+            return os.path.join(ipcdir, 'ipc')
     
     sshserver = Unicode('', config=True,
         help="""The SSH server to use to connect to the kernel.""")
@@ -256,10 +272,10 b' class IPythonConsoleApp(Configurable):'
             return
         self.log.debug(u"Loading connection file %s", fname)
         with open(fname) as f:
-            s = f.read()
-        cfg = json.loads(s)
-        if self.ip == LOCALHOST and 'ip' in cfg:
-            # not overridden by config or cl_args
+            cfg = json.load(f)
+        
+        self.transport = cfg.get('transport', 'tcp')
+        if 'ip' in cfg:
             self.ip = cfg['ip']
         for channel in ('hb', 'shell', 'iopub', 'stdin'):
             name = channel + '_port'
@@ -268,12 +284,17 b' class IPythonConsoleApp(Configurable):'
                 setattr(self, name, cfg[name])
         if 'key' in cfg:
             self.config.Session.key = str_to_bytes(cfg['key'])
+        
     
     def init_ssh(self):
         """set up ssh tunnels, if needed."""
         if not self.sshserver and not self.sshkey:
             return
         
+        if self.transport != 'tcp':
+            self.log.error("Can only use ssh tunnels with TCP sockets, not %s", self.transport)
+            return
+        
         if self.sshkey and not self.sshserver:
             # specifying just the key implies that we are connecting directly
             self.sshserver = self.ip
@@ -326,6 +347,7 b' class IPythonConsoleApp(Configurable):'
 
         # Create a KernelManager and start a kernel.
         self.kernel_manager = self.kernel_manager_class(
+                                transport=self.transport,
                                 ip=self.ip,
                                 shell_port=self.shell_port,
                                 iopub_port=self.iopub_port,

IPython/frontend/html/notebook/handlers.py

@@ -149,13 +149,13 b' class AuthenticatedHandler(RequestHandler):'
     """A RequestHandler with an authenticated user."""
 
     def get_current_user(self):
-        user_id = self.get_secure_cookie("username")
+        user_id = self.get_secure_cookie(self.settings['cookie_name'])
         # For now the user_id should not return empty, but it could eventually
         if user_id == '':
             user_id = 'anonymous'
         if user_id is None:
             # prevent extra Invalid cookie sig warnings:
-            self.clear_cookie('username')
+            self.clear_cookie(self.settings['cookie_name'])
             if not self.application.password and not self.application.read_only:
                 user_id = 'anonymous'
         return user_id
@@ -247,7 +247,7 b' class LoginHandler(AuthenticatedHandler):'
         pwd = self.get_argument('password', default=u'')
         if self.application.password:
             if passwd_check(self.application.password, pwd):
-                self.set_secure_cookie('username', str(uuid.uuid4()))
+                self.set_secure_cookie(self.settings['cookie_name'], str(uuid.uuid4()))
             else:
                 self._render(message={'error': 'Invalid password'})
                 return
@@ -258,7 +258,7 b' class LoginHandler(AuthenticatedHandler):'
 class LogoutHandler(AuthenticatedHandler):
 
     def get(self):
-        self.clear_cookie('username')
+        self.clear_cookie(self.settings['cookie_name'])
         if self.login_available:
             message = {'info': 'Successfully logged out.'}
         else:
@@ -435,7 +435,7 b' class AuthenticatedZMQStreamHandler(ZMQStreamHandler):'
         self.on_message = self.on_first_message
 
     def get_current_user(self):
-        user_id = self.get_secure_cookie("username")
+        user_id = self.get_secure_cookie(self.settings['cookie_name'])
         if user_id == '' or (user_id is None and not self.application.password):
             user_id = 'anonymous'
         return user_id

IPython/frontend/html/notebook/nbmanager.py

@@ -42,6 +42,11 b' class NotebookManager(LoggingConfigurable):'
     """)
     def _notebook_dir_changed(self, name, old, new):
         """do a bit of validation of the notebook dir"""
+        if not os.path.isabs(new):
+            # If we receive a non-absolute path, make it absolute.
+            abs_new = os.path.abspath(new)
+            self.notebook_dir = abs_new
+            return
         if os.path.exists(new) and not os.path.isdir(new):
             raise TraitError("notebook dir %r is not a directory" % new)
         if not os.path.exists(new):
@@ -117,7 +122,7 b' class NotebookManager(LoggingConfigurable):'
             # should match the Python in-memory format.
             kwargs['split_lines'] = False
         data = current.writes(nb, format, **kwargs)
-        name = nb.get('name','notebook')
+        name = nb.metadata.get('name','notebook')
         return last_modified, name, data
 
     def read_notebook_object(self, notebook_id):

IPython/frontend/html/notebook/notebookapp.py

@@ -28,6 +28,7 b' import socket'
 import sys
 import threading
 import time
+import uuid
 import webbrowser
 
 # Third party
@@ -164,6 +165,7 b' class NotebookWebApplication(web.Application):'
             static_handler_class = FileFindHandler,
             cookie_secret=os.urandom(1024),
             login_url="%s/login"%(base_project_url.rstrip('/')),
+            cookie_name='username-%s' % uuid.uuid4(),
         )
 
         # allow custom overrides for the tornado web app.
@@ -468,11 +470,14 b' class NotebookApp(BaseIPythonApplication):'
             ssl_options = None
         self.web_app.password = self.password
         self.http_server = httpserver.HTTPServer(self.web_app, ssl_options=ssl_options)
-        if ssl_options is None and not self.ip and not (self.read_only and not self.password):
-            self.log.critical('WARNING: the notebook server is listening on all IP addresses '
-                              'but not using any encryption or authentication. This is highly '
-                              'insecure and not recommended.')
-
+        if not self.ip:
+            warning = "WARNING: The notebook server is listening on all IP addresses"
+            if ssl_options is None:
+                self.log.critical(warning + " and not using encryption. This"
+                    "is not recommended.")
+            if not self.password and not self.read_only:
+                self.log.critical(warning + "and not using authentication."
+                    "This is highly insecure and not recommended.")
         success = None
         for port in random_ports(self.port, self.port_retries+1):
             try:

IPython/frontend/html/notebook/static/css/notebook.css

@@ -70,7 +70,7 b' span#notebook_name {'
     z-index: 10;
 }
 
-#toolbar {
+.toolbar {
     padding: 3px 15px;
 }
 
@@ -122,6 +122,10 b' div#pager_splitter {'
     height: 8px;
 }
 
+#pager_container {
+    position : relative;
+}
+
 div#pager {
     padding: 15px;
     overflow: auto;
@@ -234,7 +238,7 b' div.output_area {'
 /* This class is for the output subarea inside the output_area and after
    the prompt div. */
 div.output_subarea {
-    padding: 0.4em 0.4em 0.4em 0.4em;
+    padding: 0.44em 0.4em 0.4em 1px;
 }
 
 /* The rest of the output_* classes are for special styling of the different

IPython/frontend/html/notebook/static/css/page.css

@@ -33,7 +33,7 b' span#ipython_notebook {'
     padding: 2px 2px 2px 5px;
 }
 
-span#ipython_notebook h1 img {
+span#ipython_notebook img {
     font-family: Verdana, "Helvetica Neue", Arial, Helvetica, Geneva, sans-serif;
     height: 24px;
     text-decoration:none;

IPython/frontend/html/notebook/static/css/tooltip.css

@@ -44,7 +44,7 b''
     opacity: 1;
   }
 }
-.tooltip a {
+.ipython_tooltip a {
   float: right;
 }
 /*properties of tooltip after "expand"*/
@@ -81,7 +81,7 b''
 
   padding-right: 30px;
 }
-.tooltip {
+.ipython_tooltip {
   max-width: 700px;
   border-radius: 4px;
   -moz-box-shadow: 0px 6px 10px -1px #adadad;

IPython/frontend/html/notebook/static/js/cell.js

@@ -20,6 +20,8 b' var IPython = (function (IPython) {'
         this.selected = false;
         this.element = null;
         this.metadata = {};
+        // load this from metadata later ?
+        this.user_highlight == 'auto';
         this.create_element();
         if (this.element !== null) {
             this.element.data("cell", this);
@@ -48,15 +50,13 b' var IPython = (function (IPython) {'
         });
     };
 
-
-    // typeset with MathJax if MathJax is available
     Cell.prototype.typeset = function () {
         if (window.MathJax){
-            MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
+            var cell_math = this.element.get(0);
+            MathJax.Hub.Queue(["Typeset",MathJax.Hub,cell_math]);
         }
     };
 
-
     Cell.prototype.select = function () {
         this.element.addClass('ui-widget-content ui-corner-all');
         this.selected = true;
@@ -154,6 +154,61 b' var IPython = (function (IPython) {'
         this.code_mirror.refresh();
     };
 
+    Cell.prototype.force_highlight = function(mode) {
+        this.user_highlight = mode;
+        this.auto_highlight();
+    };
+
+    Cell.prototype._auto_highlight = function (modes) {
+        //Here we handle manually selected modes
+        if( this.user_highlight != undefined &&  this.user_highlight != 'auto' )
+        {
+            var mode = this.user_highlight;
+            CodeMirror.autoLoadMode(this.code_mirror, mode);
+            this.code_mirror.setOption('mode', mode);
+            return;
+        }
+        var first_line = this.code_mirror.getLine(0);
+        // loop on every pairs
+        for( var mode in modes) {
+            var regs = modes[mode]['reg'];
+            // only one key every time but regexp can't be keys...
+            for(var reg in regs ) {
+                // here we handle non magic_modes
+                if(first_line.match(regs[reg]) != null) {
+                    if (mode.search('magic_') != 0) {
+                        this.code_mirror.setOption('mode',mode);
+                        CodeMirror.autoLoadMode(this.code_mirror, mode);
+                        return;
+                    }
+                    var open = modes[mode]['open']|| "%%";
+                    var close = modes[mode]['close']|| "%%end";
+                    var mmode = mode;
+                    mode = mmode.substr(6);
+                    CodeMirror.autoLoadMode(this.code_mirror, mode);
+                    // create on the fly a mode that swhitch between
+                    // plain/text and smth else otherwise `%%` is
+                    // source of some highlight issues.
+                    // we use patchedGetMode to circumvent a bug in CM
+                    CodeMirror.defineMode(mmode , function(config) {
+                        return CodeMirror.multiplexingMode(
+                        CodeMirror.patchedGetMode(config, 'text/plain'),
+                            // always set someting on close
+                            {open: open, close: close,
+                             mode: CodeMirror.patchedGetMode(config, mode),
+                             delimStyle: "delimit"
+                            }
+                        );
+                    });
+                    this.code_mirror.setOption('mode', mmode);
+                    return;
+                }
+            }
+        }
+        // fallback on default (python)
+        var default_mode = this.default_mode || 'text/plain';
+        this.code_mirror.setOption('mode', default_mode);
+    };
 
     IPython.Cell = Cell;
 

IPython/frontend/html/notebook/static/js/codecell.js

@@ -14,6 +14,7 b' var IPython = (function (IPython) {'
 
     var utils = IPython.utils;
     var key   = IPython.utils.keycodes;
+    CodeMirror.modeURL = "/static/codemirror/mode/%N/%N.js";
 
     var CodeCell = function (kernel) {
         // The kernel doesn't have to be set at creation time, in that case
@@ -23,13 +24,23 b' var IPython = (function (IPython) {'
         this.input_prompt_number = null;
         this.tooltip_on_tab = true;
         this.collapsed = false;
+        this.default_mode = 'python';
         IPython.Cell.apply(this, arguments);
+
+        var that = this;
+        this.element.focusout(
+            function() { that.auto_highlight(); }
+        );
     };
 
 
     CodeCell.prototype = new IPython.Cell();
 
 
+    CodeCell.prototype.auto_highlight = function () {
+        this._auto_highlight(IPython.config.cell_magic_highlight)
+    };
+
     CodeCell.prototype.create_element = function () {
         var cell =  $('<div></div>').addClass('cell border-box-sizing code_cell vbox');
         cell.attr('tabindex','2');
@@ -76,6 +87,9 b' var IPython = (function (IPython) {'
         };
 
         var cur = editor.getCursor();
+        if (event.keyCode === key.ENTER){
+            this.auto_highlight();
+        }
 
         if (event.keyCode === key.ENTER && (event.shiftKey || event.ctrlKey)) {
             // Always ignore shift-enter in CodeMirror as we handle it.
@@ -109,6 +123,7 b' var IPython = (function (IPython) {'
         } else if (event.keyCode === key.TAB && event.type == 'keydown') {
             // Tab completion.
             //Do not trim here because of tooltip
+            if (editor.somethingSelected()){return false}
             var pre_cursor = editor.getRange({line:cur.line,ch:0},cur);
             if (pre_cursor.trim() === "") {
                 // Don't autocomplete if the part of the line before the cursor
@@ -172,6 +187,7 b' var IPython = (function (IPython) {'
         IPython.Cell.prototype.select.apply(this);
         this.code_mirror.refresh();
         this.code_mirror.focus();
+        this.auto_highlight();
         // We used to need an additional refresh() after the focus, but
         // it appears that this has been fixed in CM. This bug would show
         // up on FF when a newly loaded markdown cell was edited.
@@ -210,10 +226,31 b' var IPython = (function (IPython) {'
     };
 
 
+
+
+
+    CodeCell.input_prompt_classical = function (prompt_value, lines_number) {
+        var ns = prompt_value || "&nbsp;";
+        return 'In&nbsp;[' + ns + ']:'
+    };
+    
+    CodeCell.input_prompt_continuation = function (prompt_value, lines_number) {
+        var html = [CodeCell.input_prompt_classical(prompt_value, lines_number)];
+        for(var i=1; i < lines_number; i++){html.push(['...:'])};
+        return html.join('</br>')
+    };
+    
+    CodeCell.input_prompt_function = CodeCell.input_prompt_classical;
+
+
     CodeCell.prototype.set_input_prompt = function (number) {
+        var nline = 1
+        if( this.code_mirror != undefined) {
+           nline = this.code_mirror.lineCount();
+        }
         this.input_prompt_number = number;
-        var ns = number || "&nbsp;";
-        this.element.find('div.input_prompt').html('In&nbsp;[' + ns + ']:');
+        var prompt_html = CodeCell.input_prompt_function(this.input_prompt_number, nline);
+        this.element.find('div.input_prompt').html(prompt_html);
     };
 
 
@@ -267,6 +304,7 b' var IPython = (function (IPython) {'
                 // make this value the starting point, so that we can only undo
                 // to this state, instead of a blank cell
                 this.code_mirror.clearHistory();
+                this.auto_highlight();
             }
             if (data.prompt_number !== undefined) {
                 this.set_input_prompt(data.prompt_number);

IPython/frontend/html/notebook/static/js/kernel.js

@@ -64,7 +64,7 b' var IPython = (function (IPython) {'
 
 
     Kernel.prototype.restart = function () {
-        $([IPython.events]).trigger({type: 'status_restarting.Kernel', kernel: this});
+        $([IPython.events]).trigger('status_restarting.Kernel', {kernel: this});
         var that = this;
         if (this.running) {
             this.stop_channels();
@@ -86,6 +86,7 b' var IPython = (function (IPython) {'
         this.start_channels();
         this.shell_channel.onmessage = $.proxy(this._handle_shell_reply,this);
         this.iopub_channel.onmessage = $.proxy(this._handle_iopub_reply,this);
+        $([IPython.events]).trigger('status_started.Kernel', {kernel: this});
     };
 
 
@@ -245,7 +246,8 b' var IPython = (function (IPython) {'
             user_expressions : {},
             allow_stdin : false
         };
-		$.extend(true, content, options)
+        $.extend(true, content, options)
+        $([IPython.events]).trigger('execution_request.Kernel', {kernel: this, content:content});
         var msg = this._get_msg("execute_request", content);
         this.shell_channel.send(JSON.stringify(msg));
         this.set_callbacks_for_msg(msg.header.msg_id, callbacks);
@@ -279,7 +281,7 b' var IPython = (function (IPython) {'
 
     Kernel.prototype.interrupt = function () {
         if (this.running) {
-            $([IPython.events]).trigger({type: 'status_interrupting.Kernel', kernel: this});
+            $([IPython.events]).trigger('status_interrupting.Kernel', {kernel: this});
             $.post(this.kernel_url + "/interrupt");
         };
     };
@@ -312,6 +314,7 b' var IPython = (function (IPython) {'
 
     Kernel.prototype._handle_shell_reply = function (e) {
         reply = $.parseJSON(e.data);
+        $([IPython.events]).trigger('shell_reply.Kernel', {kernel: this, reply:reply});
         var header = reply.header;
         var content = reply.content;
         var metadata = reply.metadata;
@@ -367,12 +370,12 b' var IPython = (function (IPython) {'
             }
         } else if (msg_type === 'status') {
             if (content.execution_state === 'busy') {
-                $([IPython.events]).trigger({type: 'status_busy.Kernel', kernel: this});
+                $([IPython.events]).trigger('status_busy.Kernel', {kernel: this});
             } else if (content.execution_state === 'idle') {
-                $([IPython.events]).trigger({type: 'status_idle.Kernel', kernel: this});
+                $([IPython.events]).trigger('status_idle.Kernel', {kernel: this});
             } else if (content.execution_state === 'dead') {
                 this.stop_channels();
-                $([IPython.events]).trigger({type: 'status_dead.Kernel', kernel: this});
+                $([IPython.events]).trigger('status_dead.Kernel', {kernel: this});
             };
         } else if (msg_type === 'clear_output') {
             var cb = callbacks['clear_output'];

IPython/frontend/html/notebook/static/js/layoutmanager.js

@@ -32,10 +32,10 b' var IPython = (function (IPython) {'
         }
         var menubar_height = $('div#menubar').outerHeight(true);
         var toolbar_height;
-        if ($('div#toolbar').css('display') === 'none') {
+        if ($('div#maintoolbar').css('display') === 'none') {
             toolbar_height = 0;
         } else {
-            toolbar_height = $('div#toolbar').outerHeight(true);
+            toolbar_height = $('div#maintoolbar').outerHeight(true);
         }
         return h-header_height-menubar_height-toolbar_height;  // content height
     }

IPython/frontend/html/notebook/static/js/mathjaxutils.js

@@ -1,29 +1,33 b''
 //----------------------------------------------------------------------------
-//  Copyright (C) 2008-2011  The IPython Development Team
+//  Copyright (C) 2008-2012  The IPython Development Team
 //
 //  Distributed under the terms of the BSD License.  The full license is in
 //  the file COPYING, distributed as part of this software.
 //----------------------------------------------------------------------------
 
 //============================================================================
-// MathJax initialization
+// MathJax utility functions
 //============================================================================
 
-var IPython = (function (IPython) {
+IPython.namespace('IPython.mathjaxutils');
 
-    var init_mathjax = function () {
-        if (window.MathJax) { 
+IPython.mathjaxutils = (function (IPython) {
+
+    var init = function () {
+        if (window.MathJax) {
             // MathJax loaded
             MathJax.Hub.Config({
                 tex2jax: {
                     inlineMath: [ ['$','$'], ["\\(","\\)"] ],
-                    displayMath: [ ['$$','$$'], ["\\[","\\]"] ]
+                    displayMath: [ ['$$','$$'], ["\\[","\\]"] ],
+                    processEnvironments: true
                 },
                 displayAlign: 'left', // Change this to 'center' to center equations.
                 "HTML-CSS": {
                     styles: {'.MathJax_Display': {"margin": 0}}
                 }
             });
+            MathJax.Hub.Configured();
         } else if (window.mathjax_url != "") {
             // Don't have MathJax, but should. Show dialog.
             var dialog = $('<div></div>')
@@ -74,10 +78,164 b' var IPython = (function (IPython) {'
         };
     };
 
+    // Some magic for deferring mathematical expressions to MathJax
+    // by hiding them from the Markdown parser.
+    // Some of the code here is adapted with permission from Davide Cervone
+    // under the terms of the Apache2 license governing the MathJax project.
+    // Other minor modifications are also due to StackExchange and are used with
+    // permission.
+
+    var inline = "$"; // the inline math delimiter
+    var blocks, start, end, last, braces; // used in searching for math
+    var math; // stores math until pagedown (Markdown parser) is done
+
+    // MATHSPLIT contains the pattern for math delimiters and special symbols
+    // needed for searching for math in the text input.   
+    var MATHSPLIT = /(\$\$?|\\(?:begin|end)\{[a-z]*\*?\}|\\[\\{}$]|[{}]|(?:\n\s*)+|@@\d+@@)/i;
+
+    //  The math is in blocks i through j, so 
+    //    collect it into one block and clear the others.
+    //  Replace &, <, and > by named entities.
+    //  For IE, put <br> at the ends of comments since IE removes \n.
+    //  Clear the current math positions and store the index of the
+    //    math, then push the math string onto the storage array.
+    //  The preProcess function is called on all blocks if it has been passed in
+    var process_math = function (i, j, pre_process) {
+        var hub = MathJax.Hub;
+        var block = blocks.slice(i, j + 1).join("").replace(/&/g, "&amp;") // use HTML entity for &
+        .replace(/</g, "&lt;") // use HTML entity for <
+        .replace(/>/g, "&gt;") // use HTML entity for >
+        ;
+        if (hub.Browser.isMSIE) {
+            block = block.replace(/(%[^\n]*)\n/g, "$1<br/>\n")
+        }
+        while (j > i) {
+            blocks[j] = "";
+            j--;
+        }
+        blocks[i] = "@@" + math.length + "@@"; // replace the current block text with a unique tag to find later
+        if (pre_process)
+            block = pre_process(block);
+        math.push(block);
+        start = end = last = null;
+    }
+
+    //  Break up the text into its component parts and search
+    //    through them for math delimiters, braces, linebreaks, etc.
+    //  Math delimiters must match and braces must balance.
+    //  Don't allow math to pass through a double linebreak
+    //    (which will be a paragraph).
+    //
+    var remove_math = function (text) {
+        if (!window.MathJax) {
+            return text;
+        }
+
+        start = end = last = null; // for tracking math delimiters
+        math = []; // stores math strings for later
+        
+        // Except for extreme edge cases, this should catch precisely those pieces of the markdown
+        // source that will later be turned into code spans. While MathJax will not TeXify code spans,
+        // we still have to consider them at this point; the following issue has happened several times:
+        //
+        //     `$foo` and `$bar` are varibales.  -->  <code>$foo ` and `$bar</code> are variables.
+
+        var hasCodeSpans = /`/.test(text),
+            de_tilde;
+        if (hasCodeSpans) {
+            text = text.replace(/~/g, "~T").replace(/(^|[^\\])(`+)([^\n]*?[^`\n])\2(?!`)/gm, function (wholematch) {
+                return wholematch.replace(/\$/g, "~D");
+            });
+            de_tilde = function (text) { return text.replace(/~([TD])/g, function (wholematch, character) { return { T: "~", D: "$" }[character]; }) };
+        } else {
+            de_tilde = function (text) { return text; };
+        }
+        
+        blocks = IPython.utils.regex_split(text.replace(/\r\n?/g, "\n"),MATHSPLIT);
+
+        for (var i = 1, m = blocks.length; i < m; i += 2) {
+            var block = blocks[i];
+            if (block.charAt(0) === "@") {
+                //
+                //  Things that look like our math markers will get
+                //  stored and then retrieved along with the math.
+                //
+                blocks[i] = "@@" + math.length + "@@";
+                math.push(block);
+            }
+            else if (start) {
+                //
+                //  If we are in math, look for the end delimiter,
+                //    but don't go past double line breaks, and
+                //    and balance braces within the math.
+                //
+                if (block === end) {
+                    if (braces) {
+                        last = i
+                    }
+                    else {
+                        process_math(start, i, de_tilde)
+                    }
+                }
+                else if (block.match(/\n.*\n/)) {
+                    if (last) {
+                        i = last;
+                        process_math(start, i, de_tilde)
+                    }
+                    start = end = last = null;
+                    braces = 0;
+                }
+                else if (block === "{") {
+                    braces++
+                }
+                else if (block === "}" && braces) {
+                    braces--
+                }
+            }
+            else {
+                //
+                //  Look for math start delimiters and when
+                //    found, set up the end delimiter.
+                //
+                if (block === inline || block === "$$") {
+                    start = i;
+                    end = block;
+                    braces = 0;
+                }
+                else if (block.substr(1, 5) === "begin") {
+                    start = i;
+                    end = "\\end" + block.substr(6);
+                    braces = 0;
+                }
+            }
+        }
+        if (last) {
+            process_math(start, last, de_tilde)
+        }
+        return de_tilde(blocks.join(""));
+    }
 
-    // Set module variables
-    IPython.init_mathjax = init_mathjax;
+    //
+    //  Put back the math strings that were saved,
+    //    and clear the math array (no need to keep it around).
+    //  
+    var replace_math = function (text) {
+        if (!window.MathJax) {
+            return text;
+        }
 
-    return IPython;
+        text = text.replace(/@@(\d+)@@/g, function (match, n) {
+            return math[n]
+        });
+        math = null;
+        return text;
+    }
+
+    return {
+        init : init,
+        process_math : process_math,
+        remove_math : remove_math,
+        replace_math : replace_math
+    };
 
 }(IPython));
  No newline at end of file

IPython/frontend/html/notebook/static/js/menubar.js

@@ -128,7 +128,13 b' var IPython = (function (IPython) {'
         });
         this.element.find('#run_all_cells').click(function () {
             IPython.notebook.execute_all_cells();
-        });
+        }).attr('title', 'Run all cells in the notebook');
+        this.element.find('#run_all_cells_above').click(function () {
+            IPython.notebook.execute_cells_above();
+        }).attr('title', 'Run all cells above (but not including) this cell');
+        this.element.find('#run_all_cells_below').click(function () {
+            IPython.notebook.execute_cells_below();
+        }).attr('title', 'Run this cell and all cells below it');
         this.element.find('#to_code').click(function () {
             IPython.notebook.to_code();
         });

IPython/frontend/html/notebook/static/js/notebook.js

@@ -22,6 +22,9 b' var IPython = (function (IPython) {'
         this.next_prompt_number = 1;
         this.kernel = null;
         this.clipboard = null;
+        this.undelete_backup = null;
+        this.undelete_index = null;
+        this.undelete_below = false;
         this.paste_enabled = false;
         this.dirty = false;
         this.metadata = {};
@@ -139,8 +142,8 b' var IPython = (function (IPython) {'
                 that.control_key_active = false;
                 return false;
             } else if (event.which === 86 && that.control_key_active) {
-                // Paste selected cell = v
-                that.paste_cell();
+                // Paste below selected cell = v
+                that.paste_cell_below();
                 that.control_key_active = false;
                 return false;
             } else if (event.which === 68 && that.control_key_active) {
@@ -257,6 +260,11 b' var IPython = (function (IPython) {'
                 IPython.quick_help.show_keyboard_shortcuts();
                 that.control_key_active = false;
                 return false;
+            } else if (event.which === 90 && that.control_key_active) {
+                // Undo last cell delete = z
+                that.undelete();
+                that.control_key_active = false;
+                return false;
             } else if (that.control_key_active) {
                 that.control_key_active = false;
                 return true;
@@ -304,6 +312,16 b' var IPython = (function (IPython) {'
         });
     };
 
+    Notebook.prototype.scroll_to_cell = function (cell_number, time) {
+        var cells = this.get_cells();
+        var time = time || 0;
+        cell_number = Math.min(cells.length-1,cell_number);
+        cell_number = Math.max(0             ,cell_number);
+        scroll_value = cells[cell_number].element.position().top-cells[0].element.position().top ; 
+        this.element.animate({scrollTop:scroll_value}, time);
+        return scroll_value;
+    };
+
 
     Notebook.prototype.scroll_to_bottom = function () {
         this.element.animate({scrollTop:this.element.get(0).scrollHeight}, 0);
@@ -526,13 +544,19 b' var IPython = (function (IPython) {'
 
     Notebook.prototype.delete_cell = function (index) {
         var i = this.index_or_selected(index);
+        var cell = this.get_selected_cell();
+        this.undelete_backup = cell.toJSON();
         if (this.is_valid_cell_index(i)) {
             var ce = this.get_cell_element(i);
             ce.remove();
             if (i === (this.ncells())) {
                 this.select(i-1);
+                this.undelete_index = i - 1;
+                this.undelete_below = true;
             } else {
                 this.select(i);
+                this.undelete_index = i;
+                this.undelete_below = false;
             };
             this.dirty = true;
         };
@@ -540,11 +564,21 b' var IPython = (function (IPython) {'
     };
 
 
+    Notebook.prototype.insert_cell_at_bottom = function (type){
+        var len = this.ncells();
+        return this.insert_cell_below(type,len-1);
+    }
+
     Notebook.prototype.insert_cell_below = function (type, index) {
         // type = ('code','html','markdown')
         // index = cell index or undefined to insert below selected
         index = this.index_or_selected(index);
         var cell = null;
+        // This is intentionally < rather than <= for the sake of more
+        // sensible behavior in some cases.
+        if (this.undelete_index !== null && index < this.undelete_index) {
+            this.undelete_index = this.undelete_index + 1;
+        }
         if (this.ncells() === 0 || this.is_valid_cell_index(index)) {
             if (type === 'code') {
                 cell = new IPython.CodeCell(this.kernel);
@@ -579,6 +613,9 b' var IPython = (function (IPython) {'
         // index = cell index or undefined to insert above selected
         index = this.index_or_selected(index);
         var cell = null;
+        if (this.undelete_index !== null && index <= this.undelete_index) {
+            this.undelete_index = this.undelete_index + 1;
+        }
         if (this.ncells() === 0 || this.is_valid_cell_index(index)) {
             if (type === 'code') {
                 cell = new IPython.CodeCell(this.kernel);
@@ -741,8 +778,8 b' var IPython = (function (IPython) {'
     Notebook.prototype.enable_paste = function () {
         var that = this;
         if (!this.paste_enabled) {
-            $('#paste_cell').removeClass('ui-state-disabled')
-                .on('click', function () {that.paste_cell();});
+            $('#paste_cell_replace').removeClass('ui-state-disabled')
+                .on('click', function () {that.paste_cell_replace();});
             $('#paste_cell_above').removeClass('ui-state-disabled')
                 .on('click', function () {that.paste_cell_above();});
             $('#paste_cell_below').removeClass('ui-state-disabled')
@@ -754,7 +791,7 b' var IPython = (function (IPython) {'
 
     Notebook.prototype.disable_paste = function () {
         if (this.paste_enabled) {
-            $('#paste_cell').addClass('ui-state-disabled').off('click');
+            $('#paste_cell_replace').addClass('ui-state-disabled').off('click');
             $('#paste_cell_above').addClass('ui-state-disabled').off('click');
             $('#paste_cell_below').addClass('ui-state-disabled').off('click');
             this.paste_enabled = false;
@@ -774,7 +811,7 b' var IPython = (function (IPython) {'
     };
 
 
-    Notebook.prototype.paste_cell = function () {
+    Notebook.prototype.paste_cell_replace = function () {
         if (this.clipboard !== null && this.paste_enabled) {
             var cell_data = this.clipboard;
             var new_cell = this.insert_cell_above(cell_data.cell_type);
@@ -803,6 +840,33 b' var IPython = (function (IPython) {'
         };
     };
 
+    // Cell undelete
+
+    Notebook.prototype.undelete = function() {
+        if (this.undelete_backup !== null && this.undelete_index !== null) {
+            var current_index = this.get_selected_index();
+            if (this.undelete_index < current_index) {
+                current_index = current_index + 1;
+            }
+            if (this.undelete_index >= this.ncells()) {
+                this.select(this.ncells() - 1);
+            }
+            else {
+                this.select(this.undelete_index);
+            }
+            var cell_data = this.undelete_backup;
+            var new_cell = null;
+            if (this.undelete_below) {
+                new_cell = this.insert_cell_below(cell_data.cell_type);
+            } else {
+                new_cell = this.insert_cell_above(cell_data.cell_type);
+            }
+            new_cell.fromJSON(cell_data);
+            this.select(current_index);
+            this.undelete_backup = null;
+            this.undelete_index = null;
+        }
+    }
 
     // Split/merge
 
@@ -1034,13 +1098,25 b' var IPython = (function (IPython) {'
     };
 
 
+    Notebook.prototype.execute_cells_below = function () {
+        this.execute_cell_range(this.get_selected_index(), this.ncells());
+        that.scroll_to_bottom();
+    };
+
+    Notebook.prototype.execute_cells_above = function () {
+        this.execute_cell_range(0, this.get_selected_index());
+    };
+
     Notebook.prototype.execute_all_cells = function () {
-        var ncells = this.ncells();
-        for (var i=0; i<ncells; i++) {
+        this.execute_cell_range(0, this.ncells());
+        that.scroll_to_bottom();
+    };
+
+    Notebook.prototype.execute_cell_range = function (start, end) {
+        for (var i=start; i<end; i++) {
             this.select(i);
             this.execute_selected_cell({add_new:false});
         };
-        this.scroll_to_bottom();
     };
 
     // Persistance and loading

IPython/frontend/html/notebook/static/js/notebookmain.js

@@ -1,5 +1,5 b''
 //----------------------------------------------------------------------------
-//  Copyright (C) 2008-2011  The IPython Development Team
+//  Copyright (C) 2011  The IPython Development Team
 //
 //  Distributed under the terms of the BSD License.  The full license is in
 //  the file COPYING, distributed as part of this software.
@@ -12,7 +12,26 b''
 
 $(document).ready(function () {
 
-    IPython.init_mathjax();
+    // monkey patch CM to be able to syntax highlight cell magics
+    // bug reported upstream,
+    // see https://github.com/marijnh/CodeMirror2/issues/670
+    if(CodeMirror.getMode(1,'text/plain').indent == undefined ){
+        console.log('patching CM for undefined indent');
+        CodeMirror.modes.null = function() { return {token: function(stream) {stream.skipToEnd();},indent : function(){return 0}}}
+        }
+
+    CodeMirror.patchedGetMode = function(config, mode){
+            var cmmode = CodeMirror.getMode(config, mode);
+            if(cmmode.indent == null)
+            {
+                console.log('patch mode "' , mode, '" on the fly');
+                cmmode.indent = function(){return 0};
+            }
+            return cmmode;
+        }
+    // end monkey patching CodeMirror
+
+    IPython.mathjaxutils.init();
 
     IPython.read_only = $('body').data('readOnly') === 'True';
     $('div#main_app').addClass('border-box-sizing ui-widget');
@@ -29,7 +48,7 b' $(document).ready(function () {'
     IPython.notebook = new IPython.Notebook('div#notebook');
     IPython.save_widget = new IPython.SaveWidget('span#save_widget');
     IPython.menubar = new IPython.MenuBar('#menubar')
-    IPython.toolbar = new IPython.ToolBar('#toolbar')
+    IPython.toolbar = new IPython.MainToolBar('#maintoolbar')
     IPython.tooltip = new IPython.Tooltip()
     IPython.notification_area = new IPython.NotificationArea('#notification_area')
     IPython.notification_area.init_notification_widgets();

IPython/frontend/html/notebook/static/js/outputarea.js

@@ -379,8 +379,10 b' var IPython = (function (IPython) {'
     OutputArea.prototype.append_text = function (data, element, extra_class) {
         var toinsert = $("<div/>").addClass("box-flex1 output_subarea output_text");
         // escape ANSI & HTML specials in plaintext:
+        data = utils.wrapUrls(data);
         data = utils.fixConsole(data);
         data = utils.fixCarriageReturn(data);
+        data = utils.autoLinkUrls(data);
         if (extra_class){
             toinsert.addClass(extra_class);
         }

IPython/frontend/html/notebook/static/js/pager.js

@@ -15,6 +15,7 b' var IPython = (function (IPython) {'
 
     var Pager = function (pager_selector, pager_splitter_selector) {
         this.pager_element = $(pager_selector);
+        this.pager_button_area = $('#pager_button_area');
         var that = this;
         this.percentage_height = 0.40;
         this.pager_splitter_element = $(pager_splitter_selector)
@@ -39,9 +40,24 b' var IPython = (function (IPython) {'
             });
         this.expanded = false;
         this.style();
+        this.create_button_area();
         this.bind_events();
     };
 
+    Pager.prototype.create_button_area = function(){
+        var that = this;
+        this.pager_button_area.append(
+            $('<a>').attr('role', "button")
+                    .attr('title',"open the pager in an external window")
+                    .addClass('ui-button')
+                    .click(function(){that.detach()})
+                    .attr('style','position: absolute; right: 10px;')
+                    .append(
+                        $('<span>').addClass("ui-icon ui-icon-extlink")
+                    )
+        )
+    };
+
     Pager.prototype.style = function () {
         this.pager_splitter_element.addClass('border-box-sizing ui-widget ui-state-default');
         this.pager_element.addClass('border-box-sizing ui-widget');
@@ -114,6 +130,26 b' var IPython = (function (IPython) {'
         this.pager_element.empty();
     };
 
+    Pager.prototype.detach = function(){
+        var w = window.open("","_blank")
+        $(w.document.head)
+        .append(
+                $('<link>')
+                .attr('rel',"stylesheet")
+                .attr('href',"/static/css/notebook.css")
+                .attr('type',"text/css")
+        )
+        .append(
+                $('<title>').text("IPython Pager")
+        );
+        var pager_body = $(w.document.body)
+            pager_body.attr('style','overflow:scroll');
+
+        pager_body.append(this.pager_element.children())
+        w.document.close();
+        this.collapse();
+
+    }
 
     Pager.prototype.append_text = function (text) {
         var toinsert = $("<div/>").addClass("output_area output_stream");

IPython/frontend/html/notebook/static/js/printnotebookmain.js

@@ -12,7 +12,7 b''
 
 $(document).ready(function () {
 
-    IPython.init_mathjax();
+    IPython.mathjaxutils.init();
 
     IPython.read_only = $('body').data('readOnly') === 'True';
     $('div#main_app').addClass('border-box-sizing ui-widget');

IPython/frontend/html/notebook/static/js/quickhelp.js

@@ -33,6 +33,7 b' var IPython = (function (IPython) {'
             {key: 'Ctrl-m c', help: 'copy cell'},
             {key: 'Ctrl-m v', help: 'paste cell'},
             {key: 'Ctrl-m d', help: 'delete cell'},
+            {key: 'Ctrl-m z', help: 'undo last cell deletion'},
             {key: 'Ctrl-m a', help: 'insert cell above'},
             {key: 'Ctrl-m b', help: 'insert cell below'},
             {key: 'Ctrl-m o', help: 'toggle output'},

IPython/frontend/html/notebook/static/js/textcell.js

@@ -1,5 +1,5 b''
 //----------------------------------------------------------------------------
-//  Copyright (C) 2008-2011  The IPython Development Team
+//  Copyright (C) 2008-2012  The IPython Development Team
 //
 //  Distributed under the terms of the BSD License.  The full license is in
 //  the file COPYING, distributed as part of this software.
@@ -221,7 +221,9 b' var IPython = (function (IPython) {'
         if (this.rendered === false) {
             var text = this.get_text();
             if (text === "") { text = this.placeholder; }
+            text = IPython.mathjaxutils.remove_math(text)
             var html = IPython.markdown_converter.makeHtml(text);
+            html = IPython.mathjaxutils.replace_math(html)
             try {
                 this.set_rendered(html);
             } catch (e) {
@@ -231,7 +233,6 b' var IPython = (function (IPython) {'
                     "Error rendering Markdown!<br/>" + e.toString())
                 );
             }
-            this.typeset()
             this.element.find('div.text_cell_input').hide();
             this.element.find("div.text_cell_render").show();
             var code_snippets = this.element.find("pre > code");
@@ -246,6 +247,7 b' var IPython = (function (IPython) {'
 
                 return '<code class="prettyprint">' + code + '</code>';
             });
+            this.typeset()
             this.rendered = true;
         }
     };
@@ -258,11 +260,19 b' var IPython = (function (IPython) {'
         this.code_mirror_mode = 'rst';
         IPython.TextCell.apply(this, arguments);
         this.cell_type = 'raw';
+        var that = this
+
+        this.element.focusout(
+                function() { that.auto_highlight(); }
+            );
     };
 
 
     RawCell.prototype = new TextCell();
 
+    RawCell.prototype.auto_highlight = function () {
+        this._auto_highlight(IPython.config.raw_cell_highlight);
+    };
 
     RawCell.prototype.render = function () {
         this.rendered = true;

IPython/frontend/html/notebook/static/js/toolbar.js

@@ -1,5 +1,5 b''
 //----------------------------------------------------------------------------
-//  Copyright (C) 2008-2011  The IPython Development Team
+//  Copyright (C) 2008 The IPython Development Team
 //
 //  Distributed under the terms of the BSD License.  The full license is in
 //  the file COPYING, distributed as part of this software.
@@ -16,132 +16,76 b' var IPython = (function (IPython) {'
         if (this.selector !== undefined) {
             this.element = $(selector);
             this.style();
-            this.bind_events();
         }
     };
 
+    // add a group of button into the current toolbar.
+    //
+    // First argument : Mandatory
+    //      list of dict as argument, each dict should contain
+    //      3 mandatory keys and values :
+    //      label : string -- the text to show on hover
+    //      icon  : string -- the jQuery-ui icon to add on this button
+    //      callback : function -- the callback to execute on a click
+    //
+    //      and optionally an 'id' key that is assigned to the button element
+    //
+    // Second Argument, optional,
+    //      string reprensenting the id to give to the button group.
+    //
+    // Example
+    //
+    // IPython.toolbar.add_button_group([
+    //  {label:'my button',
+    //   icon:'ui-icon-disk',
+    //   callback:function(){alert('hoho'),
+    //   id : 'my_button_id',                 // this is optional
+    //   }
+    //  },
+    //  {label:'my second button',
+    //   icon:'ui-icon-scissors',
+    //   callback:function(){alert('be carefull I cut')}
+    //  }
+    //  ],
+    //  "my_button_group_id"
+    //  )
+    //
+    ToolBar.prototype.add_buttons_group = function (list, group_id) {
+        var span_group = $('<span/>');
+        if( group_id != undefined ) {
+            span_group.attr('id',group_id);
+        }
+        for(var el in list) {
+            var button  = $('<button/>').button({
+                icons : {primary : list[el].icon},
+                text  : false,
+                label : list[el].label
+                });
+            var id = list[el].id;
+            if( id != undefined )
+                button.attr('id',id);
+            var fun = list[el].callback;
+            button.click(fun);
+            span_group.append(button);
+        }
+        span_group.buttonset();
+        $(this.selector).append(span_group);
+    };
 
     ToolBar.prototype.style = function () {
         this.element.addClass('border-box-sizing').
-            addClass('ui-widget ui-widget-content').
+            addClass('ui-widget ui-widget-content toolbar').
             css('border-top-style','none').
             css('border-left-style','none').
             css('border-right-style','none');
-        this.element.find('#cell_type').addClass('ui-widget ui-widget-content');
-        this.element.find('#save_b').button({
-            icons : {primary: 'ui-icon-disk'},
-            text : false
-        });
-        this.element.find('#cut_b').button({
-            icons: {primary: 'ui-icon-scissors'},
-            text : false
-        });
-        this.element.find('#copy_b').button({
-            icons: {primary: 'ui-icon-copy'},
-            text : false
-        });
-        this.element.find('#paste_b').button({
-            icons: {primary: 'ui-icon-clipboard'},
-            text : false
-        });
-        this.element.find('#cut_copy_paste').buttonset();
-        this.element.find('#move_up_b').button({
-            icons: {primary: 'ui-icon-arrowthick-1-n'},
-            text : false
-        });
-        this.element.find('#move_down_b').button({
-            icons: {primary: 'ui-icon-arrowthick-1-s'},
-            text : false
-        });
-        this.element.find('#move_up_down').buttonset();
-        this.element.find('#insert_above_b').button({
-            icons: {primary: 'ui-icon-arrowthickstop-1-n'},
-            text : false
-        });
-        this.element.find('#insert_below_b').button({
-            icons: {primary: 'ui-icon-arrowthickstop-1-s'},
-            text : false
-        });
-        this.element.find('#insert_above_below').buttonset();
-        this.element.find('#run_b').button({
-            icons: {primary: 'ui-icon-play'},
-            text : false
-        });
-        this.element.find('#interrupt_b').button({
-            icons: {primary: 'ui-icon-stop'},
-            text : false
-        });
-        this.element.find('#run_int').buttonset();
-    };
-
-
-    ToolBar.prototype.bind_events = function () {
-        var that = this;
-        this.element.find('#save_b').click(function () {
-            IPython.notebook.save_notebook();
-        });
-        this.element.find('#cut_b').click(function () {
-            IPython.notebook.cut_cell();
-        });
-        this.element.find('#copy_b').click(function () {
-            IPython.notebook.copy_cell();
-        });
-        this.element.find('#paste_b').click(function () {
-            IPython.notebook.paste_cell();
-        });
-        this.element.find('#move_up_b').click(function () {
-            IPython.notebook.move_cell_up();
-        });
-        this.element.find('#move_down_b').click(function () {
-            IPython.notebook.move_cell_down();
-        });
-        this.element.find('#insert_above_b').click(function () {
-            IPython.notebook.insert_cell_above('code');
-        });
-        this.element.find('#insert_below_b').click(function () {
-            IPython.notebook.insert_cell_below('code');
-        });
-        this.element.find('#run_b').click(function () {
-            IPython.notebook.execute_selected_cell();
-        });
-        this.element.find('#interrupt_b').click(function () {
-            IPython.notebook.kernel.interrupt();
-        });
-        this.element.find('#cell_type').change(function () {
-            var cell_type = $(this).val();
-            if (cell_type === 'code') {
-                IPython.notebook.to_code();
-            } else if (cell_type === 'markdown')  {
-                IPython.notebook.to_markdown();
-            } else if (cell_type === 'raw')  {
-                IPython.notebook.to_raw();
-            } else if (cell_type === 'heading1')  {
-                IPython.notebook.to_heading(undefined, 1);
-            } else if (cell_type === 'heading2')  {
-                IPython.notebook.to_heading(undefined, 2);
-            } else if (cell_type === 'heading3')  {
-                IPython.notebook.to_heading(undefined, 3);
-            } else if (cell_type === 'heading4')  {
-                IPython.notebook.to_heading(undefined, 4);
-            } else if (cell_type === 'heading5')  {
-                IPython.notebook.to_heading(undefined, 5);
-            } else if (cell_type === 'heading6')  {
-                IPython.notebook.to_heading(undefined, 6);
-            };
-        });
-        $([IPython.events]).on('selected_cell_type_changed.Notebook', function (event, data) {
-            if (data.cell_type === 'heading') {
-                that.element.find('#cell_type').val(data.cell_type+data.level);
-            } else {
-                that.element.find('#cell_type').val(data.cell_type);
-            }
-        });
     };
 
 
     ToolBar.prototype.toggle = function () {
         this.element.toggle();
-        IPython.layout_manager.do_resize();
+        if (IPython.layout_manager != undefined) {
+            IPython.layout_manager.do_resize();
+        }
     };
 
 

IPython/frontend/html/notebook/static/js/tooltip.js

@@ -104,13 +104,10 b' var IPython = (function (IPython) {'
             // function that will be called if you press tab 1, 2, 3... times in a row
             this.tabs_functions = [function (cell, text) {
                 that._request_tooltip(cell, text);
-                IPython.notification_widget.set_message('tab again to expand pager', 2500);
             }, function () {
                 that.expand();
-                IPython.notification_widget.set_message('tab again to make pager sticky for 10s', 2500);
             }, function () {
                 that.stick();
-                IPython.notification_widget.set_message('tab again to open help in pager', 2500);
             }, function (cell) {
                 that.cancel_stick();
                 that.showInPager(cell);

IPython/frontend/html/notebook/static/js/utils.js

@@ -1,5 +1,5 b''
 //----------------------------------------------------------------------------
-//  Copyright (C) 2008-2011  The IPython Development Team
+//  Copyright (C) 2008-2012  The IPython Development Team
 //
 //  Distributed under the terms of the BSD License.  The full license is in
 //  the file COPYING, distributed as part of this software.
@@ -13,6 +13,123 b" IPython.namespace('IPython.utils');"
 
 IPython.utils = (function (IPython) {
 
+    //============================================================================
+    // Cross-browser RegEx Split
+    //============================================================================
+
+    // This code has been MODIFIED from the code licensed below to not replace the
+    // default browser split.  The license is reproduced here.
+
+    // see http://blog.stevenlevithan.com/archives/cross-browser-split for more info:
+    /*!
+     * Cross-Browser Split 1.1.1
+     * Copyright 2007-2012 Steven Levithan <stevenlevithan.com>
+     * Available under the MIT License
+     * ECMAScript compliant, uniform cross-browser split method
+     */
+
+    /**
+     * Splits a string into an array of strings using a regex or string
+     * separator. Matches of the separator are not included in the result array.
+     * However, if `separator` is a regex that contains capturing groups,
+     * backreferences are spliced into the result each time `separator` is
+     * matched. Fixes browser bugs compared to the native
+     * `String.prototype.split` and can be used reliably cross-browser.
+     * @param {String} str String to split.
+     * @param {RegExp|String} separator Regex or string to use for separating
+     *     the string.
+     * @param {Number} [limit] Maximum number of items to include in the result
+     *     array.
+     * @returns {Array} Array of substrings.
+     * @example
+     *
+     * // Basic use
+     * regex_split('a b c d', ' ');
+     * // -> ['a', 'b', 'c', 'd']
+     *
+     * // With limit
+     * regex_split('a b c d', ' ', 2);
+     * // -> ['a', 'b']
+     *
+     * // Backreferences in result array
+     * regex_split('..word1 word2..', /([a-z]+)(\d+)/i);
+     * // -> ['..', 'word', '1', ' ', 'word', '2', '..']
+     */
+    var regex_split = function (str, separator, limit) {
+        // If `separator` is not a regex, use `split`
+        if (Object.prototype.toString.call(separator) !== "[object RegExp]") {
+            return split.call(str, separator, limit);
+        }
+        var output = [],
+            flags = (separator.ignoreCase ? "i" : "") +
+                    (separator.multiline  ? "m" : "") +
+                    (separator.extended   ? "x" : "") + // Proposed for ES6
+                    (separator.sticky     ? "y" : ""), // Firefox 3+
+            lastLastIndex = 0,
+            // Make `global` and avoid `lastIndex` issues by working with a copy
+            separator = new RegExp(separator.source, flags + "g"),
+            separator2, match, lastIndex, lastLength;
+        str += ""; // Type-convert
+
+        compliantExecNpcg = typeof(/()??/.exec("")[1]) === "undefined"
+        if (!compliantExecNpcg) {
+            // Doesn't need flags gy, but they don't hurt
+            separator2 = new RegExp("^" + separator.source + "$(?!\\s)", flags);
+        }
+        /* Values for `limit`, per the spec:
+         * If undefined: 4294967295 // Math.pow(2, 32) - 1
+         * If 0, Infinity, or NaN: 0
+         * If positive number: limit = Math.floor(limit); if (limit > 4294967295) limit -= 4294967296;
+         * If negative number: 4294967296 - Math.floor(Math.abs(limit))
+         * If other: Type-convert, then use the above rules
+         */
+        limit = typeof(limit) === "undefined" ?
+            -1 >>> 0 : // Math.pow(2, 32) - 1
+            limit >>> 0; // ToUint32(limit)
+        while (match = separator.exec(str)) {
+            // `separator.lastIndex` is not reliable cross-browser
+            lastIndex = match.index + match[0].length;
+            if (lastIndex > lastLastIndex) {
+                output.push(str.slice(lastLastIndex, match.index));
+                // Fix browsers whose `exec` methods don't consistently return `undefined` for
+                // nonparticipating capturing groups
+                if (!compliantExecNpcg && match.length > 1) {
+                    match[0].replace(separator2, function () {
+                        for (var i = 1; i < arguments.length - 2; i++) {
+                            if (typeof(arguments[i]) === "undefined") {
+                                match[i] = undefined;
+                            }
+                        }
+                    });
+                }
+                if (match.length > 1 && match.index < str.length) {
+                    Array.prototype.push.apply(output, match.slice(1));
+                }
+                lastLength = match[0].length;
+                lastLastIndex = lastIndex;
+                if (output.length >= limit) {
+                    break;
+                }
+            }
+            if (separator.lastIndex === match.index) {
+                separator.lastIndex++; // Avoid an infinite loop
+            }
+        }
+        if (lastLastIndex === str.length) {
+            if (lastLength || !separator.test("")) {
+                output.push("");
+            }
+        } else {
+            output.push(str.slice(lastLastIndex));
+        }
+        return output.length > limit ? output.slice(0, limit) : output;
+    };
+
+    //============================================================================
+    // End contributed Cross-browser RegEx Split
+    //============================================================================
+
+
     var uuid = function () {
         // http://www.ietf.org/rfc/rfc4122.txt
         var s = [];
@@ -78,11 +195,30 b' IPython.utils = (function (IPython) {'
         tmp = txt;
         do {
             txt = tmp;
-            tmp = txt.replace(/^.*\r(?!\n)/gm, '');
+            tmp = txt.replace(/\r+\n/gm, '\n'); // \r followed by \n --> newline
+            tmp = tmp.replace(/^.*\r+/gm, '');  // Other \r --> clear line
         } while (tmp.length < txt.length);
         return txt;
     }
 
+    // Locate URLs in plain text and wrap them in spaces so that they can be
+    // better picked out by autoLinkUrls even after the text has been
+    // converted to HTML
+    function wrapUrls(txt) {
+        // Note this regexp is a modified version of one from
+        // Markdown.Converter For now it only supports http(s) and ftp URLs,
+        // but could easily support others (though file:// should maybe be
+        // avoided)
+        var url_re = /(^|\W)(https?|ftp)(:\/\/[-A-Z0-9+&@#\/%?=~_|\[\]\(\)!:,\.;]*[-A-Z0-9+&@#\/%=~_|\[\]])($|\W)/gi;
+        return txt.replace(url_re, "$1 $2$3 $4");
+    }
+
+    // Locate a URL with spaces around it and convert that to a anchor tag
+    function autoLinkUrls(txt) {
+        return txt.replace(/ ((https?|ftp):[^'">\s]+) /gi,
+            "<a target=\"_blank\" href=\"$1\">$1</a>");
+    }
+
     grow = function(element) {
         // Grow the cell by hand. This is used upon reloading from JSON, when the
         // autogrow handler is not called.
@@ -138,11 +274,14 b' IPython.utils = (function (IPython) {'
 
 
     return {
+        regex_split : regex_split,
         uuid : uuid,
         fixConsole : fixConsole,
         keycodes : keycodes,
         grow : grow,
         fixCarriageReturn : fixCarriageReturn,
+        wrapUrls : wrapUrls,
+        autoLinkUrls : autoLinkUrls,
         points_to_pixels : points_to_pixels
     };
 

IPython/frontend/html/notebook/templates/notebook.html

@@ -3,7 +3,7 b''
 {% block stylesheet %}
 
 {% if mathjax_url %}
-<script type="text/javascript" src="{{mathjax_url}}?config=TeX-AMS_HTML" charset="utf-8"></script>
+<script type="text/javascript" src="{{mathjax_url}}?config=TeX-AMS_HTML-full&delayStartupUntil=configured" charset="utf-8"></script>
 {% endif %}
 <script type="text/javascript">
 // MathJax disabled, set as null to distingish from *missing* MathJax,
@@ -74,9 +74,9 b' data-notebook-id={{notebook_id}}'
             <ul>
                 <li id="cut_cell"><a href="#">Cut Cell</a></li>
                 <li id="copy_cell"><a href="#">Copy Cell</a></li>
-                <li id="paste_cell" class="ui-state-disabled"><a href="#">Paste Cell</a></li>
                 <li id="paste_cell_above" class="ui-state-disabled"><a href="#">Paste Cell Above</a></li>
                 <li id="paste_cell_below" class="ui-state-disabled"><a href="#">Paste Cell Below</a></li>
+                <li id="paste_cell_replace" class="ui-state-disabled"><a href="#">Paste Cell &amp; Replace</a></li>
                 <li id="delete_cell"><a href="#">Delete</a></li>
                 <hr/>
                 <li id="split_cell"><a href="#">Split Cell</a></li>
@@ -107,6 +107,8 b' data-notebook-id={{notebook_id}}'
                 <li id="run_cell"><a href="#">Run</a></li>
                 <li id="run_cell_in_place"><a href="#">Run in Place</a></li>
                 <li id="run_all_cells"><a href="#">Run All</a></li>
+                <li id="run_all_cells_above"><a href="#">Run All Above</a></li>
+                <li id="run_all_cells_below"><a href="#">Run All Below</a></li>
                 <hr/>
                 <li id="to_code"><a href="#">Code</a></li>
                 <li id="to_markdown"><a href="#">Markdown </a></li>
@@ -156,54 +158,22 b' data-notebook-id={{notebook_id}}'
 </div>
 
 
-<div id="toolbar">
-
-    <span>
-        <button id="save_b">Save</button>
-    </span>
-    <span id="cut_copy_paste">
-        <button id="cut_b" title="Cut Cell">Cut Cell</button>
-        <button id="copy_b" title="Copy Cell">Copy Cell</button>
-        <button id="paste_b" title="Paste Cell">Paste Cell</button>
-    </span>
-    <span id="move_up_down">
-        <button id="move_up_b" title="Move Cell Up">Move Cell Up</button>
-        <button id="move_down_b" title="Move Cell Down">Move Down</button>
-    </span>
-    <span id="insert_above_below">
-        <button id="insert_above_b" title="Insert Cell Above">Insert Cell Above</button>
-        <button id="insert_below_b" title="Insert Cell Below">Insert Cell Below</button>
-    </span>
-    <span id="run_int">
-        <button id="run_b" title="Run Cell">Run Cell</button>
-        <button id="interrupt_b" title="Interrupt">Interrupt</button>
-    </span>
-    <span>
-        <select id="cell_type">
-             <option value="code">Code</option>
-             <option value="markdown">Markdown</option>
-             <option value="raw">Raw Text</option>
-             <option value="heading1">Heading 1</option>
-             <option value="heading2">Heading 2</option>
-             <option value="heading3">Heading 3</option>
-             <option value="heading4">Heading 4</option>
-             <option value="heading5">Heading 5</option>
-             <option value="heading6">Heading 6</option>
-        </select>
-    </span>
-
-</div>
+<div id="maintoolbar"></div>
 
 <div id="main_app">
 
     <div id="notebook_panel">
         <div id="notebook"></div>
         <div id="pager_splitter"></div>
-        <div id="pager"></div>
+        <div id="pager_container">
+            <div id='pager_button_area'>
+            </div>
+            <div id="pager"></div>
+        </div>
     </div>
 
 </div>
-<div id='tooltip' class='tooltip ui-corner-all' style='display:none'></div>
+<div id='tooltip' class='ipython_tooltip ui-corner-all' style='display:none'></div>
 
 
 {% endblock %}
@@ -212,6 +182,8 b' data-notebook-id={{notebook_id}}'
 {% block script %}
 
 <script src="{{ static_url("codemirror/lib/codemirror.js") }}" charset="utf-8"></script>
+<script src="{{ static_url("codemirror/lib/util/loadmode.js") }}" charset="utf-8"></script>
+<script src="{{ static_url("codemirror/lib/util/multiplex.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("codemirror/mode/python/python.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("codemirror/mode/htmlmixed/htmlmixed.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("codemirror/mode/xml/xml.js") }}" charset="utf-8"></script>
@@ -228,7 +200,7 b' data-notebook-id={{notebook_id}}'
 <script src="{{ static_url("js/events.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("js/utils.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("js/layoutmanager.js") }}" type="text/javascript" charset="utf-8"></script>
-<script src="{{ static_url("js/initmathjax.js") }}" type="text/javascript" charset="utf-8"></script>
+<script src="{{ static_url("js/mathjaxutils.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("js/outputarea.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("js/cell.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("js/codecell.js") }}" type="text/javascript" charset="utf-8"></script>
@@ -240,10 +212,12 b' data-notebook-id={{notebook_id}}'
 <script src="{{ static_url("js/pager.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("js/menubar.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("js/toolbar.js") }}" type="text/javascript" charset="utf-8"></script>
+<script src="{{ static_url("js/maintoolbar.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("js/notebook.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("js/notificationwidget.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("js/notificationarea.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("js/tooltip.js") }}" type="text/javascript" charset="utf-8"></script>
+<script src="{{ static_url("js/config.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("js/notebookmain.js") }}" type="text/javascript" charset="utf-8"></script>
 
 <script src="{{ static_url("js/contexthint.js") }}" charset="utf-8"></script>

IPython/frontend/html/notebook/templates/page.html

@@ -28,7 +28,7 b''
 <body {% block params %}{% endblock %}>
 
 <div id="header">
-    <span id="ipython_notebook"><h1><a href={{base_project_url}} alt='dashboard'><img src='{{static_url("ipynblogo.png") }}' alt='IPython Notebook'/></a></h1></span>
+    <span id="ipython_notebook"><div><a href={{base_project_url}} alt='dashboard'><img src='{{static_url("ipynblogo.png") }}' alt='IPython Notebook'/></a></div></span>
 
     {% block login_widget %}
 

IPython/frontend/html/notebook/templates/printnotebook.html

@@ -3,7 +3,7 b''
 {% block stylesheet %}
 
 {% if mathjax_url %}
-<script type="text/javascript" src="{{mathjax_url}}?config=TeX-AMS_HTML" charset="utf-8"></script>
+<script type="text/javascript" src="{{mathjax_url}}?config=TeX-AMS_HTML-full&delayStartupUntil=configured" charset="utf-8"></script>
 {% endif %}
 <script type="text/javascript">
 // MathJax disabled, set as null to distingish from *missing* MathJax,
@@ -69,7 +69,7 b' data-notebook-id={{notebook_id}}'
 
 <script src="{{ static_url("js/events.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("js/utils.js") }}" type="text/javascript" charset="utf-8"></script>
-<script src="{{ static_url("js/initmathjax.js") }}" type="text/javascript" charset="utf-8"></script>
+<script src="{{ static_url("js/mathjaxutils.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("js/outputarea.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("js/cell.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("js/codecell.js") }}" type="text/javascript" charset="utf-8"></script>

IPython/frontend/qt/console/console_widget.py

@@ -10,6 +10,7 b' import re'
 import sys
 from textwrap import dedent
 from unicodedata import category
+import webbrowser
 
 # System library imports
 from IPython.external.qt import QtCore, QtGui
@@ -267,7 +268,6 b' class ConsoleWidget(LoggingConfigurable, QtGui.QWidget):'
         self._continuation_prompt = '> '
         self._continuation_prompt_html = None
         self._executing = False
-        self._filter_drag = False
         self._filter_resize = False
         self._html_exporter = HtmlExporter(self._control)
         self._input_buffer_executing = ''
@@ -342,7 +342,51 b' class ConsoleWidget(LoggingConfigurable, QtGui.QWidget):'
                 triggered=self.reset_font)
         self.addAction(self.reset_font_size)
 
+        # Accept drag and drop events here. Drops were already turned off
+        # in self._control when that widget was created.
+        self.setAcceptDrops(True)
 
+    #---------------------------------------------------------------------------
+    # Drag and drop support
+    #---------------------------------------------------------------------------
+
+    def dragEnterEvent(self, e):
+        if e.mimeData().hasUrls():
+            # The link action should indicate to that the drop will insert
+            # the file anme.
+            e.setDropAction(QtCore.Qt.LinkAction)
+            e.accept()
+        elif e.mimeData().hasText():
+            # By changing the action to copy we don't need to worry about
+            # the user accidentally moving text around in the widget.
+            e.setDropAction(QtCore.Qt.CopyAction)
+            e.accept()
+
+    def dragMoveEvent(self, e):
+        if e.mimeData().hasUrls():
+            pass
+        elif e.mimeData().hasText():
+            cursor = self._control.cursorForPosition(e.pos())
+            if self._in_buffer(cursor.position()):
+                e.setDropAction(QtCore.Qt.CopyAction)
+                self._control.setTextCursor(cursor)
+            else:
+                e.setDropAction(QtCore.Qt.IgnoreAction)
+            e.accept()
+
+    def dropEvent(self, e):
+        if e.mimeData().hasUrls():
+            self._keep_cursor_in_buffer()
+            cursor = self._control.textCursor()
+            filenames = [url.toLocalFile() for url in e.mimeData().urls()]
+            text = ', '.join("'" + f.replace("'", "'\"'\"'") + "'"
+                             for f in filenames)
+            self._insert_plain_text_into_buffer(cursor, text)
+        elif e.mimeData().hasText():
+            cursor = self._control.cursorForPosition(e.pos())
+            if self._in_buffer(cursor.position()):
+                text = e.mimeData().text()
+                self._insert_plain_text_into_buffer(cursor, text)
 
     def eventFilter(self, obj, event):
         """ Reimplemented to ensure a console-like behavior in the underlying
@@ -391,39 +435,6 b' class ConsoleWidget(LoggingConfigurable, QtGui.QWidget):'
                 event.key() in self._shortcuts:
             event.accept()
 
-        # Ensure that drags are safe. The problem is that the drag starting
-        # logic, which determines whether the drag is a Copy or Move, is locked
-        # down in QTextControl. If the widget is editable, which it must be if
-        # we're not executing, the drag will be a Move. The following hack
-        # prevents QTextControl from deleting the text by clearing the selection
-        # when a drag leave event originating from this widget is dispatched.
-        # The fact that we have to clear the user's selection is unfortunate,
-        # but the alternative--trying to prevent Qt from using its hardwired
-        # drag logic and writing our own--is worse.
-        elif etype == QtCore.QEvent.DragEnter and \
-                obj == self._control.viewport() and \
-                event.source() == self._control.viewport():
-            self._filter_drag = True
-        elif etype == QtCore.QEvent.DragLeave and \
-                obj == self._control.viewport() and \
-                self._filter_drag:
-            cursor = self._control.textCursor()
-            cursor.clearSelection()
-            self._control.setTextCursor(cursor)
-            self._filter_drag = False
-
-        # Ensure that drops are safe.
-        elif etype == QtCore.QEvent.Drop and obj == self._control.viewport():
-            cursor = self._control.cursorForPosition(event.pos())
-            if self._in_buffer(cursor.position()):
-                text = event.mimeData().text()
-                self._insert_plain_text_into_buffer(cursor, text)
-
-            # Qt is expecting to get something here--drag and drop occurs in its
-            # own event loop. Send a DragLeave event to end it.
-            QtGui.qApp.sendEvent(obj, QtGui.QDragLeaveEvent())
-            return True
-
         # Handle scrolling of the vsplit pager. This hack attempts to solve
         # problems with tearing of the help text inside the pager window.  This
         # happens only on Mac OS X with both PySide and PyQt. This fix isn't
@@ -432,6 +443,11 b' class ConsoleWidget(LoggingConfigurable, QtGui.QWidget):'
                 obj == self._page_control:
             self._page_control.repaint()
             return True
+
+        elif etype == QtCore.QEvent.MouseMove:
+            anchor = self._control.anchorAt(event.pos())
+            QtGui.QToolTip.showText(event.globalPos(), anchor)
+
         return super(ConsoleWidget, self).eventFilter(obj, event)
 
     #---------------------------------------------------------------------------
@@ -511,6 +527,11 b' class ConsoleWidget(LoggingConfigurable, QtGui.QWidget):'
         """
         self.layout().currentWidget().copy()
 
+    def copy_anchor(self, anchor):
+        """ Copy anchor text to the clipboard
+        """
+        QtGui.QApplication.clipboard().setText(anchor)
+
     def cut(self):
         """ Copy the currently selected text to the clipboard and delete it
             if it's inside the input buffer.
@@ -678,6 +699,11 b' class ConsoleWidget(LoggingConfigurable, QtGui.QWidget):'
 
     font = property(_get_font, _set_font)
 
+    def open_anchor(self, anchor):
+        """ Open selected anchor in the default webbrowser
+        """
+        webbrowser.open( anchor )
+
     def paste(self, mode=QtGui.QClipboard.Clipboard):
         """ Paste the contents of the clipboard into the input region.
 
@@ -858,6 +884,11 b' class ConsoleWidget(LoggingConfigurable, QtGui.QWidget):'
 
         return result
 
+    def _append_block(self, block_format=None, before_prompt=False):
+        """ Appends an new QTextBlock to the end of the console buffer.
+        """
+        self._append_custom(self._insert_block, block_format, before_prompt)
+
     def _append_html(self, html, before_prompt=False):
         """ Appends HTML at the end of the console buffer.
         """
@@ -966,6 +997,14 b' class ConsoleWidget(LoggingConfigurable, QtGui.QWidget):'
         self.paste_action.setEnabled(self.can_paste())
         self.paste_action.setShortcut(QtGui.QKeySequence.Paste)
 
+        anchor = self._control.anchorAt(pos)
+        if anchor:
+            menu.addSeparator()
+            self.copy_link_action = menu.addAction(
+                'Copy Link Address', lambda: self.copy_anchor(anchor=anchor))
+            self.open_link_action = menu.addAction(
+                'Open Link', lambda: self.open_anchor(anchor=anchor))
+
         menu.addSeparator()
         menu.addAction(self.select_all_action)
 
@@ -1004,9 +1043,14 b' class ConsoleWidget(LoggingConfigurable, QtGui.QWidget):'
         elif self.kind == 'rich':
             control = QtGui.QTextEdit()
             control.setAcceptRichText(False)
+            control.setMouseTracking(True)
+
+        # Prevent the widget from handling drops, as we already provide
+        # the logic in this class.
+        control.setAcceptDrops(False)
 
         # Install event filters. The filter on the viewport is needed for
-        # mouse events and drag events.
+        # mouse events.
         control.installEventFilter(self)
         control.viewport().installEventFilter(self)
 
@@ -1545,6 +1589,13 b' class ConsoleWidget(LoggingConfigurable, QtGui.QWidget):'
             self._continuation_prompt = self._insert_html_fetching_plain_text(
                 cursor, self._continuation_prompt_html)
 
+    def _insert_block(self, cursor, block_format=None):
+        """ Inserts an empty QTextBlock using the specified cursor.
+        """
+        if block_format is None:
+            block_format = QtGui.QTextBlockFormat()
+        cursor.insertBlock(block_format)
+
     def _insert_html(self, cursor, html):
         """ Inserts HTML using the specified cursor in such a way that future
             formatting is unaffected.
@@ -1736,6 +1787,32 b' class ConsoleWidget(LoggingConfigurable, QtGui.QWidget):'
         else:
             self._append_plain_text(text)
 
+    def _set_paging(self, paging):
+        """
+        Change the pager to `paging` style.
+
+        XXX: currently, this is limited to switching between 'hsplit' and
+        'vsplit'.
+
+        Parameters:
+        -----------
+        paging : string
+            Either "hsplit", "vsplit", or "inside"
+        """
+        if self._splitter is None:
+            raise NotImplementedError("""can only switch if --paging=hsplit or
+                    --paging=vsplit is used.""")
+        if paging == 'hsplit':
+            self._splitter.setOrientation(QtCore.Qt.Horizontal)
+        elif paging == 'vsplit':
+            self._splitter.setOrientation(QtCore.Qt.Vertical)
+        elif paging == 'inside':
+            raise NotImplementedError("""switching to 'inside' paging not
+                    supported yet.""")
+        else:
+            raise ValueError("unknown paging method '%s'" % paging)
+        self.paging = paging
+
     def _prompt_finished(self):
         """ Called immediately after a prompt is finished, i.e. when some input
             will be processed and a new prompt displayed.
@@ -1866,7 +1943,7 b' class ConsoleWidget(LoggingConfigurable, QtGui.QWidget):'
             cursor.movePosition(QtGui.QTextCursor.Left,
                                 QtGui.QTextCursor.KeepAnchor)
             if cursor.selection().toPlainText() != '\n':
-                self._append_plain_text('\n')
+                self._append_block()
 
         # Write the prompt.
         self._append_plain_text(self._prompt_sep)

IPython/frontend/qt/console/mainwindow.py

@@ -528,7 +528,25 b' class MainWindow(QtGui.QMainWindow):'
             statusTip="Clear the console",
             triggered=self.clear_magic_active_frontend)
         self.add_menu_action(self.view_menu, self.clear_action)
-    
+
+        self.pager_menu = self.view_menu.addMenu("&Pager")
+
+        hsplit_action = QtGui.QAction(".. &Horizontal Split",
+            self,
+            triggered=lambda: self.set_paging_active_frontend('hsplit'))
+
+        vsplit_action = QtGui.QAction(" : &Vertical Split",
+            self,
+            triggered=lambda: self.set_paging_active_frontend('vsplit'))
+
+        inside_action = QtGui.QAction("   &Inside Pager",
+            self,
+            triggered=lambda: self.set_paging_active_frontend('inside'))
+
+        self.pager_menu.addAction(hsplit_action)
+        self.pager_menu.addAction(vsplit_action)
+        self.pager_menu.addAction(inside_action)
+
     def init_kernel_menu(self):
         self.kernel_menu = self.menuBar().addMenu("&Kernel")
         # Qt on OSX maps Ctrl to Cmd, and Meta to Ctrl
@@ -829,6 +847,9 b' class MainWindow(QtGui.QMainWindow):'
                 self.maximizeAct.setEnabled(True)
                 self.minimizeAct.setEnabled(True)
 
+    def set_paging_active_frontend(self, paging):
+        self.active_frontend._set_paging(paging)
+
     def close_active_frontend(self):
         self.close_tab(self.active_frontend)
 

IPython/frontend/qt/console/tests/test_console_widget.py

@@ -2,7 +2,7 b''
 import unittest
 
 # System library imports
-from IPython.external.qt import QtGui
+from IPython.external.qt import QtCore, QtGui
 
 # Local imports
 from IPython.frontend.qt.console.console_widget import ConsoleWidget
@@ -40,3 +40,41 b' class TestConsoleWidget(unittest.TestCase):'
             self.assertEqual(expected_outputs[i], selection)
             # clear all the text
             cursor.insertText('')
+
+    def test_link_handling(self):
+        noKeys = QtCore.Qt
+        noButton = QtCore.Qt.MouseButton(0)
+        noButtons = QtCore.Qt.MouseButtons(0)
+        noModifiers = QtCore.Qt.KeyboardModifiers(0)
+        MouseMove = QtCore.QEvent.MouseMove
+        QMouseEvent = QtGui.QMouseEvent
+        
+        w = ConsoleWidget()
+        cursor = w._get_prompt_cursor()
+        w._insert_html(cursor, '<a href="http://python.org">written in</a>')
+        obj = w._control
+        tip = QtGui.QToolTip
+        self.assertEqual(tip.text(), u'')
+        
+        # should be somewhere else
+        elsewhereEvent = QMouseEvent(MouseMove, QtCore.QPoint(50,50),
+                                     noButton, noButtons, noModifiers)
+        w.eventFilter(obj, elsewhereEvent)
+        self.assertEqual(tip.isVisible(), False)
+        self.assertEqual(tip.text(), u'')
+        
+        #self.assertEqual(tip.text(), u'')
+        # should be over text
+        overTextEvent = QMouseEvent(MouseMove, QtCore.QPoint(1,5),
+                                    noButton, noButtons, noModifiers)
+        w.eventFilter(obj, overTextEvent)
+        self.assertEqual(tip.isVisible(), True)
+        self.assertEqual(tip.text(), "http://python.org")
+        
+        # should still be over text
+        stillOverTextEvent = QMouseEvent(MouseMove, QtCore.QPoint(1,5),
+                                         noButton, noButtons, noModifiers)
+        w.eventFilter(obj, stillOverTextEvent)
+        self.assertEqual(tip.isVisible(), True)
+        self.assertEqual(tip.text(), "http://python.org")
+        

IPython/frontend/terminal/console/interactiveshell.py

@@ -19,15 +19,26 b' from __future__ import print_function'
 
 import bdb
 import signal
+import os
 import sys
 import time
+import subprocess
+from io import BytesIO
+import base64
 
 from Queue import Empty
 
+try:
+    from contextlib import nested
+except:
+    from IPython.utils.nested_context import nested
+
 from IPython.core.alias import AliasManager, AliasError
 from IPython.core import page
 from IPython.utils.warn import warn, error, fatal
 from IPython.utils import io
+from IPython.utils.traitlets import List, Enum, Any
+from IPython.utils.tempdir import NamedFileInTemporaryDirectory
 
 from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
 from IPython.frontend.terminal.console.completer import ZMQCompleter
@@ -36,7 +47,64 b' from IPython.frontend.terminal.console.completer import ZMQCompleter'
 class ZMQTerminalInteractiveShell(TerminalInteractiveShell):
     """A subclass of TerminalInteractiveShell that uses the 0MQ kernel"""
     _executing = False
-    
+
+    image_handler = Enum(('PIL', 'stream', 'tempfile', 'callable'),
+                         config=True, help=
+        """
+        Handler for image type output.  This is useful, for example,
+        when connecting to the kernel in which pylab inline backend is
+        activated.  There are four handlers defined.  'PIL': Use
+        Python Imaging Library to popup image; 'stream': Use an
+        external program to show the image.  Image will be fed into
+        the STDIN of the program.  You will need to configure
+        `stream_image_handler`; 'tempfile': Use an external program to
+        show the image.  Image will be saved in a temporally file and
+        the program is called with the temporally file.  You will need
+        to configure `tempfile_image_handler`; 'callable': You can set
+        any Python callable which is called with the image data.  You
+        will need to configure `callable_image_handler`.
+        """
+    )
+
+    stream_image_handler = List(config=True, help=
+        """
+        Command to invoke an image viewer program when you are using
+        'stream' image handler.  This option is a list of string where
+        the first element is the command itself and reminders are the
+        options for the command.  Raw image data is given as STDIN to
+        the program.
+        """
+    )
+
+    tempfile_image_handler = List(config=True, help=
+        """
+        Command to invoke an image viewer program when you are using
+        'tempfile' image handler.  This option is a list of string
+        where the first element is the command itself and reminders
+        are the options for the command.  You can use {file} and
+        {format} in the string to represent the location of the
+        generated image file and image format.
+        """
+    )
+
+    callable_image_handler = Any(config=True, help=
+        """
+        Callable object called via 'callable' image handler with one
+        argument, `data`, which is `msg["content"]["data"]` where
+        `msg` is the message from iopub channel.  For exmaple, you can
+        find base64 encoded PNG data as `data['image/png']`.
+        """
+    )
+
+    mime_preference = List(
+        default_value=['image/png', 'image/jpeg', 'image/svg+xml'],
+        config=True, allow_none=False, help=
+        """
+        Preferred object representation MIME type in order.  First
+        matched MIME type will be used.
+        """
+    )
+
     def __init__(self, *args, **kwargs):
         self.km = kwargs.pop('kernel_manager')
         self.session_id = self.km.session.session
@@ -163,6 +231,7 b' class ZMQTerminalInteractiveShell(TerminalInteractiveShell):'
                 elif msg_type == 'pyout':
                     self.execution_count = int(sub_msg["content"]["execution_count"])
                     format_dict = sub_msg["content"]["data"]
+                    self.handle_rich_data(format_dict)
                     # taken from DisplayHook.__call__:
                     hook = self.displayhook
                     hook.start_displayhook()
@@ -171,6 +240,61 b' class ZMQTerminalInteractiveShell(TerminalInteractiveShell):'
                     hook.log_output(format_dict)
                     hook.finish_displayhook()
 
+                elif msg_type == 'display_data':
+                    self.handle_rich_data(sub_msg["content"]["data"])
+
+    _imagemime = {
+        'image/png': 'png',
+        'image/jpeg': 'jpeg',
+        'image/svg+xml': 'svg',
+    }
+
+    def handle_rich_data(self, data):
+        for mime in self.mime_preference:
+            if mime in data and mime in self._imagemime:
+                self.handle_image(data, mime)
+                return
+
+    def handle_image(self, data, mime):
+        handler = getattr(
+            self, 'handle_image_{0}'.format(self.image_handler), None)
+        if handler:
+            handler(data, mime)
+
+    def handle_image_PIL(self, data, mime):
+        if mime not in ('image/png', 'image/jpeg'):
+            return
+        import PIL.Image
+        raw = base64.decodestring(data[mime].encode('ascii'))
+        img = PIL.Image.open(BytesIO(raw))
+        img.show()
+
+    def handle_image_stream(self, data, mime):
+        raw = base64.decodestring(data[mime].encode('ascii'))
+        imageformat = self._imagemime[mime]
+        fmt = dict(format=imageformat)
+        args = [s.format(**fmt) for s in self.stream_image_handler]
+        with open(os.devnull, 'w') as devnull:
+            proc = subprocess.Popen(
+                args, stdin=subprocess.PIPE,
+                stdout=devnull, stderr=devnull)
+            proc.communicate(raw)
+
+    def handle_image_tempfile(self, data, mime):
+        raw = base64.decodestring(data[mime].encode('ascii'))
+        imageformat = self._imagemime[mime]
+        filename = 'tmp.{0}'.format(imageformat)
+        with nested(NamedFileInTemporaryDirectory(filename),
+                    open(os.devnull, 'w')) as (f, devnull):
+            f.write(raw)
+            f.flush()
+            fmt = dict(file=f.name, format=imageformat)
+            args = [s.format(**fmt) for s in self.tempfile_image_handler]
+            subprocess.call(args, stdout=devnull, stderr=devnull)
+
+    def handle_image_callable(self, data, mime):
+        self.callable_image_handler(data)
+
     def handle_stdin_request(self, timeout=0.1):
         """ Method to capture raw_input
         """

IPython/frontend/terminal/embed.py

@@ -264,8 +264,6 b' class InteractiveShellEmbed(TerminalInteractiveShell):'
         self.user_ns = orig_user_ns
         self.compile.flags = orig_compile_flags
 
-_embedded_shell = None
-
 
 def embed(**kwargs):
     """Call this to embed IPython at the current point in your program.
@@ -284,7 +282,7 b' def embed(**kwargs):'
         d = 40
         embed
 
-    Full customization can be done by passing a :class:`Struct` in as the
+    Full customization can be done by passing a :class:`Config` in as the
     config argument.
     """
     config = kwargs.get('config')
@@ -294,7 +292,5 b' def embed(**kwargs):'
         config = load_default_config()
         config.InteractiveShellEmbed = config.TerminalInteractiveShell
         kwargs['config'] = config
-    global _embedded_shell
-    if _embedded_shell is None:
-        _embedded_shell = InteractiveShellEmbed(**kwargs)
-    _embedded_shell(header=header, stack_depth=2, compile_flags=compile_flags)
+    shell = InteractiveShellEmbed.instance(**kwargs)
+    shell(header=header, stack_depth=2, compile_flags=compile_flags)

IPython/frontend/terminal/interactiveshell.py

@@ -357,7 +357,7 b' class TerminalInteractiveShell(InteractiveShell):'
                  usage=None, banner1=None, banner2=None, display_banner=None):
 
         super(TerminalInteractiveShell, self).__init__(
-            config=config, profile_dir=profile_dir, user_ns=user_ns,
+            config=config, ipython_dir=ipython_dir, profile_dir=profile_dir, user_ns=user_ns,
             user_module=user_module, custom_exceptions=custom_exceptions
         )
         # use os.system instead of utils.process.system by default,

IPython/lib/clipboard.py

@@ -5,7 +5,7 b' import subprocess'
 import sys
 
 from IPython.core.error import TryNext
-
+import IPython.utils.py3compat as py3compat
 
 def win32_clipboard_get():
     """ Get the current clipboard's text on Windows.
@@ -31,6 +31,7 b' def osx_clipboard_get():'
     text, stderr = p.communicate()
     # Text comes in with old Mac \r line endings. Change them to \n.
     text = text.replace('\r', '\n')
+    text = py3compat.cast_unicode(text, py3compat.DEFAULT_ENCODING)
     return text
 
 def tkinter_clipboard_get():
@@ -49,6 +50,7 b' def tkinter_clipboard_get():'
     root.withdraw()
     text = root.clipboard_get()
     root.destroy()
+    text = py3compat.cast_unicode(text, py3compat.DEFAULT_ENCODING)
     return text
 
 

IPython/lib/demo.py

@@ -1,3 +1,6 b''
+from __future__ import unicode_literals
+
+
 """Module for interactive demos using IPython.
 
 This module implements a few classes for running Python scripts interactively
@@ -179,7 +182,7 b' from IPython.utils.PyColorize import Parser'
 from IPython.utils import io
 from IPython.utils.io import file_read, file_readlines
 from IPython.utils.text import marquee
-
+from IPython.utils import openpy
 __all__ = ['Demo','IPythonDemo','LineDemo','IPythonLineDemo','DemoError']
 
 class DemoError(Exception): pass
@@ -264,13 +267,13 b' class Demo(object):'
             self.fobj = self.src
         else:
              # Assume it's a string or something that can be converted to one
-            self.fobj = open(self.fname)
+            self.fobj = openpy.open(self.fname)
 
     def reload(self):
         """Reload source from disk and initialize state."""
         self.fload()
 
-        self.src     = self.fobj.read()
+        self.src     = "".join(openpy.strip_encoding_cookie(self.fobj))
         src_b        = [b.strip() for b in self.re_stop.split(self.src) if b]
         self._silent = [bool(self.re_silent.findall(b)) for b in src_b]
         self._auto   = [bool(self.re_auto.findall(b)) for b in src_b]

IPython/lib/display.py

@@ -1,7 +1,8 b''
 """Various display related classes.
 
-Authors : MinRK
+Authors : MinRK, dannystaple
 """
+import urllib
 
 class YouTubeVideo(object):
     """Class for embedding a YouTube Video in an IPython session, based on its video id.
@@ -14,22 +15,37 b' class YouTubeVideo(object):'
 
     vid = YouTubeVideo("foo")
     display(vid)
+    
+    To start from 30 seconds:
+    
+    vid = YouTubeVideo("abc", start=30)
+    display(vid)
+    
+    To calculate seconds from time as hours, minutes, seconds use:
+    start=int(timedelta(hours=1, minutes=46, seconds=40).total_seconds())
+
+    Other parameters can be provided as documented at 
+    https://developers.google.com/youtube/player_parameters#parameter-subheader
     """
 
-    def __init__(self, id, width=400, height=300):
+    def __init__(self, id, width=400, height=300, **kwargs):
         self.id = id
         self.width = width
         self.height = height
+        self.params = kwargs
 
     def _repr_html_(self):
         """return YouTube embed iframe for this video id"""
+        if self.params:
+            params = "?" + urllib.urlencode(self.params)
+        else:
+            params = ""
         return """
             <iframe
                 width="%i"
                 height="%i"
-                src="http://www.youtube.com/embed/%s"
+                src="http://www.youtube.com/embed/%s%s"
                 frameborder="0"
                 allowfullscreen
             ></iframe>
-        """%(self.width, self.height, self.id)
-
+        """ % (self.width, self.height, self.id, params)

IPython/lib/inputhookqt4.py

@@ -85,11 +85,33 b' def create_inputhook_qt4(mgr, app=None):'
                 return 0
             app.processEvents(QtCore.QEventLoop.AllEvents, 300)
             if not stdin_ready():
+                # Generally a program would run QCoreApplication::exec()
+                # from main() to enter and process the Qt event loop until
+                # quit() or exit() is called and the program terminates.
+                #
+                # For our input hook integration, we need to repeatedly
+                # enter and process the Qt event loop for only a short
+                # amount of time (say 50ms) to ensure that Python stays
+                # responsive to other user inputs.
+                #
+                # A naive approach would be to repeatedly call
+                # QCoreApplication::exec(), using a timer to quit after a
+                # short amount of time. Unfortunately, QCoreApplication
+                # emits an aboutToQuit signal before stopping, which has
+                # the undesirable effect of closing all modal windows.
+                #
+                # To work around this problem, we instead create a
+                # QEventLoop and call QEventLoop::exec(). Other than
+                # setting some state variables which do not seem to be
+                # used anywhere, the only thing QCoreApplication adds is
+                # the aboutToQuit signal which is precisely what we are
+                # trying to avoid.
                 timer = QtCore.QTimer()
-                timer.timeout.connect(app.quit)
+                event_loop = QtCore.QEventLoop()
+                timer.timeout.connect(event_loop.quit)
                 while not stdin_ready():
                     timer.start(50)
-                    app.exec_()
+                    event_loop.exec_()
                     timer.stop()
         except KeyboardInterrupt:
             ignore_CTRL_C()

IPython/parallel/apps/baseapp.py

@@ -169,8 +169,13 b' class BaseParallelApplication(BaseIPythonApplication):'
         log_dir = self.profile_dir.log_dir
         if self.clean_logs:
             for f in os.listdir(log_dir):
-                if re.match(r'%s-\d+\.(log|err|out)'%self.name,f):
-                    os.remove(os.path.join(log_dir, f))
+                if re.match(r'%s-\d+\.(log|err|out)' % self.name, f):
+                    try:
+                        os.remove(os.path.join(log_dir, f))
+                    except (OSError, IOError):
+                        # probably just conflict from sibling process
+                        # already removing it
+                        pass
         if self.log_to_file:
             # Start logging to the new log file
             log_filename = self.name + u'-' + str(os.getpid()) + u'.log'

IPython/parallel/apps/ipengineapp.py

@@ -41,6 +41,7 b' from IPython.zmq.ipkernel import Kernel, IPKernelApp'
 from IPython.zmq.session import (
     Session, session_aliases, session_flags
 )
+from IPython.zmq.zmqshell import ZMQInteractiveShell
 
 from IPython.config.configurable import Configurable
 
@@ -143,7 +144,7 b' class IPEngineApp(BaseParallelApplication):'
     description = _description
     examples = _examples
     config_file_name = Unicode(default_config_file_name)
-    classes = List([ProfileDir, Session, EngineFactory, Kernel, MPI])
+    classes = List([ZMQInteractiveShell, ProfileDir, Session, EngineFactory, Kernel, MPI])
 
     startup_script = Unicode(u'', config=True,
         help='specify a script to be run at startup')

IPython/parallel/apps/launcher.py

@@ -650,18 +650,27 b' class SSHClusterLauncher(SSHLauncher):'
         
         If not specified, use calling profile, stripping out possible leading homedir.
         """)
-
-    def _remote_profile_dir_default(self):
-        """turns /home/you/.ipython/profile_foo into .ipython/profile_foo
-        """
+    
+    def _profile_dir_changed(self, name, old, new):
+        if not self.remote_profile_dir:
+            # trigger remote_profile_dir_default logic again,
+            # in case it was already triggered before profile_dir was set
+            self.remote_profile_dir = self._strip_home(new)
+    
+    @staticmethod
+    def _strip_home(path):
+        """turns /home/you/.ipython/profile_foo into .ipython/profile_foo"""
         home = get_home_dir()
         if not home.endswith('/'):
             home = home+'/'
         
-        if self.profile_dir.startswith(home):
-            return self.profile_dir[len(home):]
+        if path.startswith(home):
+            return path[len(home):]
         else:
-            return self.profile_dir
+            return path
+
+    def _remote_profile_dir_default(self):
+        return self._strip_home(self.profile_dir)
     
     def _cluster_id_changed(self, name, old, new):
         if new:

IPython/parallel/client/client.py

@@ -418,7 +418,7 b' class Client(HasTraits):'
         location = cfg.setdefault('location', None)
         
         proto,addr = cfg['interface'].split('://')
-        addr = util.disambiguate_ip_address(addr)
+        addr = util.disambiguate_ip_address(addr, location)
         cfg['interface'] = "%s://%s" % (proto, addr)
         
         # turn interface,port into full urls:
@@ -705,12 +705,9 b' class Client(HasTraits):'
             except:
                 content = error.wrap_exception()
             # build a fake message:
-            parent = {}
-            header = {}
-            parent['msg_id'] = msg_id
-            header['engine'] = uuid
-            header['date'] = datetime.now()
-            msg = dict(parent_header=parent, header=header, content=content)
+            msg = self.session.msg('apply_reply', content=content)
+            msg['parent_header']['msg_id'] = msg_id
+            msg['metadata']['engine'] = uuid
             self._handle_apply_reply(msg)
 
     def _handle_execute_reply(self, msg):

IPython/parallel/controller/heartmonitor.py

@@ -19,7 +19,7 b' import time'
 import uuid
 
 import zmq
-from zmq.devices import ThreadDevice
+from zmq.devices import ThreadDevice, ThreadMonitoredQueue
 from zmq.eventloop import ioloop, zmqstream
 
 from IPython.config.configurable import LoggingConfigurable
@@ -39,8 +39,11 b' class Heart(object):'
     You can specify the DEALER's IDENTITY via the optional heart_id argument."""
     device=None
     id=None
-    def __init__(self, in_addr, out_addr, in_type=zmq.SUB, out_type=zmq.DEALER, heart_id=None):
-        self.device = ThreadDevice(zmq.FORWARDER, in_type, out_type)
+    def __init__(self, in_addr, out_addr, mon_addr=None, in_type=zmq.SUB, out_type=zmq.DEALER, mon_type=zmq.PUB, heart_id=None):
+        if mon_addr is None:
+            self.device = ThreadDevice(zmq.FORWARDER, in_type, out_type)
+        else:
+            self.device = ThreadMonitoredQueue(in_type, out_type, mon_type, in_prefix=b"", out_prefix=b"")
         # do not allow the device to share global Context.instance,
         # which is the default behavior in pyzmq > 2.1.10
         self.device.context_factory = zmq.Context
@@ -48,6 +51,8 b' class Heart(object):'
         self.device.daemon=True
         self.device.connect_in(in_addr)
         self.device.connect_out(out_addr)
+        if mon_addr is not None:
+            self.device.connect_mon(mon_addr)
         if in_type == zmq.SUB:
             self.device.setsockopt_in(zmq.SUBSCRIBE, b"")
         if heart_id is None:
@@ -122,7 +127,7 b' class HeartMonitor(LoggingConfigurable):'
         map(self.handle_heart_failure, heartfailures)
         self.on_probation = missed_beats.intersection(self.hearts)
         self.responses = set()
-        # print self.on_probation, self.hearts
+        #print self.on_probation, self.hearts
         # self.log.debug("heartbeat::beat %.3f, %i beating hearts", self.lifetime, len(self.hearts))
         self.pingstream.send(str_to_bytes(str(self.lifetime)))
         # flush stream to force immediate socket send
@@ -165,18 +170,3 b' class HeartMonitor(LoggingConfigurable):'
         else:
             self.log.warn("heartbeat::got bad heartbeat (possibly old?): %s (current=%.3f)", msg[1], self.lifetime)
 
-
-if __name__ == '__main__':
-    loop = ioloop.IOLoop.instance()
-    context = zmq.Context()
-    pub = context.socket(zmq.PUB)
-    pub.bind('tcp://127.0.0.1:5555')
-    router = context.socket(zmq.ROUTER)
-    router.bind('tcp://127.0.0.1:5556')
-
-    outstream = zmqstream.ZMQStream(pub, loop)
-    instream = zmqstream.ZMQStream(router, loop)
-
-    hb = HeartMonitor(loop, outstream, instream)
-
-    loop.start()

IPython/parallel/controller/hub.py

@@ -904,7 +904,7 b' class Hub(SessionFactory):'
 
         self.log.debug("registration::register_engine(%i, %r)", eid, uuid)
 
-        content = dict(id=eid,status='ok')
+        content = dict(id=eid,status='ok',hb_period=self.heartmonitor.period)
         # check if requesting available IDs:
         if cast_bytes(uuid) in self.by_ident:
             try:

IPython/parallel/engine/engine.py

@@ -25,7 +25,7 b' from zmq.eventloop import ioloop, zmqstream'
 from IPython.external.ssh import tunnel
 # internal
 from IPython.utils.traitlets import (
-    Instance, Dict, Integer, Type, CFloat, Unicode, CBytes, Bool
+    Instance, Dict, Integer, Type, Float, Integer, Unicode, CBytes, Bool
 )
 from IPython.utils.py3compat import cast_bytes
 
@@ -50,9 +50,14 b' class EngineFactory(RegistrationFactory):'
         help="""The location (an IP address) of the controller.  This is
         used for disambiguating URLs, to determine whether
         loopback should be used to connect or the public address.""")
-    timeout=CFloat(5, config=True,
+    timeout=Float(5.0, config=True,
         help="""The time (in seconds) to wait for the Controller to respond
         to registration requests before giving up.""")
+    max_heartbeat_misses=Integer(50, config=True,
+        help="""The maximum number of times a check for the heartbeat ping of a 
+        controller can be missed before shutting down the engine.
+        
+        If set to 0, the check is disabled.""")
     sshserver=Unicode(config=True,
         help="""The SSH server to use for tunneling connections to the Controller.""")
     sshkey=Unicode(config=True,
@@ -60,12 +65,23 b' class EngineFactory(RegistrationFactory):'
     paramiko=Bool(sys.platform == 'win32', config=True,
         help="""Whether to use paramiko instead of openssh for tunnels.""")
 
+
     # not configurable:
     connection_info = Dict()
     user_ns = Dict()
     id = Integer(allow_none=True)
     registrar = Instance('zmq.eventloop.zmqstream.ZMQStream')
     kernel = Instance(Kernel)
+    hb_check_period=Integer()
+    
+    # States for the heartbeat monitoring
+    # Initial values for monitored and pinged must satisfy "monitored > pinged == False" so that 
+    # during the first check no "missed" ping is reported. Must be floats for Python 3 compatibility.
+    _hb_last_pinged = 0.0
+    _hb_last_monitored = 0.0
+    _hb_missed_beats = 0
+    # The zmq Stream which receives the pings from the Heart
+    _hb_listener = None
 
     bident = CBytes()
     ident = Unicode()
@@ -134,6 +150,11 b' class EngineFactory(RegistrationFactory):'
         # print (self.session.key)
         self.session.send(self.registrar, "registration_request", content=content)
 
+    def _report_ping(self, msg):
+        """Callback for when the heartmonitor.Heart receives a ping"""
+        #self.log.debug("Received a ping: %s", msg)
+        self._hb_last_pinged = time.time()
+
     def complete_registration(self, msg, connect, maybe_tunnel):
         # print msg
         self._abort_dc.stop()
@@ -156,8 +177,20 b' class EngineFactory(RegistrationFactory):'
             # possibly forward hb ports with tunnels
             hb_ping = maybe_tunnel(url('hb_ping'))
             hb_pong = maybe_tunnel(url('hb_pong'))
+            
+            hb_monitor = None
+            if self.max_heartbeat_misses > 0:
+                # Add a monitor socket which will record the last time a ping was seen
+                mon = self.context.socket(zmq.SUB)
+                mport = mon.bind_to_random_port('tcp://127.0.0.1')
+                mon.setsockopt(zmq.SUBSCRIBE, b"")
+                self._hb_listener = zmqstream.ZMQStream(mon, self.loop)
+                self._hb_listener.on_recv(self._report_ping)
+            
+            
+                hb_monitor = "tcp://127.0.0.1:%i"%mport
 
-            heart = Heart(hb_ping, hb_pong, heart_id=identity)
+            heart = Heart(hb_ping, hb_pong, hb_monitor , heart_id=identity)
             heart.start()
 
             # create Shell Connections (MUX, Task, etc.):
@@ -201,6 +234,20 b' class EngineFactory(RegistrationFactory):'
             
             self.kernel.shell.display_pub.topic = cast_bytes('engine.%i.displaypub' % self.id)
             
+                
+            # periodically check the heartbeat pings of the controller
+            # Should be started here and not in "start()" so that the right period can be taken 
+            # from the hubs HeartBeatMonitor.period
+            if self.max_heartbeat_misses > 0:
+                # Use a slightly bigger check period than the hub signal period to not warn unnecessary 
+                self.hb_check_period = int(content['hb_period'])+10
+                self.log.info("Starting to monitor the heartbeat signal from the hub every %i ms." , self.hb_check_period)
+                self._hb_reporter = ioloop.PeriodicCallback(self._hb_monitor, self.hb_check_period, self.loop)
+                self._hb_reporter.start()
+            else:
+                self.log.info("Monitoring of the heartbeat signal from the hub is not enabled.")
+
+            
             # FIXME: This is a hack until IPKernelApp and IPEngineApp can be fully merged
             app = IPKernelApp(config=self.config, shell=self.kernel.shell, kernel=self.kernel, log=self.log)
             app.init_profile_dir()
@@ -228,9 +275,29 b' class EngineFactory(RegistrationFactory):'
         time.sleep(1)
         sys.exit(255)
 
+    def _hb_monitor(self):
+        """Callback to monitor the heartbeat from the controller"""
+        self._hb_listener.flush()
+        if self._hb_last_monitored > self._hb_last_pinged:
+            self._hb_missed_beats += 1
+            self.log.warn("No heartbeat in the last %s ms (%s time(s) in a row).", self.hb_check_period, self._hb_missed_beats)
+        else:
+            #self.log.debug("Heartbeat received (after missing %s beats).", self._hb_missed_beats)
+            self._hb_missed_beats = 0
+
+        if self._hb_missed_beats >= self.max_heartbeat_misses:
+            self.log.fatal("Maximum number of heartbeats misses reached (%s times %s ms), shutting down.",
+                           self.max_heartbeat_misses, self.hb_check_period)
+            self.session.send(self.registrar, "unregistration_request", content=dict(id=self.id))
+            self.loop.stop()
+
+        self._hb_last_monitored = time.time()
+            
+        
     def start(self):
         dc = ioloop.DelayedCallback(self.register, 0, self.loop)
         dc.start()
         self._abort_dc = ioloop.DelayedCallback(self.abort, self.timeout*1000, self.loop)
         self._abort_dc.start()
 
+

IPython/parallel/tests/test_lbview.py

@@ -21,6 +21,7 b' import time'
 
 import zmq
 from nose import SkipTest
+from nose.plugins.attrib import attr
 
 from IPython import parallel  as pmod
 from IPython.parallel import error
@@ -38,9 +39,9 b' class TestLoadBalancedView(ClusterTestCase):'
         ClusterTestCase.setUp(self)
         self.view = self.client.load_balanced_view()
 
+    @attr('crash')
     def test_z_crash_task(self):
         """test graceful handling of engine death (balanced)"""
-        raise SkipTest("crash tests disabled, due to undesirable crash reports")
         # self.add_engines(1)
         ar = self.view.apply_async(crash)
         self.assertRaisesRemote(error.EngineError, ar.get, 10)

IPython/parallel/tests/test_view.py

@@ -24,6 +24,7 b' from StringIO import StringIO'
 
 import zmq
 from nose import SkipTest
+from nose.plugins.attrib import attr
 
 from IPython.testing import decorators as dec
 from IPython.testing.ipunittest import ParametricTestCase
@@ -51,9 +52,9 b' class TestView(ClusterTestCase, ParametricTestCase):'
             time.sleep(2)
         super(TestView, self).setUp()
 
+    @attr('crash')
     def test_z_crash_mux(self):
         """test graceful handling of engine death (direct)"""
-        raise SkipTest("crash tests disabled, due to undesirable crash reports")
         # self.add_engines(1)
         eid = self.client.ids[-1]
         ar = self.client[eid].apply_async(crash)
@@ -700,4 +701,22 b' class TestView(ClusterTestCase, ParametricTestCase):'
         drank = amr.get(5)
         self.assertEqual(drank, [ r*2 for r in ranks ])
         
+    def test_nested_getitem_setitem(self):
+        """get and set with view['a.b']"""
+        view = self.client[-1]
+        view.execute('\n'.join([
+            'class A(object): pass',
+            'a = A()',
+            'a.b = 128',
+            ]), block=True)
+        ra = pmod.Reference('a')
+
+        r = view.apply_sync(lambda x: x.b, ra)
+        self.assertEqual(r, 128)
+        self.assertEqual(view['a.b'], 128)
+
+        view['a.b'] = 0
 
+        r = view.apply_sync(lambda x: x.b, ra)
+        self.assertEqual(r, 0)
+        self.assertEqual(view['a.b'], 0)

IPython/parallel/util.py

@@ -229,21 +229,24 b' def interactive(f):'
 @interactive
 def _push(**ns):
     """helper method for implementing `client.push` via `client.apply`"""
-    globals().update(ns)
+    user_ns = globals()
+    tmp = '_IP_PUSH_TMP_'
+    while tmp in user_ns:
+        tmp = tmp + '_'
+    try:
+        for name, value in ns.iteritems():
+            user_ns[tmp] = value
+            exec "%s = %s" % (name, tmp) in user_ns
+    finally:
+        user_ns.pop(tmp, None)
 
 @interactive
 def _pull(keys):
     """helper method for implementing `client.pull` via `client.apply`"""
-    user_ns = globals()
     if isinstance(keys, (list,tuple, set)):
-        for key in keys:
-            if key not in user_ns:
-                raise NameError("name '%s' is not defined"%key)
-        return map(user_ns.get, keys)
+        return map(lambda key: eval(key, globals()), keys)
     else:
-        if keys not in user_ns:
-            raise NameError("name '%s' is not defined"%keys)
-        return user_ns.get(keys)
+        return eval(keys, globals())
 
 @interactive
 def _execute(code):

IPython/testing/iptest.py

@@ -396,6 +396,8 b' class IPTester(object):'
         """Run the stored commands"""
         try:
             retcode = self._run_cmd()
+        except KeyboardInterrupt:
+            return -signal.SIGINT
         except:
             import traceback
             traceback.print_exc()
@@ -412,17 +414,22 b' class IPTester(object):'
                 continue # process is already dead
 
             try:
-                print('Cleaning stale PID: %d' % subp.pid)
+                print('Cleaning up stale PID: %d' % subp.pid)
                 subp.kill()
             except: # (OSError, WindowsError) ?
                 # This is just a best effort, if we fail or the process was
                 # really gone, ignore it.
                 pass
+            else:
+                for i in range(10):
+                    if subp.poll() is None:
+                        time.sleep(0.1)
+                    else:
+                        break
 
             if subp.poll() is None:
                 # The process did not die...
-                print('... failed. Manual cleanup may be required.'
-                      % subp.pid)
+                print('... failed. Manual cleanup may be required.')
 
 def make_runners(inc_slow=False):
     """Define the top-level packages that need to be tested.
@@ -476,6 +483,8 b' def run_iptest():'
                         # setuptools devs refuse to fix this problem!
                         '--exe',
                         ]
+    if '-a' not in argv and '-A' not in argv:
+        argv = argv + ['-a', '!crash']
 
     if nose.__version__ >= '0.11':
         # I don't fully understand why we need this one, but depending on what
@@ -533,6 +542,9 b' def run_iptestall(inc_slow=False):'
             res = runner.run()
             if res:
                 failed.append( (name, runner) )
+                if res == -signal.SIGINT:
+                    print("Interrupted")
+                    break
     finally:
         os.chdir(curdir)
     t_end = time.time()

IPython/utils/PyColorize.py

@@ -30,6 +30,8 b' formatting (which is the hard part).'
 """
 from __future__ import print_function
 
+from __future__ import unicode_literals
+
 __all__ = ['ANSICodeColors','Parser']
 
 _scheme_default = 'Linux'

IPython/utils/openpy.py

@@ -7,7 +7,7 b' Much of the code is taken from the tokenize module in Python 3.2.'
 from __future__ import absolute_import
 
 import io
-from io import TextIOWrapper
+from io import TextIOWrapper, BytesIO
 import re
 import urllib
 
@@ -120,6 +120,32 b' except ImportError:'
         text.mode = 'r'
         return text   
 
+def source_to_unicode(txt, errors='replace', skip_encoding_cookie=True):
+    """Converts a bytes string with python source code to unicode.
+
+    Unicode strings are passed through unchanged. Byte strings are checked
+    for the python source file encoding cookie to determine encoding.
+    txt can be either a bytes buffer or a string containing the source
+    code.
+    """
+    if isinstance(txt, unicode):
+        return txt
+    if isinstance(txt, bytes):
+        buffer = BytesIO(txt)
+    else:
+        buffer = txt
+    try:
+        encoding, _ = detect_encoding(buffer.readline)
+    except SyntaxError:
+        encoding = "ascii"
+    buffer.seek(0)
+    text = TextIOWrapper(buffer, encoding, errors=errors, line_buffering=True)
+    text.mode = 'r'
+    if skip_encoding_cookie:
+        return u"".join(strip_encoding_cookie(text))
+    else:
+        return text.read()
+
 def strip_encoding_cookie(filelike):
     """Generator to pull lines from a text-mode file, skipping the encoding
     cookie if it is found in the first two lines.
@@ -181,12 +207,13 b" def read_py_url(url, errors='replace', skip_encoding_cookie=True):"
     """
     response = urllib.urlopen(url)
     buffer = io.BytesIO(response.read())
-    encoding, lines = detect_encoding(buffer.readline)
-    buffer.seek(0)
-    text = TextIOWrapper(buffer, encoding, errors=errors, line_buffering=True)
-    text.mode = 'r'
-    if skip_encoding_cookie:
-        return "".join(strip_encoding_cookie(text))
-    else:
-        return text.read()
+    return source_to_unicode(buffer, errors, skip_encoding_cookie)
 
+def _list_readline(x):
+    """Given a list, returns a readline() function that returns the next element
+    with each call.
+    """
+    x = iter(x)
+    def readline():
+        return next(x)
+    return readline

IPython/utils/path.py

@@ -19,6 +19,7 b' import sys'
 import tempfile
 import warnings
 from hashlib import md5
+import glob
 
 import IPython
 from IPython.testing.skipdoctest import skip_doctest
@@ -355,6 +356,31 b' def expand_path(s):'
     return s
 
 
+def unescape_glob(string):
+    """Unescape glob pattern in `string`."""
+    def unescape(s):
+        for pattern in '*[]!?':
+            s = s.replace(r'\{0}'.format(pattern), pattern)
+        return s
+    return '\\'.join(map(unescape, string.split('\\\\')))
+
+
+def shellglob(args):
+    """
+    Do glob expansion for each element in `args` and return a flattened list.
+
+    Unmatched glob pattern will remain as-is in the returned list.
+
+    """
+    expanded = []
+    # Do not unescape backslash in Windows as it is interpreted as
+    # path separator:
+    unescape = unescape_glob if sys.platform != 'win32' else lambda x: x
+    for a in args:
+        expanded.extend(glob.glob(a) or [unescape(a)])
+    return expanded
+
+
 def target_outdated(target,deps):
     """Determine whether a target is out of date.
 

IPython/utils/pickleutil.py

@@ -98,12 +98,8 b' class CannedFunction(CannedObject):'
     def get_object(self, g=None):
         # try to load function back into its module:
         if not self.module.startswith('__'):
-            try:
-                __import__(self.module)
-            except ImportError:
-                pass
-            else:
-                g = sys.modules[self.module].__dict__
+            __import__(self.module)
+            g = sys.modules[self.module].__dict__
 
         if g is None:
             g = {}

IPython/utils/rlineimpl.py

@@ -73,7 +73,7 b" if have_readline and hasattr(_rl, 'rlmain'):"
                 line = lineobj.TextLine(line)
             return _rl.add_history(line)
 
-if sys.platform == 'win32' and have_readline:
+if (sys.platform == 'win32' or sys.platform == 'cli') and have_readline:
     try:
         _outputfile=_rl.GetOutputFile()
     except AttributeError:

IPython/utils/tempdir.py

@@ -3,14 +3,14 b''
 This is copied from the stdlib and will be standard in Python 3.2 and onwards.
 """
 
+import os as _os
+
 # This code should only be used in Python versions < 3.2, since after that we
 # can rely on the stdlib itself.
 try:
     from tempfile import TemporaryDirectory
 
 except ImportError:
-    
-    import os as _os
     from tempfile import mkdtemp, template
 
     class TemporaryDirectory(object):
@@ -74,3 +74,33 b' except ImportError:'
                 self._rmdir(path)
             except self._os_error:
                 pass
+
+
+class NamedFileInTemporaryDirectory(object):
+
+    def __init__(self, filename, mode='w+b', bufsize=-1, **kwds):
+        """
+        Open a file named `filename` in a temporary directory.
+
+        This context manager is preferred over `NamedTemporaryFile` in
+        stdlib `tempfile` when one needs to reopen the file.
+
+        Arguments `mode` and `bufsize` are passed to `open`.
+        Rest of the arguments are passed to `TemporaryDirectory`.
+
+        """
+        self._tmpdir = TemporaryDirectory(**kwds)
+        path = _os.path.join(self._tmpdir.name, filename)
+        self.file = open(path, mode, bufsize)
+
+    def cleanup(self):
+        self.file.close()
+        self._tmpdir.cleanup()
+
+    __del__ = cleanup
+
+    def __enter__(self):
+        return self.file
+
+    def __exit__(self, type, value, traceback):
+        self.cleanup()

IPython/utils/terminal.py

@@ -81,7 +81,7 b' def _set_term_title_xterm(title):'
 
 if os.name == 'posix':
     TERM = os.environ.get('TERM','')
-    if (TERM == 'xterm') or (TERM == 'xterm-color'):
+    if TERM.startswith('xterm'):
         _set_term_title = _set_term_title_xterm
 
 

IPython/utils/tests/test_path.py

@@ -19,6 +19,7 b' import shutil'
 import sys
 import tempfile
 from io import StringIO
+from contextlib import contextmanager
 
 from os.path import join, abspath, split
 
@@ -32,6 +33,7 b' from IPython.testing.decorators import skip_if_not_win32, skip_win32'
 from IPython.testing.tools import make_tempfile, AssertPrints
 from IPython.utils import path, io
 from IPython.utils import py3compat
+from IPython.utils.tempdir import TemporaryDirectory
 
 # Platform-dependent imports
 try:
@@ -444,3 +446,79 b' def test_unicode_in_filename():'
         path.get_py_filename(u'fooéè.py',  force_win32=False)
     except IOError as ex:
         str(ex)
+
+
+class TestShellGlob(object):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.filenames_start_with_a = map('a{0}'.format, range(3))
+        cls.filenames_end_with_b = map('{0}b'.format, range(3))
+        cls.filenames = cls.filenames_start_with_a + cls.filenames_end_with_b
+        cls.tempdir = TemporaryDirectory()
+        td = cls.tempdir.name
+
+        with cls.in_tempdir():
+            # Create empty files
+            for fname in cls.filenames:
+                open(os.path.join(td, fname), 'w').close()
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.tempdir.cleanup()
+
+    @classmethod
+    @contextmanager
+    def in_tempdir(cls):
+        save = os.getcwdu()
+        try:
+            os.chdir(cls.tempdir.name)
+            yield
+        finally:
+            os.chdir(save)
+
+    def check_match(self, patterns, matches):
+        with self.in_tempdir():
+            # glob returns unordered list. that's why sorted is required.
+            nt.assert_equals(sorted(path.shellglob(patterns)),
+                             sorted(matches))
+
+    def common_cases(self):
+        return [
+            (['*'], self.filenames),
+            (['a*'], self.filenames_start_with_a),
+            (['*c'], ['*c']),
+            (['*', 'a*', '*b', '*c'], self.filenames
+                                      + self.filenames_start_with_a
+                                      + self.filenames_end_with_b
+                                      + ['*c']),
+            (['a[012]'], self.filenames_start_with_a),
+        ]
+
+    @skip_win32
+    def test_match_posix(self):
+        for (patterns, matches) in self.common_cases() + [
+                ([r'\*'], ['*']),
+                ([r'a\*', 'a*'], ['a*'] + self.filenames_start_with_a),
+                ([r'a\[012]'], ['a[012]']),
+                ]:
+            yield (self.check_match, patterns, matches)
+
+    @skip_if_not_win32
+    def test_match_windows(self):
+        for (patterns, matches) in self.common_cases() + [
+                # In windows, backslash is interpreted as path
+                # separator.  Therefore, you can't escape glob
+                # using it.
+                ([r'a\*', 'a*'], [r'a\*'] + self.filenames_start_with_a),
+                ([r'a\[012]'], [r'a\[012]']),
+                ]:
+            yield (self.check_match, patterns, matches)
+
+
+def test_unescape_glob():
+    nt.assert_equals(path.unescape_glob(r'\*\[\!\]\?'), '*[!]?')
+    nt.assert_equals(path.unescape_glob(r'\\*'), r'\*')
+    nt.assert_equals(path.unescape_glob(r'\\\*'), r'\*')
+    nt.assert_equals(path.unescape_glob(r'\\a'), r'\a')
+    nt.assert_equals(path.unescape_glob(r'\a'), r'\a')

IPython/utils/tests/test_traitlets.py

@@ -25,10 +25,11 b' import re'
 import sys
 from unittest import TestCase
 
+import nose.tools as nt
 from nose import SkipTest
 
 from IPython.utils.traitlets import (
-    HasTraits, MetaHasTraits, TraitType, Any, CBytes,
+    HasTraits, MetaHasTraits, TraitType, Any, CBytes, Dict,
     Int, Long, Integer, Float, Complex, Bytes, Unicode, TraitError,
     Undefined, Type, This, Instance, TCPAddress, List, Tuple,
     ObjectName, DottedObjectName, CRegExp
@@ -906,3 +907,14 b' class TestCRegExp(TraitTestBase):'
     _default_value = re.compile(r'')
     _good_values = [r'\d+', re.compile(r'\d+')]
     _bad_values = [r'(', None, ()]
+
+class DictTrait(HasTraits):
+    value = Dict()
+
+def test_dict_assignment():
+    d = dict()
+    c = DictTrait()
+    c.value = d
+    d['a'] = 5
+    nt.assert_equal(d, c.value)
+    nt.assert_true(c.value is d)

IPython/utils/traitlets.py

@@ -117,6 +117,13 b' def repr_type(obj):'
     return msg
 
 
+def is_trait(t):
+    """ Returns whether the given value is an instance or subclass of TraitType.
+    """
+    return (isinstance(t, TraitType) or
+            (isinstance(t, type) and issubclass(t, TraitType)))
+
+
 def parse_notifier_name(name):
     """Convert the name argument to a list of names.
 
@@ -302,8 +309,8 b' class TraitType(object):'
     def __set__(self, obj, value):
         new_value = self._validate(obj, value)
         old_value = self.__get__(obj)
+        obj._trait_values[self.name] = new_value
         if old_value != new_value:
-            obj._trait_values[self.name] = new_value
             obj._notify_trait(self.name, old_value, new_value)
 
     def _validate(self, obj, value):
@@ -920,11 +927,15 b' else:'
         def validate(self, obj, value):
             if isinstance(value, int):
                 return value
-            elif isinstance(value, long):
+            if isinstance(value, long):
                 # downcast longs that fit in int:
                 # note that int(n > sys.maxint) returns a long, so
                 # we don't need a condition on this cast
                 return int(value)
+            if sys.platform == "cli":
+                from System import Int64
+                if isinstance(value, Int64):
+                    return int(value)
             self.error(obj, value)
 
 
@@ -1165,10 +1176,8 b' class Container(Instance):'
             further keys for extensions to the Trait (e.g. config)
 
         """
-        istrait = lambda t: isinstance(t, type) and issubclass(t, TraitType)
-
         # allow List([values]):
-        if default_value is None and not istrait(trait):
+        if default_value is None and not is_trait(trait):
             default_value = trait
             trait = None
 
@@ -1179,8 +1188,8 b' class Container(Instance):'
         else:
             raise TypeError('default value of %s was %s' %(self.__class__.__name__, default_value))
 
-        if istrait(trait):
-            self._trait = trait()
+        if is_trait(trait):
+            self._trait = trait() if isinstance(trait, type) else trait
             self._trait.name = 'element'
         elif trait is not None:
             raise TypeError("`trait` must be a Trait or None, got %s"%repr_type(trait))
@@ -1220,7 +1229,7 b' class List(Container):'
     """An instance of a Python list."""
     klass = list
 
-    def __init__(self, trait=None, default_value=None, minlen=0, maxlen=sys.maxint,
+    def __init__(self, trait=None, default_value=None, minlen=0, maxlen=sys.maxsize,
                 allow_none=True, **metadata):
         """Create a List trait type from a list, set, or tuple.
 
@@ -1249,7 +1258,7 b' class List(Container):'
         minlen : Int [ default 0 ]
             The minimum length of the input list
 
-        maxlen : Int [ default sys.maxint ]
+        maxlen : Int [ default sys.maxsize ]
             The maximum length of the input list
 
         allow_none : Bool [ default True ]
@@ -1327,10 +1336,8 b' class Tuple(Container):'
         default_value = metadata.pop('default_value', None)
         allow_none = metadata.pop('allow_none', True)
 
-        istrait = lambda t: isinstance(t, type) and issubclass(t, TraitType)
-
         # allow Tuple((values,)):
-        if len(traits) == 1 and default_value is None and not istrait(traits[0]):
+        if len(traits) == 1 and default_value is None and not is_trait(traits[0]):
             default_value = traits[0]
             traits = ()
 
@@ -1343,7 +1350,7 b' class Tuple(Container):'
 
         self._traits = []
         for trait in traits:
-            t = trait()
+            t = trait() if isinstance(trait, type) else trait
             t.name = 'element'
             self._traits.append(t)
 

IPython/zmq/entry_point.py

@@ -21,7 +21,7 b' from IPython.utils.py3compat import bytes_to_str'
 from parentpoller import ParentPollerWindows
 
 def write_connection_file(fname=None, shell_port=0, iopub_port=0, stdin_port=0, hb_port=0,
-                         ip=LOCALHOST, key=b''):
+                         ip=LOCALHOST, key=b'', transport='tcp'):
     """Generates a JSON config file, including the selection of random ports.
     
     Parameters
@@ -54,17 +54,26 b' def write_connection_file(fname=None, shell_port=0, iopub_port=0, stdin_port=0, '
         fname = tempfile.mktemp('.json')
     
     # Find open ports as necessary.
+    
     ports = []
     ports_needed = int(shell_port <= 0) + int(iopub_port <= 0) + \
                    int(stdin_port <= 0) + int(hb_port <= 0)
-    for i in xrange(ports_needed):
-        sock = socket.socket()
-        sock.bind(('', 0))
-        ports.append(sock)
-    for i, sock in enumerate(ports):
-        port = sock.getsockname()[1]
-        sock.close()
-        ports[i] = port
+    if transport == 'tcp':
+        for i in range(ports_needed):
+            sock = socket.socket()
+            sock.bind(('', 0))
+            ports.append(sock)
+        for i, sock in enumerate(ports):
+            port = sock.getsockname()[1]
+            sock.close()
+            ports[i] = port
+    else:
+        N = 1
+        for i in range(ports_needed):
+            while os.path.exists("%s-%s" % (ip, str(N))):
+                N += 1
+            ports.append(N)
+            N += 1
     if shell_port <= 0:
         shell_port = ports.pop(0)
     if iopub_port <= 0:
@@ -81,6 +90,7 b' def write_connection_file(fname=None, shell_port=0, iopub_port=0, stdin_port=0, '
               )
     cfg['ip'] = ip
     cfg['key'] = bytes_to_str(key)
+    cfg['transport'] = transport
     
     with open(fname, 'w') as f:
         f.write(json.dumps(cfg, indent=2))
@@ -179,8 +189,12 b' def base_launch_kernel(code, fname, stdin=None, stdout=None, stderr=None,'
                          creationflags=512, # CREATE_NEW_PROCESS_GROUP
                          stdin=_stdin, stdout=_stdout, stderr=_stderr)
         else:
-            from _subprocess import DuplicateHandle, GetCurrentProcess, \
-                DUPLICATE_SAME_ACCESS
+            try:
+                from _winapi import DuplicateHandle, GetCurrentProcess, \
+                    DUPLICATE_SAME_ACCESS
+            except:
+                from _subprocess import DuplicateHandle, GetCurrentProcess, \
+                    DUPLICATE_SAME_ACCESS
             pid = GetCurrentProcess()
             handle = DuplicateHandle(pid, pid, pid, 0,
                                      True, # Inheritable by new processes.

IPython/zmq/heartbeat.py

@@ -12,6 +12,7 b''
 # Imports
 #-----------------------------------------------------------------------------
 
+import os
 import socket
 import sys
 from threading import Thread
@@ -28,21 +29,28 b' from IPython.utils.localinterfaces import LOCALHOST'
 class Heartbeat(Thread):
     "A simple ping-pong style heartbeat that runs in a thread."
 
-    def __init__(self, context, addr=(LOCALHOST, 0)):
+    def __init__(self, context, addr=('tcp', LOCALHOST, 0)):
         Thread.__init__(self)
         self.context = context
-        self.ip, self.port = addr
+        self.transport, self.ip, self.port = addr
         if self.port == 0:
-            s = socket.socket()
-            # '*' means all interfaces to 0MQ, which is '' to socket.socket
-            s.bind(('' if self.ip == '*' else self.ip, 0))
-            self.port = s.getsockname()[1]
-            s.close()
+            if addr[0] == 'tcp':
+                s = socket.socket()
+                # '*' means all interfaces to 0MQ, which is '' to socket.socket
+                s.bind(('' if self.ip == '*' else self.ip, 0))
+                self.port = s.getsockname()[1]
+                s.close()
+            elif addr[0] == 'ipc':
+                while os.path.exists(self.ip + '-' + self.port):
+                    self.port = self.port + 1
+            else:
+                raise ValueError("Unrecognized zmq transport: %s" % addr[0])
         self.addr = (self.ip, self.port)
         self.daemon = True
 
     def run(self):
         self.socket = self.context.socket(zmq.REP)
-        self.socket.bind('tcp://%s:%i' % self.addr)
+        c = ':' if self.transport == 'tcp' else '-'
+        self.socket.bind('%s://%s' % (self.transport, self.ip) + c + str(self.port))
         zmq.device(zmq.FORWARDER, self.socket, self.socket)
 

IPython/zmq/iostream.py

@@ -4,7 +4,7 b' from io import StringIO'
 
 from session import extract_header, Message
 
-from IPython.utils import io, text, encoding
+from IPython.utils import io, text
 from IPython.utils import py3compat
 
 #-----------------------------------------------------------------------------
@@ -23,6 +23,7 b' class OutStream(object):'
     topic=None
 
     def __init__(self, session, pub_socket, name):
+        self.encoding = 'UTF-8'
         self.session = session
         self.pub_socket = pub_socket
         self.name = name
@@ -73,9 +74,8 b' class OutStream(object):'
         else:
             # Make sure that we're handling unicode
             if not isinstance(string, unicode):
-                enc = encoding.DEFAULT_ENCODING
-                string = string.decode(enc, 'replace')
-            
+                string = string.decode(self.encoding, 'replace')
+
             self._buffer.write(string)
             current_time = time.time()
             if self._start <= 0:

IPython/zmq/ipkernel.py

@@ -486,9 +486,10 b' class Kernel(Configurable):'
                                                         raw=raw, output=output)
 
         elif hist_access_type == 'search':
+            n = parent['content'].get('n')
             pattern = parent['content']['pattern']
             hist = self.shell.history_manager.search(pattern, raw=raw,
-                                                     output=output) 
+                                                     output=output, n=n)
 
         else:
             hist = []

IPython/zmq/kernelapp.py

@@ -35,8 +35,10 b' from IPython.utils import io'
 from IPython.utils.localinterfaces import LOCALHOST
 from IPython.utils.path import filefind
 from IPython.utils.py3compat import str_to_bytes
-from IPython.utils.traitlets import (Any, Instance, Dict, Unicode, Integer, Bool,
-                                        DottedObjectName)
+from IPython.utils.traitlets import (
+    Any, Instance, Dict, Unicode, Integer, Bool, CaselessStrEnum,
+    DottedObjectName,
+)
 from IPython.utils.importstring import import_item
 # local imports
 from IPython.zmq.entry_point import write_connection_file
@@ -109,6 +111,7 b' class KernelApp(BaseIPythonApplication):'
         self.config_file_specified = False
         
     # connection info:
+    transport = CaselessStrEnum(['tcp', 'ipc'], default_value='tcp', config=True)
     ip = Unicode(LOCALHOST, config=True,
         help="Set the IP or interface on which the kernel will listen.")
     hb_port = Integer(0, config=True, help="set the heartbeat port [default: random]")
@@ -154,11 +157,12 b' class KernelApp(BaseIPythonApplication):'
             self.poller = ParentPollerUnix()
 
     def _bind_socket(self, s, port):
-        iface = 'tcp://%s' % self.ip
-        if port <= 0:
+        iface = '%s://%s' % (self.transport, self.ip)
+        if port <= 0 and self.transport == 'tcp':
             port = s.bind_to_random_port(iface)
         else:
-            s.bind(iface + ':%i'%port)
+            c = ':' if self.transport == 'tcp' else '-'
+            s.bind(iface + c + str(port))
         return port
 
     def load_connection_file(self):
@@ -174,6 +178,7 b' class KernelApp(BaseIPythonApplication):'
         with open(fname) as f:
             s = f.read()
         cfg = json.loads(s)
+        self.transport = cfg.get('transport', self.transport)
         if self.ip == LOCALHOST and 'ip' in cfg:
             # not overridden by config or cl_args
             self.ip = cfg['ip']
@@ -191,7 +196,7 b' class KernelApp(BaseIPythonApplication):'
             cf = os.path.join(self.profile_dir.security_dir, self.connection_file)
         else:
             cf = self.connection_file
-        write_connection_file(cf, ip=self.ip, key=self.session.key,
+        write_connection_file(cf, ip=self.ip, key=self.session.key, transport=self.transport,
         shell_port=self.shell_port, stdin_port=self.stdin_port, hb_port=self.hb_port,
         iopub_port=self.iopub_port)
         
@@ -204,6 +209,19 b' class KernelApp(BaseIPythonApplication):'
             os.remove(cf)
         except (IOError, OSError):
             pass
+        
+        self._cleanup_ipc_files()
+    
+    def _cleanup_ipc_files(self):
+        """cleanup ipc files if we wrote them"""
+        if self.transport != 'ipc':
+            return
+        for port in (self.shell_port, self.iopub_port, self.stdin_port, self.hb_port):
+            ipcfile = "%s-%i" % (self.ip, port)
+            try:
+                os.remove(ipcfile)
+            except (IOError, OSError):
+                pass
     
     def init_connection_file(self):
         if not self.connection_file:
@@ -238,7 +256,7 b' class KernelApp(BaseIPythonApplication):'
         # heartbeat doesn't share context, because it mustn't be blocked
         # by the GIL, which is accessed by libzmq when freeing zero-copy messages
         hb_ctx = zmq.Context()
-        self.heartbeat = Heartbeat(hb_ctx, (self.ip, self.hb_port))
+        self.heartbeat = Heartbeat(hb_ctx, (self.transport, self.ip, self.hb_port))
         self.hb_port = self.heartbeat.port
         self.log.debug("Heartbeat REP Channel on port: %i"%self.hb_port)
         self.heartbeat.start()

IPython/zmq/kernelmanager.py

@@ -37,7 +37,7 b' from zmq.eventloop import ioloop, zmqstream'
 from IPython.config.loader import Config
 from IPython.utils.localinterfaces import LOCALHOST, LOCAL_IPS
 from IPython.utils.traitlets import (
-    HasTraits, Any, Instance, Type, Unicode, Integer, Bool
+    HasTraits, Any, Instance, Type, Unicode, Integer, Bool, CaselessStrEnum
 )
 from IPython.utils.py3compat import str_to_bytes
 from IPython.zmq.entry_point import write_connection_file
@@ -103,7 +103,7 b' class ZMQSocketChannel(Thread):'
             The ZMQ context to use.
         session : :class:`session.Session`
             The session to use.
-        address : tuple
+        address : zmq url
             Standard (ip, port) tuple that the kernel is listening on.
         """
         super(ZMQSocketChannel, self).__init__()
@@ -111,9 +111,11 b' class ZMQSocketChannel(Thread):'
 
         self.context = context
         self.session = session
-        if address[1] == 0:
-            message = 'The port number for a channel cannot be 0.'
-            raise InvalidPortNumber(message)
+        if isinstance(address, tuple):
+            if address[1] == 0:
+                message = 'The port number for a channel cannot be 0.'
+                raise InvalidPortNumber(message)
+            address = "tcp://%s:%i" % address
         self._address = address
         atexit.register(self._notice_exit)
     
@@ -149,10 +151,7 b' class ZMQSocketChannel(Thread):'
 
     @property
     def address(self):
-        """Get the channel's address as an (ip, port) tuple.
-
-        By the default, the address is (localhost, 0), where 0 means a random
-        port.
+        """Get the channel's address as a zmq url string ('tcp://127.0.0.1:5555').
         """
         return self._address
 
@@ -196,7 +195,7 b' class ShellSocketChannel(ZMQSocketChannel):'
         """The thread's main activity.  Call start() instead."""
         self.socket = self.context.socket(zmq.DEALER)
         self.socket.setsockopt(zmq.IDENTITY, self.session.bsession)
-        self.socket.connect('tcp://%s:%i' % self.address)
+        self.socket.connect(self.address)
         self.stream = zmqstream.ZMQStream(self.socket, self.ioloop)
         self.stream.on_recv(self._handle_recv)
         self._run_loop()
@@ -242,15 +241,16 b' class ShellSocketChannel(ZMQSocketChannel):'
             :func:`repr` as values.
 
         user_expressions : dict, optional
-            A dict with string keys and  to pull from the user's
-            namespace.  They will come back as a dict with these names as keys
-            and their :func:`repr` as values.
+            A dict mapping names to expressions to be evaluated in the user's
+            dict. The expression values are returned as strings formatted using
+            :func:`repr`.
+
+        allow_stdin : bool, optional (default self.allow_stdin)
+            Flag for whether the kernel can send stdin requests to frontends.
 
-        allow_stdin : bool, optional
-            Flag for 
-            A dict with string keys and  to pull from the user's
-            namespace.  They will come back as a dict with these names as keys
-            and their :func:`repr` as values.
+            Some frontends (e.g. the Notebook) do not support stdin requests. 
+            If raw_input is called from code executed from such a frontend, a
+            StdinNotImplementedError will be raised.
 
         Returns
         -------
@@ -395,7 +395,7 b' class SubSocketChannel(ZMQSocketChannel):'
         self.socket = self.context.socket(zmq.SUB)
         self.socket.setsockopt(zmq.SUBSCRIBE,b'')
         self.socket.setsockopt(zmq.IDENTITY, self.session.bsession)
-        self.socket.connect('tcp://%s:%i' % self.address)
+        self.socket.connect(self.address)
         self.stream = zmqstream.ZMQStream(self.socket, self.ioloop)
         self.stream.on_recv(self._handle_recv)
         self._run_loop()
@@ -461,7 +461,7 b' class StdInSocketChannel(ZMQSocketChannel):'
         """The thread's main activity.  Call start() instead."""
         self.socket = self.context.socket(zmq.DEALER)
         self.socket.setsockopt(zmq.IDENTITY, self.session.bsession)
-        self.socket.connect('tcp://%s:%i' % self.address)
+        self.socket.connect(self.address)
         self.stream = zmqstream.ZMQStream(self.socket, self.ioloop)
         self.stream.on_recv(self._handle_recv)
         self._run_loop()
@@ -520,7 +520,7 b' class HBSocketChannel(ZMQSocketChannel):'
             self.socket.close()
         self.socket = self.context.socket(zmq.REQ)
         self.socket.setsockopt(zmq.LINGER, 0)
-        self.socket.connect('tcp://%s:%i' % self.address)
+        self.socket.connect(self.address)
         
         self.poller.register(self.socket, zmq.POLLIN)
     
@@ -659,6 +659,10 b' class KernelManager(HasTraits):'
 
     # The addresses for the communication channels.
     connection_file = Unicode('')
+    
+    transport = CaselessStrEnum(['tcp', 'ipc'], default_value='tcp')
+    
+    
     ip = Unicode(LOCALHOST)
     def _ip_changed(self, name, old, new):
         if new == '*':
@@ -747,7 +751,20 b' class KernelManager(HasTraits):'
             self._connection_file_written = False
             try:
                 os.remove(self.connection_file)
-            except OSError:
+            except (IOError, OSError):
+                pass
+            
+            self._cleanup_ipc_files()
+    
+    def _cleanup_ipc_files(self):
+        """cleanup ipc files if we wrote them"""
+        if self.transport != 'ipc':
+            return
+        for port in (self.shell_port, self.iopub_port, self.stdin_port, self.hb_port):
+            ipcfile = "%s-%i" % (self.ip, port)
+            try:
+                os.remove(ipcfile)
+            except (IOError, OSError):
                 pass
     
     def load_connection_file(self):
@@ -755,6 +772,9 b' class KernelManager(HasTraits):'
         with open(self.connection_file) as f:
             cfg = json.loads(f.read())
         
+        from pprint import pprint
+        pprint(cfg)
+        self.transport = cfg.get('transport', 'tcp')
         self.ip = cfg['ip']
         self.shell_port = cfg['shell_port']
         self.stdin_port = cfg['stdin_port']
@@ -767,7 +787,7 b' class KernelManager(HasTraits):'
         if self._connection_file_written:
             return
         self.connection_file,cfg = write_connection_file(self.connection_file,
-            ip=self.ip, key=self.session.key,
+            transport=self.transport, ip=self.ip, key=self.session.key,
             stdin_port=self.stdin_port, iopub_port=self.iopub_port,
             shell_port=self.shell_port, hb_port=self.hb_port)
         # write_connection_file also sets default ports:
@@ -794,7 +814,7 b' class KernelManager(HasTraits):'
         **kw : optional
              See respective options for IPython and Python kernels.
         """
-        if self.ip not in LOCAL_IPS:
+        if self.transport == 'tcp' and self.ip not in LOCAL_IPS:
             raise RuntimeError("Can only launch a kernel on a local interface. "
                                "Make sure that the '*_address' attributes are "
                                "configured properly. "
@@ -811,8 +831,9 b' class KernelManager(HasTraits):'
         self.kernel = launch_kernel(fname=self.connection_file, **kw)
 
     def shutdown_kernel(self, restart=False):
-        """ Attempts to the stop the kernel process cleanly. If the kernel
-        cannot be stopped, it is killed, if possible.
+        """ Attempts to the stop the kernel process cleanly. 
+
+        If the kernel cannot be stopped and the kernel is local, it is killed.
         """
         # FIXME: Shutdown does not work on Windows due to ZMQ errors!
         if sys.platform == 'win32':
@@ -893,13 +914,17 b' class KernelManager(HasTraits):'
         return self.kernel is not None
 
     def kill_kernel(self):
-        """ Kill the running kernel. """
+        """ Kill the running kernel.
+
+        This method blocks until the kernel process has terminated.
+        """
         if self.has_kernel:
             # Pause the heart beat channel if it exists.
             if self._hb_channel is not None:
                 self._hb_channel.pause()
 
-            # Attempt to kill the kernel.
+            # Signal the kernel to terminate (sends SIGKILL on Unix and calls
+            # TerminateProcess() on Win32).
             try:
                 self.kernel.kill()
             except OSError as e:
@@ -914,13 +939,18 b' class KernelManager(HasTraits):'
                     from errno import ESRCH
                     if e.errno != ESRCH:
                         raise
+
+            # Block until the kernel terminates.
+            self.kernel.wait()
             self.kernel = None
         else:
             raise RuntimeError("Cannot kill kernel. No kernel is running!")
 
     def interrupt_kernel(self):
-        """ Interrupts the kernel. Unlike ``signal_kernel``, this operation is
-        well supported on all platforms.
+        """ Interrupts the kernel.
+
+        Unlike ``signal_kernel``, this operation is well supported on all
+        platforms.
         """
         if self.has_kernel:
             if sys.platform == 'win32':
@@ -932,8 +962,10 b' class KernelManager(HasTraits):'
             raise RuntimeError("Cannot interrupt kernel. No kernel is running!")
 
     def signal_kernel(self, signum):
-        """ Sends a signal to the kernel. Note that since only SIGTERM is
-        supported on Windows, this function is only useful on Unix systems.
+        """ Sends a signal to the kernel.
+
+        Note that since only SIGTERM is supported on Windows, this function is
+        only useful on Unix systems.
         """
         if self.has_kernel:
             self.kernel.send_signal(signum)
@@ -961,13 +993,21 b' class KernelManager(HasTraits):'
     # Channels used for communication with the kernel:
     #--------------------------------------------------------------------------
 
+    def _make_url(self, port):
+        """make a zmq url with a port"""
+        if self.transport == 'tcp':
+            return "tcp://%s:%i" % (self.ip, port)
+        else:
+            return "%s://%s-%s" % (self.transport, self.ip, port)
+
     @property
     def shell_channel(self):
         """Get the REQ socket channel object to make requests of the kernel."""
         if self._shell_channel is None:
             self._shell_channel = self.shell_channel_class(self.context,
-                                                         self.session,
-                                                         (self.ip, self.shell_port))
+                                                           self.session,
+                                                           self._make_url(self.shell_port),
+            )
         return self._shell_channel
 
     @property
@@ -976,7 +1016,8 b' class KernelManager(HasTraits):'
         if self._sub_channel is None:
             self._sub_channel = self.sub_channel_class(self.context,
                                                        self.session,
-                                                       (self.ip, self.iopub_port))
+                                                       self._make_url(self.iopub_port),
+            )
         return self._sub_channel
 
     @property
@@ -984,8 +1025,9 b' class KernelManager(HasTraits):'
         """Get the REP socket channel object to handle stdin (raw_input)."""
         if self._stdin_channel is None:
             self._stdin_channel = self.stdin_channel_class(self.context,
-                                                       self.session,
-                                                       (self.ip, self.stdin_port))
+                                                           self.session,
+                                                           self._make_url(self.stdin_port),
+            )
         return self._stdin_channel
 
     @property
@@ -994,6 +1036,7 b' class KernelManager(HasTraits):'
         kernel is alive."""
         if self._hb_channel is None:
             self._hb_channel = self.hb_channel_class(self.context,
-                                                       self.session,
-                                                       (self.ip, self.hb_port))
+                                                     self.session,
+                                                     self._make_url(self.hb_port),
+            )
         return self._hb_channel

IPython/zmq/parentpoller.py

@@ -100,7 +100,10 b' class ParentPollerWindows(Thread):'
     def run(self):
         """ Run the poll loop. This method never returns.
         """
-        from _subprocess import WAIT_OBJECT_0, INFINITE
+        try:
+            from _winapi import WAIT_OBJECT_0, INFINITE
+        except ImportError:
+            from _subprocess import WAIT_OBJECT_0, INFINITE
 
         # Build the list of handle to listen on.
         handles = []

IPython/zmq/pylab/backend_inline.py

@@ -10,7 +10,7 b' import sys'
 
 # Third-party imports
 import matplotlib
-from matplotlib.backends.backend_agg import new_figure_manager
+from matplotlib.backends.backend_agg import new_figure_manager, FigureCanvasAgg
 from matplotlib._pylab_helpers import Gcf
 
 # Local imports.
@@ -207,3 +207,9 b' def flush_figures():'
         show._to_draw = []
         show._draw_called = False
 
+
+# Changes to matplotlib in version 1.2 requires a mpl backend to supply a default
+# figurecanvas. This is set here to a Agg canvas
+# See https://github.com/matplotlib/matplotlib/pull/1125
+FigureCanvas = FigureCanvasAgg
+

IPython/zmq/session.py

@@ -43,6 +43,7 b' from zmq.utils import jsonapi'
 from zmq.eventloop.ioloop import IOLoop
 from zmq.eventloop.zmqstream import ZMQStream
 
+import IPython
 from IPython.config.application import Application, boolean_flag
 from IPython.config.configurable import Configurable, LoggingConfigurable
 from IPython.utils.importstring import import_item
@@ -74,7 +75,7 b' def squash_unicode(obj):'
 # globals and defaults
 #-----------------------------------------------------------------------------
 
-
+_version_info_list = list(IPython.version_info)
 # ISO8601-ify datetime objects
 json_packer = lambda obj: jsonapi.dumps(obj, default=date_default)
 json_unpacker = lambda s: extract_dates(jsonapi.loads(s))
@@ -187,6 +188,7 b' class Message(object):'
 
 def msg_header(msg_id, msg_type, username, session):
     date = datetime.now()
+    version = _version_info_list
     return locals()
 
 def extract_header(msg_or_header):

IPython/zmq/zmqshell.py

@@ -38,7 +38,7 b' from IPython.lib.kernel import ('
     get_connection_file, get_connection_info, connect_qtconsole
 )
 from IPython.testing.skipdoctest import skip_doctest
-from IPython.utils import io
+from IPython.utils import io, openpy
 from IPython.utils.jsonutil import json_clean, encode_images
 from IPython.utils.process import arg_split
 from IPython.utils import py3compat
@@ -355,7 +355,9 b' class KernelMagics(Magics):'
 
         cont = open(arg_s).read()
         if arg_s.endswith('.py'):
-            cont = self.shell.pycolorize(cont)
+            cont = self.shell.pycolorize(openpy.read_py_file(arg_s, skip_encoding_cookie=False))
+        else:
+            cont = open(arg_s).read()
         page.page(cont)
 
     more = line_magic('more')(less)

MANIFEST.in

@@ -1,4 +1,5 b''
 include README.rst
+include COPYING.txt
 include ipython.py
 include setupbase.py
 include setupegg.py

docs/examples/lib/example-demo.py

@@ -1,9 +1,12 b''
+# -*- coding: utf-8 -*-
 """A simple interactive demo to illustrate the use of IPython's Demo class.
 
 Any python script can be run as a demo, but that does little more than showing
 it on-screen, syntax-highlighted in one shot.  If you add a little simple
 markup, you can stop at specified intervals and return to the ipython prompt,
 resuming execution later.
+
+This is a unicode test, åäö
 """
 from __future__ import print_function
 

docs/examples/notebooks/Animations_and_Progress.ipynb

@@ -204,25 +204,16 b''
      "collapsed": true,
      "input": [
       "import sys, time\n",
-      "try:\n",
-      "    from IPython.display import clear_output\n",
-      "    have_ipython = True\n",
-      "except ImportError:\n",
-      "    have_ipython = False\n",
       "\n",
       "class ProgressBar:\n",
       "    def __init__(self, iterations):\n",
       "        self.iterations = iterations\n",
       "        self.prog_bar = '[]'\n",
       "        self.fill_char = '*'\n",
-      "        self.width = 40\n",
+      "        self.width = 50\n",
       "        self.__update_amount(0)\n",
-      "        if have_ipython:\n",
-      "            self.animate = self.animate_ipython\n",
-      "        else:\n",
-      "            self.animate = self.animate_noipython\n",
       "\n",
-      "    def animate_ipython(self, iter):\n",
+      "    def animate(self, iter):\n",
       "        print '\\r', self,\n",
       "        sys.stdout.flush()\n",
       "        self.update_iteration(iter + 1)\n",
@@ -254,19 +245,12 b''
      "input": [
       "p = ProgressBar(1000)\n",
       "for i in range(1001):\n",
+      "    time.sleep(0.002)\n",
       "    p.animate(i)"
      ],
      "language": "python",
      "metadata": {},
      "outputs": []
-    },
-    {
-     "cell_type": "code",
-     "collapsed": false,
-     "input": [],
-     "language": "python",
-     "metadata": {},
-     "outputs": []
     }
    ],
    "metadata": {}

docs/source/conf.py

@@ -24,26 +24,7 b' if ON_RTD:'
     # see
     # http://read-the-docs.readthedocs.org/en/latest/faq.html
     tags.add('rtd')
-    class Mock(object):
-        def __init__(self, *args, **kwargs):
-            pass
-
-        def __call__(self, *args, **kwargs):
-            return Mock()
-
-        @classmethod
-        def __getattr__(self, name):
-            if name in ('__file__', '__path__'):
-                return '/dev/null'
-            elif name[0] == name[0].upper():
-                return type(name, (), {})
-            else:
-                return Mock()
-
-    MOCK_MODULES = ['matplotlib', 'matplotlib.sphinxext', 'numpy']
-    for mod_name in MOCK_MODULES:
-        sys.modules[mod_name] = Mock()
-
+    
 # If your extensions are in another directory, add it here. If the directory
 # is relative to the documentation root, use os.path.abspath to make it
 # absolute, like shown here.
@@ -63,9 +44,9 b" execfile('../../IPython/core/release.py',iprelease)"
 # Add any Sphinx extension module names here, as strings. They can be extensions
 # coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
 extensions = [
-    # 'matplotlib.sphinxext.mathmpl',
+    'matplotlib.sphinxext.mathmpl',
     'matplotlib.sphinxext.only_directives',
-    # 'matplotlib.sphinxext.plot_directive',
+    'matplotlib.sphinxext.plot_directive',
     'sphinx.ext.autodoc',
     'sphinx.ext.doctest',
     'inheritance_diagram',

docs/source/config/extensions/index.txt

@@ -43,7 +43,7 b' functions to load and unload it. Here is a template::'
     def load_ipython_extension(ipython):
         # The `ipython` argument is the currently active `InteractiveShell`
         # instance, which can be used in any way. This allows you to register
-        # new magics, plugins or aliases, for example.
+        # new magics or aliases, for example.
 
     def unload_ipython_extension(ipython):
         # If you want your extension to be unloadable, put that logic here.
@@ -70,29 +70,6 b' write extensions, you can also put your extensions in'
 When your extension is ready for general use, please add it to the `extensions
 index <http://wiki.ipython.org/Extensions_Index>`_.
 
-Plugin class
-------------
-
-More advanced extensions might want to subclass :class:`IPython.core.plugin.Plugin`.
-A plugin can have options configured by IPython's main :ref:`configuration
-system <config_overview>`. The code to load and unload it looks like this::
-
-    def load_ipython_extension(ip):
-        """Load the plugin in IPython."""
-        plugin = MyPlugin(shell=ip, config=ip.config)
-        try:
-            ip.plugin_manager.register_plugin('myplugin', plugin)
-        except KeyError:
-            print("Already loaded")
-    
-    def unload_ipython_extension(ip):
-        ip.plugin_manager.unregister_plugin('myplugin')
-
-For examples, see these files:
-
-* :file:`IPython/extensions/autoreload.py`
-* :file:`IPython/extensions/storemagic.py`
-
 .. _bundled_extensions:
 
 Extensions bundled with IPython

docs/source/development/messaging.txt

@@ -627,7 +627,7 b' Message type: ``history_request``::'
       'start' : int,
       'stop' : int,
       
-      # If hist_access_type is 'tail', get the last n cells.
+      # If hist_access_type is 'tail' or 'search', get the last n cells.
       'n' : int,
       
       # If hist_access_type is 'search', get cells matching the specified glob

docs/source/interactive/reference.txt

@@ -337,7 +337,7 b' this is just a summary:'
     * **%pdoc <object>**: Print (or run through a pager if too long) the
       docstring for an object. If the given object is a class, it will
       print both the class and the constructor docstrings.
-    * **%pdef <object>**: Print the definition header for any callable
+    * **%pdef <object>**: Print the call signature for any callable
       object. If the object is a class, print the constructor information.
     * **%psource <object>**: Print (or run through a pager if too long)
       the source code for an object.

docs/source/parallel/parallel_task.txt

@@ -386,19 +386,20 b' weighted: Weighted Two-Bin Random'
 Greedy Assignment
 -----------------
 
-Tasks are assigned greedily as they are submitted. If their dependencies are
+Tasks can be assigned greedily as they are submitted. If their dependencies are
 met, they will be assigned to an engine right away, and multiple tasks can be
 assigned to an engine at a given time. This limit is set with the
-``TaskScheduler.hwm`` (high water mark) configurable:
+``TaskScheduler.hwm`` (high water mark) configurable in your
+:file:`ipcontroller_config.py` config file, with:
 
 .. sourcecode:: python
 
     # the most common choices are:
-    c.TaskSheduler.hwm = 0 # (minimal latency, default in IPython ≤ 0.12)
+    c.TaskSheduler.hwm = 0 # (minimal latency, default in IPython < 0.13)
     # or
-    c.TaskScheduler.hwm = 1 # (most-informed balancing, default in > 0.12)
+    c.TaskScheduler.hwm = 1 # (most-informed balancing, default in ≥ 0.13)
 
-In IPython ≤ 0.12,the default is 0, or no-limit. That is, there is no limit to the number of
+In IPython < 0.13, the default is 0, or no-limit. That is, there is no limit to the number of
 tasks that can be outstanding on a given engine. This greatly benefits the
 latency of execution, because network traffic can be hidden behind computation.
 However, this means that workload is assigned without knowledge of how long
@@ -406,10 +407,10 b' each task might take, and can result in poor load-balancing, particularly for'
 submitting a collection of heterogeneous tasks all at once. You can limit this
 effect by setting hwm to a positive integer, 1 being maximum load-balancing (a
 task will never be waiting if there is an idle engine), and any larger number
-being a compromise between load-balance and latency-hiding.
+being a compromise between load-balancing and latency-hiding.
 
 In practice, some users have been confused by having this optimization on by
-default, and the default value has been changed to 1. This can be slower,
+default, so the default value has been changed to 1 in IPython 0.13. This can be slower,
 but has more obvious behavior and won't result in assigning too many tasks to
 some engines in heterogeneous cases.
 

setup.py

@@ -230,6 +230,7 b" if 'setuptools' in sys.modules:"
     setuptools_extra_args['entry_points'] = find_scripts(True)
     setup_args['extras_require'] = dict(
         parallel = 'pyzmq>=2.1.4',
+        qtconsole = 'pygments',
         zmq = 'pyzmq>=2.1.4',
         doc = 'Sphinx>=0.3',
         test = 'nose>=0.10.1',

setupbase.py

@@ -204,12 +204,12 b' def find_data_files():'
     manpagebase = pjoin('share', 'man', 'man1')
 
     # Simple file lists can be made by hand
-    manpages  = filter(isfile, glob(pjoin('docs','man','*.1.gz')))
+    manpages = [f for f in glob(pjoin('docs','man','*.1.gz')) if isfile(f)]
     if not manpages:
         # When running from a source tree, the manpages aren't gzipped
-        manpages = filter(isfile, glob(pjoin('docs','man','*.1')))
-    igridhelpfiles = filter(isfile,
-                            glob(pjoin('IPython','extensions','igrid_help.*')))
+        manpages = [f for f in glob(pjoin('docs','man','*.1')) if isfile(f)]
+
+    igridhelpfiles = [f for f in glob(pjoin('IPython','extensions','igrid_help.*')) if isfile(f)]
 
     # For nested structures, use the utility above
     example_files = make_dir_struct(

tools/release

@@ -6,6 +6,7 b' This should ONLY be run at real release time.'
 from __future__ import print_function
 
 from toollib import *
+from gh_api import post_download
 
 # Get main ipython dir, this will raise if it doesn't pass some checks
 ipdir = get_ipdir()
@@ -53,6 +54,11 b" sh(sdists + ' upload')"
 cd(distdir)
 print( 'Uploading distribution files...')
 
+for fname in os.listdir('.'):
+    print('uploading %s to GitHub' % fname)
+    desc = "IPython %s source distribution" % version
+    post_download("ipython/ipython", fname, description=desc)
+
 # Make target dir if it doesn't exist
 sh('ssh %s "mkdir -p %s/release/%s" ' % (archive_user, archive_dir, version))
 sh('scp * %s' % release_site)

tools/release_windows.py

@@ -23,20 +23,34 b' except ImportError:'
 
 github = '--github' in sys.argv
 
-cmd_t = "{py} setup.py bdist_wininst --plat-name={plat}"
+cmd_t = "{py} setup.py bdist_wininst"
 
 pypi = '--pypi' in sys.argv
 pypi_cmd_t = "python setup.py upload_wininst -f {fname}"
 
-for py in ['python', 'python3']:
+# Windows Python cannot normally cross-compile,
+# so you must have 4 Pythons to make 4 installers:
+# http://docs.python.org/2/distutils/builtdist.html#cross-compiling-on-windows
+
+pythons = {
+    2: {
+        'win32' : r'C:\\Python27\Python.exe',
+        'win-amd64': r'C:\\Python27_64\Python.exe',
+    },
+    3: {
+        'win32' : r'C:\\Python33\Python.exe',
+        'win-amd64': r'C:\\Python33_64\Python.exe',
+    },
+}
+
+for v,plat_py in pythons.items():
     # deliberately mangle the name,
     # so easy_install doesn't find these and do horrible wrong things
-    v = 3 if py.endswith('3') else 2
     try:
         shutil.rmtree('build')
     except OSError:
         pass
-    for plat in ['win32', 'win-amd64']:
+    for plat,py in plat_py.items():
         cmd = cmd_t.format(**locals())
         sh(cmd)
         orig = glob.glob(os.path.join('dist', 'ipython-*.{plat}.exe'.format(**locals())))[0]