handle missing stream name in nbformat conversion

It was sometimes possible for this key to be absent.
Even though that's never been officially valid,
it happened, so might as well handle it.

IPython/nbformat/v4/convert.py

@@ -1,253 +1,253 b''
 """Code for converting notebooks to and from v3."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import json
 import re
 
 from .nbbase import (
     nbformat, nbformat_minor,
     NotebookNode,
 )
 
 from IPython.nbformat import v3
 from IPython.utils.log import get_logger
 
 def _warn_if_invalid(nb, version):
     """Log validation errors, if there are any."""
     from IPython.nbformat import validate, ValidationError
     try:
         validate(nb, version=version)
     except ValidationError as e:
         get_logger().error("Notebook JSON is not valid v%i: %s", version, e)
 
 def upgrade(nb, from_version=3, from_minor=0):
     """Convert a notebook to v4.
 
     Parameters
     ----------
     nb : NotebookNode
         The Python representation of the notebook to convert.
     from_version : int
         The original version of the notebook to convert.
     from_minor : int
         The original minor version of the notebook to convert (only relevant for v >= 3).
     """
     if from_version == 3:
         # Validate the notebook before conversion
         _warn_if_invalid(nb, from_version)
 
         # Mark the original nbformat so consumers know it has been converted
         orig_nbformat = nb.pop('orig_nbformat', None)
         nb.metadata.orig_nbformat = orig_nbformat or 3
 
         # Mark the new format
         nb.nbformat = nbformat
         nb.nbformat_minor = nbformat_minor
 
         # remove worksheet(s)
         nb['cells'] = cells = []
         # In the unlikely event of multiple worksheets,
         # they will be flattened
         for ws in nb.pop('worksheets', []):
             # upgrade each cell
             for cell in ws['cells']:
                 cells.append(upgrade_cell(cell))
         # upgrade metadata
         nb.metadata.pop('name', '')
         nb.metadata.pop('signature', '')
         # Validate the converted notebook before returning it
         _warn_if_invalid(nb, nbformat)
         return nb
     elif from_version == 4:
         # nothing to do
         if from_minor != nbformat_minor:
             nb.metadata.orig_nbformat_minor = from_minor
         nb.nbformat_minor = nbformat_minor
 
         return nb
     else:
         raise ValueError('Cannot convert a notebook directly from v%s to v4.  ' \
                 'Try using the IPython.nbformat.convert module.' % from_version)
 
 def upgrade_cell(cell):
     """upgrade a cell from v3 to v4
 
     heading cell:
         - -> markdown heading
     code cell:
         - remove language metadata
         - cell.input -> cell.source
         - cell.prompt_number -> cell.execution_count
         - update outputs
     """
     cell.setdefault('metadata', NotebookNode())
     if cell.cell_type == 'code':
         cell.pop('language', '')
         if 'collapsed' in cell:
             cell.metadata['collapsed'] = cell.pop('collapsed')
         cell.source = cell.pop('input', '')
         cell.execution_count = cell.pop('prompt_number', None)
         cell.outputs = upgrade_outputs(cell.outputs)
     elif cell.cell_type == 'heading':
         cell.cell_type = 'markdown'
         level = cell.pop('level', 1)
         cell.source = u'{hashes} {single_line}'.format(
             hashes='#' * level,
             single_line = ' '.join(cell.get('source', '').splitlines()),
         )
     elif cell.cell_type == 'html':
         # Technically, this exists. It will never happen in practice.
         cell.cell_type = 'markdown'
     return cell
 
 def downgrade_cell(cell):
     """downgrade a cell from v4 to v3
 
     code cell:
         - set cell.language
         - cell.input <- cell.source
         - cell.prompt_number <- cell.execution_count
         - update outputs
     markdown cell:
         - single-line heading -> heading cell
     """
     if cell.cell_type == 'code':
         cell.language = 'python'
         cell.input = cell.pop('source', '')
         cell.prompt_number = cell.pop('execution_count', None)
         cell.collapsed = cell.metadata.pop('collapsed', False)
         cell.outputs = downgrade_outputs(cell.outputs)
     elif cell.cell_type == 'markdown':
         source = cell.get('source', '')
         if '\n' not in source and source.startswith('#'):
             prefix, text = re.match(r'(#+)\s*(.*)', source).groups()
             cell.cell_type = 'heading'
             cell.source = text
             cell.level = len(prefix)
     return cell
 
 _mime_map = {
     "text" : "text/plain",
     "html" : "text/html",
     "svg" : "image/svg+xml",
     "png" : "image/png",
     "jpeg" : "image/jpeg",
     "latex" : "text/latex",
     "json" : "application/json",
     "javascript" : "application/javascript",
 };
 
 def to_mime_key(d):
     """convert dict with v3 aliases to plain mime-type keys"""
     for alias, mime in _mime_map.items():
         if alias in d:
             d[mime] = d.pop(alias)
     return d
 
 def from_mime_key(d):
     """convert dict with mime-type keys to v3 aliases"""
     for alias, mime in _mime_map.items():
         if mime in d:
             d[alias] = d.pop(mime)
     return d
 
 def upgrade_output(output):
     """upgrade a single code cell output from v3 to v4
 
     - pyout -> execute_result
     - pyerr -> error
     - output.type -> output.data.mime/type
     - mime-type keys
     - stream.stream -> stream.name
     """
     if output['output_type'] in {'pyout', 'display_data'}:
         output.setdefault('metadata', NotebookNode())
         if output['output_type'] == 'pyout':
             output['output_type'] = 'execute_result'
             output['execution_count'] = output.pop('prompt_number', None)
 
         # move output data into data sub-dict
         data = {}
         for key in list(output):
             if key in {'output_type', 'execution_count', 'metadata'}:
                 continue
             data[key] = output.pop(key)
         to_mime_key(data)
         output['data'] = data
         to_mime_key(output.metadata)
         if 'application/json' in data:
             data['application/json'] = json.loads(data['application/json'])
         # promote ascii bytes (from v2) to unicode
         for key in ('image/png', 'image/jpeg'):
             if key in data and isinstance(data[key], bytes):
                 data[key] = data[key].decode('ascii')
     elif output['output_type'] == 'pyerr':
         output['output_type'] = 'error'
     elif output['output_type'] == 'stream':
-        output['name'] = output.pop('stream')
+        output['name'] = output.pop('stream', 'stdout')
     return output
 
 def downgrade_output(output):
     """downgrade a single code cell output to v3 from v4
 
     - pyout <- execute_result
     - pyerr <- error
     - output.data.mime/type -> output.type
     - un-mime-type keys
     - stream.stream <- stream.name
     """
     if output['output_type'] in {'execute_result', 'display_data'}:
         if output['output_type'] == 'execute_result':
             output['output_type'] = 'pyout'
             output['prompt_number'] = output.pop('execution_count', None)
 
         # promote data dict to top-level output namespace
         data = output.pop('data', {})
         if 'application/json' in data:
             data['application/json'] = json.dumps(data['application/json'])
         from_mime_key(data)
         output.update(data)
         from_mime_key(output.get('metadata', {}))
     elif output['output_type'] == 'error':
         output['output_type'] = 'pyerr'
     elif output['output_type'] == 'stream':
         output['stream'] = output.pop('name')
     return output
 
 def upgrade_outputs(outputs):
     """upgrade outputs of a code cell from v3 to v4"""
     return [upgrade_output(op) for op in outputs]
 
 def downgrade_outputs(outputs):
     """downgrade outputs of a code cell to v3 from v4"""
     return [downgrade_output(op) for op in outputs]
 
 def downgrade(nb):
     """Convert a v4 notebook to v3.
 
     Parameters
     ----------
     nb : NotebookNode
         The Python representation of the notebook to convert.
     """
     if nb.nbformat != nbformat:
         return nb
 
     # Validate the notebook before conversion
     _warn_if_invalid(nb, nbformat)
 
     nb.nbformat = v3.nbformat
     nb.nbformat_minor = v3.nbformat_minor
     cells = [ downgrade_cell(cell) for cell in nb.pop('cells') ]
     nb.worksheets = [v3.new_worksheet(cells=cells)]
     nb.metadata.setdefault('name', '')
     
     # Validate the converted notebook before returning it
     _warn_if_invalid(nb, v3.nbformat)
     
     nb.orig_nbformat = nb.metadata.pop('orig_nbformat', nbformat)
     nb.orig_nbformat_minor = nb.metadata.pop('orig_nbformat_minor', nbformat_minor)
     
     return nb