preserve trailing newlines in ipynb

Principally important for distinguishing a sequence of `print n,` messages
from a sequence of `print n` messages.

IPython/nbformat/v3/rwbase.py

@@ -1,174 +1,174 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 import py3compat
 
 str_to_bytes = py3compat.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
 
 # output keys that are likely to have multiline values
 _multiline_outputs = ['text', 'html', 'svg', 'latex', 'javascript', 'json']
 
 def rejoin_lines(nb):
     """rejoin multiline text into strings
     
     For reversing effects of ``split_lines(nb)``.
     
     This only rejoins lines that have been split, so if text objects were not split
     they will pass through unchanged.
     
     Used when reading JSON files that may have been passed through split_lines.
     """
     for ws in nb.worksheets:
         for cell in ws.cells:
             if cell.cell_type == 'code':
                 if 'input' in cell and isinstance(cell.input, list):
                     cell.input = u'\n'.join(cell.input)
                 for output in cell.outputs:
                     for key in _multiline_outputs:
                         item = output.get(key, None)
                         if isinstance(item, list):
                             output[key] = u'\n'.join(item)
             else: # text, heading cell
                 for key in ['source', 'rendered']:
                     item = cell.get(key, None)
                     if isinstance(item, list):
                         cell[key] = u'\n'.join(item)
     return nb
 
 
 def split_lines(nb):
     """split likely multiline text into lists of strings
     
     For file output more friendly to line-based VCS. ``rejoin_lines(nb)`` will
     reverse the effects of ``split_lines(nb)``.
     
     Used when writing JSON files.
     """
     for ws in nb.worksheets:
         for cell in ws.cells:
             if cell.cell_type == 'code':
                 if 'input' in cell and isinstance(cell.input, basestring):
-                    cell.input = cell.input.splitlines()
+                    cell.input = (cell.input + '\n').splitlines()
                 for output in cell.outputs:
                     for key in _multiline_outputs:
                         item = output.get(key, None)
                         if isinstance(item, basestring):
-                            output[key] = item.splitlines()
+                            output[key] = (item + '\n').splitlines()
             else: # text, heading cell
                 for key in ['source', 'rendered']:
                     item = cell.get(key, None)
                     if isinstance(item, basestring):
-                        cell[key] = item.splitlines()
+                        cell[key] = (item + '\n').splitlines()
     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):
     """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':
                 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 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':
                 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"""
         nbs = fp.read()
         if not py3compat.PY3 and not isinstance(nbs, unicode):
             nbs = py3compat.str_to_unicode(nbs)
         return self.reads(nbs, **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"""
         nbs = self.writes(nb,**kwargs)
         if not py3compat.PY3 and not isinstance(nbs, unicode):
             # this branch is likely only taken for JSON on Python 2
             nbs = py3compat.str_to_unicode(nbs)
         return fp.write(nbs)
 
 
 

IPython/nbformat/v3/tests/nbexamples.py

@@ -1,129 +1,147 b''
 # -*- coding: utf-8 -*-
 
 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, new_heading_cell, nbformat
 )
 
 # 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_text_cell(
     u'plaintext',
     source='A random array',
 ))
 
 ws.cells.append(new_heading_cell(
     u'My Heading',
     level=2
 ))
 
 ws.cells.append(new_code_cell(
     input='a = numpy.random.rand(100)',
     prompt_number=2,
     collapsed=True
 ))
+ws.cells.append(new_code_cell(
+    input='a = 10\nb = 5\n',
+    prompt_number=3,
+))
+ws.cells.append(new_code_cell(
+    input='a = 10\nb = 5',
+    prompt_number=4,
+))
 
 ws.cells.append(new_code_cell(
     input=u'print "ünîcødé"',
     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=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=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 = u"""# -*- coding: utf-8 -*-
 # <nbformat>%i</nbformat>
 
 # <htmlcell>
 
 # Some NumPy Examples
 
 # <codecell>
 
 import numpy
 
 # <markdowncell>
 
 # A random array
 
 # <plaintextcell>
 
 # A random array
 
 # <headingcell level=2>
 
 # My Heading
 
 # <codecell>
 
 a = numpy.random.rand(100)
 
 # <codecell>
 
+a = 10
+b = 5
+
+# <codecell>
+
+a = 10
+b = 5
+
+# <codecell>
+
 print "ünîcødé"
 
 """ % nbformat
 
 

IPython/nbformat/v3/tests/test_nbpy.py

@@ -1,38 +1,43 b''
 # -*- coding: utf8 -*-
 from . import formattest
 
 from .. import nbpy
 from .nbexamples import nb0, nb0_py
 
 
 class TestPy(formattest.NBFormatTestCase):
 
     nb0_ref = nb0_py
     ext = 'py'
     mod = nbpy
     ignored_keys = ['collapsed', 'outputs', 'prompt_number', 'metadata']
 
     def assertSubset(self, da, db):
         """assert that da is a subset of db, ignoring self.ignored_keys.
         
         Called recursively on containers, ultimately comparing individual
         elements.
         """
         if isinstance(da, dict):
             for k,v in da.iteritems():
                 if k in self.ignored_keys:
                     continue
                 self.assertTrue(k in db)
                 self.assertSubset(v, db[k])
         elif isinstance(da, list):
             for a,b in zip(da, db):
                 self.assertSubset(a,b)
         else:
+            if isinstance(da, basestring) and isinstance(db, basestring):
+                # pyfile is not sensitive to preserving leading/trailing
+                # newlines in blocks through roundtrip
+                da = da.strip('\n')
+                db = db.strip('\n')
             self.assertEquals(da, db)
         return True
     
     def assertNBEquals(self, nba, nbb):
         # since roundtrip is lossy, only compare keys that are preserved
         # assumes nba is read from my file format
         return self.assertSubset(nba, nbb)