fix some validation bugs in v3

Python API had many inconsistencies with the actual spec

IPython/nbconvert/preprocessors/tests/test_coalescestreams.py

@@ -1,73 +1,60 b''
-"""
-Module with tests for the coalescestreams preprocessor
-"""
+"""Tests for the coalescestreams preprocessor"""
 
-#-----------------------------------------------------------------------------
-# Copyright (c) 2013, the IPython Development Team.
-#
+# Copyright (c) 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
-#-----------------------------------------------------------------------------
 from IPython.nbformat import current as nbformat
 
 from .base import PreprocessorTestsBase
 from ..coalescestreams import coalesce_streams
 
 
-#-----------------------------------------------------------------------------
-# Class
-#-----------------------------------------------------------------------------
 class TestCoalesceStreams(PreprocessorTestsBase):
     """Contains test functions for coalescestreams.py"""
 
     def test_coalesce_streams(self):
         """coalesce_streams preprocessor output test"""
         nb = self.build_notebook()
         res = self.build_resources()
         nb, res = coalesce_streams(nb, res)
         outputs = nb.worksheets[0].cells[0].outputs
         self.assertEqual(outputs[0].text, "a")
         self.assertEqual(outputs[1].output_type, "text")
         self.assertEqual(outputs[2].text, "cd")
         self.assertEqual(outputs[3].text, "ef")
 
     def test_coalesce_sequenced_streams(self):
         """Can the coalesce streams preprocessor merge a sequence of streams?"""
         outputs = [nbformat.new_output(output_type="stream", stream="stdout", output_text="0"),
                    nbformat.new_output(output_type="stream", stream="stdout", output_text="1"),
                    nbformat.new_output(output_type="stream", stream="stdout", output_text="2"),
                    nbformat.new_output(output_type="stream", stream="stdout", output_text="3"),
                    nbformat.new_output(output_type="stream", stream="stdout", output_text="4"),
                    nbformat.new_output(output_type="stream", stream="stdout", output_text="5"),
                    nbformat.new_output(output_type="stream", stream="stdout", output_text="6"),
                    nbformat.new_output(output_type="stream", stream="stdout", output_text="7")]
         cells=[nbformat.new_code_cell(input="# None", prompt_number=1,outputs=outputs)]
-        worksheets = [nbformat.new_worksheet(name="worksheet1", cells=cells)]
+        worksheets = [nbformat.new_worksheet(cells=cells)]
 
         nb = nbformat.new_notebook(name="notebook1", worksheets=worksheets)
         res = self.build_resources()
         nb, res = coalesce_streams(nb, res)
         outputs = nb.worksheets[0].cells[0].outputs
         self.assertEqual(outputs[0].text, u'01234567')
 
     def test_coalesce_replace_streams(self):
         """Are \\r characters handled?"""
         outputs = [nbformat.new_output(output_type="stream", stream="stdout", output_text="z"),
                    nbformat.new_output(output_type="stream", stream="stdout", output_text="\ra"),
                    nbformat.new_output(output_type="stream", stream="stdout", output_text="\nz\rb"),
                    nbformat.new_output(output_type="stream", stream="stdout", output_text="\nz"),
                    nbformat.new_output(output_type="stream", stream="stdout", output_text="\rc\n"),
                    nbformat.new_output(output_type="stream", stream="stdout", output_text="z\rz\rd")]
         cells=[nbformat.new_code_cell(input="# None", prompt_number=1,outputs=outputs)]
-        worksheets = [nbformat.new_worksheet(name="worksheet1", cells=cells)]
+        worksheets = [nbformat.new_worksheet(cells=cells)]
 
         nb = nbformat.new_notebook(name="notebook1", worksheets=worksheets)
         res = self.build_resources()
         nb, res = coalesce_streams(nb, res)
         outputs = nb.worksheets[0].cells[0].outputs
         self.assertEqual(outputs[0].text, u'a\nb\nc\nd')

IPython/nbconvert/preprocessors/tests/test_revealhelp.py

@@ -1,94 +1,79 b''
-"""
-Module with tests for the revealhelp preprocessor
-"""
+"""Tests for the revealhelp preprocessor"""
 
-#-----------------------------------------------------------------------------
-# Copyright (c) 2013, the IPython Development Team.
-#
+# Copyright (c) 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
-#-----------------------------------------------------------------------------
 
 from IPython.nbformat import current as nbformat
 
 from .base import PreprocessorTestsBase
 from ..revealhelp import RevealHelpPreprocessor
 
 
-#-----------------------------------------------------------------------------
-# Class
-#-----------------------------------------------------------------------------
-
 class Testrevealhelp(PreprocessorTestsBase):
     """Contains test functions for revealhelp.py"""
 
     def build_notebook(self):
         """Build a reveal slides notebook in memory for use with tests.
         Overrides base in PreprocessorTestsBase"""
 
         outputs = [nbformat.new_output(output_type="stream", stream="stdout", output_text="a")]
 
         slide_metadata = {'slideshow' : {'slide_type': 'slide'}}
         subslide_metadata = {'slideshow' : {'slide_type': 'subslide'}}
 
         cells=[nbformat.new_code_cell(input="", prompt_number=1, outputs=outputs),
                nbformat.new_text_cell('markdown', source="", metadata=slide_metadata),
                nbformat.new_code_cell(input="", prompt_number=2, outputs=outputs),
                nbformat.new_text_cell('markdown', source="", metadata=slide_metadata),
                nbformat.new_text_cell('markdown', source="", metadata=subslide_metadata)]
-        worksheets = [nbformat.new_worksheet(name="worksheet1", cells=cells)]
+        worksheets = [nbformat.new_worksheet(cells=cells)]
 
         return nbformat.new_notebook(name="notebook1", worksheets=worksheets)
 
 
     def build_preprocessor(self):
         """Make an instance of a preprocessor"""
         preprocessor = RevealHelpPreprocessor()
         preprocessor.enabled = True
         return preprocessor
 
 
     def test_constructor(self):
         """Can a RevealHelpPreprocessor be constructed?"""
         self.build_preprocessor()
 
 
     def test_reveal_attribute(self):
         """Make sure the reveal url_prefix resources is set"""
         nb = self.build_notebook()
         res = self.build_resources()
         preprocessor = self.build_preprocessor()
         nb, res = preprocessor(nb, res)
         assert 'reveal' in res
         assert  'url_prefix' in res['reveal']
 
 
     def test_reveal_output(self):
         """Make sure that the reveal preprocessor """
         nb = self.build_notebook()
         res = self.build_resources()
         preprocessor = self.build_preprocessor()
         nb, res = preprocessor(nb, res)
         cells = nb.worksheets[0].cells
         
         # Make sure correct metadata tags are available on every cell.
         for cell in cells:
             assert 'slide_type' in cell.metadata
 
         # Make sure slide end is only applied to the cells preceeding slide 
         # cells.
         assert 'slide_helper' in cells[1].metadata
         self.assertEqual(cells[1].metadata['slide_helper'], '-')
 
         # Verify 'slide-end'
         assert 'slide_helper' in cells[0].metadata
         self.assertEqual(cells[0].metadata['slide_helper'], 'slide_end')
         assert 'slide_helper' in cells[2].metadata
         self.assertEqual(cells[2].metadata['slide_helper'], 'slide_end')
         assert 'slide_helper' in cells[3].metadata
         self.assertEqual(cells[3].metadata['slide_helper'], 'subslide_end')

IPython/nbformat/v3/nbbase.py

@@ -1,205 +1,200 b''
 """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.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import pprint
 import uuid
 
 from IPython.utils.ipstruct import Struct
 from IPython.utils.py3compat import cast_unicode, unicode_type
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 # Change this when incrementing the nbformat version
 nbformat = 3
 nbformat_minor = 0
 nbformat_schema = 'nbformat.v3.schema.json'
 
 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, 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,
     ename=None, evalue=None, traceback=None, stream=None, metadata=None):
     """Create a new output, to go in the ``cell.outputs`` list of a code cell.
     """
     output = NotebookNode()
     output.output_type = unicode_type(output_type)
 
     if metadata is None:
         metadata = {}
     if not isinstance(metadata, dict):
         raise TypeError("metadata must be dict")
-    output.metadata = metadata
 
     if output_type != 'pyerr':
         if output_text is not None:
             output.text = cast_unicode(output_text)
         if output_png is not None:
             output.png = cast_unicode(output_png)
         if output_jpeg is not None:
             output.jpeg = cast_unicode(output_jpeg)
         if output_html is not None:
             output.html = cast_unicode(output_html)
         if output_svg is not None:
             output.svg = cast_unicode(output_svg)
         if output_latex is not None:
             output.latex = cast_unicode(output_latex)
         if output_json is not None:
             output.json = cast_unicode(output_json)
         if output_javascript is not None:
             output.javascript = cast_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 ename is not None:
             output.ename = cast_unicode(ename)
         if evalue is not None:
             output.evalue = cast_unicode(evalue)
         if traceback is not None:
             output.traceback = [cast_unicode(frame) for frame in list(traceback)]
 
     if output_type == u'stream':
         output.stream = 'stdout' if stream is None else cast_unicode(stream)
+    else:
+        output.metadata = metadata
     
     return output
 
 
 def new_code_cell(input=None, prompt_number=None, outputs=None,
     language=u'python', collapsed=False, metadata=None):
     """Create a new code cell with input and output"""
     cell = NotebookNode()
     cell.cell_type = u'code'
     if language is not None:
         cell.language = cast_unicode(language)
     if input is not None:
         cell.input = cast_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)
     cell.metadata = NotebookNode(metadata or {})
 
     return cell
 
 def new_text_cell(cell_type, source=None, rendered=None, metadata=None):
     """Create a new text cell."""
     cell = NotebookNode()
     # VERSIONHACK: plaintext -> raw
     # handle never-released plaintext name for raw cells
     if cell_type == 'plaintext':
         cell_type = 'raw'
     if source is not None:
         cell.source = cast_unicode(source)
-    if rendered is not None:
-        cell.rendered = cast_unicode(rendered)
     cell.metadata = NotebookNode(metadata or {})
     cell.cell_type = cell_type
     return cell
 
 
-def new_heading_cell(source=None, rendered=None, level=1, metadata=None):
+def new_heading_cell(source=None, level=1, rendered=None, metadata=None):
     """Create a new section cell with a given integer level."""
     cell = NotebookNode()
     cell.cell_type = u'heading'
     if source is not None:
         cell.source = cast_unicode(source)
-    if rendered is not None:
-        cell.rendered = cast_unicode(rendered)
     cell.level = int(level)
     cell.metadata = NotebookNode(metadata or {})
     return cell
 
 
 def new_worksheet(name=None, cells=None, metadata=None):
     """Create a worksheet by name with with a list of cells."""
     ws = NotebookNode()
-    if name is not None:
-        ws.name = cast_unicode(name)
     if cells is None:
         ws.cells = []
     else:
         ws.cells = list(cells)
     ws.metadata = NotebookNode(metadata or {})
     return ws
 
 
 def new_notebook(name=None, metadata=None, worksheets=None):
     """Create a notebook by name, id and a list of worksheets."""
     nb = NotebookNode()
     nb.nbformat = nbformat
     nb.nbformat_minor = nbformat_minor
     if worksheets is None:
         nb.worksheets = []
     else:
         nb.worksheets = list(worksheets)
     if metadata is None:
         nb.metadata = new_metadata()
     else:
         nb.metadata = NotebookNode(metadata)
     if name is not None:
         nb.metadata.name = cast_unicode(name)
     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 = cast_unicode(name)
     if authors is not None:
         metadata.authors = list(authors)
     if created is not None:
         metadata.created = cast_unicode(created)
     if modified is not None:
         metadata.modified = cast_unicode(modified)
     if license is not None:
         metadata.license = cast_unicode(license)
     if gistid is not None:
         metadata.gistid = cast_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 = cast_unicode(name)
     if email is not None:
         author.email = cast_unicode(email)
     if affiliation is not None:
         author.affiliation = cast_unicode(affiliation)
     if url is not None:
         author.url = cast_unicode(url)
     return author
 

IPython/nbformat/v3/nbformat.v3.schema.json

@@ -1,363 +1,363 b''
 {
     "$schema": "http://json-schema.org/draft-04/schema#",
     "description": "IPython Notebook v3.0 JSON schema.",
     "type": "object",
     "additionalProperties": false,
     "required": ["metadata", "nbformat_minor", "nbformat", "worksheets"],
     "properties": {
         "metadata": {
             "description": "Notebook root-level metadata.",
             "type": "object",
             "additionalProperties": true,
             "properties": {
                 "kernel_info": {
                     "description": "Kernel information.",
                     "type": "object",
                     "required": ["name", "language"],
                     "properties": {
                         "name": {
                             "description": "Name of the kernel specification.",
                             "type": "string"
                         },
                         "language": {
                             "description": "The programming language which this kernel runs.",
                             "type": "string"
                         },
                         "codemirror_mode": {
                             "description": "The codemirror mode to use for code in this language.",
                             "type": "string"
                         }
                     }
                 },
                 "signature": {
                     "description": "Hash of the notebook.",
                     "type": "string"
                 }
             }
         },
         "nbformat_minor": {
             "description": "Notebook format (minor number). Incremented for backward compatible changes to the notebook format.",
             "type": "integer",
             "minimum": 0
         },
         "nbformat": {
             "description": "Notebook format (major number). Incremented between backwards incompatible changes to the notebook format.",
             "type": "integer",
             "minimum": 3,
             "maximum": 3
         },
         "orig_nbformat": {
             "description": "Original notebook format (major number) before converting the notebook between versions.",
             "type": "integer",
             "minimum": 1
         },
         "worksheets" : {
             "description": "Array of worksheets",
             "type": "array",
             "items": {"$ref": "#/definitions/worksheet"}
         }
     },
 
     "definitions": {
         "worksheet": {
             "additionalProperties": false,
             "required" : ["cells"],
             "properties":{
                 "cells": {
                     "description": "Array of cells of the current notebook.",
                     "type": "array",
                     "items": {
                         "type": "object",
                         "oneOf": [
                             {"$ref": "#/definitions/raw_cell"},
                             {"$ref": "#/definitions/markdown_cell"},
                             {"$ref": "#/definitions/heading_cell"},
                             {"$ref": "#/definitions/code_cell"}
                         ]
                     }
                 },
                 "metadata": {
                     "type": "object",
                     "description": "metadata of the current worksheet"
                 }
             }
         },
         "raw_cell": {
             "description": "Notebook raw nbconvert cell.",
             "type": "object",
             "additionalProperties": false,
             "required": ["cell_type", "source"],
             "properties": {
                 "cell_type": {
                     "description": "String identifying the type of cell.",
                     "enum": ["raw"]
                 },
                 "metadata": {
                     "description": "Cell-level metadata.",
                     "type": "object",
                     "additionalProperties": true,
                     "properties": {
                         "format": {
                             "description": "Raw cell metadata format for nbconvert.",
                             "type": "string"
                         },
                         "name": {"$ref": "#/definitions/misc/metadata_name"},
                         "tags": {"$ref": "#/definitions/misc/metadata_tags"}
                     }
                 },
                 "source": {"$ref": "#/definitions/misc/source"}
             }
         },
 
         "markdown_cell": {
             "description": "Notebook markdown cell.",
             "type": "object",
             "additionalProperties": false,
             "required": ["cell_type", "source"],
             "properties": {
                 "cell_type": {
                     "description": "String identifying the type of cell.",
-                    "enum": ["markdown"]
+                    "enum": ["markdown", "html"]
                 },
                 "metadata": {
                     "description": "Cell-level metadata.",
                     "type": "object",
                     "properties": {
                         "name": {"$ref": "#/definitions/misc/metadata_name"},
                         "tags": {"$ref": "#/definitions/misc/metadata_tags"}
                     },
                     "additionalProperties": true
                 },
                 "source": {"$ref": "#/definitions/misc/source"}
             }
         },
 
         "heading_cell": {
             "description": "Notebook heading cell.",
             "type": "object",
             "additionalProperties": false,
             "required": ["cell_type", "source", "level"],
             "properties": {
                 "cell_type": {
                     "description": "String identifying the type of cell.",
                     "enum": ["heading"]
                 },
                 "metadata": {
                     "description": "Cell-level metadata.",
                     "type": "object",
                     "additionalProperties": true
                 },
                 "source": {"$ref": "#/definitions/misc/source"},
                 "level": {
                     "description": "Level of heading cells.",
                     "type": "integer",
                     "minimum": 1
                 }
             }
         },
 
         "code_cell": {
             "description": "Notebook code cell.",
             "type": "object",
             "additionalProperties": false,
             "required": ["cell_type", "input", "outputs", "collapsed", "language"],
             "properties": {
                 "cell_type": {
                     "description": "String identifying the type of cell.",
                     "enum": ["code"]
                 },
                 "language": {
                     "description": "The cell's language (always Python)",
                     "type": "string"
                 },
                 "collapsed": {
                     "description": "Whether the cell is collapsed/expanded.",
                     "type": "boolean"
                 },
                 "metadata": {
                     "description": "Cell-level metadata.",
                     "type": "object",
                     "additionalProperties": true
                 },
                 "input": {"$ref": "#/definitions/misc/source"},
                 "outputs": {
                     "description": "Execution, display, or stream outputs.",
                     "type": "array",
                     "items": {"$ref": "#/definitions/output"}
                 },
                 "prompt_number": {
                     "description": "The code cell's prompt number. Will be null if the cell has not been run.",
                     "type": ["integer", "null"],
                     "minimum": 0
                 }
             }
         },
         "output": {
             "type": "object",
             "oneOf": [
                 {"$ref": "#/definitions/pyout"},
                 {"$ref": "#/definitions/display_data"},
                 {"$ref": "#/definitions/stream"},
                 {"$ref": "#/definitions/pyerr"}
             ]
         },
         "pyout": {
             "description": "Result of executing a code cell.",
             "type": "object",
             "additionalProperties": false,
             "required": ["output_type", "prompt_number"],
             "properties": {
                 "output_type": {
                     "description": "Type of cell output.",
                     "enum": ["pyout"]
                 },
                 "prompt_number": {
                     "description": "A result's prompt number.",
                     "type": ["integer"],
                     "minimum": 0
                 },
                 "text": {"$ref": "#/definitions/misc/multiline_string"},
                 "latex": {"$ref": "#/definitions/misc/multiline_string"},
                 "png": {"$ref": "#/definitions/misc/multiline_string"},
                 "jpeg": {"$ref": "#/definitions/misc/multiline_string"},
                 "svg": {"$ref": "#/definitions/misc/multiline_string"},
                 "html": {"$ref": "#/definitions/misc/multiline_string"},
                 "javascript": {"$ref": "#/definitions/misc/multiline_string"},
                 "json": {"$ref": "#/definitions/misc/multiline_string"},
                 "pdf": {"$ref": "#/definitions/misc/multiline_string"},
                 "metadata": {"$ref": "#/definitions/misc/output_metadata"}
             },
             "patternProperties": {
                 "^[a-zA-Z0-9]+/[a-zA-Z0-9\\-\\+\\.]+$": {
                     "description": "mimetype output (e.g. text/plain), represented as either an array of strings or a string.",
                     "$ref": "#/definitions/misc/multiline_string"
                 }
             }
         },
 
         "display_data": {
             "description": "Data displayed as a result of code cell execution.",
             "type": "object",
             "additionalProperties": false,
             "required": ["output_type"],
             "properties": {
                 "output_type": {
                     "description": "Type of cell output.",
                     "enum": ["display_data"]
                 },
                 "text": {"$ref": "#/definitions/misc/multiline_string"},
                 "latex": {"$ref": "#/definitions/misc/multiline_string"},
                 "png": {"$ref": "#/definitions/misc/multiline_string"},
                 "jpeg": {"$ref": "#/definitions/misc/multiline_string"},
                 "svg": {"$ref": "#/definitions/misc/multiline_string"},
                 "html": {"$ref": "#/definitions/misc/multiline_string"},
                 "javascript": {"$ref": "#/definitions/misc/multiline_string"},
                 "json": {"$ref": "#/definitions/misc/multiline_string"},
                 "pdf": {"$ref": "#/definitions/misc/multiline_string"},
                 "metadata": {"$ref": "#/definitions/misc/output_metadata"}
             },
             "patternProperties": {
                 "[a-zA-Z0-9]+/[a-zA-Z0-9\\-\\+\\.]+$": {
                     "description": "mimetype output (e.g. text/plain), represented as either an array of strings or a string.",
                     "$ref": "#/definitions/misc/multiline_string"
                 }
             }
         },
 
         "stream": {
             "description": "Stream output from a code cell.",
             "type": "object",
             "additionalProperties": false,
             "required": ["output_type", "stream", "text"],
             "properties": {
                 "output_type": {
                     "description": "Type of cell output.",
                     "enum": ["stream"]
                 },
                 "stream": {
                     "description": "The stream type/destination.",
                     "type": "string"
                 },
                 "text": {
                     "description": "The stream's text output, represented as an array of strings.",
                     "$ref": "#/definitions/misc/multiline_string"
                 }
             }
         },
 
         "pyerr": {
             "description": "Output of an error that occurred during code cell execution.",
             "type": "object",
             "additionalProperties": false,
             "required": ["output_type", "ename", "evalue", "traceback"],
             "properties": {
                 "output_type": {
                     "description": "Type of cell output.",
                     "enum": ["pyerr"]
                 },
                 "metadata": {"$ref": "#/definitions/misc/output_metadata"},
                 "ename": {
                     "description": "The name of the error.",
                     "type": "string"
                 },
                 "evalue": {
                     "description": "The value, or message, of the error.",
                     "type": "string"
                 },
                 "traceback": {
                     "description": "The error's traceback, represented as an array of strings.",
                     "type": "array",
                     "items": {"type": "string"}
                 }
             }
         },
 
         "misc": {
             "metadata_name": {
                 "description": "The cell's name. If present, must be a non-empty string.",
                 "type": "string",
                 "pattern": "^.+$"
             },
             "metadata_tags": {
                 "description": "The cell's tags. Tags must be unique, and must not contain commas.",
                 "type": "array",
                 "uniqueItems": true,
                 "items": {
                     "type": "string",
                     "pattern": "^[^,]+$"
                 }
             },
             "source": {
                 "description": "Contents of the cell, represented as an array of lines.",
                 "$ref": "#/definitions/misc/multiline_string"
             },
             "prompt_number": {
                 "description": "The code cell's prompt number. Will be null if the cell has not been run.",
                 "type": ["integer", "null"],
                 "minimum": 0
             },
             "mimetype": {
                 "patternProperties": {
                     "^[a-zA-Z0-9\\-\\+]+/[a-zA-Z0-9\\-\\+]+": {
                         "description": "The cell's mimetype output (e.g. text/plain), represented as either an array of strings or a string.",
                         "$ref": "#/definitions/misc/multiline_string"
                     }
                 }
             },
             "output_metadata": {
                 "description": "Cell output metadata.",
                 "type": "object",
                 "additionalProperties": true
             },
             "multiline_string": {
                 "oneOf" : [
                     {"type": "string"},
                     {
                         "type": "array",
                         "items": {"type": "string"}
                     }
                 ]
             }
         }
     }
 }

IPython/nbformat/v3/tests/nbexamples.py

@@ -1,154 +1,152 b''
 # -*- coding: utf-8 -*-
 
 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, nbformat, nbformat_minor
 )
 
 # some random base64-encoded *text*
 png = encodestring(os.urandom(5)).decode('ascii')
 jpeg = encodestring(os.urandom(6)).decode('ascii')
 
-ws = new_worksheet(name='worksheet1')
+ws = new_worksheet()
 
 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'raw',
     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='a = 10\nb = 5\n',
     prompt_number=3,
 ))
 ws.cells.append(new_code_cell(
     input='a = 10\nb = 5',
     prompt_number=4,
 ))
 
 ws.cells.append(new_code_cell(
     input=u'print "ünîcødé"',
     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_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_json=u'{"json": "data"}',
         output_javascript=u'var i=0;'
     ),new_output(
         output_type=u'pyerr',
         ename=u'NameError',
         evalue=u'NameError was here',
         traceback=[u'frame 0', u'frame 1', u'frame 2']
     ),new_output(
         output_type=u'stream',
         output_text='foo\rbar\r\n'
     ),new_output(
         output_type=u'stream',
         stream='stderr',
         output_text='\rfoo\rbar\n'
     )]
 ))
 
 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')],
+    worksheets=[ws, new_worksheet()],
     metadata=md
 )
 
 nb0_py = u"""# -*- coding: utf-8 -*-
 # <nbformat>%i.%i</nbformat>
 
 # <htmlcell>
 
 # Some NumPy Examples
 
 # <codecell>
 
 import numpy
 
 # <markdowncell>
 
 # A random array
 
 # <rawcell>
 
 # A random array
 
 # <headingcell level=2>
 
 # My Heading
 
 # <codecell>
 
 a = numpy.random.rand(100)
 
 # <codecell>
 
 a = 10
 b = 5
 
 # <codecell>
 
 a = 10
 b = 5
 
 # <codecell>
 
 print "ünîcødé"
 
 """ % (nbformat, nbformat_minor)
 
 

IPython/nbformat/v3/tests/test_nbbase.py

@@ -1,157 +1,148 b''
 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, nbformat
 )
 
 class TestCell(TestCase):
 
     def test_empty_code_cell(self):
         cc = new_code_cell()
         self.assertEqual(cc.cell_type,u'code')
         self.assertEqual(u'input' not in cc, True)
         self.assertEqual(u'prompt_number' not in cc, True)
         self.assertEqual(cc.outputs, [])
         self.assertEqual(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.assertEqual(cc.input, u'a=10')
         self.assertEqual(cc.prompt_number, 0)
         self.assertEqual(cc.language, u'python')
         self.assertEqual(cc.outputs[0].svg, u'foo')
         self.assertEqual(cc.outputs[0].text, u'10')
         self.assertEqual(cc.outputs[0].prompt_number, 0)
         self.assertEqual(cc.collapsed, True)
 
     def test_pyerr(self):
         o = new_output(output_type=u'pyerr', ename=u'NameError',
             evalue=u'Name not found', traceback=[u'frame 0', u'frame 1', u'frame 2']
         )
         self.assertEqual(o.output_type, u'pyerr')
         self.assertEqual(o.ename, u'NameError')
         self.assertEqual(o.evalue, u'Name not found')
         self.assertEqual(o.traceback, [u'frame 0', u'frame 1', u'frame 2'])
 
     def test_empty_html_cell(self):
         tc = new_text_cell(u'html')
         self.assertEqual(tc.cell_type, u'html')
         self.assertEqual(u'source' not in tc, True)
-        self.assertEqual(u'rendered' not in tc, True)
 
     def test_html_cell(self):
-        tc = new_text_cell(u'html', 'hi', 'hi')
+        tc = new_text_cell(u'html', 'hi')
         self.assertEqual(tc.source, u'hi')
-        self.assertEqual(tc.rendered, u'hi')
 
     def test_empty_markdown_cell(self):
         tc = new_text_cell(u'markdown')
         self.assertEqual(tc.cell_type, u'markdown')
         self.assertEqual(u'source' not in tc, True)
-        self.assertEqual(u'rendered' not in tc, True)
 
     def test_markdown_cell(self):
-        tc = new_text_cell(u'markdown', 'hi', 'hi')
+        tc = new_text_cell(u'markdown', 'hi')
         self.assertEqual(tc.source, u'hi')
-        self.assertEqual(tc.rendered, u'hi')
 
     def test_empty_raw_cell(self):
         tc = new_text_cell(u'raw')
         self.assertEqual(tc.cell_type, u'raw')
         self.assertEqual(u'source' not in tc, True)
-        self.assertEqual(u'rendered' not in tc, True)
 
     def test_raw_cell(self):
-        tc = new_text_cell(u'raw', 'hi', 'hi')
+        tc = new_text_cell(u'raw', 'hi')
         self.assertEqual(tc.source, u'hi')
-        self.assertEqual(tc.rendered, u'hi')
 
     def test_empty_heading_cell(self):
         tc = new_heading_cell()
         self.assertEqual(tc.cell_type, u'heading')
         self.assertEqual(u'source' not in tc, True)
-        self.assertEqual(u'rendered' not in tc, True)
 
     def test_heading_cell(self):
-        tc = new_heading_cell(u'hi', u'hi', level=2)
+        tc = new_heading_cell(u'hi', level=2)
         self.assertEqual(tc.source, u'hi')
-        self.assertEqual(tc.rendered, u'hi')
         self.assertEqual(tc.level, 2)
 
 
 class TestWorksheet(TestCase):
 
     def test_empty_worksheet(self):
         ws = new_worksheet()
         self.assertEqual(ws.cells,[])
         self.assertEqual(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')
+        ws = new_worksheet(cells=cells)
         self.assertEqual(ws.cells,cells)
-        self.assertEqual(ws.name,u'foo')
 
 class TestNotebook(TestCase):
 
     def test_empty_notebook(self):
         nb = new_notebook()
         self.assertEqual(nb.worksheets, [])
         self.assertEqual(nb.metadata, NotebookNode())
         self.assertEqual(nb.nbformat,nbformat)
 
     def test_notebook(self):
         worksheets = [new_worksheet(),new_worksheet()]
         metadata = new_metadata(name=u'foo')
         nb = new_notebook(metadata=metadata,worksheets=worksheets)
         self.assertEqual(nb.metadata.name,u'foo')
         self.assertEqual(nb.worksheets,worksheets)
         self.assertEqual(nb.nbformat,nbformat)
 
     def test_notebook_name(self):
         worksheets = [new_worksheet(),new_worksheet()]
         nb = new_notebook(name='foo',worksheets=worksheets)
         self.assertEqual(nb.metadata.name,u'foo')
         self.assertEqual(nb.worksheets,worksheets)
         self.assertEqual(nb.nbformat,nbformat)
 
 class TestMetadata(TestCase):
 
     def test_empty_metadata(self):
         md = new_metadata()
         self.assertEqual(u'name' not in md, True)
         self.assertEqual(u'authors' not in md, True)
         self.assertEqual(u'license' not in md, True)
         self.assertEqual(u'saved' not in md, True)
         self.assertEqual(u'modified' not in md, True)
         self.assertEqual(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.assertEqual(md.name, u'foo')
         self.assertEqual(md.license, u'BSD')
         self.assertEqual(md.created, u'today')
         self.assertEqual(md.modified, u'now')
         self.assertEqual(md.gistid, u'21341231')
         self.assertEqual(md.authors, authors)
 
 class TestOutputs(TestCase):
     def test_binary_png(self):
         out = new_output(output_png=b'\x89PNG\r\n\x1a\n', output_type='display_data')
 
     def test_b64b6tes_png(self):
         out = new_output(output_png=b'iVBORw0KG', output_type='display_data')
     
     def test_binary_jpeg(self):
         out = new_output(output_jpeg=b'\xff\xd8', output_type='display_data')
 
     def test_b64b6tes_jpeg(self):
         out = new_output(output_jpeg=b'/9', output_type='display_data')