mv stream.stream > stream.name in nbformat.v4

matches message spec

IPython/nbformat/v4/nbbase.py

@@ -1,96 +1,96 b''
 """Python API for composing notebook elements
 
 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.
 
 from IPython.utils.ipstruct import Struct
 
 # Change this when incrementing the nbformat version
 nbformat = 4
 nbformat_minor = 0
 nbformat_schema = 'nbformat.v4.schema.json'
 
 def validate(node, ref=None):
     """validate a v4 node"""
     from ..current import validate
     return validate(node, ref=ref, version=nbformat)
 
 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, mime_bundle=None, **kwargs):
     """Create a new output, to go in the ``cell.outputs`` list of a code cell."""
     output = NotebookNode(output_type=output_type, **kwargs)
     if mime_bundle:
         output.update(mime_bundle)
     # populate defaults:
     output.setdefault('metadata', NotebookNode())
     if output_type == 'stream':
-        output.setdefault('stream', 'stdout')
+        output.setdefault('name', 'stdout')
         output.setdefault('text', '')
     validate(output, output_type)
     return output
 
 def new_code_cell(source='', **kwargs):
     """Create a new code cell"""
     cell = NotebookNode(cell_type='code', source=source, **kwargs)
     cell.setdefault('metadata', NotebookNode())
     cell.setdefault('source', '')
     cell.setdefault('prompt_number', None)
     cell.setdefault('outputs', [])
 
     validate(cell, 'code_cell')
     return cell
 
 def new_markdown_cell(source='', **kwargs):
     """Create a new markdown cell"""
     cell = NotebookNode(cell_type='markdown', source=source, **kwargs)
     cell.setdefault('metadata', NotebookNode())
 
     validate(cell, 'markdown_cell')
     return cell
 
 def new_heading_cell(source='', **kwargs):
     """Create a new heading cell"""
     cell = NotebookNode(cell_type='heading', source=source, **kwargs)
     cell.setdefault('metadata', NotebookNode())
     cell.setdefault('level', 1)
 
     validate(cell, 'heading_cell')
     return cell
 
 def new_raw_cell(source='', **kwargs):
     """Create a new raw cell"""
     cell = NotebookNode(cell_type='raw', source=source, **kwargs)
     cell.setdefault('metadata', NotebookNode())
 
     validate(cell, 'raw_cell')
     return cell
 
 def new_notebook(**kwargs):
     """Create a new notebook"""
     nb = NotebookNode(**kwargs)
     nb.nbformat = nbformat
     nb.nbformat_minor = nbformat_minor
     nb.setdefault('cells', [])
     nb.setdefault('metadata', NotebookNode())
     validate(nb)
     return nb

IPython/nbformat/v4/nbformat.v4.schema.json

@@ -1,346 +1,346 b''
 {
     "$schema": "http://json-schema.org/draft-04/schema#",
     "description": "IPython Notebook v4.0 JSON schema.",
     "type": "object",
     "additionalProperties": false,
     "required": ["metadata", "nbformat_minor", "nbformat", "cells"],
     "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"
                 },
                 "orig_nbformat": {
                     "description": "Original notebook format (major number) before converting the notebook between versions.",
                     "type": "integer",
                     "minimum": 1
                 }
             }
         },
         "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": 4,
             "maximum": 4
         },
         "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"}
                 ]
             }
         }
     },
 
     "definitions": {
 
         "raw_cell": {
             "description": "Notebook raw nbconvert cell.",
             "type": "object",
             "additionalProperties": false,
             "required": ["cell_type", "metadata", "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", "metadata", "source"],
             "properties": {
                 "cell_type": {
                     "description": "String identifying the type of cell.",
                     "enum": ["markdown"]
                 },
                 "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", "metadata", "source", "level"],
             "properties": {
                 "cell_type": {
                     "description": "String identifying the type of cell.",
                     "enum": ["heading"]
                 },
                 "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"},
                 "level": {
                     "description": "Level of heading cells.",
                     "type": "integer",
                     "minimum": 1
                 }
             }
         },
 
         "code_cell": {
             "description": "Notebook code cell.",
             "type": "object",
             "additionalProperties": false,
             "required": ["cell_type", "metadata", "source", "outputs", "prompt_number"],
             "properties": {
                 "cell_type": {
                     "description": "String identifying the type of cell.",
                     "enum": ["code"]
                 },
                 "metadata": {
                     "description": "Cell-level metadata.",
                     "type": "object",
                     "additionalProperties": true,
                     "properties": {
                         "collapsed": {
                             "description": "Whether the cell is collapsed/expanded.",
                             "type": "boolean"
                         },
                         "autoscroll": {
                             "description": "Whether the cell's output is scrolled, unscrolled, or autoscrolled.",
                             "enum": [true, false, "auto"]
                         },
                         "name": {"$ref": "#/definitions/misc/metadata_name"},
                         "tags": {"$ref": "#/definitions/misc/metadata_tags"}
                     }
                 },
                 "source": {"$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/execute_result"},
                 {"$ref": "#/definitions/display_data"},
                 {"$ref": "#/definitions/stream"},
                 {"$ref": "#/definitions/error"}
             ]
         },
         "execute_result": {
             "description": "Result of executing a code cell.",
             "type": "object",
             "additionalProperties": false,
             "required": ["output_type", "metadata", "prompt_number"],
             "properties": {
                 "output_type": {
                     "description": "Type of cell output.",
                     "enum": ["execute_result"]
                 },
                 "prompt_number": {
                     "description": "A result's prompt number.",
                     "type": ["integer"],
                     "minimum": 0
                 },
                 "application/json": {
                     "type": "object"
                 },
                 "metadata": {"$ref": "#/definitions/misc/output_metadata"}
             },
             "patternProperties": {
                 "^(?!application/json$)[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", "metadata"],
             "properties": {
                 "output_type": {
                     "description": "Type of cell output.",
                     "enum": ["display_data"]
                 },
                 "application/json": {
                     "type": "object"
                 },
                 "metadata": {"$ref": "#/definitions/misc/output_metadata"}
             },
             "patternProperties": {
                 "^(?!application/json$)[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", "metadata", "stream", "text"],
+            "required": ["output_type", "metadata", "name", "text"],
             "properties": {
                 "output_type": {
                     "description": "Type of cell output.",
                     "enum": ["stream"]
                 },
                 "metadata": {"$ref": "#/definitions/misc/output_metadata"},
-                "stream": {
-                    "description": "The stream type/destination.",
+                "name": {
+                    "description": "The name of the stream (stdout, stderr).",
                     "type": "string"
                 },
                 "text": {
                     "description": "The stream's text output, represented as an array of strings.",
                     "$ref": "#/definitions/misc/multiline_string"
                 }
             }
         },
 
         "error": {
             "description": "Output of an error that occurred during code cell execution.",
             "type": "object",
             "additionalProperties": false,
             "required": ["output_type", "metadata", "ename", "evalue", "traceback"],
             "properties": {
                 "output_type": {
                     "description": "Type of cell output.",
                     "enum": ["error"]
                 },
                 "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/v4/tests/nbexamples.py

@@ -1,105 +1,105 b''
 # -*- coding: utf-8 -*-
 
 import os
 from base64 import encodestring
 
 from ..nbbase import (
     new_code_cell, new_heading_cell, new_markdown_cell, new_notebook,
     new_output, new_raw_cell
 )
 
 # some random base64-encoded *text*
 png = encodestring(os.urandom(5)).decode('ascii')
 jpeg = encodestring(os.urandom(6)).decode('ascii')
 
 cells = []
 cells.append(new_markdown_cell(
     source='Some NumPy Examples',
 ))
 
 
 cells.append(new_code_cell(
     source='import numpy',
     prompt_number=1,
 ))
 
 cells.append(new_markdown_cell(
     source='A random array',
 ))
 
 cells.append(new_raw_cell(
     source='A random array',
 ))
 
 cells.append(new_heading_cell(
     source=u'My Heading',
     level=2,
 ))
 
 cells.append(new_code_cell(
     source='a = numpy.random.rand(100)',
     prompt_number=2,
 ))
 cells.append(new_code_cell(
     source='a = 10\nb = 5\n',
     prompt_number=3,
 ))
 cells.append(new_code_cell(
     source='a = 10\nb = 5',
     prompt_number=4,
 ))
 
 cells.append(new_code_cell(
     source=u'print "ünîcødé"',
     prompt_number=3,
     outputs=[new_output(
         output_type=u'execute_result',
         mime_bundle={
             'text/plain': u'<array a>',
             'text/html': u'The HTML rep',
             'text/latex': u'$a$',
             'image/png': png,
             'image/jpeg': jpeg,
             'image/svg+xml': u'<svg>',
             'application/json': {
                 'key': 'value'
             },
             'application/javascript': u'var i=0;'
         },
         prompt_number=3
     ),new_output(
         output_type=u'display_data',
         mime_bundle={
             'text/plain': u'<array a>',
             'text/html': u'The HTML rep',
             'text/latex': u'$a$',
             'image/png': png,
             'image/jpeg': jpeg,
             'image/svg+xml': u'<svg>',
             'application/json': {
                 'key': 'value'
             },
             'application/javascript': u'var i=0;'
         },
     ),new_output(
         output_type=u'error',
         ename=u'NameError',
         evalue=u'NameError was here',
         traceback=[u'frame 0', u'frame 1', u'frame 2']
     ),new_output(
         output_type=u'stream',
         text='foo\rbar\r\n'
     ),new_output(
         output_type=u'stream',
-        stream='stderr',
+        name='stderr',
         text='\rfoo\rbar\n'
     )]
 ))
 
 nb0 = new_notebook(cells=cells,
     metadata={
         'language': 'python',
     }
 )
 
 

IPython/nbformat/v4/tests/test_nbbase.py

@@ -1,105 +1,112 b''
 # coding: utf-8
 """Tests for the Python API for composing notebook elements"""
 
 import nose.tools as nt
 
 from IPython.nbformat.validator import isvalid, validate, ValidationError
 from ..nbbase import (
     NotebookNode, nbformat,
     new_code_cell, new_heading_cell, new_markdown_cell, new_notebook,
     new_output, new_raw_cell,
 )
 
 def test_empty_notebook():
     nb = new_notebook()
     nt.assert_equal(nb.cells, [])
     nt.assert_equal(nb.metadata, NotebookNode())
     nt.assert_equal(nb.nbformat, nbformat)
 
 def test_empty_markdown_cell():
     cell = new_markdown_cell()
     nt.assert_equal(cell.cell_type, 'markdown')
     nt.assert_equal(cell.source, '')
 
 def test_markdown_cell():
     cell = new_markdown_cell(u'* Søme markdown')
     nt.assert_equal(cell.source, u'* Søme markdown')
 
 def test_empty_raw_cell():
     cell = new_raw_cell()
     nt.assert_equal(cell.cell_type, u'raw')
     nt.assert_equal(cell.source, '')
 
 def test_raw_cell():
     cell = new_raw_cell('hi')
     nt.assert_equal(cell.source, u'hi')
 
 def test_empty_heading_cell():
     cell = new_heading_cell()
     nt.assert_equal(cell.cell_type, u'heading')
     nt.assert_equal(cell.source, '')
     nt.assert_equal(cell.level, 1)
 
 def test_heading_cell():
     cell = new_heading_cell(u'hi', level=2)
     nt.assert_equal(cell.source, u'hi')
     nt.assert_equal(cell.level, 2)
 
 def test_empty_code_cell():
     cell = new_code_cell('hi')
     nt.assert_equal(cell.cell_type, 'code')
     nt.assert_equal(cell.source, u'hi')
 
 def test_empty_display_data():
     output = new_output('display_data')
     nt.assert_equal(output.output_type, 'display_data')
 
 def test_empty_stream():
-    output = new_output('stream', stream='stdout', text='')
+    output = new_output('stream')
     nt.assert_equal(output.output_type, 'stream')
+    nt.assert_equal(output.name, 'stdout')
+    nt.assert_equal(output.text, '')
 
 def test_empty_execute_result():
     output = new_output('execute_result', prompt_number=1)
     nt.assert_equal(output.output_type, 'execute_result')
 
 mimebundle = {
     'text/plain': "some text",
     "application/json": {
         "key": "value"
     },
     "image/svg+xml": 'ABCDEF',
     "application/octet-stream": 'ABC-123',
     "application/vnd.foo+bar": "Some other stuff",
 }
 
 def test_display_data():
     output = new_output('display_data', mimebundle)
     for key, expected in mimebundle.items():
         nt.assert_equal(output[key], expected)
 
 def test_execute_result():
     output = new_output('execute_result', mimebundle, prompt_number=10)
     nt.assert_equal(output.prompt_number, 10)
     for key, expected in mimebundle.items():
         nt.assert_equal(output[key], expected)
 
 def test_error():
     o = new_output(output_type=u'error', ename=u'NameError',
         evalue=u'Name not found', traceback=[u'frame 0', u'frame 1', u'frame 2']
     )
     nt.assert_equal(o.output_type, u'error')
     nt.assert_equal(o.ename, u'NameError')
     nt.assert_equal(o.evalue, u'Name not found')
     nt.assert_equal(o.traceback, [u'frame 0', u'frame 1', u'frame 2'])
 
 def test_code_cell_with_outputs():
     cell = new_code_cell(prompt_number=10, outputs=[
         new_output('display_data', mimebundle),
         new_output('stream', text='hello'),
         new_output('execute_result', mimebundle, prompt_number=10),
     ])
     nt.assert_equal(cell.prompt_number, 10)
     nt.assert_equal(len(cell.outputs), 3)
     er = cell.outputs[-1]
     nt.assert_equal(er.prompt_number, 10)
     nt.assert_equal(er['output_type'], 'execute_result')
+
+def test_stream():
+    output = new_output('stream', name='stderr', text='hello there')
+    nt.assert_equal(output.name, 'stderr')
+    nt.assert_equal(output.text, 'hello there')