Full versioning added to nbformat.

IPython/nbformat/current.py

@@ -0,0 +1,190 b''
+import json
+from xml.etree import ElementTree as ET
+import re
+
+from IPython.nbformat import v2
+from IPython.nbformat import v1
+
+
+current_nbformat = 2
+
+
+class NBFormatError(Exception):
+    pass
+
+
+def parse_json(s, **kwargs):
+    """Parse a string into a (nbformat, dict) tuple."""
+    d = json.loads(s, **kwargs)
+    nbformat = d.get('nbformat',1)
+    return nbformat, d
+
+
+def parse_xml(s, **kwargs):
+    """Parse a string into a (nbformat, etree) tuple."""
+    root = ET.fromstring(s)
+    nbformat_e = root.find('nbformat')
+    if nbformat_e is not None:
+        nbformat = int(nbformat_e.text)
+    else:
+        raise NBFormatError('No nbformat version found')
+    return nbformat, root
+
+
+def parse_py(s, **kwargs):
+    """Parse a string into a (nbformat, string) tuple."""
+    pattern = r'# <nbformat>(?P<nbformat>\d+)</nbformat>'
+    m = re.search(pattern,s)
+    if m is not None:
+        nbformat = int(m.group('nbformat'))
+    else:
+        raise NBFormatError('No nbformat version found')
+    return nbformat, s
+
+
+def reads_json(s, **kwargs):
+    """Read a JSON notebook from a string and return the NotebookNode object."""
+    nbformat, d = parse_json(s, **kwargs)
+    if nbformat == 1:
+        nb = v1.to_notebook_json(d, **kwargs)
+        nb = v2.convert_to_this_nbformat(nb, orig_version=1)
+    elif nbformat == 2:
+        nb = v2.to_notebook_json(d, **kwargs)
+    else:
+        raise NBFormatError('Unsupported JSON nbformat version: %i' % nbformat)
+    return nb
+
+
+def writes_json(nb, **kwargs):
+    return v2.writes_json(nb, **kwargs)
+
+
+def reads_xml(s, **kwargs):
+    """Read an XML notebook from a string and return the NotebookNode object."""
+    nbformat, root = parse_xml(s, **kwargs)
+    if nbformat == 2:
+        nb = v2.to_notebook_xml(root, **kwargs)
+    else:
+        raise NBFormatError('Unsupported XML nbformat version: %i' % nbformat)
+    return nb
+
+
+def writes_xml(nb, **kwargs):
+    return v2.writes_xml(nb, **kwargs)
+
+
+def reads_py(s, **kwargs):
+    """Read a .py notebook from a string and return the NotebookNode object."""
+    nbformat, s = parse_py(s, **kwargs)
+    if nbformat == 2:
+        nb = v2.to_notebook_py(s, **kwargs)
+    else:
+        raise NBFormatError('Unsupported PY nbformat version: %i' % nbformat)
+    return nb
+
+
+def writes_py(nb, **kwargs):
+    return v2.writes_py(nb, **kwargs)
+
+
+# High level API
+
+
+def reads(s, format, **kwargs):
+    """Read a notebook from a string and return the NotebookNode object.
+
+    This function properly handles notebooks of any version. The notebook
+    returned will always be in the current version's format.
+
+    Parameters
+    ----------
+    s : str
+        The raw string to read the notebook from.
+    format : ('xml','json','py')
+        The format that the string is in.
+
+    Returns
+    -------
+    nb : NotebookNode
+        The notebook that was read.
+    """
+    if format == 'xml':
+        return reads_xml(s, **kwargs)
+    elif format == 'json':
+        return reads_json(s, **kwargs)
+    elif format == 'py':
+        return reads_py(s, **kwargs)
+    else:
+        raise NBFormatError('Unsupported format: %s' % format)
+
+
+def writes(nb, format, **kwargs):
+    """Write a notebook to a string in a given format in the current nbformat version.
+
+    This function always writes the notebook in the current nbformat version.
+
+    Parameters
+    ----------
+    nb : NotebookNode
+        The notebook to write.
+    format : ('xml','json','py')
+        The format to write the notebook in.
+
+    Returns
+    -------
+    s : str
+        The notebook string.
+    """
+    if format == 'xml':
+        return writes_xml(nb, **kwargs)
+    elif format == 'json':
+        return writes_json(nb, **kwargs)
+    elif format == 'py':
+        return writes_py(nb, **kwargs)
+    else:
+        raise NBFormatError('Unsupported format: %s' % format)
+
+
+def read(fp, format, **kwargs):
+    """Read a notebook from a file and return the NotebookNode object.
+
+    This function properly handles notebooks of any version. The notebook
+    returned will always be in the current version's format.
+
+    Parameters
+    ----------
+    fp : file
+        Any file-like object with a read method.
+    format : ('xml','json','py')
+        The format that the string is in.
+
+    Returns
+    -------
+    nb : NotebookNode
+        The notebook that was read.
+    """
+    return reads(fp.read(), format, **kwargs)
+
+
+def write(nb, fp, format, **kwargs):
+    """Write a notebook to a file in a given format in the current nbformat version.
+
+    This function always writes the notebook in the current nbformat version.
+
+    Parameters
+    ----------
+    nb : NotebookNode
+        The notebook to write.
+    fp : file
+        Any file-like object with a write method.
+    format : ('xml','json','py')
+        The format to write the notebook in.
+
+    Returns
+    -------
+    s : str
+        The notebook string.
+    """
+    return fp.write(writes(nb, format, **kwargs))
+
+

IPython/nbformat/v1/__init__.py

@@ -0,0 +1,12 b''
+
+from .nbbase import (
+    NotebookNode,
+    new_code_cell, new_text_cell, new_notebook
+)
+
+from .nbjson import reads as reads_json, writes as writes_json
+from .nbjson import reads as read_json, writes as write_json
+from .nbjson import to_notebook as to_notebook_json
+
+from .convert import convert_to_this_nbformat
+

IPython/nbformat/v1/convert.py

@@ -0,0 +1,5 b''
+
+
+def convert_to_this_nbformat(nb, orig_version=None):
+    raise ValueError('Cannot convert to v1 notebook format')
+

IPython/nbformat/v1/nbbase.py

@@ -0,0 +1,53 b''
+"""The basic dict based notebook format."""
+
+import pprint
+import uuid
+
+from IPython.utils.ipstruct import Struct
+
+
+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_code_cell(code=None, prompt_number=None):
+    """Create a new code cell with input and output"""
+    cell = NotebookNode()
+    cell.cell_type = u'code'
+    if code is not None:
+        cell.code = unicode(code)
+    if prompt_number is not None:
+        cell.prompt_number = int(prompt_number)
+    return cell
+
+
+def new_text_cell(text=None):
+    """Create a new text cell."""
+    cell = NotebookNode()
+    if text is not None:
+        cell.text = unicode(text)
+    cell.cell_type = u'text'
+    return cell
+
+
+def new_notebook(cells=None):
+    """Create a notebook by name, id and a list of worksheets."""
+    nb = NotebookNode()
+    if cells is not None:
+        nb.cells = cells
+    else:
+        nb.cells = []
+    return nb
+

IPython/nbformat/v1/nbjson.py

@@ -0,0 +1,35 b''
+"""Read and write notebooks in JSON format."""
+
+from base64 import encodestring
+from .rwbase import NotebookReader, NotebookWriter
+from .nbbase import from_dict
+import json
+
+
+class JSONReader(NotebookReader):
+
+    def reads(self, s, **kwargs):
+        nb = json.loads(s, **kwargs)
+        return self.to_notebook(nb, **kwargs)
+
+    def to_notebook(self, d, **kwargs):
+        """Convert from a raw JSON dict to a nested NotebookNode structure."""
+        return from_dict(d)
+
+
+class JSONWriter(NotebookWriter):
+
+    def writes(self, nb, **kwargs):
+        kwargs['indent'] = 4
+        return json.dumps(nb, **kwargs)
+
+
+_reader = JSONReader()
+_writer = JSONWriter()
+
+reads = _reader.reads
+read = _reader.read
+to_notebook = _reader.to_notebook
+write = _writer.write
+writes = _writer.writes
+

IPython/nbformat/v1/rwbase.py

@@ -0,0 +1,26 b''
+from base64 import encodestring, decodestring
+
+
+class NotebookReader(object):
+
+    def reads(self, s, **kwargs):
+        """Read a notebook from a string."""
+        raise NotImplementedError("loads must be implemented in a subclass")
+
+    def read(self, fp, **kwargs):
+        """Read a notebook from a file like object"""
+        return self.reads(fp.read(), **kwargs)
+
+
+class NotebookWriter(object):
+
+    def writes(self, nb, **kwargs):
+        """Write a notebook to a string."""
+        raise NotImplementedError("loads must be implemented in a subclass")
+
+    def write(self, nb, fp, **kwargs):
+        """Write a notebook to a file like object"""
+        return fp.write(self.writes(nb,**kwargs))
+
+
+

IPython/nbformat/v1/tests/nbexamples.py

@@ -0,0 +1,29 b''
+from ..nbbase import (
+    NotebookNode,
+    new_code_cell, new_text_cell, new_notebook
+)
+
+
+
+nb0 = new_notebook()
+
+nb0.cells.append(new_text_cell(
+    text='Some NumPy Examples'
+))
+
+
+nb0.cells.append(new_code_cell(
+    code='import numpy',
+    prompt_number=1
+))
+
+nb0.cells.append(new_code_cell(
+    code='a = numpy.random.rand(100)',
+    prompt_number=2
+))
+
+nb0.cells.append(new_code_cell(
+    code='print a',
+    prompt_number=3
+))
+

IPython/nbformat/v1/tests/test_nbbase.py

@@ -0,0 +1,41 b''
+from unittest import TestCase
+
+from ..nbbase import (
+    NotebookNode,
+    new_code_cell, new_text_cell, new_notebook
+)
+
+class TestCell(TestCase):
+
+    def test_empty_code_cell(self):
+        cc = new_code_cell()
+        self.assertEquals(cc.cell_type,'code')
+        self.assertEquals('code' not in cc, True)
+        self.assertEquals('prompt_number' not in cc, True)
+
+    def test_code_cell(self):
+        cc = new_code_cell(code='a=10', prompt_number=0)
+        self.assertEquals(cc.code, u'a=10')
+        self.assertEquals(cc.prompt_number, 0)
+
+    def test_empty_text_cell(self):
+        tc = new_text_cell()
+        self.assertEquals(tc.cell_type, 'text')
+        self.assertEquals('text' not in tc, True)
+
+    def test_text_cell(self):
+        tc = new_text_cell('hi')
+        self.assertEquals(tc.text, u'hi')
+
+
+class TestNotebook(TestCase):
+
+    def test_empty_notebook(self):
+        nb = new_notebook()
+        self.assertEquals(nb.cells, [])
+
+    def test_notebooke(self):
+        cells = [new_code_cell(),new_text_cell()]
+        nb = new_notebook(cells=cells)
+        self.assertEquals(nb.cells,cells)
+

IPython/nbformat/v2/__init__.py

@@ -0,0 +1,21 b''
+
+from .nbbase import (
+    NotebookNode,
+    new_code_cell, new_text_cell, new_notebook, new_output, new_worksheet
+)
+
+from .nbjson import reads as reads_json, writes as writes_json
+from .nbjson import reads as read_json, writes as write_json
+from .nbjson import to_notebook as to_notebook_json
+
+from .nbxml import reads as reads_xml, writes as writes_xml
+from .nbxml import reads as read_xml, writes as write_xml
+from .nbxml import to_notebook as to_notebook_xml
+
+from .nbpy import reads as reads_py, writes as writes_py
+from .nbpy import reads as read_py, writes as write_py
+from .nbpy import to_notebook as to_notebook_py
+
+from .convert import convert_to_this_nbformat
+
+

IPython/nbformat/v2/convert.py

@@ -0,0 +1,20 b''
+from .nbbase import (
+    new_code_cell, new_text_cell, new_worksheet, new_notebook, new_output
+)
+
+def convert_to_this_nbformat(nb, orig_version=1):
+    if orig_version == 1:
+        newnb = new_notebook()
+        ws = new_worksheet()
+        for cell in nb.cells:
+            if cell.cell_type == 'code':
+                newcell = new_code_cell(input=cell.get('code'),prompt_number=cell.get('prompt_number'))
+            elif cell.cell_type == 'text':
+                newcell = new_text_cell(text=cell.get('text'))
+            ws.cells.append(newcell)
+        newnb.worksheets.append(ws)
+        return newnb
+    else:
+        raise ValueError('Cannot convert a notebook from v%s to v2' % orig_version)
+
+

IPython/nbformat/v2/tests/test_json.py

@@ -0,0 +1,15 b''
+
+from unittest import TestCase
+
+from ..nbjson import reads, writes
+from .nbexamples import nb0
+
+
+class TestJSON(TestCase):
+
+    def test_roundtrip(self):
+        s = writes(nb0)
+        self.assertEquals(reads(s),nb0)
+
+
+

IPython/nbformat/v1/tests/test_json.py

@@ -1,14 +1,14 b''
 from unittest import TestCase
 
-from IPython.nbformat.nbjson import reads, writes
-from IPython.nbformat.tests.nbexamples import nb0
+from ..nbjson import reads, writes
+from .nbexamples import nb0
 
 
 class TestJSON(TestCase):
 
     def test_roundtrip(self):
         s = writes(nb0)
         self.assertEquals(reads(s),nb0)
 
 
 

IPython/nbformat/v2/nbbase.py

@@ -1,90 +1,103 b''
 """The basic dict based notebook format."""
 
 import pprint
 import uuid
 
 from IPython.utils.ipstruct import Struct
 
 
 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):
     """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_text is not None:
         output.text = unicode(output_text)
     if output_png is not None:
         output.png = bytes(output_png)
     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)
 
     return output
 
 
 def new_code_cell(input=None, prompt_number=None, outputs=None, language=u'python'):
     """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
 
     return cell
 
 def new_text_cell(text=None):
     """Create a new text cell."""
     cell = NotebookNode()
     if text is not None:
         cell.text = unicode(text)
     cell.cell_type = u'text'
     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(name=None, id=None, worksheets=None):
     """Create a notebook by name, id and a list of worksheets."""
     nb = NotebookNode()
+    nb.nbformat = 2
     if name is not None:
         nb.name = unicode(name)
     if id is None:
         nb.id = unicode(uuid.uuid4())
     else:
         nb.id = unicode(id)
     if worksheets is None:
         nb.worksheets = []
     else:
         nb.worksheets = list(worksheets)
     return nb
 

IPython/nbformat/v2/nbjson.py

@@ -1,38 +1,43 b''
 """Read and write notebooks in JSON format."""
 
 from base64 import encodestring
+from .nbbase import from_dict
 from .rwbase import NotebookReader, NotebookWriter, base64_decode
 import json
 
 
 class BytesEncoder(json.JSONEncoder):
     def default(self, obj):
         if isinstance(obj, bytes):
             return unicode(encodestring(bytes))
         return json.JSONEncoder.default(self, obj)
 
 
 class JSONReader(NotebookReader):
 
     def reads(self, s, **kwargs):
         nb = json.loads(s, **kwargs)
-        nb = base64_decode(nb)
+        nb = self.to_notebook(nb, **kwargs)
         return nb
 
+    def to_notebook(self, d, **kwargs):
+        return base64_decode(from_dict(d))
+
 
 class JSONWriter(NotebookWriter):
 
     def writes(self, nb, **kwargs):
         kwargs['cls'] = BytesEncoder
         kwargs['indent'] = 4
         return json.dumps(nb, **kwargs)
 
 
 _reader = JSONReader()
 _writer = JSONWriter()
 
 reads = _reader.reads
 read = _reader.read
+to_notebook = _reader.to_notebook
 write = _writer.write
 writes = _writer.writes
 

IPython/nbformat/v2/nbpy.py

@@ -1,47 +1,55 b''
 """Read and write notebooks as regular .py files."""
 
 from .rwbase import NotebookReader, NotebookWriter
 from .nbbase import new_code_cell, new_worksheet, new_notebook
 
 
 class PyReader(NotebookReader):
 
     def reads(self, s, **kwargs):
+        return self.to_notebook(s,**kwargs)
+
+    def to_notebook(self, s, **kwargs):
         lines = s.splitlines()
         cells = []
         cell_lines = []
         for line in lines:
             if line.startswith(u'# <codecell>'):
+                cell_lines = []
+            if line.startswith(u'# </codecell>'):
                 code = u'\n'.join(cell_lines)
                 code = code.strip(u'\n')
                 if code:
                     cells.append(new_code_cell(input=code))
-                    cell_lines = []
             else:
                 cell_lines.append(line)
         ws = new_worksheet(cells=cells)
         nb = new_notebook(worksheets=[ws])
         return nb
 
 
 class PyWriter(NotebookWriter):
 
     def writes(self, nb, **kwargs):
         lines = []
+        lines.extend(['# <nbformat>2</nbformat>',''])
         for ws in nb.worksheets:
             for cell in ws.cells:
                 if cell.cell_type == 'code':
                     input = cell.input
                     lines.extend([u'# <codecell>',u''])
                     lines.extend(input.splitlines())
-                    lines.append(u'')
+                    lines.extend([u'',u'# </codecell>'])
+        lines.append('')
         return unicode('\n'.join(lines))
 
 
 _reader = PyReader()
 _writer = PyWriter()
 
 reads = _reader.reads
 read = _reader.read
+to_notebook = _reader.to_notebook
 write = _writer.write
 writes = _writer.writes
+

IPython/nbformat/v2/nbxml.py

@@ -1,145 +1,165 b''
 """Read and write notebook files as XML."""
 
+from base64 import encodestring, decodestring
 from xml.etree import ElementTree as ET
 
 from .rwbase import NotebookReader, NotebookWriter
 from .nbbase import (
     new_code_cell, new_text_cell, new_worksheet, new_notebook, new_output
 )
 
 def indent(elem, level=0):
     i = "\n" + level*"  "
     if len(elem):
         if not elem.text or not elem.text.strip():
             elem.text = i + "  "
         if not elem.tail or not elem.tail.strip():
             elem.tail = i
         for elem in elem:
             indent(elem, level+1)
         if not elem.tail or not elem.tail.strip():
             elem.tail = i
     else:
         if level and (not elem.tail or not elem.tail.strip()):
             elem.tail = i
 
 
 def _get_text(e, tag):
     sub_e = e.find(tag)
     if sub_e is None:
         return None
     else:
         return sub_e.text
 
 
 def _set_text(nbnode, attr, parent, tag):
     if attr in nbnode:
         e = ET.SubElement(parent, tag)
         e.text = nbnode[attr]
 
 
 def _get_int(e, tag):
     sub_e = e.find(tag)
     if sub_e is None:
         return None
     else:
         return int(sub_e.text)
 
 
 def _set_int(nbnode, attr, parent, tag):
     if attr in nbnode:
         e = ET.SubElement(parent, tag)
         e.text = unicode(nbnode[attr])
 
 
+def _get_binary(e, tag):
+    sub_e = e.find(tag)
+    if sub_e is None:
+        return None
+    else:
+        return decodestring(sub_e.text)
+
+
+def _set_binary(nbnode, attr, parent, tag):
+    if attr in nbnode:
+        e = ET.SubElement(parent, tag)
+        e.text = encodestring(nbnode[attr])
+
+
 class XMLReader(NotebookReader):
 
     def reads(self, s, **kwargs):
         root = ET.fromstring(s)
+        return self.to_notebook(root, **kwargs)
 
+    def to_notebook(self, root, **kwargs):
         nbname = _get_text(root,'name')
         nbid = _get_text(root,'id')
         
         worksheets = []
         for ws_e in root.find('worksheets').getiterator('worksheet'):
             wsname = _get_text(ws_e,'name')
             cells = []
             for cell_e in ws_e.find('cells').getiterator():
                 if cell_e.tag == 'codecell':
                     input = _get_text(cell_e,'input')
                     prompt_number = _get_int(cell_e,'prompt_number')
                     language = _get_text(cell_e,'language')
                     outputs = []
                     for output_e in cell_e.find('outputs').getiterator('output'):
                         output_type = _get_text(output_e,'output_type')
                         output_text = _get_text(output_e,'text')
-                        output_png = _get_text(output_e,'png')
+                        output_png = _get_binary(output_e,'png')
                         output_svg = _get_text(output_e,'svg')
                         output_html = _get_text(output_e,'html')
                         output_latex = _get_text(output_e,'latex')
                         output_json = _get_text(output_e,'json')
                         output_javascript = _get_text(output_e,'javascript')
                         output = new_output(output_type=output_type,output_png=output_png,
                             output_text=output_text,output_svg=output_svg,
                             output_html=output_html,output_latex=output_latex,
                             output_json=output_json,output_javascript=output_javascript
                         )
                         outputs.append(output)
                     cc = new_code_cell(input=input,prompt_number=prompt_number,
                                        language=language,outputs=outputs)
                     cells.append(cc)
                 if cell_e.tag == 'textcell':
                     text = _get_text(cell_e,'text')
                     cells.append(new_text_cell(text=text))
             ws = new_worksheet(name=wsname,cells=cells)
             worksheets.append(ws)
 
         nb = new_notebook(name=nbname,id=nbid,worksheets=worksheets)
         return nb
 
 
 class XMLWriter(NotebookWriter):
 
     def writes(self, nb, **kwargs):
         nb_e = ET.Element('notebook')
         _set_text(nb,'name',nb_e,'name')
         _set_text(nb,'id',nb_e,'id')
+        _set_int(nb,'nbformat',nb_e,'nbformat')
         wss_e = ET.SubElement(nb_e,'worksheets')
         for ws in nb.worksheets:
             ws_e = ET.SubElement(wss_e, 'worksheet')
             _set_text(ws,'name',ws_e,'name')
             cells_e = ET.SubElement(ws_e,'cells')
             for cell in ws.cells:
                 cell_type = cell.cell_type
                 if cell_type == 'code':
                     cell_e = ET.SubElement(cells_e, 'codecell')
                     _set_text(cell,'input',cell_e,'input')
                     _set_text(cell,'language',cell_e,'language')
                     _set_int(cell,'prompt_number',cell_e,'prompt_number')
                     outputs_e = ET.SubElement(cell_e, 'outputs')
                     for output in cell.outputs:
                         output_e = ET.SubElement(outputs_e, 'output')
                         _set_text(output,'output_type',output_e,'output_type')
                         _set_text(output,'text',output_e,'text')
-                        _set_text(output,'png',output_e,'png')
+                        _set_binary(output,'png',output_e,'png')
                         _set_text(output,'html',output_e,'html')
                         _set_text(output,'svg',output_e,'svg')
                         _set_text(output,'latex',output_e,'latex')
                         _set_text(output,'json',output_e,'json')
                         _set_text(output,'javascript',output_e,'javascript')
                 elif cell_type == 'text':
                     cell_e = ET.SubElement(cells_e, 'textcell')
                     _set_text(cell,'text',cell_e,'text')
 
         indent(nb_e)
         txt = ET.tostring(nb_e, encoding="utf-8")
         txt = '<?xml version="1.0" encoding="utf-8"?>\n' + txt
         return txt
         
                     
 _reader = XMLReader()
 _writer = XMLWriter()
 
 reads = _reader.reads
 read = _reader.read
+to_notebook = _reader.to_notebook
 write = _writer.write
 writes = _writer.writes
+

IPython/nbformat/v2/rwbase.py

@@ -1,46 +1,46 b''
 from base64 import encodestring, decodestring
-
+import pprint
 
 def base64_decode(nb):
     """Base64 encode all bytes objects in the notebook."""
-    for ws in nb['worksheets']:
-        for cell in ws['cells']:
-            if cell['cell_type'] == 'code':
-                if cell.get('image/png',''):
-                    cell['image/png'] = bytes(decodestring(cell['image/png']))
+    for ws in nb.worksheets:
+        for cell in ws.cells:
+            if cell.cell_type == 'code':
+                if 'png' in cell:
+                    cell.png = bytes(decodestring(cell.png))
     return nb
 
 
 def base64_encode(nb):
     """Base64 decode all binary objects in the notebook."""
-    for ws in nb['worksheets']:
-        for cell in ws['cells']:
-            if cell['cell_type'] == 'code':
-                if cell.get('image/png',''):
-                    cell['image/png'] = unicode(encodestring(cell['image/png']))
+    for ws in nb.worksheets:
+        for cell in ws.cells:
+            if cell.cell_type == 'code':
+                if 'png' in cell:
+                    cell.png = unicode(encodestring(cell.png))
     return nb
 
 
 class NotebookReader(object):
 
     def reads(self, s, **kwargs):
         """Read a notebook from a string."""
         raise NotImplementedError("loads must be implemented in a subclass")
 
     def read(self, fp, **kwargs):
         """Read a notebook from a file like object"""
-        return self.loads(fp.read(), **kwargs)
+        return self.read(fp.read(), **kwargs)
 
 
 class NotebookWriter(object):
 
     def writes(self, nb, **kwargs):
         """Write a notebook to a string."""
         raise NotImplementedError("loads must be implemented in a subclass")
 
     def write(self, nb, fp, **kwargs):
         """Write a notebook to a file like object"""
-        return fp.write(self.dumps(nb,**kwargs))
+        return fp.write(self.writes(nb,**kwargs))
 
 
 

IPython/nbformat/v2/tests/nbexamples.py

@@ -1,67 +1,73 b''
-from IPython.nbformat.nbbase import (
+from ..nbbase import (
     NotebookNode,
     new_code_cell, new_text_cell, new_worksheet, new_notebook, new_output
 )
 
 
 
 ws = new_worksheet(name='worksheet1')
 
 ws.cells.append(new_text_cell(
     text='Some NumPy Examples'
 ))
 
 
 ws.cells.append(new_code_cell(
     input='import numpy',
     prompt_number=1
 ))
 
 ws.cells.append(new_code_cell(
     input='a = numpy.random.rand(100)',
     prompt_number=2
 ))
 
 ws.cells.append(new_code_cell(
     input='print a',
     prompt_number=3,
     outputs=[new_output(
         output_type=u'pyout',
         output_text=u'<array a>',
         output_html=u'The HTML rep',
         output_latex=u'$a$',
         output_png=b'data',
         output_svg=u'<svg>',
         output_json=u'json data',
         output_javascript=u'var i=0;'
     ),new_output(
         output_type=u'display_data',
         output_text=u'<array a>',
         output_html=u'The HTML rep',
         output_latex=u'$a$',
         output_png=b'data',
         output_svg=u'<svg>',
         output_json=u'json data',
         output_javascript=u'var i=0;'
     )]
 ))
 
 nb0 = new_notebook(
     name='nb0',
     worksheets=[ws, new_worksheet(name='worksheet2')]
 )
 
-nb0_py = """# <codecell>
+nb0_py = """# <nbformat>2</nbformat>
+
+# <codecell>
 
 import numpy
 
+# </codecell>
 # <codecell>
 
 a = numpy.random.rand(100)
 
+# </codecell>
 # <codecell>
 
 print a
+
+# </codecell>
 """
 
 

IPython/nbformat/v2/tests/test_nbbase.py

@@ -1,62 +1,64 b''
 from unittest import TestCase
 
-from IPython.nbformat.nbbase import (
+from ..nbbase import (
     NotebookNode,
     new_code_cell, new_text_cell, new_worksheet, new_notebook, new_output
 )
 
 class TestCell(TestCase):
 
     def test_empty_code_cell(self):
         cc = new_code_cell()
         self.assertEquals(cc.cell_type,'code')
         self.assertEquals('input' not in cc, True)
         self.assertEquals('prompt_number' not in cc, True)
         self.assertEquals(cc.outputs, [])
 
     def test_code_cell(self):
         cc = new_code_cell(input='a=10', prompt_number=0)
         cc.outputs = [new_output(output_type='pyout',output_svg='foo',output_text='10')]
         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')
 
     def test_empty_text_cell(self):
         tc = new_text_cell()
         self.assertEquals(tc.cell_type, 'text')
         self.assertEquals('text' not in tc, True)
 
     def test_text_cell(self):
         tc = new_text_cell('hi')
         self.assertEquals(tc.text, u'hi')
 
 
 class TestWorksheet(TestCase):
 
     def test_empty_worksheet(self):
         ws = new_worksheet()
         self.assertEquals(ws.cells,[])
         self.assertEquals('name' not in ws, True)
 
     def test_worksheet(self):
         cells = [new_code_cell(), new_text_cell()]
         ws = new_worksheet(cells=cells,name='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('id' in nb, True)
         self.assertEquals(nb.worksheets, [])
         self.assertEquals('name' not in nb, True)
+        self.assertEquals(nb.nbformat,2)
 
-    def test_notebooke(self):
+    def test_notebook(self):
         worksheets = [new_worksheet(),new_worksheet()]
         nb = new_notebook(name='foo',worksheets=worksheets)
         self.assertEquals(nb.name,u'foo')
         self.assertEquals(nb.worksheets,worksheets)
+        self.assertEquals(nb.nbformat,2)
 

IPython/nbformat/v2/tests/test_nbpy.py

@@ -1,18 +1,18 b''
 from unittest import TestCase
 
-from IPython.nbformat.nbbase import (
+from ..nbbase import (
     NotebookNode,
     new_code_cell, new_text_cell, new_worksheet, new_notebook
 )
 
-from IPython.nbformat.nbpy import reads, writes
-from IPython.nbformat.tests.nbexamples import nb0, nb0_py
+from ..nbpy import reads, writes
+from .nbexamples import nb0, nb0_py
 
 
 class TestPy(TestCase):
 
     def test_write(self):
         s = writes(nb0)
         self.assertEquals(s,nb0_py)
 
 

IPython/nbformat/v2/tests/test_xml.py

@@ -1,18 +1,18 b''
 from unittest import TestCase
 
-from IPython.nbformat.nbxml import reads, writes
-from IPython.nbformat.tests.nbexamples import nb0
+from ..nbxml import reads, writes
+from .nbexamples import nb0
 import pprint
 
 class TestXML(TestCase):
 
     def test_roundtrip(self):
         s = writes(nb0)
 #        print
 #        print pprint.pformat(nb0,indent=2)
 #        print
 #        print pprint.pformat(reads(s),indent=2)
 #        print
 #        print s
         self.assertEquals(reads(s),nb0)