allow name as kwarg to new_notebook

avoids unnecessary breakage of backwards-compatible interface when creating new notebook.

IPython/nbformat/v3/nbbase.py

@@ -1,194 +1,196
 """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
 
 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):
     """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)]
 
     return output
 
 
 def new_code_cell(input=None, prompt_number=None, outputs=None,
     language=u'python', collapsed=False):
     """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)
 
     return cell
 
 def new_text_cell(cell_type, source=None, rendered=None):
     """Create a new text cell."""
     cell = NotebookNode()
     if source is not None:
         cell.source = unicode(source)
     if rendered is not None:
         cell.rendered = unicode(rendered)
     cell.cell_type = cell_type
     return cell
 
 
 def new_heading_cell(source=None, rendered=None, level=1):
     """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)
     return cell
 
 
 def new_worksheet(name=None, cells=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)
     return ws
 
 
-def new_notebook(metadata=None, worksheets=None):
+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
     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/test_nbbase.py

@@ -1,136 +1,143
 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.assertEquals(cc.cell_type,u'code')
         self.assertEquals(u'input' not in cc, True)
         self.assertEquals(u'prompt_number' not in cc, True)
         self.assertEquals(cc.outputs, [])
         self.assertEquals(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.assertEquals(cc.input, u'a=10')
         self.assertEquals(cc.prompt_number, 0)
         self.assertEquals(cc.language, u'python')
         self.assertEquals(cc.outputs[0].svg, u'foo')
         self.assertEquals(cc.outputs[0].text, u'10')
         self.assertEquals(cc.outputs[0].prompt_number, 0)
         self.assertEquals(cc.collapsed, True)
 
     def test_pyerr(self):
         o = new_output(output_type=u'pyerr', etype=u'NameError',
             evalue=u'Name not found', traceback=[u'frame 0', u'frame 1', u'frame 2']
         )
         self.assertEquals(o.output_type, u'pyerr')
         self.assertEquals(o.etype, u'NameError')
         self.assertEquals(o.evalue, u'Name not found')
         self.assertEquals(o.traceback, [u'frame 0', u'frame 1', u'frame 2'])
 
     def test_empty_html_cell(self):
         tc = new_text_cell(u'html')
         self.assertEquals(tc.cell_type, u'html')
         self.assertEquals(u'source' not in tc, True)
         self.assertEquals(u'rendered' not in tc, True)
 
     def test_html_cell(self):
         tc = new_text_cell(u'html', 'hi', 'hi')
         self.assertEquals(tc.source, u'hi')
         self.assertEquals(tc.rendered, u'hi')
 
     def test_empty_markdown_cell(self):
         tc = new_text_cell(u'markdown')
         self.assertEquals(tc.cell_type, u'markdown')
         self.assertEquals(u'source' not in tc, True)
         self.assertEquals(u'rendered' not in tc, True)
 
     def test_markdown_cell(self):
         tc = new_text_cell(u'markdown', 'hi', 'hi')
         self.assertEquals(tc.source, u'hi')
         self.assertEquals(tc.rendered, u'hi')
 
     def test_empty_plaintext_cell(self):
         tc = new_text_cell(u'plaintext')
         self.assertEquals(tc.cell_type, u'plaintext')
         self.assertEquals(u'source' not in tc, True)
         self.assertEquals(u'rendered' not in tc, True)
 
     def test_plaintext_cell(self):
         tc = new_text_cell(u'plaintext', 'hi', 'hi')
         self.assertEquals(tc.source, u'hi')
         self.assertEquals(tc.rendered, u'hi')
 
     def test_empty_heading_cell(self):
         tc = new_heading_cell()
         self.assertEquals(tc.cell_type, u'heading')
         self.assertEquals(u'source' not in tc, True)
         self.assertEquals(u'rendered' not in tc, True)
 
     def test_heading_cell(self):
         tc = new_heading_cell(u'hi', u'hi', level=2)
         self.assertEquals(tc.source, u'hi')
         self.assertEquals(tc.rendered, u'hi')
         self.assertEquals(tc.level, 2)
 
 
 class TestWorksheet(TestCase):
 
     def test_empty_worksheet(self):
         ws = new_worksheet()
         self.assertEquals(ws.cells,[])
         self.assertEquals(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.assertEquals(ws.cells,cells)
         self.assertEquals(ws.name,u'foo')
 
 class TestNotebook(TestCase):
 
     def test_empty_notebook(self):
         nb = new_notebook()
         self.assertEquals(nb.worksheets, [])
         self.assertEquals(nb.metadata, NotebookNode())
         self.assertEquals(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.assertEquals(nb.metadata.name,u'foo')
         self.assertEquals(nb.worksheets,worksheets)
         self.assertEquals(nb.nbformat,nbformat)
 
+    def test_notebook_name(self):
+        worksheets = [new_worksheet(),new_worksheet()]
+        nb = new_notebook(name='foo',worksheets=worksheets)
+        self.assertEquals(nb.metadata.name,u'foo')
+        self.assertEquals(nb.worksheets,worksheets)
+        self.assertEquals(nb.nbformat,nbformat)
+
 class TestMetadata(TestCase):
 
     def test_empty_metadata(self):
         md = new_metadata()
         self.assertEquals(u'name' not in md, True)
         self.assertEquals(u'authors' not in md, True)
         self.assertEquals(u'license' not in md, True)
         self.assertEquals(u'saved' not in md, True)
         self.assertEquals(u'modified' not in md, True)
         self.assertEquals(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.assertEquals(md.name, u'foo')
         self.assertEquals(md.license, u'BSD')
         self.assertEquals(md.created, u'today')
         self.assertEquals(md.modified, u'now')
         self.assertEquals(md.gistid, u'21341231')
         self.assertEquals(md.authors, authors)