Uploaded Test files

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

@@ -0,0 +1,176 @@
+"""The Jupyter notebook format
+
+Use this module to read or write notebook files as particular nbformat versions.
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+import io
+
+from traitlets.log import get_logger
+from ._version import version_info, __version__
+
+from . import v1
+from . import v2
+from . import v3
+from . import v4
+from .sentinel import Sentinel
+
+__all__ = ['versions', 'validate', 'ValidationError', 'convert', 'from_dict',
+           'NotebookNode', 'current_nbformat', 'current_nbformat_minor',
+           'NBFormatError', 'NO_CONVERT', 'reads', 'read', 'writes', 'write',
+           'version_info', '__version__',
+]
+
+versions = {
+    1: v1,
+    2: v2,
+    3: v3,
+    4: v4,
+}
+
+from .validator import validate, ValidationError
+from .converter import convert
+from . import reader
+from .notebooknode import from_dict, NotebookNode
+
+from .v4 import (
+    nbformat as current_nbformat,
+    nbformat_minor as current_nbformat_minor,
+)
+
+class NBFormatError(ValueError):
+    pass
+
+# no-conversion singleton
+NO_CONVERT = Sentinel('NO_CONVERT', __name__,
+    """Value to prevent nbformat to convert notebooks to most recent version.
+    """)
+
+
+def reads(s, as_version, **kwargs):
+    """Read a notebook from a string and return the NotebookNode object as the given version.
+
+    The string can contain a notebook of any version.
+    The notebook will be returned `as_version`, converting, if necessary.
+
+    Notebook format errors will be logged.
+
+    Parameters
+    ----------
+    s : unicode
+        The raw unicode string to read the notebook from.
+    as_version : int
+        The version of the notebook format to return.
+        The notebook will be converted, if necessary.
+        Pass nbformat.NO_CONVERT to prevent conversion.
+
+    Returns
+    -------
+    nb : NotebookNode
+        The notebook that was read.
+    """
+    nb = reader.reads(s, **kwargs)
+    if as_version is not NO_CONVERT:
+        nb = convert(nb, as_version)
+    try:
+        validate(nb)
+    except ValidationError as e:
+        get_logger().error("Notebook JSON is invalid: %s", e)
+    return nb
+
+
+def writes(nb, version=NO_CONVERT, **kwargs):
+    """Write a notebook to a string in a given format in the given nbformat version.
+
+    Any notebook format errors will be logged.
+
+    Parameters
+    ----------
+    nb : NotebookNode
+        The notebook to write.
+    version : int, optional
+        The nbformat version to write.
+        If unspecified, or specified as nbformat.NO_CONVERT,
+        the notebook's own version will be used and no conversion performed.
+
+    Returns
+    -------
+    s : unicode
+        The notebook as a JSON string.
+    """
+    if version is not NO_CONVERT:
+        nb = convert(nb, version)
+    else:
+        version, _ = reader.get_version(nb)
+    try:
+        validate(nb)
+    except ValidationError as e:
+        get_logger().error("Notebook JSON is invalid: %s", e)
+    return versions[version].writes_json(nb, **kwargs)
+
+
+def read(fp, as_version, **kwargs):
+    """Read a notebook from a file as a NotebookNode of the given version.
+
+    The string can contain a notebook of any version.
+    The notebook will be returned `as_version`, converting, if necessary.
+
+    Notebook format errors will be logged.
+
+    Parameters
+    ----------
+    fp : file or str
+        A file-like object with a read method that returns unicode (use
+        ``io.open()`` in Python 2), or a path to a file.
+    as_version: int
+        The version of the notebook format to return.
+        The notebook will be converted, if necessary.
+        Pass nbformat.NO_CONVERT to prevent conversion.
+
+    Returns
+    -------
+    nb : NotebookNode
+        The notebook that was read.
+    """
+
+    try:
+        buf = fp.read()
+    except AttributeError:
+        with io.open(fp, encoding='utf-8') as f:
+            return reads(f.read(), as_version, **kwargs)
+
+    return reads(buf, as_version, **kwargs)
+
+
+def write(nb, fp, version=NO_CONVERT, **kwargs):
+    """Write a notebook to a file in a given nbformat version.
+
+    The file-like object must accept unicode input.
+
+    Parameters
+    ----------
+    nb : NotebookNode
+        The notebook to write.
+    fp : file or str
+        Any file-like object with a write method that accepts unicode, or
+        a path to write a file.
+    version : int, optional
+        The nbformat version to write.
+        If nb is not this version, it will be converted.
+        If unspecified, or specified as nbformat.NO_CONVERT,
+        the notebook's own version will be used and no conversion performed.
+    """
+    s = writes(nb, version, **kwargs)
+    if isinstance(s, bytes):
+        s = s.decode('utf8')
+
+    try:
+        fp.write(s)
+        if not s.endswith(u'\n'):
+            fp.write(u'\n')
+    except AttributeError:
+        with io.open(fp, 'w', encoding='utf-8') as f:
+            f.write(s)
+            if not s.endswith(u'\n'):
+                f.write(u'\n')

venv/Lib/site-packages/nbformat/_compat.py

@@ -0,0 +1,10 @@
+"""Code for supporting compatibility across python versions."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+try:
+    from base64 import decodebytes, encodebytes
+except ImportError:
+    from base64 import encodestring as encodebytes
+    from base64 import decodestring as decodebytes

venv/Lib/site-packages/nbformat/_version.py

@@ -0,0 +1,3 @@
+# Make sure to update package.json, too!
+version_info = (5, 0, 8)
+__version__ = '.'.join(map(str, version_info))

venv/Lib/site-packages/nbformat/converter.py

@@ -0,0 +1,54 @@
+"""API for converting notebooks between versions."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+from . import versions
+from .reader import get_version
+
+
+def convert(nb, to_version):
+    """Convert a notebook node object to a specific version.  Assumes that
+    all the versions starting from 1 to the latest major X are implemented.
+    In other words, there should never be a case where v1 v2 v3 v5 exist without
+    a v4.  Also assumes that all conversions can be made in one step increments
+    between major versions and ignores minor revisions.
+
+    Parameters
+    ----------
+    nb : NotebookNode
+    to_version : int
+        Major revision to convert the notebook to.  Can either be an upgrade or
+        a downgrade.
+    """
+
+    # Get input notebook version.
+    (version, version_minor) = get_version(nb)
+
+    # Check if destination is target version, if so return contents
+    if version == to_version:
+        return nb
+
+    # If the version exist, try to convert to it one step at a time.
+    elif to_version in versions:
+
+        # Get the the version that this recursion will convert to as a step 
+        # closer to the final revision.  Make sure the newer of the conversion
+        # functions is used to perform the conversion.
+        if to_version > version:
+            step_version = version + 1
+            convert_function = versions[step_version].upgrade
+        else:
+            step_version = version - 1
+            convert_function = versions[version].downgrade
+
+        # Convert and make sure version changed during conversion.
+        converted = convert_function(nb)
+        if converted.get('nbformat', 1) == version:
+            raise ValueError("Failed to convert notebook from v%d to v%d." % (version, step_version))
+
+        # Recursively convert until target version is reached.
+        return convert(converted, to_version)
+    else:
+        raise ValueError("Cannot convert notebook to v%d because that " \
+                        "version doesn't exist" % (to_version))

venv/Lib/site-packages/nbformat/current.py

@@ -0,0 +1,192 @@
+"""Deprecated API for working with notebooks
+
+- use nbformat for read/write/validate public API
+- use nbformat.vX directly for Python API for composing notebooks
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+from __future__ import print_function
+
+import re
+import warnings
+
+warnings.warn("""nbformat.current is deprecated.
+
+- use nbformat for read/write/validate public API
+- use nbformat.vX directly to composing notebooks of a particular version
+""")
+
+from nbformat.v3 import (
+    NotebookNode,
+    new_code_cell, new_text_cell, new_notebook, new_output, new_worksheet,
+    parse_filename, new_metadata, new_author, new_heading_cell, nbformat,
+    nbformat_minor, nbformat_schema, to_notebook_json,
+)
+from nbformat import v3 as _v_latest
+
+from .reader import reads as reader_reads
+from . import versions
+from .converter import convert
+from .validator import validate, ValidationError
+
+from traitlets.log import get_logger
+
+__all__ = ['NotebookNode', 'new_code_cell', 'new_text_cell', 'new_notebook',
+'new_output', 'new_worksheet', 'parse_filename', 'new_metadata', 'new_author',
+'new_heading_cell', 'nbformat', 'nbformat_minor', 'nbformat_schema',
+'to_notebook_json', 'convert', 'validate', 'NBFormatError', 'parse_py',
+'reads_json', 'writes_json', 'reads_py', 'writes_py', 'reads', 'writes', 'read',
+'write']
+
+current_nbformat = nbformat
+current_nbformat_minor = nbformat_minor
+current_nbformat_module = _v_latest.__name__
+
+
+class NBFormatError(ValueError):
+    pass
+
+
+def _warn_format():
+    warnings.warn("""Non-JSON file support in nbformat is deprecated.
+    Use nbconvert to create files of other formats.""")
+
+
+def parse_py(s, **kwargs):
+    """Parse a string into a (nbformat, string) tuple."""
+    nbf = current_nbformat
+    nbm = current_nbformat_minor
+    
+    pattern = r'# <nbformat>(?P<nbformat>\d+[\.\d+]*)</nbformat>'
+    m = re.search(pattern,s)
+    if m is not None:
+        digits = m.group('nbformat').split('.')
+        nbf = int(digits[0])
+        if len(digits) > 1:
+            nbm = int(digits[1])
+
+    return nbf, nbm, s
+
+
+def reads_json(nbjson, **kwargs):
+    """DEPRECATED, use reads"""
+    warnings.warn("reads_json is deprecated, use reads")
+    return reads(nbjson)
+
+def writes_json(nb, **kwargs):
+    """DEPRECATED, use writes"""
+    warnings.warn("writes_json is deprecated, use writes")
+    return writes(nb, **kwargs)
+
+def reads_py(s, **kwargs):
+    """DEPRECATED: use nbconvert"""
+    _warn_format()
+    nbf, nbm, s = parse_py(s, **kwargs)
+    if nbf in (2, 3):
+        nb = versions[nbf].to_notebook_py(s, **kwargs)
+    else:
+        raise NBFormatError('Unsupported PY nbformat version: %i' % nbf)
+    return nb
+
+def writes_py(nb, **kwargs):
+    """DEPRECATED: use nbconvert"""
+    _warn_format()
+    return versions[3].writes_py(nb, **kwargs)
+
+
+# High level API
+
+
+def reads(s, format='DEPRECATED', version=current_nbformat, **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 : unicode
+        The raw unicode string to read the notebook from.
+
+    Returns
+    -------
+    nb : NotebookNode
+        The notebook that was read.
+    """
+    if format not in {'DEPRECATED', 'json'}:
+        _warn_format()
+    nb = reader_reads(s, **kwargs)
+    nb = convert(nb, version)
+    try:
+        validate(nb)
+    except ValidationError as e:
+        get_logger().error("Notebook JSON is invalid: %s", e)
+    return nb
+
+
+def writes(nb, format='DEPRECATED', version=current_nbformat, **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.
+    version : int
+        The nbformat version to write.
+        Used for downgrading notebooks.
+
+    Returns
+    -------
+    s : unicode
+        The notebook string.
+    """
+    if format not in {'DEPRECATED', 'json'}:
+        _warn_format()
+    nb = convert(nb, version)
+    try:
+        validate(nb)
+    except ValidationError as e:
+        get_logger().error("Notebook JSON is invalid: %s", e)
+    return versions[version].writes_json(nb, **kwargs)
+
+
+def read(fp, format='DEPRECATED', **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.
+
+    Returns
+    -------
+    nb : NotebookNode
+        The notebook that was read.
+    """
+    return reads(fp.read(), **kwargs)
+
+
+def write(nb, fp, format='DEPRECATED', **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.
+    """
+    s = writes(nb, **kwargs)
+    if isinstance(s, bytes):
+        s = s.decode('utf8')
+    return fp.write(s)
+

venv/Lib/site-packages/nbformat/json_compat.py

@@ -0,0 +1,82 @@
+# Copyright (c) Jupyter Development Team.
+# Distributed under the terms of the Modified BSD License.
+"""
+Common validator wrapper to provide a uniform usage of other schema validation
+libraries.
+"""
+
+import os
+
+import jsonschema
+from jsonschema import Draft4Validator as _JsonSchemaValidator
+from jsonschema import ValidationError
+
+try:
+    import fastjsonschema
+    from fastjsonschema import JsonSchemaException as _JsonSchemaException
+except ImportError:
+    fastjsonschema = None
+    _JsonSchemaException = ValidationError
+
+
+class JsonSchemaValidator:
+    name = "jsonschema"
+
+    def __init__(self, schema):
+        self._schema = schema
+        self._default_validator = _JsonSchemaValidator(schema)  # Default
+        self._validator = self._default_validator
+
+    def validate(self, data):
+        self._default_validator.validate(data)
+
+    def iter_errors(self, data, schema=None):
+        return self._default_validator.iter_errors(data, schema)
+
+
+class FastJsonSchemaValidator(JsonSchemaValidator):
+    name = "fastjsonschema"
+
+    def __init__(self, schema):
+        self._validator = fastjsonschema.compile(schema)
+
+    def validate(self, data):
+        try:
+            self._validator(data)
+        except _JsonSchemaException as error:
+            raise ValidationError(error.message, schema_path=error.path)
+
+    def iter_errors(self, data, schema=None):
+        errors = []
+        validate_func = self._validator if schema is None else fastjsonschema.compile(schema)
+        try:
+            validate_func(data)
+        except _JsonSchemaException as error:
+            errors = [ValidationError(error.message, schema_path=error.path)]
+
+        return errors
+
+
+_VALIDATOR_MAP = [
+    ("fastjsonschema", fastjsonschema, FastJsonSchemaValidator),
+    ("jsonschema", jsonschema, JsonSchemaValidator),
+]
+VALIDATORS = [item[0] for item in _VALIDATOR_MAP]
+
+
+def _validator_for_name(validator_name):
+    if validator_name not in VALIDATORS:
+        raise ValueError("Invalid validator '{0}' value!\nValid values are: {1}".format(
+            validator_name, VALIDATORS))
+
+    for (name, module, validator_cls) in _VALIDATOR_MAP:
+        if module and validator_name == name:
+            return validator_cls
+
+
+def get_current_validator():
+    """
+    Return the default validator based on the value of an environment variable.
+    """
+    validator_name = os.environ.get("NBFORMAT_VALIDATOR", "jsonschema")
+    return _validator_for_name(validator_name)

venv/Lib/site-packages/nbformat/notebooknode.py

@@ -0,0 +1,53 @@
+"""NotebookNode - adding attribute access to dicts"""
+
+from ipython_genutils.ipstruct import Struct
+try:
+    from collections.abc import Mapping
+except ImportError:
+    from collections import Mapping
+
+
+class NotebookNode(Struct):
+    """A dict-like node with attribute-access"""
+
+    def __setitem__(self, key, value):
+        if isinstance(value, Mapping) and not isinstance(value, NotebookNode):
+            value = from_dict(value)
+        super(NotebookNode, self).__setitem__(key, value)
+
+    def update(self, *args, **kwargs):
+        """
+        A dict-like update method based on CPython's MutableMapping `update`
+        method.
+        """
+        if len(args) > 1:
+            raise TypeError('update expected at most 1 arguments, got %d' %
+                            len(args))
+        if args:
+            other = args[0]
+            if isinstance(other, Mapping):
+                for key in other:
+                    self[key] = other[key]
+            elif hasattr(other, "keys"):
+                for key in other.keys():
+                    self[key] = other[key]
+            else:
+                for key, value in other:
+                    self[key] = value
+        for key, value in kwargs.items():
+            self[key] = value
+
+
+def from_dict(d):
+    """Convert dict to dict-like NotebookNode
+
+    Recursively converts any dict in the container to a NotebookNode.
+    This does not check that the contents of the dictionary make a valid
+    notebook or part of a notebook.
+    """
+    if isinstance(d, dict):
+        return NotebookNode({k: from_dict(v) for k, v in d.items()})
+    elif isinstance(d, (tuple, list)):
+        return [from_dict(i) for i in d]
+    else:
+        return d

venv/Lib/site-packages/nbformat/reader.py

@@ -0,0 +1,82 @@
+"""API for reading notebooks of different versions"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import json
+
+class NotJSONError(ValueError):
+    pass
+
+def parse_json(s, **kwargs):
+    """Parse a JSON string into a dict."""
+    try:
+        nb_dict = json.loads(s, **kwargs)
+    except ValueError as e:
+        # Limit the error message to 80 characters.  Display whatever JSON will fit.
+        raise NotJSONError(("Notebook does not appear to be JSON: %r" % s)[:77] + "...") from e
+    return nb_dict
+
+# High level API
+
+def get_version(nb):
+    """Get the version of a notebook.
+
+    Parameters
+    ----------
+    nb : dict
+        NotebookNode or dict containing notebook data.
+
+    Returns
+    -------
+    Tuple containing major (int) and minor (int) version numbers
+    """
+    major = nb.get('nbformat', 1)
+    minor = nb.get('nbformat_minor', 0)
+    return (major, minor)
+
+
+def reads(s, **kwargs):
+    """Read a notebook from a json string and return the 
+    NotebookNode object.
+
+    This function properly reads notebooks of any version.  No version 
+    conversion is performed.
+
+    Parameters
+    ----------
+    s : unicode | bytes
+        The raw string or bytes object to read the notebook from.
+
+    Returns
+    -------
+    nb : NotebookNode
+        The notebook that was read.
+    """
+    from . import versions, NBFormatError
+    
+    nb_dict = parse_json(s, **kwargs)
+    (major, minor) = get_version(nb_dict)
+    if major in versions:
+        return versions[major].to_notebook_json(nb_dict, minor=minor)
+    else:
+        raise NBFormatError('Unsupported nbformat version %s' % major)
+
+
+def read(fp, **kwargs):
+    """Read a notebook from a file and return the NotebookNode object.
+
+    This function properly reads notebooks of any version.  No version 
+    conversion is performed.
+
+    Parameters
+    ----------
+    fp : file
+        Any file-like object with a read method.
+
+    Returns
+    -------
+    nb : NotebookNode
+        The notebook that was read.
+    """
+    return reads(fp.read(), **kwargs)

venv/Lib/site-packages/nbformat/sentinel.py

@@ -0,0 +1,17 @@
+"""Sentinel class for constants with useful reprs"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+class Sentinel(object):
+
+    def __init__(self, name, module, docstring=None):
+        self.name = name
+        self.module = module
+        if docstring:
+            self.__doc__ = docstring
+
+
+    def __repr__(self):
+        return str(self.module)+'.'+self.name
+

venv/Lib/site-packages/nbformat/sign.py

@@ -0,0 +1,609 @@
+"""Utilities for signing notebooks"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+from collections import OrderedDict
+from contextlib import contextmanager
+from datetime import datetime
+import hashlib
+from hmac import HMAC
+import io
+import os
+import sys
+
+try:
+    import sqlite3
+except ImportError:
+    try:
+        from pysqlite2 import dbapi2 as sqlite3
+    except ImportError:
+        sqlite3 = None
+
+from ipython_genutils.py3compat import cast_bytes, cast_unicode
+from traitlets import (
+    Instance, Bytes, Enum, Any, Unicode, Bool, Integer, TraitType,
+    default, observe,
+)
+from traitlets.config import LoggingConfigurable, MultipleInstanceError
+from jupyter_core.application import JupyterApp, base_flags
+
+from . import read, reads, NO_CONVERT, __version__
+from ._compat import encodebytes
+
+try:
+    # Python 3
+    algorithms = hashlib.algorithms_guaranteed
+    # shake algorithms in py36 are not compatible with hmac
+    # due to required length argument in digests
+    algorithms = [ a for a in algorithms if not a.startswith('shake_') ]
+except AttributeError:
+    algorithms = hashlib.algorithms
+
+
+# This has been added to traitlets, but is not released as of traitlets 4.3.1,
+# so a copy is included here for now.
+class Callable(TraitType):
+    """A trait which is callable.
+
+    Notes
+    -----
+    Classes are callable, as are instances
+    with a __call__() method."""
+
+    info_text = 'a callable'
+
+    def validate(self, obj, value):
+        if callable(value):
+            return value
+        else:
+            self.error(obj, value)
+
+
+class SignatureStore(object):
+    """Base class for a signature store."""
+    def store_signature(self, digest, algorithm):
+        """Implement in subclass to store a signature.
+
+        Should not raise if the signature is already stored.
+        """
+        raise NotImplementedError
+
+    def check_signature(self, digest, algorithm):
+        """Implement in subclass to check if a signature is known.
+
+        Return True for a known signature, False for unknown.
+        """
+        raise NotImplementedError
+
+    def remove_signature(self, digest, algorithm):
+        """Implement in subclass to delete a signature.
+
+        Should not raise if the signature is not stored.
+        """
+        raise NotImplementedError
+
+    def close(self):
+        """Close any open connections this store may use.
+
+        If the store maintains any open connections (e.g. to a database),
+        they should be closed.
+        """
+        pass
+
+
+class MemorySignatureStore(SignatureStore):
+    """Non-persistent storage of signatures in memory.
+    """
+    cache_size = 65535
+    def __init__(self):
+        # We really only want an ordered set, but the stdlib has OrderedDict,
+        # and it's easy to use a dict as a set.
+        self.data = OrderedDict()
+
+    def store_signature(self, digest, algorithm):
+        key = (digest, algorithm)
+        # Pop it so it goes to the end when we reinsert it
+        self.data.pop(key, None)
+        self.data[key] = None
+
+        self._maybe_cull()
+
+    def _maybe_cull(self):
+        """If more than cache_size signatures are stored, delete the oldest 25%
+        """
+        if len(self.data) < self.cache_size:
+            return
+
+        for _ in range(len(self.data) // 4):
+            self.data.popitem(last=False)
+
+    def check_signature(self, digest, algorithm):
+        key = (digest, algorithm)
+        if key in self.data:
+            # Move it to the end (.move_to_end() method is new in Py3)
+            del self.data[key]
+            self.data[key] = None
+            return True
+        return False
+
+    def remove_signature(self, digest, algorithm):
+        self.data.pop((digest, algorithm), None)
+
+class SQLiteSignatureStore(SignatureStore, LoggingConfigurable):
+    """Store signatures in an SQLite database.
+    """
+    # 64k entries ~ 12MB
+    cache_size = Integer(65535,
+        help="""The number of notebook signatures to cache.
+        When the number of signatures exceeds this value,
+        the oldest 25% of signatures will be culled.
+        """
+    ).tag(config=True)
+
+    def __init__(self, db_file, **kwargs):
+        super(SQLiteSignatureStore, self).__init__(**kwargs)
+        self.db_file = db_file
+        self.db = self._connect_db(db_file)
+
+    def close(self):
+        if self.db is not None:
+            self.db.close()
+
+    def _connect_db(self, db_file):
+        kwargs = dict(
+            detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES)
+        db = None
+        try:
+            db = sqlite3.connect(db_file, **kwargs)
+            self.init_db(db)
+        except (sqlite3.DatabaseError, sqlite3.OperationalError):
+            if db_file != ':memory:':
+                old_db_location = db_file + ".bak"
+                if db is not None:
+                    db.close()
+                self.log.warning(
+                    ("The signatures database cannot be opened; maybe it is corrupted or encrypted. "
+                     "You may need to rerun your notebooks to ensure that they are trusted to run Javascript. "
+                     "The old signatures database has been renamed to %s and a new one has been created."),
+                    old_db_location)
+                try:
+                    os.rename(db_file, old_db_location)
+                    db = sqlite3.connect(db_file, **kwargs)
+                    self.init_db(db)
+                except (sqlite3.DatabaseError, sqlite3.OperationalError, OSError):
+                    if db is not None:
+                        db.close()
+                    self.log.warning(
+                        ("Failed commiting signatures database to disk. "
+                         "You may need to move the database file to a non-networked file system, "
+                         "using config option `NotebookNotary.db_file`. "
+                         "Using in-memory signatures database for the remainder of this session."))
+                    self.db_file = ':memory:'
+                    db = sqlite3.connect(':memory:', **kwargs)
+                    self.init_db(db)
+            else:
+                raise
+        return db
+
+    def init_db(self, db):
+        db.execute("""
+            CREATE TABLE IF NOT EXISTS nbsignatures
+            (
+                id integer PRIMARY KEY AUTOINCREMENT,
+                algorithm text,
+                signature text,
+                path text,
+                last_seen timestamp
+            )""")
+        db.execute("""
+            CREATE INDEX IF NOT EXISTS algosig ON nbsignatures(algorithm, signature)
+            """)
+        db.commit()
+
+    def store_signature(self, digest, algorithm):
+        if self.db is None:
+            return
+        if not self.check_signature(digest, algorithm):
+            self.db.execute("""
+                INSERT INTO nbsignatures (algorithm, signature, last_seen)
+                VALUES (?, ?, ?)
+                """, (algorithm, digest, datetime.utcnow())
+            )
+        else:
+            self.db.execute("""UPDATE nbsignatures SET last_seen = ? WHERE
+                algorithm = ? AND
+                signature = ?;
+                """, (datetime.utcnow(), algorithm, digest)
+            )
+        self.db.commit()
+
+        # Check size and cull old entries if necessary
+        n, = self.db.execute("SELECT Count(*) FROM nbsignatures").fetchone()
+        if n > self.cache_size:
+            self.cull_db()
+
+    def check_signature(self, digest, algorithm):
+        if self.db is None:
+            return False
+        r = self.db.execute("""SELECT id FROM nbsignatures WHERE
+            algorithm = ? AND
+            signature = ?;
+            """, (algorithm, digest)).fetchone()
+        if r is None:
+            return False
+        self.db.execute("""UPDATE nbsignatures SET last_seen = ? WHERE
+            algorithm = ? AND
+            signature = ?;
+            """,
+                        (datetime.utcnow(), algorithm, digest),
+                        )
+        self.db.commit()
+        return True
+
+    def remove_signature(self, digest, algorithm):
+        self.db.execute("""DELETE FROM nbsignatures WHERE
+                algorithm = ? AND
+                signature = ?;
+            """,
+            (algorithm, digest)
+        )
+
+        self.db.commit()
+
+    def cull_db(self):
+        """Cull oldest 25% of the trusted signatures when the size limit is reached"""
+        self.db.execute("""DELETE FROM nbsignatures WHERE id IN (
+            SELECT id FROM nbsignatures ORDER BY last_seen DESC LIMIT -1 OFFSET ?
+        );
+        """, (max(int(0.75 * self.cache_size), 1),))
+
+
+def yield_everything(obj):
+    """Yield every item in a container as bytes
+
+    Allows any JSONable object to be passed to an HMAC digester
+    without having to serialize the whole thing.
+    """
+    if isinstance(obj, dict):
+        for key in sorted(obj):
+            value = obj[key]
+            yield cast_bytes(key)
+            for b in yield_everything(value):
+                yield b
+    elif isinstance(obj, (list, tuple)):
+        for element in obj:
+            for b in yield_everything(element):
+                yield b
+    elif isinstance(obj, str):
+        yield obj.encode('utf8')
+    else:
+        yield str(obj).encode('utf8')
+
+def yield_code_cells(nb):
+    """Iterator that yields all cells in a notebook
+
+    nbformat version independent
+    """
+    if nb.nbformat >= 4:
+        for cell in nb['cells']:
+            if cell['cell_type'] == 'code':
+                yield cell
+    elif nb.nbformat == 3:
+        for ws in nb['worksheets']:
+            for cell in ws['cells']:
+                if cell['cell_type'] == 'code':
+                    yield cell
+
+@contextmanager
+def signature_removed(nb):
+    """Context manager for operating on a notebook with its signature removed
+
+    Used for excluding the previous signature when computing a notebook's signature.
+    """
+    save_signature = nb['metadata'].pop('signature', None)
+    try:
+        yield
+    finally:
+        if save_signature is not None:
+            nb['metadata']['signature'] = save_signature
+
+
+class NotebookNotary(LoggingConfigurable):
+    """A class for computing and verifying notebook signatures."""
+
+    data_dir = Unicode()
+    @default('data_dir')
+    def _data_dir_default(self):
+        app = None
+        try:
+            if JupyterApp.initialized():
+                app = JupyterApp.instance()
+        except MultipleInstanceError:
+            pass
+        if app is None:
+            # create an app, without the global instance
+            app = JupyterApp()
+            app.initialize(argv=[])
+        return app.data_dir
+
+    store_factory = Callable(
+         help="""A callable returning the storage backend for notebook signatures.
+         The default uses an SQLite database.""").tag(config=True)
+
+    @default('store_factory')
+    def _store_factory_default(self):
+        def factory():
+            if sqlite3 is None:
+                self.log.warning("Missing SQLite3, all notebooks will be untrusted!")
+                return MemorySignatureStore()
+            return SQLiteSignatureStore(self.db_file)
+        return factory
+
+    db_file = Unicode(
+        help="""The sqlite file in which to store notebook signatures.
+        By default, this will be in your Jupyter data directory.
+        You can set it to ':memory:' to disable sqlite writing to the filesystem.
+        """).tag(config=True)
+
+    @default('db_file')
+    def _db_file_default(self):
+        if not self.data_dir:
+            return ':memory:'
+        return os.path.join(self.data_dir, u'nbsignatures.db')
+
+    algorithm = Enum(algorithms, default_value='sha256',
+        help="""The hashing algorithm used to sign notebooks."""
+    ).tag(config=True)
+    @observe('algorithm')
+    def _algorithm_changed(self, change):
+        self.digestmod = getattr(hashlib, change.new)
+
+    digestmod = Any()
+    @default('digestmod')
+    def _digestmod_default(self):
+        return getattr(hashlib, self.algorithm)
+
+    secret_file = Unicode(
+        help="""The file where the secret key is stored."""
+    ).tag(config=True)
+    @default('secret_file')
+    def _secret_file_default(self):
+        if not self.data_dir:
+            return ''
+        return os.path.join(self.data_dir, 'notebook_secret')
+
+    secret = Bytes(
+        help="""The secret key with which notebooks are signed."""
+    ).tag(config=True)
+    @default('secret')
+    def _secret_default(self):
+        # note : this assumes an Application is running
+        if os.path.exists(self.secret_file):
+            with io.open(self.secret_file, 'rb') as f:
+                return f.read()
+        else:
+            secret = encodebytes(os.urandom(1024))
+            self._write_secret_file(secret)
+            return secret
+
+    def __init__(self, **kwargs):
+        super(NotebookNotary, self).__init__(**kwargs)
+        self.store = self.store_factory()
+
+    def _write_secret_file(self, secret):
+        """write my secret to my secret_file"""
+        self.log.info("Writing notebook-signing key to %s", self.secret_file)
+        with io.open(self.secret_file, 'wb') as f:
+            f.write(secret)
+        try:
+            os.chmod(self.secret_file, 0o600)
+        except OSError:
+            self.log.warning(
+                "Could not set permissions on %s",
+                self.secret_file
+            )
+        return secret
+
+    def compute_signature(self, nb):
+        """Compute a notebook's signature
+
+        by hashing the entire contents of the notebook via HMAC digest.
+        """
+        hmac = HMAC(self.secret, digestmod=self.digestmod)
+        # don't include the previous hash in the content to hash
+        with signature_removed(nb):
+            # sign the whole thing
+            for b in yield_everything(nb):
+                hmac.update(b)
+
+        return hmac.hexdigest()
+
+    def check_signature(self, nb):
+        """Check a notebook's stored signature
+
+        If a signature is stored in the notebook's metadata,
+        a new signature is computed and compared with the stored value.
+
+        Returns True if the signature is found and matches, False otherwise.
+
+        The following conditions must all be met for a notebook to be trusted:
+        - a signature is stored in the form 'scheme:hexdigest'
+        - the stored scheme matches the requested scheme
+        - the requested scheme is available from hashlib
+        - the computed hash from notebook_signature matches the stored hash
+        """
+        if nb.nbformat < 3:
+            return False
+        signature = self.compute_signature(nb)
+        return self.store.check_signature(signature, self.algorithm)
+
+    def sign(self, nb):
+        """Sign a notebook, indicating that its output is trusted on this machine
+
+        Stores hash algorithm and hmac digest in a local database of trusted notebooks.
+        """
+        if nb.nbformat < 3:
+            return
+        signature = self.compute_signature(nb)
+        self.store.store_signature(signature, self.algorithm)
+
+    def unsign(self, nb):
+        """Ensure that a notebook is untrusted
+
+        by removing its signature from the trusted database, if present.
+        """
+        signature = self.compute_signature(nb)
+        self.store.remove_signature(signature, self.algorithm)
+
+    def mark_cells(self, nb, trusted):
+        """Mark cells as trusted if the notebook's signature can be verified
+
+        Sets ``cell.metadata.trusted = True | False`` on all code cells,
+        depending on the *trusted* parameter. This will typically be the return
+        value from ``self.check_signature(nb)``.
+
+        This function is the inverse of check_cells
+        """
+        if nb.nbformat < 3:
+            return
+
+        for cell in yield_code_cells(nb):
+            cell['metadata']['trusted'] = trusted
+
+    def _check_cell(self, cell, nbformat_version):
+        """Do we trust an individual cell?
+
+        Return True if:
+
+        - cell is explicitly trusted
+        - cell has no potentially unsafe rich output
+
+        If a cell has no output, or only simple print statements,
+        it will always be trusted.
+        """
+        # explicitly trusted
+        if cell['metadata'].pop("trusted", False):
+            return True
+
+        # explicitly safe output
+        if nbformat_version >= 4:
+            unsafe_output_types = ['execute_result', 'display_data']
+            safe_keys = {"output_type", "execution_count", "metadata"}
+        else: # v3
+            unsafe_output_types = ['pyout', 'display_data']
+            safe_keys = {"output_type", "prompt_number", "metadata"}
+
+        for output in cell['outputs']:
+            output_type = output['output_type']
+            if output_type in unsafe_output_types:
+                # if there are any data keys not in the safe whitelist
+                output_keys = set(output)
+                if output_keys.difference(safe_keys):
+                    return False
+
+        return True
+
+    def check_cells(self, nb):
+        """Return whether all code cells are trusted.
+
+        A cell is trusted if the 'trusted' field in its metadata is truthy, or
+        if it has no potentially unsafe outputs.
+        If there are no code cells, return True.
+
+        This function is the inverse of mark_cells.
+        """
+        if nb.nbformat < 3:
+            return False
+        trusted = True
+        for cell in yield_code_cells(nb):
+            # only distrust a cell if it actually has some output to distrust
+            if not self._check_cell(cell, nb.nbformat):
+                trusted = False
+
+        return trusted
+
+
+trust_flags = {
+    'reset' : (
+        {'TrustNotebookApp' : { 'reset' : True}},
+        """Delete the trusted notebook cache.
+        All previously signed notebooks will become untrusted.
+        """
+    ),
+}
+trust_flags.update(base_flags)
+
+
+class TrustNotebookApp(JupyterApp):
+    version = __version__
+    description="""Sign one or more Jupyter notebooks with your key,
+    to trust their dynamic (HTML, Javascript) output.
+
+    Otherwise, you will have to re-execute the notebook to see output.
+    """
+    # This command line tool should use the same config file as the notebook
+    @default('config_file_name')
+    def _config_file_name_default(self):
+        return 'jupyter_notebook_config'
+
+    examples = """
+    jupyter trust mynotebook.ipynb and_this_one.ipynb
+    """
+
+    flags = trust_flags
+
+    reset = Bool(False,
+        help="""If True, delete the trusted signature cache.
+        After reset, all previously signed notebooks will become untrusted.
+        """
+    ).tag(config=True)
+
+    notary = Instance(NotebookNotary)
+    @default('notary')
+    def _notary_default(self):
+        return NotebookNotary(parent=self, data_dir=self.data_dir)
+
+    def sign_notebook_file(self, notebook_path):
+        """Sign a notebook from the filesystem"""
+        if not os.path.exists(notebook_path):
+            self.log.error("Notebook missing: %s" % notebook_path)
+            self.exit(1)
+        with io.open(notebook_path, encoding='utf8') as f:
+            nb = read(f, NO_CONVERT)
+        self.sign_notebook(nb, notebook_path)
+
+    def sign_notebook(self, nb, notebook_path='<stdin>'):
+        """Sign a notebook that's been loaded"""
+        if self.notary.check_signature(nb):
+            print("Notebook already signed: %s" % notebook_path)
+        else:
+            print("Signing notebook: %s" % notebook_path)
+            self.notary.sign(nb)
+
+    def generate_new_key(self):
+        """Generate a new notebook signature key"""
+        print("Generating new notebook key: %s" % self.notary.secret_file)
+        self.notary._write_secret_file(os.urandom(1024))
+
+    def start(self):
+        if self.reset:
+            if os.path.exists(self.notary.db_file):
+                print("Removing trusted signature cache: %s" % self.notary.db_file)
+                os.remove(self.notary.db_file)
+            self.generate_new_key()
+            return
+        if not self.extra_args:
+            self.log.debug("Reading notebook from stdin")
+            nb_s = cast_unicode(sys.stdin.read())
+            nb = reads(nb_s, NO_CONVERT)
+            self.sign_notebook(nb, '<stdin>')
+        else:
+            for notebook_path in self.extra_args:
+                self.sign_notebook_file(notebook_path)
+
+
+main = TrustNotebookApp.launch_instance
+
+if __name__ == '__main__':
+    main()

venv/Lib/site-packages/nbformat/tests/base.py

@@ -0,0 +1,21 @@
+"""
+Contains base test class for nbformat
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import os
+import unittest
+import io
+
+class TestsBase(unittest.TestCase):
+    """Base tests class."""
+
+    @classmethod
+    def fopen(cls, f, mode=u'r',encoding='utf-8'):
+        return io.open(os.path.join(cls._get_files_path(), f), mode, encoding=encoding)
+
+    @classmethod
+    def _get_files_path(cls):
+        return os.path.dirname(__file__)

venv/Lib/site-packages/nbformat/tests/invalid.ipynb

@@ -0,0 +1,306 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {}
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lorem ipsum** dolor sit amet, consectetur adipiscing elit. Nunc luctus bibendum felis dictum sodales. Ut suscipit, orci ut interdum imperdiet, purus ligula mollis *justo*, non malesuada nisl augue eget lorem. Donec bibendum, erat sit amet porttitor aliquam, urna lorem ornare libero, in vehicula diam diam ut ante. Nam non urna rhoncus, accumsan elit sit amet, mollis tellus. Vestibulum nec tellus metus. Vestibulum tempor, ligula et vehicula rhoncus, sapien turpis faucibus lorem, id dapibus turpis mauris ac orci. Sed volutpat vestibulum venenatis."
+   ]
+  },
+  {
+   "cell_type": "heading",
+   "level": 2,
+   "metadata": {},
+   "source": [
+    "Printed Using Python"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "bad stream",
+     "text": [
+      "hello\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"hello\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Pyout"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "<script>\n",
+       "console.log(\"hello\");\n",
+       "</script>\n",
+       "<b>HTML</b>\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML at 0x1112757d0>"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import HTML\n",
+    "HTML(\"\"\"\n",
+    "<script>\n",
+    "console.log(\"hello\");\n",
+    "</script>\n",
+    "<b>HTML</b>\n",
+    "\"\"\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "console.log(\"hi\");"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript at 0x1112b4b50>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%javascript\n",
+    "console.log(\"hi\");"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": [
+       "iVBORw0KGgoAAAANSUhEUgAAAggAAABDCAYAAAD5/P3lAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n",
+       "AAAH3AAAB9wBYvxo6AAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAACAASURB\n",
+       "VHic7Z15uBxF1bjfugkJhCWBsCSAJGACNg4QCI3RT1lEAVE+UEBNOmwCDcjHT1wQgU+WD3dFxA1o\n",
+       "CAikAZFFVlnCjizpsCUjHQjBIAkQlpCFJGS79fvjdGf69vTsc2fuza33eeaZmeqq6jM9vZw6dc4p\n",
+       "BUwC+tE+fqW1fqmRDpRSHjCggS40sBxYDCxKvL8KzNBaL21EPoPB0DPIWVY/4NlE0ffzYfhgu+Qx\n",
+       "GHoy/YFjaK+CcB3QkIIAHAWs3wRZsuhUSs0CXgQeBm7UWi/spn0Z+jA5yxpEfYruqnwYllRic5a1\n",
+       "MaWv8U5gaT4M19Sx396IAnZLfB/SLkEMhp5O/3YL0AvoAHaKXl8HLlZK3QZcpbWe0lbJDOsaHuDU\n",
+       "0e4u4JAy2wPk/C1JzrKWArOQ0fUtwH35MOysQxaDwbCO0NFuAXoh6wPjgQeUUvcqpUa0WyCDoQls\n",
+       "CIwBjgfuAV7KWdY+7RWpmJxlXZezrEdylvXxdstiMKzrGAtCYxwI/EspdZbW+g/tFsbQ67kQuBHY\n",
+       "FNgseh9FV6vCbUAeWBC9PgBeq2EfS6J2MQOBrRDTe5KdgAdzlvW1fBjeUUP/3UbOsoYBE6OvG7VT\n",
+       "FoOhL9Af+BUwFLkZpV+DaY6V4UPkRpb1+ncT+m8nGwK/V0oN01qf025hDL2XfBi+DLycLMtZVo6u\n",
+       "CsKfGnSq8/NheEpqHwOBEcDBwJnAsGhTP2ByzrJG5cPwnQb22Sy+0G4BDIa+RH+t9dmlNiqlFKIk\n",
+       "JJWGi+jq5JPmq8BbJJQArfXqpkncczlbKbVQa/3rdgtiMNRCPgxXAK8Ar+Qs63LgXmDvaPPGwPeA\n",
+       "H7VJvCRfbLcABkNfouwUg9ZaAwuj178BlFLvVejzgR4WFviM1npcuQpKqf6IyXIjxLS7GzAWuUnu\n",
+       "XsO+fqWUellr3ZBJdq/jr9+BDn1uve07O9Rz0y6f8PtGZGgWe53oT6SBkZ/q1/nHZy47aloTRTKU\n",
+       "IR+Gy3OWNR6Zxtg0Kv4KRkEwGPocxgcBiCwcsSI0F5iOhF+ilPok8C3gVGS+thK/VErdrbWuO2ys\n",
+       "s/+aLZTuOKbe9krrIUCPUBB0B+PQ1P1bdKe6EzAKQgvJh+GbOct6gkJkxM45y+qXDIWMHBhjBWJe\n",
+       "PgyDWvaRs6zPIVObAG/nw/DpEvUGAp8E9gGGJzbtl7Os7cvs4skqp0V0Yl8jgcOBjyMDhbmIZeWl\n",
+       "fBg+UUVfReQsayhwELAnsAXi6/E28BxwTz4MP6iyn92RaSCA+/NhuCwqXx9R4MYhU0MfRTK/AjyW\n",
+       "D8MFGd0ZDFVhFIQKaK3/BXxfKXUlklTq0xWafAI4Driyu2UzGLqRlygoCArYHJif2H4gcFb0+Z2c\n",
+       "ZW2bD8NV1XScs6yNgH8g/jsAPwCeTmzfFPgjYsnbiez71MUVdnMQcF8V4nyUs6whwB8QX4+0s2Ys\n",
+       "0yPAt/NhGFbRZ/wbzgO+DaxXotqqnGX9GbigCkXhf5CBCsDngYdzljURGQhsWqLN+znL+iFwdT4M\n",
+       "dYk6BkNJTJhjlWitQ2Bf4P4qqv848t8wGHor6Yd9+ruHJFkC2BI4rIa+D6egHKwmstYlGAxMQCwH\n",
+       "rRjEPI5ER5S7ZvcFXsxZ1phKneUsawSi8HyH0soB0bbvAM9Ebaplt5xlnYkct1LKAYiFZhJwSQ19\n",
+       "GwxrMRaEGtBar1RKfRX4JxIzXortou3PN1mE+YgJsSwaeoLHOQCqUy3QSr9eqZ6G/gq2aYVMhqrY\n",
+       "OfF5FeJwvJZ8GM7JWdY/gC9HRS7wtyr7Pjrx+e6MqYC3KLbU7Qhck/h+FJIKvRRVjfSREXicU8EH\n",
+       "pgAvIIqLBZwGfC7avl5Uf29KkLOsTZCMq8npj9sQx89no37HIlaAODplNPBIzrJ2z4dhNVlaT0HC\n",
+       "XwFmIkrAC4if2PaIz8/3KCgn385Z1pX5MJxeRd8Gw1qMglAjWutlSqnTgUcqVP0SzVYQtP5mcMXE\n",
+       "SvvtUUy9YsK5QEWHy7EnTB6lOtSsFohkqEDOsgYAdqJoagkT9Z8pKAj75yzr4/kwnF2h748ho/GY\n",
+       "q9J1oqiKLj4JOctKK8Yz8mH4Yrl9VcnHkXVYTsyHoZ8WJWdZNyPThbF5/3M5yzowH4alpi9+T0E5\n",
+       "WA18Nx+Gf0zVeRG4KmdZ90R9bwCMRKwyX69C5h2j91uA4/JhuCSxbTYwJWdZtwNPIFbifsAFSISZ\n",
+       "wVA1ZoqhDrTWjyIjjXIc3ApZDIZu4ELgY4nvt5Wody8wJ/qsgBOr6HsihfvOfCRrY7v5dYZyAECk\n",
+       "GP0ISEZmZYZ55yxrB8SyEXNxhnKQ7Pt64H8TRUfmLGuXKmWeC4xPKQfJvp9CLCJlZTYYymEUhPq5\n",
+       "tcL2XVsihcHQJHKWtU3Osi5GnAZj5iKWgiKitRouTxQdl7OscnPu0HV64dp8GLY7R8pyxEGxJPkw\n",
+       "fBcZ9ceUSvN8IoV76upK/UZcgawcG3NKqYopfleFU+gDic/b5SzLWIwNNWFOmPqp5CG9sVJqPa11\n",
+       "VZ7dBkOL2D1nWcmcBkOR8MFtgM/QdTXJZcCR+TBcXqa/SYj5egAFZ8VMX4ScZe2FRPnEXF2z9M3n\n",
+       "3nwYVsrtAmK6/0z0uVR4ZXLtivvzYfhGpU7zYbgkZ1k3ACdHRQdWIQsUO3ZmkUzB3Q/xjaolLbeh\n",
+       "j2MUhDrRWr+mlFpJ+eV5hyIxz4YWs98Fj/Rf8uZbozo0/ZYt7D8rf9ORK9stUw/hU9GrEnMAp1R+\n",
+       "gph8GL4bzdNPiIpOorSzYtJ68FS1IYPdTLWp3hcnPm+Q3pizrA7E+TCmFn+aZN0dcpY1LB+G5e4b\n",
+       "y6rM8bA49X39GmQyGMwUQ4NUGnkMrbDd0A3sdeLk4z6cN+89pTtDTWd+gyErF+7pTv5eu+XqJbyK\n",
+       "TDHsmg/DJ6tsc2ni8+dzljUqXSGaevhmoqjIObFNVBzlV8kQug4W5tbQNl13WGatAv+poW+DoW6M\n",
+       "BaExPgC2LrO9nHWhpSilDqI4NPMhrfXUJvS9M/DfqeJXtdY3N9p3rex50uQ9lFKT6BrTvoFCXbTX\n",
+       "yZNfmnrZxHtbLVMP4xng74nvK5DzeD7wfIWRayb5MHwiZ1kzgF0oOCuemar2ZQoK8zLgr7Xup5t4\n",
+       "s0n9DEl9b0RBSPeV5q0a+jYY6sYoCI1RacnZ91siRXUMAH6eKnsYicdulDOAY1NlpzWh35pRqG9R\n",
+       "IuGN7uw4AfG878s8nw/DX3RDv5dScGY8NmdZP86HYXJaJzm9cHMp7/s2UHdK9BTpKaxBNbRN163k\n",
+       "t9Rux05DH8FMMTTGZhW2v9sSKarjbopNk/sqpUY30qlSahCSGS/JCuD6RvqtF6UpMm/HaHTJbYaG\n",
+       "mQzED/0umRVzlrUZhXwJ0HOmF5pJOlXyxzJrZbNt6rtZP8HQIzAKQp0opTZAlsItxTKtdTnv75YS\n",
+       "LR7lpYqrjV0vx2EUH4fbtdZtucnpMqOrDjPy6jYii8DkRFHSYnAEhem22cBjrZKrVeTDcCldTf/p\n",
+       "h345ksrEGprnF2EwNIRREOrnMxW2z2uJFLVxJcXmy2OVUo34ShydUda+EaIq7T2u0SZTY/eSdFY8\n",
+       "MGdZm0efk86J6/LCQUnFp5pIkZjkcvQz8mH4YZPkMRgawigI9VNp7v7BlkhRA1rr+RQneNqC2hba\n",
+       "WYtSajiS9z3JXLomaGktq/VllLIUdKqSWe0MjZMPwxlIel8Q/6Zv5CxrGIX8AJ10XU+hFtIRQ+UW\n",
+       "KWoXyYyTu+Qsa79KDXKWNRpJyx5zZ9OlMhjqxCgIdaCU6g98o0K1npBCNotLM8rcOvuagCRgSXKN\n",
+       "1rozq3IrCCZNfFkrfRjotWsCaJinUBODK51/tkuuPkTy/DoYOIDCfeb+fBjW4t2/lqhdcmRdbUri\n",
+       "VnILXS2HZ1WRvfAcCk61K4A/dYdgBkM9GAWhPr5F6XSrIBf6Qy2SpSaidSReShV/XilV7veUIj29\n",
+       "oOkB2fGmXT7x7sCbOGpFf7VZx4A1m0/znG2nehMyc+0bms7NFJxzxwH7J7Y1OvWUPG9/mLOsLRvs\n",
+       "r6lEaaOT0TtfBB5ITLWsJWdZg3KWdRNwTKL4wnwYzu9mMQ2GqjFhjjWilBqBpJYtx51a66UV6rST\n",
+       "S+maJz52VvxRdvVilFK7UbzexGNa67Kr+bWS6X+ekPYs79HkLGt34JOI+Xyz6D2d1vfMnGUdini6\n",
+       "L0C851/Oh2HD+SyaQT4MV+YsaxJyLm1Gwf9gAXBHg93/JNHHtsArOcuajCztPBDYCkkytBXg5sOw\n",
+       "5QmF8mF4W86yLgK+HxXtC8zKWVaALMm8CslHsicS7RFzL8VhyAZDWzEKQg0opbYE7qd8prPVdF2h\n",
+       "rSdyLfALYMNE2XFKqR/XsHbEURll62L4Wiv5PuBUqPPF6JXkLuCQbpGoPi4HfohYKGMHWD9axrlu\n",
+       "8mF4Z7RuwfioaDBwaonqRemQW0U+DH+Qs6xFwHnIFNwQsv+3mMnA8dHiVwZDj8FMMVSJUuow4DkK\n",
+       "a7GX4gqt9cstEKlutNaL6boULMho5tBq2iul+lH8IFuCmJcNfZx8GM6hOCFVU5THfBhOQHxfylkH\n",
+       "3gY+asb+6iUfhhcCewC3l5BlFbJk/P75MDwqlVTKYOgRKK1rizhSSk2h67ximo1abV5XSi2n9EIk\n",
+       "z2itx5XYVqnfQcjI7DiqW2XtfeCTUbRA3ex50nWfUrqjeJEcrfcLrpj4SCN9xyilxgDPp4of0Fof\n",
+       "UEXbg4B/pIqv1FrXnVNh7AmTR3V0qIwwRH1E4E28pd5+De0hZ1m/Bb4bfX0+H4Z7dMM+hgGjkDwC\n",
+       "S5FpjFk9bR4/Z1mDkGmF4VHR20g4Y3oxJYOhR9EXphg6lFLlVjFbH0mZvDGwCTAayCFe0ntTOZ1y\n",
+       "zDLgkEaVg1ahtX5BKfUU8OlE8ReUUjtorSstCduzch8YehSR5/6ERFG3nBvRuhE9frXUfBguA6pd\n",
+       "+Mpg6DH0BQXBBro7o+Ea4Bta66e6eT/N5lK6KggKOAE4u1QDpdTGFOdNmNkLf7uh+zgYcRQEMa+3\n",
+       "Je22wWBoDOOD0DhLgYla67vaLUgd3ETxglLHRXkeSnEExQ5gbQ9tNPQokis5TsqHoVlbwGDohRgF\n",
+       "oTECYHet9Y3tFqQetNYrKDb/DqN46eYk6emF1UhUhMFAzrImUEhDvgr4VRvFMRgMDWAUhPpYAvwf\n",
+       "8Bmte31+/8uQBEdJMjMrKqW2o5A2N+YfWusePw9s6F5yltWRs6zxwKRE8RXtyEVgMBiaQ1/wQWgm\n",
+       "eWTe/jqtdU9Zz74htNavKaXuAw5KFB+glBqptZ6Tqj6RQlrYGDO90AfJWdY5wNeQFQwHIAmetk5U\n",
+       "eZFCsiCDwdALMQpCed5AphEC4NF12BHvUroqCAoJ7TwvVS+d++BdJEmPoe+xKRLnn0UeODwfhm3N\n",
+       "RWAwGBqjLygIbwN/LbNdI1MGH6ReL/eWkMUmcDeSeGa7RNlRSqnzdZQoQym1C7Bzqt11NWReNKxb\n",
+       "zEMU6GHAesBiYCaSLOviaF0Cg8HQi+kLCsLrWuvT2y1ET0ZrvUYp5SG57mO2Bz4LPB59/2ZRQ5P7\n",
+       "oM+SD8OLgYvbLYfBYOg+jJOiIeZKxOs8STJiIb28daC1/lf3imQwGAyGdmEUBAMA0XTKraniI5VS\n",
+       "A6O0zOnloI31wGAwGNZhjIJgSHJp6vtgJBNlehW65cANLZHIYDAYDG3BKAiGtWitHwVeShV/muLF\n",
+       "uW7VWi9qjVQGg8FgaAd9wUnRUBuXAn9IfN8f+FyqTo/OfbDnSX8brDpXnqEUe2ropzQvdtDx66ev\n",
+       "GN9XolIMPQDb9T8LrBd4zsPtlsXQe7Bd/0BgQeA5QbtlMQqCIc21wC+ADaPv6WWu5wAPtVKgWtjt\n",
+       "6Os2XG/9jhdQjIzTQ2rFF9bQecy4E2/I9UQlwXb9LYDDK1R7K/Cc21shj6FxbNcfDjwGKNv1Rwae\n",
+       "83q7ZWo2tusPBb6ELGW9BbAICX99Gngs8Jx0hlZDBWzXHwvcC6ywXX9o4DlL2ymPURAMXdBaL1ZK\n",
+       "+ZRItwz8Jc6N0BMZMFB9GxiZsWnzTjrPAH7QWomqYgTF/h9pngC6RUGwXf+XwC2B50ztjv57M7br\n",
+       "XwJMCjxneo1NP0SWgAfJq7LOYLv+esAFwOkUL9wWM912/d0Dz+lsnWQ9A9v1BwEXAT8PPKfWVOML\n",
+       "kPVt3kNWQm0rxgfBkEWph5UG/tJCOWqnQ40ttUkrvWcrRamWwHOmAZsguSfGAi9Hmy5AUhgPAz7f\n",
+       "Hfu2XX8k8ENgx+7ovzdju/4uwP9D/peaCDxnCbANsF3gOYubLVu7sF1/AHAHcBaiHDwI/C+ywNsE\n",
+       "4KfA68BdfVE5iNgbOBmxqtRE4Dn/BoYDnwg8Z02zBasVY0EwFKG1fkEp9RTioJjkIa11zzaVarYq\n",
+       "vVFt2TpBaiN6oCwB5tiu/2FUPCvwnLTTaLM5oJv77800dGwCz1kXHXkvRNKydwI/Cjzn1+kKtuuf\n",
+       "i2TX7Ks0et681yxBGsUoCIZSBBQrCL0h98EbdW7rddiuPwoYFJu/bdffFNgL2BZ4DZgWKR5ZbRWS\n",
+       "2+KIqGiE7fpjUtXmlrtZRdaHscBAYDowM/CckimWbdffFfgw8JzXou/9kfUccojV5MXAcz4s0XYw\n",
+       "sCsymu8PzAVmBJ7zVqn9pdoPRVKF7wSsAN4EgqzRve36HcAoZDEqgO0zjs3rged8kGo3gOJ05ADT\n",
+       "s0bTkan+k9HXGaVGjNFxykVf81nH2Hb9Ich/MRJJeT291H9fL7brj6CwANfPspQDgOi3rijRx/rI\n",
+       "b8kB7wPPBZ4zL6Ne/JvfCDzn/WhufhvgvsBzVkR1dgN2AR4JPGduom38P7wXeM7c6FzfCfgU4iMR\n",
+       "lFLebNfPIefXzMBzikz8tusPQyx676bljmTeCfhyVLST7frp//TV9Dluu/6GwOhUvTWB58zIkjFq\n",
+       "sykyNfmfwHMW2K7fLzoWeyDTFPnAc14t1T7qYwNgT+Rc/wi5ZyT/N20UBEMRSqn+wNdTxQspTqTU\n",
+       "41BaP6yVOipzGzzSYnG6m6uBz0YPv7OQm3dytc35tuuflHZutF3/BuArwEaJ4p/QNdU2wGnAH9M7\n",
+       "jRSTG5CbS5LQdv2joymTLKYBzwHjbNc/DomW2TCxfbXt+sMCz3k/sa8RwM+Qh/X6qf5W2q4/CTit\n",
+       "zMN1OPB7CopQktW2658YeM5fEvXvRKZzBiXqZaWUPha4JlW2NfB8Rt0hiANfmjWIuf5jiLPfvVm/\n",
+       "AfmvbgNmB54zKrkheuD+Bjg11Wap7fpnBJ5TybelFk4E+iE+Fb+ptbHt+scg//nGqfJbgeMDz1mY\n",
+       "KN4UOZYX2q7fSWHhuNdt198ZOBc4MypbbLv+5wPPeTb6PiJqe5ft+ichx3WXRN8rbdc/OfCcrGis\n",
+       "R4ChiHKSlSn2f4BzkOvitMRvCKJ9DEzU9TPafwGZlkkyBvExSrKUrtdnmoOBycA5tus/iCyat3li\n",
+       "u7Zd/0rk2ihS1mzXPwT4E3LulaLTKAiGLL6EaMlJbtBat91pphIjFw289t9DVh4N7Jva9EKnWnpJ\n",
+       "G0RqBXcjCa08YCqy/PJE4L8A33b9HQPPeTNR/0bgvujzGchoywPSq5U+nd6R7fp7IDfRjYDrEE99\n",
+       "DeyHrPb5lO364xI36zTb2q4/AUnt/SSyLHQHMvJZklQOIhYChyCLid2FWBoGIQrDfwGnAP8Gskzd\n",
+       "VvSbBgPvIMdpJjLHuxdikXgg1ewa4Jbo84+BHRAFI/3gT9/QQZa+/iIy9zwccVQrSeA5nbbrX4s8\n",
+       "cI6htIIQK7xdFJLIAvEEYjmYBlyP/E4LeXj92Xb94YHnnFtOjhrYJ3q/vtbpE9v1fwqcjYxUL0GO\n",
+       "51bI//g1YIzt+mNTSgJIivfNEIXgBOThfx0ySv8Nct7vgzgfj0+1HQf8E5iPKM/vI+vLHA9cZbs+\n",
+       "JZSEevgDBZ++3yIKzgVI1FeSrCnD6ci0zebAJxCfjmoZjxzXPPBL5By0gW8jCt3sqHwtkYL1N0RB\n",
+       "/R2ymOG2yHE5CLFAHAu8ahQEQxbfyijrDdML3HTTkWvUBRfsb88bPb6TzjEK+oHKL184YHL+Jmdl\n",
+       "u+XrJsYBhwaec0dcYLu+hzw0dkcu/AvjbUmLgu36DqIgPB54zuQq9nURMgI8LjnyBibZrj8z2s/l\n",
+       "tuvvVcJJbWvkXDoi8JzbKu0s8JxFtut/IqXgAPzOdv0/IiPnb5KhICAjpMGIEjAhPV1iu35HWsbA\n",
+       "c25ObD8ZURAeqibENBqpTYnark8FBSHiakRBOMx2/cHpB29kSv4KooSlLRYnIcrBHcBXk7/Fdv0b\n",
+       "gReAM23Xvz7wnJlVyFIJK3qfXUsj2/U/jiiiq4B9ktEytuv/Fhlpfx2xEnw31XxHYLfAc6bbrv8k\n",
+       "cny/Bnwz8Jy/2q6/DTLd9F8Zu94ceXAeEHhOvM7MNbbrT0UU4vNs15+c2FY3gedcm/hNP0EUhDvL\n",
+       "KMrJtkuIFPboWNWiIOSAO4HDE7/Dj67FSxEn21+m2pyOWDpuCDxn7fG2Xf8e4F1EIVsceE5oohgM\n",
+       "XVBKjURuSEke11qXMhv3OPR553VO9Sb407yJZwTexO8FnnNV/qYj11XlAOCfSeUA1s4D/y36mp7f\n",
+       "rAvb9fdGLDMzU8pBzMXIg2wsMhLKQiFhgxWVg5gM5SDm+uh9VHqD7fr7IlaNFcAJWb4UPcHLPvCc\n",
+       "2YgVZn3gyIwq30AsQg8lQ+aiefUfR1/PzlB08sD9Udusfmsi2t+Q6GutjspnIE6L16dDaSN/irMR\n",
+       "p8dTbddPOxK/nwgxTZr8747e30SsEkNL7PvXGQrAVYgvwggK/gK9mXMyfuON0fvWkY9Dkp2i97uT\n",
+       "hYHnLKNgURsDxknRUMz5FJ8XP22DHIbqSc9pxsSOW8ObtJ89ovdXbNcvpQC8j4zcdiTbnAoy4q2b\n",
+       "6Ia3CYV5/Y0zqsXOf4/WEYveaq5GQuOOQaZekhydqJNkW2BLZF2UzhL/R+xE2XAIa+A52nb9lUho\n",
+       "Y63hd7GD5d1ZGwPPmW27/iuIUrkLXc/n9xP13rZd/yNgVezoF8n1NjAyyyKETGGl97fGdv1/IlaL\n",
+       "3h7e+06WM2PgOQtt11+GTMcNo6vVJ1aWsyK+4nvFQjAKgiGBUmoshfnOmGe11vdl1Tf0GOaUKI9v\n",
+       "lqrE9lqJb6b/Hb3KsU2Zba/VslPb9bdDfA0ORLz0N62iWWxVqMkc3iZuRuawP2u7/g6JKI9RSCTR\n",
+       "YoodhOP/YgNKK2Ix2zZJzjnINMN2NbaL/4uiaIUE/0EUhB3pqiCkMwl2IscjXZZFJ/B2iW1xRtWR\n",
+       "ZWTqDcwps63U9f8Q0TSN7fp/iK0PtuvviPjmrCHyR1qrICilNkTmHjZDLsDke/JzOtwnzY1KqXcR\n",
+       "R4cFiBab9XlRT87I19dQSo1GNPz0tJOxHvR8mhrOVobB0XuAOBiWo1zmwaqdXW3X3x+4BzGVv4SM\n",
+       "pN9AnPEg21McxMIArTs2dRN4zoe26/8NOA6xGJwfbYqV9b8GnrM81Sz+Lz5A0qOXo2y4Ww3MoT4F\n",
+       "IY4+KTfNF58TaXN4VthstVNDitLKcdxvOjKmEj0tv0M953fs87E3Eul0B2JliBflOzfwnFcA+iul\n",
+       "5iEmwQFNEBaK569L0amUWggcqrXO8gg2FKHG2CdW4Uem9XvBlUflu7RUaiByU3lPa92ZKN8cSav8\n",
+       "fUQBTHKr1rrqueIsxp18/eg1azrLjSYB6NfRsY3G6Is9nDjDYxh4zundvbMotvtm5N50duA5P09t\n",
+       "T0faJIkfirU+zNrF1YiC4FBQECZE73/JqB//F+u14r+ImIVEOB1iu/6ZNfhwzEamp7YuU2e7RN1m\n",
+       "oZBnW5YVIfZ1qNWfotw51yuIph++hET0bAkcikwpTAEuCjxnSly3PzIP0a8NcnYgD6SBlSoaIhQX\n",
+       "V2UtVup24LBU6S7IyG+NUuodZP52awojrTSvIjeshlij9XdQKh2jXYRRDtpGfOCruQfEpmzbdn0V\n",
+       "dP9iPLsgjnEryI67Lzd/PCt6/5Tt+v3LJXAqQ/z7ut2ZO/Ccx23XfxUYZbt+7D8xCngl8Jwsa80s\n",
+       "ZBS8ke36O7cg4ybA5UgegJ0QE/XN5auvZRaiIMQRF12wXX8TCv9ls6eERpOtIMR+EXNS5YsRh8dS\n",
+       "To/V+CzUck21i6uR5++4wHNeKFXJRDH0PfoR5fqmtHKwDDhCa73O5JA3lCSeF04v6Z3FPRTMzBO7\n",
+       "S6AE8Q12PbomgYn5Xpm29yMPhu2RUK96iKMn9q6zfa38JXo/NHoly7oQeM5K4Iro60+jKINuJVJC\n",
+       "Yu/439uuX805A4VkWyfbrp+V/MdFnOmeCmpfFKsSRYMc2/U/DeyG3OfSjpOx5WmfVHmcuXFcFfus\n",
+       "5ZpqObbrb45EtswqpxyAcVI0FDMbOFxrXeT9a+heopvnEArzolvashT0wmbEapdgGpIU5XDb9R9F\n",
+       "YqrXQyyL8wPPeTeuGHjOMtv1T0VuqldH6W//jigNmyHOcAcBgwPPcZog20xkRLcJ8DPb9S9CRqM7\n",
+       "I7kDvoDE1hfdxwLPWWy7/plI7oCLbNffHXm4zUQeRtsjGRP/EXhOKSfcABkpj49i5+9G/putgHmB\n",
+       "5yxIN4iSF21C14V6Rtiu/yYSW15uHv4a4P8oKAedlPcvOAv4KmItfCTKKfAS8v8NR1ILHwnsl5GA\n",
+       "qF7ORdYaGA48HGWyfBqYgViDRwCfQR72PkDgOU9E2TvHI4m0TgeeRczb30DyH2iKcyA0ymrgWNv1\n",
+       "FyDK1NvIQ3tStN3LCH+9HUl29UPb9echFo8BUbtLEKfJtJ9EmgA59ifbrj8bCR3cGDlvZqdTLcPa\n",
+       "9NCbUMhs2GFLKvPFSAKxZl7/CxEL8pgoA+QMxD+kE3HenAHcHnjOGmNB6Dt8iGjHWSFKK4HHkcQr\n",
+       "OxvloLXYrr+77fqrEIejNyiE6P0WccZbabv+lFLtG+Ry5AY/BHkYfRDtR9M79QAAA3FJREFUcwYS\n",
+       "NdCFwHPuQR6a7wHfAR5GMhk+i9xcT6G6KIOKBJ6zFBn9r0GUmBlIWN9ziHf/5yjO/phsfy2yqt4i\n",
+       "xOJxF3INTI9k/Q7ZoV4xv0PC5LZCci4sQm6g08kYHdquvxy5lt4DwsSmF5EENCts1//Idv3M9LbR\n",
+       "egJTkEx4NvBA1joFifqLIjkeR6wcfwdeQfIFTEEcjHNU79RXkShvw95Ixs5+yOj/KuSh+ATiAHcq\n",
+       "xb4fxwOXRfJMQc6zlxGF6B3g4MBznmmWnBFzEUfP0xDFcCGiAG+JHKushESXIdanjRBF4l3EInAj\n",
+       "8vuOqWK/5yNRGaOQFNkfIhkOX6CQgwAA2/W3jkI3V0T7ejjatAFyXb2PXP/LbVnroWGi6bbzo697\n",
+       "IlaWk5Br93wkk+jztusP7o94Lna7eaoMZU0cVXIAped7eqGZfP2ZqmPFl+ptrVf3n19UpvVMYLRS\n",
+       "agBywxuEjLwWAe9qrTMXV2mUzs7OP/Xrp+6qt33Hmn5Zue3XNeZTOVoky5nqKiQkrNT883Qk3WvJ\n",
+       "sMLAc1bbrv9Z5AH6KWRkOB+5wRWlWo7a3Ga7/mOIomAho/GFyI30YeDREru7ELlOq07TG3jONbbr\n",
+       "T0Nu9KOQm+i/gFsDz3nTdv2fI2FbpdpfHnlpH4LcnHdAlIz5yLErqXgFnvOR7fo28lDYE7lu3kKO\n",
+       "TdZ9K52xrhTl7knnUVB6SqVeTsr4apQU6lDEbG4hCsFbROsRBE1ebjrwnNB2/XGIGf5gRBkYhPyv\n",
+       "7yDpjR9MtVkOnGK7/vWIgrFrVPcF4O8ZKbaXIuduWkH6KfL/JbkEsWClfWK2CDzHt10/jzhXjkGO\n",
+       "yzNIZEiRD00ga3ocaLv+kUh2xo8hSuVURKmIUyiXVGYCWVzKQlJD7xrJNg85b9LX8RLgF6X6SpFU\n",
+       "9Cpe28gaJgORqEEAbNffDLlvHIQoAndR8NEYilwjExD/nwuUiTQ0GAwGw7qC7fqjEUvKqsBzmhWd\n",
+       "t05gu/5pyNoifw48J9N5PForxQeeNFMMBoPBYDD0DWL/llvK1In9jt4zCoLBYDAYDH2DePo5MwrJ\n",
+       "dv0hFPwTnjBRDAaDwWAw9A3+hPgOHRPl25iK+FhsiuR4OARx0Lwf+J1REAwGg8Fg6AMEnvNklL78\n",
+       "HMRRca/E5hVINNIVwI2B56z6/3ExLRI31pXNAAAAAElFTkSuQmCC\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Image at 0x111275490>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import Image\n",
+    "Image(\"http://ipython.org/_static/IPy_header.png\")"
+   ]
+  }
+ ],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

venv/Lib/site-packages/nbformat/tests/many_tracebacks.ipynb

@@ -0,0 +1,46 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'iAmNotDefined' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-22-56e1109ae320>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0miAmNotDefined\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m: name 'iAmNotDefined' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "# Imagine this cell called a function which runs things on a cluster and you have an error"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

venv/Lib/site-packages/nbformat/tests/test4.ipynb

@@ -0,0 +1,308 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# nbconvert latex test"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lorem ipsum** dolor sit amet, consectetur adipiscing elit. Nunc luctus bibendum felis dictum sodales. Ut suscipit, orci ut interdum imperdiet, purus ligula mollis *justo*, non malesuada nisl augue eget lorem. Donec bibendum, erat sit amet porttitor aliquam, urna lorem ornare libero, in vehicula diam diam ut ante. Nam non urna rhoncus, accumsan elit sit amet, mollis tellus. Vestibulum nec tellus metus. Vestibulum tempor, ligula et vehicula rhoncus, sapien turpis faucibus lorem, id dapibus turpis mauris ac orci. Sed volutpat vestibulum venenatis."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Printed Using Python"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "hello\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"hello\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Pyout"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "<script>\n",
+       "console.log(\"hello\");\n",
+       "</script>\n",
+       "<b>HTML</b>\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML at 0x1112757d0>"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import HTML\n",
+    "HTML(\"\"\"\n",
+    "<script>\n",
+    "console.log(\"hello\");\n",
+    "</script>\n",
+    "<b>HTML</b>\n",
+    "\"\"\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "console.log(\"hi\");"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript at 0x1112b4b50>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%javascript\n",
+    "console.log(\"hi\");"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": [
+       "iVBORw0KGgoAAAANSUhEUgAAAggAAABDCAYAAAD5/P3lAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n",
+       "AAAH3AAAB9wBYvxo6AAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAACAASURB\n",
+       "VHic7Z15uBxF1bjfugkJhCWBsCSAJGACNg4QCI3RT1lEAVE+UEBNOmwCDcjHT1wQgU+WD3dFxA1o\n",
+       "CAikAZFFVlnCjizpsCUjHQjBIAkQlpCFJGS79fvjdGf69vTsc2fuza33eeaZmeqq6jM9vZw6dc4p\n",
+       "BUwC+tE+fqW1fqmRDpRSHjCggS40sBxYDCxKvL8KzNBaL21EPoPB0DPIWVY/4NlE0ffzYfhgu+Qx\n",
+       "GHoy/YFjaK+CcB3QkIIAHAWs3wRZsuhUSs0CXgQeBm7UWi/spn0Z+jA5yxpEfYruqnwYllRic5a1\n",
+       "MaWv8U5gaT4M19Sx396IAnZLfB/SLkEMhp5O/3YL0AvoAHaKXl8HLlZK3QZcpbWe0lbJDOsaHuDU\n",
+       "0e4u4JAy2wPk/C1JzrKWArOQ0fUtwH35MOysQxaDwbCO0NFuAXoh6wPjgQeUUvcqpUa0WyCDoQls\n",
+       "CIwBjgfuAV7KWdY+7RWpmJxlXZezrEdylvXxdstiMKzrGAtCYxwI/EspdZbW+g/tFsbQ67kQuBHY\n",
+       "FNgseh9FV6vCbUAeWBC9PgBeq2EfS6J2MQOBrRDTe5KdgAdzlvW1fBjeUUP/3UbOsoYBE6OvG7VT\n",
+       "FoOhL9Af+BUwFLkZpV+DaY6V4UPkRpb1+ncT+m8nGwK/V0oN01qf025hDL2XfBi+DLycLMtZVo6u\n",
+       "CsKfGnSq8/NheEpqHwOBEcDBwJnAsGhTP2ByzrJG5cPwnQb22Sy+0G4BDIa+RH+t9dmlNiqlFKIk\n",
+       "JJWGi+jq5JPmq8BbJJQArfXqpkncczlbKbVQa/3rdgtiMNRCPgxXAK8Ar+Qs63LgXmDvaPPGwPeA\n",
+       "H7VJvCRfbLcABkNfouwUg9ZaAwuj178BlFLvVejzgR4WFviM1npcuQpKqf6IyXIjxLS7GzAWuUnu\n",
+       "XsO+fqWUellr3ZBJdq/jr9+BDn1uve07O9Rz0y6f8PtGZGgWe53oT6SBkZ/q1/nHZy47aloTRTKU\n",
+       "IR+Gy3OWNR6Zxtg0Kv4KRkEwGPocxgcBiCwcsSI0F5iOhF+ilPok8C3gVGS+thK/VErdrbWuO2ys\n",
+       "s/+aLZTuOKbe9krrIUCPUBB0B+PQ1P1bdKe6EzAKQgvJh+GbOct6gkJkxM45y+qXDIWMHBhjBWJe\n",
+       "PgyDWvaRs6zPIVObAG/nw/DpEvUGAp8E9gGGJzbtl7Os7cvs4skqp0V0Yl8jgcOBjyMDhbmIZeWl\n",
+       "fBg+UUVfReQsayhwELAnsAXi6/E28BxwTz4MP6iyn92RaSCA+/NhuCwqXx9R4MYhU0MfRTK/AjyW\n",
+       "D8MFGd0ZDFVhFIQKaK3/BXxfKXUlklTq0xWafAI4Driyu2UzGLqRlygoCArYHJif2H4gcFb0+Z2c\n",
+       "ZW2bD8NV1XScs6yNgH8g/jsAPwCeTmzfFPgjYsnbiez71MUVdnMQcF8V4nyUs6whwB8QX4+0s2Ys\n",
+       "0yPAt/NhGFbRZ/wbzgO+DaxXotqqnGX9GbigCkXhf5CBCsDngYdzljURGQhsWqLN+znL+iFwdT4M\n",
+       "dYk6BkNJTJhjlWitQ2Bf4P4qqv848t8wGHor6Yd9+ruHJFkC2BI4rIa+D6egHKwmstYlGAxMQCwH\n",
+       "rRjEPI5ER5S7ZvcFXsxZ1phKneUsawSi8HyH0soB0bbvAM9Ebaplt5xlnYkct1LKAYiFZhJwSQ19\n",
+       "GwxrMRaEGtBar1RKfRX4JxIzXortou3PN1mE+YgJsSwaeoLHOQCqUy3QSr9eqZ6G/gq2aYVMhqrY\n",
+       "OfF5FeJwvJZ8GM7JWdY/gC9HRS7wtyr7Pjrx+e6MqYC3KLbU7Qhck/h+FJIKvRRVjfSREXicU8EH\n",
+       "pgAvIIqLBZwGfC7avl5Uf29KkLOsTZCMq8npj9sQx89no37HIlaAODplNPBIzrJ2z4dhNVlaT0HC\n",
+       "XwFmIkrAC4if2PaIz8/3KCgn385Z1pX5MJxeRd8Gw1qMglAjWutlSqnTgUcqVP0SzVYQtP5mcMXE\n",
+       "SvvtUUy9YsK5QEWHy7EnTB6lOtSsFohkqEDOsgYAdqJoagkT9Z8pKAj75yzr4/kwnF2h748ho/GY\n",
+       "q9J1oqiKLj4JOctKK8Yz8mH4Yrl9VcnHkXVYTsyHoZ8WJWdZNyPThbF5/3M5yzowH4alpi9+T0E5\n",
+       "WA18Nx+Gf0zVeRG4KmdZ90R9bwCMRKwyX69C5h2j91uA4/JhuCSxbTYwJWdZtwNPIFbifsAFSISZ\n",
+       "wVA1ZoqhDrTWjyIjjXIc3ApZDIZu4ELgY4nvt5Wody8wJ/qsgBOr6HsihfvOfCRrY7v5dYZyAECk\n",
+       "GP0ISEZmZYZ55yxrB8SyEXNxhnKQ7Pt64H8TRUfmLGuXKmWeC4xPKQfJvp9CLCJlZTYYymEUhPq5\n",
+       "tcL2XVsihcHQJHKWtU3Osi5GnAZj5iKWgiKitRouTxQdl7OscnPu0HV64dp8GLY7R8pyxEGxJPkw\n",
+       "fBcZ9ceUSvN8IoV76upK/UZcgawcG3NKqYopfleFU+gDic/b5SzLWIwNNWFOmPqp5CG9sVJqPa11\n",
+       "VZ7dBkOL2D1nWcmcBkOR8MFtgM/QdTXJZcCR+TBcXqa/SYj5egAFZ8VMX4ScZe2FRPnEXF2z9M3n\n",
+       "3nwYVsrtAmK6/0z0uVR4ZXLtivvzYfhGpU7zYbgkZ1k3ACdHRQdWIQsUO3ZmkUzB3Q/xjaolLbeh\n",
+       "j2MUhDrRWr+mlFpJ+eV5hyIxz4YWs98Fj/Rf8uZbozo0/ZYt7D8rf9ORK9stUw/hU9GrEnMAp1R+\n",
+       "gph8GL4bzdNPiIpOorSzYtJ68FS1IYPdTLWp3hcnPm+Q3pizrA7E+TCmFn+aZN0dcpY1LB+G5e4b\n",
+       "y6rM8bA49X39GmQyGMwUQ4NUGnkMrbDd0A3sdeLk4z6cN+89pTtDTWd+gyErF+7pTv5eu+XqJbyK\n",
+       "TDHsmg/DJ6tsc2ni8+dzljUqXSGaevhmoqjIObFNVBzlV8kQug4W5tbQNl13WGatAv+poW+DoW6M\n",
+       "BaExPgC2LrO9nHWhpSilDqI4NPMhrfXUJvS9M/DfqeJXtdY3N9p3rex50uQ9lFKT6BrTvoFCXbTX\n",
+       "yZNfmnrZxHtbLVMP4xng74nvK5DzeD7wfIWRayb5MHwiZ1kzgF0oOCuemar2ZQoK8zLgr7Xup5t4\n",
+       "s0n9DEl9b0RBSPeV5q0a+jYY6sYoCI1RacnZ91siRXUMAH6eKnsYicdulDOAY1NlpzWh35pRqG9R\n",
+       "IuGN7uw4AfG878s8nw/DX3RDv5dScGY8NmdZP86HYXJaJzm9cHMp7/s2UHdK9BTpKaxBNbRN163k\n",
+       "t9Rux05DH8FMMTTGZhW2v9sSKarjbopNk/sqpUY30qlSahCSGS/JCuD6RvqtF6UpMm/HaHTJbYaG\n",
+       "mQzED/0umRVzlrUZhXwJ0HOmF5pJOlXyxzJrZbNt6rtZP8HQIzAKQp0opTZAlsItxTKtdTnv75YS\n",
+       "LR7lpYqrjV0vx2EUH4fbtdZtucnpMqOrDjPy6jYii8DkRFHSYnAEhem22cBjrZKrVeTDcCldTf/p\n",
+       "h345ksrEGprnF2EwNIRREOrnMxW2z2uJFLVxJcXmy2OVUo34ShydUda+EaIq7T2u0SZTY/eSdFY8\n",
+       "MGdZm0efk86J6/LCQUnFp5pIkZjkcvQz8mH4YZPkMRgawigI9VNp7v7BlkhRA1rr+RQneNqC2hba\n",
+       "WYtSajiS9z3JXLomaGktq/VllLIUdKqSWe0MjZMPwxlIel8Q/6Zv5CxrGIX8AJ10XU+hFtIRQ+UW\n",
+       "KWoXyYyTu+Qsa79KDXKWNRpJyx5zZ9OlMhjqxCgIdaCU6g98o0K1npBCNotLM8rcOvuagCRgSXKN\n",
+       "1rozq3IrCCZNfFkrfRjotWsCaJinUBODK51/tkuuPkTy/DoYOIDCfeb+fBjW4t2/lqhdcmRdbUri\n",
+       "VnILXS2HZ1WRvfAcCk61K4A/dYdgBkM9GAWhPr5F6XSrIBf6Qy2SpSaidSReShV/XilV7veUIj29\n",
+       "oOkB2fGmXT7x7sCbOGpFf7VZx4A1m0/znG2nehMyc+0bms7NFJxzxwH7J7Y1OvWUPG9/mLOsLRvs\n",
+       "r6lEaaOT0TtfBB5ITLWsJWdZg3KWdRNwTKL4wnwYzu9mMQ2GqjFhjjWilBqBpJYtx51a66UV6rST\n",
+       "S+maJz52VvxRdvVilFK7UbzexGNa67Kr+bWS6X+ekPYs79HkLGt34JOI+Xyz6D2d1vfMnGUdini6\n",
+       "L0C851/Oh2HD+SyaQT4MV+YsaxJyLm1Gwf9gAXBHg93/JNHHtsArOcuajCztPBDYCkkytBXg5sOw\n",
+       "5QmF8mF4W86yLgK+HxXtC8zKWVaALMm8CslHsicS7RFzL8VhyAZDWzEKQg0opbYE7qd8prPVdF2h\n",
+       "rSdyLfALYMNE2XFKqR/XsHbEURll62L4Wiv5PuBUqPPF6JXkLuCQbpGoPi4HfohYKGMHWD9axrlu\n",
+       "8mF4Z7RuwfioaDBwaonqRemQW0U+DH+Qs6xFwHnIFNwQsv+3mMnA8dHiVwZDj8FMMVSJUuow4DkK\n",
+       "a7GX4gqt9cstEKlutNaL6boULMho5tBq2iul+lH8IFuCmJcNfZx8GM6hOCFVU5THfBhOQHxfylkH\n",
+       "3gY+asb+6iUfhhcCewC3l5BlFbJk/P75MDwqlVTKYOgRKK1rizhSSk2h67ximo1abV5XSi2n9EIk\n",
+       "z2itx5XYVqnfQcjI7DiqW2XtfeCTUbRA3ex50nWfUrqjeJEcrfcLrpj4SCN9xyilxgDPp4of0Fof\n",
+       "UEXbg4B/pIqv1FrXnVNh7AmTR3V0qIwwRH1E4E28pd5+De0hZ1m/Bb4bfX0+H4Z7dMM+hgGjkDwC\n",
+       "S5FpjFk9bR4/Z1mDkGmF4VHR20g4Y3oxJYOhR9EXphg6lFLlVjFbH0mZvDGwCTAayCFe0ntTOZ1y\n",
+       "zDLgkEaVg1ahtX5BKfUU8OlE8ReUUjtorSstCduzch8YehSR5/6ERFG3nBvRuhE9frXUfBguA6pd\n",
+       "+Mpg6DH0BQXBBro7o+Ea4Bta66e6eT/N5lK6KggKOAE4u1QDpdTGFOdNmNkLf7uh+zgYcRQEMa+3\n",
+       "Je22wWBoDOOD0DhLgYla67vaLUgd3ETxglLHRXkeSnEExQ5gbQ9tNPQokis5TsqHoVlbwGDohRgF\n",
+       "oTECYHet9Y3tFqQetNYrKDb/DqN46eYk6emF1UhUhMFAzrImUEhDvgr4VRvFMRgMDWAUhPpYAvwf\n",
+       "8Bmte31+/8uQBEdJMjMrKqW2o5A2N+YfWusePw9s6F5yltWRs6zxwKRE8RXtyEVgMBiaQ1/wQWgm\n",
+       "eWTe/jqtdU9Zz74htNavKaXuAw5KFB+glBqptZ6Tqj6RQlrYGDO90AfJWdY5wNeQFQwHIAmetk5U\n",
+       "eZFCsiCDwdALMQpCed5AphEC4NF12BHvUroqCAoJ7TwvVS+d++BdJEmPoe+xKRLnn0UeODwfhm3N\n",
+       "RWAwGBqjLygIbwN/LbNdI1MGH6ReL/eWkMUmcDeSeGa7RNlRSqnzdZQoQym1C7Bzqt11NWReNKxb\n",
+       "zEMU6GHAesBiYCaSLOviaF0Cg8HQi+kLCsLrWuvT2y1ET0ZrvUYp5SG57mO2Bz4LPB59/2ZRQ5P7\n",
+       "oM+SD8OLgYvbLYfBYOg+jJOiIeZKxOs8STJiIb28daC1/lf3imQwGAyGdmEUBAMA0XTKraniI5VS\n",
+       "A6O0zOnloI31wGAwGNZhjIJgSHJp6vtgJBNlehW65cANLZHIYDAYDG3BKAiGtWitHwVeShV/muLF\n",
+       "uW7VWi9qjVQGg8FgaAd9wUnRUBuXAn9IfN8f+FyqTo/OfbDnSX8brDpXnqEUe2ropzQvdtDx66ev\n",
+       "GN9XolIMPQDb9T8LrBd4zsPtlsXQe7Bd/0BgQeA5QbtlMQqCIc21wC+ADaPv6WWu5wAPtVKgWtjt\n",
+       "6Os2XG/9jhdQjIzTQ2rFF9bQecy4E2/I9UQlwXb9LYDDK1R7K/Cc21shj6FxbNcfDjwGKNv1Rwae\n",
+       "83q7ZWo2tusPBb6ELGW9BbAICX99Gngs8Jx0hlZDBWzXHwvcC6ywXX9o4DlL2ymPURAMXdBaL1ZK\n",
+       "+ZRItwz8Jc6N0BMZMFB9GxiZsWnzTjrPAH7QWomqYgTF/h9pngC6RUGwXf+XwC2B50ztjv57M7br\n",
+       "XwJMCjxneo1NP0SWgAfJq7LOYLv+esAFwOkUL9wWM912/d0Dz+lsnWQ9A9v1BwEXAT8PPKfWVOML\n",
+       "kPVt3kNWQm0rxgfBkEWph5UG/tJCOWqnQ40ttUkrvWcrRamWwHOmAZsguSfGAi9Hmy5AUhgPAz7f\n",
+       "Hfu2XX8k8ENgx+7ovzdju/4uwP9D/peaCDxnCbANsF3gOYubLVu7sF1/AHAHcBaiHDwI/C+ywNsE\n",
+       "4KfA68BdfVE5iNgbOBmxqtRE4Dn/BoYDnwg8Z02zBasVY0EwFKG1fkEp9RTioJjkIa11zzaVarYq\n",
+       "vVFt2TpBaiN6oCwB5tiu/2FUPCvwnLTTaLM5oJv77800dGwCz1kXHXkvRNKydwI/Cjzn1+kKtuuf\n",
+       "i2TX7Ks0et681yxBGsUoCIZSBBQrCL0h98EbdW7rddiuPwoYFJu/bdffFNgL2BZ4DZgWKR5ZbRWS\n",
+       "2+KIqGiE7fpjUtXmlrtZRdaHscBAYDowM/CckimWbdffFfgw8JzXou/9kfUccojV5MXAcz4s0XYw\n",
+       "sCsymu8PzAVmBJ7zVqn9pdoPRVKF7wSsAN4EgqzRve36HcAoZDEqgO0zjs3rged8kGo3gOJ05ADT\n",
+       "s0bTkan+k9HXGaVGjNFxykVf81nH2Hb9Ich/MRJJeT291H9fL7brj6CwANfPspQDgOi3rijRx/rI\n",
+       "b8kB7wPPBZ4zL6Ne/JvfCDzn/WhufhvgvsBzVkR1dgN2AR4JPGduom38P7wXeM7c6FzfCfgU4iMR\n",
+       "lFLebNfPIefXzMBzikz8tusPQyx676bljmTeCfhyVLST7frp//TV9Dluu/6GwOhUvTWB58zIkjFq\n",
+       "sykyNfmfwHMW2K7fLzoWeyDTFPnAc14t1T7qYwNgT+Rc/wi5ZyT/N20UBEMRSqn+wNdTxQspTqTU\n",
+       "41BaP6yVOipzGzzSYnG6m6uBz0YPv7OQm3dytc35tuuflHZutF3/BuArwEaJ4p/QNdU2wGnAH9M7\n",
+       "jRSTG5CbS5LQdv2joymTLKYBzwHjbNc/DomW2TCxfbXt+sMCz3k/sa8RwM+Qh/X6qf5W2q4/CTit\n",
+       "zMN1OPB7CopQktW2658YeM5fEvXvRKZzBiXqZaWUPha4JlW2NfB8Rt0hiANfmjWIuf5jiLPfvVm/\n",
+       "AfmvbgNmB54zKrkheuD+Bjg11Wap7fpnBJ5TybelFk4E+iE+Fb+ptbHt+scg//nGqfJbgeMDz1mY\n",
+       "KN4UOZYX2q7fSWHhuNdt198ZOBc4MypbbLv+5wPPeTb6PiJqe5ft+ichx3WXRN8rbdc/OfCcrGis\n",
+       "R4ChiHKSlSn2f4BzkOvitMRvCKJ9DEzU9TPafwGZlkkyBvExSrKUrtdnmoOBycA5tus/iCyat3li\n",
+       "u7Zd/0rk2ihS1mzXPwT4E3LulaLTKAiGLL6EaMlJbtBat91pphIjFw289t9DVh4N7Jva9EKnWnpJ\n",
+       "G0RqBXcjCa08YCqy/PJE4L8A33b9HQPPeTNR/0bgvujzGchoywPSq5U+nd6R7fp7IDfRjYDrEE99\n",
+       "DeyHrPb5lO364xI36zTb2q4/AUnt/SSyLHQHMvJZklQOIhYChyCLid2FWBoGIQrDfwGnAP8Gskzd\n",
+       "VvSbBgPvIMdpJjLHuxdikXgg1ewa4Jbo84+BHRAFI/3gT9/QQZa+/iIy9zwccVQrSeA5nbbrX4s8\n",
+       "cI6htIIQK7xdFJLIAvEEYjmYBlyP/E4LeXj92Xb94YHnnFtOjhrYJ3q/vtbpE9v1fwqcjYxUL0GO\n",
+       "51bI//g1YIzt+mNTSgJIivfNEIXgBOThfx0ySv8Nct7vgzgfj0+1HQf8E5iPKM/vI+vLHA9cZbs+\n",
+       "JZSEevgDBZ++3yIKzgVI1FeSrCnD6ci0zebAJxCfjmoZjxzXPPBL5By0gW8jCt3sqHwtkYL1N0RB\n",
+       "/R2ymOG2yHE5CLFAHAu8ahQEQxbfyijrDdML3HTTkWvUBRfsb88bPb6TzjEK+oHKL184YHL+Jmdl\n",
+       "u+XrJsYBhwaec0dcYLu+hzw0dkcu/AvjbUmLgu36DqIgPB54zuQq9nURMgI8LjnyBibZrj8z2s/l\n",
+       "tuvvVcJJbWvkXDoi8JzbKu0s8JxFtut/IqXgAPzOdv0/IiPnb5KhICAjpMGIEjAhPV1iu35HWsbA\n",
+       "c25ObD8ZURAeqibENBqpTYnark8FBSHiakRBOMx2/cHpB29kSv4KooSlLRYnIcrBHcBXk7/Fdv0b\n",
+       "gReAM23Xvz7wnJlVyFIJK3qfXUsj2/U/jiiiq4B9ktEytuv/Fhlpfx2xEnw31XxHYLfAc6bbrv8k\n",
+       "cny/Bnwz8Jy/2q6/DTLd9F8Zu94ceXAeEHhOvM7MNbbrT0UU4vNs15+c2FY3gedcm/hNP0EUhDvL\n",
+       "KMrJtkuIFPboWNWiIOSAO4HDE7/Dj67FSxEn21+m2pyOWDpuCDxn7fG2Xf8e4F1EIVsceE5oohgM\n",
+       "XVBKjURuSEke11qXMhv3OPR553VO9Sb407yJZwTexO8FnnNV/qYj11XlAOCfSeUA1s4D/y36mp7f\n",
+       "rAvb9fdGLDMzU8pBzMXIg2wsMhLKQiFhgxWVg5gM5SDm+uh9VHqD7fr7IlaNFcAJWb4UPcHLPvCc\n",
+       "2YgVZn3gyIwq30AsQg8lQ+aiefUfR1/PzlB08sD9Udusfmsi2t+Q6GutjspnIE6L16dDaSN/irMR\n",
+       "p8dTbddPOxK/nwgxTZr8747e30SsEkNL7PvXGQrAVYgvwggK/gK9mXMyfuON0fvWkY9Dkp2i97uT\n",
+       "hYHnLKNgURsDxknRUMz5FJ8XP22DHIbqSc9pxsSOW8ObtJ89ovdXbNcvpQC8j4zcdiTbnAoy4q2b\n",
+       "6Ia3CYV5/Y0zqsXOf4/WEYveaq5GQuOOQaZekhydqJNkW2BLZF2UzhL/R+xE2XAIa+A52nb9lUho\n",
+       "Y63hd7GD5d1ZGwPPmW27/iuIUrkLXc/n9xP13rZd/yNgVezoF8n1NjAyyyKETGGl97fGdv1/IlaL\n",
+       "3h7e+06WM2PgOQtt11+GTMcNo6vVJ1aWsyK+4nvFQjAKgiGBUmoshfnOmGe11vdl1Tf0GOaUKI9v\n",
+       "lqrE9lqJb6b/Hb3KsU2Zba/VslPb9bdDfA0ORLz0N62iWWxVqMkc3iZuRuawP2u7/g6JKI9RSCTR\n",
+       "YoodhOP/YgNKK2Ix2zZJzjnINMN2NbaL/4uiaIUE/0EUhB3pqiCkMwl2IscjXZZFJ/B2iW1xRtWR\n",
+       "ZWTqDcwps63U9f8Q0TSN7fp/iK0PtuvviPjmrCHyR1qrICilNkTmHjZDLsDke/JzOtwnzY1KqXcR\n",
+       "R4cFiBab9XlRT87I19dQSo1GNPz0tJOxHvR8mhrOVobB0XuAOBiWo1zmwaqdXW3X3x+4BzGVv4SM\n",
+       "pN9AnPEg21McxMIArTs2dRN4zoe26/8NOA6xGJwfbYqV9b8GnrM81Sz+Lz5A0qOXo2y4Ww3MoT4F\n",
+       "IY4+KTfNF58TaXN4VthstVNDitLKcdxvOjKmEj0tv0M953fs87E3Eul0B2JliBflOzfwnFcA+iul\n",
+       "5iEmwQFNEBaK569L0amUWggcqrXO8gg2FKHG2CdW4Uem9XvBlUflu7RUaiByU3lPa92ZKN8cSav8\n",
+       "fUQBTHKr1rrqueIsxp18/eg1azrLjSYB6NfRsY3G6Is9nDjDYxh4zundvbMotvtm5N50duA5P09t\n",
+       "T0faJIkfirU+zNrF1YiC4FBQECZE73/JqB//F+u14r+ImIVEOB1iu/6ZNfhwzEamp7YuU2e7RN1m\n",
+       "oZBnW5YVIfZ1qNWfotw51yuIph++hET0bAkcikwpTAEuCjxnSly3PzIP0a8NcnYgD6SBlSoaIhQX\n",
+       "V2UtVup24LBU6S7IyG+NUuodZP52awojrTSvIjeshlij9XdQKh2jXYRRDtpGfOCruQfEpmzbdn0V\n",
+       "dP9iPLsgjnEryI67Lzd/PCt6/5Tt+v3LJXAqQ/z7ut2ZO/Ccx23XfxUYZbt+7D8xCngl8Jwsa80s\n",
+       "ZBS8ke36O7cg4ybA5UgegJ0QE/XN5auvZRaiIMQRF12wXX8TCv9ls6eERpOtIMR+EXNS5YsRh8dS\n",
+       "To/V+CzUck21i6uR5++4wHNeKFXJRDH0PfoR5fqmtHKwDDhCa73O5JA3lCSeF04v6Z3FPRTMzBO7\n",
+       "S6AE8Q12PbomgYn5Xpm29yMPhu2RUK96iKMn9q6zfa38JXo/NHoly7oQeM5K4Iro60+jKINuJVJC\n",
+       "Yu/439uuX805A4VkWyfbrp+V/MdFnOmeCmpfFKsSRYMc2/U/DeyG3OfSjpOx5WmfVHmcuXFcFfus\n",
+       "5ZpqObbrb45EtswqpxyAcVI0FDMbOFxrXeT9a+heopvnEArzolvashT0wmbEapdgGpIU5XDb9R9F\n",
+       "YqrXQyyL8wPPeTeuGHjOMtv1T0VuqldH6W//jigNmyHOcAcBgwPPcZog20xkRLcJ8DPb9S9CRqM7\n",
+       "I7kDvoDE1hfdxwLPWWy7/plI7oCLbNffHXm4zUQeRtsjGRP/EXhOKSfcABkpj49i5+9G/putgHmB\n",
+       "5yxIN4iSF21C14V6Rtiu/yYSW15uHv4a4P8oKAedlPcvOAv4KmItfCTKKfAS8v8NR1ILHwnsl5GA\n",
+       "qF7ORdYaGA48HGWyfBqYgViDRwCfQR72PkDgOU9E2TvHI4m0TgeeRczb30DyH2iKcyA0ymrgWNv1\n",
+       "FyDK1NvIQ3tStN3LCH+9HUl29UPb9echFo8BUbtLEKfJtJ9EmgA59ifbrj8bCR3cGDlvZqdTLcPa\n",
+       "9NCbUMhs2GFLKvPFSAKxZl7/CxEL8pgoA+QMxD+kE3HenAHcHnjOGmNB6Dt8iGjHWSFKK4HHkcQr\n",
+       "OxvloLXYrr+77fqrEIejNyiE6P0WccZbabv+lFLtG+Ry5AY/BHkYfRDtR9M79QAAA3FJREFUcwYS\n",
+       "NdCFwHPuQR6a7wHfAR5GMhk+i9xcT6G6KIOKBJ6zFBn9r0GUmBlIWN9ziHf/5yjO/phsfy2yqt4i\n",
+       "xOJxF3INTI9k/Q7ZoV4xv0PC5LZCci4sQm6g08kYHdquvxy5lt4DwsSmF5EENCts1//Idv3M9LbR\n",
+       "egJTkEx4NvBA1joFifqLIjkeR6wcfwdeQfIFTEEcjHNU79RXkShvw95Ixs5+yOj/KuSh+ATiAHcq\n",
+       "xb4fxwOXRfJMQc6zlxGF6B3g4MBznmmWnBFzEUfP0xDFcCGiAG+JHKushESXIdanjRBF4l3EInAj\n",
+       "8vuOqWK/5yNRGaOQFNkfIhkOX6CQgwAA2/W3jkI3V0T7ejjatAFyXb2PXP/LbVnroWGi6bbzo697\n",
+       "IlaWk5Br93wkk+jztusP7o94Lna7eaoMZU0cVXIAped7eqGZfP2ZqmPFl+ptrVf3n19UpvVMYLRS\n",
+       "agBywxuEjLwWAe9qrTMXV2mUzs7OP/Xrp+6qt33Hmn5Zue3XNeZTOVoky5nqKiQkrNT883Qk3WvJ\n",
+       "sMLAc1bbrv9Z5AH6KWRkOB+5wRWlWo7a3Ga7/mOIomAho/GFyI30YeDREru7ELlOq07TG3jONbbr\n",
+       "T0Nu9KOQm+i/gFsDz3nTdv2fI2FbpdpfHnlpH4LcnHdAlIz5yLErqXgFnvOR7fo28lDYE7lu3kKO\n",
+       "TdZ9K52xrhTl7knnUVB6SqVeTsr4apQU6lDEbG4hCsFbROsRBE1ebjrwnNB2/XGIGf5gRBkYhPyv\n",
+       "7yDpjR9MtVkOnGK7/vWIgrFrVPcF4O8ZKbaXIuduWkH6KfL/JbkEsWClfWK2CDzHt10/jzhXjkGO\n",
+       "yzNIZEiRD00ga3ocaLv+kUh2xo8hSuVURKmIUyiXVGYCWVzKQlJD7xrJNg85b9LX8RLgF6X6SpFU\n",
+       "9Cpe28gaJgORqEEAbNffDLlvHIQoAndR8NEYilwjExD/nwuUiTQ0GAwGw7qC7fqjEUvKqsBzmhWd\n",
+       "t05gu/5pyNoifw48J9N5PForxQeeNFMMBoPBYDD0DWL/llvK1In9jt4zCoLBYDAYDH2DePo5MwrJ\n",
+       "dv0hFPwTnjBRDAaDwWAw9A3+hPgOHRPl25iK+FhsiuR4OARx0Lwf+J1REAwGg8Fg6AMEnvNklL78\n",
+       "HMRRca/E5hVINNIVwI2B56z6/3ExLRI31pXNAAAAAElFTkSuQmCC\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Image at 0x111275490>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import Image\n",
+    "Image(\"http://ipython.org/_static/IPy_header.png\")"
+   ]
+  }
+ ],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

venv/Lib/site-packages/nbformat/tests/test4custom.ipynb

@@ -0,0 +1,52 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.raw.v1+json": {
+       "apples": [
+        "🍎",
+        "🍏"
+       ],
+       "bananas": 2,
+       "oranges": "apples"
+      }
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import IPython\n",
+    "\n",
+    "bundle = {}\n",
+    "bundle['application/vnd.raw.v1+json'] = {\n",
+    "    'apples': ['🍎', '🍏'],\n",
+    "    'bananas': 2,\n",
+    "    'oranges': 'apples'\n",
+    "}\n",
+    "\n",
+    "IPython.display.display(bundle, raw=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

venv/Lib/site-packages/nbformat/tests/test4docinfo.ipynb

@@ -0,0 +1,311 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# nbconvert latex test"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lorem ipsum** dolor sit amet, consectetur adipiscing elit. Nunc luctus bibendum felis dictum sodales. Ut suscipit, orci ut interdum imperdiet, purus ligula mollis *justo*, non malesuada nisl augue eget lorem. Donec bibendum, erat sit amet porttitor aliquam, urna lorem ornare libero, in vehicula diam diam ut ante. Nam non urna rhoncus, accumsan elit sit amet, mollis tellus. Vestibulum nec tellus metus. Vestibulum tempor, ligula et vehicula rhoncus, sapien turpis faucibus lorem, id dapibus turpis mauris ac orci. Sed volutpat vestibulum venenatis."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Printed Using Python"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "hello\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"hello\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Pyout"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "<script>\n",
+       "console.log(\"hello\");\n",
+       "</script>\n",
+       "<b>HTML</b>\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML at 0x1112757d0>"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import HTML\n",
+    "HTML(\"\"\"\n",
+    "<script>\n",
+    "console.log(\"hello\");\n",
+    "</script>\n",
+    "<b>HTML</b>\n",
+    "\"\"\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "console.log(\"hi\");"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript at 0x1112b4b50>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%javascript\n",
+    "console.log(\"hi\");"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": [
+       "iVBORw0KGgoAAAANSUhEUgAAAggAAABDCAYAAAD5/P3lAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n",
+       "AAAH3AAAB9wBYvxo6AAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAACAASURB\n",
+       "VHic7Z15uBxF1bjfugkJhCWBsCSAJGACNg4QCI3RT1lEAVE+UEBNOmwCDcjHT1wQgU+WD3dFxA1o\n",
+       "CAikAZFFVlnCjizpsCUjHQjBIAkQlpCFJGS79fvjdGf69vTsc2fuza33eeaZmeqq6jM9vZw6dc4p\n",
+       "BUwC+tE+fqW1fqmRDpRSHjCggS40sBxYDCxKvL8KzNBaL21EPoPB0DPIWVY/4NlE0ffzYfhgu+Qx\n",
+       "GHoy/YFjaK+CcB3QkIIAHAWs3wRZsuhUSs0CXgQeBm7UWi/spn0Z+jA5yxpEfYruqnwYllRic5a1\n",
+       "MaWv8U5gaT4M19Sx396IAnZLfB/SLkEMhp5O/3YL0AvoAHaKXl8HLlZK3QZcpbWe0lbJDOsaHuDU\n",
+       "0e4u4JAy2wPk/C1JzrKWArOQ0fUtwH35MOysQxaDwbCO0NFuAXoh6wPjgQeUUvcqpUa0WyCDoQls\n",
+       "CIwBjgfuAV7KWdY+7RWpmJxlXZezrEdylvXxdstiMKzrGAtCYxwI/EspdZbW+g/tFsbQ67kQuBHY\n",
+       "FNgseh9FV6vCbUAeWBC9PgBeq2EfS6J2MQOBrRDTe5KdgAdzlvW1fBjeUUP/3UbOsoYBE6OvG7VT\n",
+       "FoOhL9Af+BUwFLkZpV+DaY6V4UPkRpb1+ncT+m8nGwK/V0oN01qf025hDL2XfBi+DLycLMtZVo6u\n",
+       "CsKfGnSq8/NheEpqHwOBEcDBwJnAsGhTP2ByzrJG5cPwnQb22Sy+0G4BDIa+RH+t9dmlNiqlFKIk\n",
+       "JJWGi+jq5JPmq8BbJJQArfXqpkncczlbKbVQa/3rdgtiMNRCPgxXAK8Ar+Qs63LgXmDvaPPGwPeA\n",
+       "H7VJvCRfbLcABkNfouwUg9ZaAwuj178BlFLvVejzgR4WFviM1npcuQpKqf6IyXIjxLS7GzAWuUnu\n",
+       "XsO+fqWUellr3ZBJdq/jr9+BDn1uve07O9Rz0y6f8PtGZGgWe53oT6SBkZ/q1/nHZy47aloTRTKU\n",
+       "IR+Gy3OWNR6Zxtg0Kv4KRkEwGPocxgcBiCwcsSI0F5iOhF+ilPok8C3gVGS+thK/VErdrbWuO2ys\n",
+       "s/+aLZTuOKbe9krrIUCPUBB0B+PQ1P1bdKe6EzAKQgvJh+GbOct6gkJkxM45y+qXDIWMHBhjBWJe\n",
+       "PgyDWvaRs6zPIVObAG/nw/DpEvUGAp8E9gGGJzbtl7Os7cvs4skqp0V0Yl8jgcOBjyMDhbmIZeWl\n",
+       "fBg+UUVfReQsayhwELAnsAXi6/E28BxwTz4MP6iyn92RaSCA+/NhuCwqXx9R4MYhU0MfRTK/AjyW\n",
+       "D8MFGd0ZDFVhFIQKaK3/BXxfKXUlklTq0xWafAI4Driyu2UzGLqRlygoCArYHJif2H4gcFb0+Z2c\n",
+       "ZW2bD8NV1XScs6yNgH8g/jsAPwCeTmzfFPgjYsnbiez71MUVdnMQcF8V4nyUs6whwB8QX4+0s2Ys\n",
+       "0yPAt/NhGFbRZ/wbzgO+DaxXotqqnGX9GbigCkXhf5CBCsDngYdzljURGQhsWqLN+znL+iFwdT4M\n",
+       "dYk6BkNJTJhjlWitQ2Bf4P4qqv848t8wGHor6Yd9+ruHJFkC2BI4rIa+D6egHKwmstYlGAxMQCwH\n",
+       "rRjEPI5ER5S7ZvcFXsxZ1phKneUsawSi8HyH0soB0bbvAM9Ebaplt5xlnYkct1LKAYiFZhJwSQ19\n",
+       "GwxrMRaEGtBar1RKfRX4JxIzXortou3PN1mE+YgJsSwaeoLHOQCqUy3QSr9eqZ6G/gq2aYVMhqrY\n",
+       "OfF5FeJwvJZ8GM7JWdY/gC9HRS7wtyr7Pjrx+e6MqYC3KLbU7Qhck/h+FJIKvRRVjfSREXicU8EH\n",
+       "pgAvIIqLBZwGfC7avl5Uf29KkLOsTZCMq8npj9sQx89no37HIlaAODplNPBIzrJ2z4dhNVlaT0HC\n",
+       "XwFmIkrAC4if2PaIz8/3KCgn385Z1pX5MJxeRd8Gw1qMglAjWutlSqnTgUcqVP0SzVYQtP5mcMXE\n",
+       "SvvtUUy9YsK5QEWHy7EnTB6lOtSsFohkqEDOsgYAdqJoagkT9Z8pKAj75yzr4/kwnF2h748ho/GY\n",
+       "q9J1oqiKLj4JOctKK8Yz8mH4Yrl9VcnHkXVYTsyHoZ8WJWdZNyPThbF5/3M5yzowH4alpi9+T0E5\n",
+       "WA18Nx+Gf0zVeRG4KmdZ90R9bwCMRKwyX69C5h2j91uA4/JhuCSxbTYwJWdZtwNPIFbifsAFSISZ\n",
+       "wVA1ZoqhDrTWjyIjjXIc3ApZDIZu4ELgY4nvt5Wody8wJ/qsgBOr6HsihfvOfCRrY7v5dYZyAECk\n",
+       "GP0ISEZmZYZ55yxrB8SyEXNxhnKQ7Pt64H8TRUfmLGuXKmWeC4xPKQfJvp9CLCJlZTYYymEUhPq5\n",
+       "tcL2XVsihcHQJHKWtU3Osi5GnAZj5iKWgiKitRouTxQdl7OscnPu0HV64dp8GLY7R8pyxEGxJPkw\n",
+       "fBcZ9ceUSvN8IoV76upK/UZcgawcG3NKqYopfleFU+gDic/b5SzLWIwNNWFOmPqp5CG9sVJqPa11\n",
+       "VZ7dBkOL2D1nWcmcBkOR8MFtgM/QdTXJZcCR+TBcXqa/SYj5egAFZ8VMX4ScZe2FRPnEXF2z9M3n\n",
+       "3nwYVsrtAmK6/0z0uVR4ZXLtivvzYfhGpU7zYbgkZ1k3ACdHRQdWIQsUO3ZmkUzB3Q/xjaolLbeh\n",
+       "j2MUhDrRWr+mlFpJ+eV5hyIxz4YWs98Fj/Rf8uZbozo0/ZYt7D8rf9ORK9stUw/hU9GrEnMAp1R+\n",
+       "gph8GL4bzdNPiIpOorSzYtJ68FS1IYPdTLWp3hcnPm+Q3pizrA7E+TCmFn+aZN0dcpY1LB+G5e4b\n",
+       "y6rM8bA49X39GmQyGMwUQ4NUGnkMrbDd0A3sdeLk4z6cN+89pTtDTWd+gyErF+7pTv5eu+XqJbyK\n",
+       "TDHsmg/DJ6tsc2ni8+dzljUqXSGaevhmoqjIObFNVBzlV8kQug4W5tbQNl13WGatAv+poW+DoW6M\n",
+       "BaExPgC2LrO9nHWhpSilDqI4NPMhrfXUJvS9M/DfqeJXtdY3N9p3rex50uQ9lFKT6BrTvoFCXbTX\n",
+       "yZNfmnrZxHtbLVMP4xng74nvK5DzeD7wfIWRayb5MHwiZ1kzgF0oOCuemar2ZQoK8zLgr7Xup5t4\n",
+       "s0n9DEl9b0RBSPeV5q0a+jYY6sYoCI1RacnZ91siRXUMAH6eKnsYicdulDOAY1NlpzWh35pRqG9R\n",
+       "IuGN7uw4AfG878s8nw/DX3RDv5dScGY8NmdZP86HYXJaJzm9cHMp7/s2UHdK9BTpKaxBNbRN163k\n",
+       "t9Rux05DH8FMMTTGZhW2v9sSKarjbopNk/sqpUY30qlSahCSGS/JCuD6RvqtF6UpMm/HaHTJbYaG\n",
+       "mQzED/0umRVzlrUZhXwJ0HOmF5pJOlXyxzJrZbNt6rtZP8HQIzAKQp0opTZAlsItxTKtdTnv75YS\n",
+       "LR7lpYqrjV0vx2EUH4fbtdZtucnpMqOrDjPy6jYii8DkRFHSYnAEhem22cBjrZKrVeTDcCldTf/p\n",
+       "h345ksrEGprnF2EwNIRREOrnMxW2z2uJFLVxJcXmy2OVUo34ShydUda+EaIq7T2u0SZTY/eSdFY8\n",
+       "MGdZm0efk86J6/LCQUnFp5pIkZjkcvQz8mH4YZPkMRgawigI9VNp7v7BlkhRA1rr+RQneNqC2hba\n",
+       "WYtSajiS9z3JXLomaGktq/VllLIUdKqSWe0MjZMPwxlIel8Q/6Zv5CxrGIX8AJ10XU+hFtIRQ+UW\n",
+       "KWoXyYyTu+Qsa79KDXKWNRpJyx5zZ9OlMhjqxCgIdaCU6g98o0K1npBCNotLM8rcOvuagCRgSXKN\n",
+       "1rozq3IrCCZNfFkrfRjotWsCaJinUBODK51/tkuuPkTy/DoYOIDCfeb+fBjW4t2/lqhdcmRdbUri\n",
+       "VnILXS2HZ1WRvfAcCk61K4A/dYdgBkM9GAWhPr5F6XSrIBf6Qy2SpSaidSReShV/XilV7veUIj29\n",
+       "oOkB2fGmXT7x7sCbOGpFf7VZx4A1m0/znG2nehMyc+0bms7NFJxzxwH7J7Y1OvWUPG9/mLOsLRvs\n",
+       "r6lEaaOT0TtfBB5ITLWsJWdZg3KWdRNwTKL4wnwYzu9mMQ2GqjFhjjWilBqBpJYtx51a66UV6rST\n",
+       "S+maJz52VvxRdvVilFK7UbzexGNa67Kr+bWS6X+ekPYs79HkLGt34JOI+Xyz6D2d1vfMnGUdini6\n",
+       "L0C851/Oh2HD+SyaQT4MV+YsaxJyLm1Gwf9gAXBHg93/JNHHtsArOcuajCztPBDYCkkytBXg5sOw\n",
+       "5QmF8mF4W86yLgK+HxXtC8zKWVaALMm8CslHsicS7RFzL8VhyAZDWzEKQg0opbYE7qd8prPVdF2h\n",
+       "rSdyLfALYMNE2XFKqR/XsHbEURll62L4Wiv5PuBUqPPF6JXkLuCQbpGoPi4HfohYKGMHWD9axrlu\n",
+       "8mF4Z7RuwfioaDBwaonqRemQW0U+DH+Qs6xFwHnIFNwQsv+3mMnA8dHiVwZDj8FMMVSJUuow4DkK\n",
+       "a7GX4gqt9cstEKlutNaL6boULMho5tBq2iul+lH8IFuCmJcNfZx8GM6hOCFVU5THfBhOQHxfylkH\n",
+       "3gY+asb+6iUfhhcCewC3l5BlFbJk/P75MDwqlVTKYOgRKK1rizhSSk2h67ximo1abV5XSi2n9EIk\n",
+       "z2itx5XYVqnfQcjI7DiqW2XtfeCTUbRA3ex50nWfUrqjeJEcrfcLrpj4SCN9xyilxgDPp4of0Fof\n",
+       "UEXbg4B/pIqv1FrXnVNh7AmTR3V0qIwwRH1E4E28pd5+De0hZ1m/Bb4bfX0+H4Z7dMM+hgGjkDwC\n",
+       "S5FpjFk9bR4/Z1mDkGmF4VHR20g4Y3oxJYOhR9EXphg6lFLlVjFbH0mZvDGwCTAayCFe0ntTOZ1y\n",
+       "zDLgkEaVg1ahtX5BKfUU8OlE8ReUUjtorSstCduzch8YehSR5/6ERFG3nBvRuhE9frXUfBguA6pd\n",
+       "+Mpg6DH0BQXBBro7o+Ea4Bta66e6eT/N5lK6KggKOAE4u1QDpdTGFOdNmNkLf7uh+zgYcRQEMa+3\n",
+       "Je22wWBoDOOD0DhLgYla67vaLUgd3ETxglLHRXkeSnEExQ5gbQ9tNPQokis5TsqHoVlbwGDohRgF\n",
+       "oTECYHet9Y3tFqQetNYrKDb/DqN46eYk6emF1UhUhMFAzrImUEhDvgr4VRvFMRgMDWAUhPpYAvwf\n",
+       "8Bmte31+/8uQBEdJMjMrKqW2o5A2N+YfWusePw9s6F5yltWRs6zxwKRE8RXtyEVgMBiaQ1/wQWgm\n",
+       "eWTe/jqtdU9Zz74htNavKaXuAw5KFB+glBqptZ6Tqj6RQlrYGDO90AfJWdY5wNeQFQwHIAmetk5U\n",
+       "eZFCsiCDwdALMQpCed5AphEC4NF12BHvUroqCAoJ7TwvVS+d++BdJEmPoe+xKRLnn0UeODwfhm3N\n",
+       "RWAwGBqjLygIbwN/LbNdI1MGH6ReL/eWkMUmcDeSeGa7RNlRSqnzdZQoQym1C7Bzqt11NWReNKxb\n",
+       "zEMU6GHAesBiYCaSLOviaF0Cg8HQi+kLCsLrWuvT2y1ET0ZrvUYp5SG57mO2Bz4LPB59/2ZRQ5P7\n",
+       "oM+SD8OLgYvbLYfBYOg+jJOiIeZKxOs8STJiIb28daC1/lf3imQwGAyGdmEUBAMA0XTKraniI5VS\n",
+       "A6O0zOnloI31wGAwGNZhjIJgSHJp6vtgJBNlehW65cANLZHIYDAYDG3BKAiGtWitHwVeShV/muLF\n",
+       "uW7VWi9qjVQGg8FgaAd9wUnRUBuXAn9IfN8f+FyqTo/OfbDnSX8brDpXnqEUe2ropzQvdtDx66ev\n",
+       "GN9XolIMPQDb9T8LrBd4zsPtlsXQe7Bd/0BgQeA5QbtlMQqCIc21wC+ADaPv6WWu5wAPtVKgWtjt\n",
+       "6Os2XG/9jhdQjIzTQ2rFF9bQecy4E2/I9UQlwXb9LYDDK1R7K/Cc21shj6FxbNcfDjwGKNv1Rwae\n",
+       "83q7ZWo2tusPBb6ELGW9BbAICX99Gngs8Jx0hlZDBWzXHwvcC6ywXX9o4DlL2ymPURAMXdBaL1ZK\n",
+       "+ZRItwz8Jc6N0BMZMFB9GxiZsWnzTjrPAH7QWomqYgTF/h9pngC6RUGwXf+XwC2B50ztjv57M7br\n",
+       "XwJMCjxneo1NP0SWgAfJq7LOYLv+esAFwOkUL9wWM912/d0Dz+lsnWQ9A9v1BwEXAT8PPKfWVOML\n",
+       "kPVt3kNWQm0rxgfBkEWph5UG/tJCOWqnQ40ttUkrvWcrRamWwHOmAZsguSfGAi9Hmy5AUhgPAz7f\n",
+       "Hfu2XX8k8ENgx+7ovzdju/4uwP9D/peaCDxnCbANsF3gOYubLVu7sF1/AHAHcBaiHDwI/C+ywNsE\n",
+       "4KfA68BdfVE5iNgbOBmxqtRE4Dn/BoYDnwg8Z02zBasVY0EwFKG1fkEp9RTioJjkIa11zzaVarYq\n",
+       "vVFt2TpBaiN6oCwB5tiu/2FUPCvwnLTTaLM5oJv77800dGwCz1kXHXkvRNKydwI/Cjzn1+kKtuuf\n",
+       "i2TX7Ks0et681yxBGsUoCIZSBBQrCL0h98EbdW7rddiuPwoYFJu/bdffFNgL2BZ4DZgWKR5ZbRWS\n",
+       "2+KIqGiE7fpjUtXmlrtZRdaHscBAYDowM/CckimWbdffFfgw8JzXou/9kfUccojV5MXAcz4s0XYw\n",
+       "sCsymu8PzAVmBJ7zVqn9pdoPRVKF7wSsAN4EgqzRve36HcAoZDEqgO0zjs3rged8kGo3gOJ05ADT\n",
+       "s0bTkan+k9HXGaVGjNFxykVf81nH2Hb9Ich/MRJJeT291H9fL7brj6CwANfPspQDgOi3rijRx/rI\n",
+       "b8kB7wPPBZ4zL6Ne/JvfCDzn/WhufhvgvsBzVkR1dgN2AR4JPGduom38P7wXeM7c6FzfCfgU4iMR\n",
+       "lFLebNfPIefXzMBzikz8tusPQyx676bljmTeCfhyVLST7frp//TV9Dluu/6GwOhUvTWB58zIkjFq\n",
+       "sykyNfmfwHMW2K7fLzoWeyDTFPnAc14t1T7qYwNgT+Rc/wi5ZyT/N20UBEMRSqn+wNdTxQspTqTU\n",
+       "41BaP6yVOipzGzzSYnG6m6uBz0YPv7OQm3dytc35tuuflHZutF3/BuArwEaJ4p/QNdU2wGnAH9M7\n",
+       "jRSTG5CbS5LQdv2joymTLKYBzwHjbNc/DomW2TCxfbXt+sMCz3k/sa8RwM+Qh/X6qf5W2q4/CTit\n",
+       "zMN1OPB7CopQktW2658YeM5fEvXvRKZzBiXqZaWUPha4JlW2NfB8Rt0hiANfmjWIuf5jiLPfvVm/\n",
+       "AfmvbgNmB54zKrkheuD+Bjg11Wap7fpnBJ5TybelFk4E+iE+Fb+ptbHt+scg//nGqfJbgeMDz1mY\n",
+       "KN4UOZYX2q7fSWHhuNdt198ZOBc4MypbbLv+5wPPeTb6PiJqe5ft+ichx3WXRN8rbdc/OfCcrGis\n",
+       "R4ChiHKSlSn2f4BzkOvitMRvCKJ9DEzU9TPafwGZlkkyBvExSrKUrtdnmoOBycA5tus/iCyat3li\n",
+       "u7Zd/0rk2ihS1mzXPwT4E3LulaLTKAiGLL6EaMlJbtBat91pphIjFw289t9DVh4N7Jva9EKnWnpJ\n",
+       "G0RqBXcjCa08YCqy/PJE4L8A33b9HQPPeTNR/0bgvujzGchoywPSq5U+nd6R7fp7IDfRjYDrEE99\n",
+       "DeyHrPb5lO364xI36zTb2q4/AUnt/SSyLHQHMvJZklQOIhYChyCLid2FWBoGIQrDfwGnAP8Gskzd\n",
+       "VvSbBgPvIMdpJjLHuxdikXgg1ewa4Jbo84+BHRAFI/3gT9/QQZa+/iIy9zwccVQrSeA5nbbrX4s8\n",
+       "cI6htIIQK7xdFJLIAvEEYjmYBlyP/E4LeXj92Xb94YHnnFtOjhrYJ3q/vtbpE9v1fwqcjYxUL0GO\n",
+       "51bI//g1YIzt+mNTSgJIivfNEIXgBOThfx0ySv8Nct7vgzgfj0+1HQf8E5iPKM/vI+vLHA9cZbs+\n",
+       "JZSEevgDBZ++3yIKzgVI1FeSrCnD6ci0zebAJxCfjmoZjxzXPPBL5By0gW8jCt3sqHwtkYL1N0RB\n",
+       "/R2ymOG2yHE5CLFAHAu8ahQEQxbfyijrDdML3HTTkWvUBRfsb88bPb6TzjEK+oHKL184YHL+Jmdl\n",
+       "u+XrJsYBhwaec0dcYLu+hzw0dkcu/AvjbUmLgu36DqIgPB54zuQq9nURMgI8LjnyBibZrj8z2s/l\n",
+       "tuvvVcJJbWvkXDoi8JzbKu0s8JxFtut/IqXgAPzOdv0/IiPnb5KhICAjpMGIEjAhPV1iu35HWsbA\n",
+       "c25ObD8ZURAeqibENBqpTYnark8FBSHiakRBOMx2/cHpB29kSv4KooSlLRYnIcrBHcBXk7/Fdv0b\n",
+       "gReAM23Xvz7wnJlVyFIJK3qfXUsj2/U/jiiiq4B9ktEytuv/Fhlpfx2xEnw31XxHYLfAc6bbrv8k\n",
+       "cny/Bnwz8Jy/2q6/DTLd9F8Zu94ceXAeEHhOvM7MNbbrT0UU4vNs15+c2FY3gedcm/hNP0EUhDvL\n",
+       "KMrJtkuIFPboWNWiIOSAO4HDE7/Dj67FSxEn21+m2pyOWDpuCDxn7fG2Xf8e4F1EIVsceE5oohgM\n",
+       "XVBKjURuSEke11qXMhv3OPR553VO9Sb407yJZwTexO8FnnNV/qYj11XlAOCfSeUA1s4D/y36mp7f\n",
+       "rAvb9fdGLDMzU8pBzMXIg2wsMhLKQiFhgxWVg5gM5SDm+uh9VHqD7fr7IlaNFcAJWb4UPcHLPvCc\n",
+       "2YgVZn3gyIwq30AsQg8lQ+aiefUfR1/PzlB08sD9Udusfmsi2t+Q6GutjspnIE6L16dDaSN/irMR\n",
+       "p8dTbddPOxK/nwgxTZr8747e30SsEkNL7PvXGQrAVYgvwggK/gK9mXMyfuON0fvWkY9Dkp2i97uT\n",
+       "hYHnLKNgURsDxknRUMz5FJ8XP22DHIbqSc9pxsSOW8ObtJ89ovdXbNcvpQC8j4zcdiTbnAoy4q2b\n",
+       "6Ia3CYV5/Y0zqsXOf4/WEYveaq5GQuOOQaZekhydqJNkW2BLZF2UzhL/R+xE2XAIa+A52nb9lUho\n",
+       "Y63hd7GD5d1ZGwPPmW27/iuIUrkLXc/n9xP13rZd/yNgVezoF8n1NjAyyyKETGGl97fGdv1/IlaL\n",
+       "3h7e+06WM2PgOQtt11+GTMcNo6vVJ1aWsyK+4nvFQjAKgiGBUmoshfnOmGe11vdl1Tf0GOaUKI9v\n",
+       "lqrE9lqJb6b/Hb3KsU2Zba/VslPb9bdDfA0ORLz0N62iWWxVqMkc3iZuRuawP2u7/g6JKI9RSCTR\n",
+       "YoodhOP/YgNKK2Ix2zZJzjnINMN2NbaL/4uiaIUE/0EUhB3pqiCkMwl2IscjXZZFJ/B2iW1xRtWR\n",
+       "ZWTqDcwps63U9f8Q0TSN7fp/iK0PtuvviPjmrCHyR1qrICilNkTmHjZDLsDke/JzOtwnzY1KqXcR\n",
+       "R4cFiBab9XlRT87I19dQSo1GNPz0tJOxHvR8mhrOVobB0XuAOBiWo1zmwaqdXW3X3x+4BzGVv4SM\n",
+       "pN9AnPEg21McxMIArTs2dRN4zoe26/8NOA6xGJwfbYqV9b8GnrM81Sz+Lz5A0qOXo2y4Ww3MoT4F\n",
+       "IY4+KTfNF58TaXN4VthstVNDitLKcdxvOjKmEj0tv0M953fs87E3Eul0B2JliBflOzfwnFcA+iul\n",
+       "5iEmwQFNEBaK569L0amUWggcqrXO8gg2FKHG2CdW4Uem9XvBlUflu7RUaiByU3lPa92ZKN8cSav8\n",
+       "fUQBTHKr1rrqueIsxp18/eg1azrLjSYB6NfRsY3G6Is9nDjDYxh4zundvbMotvtm5N50duA5P09t\n",
+       "T0faJIkfirU+zNrF1YiC4FBQECZE73/JqB//F+u14r+ImIVEOB1iu/6ZNfhwzEamp7YuU2e7RN1m\n",
+       "oZBnW5YVIfZ1qNWfotw51yuIph++hET0bAkcikwpTAEuCjxnSly3PzIP0a8NcnYgD6SBlSoaIhQX\n",
+       "V2UtVup24LBU6S7IyG+NUuodZP52awojrTSvIjeshlij9XdQKh2jXYRRDtpGfOCruQfEpmzbdn0V\n",
+       "dP9iPLsgjnEryI67Lzd/PCt6/5Tt+v3LJXAqQ/z7ut2ZO/Ccx23XfxUYZbt+7D8xCngl8Jwsa80s\n",
+       "ZBS8ke36O7cg4ybA5UgegJ0QE/XN5auvZRaiIMQRF12wXX8TCv9ls6eERpOtIMR+EXNS5YsRh8dS\n",
+       "To/V+CzUck21i6uR5++4wHNeKFXJRDH0PfoR5fqmtHKwDDhCa73O5JA3lCSeF04v6Z3FPRTMzBO7\n",
+       "S6AE8Q12PbomgYn5Xpm29yMPhu2RUK96iKMn9q6zfa38JXo/NHoly7oQeM5K4Iro60+jKINuJVJC\n",
+       "Yu/439uuX805A4VkWyfbrp+V/MdFnOmeCmpfFKsSRYMc2/U/DeyG3OfSjpOx5WmfVHmcuXFcFfus\n",
+       "5ZpqObbrb45EtswqpxyAcVI0FDMbOFxrXeT9a+heopvnEArzolvashT0wmbEapdgGpIU5XDb9R9F\n",
+       "YqrXQyyL8wPPeTeuGHjOMtv1T0VuqldH6W//jigNmyHOcAcBgwPPcZog20xkRLcJ8DPb9S9CRqM7\n",
+       "I7kDvoDE1hfdxwLPWWy7/plI7oCLbNffHXm4zUQeRtsjGRP/EXhOKSfcABkpj49i5+9G/putgHmB\n",
+       "5yxIN4iSF21C14V6Rtiu/yYSW15uHv4a4P8oKAedlPcvOAv4KmItfCTKKfAS8v8NR1ILHwnsl5GA\n",
+       "qF7ORdYaGA48HGWyfBqYgViDRwCfQR72PkDgOU9E2TvHI4m0TgeeRczb30DyH2iKcyA0ymrgWNv1\n",
+       "FyDK1NvIQ3tStN3LCH+9HUl29UPb9echFo8BUbtLEKfJtJ9EmgA59ifbrj8bCR3cGDlvZqdTLcPa\n",
+       "9NCbUMhs2GFLKvPFSAKxZl7/CxEL8pgoA+QMxD+kE3HenAHcHnjOGmNB6Dt8iGjHWSFKK4HHkcQr\n",
+       "OxvloLXYrr+77fqrEIejNyiE6P0WccZbabv+lFLtG+Ry5AY/BHkYfRDtR9M79QAAA3FJREFUcwYS\n",
+       "NdCFwHPuQR6a7wHfAR5GMhk+i9xcT6G6KIOKBJ6zFBn9r0GUmBlIWN9ziHf/5yjO/phsfy2yqt4i\n",
+       "xOJxF3INTI9k/Q7ZoV4xv0PC5LZCci4sQm6g08kYHdquvxy5lt4DwsSmF5EENCts1//Idv3M9LbR\n",
+       "egJTkEx4NvBA1joFifqLIjkeR6wcfwdeQfIFTEEcjHNU79RXkShvw95Ixs5+yOj/KuSh+ATiAHcq\n",
+       "xb4fxwOXRfJMQc6zlxGF6B3g4MBznmmWnBFzEUfP0xDFcCGiAG+JHKushESXIdanjRBF4l3EInAj\n",
+       "8vuOqWK/5yNRGaOQFNkfIhkOX6CQgwAA2/W3jkI3V0T7ejjatAFyXb2PXP/LbVnroWGi6bbzo697\n",
+       "IlaWk5Br93wkk+jztusP7o94Lna7eaoMZU0cVXIAped7eqGZfP2ZqmPFl+ptrVf3n19UpvVMYLRS\n",
+       "agBywxuEjLwWAe9qrTMXV2mUzs7OP/Xrp+6qt33Hmn5Zue3XNeZTOVoky5nqKiQkrNT883Qk3WvJ\n",
+       "sMLAc1bbrv9Z5AH6KWRkOB+5wRWlWo7a3Ga7/mOIomAho/GFyI30YeDREru7ELlOq07TG3jONbbr\n",
+       "T0Nu9KOQm+i/gFsDz3nTdv2fI2FbpdpfHnlpH4LcnHdAlIz5yLErqXgFnvOR7fo28lDYE7lu3kKO\n",
+       "TdZ9K52xrhTl7knnUVB6SqVeTsr4apQU6lDEbG4hCsFbROsRBE1ebjrwnNB2/XGIGf5gRBkYhPyv\n",
+       "7yDpjR9MtVkOnGK7/vWIgrFrVPcF4O8ZKbaXIuduWkH6KfL/JbkEsWClfWK2CDzHt10/jzhXjkGO\n",
+       "yzNIZEiRD00ga3ocaLv+kUh2xo8hSuVURKmIUyiXVGYCWVzKQlJD7xrJNg85b9LX8RLgF6X6SpFU\n",
+       "9Cpe28gaJgORqEEAbNffDLlvHIQoAndR8NEYilwjExD/nwuUiTQ0GAwGw7qC7fqjEUvKqsBzmhWd\n",
+       "t05gu/5pyNoifw48J9N5PForxQeeNFMMBoPBYDD0DWL/llvK1In9jt4zCoLBYDAYDH2DePo5MwrJ\n",
+       "dv0hFPwTnjBRDAaDwWAw9A3+hPgOHRPl25iK+FhsiuR4OARx0Lwf+J1REAwGg8Fg6AMEnvNklL78\n",
+       "HMRRca/E5hVINNIVwI2B56z6/3ExLRI31pXNAAAAAElFTkSuQmCC\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Image at 0x111275490>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import Image\n",
+    "Image(\"http://ipython.org/_static/IPy_header.png\")"
+   ]
+  }
+ ],
+ "metadata": {
+   "title": "Test Notebook",
+   "authors": [{"name": "Jean Tester"}]
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

venv/Lib/site-packages/nbformat/tests/test4jupyter_metadata.ipynb

@@ -0,0 +1,30 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "collapsed": false,
+    "jupyter": {
+      "outputs_hidden": false,
+      "source_hidden": false
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "hello\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"hello\")"
+   ]
+  }
+ ],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

venv/Lib/site-packages/nbformat/tests/test4jupyter_metadata_timings.ipynb

@@ -0,0 +1,61 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2019-08-26T17:50:29.604738Z",
+     "iopub.status.busy": "2019-08-26T17:50:29.603423Z",
+     "iopub.status.idle": "2019-08-26T17:50:29.628032Z",
+     "shell.execute_reply": "2019-08-26T17:50:29.623438Z",
+     "shell.execute_reply.started": "2019-08-26T17:50:29.604616Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "1+1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 2",
+   "language": "python",
+   "name": "python2"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.0"
+  },
+  "record_timing": true
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

venv/Lib/site-packages/nbformat/tests/test4plus.ipynb

@@ -0,0 +1,349 @@
+{
+ "extra": "future",
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "extra": 5,
+   "metadata": {},
+   "source": [
+    "# nbconvert latex test"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lorem ipsum** dolor sit amet, consectetur adipiscing elit. Nunc luctus bibendum felis dictum sodales. Ut suscipit, orci ut interdum imperdiet, purus ligula mollis *justo*, non malesuada nisl augue eget lorem. Donec bibendum, erat sit amet porttitor aliquam, urna lorem ornare libero, in vehicula diam diam ut ante. Nam non urna rhoncus, accumsan elit sit amet, mollis tellus. Vestibulum nec tellus metus. Vestibulum tempor, ligula et vehicula rhoncus, sapien turpis faucibus lorem, id dapibus turpis mauris ac orci. Sed volutpat vestibulum venenatis."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Printed Using Python"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "future": "yes",
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "extra": "future",
+     "output_type": "stream",
+     "text": [
+      "hello\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"hello\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Pyout"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "<script>\n",
+       "console.log(\"hello\");\n",
+       "</script>\n",
+       "<b>HTML</b>\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML at 0x1112757d0>"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import HTML\n",
+    "HTML(\"\"\"\n",
+    "<script>\n",
+    "console.log(\"hello\");\n",
+    "</script>\n",
+    "<b>HTML</b>\n",
+    "\"\"\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "console.log(\"hi\");"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript at 0x1112b4b50>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%javascript\n",
+    "console.log(\"hi\");"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": [
+       "iVBORw0KGgoAAAANSUhEUgAAAggAAABDCAYAAAD5/P3lAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n",
+       "AAAH3AAAB9wBYvxo6AAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAACAASURB\n",
+       "VHic7Z15uBxF1bjfugkJhCWBsCSAJGACNg4QCI3RT1lEAVE+UEBNOmwCDcjHT1wQgU+WD3dFxA1o\n",
+       "CAikAZFFVlnCjizpsCUjHQjBIAkQlpCFJGS79fvjdGf69vTsc2fuza33eeaZmeqq6jM9vZw6dc4p\n",
+       "BUwC+tE+fqW1fqmRDpRSHjCggS40sBxYDCxKvL8KzNBaL21EPoPB0DPIWVY/4NlE0ffzYfhgu+Qx\n",
+       "GHoy/YFjaK+CcB3QkIIAHAWs3wRZsuhUSs0CXgQeBm7UWi/spn0Z+jA5yxpEfYruqnwYllRic5a1\n",
+       "MaWv8U5gaT4M19Sx396IAnZLfB/SLkEMhp5O/3YL0AvoAHaKXl8HLlZK3QZcpbWe0lbJDOsaHuDU\n",
+       "0e4u4JAy2wPk/C1JzrKWArOQ0fUtwH35MOysQxaDwbCO0NFuAXoh6wPjgQeUUvcqpUa0WyCDoQls\n",
+       "CIwBjgfuAV7KWdY+7RWpmJxlXZezrEdylvXxdstiMKzrGAtCYxwI/EspdZbW+g/tFsbQ67kQuBHY\n",
+       "FNgseh9FV6vCbUAeWBC9PgBeq2EfS6J2MQOBrRDTe5KdgAdzlvW1fBjeUUP/3UbOsoYBE6OvG7VT\n",
+       "FoOhL9Af+BUwFLkZpV+DaY6V4UPkRpb1+ncT+m8nGwK/V0oN01qf025hDL2XfBi+DLycLMtZVo6u\n",
+       "CsKfGnSq8/NheEpqHwOBEcDBwJnAsGhTP2ByzrJG5cPwnQb22Sy+0G4BDIa+RH+t9dmlNiqlFKIk\n",
+       "JJWGi+jq5JPmq8BbJJQArfXqpkncczlbKbVQa/3rdgtiMNRCPgxXAK8Ar+Qs63LgXmDvaPPGwPeA\n",
+       "H7VJvCRfbLcABkNfouwUg9ZaAwuj178BlFLvVejzgR4WFviM1npcuQpKqf6IyXIjxLS7GzAWuUnu\n",
+       "XsO+fqWUellr3ZBJdq/jr9+BDn1uve07O9Rz0y6f8PtGZGgWe53oT6SBkZ/q1/nHZy47aloTRTKU\n",
+       "IR+Gy3OWNR6Zxtg0Kv4KRkEwGPocxgcBiCwcsSI0F5iOhF+ilPok8C3gVGS+thK/VErdrbWuO2ys\n",
+       "s/+aLZTuOKbe9krrIUCPUBB0B+PQ1P1bdKe6EzAKQgvJh+GbOct6gkJkxM45y+qXDIWMHBhjBWJe\n",
+       "PgyDWvaRs6zPIVObAG/nw/DpEvUGAp8E9gGGJzbtl7Os7cvs4skqp0V0Yl8jgcOBjyMDhbmIZeWl\n",
+       "fBg+UUVfReQsayhwELAnsAXi6/E28BxwTz4MP6iyn92RaSCA+/NhuCwqXx9R4MYhU0MfRTK/AjyW\n",
+       "D8MFGd0ZDFVhFIQKaK3/BXxfKXUlklTq0xWafAI4Driyu2UzGLqRlygoCArYHJif2H4gcFb0+Z2c\n",
+       "ZW2bD8NV1XScs6yNgH8g/jsAPwCeTmzfFPgjYsnbiez71MUVdnMQcF8V4nyUs6whwB8QX4+0s2Ys\n",
+       "0yPAt/NhGFbRZ/wbzgO+DaxXotqqnGX9GbigCkXhf5CBCsDngYdzljURGQhsWqLN+znL+iFwdT4M\n",
+       "dYk6BkNJTJhjlWitQ2Bf4P4qqv848t8wGHor6Yd9+ruHJFkC2BI4rIa+D6egHKwmstYlGAxMQCwH\n",
+       "rRjEPI5ER5S7ZvcFXsxZ1phKneUsawSi8HyH0soB0bbvAM9Ebaplt5xlnYkct1LKAYiFZhJwSQ19\n",
+       "GwxrMRaEGtBar1RKfRX4JxIzXortou3PN1mE+YgJsSwaeoLHOQCqUy3QSr9eqZ6G/gq2aYVMhqrY\n",
+       "OfF5FeJwvJZ8GM7JWdY/gC9HRS7wtyr7Pjrx+e6MqYC3KLbU7Qhck/h+FJIKvRRVjfSREXicU8EH\n",
+       "pgAvIIqLBZwGfC7avl5Uf29KkLOsTZCMq8npj9sQx89no37HIlaAODplNPBIzrJ2z4dhNVlaT0HC\n",
+       "XwFmIkrAC4if2PaIz8/3KCgn385Z1pX5MJxeRd8Gw1qMglAjWutlSqnTgUcqVP0SzVYQtP5mcMXE\n",
+       "SvvtUUy9YsK5QEWHy7EnTB6lOtSsFohkqEDOsgYAdqJoagkT9Z8pKAj75yzr4/kwnF2h748ho/GY\n",
+       "q9J1oqiKLj4JOctKK8Yz8mH4Yrl9VcnHkXVYTsyHoZ8WJWdZNyPThbF5/3M5yzowH4alpi9+T0E5\n",
+       "WA18Nx+Gf0zVeRG4KmdZ90R9bwCMRKwyX69C5h2j91uA4/JhuCSxbTYwJWdZtwNPIFbifsAFSISZ\n",
+       "wVA1ZoqhDrTWjyIjjXIc3ApZDIZu4ELgY4nvt5Wody8wJ/qsgBOr6HsihfvOfCRrY7v5dYZyAECk\n",
+       "GP0ISEZmZYZ55yxrB8SyEXNxhnKQ7Pt64H8TRUfmLGuXKmWeC4xPKQfJvp9CLCJlZTYYymEUhPq5\n",
+       "tcL2XVsihcHQJHKWtU3Osi5GnAZj5iKWgiKitRouTxQdl7OscnPu0HV64dp8GLY7R8pyxEGxJPkw\n",
+       "fBcZ9ceUSvN8IoV76upK/UZcgawcG3NKqYopfleFU+gDic/b5SzLWIwNNWFOmPqp5CG9sVJqPa11\n",
+       "VZ7dBkOL2D1nWcmcBkOR8MFtgM/QdTXJZcCR+TBcXqa/SYj5egAFZ8VMX4ScZe2FRPnEXF2z9M3n\n",
+       "3nwYVsrtAmK6/0z0uVR4ZXLtivvzYfhGpU7zYbgkZ1k3ACdHRQdWIQsUO3ZmkUzB3Q/xjaolLbeh\n",
+       "j2MUhDrRWr+mlFpJ+eV5hyIxz4YWs98Fj/Rf8uZbozo0/ZYt7D8rf9ORK9stUw/hU9GrEnMAp1R+\n",
+       "gph8GL4bzdNPiIpOorSzYtJ68FS1IYPdTLWp3hcnPm+Q3pizrA7E+TCmFn+aZN0dcpY1LB+G5e4b\n",
+       "y6rM8bA49X39GmQyGMwUQ4NUGnkMrbDd0A3sdeLk4z6cN+89pTtDTWd+gyErF+7pTv5eu+XqJbyK\n",
+       "TDHsmg/DJ6tsc2ni8+dzljUqXSGaevhmoqjIObFNVBzlV8kQug4W5tbQNl13WGatAv+poW+DoW6M\n",
+       "BaExPgC2LrO9nHWhpSilDqI4NPMhrfXUJvS9M/DfqeJXtdY3N9p3rex50uQ9lFKT6BrTvoFCXbTX\n",
+       "yZNfmnrZxHtbLVMP4xng74nvK5DzeD7wfIWRayb5MHwiZ1kzgF0oOCuemar2ZQoK8zLgr7Xup5t4\n",
+       "s0n9DEl9b0RBSPeV5q0a+jYY6sYoCI1RacnZ91siRXUMAH6eKnsYicdulDOAY1NlpzWh35pRqG9R\n",
+       "IuGN7uw4AfG878s8nw/DX3RDv5dScGY8NmdZP86HYXJaJzm9cHMp7/s2UHdK9BTpKaxBNbRN163k\n",
+       "t9Rux05DH8FMMTTGZhW2v9sSKarjbopNk/sqpUY30qlSahCSGS/JCuD6RvqtF6UpMm/HaHTJbYaG\n",
+       "mQzED/0umRVzlrUZhXwJ0HOmF5pJOlXyxzJrZbNt6rtZP8HQIzAKQp0opTZAlsItxTKtdTnv75YS\n",
+       "LR7lpYqrjV0vx2EUH4fbtdZtucnpMqOrDjPy6jYii8DkRFHSYnAEhem22cBjrZKrVeTDcCldTf/p\n",
+       "h345ksrEGprnF2EwNIRREOrnMxW2z2uJFLVxJcXmy2OVUo34ShydUda+EaIq7T2u0SZTY/eSdFY8\n",
+       "MGdZm0efk86J6/LCQUnFp5pIkZjkcvQz8mH4YZPkMRgawigI9VNp7v7BlkhRA1rr+RQneNqC2hba\n",
+       "WYtSajiS9z3JXLomaGktq/VllLIUdKqSWe0MjZMPwxlIel8Q/6Zv5CxrGIX8AJ10XU+hFtIRQ+UW\n",
+       "KWoXyYyTu+Qsa79KDXKWNRpJyx5zZ9OlMhjqxCgIdaCU6g98o0K1npBCNotLM8rcOvuagCRgSXKN\n",
+       "1rozq3IrCCZNfFkrfRjotWsCaJinUBODK51/tkuuPkTy/DoYOIDCfeb+fBjW4t2/lqhdcmRdbUri\n",
+       "VnILXS2HZ1WRvfAcCk61K4A/dYdgBkM9GAWhPr5F6XSrIBf6Qy2SpSaidSReShV/XilV7veUIj29\n",
+       "oOkB2fGmXT7x7sCbOGpFf7VZx4A1m0/znG2nehMyc+0bms7NFJxzxwH7J7Y1OvWUPG9/mLOsLRvs\n",
+       "r6lEaaOT0TtfBB5ITLWsJWdZg3KWdRNwTKL4wnwYzu9mMQ2GqjFhjjWilBqBpJYtx51a66UV6rST\n",
+       "S+maJz52VvxRdvVilFK7UbzexGNa67Kr+bWS6X+ekPYs79HkLGt34JOI+Xyz6D2d1vfMnGUdini6\n",
+       "L0C851/Oh2HD+SyaQT4MV+YsaxJyLm1Gwf9gAXBHg93/JNHHtsArOcuajCztPBDYCkkytBXg5sOw\n",
+       "5QmF8mF4W86yLgK+HxXtC8zKWVaALMm8CslHsicS7RFzL8VhyAZDWzEKQg0opbYE7qd8prPVdF2h\n",
+       "rSdyLfALYMNE2XFKqR/XsHbEURll62L4Wiv5PuBUqPPF6JXkLuCQbpGoPi4HfohYKGMHWD9axrlu\n",
+       "8mF4Z7RuwfioaDBwaonqRemQW0U+DH+Qs6xFwHnIFNwQsv+3mMnA8dHiVwZDj8FMMVSJUuow4DkK\n",
+       "a7GX4gqt9cstEKlutNaL6boULMho5tBq2iul+lH8IFuCmJcNfZx8GM6hOCFVU5THfBhOQHxfylkH\n",
+       "3gY+asb+6iUfhhcCewC3l5BlFbJk/P75MDwqlVTKYOgRKK1rizhSSk2h67ximo1abV5XSi2n9EIk\n",
+       "z2itx5XYVqnfQcjI7DiqW2XtfeCTUbRA3ex50nWfUrqjeJEcrfcLrpj4SCN9xyilxgDPp4of0Fof\n",
+       "UEXbg4B/pIqv1FrXnVNh7AmTR3V0qIwwRH1E4E28pd5+De0hZ1m/Bb4bfX0+H4Z7dMM+hgGjkDwC\n",
+       "S5FpjFk9bR4/Z1mDkGmF4VHR20g4Y3oxJYOhR9EXphg6lFLlVjFbH0mZvDGwCTAayCFe0ntTOZ1y\n",
+       "zDLgkEaVg1ahtX5BKfUU8OlE8ReUUjtorSstCduzch8YehSR5/6ERFG3nBvRuhE9frXUfBguA6pd\n",
+       "+Mpg6DH0BQXBBro7o+Ea4Bta66e6eT/N5lK6KggKOAE4u1QDpdTGFOdNmNkLf7uh+zgYcRQEMa+3\n",
+       "Je22wWBoDOOD0DhLgYla67vaLUgd3ETxglLHRXkeSnEExQ5gbQ9tNPQokis5TsqHoVlbwGDohRgF\n",
+       "oTECYHet9Y3tFqQetNYrKDb/DqN46eYk6emF1UhUhMFAzrImUEhDvgr4VRvFMRgMDWAUhPpYAvwf\n",
+       "8Bmte31+/8uQBEdJMjMrKqW2o5A2N+YfWusePw9s6F5yltWRs6zxwKRE8RXtyEVgMBiaQ1/wQWgm\n",
+       "eWTe/jqtdU9Zz74htNavKaXuAw5KFB+glBqptZ6Tqj6RQlrYGDO90AfJWdY5wNeQFQwHIAmetk5U\n",
+       "eZFCsiCDwdALMQpCed5AphEC4NF12BHvUroqCAoJ7TwvVS+d++BdJEmPoe+xKRLnn0UeODwfhm3N\n",
+       "RWAwGBqjLygIbwN/LbNdI1MGH6ReL/eWkMUmcDeSeGa7RNlRSqnzdZQoQym1C7Bzqt11NWReNKxb\n",
+       "zEMU6GHAesBiYCaSLOviaF0Cg8HQi+kLCsLrWuvT2y1ET0ZrvUYp5SG57mO2Bz4LPB59/2ZRQ5P7\n",
+       "oM+SD8OLgYvbLYfBYOg+jJOiIeZKxOs8STJiIb28daC1/lf3imQwGAyGdmEUBAMA0XTKraniI5VS\n",
+       "A6O0zOnloI31wGAwGNZhjIJgSHJp6vtgJBNlehW65cANLZHIYDAYDG3BKAiGtWitHwVeShV/muLF\n",
+       "uW7VWi9qjVQGg8FgaAd9wUnRUBuXAn9IfN8f+FyqTo/OfbDnSX8brDpXnqEUe2ropzQvdtDx66ev\n",
+       "GN9XolIMPQDb9T8LrBd4zsPtlsXQe7Bd/0BgQeA5QbtlMQqCIc21wC+ADaPv6WWu5wAPtVKgWtjt\n",
+       "6Os2XG/9jhdQjIzTQ2rFF9bQecy4E2/I9UQlwXb9LYDDK1R7K/Cc21shj6FxbNcfDjwGKNv1Rwae\n",
+       "83q7ZWo2tusPBb6ELGW9BbAICX99Gngs8Jx0hlZDBWzXHwvcC6ywXX9o4DlL2ymPURAMXdBaL1ZK\n",
+       "+ZRItwz8Jc6N0BMZMFB9GxiZsWnzTjrPAH7QWomqYgTF/h9pngC6RUGwXf+XwC2B50ztjv57M7br\n",
+       "XwJMCjxneo1NP0SWgAfJq7LOYLv+esAFwOkUL9wWM912/d0Dz+lsnWQ9A9v1BwEXAT8PPKfWVOML\n",
+       "kPVt3kNWQm0rxgfBkEWph5UG/tJCOWqnQ40ttUkrvWcrRamWwHOmAZsguSfGAi9Hmy5AUhgPAz7f\n",
+       "Hfu2XX8k8ENgx+7ovzdju/4uwP9D/peaCDxnCbANsF3gOYubLVu7sF1/AHAHcBaiHDwI/C+ywNsE\n",
+       "4KfA68BdfVE5iNgbOBmxqtRE4Dn/BoYDnwg8Z02zBasVY0EwFKG1fkEp9RTioJjkIa11zzaVarYq\n",
+       "vVFt2TpBaiN6oCwB5tiu/2FUPCvwnLTTaLM5oJv77800dGwCz1kXHXkvRNKydwI/Cjzn1+kKtuuf\n",
+       "i2TX7Ks0et681yxBGsUoCIZSBBQrCL0h98EbdW7rddiuPwoYFJu/bdffFNgL2BZ4DZgWKR5ZbRWS\n",
+       "2+KIqGiE7fpjUtXmlrtZRdaHscBAYDowM/CckimWbdffFfgw8JzXou/9kfUccojV5MXAcz4s0XYw\n",
+       "sCsymu8PzAVmBJ7zVqn9pdoPRVKF7wSsAN4EgqzRve36HcAoZDEqgO0zjs3rged8kGo3gOJ05ADT\n",
+       "s0bTkan+k9HXGaVGjNFxykVf81nH2Hb9Ich/MRJJeT291H9fL7brj6CwANfPspQDgOi3rijRx/rI\n",
+       "b8kB7wPPBZ4zL6Ne/JvfCDzn/WhufhvgvsBzVkR1dgN2AR4JPGduom38P7wXeM7c6FzfCfgU4iMR\n",
+       "lFLebNfPIefXzMBzikz8tusPQyx676bljmTeCfhyVLST7frp//TV9Dluu/6GwOhUvTWB58zIkjFq\n",
+       "sykyNfmfwHMW2K7fLzoWeyDTFPnAc14t1T7qYwNgT+Rc/wi5ZyT/N20UBEMRSqn+wNdTxQspTqTU\n",
+       "41BaP6yVOipzGzzSYnG6m6uBz0YPv7OQm3dytc35tuuflHZutF3/BuArwEaJ4p/QNdU2wGnAH9M7\n",
+       "jRSTG5CbS5LQdv2joymTLKYBzwHjbNc/DomW2TCxfbXt+sMCz3k/sa8RwM+Qh/X6qf5W2q4/CTit\n",
+       "zMN1OPB7CopQktW2658YeM5fEvXvRKZzBiXqZaWUPha4JlW2NfB8Rt0hiANfmjWIuf5jiLPfvVm/\n",
+       "AfmvbgNmB54zKrkheuD+Bjg11Wap7fpnBJ5TybelFk4E+iE+Fb+ptbHt+scg//nGqfJbgeMDz1mY\n",
+       "KN4UOZYX2q7fSWHhuNdt198ZOBc4MypbbLv+5wPPeTb6PiJqe5ft+ichx3WXRN8rbdc/OfCcrGis\n",
+       "R4ChiHKSlSn2f4BzkOvitMRvCKJ9DEzU9TPafwGZlkkyBvExSrKUrtdnmoOBycA5tus/iCyat3li\n",
+       "u7Zd/0rk2ihS1mzXPwT4E3LulaLTKAiGLL6EaMlJbtBat91pphIjFw289t9DVh4N7Jva9EKnWnpJ\n",
+       "G0RqBXcjCa08YCqy/PJE4L8A33b9HQPPeTNR/0bgvujzGchoywPSq5U+nd6R7fp7IDfRjYDrEE99\n",
+       "DeyHrPb5lO364xI36zTb2q4/AUnt/SSyLHQHMvJZklQOIhYChyCLid2FWBoGIQrDfwGnAP8Gskzd\n",
+       "VvSbBgPvIMdpJjLHuxdikXgg1ewa4Jbo84+BHRAFI/3gT9/QQZa+/iIy9zwccVQrSeA5nbbrX4s8\n",
+       "cI6htIIQK7xdFJLIAvEEYjmYBlyP/E4LeXj92Xb94YHnnFtOjhrYJ3q/vtbpE9v1fwqcjYxUL0GO\n",
+       "51bI//g1YIzt+mNTSgJIivfNEIXgBOThfx0ySv8Nct7vgzgfj0+1HQf8E5iPKM/vI+vLHA9cZbs+\n",
+       "JZSEevgDBZ++3yIKzgVI1FeSrCnD6ci0zebAJxCfjmoZjxzXPPBL5By0gW8jCt3sqHwtkYL1N0RB\n",
+       "/R2ymOG2yHE5CLFAHAu8ahQEQxbfyijrDdML3HTTkWvUBRfsb88bPb6TzjEK+oHKL184YHL+Jmdl\n",
+       "u+XrJsYBhwaec0dcYLu+hzw0dkcu/AvjbUmLgu36DqIgPB54zuQq9nURMgI8LjnyBibZrj8z2s/l\n",
+       "tuvvVcJJbWvkXDoi8JzbKu0s8JxFtut/IqXgAPzOdv0/IiPnb5KhICAjpMGIEjAhPV1iu35HWsbA\n",
+       "c25ObD8ZURAeqibENBqpTYnark8FBSHiakRBOMx2/cHpB29kSv4KooSlLRYnIcrBHcBXk7/Fdv0b\n",
+       "gReAM23Xvz7wnJlVyFIJK3qfXUsj2/U/jiiiq4B9ktEytuv/Fhlpfx2xEnw31XxHYLfAc6bbrv8k\n",
+       "cny/Bnwz8Jy/2q6/DTLd9F8Zu94ceXAeEHhOvM7MNbbrT0UU4vNs15+c2FY3gedcm/hNP0EUhDvL\n",
+       "KMrJtkuIFPboWNWiIOSAO4HDE7/Dj67FSxEn21+m2pyOWDpuCDxn7fG2Xf8e4F1EIVsceE5oohgM\n",
+       "XVBKjURuSEke11qXMhv3OPR553VO9Sb407yJZwTexO8FnnNV/qYj11XlAOCfSeUA1s4D/y36mp7f\n",
+       "rAvb9fdGLDMzU8pBzMXIg2wsMhLKQiFhgxWVg5gM5SDm+uh9VHqD7fr7IlaNFcAJWb4UPcHLPvCc\n",
+       "2YgVZn3gyIwq30AsQg8lQ+aiefUfR1/PzlB08sD9Udusfmsi2t+Q6GutjspnIE6L16dDaSN/irMR\n",
+       "p8dTbddPOxK/nwgxTZr8747e30SsEkNL7PvXGQrAVYgvwggK/gK9mXMyfuON0fvWkY9Dkp2i97uT\n",
+       "hYHnLKNgURsDxknRUMz5FJ8XP22DHIbqSc9pxsSOW8ObtJ89ovdXbNcvpQC8j4zcdiTbnAoy4q2b\n",
+       "6Ia3CYV5/Y0zqsXOf4/WEYveaq5GQuOOQaZekhydqJNkW2BLZF2UzhL/R+xE2XAIa+A52nb9lUho\n",
+       "Y63hd7GD5d1ZGwPPmW27/iuIUrkLXc/n9xP13rZd/yNgVezoF8n1NjAyyyKETGGl97fGdv1/IlaL\n",
+       "3h7e+06WM2PgOQtt11+GTMcNo6vVJ1aWsyK+4nvFQjAKgiGBUmoshfnOmGe11vdl1Tf0GOaUKI9v\n",
+       "lqrE9lqJb6b/Hb3KsU2Zba/VslPb9bdDfA0ORLz0N62iWWxVqMkc3iZuRuawP2u7/g6JKI9RSCTR\n",
+       "YoodhOP/YgNKK2Ix2zZJzjnINMN2NbaL/4uiaIUE/0EUhB3pqiCkMwl2IscjXZZFJ/B2iW1xRtWR\n",
+       "ZWTqDcwps63U9f8Q0TSN7fp/iK0PtuvviPjmrCHyR1qrICilNkTmHjZDLsDke/JzOtwnzY1KqXcR\n",
+       "R4cFiBab9XlRT87I19dQSo1GNPz0tJOxHvR8mhrOVobB0XuAOBiWo1zmwaqdXW3X3x+4BzGVv4SM\n",
+       "pN9AnPEg21McxMIArTs2dRN4zoe26/8NOA6xGJwfbYqV9b8GnrM81Sz+Lz5A0qOXo2y4Ww3MoT4F\n",
+       "IY4+KTfNF58TaXN4VthstVNDitLKcdxvOjKmEj0tv0M953fs87E3Eul0B2JliBflOzfwnFcA+iul\n",
+       "5iEmwQFNEBaK569L0amUWggcqrXO8gg2FKHG2CdW4Uem9XvBlUflu7RUaiByU3lPa92ZKN8cSav8\n",
+       "fUQBTHKr1rrqueIsxp18/eg1azrLjSYB6NfRsY3G6Is9nDjDYxh4zundvbMotvtm5N50duA5P09t\n",
+       "T0faJIkfirU+zNrF1YiC4FBQECZE73/JqB//F+u14r+ImIVEOB1iu/6ZNfhwzEamp7YuU2e7RN1m\n",
+       "oZBnW5YVIfZ1qNWfotw51yuIph++hET0bAkcikwpTAEuCjxnSly3PzIP0a8NcnYgD6SBlSoaIhQX\n",
+       "V2UtVup24LBU6S7IyG+NUuodZP52awojrTSvIjeshlij9XdQKh2jXYRRDtpGfOCruQfEpmzbdn0V\n",
+       "dP9iPLsgjnEryI67Lzd/PCt6/5Tt+v3LJXAqQ/z7ut2ZO/Ccx23XfxUYZbt+7D8xCngl8Jwsa80s\n",
+       "ZBS8ke36O7cg4ybA5UgegJ0QE/XN5auvZRaiIMQRF12wXX8TCv9ls6eERpOtIMR+EXNS5YsRh8dS\n",
+       "To/V+CzUck21i6uR5++4wHNeKFXJRDH0PfoR5fqmtHKwDDhCa73O5JA3lCSeF04v6Z3FPRTMzBO7\n",
+       "S6AE8Q12PbomgYn5Xpm29yMPhu2RUK96iKMn9q6zfa38JXo/NHoly7oQeM5K4Iro60+jKINuJVJC\n",
+       "Yu/439uuX805A4VkWyfbrp+V/MdFnOmeCmpfFKsSRYMc2/U/DeyG3OfSjpOx5WmfVHmcuXFcFfus\n",
+       "5ZpqObbrb45EtswqpxyAcVI0FDMbOFxrXeT9a+heopvnEArzolvashT0wmbEapdgGpIU5XDb9R9F\n",
+       "YqrXQyyL8wPPeTeuGHjOMtv1T0VuqldH6W//jigNmyHOcAcBgwPPcZog20xkRLcJ8DPb9S9CRqM7\n",
+       "I7kDvoDE1hfdxwLPWWy7/plI7oCLbNffHXm4zUQeRtsjGRP/EXhOKSfcABkpj49i5+9G/putgHmB\n",
+       "5yxIN4iSF21C14V6Rtiu/yYSW15uHv4a4P8oKAedlPcvOAv4KmItfCTKKfAS8v8NR1ILHwnsl5GA\n",
+       "qF7ORdYaGA48HGWyfBqYgViDRwCfQR72PkDgOU9E2TvHI4m0TgeeRczb30DyH2iKcyA0ymrgWNv1\n",
+       "FyDK1NvIQ3tStN3LCH+9HUl29UPb9echFo8BUbtLEKfJtJ9EmgA59ifbrj8bCR3cGDlvZqdTLcPa\n",
+       "9NCbUMhs2GFLKvPFSAKxZl7/CxEL8pgoA+QMxD+kE3HenAHcHnjOGmNB6Dt8iGjHWSFKK4HHkcQr\n",
+       "OxvloLXYrr+77fqrEIejNyiE6P0WccZbabv+lFLtG+Ry5AY/BHkYfRDtR9M79QAAA3FJREFUcwYS\n",
+       "NdCFwHPuQR6a7wHfAR5GMhk+i9xcT6G6KIOKBJ6zFBn9r0GUmBlIWN9ziHf/5yjO/phsfy2yqt4i\n",
+       "xOJxF3INTI9k/Q7ZoV4xv0PC5LZCci4sQm6g08kYHdquvxy5lt4DwsSmF5EENCts1//Idv3M9LbR\n",
+       "egJTkEx4NvBA1joFifqLIjkeR6wcfwdeQfIFTEEcjHNU79RXkShvw95Ixs5+yOj/KuSh+ATiAHcq\n",
+       "xb4fxwOXRfJMQc6zlxGF6B3g4MBznmmWnBFzEUfP0xDFcCGiAG+JHKushESXIdanjRBF4l3EInAj\n",
+       "8vuOqWK/5yNRGaOQFNkfIhkOX6CQgwAA2/W3jkI3V0T7ejjatAFyXb2PXP/LbVnroWGi6bbzo697\n",
+       "IlaWk5Br93wkk+jztusP7o94Lna7eaoMZU0cVXIAped7eqGZfP2ZqmPFl+ptrVf3n19UpvVMYLRS\n",
+       "agBywxuEjLwWAe9qrTMXV2mUzs7OP/Xrp+6qt33Hmn5Zue3XNeZTOVoky5nqKiQkrNT883Qk3WvJ\n",
+       "sMLAc1bbrv9Z5AH6KWRkOB+5wRWlWo7a3Ga7/mOIomAho/GFyI30YeDREru7ELlOq07TG3jONbbr\n",
+       "T0Nu9KOQm+i/gFsDz3nTdv2fI2FbpdpfHnlpH4LcnHdAlIz5yLErqXgFnvOR7fo28lDYE7lu3kKO\n",
+       "TdZ9K52xrhTl7knnUVB6SqVeTsr4apQU6lDEbG4hCsFbROsRBE1ebjrwnNB2/XGIGf5gRBkYhPyv\n",
+       "7yDpjR9MtVkOnGK7/vWIgrFrVPcF4O8ZKbaXIuduWkH6KfL/JbkEsWClfWK2CDzHt10/jzhXjkGO\n",
+       "yzNIZEiRD00ga3ocaLv+kUh2xo8hSuVURKmIUyiXVGYCWVzKQlJD7xrJNg85b9LX8RLgF6X6SpFU\n",
+       "9Cpe28gaJgORqEEAbNffDLlvHIQoAndR8NEYilwjExD/nwuUiTQ0GAwGw7qC7fqjEUvKqsBzmhWd\n",
+       "t05gu/5pyNoifw48J9N5PForxQeeNFMMBoPBYDD0DWL/llvK1In9jt4zCoLBYDAYDH2DePo5MwrJ\n",
+       "dv0hFPwTnjBRDAaDwWAw9A3+hPgOHRPl25iK+FhsiuR4OARx0Lwf+J1REAwGg8Fg6AMEnvNklL78\n",
+       "HMRRca/E5hVINNIVwI2B56z6/3ExLRI31pXNAAAAAElFTkSuQmCC\n"
+      ],
+      "extra": "yes",
+      "text/plain": [
+       "<IPython.core.display.Image at 0x111275490>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "extra": "yes",
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import Image\n",
+    "Image(\"http://ipython.org/_static/IPy_header.png\")"
+   ]
+  },
+  {
+   "cell_type": "future cell",
+   "metadata": {},
+   "key": "value"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 99,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "hello\n"
+     ]
+    },
+    {
+     "output_type": "future output",
+     "some key": [
+      "some data"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "hello again\n"
+     ]
+    }
+   ],
+   "source": [
+    "future_output()"
+   ]
+  }
+ ],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 99
+}

venv/Lib/site-packages/nbformat/tests/test_api.py

@@ -0,0 +1,66 @@
+"""Test the APIs at the top-level of nbformat"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import json
+import os
+import pathlib
+import sys
+import unittest
+
+from .base import TestsBase
+
+from ipython_genutils.tempdir import TemporaryDirectory
+from ..reader import get_version
+from nbformat import read, current_nbformat, writes, write
+
+
+class TestAPI(TestsBase):
+
+    def test_read(self):
+        """Can older notebooks be opened and automatically converted to the current 
+        nbformat?"""
+
+        # Open a version 2 notebook.
+        with self.fopen(u'test2.ipynb', 'r') as f:
+            nb = read(f, as_version=current_nbformat)
+
+        # Check that the notebook was upgraded to the latest version automatically.
+        (major, minor) = get_version(nb)
+        self.assertEqual(major, current_nbformat)
+
+    def test_write_downgrade_2(self):
+        """dowgrade a v3 notebook to v2"""
+        # Open a version 3 notebook.
+        with self.fopen(u'test3.ipynb', 'r') as f:
+            nb = read(f, as_version=3)
+
+        jsons = writes(nb, version=2)
+        nb2 = json.loads(jsons)
+        (major, minor) = get_version(nb2)
+        self.assertEqual(major, 2)
+
+    def test_read_write_path(self):
+        """read() and write() take filesystem paths"""
+        path = os.path.join(self._get_files_path(), u'test4.ipynb')
+        nb = read(path, as_version=4)
+
+        with TemporaryDirectory() as td:
+            dest = os.path.join(td, 'echidna.ipynb')
+            write(nb, dest)
+            assert os.path.isfile(dest)
+
+    @unittest.skipIf(
+        sys.version_info < (3, 6, 0),
+        "python versions 3.5 and lower don't support opening pathlib.Path objects"
+    )
+    def test_read_write_pathlib_object(self):
+        """read() and write() take path-like objects such as pathlib objects"""
+        path = pathlib.Path(self._get_files_path()) / u'test4.ipynb'
+        nb = read(path, as_version=4)
+
+        with TemporaryDirectory() as td:
+            dest = pathlib.Path(td) / 'echidna.ipynb'
+            write(nb, dest)
+            assert os.path.isfile(dest)

venv/Lib/site-packages/nbformat/tests/test_convert.py

@@ -0,0 +1,70 @@
+"""Tests for nbformat.convert"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+from .base import TestsBase
+
+from ..converter import convert
+from ..reader import read, get_version
+from ..validator import isvalid, validate
+from .. import current_nbformat
+
+
+class TestConvert(TestsBase):
+
+    def test_downgrade_3_2(self):
+        """Do notebook downgrades work?"""
+
+        # Open a version 3 notebook and attempt to downgrade it to version 2.
+        with self.fopen(u'test3.ipynb', u'r') as f:
+            nb = read(f)
+        nb = convert(nb, 2)
+
+        # Check if downgrade was successful.
+        (major, minor) = get_version(nb)
+        self.assertEqual(major, 2)
+
+
+    def test_upgrade_2_3(self):
+        """Do notebook upgrades work?"""
+
+        # Open a version 2 notebook and attempt to upgrade it to version 3.
+        with self.fopen(u'test2.ipynb', u'r') as f:
+            nb = read(f)
+        nb = convert(nb, 3)
+
+        # Check if upgrade was successful.
+        (major, minor) = get_version(nb)
+        self.assertEqual(major, 3)
+
+
+    def test_upgrade_downgrade_4_3_4(self):
+        """Test that a v4 notebook downgraded to v3 and then upgraded to v4
+        passes validation tests"""
+        with self.fopen(u'test4.ipynb', u'r') as f:
+            nb = read(f)
+        validate(nb)
+        nb = convert(nb, 3)
+        validate(nb)
+        nb = convert(nb, 4)
+        self.assertEqual(isvalid(nb), True)
+
+
+    def test_open_current(self):
+        """Can an old notebook be opened and converted to the current version
+        while remembering the original version of the notebook?"""
+
+        # Open a version 2 notebook and attempt to upgrade it to the current version
+        # while remembering it's version information.
+        with self.fopen(u'test2.ipynb', u'r') as f:
+            nb = read(f)
+        (original_major, original_minor) = get_version(nb)
+        nb = convert(nb, current_nbformat)
+
+        # Check if upgrade was successful.
+        (major, minor) = get_version(nb)
+        self.assertEqual(major, current_nbformat)
+
+        # Check if the original major revision was remembered.
+        self.assertEqual(original_major, 2)

venv/Lib/site-packages/nbformat/tests/test_nbformat.py

@@ -0,0 +1,42 @@
+import pytest
+
+from nbformat import read
+
+
+def test_read_invalid_iowrapper(tmpdir):
+    ipynb_filepath = tmpdir.join("empty.ipynb")
+    ipynb_filepath.write("{}")
+
+    with pytest.raises(AttributeError) as excinfo:
+        with ipynb_filepath.open() as fp:
+            read(fp, as_version=4)
+    assert "cells" in str(excinfo.value)
+
+
+def test_read_invalid_filepath(tmpdir):
+    ipynb_filepath = tmpdir.join("empty.ipynb")
+    ipynb_filepath.write("{}")
+
+    with pytest.raises(AttributeError) as excinfo:
+        read(str(ipynb_filepath), as_version=4)
+    assert "cells" in str(excinfo.value)
+
+
+def test_read_invalid_pathlikeobj(tmpdir):
+    ipynb_filepath = tmpdir.join("empty.ipynb")
+    ipynb_filepath.write("{}")
+
+    with pytest.raises(AttributeError) as excinfo:
+        read(ipynb_filepath, as_version=4)
+    assert "cells" in str(excinfo.value)
+
+
+def test_read_invalid_str(tmpdir):
+    with pytest.raises(OSError) as excinfo:
+        read("not_exist_path", as_version=4)
+    assert "No such file or directory" in str(excinfo.value)
+
+
+def test_read_invalid_type(tmpdir):
+    with pytest.raises(OSError) as excinfo:
+        read(123, as_version=4)

venv/Lib/site-packages/nbformat/tests/test_reader.py

@@ -0,0 +1,38 @@
+"""
+Contains tests class for reader.py
+"""
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2013  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 .base import TestsBase
+
+from ..reader import read, get_version
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+
+class TestReader(TestsBase):
+
+    def test_read(self):
+        """Can older notebooks be opened without modification?"""
+
+        # Open a version 3 notebook.  Make sure it is still version 3.
+        with self.fopen(u'test3.ipynb', u'r') as f:
+            nb = read(f)
+        (major, minor) = get_version(nb)
+        self.assertEqual(major, 3)
+
+        # Open a version 2 notebook.  Make sure it is still version 2.
+        with self.fopen(u'test2.ipynb', u'r') as f:
+            nb = read(f)
+        (major, minor) = get_version(nb)
+        self.assertEqual(major, 2)

venv/Lib/site-packages/nbformat/tests/test_sign.py

@@ -0,0 +1,262 @@
+"""Test Notebook signing"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import codecs
+import copy
+import os
+import shutil
+from subprocess import Popen, PIPE
+import sys
+import time
+import tempfile
+import testpath
+import unittest
+
+from .base import TestsBase
+
+from traitlets.config import Config
+from nbformat import read, sign, write
+
+class TestNotary(TestsBase):
+    
+    def setUp(self):
+        self.data_dir = tempfile.mkdtemp()
+        self.notary = sign.NotebookNotary(
+            db_file=':memory:',
+            secret=b'secret',
+            data_dir=self.data_dir,
+        )
+        with self.fopen(u'test3.ipynb', u'r') as f:
+            self.nb = read(f, as_version=4)
+        with self.fopen(u'test3.ipynb', u'r') as f:
+            self.nb3 = read(f, as_version=3)
+    
+    def tearDown(self):
+        self.notary.store.close()
+        shutil.rmtree(self.data_dir)
+   
+    def test_invalid_db_file(self):
+        invalid_sql_file = os.path.join(self.data_dir, 'invalid_db_file.db')
+        with open(invalid_sql_file, 'w') as tempfile:
+            tempfile.write(u'[invalid data]')
+
+        invalid_notary = sign.NotebookNotary(
+            db_file=invalid_sql_file,
+            secret=b'secret',
+        )
+        invalid_notary.sign(self.nb)
+        invalid_notary.store.close()
+
+        testpath.assert_isfile(os.path.join(self.data_dir, invalid_sql_file))
+        testpath.assert_isfile(os.path.join(self.data_dir, invalid_sql_file + '.bak'))
+
+    
+    def test_algorithms(self):
+        last_sig = ''
+        for algo in sign.algorithms:
+            self.notary.algorithm = algo
+            sig = self.notary.compute_signature(self.nb)
+            self.assertNotEqual(last_sig, sig)
+            last_sig = sig
+    
+    def test_sign_same(self):
+        """Multiple signatures of the same notebook are the same"""
+        sig1 = self.notary.compute_signature(self.nb)
+        sig2 = self.notary.compute_signature(self.nb)
+        self.assertEqual(sig1, sig2)
+    
+    def test_change_secret(self):
+        """Changing the secret changes the signature"""
+        sig1 = self.notary.compute_signature(self.nb)
+        self.notary.secret = b'different'
+        sig2 = self.notary.compute_signature(self.nb)
+        self.assertNotEqual(sig1, sig2)
+    
+    def test_sign(self):
+        self.assertFalse(self.notary.check_signature(self.nb))
+        self.notary.sign(self.nb)
+        self.assertTrue(self.notary.check_signature(self.nb))
+    
+    def test_unsign(self):
+        self.notary.sign(self.nb)
+        self.assertTrue(self.notary.check_signature(self.nb))
+        self.notary.unsign(self.nb)
+        self.assertFalse(self.notary.check_signature(self.nb))
+        self.notary.unsign(self.nb)
+        self.assertFalse(self.notary.check_signature(self.nb))
+    
+    def test_cull_db(self):
+        # this test has various sleeps of 2ms
+        # to ensure low resolution timestamps compare as expected
+        dt = 2e-3
+        nbs = [
+            copy.deepcopy(self.nb) for i in range(10)
+        ]
+        for row in self.notary.store.db.execute("SELECT * FROM nbsignatures"):
+            print(row)
+        self.notary.store.cache_size = 8
+        for i, nb in enumerate(nbs[:8]):
+            nb.metadata.dirty = i
+            self.notary.sign(nb)
+        
+        for i, nb in enumerate(nbs[:8]):
+            time.sleep(dt)
+            self.assertTrue(self.notary.check_signature(nb), 'nb %i is trusted' % i)
+        
+        # signing the 9th triggers culling of first 3
+        # (75% of 8 = 6, 9 - 6 = 3 culled)
+        self.notary.sign(nbs[8])
+        self.assertFalse(self.notary.check_signature(nbs[0]))
+        self.assertFalse(self.notary.check_signature(nbs[1]))
+        self.assertFalse(self.notary.check_signature(nbs[2]))
+        self.assertTrue(self.notary.check_signature(nbs[3]))
+        # checking nb3 should keep it from being culled:
+        self.notary.sign(nbs[0])
+        self.notary.sign(nbs[1])
+        self.notary.sign(nbs[2])
+        self.assertTrue(self.notary.check_signature(nbs[3]))
+        self.assertFalse(self.notary.check_signature(nbs[4]))
+    
+    def test_check_signature(self):
+        nb = self.nb
+        md = nb.metadata
+        notary = self.notary
+        check_signature = notary.check_signature
+        # no signature:
+        md.pop('signature', None)
+        self.assertFalse(check_signature(nb))
+        # hash only, no algo
+        md.signature = notary.compute_signature(nb)
+        self.assertFalse(check_signature(nb))
+        # proper signature, algo mismatch
+        notary.algorithm = 'sha224'
+        notary.sign(nb)
+        notary.algorithm = 'sha256'
+        self.assertFalse(check_signature(nb))
+        # check correctly signed notebook
+        notary.sign(nb)
+        self.assertTrue(check_signature(nb))
+    
+    def test_mark_cells_untrusted(self):
+        cells = self.nb.cells
+        self.notary.mark_cells(self.nb, False)
+        for cell in cells:
+            self.assertNotIn('trusted', cell)
+            if cell.cell_type == 'code':
+                self.assertIn('trusted', cell.metadata)
+                self.assertFalse(cell.metadata.trusted)
+            else:
+                self.assertNotIn('trusted', cell.metadata)
+    
+    def test_mark_cells_trusted(self):
+        cells = self.nb.cells
+        self.notary.mark_cells(self.nb, True)
+        for cell in cells:
+            self.assertNotIn('trusted', cell)
+            if cell.cell_type == 'code':
+                self.assertIn('trusted', cell.metadata)
+                self.assertTrue(cell.metadata.trusted)
+            else:
+                self.assertNotIn('trusted', cell.metadata)
+    
+    def test_check_cells(self):
+        nb = self.nb
+        self.notary.mark_cells(nb, True)
+        self.assertTrue(self.notary.check_cells(nb))
+        for cell in nb.cells:
+            self.assertNotIn('trusted', cell)
+        self.notary.mark_cells(nb, False)
+        self.assertFalse(self.notary.check_cells(nb))
+        for cell in nb.cells:
+            self.assertNotIn('trusted', cell)
+    
+    def test_trust_no_output(self):
+        nb = self.nb
+        self.notary.mark_cells(nb, False)
+        for cell in nb.cells:
+            if cell.cell_type == 'code':
+                cell.outputs = []
+        self.assertTrue(self.notary.check_cells(nb))
+    
+    def test_mark_cells_untrusted_v3(self):
+        nb = self.nb3
+        cells = nb.worksheets[0].cells
+        self.notary.mark_cells(nb, False)
+        for cell in cells:
+            self.assertNotIn('trusted', cell)
+            if cell.cell_type == 'code':
+                self.assertIn('trusted', cell.metadata)
+                self.assertFalse(cell.metadata.trusted)
+            else:
+                self.assertNotIn('trusted', cell.metadata)
+    
+    def test_mark_cells_trusted_v3(self):
+        nb = self.nb3
+        cells = nb.worksheets[0].cells
+        self.notary.mark_cells(nb, True)
+        for cell in cells:
+            self.assertNotIn('trusted', cell)
+            if cell.cell_type == 'code':
+                self.assertIn('trusted', cell.metadata)
+                self.assertTrue(cell.metadata.trusted)
+            else:
+                self.assertNotIn('trusted', cell.metadata)
+    
+    def test_check_cells_v3(self):
+        nb = self.nb3
+        cells = nb.worksheets[0].cells
+        self.notary.mark_cells(nb, True)
+        self.assertTrue(self.notary.check_cells(nb))
+        for cell in cells:
+            self.assertNotIn('trusted', cell)
+        self.notary.mark_cells(nb, False)
+        self.assertFalse(self.notary.check_cells(nb))
+        for cell in cells:
+            self.assertNotIn('trusted', cell)
+    
+    def test_sign_stdin(self):
+        def sign_stdin(nb):
+            env = os.environ.copy()
+            env["JUPYTER_DATA_DIR"] = self.data_dir
+            p = Popen([sys.executable, '-m', 'nbformat.sign', '--log-level=0'], stdin=PIPE, stdout=PIPE,
+                env=env,
+            )
+            write(nb, codecs.getwriter("utf8")(p.stdin))
+            p.stdin.close()
+            p.wait()
+            self.assertEqual(p.returncode, 0)
+            out = p.stdout.read().decode('utf8', 'replace')
+            p.stdout.close()
+            return out
+
+        out = sign_stdin(self.nb3)
+        self.assertIn('Signing notebook: <stdin>', out)
+        out = sign_stdin(self.nb3)
+        self.assertIn('already signed: <stdin>', out)
+
+def test_config_store():
+    store = sign.MemorySignatureStore()
+
+    c = Config()
+    c.NotebookNotary.store_factory = lambda: store
+    notary = sign.NotebookNotary(config=c)
+    assert notary.store is store
+
+class SignatureStoreTests(unittest.TestCase):
+    def setUp(self):
+        self.store = sign.MemorySignatureStore()
+
+    def test_basics(self):
+        digest = '0123457689abcef'
+        algo = 'fake_sha'
+        assert not self.store.check_signature(digest, algo)
+        self.store.store_signature(digest, algo)
+        assert self.store.check_signature(digest, algo)
+        self.store.remove_signature(digest, algo)
+        assert not self.store.check_signature(digest, algo)
+
+class SQLiteSignatureStoreTests(SignatureStoreTests):
+    def setUp(self):
+        self.store = sign.SQLiteSignatureStore(':memory:')

venv/Lib/site-packages/nbformat/tests/test_validator.py

@@ -0,0 +1,199 @@
+"""Test nbformat.validator"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import os
+import re
+
+from .base import TestsBase
+from jsonschema import ValidationError
+from nbformat import read
+from ..validator import isvalid, validate, iter_validate
+from ..json_compat import VALIDATORS
+
+import pytest
+
+
+# Fixtures
+@pytest.fixture(autouse=True)
+def clean_env_before_and_after_tests():
+    """Fixture to clean up env variables before and after tests."""
+    os.environ.pop("NBFORMAT_VALIDATOR", None)
+    yield
+    os.environ.pop("NBFORMAT_VALIDATOR", None)
+
+
+# Helpers
+def set_validator(validator_name):
+    os.environ["NBFORMAT_VALIDATOR"] = validator_name
+
+
+@pytest.mark.parametrize("validator_name", VALIDATORS)
+def test_nb2(validator_name):
+    """Test that a v2 notebook converted to current passes validation"""
+    set_validator(validator_name)
+    with TestsBase.fopen(u'test2.ipynb', u'r') as f:
+        nb = read(f, as_version=4)
+    validate(nb)
+    assert isvalid(nb) == True
+
+
+@pytest.mark.parametrize("validator_name", VALIDATORS)
+def test_nb3(validator_name):
+    """Test that a v3 notebook passes validation"""
+    set_validator(validator_name)
+    with TestsBase.fopen(u'test3.ipynb', u'r') as f:
+        nb = read(f, as_version=4)
+    validate(nb)
+    assert isvalid(nb) == True
+
+
+@pytest.mark.parametrize("validator_name", VALIDATORS)
+def test_nb4(validator_name):
+    """Test that a v4 notebook passes validation"""
+    set_validator(validator_name)
+    with TestsBase.fopen(u'test4.ipynb', u'r') as f:
+        nb = read(f, as_version=4)
+    validate(nb)
+    assert isvalid(nb) == True
+
+
+@pytest.mark.parametrize("validator_name", VALIDATORS)
+def test_nb4_document_info(validator_name):
+    """Test that a notebook with document_info passes validation"""
+    set_validator(validator_name)
+    with TestsBase.fopen(u'test4docinfo.ipynb', u'r') as f:
+        nb = read(f, as_version=4)
+    validate(nb)
+    assert isvalid(nb)
+
+
+@pytest.mark.parametrize("validator_name", VALIDATORS)
+def test_nb4custom(validator_name):
+    """Test that a notebook with a custom JSON mimetype passes validation"""
+    set_validator(validator_name)
+    with TestsBase.fopen(u'test4custom.ipynb', u'r') as f:
+        nb = read(f, as_version=4)
+    validate(nb)
+    assert isvalid(nb)
+
+
+@pytest.mark.parametrize("validator_name", VALIDATORS)
+def test_nb4jupyter_metadata(validator_name):
+    """Test that a notebook with a jupyter metadata passes validation"""
+    set_validator(validator_name)
+    with TestsBase.fopen(u'test4jupyter_metadata.ipynb', u'r') as f:
+        nb = read(f, as_version=4)
+    validate(nb)
+    assert isvalid(nb)
+
+
+@pytest.mark.parametrize("validator_name", VALIDATORS)
+def test_nb4jupyter_metadata_timings(validator_name):
+    """Tests that a notebook with "timing" in metadata passes validation"""
+    set_validator(validator_name)
+    with TestsBase.fopen(u'test4jupyter_metadata_timings.ipynb', u'r') as f:
+        nb = read(f, as_version=4)
+    validate(nb)
+    assert isvalid(nb)
+
+
+@pytest.mark.parametrize("validator_name", VALIDATORS)
+def test_invalid(validator_name):
+    """Test than an invalid notebook does not pass validation"""
+    set_validator(validator_name)
+    # this notebook has a few different errors:
+    # - one cell is missing its source
+    # - invalid cell type
+    # - invalid output_type
+    with TestsBase.fopen(u'invalid.ipynb', u'r') as f:
+        nb = read(f, as_version=4)
+    with pytest.raises(ValidationError):
+        validate(nb)
+    assert not isvalid(nb)
+
+
+@pytest.mark.parametrize("validator_name", VALIDATORS)
+def test_validate_empty(validator_name):
+    """Test that an empty notebook (invalid) fails validation"""
+    set_validator(validator_name)
+    with pytest.raises(ValidationError) as e:
+        validate({})
+
+
+@pytest.mark.parametrize("validator_name", VALIDATORS)
+def test_future(validator_name):
+    """Test that a notebook from the future with extra keys passes validation"""
+    set_validator(validator_name)
+    with TestsBase.fopen(u'test4plus.ipynb', u'r') as f:
+        nb = read(f, as_version=4)
+    with pytest.raises(ValidationError):
+        validate(nb, version=4, version_minor=3)
+
+    assert not isvalid(nb, version=4, version_minor=3)
+    assert isvalid(nb)
+
+
+# This is only a valid test for the default validator, jsonschema
+@pytest.mark.parametrize("validator_name", ["jsonschema"])
+def test_validation_error(validator_name):
+    set_validator(validator_name)
+    with TestsBase.fopen(u'invalid.ipynb', u'r') as f:
+        nb = read(f, as_version=4)
+    with pytest.raises(ValidationError) as exception_info:
+        validate(nb)
+
+    s = str(exception_info.value)
+    assert re.compile(r"validating .required. in markdown_cell").search(s)
+    assert re.compile(r"source.* is a required property").search(s)
+    assert re.compile(r"On instance\[u?['\"].*cells['\"]\]\[0\]").search(s)
+    assert len(s.splitlines()) < 10
+
+
+# This is only a valid test for the default validator, jsonschema
+@pytest.mark.parametrize("validator_name", ["jsonschema"])
+def test_iter_validation_error(validator_name):
+    set_validator(validator_name)
+    with TestsBase.fopen(u'invalid.ipynb', u'r') as f:
+        nb = read(f, as_version=4)
+
+    errors = list(iter_validate(nb))
+    assert len(errors) == 3
+    assert {e.ref for e in errors} == {'markdown_cell', 'heading_cell', 'bad stream'}
+
+
+@pytest.mark.parametrize("validator_name", VALIDATORS)
+def test_iter_validation_empty(validator_name):
+    """Test that an empty notebook (invalid) fails validation via iter_validate"""
+    set_validator(validator_name)
+    errors = list(iter_validate({}))
+    assert len(errors) == 1
+    assert type(errors[0]) == ValidationError
+
+
+@pytest.mark.parametrize("validator_name", VALIDATORS)
+def test_validation_no_version(validator_name):
+    """Test that an invalid notebook with no version fails validation"""
+    set_validator(validator_name)
+    with pytest.raises(ValidationError) as e:
+        validate({'invalid': 'notebook'})
+
+
+def test_invalid_validator_raises_value_error():
+    """Test that an invalid notebook with no version fails validation"""
+    set_validator("foobar")
+    with pytest.raises(ValueError):
+        with TestsBase.fopen(u'test2.ipynb', u'r') as f:
+            nb = read(f, as_version=4)
+
+
+def test_invalid_validator_raises_value_error_after_read():
+    """Test that an invalid notebook with no version fails validation"""
+    set_validator("jsonschema")
+    with TestsBase.fopen(u'test2.ipynb', u'r') as f:
+        nb = read(f, as_version=4)
+
+    set_validator("foobar")
+    with pytest.raises(ValueError):
+        validate(nb)

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

@@ -0,0 +1,23 @@
+"""The main module for the v1 notebook format."""
+
+#-----------------------------------------------------------------------------
+#  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 (
+    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 upgrade

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

@@ -0,0 +1,16 @@
+"""Convert notebook to the v1 format."""
+
+#-----------------------------------------------------------------------------
+#  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.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+
+def upgrade(nb, orig_version=None):
+    raise ValueError('Cannot convert to v1 notebook format')
+

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

@@ -0,0 +1,72 @@
+"""The basic dict based 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 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_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 = str(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 = str(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
+

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

@@ -0,0 +1,53 @@
+"""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 .rwbase import NotebookReader, NotebookWriter
+from .nbbase import from_dict
+import json
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+
+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
+

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

@@ -0,0 +1,45 @@
+"""Base classes and function 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
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+
+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))
+
+
+

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

@@ -0,0 +1,29 @@
+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
+))
+

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

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

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

@@ -0,0 +1,41 @@
+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.assertEqual(cc.cell_type,'code')
+        self.assertEqual('code' not in cc, True)
+        self.assertEqual('prompt_number' not in cc, True)
+
+    def test_code_cell(self):
+        cc = new_code_cell(code='a=10', prompt_number=0)
+        self.assertEqual(cc.code, u'a=10')
+        self.assertEqual(cc.prompt_number, 0)
+
+    def test_empty_text_cell(self):
+        tc = new_text_cell()
+        self.assertEqual(tc.cell_type, 'text')
+        self.assertEqual('text' not in tc, True)
+
+    def test_text_cell(self):
+        tc = new_text_cell('hi')
+        self.assertEqual(tc.text, u'hi')
+
+
+class TestNotebook(TestCase):
+
+    def test_empty_notebook(self):
+        nb = new_notebook()
+        self.assertEqual(nb.cells, [])
+
+    def test_notebooke(self):
+        cells = [new_code_cell(),new_text_cell()]
+        nb = new_notebook(cells=cells)
+        self.assertEqual(nb.cells,cells)
+

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)
+

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

@@ -0,0 +1,70 @@
+"""The main API for the v3 notebook format.
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+__all__ = ['NotebookNode', 'new_code_cell', 'new_text_cell', 'new_notebook',
+           'new_output', 'new_worksheet', 'new_metadata', 'new_author',
+           'new_heading_cell', 'nbformat', 'nbformat_minor', 'nbformat_schema',
+           'reads_json', 'writes_json', 'read_json', 'write_json',
+           'to_notebook_json', 'reads_py', 'writes_py', 'read_py', 'write_py',
+           'to_notebook_py', 'downgrade', 'upgrade', 'parse_filename'
+        ]
+
+import os
+
+from .nbbase import (
+    NotebookNode,
+    new_code_cell, new_text_cell, new_notebook, new_output, new_worksheet,
+    new_metadata, new_author, new_heading_cell, nbformat, nbformat_minor,
+    nbformat_schema
+)
+
+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 .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
+
+
+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/v3/convert.py

@@ -0,0 +1,91 @@
+"""Code for converting notebooks to and from the v2 format."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+from .nbbase import (
+    new_code_cell, new_text_cell, new_worksheet, new_notebook, new_output,
+    nbformat, nbformat_minor
+)
+
+from nbformat import v2
+
+def _unbytes(obj):
+    """There should be no bytes objects in a notebook
+
+    v2 stores png/jpeg as b64 ascii bytes
+    """
+    if isinstance(obj, dict):
+        for k,v in obj.items():
+            obj[k] = _unbytes(v)
+    elif isinstance(obj, list):
+        for i,v in enumerate(obj):
+            obj[i] = _unbytes(v)
+    elif isinstance(obj, bytes):
+        # only valid bytes are b64-encoded ascii
+        obj = obj.decode('ascii')
+    return obj
+
+def upgrade(nb, from_version=2, from_minor=0):
+    """Convert a notebook to v3.
+
+    Parameters
+    ----------
+    nb : NotebookNode
+        The Python representation of the notebook to convert.
+    from_version : int
+        The original version of the notebook to convert.
+    from_minor : int
+        The original minor version of the notebook to convert (only relevant for v >= 3).
+    """
+    if from_version == 2:
+        # Mark the original nbformat so consumers know it has been converted.
+        nb.nbformat = nbformat
+        nb.nbformat_minor = nbformat_minor
+        
+        nb.orig_nbformat = 2
+        nb = _unbytes(nb)
+        for ws in nb['worksheets']:
+            for cell in ws['cells']:
+                cell.setdefault('metadata', {})
+        return nb
+    elif from_version == 3:
+        if from_minor != nbformat_minor:
+            nb.orig_nbformat_minor = from_minor
+        nb.nbformat_minor = nbformat_minor
+        return nb
+    else:
+        raise ValueError('Cannot convert a notebook directly from v%s to v3.  ' \
+                'Try using the nbformat.convert module.' % from_version)
+ 
+
+def heading_to_md(cell):
+    """turn heading cell into corresponding markdown"""
+    cell.cell_type = "markdown"
+    level = cell.pop('level', 1)
+    cell.source = '#'*level + ' ' + cell.source
+ 
+ 
+def raw_to_md(cell):
+    """let raw passthrough as markdown"""
+    cell.cell_type = "markdown"
+ 
+
+def downgrade(nb):
+    """Convert a v3 notebook to v2.
+
+    Parameters
+    ----------
+    nb : NotebookNode
+        The Python representation of the notebook to convert.
+    """
+    if nb.nbformat != 3:
+        return nb
+    nb.nbformat = 2
+    for ws in nb.worksheets:
+        for cell in ws.cells:
+            if cell.cell_type == 'heading':
+                heading_to_md(cell)
+            elif cell.cell_type == 'raw':
+                raw_to_md(cell)
+    return nb

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

@@ -0,0 +1,204 @@
+"""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.
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import pprint
+import uuid
+
+from ipython_genutils.ipstruct import Struct
+from ipython_genutils.py3compat import cast_unicode
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+
+# Change this when incrementing the nbformat version
+nbformat = 3
+nbformat_minor = 0
+nbformat_schema = {
+    (3, 0): 'nbformat.v3.schema.json'
+}
+
+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, 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,
+    ename=None, evalue=None, traceback=None, stream=None, metadata=None):
+    """Create a new output, to go in the ``cell.outputs`` list of a code cell.
+    """
+    output = NotebookNode()
+    output.output_type = str(output_type)
+
+    if metadata is None:
+        metadata = {}
+    if not isinstance(metadata, dict):
+        raise TypeError("metadata must be dict")
+
+
+    if output_type in {u'pyout', 'display_data'}:
+        output.metadata = metadata
+
+    if output_type != 'pyerr':
+        if output_text is not None:
+            output.text = cast_unicode(output_text)
+        if output_png is not None:
+            output.png = cast_unicode(output_png)
+        if output_jpeg is not None:
+            output.jpeg = cast_unicode(output_jpeg)
+        if output_html is not None:
+            output.html = cast_unicode(output_html)
+        if output_svg is not None:
+            output.svg = cast_unicode(output_svg)
+        if output_latex is not None:
+            output.latex = cast_unicode(output_latex)
+        if output_json is not None:
+            output.json = cast_unicode(output_json)
+        if output_javascript is not None:
+            output.javascript = cast_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 ename is not None:
+            output.ename = cast_unicode(ename)
+        if evalue is not None:
+            output.evalue = cast_unicode(evalue)
+        if traceback is not None:
+            output.traceback = [cast_unicode(frame) for frame in list(traceback)]
+
+    if output_type == u'stream':
+        output.stream = 'stdout' if stream is None else cast_unicode(stream)
+
+    return output
+
+
+def new_code_cell(input=None, prompt_number=None, outputs=None,
+    language=u'python', collapsed=False, metadata=None):
+    """Create a new code cell with input and output"""
+    cell = NotebookNode()
+    cell.cell_type = u'code'
+    if language is not None:
+        cell.language = cast_unicode(language)
+    if input is not None:
+        cell.input = cast_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)
+    cell.metadata = NotebookNode(metadata or {})
+
+    return cell
+
+def new_text_cell(cell_type, source=None, rendered=None, metadata=None):
+    """Create a new text cell."""
+    cell = NotebookNode()
+    # VERSIONHACK: plaintext -> raw
+    # handle never-released plaintext name for raw cells
+    if cell_type == 'plaintext':
+        cell_type = 'raw'
+    if source is not None:
+        cell.source = cast_unicode(source)
+    cell.metadata = NotebookNode(metadata or {})
+    cell.cell_type = cell_type
+    return cell
+
+
+def new_heading_cell(source=None, level=1, rendered=None, metadata=None):
+    """Create a new section cell with a given integer level."""
+    cell = NotebookNode()
+    cell.cell_type = u'heading'
+    if source is not None:
+        cell.source = cast_unicode(source)
+    cell.level = int(level)
+    cell.metadata = NotebookNode(metadata or {})
+    return cell
+
+
+def new_worksheet(name=None, cells=None, metadata=None):
+    """Create a worksheet by name with with a list of cells."""
+    ws = NotebookNode()
+    if cells is None:
+        ws.cells = []
+    else:
+        ws.cells = list(cells)
+    ws.metadata = NotebookNode(metadata or {})
+    return ws
+
+
+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
+    nb.nbformat_minor = nbformat_minor
+    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 = cast_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 = cast_unicode(name)
+    if authors is not None:
+        metadata.authors = list(authors)
+    if created is not None:
+        metadata.created = cast_unicode(created)
+    if modified is not None:
+        metadata.modified = cast_unicode(modified)
+    if license is not None:
+        metadata.license = cast_unicode(license)
+    if gistid is not None:
+        metadata.gistid = cast_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 = cast_unicode(name)
+    if email is not None:
+        author.email = cast_unicode(email)
+    if affiliation is not None:
+        author.affiliation = cast_unicode(affiliation)
+    if url is not None:
+        author.url = cast_unicode(url)
+    return author
+

venv/Lib/site-packages/nbformat/v3/nbformat.v3.schema.json

@@ -0,0 +1,367 @@
+{
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "IPython Notebook v3.0 JSON schema.",
+    "type": "object",
+    "additionalProperties": false,
+    "required": ["metadata", "nbformat_minor", "nbformat", "worksheets"],
+    "properties": {
+        "metadata": {
+            "description": "Notebook root-level metadata.",
+            "type": "object",
+            "additionalProperties": true,
+            "properties": {
+                "kernel_info": {
+                    "description": "Kernel information.",
+                    "type": "object",
+                    "required": ["name", "language"],
+                    "properties": {
+                        "name": {
+                            "description": "Name of the kernel specification.",
+                            "type": "string"
+                        },
+                        "language": {
+                            "description": "The programming language which this kernel runs.",
+                            "type": "string"
+                        },
+                        "codemirror_mode": {
+                            "description": "The codemirror mode to use for code in this language.",
+                            "type": "string"
+                        }
+                    }
+                },
+                "signature": {
+                    "description": "Hash of the notebook.",
+                    "type": "string"
+                }
+            }
+        },
+        "nbformat_minor": {
+            "description": "Notebook format (minor number). Incremented for backward compatible changes to the notebook format.",
+            "type": "integer",
+            "minimum": 0
+        },
+        "nbformat": {
+            "description": "Notebook format (major number). Incremented between backwards incompatible changes to the notebook format.",
+            "type": "integer",
+            "minimum": 3,
+            "maximum": 3
+        },
+        "orig_nbformat": {
+            "description": "Original notebook format (major number) before converting the notebook between versions.",
+            "type": "integer",
+            "minimum": 1
+        },
+        "orig_nbformat_minor": {
+            "description": "Original notebook format (minor number) before converting the notebook between versions.",
+            "type": "integer",
+            "minimum": 0
+        },
+        "worksheets" : {
+            "description": "Array of worksheets",
+            "type": "array",
+            "items": {"$ref": "#/definitions/worksheet"}
+        }
+    },
+
+    "definitions": {
+        "worksheet": {
+            "additionalProperties": false,
+            "required" : ["cells"],
+            "properties":{
+                "cells": {
+                    "description": "Array of cells of the current notebook.",
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "oneOf": [
+                            {"$ref": "#/definitions/raw_cell"},
+                            {"$ref": "#/definitions/markdown_cell"},
+                            {"$ref": "#/definitions/heading_cell"},
+                            {"$ref": "#/definitions/code_cell"}
+                        ]
+                    }
+                },
+                "metadata": {
+                    "type": "object",
+                    "description": "metadata of the current worksheet"
+                }
+            }
+        },
+        "raw_cell": {
+            "description": "Notebook raw nbconvert cell.",
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["cell_type", "source"],
+            "properties": {
+                "cell_type": {
+                    "description": "String identifying the type of cell.",
+                    "enum": ["raw"]
+                },
+                "metadata": {
+                    "description": "Cell-level metadata.",
+                    "type": "object",
+                    "additionalProperties": true,
+                    "properties": {
+                        "format": {
+                            "description": "Raw cell metadata format for nbconvert.",
+                            "type": "string"
+                        },
+                        "name": {"$ref": "#/definitions/misc/metadata_name"},
+                        "tags": {"$ref": "#/definitions/misc/metadata_tags"}
+                    }
+                },
+                "source": {"$ref": "#/definitions/misc/source"}
+            }
+        },
+
+        "markdown_cell": {
+            "description": "Notebook markdown cell.",
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["cell_type", "source"],
+            "properties": {
+                "cell_type": {
+                    "description": "String identifying the type of cell.",
+                    "enum": ["markdown", "html"]
+                },
+                "metadata": {
+                    "description": "Cell-level metadata.",
+                    "type": "object",
+                    "properties": {
+                        "name": {"$ref": "#/definitions/misc/metadata_name"},
+                        "tags": {"$ref": "#/definitions/misc/metadata_tags"}
+                    },
+                    "additionalProperties": true
+                },
+                "source": {"$ref": "#/definitions/misc/source"}
+            }
+        },
+
+        "heading_cell": {
+            "description": "Notebook heading cell.",
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["cell_type", "source", "level"],
+            "properties": {
+                "cell_type": {
+                    "description": "String identifying the type of cell.",
+                    "enum": ["heading"]
+                },
+                "metadata": {
+                    "description": "Cell-level metadata.",
+                    "type": "object",
+                    "additionalProperties": true
+                },
+                "source": {"$ref": "#/definitions/misc/source"},
+                "level": {
+                    "description": "Level of heading cells.",
+                    "type": "integer",
+                    "minimum": 1
+                }
+            }
+        },
+
+        "code_cell": {
+            "description": "Notebook code cell.",
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["cell_type", "input", "outputs", "language"],
+            "properties": {
+                "cell_type": {
+                    "description": "String identifying the type of cell.",
+                    "enum": ["code"]
+                },
+                "language": {
+                    "description": "The cell's language (always Python)",
+                    "type": "string"
+                },
+                "collapsed": {
+                    "description": "Whether the cell is collapsed/expanded.",
+                    "type": "boolean"
+                },
+                "metadata": {
+                    "description": "Cell-level metadata.",
+                    "type": "object",
+                    "additionalProperties": true
+                },
+                "input": {"$ref": "#/definitions/misc/source"},
+                "outputs": {
+                    "description": "Execution, display, or stream outputs.",
+                    "type": "array",
+                    "items": {"$ref": "#/definitions/output"}
+                },
+                "prompt_number": {
+                    "description": "The code cell's prompt number. Will be null if the cell has not been run.",
+                    "type": ["integer", "null"],
+                    "minimum": 0
+                }
+            }
+        },
+        "output": {
+            "type": "object",
+            "oneOf": [
+                {"$ref": "#/definitions/pyout"},
+                {"$ref": "#/definitions/display_data"},
+                {"$ref": "#/definitions/stream"},
+                {"$ref": "#/definitions/pyerr"}
+            ]
+        },
+        "pyout": {
+            "description": "Result of executing a code cell.",
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["output_type", "prompt_number"],
+            "properties": {
+                "output_type": {
+                    "description": "Type of cell output.",
+                    "enum": ["pyout"]
+                },
+                "prompt_number": {
+                    "description": "A result's prompt number.",
+                    "type": ["integer"],
+                    "minimum": 0
+                },
+                "text": {"$ref": "#/definitions/misc/multiline_string"},
+                "latex": {"$ref": "#/definitions/misc/multiline_string"},
+                "png": {"$ref": "#/definitions/misc/multiline_string"},
+                "jpeg": {"$ref": "#/definitions/misc/multiline_string"},
+                "svg": {"$ref": "#/definitions/misc/multiline_string"},
+                "html": {"$ref": "#/definitions/misc/multiline_string"},
+                "javascript": {"$ref": "#/definitions/misc/multiline_string"},
+                "json": {"$ref": "#/definitions/misc/multiline_string"},
+                "pdf": {"$ref": "#/definitions/misc/multiline_string"},
+                "metadata": {"$ref": "#/definitions/misc/output_metadata"}
+            },
+            "patternProperties": {
+                "^[a-zA-Z0-9]+/[a-zA-Z0-9\\-\\+\\.]+$": {
+                    "description": "mimetype output (e.g. text/plain), represented as either an array of strings or a string.",
+                    "$ref": "#/definitions/misc/multiline_string"
+                }
+            }
+        },
+
+        "display_data": {
+            "description": "Data displayed as a result of code cell execution.",
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["output_type"],
+            "properties": {
+                "output_type": {
+                    "description": "Type of cell output.",
+                    "enum": ["display_data"]
+                },
+                "text": {"$ref": "#/definitions/misc/multiline_string"},
+                "latex": {"$ref": "#/definitions/misc/multiline_string"},
+                "png": {"$ref": "#/definitions/misc/multiline_string"},
+                "jpeg": {"$ref": "#/definitions/misc/multiline_string"},
+                "svg": {"$ref": "#/definitions/misc/multiline_string"},
+                "html": {"$ref": "#/definitions/misc/multiline_string"},
+                "javascript": {"$ref": "#/definitions/misc/multiline_string"},
+                "json": {"$ref": "#/definitions/misc/multiline_string"},
+                "pdf": {"$ref": "#/definitions/misc/multiline_string"},
+                "metadata": {"$ref": "#/definitions/misc/output_metadata"}
+            },
+            "patternProperties": {
+                "[a-zA-Z0-9]+/[a-zA-Z0-9\\-\\+\\.]+$": {
+                    "description": "mimetype output (e.g. text/plain), represented as either an array of strings or a string.",
+                    "$ref": "#/definitions/misc/multiline_string"
+                }
+            }
+        },
+
+        "stream": {
+            "description": "Stream output from a code cell.",
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["output_type", "stream", "text"],
+            "properties": {
+                "output_type": {
+                    "description": "Type of cell output.",
+                    "enum": ["stream"]
+                },
+                "stream": {
+                    "description": "The stream type/destination.",
+                    "type": "string"
+                },
+                "text": {
+                    "description": "The stream's text output, represented as an array of strings.",
+                    "$ref": "#/definitions/misc/multiline_string"
+                }
+            }
+        },
+
+        "pyerr": {
+            "description": "Output of an error that occurred during code cell execution.",
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["output_type", "ename", "evalue", "traceback"],
+            "properties": {
+                "output_type": {
+                    "description": "Type of cell output.",
+                    "enum": ["pyerr"]
+                },
+                "ename": {
+                    "description": "The name of the error.",
+                    "type": "string"
+                },
+                "evalue": {
+                    "description": "The value, or message, of the error.",
+                    "type": "string"
+                },
+                "traceback": {
+                    "description": "The error's traceback, represented as an array of strings.",
+                    "type": "array",
+                    "items": {"type": "string"}
+                }
+            }
+        },
+
+        "misc": {
+            "metadata_name": {
+                "description": "The cell's name. If present, must be a non-empty string.",
+                "type": "string",
+                "pattern": "^.+$"
+            },
+            "metadata_tags": {
+                "description": "The cell's tags. Tags must be unique, and must not contain commas.",
+                "type": "array",
+                "uniqueItems": true,
+                "items": {
+                    "type": "string",
+                    "pattern": "^[^,]+$"
+                }
+            },
+            "source": {
+                "description": "Contents of the cell, represented as an array of lines.",
+                "$ref": "#/definitions/misc/multiline_string"
+            },
+            "prompt_number": {
+                "description": "The code cell's prompt number. Will be null if the cell has not been run.",
+                "type": ["integer", "null"],
+                "minimum": 0
+            },
+            "mimetype": {
+                "patternProperties": {
+                    "^[a-zA-Z0-9\\-\\+]+/[a-zA-Z0-9\\-\\+]+": {
+                        "description": "The cell's mimetype output (e.g. text/plain), represented as either an array of strings or a string.",
+                        "$ref": "#/definitions/misc/multiline_string"
+                    }
+                }
+            },
+            "output_metadata": {
+                "description": "Cell output metadata.",
+                "type": "object",
+                "additionalProperties": true
+            },
+            "multiline_string": {
+                "oneOf" : [
+                    {"type": "string"},
+                    {
+                        "type": "array",
+                        "items": {"type": "string"}
+                    }
+                ]
+            }
+        }
+    }
+}

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

@@ -0,0 +1,58 @@
+"""Read and write notebooks in JSON format."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import copy
+import json
+
+from .nbbase import from_dict
+from .rwbase import (
+    NotebookReader, NotebookWriter, restore_bytes, rejoin_lines, split_lines,
+    strip_transient,
+)
+
+
+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)
+        nb = strip_transient(nb)
+        return nb
+
+    def to_notebook(self, d, **kwargs):
+        return rejoin_lines(from_dict(d))
+
+
+class JSONWriter(NotebookWriter):
+
+    def writes(self, nb, **kwargs):
+        kwargs['cls'] = BytesEncoder
+        kwargs['indent'] = 1
+        kwargs['sort_keys'] = True
+        kwargs['separators'] = (',',': ')
+        nb = copy.deepcopy(nb)
+        nb = strip_transient(nb)
+        if kwargs.pop('split_lines', True):
+            nb = split_lines(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
+