Merge remote-tracking branch 'public-upstream/master' into links-rebase

Conflicts:
	examples/Interactive Widgets/Widget Events.ipynb

IPython/html/allow76.py

@@ -0,0 +1,311 b''
+"""WebsocketProtocol76 from tornado 3.2.2 for tornado >= 4.0
+
+The contents of this file are Copyright (c) Tornado
+Used under the Apache 2.0 license
+"""
+
+
+from __future__ import absolute_import, division, print_function, with_statement
+# Author: Jacob Kristhammar, 2010
+
+import functools
+import hashlib
+import struct
+import time
+import tornado.escape
+import tornado.web
+
+from tornado.log import gen_log, app_log
+from tornado.util import bytes_type, unicode_type
+
+from tornado.websocket import WebSocketHandler, WebSocketProtocol13
+
+class AllowDraftWebSocketHandler(WebSocketHandler):
+    """Restore Draft76 support for tornado 4
+    
+    Remove when we can run tests without phantomjs + qt4
+    """
+    
+    # get is unmodified except between the BEGIN/END PATCH lines
+    @tornado.web.asynchronous
+    def get(self, *args, **kwargs):
+        self.open_args = args
+        self.open_kwargs = kwargs
+
+        # Upgrade header should be present and should be equal to WebSocket
+        if self.request.headers.get("Upgrade", "").lower() != 'websocket':
+            self.set_status(400)
+            self.finish("Can \"Upgrade\" only to \"WebSocket\".")
+            return
+
+        # Connection header should be upgrade. Some proxy servers/load balancers
+        # might mess with it.
+        headers = self.request.headers
+        connection = map(lambda s: s.strip().lower(), headers.get("Connection", "").split(","))
+        if 'upgrade' not in connection:
+            self.set_status(400)
+            self.finish("\"Connection\" must be \"Upgrade\".")
+            return
+
+        # Handle WebSocket Origin naming convention differences
+        # The difference between version 8 and 13 is that in 8 the
+        # client sends a "Sec-Websocket-Origin" header and in 13 it's
+        # simply "Origin".
+        if "Origin" in self.request.headers:
+            origin = self.request.headers.get("Origin")
+        else:
+            origin = self.request.headers.get("Sec-Websocket-Origin", None)
+
+
+        # If there was an origin header, check to make sure it matches
+        # according to check_origin. When the origin is None, we assume it
+        # did not come from a browser and that it can be passed on.
+        if origin is not None and not self.check_origin(origin):
+            self.set_status(403)
+            self.finish("Cross origin websockets not allowed")
+            return
+
+        self.stream = self.request.connection.detach()
+        self.stream.set_close_callback(self.on_connection_close)
+
+        if self.request.headers.get("Sec-WebSocket-Version") in ("7", "8", "13"):
+            self.ws_connection = WebSocketProtocol13(self)
+            self.ws_connection.accept_connection()
+        #--------------- BEGIN PATCH ----------------
+        elif (self.allow_draft76() and
+              "Sec-WebSocket-Version" not in self.request.headers):
+            self.ws_connection = WebSocketProtocol76(self)
+            self.ws_connection.accept_connection()
+        #--------------- END PATCH ----------------
+        else:
+            if not self.stream.closed():
+                self.stream.write(tornado.escape.utf8(
+                    "HTTP/1.1 426 Upgrade Required\r\n"
+                    "Sec-WebSocket-Version: 8\r\n\r\n"))
+                self.stream.close()
+    
+    # 3.2 methods removed in 4.0:
+    def allow_draft76(self):
+        """Using this class allows draft76 connections by default"""
+        return True
+    
+    def get_websocket_scheme(self):
+        """Return the url scheme used for this request, either "ws" or "wss".
+        This is normally decided by HTTPServer, but applications
+        may wish to override this if they are using an SSL proxy
+        that does not provide the X-Scheme header as understood
+        by HTTPServer.
+        Note that this is only used by the draft76 protocol.
+        """
+        return "wss" if self.request.protocol == "https" else "ws"
+    
+
+
+# No modifications from tornado-3.2.2 below this line
+
+class WebSocketProtocol(object):
+    """Base class for WebSocket protocol versions.
+    """
+    def __init__(self, handler):
+        self.handler = handler
+        self.request = handler.request
+        self.stream = handler.stream
+        self.client_terminated = False
+        self.server_terminated = False
+
+    def async_callback(self, callback, *args, **kwargs):
+        """Wrap callbacks with this if they are used on asynchronous requests.
+
+        Catches exceptions properly and closes this WebSocket if an exception
+        is uncaught.
+        """
+        if args or kwargs:
+            callback = functools.partial(callback, *args, **kwargs)
+
+        def wrapper(*args, **kwargs):
+            try:
+                return callback(*args, **kwargs)
+            except Exception:
+                app_log.error("Uncaught exception in %s",
+                              self.request.path, exc_info=True)
+                self._abort()
+        return wrapper
+
+    def on_connection_close(self):
+        self._abort()
+
+    def _abort(self):
+        """Instantly aborts the WebSocket connection by closing the socket"""
+        self.client_terminated = True
+        self.server_terminated = True
+        self.stream.close()  # forcibly tear down the connection
+        self.close()  # let the subclass cleanup
+
+
+class WebSocketProtocol76(WebSocketProtocol):
+    """Implementation of the WebSockets protocol, version hixie-76.
+
+    This class provides basic functionality to process WebSockets requests as
+    specified in
+    http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76
+    """
+    def __init__(self, handler):
+        WebSocketProtocol.__init__(self, handler)
+        self.challenge = None
+        self._waiting = None
+
+    def accept_connection(self):
+        try:
+            self._handle_websocket_headers()
+        except ValueError:
+            gen_log.debug("Malformed WebSocket request received")
+            self._abort()
+            return
+
+        scheme = self.handler.get_websocket_scheme()
+
+        # draft76 only allows a single subprotocol
+        subprotocol_header = ''
+        subprotocol = self.request.headers.get("Sec-WebSocket-Protocol", None)
+        if subprotocol:
+            selected = self.handler.select_subprotocol([subprotocol])
+            if selected:
+                assert selected == subprotocol
+                subprotocol_header = "Sec-WebSocket-Protocol: %s\r\n" % selected
+
+        # Write the initial headers before attempting to read the challenge.
+        # This is necessary when using proxies (such as HAProxy), which
+        # need to see the Upgrade headers before passing through the
+        # non-HTTP traffic that follows.
+        self.stream.write(tornado.escape.utf8(
+            "HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
+            "Upgrade: WebSocket\r\n"
+            "Connection: Upgrade\r\n"
+            "Server: TornadoServer/%(version)s\r\n"
+            "Sec-WebSocket-Origin: %(origin)s\r\n"
+            "Sec-WebSocket-Location: %(scheme)s://%(host)s%(uri)s\r\n"
+            "%(subprotocol)s"
+            "\r\n" % (dict(
+                version=tornado.version,
+                origin=self.request.headers["Origin"],
+                scheme=scheme,
+                host=self.request.host,
+                uri=self.request.uri,
+                subprotocol=subprotocol_header))))
+        self.stream.read_bytes(8, self._handle_challenge)
+
+    def challenge_response(self, challenge):
+        """Generates the challenge response that's needed in the handshake
+
+        The challenge parameter should be the raw bytes as sent from the
+        client.
+        """
+        key_1 = self.request.headers.get("Sec-Websocket-Key1")
+        key_2 = self.request.headers.get("Sec-Websocket-Key2")
+        try:
+            part_1 = self._calculate_part(key_1)
+            part_2 = self._calculate_part(key_2)
+        except ValueError:
+            raise ValueError("Invalid Keys/Challenge")
+        return self._generate_challenge_response(part_1, part_2, challenge)
+
+    def _handle_challenge(self, challenge):
+        try:
+            challenge_response = self.challenge_response(challenge)
+        except ValueError:
+            gen_log.debug("Malformed key data in WebSocket request")
+            self._abort()
+            return
+        self._write_response(challenge_response)
+
+    def _write_response(self, challenge):
+        self.stream.write(challenge)
+        self.async_callback(self.handler.open)(*self.handler.open_args, **self.handler.open_kwargs)
+        self._receive_message()
+
+    def _handle_websocket_headers(self):
+        """Verifies all invariant- and required headers
+
+        If a header is missing or have an incorrect value ValueError will be
+        raised
+        """
+        fields = ("Origin", "Host", "Sec-Websocket-Key1",
+                  "Sec-Websocket-Key2")
+        if not all(map(lambda f: self.request.headers.get(f), fields)):
+            raise ValueError("Missing/Invalid WebSocket headers")
+
+    def _calculate_part(self, key):
+        """Processes the key headers and calculates their key value.
+
+        Raises ValueError when feed invalid key."""
+        # pyflakes complains about variable reuse if both of these lines use 'c'
+        number = int(''.join(c for c in key if c.isdigit()))
+        spaces = len([c2 for c2 in key if c2.isspace()])
+        try:
+            key_number = number // spaces
+        except (ValueError, ZeroDivisionError):
+            raise ValueError
+        return struct.pack(">I", key_number)
+
+    def _generate_challenge_response(self, part_1, part_2, part_3):
+        m = hashlib.md5()
+        m.update(part_1)
+        m.update(part_2)
+        m.update(part_3)
+        return m.digest()
+
+    def _receive_message(self):
+        self.stream.read_bytes(1, self._on_frame_type)
+
+    def _on_frame_type(self, byte):
+        frame_type = ord(byte)
+        if frame_type == 0x00:
+            self.stream.read_until(b"\xff", self._on_end_delimiter)
+        elif frame_type == 0xff:
+            self.stream.read_bytes(1, self._on_length_indicator)
+        else:
+            self._abort()
+
+    def _on_end_delimiter(self, frame):
+        if not self.client_terminated:
+            self.async_callback(self.handler.on_message)(
+                frame[:-1].decode("utf-8", "replace"))
+        if not self.client_terminated:
+            self._receive_message()
+
+    def _on_length_indicator(self, byte):
+        if ord(byte) != 0x00:
+            self._abort()
+            return
+        self.client_terminated = True
+        self.close()
+
+    def write_message(self, message, binary=False):
+        """Sends the given message to the client of this Web Socket."""
+        if binary:
+            raise ValueError(
+                "Binary messages not supported by this version of websockets")
+        if isinstance(message, unicode_type):
+            message = message.encode("utf-8")
+        assert isinstance(message, bytes_type)
+        self.stream.write(b"\x00" + message + b"\xff")
+
+    def write_ping(self, data):
+        """Send ping frame."""
+        raise ValueError("Ping messages not supported by this version of websockets")
+
+    def close(self):
+        """Closes the WebSocket connection."""
+        if not self.server_terminated:
+            if not self.stream.closed():
+                self.stream.write("\xff\x00")
+            self.server_terminated = True
+        if self.client_terminated:
+            if self._waiting is not None:
+                self.stream.io_loop.remove_timeout(self._waiting)
+            self._waiting = None
+            self.stream.close()
+        elif self._waiting is None:
+            self._waiting = self.stream.io_loop.add_timeout(
+                time.time() + 5, self._abort)
+

IPython/html/edit/handlers.py

@@ -0,0 +1,29 b''
+#encoding: utf-8
+"""Tornado handlers for the terminal emulator."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+from tornado import web
+from ..base.handlers import IPythonHandler, path_regex
+from ..utils import url_escape
+
+class EditorHandler(IPythonHandler):
+    """Render the text editor interface."""
+    @web.authenticated
+    def get(self, path):
+        path = path.strip('/')
+        if not self.contents_manager.file_exists(path):
+            raise web.HTTPError(404, u'File does not exist: %s' % path)
+
+        basename = path.rsplit('/', 1)[-1]
+        self.write(self.render_template('edit.html',
+            file_path=url_escape(path),
+            basename=basename,
+            page_title=basename + " (editing)",
+            )
+        )
+
+default_handlers = [
+    (r"/edit%s" % path_regex, EditorHandler),
+]
  No newline at end of file

IPython/html/files/handlers.py

@@ -0,0 +1,54 b''
+"""Serve files directly from the ContentsManager."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import os
+import mimetypes
+import json
+import base64
+
+from tornado import web
+
+from IPython.html.base.handlers import IPythonHandler
+
+class FilesHandler(IPythonHandler):
+    """serve files via ContentsManager"""
+
+    @web.authenticated
+    def get(self, path):
+        cm = self.contents_manager
+        if cm.is_hidden(path):
+            self.log.info("Refusing to serve hidden file, via 404 Error")
+            raise web.HTTPError(404)
+        
+        path = path.strip('/')
+        if '/' in path:
+            _, name = path.rsplit('/', 1)
+        else:
+            name = path
+        
+        model = cm.get(path)
+        
+        if self.get_argument("download", False):
+            self.set_header('Content-Disposition','attachment; filename="%s"' % name)
+        
+        if model['type'] == 'notebook':
+            self.set_header('Content-Type', 'application/json')
+        else:
+            cur_mime = mimetypes.guess_type(name)[0]
+            if cur_mime is not None:
+                self.set_header('Content-Type', cur_mime)
+        
+        if model['format'] == 'base64':
+            b64_bytes = model['content'].encode('ascii')
+            self.write(base64.decodestring(b64_bytes))
+        elif model['format'] == 'json':
+            self.write(json.dumps(model['content']))
+        else:
+            self.write(model['content'])
+        self.flush()
+
+default_handlers = [
+    (r"/files/(.*)", FilesHandler),
+]
  No newline at end of file

IPython/html/services/config/__init__.py

@@ -0,0 +1,1 b''
+from .manager import ConfigManager

IPython/html/services/config/handlers.py

@@ -0,0 +1,44 b''
+"""Tornado handlers for frontend config storage."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+import json
+import os
+import io
+import errno
+from tornado import web
+
+from IPython.utils.py3compat import PY3
+from ...base.handlers import IPythonHandler, json_errors
+
+class ConfigHandler(IPythonHandler):
+    SUPPORTED_METHODS = ('GET', 'PUT', 'PATCH')
+
+    @web.authenticated
+    @json_errors
+    def get(self, section_name):
+        self.set_header("Content-Type", 'application/json')
+        self.finish(json.dumps(self.config_manager.get(section_name)))
+
+    @web.authenticated
+    @json_errors
+    def put(self, section_name):
+        data = self.get_json_body()  # Will raise 400 if content is not valid JSON
+        self.config_manager.set(section_name, data)
+        self.set_status(204)
+
+    @web.authenticated
+    @json_errors
+    def patch(self, section_name):
+        new_data = self.get_json_body()
+        section = self.config_manager.update(section_name, new_data)
+        self.finish(json.dumps(section))
+
+
+# URL to handler mappings
+
+section_name_regex = r"(?P<section_name>\w+)"
+
+default_handlers = [
+    (r"/api/config/%s" % section_name_regex, ConfigHandler),
+]

IPython/html/services/config/manager.py

@@ -0,0 +1,90 b''
+"""Manager to read and modify frontend config data in JSON files.
+"""
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+import errno
+import io
+import json
+import os
+
+from IPython.config import LoggingConfigurable
+from IPython.utils.path import locate_profile
+from IPython.utils.py3compat import PY3
+from IPython.utils.traitlets import Unicode
+
+
+def recursive_update(target, new):
+    """Recursively update one dictionary using another.
+
+    None values will delete their keys.
+    """
+    for k, v in new.items():
+        if isinstance(v, dict):
+            if k not in target:
+                target[k] = {}
+            recursive_update(target[k], v)
+            if not target[k]:
+                # Prune empty subdicts
+                del target[k]
+
+        elif v is None:
+            target.pop(k, None)
+
+        else:
+            target[k] = v
+
+
+class ConfigManager(LoggingConfigurable):
+    profile_dir = Unicode()
+    def _profile_dir_default(self):
+        return locate_profile()
+
+    @property
+    def config_dir(self):
+        return os.path.join(self.profile_dir, 'nbconfig')
+
+    def ensure_config_dir_exists(self):
+        try:
+            os.mkdir(self.config_dir, 0o755)
+        except OSError as e:
+            if e.errno != errno.EEXIST:
+                raise
+
+    def file_name(self, section_name):
+        return os.path.join(self.config_dir, section_name+'.json')
+
+    def get(self, section_name):
+        """Retrieve the config data for the specified section.
+
+        Returns the data as a dictionary, or an empty dictionary if the file
+        doesn't exist.
+        """
+        filename = self.file_name(section_name)
+        if os.path.isfile(filename):
+            with io.open(filename, encoding='utf-8') as f:
+                return json.load(f)
+        else:
+            return {}
+
+    def set(self, section_name, data):
+        """Store the given config data.
+        """
+        filename = self.file_name(section_name)
+        self.ensure_config_dir_exists()
+
+        if PY3:
+            f = io.open(filename, 'w', encoding='utf-8')
+        else:
+            f = open(filename, 'wb')
+        with f:
+            json.dump(data, f)
+
+    def update(self, section_name, new_data):
+        """Modify the config section by recursively updating it with new_data.
+
+        Returns the modified config data as a dictionary.
+        """
+        data = self.get(section_name)
+        recursive_update(data, new_data)
+        self.set(section_name, data)
+        return data

IPython/html/services/config/tests/test_config_api.py

@@ -0,0 +1,68 b''
+# coding: utf-8
+"""Test the config webservice API."""
+
+import json
+
+import requests
+
+from IPython.html.utils import url_path_join
+from IPython.html.tests.launchnotebook import NotebookTestBase
+
+
+class ConfigAPI(object):
+    """Wrapper for notebook API calls."""
+    def __init__(self, base_url):
+        self.base_url = base_url
+
+    def _req(self, verb, section, body=None):
+        response = requests.request(verb,
+                url_path_join(self.base_url, 'api/config', section),
+                data=body,
+        )
+        response.raise_for_status()
+        return response
+
+    def get(self, section):
+        return self._req('GET', section)
+
+    def set(self, section, values):
+        return self._req('PUT', section, json.dumps(values))
+
+    def modify(self, section, values):
+        return self._req('PATCH', section, json.dumps(values))
+
+class APITest(NotebookTestBase):
+    """Test the config web service API"""
+    def setUp(self):
+        self.config_api = ConfigAPI(self.base_url())
+
+    def test_create_retrieve_config(self):
+        sample = {'foo': 'bar', 'baz': 73}
+        r = self.config_api.set('example', sample)
+        self.assertEqual(r.status_code, 204)
+
+        r = self.config_api.get('example')
+        self.assertEqual(r.status_code, 200)
+        self.assertEqual(r.json(), sample)
+
+    def test_modify(self):
+        sample = {'foo': 'bar', 'baz': 73,
+                  'sub': {'a': 6, 'b': 7}, 'sub2': {'c': 8}}
+        self.config_api.set('example', sample)
+
+        r = self.config_api.modify('example', {'foo': None,  # should delete foo
+                                               'baz': 75,
+                                               'wib': [1,2,3],
+                                               'sub': {'a': 8, 'b': None, 'd': 9},
+                                               'sub2': {'c': None}  # should delete sub2
+                                              })
+        self.assertEqual(r.status_code, 200)
+        self.assertEqual(r.json(), {'baz': 75, 'wib': [1,2,3],
+                                    'sub': {'a': 8, 'd': 9}})
+
+    def test_get_unknown(self):
+        # We should get an empty config dictionary instead of a 404
+        r = self.config_api.get('nonexistant')
+        self.assertEqual(r.status_code, 200)
+        self.assertEqual(r.json(), {})
+

IPython/html/services/contents/clientsidenbmanager.py

@@ -0,0 +1,23 b''
+"""A dummy contents manager for when the logic is done client side (in JavaScript)."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+from .manager import ContentsManager
+
+class ClientSideContentsManager(ContentsManager):
+    """Dummy contents manager for use with client-side contents APIs like GDrive
+
+    The view handlers for notebooks and directories (/tree/) check with the
+    ContentsManager that their target exists so they can return 404 if not. Using
+    this class as the contents manager allows those pages to render without
+    checking something that the server doesn't know about.
+    """
+    def dir_exists(self, path):
+        return True
+
+    def is_hidden(self, path):
+        return False
+
+    def file_exists(self, name, path=''):
+        return True

IPython/html/services/security/__init__.py

@@ -0,0 +1,4 b''
+# URI for the CSP Report. Included here to prevent a cyclic dependency.
+# csp_report_uri is needed both by the BaseHandler (for setting the report-uri)
+# and by the CSPReportHandler (which depends on the BaseHandler).
+csp_report_uri = r"/api/security/csp-report"

IPython/html/services/security/handlers.py

@@ -0,0 +1,23 b''
+"""Tornado handlers for security logging."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+from tornado import gen, web
+
+from ...base.handlers import IPythonHandler, json_errors
+from . import csp_report_uri
+
+class CSPReportHandler(IPythonHandler):
+    '''Accepts a content security policy violation report'''
+    @web.authenticated
+    @json_errors
+    def post(self):
+        '''Log a content security policy violation report'''
+        csp_report = self.get_json_body()
+        self.log.warn("Content security violation: %s",
+                      self.request.body.decode('utf8', 'replace'))
+
+default_handlers = [
+    (csp_report_uri, CSPReportHandler)
+]

IPython/html/static/base/js/notificationarea.js

@@ -0,0 +1,83 b''
+// Copyright (c) IPython Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+define([
+    'jquery',
+    'base/js/notificationwidget',
+], function($, notificationwidget) {
+    "use strict";
+
+    // store reference to the NotificationWidget class
+    var NotificationWidget = notificationwidget.NotificationWidget;
+
+    /**
+     * Construct the NotificationArea object. Options are:
+     *     events: $(Events) instance
+     *     save_widget: SaveWidget instance
+     *     notebook: Notebook instance
+     *     keyboard_manager: KeyboardManager instance
+     *
+     * @constructor
+     * @param {string} selector - a jQuery selector string for the
+     * notification area element
+     * @param {Object} [options] - a dictionary of keyword arguments.
+     */
+    var NotificationArea = function (selector, options) {
+        this.selector = selector;
+        this.events = options.events;
+        if (this.selector !== undefined) {
+            this.element = $(selector);
+        }
+        this.widget_dict = {};
+    };
+
+    /**
+     * Get a widget by name, creating it if it doesn't exist.
+     *
+     * @method widget
+     * @param {string} name - the widget name
+     */
+    NotificationArea.prototype.widget = function (name) {
+        if (this.widget_dict[name] === undefined) {
+            return this.new_notification_widget(name);
+        }
+        return this.get_widget(name);
+    };
+
+    /**
+     * Get a widget by name, throwing an error if it doesn't exist.
+     *
+     * @method get_widget
+     * @param {string} name - the widget name
+     */
+    NotificationArea.prototype.get_widget = function (name) {
+        if(this.widget_dict[name] === undefined) {
+            throw('no widgets with this name');
+        }
+        return this.widget_dict[name];
+    };
+
+    /**
+     * Create a new notification widget with the given name. The
+     * widget must not already exist.
+     *
+     * @method new_notification_widget
+     * @param {string} name - the widget name
+     */
+    NotificationArea.prototype.new_notification_widget = function (name) {
+        if (this.widget_dict[name] !== undefined) {
+            throw('widget with that name already exists!');
+        }
+
+        // create the element for the notification widget and add it
+        // to the notification aread element
+        var div = $('<div/>').attr('id', 'notification_' + name);
+        $(this.selector).append(div);
+
+        // create the widget object and return it
+        this.widget_dict[name] = new NotificationWidget('#notification_' + name);
+        return this.widget_dict[name];
+    };
+
+    return {'NotificationArea': NotificationArea};
+});

IPython/html/static/edit/js/editor.js

@@ -0,0 +1,78 b''
+// Copyright (c) IPython Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+define([
+    'jquery',
+    'base/js/utils',
+    'codemirror/lib/codemirror',
+    'codemirror/mode/meta',
+    'codemirror/addon/search/search'
+    ],
+function($,
+    utils,
+    CodeMirror
+) {
+    var Editor = function(selector, options) {
+        this.selector = selector;
+        this.contents = options.contents;
+        this.events = options.events;
+        this.base_url = options.base_url;
+        this.file_path = options.file_path;
+        
+        this.codemirror = CodeMirror($(this.selector)[0]);
+        
+        // It appears we have to set commands on the CodeMirror class, not the
+        // instance. I'd like to be wrong, but since there should only be one CM
+        // instance on the page, this is good enough for now.
+        CodeMirror.commands.save = $.proxy(this.save, this);
+        
+        this.save_enabled = false;
+    };
+    
+    Editor.prototype.load = function() {
+        var that = this;
+        var cm = this.codemirror;
+        this.contents.get(this.file_path, {type: 'file', format: 'text'})
+            .then(function(model) {
+                cm.setValue(model.content);
+
+                // Setting the file's initial value creates a history entry,
+                // which we don't want.
+                cm.clearHistory();
+
+                // Find and load the highlighting mode
+                var modeinfo = CodeMirror.findModeByMIME(model.mimetype);
+                if (modeinfo) {
+                    utils.requireCodeMirrorMode(modeinfo.mode, function() {
+                        cm.setOption('mode', modeinfo.mode);
+                    });
+                }
+                that.save_enabled = true;
+            },
+            function(error) {
+                cm.setValue("Error! " + error.message +
+                                "\nSaving disabled.");
+                that.save_enabled = false;
+            }
+        );
+    };
+
+    Editor.prototype.save = function() {
+        if (!this.save_enabled) {
+            console.log("Not saving, save disabled");
+            return;
+        }
+        var model = {
+            path: this.file_path,
+            type: 'file',
+            format: 'text',
+            content: this.codemirror.getValue(),
+        };
+        var that = this;
+        this.contents.save(this.file_path, model).then(function() {
+            that.events.trigger("save_succeeded.TextEditor");
+        });
+    };
+
+    return {Editor: Editor};
+});

IPython/html/static/edit/js/main.js

@@ -0,0 +1,64 b''
+// Copyright (c) IPython Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+require([
+    'base/js/namespace',
+    'base/js/utils',
+    'base/js/page',
+    'base/js/events',
+    'contents',
+    'services/config',
+    'edit/js/editor',
+    'edit/js/menubar',
+    'edit/js/notificationarea',
+    'custom/custom',
+], function(
+    IPython,
+    utils,
+    page,
+    events,
+    contents,
+    configmod,
+    editor,
+    menubar,
+    notificationarea
+    ){
+    page = new page.Page();
+
+    var base_url = utils.get_body_data('baseUrl');
+    var file_path = utils.get_body_data('filePath');
+    contents = new contents.Contents({base_url: base_url});
+    var config = new configmod.ConfigSection('edit', {base_url: base_url})
+    config.load();
+    
+    var editor = new editor.Editor('#texteditor-container', {
+        base_url: base_url,
+        events: events,
+        contents: contents,
+        file_path: file_path,
+    });
+    
+    // Make it available for debugging
+    IPython.editor = editor;
+    
+    var menus = new menubar.MenuBar('#menubar', {
+        base_url: base_url,
+        editor: editor,
+    });
+    
+    var notification_area = new notificationarea.EditorNotificationArea(
+        '#notification_area', {
+        events: events,
+    });
+    notification_area.init_notification_widgets();
+
+    config.loaded.then(function() {
+        if (config.data.load_extensions) {
+            var nbextension_paths = Object.getOwnPropertyNames(
+                                        config.data.load_extensions);
+            IPython.load_extensions.apply(this, nbextension_paths);
+        }
+    });
+    editor.load();
+    page.show();
+});

IPython/html/static/edit/js/menubar.js

@@ -0,0 +1,50 b''
+// Copyright (c) IPython Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+define([
+    'base/js/namespace',
+    'jquery',
+    'base/js/utils',
+    'bootstrap',
+], function(IPython, $, utils, bootstrap) {
+    "use strict";
+    
+    var MenuBar = function (selector, options) {
+        /**
+         * Constructor
+         *
+         * A MenuBar Class to generate the menubar of IPython notebook
+         *
+         * Parameters:
+         *  selector: string
+         *  options: dictionary
+         *      Dictionary of keyword arguments.
+         *          codemirror: CodeMirror instance
+         *          contents: ContentManager instance
+         *          events: $(Events) instance
+         *          base_url : string
+         *          file_path : string
+         */
+        options = options || {};
+        this.base_url = options.base_url || utils.get_body_data("baseUrl");
+        this.selector = selector;
+        this.editor = options.editor;
+
+        if (this.selector !== undefined) {
+            this.element = $(selector);
+            this.bind_events();
+        }
+    };
+
+    MenuBar.prototype.bind_events = function () {
+        /**
+         *  File
+         */
+        var that = this;
+        this.element.find('#save_file').click(function () {
+            that.editor.save();
+        });
+    };
+
+    return {'MenuBar': MenuBar};
+});

IPython/html/static/edit/js/notificationarea.js

@@ -0,0 +1,29 b''
+define([
+    'base/js/notificationarea'
+], function(notificationarea) {
+    "use strict";
+    var NotificationArea = notificationarea.NotificationArea;
+    
+    var EditorNotificationArea = function(selector, options) {
+        NotificationArea.apply(this, [selector, options]);
+    }
+    
+    EditorNotificationArea.prototype = Object.create(NotificationArea.prototype);
+    
+    /**
+     * Initialize the default set of notification widgets.
+     *
+     * @method init_notification_widgets
+     */
+    EditorNotificationArea.prototype.init_notification_widgets = function () {
+        var that = this;
+        var enw = this.new_notification_widget('editor');
+        
+        this.events.on("save_succeeded.TextEditor", function() {
+            enw.set_message("File saved", 2000);
+        });
+    };
+    
+
+    return {EditorNotificationArea: EditorNotificationArea};
+});

IPython/html/static/notebook/js/about.js

@@ -0,0 +1,38 b''
+// Copyright (c) IPython Development Team.
+// Distributed under the terms of the Modified BSD License.
+require([
+    'jquery',
+    'base/js/dialog',
+    'underscore',
+    'base/js/namespace'
+], function ($, dialog, _, IPython) {
+    'use strict';
+    $('#notebook_about').click(function () {
+        // use underscore template to auto html escape
+        var text = 'You are using IPython notebook.<br/><br/>';
+        text = text + 'The version of the notebook server is ';
+        text = text + _.template('<b><%- version %></b>')({ version: sys_info.ipython_version });
+        if (sys_info.commit_hash) {
+            text = text + _.template('-<%- hash %>')({ hash: sys_info.commit_hash });
+        }
+        text = text + _.template(' and is running on:<br/><pre>Python <%- pyver %></pre>')({ pyver: sys_info.sys_version });
+        var kinfo = $('<div/>').attr('id', '#about-kinfo').text('Waiting for kernel to be available...');
+        var body = $('<div/>');
+        body.append($('<h4/>').text('Server Information:'));
+        body.append($('<p/>').html(text));
+        body.append($('<h4/>').text('Current Kernel Information:'));
+        body.append(kinfo);
+        dialog.modal({
+            title: 'About IPython Notebook',
+            body: body,
+            buttons: { 'OK': {} }
+        });
+        try {
+            IPython.notebook.session.kernel.kernel_info(function (data) {
+                kinfo.html($('<pre/>').text(data.content.banner));
+            });
+        } catch (e) {
+            kinfo.html($('<p/>').text('unable to contact kernel'));
+        }
+    });
+});

IPython/html/static/notebook/js/actions.js

@@ -0,0 +1,503 b''
+// Copyright (c) IPython Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+define(['require'
+], function(require) {
+    "use strict";
+    
+    var ActionHandler = function (env) {
+        this.env = env || {};
+        Object.seal(this);
+    };
+
+    /**
+     *  A bunch of predefined `Simple Actions` used by IPython.
+     *  `Simple Actions` have the following keys:
+     *  help (optional): a short string the describe the action.
+     *      will be used in various context, like as menu name, tool tips on buttons,
+     *      and short description in help menu.
+     *  help_index (optional): a string used to sort action in help menu.
+     *  icon (optional): a short string that represent the icon that have to be used with this
+     *  action. this should mainly correspond to a Font_awesome class.
+     *  handler : a function which is called when the action is activated. It will receive at first parameter
+     *      a dictionary containing various handle to element of the notebook.
+     *
+     *  action need to be registered with a **name** that can be use to refer to this action.
+     *
+     *
+     *  if `help` is not provided it will be derived by replacing any dash by space
+     *  in the **name** of the action. It is advised to provide a prefix to action name to
+     *  avoid conflict the prefix should be all lowercase and end with a dot `.`
+     *  in the absence of a prefix the behavior of the action is undefined.
+     *
+     *  All action provided by IPython are prefixed with `ipython.`.
+     *
+     *  One can register extra actions or replace an existing action with another one is possible
+     *  but is considered undefined behavior.
+     *
+     **/
+    var _action = {
+        'run-select-next': {
+            icon: 'fa-play',
+            help    : 'run cell, select below',
+            help_index : 'ba',
+            handler : function (env) {
+                env.notebook.execute_cell_and_select_below();
+            }
+        },
+        'execute-in-place':{
+            help    : 'run cell',
+            help_index : 'bb',
+            handler : function (env) {
+                env.notebook.execute_cell();
+            }
+        },
+        'execute-and-insert-after':{
+            help    : 'run cell, insert below',
+            help_index : 'bc',
+            handler : function (env) {
+                env.notebook.execute_cell_and_insert_below();
+            }
+        },
+        'go-to-command-mode': {
+            help    : 'command mode',
+            help_index : 'aa',
+            handler : function (env) {
+                env.notebook.command_mode();
+            }
+        },
+        'split-cell-at-cursor': {
+            help    : 'split cell',
+            help_index : 'ea',
+            handler : function (env) {
+                env.notebook.split_cell();
+            }
+        },
+        'enter-edit-mode' : {
+            help_index : 'aa',
+            handler : function (env) {
+                env.notebook.edit_mode();
+            }
+        },
+        'select-previous-cell' : {
+            help_index : 'da',
+            handler : function (env) {
+                var index = env.notebook.get_selected_index();
+                if (index !== 0 && index !== null) {
+                    env.notebook.select_prev();
+                    env.notebook.focus_cell();
+                }
+            }
+        },
+        'select-next-cell' : {
+            help_index : 'db',
+            handler : function (env) {
+                var index = env.notebook.get_selected_index();
+                if (index !== (env.notebook.ncells()-1) && index !== null) {
+                    env.notebook.select_next();
+                    env.notebook.focus_cell();
+                }
+            }
+        },
+        'cut-selected-cell' : {
+            icon: 'fa-cut',
+            help_index : 'ee',
+            handler : function (env) {
+                env.notebook.cut_cell();
+            }
+        },
+        'copy-selected-cell' : {
+            icon: 'fa-copy',
+            help_index : 'ef',
+            handler : function (env) {
+                env.notebook.copy_cell();
+            }
+        },
+        'paste-cell-before' : {
+            help_index : 'eg',
+            handler : function (env) {
+                env.notebook.paste_cell_above();
+            }
+        },
+        'paste-cell-after' : {
+            icon: 'fa-paste',
+            help_index : 'eh',
+            handler : function (env) {
+                env.notebook.paste_cell_below();
+            }
+        },
+        'insert-cell-before' : {
+            help_index : 'ec',
+            handler : function (env) {
+                env.notebook.insert_cell_above();
+                env.notebook.select_prev();
+                env.notebook.focus_cell();
+            }
+        },
+        'insert-cell-after' : {
+            icon : 'fa-plus',
+            help_index : 'ed',
+            handler : function (env) {
+                env.notebook.insert_cell_below();
+                env.notebook.select_next();
+                env.notebook.focus_cell();
+            }
+        },
+        'change-selected-cell-to-code-cell' : {
+            help    : 'to code',
+            help_index : 'ca',
+            handler : function (env) {
+                env.notebook.to_code();
+            }
+        },
+        'change-selected-cell-to-markdown-cell' : {
+            help    : 'to markdown',
+            help_index : 'cb',
+            handler : function (env) {
+                env.notebook.to_markdown();
+            }
+        },
+        'change-selected-cell-to-raw-cell' : {
+            help    : 'to raw',
+            help_index : 'cc',
+            handler : function (env) {
+                env.notebook.to_raw();
+            }
+        },
+        'change-selected-cell-to-heading-1' : {
+            help    : 'to heading 1',
+            help_index : 'cd',
+            handler : function (env) {
+                env.notebook.to_heading(undefined, 1);
+            }
+        },
+        'change-selected-cell-to-heading-2' : {
+            help    : 'to heading 2',
+            help_index : 'ce',
+            handler : function (env) {
+                env.notebook.to_heading(undefined, 2);
+            }
+        },
+        'change-selected-cell-to-heading-3' : {
+            help    : 'to heading 3',
+            help_index : 'cf',
+            handler : function (env) {
+                env.notebook.to_heading(undefined, 3);
+            }
+        },
+        'change-selected-cell-to-heading-4' : {
+            help    : 'to heading 4',
+            help_index : 'cg',
+            handler : function (env) {
+                env.notebook.to_heading(undefined, 4);
+            }
+        },
+        'change-selected-cell-to-heading-5' : {
+            help    : 'to heading 5',
+            help_index : 'ch',
+            handler : function (env) {
+                env.notebook.to_heading(undefined, 5);
+            }
+        },
+        'change-selected-cell-to-heading-6' : {
+            help    : 'to heading 6',
+            help_index : 'ci',
+            handler : function (env) {
+                env.notebook.to_heading(undefined, 6);
+            }
+        },
+        'toggle-output-visibility-selected-cell' : {
+            help    : 'toggle output',
+            help_index : 'gb',
+            handler : function (env) {
+                env.notebook.toggle_output();
+            }
+        },
+        'toggle-output-scrolling-selected-cell' : {
+            help    : 'toggle output scrolling',
+            help_index : 'gc',
+            handler : function (env) {
+                env.notebook.toggle_output_scroll();
+            }
+        },
+        'move-selected-cell-down' : {
+            icon: 'fa-arrow-down',
+            help_index : 'eb',
+            handler : function (env) {
+                env.notebook.move_cell_down();
+            }
+        },
+        'move-selected-cell-up' : {
+            icon: 'fa-arrow-up',
+            help_index : 'ea',
+            handler : function (env) {
+                env.notebook.move_cell_up();
+            }
+        },
+        'toggle-line-number-selected-cell' : {
+            help    : 'toggle line numbers',
+            help_index : 'ga',
+            handler : function (env) {
+                env.notebook.cell_toggle_line_numbers();
+            }
+        },
+        'show-keyboard-shortcut-help-dialog' : {
+            help_index : 'ge',
+            handler : function (env) {
+                env.quick_help.show_keyboard_shortcuts();
+            }
+        },
+        'delete-cell': {
+            help_index : 'ej',
+            handler : function (env) {
+                env.notebook.delete_cell();
+            }
+        },
+        'interrupt-kernel':{
+            icon: 'fa-stop',
+            help_index : 'ha',
+            handler : function (env) {
+                env.notebook.kernel.interrupt();
+            }
+        },
+        'restart-kernel':{
+            icon: 'fa-repeat',
+            help_index : 'hb',
+            handler : function (env) {
+                env.notebook.restart_kernel();
+            }
+        },
+        'undo-last-cell-deletion' : {
+            help_index : 'ei',
+            handler : function (env) {
+                env.notebook.undelete_cell();
+            }
+        },
+        'merge-selected-cell-with-cell-after' : {
+            help    : 'merge cell below',
+            help_index : 'ek',
+            handler : function (env) {
+                env.notebook.merge_cell_below();
+            }
+        },
+        'close-pager' : {
+            help_index : 'gd',
+            handler : function (env) {
+                env.pager.collapse();
+            }
+        }
+
+    };
+
+    /**
+     * A bunch of `Advance actions` for IPython.
+     * Cf `Simple Action` plus the following properties.
+     *
+     * handler: first argument of the handler is the event that triggerd the action
+     *      (typically keypress). The handler is responsible for any modification of the
+     *      event and event propagation.
+     *      Is also responsible for returning false if the event have to be further ignored,
+     *      true, to tell keyboard manager that it ignored the event.
+     *
+     *      the second parameter of the handler is the environemnt passed to Simple Actions
+     *
+     **/
+    var custom_ignore = {
+        'ignore':{
+            handler : function () {
+                return true;
+            }
+        },
+        'move-cursor-up-or-previous-cell':{
+            handler : function (env, event) {
+                var index = env.notebook.get_selected_index();
+                var cell = env.notebook.get_cell(index);
+                var cm = env.notebook.get_selected_cell().code_mirror;
+                var cur = cm.getCursor();
+                if (cell && cell.at_top() && index !== 0 && cur.ch === 0) {
+                    if(event){
+                        event.preventDefault();
+                    }
+                    env.notebook.command_mode();
+                    env.notebook.select_prev();
+                    env.notebook.edit_mode();
+                    cm = env.notebook.get_selected_cell().code_mirror;
+                    cm.setCursor(cm.lastLine(), 0);
+                }
+                return false;
+            }
+        },
+        'move-cursor-down-or-next-cell':{
+            handler : function (env, event) {
+                var index = env.notebook.get_selected_index();
+                var cell = env.notebook.get_cell(index);
+                if (cell.at_bottom() && index !== (env.notebook.ncells()-1)) {
+                    if(event){
+                        event.preventDefault();
+                    }
+                    env.notebook.command_mode();
+                    env.notebook.select_next();
+                    env.notebook.edit_mode();
+                    var cm = env.notebook.get_selected_cell().code_mirror;
+                    cm.setCursor(0, 0);
+                }
+                return false;
+            }
+        },
+        'scroll-down': {
+            handler: function(env, event) {
+                if(event){
+                    event.preventDefault();
+                }
+                return env.notebook.scroll_manager.scroll(1);
+            },
+        },
+        'scroll-up': {
+            handler: function(env, event) {
+                if(event){
+                    event.preventDefault();
+                }
+                return env.notebook.scroll_manager.scroll(-1);
+            },
+        },
+        'save-notebook':{
+            help: "Save and Checkpoint",
+            help_index : 'fb',
+            icon: 'fa-save',
+            handler : function (env, event) {
+                env.notebook.save_checkpoint();
+                if(event){
+                    event.preventDefault();
+                }
+                return false;
+            }
+        },
+    };
+
+    // private stuff that prepend `.ipython` to actions names
+    // and uniformize/fill in missing pieces in of an action.
+    var _prepare_handler = function(registry, subkey, source){
+        registry['ipython.'+subkey] = {};
+        registry['ipython.'+subkey].help = source[subkey].help||subkey.replace(/-/g,' ');
+        registry['ipython.'+subkey].help_index = source[subkey].help_index;
+        registry['ipython.'+subkey].icon = source[subkey].icon;
+        return source[subkey].handler;
+    };
+
+    // Will actually generate/register all the IPython actions
+    var fun = function(){
+        var final_actions = {};
+        for(var k in _action){
+            // Js closure are function level not block level need to wrap in a IIFE
+            // and append ipython to event name these things do intercept event so are wrapped
+            // in a function that return false.
+            var handler = _prepare_handler(final_actions, k, _action);
+            (function(key, handler){
+                final_actions['ipython.'+key].handler = function(env, event){
+                    handler(env);
+                    if(event){
+                        event.preventDefault();
+                    }
+                    return false;
+                };
+            })(k, handler);
+        }
+
+        for(var k in custom_ignore){
+            // Js closure are function level not block level need to wrap in a IIFE
+            // same as above, but decide for themselves wether or not they intercept events.
+            var handler = _prepare_handler(final_actions, k, custom_ignore);
+            (function(key, handler){
+                final_actions['ipython.'+key].handler = function(env, event){
+                    return handler(env, event);
+                };
+            })(k, handler);
+        }
+
+        return final_actions;
+    };
+    ActionHandler.prototype._actions = fun();
+
+
+    /**
+     *  extend the environment variable that will be pass to handlers
+     **/
+    ActionHandler.prototype.extend_env = function(env){
+        for(var k in env){
+            this.env[k] = env[k];
+        }
+    };
+
+    ActionHandler.prototype.register = function(action, name, prefix){
+        /**
+         * Register an `action` with an optional name and prefix. 
+         *
+         * if name and prefix are not given they will be determined automatically. 
+         * if action if just a `function` it will be wrapped in an anonymous action.
+         *
+         * @return the full name to access this action .
+         **/
+        action = this.normalise(action);
+        if( !name ){
+            name = 'autogenerated-'+String(action.handler);
+        }
+        prefix = prefix || 'auto';
+        var full_name = prefix+'.'+name;
+        this._actions[full_name] = action;
+        return full_name;
+
+    };
+
+
+    ActionHandler.prototype.normalise = function(data){
+        /**
+         * given an `action` or `function`, return a normalised `action`
+         * by setting all known attributes and removing unknown attributes;
+         **/
+        if(typeof(data) === 'function'){
+            data = {handler:data};
+        }
+        if(typeof(data.handler) !== 'function'){
+            throw('unknown datatype, cannot register');
+        }
+        var _data = data;
+        data = {};
+        data.handler = _data.handler;
+        data.help = data.help || '';
+        data.icon = data.icon || '';
+        data.help_index = data.help_index || '';
+        return data;
+    };
+
+    ActionHandler.prototype.get_name = function(name_or_data){
+        /**
+         * given an `action` or `name` of a action, return the name attached to this action.
+         * if given the name of and corresponding actions does not exist in registry, return `null`.
+         **/
+
+        if(typeof(name_or_data) === 'string'){
+            if(this.exists(name_or_data)){
+                return name_or_data;
+            } else {
+                return null;
+            }
+        } else {
+            return this.register(name_or_data);
+        }
+    };
+
+    ActionHandler.prototype.get = function(name){
+        return this._actions[name];
+    };
+
+    ActionHandler.prototype.call = function(name, event, env){
+        return this._actions[name].handler(env|| this.env, event);
+    };
+
+    ActionHandler.prototype.exists = function(name){
+        return (typeof(this._actions[name]) !== 'undefined');
+    };
+
+    return {init:ActionHandler};
+
+});

.gitignore

@@ -5,6 +5,7 b' _build'
 docs/man/*.gz
 docs/source/api/generated
 docs/source/config/options
+docs/source/interactive/magics-generated.txt
 docs/gh-pages
 IPython/html/notebook/static/mathjax
 IPython/html/static/style/*.map
@@ -16,3 +17,6 b' __pycache__'
 .ipynb_checkpoints
 .tox
 .DS_Store
+\#*#
+.#*
+.coverage

.travis.yml

@@ -11,14 +11,15 b' before_install:'
     # workaround for https://github.com/travis-ci/travis-cookbooks/issues/155
     - sudo rm -rf /dev/shm && sudo ln -s /run/shm /dev/shm
     # Pierre Carrier's PPA for PhantomJS and CasperJS
-    - time sudo add-apt-repository -y ppa:pcarrier/ppa
-    - time sudo apt-get update
-    - time sudo apt-get install pandoc casperjs libzmq3-dev
-    # pin tornado < 4 for js tests while phantom is on super old webkit
-    - if [[ $GROUP == 'js' ]]; then pip install 'tornado<4'; fi
-    - time pip install -f https://nipy.bic.berkeley.edu/wheelhouse/travis jinja2 sphinx pygments tornado requests mock pyzmq jsonschema jsonpointer mistune
+    - sudo add-apt-repository -y ppa:pcarrier/ppa
+    # Needed to get recent version of pandoc in ubntu 12.04
+    - sudo add-apt-repository -y ppa:marutter/c2d4u
+    - sudo apt-get update
+    - sudo apt-get install pandoc casperjs libzmq3-dev
+    - git clone --quiet --depth 1 https://github.com/minrk/travis-wheels travis-wheels
+    - 'if [[ $GROUP == js* ]]; then python -m IPython.external.mathjax; fi'
 install:
-    - time python setup.py install -q 
+    - pip install -f travis-wheels/wheelhouse file://$PWD#egg=ipython[all]
 script:
     - cd /tmp && iptest $GROUP
 

Dockerfile

@@ -5,13 +5,11 b' FROM ubuntu:14.04'
 
 MAINTAINER IPython Project <[e-mail]>
 
-# Make sure apt is up to date
-RUN apt-get update
-RUN apt-get upgrade -y
+ENV DEBIAN_FRONTEND noninteractive
 
 # Not essential, but wise to set the lang
 # Note: Users with other languages should set this in their derivative image
-RUN apt-get install -y language-pack-en
+RUN apt-get update && apt-get install -y language-pack-en
 ENV LANGUAGE en_US.UTF-8
 ENV LANG en_US.UTF-8
 ENV LC_ALL en_US.UTF-8
@@ -20,14 +18,32 b' RUN locale-gen en_US.UTF-8'
 RUN dpkg-reconfigure locales
 
 # Python binary dependencies, developer tools
-RUN apt-get install -y -q build-essential make gcc zlib1g-dev git && \
-    apt-get install -y -q python python-dev python-pip python3-dev python3-pip && \
-    apt-get install -y -q libzmq3-dev sqlite3 libsqlite3-dev pandoc libcurl4-openssl-dev nodejs nodejs-legacy npm
+RUN apt-get update && apt-get install -y -q \
+    build-essential \
+    make \
+    gcc \
+    zlib1g-dev \
+    git \
+    python \
+    python-dev \
+    python-pip \
+    python3-dev \
+    python3-pip \
+    python-sphinx \
+    python3-sphinx \
+    libzmq3-dev \
+    sqlite3 \
+    libsqlite3-dev \
+    pandoc \
+    libcurl4-openssl-dev \
+    nodejs \
+    nodejs-legacy \
+    npm
 
 # In order to build from source, need less
-RUN npm install -g less
+RUN npm install -g less@1.7.5
 
-RUN apt-get -y install fabric
+RUN pip install invoke
 
 RUN mkdir -p /srv/
 WORKDIR /srv/
@@ -37,10 +53,14 b' RUN chmod -R +rX /srv/ipython'
 
 # .[all] only works with -e, so use file://path#egg
 # Can't use -e because ipython2 and ipython3 will clobber each other
-RUN pip2 install --upgrade file:///srv/ipython#egg=ipython[all]
-RUN pip3 install --upgrade file:///srv/ipython#egg=ipython[all]
+RUN pip2 install file:///srv/ipython#egg=ipython[all]
+RUN pip3 install file:///srv/ipython#egg=ipython[all]
 
 # install kernels
 RUN python2 -m IPython kernelspec install-self --system
 RUN python3 -m IPython kernelspec install-self --system
 
+WORKDIR /tmp/
+
+RUN iptest2
+RUN iptest3

IPython/config/application.py

@@ -6,6 +6,7 b''
 
 from __future__ import print_function
 
+import json
 import logging
 import os
 import re
@@ -123,7 +124,16 b' class Application(SingletonConfigurable):'
 
     # A sequence of Configurable subclasses whose config=True attributes will
     # be exposed at the command line.
-    classes = List([])
+    classes = []
+    @property
+    def _help_classes(self):
+        """Define `App.help_classes` if CLI classes should differ from config file classes"""
+        return getattr(self, 'help_classes', self.classes)
+    
+    @property
+    def _config_classes(self):
+        """Define `App.config_classes` if config file classes should differ from CLI classes."""
+        return getattr(self, 'config_classes', self.classes)
 
     # The version string of this application.
     version = Unicode(u'0.0')
@@ -256,7 +266,7 b' class Application(SingletonConfigurable):'
 
         lines = []
         classdict = {}
-        for cls in self.classes:
+        for cls in self._help_classes:
             # include all parents (up to, but excluding Configurable) in available names
             for c in cls.mro()[:-3]:
                 classdict[c.__name__] = c
@@ -331,7 +341,8 b' class Application(SingletonConfigurable):'
         self.print_options()
 
         if classes:
-            if self.classes:
+            help_classes = self._help_classes
+            if help_classes:
                 print("Class parameters")
                 print("----------------")
                 print()
@@ -339,7 +350,7 b' class Application(SingletonConfigurable):'
                     print(p)
                     print()
 
-            for cls in self.classes:
+            for cls in help_classes:
                 cls.class_print_help()
                 print()
         else:
@@ -412,7 +423,7 b' class Application(SingletonConfigurable):'
         # it will be a dict by parent classname of classes in our list
         # that are descendents
         mro_tree = defaultdict(list)
-        for cls in self.classes:
+        for cls in self._help_classes:
             clsname = cls.__name__
             for parent in cls.mro()[1:-3]:
                 # exclude cls itself and Configurable,HasTraits,object
@@ -491,27 +502,32 b' class Application(SingletonConfigurable):'
 
         yield each config object in turn.
         """
-        pyloader = PyFileConfigLoader(basefilename+'.py', path=path, log=log)
-        jsonloader = JSONFileConfigLoader(basefilename+'.json', path=path, log=log)
-        config = None
-        for loader in [pyloader, jsonloader]:
-            try:
-                config = loader.load_config()
-            except ConfigFileNotFound:
-                pass
-            except Exception:
-                # try to get the full filename, but it will be empty in the
-                # unlikely event that the error raised before filefind finished
-                filename = loader.full_filename or basefilename
-                # problem while running the file
-                if log:
-                    log.error("Exception while loading config file %s",
-                            filename, exc_info=True)
-            else:
-                if log:
-                    log.debug("Loaded config file: %s", loader.full_filename)
-            if config:
-                 yield config
+        
+        if not isinstance(path, list):
+            path = [path]
+        for path in path[::-1]:
+            # path list is in descending priority order, so load files backwards:
+            pyloader = PyFileConfigLoader(basefilename+'.py', path=path, log=log)
+            jsonloader = JSONFileConfigLoader(basefilename+'.json', path=path, log=log)
+            config = None
+            for loader in [pyloader, jsonloader]:
+                try:
+                    config = loader.load_config()
+                except ConfigFileNotFound:
+                    pass
+                except Exception:
+                    # try to get the full filename, but it will be empty in the
+                    # unlikely event that the error raised before filefind finished
+                    filename = loader.full_filename or basefilename
+                    # problem while running the file
+                    if log:
+                        log.error("Exception while loading config file %s",
+                                filename, exc_info=True)
+                else:
+                    if log:
+                        log.debug("Loaded config file: %s", loader.full_filename)
+                if config:
+                     yield config
 
         raise StopIteration
 
@@ -520,8 +536,17 b' class Application(SingletonConfigurable):'
     def load_config_file(self, filename, path=None):
         """Load config files by filename and path."""
         filename, ext = os.path.splitext(filename)
+        loaded = []
         for config in self._load_config_files(filename, path=path, log=self.log):
+            loaded.append(config)
             self.update_config(config)
+        if len(loaded) > 1:
+            collisions = loaded[0].collisions(loaded[1])
+            if collisions:
+                self.log.warn("Collisions detected in {0}.py and {0}.json config files."
+                              " {0}.json has higher priority: {1}".format(
+                              filename, json.dumps(collisions, indent=2),
+                ))
 
 
     def generate_config_file(self):
@@ -530,7 +555,7 b' class Application(SingletonConfigurable):'
         lines.append('')
         lines.append('c = get_config()')
         lines.append('')
-        for cls in self.classes:
+        for cls in self._config_classes:
             lines.append(cls.class_config_section())
         return '\n'.join(lines)
 

IPython/config/loader.py

@@ -193,7 +193,27 b' class Config(dict):'
                     to_update[k] = copy.deepcopy(v)
 
         self.update(to_update)
-
+    
+    def collisions(self, other):
+        """Check for collisions between two config objects.
+        
+        Returns a dict of the form {"Class": {"trait": "collision message"}}`,
+        indicating which values have been ignored.
+        
+        An empty dict indicates no collisions.
+        """
+        collisions = {}
+        for section in self:
+            if section not in other:
+                continue
+            mine = self[section]
+            theirs = other[section]
+            for key in mine:
+                if key in theirs and mine[key] != theirs[key]:
+                    collisions.setdefault(section, {})
+                    collisions[section][key] = "%r ignored, using %r" % (mine[key], theirs[key])
+        return collisions
+    
     def __contains__(self, key):
         # allow nested contains of the form `"Section.key" in config`
         if '.' in key:
@@ -565,7 +585,7 b' class KeyValueConfigLoader(CommandLineConfigLoader):'
 
 
     def _decode_argv(self, argv, enc=None):
-        """decode argv if bytes, using stin.encoding, falling back on default enc"""
+        """decode argv if bytes, using stdin.encoding, falling back on default enc"""
         uargv = []
         if enc is None:
             enc = DEFAULT_ENCODING

IPython/config/tests/test_application.py

@@ -1,27 +1,18 b''
 # coding: utf-8
 """
 Tests for IPython.config.application.Application
-
-Authors:
-
-* Brian Granger
 """
 
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-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.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 import logging
+import os
 from io import StringIO
 from unittest import TestCase
 
+pjoin = os.path.join
+
 import nose.tools as nt
 
 from IPython.config.configurable import Configurable
@@ -31,13 +22,11 b' from IPython.config.application import ('
     Application
 )
 
+from IPython.utils.tempdir import TemporaryDirectory
 from IPython.utils.traitlets import (
     Bool, Unicode, Integer, List, Dict
 )
 
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
 
 class Foo(Configurable):
 
@@ -189,5 +178,21 b' class TestApplication(TestCase):'
     def test_unicode_argv(self):
         app = MyApp()
         app.parse_command_line(['ünîcødé'])
-        
+    
+    def test_multi_file(self):
+        app = MyApp()
+        app.log = logging.getLogger()
+        name = 'config.py'
+        with TemporaryDirectory('_1') as td1:
+            with open(pjoin(td1, name), 'w') as f1:
+                f1.write("get_config().MyApp.Bar.b = 1")
+            with TemporaryDirectory('_2') as td2:
+                with open(pjoin(td2, name), 'w') as f2:
+                    f2.write("get_config().MyApp.Bar.b = 2")
+                app.load_config_file(name, path=[td2, td1])
+                app.init_bar()
+                self.assertEqual(app.bar.b, 2)
+                app.load_config_file(name, path=[td1, td2])
+                app.init_bar()
+                self.assertEqual(app.bar.b, 1)
 

IPython/config/tests/test_loader.py

@@ -1,28 +1,12 b''
 # encoding: utf-8
-"""
-Tests for IPython.config.loader
-
-Authors:
-
-* Brian Granger
-* Fernando Perez (design help)
-"""
+"""Tests for IPython.config.loader"""
 
-#-----------------------------------------------------------------------------
-#  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.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 import os
 import pickle
 import sys
-import json
 
 from tempfile import mkstemp
 from unittest import TestCase
@@ -43,10 +27,6 b' from IPython.config.loader import ('
     ConfigError,
 )
 
-#-----------------------------------------------------------------------------
-# Actual tests
-#-----------------------------------------------------------------------------
-
 
 pyfile = """
 c = get_config()
@@ -117,6 +97,34 b' class TestFileCL(TestCase):'
         cl = JSONFileConfigLoader(fname, log=log)
         config = cl.load_config()
         self._check_conf(config)
+    
+    def test_collision(self):
+        a = Config()
+        b = Config()
+        self.assertEqual(a.collisions(b), {})
+        a.A.trait1 = 1
+        b.A.trait2 = 2
+        self.assertEqual(a.collisions(b), {})
+        b.A.trait1 = 1
+        self.assertEqual(a.collisions(b), {})
+        b.A.trait1 = 0
+        self.assertEqual(a.collisions(b), {
+            'A': {
+                'trait1': "1 ignored, using 0",
+            }
+        })
+        self.assertEqual(b.collisions(a), {
+            'A': {
+                'trait1': "0 ignored, using 1",
+            }
+        })
+        a.A.trait2 = 3
+        self.assertEqual(b.collisions(a), {
+            'A': {
+                'trait1': "0 ignored, using 1",
+                'trait2': "2 ignored, using 3",
+            }
+        })
 
     def test_v2raise(self):
         fd, fname = mkstemp('.json')

IPython/consoleapp.py

@@ -7,11 +7,6 b' refactoring of what used to be the IPython/qt/console/qtconsoleapp.py'
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-# stdlib imports
 import atexit
 import os
 import signal
@@ -19,7 +14,6 b' import sys'
 import uuid
 
 
-# Local imports
 from IPython.config.application import boolean_flag
 from IPython.core.profiledir import ProfileDir
 from IPython.kernel.blocking import BlockingKernelClient
@@ -40,18 +34,9 b' from IPython.kernel.zmq.session import Session, default_secure'
 from IPython.kernel.zmq.zmqshell import ZMQInteractiveShell
 from IPython.kernel.connect import ConnectionFileMixin
 
-#-----------------------------------------------------------------------------
-# Network Constants
-#-----------------------------------------------------------------------------
-
 from IPython.utils.localinterfaces import localhost
 
 #-----------------------------------------------------------------------------
-# Globals
-#-----------------------------------------------------------------------------
-
-
-#-----------------------------------------------------------------------------
 # Aliases and Flags
 #-----------------------------------------------------------------------------
 
@@ -98,11 +83,7 b' aliases.update(app_aliases)'
 # Classes
 #-----------------------------------------------------------------------------
 
-#-----------------------------------------------------------------------------
-# IPythonConsole
-#-----------------------------------------------------------------------------
-
-classes = [IPKernelApp, ZMQInteractiveShell, KernelManager, ProfileDir, Session, InlineBackend]
+classes = [KernelManager, ProfileDir, Session]
 
 class IPythonConsoleApp(ConnectionFileMixin):
     name = 'ipython-console-mixin'
@@ -158,8 +139,15 b' class IPythonConsoleApp(ConnectionFileMixin):'
         Set to display confirmation dialog on exit. You can always use 'exit' or 'quit',
         to force a direct exit without any confirmation.""",
     )
-
-
+    
+    @property
+    def help_classes(self):
+        """ConsoleApps can configure kernels on the command-line
+        
+        But this shouldn't be written to a file
+        """
+        return self.classes + [IPKernelApp] + IPKernelApp.classes
+    
     def build_kernel_argv(self, argv=None):
         """build argv to be passed to kernel subprocess"""
         if argv is None:
@@ -303,7 +291,11 b' class IPythonConsoleApp(ConnectionFileMixin):'
             self.exit(1)
 
         self.kernel_manager.client_factory = self.kernel_client_class
-        self.kernel_manager.start_kernel(extra_arguments=self.kernel_argv)
+        # FIXME: remove special treatment of IPython kernels
+        kwargs = {}
+        if self.kernel_manager.ipython_kernel:
+            kwargs['extra_arguments'] = self.kernel_argv
+        self.kernel_manager.start_kernel(**kwargs)
         atexit.register(self.kernel_manager.cleanup_ipc_files)
 
         if self.sshserver:

IPython/core/alias.py

@@ -69,6 +69,21 b' def default_aliases():'
                           # things which are executable
                           ('lx', 'ls -F -o --color %l | grep ^-..x'),
                           ]
+        elif sys.platform.startswith('openbsd') or sys.platform.startswith('netbsd'):
+            # OpenBSD, NetBSD. The ls implementation on these platforms do not support
+            # the -G switch and lack the ability to use colorized output.
+            ls_aliases = [('ls', 'ls -F'),
+                          # long ls
+                          ('ll', 'ls -F -l'),
+                          # ls normal files only
+                          ('lf', 'ls -F -l %l | grep ^-'),
+                          # ls symbolic links
+                          ('lk', 'ls -F -l %l | grep ^l'),
+                          # directories or links to directories,
+                          ('ldir', 'ls -F -l %l | grep /$'),
+                          # things which are executable
+                          ('lx', 'ls -F -l %l | grep ^-..x'),
+                          ]
         else:
             # BSD, OSX, etc.
             ls_aliases = [('ls', 'ls -F -G'),

IPython/core/application.py

@@ -7,25 +7,10 b' handling configuration and creating configurables.'
 
 The job of an :class:`Application` is to create the master configuration
 object and then create the configurable objects, passing the config to them.
-
-Authors:
-
-* Brian Granger
-* Fernando Perez
-* Min RK
-
 """
 
-#-----------------------------------------------------------------------------
-#  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.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 import atexit
 import glob
@@ -42,14 +27,18 b' from IPython.utils.path import get_ipython_dir, get_ipython_package_dir, ensure_'
 from IPython.utils import py3compat
 from IPython.utils.traitlets import List, Unicode, Type, Bool, Dict, Set, Instance
 
-#-----------------------------------------------------------------------------
-# Classes and functions
-#-----------------------------------------------------------------------------
-
+if os.name == 'nt':
+    programdata = os.environ.get('PROGRAMDATA', None)
+    if programdata:
+        SYSTEM_CONFIG_DIRS = [os.path.join(programdata, 'ipython')]
+    else:  # PROGRAMDATA is not defined by default on XP.
+        SYSTEM_CONFIG_DIRS = []
+else:
+    SYSTEM_CONFIG_DIRS = [
+        "/usr/local/etc/ipython",
+        "/etc/ipython",
+    ]
 
-#-----------------------------------------------------------------------------
-# Base Application Class
-#-----------------------------------------------------------------------------
 
 # aliases and flags
 
@@ -100,7 +89,7 b' class BaseIPythonApplication(Application):'
     builtin_profile_dir = Unicode(
         os.path.join(get_ipython_package_dir(), u'config', u'profile', u'default')
     )
-
+    
     config_file_paths = List(Unicode)
     def _config_file_paths_default(self):
         return [py3compat.getcwd()]
@@ -210,11 +199,12 b' class BaseIPythonApplication(Application):'
             return crashhandler.crash_handler_lite(etype, evalue, tb)
     
     def _ipython_dir_changed(self, name, old, new):
-        str_old = py3compat.cast_bytes_py2(os.path.abspath(old),
-            sys.getfilesystemencoding()
-        )
-        if str_old in sys.path:
-            sys.path.remove(str_old)
+        if old is not None:
+            str_old = py3compat.cast_bytes_py2(os.path.abspath(old),
+                sys.getfilesystemencoding()
+            )
+            if str_old in sys.path:
+                sys.path.remove(str_old)
         str_path = py3compat.cast_bytes_py2(os.path.abspath(new),
             sys.getfilesystemencoding()
         )
@@ -336,6 +326,7 b' class BaseIPythonApplication(Application):'
 
     def init_config_files(self):
         """[optionally] copy default config files into profile dir."""
+        self.config_file_paths.extend(SYSTEM_CONFIG_DIRS)
         # copy config files
         path = self.builtin_profile_dir
         if self.copy_config_files:

IPython/core/debugger.py

@@ -277,7 +277,7 b' class Pdb(OldPdb):'
             try:
                 OldPdb.interaction(self, frame, traceback)
             except KeyboardInterrupt:
-                self.shell.write("\nKeyboardInterrupt\n")
+                self.shell.write('\n' + self.shell.get_exception_only())
                 break
             else:
                 break

IPython/core/display.py

@@ -21,6 +21,7 b' from __future__ import print_function'
 
 import os
 import struct
+import mimetypes
 
 from IPython.core.formatters import _safe_get_formatter_method
 from IPython.utils.py3compat import (string_types, cast_bytes_py2, cast_unicode,
@@ -781,6 +782,90 b' class Image(DisplayObject):'
     def _find_ext(self, s):
         return unicode_type(s.split('.')[-1].lower())
 
+class Video(DisplayObject):
+
+    def __init__(self, data=None, url=None, filename=None, embed=None, mimetype=None):
+        """Create a video object given raw data or an URL.
+
+        When this object is returned by an input cell or passed to the
+        display function, it will result in the video being displayed
+        in the frontend.
+
+        Parameters
+        ----------
+        data : unicode, str or bytes
+            The raw image data or a URL or filename to load the data from.
+            This always results in embedded image data.
+        url : unicode
+            A URL to download the data from. If you specify `url=`,
+            the image data will not be embedded unless you also specify `embed=True`.
+        filename : unicode
+            Path to a local file to load the data from.
+            Videos from a file are always embedded.
+        embed : bool
+            Should the image data be embedded using a data URI (True) or be
+            loaded using an <img> tag. Set this to True if you want the image
+            to be viewable later with no internet connection in the notebook.
+
+            Default is `True`, unless the keyword argument `url` is set, then
+            default value is `False`.
+
+            Note that QtConsole is not able to display images if `embed` is set to `False`
+        mimetype: unicode
+            Specify the mimetype in case you load in a encoded video.
+        Examples
+        --------
+        Video('https://archive.org/download/Sita_Sings_the_Blues/Sita_Sings_the_Blues_small.mp4')
+        Video('path/to/video.mp4')
+        Video('path/to/video.mp4', embed=False)
+        """
+        if url is None and (data.startswith('http') or data.startswith('https')):
+            url = data
+            data = None
+            embed = False
+        elif os.path.exists(data):
+            filename = data
+            data = None
+
+        self.mimetype = mimetype
+        self.embed = embed if embed is not None else (filename is not None)
+        super(Video, self).__init__(data=data, url=url, filename=filename)
+
+    def _repr_html_(self):
+        # External URLs and potentially local files are not embedded into the
+        # notebook output.
+        if not self.embed:
+            url = self.url if self.url is not None else self.filename
+            output = """<video src="{0}" controls>
+      Your browser does not support the <code>video</code> element.
+    </video>""".format(url)
+            return output
+        # Embedded videos uses base64 encoded videos.
+        if self.filename is not None:
+            mimetypes.init()
+            mimetype, encoding = mimetypes.guess_type(self.filename)
+
+            video = open(self.filename, 'rb').read()
+            video_encoded = video.encode('base64')
+        else:
+            video_encoded = self.data
+            mimetype = self.mimetype
+        output = """<video controls>
+ <source src="data:{0};base64,{1}" type="{0}">
+ Your browser does not support the video tag.
+ </video>""".format(mimetype, video_encoded)
+        return output
+
+    def reload(self):
+        # TODO
+        pass
+
+    def _repr_png_(self):
+        # TODO
+        pass
+    def _repr_jpeg_(self):
+        # TODO
+        pass
 
 def clear_output(wait=False):
     """Clear the output of the current cell receiving output.

IPython/core/displayhook.py

@@ -2,25 +2,11 b''
 """Displayhook for IPython.
 
 This defines a callable class that IPython uses for `sys.displayhook`.
-
-Authors:
-
-* Fernando Perez
-* Brian Granger
-* Robert Kern
 """
 
-#-----------------------------------------------------------------------------
-#       Copyright (C) 2008-2011 The IPython Development Team
-#       Copyright (C) 2001-2007 Fernando Perez <[e-mail]>
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
 from __future__ import print_function
 
 import sys
@@ -29,13 +15,9 b' from IPython.core.formatters import _safe_get_formatter_method'
 from IPython.config.configurable import Configurable
 from IPython.utils import io
 from IPython.utils.py3compat import builtin_mod
-from IPython.utils.traitlets import Instance
+from IPython.utils.traitlets import Instance, Float
 from IPython.utils.warn import warn
 
-#-----------------------------------------------------------------------------
-# Main displayhook class
-#-----------------------------------------------------------------------------
-
 # TODO: Move the various attributes (cache_size, [others now moved]). Some
 # of these are also attributes of InteractiveShell. They should be on ONE object
 # only and the other objects should ask that one object for their values.
@@ -48,10 +30,10 b' class DisplayHook(Configurable):'
     """
 
     shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
+    cull_fraction = Float(0.2)
 
     def __init__(self, shell=None, cache_size=1000, **kwargs):
         super(DisplayHook, self).__init__(shell=shell, **kwargs)
-
         cache_size_min = 3
         if cache_size <= 0:
             self.do_full_cache = 0
@@ -168,6 +150,9 b' class DisplayHook(Configurable):'
         md_dict : dict (optional)
             The metadata dict to be associated with the display data.
         """
+        if 'text/plain' not in format_dict:
+            # nothing to do
+            return
         # We want to print because we want to always make sure we have a
         # newline, even if all the prompt separators are ''. This is the
         # standard IPython behavior.
@@ -193,13 +178,7 b' class DisplayHook(Configurable):'
         # Avoid recursive reference when displaying _oh/Out
         if result is not self.shell.user_ns['_oh']:
             if len(self.shell.user_ns['_oh']) >= self.cache_size and self.do_full_cache:
-                warn('Output cache limit (currently '+
-                      repr(self.cache_size)+' entries) hit.\n'
-                     'Flushing cache and resetting history counter...\n'
-                     'The only history variables available will be _,__,___ and _1\n'
-                     'with the current result.')
-
-                self.flush()
+                self.cull_cache()
             # Don't overwrite '_' and friends if '_' is in __builtin__ (otherwise
             # we cause buggy behavior for things like gettext).
 
@@ -221,6 +200,9 b' class DisplayHook(Configurable):'
 
     def log_output(self, format_dict):
         """Log the output."""
+        if 'text/plain' not in format_dict:
+            # nothing to do
+            return
         if self.shell.logger.log_output:
             self.shell.logger.log_write(format_dict['text/plain'], 'output')
         self.shell.history_manager.output_hist_reprs[self.prompt_count] = \
@@ -255,6 +237,21 b' class DisplayHook(Configurable):'
             self.log_output(format_dict)
             self.finish_displayhook()
 
+    def cull_cache(self):
+        """Output cache is full, cull the oldest entries"""
+        oh = self.shell.user_ns.get('_oh', {})
+        sz = len(oh)
+        cull_count = max(int(sz * self.cull_fraction), 2)
+        warn('Output cache limit (currently {sz} entries) hit.\n'
+             'Flushing oldest {cull_count} entries.'.format(sz=sz, cull_count=cull_count))
+        
+        for i, n in enumerate(sorted(oh)):
+            if i >= cull_count:
+                break
+            self.shell.user_ns.pop('_%i' % n, None)
+            oh.pop(n, None)
+        
+
     def flush(self):
         if not self.do_full_cache:
             raise ValueError("You shouldn't have reached the cache flush "

IPython/core/events.py

@@ -63,14 +63,6 b' class EventManager(object):'
         """Remove a callback from the given event."""
         self.callbacks[event].remove(function)
     
-    def reset(self, event):
-        """Clear all callbacks for the given event."""
-        self.callbacks[event] = []
-    
-    def reset_all(self):
-        """Clear all callbacks for all events."""
-        self.callbacks = {n:[] for n in self.callbacks}
-    
     def trigger(self, event, *args, **kwargs):
         """Call callbacks for ``event``.
         

IPython/core/formatters.py

@@ -5,35 +5,22 b' Inheritance diagram:'
 
 .. inheritance-diagram:: IPython.core.formatters
    :parts: 3
-
-Authors:
-
-* Robert Kern
-* Brian Granger
 """
-#-----------------------------------------------------------------------------
-# Copyright (C) 2010-2011, 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.
-#-----------------------------------------------------------------------------
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
-# Stdlib imports
 import abc
 import inspect
 import sys
+import traceback
 import types
 import warnings
 
 from IPython.external.decorator import decorator
 
-# Our own imports
 from IPython.config.configurable import Configurable
+from IPython.core.getipython import get_ipython
 from IPython.lib import pretty
 from IPython.utils.traitlets import (
     Bool, Dict, Integer, Unicode, CUnicode, ObjectName, List,
@@ -223,6 +210,18 b' class DisplayFormatter(Configurable):'
 # Formatters for specific format types (text, html, svg, etc.)
 #-----------------------------------------------------------------------------
 
+
+def _safe_repr(obj):
+    """Try to return a repr of an object
+
+    always returns a string, at least.
+    """
+    try:
+        return repr(obj)
+    except Exception as e:
+        return "un-repr-able object (%r)" % e
+
+
 class FormatterWarning(UserWarning):
     """Warning class for errors in formatters"""
 
@@ -231,13 +230,16 b' def warn_format_error(method, self, *args, **kwargs):'
     """decorator for warning on failed format call"""
     try:
         r = method(self, *args, **kwargs)
-    except NotImplementedError as e:
+    except NotImplementedError:
         # don't warn on NotImplementedErrors
         return None
-    except Exception as e:
-        warnings.warn("Exception in %s formatter: %s" % (self.format_type, e),
-            FormatterWarning,
-        )
+    except Exception:
+        exc_info = sys.exc_info()
+        ip = get_ipython()
+        if ip is not None:
+            ip.showtraceback(exc_info)
+        else:
+            traceback.print_exception(*exc_info)
         return None
     if r is None or isinstance(r, self._return_type) or \
         (isinstance(r, tuple) and r and isinstance(r[0], self._return_type)):
@@ -245,7 +247,7 b' def warn_format_error(method, self, *args, **kwargs):'
     else:
         warnings.warn(
             "%s formatter returned invalid type %s (expected %s) for object: %s" % \
-            (self.format_type, type(r), self._return_type, pretty._safe_repr(args[0])),
+            (self.format_type, type(r), self._return_type, _safe_repr(args[0])),
             FormatterWarning
         )
 
@@ -588,7 +590,14 b' class PlainTextFormatter(BaseFormatter):'
     # This subclass ignores this attribute as it always need to return
     # something.
     enabled = Bool(True, config=False)
-
+    
+    max_seq_length = Integer(pretty.MAX_SEQ_LENGTH, config=True,
+        help="""Truncate large collections (lists, dicts, tuples, sets) to this size.
+        
+        Set to 0 to disable truncation.
+        """
+    )
+    
     # Look for a _repr_pretty_ methods to use for pretty printing.
     print_method = ObjectName('_repr_pretty_')
 
@@ -672,7 +681,7 b' class PlainTextFormatter(BaseFormatter):'
     def __call__(self, obj):
         """Compute the pretty representation of the object."""
         if not self.pprint:
-            return pretty._safe_repr(obj)
+            return repr(obj)
         else:
             # This uses use StringIO, as cStringIO doesn't handle unicode.
             stream = StringIO()
@@ -681,6 +690,7 b' class PlainTextFormatter(BaseFormatter):'
             # or it will cause trouble.
             printer = pretty.RepresentationPrinter(stream, self.verbose,
                 self.max_width, unicode_to_str(self.newline),
+                max_seq_length=self.max_seq_length,
                 singleton_pprinters=self.singleton_printers,
                 type_pprinters=self.type_printers,
                 deferred_pprinters=self.deferred_printers)
@@ -836,6 +846,8 b' class PDFFormatter(BaseFormatter):'
 
     print_method = ObjectName('_repr_pdf_')
 
+    _return_type = (bytes, unicode_type)
+
 
 FormatterABC.register(BaseFormatter)
 FormatterABC.register(PlainTextFormatter)

IPython/core/history.py

@@ -98,9 +98,24 b' def catch_corrupt_db(f, self, *a, **kw):'
             # The hist_file is probably :memory: or something else.
             raise
         
+class HistoryAccessorBase(Configurable):
+    """An abstract class for History Accessors """
 
+    def get_tail(self, n=10, raw=True, output=False, include_latest=False):
+        raise NotImplementedError
+
+    def search(self, pattern="*", raw=True, search_raw=True,
+               output=False, n=None, unique=False):
+        raise NotImplementedError
+
+    def get_range(self, session, start=1, stop=None, raw=True,output=False):
+        raise NotImplementedError
 
-class HistoryAccessor(Configurable):
+    def get_range_by_str(self, rangestr, raw=True, output=False):
+        raise NotImplementedError
+
+
+class HistoryAccessor(HistoryAccessorBase):
     """Access the history database without adding to it.
     
     This is intended for use by standalone history tools. IPython shells use
@@ -544,7 +559,7 b' class HistoryManager(HistoryAccessor):'
             self.input_hist_parsed[:] = [""]
             self.input_hist_raw[:] = [""]
             self.new_session()
-    
+
     # ------------------------------
     # Methods for retrieving history
     # ------------------------------

IPython/core/inputsplitter.py

@@ -20,6 +20,7 b' import ast'
 import codeop
 import re
 import sys
+import warnings
 
 from IPython.utils.py3compat import cast_unicode
 from IPython.core.inputtransformer import (leading_indent,
@@ -208,6 +209,8 b' class InputSplitter(object):'
     _full_dedent = False
     # Boolean indicating whether the current block is complete
     _is_complete = None
+    # Boolean indicating whether the current block has an unrecoverable syntax error
+    _is_invalid = False
 
     def __init__(self):
         """Create a new InputSplitter instance.
@@ -223,6 +226,7 b' class InputSplitter(object):'
         self.source = ''
         self.code = None
         self._is_complete = False
+        self._is_invalid = False
         self._full_dedent = False
 
     def source_reset(self):
@@ -232,6 +236,42 b' class InputSplitter(object):'
         self.reset()
         return out
 
+    def check_complete(self, source):
+        """Return whether a block of code is ready to execute, or should be continued
+        
+        This is a non-stateful API, and will reset the state of this InputSplitter.
+        
+        Parameters
+        ----------
+        source : string
+          Python input code, which can be multiline.
+        
+        Returns
+        -------
+        status : str
+          One of 'complete', 'incomplete', or 'invalid' if source is not a
+          prefix of valid code.
+        indent_spaces : int or None
+          The number of spaces by which to indent the next line of code. If
+          status is not 'incomplete', this is None.
+        """
+        self.reset()
+        try:
+            self.push(source)
+        except SyntaxError:
+            # Transformers in IPythonInputSplitter can raise SyntaxError,
+            # which push() will not catch.
+            return 'invalid', None
+        else:
+            if self._is_invalid:
+                return 'invalid', None
+            elif self.push_accepts_more():
+                return 'incomplete', self.indent_spaces
+            else:
+                return 'complete', None
+        finally:
+            self.reset()
+
     def push(self, lines):
         """Push one or more lines of input.
 
@@ -261,6 +301,7 b' class InputSplitter(object):'
         # exception is raised in compilation, we don't mislead by having
         # inconsistent code/source attributes.
         self.code, self._is_complete = None, None
+        self._is_invalid = False
 
         # Honor termination lines properly
         if source.endswith('\\\n'):
@@ -268,15 +309,18 b' class InputSplitter(object):'
 
         self._update_indent(lines)
         try:
-            self.code = self._compile(source, symbol="exec")
+            with warnings.catch_warnings():
+                warnings.simplefilter('error', SyntaxWarning)
+                self.code = self._compile(source, symbol="exec")
         # Invalid syntax can produce any of a number of different errors from
         # inside the compiler, so we have to catch them all.  Syntax errors
         # immediately produce a 'ready' block, so the invalid Python can be
         # sent to the kernel for evaluation with possible ipython
         # special-syntax conversion.
         except (SyntaxError, OverflowError, ValueError, TypeError,
-                MemoryError):
+                MemoryError, SyntaxWarning):
             self._is_complete = True
+            self._is_invalid = True
         else:
             # Compilation didn't produce any exceptions (though it may not have
             # given a complete code object)

IPython/core/inputtransformer.py

@@ -461,7 +461,7 b' def classic_prompt():'
 def ipy_prompt():
     """Strip IPython's In [1]:/...: prompts."""
     # FIXME: non-capturing version (?:...) usable?
-    prompt_re = re.compile(r'^(In \[\d+\]: |\ {3,}\.{3,}: )')
+    prompt_re = re.compile(r'^(In \[\d+\]: |\s*\.{3,}: ?)')
     return _strip_prompts(prompt_re)
 
 

IPython/core/interactiveshell.py

@@ -22,6 +22,7 b' import re'
 import runpy
 import sys
 import tempfile
+import traceback
 import types
 import subprocess
 from io import open as io_open
@@ -424,7 +425,7 b' class InteractiveShell(SingletonConfigurable):'
     display_trap = Instance('IPython.core.display_trap.DisplayTrap')
     extension_manager = Instance('IPython.core.extensions.ExtensionManager')
     payload_manager = Instance('IPython.core.payload.PayloadManager')
-    history_manager = Instance('IPython.core.history.HistoryManager')
+    history_manager = Instance('IPython.core.history.HistoryAccessorBase')
     magics_manager = Instance('IPython.core.magic.MagicsManager')
 
     profile_dir = Instance('IPython.core.application.ProfileDir')
@@ -523,7 +524,6 b' class InteractiveShell(SingletonConfigurable):'
         self.init_pdb()
         self.init_extension_manager()
         self.init_payload()
-        self.init_comms()
         self.hooks.late_startup_hook()
         self.events.trigger('shell_initialized', self)
         atexit.register(self.atexit_operations)
@@ -874,6 +874,8 b' class InteractiveShell(SingletonConfigurable):'
     def init_events(self):
         self.events = EventManager(self, available_events)
 
+        self.events.register("pre_execute", self._clear_warning_registry)
+
     def register_post_execute(self, func):
         """DEPRECATED: Use ip.events.register('post_run_cell', func)
         
@@ -883,6 +885,13 b' class InteractiveShell(SingletonConfigurable):'
              "ip.events.register('post_run_cell', func) instead.")
         self.events.register('post_run_cell', func)
     
+    def _clear_warning_registry(self):
+        # clear the warning registry, so that different code blocks with
+        # overlapping line number ranges don't cause spurious suppression of
+        # warnings (see gh-6611 for details)
+        if "__warningregistry__" in self.user_global_ns:
+            del self.user_global_ns["__warningregistry__"]
+
     #-------------------------------------------------------------------------
     # Things related to the "main" module
     #-------------------------------------------------------------------------
@@ -1778,6 +1787,15 b' class InteractiveShell(SingletonConfigurable):'
         """
         self.write_err("UsageError: %s" % exc)
     
+    def get_exception_only(self, exc_tuple=None):
+        """
+        Return as a string (ending with a newline) the exception that
+        just occurred, without any traceback.
+        """
+        etype, value, tb = self._get_exc_info(exc_tuple)
+        msg = traceback.format_exception_only(etype, value)
+        return ''.join(msg)
+
     def showtraceback(self, exc_tuple=None, filename=None, tb_offset=None,
                       exception_only=False):
         """Display the exception that just occurred.
@@ -1830,7 +1848,7 b' class InteractiveShell(SingletonConfigurable):'
                 self._showtraceback(etype, value, stb)
 
         except KeyboardInterrupt:
-            self.write_err("\nKeyboardInterrupt\n")
+            self.write_err('\n' + self.get_exception_only())
 
     def _showtraceback(self, etype, evalue, stb):
         """Actually show a traceback.
@@ -2344,22 +2362,38 b' class InteractiveShell(SingletonConfigurable):'
                 if path is not None:
                     cmd = '"pushd %s &&"%s' % (path, cmd)
                 cmd = py3compat.unicode_to_str(cmd)
-                ec = os.system(cmd)
+                try:
+                    ec = os.system(cmd)
+                except KeyboardInterrupt:
+                    self.write_err('\n' + self.get_exception_only())
+                    ec = -2
         else:
             cmd = py3compat.unicode_to_str(cmd)
-            # Call the cmd using the OS shell, instead of the default /bin/sh, if set.
-            ec = subprocess.call(cmd, shell=True, executable=os.environ.get('SHELL', None))
-            # exit code is positive for program failure, or negative for
-            # terminating signal number.
-            
-            # Interpret ec > 128 as signal
-            # Some shells (csh, fish) don't follow sh/bash conventions for exit codes
+            # For posix the result of the subprocess.call() below is an exit
+            # code, which by convention is zero for success, positive for
+            # program failure.  Exit codes above 128 are reserved for signals,
+            # and the formula for converting a signal to an exit code is usually
+            # signal_number+128.  To more easily differentiate between exit
+            # codes and signals, ipython uses negative numbers.  For instance
+            # since control-c is signal 2 but exit code 130, ipython's
+            # _exit_code variable will read -2.  Note that some shells like
+            # csh and fish don't follow sh/bash conventions for exit codes.
+            executable = os.environ.get('SHELL', None)
+            try:
+                # Use env shell instead of default /bin/sh
+                ec = subprocess.call(cmd, shell=True, executable=executable)
+            except KeyboardInterrupt:
+                # intercept control-C; a long traceback is not useful here
+                self.write_err('\n' + self.get_exception_only())
+                ec = 130
             if ec > 128:
                 ec = -(ec - 128)
         
         # We explicitly do NOT return the subprocess status code, because
         # a non-None value would trigger :func:`sys.displayhook` calls.
-        # Instead, we store the exit_code in user_ns.
+        # Instead, we store the exit_code in user_ns.  Note the semantics
+        # of _exit_code: for control-c, _exit_code == -signal.SIGNIT,
+        # but raising SystemExit(_exit_code) will give status 254!
         self.user_ns['_exit_code'] = ec
 
     # use piped system by default, because it is better behaved
@@ -2419,14 +2453,6 b' class InteractiveShell(SingletonConfigurable):'
         self.configurables.append(self.payload_manager)
     
     #-------------------------------------------------------------------------
-    # Things related to widgets
-    #-------------------------------------------------------------------------
-    
-    def init_comms(self):
-        # not implemented in the base class
-        pass
-    
-    #-------------------------------------------------------------------------
     # Things related to the prefilter
     #-------------------------------------------------------------------------
 
@@ -2565,10 +2591,16 b' class InteractiveShell(SingletonConfigurable):'
             silenced for zero status, as it is so common).
         raise_exceptions : bool (False)
             If True raise exceptions everywhere. Meant for testing.
+        shell_futures : bool (False)
+            If True, the code will share future statements with the interactive
+            shell. It will both be affected by previous __future__ imports, and
+            any __future__ imports in the code will affect the shell. If False,
+            __future__ imports are not shared in either direction.
 
         """
         kw.setdefault('exit_ignore', False)
         kw.setdefault('raise_exceptions', False)
+        kw.setdefault('shell_futures', False)
 
         fname = os.path.abspath(os.path.expanduser(fname))
 
@@ -2587,7 +2619,10 b' class InteractiveShell(SingletonConfigurable):'
 
         with prepended_to_syspath(dname):
             try:
-                py3compat.execfile(fname,*where)
+                glob, loc = (where + (None, ))[:2]
+                py3compat.execfile(
+                    fname, glob, loc,
+                    self.compile if kw['shell_futures'] else None)
             except SystemExit as status:
                 # If the call was made with 0 or None exit status (sys.exit(0)
                 # or sys.exit() ), don't bother showing a traceback, as both of
@@ -2608,7 +2643,7 b' class InteractiveShell(SingletonConfigurable):'
                 # tb offset is 2 because we wrap execfile
                 self.showtraceback(tb_offset=2)
 
-    def safe_execfile_ipy(self, fname):
+    def safe_execfile_ipy(self, fname, shell_futures=False):
         """Like safe_execfile, but for .ipy or .ipynb files with IPython syntax.
 
         Parameters
@@ -2616,6 +2651,11 b' class InteractiveShell(SingletonConfigurable):'
         fname : str
             The name of the file to execute.  The filename must have a
             .ipy or .ipynb extension.
+        shell_futures : bool (False)
+            If True, the code will share future statements with the interactive
+            shell. It will both be affected by previous __future__ imports, and
+            any __future__ imports in the code will affect the shell. If False,
+            __future__ imports are not shared in either direction.
         """
         fname = os.path.abspath(os.path.expanduser(fname))
 
@@ -2635,14 +2675,14 b' class InteractiveShell(SingletonConfigurable):'
         def get_cells():
             """generator for sequence of code blocks to run"""
             if fname.endswith('.ipynb'):
-                from IPython.nbformat import current
-                with open(fname) as f:
-                    nb = current.read(f, 'json')
-                    if not nb.worksheets:
+                from IPython.nbformat import read
+                with io_open(fname) as f:
+                    nb = read(f, as_version=4)
+                    if not nb.cells:
                         return
-                    for cell in nb.worksheets[0].cells:
+                    for cell in nb.cells:
                         if cell.cell_type == 'code':
-                            yield cell.input
+                            yield cell.source
             else:
                 with open(fname) as f:
                     yield f.read()
@@ -2654,7 +2694,7 b' class InteractiveShell(SingletonConfigurable):'
                     # raised in user code.  It would be nice if there were
                     # versions of run_cell that did raise, so
                     # we could catch the errors.
-                    self.run_cell(cell, silent=True, shell_futures=False)
+                    self.run_cell(cell, silent=True, shell_futures=shell_futures)
             except:
                 self.showtraceback()
                 warn('Unknown failure executing file: <%s>' % fname)
@@ -3072,7 +3112,15 b' class InteractiveShell(SingletonConfigurable):'
         namespace.
         """
         ns = self.user_ns.copy()
-        ns.update(sys._getframe(depth+1).f_locals)
+        try:
+            frame = sys._getframe(depth+1)
+        except ValueError:
+            # This is thrown if there aren't that many frames on the stack,
+            # e.g. if a script called run_line_magic() directly.
+            pass
+        else:
+            ns.update(frame.f_locals)
+
         try:
             # We have to use .vformat() here, because 'self' is a valid and common
             # name, and expanding **ns for .format() would make it collide with

IPython/core/magics/basic.py

@@ -1,25 +1,12 b''
-"""Implementation of basic magic functions.
-"""
-#-----------------------------------------------------------------------------
-#  Copyright (c) 2012 The 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.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+"""Implementation of basic magic functions."""
+
 from __future__ import print_function
 
-# Stdlib
 import io
 import json
 import sys
 from pprint import pformat
 
-# Our own packages
 from IPython.core import magic_arguments, page
 from IPython.core.error import UsageError
 from IPython.core.magic import Magics, magics_class, line_magic, magic_escapes
@@ -30,9 +17,6 b' from IPython.utils.path import unquote_filename'
 from IPython.utils.py3compat import unicode_type
 from IPython.utils.warn import warn, error
 
-#-----------------------------------------------------------------------------
-# Magics class implementation
-#-----------------------------------------------------------------------------
 
 class MagicsDisplay(object):
     def __init__(self, magics_manager):
@@ -362,9 +346,6 b' Currently the magic system has the following functions:""",'
 Proper color support under MS Windows requires the pyreadline library.
 You can find it at:
 http://ipython.org/pyreadline.html
-Gary's readline needs the ctypes module, from:
-http://starship.python.net/crew/theller/ctypes
-(Note that ctypes is already part of Python versions 2.5 and newer).
 
 Defaulting color scheme to 'NoColor'"""
             new_scheme = 'NoColor'
@@ -602,13 +583,6 b' Defaulting color scheme to \'NoColor\'"""'
              'file extension will write the notebook as a Python script'
     )
     @magic_arguments.argument(
-        '-f', '--format',
-        help='Convert an existing IPython notebook to a new format. This option '
-             'specifies the new format and can have the values: json, py. '
-             'The target filename is chosen automatically based on the new '
-             'format. The filename argument gives the name of the source file.'
-    )
-    @magic_arguments.argument(
         'filename', type=unicode_type,
         help='Notebook name or filename'
     )
@@ -616,41 +590,22 b' Defaulting color scheme to \'NoColor\'"""'
     def notebook(self, s):
         """Export and convert IPython notebooks.
 
-        This function can export the current IPython history to a notebook file
-        or can convert an existing notebook file into a different format. For
-        example, to export the history to "foo.ipynb" do "%notebook -e foo.ipynb".
-        To export the history to "foo.py" do "%notebook -e foo.py". To convert
-        "foo.ipynb" to "foo.json" do "%notebook -f json foo.ipynb". Possible
-        formats include (json/ipynb, py).
+        This function can export the current IPython history to a notebook file.
+        For example, to export the history to "foo.ipynb" do "%notebook -e foo.ipynb".
+        To export the history to "foo.py" do "%notebook -e foo.py".
         """
         args = magic_arguments.parse_argstring(self.notebook, s)
 
-        from IPython.nbformat import current
+        from IPython.nbformat import write, v4
         args.filename = unquote_filename(args.filename)
         if args.export:
-            fname, name, format = current.parse_filename(args.filename)
             cells = []
             hist = list(self.shell.history_manager.get_range())
-            for session, prompt_number, input in hist[:-1]:
-                cells.append(current.new_code_cell(prompt_number=prompt_number,
-                                                   input=input))
-            worksheet = current.new_worksheet(cells=cells)
-            nb = current.new_notebook(name=name,worksheets=[worksheet])
-            with io.open(fname, 'w', encoding='utf-8') as f:
-                current.write(nb, f, format);
-        elif args.format is not None:
-            old_fname, old_name, old_format = current.parse_filename(args.filename)
-            new_format = args.format
-            if new_format == u'xml':
-                raise ValueError('Notebooks cannot be written as xml.')
-            elif new_format == u'ipynb' or new_format == u'json':
-                new_fname = old_name + u'.ipynb'
-                new_format = u'json'
-            elif new_format == u'py':
-                new_fname = old_name + u'.py'
-            else:
-                raise ValueError('Invalid notebook format: %s' % new_format)
-            with io.open(old_fname, 'r', encoding='utf-8') as f:
-                nb = current.read(f, old_format)
-            with io.open(new_fname, 'w', encoding='utf-8') as f:
-                current.write(nb, f, new_format)
+            for session, execution_count, input in hist[:-1]:
+                cells.append(v4.new_code_cell(
+                    execution_count=execution_count,
+                    source=source
+                ))
+            nb = v4.new_notebook(cells=cells)
+            with io.open(args.filename, 'w', encoding='utf-8') as f:
+                write(nb, f, version=4)

IPython/core/magics/execution.py

@@ -1027,7 +1027,10 b' python-profiler package from non-free.""")'
                 worst = max(worst, worst_tuning)
             # Check best timing is greater than zero to avoid a
             # ZeroDivisionError.
-            if worst > 4 * best and best > 0:
+            # In cases where the slowest timing is lesser than a micosecond
+            # we assume that it does not really matter if the fastest
+            # timing is 4 times faster than the slowest timing or not.
+            if worst > 4 * best and best > 0 and worst > 1e-6:
                 print("The slowest run took %0.2f times longer than the "
                       "fastest. This could mean that an intermediate result "
                       "is being cached " % (worst / best))
@@ -1057,7 +1060,7 b' python-profiler package from non-free.""")'
           following statement raises an error).
 
         This function provides very basic timing functionality.  Use the timeit 
-        magic for more controll over the measurement.
+        magic for more control over the measurement.
 
         Examples
         --------

IPython/core/magics/osm.py

@@ -371,14 +371,52 b' class OSMagics(Magics):'
         if not 'q' in opts and self.shell.user_ns['_dh']:
             print(self.shell.user_ns['_dh'][-1])
 
-
     @line_magic
     def env(self, parameter_s=''):
         """List environment variables."""
-
+        if parameter_s.strip():
+            split = '=' if '=' in parameter_s else ' '
+            bits = parameter_s.split(split)
+            if len(bits) == 1:
+                key = parameter_s.strip()
+                if key in os.environ:
+                    return os.environ[key]
+                else:
+                    err = "Environment does not have key: {0}".format(key)
+                    raise UsageError(err)
+            if len(bits) > 1:
+                return self.set_env(parameter_s)
         return dict(os.environ)
 
     @line_magic
+    def set_env(self, parameter_s):
+        """Set environment variables.  Assumptions are that either "val" is a
+        name in the user namespace, or val is something that evaluates to a
+        string.
+
+        Usage:\\
+        %set_env var val
+        """
+        split = '=' if '=' in parameter_s else ' '
+        bits = parameter_s.split(split, 1)
+        if not parameter_s.strip() or len(bits)<2:
+            raise UsageError("usage is 'set_env var=val'")
+        var = bits[0].strip()
+        val = bits[1].strip()
+        if re.match(r'.*\s.*', var):
+            # an environment variable with whitespace is almost certainly
+            # not what the user intended.  what's more likely is the wrong
+            # split was chosen, ie for "set_env cmd_args A=B", we chose
+            # '=' for the split and should have chosen ' '.  to get around
+            # this, users should just assign directly to os.environ or use
+            # standard magic {var} expansion.
+            err = "refusing to set env var with whitespace: '{0}'"
+            err = err.format(val)
+            raise UsageError(err)
+        os.environ[py3compat.cast_bytes_py2(var)] = py3compat.cast_bytes_py2(val)
+        print('env: {0}={1}'.format(var,val))
+
+    @line_magic
     def pushd(self, parameter_s=''):
         """Place the current dir on stack and change directory.
 

IPython/core/oinspect.py

@@ -40,6 +40,7 b' from IPython.utils.text import indent'
 from IPython.utils.wildcard import list_namespace
 from IPython.utils.coloransi import TermColors, ColorScheme, ColorSchemeTable
 from IPython.utils.py3compat import cast_unicode, string_types, PY3
+from IPython.utils.signatures import signature
 
 # builtin docstrings to ignore
 _func_call_docstring = types.FunctionType.__call__.__doc__
@@ -390,7 +391,7 b' class Inspector:'
         If any exception is generated, None is returned instead and the
         exception is suppressed."""
         try:
-            hdef = oname + inspect.formatargspec(*getargspec(obj))
+            hdef = oname + str(signature(obj))
             return cast_unicode(hdef)
         except:
             return None

IPython/core/payloadpage.py

@@ -38,7 +38,6 b' def page(strng, start=0, screen_lines=0, pager_cmd=None):'
         source='page',
         data=data,
         start=start,
-        screen_lines=screen_lines,
         )
     shell.payload_manager.write_payload(payload)
 

IPython/core/profileapp.py

@@ -261,6 +261,8 b' class ProfileCreate(BaseIPythonApplication):'
         from IPython.terminal.ipapp import TerminalIPythonApp
         apps = [TerminalIPythonApp]
         for app_path in (
+            'IPython.kernel.zmq.kernelapp.IPKernelApp',
+            'IPython.terminal.console.app.ZMQTerminalIPythonApp',
             'IPython.qt.console.qtconsoleapp.IPythonQtConsoleApp',
             'IPython.html.notebookapp.NotebookApp',
             'IPython.nbconvert.nbconvertapp.NbConvertApp',

IPython/core/pylabtools.py

@@ -1,24 +1,9 b''
 # -*- coding: utf-8 -*-
-"""Pylab (matplotlib) support utilities.
-
-Authors
--------
-
-* Fernando Perez.
-* Brian Granger
-"""
+"""Pylab (matplotlib) support utilities."""
 from __future__ import print_function
 
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2009  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.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 from io import BytesIO
 
@@ -34,7 +19,9 b" backends = {'tk': 'TkAgg',"
             'wx': 'WXAgg',
             'qt': 'Qt4Agg', # qt3 not supported
             'qt4': 'Qt4Agg',
+            'qt5': 'Qt5Agg',
             'osx': 'MacOSX',
+            'nbagg': 'nbAgg',
             'inline' : 'module://IPython.kernel.zmq.pylab.backend_inline'}
 
 # We also need a reverse backends2guis mapping that will properly choose which

IPython/core/shellapp.py

@@ -324,7 +324,7 b' class InteractiveShellApp(Configurable):'
             self.log.warn("Unknown error in handling IPythonApp.exec_lines:")
             self.shell.showtraceback()
 
-    def _exec_file(self, fname):
+    def _exec_file(self, fname, shell_futures=False):
         try:
             full_filename = filefind(fname, [u'.', self.ipython_dir])
         except IOError as e:
@@ -346,11 +346,13 b' class InteractiveShellApp(Configurable):'
                 with preserve_keys(self.shell.user_ns, '__file__'):
                     self.shell.user_ns['__file__'] = fname
                     if full_filename.endswith('.ipy'):
-                        self.shell.safe_execfile_ipy(full_filename)
+                        self.shell.safe_execfile_ipy(full_filename,
+                                                     shell_futures=shell_futures)
                     else:
                         # default to python, even without extension
                         self.shell.safe_execfile(full_filename,
-                                                 self.shell.user_ns)
+                                                 self.shell.user_ns,
+                                                 shell_futures=shell_futures)
         finally:
             sys.argv = save_argv
 
@@ -418,7 +420,7 b' class InteractiveShellApp(Configurable):'
         elif self.file_to_run:
             fname = self.file_to_run
             try:
-                self._exec_file(fname)
+                self._exec_file(fname, shell_futures=True)
             except:
                 self.log.warn("Error in executing file in user namespace: %s" %
                               fname)

IPython/core/tests/test_display.py

@@ -52,9 +52,9 b' def test_image_filename_defaults():'
     nt.assert_raises(ValueError, display.Image, data='this is not an image', format='badformat', embed=True)
     from IPython.html import DEFAULT_STATIC_FILES_PATH
     # check boths paths to allow packages to test at build and install time
-    imgfile = os.path.join(tpath, 'html/static/base/images/ipynblogo.png')
+    imgfile = os.path.join(tpath, 'html/static/base/images/logo.png')
     if not os.path.exists(imgfile):
-        imgfile = os.path.join(DEFAULT_STATIC_FILES_PATH, 'base/images/ipynblogo.png')
+        imgfile = os.path.join(DEFAULT_STATIC_FILES_PATH, 'base/images/logo.png')
     img = display.Image(filename=imgfile)
     nt.assert_equal('png', img.format)
     nt.assert_is_not_none(img._repr_png_())

IPython/core/tests/test_events.py

@@ -25,22 +25,8 b' class CallbackTests(unittest.TestCase):'
         self.em.trigger('ping_received')
         self.assertEqual(cb.call_count, 1)
     
-    def test_reset(self):
-        cb = Mock()
-        self.em.register('ping_received', cb)
-        self.em.reset('ping_received')
-        self.em.trigger('ping_received')
-        assert not cb.called
-    
-    def test_reset_all(self):
-        cb = Mock()
-        self.em.register('ping_received', cb)
-        self.em.reset_all()
-        self.em.trigger('ping_received')
-        assert not cb.called
-    
     def test_cb_error(self):
         cb = Mock(side_effect=ValueError)
         self.em.register('ping_received', cb)
         with tt.AssertPrints("Error in callback"):
-            self.em.trigger('ping_received')
  No newline at end of file
+            self.em.trigger('ping_received')

IPython/core/tests/test_formatters.py

@@ -25,6 +25,10 b' class B(A):'
 class C:
     pass
 
+class BadRepr(object):
+    def __repr__(self):
+        raise ValueError("bad repr")
+
 class BadPretty(object):
     _repr_pretty_ = None
 
@@ -234,30 +238,30 b' def test_pop_string():'
     nt.assert_is(f.pop(type_str, None), None)
     
 
-def test_warn_error_method():
+def test_error_method():
     f = HTMLFormatter()
     class BadHTML(object):
         def _repr_html_(self):
-            return 1/0
+            raise ValueError("Bad HTML")
     bad = BadHTML()
     with capture_output() as captured:
         result = f(bad)
     nt.assert_is(result, None)
-    nt.assert_in("FormatterWarning", captured.stderr)
-    nt.assert_in("text/html", captured.stderr)
-    nt.assert_in("zero", captured.stderr)
+    nt.assert_in("Traceback", captured.stdout)
+    nt.assert_in("Bad HTML", captured.stdout)
+    nt.assert_in("_repr_html_", captured.stdout)
 
 def test_nowarn_notimplemented():
     f = HTMLFormatter()
     class HTMLNotImplemented(object):
         def _repr_html_(self):
             raise NotImplementedError
-            return 1/0
     h = HTMLNotImplemented()
     with capture_output() as captured:
         result = f(h)
     nt.assert_is(result, None)
-    nt.assert_not_in("FormatterWarning", captured.stderr)
+    nt.assert_equal("", captured.stderr)
+    nt.assert_equal("", captured.stdout)
 
 def test_warn_error_for_type():
     f = HTMLFormatter()
@@ -265,11 +269,11 b' def test_warn_error_for_type():'
     with capture_output() as captured:
         result = f(5)
     nt.assert_is(result, None)
-    nt.assert_in("FormatterWarning", captured.stderr)
-    nt.assert_in("text/html", captured.stderr)
-    nt.assert_in("name_error", captured.stderr)
+    nt.assert_in("Traceback", captured.stdout)
+    nt.assert_in("NameError", captured.stdout)
+    nt.assert_in("name_error", captured.stdout)
 
-def test_warn_error_pretty_method():
+def test_error_pretty_method():
     f = PlainTextFormatter()
     class BadPretty(object):
         def _repr_pretty_(self):
@@ -278,9 +282,23 b' def test_warn_error_pretty_method():'
     with capture_output() as captured:
         result = f(bad)
     nt.assert_is(result, None)
-    nt.assert_in("FormatterWarning", captured.stderr)
-    nt.assert_in("text/plain", captured.stderr)
-    nt.assert_in("argument", captured.stderr)
+    nt.assert_in("Traceback", captured.stdout)
+    nt.assert_in("_repr_pretty_", captured.stdout)
+    nt.assert_in("given", captured.stdout)
+    nt.assert_in("argument", captured.stdout)
+
+
+def test_bad_repr_traceback():
+    f = PlainTextFormatter()
+    bad = BadRepr()
+    with capture_output() as captured:
+        result = f(bad)
+    # catches error, returns None
+    nt.assert_is(result, None)
+    nt.assert_in("Traceback", captured.stdout)
+    nt.assert_in("__repr__", captured.stdout)
+    nt.assert_in("ValueError", captured.stdout)
+
 
 class MakePDF(object):
     def _repr_pdf_(self):
@@ -320,3 +338,15 b' def test_format_config():'
         result = f(Config)
     nt.assert_is(result, None)
     nt.assert_equal(captured.stderr, "")
+
+def test_pretty_max_seq_length():
+    f = PlainTextFormatter(max_seq_length=1)
+    lis = list(range(3))
+    text = f(lis)
+    nt.assert_equal(text, '[0, ...]')
+    f.max_seq_length = 0
+    text = f(lis)
+    nt.assert_equal(text, '[0, 1, 2]')
+    text = f(list(range(1024)))
+    lines = text.splitlines()
+    nt.assert_equal(len(lines), 1024)

IPython/core/tests/test_inputsplitter.py

@@ -342,6 +342,14 b' class InputSplitterTestCase(unittest.TestCase):'
         isp.push(r"(1 \ ")
         self.assertFalse(isp.push_accepts_more())
 
+    def test_check_complete(self):
+        isp = self.isp
+        self.assertEqual(isp.check_complete("a = 1"), ('complete', None))
+        self.assertEqual(isp.check_complete("for a in range(5):"), ('incomplete', 4))
+        self.assertEqual(isp.check_complete("raise = 2"), ('invalid', None))
+        self.assertEqual(isp.check_complete("a = [1,\n2,"), ('incomplete', 0))
+        self.assertEqual(isp.check_complete("def a():\n x=1\n global x"), ('invalid', None))
+
 class InteractiveLoopTestCase(unittest.TestCase):
     """Tests for an interactive loop like a python shell.
     """

IPython/core/tests/test_inputtransformer.py

@@ -228,6 +228,16 b' syntax_ml = \\'
           ('    ...:     print i','    print i'),
           ('    ...: ', ''),
           ],
+         [('In [24]: for i in range(10):','for i in range(10):'),
+          # Sometimes whitespace preceding '...' has been removed
+          ('...:     print i','    print i'),
+          ('...: ', ''),
+          ],
+         [('In [24]: for i in range(10):','for i in range(10):'),
+          # Space after last continuation prompt has been removed (issue #6674)
+          ('...:     print i','    print i'),
+          ('...:', ''),
+          ],
          [('In [2]: a="""','a="""'),
           ('   ...: 123"""','123"""'),
           ],

IPython/core/tests/test_interactiveshell.py

@@ -301,7 +301,10 b' class InteractiveShellTestCase(unittest.TestCase):'
             assert post_explicit.called
         finally:
             # remove post-exec
-            ip.events.reset_all()
+            ip.events.unregister('pre_run_cell', pre_explicit)
+            ip.events.unregister('pre_execute', pre_always)
+            ip.events.unregister('post_run_cell', post_explicit)
+            ip.events.unregister('post_execute', post_always)
     
     def test_silent_noadvance(self):
         """run_cell(silent=True) doesn't advance execution_count"""
@@ -479,6 +482,24 b' class InteractiveShellTestCase(unittest.TestCase):'
         mod = ip.new_main_mod(u'%s.py' % name, name)
         self.assertEqual(mod.__name__, name)
 
+    def test_get_exception_only(self):
+        try:
+            raise KeyboardInterrupt
+        except KeyboardInterrupt:
+            msg = ip.get_exception_only()
+        self.assertEqual(msg, 'KeyboardInterrupt\n')
+
+        class DerivedInterrupt(KeyboardInterrupt):
+            pass
+        try:
+            raise DerivedInterrupt("foo")
+        except KeyboardInterrupt:
+            msg = ip.get_exception_only()
+        if sys.version_info[0] <= 2:
+            self.assertEqual(msg, 'DerivedInterrupt: foo\n')
+        else:
+            self.assertEqual(msg, 'IPython.core.tests.test_interactiveshell.DerivedInterrupt: foo\n')
+
 class TestSafeExecfileNonAsciiPath(unittest.TestCase):
 
     @onlyif_unicode_paths
@@ -541,6 +562,16 b' class TestSystemRaw(unittest.TestCase, ExitCodeChecks):'
         cmd = u'''python -c "'åäö'"   '''
         ip.system_raw(cmd)
 
+    @mock.patch('subprocess.call', side_effect=KeyboardInterrupt)
+    @mock.patch('os.system', side_effect=KeyboardInterrupt)
+    def test_control_c(self, *mocks):
+        try:
+            self.system("sleep 1 # wont happen")
+        except KeyboardInterrupt:
+            self.fail("system call should intercept "
+                      "keyboard interrupt from subprocess.call")
+        self.assertEqual(ip.user_ns['_exit_code'], -signal.SIGINT)
+
 # TODO: Exit codes are currently ignored on Windows.
 class TestSystemPipedExitCode(unittest.TestCase, ExitCodeChecks):
     system = ip.system_piped
@@ -840,3 +871,17 b' class TestSyntaxErrorTransformer(unittest.TestCase):'
 
 
 
+def test_warning_suppression():
+    ip.run_cell("import warnings")
+    try:
+        with tt.AssertPrints("UserWarning: asdf", channel="stderr"):
+            ip.run_cell("warnings.warn('asdf')")
+        # Here's the real test -- if we run that again, we should get the
+        # warning again. Traditionally, each warning was only issued once per
+        # IPython session (approximately), even if the user typed in new and
+        # different code that should have also triggered the warning, leading
+        # to much confusion.
+        with tt.AssertPrints("UserWarning: asdf", channel="stderr"):
+            ip.run_cell("warnings.warn('asdf')")
+    finally:
+        ip.run_cell("del warnings")

IPython/core/tests/test_magic.py

@@ -5,10 +5,6 b' Needs to be run by nose (to make ipython session available).'
 """
 from __future__ import absolute_import
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
 import io
 import os
 import sys
@@ -23,6 +19,7 b' except ImportError:'
 import nose.tools as nt
 
 from IPython.core import magic
+from IPython.core.error import UsageError
 from IPython.core.magic import (Magics, magics_class, line_magic,
                                 cell_magic, line_cell_magic,
                                 register_line_magic, register_cell_magic,
@@ -40,9 +37,6 b' if py3compat.PY3:'
 else:
     from StringIO import StringIO
 
-#-----------------------------------------------------------------------------
-# Test functions begin
-#-----------------------------------------------------------------------------
 
 @magic.magics_class
 class DummyMagics(magic.Magics): pass
@@ -624,7 +618,7 b' def test_extension():'
 
 
 # The nose skip decorator doesn't work on classes, so this uses unittest's skipIf
-@skipIf(dec.module_not_available('IPython.nbformat.current'), 'nbformat not importable')
+@skipIf(dec.module_not_available('IPython.nbformat'), 'nbformat not importable')
 class NotebookExportMagicTests(TestCase):
     def test_notebook_export_json(self):
         with TemporaryDirectory() as td:
@@ -632,39 +626,36 b' class NotebookExportMagicTests(TestCase):'
             _ip.ex(py3compat.u_format(u"u = {u}'héllo'"))
             _ip.magic("notebook -e %s" % outfile)
 
-    def test_notebook_export_py(self):
-        with TemporaryDirectory() as td:
-            outfile = os.path.join(td, "nb.py")
-            _ip.ex(py3compat.u_format(u"u = {u}'héllo'"))
-            _ip.magic("notebook -e %s" % outfile)
 
-    def test_notebook_reformat_py(self):
-        from IPython.nbformat.v3.tests.nbexamples import nb0
-        from IPython.nbformat import current
-        with TemporaryDirectory() as td:
-            infile = os.path.join(td, "nb.ipynb")
-            with io.open(infile, 'w', encoding='utf-8') as f:
-                current.write(nb0, f, 'json')
+class TestEnv(TestCase):
 
-            _ip.ex(py3compat.u_format(u"u = {u}'héllo'"))
-            _ip.magic("notebook -f py %s" % infile)
+    def test_env(self):
+        env = _ip.magic("env")
+        self.assertTrue(isinstance(env, dict))
 
-    def test_notebook_reformat_json(self):
-        from IPython.nbformat.v3.tests.nbexamples import nb0
-        from IPython.nbformat import current
-        with TemporaryDirectory() as td:
-            infile = os.path.join(td, "nb.py")
-            with io.open(infile, 'w', encoding='utf-8') as f:
-                current.write(nb0, f, 'py')
+    def test_env_get_set_simple(self):
+        env = _ip.magic("env var val1")
+        self.assertEqual(env, None)
+        self.assertEqual(os.environ['var'], 'val1')
+        self.assertEqual(_ip.magic("env var"), 'val1')
+        env = _ip.magic("env var=val2")
+        self.assertEqual(env, None)
+        self.assertEqual(os.environ['var'], 'val2')
 
-            _ip.ex(py3compat.u_format(u"u = {u}'héllo'"))
-            _ip.magic("notebook -f ipynb %s" % infile)
-            _ip.magic("notebook -f json %s" % infile)
+    def test_env_get_set_complex(self):
+        env = _ip.magic("env var 'val1 '' 'val2")
+        self.assertEqual(env, None)
+        self.assertEqual(os.environ['var'], "'val1 '' 'val2")
+        self.assertEqual(_ip.magic("env var"), "'val1 '' 'val2")
+        env = _ip.magic('env var=val2 val3="val4')
+        self.assertEqual(env, None)
+        self.assertEqual(os.environ['var'], 'val2 val3="val4')
 
+    def test_env_set_bad_input(self):
+        self.assertRaises(UsageError, lambda: _ip.magic("set_env var"))
 
-def test_env():
-    env = _ip.magic("env")
-    assert isinstance(env, dict), type(env)
+    def test_env_set_whitespace(self):
+        self.assertRaises(UsageError, lambda: _ip.magic("env var A=B"))
 
 
 class CellMagicTestCase(TestCase):

IPython/core/tests/test_run.py

@@ -7,11 +7,12 b' will be kept in this separate file. This makes it easier to aggregate in one'
 place the tricks needed to handle it; most other magics are much easier to test
 and we do so in a common test_magic file.
 """
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
 from __future__ import absolute_import
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
 
 import functools
 import os
@@ -32,9 +33,6 b' from IPython.utils.io import capture_output'
 from IPython.utils.tempdir import TemporaryDirectory
 from IPython.core import debugger
 
-#-----------------------------------------------------------------------------
-# Test functions begin
-#-----------------------------------------------------------------------------
 
 def doctest_refbug():
     """Very nasty problem with references held by multiple runs of a script.
@@ -372,19 +370,17 b' tclass.py: deleting object: C-third'
         with tt.AssertNotPrints('SystemExit'):
             _ip.magic('run -e %s' % self.fname)
 
-    @dec.skip_without('IPython.nbformat.current')  # Requires jsonschema
+    @dec.skip_without('IPython.nbformat')  # Requires jsonschema
     def test_run_nb(self):
         """Test %run notebook.ipynb"""
-        from IPython.nbformat import current
-        nb = current.new_notebook(
-            worksheets=[
-                current.new_worksheet(cells=[
-                    current.new_text_cell("The Ultimate Question of Everything"),
-                    current.new_code_cell("answer=42")
-                ])
+        from IPython.nbformat import v4, writes
+        nb = v4.new_notebook(
+           cells=[
+                v4.new_markdown_cell("The Ultimate Question of Everything"),
+                v4.new_code_cell("answer=42")
             ]
         )
-        src = current.writes(nb, 'json')
+        src = writes(nb, version=4)
         self.mktmp(src, ext='.ipynb')
         
         _ip.magic("run %s" % self.fname)

IPython/core/tests/test_shellapp.py

@@ -19,6 +19,11 b' import unittest'
 
 from IPython.testing import decorators as dec
 from IPython.testing import tools as tt
+from IPython.utils.py3compat import PY3
+
+sqlite_err_maybe = dec.module_not_available('sqlite3')
+SQLITE_NOT_AVAILABLE_ERROR = ('WARNING: IPython History requires SQLite,'
+                              ' your history will not be saved\n')
 
 class TestFileToRun(unittest.TestCase, tt.TempFileMixin):
     """Test the behavior of the file_to_run parameter."""
@@ -28,10 +33,7 b' class TestFileToRun(unittest.TestCase, tt.TempFileMixin):'
         src = "print(__file__)\n"
         self.mktmp(src)
 
-        if dec.module_not_available('sqlite3'):
-            err = 'WARNING: IPython History requires SQLite, your history will not be saved\n'
-        else:
-            err = None
+        err = SQLITE_NOT_AVAILABLE_ERROR if sqlite_err_maybe else None
         tt.ipexec_validate(self.fname, self.fname, err)
 
     def test_ipy_script_file_attribute(self):
@@ -39,11 +41,28 b' class TestFileToRun(unittest.TestCase, tt.TempFileMixin):'
         src = "print(__file__)\n"
         self.mktmp(src, ext='.ipy')
 
-        if dec.module_not_available('sqlite3'):
-            err = 'WARNING: IPython History requires SQLite, your history will not be saved\n'
-        else:
-            err = None
+        err = SQLITE_NOT_AVAILABLE_ERROR if sqlite_err_maybe else None
         tt.ipexec_validate(self.fname, self.fname, err)
 
-    # Ideally we would also test that `__file__` is not set in the
-    # interactive namespace after running `ipython -i <file>`.
+    # The commands option to ipexec_validate doesn't work on Windows, and it
+    # doesn't seem worth fixing
+    @dec.skip_win32
+    def test_py_script_file_attribute_interactively(self):
+        """Test that `__file__` is not set after `ipython -i file.py`"""
+        src = "True\n"
+        self.mktmp(src)
+
+        err = SQLITE_NOT_AVAILABLE_ERROR if sqlite_err_maybe else None
+        tt.ipexec_validate(self.fname, 'False', err, options=['-i'],
+                           commands=['"__file__" in globals()', 'exit()'])
+
+    @dec.skip_win32
+    @dec.skipif(PY3)
+    def test_py_script_file_compiler_directive(self):
+        """Test `__future__` compiler directives with `ipython -i file.py`"""
+        src = "from __future__ import division\n"
+        self.mktmp(src)
+
+        err = SQLITE_NOT_AVAILABLE_ERROR if sqlite_err_maybe else None
+        tt.ipexec_validate(self.fname, 'float', err, options=['-i'],
+                           commands=['type(1/2)', 'exit()'])

IPython/core/ultratb.py

@@ -722,15 +722,23 b' class VerboseTB(TBTools):'
             #print '*** record:',file,lnum,func,lines,index  # dbg
             if not file:
                 file = '?'
-            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:
-                    file = abspath(file)
-                except OSError:
-                    # Not sure if this can still happen: abspath now works with
-                    # file names like <string>
-                    pass
+            elif file.startswith(str("<")) and file.endswith(str(">")):
+                # Not a real filename, no problem...
+                pass
+            elif not os.path.isabs(file):
+                # Try to make the filename absolute by trying all
+                # sys.path entries (which is also what linecache does)
+                for dirname in sys.path:
+                    try:
+                        fullname = os.path.join(dirname, file)
+                        if os.path.isfile(fullname):
+                            file = os.path.abspath(fullname)
+                            break
+                    except Exception:
+                        # Just in case that sys.path contains very
+                        # strange entries...
+                        pass
+
             file = py3compat.cast_unicode(file, util_path.fs_encoding)
             link = tpl_link % file
             args, varargs, varkw, locals = inspect.getargvalues(frame)

IPython/core/usage.py

@@ -103,11 +103,6 b' MAIN FEATURES'
   If you just want to see an object's docstring, type '%pdoc object' (without
   quotes, and without % if you have automagic on).
 
-  Both %pdoc and ?/?? give you access to documentation even on things which are
-  not explicitely defined. Try for example typing {}.get? or after import os,
-  type os.path.abspath??. The magic functions %pdef, %source and %file operate
-  similarly.
-
 * Completion in the local namespace, by typing TAB at the prompt.
 
   At any time, hitting tab will complete any available python commands or

IPython/extensions/autoreload.py

@@ -183,7 +183,7 b' class ModuleReloader(object):'
         return top_module, top_name
 
     def filename_and_mtime(self, module):
-        if not hasattr(module, '__file__'):
+        if not hasattr(module, '__file__') or module.__file__ is None:
             return None, None
 
         if module.__name__ == '__main__':

IPython/extensions/cythonmagic.py

@@ -1,37 +1,10 b''
 # -*- coding: utf-8 -*-
 """
-=====================
-Cython related magics
-=====================
+The cython magic has been integrated into Cython itself, 
+which is now released in version 0.21.
 
-Magic command interface for interactive work with Cython
-
-.. note::
-
-  The ``Cython`` package needs to be installed separately. It
-  can be obtained using ``easy_install`` or ``pip``.
-
-Usage
-=====
-
-To enable the magics below, execute ``%load_ext cythonmagic``.
-
-``%%cython``
-
-{CYTHON_DOC}
-
-``%%cython_inline``
-
-{CYTHON_INLINE_DOC}
-
-``%%cython_pyximport``
-
-{CYTHON_PYXIMPORT_DOC}
-
-Author:
-* Brian Granger
-
-Parts of this code were taken from Cython.inline.
+cf github `Cython` organisation, `Cython` repo, under the 
+file `Cython/Build/IpythonMagic.py`
 """
 #-----------------------------------------------------------------------------
 # Copyright (C) 2010-2011, IPython Development Team.
@@ -43,303 +16,28 b' Parts of this code were taken from Cython.inline.'
 
 from __future__ import print_function
 
-import imp
-import io
-import os
-import re
-import sys
-import time
+import IPython.utils.version as version
 
 try:
-    reload
-except NameError:   # Python 3
-    from imp import reload
+    import Cython
+except:
+    Cython = None
 
 try:
-    import hashlib
-except ImportError:
-    import md5 as hashlib
-
-from distutils.core import Distribution, Extension
-from distutils.command.build_ext import build_ext
-
-from IPython.core import display
-from IPython.core import magic_arguments
-from IPython.core.magic import Magics, magics_class, cell_magic
-from IPython.utils import py3compat
-from IPython.utils.path import get_ipython_cache_dir
-from IPython.utils.text import dedent
-
-import Cython
-from Cython.Compiler.Errors import CompileError
-from Cython.Build.Dependencies import cythonize
-
-
-@magics_class
-class CythonMagics(Magics):
-
-    def __init__(self, shell):
-        super(CythonMagics,self).__init__(shell)
-        self._reloads = {}
-        self._code_cache = {}
-
-    def _import_all(self, module):
-        for k,v in module.__dict__.items():
-            if not k.startswith('__'):
-                self.shell.push({k:v})
-
-    @cell_magic
-    def cython_inline(self, line, cell):
-        """Compile and run a Cython code cell using Cython.inline.
-
-        This magic simply passes the body of the cell to Cython.inline
-        and returns the result. If the variables `a` and `b` are defined
-        in the user's namespace, here is a simple example that returns
-        their sum::
-
-            %%cython_inline
-            return a+b
-
-        For most purposes, we recommend the usage of the `%%cython` magic.
-        """
-        locs = self.shell.user_global_ns
-        globs = self.shell.user_ns
-        return Cython.inline(cell, locals=locs, globals=globs)
-
-    @cell_magic
-    def cython_pyximport(self, line, cell):
-        """Compile and import a Cython code cell using pyximport.
+    from Cython.Build.IpythonMagic import CythonMagics
+except :
+    pass
 
-        The contents of the cell are written to a `.pyx` file in the current
-        working directory, which is then imported using `pyximport`. This
-        magic requires a module name to be passed::
-
-            %%cython_pyximport modulename
-            def f(x):
-                return 2.0*x
-
-        The compiled module is then imported and all of its symbols are
-        injected into the user's namespace. For most purposes, we recommend
-        the usage of the `%%cython` magic.
-        """
-        module_name = line.strip()
-        if not module_name:
-            raise ValueError('module name must be given')
-        fname = module_name + '.pyx'
-        with io.open(fname, 'w', encoding='utf-8') as f:
-            f.write(cell)
-        if 'pyximport' not in sys.modules:
-            import pyximport
-            pyximport.install(reload_support=True)
-        if module_name in self._reloads:
-            module = self._reloads[module_name]
-            reload(module)
-        else:
-            __import__(module_name)
-            module = sys.modules[module_name]
-            self._reloads[module_name] = module
-        self._import_all(module)
-
-    @magic_arguments.magic_arguments()
-    @magic_arguments.argument(
-        '-c', '--compile-args', action='append', default=[],
-        help="Extra flags to pass to compiler via the `extra_compile_args` "
-             "Extension flag (can be specified  multiple times)."
-    )
-    @magic_arguments.argument(
-        '--link-args', action='append', default=[],
-        help="Extra flags to pass to linker via the `extra_link_args` "
-             "Extension flag (can be specified  multiple times)."
-    )
-    @magic_arguments.argument(
-        '-l', '--lib', action='append', default=[],
-        help="Add a library to link the extension against (can be specified "
-             "multiple times)."
-    )
-    @magic_arguments.argument(
-        '-n', '--name',
-        help="Specify a name for the Cython module."
-    )
-    @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)."
-    )
-    @magic_arguments.argument(
-        '-+', '--cplus', action='store_true', default=False,
-        help="Output a C++ rather than C file."
-    )
-    @magic_arguments.argument(
-        '-f', '--force', action='store_true', default=False,
-        help="Force the compilation of a new module, even if the source has been "
-             "previously compiled."
-    )
-    @magic_arguments.argument(
-        '-a', '--annotate', action='store_true', default=False,
-        help="Produce a colorized HTML version of the source."
-    )
-    @cell_magic
-    def cython(self, line, cell):
-        """Compile and import everything from a Cython code cell.
-
-        The contents of the cell are written to a `.pyx` file in the
-        directory `IPYTHONDIR/cython` using a filename with the hash of the
-        code. This file is then cythonized and compiled. The resulting module
-        is imported and all of its symbols are injected into the user's
-        namespace. The usage is similar to that of `%%cython_pyximport` but
-        you don't have to pass a module name::
-
-            %%cython
-            def f(x):
-                return 2.0*x
-
-        To compile OpenMP codes, pass the required  `--compile-args`
-        and `--link-args`.  For example with gcc::
-
-            %%cython --compile-args=-fopenmp --link-args=-fopenmp
-            ...
-        """
-        args = magic_arguments.parse_argstring(self.cython, line)
-        code = cell if cell.endswith('\n') else cell+'\n'
-        lib_dir = os.path.join(get_ipython_cache_dir(), 'cython')
-        quiet = True
-        key = code, sys.version_info, sys.executable, Cython.__version__
-
-        if not os.path.exists(lib_dir):
-            os.makedirs(lib_dir)
-
-        if args.force:
-            # Force a new module name by adding the current time to the
-            # key which is hashed to determine the module name.
-            key += time.time(),
-
-        if args.name:
-            module_name = py3compat.unicode_to_str(args.name)
-        else:
-            module_name = "_cython_magic_" + hashlib.md5(str(key).encode('utf-8')).hexdigest()
-        module_path = os.path.join(lib_dir, module_name + self.so_ext)
-
-        have_module = os.path.isfile(module_path)
-        need_cythonize = not have_module
-
-        if args.annotate:
-            html_file = os.path.join(lib_dir, module_name + '.html')
-            if not os.path.isfile(html_file):
-                need_cythonize = True
-
-        if need_cythonize:
-            c_include_dirs = args.include
-            if 'numpy' in code:
-                import numpy
-                c_include_dirs.append(numpy.get_include())
-            pyx_file = os.path.join(lib_dir, module_name + '.pyx')
-            pyx_file = py3compat.cast_bytes_py2(pyx_file, encoding=sys.getfilesystemencoding())
-            with io.open(pyx_file, 'w', encoding='utf-8') as f:
-                f.write(code)
-            extension = Extension(
-                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,
-                language = 'c++' if args.cplus else 'c',
-            )
-            build_extension = self._get_build_extension()
-            try:
-                opts = dict(
-                    quiet=quiet,
-                    annotate = args.annotate,
-                    force = True,
-                    )
-                build_extension.extensions = cythonize([extension], **opts)
-            except CompileError:
-                return
-
-        if not have_module:
-            build_extension.build_temp = os.path.dirname(pyx_file)
-            build_extension.build_lib  = lib_dir
-            build_extension.run()
-            self._code_cache[key] = module_name
-
-        module = imp.load_dynamic(module_name, module_path)
-        self._import_all(module)
-
-        if args.annotate:
-            try:
-                with io.open(html_file, encoding='utf-8') as f:
-                    annotated_html = f.read()
-            except IOError as e:
-                # File could not be opened. Most likely the user has a version
-                # of Cython before 0.15.1 (when `cythonize` learned the
-                # `force` keyword argument) and has already compiled this
-                # exact source without annotation.
-                print('Cython completed successfully but the annotated '
-                      'source could not be read.', file=sys.stderr)
-                print(e, file=sys.stderr)
-            else:
-                return display.HTML(self.clean_annotated_html(annotated_html))
-
-    @property
-    def so_ext(self):
-        """The extension suffix for compiled modules."""
-        try:
-            return self._so_ext
-        except AttributeError:
-            self._so_ext = self._get_build_extension().get_ext_filename('')
-            return self._so_ext
-
-    def _clear_distutils_mkpath_cache(self):
-        """clear distutils mkpath cache
-        
-        prevents distutils from skipping re-creation of dirs that have been removed
-        """
-        try:
-            from distutils.dir_util import _path_created
-        except ImportError:
-            pass
-        else:
-            _path_created.clear()
-    
-    def _get_build_extension(self):
-        self._clear_distutils_mkpath_cache()
-        dist = Distribution()
-        config_files = dist.find_config_files()
-        try:
-            config_files.remove('setup.cfg')
-        except ValueError:
-            pass
-        dist.parse_config_files(config_files)
-        build_extension = build_ext(dist)
-        build_extension.finalize_options()
-        return build_extension
-
-    @staticmethod
-    def clean_annotated_html(html):
-        """Clean up the annotated HTML source.
-
-        Strips the link to the generated C or C++ file, which we do not
-        present to the user.
-        """
-        r = re.compile('<p>Raw output: <a href="(.*)">(.*)</a>')
-        html = '\n'.join(l for l in html.splitlines() if not r.match(l))
-        return html
-
-__doc__ = __doc__.format(
-                # rST doesn't see the -+ flag as part of an option list, so we
-                # hide it from the module-level docstring.
-                CYTHON_DOC = dedent(CythonMagics.cython.__doc__\
-                            .replace('-+, --cplus','--cplus    ')),
-                CYTHON_INLINE_DOC = dedent(CythonMagics.cython_inline.__doc__),
-                CYTHON_PYXIMPORT_DOC = dedent(CythonMagics.cython_pyximport.__doc__),
-)
 
+## still load the magic in IPython 3.x, remove completely in future versions.
 def load_ipython_extension(ip):
     """Load the extension in IPython."""
-    ip.register_magics(CythonMagics)
+    
+    print("""The Cython magic has been move to the Cython package, hence """)
+    print("""`%load_ext cythonmagic` is deprecated; Please use `%load_ext Cython` instead.""")
+    
+    if Cython is None or not version.check_version(Cython.__version__, "0.21"):
+        print("You need Cython version >=0.21 to use the Cython magic")
+        return 
+    print("""\nThough, because I am nice, I'll still try to load it for you this time.""")
+    Cython.load_ipython_extension(ip)

IPython/external/mathjax.py

@@ -132,7 +132,6 b' def extract_zip(fd, dest):'
     z.extractall(parent)
 
     # it will be mathjax-MathJax-<sha>, rename to just mathjax
-    d = os.path.join(parent, topdir)
     os.rename(os.path.join(parent, topdir), dest)
 
 

IPython/external/qt_loaders.py

@@ -57,11 +57,11 b' def commit_api(api):'
     if api == QT_API_PYSIDE:
         ID.forbid('PyQt4')
         ID.forbid('PyQt5')
-    elif api == QT_API_PYQT:
+    elif api == QT_API_PYQT5:
         ID.forbid('PySide')
-        ID.forbid('PyQt5')
-    else:
         ID.forbid('PyQt4')
+    else:   # There are three other possibilities, all representing PyQt4
+        ID.forbid('PyQt5')
         ID.forbid('PySide')
 
 
@@ -241,7 +241,7 b' def load_qt(api_options):'
     ----------
     api_options: List of strings
         The order of APIs to try. Valid items are 'pyside',
-        'pyqt', 'pyqt5' and 'pyqtv1'
+        'pyqt', 'pyqt5', 'pyqtv1' and 'pyqtdefault'
 
     Returns
     -------

IPython/html/README.md

@@ -4,10 +4,9 b''
 
 Developers of the IPython Notebook will need to install the following tools:
 
-* fabric
+* invoke
 * node.js
 * less (`npm install -g less`)
-* bower (`npm install -g bower`)
 
 ## Components
 
@@ -15,14 +14,13 b' We are moving to a model where our JavaScript dependencies are managed using'
 [bower](http://bower.io/). These packages are installed in `static/components`
 and committed into a separate git repo [ipython/ipython-components](ipython/ipython-components).
 Our dependencies are described in the file
-`static/components/bower.json`. To update our bower packages, run `fab update`
+`static/components/bower.json`. To update our bower packages, run `bower install`
 in this directory.
 
 ## less
 
 If you edit our `.less` files you will need to run the less compiler to build
-our minified css files.  This can be done by running `fab css` from this directory,
-or `python setup.py css` from the root of the repository. 
+our minified css files.  This can be done by running `python setup.py css` from the root of the repository. 
 If you are working frequently with `.less` files please consider installing git hooks that
 rebuild the css files and corresponding maps in `${RepoRoot}/git-hooks/install-hooks.sh`.
 

IPython/html/__init__.py

@@ -4,6 +4,22 b' import os'
 # Packagers: modify this line if you store the notebook static files elsewhere
 DEFAULT_STATIC_FILES_PATH = os.path.join(os.path.dirname(__file__), "static")
 
+# Packagers: modify the next line if you store the notebook template files
+# elsewhere
+
+# Include both IPython/html/ and IPython/html/templates/.  This makes it
+# possible for users to override a template with a file that inherits from that
+# template.
+#
+# For example, if you want to override a specific block of notebook.html, you
+# can create a file called notebook.html that inherits from
+# templates/notebook.html, and the latter will resolve correctly to the base
+# implementation.
+DEFAULT_TEMPLATE_PATH_LIST = [
+    os.path.dirname(__file__),
+    os.path.join(os.path.dirname(__file__), "templates"),
+]
+
 del os
 
-from .nbextensions import install_nbextension
  No newline at end of file
+from .nbextensions import install_nbextension

IPython/html/base/handlers.py

@@ -24,33 +24,45 b' try:'
 except ImportError:
     app_log = logging.getLogger()
 
+import IPython
+from IPython.utils.sysinfo import get_sys_info
+
 from IPython.config import Application
 from IPython.utils.path import filefind
 from IPython.utils.py3compat import string_types
 from IPython.html.utils import is_hidden, url_path_join, url_escape
 
+from IPython.html.services.security import csp_report_uri
+
 #-----------------------------------------------------------------------------
 # Top-level handlers
 #-----------------------------------------------------------------------------
 non_alphanum = re.compile(r'[^A-Za-z0-9]')
 
+sys_info = json.dumps(get_sys_info())
+
 class AuthenticatedHandler(web.RequestHandler):
     """A RequestHandler with an authenticated user."""
 
     def set_default_headers(self):
         headers = self.settings.get('headers', {})
 
-        if "X-Frame-Options" not in headers:
-            headers["X-Frame-Options"] = "SAMEORIGIN"
+        if "Content-Security-Policy" not in headers:
+            headers["Content-Security-Policy"] = (
+                    "frame-ancestors 'self'; "
+                    # Make sure the report-uri is relative to the base_url
+                    "report-uri " + url_path_join(self.base_url, csp_report_uri) + ";"
+            )
 
+        # Allow for overriding headers
         for header_name,value in headers.items() :
             try:
                 self.set_header(header_name, value)
-            except Exception:
+            except Exception as e:
                 # tornado raise Exception (not a subclass)
                 # if method is unsupported (websocket and Access-Control-Allow-Origin
                 # for example, so just ignore)
-                pass
+                self.log.debug(e)
     
     def clear_login_cookie(self):
         self.clear_cookie(self.cookie_name)
@@ -121,6 +133,11 b' class IPythonHandler(AuthenticatedHandler):'
     #---------------------------------------------------------------
     
     @property
+    def version_hash(self):
+        """The version hash to use for cache hints for static files"""
+        return self.settings.get('version_hash', '')
+    
+    @property
     def mathjax_url(self):
         return self.settings.get('mathjax_url', '')
     
@@ -131,6 +148,12 b' class IPythonHandler(AuthenticatedHandler):'
     @property
     def ws_url(self):
         return self.settings.get('websocket_url', '')
+
+    @property
+    def contents_js_source(self):
+        self.log.debug("Using contents: %s", self.settings.get('contents_js_source',
+            'services/contents'))
+        return self.settings.get('contents_js_source', 'services/contents')
     
     #---------------------------------------------------------------
     # Manager objects
@@ -153,9 +176,17 b' class IPythonHandler(AuthenticatedHandler):'
         return self.settings['session_manager']
     
     @property
+    def terminal_manager(self):
+        return self.settings['terminal_manager']
+    
+    @property
     def kernel_spec_manager(self):
         return self.settings['kernel_spec_manager']
 
+    @property
+    def config_manager(self):
+        return self.settings['config_manager']
+
     #---------------------------------------------------------------
     # CORS
     #---------------------------------------------------------------
@@ -219,6 +250,9 b' class IPythonHandler(AuthenticatedHandler):'
             logged_in=self.logged_in,
             login_available=self.login_available,
             static_url=self.static_url,
+            sys_info=sys_info,
+            contents_js_source=self.contents_js_source,
+            version_hash=self.version_hash,
         )
     
     def get_json_body(self):
@@ -285,12 +319,18 b' class AuthenticatedFileHandler(IPythonHandler, web.StaticFileHandler):'
     @web.authenticated
     def get(self, path):
         if os.path.splitext(path)[1] == '.ipynb':
-            name = os.path.basename(path)
+            name = path.rsplit('/', 1)[-1]
             self.set_header('Content-Type', 'application/json')
             self.set_header('Content-Disposition','attachment; filename="%s"' % name)
         
         return web.StaticFileHandler.get(self, path)
     
+    def set_headers(self):
+        super(AuthenticatedFileHandler, self).set_headers()
+        # disable browser caching, rely on 304 replies for savings
+        if "v" not in self.request.arguments:
+            self.add_header("Cache-Control", "no-cache")
+    
     def compute_etag(self):
         return None
     
@@ -359,7 +399,16 b' class FileFindHandler(web.StaticFileHandler):'
     # cache search results, don't search for files more than once
     _static_paths = {}
     
-    def initialize(self, path, default_filename=None):
+    def set_headers(self):
+        super(FileFindHandler, self).set_headers()
+        # disable browser caching, rely on 304 replies for savings
+        if "v" not in self.request.arguments or \
+                any(self.request.path.startswith(path) for path in self.no_cache_paths):
+            self.add_header("Cache-Control", "no-cache")
+    
+    def initialize(self, path, default_filename=None, no_cache_paths=None):
+        self.no_cache_paths = no_cache_paths or []
+        
         if isinstance(path, string_types):
             path = [path]
         
@@ -398,43 +447,49 b' class FileFindHandler(web.StaticFileHandler):'
         return super(FileFindHandler, self).validate_absolute_path(root, absolute_path)
 
 
+class ApiVersionHandler(IPythonHandler):
+
+    @json_errors
+    def get(self):
+        # not authenticated, so give as few info as possible
+        self.finish(json.dumps({"version":IPython.__version__}))
+
+
 class TrailingSlashHandler(web.RequestHandler):
     """Simple redirect handler that strips trailing slashes
     
     This should be the first, highest priority handler.
     """
     
-    SUPPORTED_METHODS = ['GET']
-    
     def get(self):
         self.redirect(self.request.uri.rstrip('/'))
+    
+    post = put = get
 
 
 class FilesRedirectHandler(IPythonHandler):
     """Handler for redirecting relative URLs to the /files/ handler"""
     def get(self, path=''):
         cm = self.contents_manager
-        if cm.path_exists(path):
+        if cm.dir_exists(path):
             # it's a *directory*, redirect to /tree
             url = url_path_join(self.base_url, 'tree', path)
         else:
             orig_path = path
             # otherwise, redirect to /files
             parts = path.split('/')
-            path = '/'.join(parts[:-1])
-            name = parts[-1]
 
-            if not cm.file_exists(name=name, path=path) and 'files' in parts:
+            if not cm.file_exists(path=path) and 'files' in parts:
                 # redirect without files/ iff it would 404
                 # this preserves pre-2.0-style 'files/' links
                 self.log.warn("Deprecated files/ URL: %s", orig_path)
                 parts.remove('files')
-                path = '/'.join(parts[:-1])
+                path = '/'.join(parts)
 
-            if not cm.file_exists(name=name, path=path):
+            if not cm.file_exists(path=path):
                 raise web.HTTPError(404)
 
-            url = url_path_join(self.base_url, 'files', path, name)
+            url = url_path_join(self.base_url, 'files', path)
         url = url_escape(url)
         self.log.debug("Redirecting %s to %s", self.request.path, url)
         self.redirect(url)
@@ -444,11 +499,9 b' class FilesRedirectHandler(IPythonHandler):'
 # URL pattern fragments for re-use
 #-----------------------------------------------------------------------------
 
-path_regex = r"(?P<path>(?:/.*)*)"
-notebook_name_regex = r"(?P<name>[^/]+\.ipynb)"
-notebook_path_regex = "%s/%s" % (path_regex, notebook_name_regex)
-file_name_regex = r"(?P<name>[^/]+)"
-file_path_regex = "%s/%s" % (path_regex, file_name_regex)
+# path matches any number of `/foo[/bar...]` or just `/` or ''
+path_regex = r"(?P<path>(?:(?:/[^/]+)+|/?))"
+notebook_path_regex = r"(?P<path>(?:/[^/]+)+\.ipynb)"
 
 #-----------------------------------------------------------------------------
 # URL to handler mappings
@@ -456,5 +509,6 b' file_path_regex = "%s/%s" % (path_regex, file_name_regex)'
 
 
 default_handlers = [
-    (r".*/", TrailingSlashHandler)
+    (r".*/", TrailingSlashHandler),
+    (r"api", ApiVersionHandler)
 ]

IPython/html/base/zmqhandlers.py

@@ -1,34 +1,98 b''
+# coding: utf-8
 """Tornado handlers for WebSocket <-> ZMQ sockets."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
+import os
 import json
+import struct
+import warnings
 
 try:
     from urllib.parse import urlparse # Py 3
 except ImportError:
     from urlparse import urlparse # Py 2
 
-try:
-    from http.cookies import SimpleCookie  # Py 3
-except ImportError:
-    from Cookie import SimpleCookie  # Py 2
-import logging
-
 import tornado
-from tornado import ioloop
-from tornado import web
-from tornado import websocket
+from tornado import gen, ioloop, web
+from tornado.websocket import WebSocketHandler
 
 from IPython.kernel.zmq.session import Session
-from IPython.utils.jsonutil import date_default
-from IPython.utils.py3compat import PY3, cast_unicode
+from IPython.utils.jsonutil import date_default, extract_dates
+from IPython.utils.py3compat import cast_unicode
 
 from .handlers import IPythonHandler
 
+def serialize_binary_message(msg):
+    """serialize a message as a binary blob
+
+    Header:
+
+    4 bytes: number of msg parts (nbufs) as 32b int
+    4 * nbufs bytes: offset for each buffer as integer as 32b int
+
+    Offsets are from the start of the buffer, including the header.
+
+    Returns
+    -------
+
+    The message serialized to bytes.
+
+    """
+    # don't modify msg or buffer list in-place
+    msg = msg.copy()
+    buffers = list(msg.pop('buffers'))
+    bmsg = json.dumps(msg, default=date_default).encode('utf8')
+    buffers.insert(0, bmsg)
+    nbufs = len(buffers)
+    offsets = [4 * (nbufs + 1)]
+    for buf in buffers[:-1]:
+        offsets.append(offsets[-1] + len(buf))
+    offsets_buf = struct.pack('!' + 'I' * (nbufs + 1), nbufs, *offsets)
+    buffers.insert(0, offsets_buf)
+    return b''.join(buffers)
+
+
+def deserialize_binary_message(bmsg):
+    """deserialize a message from a binary blog
+
+    Header:
+
+    4 bytes: number of msg parts (nbufs) as 32b int
+    4 * nbufs bytes: offset for each buffer as integer as 32b int
 
-class ZMQStreamHandler(websocket.WebSocketHandler):
+    Offsets are from the start of the buffer, including the header.
+
+    Returns
+    -------
+
+    message dictionary
+    """
+    nbufs = struct.unpack('!i', bmsg[:4])[0]
+    offsets = list(struct.unpack('!' + 'I' * nbufs, bmsg[4:4*(nbufs+1)]))
+    offsets.append(None)
+    bufs = []
+    for start, stop in zip(offsets[:-1], offsets[1:]):
+        bufs.append(bmsg[start:stop])
+    msg = json.loads(bufs[0].decode('utf8'))
+    msg['header'] = extract_dates(msg['header'])
+    msg['parent_header'] = extract_dates(msg['parent_header'])
+    msg['buffers'] = bufs[1:]
+    return msg
+
+# ping interval for keeping websockets alive (30 seconds)
+WS_PING_INTERVAL = 30000
+
+if os.environ.get('IPYTHON_ALLOW_DRAFT_WEBSOCKETS_FOR_PHANTOMJS', False):
+    warnings.warn("""Allowing draft76 websocket connections!
+    This should only be done for testing with phantomjs!""")
+    from IPython.html import allow76
+    WebSocketHandler = allow76.AllowDraftWebSocketHandler
+    # draft 76 doesn't support ping
+    WS_PING_INTERVAL = 0
+
+class ZMQStreamHandler(WebSocketHandler):
     
     def check_origin(self, origin):
         """Check Origin == Host or Access-Control-Allow-Origin.
@@ -77,23 +141,19 b' class ZMQStreamHandler(websocket.WebSocketHandler):'
     def _reserialize_reply(self, msg_list):
         """Reserialize a reply message using JSON.
 
-        This takes the msg list from the ZMQ socket, unserializes it using
+        This takes the msg list from the ZMQ socket, deserializes it using
         self.session and then serializes the result using JSON. This method
         should be used by self._on_zmq_reply to build messages that can
         be sent back to the browser.
         """
         idents, msg_list = self.session.feed_identities(msg_list)
-        msg = self.session.unserialize(msg_list)
-        try:
-            msg['header'].pop('date')
-        except KeyError:
-            pass
-        try:
-            msg['parent_header'].pop('date')
-        except KeyError:
-            pass
-        msg.pop('buffers')
-        return json.dumps(msg, default=date_default)
+        msg = self.session.deserialize(msg_list)
+        if msg['buffers']:
+            buf = serialize_binary_message(msg)
+            return buf
+        else:
+            smsg = json.dumps(msg, default=date_default)
+            return cast_unicode(smsg)
 
     def _on_zmq_reply(self, msg_list):
         # Sometimes this gets triggered when the on_close method is scheduled in the
@@ -104,18 +164,7 b' class ZMQStreamHandler(websocket.WebSocketHandler):'
         except Exception:
             self.log.critical("Malformed message: %r" % msg_list, exc_info=True)
         else:
-            self.write_message(msg)
-
-    def allow_draft76(self):
-        """Allow draft 76, until browsers such as Safari update to RFC 6455.
-        
-        This has been disabled by default in tornado in release 2.2.0, and
-        support will be removed in later versions.
-        """
-        return True
-
-# ping interval for keeping websockets alive (30 seconds)
-WS_PING_INTERVAL = 30000
+            self.write_message(msg, binary=isinstance(msg, bytes))
 
 class AuthenticatedZMQStreamHandler(ZMQStreamHandler, IPythonHandler):
     ping_callback = None
@@ -146,18 +195,37 b' class AuthenticatedZMQStreamHandler(ZMQStreamHandler, IPythonHandler):'
         which doesn't make sense for websockets
         """
         pass
-
-    def open(self, kernel_id):
-        self.kernel_id = cast_unicode(kernel_id, 'ascii')
-        # Check to see that origin matches host directly, including ports
-        # Tornado 4 already does CORS checking
-        if tornado.version_info[0] < 4:
-            if not self.check_origin(self.get_origin()):
-                raise web.HTTPError(403)
-
+    
+    def pre_get(self):
+        """Run before finishing the GET request
+        
+        Extend this method to add logic that should fire before
+        the websocket finishes completing.
+        """
+        # authenticate the request before opening the websocket
+        if self.get_current_user() is None:
+            self.log.warn("Couldn't authenticate WebSocket connection")
+            raise web.HTTPError(403)
+        
+        if self.get_argument('session_id', False):
+            self.session.session = cast_unicode(self.get_argument('session_id'))
+        else:
+            self.log.warn("No session ID specified")
+    
+    @gen.coroutine
+    def get(self, *args, **kwargs):
+        # pre_get can be a coroutine in subclasses
+        # assign and yield in two step to avoid tornado 3 issues
+        res = self.pre_get()
+        yield gen.maybe_future(res)
+        super(AuthenticatedZMQStreamHandler, self).get(*args, **kwargs)
+    
+    def initialize(self):
+        self.log.debug("Initializing websocket connection %s", self.request.path)
         self.session = Session(config=self.config)
-        self.save_on_message = self.on_message
-        self.on_message = self.on_first_message
+    
+    def open(self, *args, **kwargs):
+        self.log.debug("Opening websocket %s", self.request.path)
         
         # start the pinging
         if self.ping_interval > 0:
@@ -187,28 +255,3 b' class AuthenticatedZMQStreamHandler(ZMQStreamHandler, IPythonHandler):'
 
     def on_pong(self, data):
         self.last_pong = ioloop.IOLoop.instance().time()
-
-    def _inject_cookie_message(self, msg):
-        """Inject the first message, which is the document cookie,
-        for authentication."""
-        if not PY3 and isinstance(msg, unicode):
-            # Cookie constructor doesn't accept unicode strings
-            # under Python 2.x for some reason
-            msg = msg.encode('utf8', 'replace')
-        try:
-            identity, msg = msg.split(':', 1)
-            self.session.session = cast_unicode(identity, 'ascii')
-        except Exception:
-            logging.error("First ws message didn't have the form 'identity:[cookie]' - %r", msg)
-        
-        try:
-            self.request._cookies = SimpleCookie(msg)
-        except:
-            self.log.warn("couldn't parse cookie string: %s",msg, exc_info=True)
-
-    def on_first_message(self, msg):
-        self._inject_cookie_message(msg)
-        if self.get_current_user() is None:
-            self.log.warn("Couldn't authenticate WebSocket connection")
-            raise web.HTTPError(403)
-        self.on_message = self.save_on_message

IPython/html/nbconvert/handlers.py

@@ -13,7 +13,7 b' from ..base.handlers import ('
     IPythonHandler, FilesRedirectHandler,
     notebook_path_regex, path_regex,
 )
-from IPython.nbformat.current import to_notebook_json
+from IPython.nbformat import from_dict
 
 from IPython.utils.py3compat import cast_bytes
 
@@ -43,7 +43,7 b' def respond_zip(handler, name, output, resources):'
     # Prepare the zip file
     buffer = io.BytesIO()
     zipf = zipfile.ZipFile(buffer, mode='w', compression=zipfile.ZIP_DEFLATED)
-    output_filename = os.path.splitext(name)[0] + '.' + resources['output_extension']
+    output_filename = os.path.splitext(name)[0] + resources['output_extension']
     zipf.writestr(output_filename, cast_bytes(output, 'utf-8'))
     for filename, data in output_files.items():
         zipf.writestr(os.path.basename(filename), data)
@@ -76,12 +76,13 b' class NbconvertFileHandler(IPythonHandler):'
     SUPPORTED_METHODS = ('GET',)
     
     @web.authenticated
-    def get(self, format, path='', name=None):
+    def get(self, format, path):
         
         exporter = get_exporter(format, config=self.config, log=self.log)
         
         path = path.strip('/')
-        model = self.contents_manager.get_model(name=name, path=path)
+        model = self.contents_manager.get(path=path)
+        name = model['name']
 
         self.set_header('Last-Modified', model['last_modified'])
         
@@ -95,7 +96,7 b' class NbconvertFileHandler(IPythonHandler):'
 
         # Force download if requested
         if self.get_argument('download', 'false').lower() == 'true':
-            filename = os.path.splitext(name)[0] + '.' + resources['output_extension']
+            filename = os.path.splitext(name)[0] + resources['output_extension']
             self.set_header('Content-Disposition',
                                'attachment; filename="%s"' % filename)
 
@@ -109,19 +110,20 b' class NbconvertFileHandler(IPythonHandler):'
 class NbconvertPostHandler(IPythonHandler):
     SUPPORTED_METHODS = ('POST',)
 
-    @web.authenticated 
+    @web.authenticated
     def post(self, format):
         exporter = get_exporter(format, config=self.config)
         
         model = self.get_json_body()
-        nbnode = to_notebook_json(model['content'])
+        name = model.get('name', 'notebook.ipynb')
+        nbnode = from_dict(model['content'])
         
         try:
             output, resources = exporter.from_notebook_node(nbnode)
         except Exception as e:
             raise web.HTTPError(500, "nbconvert failed: %s" % e)
 
-        if respond_zip(self, nbnode.metadata.name, output, resources):
+        if respond_zip(self, name, output, resources):
             return
 
         # MIME type

IPython/html/nbconvert/tests/test_nbconvert_handlers.py

@@ -10,9 +10,10 b' import requests'
 
 from IPython.html.utils import url_path_join
 from IPython.html.tests.launchnotebook import NotebookTestBase, assert_http_error
-from IPython.nbformat.current import (new_notebook, write, new_worksheet,
-                                      new_heading_cell, new_code_cell,
-                                      new_output)
+from IPython.nbformat import write
+from IPython.nbformat.v4 import (
+    new_notebook, new_markdown_cell, new_code_cell, new_output,
+)
 
 from IPython.testing.decorators import onlyif_cmds_exist
 
@@ -43,7 +44,8 b' class NbconvertAPI(object):'
 
 png_green_pixel = base64.encodestring(b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00'
 b'\x00\x00\x01\x00\x00x00\x01\x08\x02\x00\x00\x00\x90wS\xde\x00\x00\x00\x0cIDAT'
-b'\x08\xd7c\x90\xfb\xcf\x00\x00\x02\\\x01\x1e.~d\x87\x00\x00\x00\x00IEND\xaeB`\x82')
+b'\x08\xd7c\x90\xfb\xcf\x00\x00\x02\\\x01\x1e.~d\x87\x00\x00\x00\x00IEND\xaeB`\x82'
+).decode('ascii')
 
 class APITest(NotebookTestBase):
     def setUp(self):
@@ -52,19 +54,20 b' class APITest(NotebookTestBase):'
         if not os.path.isdir(pjoin(nbdir, 'foo')):
             os.mkdir(pjoin(nbdir, 'foo'))
         
-        nb = new_notebook(name='testnb')
+        nb = new_notebook()
         
-        ws = new_worksheet()
-        nb.worksheets = [ws]
-        ws.cells.append(new_heading_cell(u'Created by test ³'))
-        cc1 = new_code_cell(input=u'print(2*6)')
-        cc1.outputs.append(new_output(output_text=u'12', output_type='stream'))
-        cc1.outputs.append(new_output(output_png=png_green_pixel, output_type='pyout'))
-        ws.cells.append(cc1)
+        nb.cells.append(new_markdown_cell(u'Created by test ³'))
+        cc1 = new_code_cell(source=u'print(2*6)')
+        cc1.outputs.append(new_output(output_type="stream", text=u'12'))
+        cc1.outputs.append(new_output(output_type="execute_result",
+            data={'image/png' : png_green_pixel},
+            execution_count=1,
+        ))
+        nb.cells.append(cc1)
         
         with io.open(pjoin(nbdir, 'foo', 'testnb.ipynb'), 'w',
                      encoding='utf-8') as f:
-            write(nb, f, format='ipynb')
+            write(nb, f, version=4)
 
         self.nbconvert_api = NbconvertAPI(self.base_url())
 

IPython/html/nbextensions.py

@@ -93,7 +93,9 b' def install_nbextension(files, overwrite=False, symlink=False, ipython_dir=None,'
         If True, always install the files, regardless of what may already be installed.
     symlink : bool [default: False]
         If True, create a symlink in nbextensions, rather than copying files.
-        Not allowed with URLs or archives.
+        Not allowed with URLs or archives. Windows support for symlinks requires
+        Vista or above, Python 3, and a permission bit which only admin users
+        have by default, so don't rely on it.
     ipython_dir : str [optional]
         The path to an IPython directory, if the default value is not desired.
         get_ipython_dir() is used by default.
@@ -147,7 +149,7 b' def install_nbextension(files, overwrite=False, symlink=False, ipython_dir=None,'
         if overwrite and os.path.exists(dest):
             if verbose >= 1:
                 print("removing %s" % dest)
-            if os.path.isdir(dest):
+            if os.path.isdir(dest) and not os.path.islink(dest):
                 shutil.rmtree(dest)
             else:
                 os.remove(dest)

IPython/html/notebook/handlers.py

@@ -17,18 +17,16 b' from ..utils import url_escape'
 class NotebookHandler(IPythonHandler):
 
     @web.authenticated
-    def get(self, path='', name=None):
+    def get(self, path):
         """get renders the notebook template if a name is given, or 
         redirects to the '/files/' handler if the name is not given."""
         path = path.strip('/')
         cm = self.contents_manager
-        if name is None:
-            raise web.HTTPError(500, "This shouldn't be accessible: %s" % self.request.uri)
         
         # a .ipynb filename was given
-        if not cm.file_exists(name, path):
-            raise web.HTTPError(404, u'Notebook does not exist: %s/%s' % (path, name))
-        name = url_escape(name)
+        if not cm.file_exists(path):
+            raise web.HTTPError(404, u'Notebook does not exist: %s' % path)
+        name = url_escape(path.rsplit('/', 1)[-1])
         path = url_escape(path)
         self.write(self.render_template('notebook.html',
             notebook_path=path,

IPython/html/notebookapp.py

@@ -7,6 +7,7 b''
 from __future__ import print_function
 
 import base64
+import datetime
 import errno
 import io
 import json
@@ -35,7 +36,7 b' from zmq.eventloop import ioloop'
 ioloop.install()
 
 # check for tornado 3.1.0
-msg = "The IPython Notebook requires tornado >= 3.1.0"
+msg = "The IPython Notebook requires tornado >= 4.0"
 try:
     import tornado
 except ImportError:
@@ -44,14 +45,17 b' try:'
     version_info = tornado.version_info
 except AttributeError:
     raise ImportError(msg + ", but you have < 1.1.0")
-if version_info < (3,1,0):
+if version_info < (4,0):
     raise ImportError(msg + ", but you have %s" % tornado.version)
 
 from tornado import httpserver
 from tornado import web
-from tornado.log import LogFormatter
+from tornado.log import LogFormatter, app_log, access_log, gen_log
 
-from IPython.html import DEFAULT_STATIC_FILES_PATH
+from IPython.html import (
+    DEFAULT_STATIC_FILES_PATH,
+    DEFAULT_TEMPLATE_PATH_LIST,
+)
 from .base.handlers import Template404
 from .log import log_request
 from .services.kernels.kernelmanager import MappingKernelManager
@@ -81,6 +85,7 b' from IPython.utils.traitlets import ('
 )
 from IPython.utils import py3compat
 from IPython.utils.path import filefind, get_ipython_dir
+from IPython.utils.sysinfo import get_sys_info
 
 from .utils import url_path_join
 
@@ -122,37 +127,43 b' def load_handlers(name):'
 class NotebookWebApplication(web.Application):
 
     def __init__(self, ipython_app, kernel_manager, contents_manager,
-                 cluster_manager, session_manager, kernel_spec_manager, log,
+                 cluster_manager, session_manager, kernel_spec_manager,
+                 config_manager, log,
                  base_url, default_url, settings_overrides, jinja_env_options):
 
         settings = self.init_settings(
             ipython_app, kernel_manager, contents_manager, cluster_manager,
-            session_manager, kernel_spec_manager, log, base_url, default_url,
-            settings_overrides, jinja_env_options)
+            session_manager, kernel_spec_manager, config_manager, log, base_url,
+            default_url, settings_overrides, jinja_env_options)
         handlers = self.init_handlers(settings)
 
         super(NotebookWebApplication, self).__init__(handlers, **settings)
 
     def init_settings(self, ipython_app, kernel_manager, contents_manager,
                       cluster_manager, session_manager, kernel_spec_manager,
+                      config_manager,
                       log, base_url, default_url, settings_overrides,
                       jinja_env_options=None):
-        # Python < 2.6.5 doesn't accept unicode keys in f(**kwargs), and
-        # base_url will always be unicode, which will in turn
-        # make the patterns unicode, and ultimately result in unicode
-        # keys in kwargs to handler._execute(**kwargs) in tornado.
-        # This enforces that base_url be ascii in that situation.
-        #
-        # Note that the URLs these patterns check against are escaped,
-        # and thus guaranteed to be ASCII: 'héllo' is really 'h%C3%A9llo'.
-        base_url = py3compat.unicode_to_str(base_url, 'ascii')
-        _template_path = settings_overrides.get("template_path", os.path.join(os.path.dirname(__file__), "templates"))
+
+        _template_path = settings_overrides.get(
+            "template_path",
+            ipython_app.template_file_path,
+        )
         if isinstance(_template_path, str):
             _template_path = (_template_path,)
         template_path = [os.path.expanduser(path) for path in _template_path]
 
         jenv_opt = jinja_env_options if jinja_env_options else {}
         env = Environment(loader=FileSystemLoader(template_path), **jenv_opt)
+        
+        sys_info = get_sys_info()
+        if sys_info['commit_source'] == 'repository':
+            # don't cache (rely on 304) when working from master
+            version_hash = ''
+        else:
+            # reset the cache on server restart
+            version_hash = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
+
         settings = dict(
             # basics
             log_function=log_request,
@@ -162,6 +173,11 b' class NotebookWebApplication(web.Application):'
             static_path=ipython_app.static_file_path,
             static_handler_class = FileFindHandler,
             static_url_prefix = url_path_join(base_url,'/static/'),
+            static_handler_args = {
+                # don't cache custom.js
+                'no_cache_paths': [url_path_join(base_url, 'static', 'custom')],
+            },
+            version_hash=version_hash,
             
             # authentication
             cookie_secret=ipython_app.cookie_secret,
@@ -174,6 +190,7 b' class NotebookWebApplication(web.Application):'
             cluster_manager=cluster_manager,
             session_manager=session_manager,
             kernel_spec_manager=kernel_spec_manager,
+            config_manager=config_manager,
 
             # IPython stuff
             nbextensions_path = ipython_app.nbextensions_path,
@@ -181,6 +198,7 b' class NotebookWebApplication(web.Application):'
             mathjax_url=ipython_app.mathjax_url,
             config=ipython_app.config,
             jinja2_env=env,
+            terminals_available=False,  # Set later if terminals are available
         )
 
         # allow custom overrides for the tornado web app.
@@ -188,30 +206,34 b' class NotebookWebApplication(web.Application):'
         return settings
 
     def init_handlers(self, settings):
-        # Load the (URL pattern, handler) tuples for each component.
+        """Load the (URL pattern, handler) tuples for each component."""
+        
+        # Order matters. The first handler to match the URL will handle the request.
         handlers = []
-        handlers.extend(load_handlers('base.handlers'))
         handlers.extend(load_handlers('tree.handlers'))
         handlers.extend(load_handlers('auth.login'))
         handlers.extend(load_handlers('auth.logout'))
+        handlers.extend(load_handlers('files.handlers'))
         handlers.extend(load_handlers('notebook.handlers'))
         handlers.extend(load_handlers('nbconvert.handlers'))
         handlers.extend(load_handlers('kernelspecs.handlers'))
+        handlers.extend(load_handlers('edit.handlers'))
+        handlers.extend(load_handlers('services.config.handlers'))
         handlers.extend(load_handlers('services.kernels.handlers'))
         handlers.extend(load_handlers('services.contents.handlers'))
         handlers.extend(load_handlers('services.clusters.handlers'))
         handlers.extend(load_handlers('services.sessions.handlers'))
         handlers.extend(load_handlers('services.nbconvert.handlers'))
         handlers.extend(load_handlers('services.kernelspecs.handlers'))
-        # FIXME: /files/ should be handled by the Contents service when it exists
-        cm = settings['contents_manager']
-        if hasattr(cm, 'root_dir'):
-            handlers.append(
-            (r"/files/(.*)", AuthenticatedFileHandler, {'path' : cm.root_dir}),
-        )
+        handlers.extend(load_handlers('services.security.handlers'))
         handlers.append(
-            (r"/nbextensions/(.*)", FileFindHandler, {'path' : settings['nbextensions_path']}),
+            (r"/nbextensions/(.*)", FileFindHandler, {
+                'path': settings['nbextensions_path'],
+                'no_cache_paths': ['/'], # don't cache anything in nbextensions
+            }),
         )
+        # register base handlers last
+        handlers.extend(load_handlers('base.handlers'))
         # set the URL that will be redirected from `/`
         handlers.append(
             (r'/?', web.RedirectHandler, {
@@ -325,7 +347,7 b' class NotebookApp(BaseIPythonApplication):'
         list=(NbserverListApp, NbserverListApp.description.splitlines()[0]),
     )
 
-    kernel_argv = List(Unicode)
+    ipython_kernel_argv = List(Unicode)
     
     _log_formatter_cls = LogFormatter
 
@@ -345,11 +367,6 b' class NotebookApp(BaseIPythonApplication):'
 
     # file to be opened in the notebook server
     file_to_run = Unicode('', config=True)
-    def _file_to_run_changed(self, name, old, new):
-        path, base = os.path.split(new)
-        if path:
-            self.file_to_run = base
-            self.notebook_dir = path
 
     # Network related information
     
@@ -531,7 +548,20 b' class NotebookApp(BaseIPythonApplication):'
     def static_file_path(self):
         """return extra paths + the default location"""
         return self.extra_static_paths + [DEFAULT_STATIC_FILES_PATH]
-    
+
+    extra_template_paths = List(Unicode, config=True,
+        help="""Extra paths to search for serving jinja templates.
+
+        Can be used to override templates from IPython.html.templates."""
+    )
+    def _extra_template_paths_default(self):
+        return []
+
+    @property
+    def template_file_path(self):
+        """return extra paths + the default locations"""
+        return self.extra_template_paths + DEFAULT_TEMPLATE_PATH_LIST
+
     nbextensions_path = List(Unicode, config=True,
         help="""paths for Javascript extensions. By default, this is just IPYTHONDIR/nbextensions"""
     )
@@ -599,26 +629,38 b' class NotebookApp(BaseIPythonApplication):'
         help='The cluster manager class to use.'
     )
 
+    config_manager_class = DottedObjectName('IPython.html.services.config.manager.ConfigManager',
+        config = True,
+        help='The config manager class to use'
+    )
+
     kernel_spec_manager = Instance(KernelSpecManager)
 
     def _kernel_spec_manager_default(self):
         return KernelSpecManager(ipython_dir=self.ipython_dir)
 
+
+    kernel_spec_manager_class = DottedObjectName('IPython.kernel.kernelspec.KernelSpecManager',
+            config=True,
+            help="""
+            The kernel spec manager class to use. Should be a subclass
+            of `IPython.kernel.kernelspec.KernelSpecManager`.
+
+            The Api of KernelSpecManager is provisional and might change
+            without warning between this version of IPython and the next stable one.
+            """)
+
     trust_xheaders = Bool(False, config=True,
         help=("Whether to trust or not X-Scheme/X-Forwarded-Proto and X-Real-Ip/X-Forwarded-For headers"
               "sent by the upstream reverse proxy. Necessary if the proxy handles SSL")
     )
-    
+
     info_file = Unicode()
 
     def _info_file_default(self):
         info_file = "nbserver-%s.json"%os.getpid()
         return os.path.join(self.profile_dir.security_dir, info_file)
     
-    notebook_dir = Unicode(py3compat.getcwd(), config=True,
-        help="The directory to use for notebooks and kernels."
-    )
-    
     pylab = Unicode('disabled', config=True,
         help="""
         DISABLED: use %pylab or %matplotlib in the notebook to enable matplotlib.
@@ -636,6 +678,16 b' class NotebookApp(BaseIPythonApplication):'
         )
         self.exit(1)
 
+    notebook_dir = Unicode(config=True,
+        help="The directory to use for notebooks and kernels."
+    )
+
+    def _notebook_dir_default(self):
+        if self.file_to_run:
+            return os.path.dirname(os.path.abspath(self.file_to_run))
+        else:
+            return py3compat.getcwd()
+
     def _notebook_dir_changed(self, name, old, new):
         """Do a bit of validation of the notebook dir."""
         if not os.path.isabs(new):
@@ -671,16 +723,20 b' class NotebookApp(BaseIPythonApplication):'
             self.update_config(c)
 
     def init_kernel_argv(self):
-        """construct the kernel arguments"""
+        """add the profile-dir to arguments to be passed to IPython kernels"""
+        # FIXME: remove special treatment of IPython kernels
         # Kernel should get *absolute* path to profile directory
-        self.kernel_argv = ["--profile-dir", self.profile_dir.location]
+        self.ipython_kernel_argv = ["--profile-dir", self.profile_dir.location]
 
     def init_configurables(self):
         # force Session default to be secure
         default_secure(self.config)
+        kls = import_item(self.kernel_spec_manager_class)
+        self.kernel_spec_manager = kls(ipython_dir=self.ipython_dir)
+
         kls = import_item(self.kernel_manager_class)
         self.kernel_manager = kls(
-            parent=self, log=self.log, kernel_argv=self.kernel_argv,
+            parent=self, log=self.log, ipython_kernel_argv=self.ipython_kernel_argv,
             connection_dir = self.profile_dir.security_dir,
         )
         kls = import_item(self.contents_manager_class)
@@ -693,12 +749,19 b' class NotebookApp(BaseIPythonApplication):'
         self.cluster_manager = kls(parent=self, log=self.log)
         self.cluster_manager.update_profiles()
 
+        kls = import_item(self.config_manager_class)
+        self.config_manager = kls(parent=self, log=self.log,
+                                  profile_dir=self.profile_dir.location)
+
     def init_logging(self):
         # This prevents double log messages because tornado use a root logger that
         # self.log is a child of. The logging module dipatches log messages to a log
         # and all of its ancenstors until propagate is set to False.
         self.log.propagate = False
         
+        for log in app_log, access_log, gen_log:
+            # consistent log output name (NotebookApp instead of tornado.access, etc.)
+            log.name = self.log.name
         # hook up tornado 3's loggers to our app handlers
         logger = logging.getLogger('tornado')
         logger.propagate = True
@@ -715,6 +778,7 b' class NotebookApp(BaseIPythonApplication):'
         self.web_app = NotebookWebApplication(
             self, self.kernel_manager, self.contents_manager,
             self.cluster_manager, self.session_manager, self.kernel_spec_manager,
+            self.config_manager,
             self.log, self.base_url, self.default_url, self.tornado_settings,
             self.jinja_environment_options
         )
@@ -771,6 +835,14 b' class NotebookApp(BaseIPythonApplication):'
         proto = 'https' if self.certfile else 'http'
         return "%s://%s:%i%s" % (proto, ip, self.port, self.base_url)
 
+    def init_terminals(self):
+        try:
+            from .terminal import initialize
+            initialize(self.web_app)
+            self.web_app.settings['terminals_available'] = True
+        except ImportError as e:
+            self.log.info("Terminals not available (error was %s)", e)
+
     def init_signal(self):
         if not sys.platform.startswith('win'):
             signal.signal(signal.SIGINT, self._handle_sigint)
@@ -850,6 +922,7 b' class NotebookApp(BaseIPythonApplication):'
         self.init_configurables()
         self.init_components()
         self.init_webapp()
+        self.init_terminals()
         self.init_signal()
 
     def cleanup_kernels(self):
@@ -917,12 +990,12 b' class NotebookApp(BaseIPythonApplication):'
                 browser = None
             
             if self.file_to_run:
-                fullpath = os.path.join(self.notebook_dir, self.file_to_run)
-                if not os.path.exists(fullpath):
-                    self.log.critical("%s does not exist" % fullpath)
+                if not os.path.exists(self.file_to_run):
+                    self.log.critical("%s does not exist" % self.file_to_run)
                     self.exit(1)
-                
-                uri = url_path_join('notebooks', self.file_to_run)
+
+                relpath = os.path.relpath(self.file_to_run, self.notebook_dir)
+                uri = url_path_join('notebooks', *relpath.split(os.sep))
             else:
                 uri = 'tree'
             if browser:

IPython/html/services/clusters/clustermanager.py

@@ -1,44 +1,23 b''
-"""Manage IPython.parallel clusters in the notebook.
+"""Manage IPython.parallel clusters in the notebook."""
 
-Authors:
-
-* Brian Granger
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-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.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 from tornado import web
-from zmq.eventloop import ioloop
 
 from IPython.config.configurable import LoggingConfigurable
-from IPython.utils.traitlets import Dict, Instance, CFloat
+from IPython.utils.traitlets import Dict, Instance, Float
 from IPython.core.profileapp import list_profiles_in
 from IPython.core.profiledir import ProfileDir
 from IPython.utils import py3compat
 from IPython.utils.path import get_ipython_dir
 
 
-#-----------------------------------------------------------------------------
-# Classes
-#-----------------------------------------------------------------------------
-
-
-
-
 class ClusterManager(LoggingConfigurable):
 
     profiles = Dict()
 
-    delay = CFloat(1., config=True,
+    delay = Float(1., config=True,
         help="delay (in s) between starting the controller and the engines")
 
     loop = Instance('zmq.eventloop.ioloop.IOLoop')
@@ -75,16 +54,24 b' class ClusterManager(LoggingConfigurable):'
     def update_profiles(self):
         """List all profiles in the ipython_dir and cwd.
         """
+        
+        stale = set(self.profiles)
         for path in [get_ipython_dir(), py3compat.getcwd()]:
             for profile in list_profiles_in(path):
+                if profile in stale:
+                    stale.remove(profile)
                 pd = self.get_profile_dir(profile, path)
                 if profile not in self.profiles:
-                    self.log.debug("Adding cluster profile '%s'" % profile)
+                    self.log.debug("Adding cluster profile '%s'", profile)
                     self.profiles[profile] = {
                         'profile': profile,
                         'profile_dir': pd,
                         'status': 'stopped'
                     }
+        for profile in stale:
+            # remove profiles that no longer exist
+            self.log.debug("Profile '%s' no longer exists", profile)
+            self.profiles.pop(stale)
 
     def list_profiles(self):
         self.update_profiles()
@@ -133,11 +120,13 b' class ClusterManager(LoggingConfigurable):'
                 esl.stop()
             clean_data()
         cl.on_stop(controller_stopped)
-
-        dc = ioloop.DelayedCallback(lambda: cl.start(), 0, self.loop)
-        dc.start()
-        dc = ioloop.DelayedCallback(lambda: esl.start(n), 1000*self.delay, self.loop)
-        dc.start()
+        loop = self.loop
+        
+        def start():
+            """start the controller, then the engines after a delay"""
+            cl.start()
+            loop.add_timeout(self.loop.time() + self.delay, lambda : esl.start(n))
+        self.loop.add_callback(start)
 
         self.log.debug('Cluster started')
         data['controller_launcher'] = cl

IPython/html/services/contents/filemanager.py

@@ -4,27 +4,66 b''
 # Distributed under the terms of the Modified BSD License.
 
 import base64
+import errno
 import io
 import os
-import glob
 import shutil
+from contextlib import contextmanager
+import mimetypes
 
 from tornado import web
 
 from .manager import ContentsManager
-from IPython.nbformat import current
+from IPython import nbformat
 from IPython.utils.io import atomic_writing
 from IPython.utils.path import ensure_dir_exists
 from IPython.utils.traitlets import Unicode, Bool, TraitError
-from IPython.utils.py3compat import getcwd
+from IPython.utils.py3compat import getcwd, str_to_unicode
 from IPython.utils import tz
-from IPython.html.utils import is_hidden, to_os_path, url_path_join
+from IPython.html.utils import is_hidden, to_os_path, to_api_path
 
 
 class FileContentsManager(ContentsManager):
 
-    root_dir = Unicode(getcwd(), config=True)
+    root_dir = Unicode(config=True)
 
+    def _root_dir_default(self):
+        try:
+            return self.parent.notebook_dir
+        except AttributeError:
+            return getcwd()
+    
+    @contextmanager
+    def perm_to_403(self, os_path=''):
+        """context manager for turning permission errors into 403"""
+        try:
+            yield
+        except OSError as e:
+            if e.errno in {errno.EPERM, errno.EACCES}:
+                # make 403 error message without root prefix
+                # this may not work perfectly on unicode paths on Python 2,
+                # but nobody should be doing that anyway.
+                if not os_path:
+                    os_path = str_to_unicode(e.filename or 'unknown file')
+                path = to_api_path(os_path, self.root_dir)
+                raise web.HTTPError(403, u'Permission denied: %s' % path)
+            else:
+                raise
+    
+    @contextmanager
+    def open(self, os_path, *args, **kwargs):
+        """wrapper around io.open that turns permission errors into 403"""
+        with self.perm_to_403(os_path):
+            with io.open(os_path, *args, **kwargs) as f:
+                yield f
+    
+    @contextmanager
+    def atomic_writing(self, os_path, *args, **kwargs):
+        """wrapper around atomic_writing that turns permission errors into 403"""
+        with self.perm_to_403(os_path):
+            with atomic_writing(os_path, *args, **kwargs) as f:
+                yield f
+    
     save_script = Bool(False, config=True, help='DEPRECATED, IGNORED')
     def _save_script_changed(self):
         self.log.warn("""
@@ -61,27 +100,22 b' class FileContentsManager(ContentsManager):'
         except OSError as e:
             self.log.debug("copystat on %s failed", dest, exc_info=True)
 
-    def _get_os_path(self, name=None, path=''):
-        """Given a filename and API path, return its file system
-        path.
+    def _get_os_path(self, path):
+        """Given an API path, return its file system path.
 
         Parameters
         ----------
-        name : string
-            A filename
         path : string
             The relative API path to the named file.
 
         Returns
         -------
         path : string
-            API path to be evaluated relative to root_dir.
+            Native, absolute OS path to for a file.
         """
-        if name is not None:
-            path = url_path_join(path, name)
         return to_os_path(path, self.root_dir)
 
-    def path_exists(self, path):
+    def dir_exists(self, path):
         """Does the API-style path refer to an extant directory?
 
         API-style wrapper for os.path.isdir
@@ -112,25 +146,22 b' class FileContentsManager(ContentsManager):'
 
         Returns
         -------
-        exists : bool
-            Whether the path is hidden.
-
+        hidden : bool
+            Whether the path exists and is hidden.
         """
         path = path.strip('/')
         os_path = self._get_os_path(path=path)
         return is_hidden(os_path, self.root_dir)
 
-    def file_exists(self, name, path=''):
+    def file_exists(self, path):
         """Returns True if the file exists, else returns False.
 
         API-style wrapper for os.path.isfile
 
         Parameters
         ----------
-        name : string
-            The name of the file you are checking.
         path : string
-            The relative path to the file's directory (with '/' as separator)
+            The relative path to the file (with '/' as separator)
 
         Returns
         -------
@@ -138,20 +169,18 b' class FileContentsManager(ContentsManager):'
             Whether the file exists.
         """
         path = path.strip('/')
-        nbpath = self._get_os_path(name, path=path)
-        return os.path.isfile(nbpath)
+        os_path = self._get_os_path(path)
+        return os.path.isfile(os_path)
 
-    def exists(self, name=None, path=''):
-        """Returns True if the path [and name] exists, else returns False.
+    def exists(self, path):
+        """Returns True if the path exists, else returns False.
 
         API-style wrapper for os.path.exists
 
         Parameters
         ----------
-        name : string
-            The name of the file you are checking.
         path : string
-            The relative path to the file's directory (with '/' as separator)
+            The API path to the file (with '/' as separator)
 
         Returns
         -------
@@ -159,33 +188,39 b' class FileContentsManager(ContentsManager):'
             Whether the target exists.
         """
         path = path.strip('/')
-        os_path = self._get_os_path(name, path=path)
+        os_path = self._get_os_path(path=path)
         return os.path.exists(os_path)
 
-    def _base_model(self, name, path=''):
+    def _base_model(self, path):
         """Build the common base of a contents model"""
-        os_path = self._get_os_path(name, path)
+        os_path = self._get_os_path(path)
         info = os.stat(os_path)
         last_modified = tz.utcfromtimestamp(info.st_mtime)
         created = tz.utcfromtimestamp(info.st_ctime)
         # Create the base model.
         model = {}
-        model['name'] = name
+        model['name'] = path.rsplit('/', 1)[-1]
         model['path'] = path
         model['last_modified'] = last_modified
         model['created'] = created
         model['content'] = None
         model['format'] = None
+        model['mimetype'] = None
+        try:
+            model['writable'] = os.access(os_path, os.W_OK)
+        except OSError:
+            self.log.error("Failed to check write permissions on %s", os_path)
+            model['writable'] = False
         return model
 
-    def _dir_model(self, name, path='', content=True):
+    def _dir_model(self, path, content=True):
         """Build a model for a directory
 
         if content is requested, will include a listing of the directory
         """
-        os_path = self._get_os_path(name, path)
+        os_path = self._get_os_path(path)
 
-        four_o_four = u'directory does not exist: %r' % os_path
+        four_o_four = u'directory does not exist: %r' % path
 
         if not os.path.isdir(os_path):
             raise web.HTTPError(404, four_o_four)
@@ -195,80 +230,105 b' class FileContentsManager(ContentsManager):'
             )
             raise web.HTTPError(404, four_o_four)
 
-        if name is None:
-            if '/' in path:
-                path, name = path.rsplit('/', 1)
-            else:
-                name = ''
-        model = self._base_model(name, path)
+        model = self._base_model(path)
         model['type'] = 'directory'
-        dir_path = u'{}/{}'.format(path, name)
         if content:
             model['content'] = contents = []
-            for os_path in glob.glob(self._get_os_path('*', dir_path)):
-                name = os.path.basename(os_path)
+            os_dir = self._get_os_path(path)
+            for name in os.listdir(os_dir):
+                os_path = os.path.join(os_dir, name)
                 # skip over broken symlinks in listing
                 if not os.path.exists(os_path):
                     self.log.warn("%s doesn't exist", os_path)
                     continue
+                elif not os.path.isfile(os_path) and not os.path.isdir(os_path):
+                    self.log.debug("%s not a regular file", os_path)
+                    continue
                 if self.should_list(name) and not is_hidden(os_path, self.root_dir):
-                    contents.append(self.get_model(name=name, path=dir_path, content=False))
+                    contents.append(self.get(
+                        path='%s/%s' % (path, name),
+                        content=False)
+                    )
 
             model['format'] = 'json'
 
         return model
 
-    def _file_model(self, name, path='', content=True):
+    def _file_model(self, path, content=True, format=None):
         """Build a model for a file
 
         if content is requested, include the file contents.
-        UTF-8 text files will be unicode, binary files will be base64-encoded.
+
+        format:
+          If 'text', the contents will be decoded as UTF-8.
+          If 'base64', the raw bytes contents will be encoded as base64.
+          If not specified, try to decode as UTF-8, and fall back to base64
         """
-        model = self._base_model(name, path)
+        model = self._base_model(path)
         model['type'] = 'file'
+
+        os_path = self._get_os_path(path)
+        model['mimetype'] = mimetypes.guess_type(os_path)[0] or 'text/plain'
+
         if content:
-            os_path = self._get_os_path(name, path)
-            with io.open(os_path, 'rb') as f:
+            if not os.path.isfile(os_path):
+                # could be FIFO
+                raise web.HTTPError(400, "Cannot get content of non-file %s" % os_path)
+            with self.open(os_path, 'rb') as f:
                 bcontent = f.read()
-            try:
-                model['content'] = bcontent.decode('utf8')
-            except UnicodeError as e:
+
+            if format != 'base64':
+                try:
+                    model['content'] = bcontent.decode('utf8')
+                except UnicodeError as e:
+                    if format == 'text':
+                        raise web.HTTPError(400, "%s is not UTF-8 encoded" % path)
+                else:
+                    model['format'] = 'text'
+
+            if model['content'] is None:
                 model['content'] = base64.encodestring(bcontent).decode('ascii')
                 model['format'] = 'base64'
-            else:
-                model['format'] = 'text'
+
         return model
 
 
-    def _notebook_model(self, name, path='', content=True):
+    def _notebook_model(self, path, content=True):
         """Build a notebook model
 
         if content is requested, the notebook content will be populated
         as a JSON structure (not double-serialized)
         """
-        model = self._base_model(name, path)
+        model = self._base_model(path)
         model['type'] = 'notebook'
         if content:
-            os_path = self._get_os_path(name, path)
-            with io.open(os_path, 'r', encoding='utf-8') as f:
+            os_path = self._get_os_path(path)
+            with self.open(os_path, 'r', encoding='utf-8') as f:
                 try:
-                    nb = current.read(f, u'json')
+                    nb = nbformat.read(f, as_version=4)
                 except Exception as e:
-                    raise web.HTTPError(400, u"Unreadable Notebook: %s %s" % (os_path, e))
-            self.mark_trusted_cells(nb, name, path)
+                    raise web.HTTPError(400, u"Unreadable Notebook: %s %r" % (os_path, e))
+            self.mark_trusted_cells(nb, path)
             model['content'] = nb
             model['format'] = 'json'
+            self.validate_notebook_model(model)
         return model
 
-    def get_model(self, name, path='', content=True):
-        """ Takes a path and name for an entity and returns its model
+    def get(self, path, content=True, type_=None, format=None):
+        """ Takes a path for an entity and returns its model
 
         Parameters
         ----------
-        name : str
-            the name of the target
         path : str
             the API path that describes the relative path for the target
+        content : bool
+            Whether to include the contents in the reply
+        type_ : str, optional
+            The requested type - 'file', 'notebook', or 'directory'.
+            Will raise HTTPError 400 if the content doesn't match.
+        format : str, optional
+            The requested format for file contents. 'text' or 'base64'.
+            Ignored if this returns a notebook or directory model.
 
         Returns
         -------
@@ -278,32 +338,35 b' class FileContentsManager(ContentsManager):'
         """
         path = path.strip('/')
 
-        if not self.exists(name=name, path=path):
-            raise web.HTTPError(404, u'No such file or directory: %s/%s' % (path, name))
+        if not self.exists(path):
+            raise web.HTTPError(404, u'No such file or directory: %s' % path)
 
-        os_path = self._get_os_path(name, path)
+        os_path = self._get_os_path(path)
         if os.path.isdir(os_path):
-            model = self._dir_model(name, path, content)
-        elif name.endswith('.ipynb'):
-            model = self._notebook_model(name, path, content)
+            if type_ not in (None, 'directory'):
+                raise web.HTTPError(400,
+                                u'%s is a directory, not a %s' % (path, type_))
+            model = self._dir_model(path, content=content)
+        elif type_ == 'notebook' or (type_ is None and path.endswith('.ipynb')):
+            model = self._notebook_model(path, content=content)
         else:
-            model = self._file_model(name, path, content)
+            if type_ == 'directory':
+                raise web.HTTPError(400,
+                                u'%s is not a directory')
+            model = self._file_model(path, content=content, format=format)
         return model
 
-    def _save_notebook(self, os_path, model, name='', path=''):
+    def _save_notebook(self, os_path, model, path=''):
         """save a notebook file"""
         # Save the notebook file
-        nb = current.to_notebook_json(model['content'])
+        nb = nbformat.from_dict(model['content'])
 
-        self.check_and_sign(nb, name, path)
+        self.check_and_sign(nb, path)
 
-        if 'name' in nb['metadata']:
-            nb['metadata']['name'] = u''
+        with self.atomic_writing(os_path, encoding='utf-8') as f:
+            nbformat.write(nb, f, version=nbformat.NO_CONVERT)
 
-        with atomic_writing(os_path, encoding='utf-8') as f:
-            current.write(nb, f, u'json')
-
-    def _save_file(self, os_path, model, name='', path=''):
+    def _save_file(self, os_path, model, path=''):
         """save a non-notebook file"""
         fmt = model.get('format', None)
         if fmt not in {'text', 'base64'}:
@@ -317,21 +380,22 b' class FileContentsManager(ContentsManager):'
                 bcontent = base64.decodestring(b64_bytes)
         except Exception as e:
             raise web.HTTPError(400, u'Encoding error saving %s: %s' % (os_path, e))
-        with atomic_writing(os_path, text=False) as f:
+        with self.atomic_writing(os_path, text=False) as f:
             f.write(bcontent)
 
-    def _save_directory(self, os_path, model, name='', path=''):
+    def _save_directory(self, os_path, model, path=''):
         """create a directory"""
         if is_hidden(os_path, self.root_dir):
             raise web.HTTPError(400, u'Cannot create hidden directory %r' % os_path)
         if not os.path.exists(os_path):
-            os.mkdir(os_path)
+            with self.perm_to_403():
+                os.mkdir(os_path)
         elif not os.path.isdir(os_path):
             raise web.HTTPError(400, u'Not a directory: %s' % (os_path))
         else:
             self.log.debug("Directory %r already exists", os_path)
 
-    def save(self, model, name='', path=''):
+    def save(self, model, path=''):
         """Save the file model and return the model with no content."""
         path = path.strip('/')
 
@@ -341,52 +405,53 b' class FileContentsManager(ContentsManager):'
             raise web.HTTPError(400, u'No file content provided')
 
         # One checkpoint should always exist
-        if self.file_exists(name, path) and not self.list_checkpoints(name, path):
-            self.create_checkpoint(name, path)
-
-        new_path = model.get('path', path).strip('/')
-        new_name = model.get('name', name)
+        if self.file_exists(path) and not self.list_checkpoints(path):
+            self.create_checkpoint(path)
 
-        if path != new_path or name != new_name:
-            self.rename(name, path, new_name, new_path)
-
-        os_path = self._get_os_path(new_name, new_path)
+        os_path = self._get_os_path(path)
         self.log.debug("Saving %s", os_path)
         try:
             if model['type'] == 'notebook':
-                self._save_notebook(os_path, model, new_name, new_path)
+                self._save_notebook(os_path, model, path)
             elif model['type'] == 'file':
-                self._save_file(os_path, model, new_name, new_path)
+                self._save_file(os_path, model, path)
             elif model['type'] == 'directory':
-                self._save_directory(os_path, model, new_name, new_path)
+                self._save_directory(os_path, model, path)
             else:
                 raise web.HTTPError(400, "Unhandled contents type: %s" % model['type'])
         except web.HTTPError:
             raise
         except Exception as e:
-            raise web.HTTPError(400, u'Unexpected error while saving file: %s %s' % (os_path, e))
+            self.log.error(u'Error while saving file: %s %s', path, e, exc_info=True)
+            raise web.HTTPError(500, u'Unexpected error while saving file: %s %s' % (path, e))
+
+        validation_message = None
+        if model['type'] == 'notebook':
+            self.validate_notebook_model(model)
+            validation_message = model.get('message', None)
 
-        model = self.get_model(new_name, new_path, content=False)
+        model = self.get(path, content=False)
+        if validation_message:
+            model['message'] = validation_message
         return model
 
-    def update(self, model, name, path=''):
-        """Update the file's path and/or name
+    def update(self, model, path):
+        """Update the file's path
 
         For use in PATCH requests, to enable renaming a file without
         re-uploading its contents. Only used for renaming at the moment.
         """
         path = path.strip('/')
-        new_name = model.get('name', name)
         new_path = model.get('path', path).strip('/')
-        if path != new_path or name != new_name:
-            self.rename(name, path, new_name, new_path)
-        model = self.get_model(new_name, new_path, content=False)
+        if path != new_path:
+            self.rename(path, new_path)
+        model = self.get(new_path, content=False)
         return model
 
-    def delete(self, name, path=''):
-        """Delete file by name and path."""
+    def delete(self, path):
+        """Delete file at path."""
         path = path.strip('/')
-        os_path = self._get_os_path(name, path)
+        os_path = self._get_os_path(path)
         rm = os.unlink
         if os.path.isdir(os_path):
             listing = os.listdir(os_path)
@@ -397,71 +462,81 b' class FileContentsManager(ContentsManager):'
             raise web.HTTPError(404, u'File does not exist: %s' % os_path)
 
         # clear checkpoints
-        for checkpoint in self.list_checkpoints(name, path):
+        for checkpoint in self.list_checkpoints(path):
             checkpoint_id = checkpoint['id']
-            cp_path = self.get_checkpoint_path(checkpoint_id, name, path)
+            cp_path = self.get_checkpoint_path(checkpoint_id, path)
             if os.path.isfile(cp_path):
                 self.log.debug("Unlinking checkpoint %s", cp_path)
-                os.unlink(cp_path)
+                with self.perm_to_403():
+                    rm(cp_path)
 
         if os.path.isdir(os_path):
             self.log.debug("Removing directory %s", os_path)
-            shutil.rmtree(os_path)
+            with self.perm_to_403():
+                shutil.rmtree(os_path)
         else:
             self.log.debug("Unlinking file %s", os_path)
-            rm(os_path)
+            with self.perm_to_403():
+                rm(os_path)
 
-    def rename(self, old_name, old_path, new_name, new_path):
+    def rename(self, old_path, new_path):
         """Rename a file."""
         old_path = old_path.strip('/')
         new_path = new_path.strip('/')
-        if new_name == old_name and new_path == old_path:
+        if new_path == old_path:
             return
 
-        new_os_path = self._get_os_path(new_name, new_path)
-        old_os_path = self._get_os_path(old_name, old_path)
+        new_os_path = self._get_os_path(new_path)
+        old_os_path = self._get_os_path(old_path)
 
         # Should we proceed with the move?
-        if os.path.isfile(new_os_path):
-            raise web.HTTPError(409, u'File with name already exists: %s' % new_os_path)
+        if os.path.exists(new_os_path):
+            raise web.HTTPError(409, u'File already exists: %s' % new_path)
 
         # Move the file
         try:
-            shutil.move(old_os_path, new_os_path)
+            with self.perm_to_403():
+                shutil.move(old_os_path, new_os_path)
+        except web.HTTPError:
+            raise
         except Exception as e:
-            raise web.HTTPError(500, u'Unknown error renaming file: %s %s' % (old_os_path, e))
+            raise web.HTTPError(500, u'Unknown error renaming file: %s %s' % (old_path, e))
 
         # Move the checkpoints
-        old_checkpoints = self.list_checkpoints(old_name, old_path)
+        old_checkpoints = self.list_checkpoints(old_path)
         for cp in old_checkpoints:
             checkpoint_id = cp['id']
-            old_cp_path = self.get_checkpoint_path(checkpoint_id, old_name, old_path)
-            new_cp_path = self.get_checkpoint_path(checkpoint_id, new_name, new_path)
+            old_cp_path = self.get_checkpoint_path(checkpoint_id, old_path)
+            new_cp_path = self.get_checkpoint_path(checkpoint_id, new_path)
             if os.path.isfile(old_cp_path):
                 self.log.debug("Renaming checkpoint %s -> %s", old_cp_path, new_cp_path)
-                shutil.move(old_cp_path, new_cp_path)
+                with self.perm_to_403():
+                    shutil.move(old_cp_path, new_cp_path)
 
     # Checkpoint-related utilities
 
-    def get_checkpoint_path(self, checkpoint_id, name, path=''):
+    def get_checkpoint_path(self, checkpoint_id, path):
         """find the path to a checkpoint"""
         path = path.strip('/')
+        parent, name = ('/' + path).rsplit('/', 1)
+        parent = parent.strip('/')
         basename, ext = os.path.splitext(name)
         filename = u"{name}-{checkpoint_id}{ext}".format(
             name=basename,
             checkpoint_id=checkpoint_id,
             ext=ext,
         )
-        os_path = self._get_os_path(path=path)
+        os_path = self._get_os_path(path=parent)
         cp_dir = os.path.join(os_path, self.checkpoint_dir)
-        ensure_dir_exists(cp_dir)
+        with self.perm_to_403():
+            ensure_dir_exists(cp_dir)
         cp_path = os.path.join(cp_dir, filename)
         return cp_path
 
-    def get_checkpoint_model(self, checkpoint_id, name, path=''):
+    def get_checkpoint_model(self, checkpoint_id, path):
         """construct the info dict for a given checkpoint"""
         path = path.strip('/')
-        cp_path = self.get_checkpoint_path(checkpoint_id, name, path)
+        cp_path = self.get_checkpoint_path(checkpoint_id, path)
         stats = os.stat(cp_path)
         last_modified = tz.utcfromtimestamp(stats.st_mtime)
         info = dict(
@@ -472,58 +547,62 b' class FileContentsManager(ContentsManager):'
 
     # public checkpoint API
 
-    def create_checkpoint(self, name, path=''):
+    def create_checkpoint(self, path):
         """Create a checkpoint from the current state of a file"""
         path = path.strip('/')
-        src_path = self._get_os_path(name, path)
+        if not self.file_exists(path):
+            raise web.HTTPError(404)
+        src_path = self._get_os_path(path)
         # only the one checkpoint ID:
         checkpoint_id = u"checkpoint"
-        cp_path = self.get_checkpoint_path(checkpoint_id, name, path)
-        self.log.debug("creating checkpoint for %s", name)
-        self._copy(src_path, cp_path)
+        cp_path = self.get_checkpoint_path(checkpoint_id, path)
+        self.log.debug("creating checkpoint for %s", path)
+        with self.perm_to_403():
+            self._copy(src_path, cp_path)
 
         # return the checkpoint info
-        return self.get_checkpoint_model(checkpoint_id, name, path)
+        return self.get_checkpoint_model(checkpoint_id, path)
 
-    def list_checkpoints(self, name, path=''):
+    def list_checkpoints(self, path):
         """list the checkpoints for a given file
 
         This contents manager currently only supports one checkpoint per file.
         """
         path = path.strip('/')
         checkpoint_id = "checkpoint"
-        os_path = self.get_checkpoint_path(checkpoint_id, name, path)
+        os_path = self.get_checkpoint_path(checkpoint_id, path)
         if not os.path.exists(os_path):
             return []
         else:
-            return [self.get_checkpoint_model(checkpoint_id, name, path)]
+            return [self.get_checkpoint_model(checkpoint_id, path)]
 
 
-    def restore_checkpoint(self, checkpoint_id, name, path=''):
+    def restore_checkpoint(self, checkpoint_id, path):
         """restore a file to a checkpointed state"""
         path = path.strip('/')
-        self.log.info("restoring %s from checkpoint %s", name, checkpoint_id)
-        nb_path = self._get_os_path(name, path)
-        cp_path = self.get_checkpoint_path(checkpoint_id, name, path)
+        self.log.info("restoring %s from checkpoint %s", path, checkpoint_id)
+        nb_path = self._get_os_path(path)
+        cp_path = self.get_checkpoint_path(checkpoint_id, path)
         if not os.path.isfile(cp_path):
             self.log.debug("checkpoint file does not exist: %s", cp_path)
             raise web.HTTPError(404,
-                u'checkpoint does not exist: %s-%s' % (name, checkpoint_id)
+                u'checkpoint does not exist: %s@%s' % (path, checkpoint_id)
             )
         # ensure notebook is readable (never restore from an unreadable notebook)
         if cp_path.endswith('.ipynb'):
-            with io.open(cp_path, 'r', encoding='utf-8') as f:
-                current.read(f, u'json')
-        self._copy(cp_path, nb_path)
+            with self.open(cp_path, 'r', encoding='utf-8') as f:
+                nbformat.read(f, as_version=4)
         self.log.debug("copying %s -> %s", cp_path, nb_path)
+        with self.perm_to_403():
+            self._copy(cp_path, nb_path)
 
-    def delete_checkpoint(self, checkpoint_id, name, path=''):
+    def delete_checkpoint(self, checkpoint_id, path):
         """delete a file's checkpoint"""
         path = path.strip('/')
-        cp_path = self.get_checkpoint_path(checkpoint_id, name, path)
+        cp_path = self.get_checkpoint_path(checkpoint_id, path)
         if not os.path.isfile(cp_path):
             raise web.HTTPError(404,
-                u'Checkpoint does not exist: %s%s-%s' % (path, name, checkpoint_id)
+                u'Checkpoint does not exist: %s@%s' % (path, checkpoint_id)
             )
         self.log.debug("unlinking %s", cp_path)
         os.unlink(cp_path)
@@ -531,6 +610,10 b' class FileContentsManager(ContentsManager):'
     def info_string(self):
         return "Serving notebooks from local directory: %s" % self.root_dir
 
-    def get_kernel_path(self, name, path='', model=None):
-        """Return the initial working dir a kernel associated with a given notebook"""
-        return os.path.join(self.root_dir, path)
+    def get_kernel_path(self, path, model=None):
+        """Return the initial API path of  a kernel associated with a given notebook"""
+        if '/' in path:
+            parent_dir = path.rsplit('/', 1)[0]
+        else:
+            parent_dir = ''
+        return parent_dir

IPython/html/services/contents/handlers.py

@@ -10,9 +10,9 b' from tornado import web'
 from IPython.html.utils import url_path_join, url_escape
 from IPython.utils.jsonutil import date_default
 
-from IPython.html.base.handlers import (IPythonHandler, json_errors,
-                                    file_path_regex, path_regex,
-                                    file_name_regex)
+from IPython.html.base.handlers import (
+    IPythonHandler, json_errors, path_regex,
+)
 
 
 def sort_key(model):
@@ -29,38 +29,44 b' class ContentsHandler(IPythonHandler):'
 
     SUPPORTED_METHODS = (u'GET', u'PUT', u'PATCH', u'POST', u'DELETE')
 
-    def location_url(self, name, path):
+    def location_url(self, path):
         """Return the full URL location of a file.
 
         Parameters
         ----------
-        name : unicode
-            The base name of the file, such as "foo.ipynb".
         path : unicode
-            The API path of the file, such as "foo/bar".
+            The API path of the file, such as "foo/bar.txt".
         """
         return url_escape(url_path_join(
-            self.base_url, 'api', 'contents', path, name
+            self.base_url, 'api', 'contents', path
         ))
 
     def _finish_model(self, model, location=True):
         """Finish a JSON request with a model, setting relevant headers, etc."""
         if location:
-            location = self.location_url(model['name'], model['path'])
+            location = self.location_url(model['path'])
             self.set_header('Location', location)
         self.set_header('Last-Modified', model['last_modified'])
         self.finish(json.dumps(model, default=date_default))
 
     @web.authenticated
     @json_errors
-    def get(self, path='', name=None):
+    def get(self, path=''):
         """Return a model for a file or directory.
 
         A directory model contains a list of models (without content)
         of the files and directories it contains.
         """
         path = path or ''
-        model = self.contents_manager.get_model(name=name, path=path)
+        type_ = self.get_query_argument('type', default=None)
+        if type_ not in {None, 'directory', 'file', 'notebook'}:
+            raise web.HTTPError(400, u'Type %r is invalid' % type_)
+
+        format = self.get_query_argument('format', default=None)#
+        if format not in {None, 'text', 'base64'}:
+            raise web.HTTPError(400, u'Format %r is invalid' % format)
+
+        model = self.contents_manager.get(path=path, type_=type_, format=format)
         if model['type'] == 'directory':
             # group listing by type, then by name (case-insensitive)
             # FIXME: sorting should be done in the frontends
@@ -69,112 +75,83 b' class ContentsHandler(IPythonHandler):'
 
     @web.authenticated
     @json_errors
-    def patch(self, path='', name=None):
-        """PATCH renames a notebook without re-uploading content."""
+    def patch(self, path=''):
+        """PATCH renames a file or directory without re-uploading content."""
         cm = self.contents_manager
-        if name is None:
-            raise web.HTTPError(400, u'Filename missing')
         model = self.get_json_body()
         if model is None:
             raise web.HTTPError(400, u'JSON body missing')
-        model = cm.update(model, name, path)
+        model = cm.update(model, path)
         self._finish_model(model)
 
-    def _copy(self, copy_from, path, copy_to=None):
-        """Copy a file, optionally specifying the new name.
-        """
-        self.log.info(u"Copying {copy_from} to {path}/{copy_to}".format(
+    def _copy(self, copy_from, copy_to=None):
+        """Copy a file, optionally specifying a target directory."""
+        self.log.info(u"Copying {copy_from} to {copy_to}".format(
             copy_from=copy_from,
-            path=path,
             copy_to=copy_to or '',
         ))
-        model = self.contents_manager.copy(copy_from, copy_to, path)
+        model = self.contents_manager.copy(copy_from, copy_to)
         self.set_status(201)
         self._finish_model(model)
 
-    def _upload(self, model, path, name=None):
-        """Handle upload of a new file
-
-        If name specified, create it in path/name,
-        otherwise create a new untitled file in path.
-        """
-        self.log.info(u"Uploading file to %s/%s", path, name or '')
-        if name:
-            model['name'] = name
-
-        model = self.contents_manager.create_file(model, path)
+    def _upload(self, model, path):
+        """Handle upload of a new file to path"""
+        self.log.info(u"Uploading file to %s", path)
+        model = self.contents_manager.new(model, path)
         self.set_status(201)
         self._finish_model(model)
-
-    def _create_empty_file(self, path, name=None, ext='.ipynb'):
-        """Create an empty file in path
-
-        If name specified, create it in path/name.
-        """
-        self.log.info(u"Creating new file in %s/%s", path, name or '')
-        model = {}
-        if name:
-            model['name'] = name
-        model = self.contents_manager.create_file(model, path=path, ext=ext)
+        
+    def _new_untitled(self, path, type='', ext=''):
+        """Create a new, empty untitled entity"""
+        self.log.info(u"Creating new %s in %s", type or 'file', path)
+        model = self.contents_manager.new_untitled(path=path, type=type, ext=ext)
         self.set_status(201)
         self._finish_model(model)
 
-    def _save(self, model, path, name):
+    def _save(self, model, path):
         """Save an existing file."""
-        self.log.info(u"Saving file at %s/%s", path, name)
-        model = self.contents_manager.save(model, name, path)
-        if model['path'] != path.strip('/') or model['name'] != name:
-            # a rename happened, set Location header
-            location = True
-        else:
-            location = False
-        self._finish_model(model, location)
+        self.log.info(u"Saving file at %s", path)
+        model = self.contents_manager.save(model, path)
+        self._finish_model(model)
 
     @web.authenticated
     @json_errors
-    def post(self, path='', name=None):
-        """Create a new file or directory in the specified path.
+    def post(self, path=''):
+        """Create a new file in the specified path.
 
-        POST creates new files or directories. The server always decides on the name.
+        POST creates new files. The server always decides on the name.
 
         POST /api/contents/path
-          New untitled notebook in path. If content specified, upload a
-          notebook, otherwise start empty.
+          New untitled, empty file or directory.
         POST /api/contents/path
-          with body {"copy_from" : "OtherNotebook.ipynb"}
+          with body {"copy_from" : "/path/to/OtherNotebook.ipynb"}
           New copy of OtherNotebook in path
         """
 
-        if name is not None:
-            path = u'{}/{}'.format(path, name)
-
         cm = self.contents_manager
 
         if cm.file_exists(path):
-            raise web.HTTPError(400, "Cannot POST to existing files, use PUT instead.")
+            raise web.HTTPError(400, "Cannot POST to files, use PUT instead.")
 
-        if not cm.path_exists(path):
+        if not cm.dir_exists(path):
             raise web.HTTPError(404, "No such directory: %s" % path)
 
         model = self.get_json_body()
 
         if model is not None:
             copy_from = model.get('copy_from')
-            ext = model.get('ext', '.ipynb')
-            if model.get('content') is not None:
-                if copy_from:
-                    raise web.HTTPError(400, "Can't upload and copy at the same time.")
-                self._upload(model, path)
-            elif copy_from:
+            ext = model.get('ext', '')
+            type = model.get('type', '')
+            if copy_from:
                 self._copy(copy_from, path)
             else:
-                self._create_empty_file(path, ext=ext)
+                self._new_untitled(path, type=type, ext=ext)
         else:
-            self._create_empty_file(path)
+            self._new_untitled(path)
 
     @web.authenticated
     @json_errors
-    def put(self, path='', name=None):
+    def put(self, path=''):
         """Saves the file in the location specified by name and path.
 
         PUT is very similar to POST, but the requester specifies the name,
@@ -184,39 +161,25 b' class ContentsHandler(IPythonHandler):'
           Save notebook at ``path/Name.ipynb``. Notebook structure is specified
           in `content` key of JSON request body. If content is not specified,
           create a new empty notebook.
-        PUT /api/contents/path/Name.ipynb
-          with JSON body::
-
-            {
-              "copy_from" : "[path/to/]OtherNotebook.ipynb"
-            }
-
-          Copy OtherNotebook to Name
         """
-        if name is None:
-            raise web.HTTPError(400, "name must be specified with PUT.")
-
         model = self.get_json_body()
         if model:
-            copy_from = model.get('copy_from')
-            if copy_from:
-                if model.get('content'):
-                    raise web.HTTPError(400, "Can't upload and copy at the same time.")
-                self._copy(copy_from, path, name)
-            elif self.contents_manager.file_exists(name, path):
-                self._save(model, path, name)
+            if model.get('copy_from'):
+                raise web.HTTPError(400, "Cannot copy with PUT, only POST")
+            if self.contents_manager.file_exists(path):
+                self._save(model, path)
             else:
-                self._upload(model, path, name)
+                self._upload(model, path)
         else:
-            self._create_empty_file(path, name)
+            self._new_untitled(path)
 
     @web.authenticated
     @json_errors
-    def delete(self, path='', name=None):
+    def delete(self, path=''):
         """delete a file in the given path"""
         cm = self.contents_manager
-        self.log.warn('delete %s:%s', path, name)
-        cm.delete(name, path)
+        self.log.warn('delete %s', path)
+        cm.delete(path)
         self.set_status(204)
         self.finish()
 
@@ -227,22 +190,22 b' class CheckpointsHandler(IPythonHandler):'
 
     @web.authenticated
     @json_errors
-    def get(self, path='', name=None):
+    def get(self, path=''):
         """get lists checkpoints for a file"""
         cm = self.contents_manager
-        checkpoints = cm.list_checkpoints(name, path)
+        checkpoints = cm.list_checkpoints(path)
         data = json.dumps(checkpoints, default=date_default)
         self.finish(data)
 
     @web.authenticated
     @json_errors
-    def post(self, path='', name=None):
+    def post(self, path=''):
         """post creates a new checkpoint"""
         cm = self.contents_manager
-        checkpoint = cm.create_checkpoint(name, path)
+        checkpoint = cm.create_checkpoint(path)
         data = json.dumps(checkpoint, default=date_default)
         location = url_path_join(self.base_url, 'api/contents',
-            path, name, 'checkpoints', checkpoint['id'])
+            path, 'checkpoints', checkpoint['id'])
         self.set_header('Location', url_escape(location))
         self.set_status(201)
         self.finish(data)
@@ -254,22 +217,38 b' class ModifyCheckpointsHandler(IPythonHandler):'
 
     @web.authenticated
     @json_errors
-    def post(self, path, name, checkpoint_id):
+    def post(self, path, checkpoint_id):
         """post restores a file from a checkpoint"""
         cm = self.contents_manager
-        cm.restore_checkpoint(checkpoint_id, name, path)
+        cm.restore_checkpoint(checkpoint_id, path)
         self.set_status(204)
         self.finish()
 
     @web.authenticated
     @json_errors
-    def delete(self, path, name, checkpoint_id):
+    def delete(self, path, checkpoint_id):
         """delete clears a checkpoint for a given file"""
         cm = self.contents_manager
-        cm.delete_checkpoint(checkpoint_id, name, path)
+        cm.delete_checkpoint(checkpoint_id, path)
         self.set_status(204)
         self.finish()
 
+
+class NotebooksRedirectHandler(IPythonHandler):
+    """Redirect /api/notebooks to /api/contents"""
+    SUPPORTED_METHODS = ('GET', 'PUT', 'PATCH', 'POST', 'DELETE')
+
+    def get(self, path):
+        self.log.warn("/api/notebooks is deprecated, use /api/contents")
+        self.redirect(url_path_join(
+            self.base_url,
+            'api/contents',
+            path
+        ))
+
+    put = patch = post = delete = get
+
+
 #-----------------------------------------------------------------------------
 # URL to handler mappings
 #-----------------------------------------------------------------------------
@@ -278,9 +257,9 b' class ModifyCheckpointsHandler(IPythonHandler):'
 _checkpoint_id_regex = r"(?P<checkpoint_id>[\w-]+)"
 
 default_handlers = [
-    (r"/api/contents%s/checkpoints" % file_path_regex, CheckpointsHandler),
-    (r"/api/contents%s/checkpoints/%s" % (file_path_regex, _checkpoint_id_regex),
+    (r"/api/contents%s/checkpoints" % path_regex, CheckpointsHandler),
+    (r"/api/contents%s/checkpoints/%s" % (path_regex, _checkpoint_id_regex),
         ModifyCheckpointsHandler),
-    (r"/api/contents%s" % file_path_regex, ContentsHandler),
     (r"/api/contents%s" % path_regex, ContentsHandler),
+    (r"/api/notebooks/?(.*)", NotebooksRedirectHandler),
 ]

IPython/html/services/contents/manager.py

@@ -5,14 +5,18 b''
 
 from fnmatch import fnmatch
 import itertools
+import json
 import os
+import re
 
 from tornado.web import HTTPError
 
 from IPython.config.configurable import LoggingConfigurable
-from IPython.nbformat import current, sign
+from IPython.nbformat import sign, validate, ValidationError
+from IPython.nbformat.v4 import new_notebook
 from IPython.utils.traitlets import Instance, Unicode, List
 
+copy_pat = re.compile(r'\-Copy\d*\.')
 
 class ContentsManager(LoggingConfigurable):
     """Base class for serving files and directories.
@@ -31,14 +35,6 b' class ContentsManager(LoggingConfigurable):'
     - if unspecified, path defaults to '',
       indicating the root path.
 
-    name is also unicode, and refers to a specfic target:
-
-    - unicode, not url-escaped
-    - must not contain '/'
-    - It refers to an individual filename
-    - It may refer to a directory name,
-      in the case of listing or creating directories.
-
     """
 
     notary = Instance(sign.NotebookNotary)
@@ -67,7 +63,7 b' class ContentsManager(LoggingConfigurable):'
     # ContentsManager API part 1: methods that must be
     # implemented in subclasses.
 
-    def path_exists(self, path):
+    def dir_exists(self, path):
         """Does the API-style path (directory) actually exist?
 
         Like os.path.isdir
@@ -103,8 +99,8 b' class ContentsManager(LoggingConfigurable):'
         """
         raise NotImplementedError
 
-    def file_exists(self, name, path=''):
-        """Does a file exist at the given name and path?
+    def file_exists(self, path=''):
+        """Does a file exist at the given path?
 
         Like os.path.isfile
 
@@ -124,15 +120,13 b' class ContentsManager(LoggingConfigurable):'
         """
         raise NotImplementedError('must be implemented in a subclass')
 
-    def exists(self, name, path=''):
-        """Does a file or directory exist at the given name and path?
+    def exists(self, path):
+        """Does a file or directory exist at the given path?
 
         Like os.path.exists
 
         Parameters
         ----------
-        name : string
-            The name of the file you are checking.
         path : string
             The relative path to the file's directory (with '/' as separator)
 
@@ -141,17 +135,17 b' class ContentsManager(LoggingConfigurable):'
         exists : bool
             Whether the target exists.
         """
-        return self.file_exists(name, path) or self.path_exists("%s/%s" % (path, name))
+        return self.file_exists(path) or self.dir_exists(path)
 
-    def get_model(self, name, path='', content=True):
+    def get(self, path, content=True, type_=None, format=None):
         """Get the model of a file or directory with or without content."""
         raise NotImplementedError('must be implemented in a subclass')
 
-    def save(self, model, name, path=''):
+    def save(self, model, path):
         """Save the file or directory and return the model with no content."""
         raise NotImplementedError('must be implemented in a subclass')
 
-    def update(self, model, name, path=''):
+    def update(self, model, path):
         """Update the file or directory and return the model with no content.
 
         For use in PATCH requests, to enable renaming a file without
@@ -159,26 +153,26 b' class ContentsManager(LoggingConfigurable):'
         """
         raise NotImplementedError('must be implemented in a subclass')
 
-    def delete(self, name, path=''):
-        """Delete file or directory by name and path."""
+    def delete(self, path):
+        """Delete file or directory by path."""
         raise NotImplementedError('must be implemented in a subclass')
 
-    def create_checkpoint(self, name, path=''):
+    def create_checkpoint(self, path):
         """Create a checkpoint of the current state of a file
 
         Returns a checkpoint_id for the new checkpoint.
         """
         raise NotImplementedError("must be implemented in a subclass")
 
-    def list_checkpoints(self, name, path=''):
+    def list_checkpoints(self, path):
         """Return a list of checkpoints for a given file"""
         return []
 
-    def restore_checkpoint(self, checkpoint_id, name, path=''):
+    def restore_checkpoint(self, checkpoint_id, path):
         """Restore a file from one of its checkpoints"""
         raise NotImplementedError("must be implemented in a subclass")
 
-    def delete_checkpoint(self, checkpoint_id, name, path=''):
+    def delete_checkpoint(self, checkpoint_id, path):
         """delete a checkpoint for a file"""
         raise NotImplementedError("must be implemented in a subclass")
 
@@ -188,11 +182,19 b' class ContentsManager(LoggingConfigurable):'
     def info_string(self):
         return "Serving contents"
 
-    def get_kernel_path(self, name, path='', model=None):
-        """ Return the path to start kernel in """
-        return path
+    def get_kernel_path(self, path, model=None):
+        """Return the API path for the kernel
+        
+        KernelManagers can turn this value into a filesystem path,
+        or ignore it altogether.
 
-    def increment_filename(self, filename, path=''):
+        The default value here will start kernels in the directory of the
+        notebook server. FileContentsManager overrides this to use the
+        directory containing the notebook.
+        """
+        return ''
+
+    def increment_filename(self, filename, path='', insert=''):
         """Increment a filename until it is unique.
 
         Parameters
@@ -210,87 +212,140 b' class ContentsManager(LoggingConfigurable):'
         path = path.strip('/')
         basename, ext = os.path.splitext(filename)
         for i in itertools.count():
-            name = u'{basename}{i}{ext}'.format(basename=basename, i=i,
-                                                ext=ext)
-            if not self.file_exists(name, path):
+            if i:
+                insert_i = '{}{}'.format(insert, i)
+            else:
+                insert_i = ''
+            name = u'{basename}{insert}{ext}'.format(basename=basename,
+                insert=insert_i, ext=ext)
+            if not self.exists(u'{}/{}'.format(path, name)):
                 break
         return name
 
-    def create_file(self, model=None, path='', ext='.ipynb'):
-        """Create a new file or directory and return its model with no content."""
+    def validate_notebook_model(self, model):
+        """Add failed-validation message to model"""
+        try:
+            validate(model['content'])
+        except ValidationError as e:
+            model['message'] = u'Notebook Validation failed: {}:\n{}'.format(
+                e.message, json.dumps(e.instance, indent=1, default=lambda obj: '<UNKNOWN>'),
+            )
+        return model
+    
+    def new_untitled(self, path='', type='', ext=''):
+        """Create a new untitled file or directory in path
+        
+        path must be a directory
+        
+        File extension can be specified.
+        
+        Use `new` to create files with a fully specified path (including filename).
+        """
+        path = path.strip('/')
+        if not self.dir_exists(path):
+            raise HTTPError(404, 'No such directory: %s' % path)
+        
+        model = {}
+        if type:
+            model['type'] = type
+        
+        if ext == '.ipynb':
+            model.setdefault('type', 'notebook')
+        else:
+            model.setdefault('type', 'file')
+        
+        insert = ''
+        if model['type'] == 'directory':
+            untitled = self.untitled_directory
+            insert = ' '
+        elif model['type'] == 'notebook':
+            untitled = self.untitled_notebook
+            ext = '.ipynb'
+        elif model['type'] == 'file':
+            untitled = self.untitled_file
+        else:
+            raise HTTPError(400, "Unexpected model type: %r" % model['type'])
+        
+        name = self.increment_filename(untitled + ext, path, insert=insert)
+        path = u'{0}/{1}'.format(path, name)
+        return self.new(model, path)
+    
+    def new(self, model=None, path=''):
+        """Create a new file or directory and return its model with no content.
+        
+        To create a new untitled entity in a directory, use `new_untitled`.
+        """
         path = path.strip('/')
         if model is None:
             model = {}
-        if 'content' not in model and model.get('type', None) != 'directory':
-            if ext == '.ipynb':
-                metadata = current.new_metadata(name=u'')
-                model['content'] = current.new_notebook(metadata=metadata)
-                model['type'] = 'notebook'
+        
+        if path.endswith('.ipynb'):
+            model.setdefault('type', 'notebook')
+        else:
+            model.setdefault('type', 'file')
+        
+        # no content, not a directory, so fill out new-file model
+        if 'content' not in model and model['type'] != 'directory':
+            if model['type'] == 'notebook':
+                model['content'] = new_notebook()
                 model['format'] = 'json'
             else:
                 model['content'] = ''
                 model['type'] = 'file'
                 model['format'] = 'text'
-        if 'name' not in model:
-            if model['type'] == 'directory':
-                untitled = self.untitled_directory
-            elif model['type'] == 'notebook':
-                untitled = self.untitled_notebook
-            elif model['type'] == 'file':
-                untitled = self.untitled_file
-            else:
-                raise HTTPError(400, "Unexpected model type: %r" % model['type'])
-            model['name'] = self.increment_filename(untitled + ext, path)
-
-        model['path'] = path
-        model = self.save(model, model['name'], model['path'])
+        
+        model = self.save(model, path)
         return model
 
-    def copy(self, from_name, to_name=None, path=''):
+    def copy(self, from_path, to_path=None):
         """Copy an existing file and return its new model.
 
-        If to_name not specified, increment `from_name-Copy#.ext`.
+        If to_path not specified, it will be the parent directory of from_path.
+        If to_path is a directory, filename will increment `from_path-Copy#.ext`.
 
-        copy_from can be a full path to a file,
-        or just a base name. If a base name, `path` is used.
+        from_path must be a full path to a file.
         """
-        path = path.strip('/')
-        if '/' in from_name:
-            from_path, from_name = from_name.rsplit('/', 1)
+        path = from_path.strip('/')
+        if '/' in path:
+            from_dir, from_name = path.rsplit('/', 1)
         else:
-            from_path = path
-        model = self.get_model(from_name, from_path)
+            from_dir = ''
+            from_name = path
+        
+        model = self.get(path)
+        model.pop('path', None)
+        model.pop('name', None)
         if model['type'] == 'directory':
             raise HTTPError(400, "Can't copy directories")
-        if not to_name:
-            base, ext = os.path.splitext(from_name)
-            copy_name = u'{0}-Copy{1}'.format(base, ext)
-            to_name = self.increment_filename(copy_name, path)
-        model['name'] = to_name
-        model['path'] = path
-        model = self.save(model, to_name, path)
+        
+        if not to_path:
+            to_path = from_dir
+        if self.dir_exists(to_path):
+            name = copy_pat.sub(u'.', from_name)
+            to_name = self.increment_filename(name, to_path, insert='-Copy')
+            to_path = u'{0}/{1}'.format(to_path, to_name)
+        
+        model = self.save(model, to_path)
         return model
 
     def log_info(self):
         self.log.info(self.info_string())
 
-    def trust_notebook(self, name, path=''):
+    def trust_notebook(self, path):
         """Explicitly trust a notebook
 
         Parameters
         ----------
-        name : string
-            The filename of the notebook
         path : string
-            The notebook's directory
+            The path of a notebook
         """
-        model = self.get_model(name, path)
+        model = self.get(path)
         nb = model['content']
-        self.log.warn("Trusting notebook %s/%s", path, name)
+        self.log.warn("Trusting notebook %s", path)
         self.notary.mark_cells(nb, True)
-        self.save(model, name, path)
+        self.save(model, path)
 
-    def check_and_sign(self, nb, name='', path=''):
+    def check_and_sign(self, nb, path=''):
         """Check for trusted cells, and sign the notebook.
 
         Called as a part of saving notebooks.
@@ -298,18 +353,16 b' class ContentsManager(LoggingConfigurable):'
         Parameters
         ----------
         nb : dict
-            The notebook object (in nbformat.current format)
-        name : string
-            The filename of the notebook (for logging)
+            The notebook dict
         path : string
-            The notebook's directory (for logging)
+            The notebook's path (for logging)
         """
         if self.notary.check_cells(nb):
             self.notary.sign(nb)
         else:
-            self.log.warn("Saving untrusted notebook %s/%s", path, name)
+            self.log.warn("Saving untrusted notebook %s", path)
 
-    def mark_trusted_cells(self, nb, name='', path=''):
+    def mark_trusted_cells(self, nb, path=''):
         """Mark cells as trusted if the notebook signature matches.
 
         Called as a part of loading notebooks.
@@ -317,15 +370,13 b' class ContentsManager(LoggingConfigurable):'
         Parameters
         ----------
         nb : dict
-            The notebook object (in nbformat.current format)
-        name : string
-            The filename of the notebook (for logging)
+            The notebook object (in current nbformat)
         path : string
-            The notebook's directory (for logging)
+            The notebook's path (for logging)
         """
         trusted = self.notary.check_signature(nb)
         if not trusted:
-            self.log.warn("Notebook %s/%s is not trusted", path, name)
+            self.log.warn("Notebook %s is not trusted", path)
         self.notary.mark_cells(nb, trusted)
 
     def should_list(self, name):

IPython/html/services/contents/tests/test_contents_api.py

@@ -14,9 +14,10 b' import requests'
 
 from IPython.html.utils import url_path_join, url_escape
 from IPython.html.tests.launchnotebook import NotebookTestBase, assert_http_error
-from IPython.nbformat import current
-from IPython.nbformat.current import (new_notebook, write, read, new_worksheet,
-                                      new_heading_cell, to_notebook_json)
+from IPython.nbformat import read, write, from_dict
+from IPython.nbformat.v4 import (
+    new_notebook, new_markdown_cell,
+)
 from IPython.nbformat import v2
 from IPython.utils import py3compat
 from IPython.utils.data import uniq_stable
@@ -34,10 +35,10 b' class API(object):'
     def __init__(self, base_url):
         self.base_url = base_url
 
-    def _req(self, verb, path, body=None):
+    def _req(self, verb, path, body=None, params=None):
         response = requests.request(verb,
                 url_path_join(self.base_url, 'api/contents', path),
-                data=body,
+                data=body, params=params,
         )
         response.raise_for_status()
         return response
@@ -45,56 +46,64 b' class API(object):'
     def list(self, path='/'):
         return self._req('GET', path)
 
-    def read(self, name, path='/'):
-        return self._req('GET', url_path_join(path, name))
+    def read(self, path, type_=None, format=None):
+        params = {}
+        if type_ is not None:
+            params['type'] = type_
+        if format is not None:
+            params['format'] = format
+        return self._req('GET', path, params=params)
 
-    def create_untitled(self, path='/', ext=None):
+    def create_untitled(self, path='/', ext='.ipynb'):
         body = None
         if ext:
             body = json.dumps({'ext': ext})
         return self._req('POST', path, body)
 
-    def upload_untitled(self, body, path='/'):
-        return self._req('POST', path, body)
+    def mkdir_untitled(self, path='/'):
+        return self._req('POST', path, json.dumps({'type': 'directory'}))
 
-    def copy_untitled(self, copy_from, path='/'):
+    def copy(self, copy_from, path='/'):
         body = json.dumps({'copy_from':copy_from})
         return self._req('POST', path, body)
 
-    def create(self, name, path='/'):
-        return self._req('PUT', url_path_join(path, name))
+    def create(self, path='/'):
+        return self._req('PUT', path)
+
+    def upload(self, path, body):
+        return self._req('PUT', path, body)
 
-    def upload(self, name, body, path='/'):
-        return self._req('PUT', url_path_join(path, name), body)
+    def mkdir_untitled(self, path='/'):
+        return self._req('POST', path, json.dumps({'type': 'directory'}))
 
-    def mkdir(self, name, path='/'):
-        return self._req('PUT', url_path_join(path, name), json.dumps({'type': 'directory'}))
+    def mkdir(self, path='/'):
+        return self._req('PUT', path, json.dumps({'type': 'directory'}))
 
-    def copy(self, copy_from, copy_to, path='/'):
+    def copy_put(self, copy_from, path='/'):
         body = json.dumps({'copy_from':copy_from})
-        return self._req('PUT', url_path_join(path, copy_to), body)
+        return self._req('PUT', path, body)
 
-    def save(self, name, body, path='/'):
-        return self._req('PUT', url_path_join(path, name), body)
+    def save(self, path, body):
+        return self._req('PUT', path, body)
 
-    def delete(self, name, path='/'):
-        return self._req('DELETE', url_path_join(path, name))
+    def delete(self, path='/'):
+        return self._req('DELETE', path)
 
-    def rename(self, name, path, new_name):
-        body = json.dumps({'name': new_name})
-        return self._req('PATCH', url_path_join(path, name), body)
+    def rename(self, path, new_path):
+        body = json.dumps({'path': new_path})
+        return self._req('PATCH', path, body)
 
-    def get_checkpoints(self, name, path):
-        return self._req('GET', url_path_join(path, name, 'checkpoints'))
+    def get_checkpoints(self,  path):
+        return self._req('GET', url_path_join(path, 'checkpoints'))
 
-    def new_checkpoint(self, name, path):
-        return self._req('POST', url_path_join(path, name, 'checkpoints'))
+    def new_checkpoint(self,  path):
+        return self._req('POST', url_path_join(path, 'checkpoints'))
 
-    def restore_checkpoint(self, name, path, checkpoint_id):
-        return self._req('POST', url_path_join(path, name, 'checkpoints', checkpoint_id))
+    def restore_checkpoint(self, path, checkpoint_id):
+        return self._req('POST', url_path_join(path, 'checkpoints', checkpoint_id))
 
-    def delete_checkpoint(self, name, path, checkpoint_id):
-        return self._req('DELETE', url_path_join(path, name, 'checkpoints', checkpoint_id))
+    def delete_checkpoint(self, path, checkpoint_id):
+        return self._req('DELETE', url_path_join(path, 'checkpoints', checkpoint_id))
 
 class APITest(NotebookTestBase):
     """Test the kernels web service API"""
@@ -130,8 +139,6 b' class APITest(NotebookTestBase):'
         self.blob = os.urandom(100)
         self.b64_blob = base64.encodestring(self.blob).decode('ascii')
 
-
-
         for d in (self.dirs + self.hidden_dirs):
             d.replace('/', os.sep)
             if not os.path.isdir(pjoin(nbdir, d)):
@@ -142,8 +149,8 b' class APITest(NotebookTestBase):'
             # create a notebook
             with io.open(pjoin(nbdir, d, '%s.ipynb' % name), 'w',
                          encoding='utf-8') as f:
-                nb = new_notebook(name=name)
-                write(nb, f, format='ipynb')
+                nb = new_notebook()
+                write(nb, f, version=4)
 
             # create a text file
             with io.open(pjoin(nbdir, d, '%s.txt' % name), 'w',
@@ -177,12 +184,12 b' class APITest(NotebookTestBase):'
         nbs = notebooks_only(self.api.list(u'/unicodé/').json())
         self.assertEqual(len(nbs), 1)
         self.assertEqual(nbs[0]['name'], 'innonascii.ipynb')
-        self.assertEqual(nbs[0]['path'], u'unicodé')
+        self.assertEqual(nbs[0]['path'], u'unicodé/innonascii.ipynb')
 
         nbs = notebooks_only(self.api.list('/foo/bar/').json())
         self.assertEqual(len(nbs), 1)
         self.assertEqual(nbs[0]['name'], 'baz.ipynb')
-        self.assertEqual(nbs[0]['path'], 'foo/bar')
+        self.assertEqual(nbs[0]['path'], 'foo/bar/baz.ipynb')
 
         nbs = notebooks_only(self.api.list('foo').json())
         self.assertEqual(len(nbs), 4)
@@ -197,8 +204,11 b' class APITest(NotebookTestBase):'
         self.assertEqual(nbnames, expected)
 
     def test_list_dirs(self):
+        print(self.api.list().json())
         dirs = dirs_only(self.api.list().json())
         dir_names = {normalize('NFC', d['name']) for d in dirs}
+        print(dir_names)
+        print(self.top_level_dirs)
         self.assertEqual(dir_names, self.top_level_dirs)  # Excluding hidden dirs
 
     def test_list_nonexistant_dir(self):
@@ -207,8 +217,10 b' class APITest(NotebookTestBase):'
 
     def test_get_nb_contents(self):
         for d, name in self.dirs_nbs:
-            nb = self.api.read('%s.ipynb' % name, d+'/').json()
+            path = url_path_join(d, name + '.ipynb')
+            nb = self.api.read(path).json()
             self.assertEqual(nb['name'], u'%s.ipynb' % name)
+            self.assertEqual(nb['path'], path)
             self.assertEqual(nb['type'], 'notebook')
             self.assertIn('content', nb)
             self.assertEqual(nb['format'], 'json')
@@ -219,12 +231,14 b' class APITest(NotebookTestBase):'
     def test_get_contents_no_such_file(self):
         # Name that doesn't exist - should be a 404
         with assert_http_error(404):
-            self.api.read('q.ipynb', 'foo')
+            self.api.read('foo/q.ipynb')
 
     def test_get_text_file_contents(self):
         for d, name in self.dirs_nbs:
-            model = self.api.read(u'%s.txt' % name, d+'/').json()
+            path = url_path_join(d, name + '.txt')
+            model = self.api.read(path).json()
             self.assertEqual(model['name'], u'%s.txt' % name)
+            self.assertEqual(model['path'], path)
             self.assertIn('content', model)
             self.assertEqual(model['format'], 'text')
             self.assertEqual(model['type'], 'file')
@@ -232,12 +246,18 b' class APITest(NotebookTestBase):'
 
         # Name that doesn't exist - should be a 404
         with assert_http_error(404):
-            self.api.read('q.txt', 'foo')
+            self.api.read('foo/q.txt')
+
+        # Specifying format=text should fail on a non-UTF-8 file
+        with assert_http_error(400):
+            self.api.read('foo/bar/baz.blob', type_='file', format='text')
 
     def test_get_binary_file_contents(self):
         for d, name in self.dirs_nbs:
-            model = self.api.read(u'%s.blob' % name, d+'/').json()
+            path = url_path_join(d, name + '.blob')
+            model = self.api.read(path).json()
             self.assertEqual(model['name'], u'%s.blob' % name)
+            self.assertEqual(model['path'], path)
             self.assertIn('content', model)
             self.assertEqual(model['format'], 'base64')
             self.assertEqual(model['type'], 'file')
@@ -246,66 +266,78 b' class APITest(NotebookTestBase):'
 
         # Name that doesn't exist - should be a 404
         with assert_http_error(404):
-            self.api.read('q.txt', 'foo')
+            self.api.read('foo/q.txt')
 
-    def _check_created(self, resp, name, path, type='notebook'):
+    def test_get_bad_type(self):
+        with assert_http_error(400):
+            self.api.read(u'unicodé', type_='file')  # this is a directory
+
+        with assert_http_error(400):
+            self.api.read(u'unicodé/innonascii.ipynb', type_='directory')
+
+    def _check_created(self, resp, path, type='notebook'):
         self.assertEqual(resp.status_code, 201)
         location_header = py3compat.str_to_unicode(resp.headers['Location'])
-        self.assertEqual(location_header, url_escape(url_path_join(u'/api/contents', path, name)))
+        self.assertEqual(location_header, url_escape(url_path_join(u'/api/contents', path)))
         rjson = resp.json()
-        self.assertEqual(rjson['name'], name)
+        self.assertEqual(rjson['name'], path.rsplit('/', 1)[-1])
         self.assertEqual(rjson['path'], path)
         self.assertEqual(rjson['type'], type)
         isright = os.path.isdir if type == 'directory' else os.path.isfile
         assert isright(pjoin(
             self.notebook_dir.name,
             path.replace('/', os.sep),
-            name,
         ))
 
     def test_create_untitled(self):
         resp = self.api.create_untitled(path=u'å b')
-        self._check_created(resp, 'Untitled0.ipynb', u'å b')
+        self._check_created(resp, u'å b/Untitled.ipynb')
 
         # Second time
         resp = self.api.create_untitled(path=u'å b')
-        self._check_created(resp, 'Untitled1.ipynb', u'å b')
+        self._check_created(resp, u'å b/Untitled1.ipynb')
 
         # And two directories down
         resp = self.api.create_untitled(path='foo/bar')
-        self._check_created(resp, 'Untitled0.ipynb', 'foo/bar')
+        self._check_created(resp, 'foo/bar/Untitled.ipynb')
 
     def test_create_untitled_txt(self):
         resp = self.api.create_untitled(path='foo/bar', ext='.txt')
-        self._check_created(resp, 'untitled0.txt', 'foo/bar', type='file')
+        self._check_created(resp, 'foo/bar/untitled.txt', type='file')
 
-        resp = self.api.read(path='foo/bar', name='untitled0.txt')
+        resp = self.api.read(path='foo/bar/untitled.txt')
         model = resp.json()
         self.assertEqual(model['type'], 'file')
         self.assertEqual(model['format'], 'text')
         self.assertEqual(model['content'], '')
 
-    def test_upload_untitled(self):
-        nb = new_notebook(name='Upload test')
-        nbmodel = {'content': nb, 'type': 'notebook'}
-        resp = self.api.upload_untitled(path=u'å b',
-                                              body=json.dumps(nbmodel))
-        self._check_created(resp, 'Untitled0.ipynb', u'å b')
-
     def test_upload(self):
-        nb = new_notebook(name=u'ignored')
+        nb = new_notebook()
         nbmodel = {'content': nb, 'type': 'notebook'}
-        resp = self.api.upload(u'Upload tést.ipynb', path=u'å b',
-                                              body=json.dumps(nbmodel))
-        self._check_created(resp, u'Upload tést.ipynb', u'å b')
+        path = u'å b/Upload tést.ipynb'
+        resp = self.api.upload(path, body=json.dumps(nbmodel))
+        self._check_created(resp, path)
+
+    def test_mkdir_untitled(self):
+        resp = self.api.mkdir_untitled(path=u'å b')
+        self._check_created(resp, u'å b/Untitled Folder', type='directory')
+
+        # Second time
+        resp = self.api.mkdir_untitled(path=u'å b')
+        self._check_created(resp, u'å b/Untitled Folder 1', type='directory')
+
+        # And two directories down
+        resp = self.api.mkdir_untitled(path='foo/bar')
+        self._check_created(resp, 'foo/bar/Untitled Folder', type='directory')
 
     def test_mkdir(self):
-        resp = self.api.mkdir(u'New ∂ir', path=u'å b')
-        self._check_created(resp, u'New ∂ir', u'å b', type='directory')
+        path = u'å b/New ∂ir'
+        resp = self.api.mkdir(path)
+        self._check_created(resp, path, type='directory')
 
     def test_mkdir_hidden_400(self):
         with assert_http_error(400):
-            resp = self.api.mkdir(u'.hidden', path=u'å b')
+            resp = self.api.mkdir(u'å b/.hidden')
 
     def test_upload_txt(self):
         body = u'ünicode téxt'
@@ -314,11 +346,11 b' class APITest(NotebookTestBase):'
             'format'  : 'text',
             'type'    : 'file',
         }
-        resp = self.api.upload(u'Upload tést.txt', path=u'å b',
-                                              body=json.dumps(model))
+        path = u'å b/Upload tést.txt'
+        resp = self.api.upload(path, body=json.dumps(model))
 
         # check roundtrip
-        resp = self.api.read(path=u'å b', name=u'Upload tést.txt')
+        resp = self.api.read(path)
         model = resp.json()
         self.assertEqual(model['type'], 'file')
         self.assertEqual(model['format'], 'text')
@@ -332,13 +364,14 b' class APITest(NotebookTestBase):'
             'format'  : 'base64',
             'type'    : 'file',
         }
-        resp = self.api.upload(u'Upload tést.blob', path=u'å b',
-                                              body=json.dumps(model))
+        path = u'å b/Upload tést.blob'
+        resp = self.api.upload(path, body=json.dumps(model))
 
         # check roundtrip
-        resp = self.api.read(path=u'å b', name=u'Upload tést.blob')
+        resp = self.api.read(path)
         model = resp.json()
         self.assertEqual(model['type'], 'file')
+        self.assertEqual(model['path'], path)
         self.assertEqual(model['format'], 'base64')
         decoded = base64.decodestring(model['content'].encode('ascii'))
         self.assertEqual(decoded, body)
@@ -349,46 +382,62 b' class APITest(NotebookTestBase):'
         nb.worksheets.append(ws)
         ws.cells.append(v2.new_code_cell(input='print("hi")'))
         nbmodel = {'content': nb, 'type': 'notebook'}
-        resp = self.api.upload(u'Upload tést.ipynb', path=u'å b',
-                                              body=json.dumps(nbmodel))
-        self._check_created(resp, u'Upload tést.ipynb', u'å b')
-        resp = self.api.read(u'Upload tést.ipynb', u'å b')
+        path = u'å b/Upload tést.ipynb'
+        resp = self.api.upload(path, body=json.dumps(nbmodel))
+        self._check_created(resp, path)
+        resp = self.api.read(path)
         data = resp.json()
-        self.assertEqual(data['content']['nbformat'], current.nbformat)
-        self.assertEqual(data['content']['orig_nbformat'], 2)
-
-    def test_copy_untitled(self):
-        resp = self.api.copy_untitled(u'ç d.ipynb', path=u'å b')
-        self._check_created(resp, u'ç d-Copy0.ipynb', u'å b')
+        self.assertEqual(data['content']['nbformat'], 4)
 
     def test_copy(self):
-        resp = self.api.copy(u'ç d.ipynb', u'cøpy.ipynb', path=u'å b')
-        self._check_created(resp, u'cøpy.ipynb', u'å b')
-
+        resp = self.api.copy(u'å b/ç d.ipynb', u'å b')
+        self._check_created(resp, u'å b/ç d-Copy1.ipynb')
+        
+        resp = self.api.copy(u'å b/ç d.ipynb', u'å b')
+        self._check_created(resp, u'å b/ç d-Copy2.ipynb')
+    
+    def test_copy_copy(self):
+        resp = self.api.copy(u'å b/ç d.ipynb', u'å b')
+        self._check_created(resp, u'å b/ç d-Copy1.ipynb')
+        
+        resp = self.api.copy(u'å b/ç d-Copy1.ipynb', u'å b')
+        self._check_created(resp, u'å b/ç d-Copy2.ipynb')
+    
     def test_copy_path(self):
-        resp = self.api.copy(u'foo/a.ipynb', u'cøpyfoo.ipynb', path=u'å b')
-        self._check_created(resp, u'cøpyfoo.ipynb', u'å b')
+        resp = self.api.copy(u'foo/a.ipynb', u'å b')
+        self._check_created(resp, u'å b/a.ipynb')
+        
+        resp = self.api.copy(u'foo/a.ipynb', u'å b')
+        self._check_created(resp, u'å b/a-Copy1.ipynb')
+
+    def test_copy_put_400(self):
+        with assert_http_error(400):
+            resp = self.api.copy_put(u'å b/ç d.ipynb', u'å b/cøpy.ipynb')
 
     def test_copy_dir_400(self):
         # can't copy directories
         with assert_http_error(400):
-            resp = self.api.copy(u'å b', u'å c')
+            resp = self.api.copy(u'å b', u'foo')
 
     def test_delete(self):
         for d, name in self.dirs_nbs:
-            resp = self.api.delete('%s.ipynb' % name, d)
+            print('%r, %r' % (d, name))
+            resp = self.api.delete(url_path_join(d, name + '.ipynb'))
             self.assertEqual(resp.status_code, 204)
 
         for d in self.dirs + ['/']:
             nbs = notebooks_only(self.api.list(d).json())
-            self.assertEqual(len(nbs), 0)
+            print('------')
+            print(d)
+            print(nbs)
+            self.assertEqual(nbs, [])
 
     def test_delete_dirs(self):
         # depth-first delete everything, so we don't try to delete empty directories
         for name in sorted(self.dirs + ['/'], key=len, reverse=True):
             listing = self.api.list(name).json()['content']
             for model in listing:
-                self.api.delete(model['name'], model['path'])
+                self.api.delete(model['path'])
         listing = self.api.list('/').json()['content']
         self.assertEqual(listing, [])
 
@@ -398,9 +447,10 b' class APITest(NotebookTestBase):'
             self.api.delete(u'å b')
 
     def test_rename(self):
-        resp = self.api.rename('a.ipynb', 'foo', 'z.ipynb')
+        resp = self.api.rename('foo/a.ipynb', 'foo/z.ipynb')
         self.assertEqual(resp.headers['Location'].split('/')[-1], 'z.ipynb')
         self.assertEqual(resp.json()['name'], 'z.ipynb')
+        self.assertEqual(resp.json()['path'], 'foo/z.ipynb')
         assert os.path.isfile(pjoin(self.notebook_dir.name, 'foo', 'z.ipynb'))
 
         nbs = notebooks_only(self.api.list('foo').json())
@@ -410,43 +460,31 b' class APITest(NotebookTestBase):'
 
     def test_rename_existing(self):
         with assert_http_error(409):
-            self.api.rename('a.ipynb', 'foo', 'b.ipynb')
+            self.api.rename('foo/a.ipynb', 'foo/b.ipynb')
 
     def test_save(self):
-        resp = self.api.read('a.ipynb', 'foo')
+        resp = self.api.read('foo/a.ipynb')
         nbcontent = json.loads(resp.text)['content']
-        nb = to_notebook_json(nbcontent)
-        ws = new_worksheet()
-        nb.worksheets = [ws]
-        ws.cells.append(new_heading_cell(u'Created by test ³'))
+        nb = from_dict(nbcontent)
+        nb.cells.append(new_markdown_cell(u'Created by test ³'))
 
-        nbmodel= {'name': 'a.ipynb', 'path':'foo', 'content': nb, 'type': 'notebook'}
-        resp = self.api.save('a.ipynb', path='foo', body=json.dumps(nbmodel))
+        nbmodel= {'content': nb, 'type': 'notebook'}
+        resp = self.api.save('foo/a.ipynb', body=json.dumps(nbmodel))
 
         nbfile = pjoin(self.notebook_dir.name, 'foo', 'a.ipynb')
         with io.open(nbfile, 'r', encoding='utf-8') as f:
-            newnb = read(f, format='ipynb')
-        self.assertEqual(newnb.worksheets[0].cells[0].source,
+            newnb = read(f, as_version=4)
+        self.assertEqual(newnb.cells[0].source,
                          u'Created by test ³')
-        nbcontent = self.api.read('a.ipynb', 'foo').json()['content']
-        newnb = to_notebook_json(nbcontent)
-        self.assertEqual(newnb.worksheets[0].cells[0].source,
+        nbcontent = self.api.read('foo/a.ipynb').json()['content']
+        newnb = from_dict(nbcontent)
+        self.assertEqual(newnb.cells[0].source,
                          u'Created by test ³')
 
-        # Save and rename
-        nbmodel= {'name': 'a2.ipynb', 'path':'foo/bar', 'content': nb, 'type': 'notebook'}
-        resp = self.api.save('a.ipynb', path='foo', body=json.dumps(nbmodel))
-        saved = resp.json()
-        self.assertEqual(saved['name'], 'a2.ipynb')
-        self.assertEqual(saved['path'], 'foo/bar')
-        assert os.path.isfile(pjoin(self.notebook_dir.name,'foo','bar','a2.ipynb'))
-        assert not os.path.isfile(pjoin(self.notebook_dir.name, 'foo', 'a.ipynb'))
-        with assert_http_error(404):
-            self.api.read('a.ipynb', 'foo')
 
     def test_checkpoints(self):
-        resp = self.api.read('a.ipynb', 'foo')
-        r = self.api.new_checkpoint('a.ipynb', 'foo')
+        resp = self.api.read('foo/a.ipynb')
+        r = self.api.new_checkpoint('foo/a.ipynb')
         self.assertEqual(r.status_code, 201)
         cp1 = r.json()
         self.assertEqual(set(cp1), {'id', 'last_modified'})
@@ -454,32 +492,30 b' class APITest(NotebookTestBase):'
 
         # Modify it
         nbcontent = json.loads(resp.text)['content']
-        nb = to_notebook_json(nbcontent)
-        ws = new_worksheet()
-        nb.worksheets = [ws]
-        hcell = new_heading_cell('Created by test')
-        ws.cells.append(hcell)
+        nb = from_dict(nbcontent)
+        hcell = new_markdown_cell('Created by test')
+        nb.cells.append(hcell)
         # Save
-        nbmodel= {'name': 'a.ipynb', 'path':'foo', 'content': nb, 'type': 'notebook'}
-        resp = self.api.save('a.ipynb', path='foo', body=json.dumps(nbmodel))
+        nbmodel= {'content': nb, 'type': 'notebook'}
+        resp = self.api.save('foo/a.ipynb', body=json.dumps(nbmodel))
 
         # List checkpoints
-        cps = self.api.get_checkpoints('a.ipynb', 'foo').json()
+        cps = self.api.get_checkpoints('foo/a.ipynb').json()
         self.assertEqual(cps, [cp1])
 
-        nbcontent = self.api.read('a.ipynb', 'foo').json()['content']
-        nb = to_notebook_json(nbcontent)
-        self.assertEqual(nb.worksheets[0].cells[0].source, 'Created by test')
+        nbcontent = self.api.read('foo/a.ipynb').json()['content']
+        nb = from_dict(nbcontent)
+        self.assertEqual(nb.cells[0].source, 'Created by test')
 
         # Restore cp1
-        r = self.api.restore_checkpoint('a.ipynb', 'foo', cp1['id'])
+        r = self.api.restore_checkpoint('foo/a.ipynb', cp1['id'])
         self.assertEqual(r.status_code, 204)
-        nbcontent = self.api.read('a.ipynb', 'foo').json()['content']
-        nb = to_notebook_json(nbcontent)
-        self.assertEqual(nb.worksheets, [])
+        nbcontent = self.api.read('foo/a.ipynb').json()['content']
+        nb = from_dict(nbcontent)
+        self.assertEqual(nb.cells, [])
 
         # Delete cp1
-        r = self.api.delete_checkpoint('a.ipynb', 'foo', cp1['id'])
+        r = self.api.delete_checkpoint('foo/a.ipynb', cp1['id'])
         self.assertEqual(r.status_code, 204)
-        cps = self.api.get_checkpoints('a.ipynb', 'foo').json()
+        cps = self.api.get_checkpoints('foo/a.ipynb').json()
         self.assertEqual(cps, [])

IPython/html/services/contents/tests/test_manager.py

@@ -9,7 +9,7 b' from tornado.web import HTTPError'
 from unittest import TestCase
 from tempfile import NamedTemporaryFile
 
-from IPython.nbformat import current
+from IPython.nbformat import v4 as nbformat
 
 from IPython.utils.tempdir import TemporaryDirectory
 from IPython.utils.traitlets import TraitError
@@ -42,7 +42,7 b' class TestFileContentsManager(TestCase):'
         with TemporaryDirectory() as td:
             root = td
             fm = FileContentsManager(root_dir=root)
-            path = fm._get_os_path('test.ipynb', '/path/to/notebook/')
+            path = fm._get_os_path('/path/to/notebook/test.ipynb')
             rel_path_list =  '/path/to/notebook/test.ipynb'.split('/')
             fs_path = os.path.join(fm.root_dir, *rel_path_list)
             self.assertEqual(path, fs_path)
@@ -53,7 +53,7 b' class TestFileContentsManager(TestCase):'
             self.assertEqual(path, fs_path)
 
             fm = FileContentsManager(root_dir=root)
-            path = fm._get_os_path('test.ipynb', '////')
+            path = fm._get_os_path('////test.ipynb')
             fs_path = os.path.join(fm.root_dir, 'test.ipynb')
             self.assertEqual(path, fs_path)
 
@@ -64,8 +64,8 b' class TestFileContentsManager(TestCase):'
             root = td
             os.mkdir(os.path.join(td, subd))
             fm = FileContentsManager(root_dir=root)
-            cp_dir = fm.get_checkpoint_path('cp', 'test.ipynb', '/')
-            cp_subdir = fm.get_checkpoint_path('cp', 'test.ipynb', '/%s/' % subd)
+            cp_dir = fm.get_checkpoint_path('cp', 'test.ipynb')
+            cp_subdir = fm.get_checkpoint_path('cp', '/%s/test.ipynb' % subd)
         self.assertNotEqual(cp_dir, cp_subdir)
         self.assertEqual(cp_dir, os.path.join(root, fm.checkpoint_dir, cp_name))
         self.assertEqual(cp_subdir, os.path.join(root, subd, fm.checkpoint_dir, cp_name))
@@ -95,71 +95,98 b' class TestContentsManager(TestCase):'
         return os_path
 
     def add_code_cell(self, nb):
-        output = current.new_output("display_data", output_javascript="alert('hi');")
-        cell = current.new_code_cell("print('hi')", outputs=[output])
-        if not nb.worksheets:
-            nb.worksheets.append(current.new_worksheet())
-        nb.worksheets[0].cells.append(cell)
+        output = nbformat.new_output("display_data", {'application/javascript': "alert('hi');"})
+        cell = nbformat.new_code_cell("print('hi')", outputs=[output])
+        nb.cells.append(cell)
 
     def new_notebook(self):
         cm = self.contents_manager
-        model = cm.create_file()
+        model = cm.new_untitled(type='notebook')
         name = model['name']
         path = model['path']
 
-        full_model = cm.get_model(name, path)
+        full_model = cm.get(path)
         nb = full_model['content']
         self.add_code_cell(nb)
 
-        cm.save(full_model, name, path)
+        cm.save(full_model, path)
         return nb, name, path
 
-    def test_create_file(self):
+    def test_new_untitled(self):
         cm = self.contents_manager
         # Test in root directory
-        model = cm.create_file()
+        model = cm.new_untitled(type='notebook')
         assert isinstance(model, dict)
         self.assertIn('name', model)
         self.assertIn('path', model)
-        self.assertEqual(model['name'], 'Untitled0.ipynb')
-        self.assertEqual(model['path'], '')
+        self.assertIn('type', model)
+        self.assertEqual(model['type'], 'notebook')
+        self.assertEqual(model['name'], 'Untitled.ipynb')
+        self.assertEqual(model['path'], 'Untitled.ipynb')
 
         # Test in sub-directory
-        sub_dir = '/foo/'
-        self.make_dir(cm.root_dir, 'foo')
-        model = cm.create_file(None, sub_dir)
+        model = cm.new_untitled(type='directory')
         assert isinstance(model, dict)
         self.assertIn('name', model)
         self.assertIn('path', model)
-        self.assertEqual(model['name'], 'Untitled0.ipynb')
-        self.assertEqual(model['path'], sub_dir.strip('/'))
+        self.assertIn('type', model)
+        self.assertEqual(model['type'], 'directory')
+        self.assertEqual(model['name'], 'Untitled Folder')
+        self.assertEqual(model['path'], 'Untitled Folder')
+        sub_dir = model['path']
+        
+        model = cm.new_untitled(path=sub_dir)
+        assert isinstance(model, dict)
+        self.assertIn('name', model)
+        self.assertIn('path', model)
+        self.assertIn('type', model)
+        self.assertEqual(model['type'], 'file')
+        self.assertEqual(model['name'], 'untitled')
+        self.assertEqual(model['path'], '%s/untitled' % sub_dir)
 
     def test_get(self):
         cm = self.contents_manager
         # Create a notebook
-        model = cm.create_file()
+        model = cm.new_untitled(type='notebook')
         name = model['name']
         path = model['path']
 
         # Check that we 'get' on the notebook we just created
-        model2 = cm.get_model(name, path)
+        model2 = cm.get(path)
         assert isinstance(model2, dict)
         self.assertIn('name', model2)
         self.assertIn('path', model2)
         self.assertEqual(model['name'], name)
         self.assertEqual(model['path'], path)
 
+        nb_as_file = cm.get(path, content=True, type_='file')
+        self.assertEqual(nb_as_file['path'], path)
+        self.assertEqual(nb_as_file['type'], 'file')
+        self.assertEqual(nb_as_file['format'], 'text')
+        self.assertNotIsInstance(nb_as_file['content'], dict)
+
+        nb_as_bin_file = cm.get(path, content=True, type_='file', format='base64')
+        self.assertEqual(nb_as_bin_file['format'], 'base64')
+
         # Test in sub-directory
         sub_dir = '/foo/'
         self.make_dir(cm.root_dir, 'foo')
-        model = cm.create_file(None, sub_dir)
-        model2 = cm.get_model(name, sub_dir)
+        model = cm.new_untitled(path=sub_dir, ext='.ipynb')
+        model2 = cm.get(sub_dir + name)
         assert isinstance(model2, dict)
         self.assertIn('name', model2)
         self.assertIn('path', model2)
         self.assertIn('content', model2)
-        self.assertEqual(model2['name'], 'Untitled0.ipynb')
-        self.assertEqual(model2['path'], sub_dir.strip('/'))
+        self.assertEqual(model2['name'], 'Untitled.ipynb')
+        self.assertEqual(model2['path'], '{0}/{1}'.format(sub_dir.strip('/'), name))
+
+        # Test getting directory model
+        dirmodel = cm.get('foo')
+        self.assertEqual(dirmodel['type'], 'directory')
+
+        with self.assertRaises(HTTPError):
+            cm.get('foo', type_='file')
+
     
     @dec.skip_win32
     def test_bad_symlink(self):
@@ -167,26 +194,27 b' class TestContentsManager(TestCase):'
         path = 'test bad symlink'
         os_path = self.make_dir(cm.root_dir, path)
         
-        file_model = cm.create_file(path=path, ext='.txt')
+        file_model = cm.new_untitled(path=path, ext='.txt')
         
         # create a broken symlink
         os.symlink("target", os.path.join(os_path, "bad symlink"))
-        model = cm.get_model(path)
+        model = cm.get(path)
         self.assertEqual(model['content'], [file_model])
     
     @dec.skip_win32
     def test_good_symlink(self):
         cm = self.contents_manager
-        path = 'test good symlink'
-        os_path = self.make_dir(cm.root_dir, path)
+        parent = 'test good symlink'
+        name = 'good symlink'
+        path = '{0}/{1}'.format(parent, name)
+        os_path = self.make_dir(cm.root_dir, parent)
         
-        file_model = cm.create_file(path=path, ext='.txt')
+        file_model = cm.new(path=parent + '/zfoo.txt')
         
         # create a good symlink
-        os.symlink(file_model['name'], os.path.join(os_path, "good symlink"))
-        symlink_model = cm.get_model(name="good symlink", path=path, content=False)
-        
-        dir_model = cm.get_model(path)
+        os.symlink(file_model['name'], os.path.join(os_path, name))
+        symlink_model = cm.get(path, content=False)
+        dir_model = cm.get(parent)
         self.assertEqual(
             sorted(dir_model['content'], key=lambda x: x['name']),
             [symlink_model, file_model],
@@ -195,53 +223,54 b' class TestContentsManager(TestCase):'
     def test_update(self):
         cm = self.contents_manager
         # Create a notebook
-        model = cm.create_file()
+        model = cm.new_untitled(type='notebook')
         name = model['name']
         path = model['path']
 
         # Change the name in the model for rename
-        model['name'] = 'test.ipynb'
-        model = cm.update(model, name, path)
+        model['path'] = 'test.ipynb'
+        model = cm.update(model, path)
         assert isinstance(model, dict)
         self.assertIn('name', model)
         self.assertIn('path', model)
         self.assertEqual(model['name'], 'test.ipynb')
 
         # Make sure the old name is gone
-        self.assertRaises(HTTPError, cm.get_model, name, path)
+        self.assertRaises(HTTPError, cm.get, path)
 
         # Test in sub-directory
         # Create a directory and notebook in that directory
         sub_dir = '/foo/'
         self.make_dir(cm.root_dir, 'foo')
-        model = cm.create_file(None, sub_dir)
+        model = cm.new_untitled(path=sub_dir, type='notebook')
         name = model['name']
         path = model['path']
 
         # Change the name in the model for rename
-        model['name'] = 'test_in_sub.ipynb'
-        model = cm.update(model, name, path)
+        d = path.rsplit('/', 1)[0]
+        new_path = model['path'] = d + '/test_in_sub.ipynb'
+        model = cm.update(model, path)
         assert isinstance(model, dict)
         self.assertIn('name', model)
         self.assertIn('path', model)
         self.assertEqual(model['name'], 'test_in_sub.ipynb')
-        self.assertEqual(model['path'], sub_dir.strip('/'))
+        self.assertEqual(model['path'], new_path)
 
         # Make sure the old name is gone
-        self.assertRaises(HTTPError, cm.get_model, name, path)
+        self.assertRaises(HTTPError, cm.get, path)
 
     def test_save(self):
         cm = self.contents_manager
         # Create a notebook
-        model = cm.create_file()
+        model = cm.new_untitled(type='notebook')
         name = model['name']
         path = model['path']
 
         # Get the model with 'content'
-        full_model = cm.get_model(name, path)
+        full_model = cm.get(path)
 
         # Save the notebook
-        model = cm.save(full_model, name, path)
+        model = cm.save(full_model, path)
         assert isinstance(model, dict)
         self.assertIn('name', model)
         self.assertIn('path', model)
@@ -252,18 +281,18 b' class TestContentsManager(TestCase):'
         # Create a directory and notebook in that directory
         sub_dir = '/foo/'
         self.make_dir(cm.root_dir, 'foo')
-        model = cm.create_file(None, sub_dir)
+        model = cm.new_untitled(path=sub_dir, type='notebook')
         name = model['name']
         path = model['path']
-        model = cm.get_model(name, path)
+        model = cm.get(path)
 
         # Change the name in the model for rename
-        model = cm.save(model, name, path)
+        model = cm.save(model, path)
         assert isinstance(model, dict)
         self.assertIn('name', model)
         self.assertIn('path', model)
-        self.assertEqual(model['name'], 'Untitled0.ipynb')
-        self.assertEqual(model['path'], sub_dir.strip('/'))
+        self.assertEqual(model['name'], 'Untitled.ipynb')
+        self.assertEqual(model['path'], 'foo/Untitled.ipynb')
 
     def test_delete(self):
         cm = self.contents_manager
@@ -271,36 +300,42 b' class TestContentsManager(TestCase):'
         nb, name, path = self.new_notebook()
 
         # Delete the notebook
-        cm.delete(name, path)
+        cm.delete(path)
 
         # Check that a 'get' on the deleted notebook raises and error
-        self.assertRaises(HTTPError, cm.get_model, name, path)
+        self.assertRaises(HTTPError, cm.get, path)
 
     def test_copy(self):
         cm = self.contents_manager
-        path = u'å b'
+        parent = u'å b'
         name = u'nb √.ipynb'
-        os.mkdir(os.path.join(cm.root_dir, path))
-        orig = cm.create_file({'name' : name}, path=path)
+        path = u'{0}/{1}'.format(parent, name)
+        os.mkdir(os.path.join(cm.root_dir, parent))
+        orig = cm.new(path=path)
 
         # copy with unspecified name
-        copy = cm.copy(name, path=path)
-        self.assertEqual(copy['name'], orig['name'].replace('.ipynb', '-Copy0.ipynb'))
+        copy = cm.copy(path)
+        self.assertEqual(copy['name'], orig['name'].replace('.ipynb', '-Copy1.ipynb'))
 
         # copy with specified name
-        copy2 = cm.copy(name, u'copy 2.ipynb', path=path)
+        copy2 = cm.copy(path, u'å b/copy 2.ipynb')
         self.assertEqual(copy2['name'], u'copy 2.ipynb')
+        self.assertEqual(copy2['path'], u'å b/copy 2.ipynb')
+        # copy with specified path
+        copy2 = cm.copy(path, u'/')
+        self.assertEqual(copy2['name'], name)
+        self.assertEqual(copy2['path'], name)
 
     def test_trust_notebook(self):
         cm = self.contents_manager
         nb, name, path = self.new_notebook()
 
-        untrusted = cm.get_model(name, path)['content']
+        untrusted = cm.get(path)['content']
         assert not cm.notary.check_cells(untrusted)
 
         # print(untrusted)
-        cm.trust_notebook(name, path)
-        trusted = cm.get_model(name, path)['content']
+        cm.trust_notebook(path)
+        trusted = cm.get(path)['content']
         # print(trusted)
         assert cm.notary.check_cells(trusted)
 
@@ -308,27 +343,27 b' class TestContentsManager(TestCase):'
         cm = self.contents_manager
         nb, name, path = self.new_notebook()
 
-        cm.mark_trusted_cells(nb, name, path)
-        for cell in nb.worksheets[0].cells:
+        cm.mark_trusted_cells(nb, path)
+        for cell in nb.cells:
             if cell.cell_type == 'code':
-                assert not cell.trusted
+                assert not cell.metadata.trusted
 
-        cm.trust_notebook(name, path)
-        nb = cm.get_model(name, path)['content']
-        for cell in nb.worksheets[0].cells:
+        cm.trust_notebook(path)
+        nb = cm.get(path)['content']
+        for cell in nb.cells:
             if cell.cell_type == 'code':
-                assert cell.trusted
+                assert cell.metadata.trusted
 
     def test_check_and_sign(self):
         cm = self.contents_manager
         nb, name, path = self.new_notebook()
 
-        cm.mark_trusted_cells(nb, name, path)
-        cm.check_and_sign(nb, name, path)
+        cm.mark_trusted_cells(nb, path)
+        cm.check_and_sign(nb, path)
         assert not cm.notary.check_signature(nb)
 
-        cm.trust_notebook(name, path)
-        nb = cm.get_model(name, path)['content']
-        cm.mark_trusted_cells(nb, name, path)
-        cm.check_and_sign(nb, name, path)
+        cm.trust_notebook(path)
+        nb = cm.get(path)['content']
+        cm.mark_trusted_cells(nb, path)
+        cm.check_and_sign(nb, path)
         assert cm.notary.check_signature(nb)

IPython/html/services/kernels/handlers.py

@@ -5,14 +5,16 b''
 
 import json
 import logging
-from tornado import web
+from tornado import gen, web
+from tornado.concurrent import Future
+from tornado.ioloop import IOLoop
 
 from IPython.utils.jsonutil import date_default
-from IPython.utils.py3compat import string_types
+from IPython.utils.py3compat import cast_unicode
 from IPython.html.utils import url_path_join, url_escape
 
 from ...base.handlers import IPythonHandler, json_errors
-from ...base.zmqhandlers import AuthenticatedZMQStreamHandler
+from ...base.zmqhandlers import AuthenticatedZMQStreamHandler, deserialize_binary_message
 
 from IPython.core.release import kernel_protocol_version
 
@@ -27,16 +29,16 b' class MainKernelHandler(IPythonHandler):'
     @web.authenticated
     @json_errors
     def post(self):
+        km = self.kernel_manager
         model = self.get_json_body()
         if model is None:
-            raise web.HTTPError(400, "No JSON data provided")
-        try:
-            name = model['name']
-        except KeyError:
-            raise web.HTTPError(400, "Missing field in JSON data: name")
+            model = {
+                'name': km.default_kernel_name
+            }
+        else:
+            model.setdefault('name', km.default_kernel_name)
 
-        km = self.kernel_manager
-        kernel_id = km.start_kernel(kernel_name=name)
+        kernel_id = km.start_kernel(kernel_name=model['name'])
         model = km.kernel_model(kernel_id)
         location = url_path_join(self.base_url, 'api', 'kernels', kernel_id)
         self.set_header('Location', url_escape(location))
@@ -84,6 +86,10 b' class KernelActionHandler(IPythonHandler):'
 
 class ZMQChannelHandler(AuthenticatedZMQStreamHandler):
     
+    @property
+    def kernel_info_timeout(self):
+        return self.settings.get('kernel_info_timeout', 10)
+    
     def __repr__(self):
         return "%s(%s)" % (self.__class__.__name__, getattr(self, 'kernel_id', 'uninitialized'))
     
@@ -91,17 +97,29 b' class ZMQChannelHandler(AuthenticatedZMQStreamHandler):'
         km = self.kernel_manager
         meth = getattr(km, 'connect_%s' % self.channel)
         self.zmq_stream = meth(self.kernel_id, identity=self.session.bsession)
-        # Create a kernel_info channel to query the kernel protocol version.
-        # This channel will be closed after the kernel_info reply is received.
-        self.kernel_info_channel = None
-        self.kernel_info_channel = km.connect_shell(self.kernel_id)
-        self.kernel_info_channel.on_recv(self._handle_kernel_info_reply)
-        self._request_kernel_info()
     
-    def _request_kernel_info(self):
+    def request_kernel_info(self):
         """send a request for kernel_info"""
-        self.log.debug("requesting kernel info")
-        self.session.send(self.kernel_info_channel, "kernel_info_request")
+        km = self.kernel_manager
+        kernel = km.get_kernel(self.kernel_id)
+        try:
+            # check for previous request
+            future = kernel._kernel_info_future
+        except AttributeError:
+            self.log.debug("Requesting kernel info from %s", self.kernel_id)
+            # Create a kernel_info channel to query the kernel protocol version.
+            # This channel will be closed after the kernel_info reply is received.
+            if self.kernel_info_channel is None:
+                self.kernel_info_channel = km.connect_shell(self.kernel_id)
+            self.kernel_info_channel.on_recv(self._handle_kernel_info_reply)
+            self.session.send(self.kernel_info_channel, "kernel_info_request")
+            # store the future on the kernel, so only one request is sent
+            kernel._kernel_info_future = self._kernel_info_future
+        else:
+            if not future.done():
+                self.log.debug("Waiting for pending kernel_info request")
+            future.add_done_callback(lambda f: self._finish_kernel_info(f.result()))
+        return self._kernel_info_future
     
     def _handle_kernel_info_reply(self, msg):
         """process the kernel_info_reply
@@ -110,35 +128,75 b' class ZMQChannelHandler(AuthenticatedZMQStreamHandler):'
         """
         idents,msg = self.session.feed_identities(msg)
         try:
-            msg = self.session.unserialize(msg)
+            msg = self.session.deserialize(msg)
         except:
             self.log.error("Bad kernel_info reply", exc_info=True)
-            self._request_kernel_info()
+            self._kernel_info_future.set_result({})
             return
         else:
-            if msg['msg_type'] != 'kernel_info_reply' or 'protocol_version' not in msg['content']:
-                self.log.error("Kernel info request failed, assuming current %s", msg['content'])
-            else:
-                protocol_version = msg['content']['protocol_version']
-                if protocol_version != kernel_protocol_version:
-                    self.session.adapt_version = int(protocol_version.split('.')[0])
-                    self.log.info("adapting kernel to %s" % protocol_version)
-        self.kernel_info_channel.close()
+            info = msg['content']
+            self.log.debug("Received kernel info: %s", info)
+            if msg['msg_type'] != 'kernel_info_reply' or 'protocol_version' not in info:
+                self.log.error("Kernel info request failed, assuming current %s", info)
+                info = {}
+            self._finish_kernel_info(info)
+        
+        # close the kernel_info channel, we don't need it anymore
+        if self.kernel_info_channel:
+            self.kernel_info_channel.close()
         self.kernel_info_channel = None
     
+    def _finish_kernel_info(self, info):
+        """Finish handling kernel_info reply
+        
+        Set up protocol adaptation, if needed,
+        and signal that connection can continue.
+        """
+        protocol_version = info.get('protocol_version', kernel_protocol_version)
+        if protocol_version != kernel_protocol_version:
+            self.session.adapt_version = int(protocol_version.split('.')[0])
+            self.log.info("Kernel %s speaks protocol %s", self.kernel_id, protocol_version)
+        if not self._kernel_info_future.done():
+            self._kernel_info_future.set_result(info)
     
-    def initialize(self, *args, **kwargs):
+    def initialize(self):
+        super(ZMQChannelHandler, self).initialize()
         self.zmq_stream = None
+        self.kernel_id = None
+        self.kernel_info_channel = None
+        self._kernel_info_future = Future()
     
-    def on_first_message(self, msg):
-        try:
-            super(ZMQChannelHandler, self).on_first_message(msg)
-        except web.HTTPError:
-            self.close()
-            return
+    @gen.coroutine
+    def pre_get(self):
+        # authenticate first
+        super(ZMQChannelHandler, self).pre_get()
+        # then request kernel info, waiting up to a certain time before giving up.
+        # We don't want to wait forever, because browsers don't take it well when
+        # servers never respond to websocket connection requests.
+        future = self.request_kernel_info()
+        
+        def give_up():
+            """Don't wait forever for the kernel to reply"""
+            if future.done():
+                return
+            self.log.warn("Timeout waiting for kernel_info reply from %s", self.kernel_id)
+            future.set_result({})
+        loop = IOLoop.current()
+        loop.add_timeout(loop.time() + self.kernel_info_timeout, give_up)
+        # actually wait for it
+        yield future
+    
+    @gen.coroutine
+    def get(self, kernel_id):
+        self.kernel_id = cast_unicode(kernel_id, 'ascii')
+        yield super(ZMQChannelHandler, self).get(kernel_id=kernel_id)
+    
+    def open(self, kernel_id):
+        super(ZMQChannelHandler, self).open()
         try:
             self.create_stream()
-        except web.HTTPError:
+        except web.HTTPError as e:
+            self.log.error("Error opening stream: %s", e)
             # WebSockets don't response to traditional error codes so we
             # close the connection.
             if not self.stream.closed():
@@ -154,7 +212,10 b' class ZMQChannelHandler(AuthenticatedZMQStreamHandler):'
             self.log.info("%s closed, closing websocket.", self)
             self.close()
             return
-        msg = json.loads(msg)
+        if isinstance(msg, bytes):
+            msg = deserialize_binary_message(msg)
+        else:
+            msg = json.loads(msg)
         self.session.send(self.zmq_stream, msg)
 
     def on_close(self):

IPython/html/services/kernels/kernelmanager.py

@@ -1,20 +1,11 b''
-"""A kernel manager relating notebooks and kernels
+"""A MultiKernelManager for use in the notebook webserver
 
-Authors:
-
-* Brian Granger
+- raises HTTPErrors
+- creates REST API models
 """
 
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2013  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.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 import os
 
@@ -26,10 +17,6 b' from IPython.utils.traitlets import List, Unicode, TraitError'
 from IPython.html.utils import to_os_path
 from IPython.utils.py3compat import getcwd
 
-#-----------------------------------------------------------------------------
-# Classes
-#-----------------------------------------------------------------------------
-
 
 class MappingKernelManager(MultiKernelManager):
     """A KernelManager that handles notebook mapping and HTTP error handling"""
@@ -39,7 +26,13 b' class MappingKernelManager(MultiKernelManager):'
 
     kernel_argv = List(Unicode)
 
-    root_dir = Unicode(getcwd(), config=True)
+    root_dir = Unicode(config=True)
+
+    def _root_dir_default(self):
+        try:
+            return self.parent.notebook_dir
+        except AttributeError:
+            return getcwd()
 
     def _root_dir_changed(self, name, old, new):
         """Do a bit of validation of the root dir."""
@@ -61,14 +54,10 b' class MappingKernelManager(MultiKernelManager):'
 
     def cwd_for_path(self, path):
         """Turn API path into absolute OS path."""
-        # short circuit for NotebookManagers that pass in absolute paths
-        if os.path.exists(path):
-            return path
-
         os_path = to_os_path(path, self.root_dir)
         # in the case of notebooks and kernels not being on the same filesystem,
         # walk up to root_dir if the paths don't exist
-        while not os.path.exists(os_path) and os_path != self.root_dir:
+        while not os.path.isdir(os_path) and os_path != self.root_dir:
             os_path = os.path.dirname(os_path)
         return os_path
 
@@ -89,7 +78,6 b' class MappingKernelManager(MultiKernelManager):'
             an existing kernel is returned, but it may be checked in the future.
         """
         if kernel_id is None:
-            kwargs['extra_arguments'] = self.kernel_argv
             if path is not None:
                 kwargs['cwd'] = self.cwd_for_path(path)
             kernel_id = super(MappingKernelManager, self).start_kernel(

IPython/html/services/kernels/tests/test_kernels_api.py

@@ -57,6 +57,19 b' class KernelAPITest(NotebookTestBase):'
         kernels = self.kern_api.list().json()
         self.assertEqual(kernels, [])
 
+    def test_default_kernel(self):
+        # POST request
+        r = self.kern_api._req('POST', '')
+        kern1 = r.json()
+        self.assertEqual(r.headers['location'], '/api/kernels/' + kern1['id'])
+        self.assertEqual(r.status_code, 201)
+        self.assertIsInstance(kern1, dict)
+
+        self.assertEqual(r.headers['Content-Security-Policy'], (
+                            "frame-ancestors 'self'; "
+                            "report-uri /api/security/csp-report;"
+        ))
+
     def test_main_kernel_handler(self):
         # POST request
         r = self.kern_api.start()
@@ -65,7 +78,10 b' class KernelAPITest(NotebookTestBase):'
         self.assertEqual(r.status_code, 201)
         self.assertIsInstance(kern1, dict)
 
-        self.assertEqual(r.headers['x-frame-options'], "SAMEORIGIN")
+        self.assertEqual(r.headers['Content-Security-Policy'], (
+                            "frame-ancestors 'self'; "
+                            "report-uri /api/security/csp-report;"
+        ))
 
         # GET request
         r = self.kern_api.list()

IPython/html/services/kernelspecs/handlers.py

@@ -19,7 +19,11 b' class MainKernelSpecHandler(IPythonHandler):'
         ksm = self.kernel_spec_manager
         results = []
         for kernel_name in sorted(ksm.find_kernel_specs(), key=_pythonfirst):
-            d = ksm.get_kernel_spec(kernel_name).to_dict()
+            try:
+                d = ksm.get_kernel_spec(kernel_name).to_dict()
+            except Exception:
+                self.log.error("Failed to load kernel spec: '%s'", kernel_name, exc_info=True)
+                continue
             d['name'] = kernel_name
             results.append(d)
 

IPython/html/services/kernelspecs/tests/test_kernelspecs_api.py

@@ -5,6 +5,7 b' import errno'
 import io
 import json
 import os
+import shutil
 
 pjoin = os.path.join
 
@@ -18,7 +19,6 b' from IPython.html.tests.launchnotebook import NotebookTestBase, assert_http_erro'
 # break these tests
 sample_kernel_json = {'argv':['cat', '{connection_file}'],
                       'display_name':'Test kernel',
-                      'language':'bash',
                      }
 
 some_resource = u"The very model of a modern major general"
@@ -66,6 +66,25 b' class APITest(NotebookTestBase):'
 
         self.ks_api = KernelSpecAPI(self.base_url())
 
+    def test_list_kernelspecs_bad(self):
+        """Can list kernelspecs when one is invalid"""
+        bad_kernel_dir = pjoin(self.ipython_dir.name, 'kernels', 'bad')
+        try:
+            os.makedirs(bad_kernel_dir)
+        except OSError as e:
+            if e.errno != errno.EEXIST:
+                raise
+        
+        with open(pjoin(bad_kernel_dir, 'kernel.json'), 'w') as f:
+            f.write("garbage")
+        
+        specs = self.ks_api.list().json()
+        assert isinstance(specs, list)
+        # 2: the sample kernelspec created in setUp, and the native Python kernel
+        self.assertGreaterEqual(len(specs), 2)
+        
+        shutil.rmtree(bad_kernel_dir)
+    
     def test_list_kernelspecs(self):
         specs = self.ks_api.list().json()
         assert isinstance(specs, list)
@@ -84,7 +103,7 b' class APITest(NotebookTestBase):'
 
     def test_get_kernelspec(self):
         spec = self.ks_api.kernel_spec_info('Sample').json()  # Case insensitive
-        self.assertEqual(spec['language'], 'bash')
+        self.assertEqual(spec['display_name'], 'Test kernel')
 
     def test_get_nonexistant_kernelspec(self):
         with assert_http_error(404):

IPython/html/services/sessions/handlers.py

@@ -10,6 +10,7 b' from tornado import web'
 from ...base.handlers import IPythonHandler, json_errors
 from IPython.utils.jsonutil import date_default
 from IPython.html.utils import url_path_join, url_escape
+from IPython.kernel.kernelspec import NoSuchKernel
 
 
 class SessionRootHandler(IPythonHandler):
@@ -35,23 +36,30 b' class SessionRootHandler(IPythonHandler):'
         if model is None:
             raise web.HTTPError(400, "No JSON data provided")
         try:
-            name = model['notebook']['name']
-        except KeyError:
-            raise web.HTTPError(400, "Missing field in JSON data: notebook.name")
-        try:
             path = model['notebook']['path']
         except KeyError:
             raise web.HTTPError(400, "Missing field in JSON data: notebook.path")
         try:
             kernel_name = model['kernel']['name']
         except KeyError:
-            raise web.HTTPError(400, "Missing field in JSON data: kernel.name")
+            self.log.debug("No kernel name specified, using default kernel")
+            kernel_name = None
 
         # Check to see if session exists
-        if sm.session_exists(name=name, path=path):
-            model = sm.get_session(name=name, path=path)
+        if sm.session_exists(path=path):
+            model = sm.get_session(path=path)
         else:
-            model = sm.create_session(name=name, path=path, kernel_name=kernel_name)
+            try:
+                model = sm.create_session(path=path, kernel_name=kernel_name)
+            except NoSuchKernel:
+                msg = ("The '%s' kernel is not available. Please pick another "
+                       "suitable kernel instead, or install that kernel." % kernel_name)
+                status_msg = '%s not found' % kernel_name
+                self.log.warn('Kernel not found: %s' % kernel_name)
+                self.set_status(501)
+                self.finish(json.dumps(dict(message=msg, short_message=status_msg)))
+                return
+
         location = url_path_join(self.base_url, 'api', 'sessions', model['id'])
         self.set_header('Location', url_escape(location))
         self.set_status(201)
@@ -80,8 +88,6 b' class SessionHandler(IPythonHandler):'
         changes = {}
         if 'notebook' in model:
             notebook = model['notebook']
-            if 'name' in notebook:
-                changes['name'] = notebook['name']
             if 'path' in notebook:
                 changes['path'] = notebook['path']
 
@@ -94,7 +100,11 b' class SessionHandler(IPythonHandler):'
     def delete(self, session_id):
         # Deletes the session with given session_id
         sm = self.session_manager
-        sm.delete_session(session_id)
+        try:
+            sm.delete_session(session_id)
+        except KeyError:
+            # the kernel was deleted but the session wasn't!
+            raise web.HTTPError(410, "Kernel deleted before session")
         self.set_status(204)
         self.finish()
 

IPython/html/services/sessions/sessionmanager.py

@@ -1,20 +1,7 b''
-"""A base class session manager.
+"""A base class session manager."""
 
-Authors:
-
-* Zach Sailer
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2013  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.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 import uuid
 import sqlite3
@@ -25,9 +12,6 b' from IPython.config.configurable import LoggingConfigurable'
 from IPython.utils.py3compat import unicode_type
 from IPython.utils.traitlets import Instance
 
-#-----------------------------------------------------------------------------
-# Classes
-#-----------------------------------------------------------------------------
 
 class SessionManager(LoggingConfigurable):
 
@@ -37,7 +21,7 b' class SessionManager(LoggingConfigurable):'
     # Session database initialized below
     _cursor = None
     _connection = None
-    _columns = {'session_id', 'name', 'path', 'kernel_id'}
+    _columns = {'session_id', 'path', 'kernel_id'}
     
     @property
     def cursor(self):
@@ -45,7 +29,7 b' class SessionManager(LoggingConfigurable):'
         if self._cursor is None:
             self._cursor = self.connection.cursor()
             self._cursor.execute("""CREATE TABLE session 
-                (session_id, name, path, kernel_id)""")
+                (session_id, path, kernel_id)""")
         return self._cursor
 
     @property
@@ -60,9 +44,9 b' class SessionManager(LoggingConfigurable):'
         """Close connection once SessionManager closes"""
         self.cursor.close()
 
-    def session_exists(self, name, path):
+    def session_exists(self, path):
         """Check to see if the session for a given notebook exists"""
-        self.cursor.execute("SELECT * FROM session WHERE name=? AND path=?", (name, path))
+        self.cursor.execute("SELECT * FROM session WHERE path=?", (path,))
         reply = self.cursor.fetchone()
         if reply is None:
             return False
@@ -73,17 +57,17 b' class SessionManager(LoggingConfigurable):'
         "Create a uuid for a new session"
         return unicode_type(uuid.uuid4())
 
-    def create_session(self, name=None, path=None, kernel_name='python'):
+    def create_session(self, path=None, kernel_name=None):
         """Creates a session and returns its model"""
         session_id = self.new_session_id()
         # allow nbm to specify kernels cwd
-        kernel_path = self.contents_manager.get_kernel_path(name=name, path=path)
+        kernel_path = self.contents_manager.get_kernel_path(path=path)
         kernel_id = self.kernel_manager.start_kernel(path=kernel_path,
                                                      kernel_name=kernel_name)
-        return self.save_session(session_id, name=name, path=path,
+        return self.save_session(session_id, path=path,
                                  kernel_id=kernel_id)
 
-    def save_session(self, session_id, name=None, path=None, kernel_id=None):
+    def save_session(self, session_id, path=None, kernel_id=None):
         """Saves the items for the session with the given session_id
         
         Given a session_id (and any other of the arguments), this method
@@ -94,10 +78,8 b' class SessionManager(LoggingConfigurable):'
         ----------
         session_id : str
             uuid for the session; this method must be given a session_id
-        name : str
-            the .ipynb notebook name that started the session
         path : str
-            the path to the named notebook
+            the path for the given notebook
         kernel_id : str
             a uuid for the kernel associated with this session
         
@@ -106,8 +88,8 b' class SessionManager(LoggingConfigurable):'
         model : dict
             a dictionary of the session model
         """
-        self.cursor.execute("INSERT INTO session VALUES (?,?,?,?)",
-            (session_id, name, path, kernel_id)
+        self.cursor.execute("INSERT INTO session VALUES (?,?,?)",
+            (session_id, path, kernel_id)
         )
         return self.get_session(session_id=session_id)
 
@@ -121,7 +103,7 b' class SessionManager(LoggingConfigurable):'
         ----------
         **kwargs : keyword argument
             must be given one of the keywords and values from the session database
-            (i.e. session_id, name, path, kernel_id)
+            (i.e. session_id, path, kernel_id)
 
         Returns
         -------
@@ -198,7 +180,6 b' class SessionManager(LoggingConfigurable):'
         model = {
             'id': row['session_id'],
             'notebook': {
-                'name': row['name'],
                 'path': row['path']
             },
             'kernel': self.kernel_manager.kernel_model(row['kernel_id'])

IPython/html/services/sessions/tests/test_sessionmanager.py

@@ -32,24 +32,24 b' class TestSessionManager(TestCase):'
     
     def test_get_session(self):
         sm = SessionManager(kernel_manager=DummyMKM())
-        session_id = sm.create_session(name='test.ipynb', path='/path/to/',
+        session_id = sm.create_session(path='/path/to/test.ipynb',
                                        kernel_name='bar')['id']
         model = sm.get_session(session_id=session_id)
         expected = {'id':session_id,
-                    'notebook':{'name':u'test.ipynb', 'path': u'/path/to/'},
+                    'notebook':{'path': u'/path/to/test.ipynb'},
                     'kernel': {'id':u'A', 'name': 'bar'}}
         self.assertEqual(model, expected)
 
     def test_bad_get_session(self):
         # Should raise error if a bad key is passed to the database.
         sm = SessionManager(kernel_manager=DummyMKM())
-        session_id = sm.create_session(name='test.ipynb', path='/path/to/',
+        session_id = sm.create_session(path='/path/to/test.ipynb',
                                        kernel_name='foo')['id']
         self.assertRaises(TypeError, sm.get_session, bad_id=session_id) # Bad keyword
 
     def test_get_session_dead_kernel(self):
         sm = SessionManager(kernel_manager=DummyMKM())
-        session = sm.create_session(name='test1.ipynb', path='/path/to/1/', kernel_name='python')
+        session = sm.create_session(path='/path/to/1/test1.ipynb', kernel_name='python')
         # kill the kernel
         sm.kernel_manager.shutdown_kernel(session['kernel']['id'])
         with self.assertRaises(KeyError):
@@ -61,24 +61,33 b' class TestSessionManager(TestCase):'
     def test_list_sessions(self):
         sm = SessionManager(kernel_manager=DummyMKM())
         sessions = [
-            sm.create_session(name='test1.ipynb', path='/path/to/1/', kernel_name='python'),
-            sm.create_session(name='test2.ipynb', path='/path/to/2/', kernel_name='python'),
-            sm.create_session(name='test3.ipynb', path='/path/to/3/', kernel_name='python'),
+            sm.create_session(path='/path/to/1/test1.ipynb', kernel_name='python'),
+            sm.create_session(path='/path/to/2/test2.ipynb', kernel_name='python'),
+            sm.create_session(path='/path/to/3/test3.ipynb', kernel_name='python'),
         ]
         sessions = sm.list_sessions()
-        expected = [{'id':sessions[0]['id'], 'notebook':{'name':u'test1.ipynb', 
-                    'path': u'/path/to/1/'}, 'kernel':{'id':u'A', 'name':'python'}},
-                    {'id':sessions[1]['id'], 'notebook': {'name':u'test2.ipynb', 
-                    'path': u'/path/to/2/'}, 'kernel':{'id':u'B', 'name':'python'}},
-                    {'id':sessions[2]['id'], 'notebook':{'name':u'test3.ipynb', 
-                    'path': u'/path/to/3/'}, 'kernel':{'id':u'C', 'name':'python'}}]
+        expected = [
+            {
+                'id':sessions[0]['id'],
+                'notebook':{'path': u'/path/to/1/test1.ipynb'},
+                'kernel':{'id':u'A', 'name':'python'}
+            }, {
+                'id':sessions[1]['id'],
+                'notebook': {'path': u'/path/to/2/test2.ipynb'},
+                'kernel':{'id':u'B', 'name':'python'}
+            }, {
+                'id':sessions[2]['id'],
+                'notebook':{'path': u'/path/to/3/test3.ipynb'},
+                'kernel':{'id':u'C', 'name':'python'}
+            }
+        ]
         self.assertEqual(sessions, expected)
 
     def test_list_sessions_dead_kernel(self):
         sm = SessionManager(kernel_manager=DummyMKM())
         sessions = [
-            sm.create_session(name='test1.ipynb', path='/path/to/1/', kernel_name='python'),
-            sm.create_session(name='test2.ipynb', path='/path/to/2/', kernel_name='python'),
+            sm.create_session(path='/path/to/1/test1.ipynb', kernel_name='python'),
+            sm.create_session(path='/path/to/2/test2.ipynb', kernel_name='python'),
         ]
         # kill one of the kernels
         sm.kernel_manager.shutdown_kernel(sessions[0]['kernel']['id'])
@@ -87,8 +96,7 b' class TestSessionManager(TestCase):'
             {
                 'id': sessions[1]['id'],
                 'notebook': {
-                    'name': u'test2.ipynb',
-                    'path': u'/path/to/2/',
+                    'path': u'/path/to/2/test2.ipynb',
                 },
                 'kernel': {
                     'id': u'B',
@@ -100,41 +108,47 b' class TestSessionManager(TestCase):'
 
     def test_update_session(self):
         sm = SessionManager(kernel_manager=DummyMKM())
-        session_id = sm.create_session(name='test.ipynb', path='/path/to/',
+        session_id = sm.create_session(path='/path/to/test.ipynb',
                                        kernel_name='julia')['id']
-        sm.update_session(session_id, name='new_name.ipynb')
+        sm.update_session(session_id, path='/path/to/new_name.ipynb')
         model = sm.get_session(session_id=session_id)
         expected = {'id':session_id,
-                    'notebook':{'name':u'new_name.ipynb', 'path': u'/path/to/'},
+                    'notebook':{'path': u'/path/to/new_name.ipynb'},
                     'kernel':{'id':u'A', 'name':'julia'}}
         self.assertEqual(model, expected)
     
     def test_bad_update_session(self):
         # try to update a session with a bad keyword ~ raise error
         sm = SessionManager(kernel_manager=DummyMKM())
-        session_id = sm.create_session(name='test.ipynb', path='/path/to/',
+        session_id = sm.create_session(path='/path/to/test.ipynb',
                                        kernel_name='ir')['id']
         self.assertRaises(TypeError, sm.update_session, session_id=session_id, bad_kw='test.ipynb') # Bad keyword
 
     def test_delete_session(self):
         sm = SessionManager(kernel_manager=DummyMKM())
         sessions = [
-            sm.create_session(name='test1.ipynb', path='/path/to/1/', kernel_name='python'),
-            sm.create_session(name='test2.ipynb', path='/path/to/2/', kernel_name='python'),
-            sm.create_session(name='test3.ipynb', path='/path/to/3/', kernel_name='python'),
+            sm.create_session(path='/path/to/1/test1.ipynb', kernel_name='python'),
+            sm.create_session(path='/path/to/2/test2.ipynb', kernel_name='python'),
+            sm.create_session(path='/path/to/3/test3.ipynb', kernel_name='python'),
         ]
         sm.delete_session(sessions[1]['id'])
         new_sessions = sm.list_sessions()
-        expected = [{'id':sessions[0]['id'], 'notebook':{'name':u'test1.ipynb', 
-                    'path': u'/path/to/1/'}, 'kernel':{'id':u'A', 'name':'python'}},
-                    {'id':sessions[2]['id'], 'notebook':{'name':u'test3.ipynb', 
-                    'path': u'/path/to/3/'}, 'kernel':{'id':u'C', 'name':'python'}}]
+        expected = [{
+                'id': sessions[0]['id'],
+                'notebook': {'path': u'/path/to/1/test1.ipynb'},
+                'kernel': {'id':u'A', 'name':'python'}
+            }, {
+                'id': sessions[2]['id'],
+                'notebook': {'path': u'/path/to/3/test3.ipynb'},
+                'kernel': {'id':u'C', 'name':'python'}
+            }
+        ]
         self.assertEqual(new_sessions, expected)
 
     def test_bad_delete_session(self):
         # try to delete a session that doesn't exist ~ raise error
         sm = SessionManager(kernel_manager=DummyMKM())
-        sm.create_session(name='test.ipynb', path='/path/to/', kernel_name='python')
+        sm.create_session(path='/path/to/test.ipynb', kernel_name='python')
         self.assertRaises(TypeError, sm.delete_session, bad_kwarg='23424') # Bad keyword
         self.assertRaises(web.HTTPError, sm.delete_session, session_id='23424') # nonexistant
 

IPython/html/services/sessions/tests/test_sessions_api.py

@@ -11,7 +11,8 b' pjoin = os.path.join'
 
 from IPython.html.utils import url_path_join
 from IPython.html.tests.launchnotebook import NotebookTestBase, assert_http_error
-from IPython.nbformat.current import new_notebook, write
+from IPython.nbformat.v4 import new_notebook
+from IPython.nbformat import write
 
 class SessionAPI(object):
     """Wrapper for notebook API calls."""
@@ -37,13 +38,13 b' class SessionAPI(object):'
     def get(self, id):
         return self._req('GET', id)
 
-    def create(self, name, path, kernel_name='python'):
-        body = json.dumps({'notebook': {'name':name, 'path':path},
+    def create(self, path, kernel_name='python'):
+        body = json.dumps({'notebook': {'path':path},
                            'kernel': {'name': kernel_name}})
         return self._req('POST', '', body)
 
-    def modify(self, id, name, path):
-        body = json.dumps({'notebook': {'name':name, 'path':path}})
+    def modify(self, id, path):
+        body = json.dumps({'notebook': {'path':path}})
         return self._req('PATCH', id, body)
 
     def delete(self, id):
@@ -62,8 +63,8 b' class SessionAPITest(NotebookTestBase):'
 
         with io.open(pjoin(nbdir, 'foo', 'nb1.ipynb'), 'w',
                      encoding='utf-8') as f:
-            nb = new_notebook(name='nb1')
-            write(nb, f, format='ipynb')
+            nb = new_notebook()
+            write(nb, f, version=4)
 
         self.sess_api = SessionAPI(self.base_url())
 
@@ -77,12 +78,11 b' class SessionAPITest(NotebookTestBase):'
         sessions = self.sess_api.list().json()
         self.assertEqual(len(sessions), 0)
 
-        resp = self.sess_api.create('nb1.ipynb', 'foo')
+        resp = self.sess_api.create('foo/nb1.ipynb')
         self.assertEqual(resp.status_code, 201)
         newsession = resp.json()
         self.assertIn('id', newsession)
-        self.assertEqual(newsession['notebook']['name'], 'nb1.ipynb')
-        self.assertEqual(newsession['notebook']['path'], 'foo')
+        self.assertEqual(newsession['notebook']['path'], 'foo/nb1.ipynb')
         self.assertEqual(resp.headers['Location'], '/api/sessions/{0}'.format(newsession['id']))
 
         sessions = self.sess_api.list().json()
@@ -94,7 +94,7 b' class SessionAPITest(NotebookTestBase):'
         self.assertEqual(got, newsession)
 
     def test_delete(self):
-        newsession = self.sess_api.create('nb1.ipynb', 'foo').json()
+        newsession = self.sess_api.create('foo/nb1.ipynb').json()
         sid = newsession['id']
 
         resp = self.sess_api.delete(sid)
@@ -107,10 +107,9 b' class SessionAPITest(NotebookTestBase):'
             self.sess_api.get(sid)
 
     def test_modify(self):
-        newsession = self.sess_api.create('nb1.ipynb', 'foo').json()
+        newsession = self.sess_api.create('foo/nb1.ipynb').json()
         sid = newsession['id']
 
-        changed = self.sess_api.modify(sid, 'nb2.ipynb', '').json()
+        changed = self.sess_api.modify(sid, 'nb2.ipynb').json()
         self.assertEqual(changed['id'], sid)
-        self.assertEqual(changed['notebook']['name'], 'nb2.ipynb')
-        self.assertEqual(changed['notebook']['path'], '')
+        self.assertEqual(changed['notebook']['path'], 'nb2.ipynb')

IPython/html/static/base/js/dialog.js

@@ -4,7 +4,8 b''
 define([
     'base/js/namespace',
     'jquery',
-], function(IPython, $) {
+    'codemirror/lib/codemirror',
+], function(IPython, $, CodeMirror) {
     "use strict";
     
     var modal = function (options) {
@@ -90,6 +91,17 b' define(['
         return modal.modal(options);
     };
 
+    var kernel_modal = function (options) {
+        /**
+         * only one kernel dialog should be open at a time -- but
+         * other modal dialogs can still be open
+         */
+        $('.kernel-modal').modal('hide');
+        var dialog = modal(options);
+        dialog.addClass('kernel-modal');
+        return dialog;
+    };
+
     var edit_metadata = function (options) {
         options.name = options.name || "Cell";
         var error_div = $('<div/>').css('color', 'red');
@@ -130,7 +142,9 b' define(['
             buttons: {
                 OK: { class : "btn-primary",
                     click: function() {
-                        // validate json and set it
+                        /**
+                         * validate json and set it
+                         */
                         var new_md;
                         try {
                             new_md = JSON.parse(editor.getValue());
@@ -153,6 +167,7 b' define(['
     
     var dialog = {
         modal : modal,
+        kernel_modal : kernel_modal,
         edit_metadata : edit_metadata,
     };
 

IPython/html/static/base/js/keyboard.js

@@ -1,22 +1,33 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
+/**
+ *
+ *
+ * @module keyboard
+ * @namespace keyboard
+ * @class ShortcutManager
+ */
 
 define([
     'base/js/namespace',
     'jquery',
     'base/js/utils',
-], function(IPython, $, utils) {
+    'underscore',
+], function(IPython, $, utils, _) {
     "use strict";
 
 
-    // Setup global keycodes and inverse keycodes.
+    /**
+     * Setup global keycodes and inverse keycodes.
+     * 
+     * See http://unixpapa.com/js/key.html for a complete description. The short of
+     * it is that there are different keycode sets. Firefox uses the "Mozilla keycodes"
+     * and Webkit/IE use the "IE keycodes". These keycode sets are mostly the same
+     * but have minor differences.
+     **/
 
-    // See http://unixpapa.com/js/key.html for a complete description. The short of
-    // it is that there are different keycode sets. Firefox uses the "Mozilla keycodes"
-    // and Webkit/IE use the "IE keycodes". These keycode sets are mostly the same
-    // but have minor differences.
-
-    // These apply to Firefox, (Webkit and IE)
+     // These apply to Firefox, (Webkit and IE)
+     // This does work **only** on US keyboard.
     var _keycodes = {
         'a': 65, 'b': 66, 'c': 67, 'd': 68, 'e': 69, 'f': 70, 'g': 71, 'h': 72, 'i': 73,
         'j': 74, 'k': 75, 'l': 76, 'm': 77, 'n': 78, 'o': 79, 'p': 80, 'q': 81, 'r': 82,
@@ -77,13 +88,32 b' define(['
     };
 
     var normalize_shortcut = function (shortcut) {
-        // Put a shortcut into normalized form:
-        // 1. Make lowercase
-        // 2. Replace cmd by meta
-        // 3. Sort '-' separated modifiers into the order alt-ctrl-meta-shift
-        // 4. Normalize keys
+        /**
+         * @function _normalize_shortcut
+         * @private
+         * return a dict containing the normalized shortcut and the number of time it should be pressed:
+         *
+         * Put a shortcut into normalized form:
+         * 1. Make lowercase
+         * 2. Replace cmd by meta
+         * 3. Sort '-' separated modifiers into the order alt-ctrl-meta-shift
+         * 4. Normalize keys
+         **/
+        if (platform === 'MacOS') {
+            shortcut = shortcut.toLowerCase().replace('cmdtrl-', 'cmd-');
+        } else {
+            shortcut = shortcut.toLowerCase().replace('cmdtrl-', 'ctrl-');
+        }
+
         shortcut = shortcut.toLowerCase().replace('cmd', 'meta');
         shortcut = shortcut.replace(/-$/, '_');  // catch shortcuts using '-' key
+        shortcut = shortcut.replace(/,$/, 'comma');  // catch shortcuts using '-' key
+        if(shortcut.indexOf(',') !== -1){
+            var sht = shortcut.split(',');
+            sht = _.map(sht, normalize_shortcut);
+            return shortcut;
+        }
+        shortcut = shortcut.replace(/comma/g, ',');  // catch shortcuts using '-' key
         var values = shortcut.split("-");
         if (values.length === 1) {
             return normalize_key(values[0]);
@@ -96,7 +126,9 b' define(['
     };
 
     var shortcut_to_event = function (shortcut, type) {
-        // Convert a shortcut (shift-r) to a jQuery Event object
+        /**
+         * Convert a shortcut (shift-r) to a jQuery Event object
+         **/
         type = type || 'keydown';
         shortcut = normalize_shortcut(shortcut);
         shortcut = shortcut.replace(/-$/, '_');  // catch shortcuts using '-' key
@@ -111,8 +143,21 b' define(['
         return $.Event(type, opts);
     };
 
+    var only_modifier_event = function(event){
+        /**
+         * Return `true` if the event only contains modifiers keys.
+         * false otherwise
+         **/
+        var key = inv_keycodes[event.which];
+        return ((event.altKey || event.ctrlKey || event.metaKey || event.shiftKey) && 
+         (key === 'alt'|| key === 'ctrl'|| key === 'meta'|| key === 'shift'));
+
+    };
+
     var event_to_shortcut = function (event) {
-        // Convert a jQuery Event object to a shortcut (shift-r)
+        /**
+         * Convert a jQuery Event object to a normalized shortcut string (shift-r)
+         **/
         var shortcut = '';
         var key = inv_keycodes[event.which];
         if (event.altKey && key !== 'alt') {shortcut += 'alt-';}
@@ -125,35 +170,86 b' define(['
 
     // Shortcut manager class
 
-    var ShortcutManager = function (delay, events) {
+    var ShortcutManager = function (delay, events, actions, env) {
+        /**
+         * A class to deal with keyboard event and shortcut
+         *
+         * @class ShortcutManager
+         * @constructor
+         */
         this._shortcuts = {};
-        this._counts = {};
-        this._timers = {};
         this.delay = delay || 800; // delay in milliseconds
         this.events = events;
+        this.actions = actions;
+        this.actions.extend_env(env);
+        this._queue = [];
+        this._cleartimeout = null;
+        Object.seal(this);
+    };
+
+    ShortcutManager.prototype.clearsoon = function(){
+        /**
+         * Clear the pending shortcut soon, and cancel previous clearing
+         * that might be registered.
+         **/ 
+         var that = this;
+         clearTimeout(this._cleartimeout);
+         this._cleartimeout = setTimeout(function(){that.clearqueue();}, this.delay);
+    };
+
+
+    ShortcutManager.prototype.clearqueue = function(){
+        /**
+         * clear the pending shortcut sequence now. 
+         **/
+        this._queue = [];
+        clearTimeout(this._cleartimeout);
+    };
+
+
+    var flatten_shorttree = function(tree){
+        /**
+         * Flatten a tree of shortcut sequences. 
+         * use full to iterate over all the key/values of available shortcuts.
+         **/
+        var  dct = {};
+        for(var key in tree){
+            var value = tree[key];
+            if(typeof(value) === 'string'){
+                dct[key] = value;
+            } else {
+                var ftree=flatten_shorttree(value);
+                for(var subkey in ftree){
+                    dct[key+','+subkey] = ftree[subkey];
+                }
+            } 
+        }
+        return dct;
     };
 
     ShortcutManager.prototype.help = function () {
         var help = [];
-        for (var shortcut in this._shortcuts) {
-            var help_string = this._shortcuts[shortcut].help;
-            var help_index = this._shortcuts[shortcut].help_index;
+        var ftree = flatten_shorttree(this._shortcuts);
+        for (var shortcut in ftree) {
+            var action = this.actions.get(ftree[shortcut]);
+            var help_string = action.help||'== no help ==';
+            var help_index = action.help_index;
             if (help_string) {
-                if (platform === 'MacOS') {
-                    shortcut = shortcut.replace('meta', 'cmd');
-                }
+                var shortstring = (action.shortstring||shortcut);
                 help.push({
-                    shortcut: shortcut,
+                    shortcut: shortstring,
                     help: help_string,
                     help_index: help_index}
                 );
             }
         }
         help.sort(function (a, b) {
-            if (a.help_index > b.help_index)
+            if (a.help_index > b.help_index){
                 return 1;
-            if (a.help_index < b.help_index)
+            }
+            if (a.help_index < b.help_index){
                 return -1;
+            }
             return 0;
         });
         return help;
@@ -163,19 +259,105 b' define(['
         this._shortcuts = {};
     };
 
-    ShortcutManager.prototype.add_shortcut = function (shortcut, data, suppress_help_update) {
-        if (typeof(data) === 'function') {
-            data = {help: '', help_index: '', handler: data};
+    ShortcutManager.prototype.get_shortcut = function (shortcut){
+        /**
+         * return a node of the shortcut tree which an action name (string) if leaf,
+         * and an object with `object.subtree===true`
+         **/
+        if(typeof(shortcut) === 'string'){
+            shortcut = shortcut.split(',');
+        }
+        
+        return this._get_leaf(shortcut, this._shortcuts);
+    };
+
+
+    ShortcutManager.prototype._get_leaf = function(shortcut_array, tree){
+        /**
+         * @private
+         * find a leaf/node in a subtree of the keyboard shortcut
+         *
+         **/
+        if(shortcut_array.length === 1){
+            return tree[shortcut_array[0]];
+        } else if(  typeof(tree[shortcut_array[0]]) !== 'string'){
+            return this._get_leaf(shortcut_array.slice(1), tree[shortcut_array[0]]);
+        }
+        return null;
+    };
+
+    ShortcutManager.prototype.set_shortcut = function( shortcut, action_name){
+        if( typeof(action_name) !== 'string'){ throw('action is not a string', action_name);}
+        if( typeof(shortcut) === 'string'){
+            shortcut = shortcut.split(',');
+        }
+        return this._set_leaf(shortcut, action_name, this._shortcuts);
+    };
+
+    ShortcutManager.prototype._is_leaf = function(shortcut_array, tree){
+        if(shortcut_array.length === 1){
+           return(typeof(tree[shortcut_array[0]]) === 'string');
+        } else {
+            var subtree = tree[shortcut_array[0]];
+            return this._is_leaf(shortcut_array.slice(1), subtree );
         }
-        data.help_index = data.help_index || '';
-        data.help = data.help || '';
-        data.count = data.count || 1;
-        if (data.help_index === '') {
-            data.help_index = 'zz';
+    };
+
+    ShortcutManager.prototype._remove_leaf = function(shortcut_array, tree, allow_node){
+        if(shortcut_array.length === 1){
+            var current_node = tree[shortcut_array[0]];
+            if(typeof(current_node) === 'string'){
+                delete tree[shortcut_array[0]];
+            } else {
+                throw('try to delete non-leaf');
+            }
+        } else {
+            this._remove_leaf(shortcut_array.slice(1),  tree[shortcut_array[0]], allow_node);
+            if(_.keys(tree[shortcut_array[0]]).length === 0){
+                delete tree[shortcut_array[0]];
+            }
         }
+    };
+
+    ShortcutManager.prototype._set_leaf = function(shortcut_array, action_name, tree){
+        var current_node = tree[shortcut_array[0]];
+        if(shortcut_array.length === 1){
+            if(current_node !== undefined && typeof(current_node) !== 'string'){
+                console.warn('[warning], you are overriting a long shortcut with a shorter one');
+            }
+            tree[shortcut_array[0]] = action_name;
+            return true;
+        } else {
+            if(typeof(current_node) === 'string'){
+                console.warn('you are trying to set a shortcut that will be shadowed'+
+                             'by a more specific one. Aborting for :', action_name, 'the follwing '+
+                             'will take precedence', current_node);
+                return false;
+            } else {
+                tree[shortcut_array[0]] = tree[shortcut_array[0]]||{};
+            }
+            this._set_leaf(shortcut_array.slice(1), action_name, tree[shortcut_array[0]]);
+            return true;
+        }
+    };
+
+    ShortcutManager.prototype.add_shortcut = function (shortcut, data, suppress_help_update) {
+        /**
+         * Add a action to be handled by shortcut manager. 
+         * 
+         * - `shortcut` should be a `Shortcut Sequence` of the for `Ctrl-Alt-C,Meta-X`...
+         * - `data` could be an `action name`, an `action` or a `function`.
+         *   if a `function` is passed it will be converted to an anonymous `action`. 
+         *
+         **/
+        var action_name = this.actions.get_name(data);
+        if (! action_name){
+            throw('does nto know how to deal with ', data);
+        }
+        
         shortcut = normalize_shortcut(shortcut);
-        this._counts[shortcut] = 0;
-        this._shortcuts[shortcut] = data;
+        this.set_shortcut(shortcut, action_name);
+
         if (!suppress_help_update) {
             // update the keyboard shortcuts notebook help
             this.events.trigger('rebuild.QuickHelp');
@@ -183,6 +365,11 b' define(['
     };
 
     ShortcutManager.prototype.add_shortcuts = function (data) {
+        /**
+         * Convenient methods to call `add_shortcut(key, value)` on several items
+         * 
+         *  data : Dict of the form {key:value, ...}
+         **/
         for (var shortcut in data) {
             this.add_shortcut(shortcut, data[shortcut], true);
         }
@@ -191,55 +378,63 b' define(['
     };
 
     ShortcutManager.prototype.remove_shortcut = function (shortcut, suppress_help_update) {
+        /**
+         * Remove the binding of shortcut `sortcut` with its action.
+         * throw an error if trying to remove a non-exiting shortcut
+         **/
         shortcut = normalize_shortcut(shortcut);
-        delete this._counts[shortcut];
-        delete this._shortcuts[shortcut];
+        if( typeof(shortcut) === 'string'){
+            shortcut = shortcut.split(',');
+        }
+        this._remove_leaf(shortcut, this._shortcuts);
         if (!suppress_help_update) {
             // update the keyboard shortcuts notebook help
             this.events.trigger('rebuild.QuickHelp');
         }
     };
 
-    ShortcutManager.prototype.count_handler = function (shortcut, event, data) {
-        var that = this;
-        var c = this._counts;
-        var t = this._timers;
-        var timer = null;
-        if (c[shortcut] === data.count-1) {
-            c[shortcut] = 0;
-            timer = t[shortcut];
-            if (timer) {clearTimeout(timer); delete t[shortcut];}
-            return data.handler(event);
-        } else {
-            c[shortcut] = c[shortcut] + 1;
-            timer = setTimeout(function () {
-                c[shortcut] = 0;
-            }, that.delay);
-            t[shortcut] = timer;
-        }
-        return false;
-    };
+
 
     ShortcutManager.prototype.call_handler = function (event) {
+        /**
+         * Call the corresponding shortcut handler for a keyboard event
+         * @method call_handler
+         * @return {Boolean} `true|false`, `false` if no handler was found, otherwise the  value return by the handler. 
+         * @param event {event}
+         *
+         * given an event, call the corresponding shortcut. 
+         * return false is event wan handled, true otherwise 
+         * in any case returning false stop event propagation
+         **/
+
+
+        this.clearsoon();
+        if(only_modifier_event(event)){
+            return true;
+        }
         var shortcut = event_to_shortcut(event);
-        var data = this._shortcuts[shortcut];
-        if (data) {
-            var handler = data.handler;
-            if (handler) {
-                if (data.count === 1) {
-                    return handler(event);
-                } else if (data.count > 1) {
-                    return this.count_handler(shortcut, event, data);
-                }
-            }
+        this._queue.push(shortcut);
+        var action_name = this.get_shortcut(this._queue);
+
+        if (typeof(action_name) === 'undefined'|| action_name === null){
+            this.clearqueue();
+            return true;
         }
-        return true;
+        
+        if (this.actions.exists(action_name)) {
+            event.preventDefault();
+            this.clearqueue();
+            return this.actions.call(action_name, event);
+        }
+
+        return false;
     };
 
+
     ShortcutManager.prototype.handles = function (event) {
         var shortcut = event_to_shortcut(event);
-        var data = this._shortcuts[shortcut];
-        return !( data === undefined || data.handler === undefined );
+        var action_name = this.get_shortcut(this._queue.concat(shortcut));
+        return (typeof(action_name) !== 'undefined');
     };
 
     var keyboard = {
@@ -249,10 +444,10 b' define(['
         normalize_key : normalize_key,
         normalize_shortcut : normalize_shortcut,
         shortcut_to_event : shortcut_to_event,
-        event_to_shortcut : event_to_shortcut
+        event_to_shortcut : event_to_shortcut,
     };
 
-    // For backwards compatability.
+    // For backwards compatibility.
     IPython.keyboard = keyboard;
 
     return keyboard;

IPython/html/static/base/js/namespace.js

@@ -3,6 +3,7 b''
 
 var IPython = IPython || {};
 define([], function(){
+    "use strict";
     IPython.version = "3.0.0-dev";
     return IPython;
 });

IPython/html/static/base/js/notificationwidget.js

@@ -7,6 +7,13 b' define(['
 ], function(IPython, $) {
     "use strict";
 
+    /**
+     * Construct a NotificationWidget object.
+     *
+     * @constructor
+     * @param {string} selector - a jQuery selector string for the
+     * notification widget element
+     */
     var NotificationWidget = function (selector) {
         this.selector = selector;
         this.timeout = null;
@@ -16,27 +23,41 b' define(['
             this.style();
         }
         this.element.hide();
-        var that = this;
-
         this.inner = $('<span/>');
         this.element.append(this.inner);
-
     };
 
+    /**
+     * Add the 'notification_widget' CSS class to the widget element.
+     *
+     * @method style
+     */
     NotificationWidget.prototype.style = function () {
         this.element.addClass('notification_widget');
     };
 
-    // msg : message to display
-    // timeout : time in ms before diseapearing
-    //
-    // if timeout <= 0
-    // click_callback : function called if user click on notification
-    // could return false to prevent the notification to be dismissed
+    /**
+     * Set the notification widget message to display for a certain
+     * amount of time (timeout).  The widget will be shown forever if
+     * timeout is <= 0 or undefined. If the widget is clicked while it
+     * is still displayed, execute an optional callback
+     * (click_callback). If the callback returns false, it will
+     * prevent the notification from being dismissed.
+     *
+     * Options:
+     *    class - CSS class name for styling
+     *    icon - CSS class name for the widget icon
+     *    title - HTML title attribute for the widget
+     *
+     * @method set_message
+     * @param {string} msg - The notification to display
+     * @param {integer} [timeout] - The amount of time in milliseconds to display the widget
+     * @param {function} [click_callback] - The function to run when the widget is clicked
+     * @param {Object} [options] - Additional options
+     */
     NotificationWidget.prototype.set_message = function (msg, timeout, click_callback, options) {
-        var options = options || {};
-        var callback = click_callback || function() {return true;};
-        var that = this;
+        options = options || {};
+
         // unbind potential previous callback
         this.element.unbind('click');
         this.inner.attr('class', options.icon);
@@ -47,52 +68,87 b' define(['
         // reset previous set style
         this.element.removeClass();
         this.style();
-        if (options.class){
-
-            this.element.addClass(options.class)
+        if (options.class) {
+            this.element.addClass(options.class);
         }
+
+        // clear previous timer
         if (this.timeout !== null) {
             clearTimeout(this.timeout);
             this.timeout = null;
         }
-        if (timeout !== undefined && timeout >=0) {
+
+        // set the timer if a timeout is given
+        var that = this;
+        if (timeout !== undefined && timeout >= 0) {
             this.timeout = setTimeout(function () {
                 that.element.fadeOut(100, function () {that.inner.text('');});
+                that.element.unbind('click');
                 that.timeout = null;
             }, timeout);
-        } else {
-            this.element.click(function() {
-                if( callback() !== false ) {
+        }
+
+        // bind the click callback if it is given
+        if (click_callback !== undefined) {
+            this.element.click(function () {
+                if (click_callback() !== false) {
                     that.element.fadeOut(100, function () {that.inner.text('');});
-                    that.element.unbind('click');
                 }
-                if (that.timeout !== undefined) {
-                    that.timeout = undefined;
+                that.element.unbind('click');
+                if (that.timeout !== null) {
                     clearTimeout(that.timeout);
+                    that.timeout = null;
                 }
             });
         }
     };
 
-
+    /**
+     * Display an information message (styled with the 'info'
+     * class). Arguments are the same as in set_message. Default
+     * timeout is 3500 milliseconds.
+     *
+     * @method info
+     */
     NotificationWidget.prototype.info = function (msg, timeout, click_callback, options) {
-        var options = options || {};
-        options.class = options.class +' info';
-        var timeout = timeout || 3500;
+        options = options || {};
+        options.class = options.class + ' info';
+        timeout = timeout || 3500;
         this.set_message(msg, timeout, click_callback, options);
-    }
+    };
+
+    /**
+     * Display a warning message (styled with the 'warning'
+     * class). Arguments are the same as in set_message. Messages are
+     * sticky by default.
+     *
+     * @method warning
+     */
     NotificationWidget.prototype.warning = function (msg, timeout, click_callback, options) {
-        var options = options || {};
-        options.class = options.class +' warning';
+        options = options || {};
+        options.class = options.class + ' warning';
         this.set_message(msg, timeout, click_callback, options);
-    }
+    };
+
+    /**
+     * Display a danger message (styled with the 'danger'
+     * class). Arguments are the same as in set_message. Messages are
+     * sticky by default.
+     *
+     * @method danger
+     */
     NotificationWidget.prototype.danger = function (msg, timeout, click_callback, options) {
-        var options = options || {};
-        options.class = options.class +' danger';
+        options = options || {};
+        options.class = options.class + ' danger';
         this.set_message(msg, timeout, click_callback, options);
-    }
-
+    };
 
+    /**
+     * Get the text of the widget message.
+     *
+     * @method get_message
+     * @return {string} - the message text
+     */
     NotificationWidget.prototype.get_message = function () {
         return this.inner.html();
     };

IPython/html/static/base/js/page.js

@@ -15,23 +15,29 b' define(['
     };
 
     Page.prototype.show = function () {
-        // The header and site divs start out hidden to prevent FLOUC.
-        // Main scripts should call this method after styling everything.
+        /**
+         * The header and site divs start out hidden to prevent FLOUC.
+         * Main scripts should call this method after styling everything.
+         */
         this.show_header();
         this.show_site();
     };
 
     Page.prototype.show_header = function () {
-        // The header and site divs start out hidden to prevent FLOUC.
-        // Main scripts should call this method after styling everything.
-        // TODO: selector are hardcoded, pass as constructor argument
+        /**
+         * The header and site divs start out hidden to prevent FLOUC.
+         * Main scripts should call this method after styling everything.
+         * TODO: selector are hardcoded, pass as constructor argument
+         */
         $('div#header').css('display','block');
     };
 
     Page.prototype.show_site = function () {
-        // The header and site divs start out hidden to prevent FLOUC.
-        // Main scripts should call this method after styling everything.
-        // TODO: selector are hardcoded, pass as constructor argument
+        /**
+         * The header and site divs start out hidden to prevent FLOUC.
+         * Main scripts should call this method after styling everything.
+         * TODO: selector are hardcoded, pass as constructor argument
+         */
         $('div#site').css('display','block');
     };
 

IPython/html/static/base/js/security.js

@@ -18,8 +18,10 b' define(['
     }
     
     var sanitizeAttribs = function (tagName, attribs, opt_naiveUriRewriter, opt_nmTokenPolicy, opt_logger) {
-        // add trusting data-attributes to the default sanitizeAttribs from caja
-        // this function is mostly copied from the caja source
+        /**
+         * add trusting data-attributes to the default sanitizeAttribs from caja
+         * this function is mostly copied from the caja source
+         */
         var ATTRIBS = caja.html4.ATTRIBS;
         for (var i = 0; i < attribs.length; i += 2) {
             var attribName = attribs[i];
@@ -34,9 +36,11 b' define(['
     };
     
     var sanitize_css = function (css, tagPolicy) {
-        // sanitize CSS
-        // like sanitize_html, but for CSS
-        // called by sanitize_stylesheets
+        /**
+         * sanitize CSS
+         * like sanitize_html, but for CSS
+         * called by sanitize_stylesheets
+         */
         return caja.sanitizeStylesheet(
             window.location.pathname,
             css,
@@ -51,8 +55,10 b' define(['
     };
     
     var sanitize_stylesheets = function (html, tagPolicy) {
-        // sanitize just the css in style tags in a block of html
-        // called by sanitize_html, if allow_css is true
+        /**
+         * sanitize just the css in style tags in a block of html
+         * called by sanitize_html, if allow_css is true
+         */
         var h = $("<div/>").append(html);
         var style_tags = h.find("style");
         if (!style_tags.length) {
@@ -66,9 +72,11 b' define(['
     };
     
     var sanitize_html = function (html, allow_css) {
-        // sanitize HTML
-        // if allow_css is true (default: false), CSS is sanitized as well.
-        // otherwise, CSS elements and attributes are simply removed.
+        /**
+         * sanitize HTML
+         * if allow_css is true (default: false), CSS is sanitized as well.
+         * otherwise, CSS elements and attributes are simply removed.
+         */
         var html4 = caja.html4;
 
         if (allow_css) {

IPython/html/static/base/js/utils.js

@@ -4,7 +4,8 b''
 define([
     'base/js/namespace',
     'jquery',
-], function(IPython, $){
+    'codemirror/lib/codemirror',
+], function(IPython, $, CodeMirror){
     "use strict";
     
     IPython.load_extensions = function () {
@@ -153,7 +154,9 b' define(['
 
 
     var uuid = function () {
-        // http://www.ietf.org/rfc/rfc4122.txt
+        /**
+         * http://www.ietf.org/rfc/rfc4122.txt
+         */
         var s = [];
         var hexDigits = "0123456789ABCDEF";
         for (var i = 0; i < 32; i++) {
@@ -271,11 +274,11 b' define(['
                 } else {
                     line = "background-color: ";
                 }
-                line = line + "rgb(" + r + "," + g + "," + b + ");"
-                if ( !attrs["style"] ) {
-                    attrs["style"] = line;
+                line = line + "rgb(" + r + "," + g + "," + b + ");";
+                if ( !attrs.style ) {
+                    attrs.style = line;
                 } else {
-                    attrs["style"] += " " + line;
+                    attrs.style += " " + line;
                 }
             }
         }
@@ -284,27 +287,36 b' define(['
     function ansispan(str) {
         // ansispan function adapted from github.com/mmalecki/ansispan (MIT License)
         // regular ansi escapes (using the table above)
+        var is_open = false;
         return str.replace(/\033\[(0?[01]|22|39)?([;\d]+)?m/g, function(match, prefix, pattern) {
             if (!pattern) {
                 // [(01|22|39|)m close spans
-                return "</span>";
-            }
-            // consume sequence of color escapes
-            var numbers = pattern.match(/\d+/g);
-            var attrs = {};
-            while (numbers.length > 0) {
-                _process_numbers(attrs, numbers);
-            }
-            
-            var span = "<span ";
-            for (var attr in attrs) {
-                var value = attrs[attr];
-                span = span + " " + attr + '="' + attrs[attr] + '"';
+                if (is_open) {
+                    is_open = false;
+                    return "</span>";
+                } else {
+                    return "";
+                }
+            } else {
+                is_open = true;
+
+                // consume sequence of color escapes
+                var numbers = pattern.match(/\d+/g);
+                var attrs = {};
+                while (numbers.length > 0) {
+                    _process_numbers(attrs, numbers);
+                }
+
+                var span = "<span ";
+                for (var attr in attrs) {
+                    var value = attrs[attr];
+                    span = span + " " + attr + '="' + attrs[attr] + '"';
+                }
+                return span + ">";
             }
-            return span + ">";
         });
-    };
-    
+    }
+
     // Transform ANSI color escape codes into HTML <span> tags with css
     // classes listed in the above ansi_colormap object. The actual color used
     // are set in the css file.
@@ -345,7 +357,9 b' define(['
     }
 
     var points_to_pixels = function (points) {
-        // A reasonably good way of converting between points and pixels.
+        /**
+         * A reasonably good way of converting between points and pixels.
+         */
         var test = $('<div style="display: none; width: 10000pt; padding:0; border:0;"></div>');
         $(body).append(test);
         var pixel_per_point = test.width()/10000;
@@ -354,10 +368,12 b' define(['
     };
     
     var always_new = function (constructor) {
-        // wrapper around contructor to avoid requiring `var a = new constructor()`
-        // useful for passing constructors as callbacks,
-        // not for programmer laziness.
-        // from http://programmers.stackexchange.com/questions/118798
+        /**
+         * wrapper around contructor to avoid requiring `var a = new constructor()`
+         * useful for passing constructors as callbacks,
+         * not for programmer laziness.
+         * from http://programmers.stackexchange.com/questions/118798
+         */
         return function () {
             var obj = Object.create(constructor.prototype);
             constructor.apply(obj, arguments);
@@ -366,7 +382,9 b' define(['
     };
 
     var url_path_join = function () {
-        // join a sequence of url components with '/'
+        /**
+         * join a sequence of url components with '/'
+         */
         var url = '';
         for (var i = 0; i < arguments.length; i++) {
             if (arguments[i] === '') {
@@ -382,36 +400,58 b' define(['
         return url;
     };
     
+    var url_path_split = function (path) {
+        /**
+         * Like os.path.split for URLs.
+         * Always returns two strings, the directory path and the base filename
+         */
+        
+        var idx = path.lastIndexOf('/');
+        if (idx === -1) {
+            return ['', path];
+        } else {
+            return [ path.slice(0, idx), path.slice(idx + 1) ];
+        }
+    };
+    
     var parse_url = function (url) {
-        // an `a` element with an href allows attr-access to the parsed segments of a URL
-        // a = parse_url("http://localhost:8888/path/name#hash")
-        // a.protocol = "http:"
-        // a.host     = "localhost:8888"
-        // a.hostname = "localhost"
-        // a.port     = 8888
-        // a.pathname = "/path/name"
-        // a.hash     = "#hash"
+        /**
+         * an `a` element with an href allows attr-access to the parsed segments of a URL
+         * a = parse_url("http://localhost:8888/path/name#hash")
+         * a.protocol = "http:"
+         * a.host     = "localhost:8888"
+         * a.hostname = "localhost"
+         * a.port     = 8888
+         * a.pathname = "/path/name"
+         * a.hash     = "#hash"
+         */
         var a = document.createElement("a");
         a.href = url;
         return a;
     };
     
     var encode_uri_components = function (uri) {
-        // encode just the components of a multi-segment uri,
-        // leaving '/' separators
+        /**
+         * encode just the components of a multi-segment uri,
+         * leaving '/' separators
+         */
         return uri.split('/').map(encodeURIComponent).join('/');
     };
     
     var url_join_encode = function () {
-        // join a sequence of url components with '/',
-        // encoding each component with encodeURIComponent
+        /**
+         * join a sequence of url components with '/',
+         * encoding each component with encodeURIComponent
+         */
         return encode_uri_components(url_path_join.apply(null, arguments));
     };
 
 
     var splitext = function (filename) {
-        // mimic Python os.path.splitext
-        // Returns ['base', '.ext']
+        /**
+         * mimic Python os.path.splitext
+         * Returns ['base', '.ext']
+         */
         var idx = filename.lastIndexOf('.');
         if (idx > 0) {
             return [filename.slice(0, idx), filename.slice(idx)];
@@ -422,20 +462,26 b' define(['
 
 
     var escape_html = function (text) {
-        // escape text to HTML
+        /**
+         * escape text to HTML
+         */
         return $("<div/>").text(text).html();
     };
 
 
     var get_body_data = function(key) {
-        // get a url-encoded item from body.data and decode it
-        // we should never have any encoded URLs anywhere else in code
-        // until we are building an actual request
+        /**
+         * get a url-encoded item from body.data and decode it
+         * we should never have any encoded URLs anywhere else in code
+         * until we are building an actual request
+         */
         return decodeURIComponent($('body').data(key));
     };
     
     var to_absolute_cursor_pos = function (cm, cursor) {
-        // get the absolute cursor position from CodeMirror's col, ch
+        /**
+         * get the absolute cursor position from CodeMirror's col, ch
+         */
         if (!cursor) {
             cursor = cm.getCursor();
         }
@@ -447,7 +493,9 b' define(['
     };
     
     var from_absolute_cursor_pos = function (cm, cursor_pos) {
-        // turn absolute cursor postion into CodeMirror col, ch cursor
+        /**
+         * turn absolute cursor postion into CodeMirror col, ch cursor
+         */
         var i, line;
         var offset = 0;
         for (i = 0, line=cm.getLine(i); line !== undefined; i++, line=cm.getLine(i)) {
@@ -495,12 +543,16 b' define(['
     })();
 
     var is_or_has = function (a, b) {
-        // Is b a child of a or a itself?
+        /**
+         * Is b a child of a or a itself?
+         */
         return a.has(b).length !==0 || a.is(b);
     };
 
     var is_focused = function (e) {
-        // Is element e, or one of its children focused?
+        /**
+         * Is element e, or one of its children focused?
+         */
         e = $(e);
         var target = $(document.activeElement);
         if (target.length > 0) {
@@ -521,21 +573,198 b' define(['
     };
     
     var ajax_error_msg = function (jqXHR) {
-        // Return a JSON error message if there is one,
-        // otherwise the basic HTTP status text.
-        if (jqXHR.responseJSON && jqXHR.responseJSON.message) {
+        /**
+         * Return a JSON error message if there is one,
+         * otherwise the basic HTTP status text.
+         */
+        if (jqXHR.responseJSON && jqXHR.responseJSON.traceback) {
+            return jqXHR.responseJSON.traceback;
+        } else if (jqXHR.responseJSON && jqXHR.responseJSON.message) {
             return jqXHR.responseJSON.message;
         } else {
             return jqXHR.statusText;
         }
-    }
+    };
     var log_ajax_error = function (jqXHR, status, error) {
-        // log ajax failures with informative messages
+        /**
+         * log ajax failures with informative messages
+         */
         var msg = "API request failed (" + jqXHR.status + "): ";
         console.log(jqXHR);
         msg += ajax_error_msg(jqXHR);
         console.log(msg);
     };
+    
+    var requireCodeMirrorMode = function (mode, callback, errback) {
+        /**
+         * load a mode with requirejs
+         */
+        if (typeof mode != "string") mode = mode.name;
+        if (CodeMirror.modes.hasOwnProperty(mode)) {
+            callback(CodeMirror.modes.mode);
+            return;
+        }
+        require([
+                // might want to use CodeMirror.modeURL here
+                ['codemirror/mode', mode, mode].join('/'),
+            ], callback, errback
+        );
+    };
+    
+    /** Error type for wrapped XHR errors. */
+    var XHR_ERROR = 'XhrError';
+    
+    /**
+     * Wraps an AJAX error as an Error object.
+     */
+    var wrap_ajax_error = function (jqXHR, status, error) {
+        var wrapped_error = new Error(ajax_error_msg(jqXHR));
+        wrapped_error.name =  XHR_ERROR;
+        // provide xhr response
+        wrapped_error.xhr = jqXHR;
+        wrapped_error.xhr_status = status;
+        wrapped_error.xhr_error = error;
+        return wrapped_error;
+    };
+    
+    var promising_ajax = function(url, settings) {
+        /**
+         * Like $.ajax, but returning an ES6 promise. success and error settings
+         * will be ignored.
+         */
+        return new Promise(function(resolve, reject) {
+            settings.success = function(data, status, jqXHR) {
+                resolve(data);
+            };
+            settings.error = function(jqXHR, status, error) {
+                log_ajax_error(jqXHR, status, error);
+                reject(wrap_ajax_error(jqXHR, status, error));
+            };
+            $.ajax(url, settings);
+        });
+    };
+
+    var WrappedError = function(message, error){
+        /**
+         * Wrappable Error class
+         *
+         * The Error class doesn't actually act on `this`.  Instead it always
+         * returns a new instance of Error.  Here we capture that instance so we
+         * can apply it's properties to `this`.
+         */
+        var tmp = Error.apply(this, [message]);
+
+        // Copy the properties of the error over to this.
+        var properties = Object.getOwnPropertyNames(tmp);
+        for (var i = 0; i < properties.length; i++) {
+            this[properties[i]] = tmp[properties[i]];
+        }
+
+        // Keep a stack of the original error messages.
+        if (error instanceof WrappedError) {
+            this.error_stack = error.error_stack;
+        } else {
+            this.error_stack = [error];
+        }
+        this.error_stack.push(tmp);
+
+        return this;
+    };
+
+    WrappedError.prototype = Object.create(Error.prototype, {});
+
+
+    var load_class = function(class_name, module_name, registry) {
+        /**
+         * Tries to load a class
+         *
+         * Tries to load a class from a module using require.js, if a module 
+         * is specified, otherwise tries to load a class from the global 
+         * registry, if the global registry is provided.
+         */
+        return new Promise(function(resolve, reject) {
+
+            // Try loading the view module using require.js
+            if (module_name) {
+                require([module_name], function(module) {
+                    if (module[class_name] === undefined) {
+                        reject(new Error('Class '+class_name+' not found in module '+module_name));
+                    } else {
+                        resolve(module[class_name]);
+                    }
+                }, reject);
+            } else {
+                if (registry && registry[class_name]) {
+                    resolve(registry[class_name]);
+                } else {
+                    reject(new Error('Class '+class_name+' not found in registry '));
+                }
+            }
+        });
+    };
+
+    var resolve_promises_dict = function(d) {
+        /**
+         * Resolve a promiseful dictionary.
+         * Returns a single Promise.
+         */
+        var keys = Object.keys(d);
+        var values = [];
+        keys.forEach(function(key) {
+            values.push(d[key]);
+        });
+        return Promise.all(values).then(function(v) {
+            d = {};
+            for(var i=0; i<keys.length; i++) {
+                d[keys[i]] = v[i];
+            }
+            return d;
+        });
+    };
+
+    var WrappedError = function(message, error){
+        /**
+         * Wrappable Error class
+         *
+         * The Error class doesn't actually act on `this`.  Instead it always
+         * returns a new instance of Error.  Here we capture that instance so we
+         * can apply it's properties to `this`.
+         */
+        var tmp = Error.apply(this, [message]);
+
+        // Copy the properties of the error over to this.
+        var properties = Object.getOwnPropertyNames(tmp);
+        for (var i = 0; i < properties.length; i++) {
+            this[properties[i]] = tmp[properties[i]];
+        }
+
+        // Keep a stack of the original error messages.
+        if (error instanceof WrappedError) {
+            this.error_stack = error.error_stack;
+        } else {
+            this.error_stack = [error];
+        }
+        this.error_stack.push(tmp);
+
+        return this;
+    };
+
+    WrappedError.prototype = Object.create(Error.prototype, {});
+
+    var reject = function(message, log) {
+        /**
+         * Creates a wrappable Promise rejection function.
+         * 
+         * Creates a function that returns a Promise.reject with a new WrappedError
+         * that has the provided message and wraps the original error that 
+         * caused the promise to reject.
+         */
+        return function(error) { 
+            var wrapped_error = new WrappedError(message, error);
+            if (log) console.error(wrapped_error); 
+            return Promise.reject(wrapped_error); 
+        };
+    };
 
     var utils = {
         regex_split : regex_split,
@@ -546,6 +775,7 b' define(['
         points_to_pixels : points_to_pixels,
         get_body_data : get_body_data,
         parse_url : parse_url,
+        url_path_split : url_path_split,
         url_path_join : url_path_join,
         url_join_encode : url_join_encode,
         encode_uri_components : encode_uri_components,
@@ -561,6 +791,14 b' define(['
         mergeopt: mergeopt,
         ajax_error_msg : ajax_error_msg,
         log_ajax_error : log_ajax_error,
+        requireCodeMirrorMode : requireCodeMirrorMode,
+        XHR_ERROR : XHR_ERROR,
+        wrap_ajax_error : wrap_ajax_error,
+        promising_ajax : promising_ajax,
+        WrappedError: WrappedError,
+        load_class: load_class,
+        resolve_promises_dict: resolve_promises_dict,
+        reject: reject,
     };
 
     // Backwards compatability.

IPython/html/static/base/less/variables.less

@@ -8,6 +8,7 b''
 @breadcrumb-color: darken(@border_color, 30%);
 @blockquote-font-size: inherit;
 @modal-inner-padding: 15px;
+@grid-float-breakpoint: 540px;
 
 // Disable modal slide-in from top animation.
 .modal {

IPython/html/static/components

@@ -1,1 +1,1 b''
-Subproject commit b3909af1b61ca7a412481759fdb441ecdfb3ab66
+Subproject commit 87ff70d96567bf055eb94161a41e7b3e6da31b23

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

@@ -1,44 +1,39 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
+/**
+ *
+ *
+ * @module cell
+ * @namespace cell
+ * @class Cell
+ */
+
+
 define([
     'base/js/namespace',
     'jquery',
     'base/js/utils',
-], function(IPython, $, utils) {
+    'codemirror/lib/codemirror',
+    'codemirror/addon/edit/matchbrackets',
+    'codemirror/addon/edit/closebrackets',
+    'codemirror/addon/comment/comment'
+], function(IPython, $, utils, CodeMirror, cm_match, cm_closeb, cm_comment) {
     // TODO: remove IPython dependency here 
     "use strict";
 
-    // monkey patch CM to be able to syntax highlight cell magics
-    // bug reported upstream,
-    // see https://github.com/codemirror/CodeMirror/issues/670
-    if(CodeMirror.getMode(1,'text/plain').indent === undefined ){
-        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
-
     var Cell = function (options) {
-        // Constructor
-        //
-        // The Base `Cell` class from which to inherit.
-        //
-        // Parameters:
-        //  options: dictionary
-        //      Dictionary of keyword arguments.
-        //          events: $(Events) instance 
-        //          config: dictionary
-        //          keyboard_manager: KeyboardManager instance 
+        /* Constructor
+         *
+         * The Base `Cell` class from which to inherit.
+         * @constructor
+         * @param:
+         *  options: dictionary
+         *      Dictionary of keyword arguments.
+         *          events: $(Events) instance
+         *          config: dictionary
+         *          keyboard_manager: KeyboardManager instance
+         */
         options = options || {};
         this.keyboard_manager = options.keyboard_manager;
         this.events = options.events;
@@ -50,7 +45,20 b' define(['
         this.selected = false;
         this.rendered = false;
         this.mode = 'command';
-        this.metadata = {};
+
+        // Metadata property
+        var that = this;
+        this._metadata = {};
+        Object.defineProperty(this, 'metadata', {
+            get: function() { return that._metadata; },
+            set: function(value) {
+                that._metadata = value;
+                if (that.celltoolbar) {
+                    that.celltoolbar.rebuild();
+                }
+            }
+        });
+
         // load this from metadata later ?
         this.user_highlight = 'auto';
         this.cm_config = config.cm_config;
@@ -104,8 +112,10 b' define(['
     };
 
     Cell.prototype.init_classes = function () {
-        // Call after this.element exists to initialize the css classes
-        // related to selected, rendered and mode.
+        /**
+         * Call after this.element exists to initialize the css classes
+         * related to selected, rendered and mode.
+         */
         if (this.selected) {
             this.element.addClass('selected');
         } else {
@@ -157,6 +167,16 b' define(['
                 that.events.trigger('command_mode.Cell', {cell: that});
             });
         }
+
+        this.element.dblclick(function () {
+            if (that.selected === false) {
+                this.events.trigger('select.Cell', {'cell':that});
+            }
+            var cont = that.unrender();
+            if (cont) {
+                that.focus_editor();
+            }
+        });
     };
     
     /**
@@ -174,9 +194,22 b' define(['
     Cell.prototype.handle_codemirror_keyevent = function (editor, event) {
         var shortcuts = this.keyboard_manager.edit_shortcuts;
 
+        var cur = editor.getCursor();
+        if((cur.line !== 0 || cur.ch !==0) && event.keyCode === 38){
+            event._ipkmIgnore = true;
+        }
+        var nLastLine = editor.lastLine();
+        if ((event.keyCode === 40) &&
+             ((cur.line !== nLastLine) ||
+               (cur.ch !== editor.getLineHandle(nLastLine).text.length))
+           ) {
+            event._ipkmIgnore = true;
+        }
         // if this is an edit_shortcuts shortcut, the global keyboard/shortcut
         // manager will handle it
-        if (shortcuts.handles(event)) { return true; }
+        if (shortcuts.handles(event)) {
+            return true;
+        }
         
         return false;
     };
@@ -226,6 +259,14 b' define(['
     };
 
     /**
+     * should be overritten by subclass
+     * @method execute
+     */
+    Cell.prototype.execute = function () {
+        return;
+    };
+
+    /**
      * handle cell level logic when a cell is rendered
      * @method render
      * @return is the action being taken
@@ -267,9 +308,6 b' define(['
      * @return {Boolean} `true` if CodeMirror should ignore the event, `false` Otherwise
      */
     Cell.prototype.handle_keyevent = function (editor, event) {
-
-        // console.log('CM', this.mode, event.which, event.type)
-
         if (this.mode === 'command') {
             return true;
         } else if (this.mode === 'edit') {
@@ -360,7 +398,9 b' define(['
      * @method refresh
      */
     Cell.prototype.refresh = function () {
-        this.code_mirror.refresh();
+        if (this.code_mirror) {
+            this.code_mirror.refresh();
+        }
     };
 
     /**
@@ -385,12 +425,12 b' define(['
      **/
     Cell.prototype.toJSON = function () {
         var data = {};
-        data.metadata = this.metadata;
+        // deepcopy the metadata so copied cells don't share the same object
+        data.metadata = JSON.parse(JSON.stringify(this.metadata));
         data.cell_type = this.cell_type;
         return data;
     };
 
-
     /**
      * should be overritten by subclass
      * @method fromJSON
@@ -399,27 +439,39 b' define(['
         if (data.metadata !== undefined) {
             this.metadata = data.metadata;
         }
-        this.celltoolbar.rebuild();
     };
 
 
     /**
-     * can the cell be split into two cells
+     * can the cell be split into two cells (false if not deletable)
      * @method is_splittable
      **/
     Cell.prototype.is_splittable = function () {
-        return true;
+        return this.is_deletable();
     };
 
 
     /**
-     * can the cell be merged with other cells
+     * can the cell be merged with other cells (false if not deletable)
      * @method is_mergeable
      **/
     Cell.prototype.is_mergeable = function () {
-        return true;
+        return this.is_deletable();
     };
 
+    /**
+     * is the cell deletable? only false (undeletable) if
+     * metadata.deletable is explicitly false -- everything else
+     * counts as true
+     *
+     * @method is_deletable
+     **/
+    Cell.prototype.is_deletable = function () {
+        if (this.metadata.deletable === false) {
+            return false;
+        }
+        return true;
+    };
 
     /**
      * @return {String} - the text before the cursor
@@ -484,7 +536,10 b' define(['
      * @param {String|object|undefined} - CodeMirror mode | 'auto'
      **/
     Cell.prototype._auto_highlight = function (modes) {
-        //Here we handle manually selected modes
+        /**
+         *Here we handle manually selected modes
+         */
+        var that = this;
         var mode;
         if( this.user_highlight !== undefined &&  this.user_highlight != 'auto' )
         {
@@ -506,33 +561,34 b' define(['
                         return;
                     }
                     if (mode.search('magic_') !== 0) {
-                        this.code_mirror.setOption('mode', mode);
-                        CodeMirror.autoLoadMode(this.code_mirror, mode);
+                        utils.requireCodeMirrorMode(mode, function () {
+                            that.code_mirror.setOption('mode', mode);
+                        });
                         return;
                     }
                     var open = modes[mode].open || "%%";
                     var close = modes[mode].close || "%%end";
-                    var mmode = mode;
-                    mode = mmode.substr(6);
-                    if(current_mode == mode){
+                    var magic_mode = mode;
+                    mode = magic_mode.substr(6);
+                    if(current_mode == magic_mode){
                         return;
                     }
-                    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"
-                            }
-                        );
+                    utils.requireCodeMirrorMode(mode, function () {
+                        // create on the fly a mode that switch between
+                        // plain/text and something else, otherwise `%%` is
+                        // source of some highlight issues.
+                        CodeMirror.defineMode(magic_mode, function(config) {
+                            return CodeMirror.multiplexingMode(
+                                CodeMirror.getMode(config, 'text/plain'),
+                                // always set something on close
+                                {open: open, close: close,
+                                 mode: CodeMirror.getMode(config, mode),
+                                 delimStyle: "delimit"
+                                }
+                            );
+                        });
+                        that.code_mirror.setOption('mode', magic_mode);
                     });
-                    this.code_mirror.setOption('mode', mmode);
                     return;
                 }
             }
@@ -550,8 +606,76 b' define(['
         this.code_mirror.setOption('mode', default_mode);
     };
 
+    var UnrecognizedCell = function (options) {
+        /** Constructor for unrecognized cells */
+        Cell.apply(this, arguments);
+        this.cell_type = 'unrecognized';
+        this.celltoolbar = null;
+        this.data = {};
+        
+        Object.seal(this);
+    };
+
+    UnrecognizedCell.prototype = Object.create(Cell.prototype);
+    
+    
+    // cannot merge or split unrecognized cells
+    UnrecognizedCell.prototype.is_mergeable = function () {
+        return false;
+    };
+    
+    UnrecognizedCell.prototype.is_splittable = function () {
+        return false;
+    };
+    
+    UnrecognizedCell.prototype.toJSON = function () {
+        /**
+         * deepcopy the metadata so copied cells don't share the same object
+         */
+        return JSON.parse(JSON.stringify(this.data));
+    };
+
+    UnrecognizedCell.prototype.fromJSON = function (data) {
+        this.data = data;
+        if (data.metadata !== undefined) {
+            this.metadata = data.metadata;
+        } else {
+            data.metadata = this.metadata;
+        }
+        this.element.find('.inner_cell').find("a").text("Unrecognized cell type: " + data.cell_type);
+    };
+    
+    UnrecognizedCell.prototype.create_element = function () {
+        Cell.prototype.create_element.apply(this, arguments);
+        var cell = this.element = $("<div>").addClass('cell unrecognized_cell');
+        cell.attr('tabindex','2');
+
+        var prompt = $('<div/>').addClass('prompt input_prompt');
+        cell.append(prompt);
+        var inner_cell = $('<div/>').addClass('inner_cell');
+        inner_cell.append(
+            $("<a>")
+                .attr("href", "#")
+                .text("Unrecognized cell type")
+        );
+        cell.append(inner_cell);
+        this.element = cell;
+    };
+    
+    UnrecognizedCell.prototype.bind_events = function () {
+        Cell.prototype.bind_events.apply(this, arguments);
+        var cell = this;
+        
+        this.element.find('.inner_cell').find("a").click(function () {
+            cell.events.trigger('unrecognized_cell.Cell', {cell: cell})
+        });
+    };
+
     // Backwards compatibility.
     IPython.Cell = Cell;
 
-    return {'Cell': Cell};
+    return {
+        Cell: Cell,
+        UnrecognizedCell: UnrecognizedCell
+    };
 });

IPython/html/static/notebook/js/celltoolbar.js

@@ -9,17 +9,19 b' define(['
     "use strict";
 
     var CellToolbar = function (options) {
-        // Constructor
-        //
-        // Parameters:
-        //  options: dictionary
-        //      Dictionary of keyword arguments.
-        //          events: $(Events) instance 
-        //          cell: Cell instance
-        //          notebook: Notebook instance 
-        //
-        //  TODO: This leaks, when cell are deleted
-        //  There is still a reference to each celltoolbars. 
+        /**
+         * Constructor
+         *
+         * Parameters:
+         *  options: dictionary
+         *      Dictionary of keyword arguments.
+         *          events: $(Events) instance 
+         *          cell: Cell instance
+         *          notebook: Notebook instance 
+         *
+         *  TODO: This leaks, when cell are deleted
+         *  There is still a reference to each celltoolbars.
+         */
         CellToolbar._instances.push(this);
         this.notebook = options.notebook;
         this.cell = options.cell;
@@ -114,7 +116,7 b' define(['
      * @param name {String} name to use to refer to the callback. It is advised to use a prefix with the name
      * for easier sorting and avoid collision
      * @param callback {function(div, cell)} callback that will be called to generate the ui element
-     * @param [cell_types] {List of String|undefined} optional list of cell types. If present the UI element
+     * @param [cell_types] {List_of_String|undefined} optional list of cell types. If present the UI element
      * will be added only to cells of types in the list.
      *
      *
@@ -163,7 +165,7 b' define(['
      * @method register_preset
      * @param name {String} name to use to refer to the preset. It is advised to use a prefix with the name
      * for easier sorting and avoid collision
-     * @param  preset_list {List of String} reverse order of the button in the toolbar. Each String of the list
+     * @param  preset_list {List_of_String} reverse order of the button in the toolbar. Each String of the list
      *          should correspond to a name of a registerd callback.
      *
      * @private
@@ -248,9 +250,11 b' define(['
      * @method rebuild
      */
     CellToolbar.prototype.rebuild = function(){
-        // strip evrything from the div
-        // which is probably inner_element
-        // or this.element.
+        /**
+         * strip evrything from the div
+         * which is probably inner_element
+         * or this.element.
+         */
         this.inner_element.empty();
         this.ui_controls_list = [];
 
@@ -288,8 +292,6 b' define(['
     };
 
 
-    /**
-     */
     CellToolbar.utils = {};
 
 
@@ -385,7 +387,7 b' define(['
      * @method utils.select_ui_generator
      * @static
      *
-     * @param list_list {list of sublist} List of sublist of metadata value and name in the dropdown list.
+     * @param list_list {list_of_sublist} List of sublist of metadata value and name in the dropdown list.
      *        subslit shoud contain 2 element each, first a string that woul be displayed in the dropdown list,
      *        and second the corresponding value to  be passed to setter/return by getter. the corresponding value 
      *        should not be "undefined" or behavior can be unexpected.

IPython/html/static/notebook/js/celltoolbarpresets/example.js

@@ -119,7 +119,9 b' define(['
                 width: 650,
                 modal: true,
                 close: function() {
-                    //cleanup on close
+                    /**
+                     *cleanup on close
+                     */
                     $(this).remove();
                 }
         });

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

@@ -1,5 +1,13 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
+/**
+ *
+ *
+ * @module codecell
+ * @namespace codecell
+ * @class CodeCell
+ */
+
 
 define([
     'base/js/namespace',
@@ -10,8 +18,12 b' define(['
     'notebook/js/outputarea',
     'notebook/js/completer',
     'notebook/js/celltoolbar',
-], function(IPython, $, utils, keyboard, cell, outputarea, completer, celltoolbar) {
+    'codemirror/lib/codemirror',
+    'codemirror/mode/python/python',
+    'notebook/js/codemirror-ipython'
+], function(IPython, $, utils, keyboard, cell, outputarea, completer, celltoolbar, CodeMirror, cmpython, cmip) {
     "use strict";
+    
     var Cell = cell.Cell;
 
     /* local util for codemirror */
@@ -41,21 +53,23 b' define(['
     var keycodes = keyboard.keycodes;
 
     var CodeCell = function (kernel, options) {
-        // Constructor
-        //
-        // A Cell conceived to write code.
-        //
-        // Parameters:
-        //  kernel: Kernel instance
-        //      The kernel doesn't have to be set at creation time, in that case
-        //      it will be null and set_kernel has to be called later.
-        //  options: dictionary
-        //      Dictionary of keyword arguments.
-        //          events: $(Events) instance 
-        //          config: dictionary
-        //          keyboard_manager: KeyboardManager instance 
-        //          notebook: Notebook instance
-        //          tooltip: Tooltip instance
+        /**
+         * Constructor
+         *
+         * A Cell conceived to write code.
+         *
+         * Parameters:
+         *  kernel: Kernel instance
+         *      The kernel doesn't have to be set at creation time, in that case
+         *      it will be null and set_kernel has to be called later.
+         *  options: dictionary
+         *      Dictionary of keyword arguments.
+         *          events: $(Events) instance 
+         *          config: dictionary
+         *          keyboard_manager: KeyboardManager instance 
+         *          notebook: Notebook instance
+         *          tooltip: Tooltip instance
+         */
         this.kernel = kernel || null;
         this.notebook = options.notebook;
         this.collapsed = false;
@@ -68,15 +82,28 b' define(['
         this.input_prompt_number = null;
         this.celltoolbar = null;
         this.output_area = null;
+        // Keep a stack of the 'active' output areas (where active means the 
+        // output area that recieves output).  When a user activates an output
+        // area, it gets pushed to the stack.  Then, when the output area is
+        // deactivated, it's popped from the stack.  When the stack is empty,
+        // the cell's output area is used.
+        this.active_output_areas = [];
+        var that = this;
+        Object.defineProperty(this, 'active_output_area', {
+            get: function() {
+                if (that.active_output_areas && that.active_output_areas.length > 0) {
+                    return that.active_output_areas[that.active_output_areas.length-1];
+                } else {
+                    return that.output_area;
+                }
+            },
+        });
+
         this.last_msg_id = null;
         this.completer = null;
 
 
-        var cm_overwrite_options  = {
-            onKeyEvent: $.proxy(this.handle_keyevent,this)
-        };
-
-        var config = utils.mergeopt(CodeCell, this.config, {cm_config: cm_overwrite_options});
+        var config = utils.mergeopt(CodeCell, this.config);
         Cell.apply(this,[{
             config: config, 
             keyboard_manager: options.keyboard_manager, 
@@ -84,8 +111,6 b' define(['
 
         // Attributes we want to override in this subclass.
         this.cell_type = "code";
-
-        var that = this;
         this.element.focusout(
             function() { that.auto_highlight(); }
         );
@@ -102,15 +127,30 b' define(['
             },
             mode: 'ipython',
             theme: 'ipython',
-            matchBrackets: true,
-             // don't auto-close strings because of CodeMirror #2385
-            autoCloseBrackets: "()[]{}"
+            matchBrackets: true
         }
     };
 
     CodeCell.msg_cells = {};
 
-    CodeCell.prototype = new Cell();
+    CodeCell.prototype = Object.create(Cell.prototype);
+
+    /**
+     * @method push_output_area
+     */
+    CodeCell.prototype.push_output_area = function (output_area) {
+        this.active_output_areas.push(output_area);
+    };
+
+    /**
+     * @method pop_output_area
+     */
+    CodeCell.prototype.pop_output_area = function (output_area) {
+        var index = this.active_output_areas.lastIndexOf(output_area);
+        if (index > -1) {
+            this.active_output_areas.splice(index, 1);
+        }
+    };
 
     /**
      * @method auto_highlight
@@ -135,6 +175,7 b' define(['
         inner_cell.append(this.celltoolbar.element);
         var input_area = $('<div/>').addClass('input_area');
         this.code_mirror = new CodeMirror(input_area.get(0), this.cm_config);
+        this.code_mirror.on('keydown', $.proxy(this.handle_keyevent,this))
         $(this.code_mirror.getInputField()).attr("spellcheck", "false");
         inner_cell.append(input_area);
         input.append(prompt).append(inner_cell);
@@ -187,6 +228,7 b' define(['
      *  true = ignore, false = don't ignore.
      *  @method handle_codemirror_keyevent
      */
+
     CodeCell.prototype.handle_codemirror_keyevent = function (editor, event) {
 
         var that = this;
@@ -220,10 +262,11 b' define(['
             }
             // If we closed the tooltip, don't let CM or the global handlers
             // handle this event.
-            event.stop();
+            event.codemirrorIgnore = true;
+            event.preventDefault();
             return true;
         } else if (event.keyCode === keycodes.tab && event.type === 'keydown' && event.shiftKey) {
-                if (editor.somethingSelected()){
+                if (editor.somethingSelected() || editor.getSelections().length !== 1){
                     var anchor = editor.getCursor("anchor");
                     var head = editor.getCursor("head");
                     if( anchor.line != head.line){
@@ -231,12 +274,15 b' define(['
                     }
                 }
                 this.tooltip.request(that);
-                event.stop();
+                event.codemirrorIgnore = true;
+                event.preventDefault();
                 return true;
         } else if (event.keyCode === keycodes.tab && event.type == 'keydown') {
             // Tab completion.
             this.tooltip.remove_and_cancel_tooltip();
-            if (editor.somethingSelected()) {
+
+            // completion does not work on multicursor, it might be possible though in some cases
+            if (editor.somethingSelected() || editor.getSelections().length > 1) {
                 return false;
             }
             var pre_cursor = editor.getRange({line:cur.line,ch:0},cur);
@@ -245,7 +291,8 b' define(['
                 // is empty.  In this case, let CodeMirror handle indentation.
                 return false;
             } else {
-                event.stop();
+                event.codemirrorIgnore = true;
+                event.preventDefault();
                 this.completer.startCompletion();
                 return true;
             }
@@ -267,7 +314,12 b' define(['
      * @method execute
      */
     CodeCell.prototype.execute = function () {
-        this.output_area.clear_output();
+        if (!this.kernel || !this.kernel.is_connected()) {
+            console.log("Can't execute, kernel is not connected.");
+            return;
+        }
+
+        this.active_output_area.clear_output();
         
         // Clear widget area
         this.widget_subarea.html('');
@@ -288,6 +340,8 b' define(['
             delete CodeCell.msg_cells[old_msg_id];
         }
         CodeCell.msg_cells[this.last_msg_id] = this;
+        this.render();
+        this.events.trigger('execute.CodeCell', {cell: this});
     };
     
     /**
@@ -295,6 +349,7 b' define(['
      * @method get_callbacks
      */
     CodeCell.prototype.get_callbacks = function () {
+        var that = this;
         return {
             shell : {
                 reply : $.proxy(this._handle_execute_reply, this),
@@ -304,8 +359,12 b' define(['
                 }
             },
             iopub : {
-                output : $.proxy(this.output_area.handle_output, this.output_area),
-                clear_output : $.proxy(this.output_area.handle_clear_output, this.output_area),
+                output : function() { 
+                    that.active_output_area.handle_output.apply(that.active_output_area, arguments);
+                }, 
+                clear_output : function() { 
+                    that.active_output_area.handle_clear_output.apply(that.active_output_area, arguments);
+                }, 
             },
             input : $.proxy(this._handle_input_request, this)
         };
@@ -339,7 +398,7 b' define(['
      * @private
      */
     CodeCell.prototype._handle_input_request = function (msg) {
-        this.output_area.append_raw_input(msg);
+        this.active_output_area.append_raw_input(msg);
     };
 
 
@@ -360,11 +419,6 b' define(['
         return cont;
     };
     
-    CodeCell.prototype.unrender = function () {
-        // CodeCell is always rendered
-        return false;
-    };
-
     CodeCell.prototype.select_all = function () {
         var start = {line: 0, ch: 0};
         var nlines = this.code_mirror.lineCount();
@@ -375,13 +429,11 b' define(['
 
 
     CodeCell.prototype.collapse_output = function () {
-        this.collapsed = true;
         this.output_area.collapse();
     };
 
 
     CodeCell.prototype.expand_output = function () {
-        this.collapsed = false;
         this.output_area.expand();
         this.output_area.unscroll_area();
     };
@@ -392,7 +444,6 b' define(['
     };
 
     CodeCell.prototype.toggle_output = function () {
-        this.collapsed = Boolean(1 - this.collapsed);
         this.output_area.toggle_output();
     };
 
@@ -403,7 +454,7 b' define(['
 
     CodeCell.input_prompt_classical = function (prompt_value, lines_number) {
         var ns;
-        if (prompt_value === undefined) {
+        if (prompt_value === undefined || prompt_value === null) {
             ns = "&nbsp;";
         } else {
             ns = encodeURIComponent(prompt_value);
@@ -450,7 +501,7 b' define(['
 
 
     CodeCell.prototype.clear_output = function (wait) {
-        this.output_area.clear_output(wait);
+        this.active_output_area.clear_output(wait);
         this.set_input_prompt();
     };
 
@@ -460,22 +511,18 b' define(['
     CodeCell.prototype.fromJSON = function (data) {
         Cell.prototype.fromJSON.apply(this, arguments);
         if (data.cell_type === 'code') {
-            if (data.input !== undefined) {
-                this.set_text(data.input);
+            if (data.source !== undefined) {
+                this.set_text(data.source);
                 // 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);
-            } else {
-                this.set_input_prompt();
-            }
-            this.output_area.trusted = data.trusted || false;
+            this.set_input_prompt(data.execution_count);
+            this.output_area.trusted = data.metadata.trusted || false;
             this.output_area.fromJSON(data.outputs);
-            if (data.collapsed !== undefined) {
-                if (data.collapsed) {
+            if (data.metadata.collapsed !== undefined) {
+                if (data.metadata.collapsed) {
                     this.collapse_output();
                 } else {
                     this.expand_output();
@@ -487,16 +534,17 b' define(['
 
     CodeCell.prototype.toJSON = function () {
         var data = Cell.prototype.toJSON.apply(this);
-        data.input = this.get_text();
+        data.source = this.get_text();
         // is finite protect against undefined and '*' value
         if (isFinite(this.input_prompt_number)) {
-            data.prompt_number = this.input_prompt_number;
+            data.execution_count = this.input_prompt_number;
+        } else {
+            data.execution_count = null;
         }
         var outputs = this.output_area.toJSON();
         data.outputs = outputs;
-        data.language = 'python';
-        data.trusted = this.output_area.trusted;
-        data.collapsed = this.collapsed;
+        data.metadata.trusted = this.output_area.trusted;
+        data.metadata.collapsed = this.output_area.collapsed;
         return data;
     };
 

IPython/html/static/notebook/js/codemirror-ipython.js

@@ -3,7 +3,18 b''
 // callback to auto-load python mode, which is more likely not the best things
 // to do, but at least the simple one for now.
 
-CodeMirror.requireMode('python',function(){
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object"){ // CommonJS
+    mod(require("codemirror/lib/codemirror"),
+        require("codemirror/mode/python/python")
+        );
+  } else if (typeof define == "function" && define.amd){ // AMD
+    define(["codemirror/lib/codemirror",
+            "codemirror/mode/python/python"], mod);
+  } else {// Plain browser env
+    mod(CodeMirror);
+  }
+})(function(CodeMirror) {
     "use strict";
 
     CodeMirror.defineMode("ipython", function(conf, parserConf) {

IPython/html/static/notebook/js/codemirror-ipythongfm.js

@@ -1,44 +1,62 b''
-// IPython GFM (GitHub Flavored Markdown) mode is just a slightly altered GFM 
-// Mode with support for latex. 
+// IPython GFM (GitHub Flavored Markdown) mode is just a slightly altered GFM
+// Mode with support for latex.
 //
-// Latex support was supported by Codemirror GFM as of 
+// Latex support was supported by Codemirror GFM as of
 //   https://github.com/codemirror/CodeMirror/pull/567
 // But was later removed in
 //   https://github.com/codemirror/CodeMirror/commit/d9c9f1b1ffe984aee41307f3e927f80d1f23590c
 
-CodeMirror.requireMode('gfm', function(){ 
-    CodeMirror.requireMode('stex', function(){ 
-        CodeMirror.defineMode("ipythongfm", function(config, parserConfig) {
-            
-            var gfm_mode = CodeMirror.getMode(config, "gfm");
-            var tex_mode = CodeMirror.getMode(config, "stex");
-            
-            return CodeMirror.multiplexingMode(
-                gfm_mode,
-                {
-                    open: "$", close: "$",
-                    mode: tex_mode,
-                    delimStyle: "delimit"
-                },
-                {
-                    open: "$$", close: "$$",
-                    mode: tex_mode,
-                    delimStyle: "delimit"
-                },
-                {
-                    open: "\\(", close: "\\)",
-                    mode: tex_mode,
-                    delimStyle: "delimit"
-                },
-                {
-                    open: "\\[", close: "\\]",
-                    mode: tex_mode,
-                    delimStyle: "delimit"
-                }
-                // .. more multiplexed styles can follow here
-            );
-        }, 'gfm');
-        
-        CodeMirror.defineMIME("text/x-ipythongfm", "ipythongfm");
-    });
-});
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object"){ // CommonJS
+    mod(require("codemirror/lib/codemirror")
+        ,require("codemirror/addon/mode/multiplex")
+        ,require("codemirror/mode/gfm/gfm")
+        ,require("codemirror/mode/stex/stex")
+        );
+  } else if (typeof define == "function" && define.amd){ // AMD
+    define(["codemirror/lib/codemirror"
+            ,"codemirror/addon/mode/multiplex"
+            ,"codemirror/mode/python/python"
+            ,"codemirror/mode/stex/stex"
+            ], mod);
+  } else {// Plain browser env
+    mod(CodeMirror);
+  }
+})( function(CodeMirror){
+    "use strict";
+
+    CodeMirror.defineMode("ipythongfm", function(config, parserConfig) {
+
+        var gfm_mode = CodeMirror.getMode(config, "gfm");
+        var tex_mode = CodeMirror.getMode(config, "stex");
+
+        return CodeMirror.multiplexingMode(
+            gfm_mode,
+            {
+                open: "$", close: "$",
+                mode: tex_mode,
+                delimStyle: "delimit"
+            },
+            {
+                // not sure this works as $$ is interpreted at (opening $, closing $, as defined just above)
+                open: "$$", close: "$$",
+                mode: tex_mode,
+                delimStyle: "delimit"
+            },
+            {
+                open: "\\(", close: "\\)",
+                mode: tex_mode,
+                delimStyle: "delimit"
+            },
+            {
+                open: "\\[", close: "\\]",
+                mode: tex_mode,
+                delimStyle: "delimit"
+            }
+            // .. more multiplexed styles can follow here
+        );
+    }, 'gfm');
+
+    CodeMirror.defineMIME("text/x-ipythongfm", "ipythongfm");
+})

IPython/html/static/notebook/js/completer.js

@@ -7,7 +7,8 b' define(['
     'base/js/utils',
     'base/js/keyboard',
     'notebook/js/contexthint',
-], function(IPython, $, utils, keyboard) {
+    'codemirror/lib/codemirror',
+], function(IPython, $, utils, keyboard, CodeMirror) {
     "use strict";
 
     // easier key mapping
@@ -82,18 +83,20 b' define(['
         this.cell = cell;
         this.editor = cell.code_mirror;
         var that = this;
-        events.on('status_busy.Kernel', function () {
+        events.on('kernel_busy.Kernel', function () {
             that.skip_kernel_completion = true;
         });
-        events.on('status_idle.Kernel', function () {
+        events.on('kernel_idle.Kernel', function () {
             that.skip_kernel_completion = false;
         });
     };
 
     Completer.prototype.startCompletion = function () {
-        // call for a 'first' completion, that will set the editor and do some
-        // special behavior like autopicking if only one completion available.
-        if (this.editor.somethingSelected()) return;
+        /**
+         * call for a 'first' completion, that will set the editor and do some
+         * special behavior like autopicking if only one completion available.
+         */
+        if (this.editor.somethingSelected()|| this.editor.getSelections().length > 1) return;
         this.done = false;
         // use to get focus back on opera
         this.carry_on_completion(true);
@@ -118,9 +121,11 b' define(['
      * shared start
      **/
     Completer.prototype.carry_on_completion = function (first_invocation) {
-        // Pass true as parameter if you want the completer to autopick when
-        // only one completion. This function is automatically reinvoked at
-        // each keystroke with first_invocation = false
+        /**
+         * Pass true as parameter if you want the completer to autopick when
+         * only one completion. This function is automatically reinvoked at
+         * each keystroke with first_invocation = false
+         */
         var cur = this.editor.getCursor();
         var line = this.editor.getLine(cur.line);
         var pre_cursor = this.editor.getRange({
@@ -142,7 +147,7 b' define(['
         }
 
         // We want a single cursor position.
-        if (this.editor.somethingSelected()) {
+        if (this.editor.somethingSelected()|| this.editor.getSelections().length > 1) {
             return;
         }
 
@@ -163,8 +168,10 b' define(['
     };
 
     Completer.prototype.finish_completing = function (msg) {
-        // let's build a function that wrap all that stuff into what is needed
-        // for the new completer:
+        /**
+         * let's build a function that wrap all that stuff into what is needed
+         * for the new completer:
+         */
         var content = msg.content;
         var start = content.cursor_start;
         var end = content.cursor_end;
@@ -316,11 +323,15 b' define(['
 
         // Enter
         if (code == keycodes.enter) {
-            CodeMirror.e_stop(event);
+            event.codemirrorIgnore = true;
+            event._ipkmIgnore = true;
+            event.preventDefault();
             this.pick();
         // Escape or backspace
         } else if (code == keycodes.esc || code == keycodes.backspace) {
-            CodeMirror.e_stop(event);
+            event.codemirrorIgnore = true;
+            event._ipkmIgnore = true;
+            event.preventDefault();
             this.close();
         } else if (code == keycodes.tab) {
             //all the fastforwarding operation,
@@ -339,7 +350,9 b' define(['
         } else if (code == keycodes.up || code == keycodes.down) {
             // need to do that to be able to move the arrow
             // when on the first or last line ofo a code cell
-            CodeMirror.e_stop(event);
+            event.codemirrorIgnore = true;
+            event._ipkmIgnore = true;
+            event.preventDefault();
 
             var options = this.sel.find('option');
             var index = this.sel[0].selectedIndex;
@@ -352,7 +365,7 b' define(['
             index = Math.min(Math.max(index, 0), options.length-1);
             this.sel[0].selectedIndex = index;
         } else if (code == keycodes.pageup || code == keycodes.pagedown) {
-            CodeMirror.e_stop(event);
+            event._ipkmIgnore = true;
 
             var options = this.sel.find('option');
             var index = this.sel[0].selectedIndex;
@@ -369,11 +382,13 b' define(['
     };
 
     Completer.prototype.keypress = function (event) {
-        // FIXME: This is a band-aid.
-        // on keypress, trigger insertion of a single character.
-        // This simulates the old behavior of completion as you type,
-        // before events were disconnected and CodeMirror stopped
-        // receiving events while the completer is focused.
+        /**
+         * FIXME: This is a band-aid.
+         * on keypress, trigger insertion of a single character.
+         * This simulates the old behavior of completion as you type,
+         * before events were disconnected and CodeMirror stopped
+         * receiving events while the completer is focused.
+         */
         
         var that = this;
         var code = event.keyCode;

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

@@ -1,6 +1,15 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
+/**
+ *
+ *
+ * @module config
+ * @namespace config
+ * @class Config
+ */
+
+
 define([], function() {
     "use strict";
 

IPython/html/static/notebook/js/contexthint.js

@@ -2,7 +2,7 b''
 // Distributed under the terms of the Modified BSD License.
 
 // highly adapted for codemiror jshint
-define([], function() {
+define(['codemirror/lib/codemirror'], function(CodeMirror) {
     "use strict";
 
     var forEach = function(arr, f) {

IPython/html/static/notebook/js/kernelselector.js

@@ -12,7 +12,7 b' define(['
         this.selector = selector;
         this.notebook = notebook;
         this.events = notebook.events;
-        this.current_selection = notebook.default_kernel_name;
+        this.current_selection = null;
         this.kernelspecs = {};
         if (this.selector !== undefined) {
             this.element = $(selector);
@@ -76,12 +76,12 b' define(['
             that.element.find("#current_kernel_spec").find('.kernel_name').text(data.display_name);
         });
         
-        this.events.on('started.Session', function(events, session) {
-            if (session.kernel_name !== that.current_selection) {
+        this.events.on('kernel_created.Session', function(event, data) {
+            if (data.kernel.name !== that.current_selection) {
                 // If we created a 'python' session, we only know if it's Python
                 // 3 or 2 on the server's reply, so we fire the event again to
                 // set things up.
-                var ks = that.kernelspecs[session.kernel_name];
+                var ks = that.kernelspecs[data.kernel.name];
                 that.events.trigger('spec_changed.Kernel', ks);
             }
         });

IPython/html/static/notebook/js/keyboardmanager.js

@@ -1,5 +1,12 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
+/**
+ *
+ *
+ * @module keyboardmanager
+ * @namespace keyboardmanager
+ * @class KeyboardManager
+ */
 
 define([
     'base/js/namespace',
@@ -9,491 +16,138 b' define(['
 ], function(IPython, $, utils, keyboard) {
     "use strict";
     
-    var browser = utils.browser[0];
-    var platform = utils.platform;
-
     // Main keyboard manager for the notebook
     var keycodes = keyboard.keycodes;
 
     var KeyboardManager = function (options) {
-        // Constructor
-        //
-        // Parameters:
-        //  options: dictionary
-        //      Dictionary of keyword arguments.
-        //          events: $(Events) instance
-        //          pager: Pager instance
+        /**
+         * A class to deal with keyboard event and shortcut
+         *
+         * @class KeyboardManager
+         * @constructor
+         * @param options {dict} Dictionary of keyword arguments :
+         *    @param options.events {$(Events)} instance 
+         *    @param options.pager: {Pager}  pager instance
+         */
         this.mode = 'command';
         this.enabled = true;
         this.pager = options.pager;
         this.quick_help = undefined;
         this.notebook = undefined;
+        this.last_mode = undefined;
         this.bind_events();
-        this.command_shortcuts = new keyboard.ShortcutManager(undefined, options.events);
+        this.env = {pager:this.pager};
+        this.actions = options.actions;
+        this.command_shortcuts = new keyboard.ShortcutManager(undefined, options.events, this.actions, this.env );
         this.command_shortcuts.add_shortcuts(this.get_default_common_shortcuts());
         this.command_shortcuts.add_shortcuts(this.get_default_command_shortcuts());
-        this.edit_shortcuts = new keyboard.ShortcutManager(undefined, options.events);
+        this.edit_shortcuts = new keyboard.ShortcutManager(undefined, options.events, this.actions, this.env);
         this.edit_shortcuts.add_shortcuts(this.get_default_common_shortcuts());
         this.edit_shortcuts.add_shortcuts(this.get_default_edit_shortcuts());
+        Object.seal(this);
     };
 
+
+
+
+    /**
+     * Return a dict of common shortcut
+     * @method get_default_common_shortcuts
+     *
+     * @example Example of returned shortcut
+     * ```
+     * 'shortcut-key': 'action-name'
+     * // a string representing the shortcut as dash separated value.
+     * // e.g. 'shift' , 'shift-enter', 'cmd-t'
+     *```
+     */
     KeyboardManager.prototype.get_default_common_shortcuts = function() {
-        var that = this;
-        var shortcuts = {
-            'shift' : {
-                help    : '',
-                help_index : '',
-                handler : function (event) {
-                    // ignore shift keydown
-                    return true;
-                }
-            },
-            'shift-enter' : {
-                help    : 'run cell, select below',
-                help_index : 'ba',
-                handler : function (event) {
-                    that.notebook.execute_cell_and_select_below();
-                    return false;
-                }
-            },
-            'ctrl-enter' : {
-                help    : 'run cell',
-                help_index : 'bb',
-                handler : function (event) {
-                    that.notebook.execute_cell();
-                    return false;
-                }
-            },
-            'alt-enter' : {
-                help    : 'run cell, insert below',
-                help_index : 'bc',
-                handler : function (event) {
-                    that.notebook.execute_cell_and_insert_below();
-                    return false;
-                }
-            }
+        return {
+            'shift'       : 'ipython.ignore',
+            'shift-enter' : 'ipython.run-select-next',
+            'ctrl-enter'  : 'ipython.execute-in-place',
+            'alt-enter'   : 'ipython.execute-and-insert-after',
+            // cmd on mac, ctrl otherwise
+            'cmdtrl-s'    : 'ipython.save-notebook',
         };
-
-        if (platform === 'MacOS') {
-            shortcuts['cmd-s'] =
-                {
-                    help    : 'save notebook',
-                    help_index : 'fb',
-                    handler : function (event) {
-                        that.notebook.save_checkpoint();
-                        event.preventDefault();
-                        return false;
-                    }
-                };
-        } else {
-            shortcuts['ctrl-s'] =
-                {
-                    help    : 'save notebook',
-                    help_index : 'fb',
-                    handler : function (event) {
-                        that.notebook.save_checkpoint();
-                        event.preventDefault();
-                        return false;
-                    }
-                };
-        }
-        return shortcuts;
     };
 
     KeyboardManager.prototype.get_default_edit_shortcuts = function() {
-        var that = this;
         return {
-            'esc' : {
-                help    : 'command mode',
-                help_index : 'aa',
-                handler : function (event) {
-                    that.notebook.command_mode();
-                    return false;
-                }
-            },
-            'ctrl-m' : {
-                help    : 'command mode',
-                help_index : 'ab',
-                handler : function (event) {
-                    that.notebook.command_mode();
-                    return false;
-                }
-            },
-            'up' : {
-                help    : '',
-                help_index : '',
-                handler : function (event) {
-                    var index = that.notebook.get_selected_index();
-                    var cell = that.notebook.get_cell(index);
-                    if (cell && cell.at_top() && index !== 0) {
-                        event.preventDefault();
-                        that.notebook.command_mode();
-                        that.notebook.select_prev();
-                        that.notebook.edit_mode();
-                        var cm = that.notebook.get_selected_cell().code_mirror;
-                        cm.setCursor(cm.lastLine(), 0);
-                        return false;
-                    } else if (cell) {
-                        var cm = cell.code_mirror;
-                        cm.execCommand('goLineUp');
-                        return false;
-                    }
-                }
-            },
-            'down' : {
-                help    : '',
-                help_index : '',
-                handler : function (event) {
-                    var index = that.notebook.get_selected_index();
-                    var cell = that.notebook.get_cell(index);
-                    if (cell.at_bottom() && index !== (that.notebook.ncells()-1)) {
-                        event.preventDefault();
-                        that.notebook.command_mode();
-                        that.notebook.select_next();
-                        that.notebook.edit_mode();
-                        var cm = that.notebook.get_selected_cell().code_mirror;
-                        cm.setCursor(0, 0);
-                        return false;
-                    } else {
-                        var cm = cell.code_mirror;
-                        cm.execCommand('goLineDown');
-                        return false;
-                    }
-                }
-            },
-            'ctrl-shift--' : {
-                help    : 'split cell',
-                help_index : 'ea',
-                handler : function (event) {
-                    that.notebook.split_cell();
-                    return false;
-                }
-            },
-            'ctrl-shift-subtract' : {
-                help    : '',
-                help_index : 'eb',
-                handler : function (event) {
-                    that.notebook.split_cell();
-                    return false;
-                }
-            },
+            'esc'                 : 'ipython.go-to-command-mode',
+            'ctrl-m'              : 'ipython.go-to-command-mode',
+            'up'                  : 'ipython.move-cursor-up-or-previous-cell',
+            'down'                : 'ipython.move-cursor-down-or-next-cell',
+            'ctrl-shift--'        : 'ipython.split-cell-at-cursor',
+            'ctrl-shift-subtract' : 'ipython.split-cell-at-cursor'
         };
     };
 
     KeyboardManager.prototype.get_default_command_shortcuts = function() {
-        var that = this;
         return {
-            'space': {
-                help: "Scroll down",
-                handler: function(event) {
-                    return that.notebook.scroll_manager.scroll(1);
-                },
-            },
-            'shift-space': {
-                help: "Scroll up",
-                handler: function(event) {
-                    return that.notebook.scroll_manager.scroll(-1);
-                },
-            },
-            'enter' : {
-                help    : 'edit mode',
-                help_index : 'aa',
-                handler : function (event) {
-                    that.notebook.edit_mode();
-                    return false;
-                }
-            },
-            'up' : {
-                help    : 'select previous cell',
-                help_index : 'da',
-                handler : function (event) {
-                    var index = that.notebook.get_selected_index();
-                    if (index !== 0 && index !== null) {
-                        that.notebook.select_prev();
-                        that.notebook.focus_cell();
-                    }
-                    return false;
-                }
-            },
-            'down' : {
-                help    : 'select next cell',
-                help_index : 'db',
-                handler : function (event) {
-                    var index = that.notebook.get_selected_index();
-                    if (index !== (that.notebook.ncells()-1) && index !== null) {
-                        that.notebook.select_next();
-                        that.notebook.focus_cell();
-                    }
-                    return false;
-                }
-            },
-            'k' : {
-                help    : 'select previous cell',
-                help_index : 'dc',
-                handler : function (event) {
-                    var index = that.notebook.get_selected_index();
-                    if (index !== 0 && index !== null) {
-                        that.notebook.select_prev();
-                        that.notebook.focus_cell();
-                    }
-                    return false;
-                }
-            },
-            'j' : {
-                help    : 'select next cell',
-                help_index : 'dd',
-                handler : function (event) {
-                    var index = that.notebook.get_selected_index();
-                    if (index !== (that.notebook.ncells()-1) && index !== null) {
-                        that.notebook.select_next();
-                        that.notebook.focus_cell();
-                    }
-                    return false;
-                }
-            },
-            'x' : {
-                help    : 'cut cell',
-                help_index : 'ee',
-                handler : function (event) {
-                    that.notebook.cut_cell();
-                    return false;
-                }
-            },
-            'c' : {
-                help    : 'copy cell',
-                help_index : 'ef',
-                handler : function (event) {
-                    that.notebook.copy_cell();
-                    return false;
-                }
-            },
-            'shift-v' : {
-                help    : 'paste cell above',
-                help_index : 'eg',
-                handler : function (event) {
-                    that.notebook.paste_cell_above();
-                    return false;
-                }
-            },
-            'v' : {
-                help    : 'paste cell below',
-                help_index : 'eh',
-                handler : function (event) {
-                    that.notebook.paste_cell_below();
-                    return false;
-                }
-            },
-            'd' : {
-                help    : 'delete cell (press twice)',
-                help_index : 'ej',
-                count: 2,
-                handler : function (event) {
-                    that.notebook.delete_cell();
-                    return false;
-                }
-            },
-            'a' : {
-                help    : 'insert cell above',
-                help_index : 'ec',
-                handler : function (event) {
-                    that.notebook.insert_cell_above();
-                    that.notebook.select_prev();
-                    that.notebook.focus_cell();
-                    return false;
-                }
-            },
-            'b' : {
-                help    : 'insert cell below',
-                help_index : 'ed',
-                handler : function (event) {
-                    that.notebook.insert_cell_below();
-                    that.notebook.select_next();
-                    that.notebook.focus_cell();
-                    return false;
-                }
-            },
-            'y' : {
-                help    : 'to code',
-                help_index : 'ca',
-                handler : function (event) {
-                    that.notebook.to_code();
-                    return false;
-                }
-            },
-            'm' : {
-                help    : 'to markdown',
-                help_index : 'cb',
-                handler : function (event) {
-                    that.notebook.to_markdown();
-                    return false;
-                }
-            },
-            'r' : {
-                help    : 'to raw',
-                help_index : 'cc',
-                handler : function (event) {
-                    that.notebook.to_raw();
-                    return false;
-                }
-            },
-            '1' : {
-                help    : 'to heading 1',
-                help_index : 'cd',
-                handler : function (event) {
-                    that.notebook.to_heading(undefined, 1);
-                    return false;
-                }
-            },
-            '2' : {
-                help    : 'to heading 2',
-                help_index : 'ce',
-                handler : function (event) {
-                    that.notebook.to_heading(undefined, 2);
-                    return false;
-                }
-            },
-            '3' : {
-                help    : 'to heading 3',
-                help_index : 'cf',
-                handler : function (event) {
-                    that.notebook.to_heading(undefined, 3);
-                    return false;
-                }
-            },
-            '4' : {
-                help    : 'to heading 4',
-                help_index : 'cg',
-                handler : function (event) {
-                    that.notebook.to_heading(undefined, 4);
-                    return false;
-                }
-            },
-            '5' : {
-                help    : 'to heading 5',
-                help_index : 'ch',
-                handler : function (event) {
-                    that.notebook.to_heading(undefined, 5);
-                    return false;
-                }
-            },
-            '6' : {
-                help    : 'to heading 6',
-                help_index : 'ci',
-                handler : function (event) {
-                    that.notebook.to_heading(undefined, 6);
-                    return false;
-                }
-            },
-            'o' : {
-                help    : 'toggle output',
-                help_index : 'gb',
-                handler : function (event) {
-                    that.notebook.toggle_output();
-                    return false;
-                }
-            },
-            'shift-o' : {
-                help    : 'toggle output scrolling',
-                help_index : 'gc',
-                handler : function (event) {
-                    that.notebook.toggle_output_scroll();
-                    return false;
-                }
-            },
-            's' : {
-                help    : 'save notebook',
-                help_index : 'fa',
-                handler : function (event) {
-                    that.notebook.save_checkpoint();
-                    return false;
-                }
-            },
-            'ctrl-j' : {
-                help    : 'move cell down',
-                help_index : 'eb',
-                handler : function (event) {
-                    that.notebook.move_cell_down();
-                    return false;
-                }
-            },
-            'ctrl-k' : {
-                help    : 'move cell up',
-                help_index : 'ea',
-                handler : function (event) {
-                    that.notebook.move_cell_up();
-                    return false;
-                }
-            },
-            'l' : {
-                help    : 'toggle line numbers',
-                help_index : 'ga',
-                handler : function (event) {
-                    that.notebook.cell_toggle_line_numbers();
-                    return false;
-                }
-            },
-            'i' : {
-                help    : 'interrupt kernel (press twice)',
-                help_index : 'ha',
-                count: 2,
-                handler : function (event) {
-                    that.notebook.kernel.interrupt();
-                    return false;
-                }
-            },
-            '0' : {
-                help    : 'restart kernel (press twice)',
-                help_index : 'hb',
-                count: 2,
-                handler : function (event) {
-                    that.notebook.restart_kernel();
-                    return false;
-                }
-            },
-            'h' : {
-                help    : 'keyboard shortcuts',
-                help_index : 'ge',
-                handler : function (event) {
-                    that.quick_help.show_keyboard_shortcuts();
-                    return false;
-                }
-            },
-            'z' : {
-                help    : 'undo last delete',
-                help_index : 'ei',
-                handler : function (event) {
-                    that.notebook.undelete_cell();
-                    return false;
-                }
-            },
-            'shift-m' : {
-                help    : 'merge cell below',
-                help_index : 'ek',
-                handler : function (event) {
-                    that.notebook.merge_cell_below();
-                    return false;
-                }
-            },
-            'q' : {
-                help    : 'close pager',
-                help_index : 'gd',
-                handler : function (event) {
-                    that.pager.collapse();
-                    return false;
-                }
-            },
+            'shift-space': 'ipython.scroll-up',
+            'shift-v' : 'ipython.paste-cell-before',
+            'shift-m' : 'ipython.merge-selected-cell-with-cell-after',
+            'shift-o' : 'ipython.toggle-output-scrolling-selected-cell',
+            'ctrl-j' : 'ipython.move-selected-cell-down',
+            'ctrl-k' : 'ipython.move-selected-cell-up',
+            'enter' : 'ipython.enter-edit-mode',
+            'space' : 'ipython.scroll-down',
+            'down' : 'ipython.select-next-cell',
+            'i,i' : 'ipython.interrupt-kernel',
+            '0,0' : 'ipython.restart-kernel',
+            'd,d' : 'ipython.delete-cell',
+            'esc': 'ipython.close-pager',
+            'up' : 'ipython.select-previous-cell',
+            'k' : 'ipython.select-previous-cell',
+            'j' : 'ipython.select-next-cell',
+            'x' : 'ipython.cut-selected-cell',
+            'c' : 'ipython.copy-selected-cell',
+            'v' : 'ipython.paste-cell-after',
+            'a' : 'ipython.insert-cell-before',
+            'b' : 'ipython.insert-cell-after',
+            'y' : 'ipython.change-selected-cell-to-code-cell',
+            'm' : 'ipython.change-selected-cell-to-markdown-cell',
+            'r' : 'ipython.change-selected-cell-to-raw-cell',
+            '1' : 'ipython.change-selected-cell-to-heading-1',
+            '2' : 'ipython.change-selected-cell-to-heading-2',
+            '3' : 'ipython.change-selected-cell-to-heading-3',
+            '4' : 'ipython.change-selected-cell-to-heading-4',
+            '5' : 'ipython.change-selected-cell-to-heading-5',
+            '6' : 'ipython.change-selected-cell-to-heading-6',
+            'o' : 'ipython.toggle-output-visibility-selected-cell',
+            's' : 'ipython.save-notebook',
+            'l' : 'ipython.toggle-line-number-selected-cell',
+            'h' : 'ipython.show-keyboard-shortcut-help-dialog',
+            'z' : 'ipython.undo-last-cell-deletion',
+            'q' : 'ipython.close-pager',
         };
     };
 
     KeyboardManager.prototype.bind_events = function () {
         var that = this;
         $(document).keydown(function (event) {
+            if(event._ipkmIgnore===true||(event.originalEvent||{})._ipkmIgnore===true){
+                return false;
+            }
             return that.handle_keydown(event);
         });
     };
 
+    KeyboardManager.prototype.set_notebook = function (notebook) {
+        this.notebook = notebook;
+        this.actions.extend_env({notebook:notebook});
+    };
+    
+    KeyboardManager.prototype.set_quickhelp = function (notebook) {
+        this.actions.extend_env({quick_help:notebook});
+    };
+
+
     KeyboardManager.prototype.handle_keydown = function (event) {
-        var notebook = this.notebook;
+        /**
+         *  returning false from this will stop event propagation
+         **/
 
         if (event.which === keycodes.esc) {
             // Intercept escape at highest level to avoid closing
@@ -503,8 +157,7 b' define(['
         
         if (!this.enabled) {
             if (event.which === keycodes.esc) {
-                // ESC
-                notebook.command_mode();
+                this.notebook.command_mode();
                 return false;
             }
             return true;
@@ -571,7 +224,8 b' define(['
         });
     };
 
-    // For backwards compatability.
+
+    // For backwards compatibility.
     IPython.KeyboardManager = KeyboardManager;
 
     return {'KeyboardManager': KeyboardManager};

IPython/html/static/notebook/js/main.js

@@ -5,6 +5,8 b' require(['
     'base/js/namespace',
     'jquery',
     'notebook/js/notebook',
+    'contents',
+    'services/config',
     'base/js/utils',
     'base/js/page',
     'notebook/js/layoutmanager',
@@ -16,15 +18,20 b' require(['
     'notebook/js/menubar',
     'notebook/js/notificationarea',
     'notebook/js/savewidget',
+    'notebook/js/actions',
     'notebook/js/keyboardmanager',
     'notebook/js/config',
     'notebook/js/kernelselector',
-    // only loaded, not used:
-    'custom/custom',
+    'codemirror/lib/codemirror',
+    'notebook/js/about',
+    // only loaded, not used, please keep sure this is loaded last
+    'custom/custom'
 ], function(
     IPython, 
     $,
     notebook, 
+    contents,
+    configmod,
     utils, 
     page, 
     layoutmanager, 
@@ -35,16 +42,24 b' require(['
     quickhelp, 
     menubar, 
     notificationarea, 
-    savewidget, 
+    savewidget,
+    actions,
     keyboardmanager,
     config,
-    kernelselector
+    kernelselector,
+    CodeMirror,
+    about,
+    // please keep sure that even if not used, this is loaded last
+    custom
     ) {
     "use strict";
 
+    // compat with old IPython, remove for IPython > 3.0
+    window.CodeMirror = CodeMirror;
+
     var common_options = {
+        ws_url : utils.get_body_data("wsUrl"),
         base_url : utils.get_body_data("baseUrl"),
-        ws_url : IPython.utils.get_body_data("wsUrl"),
         notebook_path : utils.get_body_data("notebookPath"),
         notebook_name : utils.get_body_data('notebookName')
     };
@@ -55,34 +70,46 b' require(['
     var pager = new pager.Pager('div#pager', 'div#pager_splitter', {
         layout_manager: layout_manager, 
         events: events});
+    var acts = new actions.init();
     var keyboard_manager = new keyboardmanager.KeyboardManager({
         pager: pager, 
-        events: events});
+        events: events, 
+        actions: acts });
     var save_widget = new savewidget.SaveWidget('span#save_widget', {
         events: events, 
         keyboard_manager: keyboard_manager});
+    var contents = new contents.Contents($.extend({
+        events: events},
+        common_options));
+    var config_section = new configmod.ConfigSection('notebook', common_options);
+    config_section.load();
     var notebook = new notebook.Notebook('div#notebook', $.extend({
         events: events,
         keyboard_manager: keyboard_manager,
         save_widget: save_widget,
+        contents: contents,
         config: user_config},
         common_options));
     var login_widget = new loginwidget.LoginWidget('span#login_widget', common_options);
     var toolbar = new maintoolbar.MainToolBar('#maintoolbar-container', {
         notebook: notebook, 
-        events: events}); 
+        events: events, 
+        actions: acts}); 
     var quick_help = new quickhelp.QuickHelp({
         keyboard_manager: keyboard_manager, 
         events: events,
         notebook: notebook});
+    keyboard_manager.set_notebook(notebook);
+    keyboard_manager.set_quickhelp(quick_help);
     var menubar = new menubar.MenuBar('#menubar', $.extend({
         notebook: notebook, 
+        contents: contents,
         layout_manager: layout_manager, 
         events: events, 
         save_widget: save_widget, 
         quick_help: quick_help}, 
         common_options));
-    var notification_area = new notificationarea.NotificationArea(
+    var notification_area = new notificationarea.NotebookNotificationArea(
         '#notification_area', {
         events: events, 
         save_widget: save_widget, 
@@ -122,6 +149,7 b' require(['
     IPython.page = page;
     IPython.layout_manager = layout_manager;
     IPython.notebook = notebook;
+    IPython.contents = contents;
     IPython.pager = pager;
     IPython.quick_help = quick_help;
     IPython.login_widget = login_widget;
@@ -134,6 +162,13 b' require(['
     IPython.tooltip = notebook.tooltip;
 
     events.trigger('app_initialized.NotebookApp');
-    notebook.load_notebook(common_options.notebook_name, common_options.notebook_path);
+    config_section.loaded.then(function() {
+        if (config_section.data.load_extensions) {
+            var nbextension_paths = Object.getOwnPropertyNames(
+                                        config_section.data.load_extensions);
+            IPython.load_extensions.apply(this, nbextension_paths);
+        }
+    });
+    notebook.load_notebook(common_options.notebook_path);
 
 });

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

@@ -10,14 +10,16 b' define(['
     "use strict";
 
     var MainToolBar = function (selector, options) {
-        // Constructor
-        //
-        // Parameters:
-        //  selector: string
-        //  options: dictionary
-        //      Dictionary of keyword arguments.
-        //          events: $(Events) instance
-        //          notebook: Notebook instance
+        /**
+         * Constructor
+         *
+         * Parameters:
+         *  selector: string
+         *  options: dictionary
+         *      Dictionary of keyword arguments.
+         *          events: $(Events) instance
+         *          notebook: Notebook instance
+         */
         toolbar.ToolBar.apply(this, arguments);
         this.events = options.events;
         this.notebook = options.notebook;
@@ -27,7 +29,7 b' define(['
         this.bind_events();
     };
 
-    MainToolBar.prototype = new toolbar.ToolBar();
+    MainToolBar.prototype = Object.create(toolbar.ToolBar.prototype);
 
     MainToolBar.prototype.construct = function () {
         var that = this;
@@ -108,7 +110,9 b' define(['
                     label : 'Run Cell',
                     icon : 'fa-play',
                     callback : function () {
-                        // emulate default shift-enter behavior
+                        /**
+                         * emulate default shift-enter behavior
+                         */
                         that.notebook.execute_cell_and_select_below();
                     }
                 },
@@ -117,7 +121,7 b' define(['
                     label : 'Interrupt',
                     icon : 'fa-stop',
                     callback : function () {
-                        that.notebook.session.interrupt_kernel();
+                        that.notebook.kernel.interrupt();
                         }
                 },
                 {
@@ -139,12 +143,7 b' define(['
                 .append($('<option/>').attr('value','code').text('Code'))
                 .append($('<option/>').attr('value','markdown').text('Markdown'))
                 .append($('<option/>').attr('value','raw').text('Raw NBConvert'))
-                .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','heading').text('Heading'))
             );
     };
 
@@ -190,24 +189,23 b' define(['
         
         this.element.find('#cell_type').change(function () {
             var cell_type = $(this).val();
-            if (cell_type === 'code') {
+            switch (cell_type) {
+            case 'code':
                 that.notebook.to_code();
-            } else if (cell_type === 'markdown')  {
+                break;
+            case 'markdown':
                 that.notebook.to_markdown();
-            } else if (cell_type === 'raw')  {
+                break;
+            case 'raw':
                 that.notebook.to_raw();
-            } else if (cell_type === 'heading1')  {
-                that.notebook.to_heading(undefined, 1);
-            } else if (cell_type === 'heading2')  {
-                that.notebook.to_heading(undefined, 2);
-            } else if (cell_type === 'heading3')  {
-                that.notebook.to_heading(undefined, 3);
-            } else if (cell_type === 'heading4')  {
-                that.notebook.to_heading(undefined, 4);
-            } else if (cell_type === 'heading5')  {
-                that.notebook.to_heading(undefined, 5);
-            } else if (cell_type === 'heading6')  {
-                that.notebook.to_heading(undefined, 6);
+                break;
+            case 'heading':
+                that.notebook._warn_heading();
+                that.notebook.to_heading();
+                that.element.find('#cell_type').val("markdown");
+                break;
+            default:
+                console.log("unrecognized cell type:", cell_type);
             }
         });
         this.events.on('selected_cell_type_changed.Notebook', function (event, data) {

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

@@ -2,36 +2,41 b''
 // Distributed under the terms of the Modified BSD License.
 
 define([
-    'base/js/namespace',
     'jquery',
+    'base/js/namespace',
+    'base/js/dialog',
     'base/js/utils',
     'notebook/js/tour',
     'bootstrap',
     'moment',
-], function(IPython, $, utils, tour, bootstrap, moment) {
+], function($, IPython, dialog, utils, tour, bootstrap, moment) {
     "use strict";
     
     var MenuBar = function (selector, options) {
-        // Constructor
-        //
-        // A MenuBar Class to generate the menubar of IPython notebook
-        //
-        // Parameters:
-        //  selector: string
-        //  options: dictionary
-        //      Dictionary of keyword arguments.
-        //          notebook: Notebook instance
-        //          layout_manager: LayoutManager instance
-        //          events: $(Events) instance
-        //          save_widget: SaveWidget instance
-        //          quick_help: QuickHelp instance
-        //          base_url : string
-        //          notebook_path : string
-        //          notebook_name : string
+        /**
+         * Constructor
+         *
+         * A MenuBar Class to generate the menubar of IPython notebook
+         *
+         * Parameters:
+         *  selector: string
+         *  options: dictionary
+         *      Dictionary of keyword arguments.
+         *          notebook: Notebook instance
+         *          contents: ContentManager instance
+         *          layout_manager: LayoutManager instance
+         *          events: $(Events) instance
+         *          save_widget: SaveWidget instance
+         *          quick_help: QuickHelp instance
+         *          base_url : string
+         *          notebook_path : string
+         *          notebook_name : string
+         */
         options = options || {};
         this.base_url = options.base_url || utils.get_body_data("baseUrl");
         this.selector = selector;
         this.notebook = options.notebook;
+        this.contents = options.contents;
         this.layout_manager = options.layout_manager;
         this.events = options.events;
         this.save_widget = options.save_widget;
@@ -66,33 +71,52 b' define(['
     MenuBar.prototype._nbconvert = function (format, download) {
         download = download || false;
         var notebook_path = this.notebook.notebook_path;
-        var notebook_name = this.notebook.notebook_name;
-        if (this.notebook.dirty) {
-            this.notebook.save_notebook({async : false});
-        }
         var url = utils.url_join_encode(
             this.base_url,
             'nbconvert',
             format,
-            notebook_path,
-            notebook_name
+            notebook_path
         ) + "?download=" + download.toString();
-
-        window.open(url);
+        
+        var w = window.open()
+        if (this.notebook.dirty) {
+            this.notebook.save_notebook().then(function() {
+                w.location = url;
+            });
+        } else {
+            w.location = url;
+        }
     };
 
     MenuBar.prototype.bind_events = function () {
-        //  File
+        /**
+         *  File
+         */
         var that = this;
         this.element.find('#new_notebook').click(function () {
-            that.notebook.new_notebook();
+            var w = window.open();
+            // Create a new notebook in the same path as the current
+            // notebook's path.
+            var parent = utils.url_path_split(that.notebook.notebook_path)[0];
+            that.contents.new_untitled(parent, {type: "notebook"}).then(
+                    function (data) {
+                        w.location = utils.url_join_encode(
+                                that.base_url, 'notebooks', data.path
+                            );
+                    },
+                    function(error) {
+                        w.close();
+                        dialog.modal({
+                            title : 'Creating Notebook Failed',
+                            body : "The error was: " + error.message,
+                            buttons : {'OK' : {'class' : 'btn-primary'}}
+                        });
+                    }
+                );
         });
         this.element.find('#open_notebook').click(function () {
-            window.open(utils.url_join_encode(
-                that.notebook.base_url,
-                'tree',
-                that.notebook.notebook_path
-            ));
+            var parent = utils.url_path_split(that.notebook.notebook_path)[0];
+            window.open(utils.url_join_encode(that.base_url, 'tree', parent));
         });
         this.element.find('#copy_notebook').click(function () {
             that.notebook.copy_notebook();
@@ -101,28 +125,18 b' define(['
         this.element.find('#download_ipynb').click(function () {
             var base_url = that.notebook.base_url;
             var notebook_path = that.notebook.notebook_path;
-            var notebook_name = that.notebook.notebook_name;
             if (that.notebook.dirty) {
                 that.notebook.save_notebook({async : false});
             }
             
-            var url = utils.url_join_encode(
-                base_url,
-                'files',
-                notebook_path,
-                notebook_name
-            );
-            window.location.assign(url);
+            var url = utils.url_join_encode(base_url, 'files', notebook_path);
+            window.open(url + '?download=1');
         });
         
         this.element.find('#print_preview').click(function () {
             that._nbconvert('html', false);
         });
 
-        this.element.find('#download_py').click(function () {
-            that._nbconvert('python', true);
-        });
-
         this.element.find('#download_html').click(function () {
             that._nbconvert('html', true);
         });
@@ -159,7 +173,9 b' define(['
         });
         this.element.find('#kill_and_exit').click(function () {
             var close_window = function () {
-                // allow closing of new tabs in Chromium, impossible in FF
+                /**
+                 * allow closing of new tabs in Chromium, impossible in FF
+                 */
                 window.open('', '_self', '');
                 window.close();
             };
@@ -246,24 +262,6 b' define(['
         this.element.find('#to_raw').click(function () {
             that.notebook.to_raw();
         });
-        this.element.find('#to_heading1').click(function () {
-            that.notebook.to_heading(undefined, 1);
-        });
-        this.element.find('#to_heading2').click(function () {
-            that.notebook.to_heading(undefined, 2);
-        });
-        this.element.find('#to_heading3').click(function () {
-            that.notebook.to_heading(undefined, 3);
-        });
-        this.element.find('#to_heading4').click(function () {
-            that.notebook.to_heading(undefined, 4);
-        });
-        this.element.find('#to_heading5').click(function () {
-            that.notebook.to_heading(undefined, 5);
-        });
-        this.element.find('#to_heading6').click(function () {
-            that.notebook.to_heading(undefined, 6);
-        });
         
         this.element.find('#toggle_current_output').click(function () {
             that.notebook.toggle_output();
@@ -287,11 +285,14 b' define(['
         
         // Kernel
         this.element.find('#int_kernel').click(function () {
-            that.notebook.session.interrupt_kernel();
+            that.notebook.kernel.interrupt();
         });
         this.element.find('#restart_kernel').click(function () {
             that.notebook.restart_kernel();
         });
+        this.element.find('#reconnect_kernel').click(function () {
+            that.notebook.kernel.reconnect();
+        });
         // Help
         if (this.tour) {
             this.element.find('#notebook_tour').click(function () {
@@ -313,6 +314,16 b' define(['
         this.events.on('checkpoint_created.Notebook', function (event, data) {
             that.update_restore_checkpoint(that.notebook.checkpoints);
         });
+        
+        this.events.on('notebook_loaded.Notebook', function() {
+            var langinfo = that.notebook.metadata.language_info || {};
+            that.update_nbconvert_script(langinfo);
+        });
+        
+        this.events.on('kernel_ready.Kernel', function(event, data) {
+            var langinfo = data.kernel.info_reply.language_info || {};
+            that.update_nbconvert_script(langinfo);
+        });
     };
 
     MenuBar.prototype.update_restore_checkpoint = function(checkpoints) {
@@ -345,6 +356,33 b' define(['
             );
         });
     };
+    
+    MenuBar.prototype.update_nbconvert_script = function(langinfo) {
+        /**
+         * Set the 'Download as foo' menu option for the relevant language.
+         */
+        var el = this.element.find('#download_script');
+        var that = this;
+        
+        // Set menu entry text to e.g. "Python (.py)"
+        var langname = (langinfo.name || 'Script')
+        langname = langname.charAt(0).toUpperCase()+langname.substr(1) // Capitalise
+        el.find('a').text(langname + ' ('+(langinfo.file_extension || 'txt')+')');
+        
+        // Unregister any previously registered handlers
+        el.off('click');
+        if (langinfo.nbconvert_exporter) {
+            // Metadata specifies a specific exporter, e.g. 'python'
+            el.click(function() {
+                that._nbconvert(langinfo.nbconvert_exporter, true);
+            });
+        } else {
+            // Use generic 'script' exporter
+            el.click(function() {
+                that._nbconvert('script', true);
+            });
+        }
+    };
 
     // Backwards compatability.
     IPython.MenuBar = MenuBar;