Uploaded Test files

venv/Lib/site-packages/nbformat/v2/__init__.py

@@ -0,0 +1,84 @@
+"""The main API for the v2 notebook 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
+#-----------------------------------------------------------------------------
+
+import os
+
+from .nbbase import (
+    NotebookNode,
+    new_code_cell, new_text_cell, new_notebook, new_output, new_worksheet,
+    new_metadata, new_author
+)
+
+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
+
+# Implementation removed, vulnerable to DoS attacks
+from .nbxml import reads as reads_xml
+from .nbxml import reads as read_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 downgrade, upgrade
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+
+nbformat = 2
+nbformat_minor = 0
+
+def parse_filename(fname):
+    """Parse a notebook filename.
+
+    This function takes a notebook filename and returns the notebook
+    format (json/py) and the notebook name. This logic can be
+    summarized as follows:
+
+    * notebook.ipynb -> (notebook.ipynb, notebook, json)
+    * notebook.json  -> (notebook.json, notebook, json)
+    * notebook.py    -> (notebook.py, notebook, py)
+    * notebook       -> (notebook.ipynb, notebook, json)
+
+    Parameters
+    ----------
+    fname : unicode
+        The notebook filename. The filename can use a specific filename
+        extention (.ipynb, .json, .py) or none, in which case .ipynb will
+        be assumed.
+
+    Returns
+    -------
+    (fname, name, format) : (unicode, unicode, unicode)
+        The filename, notebook name and format.
+    """
+    basename, ext = os.path.splitext(fname)
+    if ext == u'.ipynb':
+        format = u'json'
+    elif ext == u'.json':
+        format = u'json'
+    elif ext == u'.py':
+        format = u'py'
+    else:
+        basename = fname
+        fname = fname + u'.ipynb'
+        format = u'json'
+    return fname, basename, format

venv/Lib/site-packages/nbformat/v2/convert.py

@@ -0,0 +1,61 @@
+"""Code for converting notebooks to and from the v2 format.
+
+Authors:
+
+* Brian Granger
+* Jonathan Frederic
+"""
+
+#-----------------------------------------------------------------------------
+#  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 .nbbase import (
+    new_code_cell, new_text_cell, new_worksheet, new_notebook, new_output
+)
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+
+def upgrade(nb, from_version=1):
+    """Convert a notebook to the v2 format.
+
+    Parameters
+    ----------
+    nb : NotebookNode
+        The Python representation of the notebook to convert.
+    from_version : int
+        The version of the notebook to convert from.
+    """
+    if from_version == 1:
+        newnb = new_notebook()
+        ws = new_worksheet()
+        for cell in nb.cells:
+            if cell.cell_type == u'code':
+                newcell = new_code_cell(input=cell.get('code'),prompt_number=cell.get('prompt_number'))
+            elif cell.cell_type == u'text':
+                newcell = new_text_cell(u'markdown',source=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' % from_version)
+
+
+def downgrade(nb):
+    """Convert a v2 notebook to v1.
+
+    Parameters
+    ----------
+    nb : NotebookNode
+        The Python representation of the notebook to convert.
+    """
+    raise Exception("Downgrade from notebook v2 to v1 is not supported.")

venv/Lib/site-packages/nbformat/v2/nbbase.py

@@ -0,0 +1,179 @@
+"""The basic dict based notebook format.
+
+The Python representation of a notebook is a nested structure of
+dictionary subclasses that support attribute access
+(ipython_genutils.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_genutils.ipstruct import Struct
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+
+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 = str(output_type)
+
+    if output_type != 'pyerr':
+        if output_text is not None:
+            output.text = str(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 = str(output_html)
+        if output_svg is not None:
+            output.svg = str(output_svg)
+        if output_latex is not None:
+            output.latex = str(output_latex)
+        if output_json is not None:
+            output.json = str(output_json)
+        if output_javascript is not None:
+            output.javascript = str(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 = str(etype)
+        if evalue is not None:
+            output.evalue = str(evalue)
+        if traceback is not None:
+            output.traceback = [str(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 = str(language)
+    if input is not None:
+        cell.input = str(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 = str(source)
+    if rendered is not None:
+        cell.rendered = str(rendered)
+    cell.cell_type = cell_type
+    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 = str(name)
+    if cells is None:
+        ws.cells = []
+    else:
+        ws.cells = list(cells)
+    return ws
+
+
+def new_notebook(metadata=None, worksheets=None):
+    """Create a notebook by name, id and a list of worksheets."""
+    nb = NotebookNode()
+    nb.nbformat = 2
+    if worksheets is None:
+        nb.worksheets = []
+    else:
+        nb.worksheets = list(worksheets)
+    if metadata is None:
+        nb.metadata = new_metadata()
+    else:
+        nb.metadata = NotebookNode(metadata)
+    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 = str(name)
+    if authors is not None:
+        metadata.authors = list(authors)
+    if created is not None:
+        metadata.created = str(created)
+    if modified is not None:
+        metadata.modified = str(modified)
+    if license is not None:
+        metadata.license = str(license)
+    if gistid is not None:
+        metadata.gistid = str(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 = str(name)
+    if email is not None:
+        author.email = str(email)
+    if affiliation is not None:
+        author.affiliation = str(affiliation)
+    if url is not None:
+        author.url = str(url)
+    return author
+

venv/Lib/site-packages/nbformat/v2/nbjson.py

@@ -0,0 +1,69 @@
+"""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
+#-----------------------------------------------------------------------------
+
+import copy
+import json
+
+from .nbbase import from_dict
+from .rwbase import (
+    NotebookReader, NotebookWriter, restore_bytes, rejoin_lines, split_lines
+)
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+
+class BytesEncoder(json.JSONEncoder):
+    """A JSON encoder that accepts b64 (and other *ascii*) bytestrings."""
+    def default(self, obj):
+        if isinstance(obj, bytes):
+            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 restore_bytes(rejoin_lines(from_dict(d)))
+
+
+class JSONWriter(NotebookWriter):
+
+    def writes(self, nb, **kwargs):
+        kwargs['cls'] = BytesEncoder
+        kwargs['indent'] = 1
+        kwargs['sort_keys'] = True
+        if kwargs.pop('split_lines', True):
+            nb = split_lines(copy.deepcopy(nb))
+        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
+

venv/Lib/site-packages/nbformat/v2/nbpy.py

@@ -0,0 +1,150 @@
+"""Read and write notebooks as regular .py files.
+
+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 re
+from .rwbase import NotebookReader, NotebookWriter
+from .nbbase import new_code_cell, new_text_cell, new_worksheet, new_notebook
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+
+_encoding_declaration_re = re.compile(r"^#.*coding[:=]\s*([-\w.]+)")
+
+class PyReaderError(Exception):
+    pass
+
+
+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 = []
+        state = u'codecell'
+        for line in lines:
+            if line.startswith(u'# <nbformat>') or _encoding_declaration_re.match(line):
+                pass
+            elif line.startswith(u'# <codecell>'):
+                cell = self.new_cell(state, cell_lines)
+                if cell is not None:
+                    cells.append(cell)
+                state = u'codecell'
+                cell_lines = []
+            elif line.startswith(u'# <htmlcell>'):
+                cell = self.new_cell(state, cell_lines)
+                if cell is not None:
+                    cells.append(cell)
+                state = u'htmlcell'
+                cell_lines = []
+            elif line.startswith(u'# <markdowncell>'):
+                cell = self.new_cell(state, cell_lines)
+                if cell is not None:
+                    cells.append(cell)
+                state = u'markdowncell'
+                cell_lines = []
+            else:
+                cell_lines.append(line)
+        if cell_lines and state == u'codecell':
+            cell = self.new_cell(state, cell_lines)
+            if cell is not None:
+                cells.append(cell)
+        ws = new_worksheet(cells=cells)
+        nb = new_notebook(worksheets=[ws])
+        return nb
+
+    def new_cell(self, state, lines):
+        if state == u'codecell':
+            input = u'\n'.join(lines)
+            input = input.strip(u'\n')
+            if input:
+                return new_code_cell(input=input)
+        elif state == u'htmlcell':
+            text = self._remove_comments(lines)
+            if text:
+                return new_text_cell(u'html',source=text)
+        elif state == u'markdowncell':
+            text = self._remove_comments(lines)
+            if text:
+                return new_text_cell(u'markdown',source=text)
+
+    def _remove_comments(self, lines):
+        new_lines = []
+        for line in lines:
+            if line.startswith(u'#'):
+                new_lines.append(line[2:])
+            else:
+                new_lines.append(line)
+        text = u'\n'.join(new_lines)
+        text = text.strip(u'\n')
+        return text
+
+    def split_lines_into_blocks(self, lines):
+        if len(lines) == 1:
+            yield lines[0]
+            raise StopIteration()
+        import ast
+        source = '\n'.join(lines)
+        code = ast.parse(source)
+        starts = [x.lineno-1 for x in code.body]
+        for i in range(len(starts)-1):
+            yield '\n'.join(lines[starts[i]:starts[i+1]]).strip('\n')
+        yield '\n'.join(lines[starts[-1]:]).strip('\n')
+
+
+class PyWriter(NotebookWriter):
+
+    def writes(self, nb, **kwargs):
+        lines = [u'# -*- coding: utf-8 -*-']
+        lines.extend([u'# <nbformat>2</nbformat>',''])
+        for ws in nb.worksheets:
+            for cell in ws.cells:
+                if cell.cell_type == u'code':
+                    input = cell.get(u'input')
+                    if input is not None:
+                        lines.extend([u'# <codecell>',u''])
+                        lines.extend(input.splitlines())
+                        lines.append(u'')
+                elif cell.cell_type == u'html':
+                    input = cell.get(u'source')
+                    if input is not None:
+                        lines.extend([u'# <htmlcell>',u''])
+                        lines.extend([u'# ' + line for line in input.splitlines()])
+                        lines.append(u'')
+                elif cell.cell_type == u'markdown':
+                    input = cell.get(u'source')
+                    if input is not None:
+                        lines.extend([u'# <markdowncell>',u''])
+                        lines.extend([u'# ' + line for line in input.splitlines()])
+                        lines.append(u'')
+        lines.append('')
+        return str('\n'.join(lines))
+
+
+_reader = PyReader()
+_writer = PyWriter()
+
+reads = _reader.reads
+read = _reader.read
+to_notebook = _reader.to_notebook
+write = _writer.write
+writes = _writer.writes
+

venv/Lib/site-packages/nbformat/v2/nbxml.py

@@ -0,0 +1,27 @@
+"""REMOVED: Read and write notebook files as XML.
+"""
+
+
+REMOVED_MSG = """\
+Reading notebooks as XML has been removed to harden security and avoid
+possible denial-of-service attacks.
+
+The XML notebook format was deprecated before the Jupyter (previously IPython)
+Notebook was ever released. We are not aware of anyone using it, so we have
+removed it.
+
+If you were using this code, and you need to continue using it, feel free to
+fork an earlier version of the nbformat package and maintain it yourself.
+The issue which prompted this removal is:
+
+https://github.com/jupyter/nbformat/issues/132
+"""
+
+def reads(s, **kwargs):
+    raise Exception(REMOVED_MSG)
+
+def read(fp, **kwargs):
+    raise Exception(REMOVED_MSG)
+
+def to_notebook(root, **kwargs):
+    raise Exception(REMOVED_MSG)

venv/Lib/site-packages/nbformat/v2/rwbase.py

@@ -0,0 +1,165 @@
+"""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
+#-----------------------------------------------------------------------------
+
+import pprint
+
+from ipython_genutils.py3compat import str_to_bytes
+from .._compat import encodebytes, decodebytes
+
+#-----------------------------------------------------------------------------
+# 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 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, str):
+                    cell.input = cell.input.splitlines()
+                for output in cell.outputs:
+                    for key in _multiline_outputs:
+                        item = output.get(key, None)
+                        if isinstance(item, str):
+                            output[key] = item.splitlines()
+            else: # text cell
+                for key in ['source', 'rendered']:
+                    item = cell.get(key, None)
+                    if isinstance(item, str):
+                        cell[key] = item.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, str):
+                            output.png = output.png.encode('ascii')
+                        output.png = decodebytes(output.png)
+                    if 'jpeg' in output:
+                        if isinstance(output.jpeg, str):
+                            output.jpeg = output.jpeg.encode('ascii')
+                        output.jpeg = decodebytes(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 = encodebytes(output.png).decode('ascii')
+                    if 'jpeg' in output:
+                        output.jpeg = encodebytes(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))
+
+
+

venv/Lib/site-packages/nbformat/v2/tests/nbexamples.py

@@ -0,0 +1,109 @@
+import os
+
+from ..._compat import encodebytes
+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 = encodebytes(os.urandom(5))
+jpeg = encodebytes(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=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='bsimpson@fox.com',
+           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 = """# -*- coding: utf-8 -*-
+# <nbformat>2</nbformat>
+
+# <htmlcell>
+
+# Some NumPy Examples
+
+# <codecell>
+
+import numpy
+
+# <markdowncell>
+
+# A random array
+
+# <codecell>
+
+a = numpy.random.rand(100)
+
+# <codecell>
+
+print a
+
+"""
+
+

venv/Lib/site-packages/nbformat/v2/tests/test_json.py

@@ -0,0 +1,34 @@
+import pprint
+from unittest import TestCase
+
+from ..nbjson import reads, writes
+from .nbexamples import nb0
+
+
+class TestJSON(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.assertEqual(reads(s),nb0)
+    
+    def test_roundtrip_nosplit(self):
+        """Ensure that multiline blobs are still readable"""
+        # ensures that notebooks written prior to splitlines change
+        # are still readable.
+        s = writes(nb0, split_lines=False)
+        self.assertEqual(reads(s),nb0)
+
+    def test_roundtrip_split(self):
+        """Ensure that splitting multiline blocks is safe"""
+        # This won't differ from test_roundtrip unless the default changes
+        s = writes(nb0, split_lines=True)
+        self.assertEqual(reads(s),nb0)
+
+
+

venv/Lib/site-packages/nbformat/v2/tests/test_nbbase.py

@@ -0,0 +1,113 @@
+from unittest import TestCase
+
+from ..nbbase import (
+    NotebookNode,
+    new_code_cell, new_text_cell, new_worksheet, new_notebook, new_output,
+    new_author, new_metadata
+)
+
+class TestCell(TestCase):
+
+    def test_empty_code_cell(self):
+        cc = new_code_cell()
+        self.assertEqual(cc.cell_type,u'code')
+        self.assertEqual(u'input' not in cc, True)
+        self.assertEqual(u'prompt_number' not in cc, True)
+        self.assertEqual(cc.outputs, [])
+        self.assertEqual(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.assertEqual(cc.input, u'a=10')
+        self.assertEqual(cc.prompt_number, 0)
+        self.assertEqual(cc.language, u'python')
+        self.assertEqual(cc.outputs[0].svg, u'foo')
+        self.assertEqual(cc.outputs[0].text, u'10')
+        self.assertEqual(cc.outputs[0].prompt_number, 0)
+        self.assertEqual(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.assertEqual(o.output_type, u'pyerr')
+        self.assertEqual(o.etype, u'NameError')
+        self.assertEqual(o.evalue, u'Name not found')
+        self.assertEqual(o.traceback, [u'frame 0', u'frame 1', u'frame 2'])
+
+    def test_empty_html_cell(self):
+        tc = new_text_cell(u'html')
+        self.assertEqual(tc.cell_type, u'html')
+        self.assertEqual(u'source' not in tc, True)
+        self.assertEqual(u'rendered' not in tc, True)
+
+    def test_html_cell(self):
+        tc = new_text_cell(u'html', 'hi', 'hi')
+        self.assertEqual(tc.source, u'hi')
+        self.assertEqual(tc.rendered, u'hi')
+
+    def test_empty_markdown_cell(self):
+        tc = new_text_cell(u'markdown')
+        self.assertEqual(tc.cell_type, u'markdown')
+        self.assertEqual(u'source' not in tc, True)
+        self.assertEqual(u'rendered' not in tc, True)
+
+    def test_markdown_cell(self):
+        tc = new_text_cell(u'markdown', 'hi', 'hi')
+        self.assertEqual(tc.source, u'hi')
+        self.assertEqual(tc.rendered, u'hi')
+
+
+class TestWorksheet(TestCase):
+
+    def test_empty_worksheet(self):
+        ws = new_worksheet()
+        self.assertEqual(ws.cells,[])
+        self.assertEqual(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.assertEqual(ws.cells,cells)
+        self.assertEqual(ws.name,u'foo')
+
+class TestNotebook(TestCase):
+
+    def test_empty_notebook(self):
+        nb = new_notebook()
+        self.assertEqual(nb.worksheets, [])
+        self.assertEqual(nb.metadata, NotebookNode())
+        self.assertEqual(nb.nbformat,2)
+
+    def test_notebook(self):
+        worksheets = [new_worksheet(),new_worksheet()]
+        metadata = new_metadata(name=u'foo')
+        nb = new_notebook(metadata=metadata,worksheets=worksheets)
+        self.assertEqual(nb.metadata.name,u'foo')
+        self.assertEqual(nb.worksheets,worksheets)
+        self.assertEqual(nb.nbformat,2)
+
+class TestMetadata(TestCase):
+
+    def test_empty_metadata(self):
+        md = new_metadata()
+        self.assertEqual(u'name' not in md, True)
+        self.assertEqual(u'authors' not in md, True)
+        self.assertEqual(u'license' not in md, True)
+        self.assertEqual(u'saved' not in md, True)
+        self.assertEqual(u'modified' not in md, True)
+        self.assertEqual(u'gistid' not in md, True)
+
+    def test_metadata(self):
+        authors = [new_author(name='Bart Simpson',email='bsimpson@fox.com')]
+        md = new_metadata(name=u'foo',license=u'BSD',created=u'today',
+            modified=u'now',gistid=u'21341231',authors=authors)
+        self.assertEqual(md.name, u'foo')
+        self.assertEqual(md.license, u'BSD')
+        self.assertEqual(md.created, u'today')
+        self.assertEqual(md.modified, u'now')
+        self.assertEqual(md.gistid, u'21341231')
+        self.assertEqual(md.authors, authors)
+

venv/Lib/site-packages/nbformat/v2/tests/test_nbpy.py

@@ -0,0 +1,17 @@
+from unittest import TestCase
+
+from ..nbbase import (
+    NotebookNode,
+    new_code_cell, new_text_cell, new_worksheet, new_notebook
+)
+
+from ..nbpy import reads, writes
+from .nbexamples import nb0, nb0_py
+
+
+class TestPy(TestCase):
+
+    def test_write(self):
+        s = writes(nb0)
+        self.assertEqual(s,nb0_py)
+