adding stream kwarg to current.new_output

This was missing, and made unnecessarily clunky to create output cells
of stream type using the nbformat API.

Before this commit, you had to do something like

  from IPython.nbformat import current as c
  output = c.new_output('stream', the_text)
  output['stream'] = 'stdout'

after this commit

  from IPython.nbformat import current as c
  output = c.new_output('stream', the_text, stream='stdout')

IPython/nbformat/v3/nbbase.py

@@ -1,206 +1,209 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
 #-----------------------------------------------------------------------------
 
 import pprint
 import uuid
 
 from IPython.utils.ipstruct import Struct
 
 #-----------------------------------------------------------------------------
 # 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,
     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):
+    etype=None, evalue=None, traceback=None, stream=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)]
 
+    if output_type == u'stream':
+        output.stream = 'stdout' if stream is None else 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 = 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)
     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 = unicode(source)
     if rendered is not None:
         cell.rendered = 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 = unicode(source)
     if rendered is not None:
         cell.rendered = 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 = 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 = 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 = 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/tests/nbexamples.py

@@ -1,153 +1,154 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 *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'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_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']
     ),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')],
     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)