Backport PR #5535: fix n^2 performance issue in coalesce_streams preprocessor

for n consecutive stream outputs, `\r` fix would be compiled n times, and applied to each ith output (n-i) times.

- move pattern to module level
- apply replacement after coalescing outputs

An example notebook from nbviewer with ~1k outputs that was taking 90 seconds to render now takes 3 seconds.

IPython/html/nbconvert/tests/test_nbconvert_handlers.py

@@ -1,129 +1,129 b''
 # 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/nbconvert/preprocessors/base.py

@@ -1,111 +1,93 b''
-"""
-Module that re-groups preprocessor that would be applied to ipynb files
-before going through the templating machinery.
-
-It exposes a convenient class to inherit from to access configurability.
-"""
-#-----------------------------------------------------------------------------
-# Copyright (c) 2013, the IPython Development Team.
-#
-# Distributed under the terms of the Modified BSD License.
-#
-# The full license is in the file COPYING.txt, distributed with this software.
-#-----------------------------------------------------------------------------
+"""Base class for preprocessors"""
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 from ..utils.base import NbConvertBase
 from IPython.utils.traitlets import Bool
 
-#-----------------------------------------------------------------------------
-# Classes and Functions
-#-----------------------------------------------------------------------------
 
 class Preprocessor(NbConvertBase):
     """ A configurable preprocessor
 
     Inherit from this class if you wish to have configurability for your
     preprocessor.
 
     Any configurable traitlets this class exposed will be configurable in
-    profiles using c.SubClassName.atribute=value
+    profiles using c.SubClassName.attribute = value
 
     you can overwrite :meth:`preprocess_cell` to apply a transformation
     independently on each cell or :meth:`preprocess` if you prefer your own
     logic. See corresponding docstring for informations.
 
     Disabled by default and can be enabled via the config by
         'c.YourPreprocessorName.enabled = True'
     """
     
     enabled = Bool(False, config=True)
 
     def __init__(self, **kw):
         """
         Public constructor
         
         Parameters
         ----------
         config : Config
             Configuration file structure
         **kw : misc
             Additional arguments
         """
         
         super(Preprocessor, self).__init__(**kw)
 
        
     def __call__(self, nb, resources):
         if self.enabled:
+            self.log.debug("Applying preprocessor: %s", self.__class__.__name__)
             return self.preprocess(nb,resources)
         else:
             return nb, resources
 
 
     def preprocess(self, nb, resources):
         """
         Preprocessing to apply on each notebook.
         
-        You should return modified nb, resources.
+        Must return modified nb, resources.
+
         If you wish to apply your preprocessing to each cell, you might want
-        to overwrite preprocess_cell method instead.
+        to override preprocess_cell method instead.
         
         Parameters
         ----------
         nb : NotebookNode
             Notebook being converted
         resources : dictionary
             Additional resources used in the conversion process.  Allows
             preprocessors to pass variables into the Jinja engine.
         """
-        self.log.debug("Applying preprocess: %s", self.__class__.__name__)
-        try :
-            for worksheet in nb.worksheets:
-                for index, cell in enumerate(worksheet.cells):
-                    worksheet.cells[index], resources = self.preprocess_cell(cell, resources, index)
-            return nb, resources
-        except NotImplementedError:
-            raise NotImplementedError('should be implemented by subclass')
+        for worksheet in nb.worksheets:
+            for index, cell in enumerate(worksheet.cells):
+                worksheet.cells[index], resources = self.preprocess_cell(cell, resources, index)
+        return nb, resources
 
 
     def preprocess_cell(self, cell, resources, index):
         """
-        Overwrite if you want to apply some preprocessing to each cell.  You 
-        should return modified cell and resource dictionary.
+        Override if you want to apply some preprocessing to each cell.
+        Must return modified cell and resource dictionary.
         
         Parameters
         ----------
         cell : NotebookNode cell
             Notebook cell being processed
         resources : dictionary
             Additional resources used in the conversion process.  Allows
             preprocessors to pass variables into the Jinja engine.
         index : int
             Index of the cell being processed
         """
 
         raise NotImplementedError('should be implemented by subclass')
         return cell, resources
 

IPython/nbconvert/preprocessors/coalescestreams.py

@@ -1,83 +1,77 b''
-"""Module that allows latex output notebooks to be conditioned before
-they are converted.  Exposes a decorator (@cell_preprocessor) in
-addition to the coalesce_streams pre-proccessor.
-"""
-#-----------------------------------------------------------------------------
-# Copyright (c) 2013, the IPython Development Team.
-#
+"""Preprocessor for merging consecutive stream outputs for easier handling."""
+
+# 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
-#-----------------------------------------------------------------------------
 import re
 
-#-----------------------------------------------------------------------------
-# Functions
-#-----------------------------------------------------------------------------
 def cell_preprocessor(function):
     """
     Wrap a function to be executed on all cells of a notebook
     
     The wrapped function should have these parameters:
     
     cell : NotebookNode cell
         Notebook cell being processed
     resources : dictionary
         Additional resources used in the conversion process.  Allows
         preprocessors to pass variables into the Jinja engine.
     index : int
         Index of the cell being processed
     """
     
     def wrappedfunc(nb, resources):
-        for worksheet in nb.worksheets :
+        from IPython.config import Application
+        if Application.initialized():
+            Application.instance().log.debug(
+                "Applying preprocessor: %s", function.__name__
+            )
+        for worksheet in nb.worksheets:
             for index, cell in enumerate(worksheet.cells):
                 worksheet.cells[index], resources = function(cell, resources, index)
         return nb, resources
     return wrappedfunc
 
+cr_pat = re.compile(r'.*\r(?=[^\n])')
 
 @cell_preprocessor
 def coalesce_streams(cell, resources, index):
     """
     Merge consecutive sequences of stream output into single stream
     to prevent extra newlines inserted at flush calls
     
     Parameters
     ----------
     cell : NotebookNode cell
         Notebook cell being processed
     resources : dictionary
         Additional resources used in the conversion process.  Allows
         transformers to pass variables into the Jinja engine.
     index : int
         Index of the cell being processed
     """
     
     outputs = cell.get('outputs', [])
     if not outputs:
         return cell, resources
     
     last = outputs[0]
     new_outputs = [last]
-    
     for output in outputs[1:]:
         if (output.output_type == 'stream' and
             last.output_type == 'stream' and
             last.stream == output.stream
         ):
             last.text += output.text
 
-            # Respect \r characters.
-            cr_pat = re.compile(r'.*\r(?=[^\n])')
-            last.text = cr_pat.sub('', last.text)
         else:
             new_outputs.append(output)
             last = output
 
+    # process \r characters
+    for output in new_outputs:
+        if output.output_type == 'stream':
+            output.text = cr_pat.sub('', output.text)
+
     cell.outputs = new_outputs
     return cell, resources

IPython/nbformat/v3/nbbase.py

@@ -1,217 +1,204 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.
-
-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 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')
         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')