fix base64 code in nbformat.v2

base64 encoding functions were called, but had no effect, because
the notebook already has everything as b64-encoded bytestrings, which
are valid ascii literals on Python 2.

However, the encode/decode logic is actually triggered on Python 3, revealing its errors.

This fixes the base64 functions that had no effect to have their intended effect,
but does not use them.  Rather, it is assumed that
bytes objects are already b64-encoded (and thus ascii-safe), which
assumption was already made in Python 2.

IPython/nbformat/v2/nbjson.py

@@ -1,62 +1,62 b''
 """Read and write notebooks in JSON format.
 
 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
 #-----------------------------------------------------------------------------
 
-from base64 import encodestring
 from .nbbase import from_dict
-from .rwbase import NotebookReader, NotebookWriter, base64_decode
+from .rwbase import NotebookReader, NotebookWriter, restore_bytes
 import json
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 class BytesEncoder(json.JSONEncoder):
+    """A JSON encoder that accepts b64 (and other *ascii*) bytestrings."""
     def default(self, obj):
         if isinstance(obj, bytes):
-            return encodestring(obj).decode('ascii')
+            return obj.decode('ascii')
         return json.JSONEncoder.default(self, obj)
 
 
 class JSONReader(NotebookReader):
 
     def reads(self, s, **kwargs):
         nb = json.loads(s, **kwargs)
         nb = self.to_notebook(nb, **kwargs)
         return nb
 
     def to_notebook(self, d, **kwargs):
-        return base64_decode(from_dict(d))
+        return restore_bytes(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/rwbase.py

@@ -1,74 +1,110 b''
 """Base classes and utilities for readers and writers.
 
 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
 #-----------------------------------------------------------------------------
 
 from base64 import encodestring, decodestring
 import pprint
 
+from IPython.utils.py3compat import str_to_bytes
+
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
+def restore_bytes(nb):
+    """Restore bytes of image data from unicode-only formats.
+    
+    Base64 encoding is handled elsewhere.  Bytes objects in the notebook are
+    always b64-encoded. We DO NOT encode/decode around file formats.
+    """
+    for ws in nb.worksheets:
+        for cell in ws.cells:
+            if cell.cell_type == 'code':
+                for output in cell.outputs:
+                    if 'png' in output:
+                        output.png = str_to_bytes(output.png, 'ascii')
+                    if 'jpeg' in output:
+                        output.jpeg = str_to_bytes(output.jpeg, 'ascii')
+    return nb
+
+
+# b64 encode/decode are never actually used, because all bytes objects in
+# the notebook are already b64-encoded, and we don't need/want to double-encode
+
 def base64_decode(nb):
-    """Base64 encode all bytes objects in the notebook."""
+    """Restore all bytes objects in the notebook from base64-encoded strings.
+    
+    Note: This is never used
+    """
     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))
-                if 'jpeg' in cell:
-                    cell.jpeg = bytes(decodestring(cell.jpeg))
+                for output in cell.outputs:
+                    if 'png' in output:
+                        if isinstance(output.png, unicode):
+                            output.png = output.png.encode('ascii')
+                        output.png = decodestring(output.png)
+                    if 'jpeg' in output:
+                        if isinstance(output.jpeg, unicode):
+                            output.jpeg = output.jpeg.encode('ascii')
+                        output.jpeg = decodestring(output.jpeg)
     return nb
 
 
 def base64_encode(nb):
-    """Base64 decode all binary objects in the notebook."""
+    """Base64 encode all bytes objects in the notebook.
+    
+    These will be b64-encoded unicode strings
+    
+    Note: This is never used
+    """
     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))
-                if 'jpeg' in cell:
-                    cell.jpeg = unicode(encodestring(cell.jpeg))
+                for output in cell.outputs:
+                    if 'png' in output:
+                        output.png = encodestring(output.png).decode('ascii')
+                    if 'jpeg' in output:
+                        output.jpeg = encodestring(output.jpeg).decode('ascii')
     return nb
 
 
 class NotebookReader(object):
     """A class for reading notebooks."""
 
     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.read(fp.read(), **kwargs)
 
 
 class NotebookWriter(object):
     """A class for writing notebooks."""
 
     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/v2/tests/nbexamples.py

@@ -1,103 +1,108 b''
+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
 )
 
-
+# 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_code_cell(
     input='a = numpy.random.rand(100)',
     prompt_number=2,
     collapsed=True
 ))
 
 ws.cells.append(new_code_cell(
     input='print a',
     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=b'data',
-        output_jpeg=b'data',
+        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=b'data',
-        output_jpeg=b'data',
+        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']
     )]
 ))
 
 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 = """# <nbformat>2</nbformat>
 
 # <htmlcell>
 
 # Some NumPy Examples
 
 # <codecell>
 
 import numpy
 
 # <markdowncell>
 
 # A random array
 
 # <codecell>
 
 a = numpy.random.rand(100)
 
 # <codecell>
 
 print a
 
 """