output_type should not be optional in new_output

and fix bug that this would have revealed

IPython/html/nbconvert/tests/test_nbconvert_handlers.py

@@ -1,129 +1,129
 # coding: utf-8
 import base64
 import io
 import json
 import os
 from os.path import join as pjoin
 import shutil
 
 import requests
 
 from IPython.html.utils import url_path_join
 from IPython.html.tests.launchnotebook import NotebookTestBase, assert_http_error
 from IPython.nbformat.current import (new_notebook, write, new_worksheet,
                                       new_heading_cell, new_code_cell,
                                       new_output)
 
 from IPython.testing.decorators import onlyif_cmds_exist
 
 
 class NbconvertAPI(object):
     """Wrapper for nbconvert API calls."""
     def __init__(self, base_url):
         self.base_url = base_url
 
     def _req(self, verb, path, body=None, params=None):
         response = requests.request(verb,
                 url_path_join(self.base_url, 'nbconvert', path),
                 data=body, params=params,
         )
         response.raise_for_status()
         return response
 
     def from_file(self, format, path, name, download=False):
         return self._req('GET', url_path_join(format, path, name),
                          params={'download':download})
 
     def from_post(self, format, nbmodel):
         body = json.dumps(nbmodel)
         return self._req('POST', format, body)
 
     def list_formats(self):
         return self._req('GET', '')
 
 png_green_pixel = base64.encodestring(b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00'
 b'\x00\x00\x01\x00\x00x00\x01\x08\x02\x00\x00\x00\x90wS\xde\x00\x00\x00\x0cIDAT'
 b'\x08\xd7c\x90\xfb\xcf\x00\x00\x02\\\x01\x1e.~d\x87\x00\x00\x00\x00IEND\xaeB`\x82')
 
 class APITest(NotebookTestBase):
     def setUp(self):
         nbdir = self.notebook_dir.name
         
         if not os.path.isdir(pjoin(nbdir, 'foo')):
             os.mkdir(pjoin(nbdir, 'foo'))
         
         nb = new_notebook(name='testnb')
         
         ws = new_worksheet()
         nb.worksheets = [ws]
         ws.cells.append(new_heading_cell(u'Created by test ³'))
         cc1 = new_code_cell(input=u'print(2*6)')
-        cc1.outputs.append(new_output(output_text=u'12'))
+        cc1.outputs.append(new_output(output_text=u'12', output_type='stream'))
         cc1.outputs.append(new_output(output_png=png_green_pixel, output_type='pyout'))
         ws.cells.append(cc1)
         
         with io.open(pjoin(nbdir, 'foo', 'testnb.ipynb'), 'w',
                      encoding='utf-8') as f:
             write(nb, f, format='ipynb')
 
         self.nbconvert_api = NbconvertAPI(self.base_url())
 
     def tearDown(self):
         nbdir = self.notebook_dir.name
 
         for dname in ['foo']:
             shutil.rmtree(pjoin(nbdir, dname), ignore_errors=True)
     
     @onlyif_cmds_exist('pandoc')
     def test_from_file(self):
         r = self.nbconvert_api.from_file('html', 'foo', 'testnb.ipynb')
         self.assertEqual(r.status_code, 200)
         self.assertIn(u'text/html', r.headers['Content-Type'])
         self.assertIn(u'Created by test', r.text)
         self.assertIn(u'print', r.text)
 
         r = self.nbconvert_api.from_file('python', 'foo', 'testnb.ipynb')
         self.assertIn(u'text/x-python', r.headers['Content-Type'])
         self.assertIn(u'print(2*6)', r.text)
 
     @onlyif_cmds_exist('pandoc')
     def test_from_file_404(self):
         with assert_http_error(404):
             self.nbconvert_api.from_file('html', 'foo', 'thisdoesntexist.ipynb')
 
     @onlyif_cmds_exist('pandoc')
     def test_from_file_download(self):
         r = self.nbconvert_api.from_file('python', 'foo', 'testnb.ipynb', download=True)
         content_disposition = r.headers['Content-Disposition']
         self.assertIn('attachment', content_disposition)
         self.assertIn('testnb.py', content_disposition)
 
     @onlyif_cmds_exist('pandoc')
     def test_from_file_zip(self):
         r = self.nbconvert_api.from_file('latex', 'foo', 'testnb.ipynb', download=True)
         self.assertIn(u'application/zip', r.headers['Content-Type'])
         self.assertIn(u'.zip', r.headers['Content-Disposition'])
 
     @onlyif_cmds_exist('pandoc')
     def test_from_post(self):
         nbmodel_url = url_path_join(self.base_url(), 'api/notebooks/foo/testnb.ipynb')
         nbmodel = requests.get(nbmodel_url).json()
         
         r = self.nbconvert_api.from_post(format='html', nbmodel=nbmodel)
         self.assertEqual(r.status_code, 200)
         self.assertIn(u'text/html', r.headers['Content-Type'])
         self.assertIn(u'Created by test', r.text)
         self.assertIn(u'print', r.text)
         
         r = self.nbconvert_api.from_post(format='python', nbmodel=nbmodel)
         self.assertIn(u'text/x-python', r.headers['Content-Type'])
         self.assertIn(u'print(2*6)', r.text)
 
     @onlyif_cmds_exist('pandoc')
     def test_from_post_zip(self):
         nbmodel_url = url_path_join(self.base_url(), 'api/notebooks/foo/testnb.ipynb')
         nbmodel = requests.get(nbmodel_url).json()
 
         r = self.nbconvert_api.from_post(format='latex', nbmodel=nbmodel)
         self.assertIn(u'application/zip', r.headers['Content-Type'])
         self.assertIn(u'.zip', r.headers['Content-Disposition'])

IPython/nbformat/v3/nbbase.py

@@ -1,217 +1,204
 """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
-#-----------------------------------------------------------------------------
+# 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
 
 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,
+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()
-    if output_type is not None:
-        output.output_type = unicode_type(output_type)
+    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)
     
     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):
     """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/tests/test_nbbase.py

@@ -1,157 +1,157
 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')
         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')
         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')
         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)
         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')
         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')
+        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')
+        out = new_output(output_png=b'iVBORw0KG', output_type='display_data')
     
     def test_binary_jpeg(self):
-        out = new_output(output_jpeg=b'\xff\xd8')
+        out = new_output(output_jpeg=b'\xff\xd8', output_type='display_data')
 
     def test_b64b6tes_jpeg(self):
-        out = new_output(output_jpeg=b'/9')
+        out = new_output(output_jpeg=b'/9', output_type='display_data')