Rebase changes made by hand

IPython/nbconvert/exporters/__init__.py

@@ -1,9 +1,9 b''
 from .export import *
 from .html import HTMLExporter
 from .slides import SlidesExporter
-from .exporter import TemplateExporter
+from .templateexporter import TemplateExporter
 from .latex import LatexExporter
 from .markdown import MarkdownExporter
 from .python import PythonExporter
 from .rst import RSTExporter
-from .baseexporter import BaseExporter
+from .exporter import Exporter

IPython/nbconvert/exporters/export.py

@@ -1,169 +1,169 b''
 """
 Module containing single call export functions.
 """
 #-----------------------------------------------------------------------------
 # 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 functools import wraps
 
 from IPython.nbformat.v3.nbbase import NotebookNode
 from IPython.config import Config
 
-from .exporter import TemplateExporter
+from .templateexporter import TemplateExporter
 from .html import HTMLExporter
 from .slides import SlidesExporter
 from .latex import LatexExporter
 from .markdown import MarkdownExporter
 from .python import PythonExporter
 from .rst import RSTExporter
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 def DocDecorator(f):
     
     #Set docstring of function
     f.__doc__ = f.__doc__ + """
     nb : Notebook node
     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.
 
     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_markdown',
     'export_python',
     'export_rst',
     'export_by_name',
     'get_export_names',
     'ExporterNameError'
 ]
 
 
 class ExporterNameError(NameError):
     pass
 
 @DocDecorator
 def export(exporter, nb, **kw):
     """
     Export a notebook object using specific exporter class.
     
     exporter : Exporter class type 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, TemplateExporter) and not issubclass(exporter, TemplateExporter):
         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, TemplateExporter):
         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, basestring):
         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,
     markdown=MarkdownExporter,
     python=PythonExporter,
     rst=RSTExporter,
 )
 
 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.
     
     format_name : str
         Name of the template style to export to.
     """
     
     function_name = "export_" + format_name.lower()
     
     if function_name in globals():
         return globals()[function_name](nb, **kw)
     else:
         raise ExporterNameError("template for `%s` not found" % function_name)
 
 
 def get_export_names():
     """Return a list of the currently supported export targets
 
     WARNING: API WILL CHANGE IN FUTURE RELEASES OF NBCONVERT"""
     return sorted(exporter_map.keys())

IPython/nbconvert/exporters/exporter.py

@@ -1,282 +1,281 b''
-"""This module defines BaseExporter, a highly configurable converter
+"""This module defines Exporter, 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 io
 import os
 import copy
 import collections
 import datetime
 
 
 # IPython imports
 from IPython.config.configurable import LoggingConfigurable
 from IPython.config import Config
 from IPython.nbformat import current as nbformat
 from IPython.utils.traitlets import MetaHasTraits, Unicode, List
 from IPython.utils.importstring import import_item
-from IPython.utils import py3compat
+from IPython.utils import text, py3compat
 
-from IPython.nbconvert import transformers as nbtransformers
+from IPython.nbconvert import preprocessors as nbpreprocessors
 
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class ResourcesDict(collections.defaultdict):
     def __missing__(self, key):
         return ''
 
 
-class BaseExporter(LoggingConfigurable):
+class Exporter(LoggingConfigurable):
     """
-    Base Exporter Class that only conver notebook to notebook
-    and apply the transformers and provide basic methods for
+    Exporter class that only converts from notebook to notebook
+    by applying the preprocessors and providing basic methods for
     reading a notebook from different sources.
-
     """
 
     # finish the docstring
 
     file_extension = Unicode(
         'txt', config=True,
         help="Extension of the file that should be written to disk"
         )
 
-    #Configurability, allows the user to easily add transformers.
-    transformers = List(config=True,
-        help="""List of transformers, by name or namespace, to enable.""")
+    #Configurability, allows the user to easily add filters and preprocessors.
+    preprocessors = List(config=True,
+        help="""List of preprocessors, by name or namespace, to enable.""")
 
-    _transformers = None
+    _preprocessors = None
 
-    default_transformers = List([nbtransformers.coalesce_streams,
-                                 nbtransformers.SVG2PDFTransformer,
-                                 nbtransformers.ExtractOutputTransformer,
-                                 nbtransformers.CSSHTMLHeaderTransformer,
-                                 nbtransformers.RevealHelpTransformer,
-                                 nbtransformers.LatexTransformer,
-                                 nbtransformers.SphinxTransformer],
+    default_preprocessors = List([nbpreprocessors.coalesce_streams,
+                                 nbpreprocessors.SVG2PDFPreprocessor,
+                                 nbpreprocessors.ExtractOutputPreprocessor,
+                                 nbpreprocessors.CSSHTMLHeaderPreprocessor,
+                                 nbpreprocessors.RevealHelpPreprocessor,
+                                 nbpreprocessors.LatexPreprocessor,
+                                 nbpreprocessors.SphinxPreprocessor],
         config=True,
-        help="""List of transformers available by default, by name, namespace,
+        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.
         """
         if not config:
             config = self.default_config
 
-        super(BaseExporter, self).__init__(config=config, **kw)
+        super(Exporter, self).__init__(config=config, **kw)
 
         #Init
-        self._init_transformers()
+        self._init_preprocessors()
 
 
     @property
     def default_config(self):
         return Config()
 
     def _config_changed(self, name, old, new):
         """When setting config, make sure to start with our default_config"""
         c = self.default_config
         if new:
             c.merge(new)
         if c != old:
             self.config = c
-        super(BaseExporter, self)._config_changed(name, old, c)
+        super(Exporter, self)._config_changed(name, old, c)
 
 
     def from_notebook_node(self, nb, resources=None):
         """
         Convert a notebook from a notebook node instance.
 
         Parameters
         ----------
         nb : Notebook node
         resources : dict (**kw)
             of additional resources that can be accessed read/write by
-            transformers.
+            preprocessors.
         """
         nb_copy = copy.deepcopy(nb)
         resources = self._init_resources(resources)
 
         # Preprocess
         nb_copy, resources = self._transform(nb_copy, resources)
 
         return nb_copy, resources
 
 
     def from_filename(self, filename, resources=None, **kw):
         """
         Convert a notebook from a notebook file.
 
         Parameters
         ----------
         filename : str
             Full filename of the notebook file to open and convert.
         """
 
         #Pull the metadata from the filesystem.
         if resources is None:
             resources = ResourcesDict()
         if not 'metadata' in resources or resources['metadata'] == '':
             resources['metadata'] = ResourcesDict()
         basename = os.path.basename(filename)
         notebook_name = basename[:basename.rfind('.')]
         resources['metadata']['name'] = notebook_name
 
         modified_date = datetime.datetime.fromtimestamp(os.path.getmtime(filename))
-        resources['metadata']['modified_date'] = modified_date.strftime("%B %d, %Y")
+        resources['metadata']['modified_date'] = modified_date.strftime(text.date_format)
 
         with io.open(filename) as f:
             return self.from_notebook_node(nbformat.read(f, 'json'), resources=resources, **kw)
 
 
     def from_file(self, file_stream, resources=None, **kw):
         """
         Convert a notebook from a notebook file.
 
         Parameters
         ----------
         file_stream : file-like object
             Notebook file-like object to convert.
         """
         return self.from_notebook_node(nbformat.read(file_stream, 'json'), resources=resources, **kw)
 
 
-    def register_transformer(self, transformer, enabled=False):
+    def register_preprocessor(self, preprocessor, enabled=False):
         """
-        Register a transformer.
-        Transformers are classes that act upon the notebook before it is
-        passed into the Jinja templating engine.  Transformers are also
+        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
         ----------
-        transformer : transformer
+        preprocessor : preprocessor
         """
-        if transformer is None:
-            raise TypeError('transformer')
-        isclass = isinstance(transformer, type)
+        if preprocessor is None:
+            raise TypeError('preprocessor')
+        isclass = isinstance(preprocessor, type)
         constructed = not isclass
 
-        #Handle transformer's registration based on it's type
-        if constructed and isinstance(transformer, py3compat.string_types):
-            #Transformer is a string, import the namespace and recursively call
-            #this register_transformer method
-            transformer_cls = import_item(transformer)
-            return self.register_transformer(transformer_cls, enabled)
+        #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(transformer, '__call__'):
-            #Transformer is a function, no need to construct it.
-            #Register and return the transformer.
+        if constructed and hasattr(preprocessor, '__call__'):
+            #preprocessor is a function, no need to construct it.
+            #Register and return the preprocessor.
             if enabled:
-                transformer.enabled = True
-            self._transformers.append(transformer)
-            return transformer
+                preprocessor.enabled = True
+            self._preprocessors.append(preprocessor)
+            return preprocessor
 
-        elif isclass and isinstance(transformer, MetaHasTraits):
-            #Transformer is configurable.  Make sure to pass in new default for
+        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_transformer(transformer(parent=self), enabled)
+            self.register_preprocessor(preprocessor(parent=self), enabled)
 
         elif isclass:
-            #Transformer is not configurable, construct it
-            self.register_transformer(transformer(), enabled)
+            #preprocessor is not configurable, construct it
+            self.register_preprocessor(preprocessor(), enabled)
 
         else:
-            #Transformer is an instance of something without a __call__
+            #preprocessor is an instance of something without a __call__
             #attribute.
-            raise TypeError('transformer')
+            raise TypeError('preprocessor')
 
 
-    def _init_transformers(self):
+    def _init_preprocessors(self):
         """
-        Register all of the transformers needed for this exporter, disabled
+        Register all of the preprocessors needed for this exporter, disabled
         unless specified explicitly.
         """
-        if self._transformers is None:
-            self._transformers = []
+        if self._preprocessors is None:
+            self._preprocessors = []
 
-        #Load default transformers (not necessarly enabled by default).
-        if self.default_transformers:
-            for transformer in self.default_transformers:
-                self.register_transformer(transformer)
+        #Load default preprocessors (not necessarly enabled by default).
+        if self.default_preprocessors:
+            for preprocessor in self.default_preprocessors:
+                self.register_preprocessor(preprocessor)
 
-        #Load user transformers.  Enable by default.
-        if self.transformers:
-            for transformer in self.transformers:
-                self.register_transformer(transformer, enabled=True)
+        #Load user preprocessors.  Enable by default.
+        if self.preprocessors:
+            for preprocessor in self.preprocessors:
+                self.register_preprocessor(preprocessor, enabled=True)
 
 
     def _init_resources(self, resources):
 
         #Make sure the resources dict is of ResourcesDict type.
         if resources is None:
             resources = ResourcesDict()
         if not isinstance(resources, ResourcesDict):
             new_resources = ResourcesDict()
             new_resources.update(resources)
             resources = new_resources
 
         #Make sure the metadata extension exists in resources
         if 'metadata' in resources:
             if not isinstance(resources['metadata'], ResourcesDict):
                 resources['metadata'] = ResourcesDict(resources['metadata'])
         else:
             resources['metadata'] = ResourcesDict()
             if not resources['metadata']['name']:
                 resources['metadata']['name'] = 'Notebook'
 
         #Set the output extension
         resources['output_extension'] = self.file_extension
         return resources
 
 
     def _transform(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 transformers
+            can be accessed read/write by preprocessors
         """
 
         # Do a copy.deepcopy first,
-        # we are never safe enough with what the transformers could do.
+        # we are never safe enough with what the preprocessors could do.
         nbc =  copy.deepcopy(nb)
         resc = copy.deepcopy(resources)
 
-        #Run each transformer on the notebook.  Carry the output along
-        #to each transformer
-        for transformer in self._transformers:
-            nbc, resc = transformer(nbc, resc)
+        #Run each preprocessor on the notebook.  Carry the output along
+        #to each preprocessor
+        for preprocessor in self._preprocessors:
+            nbc, resc = preprocessor(nbc, resc)
         return nbc, resc

IPython/nbconvert/exporters/html.py

@@ -1,52 +1,52 b''
 """
 Exporter that exports Basic HTML.
 """
 
 #-----------------------------------------------------------------------------
 # 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.utils.traitlets import Unicode, List
 
 from IPython.nbconvert import preprocessors
 from IPython.config import Config
 
-from .exporter import TemplateExporter
+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.  
     """
     
     file_extension = Unicode(
         'html', config=True, 
         help="Extension of the file that should be written to disk"
         )
 
     default_template = Unicode('full', config=True, help="""Flavor of the data 
         format to use.  I.E. 'full' or 'basic'""")
 
     @property
     def default_config(self):
         c = Config({
             'CSSHTMLHeaderPreprocessor':{
                 'enabled':True
                 }          
             })
         c.merge(super(HTMLExporter,self).default_config)
         return c

IPython/nbconvert/exporters/latex.py

@@ -1,91 +1,91 b''
 """
 Exporter that allows Latex Jinja templates to work.  Contains logic to
 appropriately prepare IPYNB files for export to LaTeX.  Including but 
 not limited to escaping LaTeX, fixing math region tags, using special
 tags to circumvent Jinja/Latex syntax conflicts.
 """
 #-----------------------------------------------------------------------------
 # 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, List
 from IPython.config import Config
 
 from IPython.nbconvert import filters, preprocessors
-from .exporter import Exporter
+from .templateexporter import TemplateExporter
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
-class LatexExporter(Exporter):
+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.
     """
     
     file_extension = Unicode(
         'tex', config=True, 
         help="Extension of the file that should be written to disk")
 
     default_template = Unicode('article', config=True, help="""Template of the 
         data format to use.  I.E. 'full' or 'basic'""")
 
     #Latex constants
     default_template_path = Unicode(
         os.path.join("..", "templates", "latex"), config=True,
         help="Path where the template files are located.")
 
     template_skeleton_path = Unicode(
         os.path.join("..", "templates", "latex", "skeleton"), config=True,
         help="Path where the template skeleton files are located.") 
 
     #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)
 
 
     @property
     def default_config(self):
         c = Config({
             'NbConvertBase': {
                 'display_data_priority' : ['latex', 'pdf', 'png', 'jpg', 'svg', 'jpeg', 'text']
                 },
              'ExtractOutputPreprocessor': {
                     'enabled':True
                  },
              'SVG2PDFPreprocessor': {
                     'enabled':True
                  },
              'LatexPreprocessor': {
                     'enabled':True
                  },
              'SphinxPreprocessor': {
                     'enabled':True
                  }
          })
         c.merge(super(LatexExporter,self).default_config)
         return c

IPython/nbconvert/exporters/markdown.py

@@ -1,38 +1,38 b''
 """
 Exporter that will export your ipynb to Markdown.
 """
 #-----------------------------------------------------------------------------
 # 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 IPython.utils.traitlets import Unicode
 
-from .exporter import TemplateExporter
+from .templateexporter import TemplateExporter
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class MarkdownExporter(TemplateExporter):
     """
     Exports to a markdown document (.md)
     """
     
     file_extension = Unicode(
         'md', config=True, 
         help="Extension of the file that should be written to disk")
 
     @property
     def default_config(self):
         c = Config({'ExtractOutputPreprocessor':{'enabled':True}})
         c.merge(super(MarkdownExporter,self).default_config)
         return c

IPython/nbconvert/exporters/python.py

@@ -1,31 +1,31 b''
 """
 Python exporter which exports Notebook code into a PY file.
 """
 #-----------------------------------------------------------------------------
 # 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.utils.traitlets import Unicode
 
-from .exporter import TemplateExporter
+from .templateexporter import TemplateExporter
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class PythonExporter(TemplateExporter):
     """
     Exports a Python code file.
     """
     
     file_extension = Unicode(
         'py', config=True, 
         help="Extension of the file that should be written to disk")

IPython/nbconvert/exporters/rst.py

@@ -1,38 +1,38 b''
 """
 Exporter for exporting notebooks to restructured text.
 """
 #-----------------------------------------------------------------------------
 # 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.utils.traitlets import Unicode
 from IPython.config import Config
 
-from .exporter import TemplateExporter
+from .templateexporter import TemplateExporter
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class RSTExporter(TemplateExporter):
     """
     Exports restructured text documents.
     """
     
     file_extension = Unicode(
         'rst', config=True, 
         help="Extension of the file that should be written to disk")
 
     @property
     def default_config(self):
         c = Config({'ExtractOutputPreprocessor':{'enabled':True}})
         c.merge(super(RSTExporter,self).default_config)
         return c

IPython/nbconvert/exporters/slides.py

@@ -1,52 +1,52 b''
 """
 Contains slide show exporter
 """
 
 #-----------------------------------------------------------------------------
 # 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.utils.traitlets import Unicode
 
 from IPython.nbconvert import preprocessors
 from IPython.config import Config
 
-from .exporter import TemplateExporter
+from .templateexporter import TemplateExporter
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class SlidesExporter(TemplateExporter):
     """
     Exports slides
     """
     
     file_extension = Unicode(
         'slides.html', config=True, 
         help="Extension of the file that should be written to disk"
         )
 
     default_template = Unicode('reveal', config=True, help="""Template of the 
         data format to use.  I.E. 'reveal'""")
 
     @property
     def default_config(self):
         c = Config({
             'CSSHTMLHeaderPreprocessor':{
                 'enabled':True
                 },
             'RevealHelpPreprocessor':{
                 'enabled':True,
                 },                
             })
         c.merge(super(SlidesExporter,self).default_config)
         return c

IPython/nbconvert/exporters/templateexporter.py

@@ -1,520 +1,315 b''
 """This module defines Exporter, 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 io
 import os
-import inspect
-import copy
-import collections
-import datetime
 
 # other libs/dependencies
 from jinja2 import Environment, FileSystemLoader, ChoiceLoader, TemplateNotFound
 
 # IPython imports
-from IPython.config.configurable import LoggingConfigurable
-from IPython.config import Config
-from IPython.nbformat import current as nbformat
-from IPython.utils.traitlets import MetaHasTraits, DottedObjectName, Unicode, List, Dict, Any
+from IPython.utils.traitlets import MetaHasTraits, Unicode, List, Dict, Any
 from IPython.utils.importstring import import_item
-from IPython.utils import text
-from IPython.utils import py3compat
+from IPython.utils import py3compat, text
 
-from IPython.nbconvert import preprocessors as nbpreprocessors
 from IPython.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,
         'strip_math_space': filters.strip_math_space,
         'wrap_text': filters.wrap_text,
         'escape_latex': filters.escape_latex,
         'citation2latex': filters.citation2latex,
         'path2url': filters.path2url,
 }
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
-class ResourcesDict(collections.defaultdict):
-    def __missing__(self, key):
-        return ''
-
-
-class Exporter(LoggingConfigurable):
+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()
 
-    file_extension = Unicode(
-        'txt', config=True, 
-        help="Extension of the file that should be written to disk"
-        )
-
     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)
 
-    #Configurability, allows the user to easily add filters and preprocessors.
-    preprocessors = List(config=True,
-        help="""List of preprocessors, by name or namespace, to enable.""")
-
     filters = Dict(config=True,
         help="""Dictionary of filters, by name and namespace, to add to the Jinja
         environment.""")
 
-    default_preprocessors = List([nbpreprocessors.coalesce_streams,
-                                 nbpreprocessors.SVG2PDFPreprocessor,
-                                 nbpreprocessors.ExtractOutputPreprocessor,
-                                 nbpreprocessors.CSSHTMLHeaderPreprocessor,
-                                 nbpreprocessors.RevealHelpPreprocessor,
-                                 nbpreprocessors.LatexPreprocessor,
-                                 nbpreprocessors.SphinxPreprocessor],
-        config=True,
-        help="""List of preprocessors available by default, by name, namespace, 
-        instance, or type.""")
-
 
     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.
         """
         if not config:
             config = self.default_config
         
         super(Exporter, self).__init__(config=config, **kw)
 
         #Init
         self._init_template()
         self._init_environment(extra_loaders=extra_loaders)
         self._init_preprocessors()
         self._init_filters()
 
 
-    @property
-    def default_config(self):
-        return Config()
-    
-    def _config_changed(self, name, old, new):
-        """When setting config, make sure to start with our default_config"""
-        c = self.default_config
-        if new:
-            c.merge(new)
-        if c != old:
-            self.config = c
-        super(Exporter, self)._config_changed(name, old, c)
-        
-
     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.
         """
         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.
         module_name = self.__module__.rsplit('.', 1)[-1]
         try_names = []
         if self.template_file:
             try_names.extend([
                 self.template_file + self.template_extension,
                 self.template_file,
                 module_name + '_' + self.template_file + self.template_extension,
             ])
         try_names.append(module_name + self.template_extension)
         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.info("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 : Notebook node
         resources : dict (**kw) 
             of additional resources that can be accessed read/write by 
             preprocessors and filters.
         """
-        nb_copy = copy.deepcopy(nb)
-        resources = self._init_resources(resources)
-
-        # Preprocess
-        nb_copy, resources = self._preprocess(nb_copy, resources)
+        nb_copy, resources = super(TemplateExporter, self).from_notebook_node(nb, resources, **kw)
 
         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 from_filename(self, filename, resources=None, **kw):
-        """
-        Convert a notebook from a notebook file.
-    
-        Parameters
-        ----------
-        filename : str
-            Full filename of the notebook file to open and convert.
-        """
-
-        #Pull the metadata from the filesystem.
-        if resources is None:
-            resources = ResourcesDict()
-        if not 'metadata' in resources or resources['metadata'] == '':
-            resources['metadata'] = ResourcesDict()
-        basename = os.path.basename(filename)
-        notebook_name = basename[:basename.rfind('.')]
-        resources['metadata']['name'] = notebook_name
-
-        modified_date = datetime.datetime.fromtimestamp(os.path.getmtime(filename))
-        resources['metadata']['modified_date'] = modified_date.strftime(text.date_format)
-        
-        with io.open(filename) as f:
-            return self.from_notebook_node(nbformat.read(f, 'json'), resources=resources,**kw)
-
-
-    def from_file(self, file_stream, resources=None, **kw):
-        """
-        Convert a notebook from a notebook file.
-    
-        Parameters
-        ----------
-        file_stream : file-like object
-            Notebook file-like object to convert.
-        """
-        return self.from_notebook_node(nbformat.read(file_stream, 'json'), resources=resources, **kw)
-
-
-    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 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.
         """
         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_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).
-        if self.default_preprocessors:
-            for preprocessor in self.default_preprocessors:
-                self.register_preprocessor(preprocessor)
-
-        #Load user preprocessors.  Enable by default.
-        if self.preprocessors:
-            for preprocessor in self.preprocessors:
-                self.register_preprocessor(preprocessor, enabled=True)
- 
-
     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)
-
-
-    def _init_resources(self, resources):
-
-        #Make sure the resources dict is of ResourcesDict type.
-        if resources is None:
-            resources = ResourcesDict()
-        if not isinstance(resources, ResourcesDict):
-            new_resources = ResourcesDict()
-            new_resources.update(resources)
-            resources = new_resources 
-
-        #Make sure the metadata extension exists in resources
-        if 'metadata' in resources:
-            if not isinstance(resources['metadata'], ResourcesDict):
-                resources['metadata'] = ResourcesDict(resources['metadata'])
-        else:
-            resources['metadata'] = ResourcesDict()
-            if not resources['metadata']['name']: 
-                resources['metadata']['name'] = 'Notebook'
-
-        #Set the output extension
-        resources['output_extension'] = self.file_extension
-        return resources
-        
-
-    def _preprocess(self, nb, resources):
-        """
-        Preprocess the notebook before passing it into the Jinja engine.
-        To preprocess the notebook is to apply all of the 
-    
-        Parameters
-        ----------
-        nb : notebook node
-            notebook that is being exported.
-        resources : a dict of additional resources that
-            can be accessed read/write by preprocessors
-            and filters.
-        """
-        
-        # Do a copy.deepcopy first, 
-        # we are never safe enough with what the preprocessors could do.
-        nbc =  copy.deepcopy(nb)
-        resc = copy.deepcopy(resources)
-
-        #Run each preprocessor on the notebook.  Carry the output along
-        #to each preprocessor
-        for preprocessor in self._preprocessors:
-            nbc, resc = preprocessor(nbc, resc)
-        return nbc, resc

IPython/nbconvert/exporters/tests/test_exporter.py

@@ -1,108 +1,108 b''
 """
 Module with tests for exporter.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 ..exporter import Exporter
+from ..templateexporter import TemplateExporter
 
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class TestExporter(ExportersTestsBase):
     """Contains test functions for exporter.py"""
 
 
     def test_constructor(self):
         """
-        Can an Exporter be constructed?
+        Can an TemplateExporter be constructed?
         """
-        Exporter()
+        TemplateExporter()
 
 
     def test_export(self):
         """
         Can an Exporter 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']}})
         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 Exporter doesn't have a template associated with it.
-        exporter = Exporter(config=config, template_file='python')
+        exporter = TemplateExporter(config=config, template_file='python')
         return exporter        

IPython/nbconvert/filters/__init__.py

@@ -1,7 +1,7 b''
 from .ansi import *
+from .citation import *
 from .datatypefilter import *
 from .highlight import *
 from .latex import *
 from .markdown import *
 from .strings import *
-from .citation import *
  No newline at end of file

IPython/nbconvert/preprocessors/tests/base.py

@@ -1,53 +1,53 b''
 """
 Module with utility functions for preprocessor tests
 """
 
 #-----------------------------------------------------------------------------
 # 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.nbformat import current as nbformat
 
 from ...tests.base import TestsBase
-from ...exporters.baseexporter import ResourcesDict
+from ...exporters.exporter import ResourcesDict
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class PreprocessorTestsBase(TestsBase):
     """Contains test functions preprocessor tests"""
 
 
     def build_notebook(self):
         """Build a notebook in memory for use with preprocessor tests"""
 
         outputs = [nbformat.new_output(output_type="stream", stream="stdout", output_text="a"),
                    nbformat.new_output(output_type="text", output_text="b"),
                    nbformat.new_output(output_type="stream", stream="stdout", output_text="c"),
                    nbformat.new_output(output_type="stream", stream="stdout", output_text="d"),
                    nbformat.new_output(output_type="stream", stream="stderr", output_text="e"),
                    nbformat.new_output(output_type="stream", stream="stderr", output_text="f"),
                    nbformat.new_output(output_type="png", output_png='Zw==')] #g
         
         cells=[nbformat.new_code_cell(input="$ e $", prompt_number=1,outputs=outputs),
                nbformat.new_text_cell('markdown', source="$ e $")]
         worksheets = [nbformat.new_worksheet(name="worksheet1", cells=cells)]
 
         return nbformat.new_notebook(name="notebook1", worksheets=worksheets)
 
 
     def build_resources(self):
         """Build an empty resources dictionary."""
         
         res = ResourcesDict()
         res['metadata'] = ResourcesDict()
         return res