Merge pull request #1331 from ellisonbg/celltypes

Added plaintext and heading cells to the notebook UI and nbformat.

In the process we have updated the nbformat to v3 and integrated these new cell types into the new toolbar.

IPython/nbformat/v3/__init__.py

@@ -0,0 +1,74
+"""The main API for the v2 notebook format.
+
+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
+#-----------------------------------------------------------------------------
+
+from .nbbase import (
+    NotebookNode,
+    new_code_cell, new_text_cell, new_notebook, new_output, new_worksheet,
+    new_metadata, new_author, new_heading_cell
+)
+
+from .nbjson import reads as reads_json, writes as writes_json
+from .nbjson import reads as read_json, writes as write_json
+from .nbjson import to_notebook as to_notebook_json
+
+from .nbpy import reads as reads_py, writes as writes_py
+from .nbpy import reads as read_py, writes as write_py
+from .nbpy import to_notebook as to_notebook_py
+
+from .convert import convert_to_this_nbformat
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+
+def parse_filename(fname):
+    """Parse a notebook filename.
+
+    This function takes a notebook filename and returns the notebook
+    format (json/py) and the notebook name. This logic can be
+    summarized as follows:
+
+    * notebook.ipynb -> (notebook.ipynb, notebook, json)
+    * notebook.json  -> (notebook.json, notebook, json)
+    * notebook.py    -> (notebook.py, notebook, py)
+    * notebook       -> (notebook.ipynb, notebook, json)
+
+    Parameters
+    ----------
+    fname : unicode
+        The notebook filename. The filename can use a specific filename
+        extention (.ipynb, .json, .py) or none, in which case .ipynb will
+        be assumed.
+
+    Returns
+    -------
+    (fname, name, format) : (unicode, unicode, unicode)
+        The filename, notebook name and format.
+    """
+    if fname.endswith(u'.ipynb'):
+        format = u'json'
+    elif fname.endswith(u'.json'):
+        format = u'json'
+    elif fname.endswith(u'.py'):
+        format = u'py'
+    else:
+        fname = fname + u'.ipynb'
+        format = u'json'
+    name = fname.split('.')[0]
+    return fname, name, format
+

IPython/nbformat/v3/convert.py

@@ -0,0 +1,48
+"""Code for converting notebooks to and from the v2 format.
+
+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
+#-----------------------------------------------------------------------------
+
+from .nbbase import (
+    new_code_cell, new_text_cell, new_worksheet, new_notebook, new_output
+)
+
+from IPython.nbformat import v2
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+
+def convert_to_this_nbformat(nb, orig_version=2):
+    """Convert a notebook to the v2 format.
+
+    Parameters
+    ----------
+    nb : NotebookNode
+        The Python representation of the notebook to convert.
+    orig_version : int
+        The original version of the notebook to convert.
+    """
+    if orig_version == 1:
+        nb = v2.convert_to_this_nbformat(nb)
+        orig_version = 2
+    if orig_version == 2:
+        return nb
+    elif orig_version == 3:
+        return nb
+    else:
+        raise ValueError('Cannot convert a notebook from v%s to v3' % orig_version)
+

IPython/nbformat/v3/nbbase.py

@@ -0,0 +1,191
+"""The basic dict based notebook format.
+
+The Python representation of a notebook is a nested structure of
+dictionary subclasses that support attribute access
+(IPython.utils.ipstruct.Struct). The functions in this module are merely
+helpers to build the structs in the right form.
+
+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
+#-----------------------------------------------------------------------------
+
+import pprint
+import uuid
+
+from IPython.utils.ipstruct import Struct
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+
+class NotebookNode(Struct):
+    pass
+
+
+def from_dict(d):
+    if isinstance(d, dict):
+        newd = NotebookNode()
+        for k,v in d.items():
+            newd[k] = from_dict(v)
+        return newd
+    elif isinstance(d, (tuple, list)):
+        return [from_dict(i) for i in d]
+    else:
+        return d
+
+
+def new_output(output_type=None, output_text=None, output_png=None,
+    output_html=None, output_svg=None, output_latex=None, output_json=None,
+    output_javascript=None, output_jpeg=None, prompt_number=None,
+    etype=None, evalue=None, traceback=None):
+    """Create a new code cell with input and output"""
+    output = NotebookNode()
+    if output_type is not None:
+        output.output_type = unicode(output_type)
+
+    if output_type != 'pyerr':
+        if output_text is not None:
+            output.text = unicode(output_text)
+        if output_png is not None:
+            output.png = bytes(output_png)
+        if output_jpeg is not None:
+            output.jpeg = bytes(output_jpeg)
+        if output_html is not None:
+            output.html = unicode(output_html)
+        if output_svg is not None:
+            output.svg = unicode(output_svg)
+        if output_latex is not None:
+            output.latex = unicode(output_latex)
+        if output_json is not None:
+            output.json = unicode(output_json)
+        if output_javascript is not None:
+            output.javascript = unicode(output_javascript)
+
+    if output_type == u'pyout':
+        if prompt_number is not None:
+            output.prompt_number = int(prompt_number)
+
+    if output_type == u'pyerr':
+        if etype is not None:
+            output.etype = unicode(etype)
+        if evalue is not None:
+            output.evalue = unicode(evalue)
+        if traceback is not None:
+            output.traceback = [unicode(frame) for frame in list(traceback)]
+
+    return output
+
+
+def new_code_cell(input=None, prompt_number=None, outputs=None,
+    language=u'python', collapsed=False):
+    """Create a new code cell with input and output"""
+    cell = NotebookNode()
+    cell.cell_type = u'code'
+    if language is not None:
+        cell.language = unicode(language)
+    if input is not None:
+        cell.input = unicode(input)
+    if prompt_number is not None:
+        cell.prompt_number = int(prompt_number)
+    if outputs is None:
+        cell.outputs = []
+    else:
+        cell.outputs = outputs
+    if collapsed is not None:
+        cell.collapsed = bool(collapsed)
+
+    return cell
+
+def new_text_cell(cell_type, source=None, rendered=None):
+    """Create a new text cell."""
+    cell = NotebookNode()
+    if source is not None:
+        cell.source = unicode(source)
+    if rendered is not None:
+        cell.rendered = unicode(rendered)
+    cell.cell_type = cell_type
+    return cell
+
+
+def new_heading_cell(source=None, rendered=None, level=1):
+    """Create a new section cell with a given integer level."""
+    cell = NotebookNode()
+    cell.cell_type = u'heading'
+    if source is not None:
+        cell.source = unicode(source)
+    if rendered is not None:
+        cell.rendered = unicode(rendered)
+    cell.level = int(level)
+    return cell
+
+
+def new_worksheet(name=None, cells=None):
+    """Create a worksheet by name with with a list of cells."""
+    ws = NotebookNode()
+    if name is not None:
+        ws.name = unicode(name)
+    if cells is None:
+        ws.cells = []
+    else:
+        ws.cells = list(cells)
+    return ws
+
+
+def new_notebook(metadata=None, worksheets=None):
+    """Create a notebook by name, id and a list of worksheets."""
+    nb = NotebookNode()
+    nb.nbformat = 3
+    if worksheets is None:
+        nb.worksheets = []
+    else:
+        nb.worksheets = list(worksheets)
+    if metadata is None:
+        nb.metadata = new_metadata()
+    else:
+        nb.metadata = NotebookNode(metadata)
+    return nb
+
+
+def new_metadata(name=None, authors=None, license=None, created=None,
+    modified=None, gistid=None):
+    """Create a new metadata node."""
+    metadata = NotebookNode()
+    if name is not None:
+        metadata.name = unicode(name)
+    if authors is not None:
+        metadata.authors = list(authors)
+    if created is not None:
+        metadata.created = unicode(created)
+    if modified is not None:
+        metadata.modified = unicode(modified)
+    if license is not None:
+        metadata.license = unicode(license)
+    if gistid is not None:
+        metadata.gistid = unicode(gistid)
+    return metadata
+
+def new_author(name=None, email=None, affiliation=None, url=None):
+    """Create a new author."""
+    author = NotebookNode()
+    if name is not None:
+        author.name = unicode(name)
+    if email is not None:
+        author.email = unicode(email)
+    if affiliation is not None:
+        author.affiliation = unicode(affiliation)
+    if url is not None:
+        author.url = unicode(url)
+    return author
+

IPython/nbformat/v3/nbjson.py

@@ -0,0 +1,70
+"""Read and write notebooks in JSON format.
+
+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
+#-----------------------------------------------------------------------------
+
+import copy
+import json
+
+from .nbbase import from_dict
+from .rwbase import (
+    NotebookReader, NotebookWriter, restore_bytes, rejoin_lines, split_lines
+)
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+
+class BytesEncoder(json.JSONEncoder):
+    """A JSON encoder that accepts b64 (and other *ascii*) bytestrings."""
+    def default(self, obj):
+        if isinstance(obj, bytes):
+            return obj.decode('ascii')
+        return json.JSONEncoder.default(self, obj)
+
+
+class JSONReader(NotebookReader):
+
+    def reads(self, s, **kwargs):
+        nb = json.loads(s, **kwargs)
+        nb = self.to_notebook(nb, **kwargs)
+        return nb
+
+    def to_notebook(self, d, **kwargs):
+        return restore_bytes(rejoin_lines(from_dict(d)))
+
+
+class JSONWriter(NotebookWriter):
+
+    def writes(self, nb, **kwargs):
+        kwargs['cls'] = BytesEncoder
+        kwargs['indent'] = 1
+        kwargs['sort_keys'] = True
+        kwargs['separators'] = (',',': ')
+        if kwargs.pop('split_lines', True):
+            nb = split_lines(copy.deepcopy(nb))
+        return json.dumps(nb, **kwargs)
+    
+
+_reader = JSONReader()
+_writer = JSONWriter()
+
+reads = _reader.reads
+read = _reader.read
+to_notebook = _reader.to_notebook
+write = _writer.write
+writes = _writer.writes
+

IPython/nbformat/v3/nbpy.py

@@ -0,0 +1,200
+"""Read and write notebooks as regular .py files.
+
+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
+#-----------------------------------------------------------------------------
+
+import re
+from .rwbase import NotebookReader, NotebookWriter
+from .nbbase import (
+    new_code_cell, new_text_cell, new_worksheet,
+    new_notebook, new_heading_cell
+)
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+
+_encoding_declaration_re = re.compile(r"^#.*coding[:=]\s*([-\w.]+)")
+
+class PyReaderError(Exception):
+    pass
+
+
+class PyReader(NotebookReader):
+
+    def reads(self, s, **kwargs):
+        return self.to_notebook(s,**kwargs)
+
+    def to_notebook(self, s, **kwargs):
+        lines = s.splitlines()
+        cells = []
+        cell_lines = []
+        kwargs = {}
+        state = u'codecell'
+        for line in lines:
+            if line.startswith(u'# <nbformat>') or _encoding_declaration_re.match(line):
+                pass
+            elif line.startswith(u'# <codecell>'):
+                cell = self.new_cell(state, cell_lines, **kwargs)
+                if cell is not None:
+                    cells.append(cell)
+                state = u'codecell'
+                cell_lines = []
+                kwargs = {}
+            elif line.startswith(u'# <htmlcell>'):
+                cell = self.new_cell(state, cell_lines, **kwargs)
+                if cell is not None:
+                    cells.append(cell)
+                state = u'htmlcell'
+                cell_lines = []
+                kwargs = {}
+            elif line.startswith(u'# <markdowncell>'):
+                cell = self.new_cell(state, cell_lines, **kwargs)
+                if cell is not None:
+                    cells.append(cell)
+                state = u'markdowncell'
+                cell_lines = []
+                kwargs = {}
+            elif line.startswith(u'# <plaintextcell>'):
+                cell = self.new_cell(state, cell_lines, **kwargs)
+                if cell is not None:
+                    cells.append(cell)
+                state = u'plaintextcell'
+                cell_lines = []
+                kwargs = {}
+            elif line.startswith(u'# <headingcell'):
+                cell = self.new_cell(state, cell_lines, **kwargs)
+                if cell is not None:
+                    cells.append(cell)
+                    cell_lines = []
+                m = re.match(r'# <headingcell level=(?P<level>\d)>',line)
+                if m is not None:
+                    state = u'headingcell'
+                    kwargs = {}
+                    kwargs['level'] = int(m.group('level'))
+                else:
+                    state = u'codecell'
+                    kwargs = {}
+                    cell_lines = []
+            else:
+                cell_lines.append(line)
+        if cell_lines and state == u'codecell':
+            cell = self.new_cell(state, cell_lines)
+            if cell is not None:
+                cells.append(cell)
+        ws = new_worksheet(cells=cells)
+        nb = new_notebook(worksheets=[ws])
+        return nb
+
+    def new_cell(self, state, lines, **kwargs):
+        if state == u'codecell':
+            input = u'\n'.join(lines)
+            input = input.strip(u'\n')
+            if input:
+                return new_code_cell(input=input)
+        elif state == u'htmlcell':
+            text = self._remove_comments(lines)
+            if text:
+                return new_text_cell(u'html',source=text)
+        elif state == u'markdowncell':
+            text = self._remove_comments(lines)
+            if text:
+                return new_text_cell(u'markdown',source=text)
+        elif state == u'plaintextcell':
+            text = self._remove_comments(lines)
+            if text:
+                return new_text_cell(u'plaintext',source=text)
+        elif state == u'headingcell':
+            text = self._remove_comments(lines)
+            level = kwargs.get('level',1)
+            if text:
+                return new_heading_cell(source=text,level=level)
+
+    def _remove_comments(self, lines):
+        new_lines = []
+        for line in lines:
+            if line.startswith(u'#'):
+                new_lines.append(line[2:])
+            else:
+                new_lines.append(line)
+        text = u'\n'.join(new_lines)
+        text = text.strip(u'\n')
+        return text
+
+    def split_lines_into_blocks(self, lines):
+        if len(lines) == 1:
+            yield lines[0]
+            raise StopIteration()
+        import ast
+        source = '\n'.join(lines)
+        code = ast.parse(source)
+        starts = [x.lineno-1 for x in code.body]
+        for i in range(len(starts)-1):
+            yield '\n'.join(lines[starts[i]:starts[i+1]]).strip('\n')
+        yield '\n'.join(lines[starts[-1]:]).strip('\n')
+
+
+class PyWriter(NotebookWriter):
+
+    def writes(self, nb, **kwargs):
+        lines = [u'# -*- coding: utf-8 -*-']
+        lines.extend([u'# <nbformat>2</nbformat>',''])
+        for ws in nb.worksheets:
+            for cell in ws.cells:
+                if cell.cell_type == u'code':
+                    input = cell.get(u'input')
+                    if input is not None:
+                        lines.extend([u'# <codecell>',u''])
+                        lines.extend(input.splitlines())
+                        lines.append(u'')
+                elif cell.cell_type == u'html':
+                    input = cell.get(u'source')
+                    if input is not None:
+                        lines.extend([u'# <htmlcell>',u''])
+                        lines.extend([u'# ' + line for line in input.splitlines()])
+                        lines.append(u'')
+                elif cell.cell_type == u'markdown':
+                    input = cell.get(u'source')
+                    if input is not None:
+                        lines.extend([u'# <markdowncell>',u''])
+                        lines.extend([u'# ' + line for line in input.splitlines()])
+                        lines.append(u'')
+                elif cell.cell_type == u'plaintext':
+                    input = cell.get(u'source')
+                    if input is not None:
+                        lines.extend([u'# <plaintextcell>',u''])
+                        lines.extend([u'# ' + line for line in input.splitlines()])
+                        lines.append(u'')
+                elif cell.cell_type == u'heading':
+                    input = cell.get(u'source')
+                    level = cell.get(u'level',1)
+                    if input is not None:
+                        lines.extend([u'# <headingcell level=%s>' % level,u''])
+                        lines.extend([u'# ' + line for line in input.splitlines()])
+                        lines.append(u'')
+        lines.append('')
+        return unicode('\n'.join(lines))
+
+
+_reader = PyReader()
+_writer = PyWriter()
+
+reads = _reader.reads
+read = _reader.read
+to_notebook = _reader.to_notebook
+write = _writer.write
+writes = _writer.writes
+

IPython/nbformat/v3/rwbase.py

@@ -0,0 +1,165
+"""Base classes and utilities for readers and writers.
+
+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
+#-----------------------------------------------------------------------------
+
+from base64 import encodestring, decodestring
+import pprint
+
+from IPython.utils.py3compat import str_to_bytes
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+
+def restore_bytes(nb):
+    """Restore bytes of image data from unicode-only formats.
+    
+    Base64 encoding is handled elsewhere.  Bytes objects in the notebook are
+    always b64-encoded. We DO NOT encode/decode around file formats.
+    """
+    for ws in nb.worksheets:
+        for cell in ws.cells:
+            if cell.cell_type == 'code':
+                for output in cell.outputs:
+                    if 'png' in output:
+                        output.png = str_to_bytes(output.png, 'ascii')
+                    if 'jpeg' in output:
+                        output.jpeg = str_to_bytes(output.jpeg, 'ascii')
+    return nb
+
+# output keys that are likely to have multiline values
+_multiline_outputs = ['text', 'html', 'svg', 'latex', 'javascript', 'json']
+
+def rejoin_lines(nb):
+    """rejoin multiline text into strings
+    
+    For reversing effects of ``split_lines(nb)``.
+    
+    This only rejoins lines that have been split, so if text objects were not split
+    they will pass through unchanged.
+    
+    Used when reading JSON files that may have been passed through split_lines.
+    """
+    for ws in nb.worksheets:
+        for cell in ws.cells:
+            if cell.cell_type == 'code':
+                if 'input' in cell and isinstance(cell.input, list):
+                    cell.input = u'\n'.join(cell.input)
+                for output in cell.outputs:
+                    for key in _multiline_outputs:
+                        item = output.get(key, None)
+                        if isinstance(item, list):
+                            output[key] = u'\n'.join(item)
+            else: # text, heading cell
+                for key in ['source', 'rendered']:
+                    item = cell.get(key, None)
+                    if isinstance(item, list):
+                        cell[key] = u'\n'.join(item)
+    return nb
+
+
+def split_lines(nb):
+    """split likely multiline text into lists of strings
+    
+    For file output more friendly to line-based VCS. ``rejoin_lines(nb)`` will
+    reverse the effects of ``split_lines(nb)``.
+    
+    Used when writing JSON files.
+    """
+    for ws in nb.worksheets:
+        for cell in ws.cells:
+            if cell.cell_type == 'code':
+                if 'input' in cell and isinstance(cell.input, basestring):
+                    cell.input = cell.input.splitlines()
+                for output in cell.outputs:
+                    for key in _multiline_outputs:
+                        item = output.get(key, None)
+                        if isinstance(item, basestring):
+                            output[key] = item.splitlines()
+            else: # text, heading cell
+                for key in ['source', 'rendered']:
+                    item = cell.get(key, None)
+                    if isinstance(item, basestring):
+                        cell[key] = item.splitlines()
+    return nb
+
+# b64 encode/decode are never actually used, because all bytes objects in
+# the notebook are already b64-encoded, and we don't need/want to double-encode
+
+def base64_decode(nb):
+    """Restore all bytes objects in the notebook from base64-encoded strings.
+    
+    Note: This is never used
+    """
+    for ws in nb.worksheets:
+        for cell in ws.cells:
+            if cell.cell_type == 'code':
+                for output in cell.outputs:
+                    if 'png' in output:
+                        if isinstance(output.png, unicode):
+                            output.png = output.png.encode('ascii')
+                        output.png = decodestring(output.png)
+                    if 'jpeg' in output:
+                        if isinstance(output.jpeg, unicode):
+                            output.jpeg = output.jpeg.encode('ascii')
+                        output.jpeg = decodestring(output.jpeg)
+    return nb
+
+
+def base64_encode(nb):
+    """Base64 encode all bytes objects in the notebook.
+    
+    These will be b64-encoded unicode strings
+    
+    Note: This is never used
+    """
+    for ws in nb.worksheets:
+        for cell in ws.cells:
+            if cell.cell_type == 'code':
+                for output in cell.outputs:
+                    if 'png' in output:
+                        output.png = encodestring(output.png).decode('ascii')
+                    if 'jpeg' in output:
+                        output.jpeg = encodestring(output.jpeg).decode('ascii')
+    return nb
+
+
+class NotebookReader(object):
+    """A class for reading notebooks."""
+
+    def reads(self, s, **kwargs):
+        """Read a notebook from a string."""
+        raise NotImplementedError("loads must be implemented in a subclass")
+
+    def read(self, fp, **kwargs):
+        """Read a notebook from a file like object"""
+        return self.read(fp.read(), **kwargs)
+
+
+class NotebookWriter(object):
+    """A class for writing notebooks."""
+
+    def writes(self, nb, **kwargs):
+        """Write a notebook to a string."""
+        raise NotImplementedError("loads must be implemented in a subclass")
+
+    def write(self, nb, fp, **kwargs):
+        """Write a notebook to a file like object"""
+        return fp.write(self.writes(nb,**kwargs))
+
+
+

IPython/nbformat/v3/tests/nbexamples.py

@@ -0,0 +1,127
+import os
+from base64 import encodestring
+
+from ..nbbase import (
+    NotebookNode,
+    new_code_cell, new_text_cell, new_worksheet, new_notebook, new_output,
+    new_metadata, new_author, new_heading_cell
+)
+
+# some random base64-encoded *bytes*
+png = encodestring(os.urandom(5))
+jpeg = encodestring(os.urandom(6))
+
+ws = new_worksheet(name='worksheet1')
+
+ws.cells.append(new_text_cell(
+    u'html',
+    source='Some NumPy Examples',
+    rendered='Some NumPy Examples'
+))
+
+
+ws.cells.append(new_code_cell(
+    input='import numpy',
+    prompt_number=1,
+    collapsed=False
+))
+
+ws.cells.append(new_text_cell(
+    u'markdown',
+    source='A random array',
+    rendered='A random array'
+))
+
+ws.cells.append(new_text_cell(
+    u'plaintext',
+    source='A random array',
+))
+
+ws.cells.append(new_heading_cell(
+    u'My Heading',
+    level=2
+))
+
+ws.cells.append(new_code_cell(
+    input='a = numpy.random.rand(100)',
+    prompt_number=2,
+    collapsed=True
+))
+
+ws.cells.append(new_code_cell(
+    input='print a',
+    prompt_number=3,
+    collapsed=False,
+    outputs=[new_output(
+        output_type=u'pyout',
+        output_text=u'<array a>',
+        output_html=u'The HTML rep',
+        output_latex=u'$a$',
+        output_png=png,
+        output_jpeg=jpeg,
+        output_svg=u'<svg>',
+        output_json=u'json data',
+        output_javascript=u'var i=0;',
+        prompt_number=3
+    ),new_output(
+        output_type=u'display_data',
+        output_text=u'<array a>',
+        output_html=u'The HTML rep',
+        output_latex=u'$a$',
+        output_png=png,
+        output_jpeg=jpeg,
+        output_svg=u'<svg>',
+        output_json=u'json data',
+        output_javascript=u'var i=0;'
+    ),new_output(
+        output_type=u'pyerr',
+        etype=u'NameError',
+        evalue=u'NameError was here',
+        traceback=[u'frame 0', u'frame 1', u'frame 2']
+    )]
+))
+
+authors = [new_author(name='Bart Simpson',email='[e-mail]',
+           affiliation=u'Fox',url=u'http://www.fox.com')]
+md = new_metadata(name=u'My Notebook',license=u'BSD',created=u'8601_goes_here',
+    modified=u'8601_goes_here',gistid=u'21341231',authors=authors)
+
+nb0 = new_notebook(
+    worksheets=[ws, new_worksheet(name='worksheet2')],
+    metadata=md
+)
+
+nb0_py = """# -*- coding: utf-8 -*-
+# <nbformat>2</nbformat>
+
+# <htmlcell>
+
+# Some NumPy Examples
+
+# <codecell>
+
+import numpy
+
+# <markdowncell>
+
+# A random array
+
+# <plaintextcell>
+
+# A random array
+
+# <headingcell level=2>
+
+# My Heading
+
+# <codecell>
+
+a = numpy.random.rand(100)
+
+# <codecell>
+
+print a
+
+"""
+
+

IPython/nbformat/v3/tests/test_json.py

@@ -0,0 +1,34
+import pprint
+from unittest import TestCase
+
+from ..nbjson import reads, writes
+from .nbexamples import nb0
+
+
+class TestJSON(TestCase):
+
+    def test_roundtrip(self):
+        s = writes(nb0)
+        # print
+        # print pprint.pformat(nb0,indent=2)
+        # print
+        # print pprint.pformat(reads(s),indent=2)
+        # print
+        # print s
+        self.assertEquals(reads(s),nb0)
+    
+    def test_roundtrip_nosplit(self):
+        """Ensure that multiline blobs are still readable"""
+        # ensures that notebooks written prior to splitlines change
+        # are still readable.
+        s = writes(nb0, split_lines=False)
+        self.assertEquals(reads(s),nb0)
+
+    def test_roundtrip_split(self):
+        """Ensure that splitting multiline blocks is safe"""
+        # This won't differ from test_roundtrip unless the default changes
+        s = writes(nb0, split_lines=True)
+        self.assertEquals(reads(s),nb0)
+
+
+

IPython/nbformat/v3/tests/test_nbbase.py

@@ -0,0 +1,136
+from unittest import TestCase
+
+from ..nbbase import (
+    NotebookNode,
+    new_code_cell, new_text_cell, new_worksheet, new_notebook, new_output,
+    new_author, new_metadata, new_heading_cell
+)
+
+class TestCell(TestCase):
+
+    def test_empty_code_cell(self):
+        cc = new_code_cell()
+        self.assertEquals(cc.cell_type,u'code')
+        self.assertEquals(u'input' not in cc, True)
+        self.assertEquals(u'prompt_number' not in cc, True)
+        self.assertEquals(cc.outputs, [])
+        self.assertEquals(cc.collapsed, False)
+
+    def test_code_cell(self):
+        cc = new_code_cell(input='a=10', prompt_number=0, collapsed=True)
+        cc.outputs = [new_output(output_type=u'pyout',
+            output_svg=u'foo',output_text=u'10',prompt_number=0)]
+        self.assertEquals(cc.input, u'a=10')
+        self.assertEquals(cc.prompt_number, 0)
+        self.assertEquals(cc.language, u'python')
+        self.assertEquals(cc.outputs[0].svg, u'foo')
+        self.assertEquals(cc.outputs[0].text, u'10')
+        self.assertEquals(cc.outputs[0].prompt_number, 0)
+        self.assertEquals(cc.collapsed, True)
+
+    def test_pyerr(self):
+        o = new_output(output_type=u'pyerr', etype=u'NameError',
+            evalue=u'Name not found', traceback=[u'frame 0', u'frame 1', u'frame 2']
+        )
+        self.assertEquals(o.output_type, u'pyerr')
+        self.assertEquals(o.etype, u'NameError')
+        self.assertEquals(o.evalue, u'Name not found')
+        self.assertEquals(o.traceback, [u'frame 0', u'frame 1', u'frame 2'])
+
+    def test_empty_html_cell(self):
+        tc = new_text_cell(u'html')
+        self.assertEquals(tc.cell_type, u'html')
+        self.assertEquals(u'source' not in tc, True)
+        self.assertEquals(u'rendered' not in tc, True)
+
+    def test_html_cell(self):
+        tc = new_text_cell(u'html', 'hi', 'hi')
+        self.assertEquals(tc.source, u'hi')
+        self.assertEquals(tc.rendered, u'hi')
+
+    def test_empty_markdown_cell(self):
+        tc = new_text_cell(u'markdown')
+        self.assertEquals(tc.cell_type, u'markdown')
+        self.assertEquals(u'source' not in tc, True)
+        self.assertEquals(u'rendered' not in tc, True)
+
+    def test_markdown_cell(self):
+        tc = new_text_cell(u'markdown', 'hi', 'hi')
+        self.assertEquals(tc.source, u'hi')
+        self.assertEquals(tc.rendered, u'hi')
+
+    def test_empty_plaintext_cell(self):
+        tc = new_text_cell(u'plaintext')
+        self.assertEquals(tc.cell_type, u'plaintext')
+        self.assertEquals(u'source' not in tc, True)
+        self.assertEquals(u'rendered' not in tc, True)
+
+    def test_plaintext_cell(self):
+        tc = new_text_cell(u'plaintext', 'hi', 'hi')
+        self.assertEquals(tc.source, u'hi')
+        self.assertEquals(tc.rendered, u'hi')
+
+    def test_empty_heading_cell(self):
+        tc = new_heading_cell()
+        self.assertEquals(tc.cell_type, u'heading')
+        self.assertEquals(u'source' not in tc, True)
+        self.assertEquals(u'rendered' not in tc, True)
+
+    def test_heading_cell(self):
+        tc = new_heading_cell(u'hi', u'hi', level=2)
+        self.assertEquals(tc.source, u'hi')
+        self.assertEquals(tc.rendered, u'hi')
+        self.assertEquals(tc.level, 2)
+
+
+class TestWorksheet(TestCase):
+
+    def test_empty_worksheet(self):
+        ws = new_worksheet()
+        self.assertEquals(ws.cells,[])
+        self.assertEquals(u'name' not in ws, True)
+
+    def test_worksheet(self):
+        cells = [new_code_cell(), new_text_cell(u'html')]
+        ws = new_worksheet(cells=cells,name=u'foo')
+        self.assertEquals(ws.cells,cells)
+        self.assertEquals(ws.name,u'foo')
+
+class TestNotebook(TestCase):
+
+    def test_empty_notebook(self):
+        nb = new_notebook()
+        self.assertEquals(nb.worksheets, [])
+        self.assertEquals(nb.metadata, NotebookNode())
+        self.assertEquals(nb.nbformat,2)
+
+    def test_notebook(self):
+        worksheets = [new_worksheet(),new_worksheet()]
+        metadata = new_metadata(name=u'foo')
+        nb = new_notebook(metadata=metadata,worksheets=worksheets)
+        self.assertEquals(nb.metadata.name,u'foo')
+        self.assertEquals(nb.worksheets,worksheets)
+        self.assertEquals(nb.nbformat,2)
+
+class TestMetadata(TestCase):
+
+    def test_empty_metadata(self):
+        md = new_metadata()
+        self.assertEquals(u'name' not in md, True)
+        self.assertEquals(u'authors' not in md, True)
+        self.assertEquals(u'license' not in md, True)
+        self.assertEquals(u'saved' not in md, True)
+        self.assertEquals(u'modified' not in md, True)
+        self.assertEquals(u'gistid' not in md, True)
+
+    def test_metadata(self):
+        authors = [new_author(name='Bart Simpson',email='[e-mail]')]
+        md = new_metadata(name=u'foo',license=u'BSD',created=u'today',
+            modified=u'now',gistid=u'21341231',authors=authors)
+        self.assertEquals(md.name, u'foo')
+        self.assertEquals(md.license, u'BSD')
+        self.assertEquals(md.created, u'today')
+        self.assertEquals(md.modified, u'now')
+        self.assertEquals(md.gistid, u'21341231')
+        self.assertEquals(md.authors, authors)
+

IPython/nbformat/v3/tests/test_nbpy.py

@@ -0,0 +1,17
+from unittest import TestCase
+
+from ..nbbase import (
+    NotebookNode,
+    new_code_cell, new_text_cell, new_worksheet, new_notebook
+)
+
+from ..nbpy import reads, writes
+from .nbexamples import nb0, nb0_py
+
+
+class TestPy(TestCase):
+
+    def test_write(self):
+        s = writes(nb0)
+        self.assertEquals(s,nb0_py)
+

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

@@ -824,6 +824,8 var IPython = (function (IPython) {
             if (data.collapsed !== undefined) {
                 if (data.collapsed) {
                     this.collapse();
+                } else {
+                    this.expand();
                 };
             };
         };

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

@@ -129,6 +129,27 var IPython = (function (IPython) {
         this.element.find('#to_markdown').click(function () {
             IPython.notebook.to_markdown();
         });
+        this.element.find('#to_plaintext').click(function () {
+            IPython.notebook.to_plaintext();
+        });
+        this.element.find('#to_heading1').click(function () {
+            IPython.notebook.to_heading(undefined, 1);
+        });
+        this.element.find('#to_heading2').click(function () {
+            IPython.notebook.to_heading(undefined, 2);
+        });
+        this.element.find('#to_heading3').click(function () {
+            IPython.notebook.to_heading(undefined, 3);
+        });
+        this.element.find('#to_heading4').click(function () {
+            IPython.notebook.to_heading(undefined, 4);
+        });
+        this.element.find('#to_heading5').click(function () {
+            IPython.notebook.to_heading(undefined, 5);
+        });
+        this.element.find('#to_heading6').click(function () {
+            IPython.notebook.to_heading(undefined, 6);
+        });
         this.element.find('#toggle_output').click(function () {
             IPython.notebook.toggle_output();
         });

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

@@ -136,7 +136,42 var IPython = (function (IPython) {
                 that.control_key_active = false;
                 return false;
             } else if (event.which === 84 && that.control_key_active) {
-                // Toggle output = t
+                // To Plaintext = t
+                that.to_plaintext();
+                that.control_key_active = false;
+                return false;
+            } else if (event.which === 49 && that.control_key_active) {
+                // To Heading 1 = 1
+                that.to_heading(undefined, 1);
+                that.control_key_active = false;
+                return false;
+            } else if (event.which === 50 && that.control_key_active) {
+                // To Heading 2 = 2
+                that.to_heading(undefined, 2);
+                that.control_key_active = false;
+                return false;
+            } else if (event.which === 51 && that.control_key_active) {
+                // To Heading 3 = 3
+                that.to_heading(undefined, 3);
+                that.control_key_active = false;
+                return false;
+            } else if (event.which === 52 && that.control_key_active) {
+                // To Heading 4 = 4
+                that.to_heading(undefined, 4);
+                that.control_key_active = false;
+                return false;
+            } else if (event.which === 53 && that.control_key_active) {
+                // To Heading 5 = 5
+                that.to_heading(undefined, 5);
+                that.control_key_active = false;
+                return false;
+            } else if (event.which === 54 && that.control_key_active) {
+                // To Heading 6 = 6
+                that.to_heading(undefined, 6);
+                that.control_key_active = false;
+                return false;
+            } else if (event.which === 79 && that.control_key_active) {
+                // Toggle output = o
                 that.toggle_output();
                 that.control_key_active = false;
                 return false;
@@ -366,7 +401,11 var IPython = (function (IPython) {
             };
             var cell = this.get_cell(index)
             cell.select();
-            IPython.toolbar.set_cell_type(cell.cell_type);
+            if (cell.cell_type === 'heading') {
+                IPython.toolbar.set_cell_type(cell.cell_type+cell.level);
+            } else {
+                IPython.toolbar.set_cell_type(cell.cell_type)
+            }
         };
         return this;
     };
@@ -467,15 +506,19 var IPython = (function (IPython) {
         // type = ('code','html','markdown')
         // index = cell index or undefined to insert below selected
         index = this.index_or_selected(index);
-        if (this.ncells() === 0 || this.is_valid_cell_index(index)) {
             var cell = null;
+        if (this.ncells() === 0 || this.is_valid_cell_index(index)) {
             if (type === 'code') {
-                var cell = new IPython.CodeCell(this);
+                cell = new IPython.CodeCell(this);
                 cell.set_input_prompt();
             } else if (type === 'markdown') {
-                var cell = new IPython.MarkdownCell(this);
+                cell = new IPython.MarkdownCell(this);
             } else if (type === 'html') {
-                var cell = new IPython.HTMLCell(this);
+                cell = new IPython.HTMLCell(this);
+            } else if (type === 'plaintext') {
+                cell = new IPython.PlaintextCell(this);
+            } else if (type === 'heading') {
+                cell = new IPython.HeadingCell(this);
             };
             if (cell !== null) {
                 if (this.ncells() === 0) {
@@ -489,6 +532,7 var IPython = (function (IPython) {
                 return cell;
             };
         };
+        return cell;
     };
 
 
@@ -496,15 +540,19 var IPython = (function (IPython) {
         // type = ('code','html','markdown')
         // index = cell index or undefined to insert above selected
         index = this.index_or_selected(index);
-        if (this.ncells() === 0 || this.is_valid_cell_index(index)) {
             var cell = null;
+        if (this.ncells() === 0 || this.is_valid_cell_index(index)) {
             if (type === 'code') {
-                var cell = new IPython.CodeCell(this);
+                cell = new IPython.CodeCell(this);
                 cell.set_input_prompt();
             } else if (type === 'markdown') {
-                var cell = new IPython.MarkdownCell(this);
+                cell = new IPython.MarkdownCell(this);
             } else if (type === 'html') {
-                var cell = new IPython.HTMLCell(this);
+                cell = new IPython.HTMLCell(this);
+            } else if (type === 'plaintext') {
+                cell = new IPython.PlaintextCell(this);
+            } else if (type === 'heading') {
+                cell = new IPython.HeadingCell(this);
             };
             if (cell !== null) {
                 if (this.ncells() === 0) {
@@ -518,6 +566,7 var IPython = (function (IPython) {
                 return cell;
             };
         };
+        return cell;
     };
 
 
@@ -534,10 +583,10 var IPython = (function (IPython) {
                 }
                 target_cell.set_text(text);
                 source_element.remove();
-            };
             this.dirty = true;
         };
     };
+    };
 
 
     Notebook.prototype.to_markdown = function (index) {
@@ -545,19 +594,16 var IPython = (function (IPython) {
         if (this.is_valid_cell_index(i)) {
             var source_element = this.get_cell_element(i);
             var source_cell = source_element.data("cell");
-            var target_cell = null;
             if (!(source_cell instanceof IPython.MarkdownCell)) {
                 target_cell = this.insert_cell_below('markdown',i);
                 var text = source_cell.get_text();
                 if (text === source_cell.placeholder) {
                     text = '';
                 };
-                if (target_cell !== null) {
                     // The edit must come before the set_text.
                     target_cell.edit();
                     target_cell.set_text(text);
                     source_element.remove();
-                }
                 this.dirty = true;
             };
         };
@@ -576,18 +622,65 var IPython = (function (IPython) {
                 if (text === source_cell.placeholder) {
                     text = '';
                 };
-                if (target_cell !== null) {
                     // The edit must come before the set_text.
                     target_cell.edit();
                     target_cell.set_text(text);
                     source_element.remove();
-                }
                 this.dirty = true;
             };
         };
     };
 
 
+    Notebook.prototype.to_plaintext = function (index) {
+        var i = this.index_or_selected(index);
+        if (this.is_valid_cell_index(i)) {
+            var source_element = this.get_cell_element(i);
+            var source_cell = source_element.data("cell");
+            var target_cell = null;
+            if (!(source_cell instanceof IPython.PlaintextCell)) {
+                target_cell = this.insert_cell_below('plaintext',i);
+                var text = source_cell.get_text();
+                if (text === source_cell.placeholder) {
+                    text = '';
+                };
+                // The edit must come before the set_text.
+                target_cell.edit();
+                target_cell.set_text(text);
+                source_element.remove();
+                this.dirty = true;
+            };
+        };
+    };
+
+
+    Notebook.prototype.to_heading = function (index, level) {
+        level = level || 1;
+        var i = this.index_or_selected(index);
+        if (this.is_valid_cell_index(i)) {
+            var source_element = this.get_cell_element(i);
+            var source_cell = source_element.data("cell");
+            var target_cell = null;
+            if (source_cell instanceof IPython.HeadingCell) {
+                source_cell.set_level(level);
+            } else {
+                target_cell = this.insert_cell_below('heading',i);
+                var text = source_cell.get_text();
+                if (text === source_cell.placeholder) {
+                    text = '';
+                };
+                // The edit must come before the set_text.
+                target_cell.set_level(level);
+                target_cell.edit();
+                target_cell.set_text(text);
+                source_element.remove();
+                this.dirty = true;
+            };
+            IPython.toolbar.set_cell_type("heading"+level);
+        };
+    };
+
+
     // Cut/Copy/Paste
 
     Notebook.prototype.enable_paste = function () {
@@ -1098,7 +1191,7 var IPython = (function (IPython) {
         // We may want to move the name/id/nbformat logic inside toJSON?
         var data = this.toJSON();
         data.metadata.name = nbname;
-        data.nbformat = 2;
+        data.nbformat = 3;
         // We do the call with settings so we can set cache to false.
         var settings = {
             processData : false,

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

@@ -34,13 +34,15 var IPython = (function (IPython) {
             {key: 'Ctrl-m d', help: 'delete cell'},
             {key: 'Ctrl-m a', help: 'insert cell above'},
             {key: 'Ctrl-m b', help: 'insert cell below'},
-            {key: 'Ctrl-m t', help: 'toggle output'},
+            {key: 'Ctrl-m o', help: 'toggle output'},
             {key: 'Ctrl-m l', help: 'toggle line numbers'},
             {key: 'Ctrl-m s', help: 'save notebook'},
             {key: 'Ctrl-m j', help: 'move cell down'},
             {key: 'Ctrl-m k', help: 'move cell up'},
             {key: 'Ctrl-m y', help: 'code cell'},
             {key: 'Ctrl-m m', help: 'markdown cell'},
+            {key: 'Ctrl-m t', help: 'plaintext cell'},
+            {key: 'Ctrl-m 1-6', help: 'heading 1-6 cell'},
             {key: 'Ctrl-m p', help: 'select previous'},
             {key: 'Ctrl-m n', help: 'select next'},
             {key: 'Ctrl-m i', help: 'interrupt kernel'},

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

@@ -237,49 +237,109 var IPython = (function (IPython) {
     };
 
 
-    // RSTCell
+    // PlaintextCell
 
-    var RSTCell = function (notebook) {
-        this.placeholder = "Type *ReStructured Text* and LaTeX: $\\alpha^2$";
+    var PlaintextCell = function (notebook) {
+        this.placeholder = "Type plain text and LaTeX: $\\alpha^2$";
+        this.code_mirror_mode = 'rst';
         IPython.TextCell.apply(this, arguments);
-        this.cell_type = 'rst';
+        this.cell_type = 'plaintext';
     };
 
 
-    RSTCell.prototype = new TextCell();
+    PlaintextCell.prototype = new TextCell();
 
 
-    RSTCell.prototype.render = function () {
-        if (this.rendered === false) {
-            var text = this.get_text();
-            if (text === "") { text = this.placeholder; }
-            var settings = {
-                processData : false,
-                cache : false,
-                type : "POST",
-                data : text,
-                headers : {'Content-Type': 'application/x-rst'},
-                success : $.proxy(this.handle_render,this)
-            };
-            $.ajax("/rstservice/render", settings);
-            this.element.find('div.text_cell_input').hide();
-            this.element.find("div.text_cell_render").show();
-            this.set_rendered("Rendering...");
+    PlaintextCell.prototype.render = function () {
+        this.rendered = true;
+        this.edit();
+    };
+
+
+    PlaintextCell.prototype.select = function () {
+        IPython.Cell.prototype.select.apply(this);
+        this.code_mirror.refresh();
+        this.code_mirror.focus();
+    };
+
+
+    PlaintextCell.prototype.at_top = function () {
+        var cursor = this.code_mirror.getCursor();
+        if (cursor.line === 0) {
+            return true;
+        } else {
+            return false;
+        }
+    };
+
+
+    PlaintextCell.prototype.at_bottom = function () {
+        var cursor = this.code_mirror.getCursor();
+        if (cursor.line === (this.code_mirror.lineCount()-1)) {
+            return true;
+        } else {
+            return false;
         }
     };
 
 
-    RSTCell.prototype.handle_render = function (data, status, xhr) {
-        this.set_rendered(data);
+    // HTMLCell
+
+    var HeadingCell = function (notebook) {
+        this.placeholder = "Type Heading Here";
+        IPython.TextCell.apply(this, arguments);
+        this.cell_type = 'heading';
+        this.level = 1;
+    };
+
+
+    HeadingCell.prototype = new TextCell();
+
+
+    HeadingCell.prototype.set_level = function (level) {
+        this.level = level;
+        if (this.rendered) {
+            this.rendered = false;
+            this.render();
+        };
+    };
+
+
+    HeadingCell.prototype.get_level = function () {
+        return this.level;
+    };
+
+
+    HeadingCell.prototype.set_rendered = function (text) {
+        var r = this.element.find("div.text_cell_render");
+        r.empty();
+        r.append($('<h'+this.level+'/>').html(text));
+    };
+
+
+    HeadingCell.prototype.get_rendered = function () {
+        var r = this.element.find("div.text_cell_render");
+        return r.children().first().html();
+    };
+
+
+    HeadingCell.prototype.render = function () {
+        if (this.rendered === false) {
+            var text = this.get_text();
+            if (text === "") { text = this.placeholder; }
+            this.set_rendered(text);
         this.typeset();
+            this.element.find('div.text_cell_input').hide();
+            this.element.find("div.text_cell_render").show();
         this.rendered = true;
     };
-
+    };
 
     IPython.TextCell = TextCell;
     IPython.HTMLCell = HTMLCell;
     IPython.MarkdownCell = MarkdownCell;
-    IPython.RSTCell = RSTCell;
+    IPython.PlaintextCell = PlaintextCell;
+    IPython.HeadingCell = HeadingCell;
 
 
     return IPython;

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

@@ -108,6 +108,20 var IPython = (function (IPython) {
                 IPython.notebook.to_code();
             } else if (cell_type === 'markdown')  {
                 IPython.notebook.to_markdown();
+            } else if (cell_type === 'plaintext')  {
+                IPython.notebook.to_plaintext();
+            } else if (cell_type === 'heading1')  {
+                IPython.notebook.to_heading(undefined, 1);
+            } else if (cell_type === 'heading2')  {
+                IPython.notebook.to_heading(undefined, 2);
+            } else if (cell_type === 'heading3')  {
+                IPython.notebook.to_heading(undefined, 3);
+            } else if (cell_type === 'heading4')  {
+                IPython.notebook.to_heading(undefined, 4);
+            } else if (cell_type === 'heading5')  {
+                IPython.notebook.to_heading(undefined, 5);
+            } else if (cell_type === 'heading6')  {
+                IPython.notebook.to_heading(undefined, 6);
             };
         });
 

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

@@ -117,8 +117,15
                 <li id="run_cell_in_place"><a href="#">Run in Place</a></li>
                 <li id="run_all_cells"><a href="#">Run All</a></li>
                 <hr/>
-                <li id="to_code"><a href="#">Code Cell</a></li>
-                <li id="to_markdown"><a href="#">Markdown Cell</a></li>
+                <li id="to_code"><a href="#">Code</a></li>
+                <li id="to_markdown"><a href="#">Markdown </a></li>
+                <li id="to_plaintext"><a href="#">Plaintext</a></li>
+                <li id="to_heading1"><a href="#">Heading 1</a></li>
+                <li id="to_heading2"><a href="#">Heading 2</a></li>
+                <li id="to_heading3"><a href="#">Heading 3</a></li>
+                <li id="to_heading4"><a href="#">Heading 4</a></li>
+                <li id="to_heading5"><a href="#">Heading 5</a></li>
+                <li id="to_heading6"><a href="#">Heading 6</a></li>
                 <hr/>
                 <li id="toggle_output"><a href="#">Toggle Output</a></li>
                 <li id="clear_all_output"><a href="#">Clear All Output</a></li>
@@ -173,6 +180,13
         <select id="cell_type">
              <option value="code">Code</option>
              <option value="markdown">Markdown</option>
+             <option value="plaintext">Plaintext</option>
+             <option value="heading1">Heading 1</option>
+             <option value="heading2">Heading 2</option>
+             <option value="heading3">Heading 3</option>
+             <option value="heading4">Heading 4</option>
+             <option value="heading5">Heading 5</option>
+             <option value="heading6">Heading 6</option>
         </select>
     </span>
 

IPython/nbformat/current.py

@@ -21,20 +21,21 import json
 from xml.etree import ElementTree as ET
 import re
 
+from IPython.nbformat import v3
 from IPython.nbformat import v2
 from IPython.nbformat import v1
 
-from IPython.nbformat.v2 import (
+from IPython.nbformat.v3 import (
     NotebookNode,
     new_code_cell, new_text_cell, new_notebook, new_output, new_worksheet,
-    parse_filename, new_metadata, new_author
+    parse_filename, new_metadata, new_author, new_heading_cell
 )
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
-current_nbformat = 2
+current_nbformat = 3
 
 
 class NBFormatError(Exception):
@@ -48,17 +49,6 def parse_json(s, **kwargs):
     return nbformat, d
 
 
-def parse_xml(s, **kwargs):
-    """Parse a string into a (nbformat, etree) tuple."""
-    root = ET.fromstring(s)
-    nbformat_e = root.find('nbformat')
-    if nbformat_e is not None:
-        nbformat = int(nbformat_e.text)
-    else:
-        raise NBFormatError('No nbformat version found')
-    return nbformat, root
-
-
 def parse_py(s, **kwargs):
     """Parse a string into a (nbformat, string) tuple."""
     pattern = r'# <nbformat>(?P<nbformat>\d+)</nbformat>'
@@ -66,7 +56,7 def parse_py(s, **kwargs):
     if m is not None:
         nbformat = int(m.group('nbformat'))
     else:
-        nbformat = 2
+        nbformat = 3
     return nbformat, s
 
 
@@ -75,26 +65,19 def reads_json(s, **kwargs):
     nbformat, d = parse_json(s, **kwargs)
     if nbformat == 1:
         nb = v1.to_notebook_json(d, **kwargs)
-        nb = v2.convert_to_this_nbformat(nb, orig_version=1)
+        nb = v3.convert_to_this_nbformat(nb, orig_version=1)
     elif nbformat == 2:
         nb = v2.to_notebook_json(d, **kwargs)
+        nb = v3.convert_to_this_nbformat(nb, orig_version=2)
+    elif nbformat == 3:
+        nb = v3.to_notebook_json(d, **kwargs)
     else:
         raise NBFormatError('Unsupported JSON nbformat version: %i' % nbformat)
     return nb
 
 
 def writes_json(nb, **kwargs):
-    return v2.writes_json(nb, **kwargs)
-
-
-def reads_xml(s, **kwargs):
-    """Read an XML notebook from a string and return the NotebookNode object."""
-    nbformat, root = parse_xml(s, **kwargs)
-    if nbformat == 2:
-        nb = v2.to_notebook_xml(root, **kwargs)
-    else:
-        raise NBFormatError('Unsupported XML nbformat version: %i' % nbformat)
-    return nb
+    return v3.writes_json(nb, **kwargs)
 
 
 def reads_py(s, **kwargs):
@@ -102,13 +85,15 def reads_py(s, **kwargs):
     nbformat, s = parse_py(s, **kwargs)
     if nbformat == 2:
         nb = v2.to_notebook_py(s, **kwargs)
+    elif nbformat == 3:
+        nb = v3.to_notebook_py(s, **kwargs)
     else:
         raise NBFormatError('Unsupported PY nbformat version: %i' % nbformat)
     return nb
 
 
 def writes_py(nb, **kwargs):
-    return v2.writes_py(nb, **kwargs)
+    return v3.writes_py(nb, **kwargs)
 
 
 # High level API
@@ -133,9 +118,7 def reads(s, format, **kwargs):
         The notebook that was read.
     """
     format = unicode(format)
-    if format == u'xml':
-        return reads_xml(s, **kwargs)
-    elif format == u'json' or format == u'ipynb':
+    if format == u'json' or format == u'ipynb':
         return reads_json(s, **kwargs)
     elif format == u'py':
         return reads_py(s, **kwargs)
@@ -161,9 +144,7 def writes(nb, format, **kwargs):
         The notebook string.
     """
     format = unicode(format)
-    if format == u'xml':
-        raise NotImplementedError('Write to XML files is not implemented.')
-    elif format == u'json' or format == u'ipynb':
+    if format == u'json' or format == u'ipynb':
         return writes_json(nb, **kwargs)
     elif format == u'py':
         return writes_py(nb, **kwargs)

docs/examples/notebooks/00_notebook_tour.ipynb

@@ -2,7 +2,7
  "metadata": {
   "name": "00_notebook_tour"
  }, 
- "nbformat": 2, 
+ "nbformat": 3,
  "worksheets": [
   {
    "cells": [

docs/examples/notebooks/01_notebook_introduction.ipynb

@@ -2,7 +2,7
  "metadata": {
   "name": "01_notebook_introduction"
  }, 
- "nbformat": 2, 
+ "nbformat": 3,
  "worksheets": [
   {
    "cells": [

docs/examples/notebooks/display_protocol.ipynb

@@ -2,7 +2,7
  "metadata": {
   "name": "display_protocol"
  }, 
- "nbformat": 2, 
+ "nbformat": 3,
  "worksheets": [
   {
    "cells": [

docs/examples/notebooks/formatting.ipynb

@@ -2,7 +2,7
  "metadata": {
   "name": "formatting"
  }, 
- "nbformat": 2, 
+ "nbformat": 3,
  "worksheets": [
   {
    "cells": [

docs/examples/notebooks/sympy.ipynb

@@ -2,7 +2,7
  "metadata": {
   "name": "sympy"
  }, 
- "nbformat": 2, 
+ "nbformat": 3,
  "worksheets": [
   {
    "cells": [

docs/examples/notebooks/sympy_quantum_computing.ipynb

@@ -2,7 +2,7
  "metadata": {
   "name": "sympy_quantum_computing"
  },
- "nbformat": 2,
+ "nbformat": 3,
  "worksheets": [
   {
    "cells": [

docs/examples/notebooks/trapezoid_rule.ipynb

@@ -2,7 +2,7
  "metadata": {
   "name": "trapezoid_rule"
  }, 
- "nbformat": 2, 
+ "nbformat": 3,
  "worksheets": [
   {
    "cells": [

docs/examples/parallel/helloworld.ipynb

@@ -2,7 +2,7
  "metadata": {
   "name": "helloworld"
  }, 
- "nbformat": 2, 
+ "nbformat": 3,
  "worksheets": [
   {
    "cells": [

docs/examples/parallel/parallel_mpi.ipynb

@@ -2,7 +2,7
  "metadata": {
   "name": "parallel_mpi"
  }, 
- "nbformat": 2, 
+ "nbformat": 3,
  "worksheets": [
   {
    "cells": [

docs/examples/parallel/task1.ipynb

@@ -1,87 +1,116
 {
-    "nbformat": 2, 
     "metadata": {
-        "name": "task_1"
+  "name": "task1"
     }, 
+ "nbformat": 3,
     "worksheets": [
         {
             "cells": [
                 {
-                    "source": "# Simple task farming example", 
-                    "cell_type": "markdown"
+     "cell_type": "markdown",
+     "source": [
+      "# Simple task farming example"
+     ]
                 }, 
                 {
                     "cell_type": "code", 
+     "collapsed": true,
+     "input": [
+      "from IPython.parallel import Client"
+     ],
                     "language": "python", 
                     "outputs": [], 
-                    "collapsed": true, 
-                    "prompt_number": 3, 
-                    "input": "from IPython.parallel import Client"
+     "prompt_number": 3
                 }, 
                 {
-                    "source": "A `Client.load_balanced_view` is used to get the object used for working with load balanced tasks.", 
-                    "cell_type": "markdown"
+     "cell_type": "markdown",
+     "source": [
+      "A `Client.load_balanced_view` is used to get the object used for working with load balanced tasks."
+     ]
                 }, 
                 {
                     "cell_type": "code", 
+     "collapsed": true,
+     "input": [
+      "rc = Client()",
+      "v = rc.load_balanced_view()"
+     ],
                     "language": "python", 
                     "outputs": [], 
-                    "collapsed": true, 
-                    "prompt_number": 4, 
-                    "input": "rc = Client()\nv = rc.load_balanced_view()"
+     "prompt_number": 4
                 }, 
                 {
-                    "source": "Set the variable `d` on all engines:", 
-                    "cell_type": "markdown"
+     "cell_type": "markdown",
+     "source": [
+      "Set the variable `d` on all engines:"
+     ]
                 }, 
                 {
                     "cell_type": "code", 
+     "collapsed": true,
+     "input": [
+      "rc[:]['d'] = 30"
+     ],
                     "language": "python", 
                     "outputs": [], 
-                    "collapsed": true, 
-                    "prompt_number": 5, 
-                    "input": "rc[:]['d'] = 30"
+     "prompt_number": 5
                 }, 
                 {
-                    "source": "Define a function that will be our task:", 
-                    "cell_type": "markdown"
+     "cell_type": "markdown",
+     "source": [
+      "Define a function that will be our task:"
+     ]
                 }, 
                 {
                     "cell_type": "code", 
+     "collapsed": true,
+     "input": [
+      "def task(a):",
+      "    return a, 10*d, a*10*d"
+     ],
                     "language": "python", 
                     "outputs": [], 
-                    "collapsed": true, 
-                    "prompt_number": 6, 
-                    "input": "def task(a):\n    return a, 10*d, a*10*d"
+     "prompt_number": 6
                 }, 
                 {
-                    "source": "Run the task once:", 
-                    "cell_type": "markdown"
+     "cell_type": "markdown",
+     "source": [
+      "Run the task once:"
+     ]
                 }, 
                 {
                     "cell_type": "code", 
+     "collapsed": true,
+     "input": [
+      "ar = v.apply(task, 5)"
+     ],
                     "language": "python", 
                     "outputs": [], 
-                    "collapsed": true, 
-                    "prompt_number": 7, 
-                    "input": "ar = v.apply(task, 5)"
+     "prompt_number": 7
                 }, 
                 {
-                    "source": "Print the results:", 
-                    "cell_type": "markdown"
+     "cell_type": "markdown",
+     "source": [
+      "Print the results:"
+     ]
                 }, 
                 {
                     "cell_type": "code", 
+     "collapsed": false,
+     "input": [
+      "print \"a, b, c: \", ar.get()"
+     ],
                     "language": "python", 
                     "outputs": [
                         {
                             "output_type": "stream", 
-                            "text": "a, b, c:  [5, 300, 1500]"
+       "stream": "stdout",
+       "text": [
+        "a, b, c:  [5, 300, 1500]"
+       ]
                         }
                     ], 
-                    "collapsed": false, 
-                    "prompt_number": 8, 
-                    "input": "print \"a, b, c: \", ar.get()"
+     "prompt_number": 8
                 }
             ]
         }

docs/examples/parallel/taskmap.ipynb

@@ -2,7 +2,7
  "metadata": {
   "name": "taskmap"
  }, 
- "nbformat": 2, 
+ "nbformat": 3,
  "worksheets": [
   {
    "cells": [