Don't use nbformat.current in nbconvert

IPython/nbconvert/exporters/export.py

@@ -1,174 +1,174
 """Module containing single call export functions."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from functools import wraps
 
-from IPython.nbformat.current import NotebookNode
+from IPython.nbformat.v4 import NotebookNode
 from IPython.utils.decorators import undoc
 from IPython.utils.py3compat import string_types
 
 from .exporter import Exporter
 from .templateexporter import TemplateExporter
 from .html import HTMLExporter
 from .slides import SlidesExporter
 from .latex import LatexExporter
 from .pdf import PDFExporter
 from .markdown import MarkdownExporter
 from .python import PythonExporter
 from .rst import RSTExporter
 from .notebook import NotebookExporter
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 @undoc
 def DocDecorator(f):
     
     #Set docstring of function
     f.__doc__ = f.__doc__ + """
     nb : :class:`~{nbnode_mod}.NotebookNode`
       The notebook to export.
     config : config (optional, keyword arg)
         User configuration instance.
     resources : dict (optional, keyword arg)
         Resources used in the conversion process.
         
     Returns
     -------
     tuple- output, resources, exporter_instance
     output : str
         Jinja 2 output.  This is the resulting converted notebook.
     resources : dictionary
         Dictionary of resources used prior to and during the conversion 
         process.
     exporter_instance : Exporter
         Instance of the Exporter class used to export the document.  Useful
         to caller because it provides a 'file_extension' property which
         specifies what extension the output should be saved as.
 
     Notes
     -----
     WARNING: API WILL CHANGE IN FUTURE RELEASES OF NBCONVERT
     """.format(nbnode_mod=NotebookNode.__module__)
             
     @wraps(f)
     def decorator(*args, **kwargs):
         return f(*args, **kwargs)
     
     return decorator
 
 
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
 
 __all__ = [
     'export',
     'export_html',
     'export_custom',
     'export_slides',
     'export_latex',
     'export_pdf',
     'export_markdown',
     'export_python',
     'export_rst',
     'export_by_name',
     'get_export_names',
     'ExporterNameError'
 ]
 
 
 class ExporterNameError(NameError):
     pass
 
 @DocDecorator
 def export(exporter, nb, **kw):
     """
     Export a notebook object using specific exporter class.
     
     Parameters
     ----------
     exporter : class:`~IPython.nbconvert.exporters.exporter.Exporter` class or instance
       Class type or instance of the exporter that should be used.  If the
       method initializes it's own instance of the class, it is ASSUMED that
       the class type provided exposes a constructor (``__init__``) with the same
       signature as the base Exporter class.
     """
     
     #Check arguments
     if exporter is None:
         raise TypeError("Exporter is None")
     elif not isinstance(exporter, Exporter) and not issubclass(exporter, Exporter):
         raise TypeError("exporter does not inherit from Exporter (base)")
     if nb is None:
         raise TypeError("nb is None")
     
     #Create the exporter
     resources = kw.pop('resources', None)
     if isinstance(exporter, Exporter):
         exporter_instance = exporter
     else:
         exporter_instance = exporter(**kw)
     
     #Try to convert the notebook using the appropriate conversion function.
     if isinstance(nb, NotebookNode):
         output, resources = exporter_instance.from_notebook_node(nb, resources)
     elif isinstance(nb, string_types):
         output, resources = exporter_instance.from_filename(nb, resources)
     else:
         output, resources = exporter_instance.from_file(nb, resources)
     return output, resources
 
 exporter_map = dict(
     custom=TemplateExporter,
     html=HTMLExporter,
     slides=SlidesExporter,
     latex=LatexExporter,
     pdf=PDFExporter,
     markdown=MarkdownExporter,
     python=PythonExporter,
     rst=RSTExporter,
     notebook=NotebookExporter,
 )
 
 def _make_exporter(name, E):
     """make an export_foo function from a short key and Exporter class E"""
     def _export(nb, **kw):
         return export(E, nb, **kw)
     _export.__doc__ = """Export a notebook object to {0} format""".format(name)
     return _export
     
 g = globals()
 
 for name, E in exporter_map.items():
     g['export_%s' % name] = DocDecorator(_make_exporter(name, E))
 
 @DocDecorator
 def export_by_name(format_name, nb, **kw):
     """
     Export a notebook object to a template type by its name.  Reflection
     (Inspect) is used to find the template's corresponding explicit export
     method defined in this module.  That method is then called directly.
     
     Parameters
     ----------
     format_name : str
         Name of the template style to export to.
     """
     
     function_name = "export_" + format_name.lower()
     
     if function_name in globals():
         return globals()[function_name](nb, **kw)
     else:
         raise ExporterNameError("template for `%s` not found" % function_name)
 
 
 def get_export_names():
     """Return a list of the currently supported export targets
 
     WARNING: API WILL CHANGE IN FUTURE RELEASES OF NBCONVERT"""
     return sorted(exporter_map.keys())

IPython/nbconvert/exporters/exporter.py

@@ -1,276 +1,259
 """This module defines a base Exporter class. For Jinja template-based export,
 see templateexporter.py.
 """
 
-#-----------------------------------------------------------------------------
-# Copyright (c) 2013, the IPython Development Team.
-#
-# Distributed under the terms of the Modified BSD License.
-#
-# The full license is in the file COPYING.txt, distributed with this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
 
 from __future__ import print_function, absolute_import
 
-# Stdlib imports
 import io
 import os
 import copy
 import collections
 import datetime
 
-
-# IPython imports
 from IPython.config.configurable import LoggingConfigurable
 from IPython.config import Config
-from IPython.nbformat import current as nbformat
+from IPython import nbformat
 from IPython.utils.traitlets import MetaHasTraits, Unicode, List
 from IPython.utils.importstring import import_item
 from IPython.utils import text, py3compat
 
-#-----------------------------------------------------------------------------
-# Class
-#-----------------------------------------------------------------------------
 
 class ResourcesDict(collections.defaultdict):
     def __missing__(self, key):
         return ''
 
 
 class Exporter(LoggingConfigurable):
     """
     Class containing methods that sequentially run a list of preprocessors on a 
     NotebookNode object and then return the modified NotebookNode object and 
     accompanying resources dict.
     """
 
     file_extension = Unicode(
         'txt', config=True,
         help="Extension of the file that should be written to disk"
         )
 
     # MIME type of the result file, for HTTP response headers.
     # This is *not* a traitlet, because we want to be able to access it from
     # the class, not just on instances.
     output_mimetype = ''
 
     #Configurability, allows the user to easily add filters and preprocessors.
     preprocessors = List(config=True,
         help="""List of preprocessors, by name or namespace, to enable.""")
 
     _preprocessors = List()
 
     default_preprocessors = List(['IPython.nbconvert.preprocessors.coalesce_streams',
                                   'IPython.nbconvert.preprocessors.SVG2PDFPreprocessor',
                                   'IPython.nbconvert.preprocessors.ExtractOutputPreprocessor',
                                   'IPython.nbconvert.preprocessors.CSSHTMLHeaderPreprocessor',
                                   'IPython.nbconvert.preprocessors.RevealHelpPreprocessor',
                                   'IPython.nbconvert.preprocessors.LatexPreprocessor',
                                   'IPython.nbconvert.preprocessors.ClearOutputPreprocessor',
                                   'IPython.nbconvert.preprocessors.ExecutePreprocessor',
                                   'IPython.nbconvert.preprocessors.HighlightMagicsPreprocessor'],
         config=True,
         help="""List of preprocessors available by default, by name, namespace, 
         instance, or type.""")
 
 
     def __init__(self, config=None, **kw):
         """
         Public constructor
 
         Parameters
         ----------
         config : config
             User configuration instance.
         """
         with_default_config = self.default_config
         if config:
             with_default_config.merge(config)
         
         super(Exporter, self).__init__(config=with_default_config, **kw)
 
         self._init_preprocessors()
 
 
     @property
     def default_config(self):
         return Config()
 
     def from_notebook_node(self, nb, resources=None, **kw):
         """
         Convert a notebook from a notebook node instance.
 
         Parameters
         ----------
         nb : :class:`~IPython.nbformat.current.NotebookNode`
-          Notebook node
+          Notebook node (dict-like with attr-access)
         resources : dict
           Additional resources that can be accessed read/write by
           preprocessors and filters.
         **kw
           Ignored (?)
         """
         nb_copy = copy.deepcopy(nb)
         resources = self._init_resources(resources)
         
         if 'language' in nb['metadata']:
             resources['language'] = nb['metadata']['language'].lower()
 
         # Preprocess
         nb_copy, resources = self._preprocess(nb_copy, resources)
 
         return nb_copy, resources
 
 
     def from_filename(self, filename, resources=None, **kw):
         """
         Convert a notebook from a notebook file.
 
         Parameters
         ----------
         filename : str
             Full filename of the notebook file to open and convert.
         """
 
         # Pull the metadata from the filesystem.
         if resources is None:
             resources = ResourcesDict()
         if not 'metadata' in resources or resources['metadata'] == '':
             resources['metadata'] = ResourcesDict()
         basename = os.path.basename(filename)
         notebook_name = basename[:basename.rfind('.')]
         resources['metadata']['name'] = notebook_name
 
         modified_date = datetime.datetime.fromtimestamp(os.path.getmtime(filename))
         resources['metadata']['modified_date'] = modified_date.strftime(text.date_format)
 
         with io.open(filename, encoding='utf-8') as f:
-            return self.from_notebook_node(nbformat.read(f, 'json'), resources=resources, **kw)
+            return self.from_notebook_node(nbformat.read(f, as_version=4), resources=resources, **kw)
 
 
     def from_file(self, file_stream, resources=None, **kw):
         """
         Convert a notebook from a notebook file.
 
         Parameters
         ----------
         file_stream : file-like object
             Notebook file-like object to convert.
         """
-        return self.from_notebook_node(nbformat.read(file_stream, 'json'), resources=resources, **kw)
+        return self.from_notebook_node(nbformat.read(file_stream, as_version=4), resources=resources, **kw)
 
 
     def register_preprocessor(self, preprocessor, enabled=False):
         """
         Register a preprocessor.
         Preprocessors are classes that act upon the notebook before it is
         passed into the Jinja templating engine.  preprocessors are also
         capable of passing additional information to the Jinja
         templating engine.
 
         Parameters
         ----------
         preprocessor : preprocessor
         """
         if preprocessor is None:
             raise TypeError('preprocessor')
         isclass = isinstance(preprocessor, type)
         constructed = not isclass
 
         # Handle preprocessor's registration based on it's type
         if constructed and isinstance(preprocessor, py3compat.string_types):
             # Preprocessor is a string, import the namespace and recursively call
             # this register_preprocessor method
             preprocessor_cls = import_item(preprocessor)
             return self.register_preprocessor(preprocessor_cls, enabled)
 
         if constructed and hasattr(preprocessor, '__call__'):
             # Preprocessor is a function, no need to construct it.
             # Register and return the preprocessor.
             if enabled:
                 preprocessor.enabled = True
             self._preprocessors.append(preprocessor)
             return preprocessor
 
         elif isclass and isinstance(preprocessor, MetaHasTraits):
             # Preprocessor is configurable.  Make sure to pass in new default for 
             # the enabled flag if one was specified.
             self.register_preprocessor(preprocessor(parent=self), enabled)
 
         elif isclass:
             # Preprocessor is not configurable, construct it
             self.register_preprocessor(preprocessor(), enabled)
 
         else:
             # Preprocessor is an instance of something without a __call__ 
             # attribute.  
             raise TypeError('preprocessor')
 
 
     def _init_preprocessors(self):
         """
         Register all of the preprocessors needed for this exporter, disabled
         unless specified explicitly.
         """
         self._preprocessors = []
 
         # Load default preprocessors (not necessarly enabled by default).
         for preprocessor in self.default_preprocessors:
             self.register_preprocessor(preprocessor)
 
         # Load user-specified preprocessors.  Enable by default.
         for preprocessor in self.preprocessors:
             self.register_preprocessor(preprocessor, enabled=True)
 
 
     def _init_resources(self, resources):
 
         #Make sure the resources dict is of ResourcesDict type.
         if resources is None:
             resources = ResourcesDict()
         if not isinstance(resources, ResourcesDict):
             new_resources = ResourcesDict()
             new_resources.update(resources)
             resources = new_resources
 
         #Make sure the metadata extension exists in resources
         if 'metadata' in resources:
             if not isinstance(resources['metadata'], ResourcesDict):
                 resources['metadata'] = ResourcesDict(resources['metadata'])
         else:
             resources['metadata'] = ResourcesDict()
             if not resources['metadata']['name']:
                 resources['metadata']['name'] = 'Notebook'
 
         #Set the output extension
         resources['output_extension'] = self.file_extension
         return resources
 
 
     def _preprocess(self, nb, resources):
         """
         Preprocess the notebook before passing it into the Jinja engine.
         To preprocess the notebook is to apply all of the
 
         Parameters
         ----------
         nb : notebook node
             notebook that is being exported.
         resources : a dict of additional resources that
             can be accessed read/write by preprocessors
         """
 
         # Do a copy.deepcopy first,
         # we are never safe enough with what the preprocessors could do.
         nbc =  copy.deepcopy(nb)
         resc = copy.deepcopy(resources)
 
         #Run each preprocessor on the notebook.  Carry the output along
         #to each preprocessor
         for preprocessor in self._preprocessors:
             nbc, resc = preprocessor(nbc, resc)
         return nbc, resc

IPython/nbconvert/exporters/notebook.py

@@ -1,32 +1,32
 """NotebookExporter class"""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from .exporter import Exporter
-from IPython.nbformat import current as nbformat
+from IPython import nbformat
 from IPython.utils.traitlets import Enum
 
 class NotebookExporter(Exporter):
     """Exports to an IPython notebook."""
 
-    nbformat_version = Enum(list(range(2, nbformat.current_nbformat + 1)),
+    nbformat_version = Enum(list(nbformat.versions),
         default_value=nbformat.current_nbformat,
         config=True,
         help="""The nbformat version to write.
         Use this to downgrade notebooks.
         """
     )
     def _file_extension_default(self):
         return 'ipynb'
 
     output_mimetype = 'application/json'
 
     def from_notebook_node(self, nb, resources=None, **kw):
         nb_copy, resources = super(NotebookExporter, self).from_notebook_node(nb, resources, **kw)
-        if self.nbformat_version != nbformat.current_nbformat:
+        if self.nbformat_version != nb_copy.nbformat:
             resources['output_suffix'] = '.v%i' % self.nbformat_version
         else:
             resources['output_suffix'] = '.nbconvert'
         output = nbformat.writes(nb_copy, version=self.nbformat_version)
         return output, resources

IPython/nbconvert/exporters/tests/test_export.py

@@ -1,102 +1,90
 """
 Module with tests for export.py
 """
 
-#-----------------------------------------------------------------------------
-# Copyright (c) 2013, the IPython Development Team.
-#
+# Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
-#
-# The full license is in the file COPYING.txt, distributed with this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
 
 import os
 
-from IPython.nbformat import current as nbformat
+from IPython import nbformat
 
 from .base import ExportersTestsBase
 from ..export import *
 from ..python import PythonExporter
 
-#-----------------------------------------------------------------------------
-# Class
-#-----------------------------------------------------------------------------
 
 class TestExport(ExportersTestsBase):
     """Contains test functions for export.py"""
 
 
     def test_export_wrong_name(self):
         """
         Is the right error thrown when a bad template name is used?
         """
         try:
             export_by_name('not_a_name', self._get_notebook())
         except ExporterNameError as e:
             pass
 
 
     def test_export_filename(self):
         """
         Can a notebook be exported by filename?
         """
         (output, resources) = export_by_name('python', self._get_notebook())
         assert len(output) > 0
 
 
     def test_export_nbnode(self):
         """
         Can a notebook be exported by a notebook node handle?
         """
         with open(self._get_notebook(), 'r') as f:
-            notebook = nbformat.read(f, 'json')
+            notebook = nbformat.read(f, 4)
             (output, resources) = export_by_name('python', notebook)
         assert len(output) > 0
 
 
     def test_export_filestream(self):
         """
         Can a notebook be exported by a filesteam?
         """
         with open(self._get_notebook(), 'r') as f:
             (output, resources) = export_by_name('python', f)
         assert len(output) > 0
 
 
     def test_export_using_exporter(self):
         """
         Can a notebook be exported using an instanciated exporter?
         """
         (output, resources) = export(PythonExporter(), self._get_notebook())
         assert len(output) > 0
 
 
     def test_export_using_exporter_class(self):
         """
         Can a notebook be exported using an exporter class type?
         """
         (output, resources) = export(PythonExporter, self._get_notebook())
         assert len(output) > 0
 
 
     def test_export_resources(self):
         """
         Can a notebook be exported along with a custom resources dict?
         """
         (output, resources) = export(PythonExporter, self._get_notebook(), resources={})
         assert len(output) > 0
 
 
     def test_no_exporter(self):
         """
         Is the right error thrown if no exporter is provided?
         """
         try:
             (output, resources) = export(None, self._get_notebook())
         except TypeError:
             pass
                 

IPython/nbconvert/exporters/tests/test_latex.py

@@ -1,116 +1,117
 """Tests for Latex exporter"""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import os.path
 import textwrap
 import re
 
 from .base import ExportersTestsBase
 from ..latex import LatexExporter
-from IPython.nbformat import current
+from IPython.nbformat import write
+from IPython.nbformat import v4
 from IPython.testing.decorators import onlyif_cmds_exist
 from IPython.utils.tempdir import TemporaryDirectory
 
 
 class TestLatexExporter(ExportersTestsBase):
     """Contains test functions for latex.py"""
 
     exporter_class = LatexExporter
     should_include_raw = ['latex']
 
     def test_constructor(self):
         """
         Can a LatexExporter be constructed?
         """
         LatexExporter()
 
 
     @onlyif_cmds_exist('pandoc')
     def test_export(self):
         """
         Can a LatexExporter export something?
         """
         (output, resources) = LatexExporter().from_filename(self._get_notebook())
         assert len(output) > 0
 
 
     @onlyif_cmds_exist('pandoc')
     def test_export_book(self):
         """
         Can a LatexExporter export using 'report' template?
         """
         (output, resources) = LatexExporter(template_file='report').from_filename(self._get_notebook())
         assert len(output) > 0
 
 
     @onlyif_cmds_exist('pandoc')
     def test_export_basic(self):
         """
         Can a LatexExporter export using 'article' template?
         """
         (output, resources) = LatexExporter(template_file='article').from_filename(self._get_notebook())
         assert len(output) > 0
 
 
     @onlyif_cmds_exist('pandoc')
     def test_export_article(self):
         """
         Can a LatexExporter export using 'article' template?
         """
         (output, resources) = LatexExporter(template_file='article').from_filename(self._get_notebook())
         assert len(output) > 0
 
     @onlyif_cmds_exist('pandoc')
     def test_very_long_cells(self):
         """
         Torture test that long cells do not cause issues
         """
         lorem_ipsum_text = textwrap.dedent("""\
           Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec
           dignissim, ipsum non facilisis tempus, dui felis tincidunt metus,
           nec pulvinar neque odio eget risus. Nulla nisi lectus, cursus
           suscipit interdum at, ultrices sit amet orci. Mauris facilisis
           imperdiet elit, vitae scelerisque ipsum dignissim non. Integer
           consequat malesuada neque sit amet pulvinar. Curabitur pretium
           ut turpis eget aliquet. Maecenas sagittis lacus sed lectus
           volutpat, eu adipiscing purus pulvinar. Maecenas consequat
           luctus urna, eget cursus quam mollis a. Aliquam vitae ornare
           erat, non hendrerit urna. Sed eu diam nec massa egestas pharetra
           at nec tellus. Fusce feugiat lacus quis urna sollicitudin volutpat.
           Quisque at sapien non nibh feugiat tempus ac ultricies purus.
            """)
         lorem_ipsum_text = lorem_ipsum_text.replace("\n"," ") + "\n\n"
         large_lorem_ipsum_text = "".join([lorem_ipsum_text]*3000)
 
         notebook_name = "lorem_ipsum_long.ipynb"
-        nb = current.new_notebook(
+        nb = v4.new_notebook(
             cells=[
-                    current.new_markdown_cell(source=large_lorem_ipsum_text)
+                    v4.new_markdown_cell(source=large_lorem_ipsum_text)
             ]
         )
 
         with TemporaryDirectory() as td:
             nbfile = os.path.join(td, notebook_name)
             with open(nbfile, 'w') as f:
-                current.write(nb, f, 'ipynb')
+                write(f, nb, 4)
 
             (output, resources) = LatexExporter(template_file='article').from_filename(nbfile)            
             assert len(output) > 0
 
     @onlyif_cmds_exist('pandoc')
     def test_prompt_number_color(self):
         """
         Does LatexExporter properly format input and output prompts in color?
         """
         (output, resources) = LatexExporter().from_filename(
             self._get_notebook(nb_name="prompt_numbers.ipynb"))
         in_regex = r"In \[\{\\color\{incolor\}(.*)\}\]:"
         out_regex = r"Out\[\{\\color\{outcolor\}(.*)\}\]:"
 
         ins = ["2", "10", " ", " ", "*", "0"]
         outs = ["10"]
 
         assert re.findall(in_regex, output) == ins
         assert re.findall(out_regex, output) == outs

IPython/nbconvert/exporters/tests/test_notebook.py

@@ -1,39 +1,39
 """Tests for notebook.py"""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import json
 
 from .base import ExportersTestsBase
 from ..notebook import NotebookExporter
 
-from IPython.nbformat.current import validate
+from IPython.nbformat import validate
 from IPython.testing.tools import assert_big_text_equal
 
 class TestNotebookExporter(ExportersTestsBase):
     """Contains test functions for notebook.py"""
 
     exporter_class = NotebookExporter
 
     def test_export(self):
         """
         Does the NotebookExporter return the file unchanged?
         """
         with open(self._get_notebook()) as f:
             file_contents = f.read()
         (output, resources) = self.exporter_class().from_filename(self._get_notebook())
         assert len(output) > 0
         assert_big_text_equal(output, file_contents)
 
     def test_downgrade_3(self):
         exporter = self.exporter_class(nbformat_version=3)
         (output, resources) = exporter.from_filename(self._get_notebook())
         nb = json.loads(output)
         validate(nb)
 
     def test_downgrade_2(self):
         exporter = self.exporter_class(nbformat_version=2)
         (output, resources) = exporter.from_filename(self._get_notebook())
         nb = json.loads(output)
         self.assertEqual(nb['nbformat'], 2)

IPython/nbconvert/exporters/tests/test_rst.py

@@ -1,62 +1,54
 """Tests for RSTExporter"""
 
-#-----------------------------------------------------------------------------
-# Copyright (c) 2013, the IPython Development Team.
-#
+# Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
-#
-# The full license is in the file COPYING.txt, distributed with this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
 
 import io
 
-from IPython.nbformat import current
+from IPython import nbformat
+from IPython.nbformat import v4
 
 from .base import ExportersTestsBase
 from ..rst import RSTExporter
 from IPython.testing.decorators import onlyif_cmds_exist
 
 
 class TestRSTExporter(ExportersTestsBase):
     """Tests for RSTExporter"""
 
     exporter_class = RSTExporter
     should_include_raw = ['rst']
 
     def test_constructor(self):
         """
         Can a RSTExporter be constructed?
         """
         RSTExporter()
 
 
     @onlyif_cmds_exist('pandoc')
     def test_export(self):
         """
         Can a RSTExporter export something?
         """
         (output, resources) = RSTExporter().from_filename(self._get_notebook())
         assert len(output) > 0
         
     @onlyif_cmds_exist('pandoc')
     def test_empty_code_cell(self):
         """No empty code cells in rst"""
         nbname = self._get_notebook()
         with io.open(nbname, encoding='utf8') as f:
-            nb = current.read(f, 'json')
+            nb = nbformat.read(f, 4)
         
         exporter = self.exporter_class()
         
         (output, resources) = exporter.from_notebook_node(nb)
         # add an empty code cell
         nb.cells.append(
-            current.new_code_cell(source="")
+            v4.new_code_cell(source="")
         )
         (output2, resources) = exporter.from_notebook_node(nb)
         # adding an empty code cell shouldn't change output
         self.assertEqual(output.strip(), output2.strip())
         

IPython/nbconvert/preprocessors/execute.py

@@ -1,111 +1,111
 """Module containing a preprocessor that removes the outputs from code cells"""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import os
-import sys
 
 try:
     from queue import Empty  # Py 3
 except ImportError:
     from Queue import Empty  # Py 2
 
 from IPython.utils.traitlets import List, Unicode
 
-from IPython.nbformat.current import reads, writes, output_from_msg
+from IPython.nbformat.v4 import output_from_msg
 from .base import Preprocessor
 from IPython.utils.traitlets import Integer
 
+
 class ExecutePreprocessor(Preprocessor):
     """
     Executes all the cells in a notebook
     """
     
     timeout = Integer(30, config=True,
         help="The time to wait (in seconds) for output from executions."
     )
     
     extra_arguments = List(Unicode)
 
     def preprocess(self, nb, resources):
         from IPython.kernel import run_kernel
         kernel_name = nb.metadata.get('kernelspec', {}).get('name', 'python')
         self.log.info("Executing notebook with kernel: %s" % kernel_name)
         with run_kernel(kernel_name=kernel_name,
                         extra_arguments=self.extra_arguments,
                         stderr=open(os.devnull, 'w')) as kc:
             self.kc = kc
             nb, resources = super(ExecutePreprocessor, self).preprocess(nb, resources)
         return nb, resources
 
     def preprocess_cell(self, cell, resources, cell_index):
         """
         Apply a transformation on each code cell. See base.py for details.
         """
         if cell.cell_type != 'code':
             return cell, resources
         try:
             outputs = self.run_cell(self.kc.shell_channel, self.kc.iopub_channel, cell)
         except Exception as e:
             self.log.error("failed to run cell: " + repr(e))
             self.log.error(str(cell.source))
             raise
         cell.outputs = outputs
         return cell, resources
 
     def run_cell(self, shell, iopub, cell):
         msg_id = shell.execute(cell.source)
         self.log.debug("Executing cell:\n%s", cell.source)
         # wait for finish, with timeout
         while True:
             try:
                 msg = shell.get_msg(timeout=self.timeout)
             except Empty:
                 self.log.error("Timeout waiting for execute reply")
                 raise
             if msg['parent_header'].get('msg_id') == msg_id:
                 break
             else:
                 # not our reply
                 continue
         
         outs = []
 
         while True:
             try:
                 msg = iopub.get_msg(timeout=self.timeout)
             except Empty:
                 self.log.warn("Timeout waiting for IOPub output")
                 break
             if msg['parent_header'].get('msg_id') != msg_id:
                 # not an output from our execution
                 continue
 
             msg_type = msg['msg_type']
             self.log.debug("output: %s", msg_type)
             content = msg['content']
 
             # set the prompt number for the input and the output
             if 'execution_count' in content:
                 cell['execution_count'] = content['execution_count']
 
             if msg_type == 'status':
                 if content['execution_state'] == 'idle':
                     break
                 else:
                     continue
             elif msg_type == 'execute_input':
                 continue
             elif msg_type == 'clear_output':
                 outs = []
                 continue
 
             try:
                 out = output_from_msg(msg)
             except ValueError:
                 self.log.error("unhandled iopub msg: " + msg_type)
             else:
                 outs.append(out)
 
         return outs

IPython/nbconvert/preprocessors/tests/base.py

@@ -1,41 +1,41
 """utility functions for preprocessor tests"""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from IPython.nbformat import current as nbformat
+from IPython.nbformat import v4 as nbformat
 
 from ...tests.base import TestsBase
 from ...exporters.exporter import ResourcesDict
 
 
 class PreprocessorTestsBase(TestsBase):
     """Contains test functions preprocessor tests"""
 
 
     def build_notebook(self):
         """Build a notebook in memory for use with preprocessor tests"""
 
         outputs = [
             nbformat.new_output("stream", name="stdout", text="a"),
             nbformat.new_output("display_data", data={'text/plain': 'b'}),
             nbformat.new_output("stream", name="stdout", text="c"),
             nbformat.new_output("stream", name="stdout", text="d"),
             nbformat.new_output("stream", name="stderr", text="e"),
             nbformat.new_output("stream", name="stderr", text="f"),
             nbformat.new_output("display_data", data={'image/png': 'Zw=='}), # g
             nbformat.new_output("display_data", data={'application/pdf': 'aA=='}), # h
         ]
         
         cells=[nbformat.new_code_cell(source="$ e $", execution_count=1, outputs=outputs),
                nbformat.new_markdown_cell(source="$ e $")]
 
         return nbformat.new_notebook(cells=cells)
 
 
     def build_resources(self):
         """Build an empty resources dictionary."""
         
         res = ResourcesDict()
         res['metadata'] = ResourcesDict()
         return res

IPython/nbconvert/preprocessors/tests/test_clearoutput.py

@@ -1,35 +1,33
 """
 Module with tests for the clearoutput preprocessor.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from IPython.nbformat import current as nbformat
-
 from .base import PreprocessorTestsBase
 from ..clearoutput import ClearOutputPreprocessor
 
 
 class TestClearOutput(PreprocessorTestsBase):
     """Contains test functions for clearoutput.py"""
 
 
     def build_preprocessor(self):
         """Make an instance of a preprocessor"""
         preprocessor = ClearOutputPreprocessor()
         preprocessor.enabled = True
         return preprocessor
 
     def test_constructor(self):
         """Can a ClearOutputPreprocessor be constructed?"""
         self.build_preprocessor()
 
     def test_output(self):
         """Test the output of the ClearOutputPreprocessor"""
         nb = self.build_notebook()
         res = self.build_resources()
         preprocessor = self.build_preprocessor()
         nb, res = preprocessor(nb, res)
         assert nb.cells[0].outputs == []
         assert nb.cells[0].execution_count is None

IPython/nbconvert/preprocessors/tests/test_coalescestreams.py

@@ -1,58 +1,58
 """Tests for the coalescestreams preprocessor"""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from IPython.nbformat import current as nbformat
+from IPython.nbformat import v4 as nbformat
 
 from .base import PreprocessorTestsBase
 from ..coalescestreams import coalesce_streams
 
 
 class TestCoalesceStreams(PreprocessorTestsBase):
     """Contains test functions for coalescestreams.py"""
 
     def test_coalesce_streams(self):
         """coalesce_streams preprocessor output test"""
         nb = self.build_notebook()
         res = self.build_resources()
         nb, res = coalesce_streams(nb, res)
         outputs = nb.cells[0].outputs
         self.assertEqual(outputs[0].text, "a")
         self.assertEqual(outputs[1].output_type, "display_data")
         self.assertEqual(outputs[2].text, "cd")
         self.assertEqual(outputs[3].text, "ef")
 
     def test_coalesce_sequenced_streams(self):
         """Can the coalesce streams preprocessor merge a sequence of streams?"""
         outputs = [nbformat.new_output(output_type="stream", name="stdout", text="0"),
                    nbformat.new_output(output_type="stream", name="stdout", text="1"),
                    nbformat.new_output(output_type="stream", name="stdout", text="2"),
                    nbformat.new_output(output_type="stream", name="stdout", text="3"),
                    nbformat.new_output(output_type="stream", name="stdout", text="4"),
                    nbformat.new_output(output_type="stream", name="stdout", text="5"),
                    nbformat.new_output(output_type="stream", name="stdout", text="6"),
                    nbformat.new_output(output_type="stream", name="stdout", text="7")]
         cells=[nbformat.new_code_cell(source="# None", execution_count=1,outputs=outputs)]
 
         nb = nbformat.new_notebook(cells=cells)
         res = self.build_resources()
         nb, res = coalesce_streams(nb, res)
         outputs = nb.cells[0].outputs
         self.assertEqual(outputs[0].text, u'01234567')
 
     def test_coalesce_replace_streams(self):
         """Are \\r characters handled?"""
         outputs = [nbformat.new_output(output_type="stream", name="stdout", text="z"),
                    nbformat.new_output(output_type="stream", name="stdout", text="\ra"),
                    nbformat.new_output(output_type="stream", name="stdout", text="\nz\rb"),
                    nbformat.new_output(output_type="stream", name="stdout", text="\nz"),
                    nbformat.new_output(output_type="stream", name="stdout", text="\rc\n"),
                    nbformat.new_output(output_type="stream", name="stdout", text="z\rz\rd")]
         cells=[nbformat.new_code_cell(source="# None", execution_count=1,outputs=outputs)]
 
         nb = nbformat.new_notebook(cells=cells)
         res = self.build_resources()
         nb, res = coalesce_streams(nb, res)
         outputs = nb.cells[0].outputs
         self.assertEqual(outputs[0].text, u'a\nb\nc\nd')

IPython/nbconvert/preprocessors/tests/test_execute.py

@@ -1,91 +1,92
 """
 Module with tests for the execute preprocessor.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import copy
 import glob
+import io
 import os
 import re
 
-from IPython.nbformat import current as nbformat
+from IPython import nbformat
 
 from .base import PreprocessorTestsBase
 from ..execute import ExecutePreprocessor
 
 from IPython.nbconvert.filters import strip_ansi
 
 addr_pat = re.compile(r'0x[0-9a-f]{7,9}')
 
 class TestExecute(PreprocessorTestsBase):
     """Contains test functions for execute.py"""
 
     @staticmethod
     def normalize_output(output):
         """
         Normalizes outputs for comparison.
         """
         output = dict(output)
         if 'metadata' in output:
             del output['metadata']
         if 'text' in output:
             output['text'] = re.sub(addr_pat, '<HEXADDR>', output['text'])
         if 'text/plain' in output.get('data', {}):
             output['data']['text/plain'] = \
                 re.sub(addr_pat, '<HEXADDR>', output['data']['text/plain'])
         if 'traceback' in output:
             tb = []
             for line in output['traceback']:
                 tb.append(strip_ansi(line))
             output['traceback'] = tb
             
         return output
 
 
     def assert_notebooks_equal(self, expected, actual):
         expected_cells = expected['cells']
         actual_cells = actual['cells']
         self.assertEqual(len(expected_cells), len(actual_cells))
 
         for expected_cell, actual_cell in zip(expected_cells, actual_cells):
             expected_outputs = expected_cell.get('outputs', [])
             actual_outputs = actual_cell.get('outputs', [])
             normalized_expected_outputs = list(map(self.normalize_output, expected_outputs))
             normalized_actual_outputs = list(map(self.normalize_output, actual_outputs))
             self.assertEqual(normalized_expected_outputs, normalized_actual_outputs)
 
             expected_execution_count = expected_cell.get('execution_count', None)
             actual_execution_count = actual_cell.get('execution_count', None)
             self.assertEqual(expected_execution_count, actual_execution_count)
 
 
     def build_preprocessor(self):
         """Make an instance of a preprocessor"""
         preprocessor = ExecutePreprocessor()
         preprocessor.enabled = True
         return preprocessor
 
 
     def test_constructor(self):
         """Can a ExecutePreprocessor be constructed?"""
         self.build_preprocessor()
 
 
     def test_run_notebooks(self):
         """Runs a series of test notebooks and compares them to their actual output"""
         current_dir = os.path.dirname(__file__)
         input_files = glob.glob(os.path.join(current_dir, 'files', '*.ipynb'))
         for filename in input_files:
-            with open(os.path.join(current_dir, 'files', filename)) as f:
-                input_nb = nbformat.read(f, 'ipynb')
+            with io.open(os.path.join(current_dir, 'files', filename)) as f:
+                input_nb = nbformat.read(f, 4)
             res = self.build_resources()
             preprocessor = self.build_preprocessor()
             cleaned_input_nb = copy.deepcopy(input_nb)
             for cell in cleaned_input_nb.cells:
                 if 'execution_count' in cell:
                     del cell['execution_count']
                 cell['outputs'] = []
             output_nb, _ = preprocessor(cleaned_input_nb, res)
             self.assert_notebooks_equal(output_nb, input_nb)

IPython/nbconvert/preprocessors/tests/test_revealhelp.py

@@ -1,78 +1,78
 """Tests for the revealhelp preprocessor"""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from IPython.nbformat import current as nbformat
+from IPython.nbformat import v4 as nbformat
 
 from .base import PreprocessorTestsBase
 from ..revealhelp import RevealHelpPreprocessor
 
 
 class Testrevealhelp(PreprocessorTestsBase):
     """Contains test functions for revealhelp.py"""
 
     def build_notebook(self):
         """Build a reveal slides notebook in memory for use with tests.
         Overrides base in PreprocessorTestsBase"""
 
         outputs = [nbformat.new_output(output_type="stream", name="stdout", text="a")]
 
         slide_metadata = {'slideshow' : {'slide_type': 'slide'}}
         subslide_metadata = {'slideshow' : {'slide_type': 'subslide'}}
 
         cells=[nbformat.new_code_cell(source="", execution_count=1, outputs=outputs),
                nbformat.new_markdown_cell(source="", metadata=slide_metadata),
                nbformat.new_code_cell(source="", execution_count=2, outputs=outputs),
                nbformat.new_markdown_cell(source="", metadata=slide_metadata),
                nbformat.new_markdown_cell(source="", metadata=subslide_metadata)]
 
         return nbformat.new_notebook(cells=cells)
 
 
     def build_preprocessor(self):
         """Make an instance of a preprocessor"""
         preprocessor = RevealHelpPreprocessor()
         preprocessor.enabled = True
         return preprocessor
 
 
     def test_constructor(self):
         """Can a RevealHelpPreprocessor be constructed?"""
         self.build_preprocessor()
 
 
     def test_reveal_attribute(self):
         """Make sure the reveal url_prefix resources is set"""
         nb = self.build_notebook()
         res = self.build_resources()
         preprocessor = self.build_preprocessor()
         nb, res = preprocessor(nb, res)
         assert 'reveal' in res
         assert  'url_prefix' in res['reveal']
 
 
     def test_reveal_output(self):
         """Make sure that the reveal preprocessor """
         nb = self.build_notebook()
         res = self.build_resources()
         preprocessor = self.build_preprocessor()
         nb, res = preprocessor(nb, res)
         cells = nb.cells
         
         # Make sure correct metadata tags are available on every cell.
         for cell in cells:
             assert 'slide_type' in cell.metadata
 
         # Make sure slide end is only applied to the cells preceeding slide 
         # cells.
         assert 'slide_helper' in cells[1].metadata
         self.assertEqual(cells[1].metadata['slide_helper'], '-')
 
         # Verify 'slide-end'
         assert 'slide_helper' in cells[0].metadata
         self.assertEqual(cells[0].metadata['slide_helper'], 'slide_end')
         assert 'slide_helper' in cells[2].metadata
         self.assertEqual(cells[2].metadata['slide_helper'], 'slide_end')
         assert 'slide_helper' in cells[3].metadata
         self.assertEqual(cells[3].metadata['slide_helper'], 'subslide_end')

IPython/nbconvert/preprocessors/tests/test_svg2pdf.py

@@ -1,74 +1,74
 """Tests for the svg2pdf preprocessor"""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from IPython.testing import decorators as dec
-from IPython.nbformat import current as nbformat
+from IPython.nbformat import v4 as nbformat
 
 from .base import PreprocessorTestsBase
 from ..svg2pdf import SVG2PDFPreprocessor
 
 
 class Testsvg2pdf(PreprocessorTestsBase):
     """Contains test functions for svg2pdf.py"""
 
     simple_svg = """<?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!-- Created with Inkscape (http://www.inkscape.org/) -->
 <svg
    xmlns:svg="http://www.w3.org/2000/svg"
    xmlns="http://www.w3.org/2000/svg"
    version="1.0"
    x="0.00000000"
    y="0.00000000"
    width="500.00000"
    height="500.00000"
    id="svg2">
   <defs
      id="defs4" />
   <g
      id="layer1">
     <rect
        width="300.00000"
        height="300.00000"
        x="100.00000"
        y="100.00000"
        style="opacity:1.0000000;fill:none;fill-opacity:1.0000000;fill-rule:evenodd;stroke:#000000;stroke-width:8.0000000;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4.0000000;stroke-dasharray:none;stroke-dashoffset:0.00000000;stroke-opacity:1.0000000"
        id="rect5719" />
   </g>
 </svg>"""
 
     def build_notebook(self):
         """Build a reveal slides notebook in memory for use with tests.
         Overrides base in PreprocessorTestsBase"""
 
         outputs = [nbformat.new_output(output_type="image/svg+xml", output_svg=self.simple_svg)]
         
         slide_metadata = {'slideshow' : {'slide_type': 'slide'}}
         subslide_metadata = {'slideshow' : {'slide_type': 'subslide'}}
 
         cells=[nbformat.new_code_cell(source="", execution_count=1, outputs=outputs)]
 
         return nbformat.new_notebook(cells=cells)
 
 
     def build_preprocessor(self):
         """Make an instance of a preprocessor"""
         preprocessor = SVG2PDFPreprocessor()
         preprocessor.enabled = True
         return preprocessor
 
 
     def test_constructor(self):
         """Can a SVG2PDFPreprocessor be constructed?"""
         self.build_preprocessor()
 
 
     @dec.onlyif_cmds_exist('inkscape')
     def test_output(self):
         """Test the output of the SVG2PDFPreprocessor"""
         nb = self.build_notebook()
         res = self.build_resources()
         preprocessor = self.build_preprocessor()
         nb, res = preprocessor(nb, res)
         self.assertIn('application/pdf', nb.cells[0].outputs[0])

IPython/nbconvert/tests/base.py

@@ -1,149 +1,148
 """Base test class for nbconvert"""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import io
 import os
 import glob
 import shutil
 import unittest
 
 import IPython
-from IPython.nbformat import current
+from IPython.nbformat import v4, write
 from IPython.utils.tempdir import TemporaryWorkingDirectory
 from IPython.utils.path import get_ipython_package_dir
 from IPython.utils.process import get_output_error_code
 from IPython.testing.tools import get_ipython_cmd
 
 # a trailing space allows for simpler concatenation with the other arguments
 ipy_cmd = get_ipython_cmd(as_string=True) + " "
 
 
 class TestsBase(unittest.TestCase):
     """Base tests class.  Contains useful fuzzy comparison and nbconvert
     functions."""
 
 
     def fuzzy_compare(self, a, b, newlines_are_spaces=True, tabs_are_spaces=True, 
                       fuzzy_spacing=True, ignore_spaces=False, 
                       ignore_newlines=False, case_sensitive=False, leave_padding=False):
         """
         Performs a fuzzy comparison of two strings.  A fuzzy comparison is a
         comparison that ignores insignificant differences in the two comparands.
         The significance of certain differences can be specified via the keyword
         parameters of this method.
         """
 
         if not leave_padding:
             a = a.strip()
             b = b.strip()
 
         if ignore_newlines:
             a = a.replace('\n', '')
             b = b.replace('\n', '')
 
         if newlines_are_spaces:
             a = a.replace('\n', ' ')
             b = b.replace('\n', ' ')
 
         if tabs_are_spaces:
             a = a.replace('\t', ' ')
             b = b.replace('\t', ' ')
 
         if ignore_spaces:
             a = a.replace(' ', '')
             b = b.replace(' ', '')
 
         if fuzzy_spacing:
             a = self.recursive_replace(a, '  ', ' ')
             b = self.recursive_replace(b, '  ', ' ')
 
         if not case_sensitive:
             a = a.lower()
             b = b.lower()
 
         self.assertEqual(a, b)
 
 
     def recursive_replace(self, text, search, replacement):
         """
         Performs a recursive replacement operation.  Replaces all instances
         of a search string in a text string with a replacement string until
         the search string no longer exists.  Recursion is needed because the
         replacement string may generate additional search strings.
 
         For example:
            Replace "ii" with "i" in the string "Hiiii" yields "Hii"
            Another replacement cds "Hi" (the desired output)
 
         Parameters
         ----------
         text : string
             Text to replace in.
         search : string
             String to search for within "text"
         replacement : string
             String to replace "search" with
         """
         while search in text:
             text = text.replace(search, replacement)
         return text
 
     def create_temp_cwd(self, copy_filenames=None):
         temp_dir = TemporaryWorkingDirectory()
 
         #Copy the files if requested.
         if copy_filenames is not None:
             self.copy_files_to(copy_filenames, dest=temp_dir.name)
 
         #Return directory handler
         return temp_dir
     
     def create_empty_notebook(self, path):
-        nb = current.new_notebook()
+        nb = v4.new_notebook()
         with io.open(path, 'w', encoding='utf-8') as f:
-            current.write(nb, f, 'json')
-
+            write(f, nb, 4)
 
     def copy_files_to(self, copy_filenames, dest='.'):
         "Copy test files into the destination directory"
         if not os.path.isdir(dest):
             os.makedirs(dest)
         files_path = self._get_files_path()
         for pattern in copy_filenames:
             for match in glob.glob(os.path.join(files_path, pattern)):
                 shutil.copyfile(match, os.path.join(dest, os.path.basename(match)))
 
 
     def _get_files_path(self):
 
         #Get the relative path to this module in the IPython directory.
         names = self.__module__.split('.')[1:-1]
         names.append('files')
         
         #Build a path using the IPython directory and the relative path we just
         #found.
         path = get_ipython_package_dir()
         for name in names:
             path = os.path.join(path, name)
         return path
 
 
     def call(self, parameters, ignore_return_code=False):
         """
         Execute a, IPython shell command, listening for both Errors and non-zero
         return codes.
 
         Parameters
         ----------
         parameters : str
             List of parameters to pass to IPython.
         ignore_return_code : optional bool (default False)
             Throw an OSError if the return code 
         """
 
         stdout, stderr, retcode = get_output_error_code(ipy_cmd + parameters)
         if not (retcode == 0 or ignore_return_code):
             raise OSError(stderr)
         return stdout, stderr