s/IPython.nbconvert/jupyter_nbconvert/

inside jupyter_nbconvert

jupyter_nbconvert/exporters/export.py

@@ -1,177 +1,177 b''
 """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 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
 from .script import ScriptExporter
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 @undoc
 def DocDecorator(f):
     
     #Set docstring of function
     f.__doc__ = f.__doc__ + """
     nb : :class:`~IPython.nbformat.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
     """
             
     @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_script',
     '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
+    exporter : class:`~jupyter_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,
     script=ScriptExporter,
 )
 
 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())

jupyter_nbconvert/exporters/exporter.py

@@ -1,280 +1,280 b''
 """This module defines a base Exporter class. For Jinja template-based export,
 see templateexporter.py.
 """
 
 
 from __future__ import print_function, absolute_import
 
 import io
 import os
 import copy
 import collections
 import datetime
 
 from IPython.config.configurable import LoggingConfigurable
 from IPython.config import Config
 from IPython import nbformat
 from IPython.utils.traitlets import MetaHasTraits, Unicode, List, TraitError
 from IPython.utils.importstring import import_item
 from IPython.utils import text, py3compat
 
 
 class ResourcesDict(collections.defaultdict):
     def __missing__(self, key):
         return ''
 
 
 class FilenameExtension(Unicode):
     """A trait for filename extensions."""
 
     default_value = u''
     info_text = 'a filename extension, beginning with a dot'
 
     def validate(self, obj, value):
         # cast to proper unicode
         value = super(FilenameExtension, self).validate(obj, value)
 
         # check that it starts with a dot
         if value and not value.startswith('.'):
             msg = "FileExtension trait '{}' does not begin with a dot: {!r}"
             raise TraitError(msg.format(self.name, value))
 
         return value
 
 
 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 = FilenameExtension(
         '.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'],
+    default_preprocessors = List(['jupyter_nbconvert.preprocessors.coalesce_streams',
+                                  'jupyter_nbconvert.preprocessors.SVG2PDFPreprocessor',
+                                  'jupyter_nbconvert.preprocessors.ExtractOutputPreprocessor',
+                                  'jupyter_nbconvert.preprocessors.CSSHTMLHeaderPreprocessor',
+                                  'jupyter_nbconvert.preprocessors.RevealHelpPreprocessor',
+                                  'jupyter_nbconvert.preprocessors.LatexPreprocessor',
+                                  'jupyter_nbconvert.preprocessors.ClearOutputPreprocessor',
+                                  'jupyter_nbconvert.preprocessors.ExecutePreprocessor',
+                                  'jupyter_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.NotebookNode`
           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()
         path, basename = os.path.split(filename)
         notebook_name = basename[:basename.rfind('.')]
         resources['metadata']['name'] = notebook_name
         resources['metadata']['path'] = path
 
         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, 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, 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):
                 new_metadata = ResourcesDict()
                 new_metadata.update(resources['metadata'])
                 resources['metadata'] = new_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

jupyter_nbconvert/exporters/html.py

@@ -1,57 +1,57 b''
 """HTML Exporter class"""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import os
 
-from IPython.nbconvert.filters.highlight import Highlight2HTML
+from jupyter_nbconvert.filters.highlight import Highlight2HTML
 from IPython.config import Config
 
 from .templateexporter import TemplateExporter
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class HTMLExporter(TemplateExporter):
     """
     Exports a basic HTML document.  This exporter assists with the export of
     HTML.  Inherit from it if you are writing your own HTML template and need
     custom preprocessors/filters.  If you don't need custom preprocessors/
     filters, just change the 'template_file' config option.  
     """
     
     def _file_extension_default(self):
         return '.html'
 
     def _default_template_path_default(self):
         return os.path.join("..", "templates", "html")
 
     def _template_file_default(self):
         return 'full'
     
     output_mimetype = 'text/html'
     
     @property
     def default_config(self):
         c = Config({
             'NbConvertBase': {
                 'display_data_priority' : ['application/javascript', 'text/html', 'text/markdown', 'application/pdf', 'image/svg+xml', 'text/latex', 'image/png', 'image/jpeg', 'text/plain']
                 },
             'CSSHTMLHeaderPreprocessor':{
                 'enabled':True
                 },
             'HighlightMagicsPreprocessor': {
                 'enabled':True
                 }
             })
         c.merge(super(HTMLExporter,self).default_config)
         return c
 
     def from_notebook_node(self, nb, resources=None, **kw):
         langinfo = nb.metadata.get('language_info', {})
         lexer = langinfo.get('pygments_lexer', langinfo.get('name', None))
         self.register_filter('highlight_code',
                              Highlight2HTML(pygments_lexer=lexer, parent=self))
         return super(HTMLExporter, self).from_notebook_node(nb, resources, **kw)

jupyter_nbconvert/exporters/latex.py

@@ -1,96 +1,96 b''
 """LaTeX Exporter class"""
 
 #-----------------------------------------------------------------------------
 # 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
 #-----------------------------------------------------------------------------
 
 # Stdlib imports
 import os
 
 # IPython imports
 from IPython.utils.traitlets import Unicode
 from IPython.config import Config
 
-from IPython.nbconvert.filters.highlight import Highlight2Latex
+from jupyter_nbconvert.filters.highlight import Highlight2Latex
 from .templateexporter import TemplateExporter
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 class LatexExporter(TemplateExporter):
     """
     Exports to a Latex template.  Inherit from this class if your template is
     LaTeX based and you need custom tranformers/filters.  Inherit from it if 
     you are writing your own HTML template and need custom tranformers/filters.  
     If you don't need custom tranformers/filters, just change the 
     'template_file' config option.  Place your template in the special "/latex" 
     subfolder of the "../templates" folder.
     """
 
     def _file_extension_default(self):
         return '.tex'
 
     def _template_file_default(self):
         return 'article'
 
     #Latex constants
     def _default_template_path_default(self):
         return os.path.join("..", "templates", "latex")
 
     def _template_skeleton_path_default(self):
         return os.path.join("..", "templates", "latex", "skeleton")
 
     #Special Jinja2 syntax that will not conflict when exporting latex.
     jinja_comment_block_start = Unicode("((=", config=True)
     jinja_comment_block_end = Unicode("=))", config=True)
     jinja_variable_block_start = Unicode("(((", config=True)
     jinja_variable_block_end = Unicode(")))", config=True)
     jinja_logic_block_start = Unicode("((*", config=True)
     jinja_logic_block_end = Unicode("*))", config=True)
     
     #Extension that the template files use.    
     template_extension = Unicode(".tplx", config=True)
 
     output_mimetype = 'text/latex'
 
 
     @property
     def default_config(self):
         c = Config({
             'NbConvertBase': {
                 'display_data_priority' : ['text/latex', 'application/pdf', 'image/png', 'image/jpeg', 'image/svg+xml', 'text/plain']
                 },
              'ExtractOutputPreprocessor': {
                     'enabled':True
                  },
              'SVG2PDFPreprocessor': {
                     'enabled':True
                  },
              'LatexPreprocessor': {
                     'enabled':True
                  },
              'SphinxPreprocessor': {
                     'enabled':True
                  },
              'HighlightMagicsPreprocessor': {
                     'enabled':True
                  }
          })
         c.merge(super(LatexExporter,self).default_config)
         return c
 
     def from_notebook_node(self, nb, resources=None, **kw):
         langinfo = nb.metadata.get('language_info', {})
         lexer = langinfo.get('pygments_lexer', langinfo.get('name', None))
         self.register_filter('highlight_code',
                              Highlight2Latex(pygments_lexer=lexer, parent=self))
         return super(LatexExporter, self).from_notebook_node(nb, resources, **kw)

jupyter_nbconvert/exporters/pdf.py

@@ -1,147 +1,147 b''
 """Export to PDF via latex"""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import subprocess
 import os
 import sys
 
 from IPython.utils.process import find_cmd
 from IPython.utils.traitlets import Integer, List, Bool, Instance
 from IPython.utils.tempdir import TemporaryWorkingDirectory
 from .latex import LatexExporter
 
 
 class PDFExporter(LatexExporter):
     """Writer designed to write to PDF files"""
 
     latex_count = Integer(3, config=True,
         help="How many times latex will be called."
     )
 
     latex_command = List([u"pdflatex", u"{filename}"], config=True, 
         help="Shell command used to compile latex."
     )
 
     bib_command = List([u"bibtex", u"{filename}"], config=True,
         help="Shell command used to run bibtex."
     )
 
     verbose = Bool(False, config=True,
         help="Whether to display the output of latex commands."
     )
 
     temp_file_exts = List(['.aux', '.bbl', '.blg', '.idx', '.log', '.out'], config=True,
         help="File extensions of temp files to remove after running."
     )
     
-    writer = Instance("IPython.nbconvert.writers.FilesWriter", args=())
+    writer = Instance("jupyter_nbconvert.writers.FilesWriter", args=())
 
     def run_command(self, command_list, filename, count, log_function):
         """Run command_list count times.
         
         Parameters
         ----------
         command_list : list
             A list of args to provide to Popen. Each element of this
             list will be interpolated with the filename to convert.
         filename : unicode
             The name of the file to convert.
         count : int
             How many times to run the command.
         
         Returns
         -------
         success : bool
             A boolean indicating if the command was successful (True)
             or failed (False).
         """
         command = [c.format(filename=filename) for c in command_list]
 
         # On windows with python 2.x there is a bug in subprocess.Popen and
         # unicode commands are not supported
         if sys.platform == 'win32' and sys.version_info < (3,0):
             #We must use cp1252 encoding for calling subprocess.Popen
             #Note that sys.stdin.encoding and encoding.DEFAULT_ENCODING
             # could be different (cp437 in case of dos console)
             command = [c.encode('cp1252') for c in command]        
 
         # This will throw a clearer error if the command is not found
         find_cmd(command_list[0])
         
         times = 'time' if count == 1 else 'times'
         self.log.info("Running %s %i %s: %s", command_list[0], count, times, command)
         with open(os.devnull, 'rb') as null:
             stdout = subprocess.PIPE if not self.verbose else None
             for index in range(count):
                 p = subprocess.Popen(command, stdout=stdout, stdin=null)
                 out, err = p.communicate()
                 if p.returncode:
                     if self.verbose:
                         # verbose means I didn't capture stdout with PIPE,
                         # so it's already been displayed and `out` is None.
                         out = u''
                     else:
                         out = out.decode('utf-8', 'replace')
                     log_function(command, out)
                     return False # failure
         return True # success
 
     def run_latex(self, filename):
         """Run pdflatex self.latex_count times."""
 
         def log_error(command, out):
             self.log.critical(u"%s failed: %s\n%s", command[0], command, out)
 
         return self.run_command(self.latex_command, filename, 
             self.latex_count, log_error)
 
     def run_bib(self, filename):
         """Run bibtex self.latex_count times."""
         filename = os.path.splitext(filename)[0]
 
         def log_error(command, out):
             self.log.warn('%s had problems, most likely because there were no citations',
                 command[0])
             self.log.debug(u"%s output: %s\n%s", command[0], command, out)
 
         return self.run_command(self.bib_command, filename, 1, log_error)
 
     def clean_temp_files(self, filename):
         """Remove temporary files created by pdflatex/bibtex."""
         self.log.info("Removing temporary LaTeX files")
         filename = os.path.splitext(filename)[0]
         for ext in self.temp_file_exts:
             try:
                 os.remove(filename+ext)
             except OSError:
                 pass
 
     def from_notebook_node(self, nb, resources=None, **kw):
         latex, resources = super(PDFExporter, self).from_notebook_node(
             nb, resources=resources, **kw
         )
         with TemporaryWorkingDirectory() as td:
             notebook_name = "notebook"
             tex_file = self.writer.write(latex, resources, notebook_name=notebook_name)
             self.log.info("Building PDF")
             rc = self.run_latex(tex_file)
             if not rc:
                 rc = self.run_bib(tex_file)
             if not rc:
                 rc = self.run_latex(tex_file)
             
             pdf_file = notebook_name + '.pdf'
             if not os.path.isfile(pdf_file):
                 raise RuntimeError("PDF creating failed")
             self.log.info('PDF successfully created')
             with open(pdf_file, 'rb') as f:
                 pdf_data = f.read()
         
         # convert output extension to pdf
         # the writer above required it to be tex
         resources['output_extension'] = '.pdf'
         
         return pdf_data, resources
     

jupyter_nbconvert/exporters/slides.py

@@ -1,43 +1,43 b''
 """HTML slide show Exporter class"""
 
 #-----------------------------------------------------------------------------
 # 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 IPython.nbconvert import preprocessors
+from jupyter_nbconvert import preprocessors
 from IPython.config import Config
 
 from .html import HTMLExporter
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class SlidesExporter(HTMLExporter):
     """Exports HTML slides with reveal.js"""
     
     def _file_extension_default(self):
         return '.slides.html'
 
     def _template_file_default(self):
         return 'slides_reveal'
 
     output_mimetype = 'text/html'
 
     @property
     def default_config(self):
         c = Config({
             'RevealHelpPreprocessor': {
                 'enabled': True,
                 },
             })
         c.merge(super(SlidesExporter,self).default_config)
         return c

jupyter_nbconvert/exporters/templateexporter.py

@@ -1,321 +1,321 b''
 """This module defines TemplateExporter, a highly configurable converter
 that uses Jinja2 to export notebook files into different formats.
 """
 
 #-----------------------------------------------------------------------------
 # 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 os
 
 # other libs/dependencies are imported at runtime
 # to move ImportErrors to runtime when the requirement is actually needed
 
 # IPython imports
 from IPython.utils.traitlets import MetaHasTraits, Unicode, List, Dict, Any
 from IPython.utils.importstring import import_item
 from IPython.utils import py3compat, text
 
-from IPython.nbconvert import filters
+from jupyter_nbconvert import filters
 from .exporter import Exporter
 
 #-----------------------------------------------------------------------------
 # Globals and constants
 #-----------------------------------------------------------------------------
 
 #Jinja2 extensions to load.
 JINJA_EXTENSIONS = ['jinja2.ext.loopcontrols']
 
 default_filters = {
         'indent': text.indent,
         'markdown2html': filters.markdown2html,
         'ansi2html': filters.ansi2html,
         'filter_data_type': filters.DataTypeFilter,
         'get_lines': filters.get_lines,
         'highlight2html': filters.Highlight2HTML,
         'highlight2latex': filters.Highlight2Latex,
         'ipython2python': filters.ipython2python,
         'posix_path': filters.posix_path,
         'markdown2latex': filters.markdown2latex,
         'markdown2rst': filters.markdown2rst,
         'comment_lines': filters.comment_lines,
         'strip_ansi': filters.strip_ansi,
         'strip_dollars': filters.strip_dollars,
         'strip_files_prefix': filters.strip_files_prefix,
         'html2text' : filters.html2text,
         'add_anchor': filters.add_anchor,
         'ansi2latex': filters.ansi2latex,
         'wrap_text': filters.wrap_text,
         'escape_latex': filters.escape_latex,
         'citation2latex': filters.citation2latex,
         'path2url': filters.path2url,
         'add_prompts': filters.add_prompts,
         'ascii_only': filters.ascii_only,
         'prevent_list_blocks': filters.prevent_list_blocks,
 }
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class TemplateExporter(Exporter):
     """
     Exports notebooks into other file formats.  Uses Jinja 2 templating engine
     to output new formats.  Inherit from this class if you are creating a new
     template type along with new filters/preprocessors.  If the filters/
     preprocessors provided by default suffice, there is no need to inherit from
     this class.  Instead, override the template_file and file_extension
     traits via a config file.
 
     {filters}
     """
     
     # finish the docstring
     __doc__ = __doc__.format(filters = '- '+'\n    - '.join(default_filters.keys()))
 
 
     template_file = Unicode(u'default',
             config=True,
             help="Name of the template file to use")
     def _template_file_changed(self, name, old, new):
         if new == 'default':
             self.template_file = self.default_template
         else:
             self.template_file = new
         self.template = None
         self._load_template()
     
     default_template = Unicode(u'')
     template = Any()
     environment = Any()
 
     template_path = List(['.'], config=True)
     def _template_path_changed(self, name, old, new):
         self._load_template()
 
     default_template_path = Unicode(
         os.path.join("..", "templates"), 
         help="Path where the template files are located.")
 
     template_skeleton_path = Unicode(
         os.path.join("..", "templates", "skeleton"), 
         help="Path where the template skeleton files are located.") 
 
     #Jinja block definitions
     jinja_comment_block_start = Unicode("", config=True)
     jinja_comment_block_end = Unicode("", config=True)
     jinja_variable_block_start = Unicode("", config=True)
     jinja_variable_block_end = Unicode("", config=True)
     jinja_logic_block_start = Unicode("", config=True)
     jinja_logic_block_end = Unicode("", config=True)
     
     #Extension that the template files use.    
     template_extension = Unicode(".tpl", config=True)
 
     filters = Dict(config=True,
         help="""Dictionary of filters, by name and namespace, to add to the Jinja
         environment.""")
 
     raw_mimetypes = List(config=True,
         help="""formats of raw cells to be included in this Exporter's output."""
     )
     def _raw_mimetypes_default(self):
         return [self.output_mimetype, '']
 
 
     def __init__(self, config=None, extra_loaders=None, **kw):
         """
         Public constructor
     
         Parameters
         ----------
         config : config
             User configuration instance.
         extra_loaders : list[of Jinja Loaders]
             ordered list of Jinja loader to find templates. Will be tried in order
             before the default FileSystem ones.
         template : str (optional, kw arg)
             Template to use when exporting.
         """
         super(TemplateExporter, self).__init__(config=config, **kw)
 
         #Init
         self._init_template()
         self._init_environment(extra_loaders=extra_loaders)
         self._init_filters()
 
 
     def _load_template(self):
         """Load the Jinja template object from the template file
         
         This is a no-op if the template attribute is already defined,
         or the Jinja environment is not setup yet.
         
         This is triggered by various trait changes that would change the template.
         """
         from jinja2 import TemplateNotFound
         
         if self.template is not None:
             return
         # called too early, do nothing
         if self.environment is None:
             return
         # Try different template names during conversion.  First try to load the
         # template by name with extension added, then try loading the template
         # as if the name is explicitly specified, then try the name as a 
         # 'flavor', and lastly just try to load the template by module name.
         try_names = []
         if self.template_file:
             try_names.extend([
                 self.template_file + self.template_extension,
                 self.template_file,
             ])
         for try_name in try_names:
             self.log.debug("Attempting to load template %s", try_name)
             try:
                 self.template = self.environment.get_template(try_name)
             except (TemplateNotFound, IOError):
                 pass
             except Exception as e:
                 self.log.warn("Unexpected exception loading template: %s", try_name, exc_info=True)
             else:
                 self.log.debug("Loaded template %s", try_name)
                 break
 
     def from_notebook_node(self, nb, resources=None, **kw):
         """
         Convert a notebook from a notebook node instance.
     
         Parameters
         ----------
         nb : :class:`~IPython.nbformat.NotebookNode`
           Notebook node
         resources : dict
           Additional resources that can be accessed read/write by
           preprocessors and filters.
         """
         nb_copy, resources = super(TemplateExporter, self).from_notebook_node(nb, resources, **kw)
         resources.setdefault('raw_mimetypes', self.raw_mimetypes)
 
         self._load_template()
 
         if self.template is not None:
             output = self.template.render(nb=nb_copy, resources=resources)
         else:
             raise IOError('template file "%s" could not be found' % self.template_file)
         return output, resources
 
 
     def register_filter(self, name, jinja_filter):
         """
         Register a filter.
         A filter is a function that accepts and acts on one string.  
         The filters are accesible within the Jinja templating engine.
     
         Parameters
         ----------
         name : str
             name to give the filter in the Jinja engine
         filter : filter
         """
         if jinja_filter is None:
             raise TypeError('filter')
         isclass = isinstance(jinja_filter, type)
         constructed = not isclass
 
         #Handle filter's registration based on it's type
         if constructed and isinstance(jinja_filter, py3compat.string_types):
             #filter is a string, import the namespace and recursively call
             #this register_filter method
             filter_cls = import_item(jinja_filter)
             return self.register_filter(name, filter_cls)
         
         if constructed and hasattr(jinja_filter, '__call__'):
             #filter is a function, no need to construct it.
             self.environment.filters[name] = jinja_filter
             return jinja_filter
 
         elif isclass and isinstance(jinja_filter, MetaHasTraits):
             #filter is configurable.  Make sure to pass in new default for 
             #the enabled flag if one was specified.
             filter_instance = jinja_filter(parent=self)
             self.register_filter(name, filter_instance )
 
         elif isclass:
             #filter is not configurable, construct it
             filter_instance = jinja_filter()
             self.register_filter(name, filter_instance)
 
         else:
             #filter is an instance of something without a __call__ 
             #attribute.  
             raise TypeError('filter')
 
         
     def _init_template(self):
         """
         Make sure a template name is specified.  If one isn't specified, try to
         build one from the information we know.
         """
         self._template_file_changed('template_file', self.template_file, self.template_file)
         
 
     def _init_environment(self, extra_loaders=None):
         """
         Create the Jinja templating environment.
         """
         from jinja2 import Environment, ChoiceLoader, FileSystemLoader
         here = os.path.dirname(os.path.realpath(__file__))
         loaders = []
         if extra_loaders:
             loaders.extend(extra_loaders)
 
         paths = self.template_path
         paths.extend([os.path.join(here, self.default_template_path),
                       os.path.join(here, self.template_skeleton_path)])
         loaders.append(FileSystemLoader(paths))
 
         self.environment = Environment(
             loader= ChoiceLoader(loaders),
             extensions=JINJA_EXTENSIONS
             )
         
         #Set special Jinja2 syntax that will not conflict with latex.
         if self.jinja_logic_block_start:
             self.environment.block_start_string = self.jinja_logic_block_start
         if self.jinja_logic_block_end:
             self.environment.block_end_string = self.jinja_logic_block_end
         if self.jinja_variable_block_start:
             self.environment.variable_start_string = self.jinja_variable_block_start
         if self.jinja_variable_block_end:
             self.environment.variable_end_string = self.jinja_variable_block_end
         if self.jinja_comment_block_start:
             self.environment.comment_start_string = self.jinja_comment_block_start
         if self.jinja_comment_block_end:
             self.environment.comment_end_string = self.jinja_comment_block_end
 
     
     def _init_filters(self):
         """
         Register all of the filters required for the exporter.
         """
         
         #Add default filters to the Jinja2 environment
         for key, value in default_filters.items():
             self.register_filter(key, value)
 
         #Load user filters.  Overwrite existing filters if need be.
         if self.filters:
             for key, user_filter in self.filters.items():
                 self.register_filter(key, user_filter)

jupyter_nbconvert/exporters/tests/test_templateexporter.py

@@ -1,108 +1,108 b''
 """
 Module with tests for 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 IPython.config import Config
 
 from .base import ExportersTestsBase
 from .cheese import CheesePreprocessor
 from ..templateexporter import TemplateExporter
 
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class TestExporter(ExportersTestsBase):
     """Contains test functions for exporter.py"""
 
 
     def test_constructor(self):
         """
         Can a TemplateExporter be constructed?
         """
         TemplateExporter()
 
 
     def test_export(self):
         """
         Can a TemplateExporter export something?
         """
         exporter = self._make_exporter()
         (output, resources) = exporter.from_filename(self._get_notebook())
         assert len(output) > 0
 
 
     def test_extract_outputs(self):
         """
         If the ExtractOutputPreprocessor is enabled, are outputs extracted?
         """
         config = Config({'ExtractOutputPreprocessor': {'enabled': True}})
         exporter = self._make_exporter(config=config)
         (output, resources) = exporter.from_filename(self._get_notebook())
         assert resources is not None
         assert isinstance(resources['outputs'], dict)
         assert len(resources['outputs']) > 0
 
 
     def test_preprocessor_class(self):
         """
         Can a preprocessor be added to the preprocessors list by class type?
         """
         config = Config({'Exporter': {'preprocessors': [CheesePreprocessor]}})
         exporter = self._make_exporter(config=config)
         (output, resources) = exporter.from_filename(self._get_notebook())
         assert resources is not None
         assert resources['cheese'] == 'real'
 
 
     def test_preprocessor_instance(self):
         """
         Can a preprocessor be added to the preprocessors list by instance?
         """
         config = Config({'Exporter': {'preprocessors': [CheesePreprocessor()]}})
         exporter = self._make_exporter(config=config)
         (output, resources) = exporter.from_filename(self._get_notebook())
         assert resources is not None
         assert resources['cheese'] == 'real'
 
 
     def test_preprocessor_dottedobjectname(self):
         """
         Can a preprocessor be added to the preprocessors list by dotted object name?
         """
-        config = Config({'Exporter': {'preprocessors': ['IPython.nbconvert.exporters.tests.cheese.CheesePreprocessor']}})
+        config = Config({'Exporter': {'preprocessors': ['jupyter_nbconvert.exporters.tests.cheese.CheesePreprocessor']}})
         exporter = self._make_exporter(config=config)
         (output, resources) = exporter.from_filename(self._get_notebook())
         assert resources is not None
         assert resources['cheese'] == 'real'
 
 
     def test_preprocessor_via_method(self):
         """
         Can a preprocessor be added via the Exporter convenience method?
         """
         exporter = self._make_exporter()
         exporter.register_preprocessor(CheesePreprocessor, enabled=True)
         (output, resources) = exporter.from_filename(self._get_notebook())
         assert resources is not None
         assert resources['cheese'] == 'real'
 
 
     def _make_exporter(self, config=None):
         # Create the exporter instance, make sure to set a template name since
         # the base TemplateExporter doesn't have a template associated with it.
         exporter = TemplateExporter(config=config, template_file='python')
         return exporter        

jupyter_nbconvert/filters/highlight.py

@@ -1,135 +1,135 b''
 """
 Module containing filter functions that allow code to be highlighted
 from within Jinja templates.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 # pygments must not be imported at the module level
 # because errors should be raised at runtime if it's actually needed,
 # not import time, when it may not be needed.
 
-from IPython.nbconvert.utils.base import NbConvertBase
+from jupyter_nbconvert.utils.base import NbConvertBase
 from warnings import warn
 
 MULTILINE_OUTPUTS = ['text', 'html', 'svg', 'latex', 'javascript', 'json']
 
 __all__ = [
     'Highlight2HTML',
     'Highlight2Latex'
 ]
 
 class Highlight2HTML(NbConvertBase):
     def __init__(self, pygments_lexer=None, **kwargs):
         self.pygments_lexer = pygments_lexer or 'ipython3'
         super(Highlight2HTML, self).__init__(**kwargs)
 
     def _default_language_changed(self, name, old, new):
         warn('Setting default_language in config is deprecated, '
              'please use language_info metadata instead.')
         self.pygments_lexer = new
 
     def __call__(self, source, language=None, metadata=None):
         """
         Return a syntax-highlighted version of the input source as html output.
 
         Parameters
         ----------
         source : str
             source of the cell to highlight
         language : str
             language to highlight the syntax of
         metadata : NotebookNode cell metadata
             metadata of the cell to highlight
         """
         from pygments.formatters import HtmlFormatter
 
         if not language:
             language=self.pygments_lexer
 
         return _pygments_highlight(source if len(source) > 0 else ' ',
                                    # needed to help post processors:
                                    HtmlFormatter(cssclass=" highlight hl-"+language),
                                    language, metadata)
 
 
 class Highlight2Latex(NbConvertBase):
     def __init__(self, pygments_lexer=None, **kwargs):
         self.pygments_lexer = pygments_lexer or 'ipython3'
         super(Highlight2Latex, self).__init__(**kwargs)
 
     def _default_language_changed(self, name, old, new):
         warn('Setting default_language in config is deprecated, '
              'please use language_info metadata instead.')
         self.pygments_lexer = new
 
     def __call__(self, source, language=None, metadata=None, strip_verbatim=False):
         """
         Return a syntax-highlighted version of the input source as latex output.
 
         Parameters
         ----------
         source : str
             source of the cell to highlight
         language : str
             language to highlight the syntax of
         metadata : NotebookNode cell metadata
             metadata of the cell to highlight
         strip_verbatim : bool
             remove the Verbatim environment that pygments provides by default
         """
         from pygments.formatters import LatexFormatter
         if not language:
             language=self.pygments_lexer
 
         latex = _pygments_highlight(source, LatexFormatter(), language, metadata)
         if strip_verbatim:
             latex = latex.replace(r'\begin{Verbatim}[commandchars=\\\{\}]' + '\n', '')
             return latex.replace('\n\\end{Verbatim}\n', '')
         else:
             return latex
 
 
 
 def _pygments_highlight(source, output_formatter, language='ipython', metadata=None):
     """
     Return a syntax-highlighted version of the input source
 
     Parameters
     ----------
     source : str
         source of the cell to highlight
     output_formatter : Pygments formatter
     language : str
         language to highlight the syntax of
     metadata : NotebookNode cell metadata
         metadata of the cell to highlight
     """
     from pygments import highlight
     from pygments.lexers import get_lexer_by_name
     from pygments.util import ClassNotFound
     from IPython.lib.lexers import IPythonLexer, IPython3Lexer
 
     # If the cell uses a magic extension language,
     # use the magic language instead.
     if language.startswith('ipython') \
         and metadata \
         and 'magics_language' in metadata:
 
         language = metadata['magics_language']
 
     if language == 'ipython2':
         lexer = IPythonLexer()
     elif language == 'ipython3':
         lexer = IPython3Lexer()
     else:
         try:
             lexer = get_lexer_by_name(language, stripall=True)
         except ClassNotFound:
             warn("No lexer found for language %r. Treating as plain text." % language)
             from pygments.lexers.special import TextLexer
             lexer = TextLexer()
 
 
     return highlight(source, lexer, output_formatter)

jupyter_nbconvert/filters/markdown.py

@@ -1,140 +1,140 b''
 """Markdown filters
 
 This file contains a collection of utility filters for dealing with 
 markdown within Jinja templates.
 """
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from __future__ import print_function
 
 import os
 import subprocess
 from io import TextIOWrapper, BytesIO
 
 try:
     from .markdown_mistune import markdown2html_mistune
 except ImportError as e:
     # store in variable for Python 3
     _mistune_import_error = e
     def markdown2html_mistune(source):
         """mistune is unavailable, raise ImportError"""
         raise ImportError("markdown2html requires mistune: %s" % _mistune_import_error)
 
-from IPython.nbconvert.utils.pandoc import pandoc
-from IPython.nbconvert.utils.exceptions import ConversionException
+from jupyter_nbconvert.utils.pandoc import pandoc
+from jupyter_nbconvert.utils.exceptions import ConversionException
 from IPython.utils.process import get_output_error_code
 from IPython.utils.py3compat import cast_bytes
 from IPython.utils.version import check_version
 
 
 marked = os.path.join(os.path.dirname(__file__), "marked.js")
 _node = None
 
 __all__ = [
     'markdown2html',
     'markdown2html_pandoc',
     'markdown2html_marked',
     'markdown2html_mistune',
     'markdown2latex',
     'markdown2rst',
 ]
 
 class NodeJSMissing(ConversionException):
     """Exception raised when node.js is missing."""
     pass
 
 
 def markdown2latex(source, markup='markdown', extra_args=None):
     """Convert a markdown string to LaTeX via pandoc.
 
     This function will raise an error if pandoc is not installed.
     Any error messages generated by pandoc are printed to stderr.
 
     Parameters
     ----------
     source : string
       Input string, assumed to be valid markdown.
     markup : string
       Markup used by pandoc's reader
       default : pandoc extended markdown
       (see http://johnmacfarlane.net/pandoc/README.html#pandocs-markdown)
 
     Returns
     -------
     out : string
       Output as returned by pandoc.
     """
     return pandoc(source, markup, 'latex', extra_args=extra_args)
 
 
 def markdown2html_pandoc(source, extra_args=None):
     """Convert a markdown string to HTML via pandoc"""
     extra_args = extra_args or ['--mathjax']
     return pandoc(source, 'markdown', 'html', extra_args=extra_args)
 
 
 def _find_nodejs():
     global _node
     if _node is None:
         # prefer md2html via marked if node.js >= 0.9.12 is available
         # node is called nodejs on debian, so try that first
         _node = 'nodejs'
         if not _verify_node(_node):
             _node = 'node'
     return _node
 
 def markdown2html_marked(source, encoding='utf-8'):
     """Convert a markdown string to HTML via marked"""
     command = [_find_nodejs(), marked]
     try:
         p = subprocess.Popen(command,
                              stdin=subprocess.PIPE, stdout=subprocess.PIPE
         )
     except OSError as e:
         raise NodeJSMissing(
             "The command '%s' returned an error: %s.\n" % (" ".join(command), e) +
             "Please check that Node.js is installed."
         )
     out, _ = p.communicate(cast_bytes(source, encoding))
     out = TextIOWrapper(BytesIO(out), encoding, 'replace').read()
     return out.rstrip('\n')
 
 # The mistune renderer is the default, because it's simple to depend on it
 markdown2html = markdown2html_mistune
 
 def markdown2rst(source, extra_args=None):
     """Convert a markdown string to ReST via pandoc.
 
     This function will raise an error if pandoc is not installed.
     Any error messages generated by pandoc are printed to stderr.
 
     Parameters
     ----------
     source : string
       Input string, assumed to be valid markdown.
 
     Returns
     -------
     out : string
       Output as returned by pandoc.
     """
     return pandoc(source, 'markdown', 'rst', extra_args=extra_args)
 
 def _verify_node(cmd):
     """Verify that the node command exists and is at least the minimum supported
     version of node.
 
     Parameters
     ----------
     cmd : string
         Node command to verify (i.e 'node')."""
     try:
         out, err, return_code = get_output_error_code([cmd, '--version'])
     except OSError:
         # Command not found
         return False
     if return_code:
         # Command error
         return False
     return check_version(out.lstrip('v'), '0.9.12')

jupyter_nbconvert/filters/markdown_mistune.py

@@ -1,122 +1,122 b''
 """Markdown filters with mistune
 
 Used from markdown.py
 """
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from __future__ import print_function
 
 import re
 
 import mistune
 
 from pygments import highlight
 from pygments.lexers import get_lexer_by_name
 from pygments.formatters import HtmlFormatter
 from pygments.util import ClassNotFound
 
-from IPython.nbconvert.filters.strings import add_anchor
-from IPython.nbconvert.utils.exceptions import ConversionException
+from jupyter_nbconvert.filters.strings import add_anchor
+from jupyter_nbconvert.utils.exceptions import ConversionException
 from IPython.utils.decorators import undoc
 
 
 @undoc
 class MathBlockGrammar(mistune.BlockGrammar):
     block_math = re.compile(r"^\$\$(.*?)\$\$", re.DOTALL)
     latex_environment = re.compile(r"^\\begin\{([a-z]*\*?)\}(.*?)\\end\{\1\}",
                                                 re.DOTALL)
 
 @undoc
 class MathBlockLexer(mistune.BlockLexer):
     default_rules = ['block_math', 'latex_environment'] + mistune.BlockLexer.default_rules
 
     def __init__(self, rules=None, **kwargs):
         if rules is None:
             rules = MathBlockGrammar()
         super(MathBlockLexer, self).__init__(rules, **kwargs)
 
     def parse_block_math(self, m):
         """Parse a $$math$$ block"""
         self.tokens.append({
             'type': 'block_math',
             'text': m.group(1)
         })
 
     def parse_latex_environment(self, m):
         self.tokens.append({
             'type': 'latex_environment',
             'name': m.group(1),
             'text': m.group(2)
         })
 
 @undoc
 class MathInlineGrammar(mistune.InlineGrammar):
     math = re.compile(r"^\$(.+?)\$")
     block_math = re.compile(r"^\$\$(.+?)\$\$", re.DOTALL)
     text = re.compile(r'^[\s\S]+?(?=[\\<!\[_*`~$]|https?://| {2,}\n|$)')
 
 @undoc
 class MathInlineLexer(mistune.InlineLexer):
     default_rules = ['math', 'block_math'] + mistune.InlineLexer.default_rules
 
     def __init__(self, renderer, rules=None, **kwargs):
         if rules is None:
             rules = MathInlineGrammar()
         super(MathInlineLexer, self).__init__(renderer, rules, **kwargs)
 
     def output_math(self, m):
         return self.renderer.inline_math(m.group(1))
 
     def output_block_math(self, m):
         return self.renderer.block_math(m.group(1))
 
 @undoc
 class MarkdownWithMath(mistune.Markdown):
     def __init__(self, renderer, **kwargs):
         if 'inline' not in kwargs:
             kwargs['inline'] = MathInlineLexer
         if 'block' not in kwargs:
             kwargs['block'] = MathBlockLexer
         super(MarkdownWithMath, self).__init__(renderer, **kwargs)
 
     def output_block_math(self):
         return self.renderer.block_math(self.token['text'])
 
     def output_latex_environment(self):
         return self.renderer.latex_environment(self.token['name'], self.token['text'])
 
 @undoc
 class IPythonRenderer(mistune.Renderer):
     def block_code(self, code, lang):
         if lang:
             try:
                 lexer = get_lexer_by_name(lang, stripall=True)
             except ClassNotFound:
                 code = lang + '\n' + code
                 lang = None
 
         if not lang:
             return '\n<pre><code>%s</code></pre>\n' % \
                 mistune.escape(code)
 
         formatter = HtmlFormatter()
         return highlight(code, lexer, formatter)
 
     def header(self, text, level, raw=None):
         html = super(IPythonRenderer, self).header(text, level, raw=raw)
         return add_anchor(html)
 
     # Pass math through unaltered - mathjax does the rendering in the browser
     def block_math(self, text):
         return '$$%s$$' % text
 
     def latex_environment(self, name, text):
         return r'\begin{%s}%s\end{%s}' % (name, text, name)
 
     def inline_math(self, text):
         return '$%s$' % text
 
 def markdown2html_mistune(source):
     """Convert a markdown string to HTML using mistune"""
     return MarkdownWithMath(renderer=IPythonRenderer()).render(source)

jupyter_nbconvert/nbconvertapp.py

@@ -1,407 +1,407 b''
 #!/usr/bin/env python
 """NbConvert is a utility for conversion of .ipynb files.
 
 Command-line interface for the NbConvert conversion utility.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from __future__ import print_function
 
 import logging
 import sys
 import os
 import glob
 
 from IPython.core.application import BaseIPythonApplication, base_aliases, base_flags
 from IPython.core.profiledir import ProfileDir
 from IPython.config import catch_config_error, Configurable
 from IPython.utils.traitlets import (
     Unicode, List, Instance, DottedObjectName, Type, CaselessStrEnum, Bool,
 )
 from IPython.utils.importstring import import_item
 
 from .exporters.export import get_export_names, exporter_map
-from IPython.nbconvert import exporters, preprocessors, writers, postprocessors
+from jupyter_nbconvert import exporters, preprocessors, writers, postprocessors
 from .utils.base import NbConvertBase
 from .utils.exceptions import ConversionException
 
 #-----------------------------------------------------------------------------
 #Classes and functions
 #-----------------------------------------------------------------------------
 
 class DottedOrNone(DottedObjectName):
     """
     A string holding a valid dotted object name in Python, such as A.b3._c
     Also allows for None type."""
     
     default_value = u''
 
     def validate(self, obj, value):
         if value is not None and len(value) > 0:
             return super(DottedOrNone, self).validate(obj, value)
         else:
             return value
             
 nbconvert_aliases = {}
 nbconvert_aliases.update(base_aliases)
 nbconvert_aliases.update({
     'to' : 'NbConvertApp.export_format',
     'template' : 'TemplateExporter.template_file',
     'writer' : 'NbConvertApp.writer_class',
     'post': 'NbConvertApp.postprocessor_class',
     'output': 'NbConvertApp.output_base',
     'reveal-prefix': 'RevealHelpPreprocessor.url_prefix',
     'nbformat': 'NotebookExporter.nbformat_version',
 })
 
 nbconvert_flags = {}
 nbconvert_flags.update(base_flags)
 nbconvert_flags.update({
     'execute' : (
         {'ExecutePreprocessor' : {'enabled' : True}},
         "Execute the notebook prior to export."
         ),
     'stdout' : (
         {'NbConvertApp' : {'writer_class' : "StdoutWriter"}},
         "Write notebook output to stdout instead of files."
         ),
     'inplace' : (
         {
             'NbConvertApp' : {'use_output_suffix' : False},
             'FilesWriter': {'build_directory': ''}
         },
         """Run nbconvert in place, overwriting the existing notebook (only 
         relevant when converting to notebook format)"""
         )
 })
 
 
 class NbConvertApp(BaseIPythonApplication):
     """Application used to convert from notebook file type (``*.ipynb``)"""
 
     name = 'ipython-nbconvert'
     aliases = nbconvert_aliases
     flags = nbconvert_flags
     
     def _log_level_default(self):
         return logging.INFO
     
     def _classes_default(self):
         classes = [NbConvertBase, ProfileDir]
         for pkg in (exporters, preprocessors, writers, postprocessors):
             for name in dir(pkg):
                 cls = getattr(pkg, name)
                 if isinstance(cls, type) and issubclass(cls, Configurable):
                     classes.append(cls)
         
         return classes
 
     description = Unicode(
         u"""This application is used to convert notebook files (*.ipynb)
         to various other formats.
 
         WARNING: THE COMMANDLINE INTERFACE MAY CHANGE IN FUTURE RELEASES.""")
 
     output_base = Unicode('', config=True, help='''overwrite base name use for output files.
             can only be used when converting one notebook at a time.
             ''')
 
     use_output_suffix = Bool(
         True, 
         config=True,
         help="""Whether to apply a suffix prior to the extension (only relevant
             when converting to notebook format). The suffix is determined by
             the exporter, and is usually '.nbconvert'.""")
 
     examples = Unicode(u"""
         The simplest way to use nbconvert is
         
         > ipython nbconvert mynotebook.ipynb
         
         which will convert mynotebook.ipynb to the default format (probably HTML).
         
         You can specify the export format with `--to`.
         Options include {0}
         
         > ipython nbconvert --to latex mynotebook.ipynb
 
         Both HTML and LaTeX support multiple output templates. LaTeX includes
         'base', 'article' and 'report'.  HTML includes 'basic' and 'full'. You
         can specify the flavor of the format used.
 
         > ipython nbconvert --to html --template basic mynotebook.ipynb
         
         You can also pipe the output to stdout, rather than a file
         
         > ipython nbconvert mynotebook.ipynb --stdout
 
         PDF is generated via latex
 
         > ipython nbconvert mynotebook.ipynb --to pdf
         
         You can get (and serve) a Reveal.js-powered slideshow
         
         > ipython nbconvert myslides.ipynb --to slides --post serve
         
         Multiple notebooks can be given at the command line in a couple of 
         different ways:
   
         > ipython nbconvert notebook*.ipynb
         > ipython nbconvert notebook1.ipynb notebook2.ipynb
         
         or you can specify the notebooks list in a config file, containing::
         
             c.NbConvertApp.notebooks = ["my_notebook.ipynb"]
         
         > ipython nbconvert --config mycfg.py
         """.format(get_export_names()))
 
     # Writer specific variables
-    writer = Instance('IPython.nbconvert.writers.base.WriterBase',  
+    writer = Instance('jupyter_nbconvert.writers.base.WriterBase',  
                       help="""Instance of the writer class used to write the 
                       results of the conversion.""")
     writer_class = DottedObjectName('FilesWriter', config=True, 
                                     help="""Writer class used to write the 
                                     results of the conversion""")
-    writer_aliases = {'fileswriter': 'IPython.nbconvert.writers.files.FilesWriter',
-                      'debugwriter': 'IPython.nbconvert.writers.debug.DebugWriter',
-                      'stdoutwriter': 'IPython.nbconvert.writers.stdout.StdoutWriter'}
+    writer_aliases = {'fileswriter': 'jupyter_nbconvert.writers.files.FilesWriter',
+                      'debugwriter': 'jupyter_nbconvert.writers.debug.DebugWriter',
+                      'stdoutwriter': 'jupyter_nbconvert.writers.stdout.StdoutWriter'}
     writer_factory = Type()
 
     def _writer_class_changed(self, name, old, new):
         if new.lower() in self.writer_aliases:
             new = self.writer_aliases[new.lower()]
         self.writer_factory = import_item(new)
 
     # Post-processor specific variables
-    postprocessor = Instance('IPython.nbconvert.postprocessors.base.PostProcessorBase',  
+    postprocessor = Instance('jupyter_nbconvert.postprocessors.base.PostProcessorBase',  
                       help="""Instance of the PostProcessor class used to write the 
                       results of the conversion.""")
 
     postprocessor_class = DottedOrNone(config=True, 
                                     help="""PostProcessor class used to write the 
                                     results of the conversion""")
-    postprocessor_aliases = {'serve': 'IPython.nbconvert.postprocessors.serve.ServePostProcessor'}
+    postprocessor_aliases = {'serve': 'jupyter_nbconvert.postprocessors.serve.ServePostProcessor'}
     postprocessor_factory = Type()
 
     def _postprocessor_class_changed(self, name, old, new):
         if new.lower() in self.postprocessor_aliases:
             new = self.postprocessor_aliases[new.lower()]
         if new:
             self.postprocessor_factory = import_item(new)
 
 
     # Other configurable variables
     export_format = CaselessStrEnum(get_export_names(),
         default_value="html",
         config=True,
         help="""The export format to be used."""
     )
 
     notebooks = List([], config=True, help="""List of notebooks to convert.
                      Wildcards are supported.
                      Filenames passed positionally will be added to the list.
                      """)
 
     @catch_config_error
     def initialize(self, argv=None):
         self.init_syspath()
         super(NbConvertApp, self).initialize(argv)
         self.init_notebooks()
         self.init_writer()
         self.init_postprocessor()
 
 
 
     def init_syspath(self):
         """
         Add the cwd to the sys.path ($PYTHONPATH)
         """
         sys.path.insert(0, os.getcwd())
         
 
     def init_notebooks(self):
         """Construct the list of notebooks.
         If notebooks are passed on the command-line,
         they override notebooks specified in config files.
         Glob each notebook to replace notebook patterns with filenames.
         """
 
         # Specifying notebooks on the command-line overrides (rather than adds)
         # the notebook list
         if self.extra_args:
             patterns = self.extra_args
         else:
             patterns = self.notebooks
 
         # Use glob to replace all the notebook patterns with filenames.
         filenames = []
         for pattern in patterns:
             
             # Use glob to find matching filenames.  Allow the user to convert 
             # notebooks without having to type the extension.
             globbed_files = glob.glob(pattern)
             globbed_files.extend(glob.glob(pattern + '.ipynb'))
             if not globbed_files:
                 self.log.warn("pattern %r matched no files", pattern)
 
             for filename in globbed_files:
                 if not filename in filenames:
                     filenames.append(filename)
         self.notebooks = filenames
 
     def init_writer(self):
         """
         Initialize the writer (which is stateless)
         """
         self._writer_class_changed(None, self.writer_class, self.writer_class)
         self.writer = self.writer_factory(parent=self)
         if hasattr(self.writer, 'build_directory') and self.writer.build_directory != '':
             self.use_output_suffix = False
 
     def init_postprocessor(self):
         """
         Initialize the postprocessor (which is stateless)
         """
         self._postprocessor_class_changed(None, self.postprocessor_class, 
             self.postprocessor_class)
         if self.postprocessor_factory:
             self.postprocessor = self.postprocessor_factory(parent=self)
 
     def start(self):
         """
         Ran after initialization completed
         """
         super(NbConvertApp, self).start()
         self.convert_notebooks()
 
     def init_single_notebook_resources(self, notebook_filename):
         """Step 1: Initialize resources
 
         This intializes the resources dictionary for a single notebook. This
         method should return the resources dictionary, and MUST include the
         following keys:
 
             - profile_dir: the location of the profile directory
             - unique_key: the notebook name
             - output_files_dir: a directory where output files (not including
               the notebook itself) should be saved
 
         """
 
         # Get a unique key for the notebook and set it in the resources object.
         basename = os.path.basename(notebook_filename)
         notebook_name = basename[:basename.rfind('.')]
         if self.output_base:
             # strip duplicate extension from output_base, to avoid Basname.ext.ext
             if getattr(self.exporter, 'file_extension', False):
                 base, ext = os.path.splitext(self.output_base)
                 if ext == self.exporter.file_extension:
                     self.output_base = base
             notebook_name = self.output_base
 
         self.log.debug("Notebook name is '%s'", notebook_name)
 
         # first initialize the resources we want to use
         resources = {}
         resources['profile_dir'] = self.profile_dir.location
         resources['unique_key'] = notebook_name
         resources['output_files_dir'] = '%s_files' % notebook_name
 
         return resources
 
     def export_single_notebook(self, notebook_filename, resources):
         """Step 2: Export the notebook
 
         Exports the notebook to a particular format according to the specified
         exporter. This function returns the output and (possibly modified)
         resources from the exporter.
 
         """
         try:
             output, resources = self.exporter.from_filename(notebook_filename, resources=resources)
         except ConversionException:
             self.log.error("Error while converting '%s'", notebook_filename, exc_info=True)
             self.exit(1)
 
         return output, resources
 
     def write_single_notebook(self, output, resources):
         """Step 3: Write the notebook to file
 
         This writes output from the exporter to file using the specified writer.
         It returns the results from the writer.
 
         """
         if 'unique_key' not in resources:
             raise KeyError("unique_key MUST be specified in the resources, but it is not")
 
         notebook_name = resources['unique_key']
         if self.use_output_suffix and not self.output_base:
             notebook_name += resources.get('output_suffix', '')
 
         write_results = self.writer.write(
             output, resources, notebook_name=notebook_name)
         return write_results
 
     def postprocess_single_notebook(self, write_results):
         """Step 4: Postprocess the notebook
 
         This postprocesses the notebook after it has been written, taking as an
         argument the results of writing the notebook to file. This only actually
         does anything if a postprocessor has actually been specified.
 
         """
         # Post-process if post processor has been defined.
         if hasattr(self, 'postprocessor') and self.postprocessor:
             self.postprocessor(write_results)
 
     def convert_single_notebook(self, notebook_filename):
         """Convert a single notebook. Performs the following steps:
 
             1. Initialize notebook resources
             2. Export the notebook to a particular format
             3. Write the exported notebook to file
             4. (Maybe) postprocess the written file
 
         """
         self.log.info("Converting notebook %s to %s", notebook_filename, self.export_format)
         resources = self.init_single_notebook_resources(notebook_filename)
         output, resources = self.export_single_notebook(notebook_filename, resources)
         write_results = self.write_single_notebook(output, resources)
         self.postprocess_single_notebook(write_results)
 
     def convert_notebooks(self):
         """
         Convert the notebooks in the self.notebook traitlet
         """
         # check that the output base isn't specified if there is more than
         # one notebook to convert
         if self.output_base != '' and len(self.notebooks) > 1:
             self.log.error(
                 """
                 UsageError: --output flag or `NbConvertApp.output_base` config option
                 cannot be used when converting multiple notebooks.
                 """
             )
             self.exit(1)
         
         # initialize the exporter
         self.exporter = exporter_map[self.export_format](config=self.config)
 
         # no notebooks to convert!
         if len(self.notebooks) == 0:
             self.print_help()
             sys.exit(-1)
 
         # convert each notebook
         for notebook_filename in self.notebooks:
             self.convert_single_notebook(notebook_filename)
             
 #-----------------------------------------------------------------------------
 # Main entry point
 #-----------------------------------------------------------------------------
 
 launch_new_instance = NbConvertApp.launch_instance

jupyter_nbconvert/preprocessors/tests/test_execute.py

@@ -1,151 +1,151 b''
 """
 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
 
 try:
     from queue import Empty  # Py 3
 except ImportError:
     from Queue import Empty  # Py 2
 
 from IPython import nbformat
 
 from .base import PreprocessorTestsBase
 from ..execute import ExecutePreprocessor
 
-from IPython.nbconvert.filters import strip_ansi
+from jupyter_nbconvert.filters import strip_ansi
 from nose.tools import assert_raises
 
 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, opts):
         """Make an instance of a preprocessor"""
         preprocessor = ExecutePreprocessor()
         preprocessor.enabled = True
         for opt in opts:
             setattr(preprocessor, opt, opts[opt])
         return preprocessor
 
 
     def test_constructor(self):
         """Can a ExecutePreprocessor be constructed?"""
         self.build_preprocessor({})
 
 
     def run_notebook(self, filename, opts, resources):
         """Loads and runs a notebook, returning both the version prior to 
         running it and the version after running it.
 
         """
         with io.open(filename) as f:
             input_nb = nbformat.read(f, 4)
         preprocessor = self.build_preprocessor(opts)
         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, resources)
         return input_nb, output_nb
 
     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:
             if os.path.basename(filename) == "Disable Stdin.ipynb":
                 continue
             elif os.path.basename(filename) == "Interrupt.ipynb":
                 opts = dict(timeout=1, interrupt_on_timeout=True)
             else:
                 opts = {}
             res = self.build_resources()
             res['metadata']['path'] = os.path.dirname(filename)
             input_nb, output_nb = self.run_notebook(filename, opts, res)
             self.assert_notebooks_equal(input_nb, output_nb)
 
     def test_empty_path(self):
         """Can the kernel be started when the path is empty?"""
         current_dir = os.path.dirname(__file__)
         filename = os.path.join(current_dir, 'files', 'HelloWorld.ipynb')
         res = self.build_resources()
         res['metadata']['path'] = ''
         input_nb, output_nb = self.run_notebook(filename, {}, res)
         self.assert_notebooks_equal(input_nb, output_nb)
 
     def test_disable_stdin(self):
         """Test disabling standard input"""
         current_dir = os.path.dirname(__file__)
         filename = os.path.join(current_dir, 'files', 'Disable Stdin.ipynb')
         res = self.build_resources()
         res['metadata']['path'] = os.path.dirname(filename)
         input_nb, output_nb = self.run_notebook(filename, {}, res)
 
         # We need to special-case this particular notebook, because the
         # traceback contains machine-specific stuff like where IPython
         # is installed. It is sufficient here to just check that an error
         # was thrown, and that it was a StdinNotImplementedError
         self.assertEqual(len(output_nb['cells']), 1)
         self.assertEqual(len(output_nb['cells'][0]['outputs']), 1)
         output = output_nb['cells'][0]['outputs'][0]
         self.assertEqual(output['output_type'], 'error')
         self.assertEqual(output['ename'], 'StdinNotImplementedError')
         self.assertEqual(output['evalue'], 'raw_input was called, but this frontend does not support input requests.')
 
     def test_timeout(self):
         """Check that an error is raised when a computation times out"""
         current_dir = os.path.dirname(__file__)
         filename = os.path.join(current_dir, 'files', 'Interrupt.ipynb')
         res = self.build_resources()
         res['metadata']['path'] = os.path.dirname(filename)
         assert_raises(Empty, self.run_notebook, filename, dict(timeout=1), res)

jupyter_nbconvert/tests/files/hello.py

@@ -1,7 +1,7 b''
-from IPython.nbconvert.writers.base import WriterBase
+from jupyter_nbconvert.writers.base import WriterBase
 
 class HelloWriter(WriterBase):
 
     def write(self, output, resources, notebook_name=None, **kw):
         with open('hello.txt', 'w') as outfile:
             outfile.write('hello world')

jupyter_nbconvert/tests/test_nbconvertapp.py

@@ -1,243 +1,243 b''
 # -*- coding: utf-8 -*- 
 """Test NbConvertApp"""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import os
 import glob
 import sys
 
 from .base import TestsBase
 from ..postprocessors import PostProcessorBase
 
 import IPython.testing.tools as tt
 from IPython.testing import decorators as dec
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 class DummyPost(PostProcessorBase):
     def postprocess(self, filename):
         print("Dummy:%s" % filename)
 
 class TestNbConvertApp(TestsBase):
     """Collection of NbConvertApp tests"""
 
 
     def test_notebook_help(self):
         """Will help show if no notebooks are specified?"""
         with self.create_temp_cwd():
             out, err = self.call('nbconvert --log-level 0', ignore_return_code=True)
             self.assertIn("see '--help-all'", out)
     
     def test_help_output(self):
         """ipython nbconvert --help-all works"""
         tt.help_all_output_test('nbconvert')
 
     def test_glob(self):
         """
         Do search patterns work for notebook names?
         """
         with self.create_temp_cwd(['notebook*.ipynb']):
             self.call('nbconvert --to python *.ipynb --log-level 0')
             assert os.path.isfile('notebook1.py')
             assert os.path.isfile('notebook2.py')
 
 
     def test_glob_subdir(self):
         """
         Do search patterns work for subdirectory notebook names?
         """
         with self.create_temp_cwd():
             self.copy_files_to(['notebook*.ipynb'], 'subdir/')
             self.call('nbconvert --to python --log-level 0 ' + 
                       os.path.join('subdir', '*.ipynb'))
             assert os.path.isfile('notebook1.py')
             assert os.path.isfile('notebook2.py')
 
 
     def test_explicit(self):
         """
         Do explicit notebook names work?
         """
         with self.create_temp_cwd(['notebook*.ipynb']):
             self.call('nbconvert --log-level 0 --to python notebook2')
             assert not os.path.isfile('notebook1.py')
             assert os.path.isfile('notebook2.py')
 
 
     @dec.onlyif_cmds_exist('pdflatex')
     @dec.onlyif_cmds_exist('pandoc')
     def test_filename_spaces(self):
         """
         Generate PDFs with graphics if notebooks have spaces in the name?
         """
         with self.create_temp_cwd(['notebook2.ipynb']):
             os.rename('notebook2.ipynb', 'notebook with spaces.ipynb')
             self.call('nbconvert --log-level 0 --to pdf'
                     ' "notebook with spaces"'
                     ' --PDFExporter.latex_count=1'
                     ' --PDFExporter.verbose=True'
             )
             assert os.path.isfile('notebook with spaces.pdf')
 
     def test_post_processor(self):
         """Do post processors work?"""
         with self.create_temp_cwd(['notebook1.ipynb']):
             out, err = self.call('nbconvert --log-level 0 --to python notebook1 '
-                      '--post IPython.nbconvert.tests.test_nbconvertapp.DummyPost')
+                      '--post jupyter_nbconvert.tests.test_nbconvertapp.DummyPost')
             self.assertIn('Dummy:notebook1.py', out)
 
     @dec.onlyif_cmds_exist('pandoc')
     def test_spurious_cr(self):
         """Check for extra CR characters"""
         with self.create_temp_cwd(['notebook2.ipynb']):
             self.call('nbconvert --log-level 0 --to latex notebook2')
             assert os.path.isfile('notebook2.tex')
             with open('notebook2.tex') as f:
                 tex = f.read()
             self.call('nbconvert --log-level 0 --to html notebook2')
             assert os.path.isfile('notebook2.html')
             with open('notebook2.html') as f:
                 html = f.read()
         self.assertEqual(tex.count('\r'), tex.count('\r\n'))
         self.assertEqual(html.count('\r'), html.count('\r\n'))
 
     @dec.onlyif_cmds_exist('pandoc')
     def test_png_base64_html_ok(self):
         """Is embedded png data well formed in HTML?"""
         with self.create_temp_cwd(['notebook2.ipynb']):
             self.call('nbconvert --log-level 0 --to HTML '
                       'notebook2.ipynb --template full')
             assert os.path.isfile('notebook2.html')
             with open('notebook2.html') as f:
                 assert "data:image/png;base64,b'" not in f.read()
 
     @dec.onlyif_cmds_exist('pandoc')
     def test_template(self):
         """
         Do export templates work?
         """
         with self.create_temp_cwd(['notebook2.ipynb']):
             self.call('nbconvert --log-level 0 --to slides '  
                       'notebook2.ipynb')
             assert os.path.isfile('notebook2.slides.html')
             with open('notebook2.slides.html') as f:
                 assert '/reveal.css' in f.read()
 
     def test_output_ext(self):
         """test --output=outputfile[.ext]"""
         with self.create_temp_cwd(['notebook1.ipynb']):
             self.call('nbconvert --log-level 0 --to python '
                       'notebook1.ipynb --output nb.py')
             assert os.path.exists('nb.py')
 
             self.call('nbconvert --log-level 0 --to python '
                       'notebook1.ipynb --output nb2')
             assert os.path.exists('nb2.py')
 
     def test_glob_explicit(self):
         """
         Can a search pattern be used along with matching explicit notebook names?
         """
         with self.create_temp_cwd(['notebook*.ipynb']):
             self.call('nbconvert --log-level 0 --to python '
                       '*.ipynb notebook1.ipynb notebook2.ipynb')
             assert os.path.isfile('notebook1.py')
             assert os.path.isfile('notebook2.py')
 
 
     def test_explicit_glob(self):
         """
         Can explicit notebook names be used and then a matching search pattern?
         """
         with self.create_temp_cwd(['notebook*.ipynb']):
             self.call('nbconvert --log-level 0 --to=python '
                       'notebook1.ipynb notebook2.ipynb *.ipynb')
             assert os.path.isfile('notebook1.py')
             assert os.path.isfile('notebook2.py')
 
 
     def test_default_config(self):
         """
         Does the default config work?
         """
         with self.create_temp_cwd(['notebook*.ipynb', 'ipython_nbconvert_config.py']):
             self.call('nbconvert --log-level 0')
             assert os.path.isfile('notebook1.py')
             assert not os.path.isfile('notebook2.py')
 
 
     def test_override_config(self):
         """
         Can the default config be overriden?
         """
         with self.create_temp_cwd(['notebook*.ipynb',
                                    'ipython_nbconvert_config.py',
                                    'override.py']):
             self.call('nbconvert --log-level 0 --config="override.py"')
             assert not os.path.isfile('notebook1.py')
             assert os.path.isfile('notebook2.py')
 
     def test_accents_in_filename(self):
         """
         Can notebook names include accents?
         """
         with self.create_temp_cwd():
             self.create_empty_notebook(u'nb1_análisis.ipynb')
             self.call('nbconvert --log-level 0 --to python nb1_*')
             assert os.path.isfile(u'nb1_análisis.py')
     
     @dec.onlyif_cmds_exist('pdflatex', 'pandoc')
     def test_filename_accent_pdf(self):
         """
         Generate PDFs if notebooks have an accent in their name?
         """
         with self.create_temp_cwd():
             self.create_empty_notebook(u'nb1_análisis.ipynb')
             self.call('nbconvert --log-level 0 --to pdf "nb1_*"'
                     ' --PDFExporter.latex_count=1'
                     ' --PDFExporter.verbose=True')
             assert os.path.isfile(u'nb1_análisis.pdf')
 
     def test_cwd_plugin(self):
         """
         Verify that an extension in the cwd can be imported.
         """
         with self.create_temp_cwd(['hello.py']):
             self.create_empty_notebook(u'empty.ipynb')
             self.call('nbconvert empty --to html --NbConvertApp.writer_class=\'hello.HelloWriter\'')
             assert os.path.isfile(u'hello.txt')
 
     def test_output_suffix(self):
         """
         Verify that the output suffix is applied
         """
         with self.create_temp_cwd():
             self.create_empty_notebook('empty.ipynb')
             self.call('nbconvert empty.ipynb --to notebook')
             assert os.path.isfile('empty.nbconvert.ipynb')
 
     def test_different_build_dir(self):
         """
         Verify that the output suffix is not applied
         """
         with self.create_temp_cwd():
             self.create_empty_notebook('empty.ipynb')
             os.mkdir('output')
             self.call(
                 'nbconvert empty.ipynb --to notebook '
                 '--FilesWriter.build_directory=output')
             assert os.path.isfile('output/empty.ipynb')
 
     def test_inplace(self):
         """
         Verify that the notebook is converted in place
         """
         with self.create_temp_cwd():
             self.create_empty_notebook('empty.ipynb')
             self.call('nbconvert empty.ipynb --to notebook --inplace')
             assert os.path.isfile('empty.ipynb')
             assert not os.path.isfile('empty.nbconvert.ipynb')

jupyter_nbconvert/utils/tests/test_lexers.py

@@ -1,131 +1,131 b''
 """Test lexers module"""
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2014 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 pygments.token import Token
 
-from IPython.nbconvert.tests.base import TestsBase
+from jupyter_nbconvert.tests.base import TestsBase
 from .. import lexers
 
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 class TestLexers(TestsBase):
     """Collection of lexers tests"""
     def setUp(self):
         self.lexer = lexers.IPythonLexer()
 
     def testIPythonLexer(self):
         fragment = '!echo $HOME\n'
         tokens = [
             (Token.Operator, '!'),
             (Token.Name.Builtin, 'echo'),
             (Token.Text, ' '),
             (Token.Name.Variable, '$HOME'),
             (Token.Text, '\n'),
         ]
         self.assertEqual(tokens, list(self.lexer.get_tokens(fragment)))
 
         fragment_2 = '!' + fragment
         tokens_2 = [
             (Token.Operator, '!!'),
         ] + tokens[1:]
         self.assertEqual(tokens_2, list(self.lexer.get_tokens(fragment_2)))
 
         fragment_2 = '\t %%!\n' + fragment[1:]
         tokens_2 = [
             (Token.Text, '\t '),
             (Token.Operator, '%%!'),
             (Token.Text, '\n'),
         ] + tokens[1:]
         self.assertEqual(tokens_2, list(self.lexer.get_tokens(fragment_2)))
 
         fragment_2 = 'x = ' + fragment
         tokens_2 = [
             (Token.Name, 'x'),
             (Token.Text, ' '),
             (Token.Operator, '='),
             (Token.Text, ' '),
         ] + tokens
         self.assertEqual(tokens_2, list(self.lexer.get_tokens(fragment_2)))
 
         fragment_2 = 'x, = ' + fragment
         tokens_2 = [
             (Token.Name, 'x'),
             (Token.Punctuation, ','),
             (Token.Text, ' '),
             (Token.Operator, '='),
             (Token.Text, ' '),
         ] + tokens
         self.assertEqual(tokens_2, list(self.lexer.get_tokens(fragment_2)))
 
         fragment_2 = 'x, = %sx ' + fragment[1:]
         tokens_2 = [
             (Token.Name, 'x'),
             (Token.Punctuation, ','),
             (Token.Text, ' '),
             (Token.Operator, '='),
             (Token.Text, ' '),
             (Token.Operator, '%'),
             (Token.Keyword, 'sx'),
             (Token.Text, ' '),
         ] + tokens[1:]
         self.assertEqual(tokens_2, list(self.lexer.get_tokens(fragment_2)))
 
         fragment_2 = 'f = %R function () {}\n'
         tokens_2 = [
             (Token.Name, 'f'),
             (Token.Text, ' '),
             (Token.Operator, '='),
             (Token.Text, ' '),
             (Token.Operator, '%'),
             (Token.Keyword, 'R'),
             (Token.Text, ' function () {}\n'),
         ]
         self.assertEqual(tokens_2, list(self.lexer.get_tokens(fragment_2)))
 
         fragment_2 = '\t%%xyz\n$foo\n'
         tokens_2 = [
             (Token.Text, '\t'),
             (Token.Operator, '%%'),
             (Token.Keyword, 'xyz'),
             (Token.Text, '\n$foo\n'),
         ]
         self.assertEqual(tokens_2, list(self.lexer.get_tokens(fragment_2)))
 
         fragment_2 = '%system?\n'
         tokens_2 = [
             (Token.Operator, '%'),
             (Token.Keyword, 'system'),
             (Token.Operator, '?'),
             (Token.Text, '\n'),
         ]
         self.assertEqual(tokens_2, list(self.lexer.get_tokens(fragment_2)))
 
         fragment_2 = 'x != y\n'
         tokens_2 = [
             (Token.Name, 'x'),
             (Token.Text, ' '),
             (Token.Operator, '!='),
             (Token.Text, ' '),
             (Token.Name, 'y'),
             (Token.Text, '\n'),
         ]
         self.assertEqual(tokens_2, list(self.lexer.get_tokens(fragment_2)))
 
         fragment_2 = ' ?math.sin\n'
         tokens_2 = [
             (Token.Text, ' '),
             (Token.Operator, '?'),
             (Token.Text, 'math.sin'),
             (Token.Text, '\n'),
         ]
         self.assertEqual(tokens_2, list(self.lexer.get_tokens(fragment_2)))

jupyter_nbconvert/utils/tests/test_pandoc.py

@@ -1,70 +1,70 b''
 """Test Pandoc module"""
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2014 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
 import warnings
 
 from IPython.testing import decorators as dec
 
-from IPython.nbconvert.tests.base import TestsBase
+from jupyter_nbconvert.tests.base import TestsBase
 from .. import pandoc
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 class TestPandoc(TestsBase):
     """Collection of Pandoc tests"""
 
     def __init__(self, *args, **kwargs):
         super(TestPandoc, self).__init__(*args, **kwargs)
         self.original_env = os.environ.copy()
 
     @dec.onlyif_cmds_exist('pandoc')
     def test_pandoc_available(self):
         """ Test behaviour that pandoc functions raise PandocMissing as documented """
         pandoc.clean_cache()
 
         os.environ["PATH"] = ""
         with self.assertRaises(pandoc.PandocMissing):
             pandoc.get_pandoc_version()
         with self.assertRaises(pandoc.PandocMissing):
             pandoc.check_pandoc_version()
         with self.assertRaises(pandoc.PandocMissing):
             pandoc.pandoc("", "markdown", "html")
 
         # original_env["PATH"] should contain pandoc
         os.environ["PATH"] = self.original_env["PATH"]
         with warnings.catch_warnings(record=True) as w:
             pandoc.get_pandoc_version()
             pandoc.check_pandoc_version()
             pandoc.pandoc("", "markdown", "html")
         self.assertEqual(w, [])
         
     @dec.onlyif_cmds_exist('pandoc')
     def test_minimal_version(self):
         original_minversion = pandoc._minimal_version
         
         pandoc._minimal_version = "120.0"
         with warnings.catch_warnings(record=True) as w:
             assert not pandoc.check_pandoc_version()
         self.assertEqual(len(w), 1)
 
         pandoc._minimal_version = pandoc.get_pandoc_version()
         assert pandoc.check_pandoc_version()
 
 
 def pandoc_function_raised_missing(f, *args, **kwargs):
     try:
         f(*args, **kwargs)
     except pandoc.PandocMissing:
         return True
     else:
         return False