Merge pull request #3607 from jdfreder/writers_no_yaml

NbConvert: Writers

Add the notion of 'writers', and further cleanup the app and some classes

IPython/nbconvert/transformers/convertfigures.py

@@ -0,0 +1,79 b''
+"""Module containing a transformer that converts outputs in the notebook from 
+one format to another.
+"""
+#-----------------------------------------------------------------------------
+# 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 .base import Transformer
+from IPython.utils.traitlets import Unicode
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+
+class ConvertFiguresTransformer(Transformer):
+    """
+    Converts all of the outputs in a notebook from one format to another.
+    """
+
+    from_format = Unicode(config=True, help='Format the converter accepts')
+    to_format = Unicode(config=True, help='Format the converter writes')
+
+    def __init__(self, **kw):
+        """
+        Public constructor
+        """
+        super(ConvertFiguresTransformer, self).__init__(**kw)
+
+
+    def convert_figure(self, data_format, data):
+        raise NotImplementedError()
+
+
+    def transform_cell(self, cell, resources, cell_index):
+        """
+        Apply a transformation on each cell,
+        
+        See base.py
+        """
+
+        #Loop through all of the datatypes of the outputs in the cell.
+        for index, cell_out in enumerate(cell.get('outputs', [])):
+            for data_type, data in cell_out.items():
+
+                #Get the name of the file exported by the extract figure 
+                #transformer.  Do not try to convert the figure if the extract
+                #fig transformer hasn't touched it
+                filename = cell_out.get(data_type + '_filename', None)
+                if filename:
+                    figure_name = filename[:filename.rfind('.')]
+                    self._convert_figure(cell_out, figure_name, resources, data_type, data)
+        return cell, resources
+
+
+    def _convert_figure(self, cell_out, resources, figure_name, data_type, data):
+        """
+        Convert a figure and output the results to the cell output
+        """
+
+        if not self.to_format in cell_out:
+            if data_type == self.from_format:
+                filename = figure_name + '.' + self.to_format
+                if filename not in resources['figures']:
+
+                    #On the cell, make the figure available via 
+                    #   cell.outputs[i].pdf_filename  ... etc (PDF in example)
+                    cell_out[self.to_format + '_filename'] = filename
+
+                    #In the resources, make the figure available via
+                    #   resources['figures']['filename'] = data
+                    resources['figures'][filename] = self.convert_figure(data_type, data)

IPython/nbconvert/transformers/svg2pdf.py

@@ -0,0 +1,77 b''
+"""Module containing a transformer that converts outputs in the notebook from 
+one format to another.
+"""
+#-----------------------------------------------------------------------------
+# 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
+#-----------------------------------------------------------------------------
+
+import os
+import sys
+import subprocess
+
+from IPython.utils.tempdir import TemporaryDirectory
+from IPython.utils.traitlets import Unicode
+
+from .convertfigures import ConvertFiguresTransformer
+
+
+#-----------------------------------------------------------------------------
+# Constants
+#-----------------------------------------------------------------------------
+
+INKSCAPE_COMMAND = 'inkscape --without-gui --export-pdf="{to_filename}" "{from_filename}"'
+INKSCAPE_OSX_COMMAND = '/Applications/Inkscape.app/Contents/Resources/bin/inkscape --without-gui --export-pdf="{to_filename}" "{from_filename}"'
+
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+
+class SVG2PDFTransformer(ConvertFiguresTransformer):
+    """
+    Converts all of the outputs in a notebook from one format to another.
+    """
+
+    from_format = Unicode('svg', config=True, help='Format the converter accepts')
+    to_format = Unicode('pdf', config=False, help='Format the converter writes')
+
+
+    def convert_figure(self, data_format, data):
+        """
+        Convert a single Svg figure.  Returns converted data.
+        """
+
+        #Work in a temporary directory
+        with TemporaryDirectory() as tmpdir:
+            
+            #Write fig to temp file
+            input_filename = os.path.join(tmpdir, 'figure.' + data_format)
+            with open(input_filename, 'w') as f:
+                f.write(data)
+
+            #Determine command (different on Mac OSX)
+            command = INKSCAPE_COMMAND 
+            if sys.platform == 'darwin':
+                command = INKSCAPE_OSX_COMMAND
+
+            #Call conversion application
+            output_filename = os.path.join(tmpdir, 'figure.pdf')
+            shell = command.format(from_filename=input_filename, 
+                                   to_filename=output_filename)
+            subprocess.call(shell, shell=True) #Shell=True okay since input is trusted.
+
+            #Read output from drive
+            if os.path.isfile(output_filename):
+                with open(output_filename, 'rb') as f:
+                    return f.read().encode("base64") #PDF is a nb supported binary
+                                                     #data type, so base64 encode.
+            else:
+                return TypeError("Inkscape svg to png conversion failed")

IPython/nbconvert/writers/__init__.py

@@ -0,0 +1,2 b''
+from .files import FilesWriter
+from .stdout import StdoutWriter

IPython/nbconvert/writers/base.py

@@ -0,0 +1,57 b''
+#!/usr/bin/env python
+"""
+Contains writer base 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.utils.traitlets import List
+
+from ..utils.base import NbConvertBase
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+
+class WriterBase(NbConvertBase):
+    """Consumes output from nbconvert export...() methods and writes to a
+    useful location. """
+
+
+    files = List([], config=True, help="""
+        List of the files that the notebook references.  Files will be 
+        included with written output.""")
+
+
+    def __init__(self, config=None, **kw):
+        """
+        Constructor
+        """
+        super(WriterBase, self).__init__(config=config, **kw)
+
+
+    def write(self, output, resources, **kw):
+        """
+        Consume and write Jinja output.
+
+        Parameters
+        ----------
+        output : string
+            Conversion results.  This string contains the file contents of the
+            converted file.
+        resources : dict
+            Resources created and filled by the nbconvert conversion process.
+            Includes output from transformers, such as the extract figure 
+            transformer.
+        """
+
+        raise NotImplementedError()

IPython/nbconvert/writers/debug.py

@@ -0,0 +1,43 b''
+#!/usr/bin/env python
+"""
+Contains debug writer.
+"""
+#-----------------------------------------------------------------------------
+#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 .base import WriterBase
+from pprint import pprint
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+
+class DebugWriter(WriterBase):
+    """Consumes output from nbconvert export...() methods and writes usefull
+    debugging information to the stdout.  The information includes a list of
+    resources that were extracted from the notebook(s) during export."""
+
+
+    def write(self, output, resources, **kw):
+        """
+        Consume and write Jinja output.
+
+        See base for more...
+        """
+
+        if 'figures' in resources:
+            print("Figures extracted from %s" % notebook_name)
+            print('-' * 80)
+            pprint.pprint(resources['figures'], indent=2, width=70)
+        else:
+            print("No figures extracted from %s" % notebook_name)
+        print('=' * 80)

IPython/nbconvert/writers/files.py

@@ -0,0 +1,98 b''
+#!/usr/bin/env python
+"""
+Contains writer for writing nbconvert output to filesystem.
+"""
+#-----------------------------------------------------------------------------
+#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
+#-----------------------------------------------------------------------------
+
+import io
+import os
+import shutil
+import glob
+
+from IPython.utils.traitlets import Unicode
+
+from .base import WriterBase
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+
+class FilesWriter(WriterBase):
+    """Consumes nbconvert output and produces files."""
+
+
+    build_directory = Unicode("nbconvert_build", config=True, 
+                              help="""Directory to write output to.  Leave blank
+                              to output to the current directory""")
+
+
+    #Make sure that the output directory exists.
+    def _build_directory_changed(self, name, old, new):
+        if new and not os.path.isdir(new):
+            os.makedirs(new)
+
+
+    def __init__(self, **kw):
+        super(FilesWriter, self).__init__(**kw)
+        self._build_directory_changed('build_directory', self.build_directory, 
+                                      self.build_directory)
+
+
+    def write(self, output, resources, notebook_name=None, **kw):
+            """
+            Consume and write Jinja output to the file system.  Output directory
+            is set via the 'build_directory' variable of this instance (a 
+            configurable).
+
+            See base for more...
+            """
+
+            #Pull the extension from the resources dict.
+            output_extension = resources['output_extension']
+
+            #Write all of the extracted resources to the destination directory.
+            #NOTE: WE WRITE EVERYTHING AS-IF IT'S BINARY.  THE EXTRACT FIG
+            #TRANSFORMER SHOULD HANDLE UNIX/WINDOWS LINE ENDINGS...
+            for filename, data in resources.get('figures', {}).items():
+
+                #Determine where to write the file to
+                dest = os.path.join(self.build_directory, filename)
+
+                #Write file
+                with io.open(dest, 'wb') as f:
+                    f.write(data)
+
+            #Copy referenced files to output directory
+            if self.build_directory:
+                for filename in self.files:
+
+                    #Copy files that match search pattern
+                    for matching_filename in glob.glob(filename):
+
+                        #Make sure folder exists.
+                        dest = os.path.join(self.build_directory, filename)
+                        path = os.path.dirname(dest)
+                        if not os.path.isdir(path):
+                            os.makedirs(path)
+
+                        #Copy
+                        shutil.copyfile(matching_filename, dest)
+
+            #Determine where to write conversion results.
+            dest = notebook_name + '.' + output_extension
+            if self.build_directory:
+                dest = os.path.join(self.build_directory, dest)
+
+            #Write conversion results.
+            with io.open(dest, 'w') as f:
+                f.write(output)

IPython/nbconvert/writers/stdout.py

@@ -0,0 +1,37 b''
+#!/usr/bin/env python
+"""
+Contains Stdout writer
+"""
+#-----------------------------------------------------------------------------
+#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 .base import WriterBase
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+
+class StdoutWriter(WriterBase):
+    """Consumes output from nbconvert export...() methods and writes to the 
+    stdout stream.  Allows for quick debuging of nbconvert output.  Using the
+    debug flag makes the writer pretty-print the figures contained within the
+    notebook."""
+
+
+    def write(self, output, resources, **kw):
+        """
+        Consume and write Jinja output.
+
+        See base for more...
+        """
+
+        print(output)

IPython/nbconvert/__init__.py

@@ -3,3 +3,4 b''
 from .exporters import *
 import filters
 import transformers
+import writers

IPython/nbconvert/exporters/__init__.py

@@ -6,6 +6,6 b' from .reveal import RevealExporter'
 from .latex import LatexExporter
 from .markdown import MarkdownExporter
 from .python import PythonExporter
-from .rst import RstExporter
+from .rst import RSTExporter
 from .sphinx_howto import SphinxHowtoExporter
 from .sphinx_manual import SphinxManualExporter

IPython/nbconvert/exporters/basichtml.py

@@ -14,9 +14,9 b' Exporter that exports Basic HTML.'
 # Imports
 #-----------------------------------------------------------------------------
 
-from IPython.utils.traitlets import Unicode
+from IPython.utils.traitlets import Unicode, List
 
-from ..transformers.csshtmlheader import CSSHTMLHeaderTransformer
+from IPython.nbconvert import transformers
 
 from .exporter import Exporter
 
@@ -40,16 +40,3 b' class BasicHTMLExporter(Exporter):'
     template_file = Unicode(
             'basichtml', config=True,
             help="Name of the template file to use")
-
-
-    def _register_transformers(self):
-        """
-        Register all of the transformers needed for this exporter.
-        """
-        
-        #Register the transformers of the base class.
-        super(BasicHTMLExporter, self)._register_transformers()
-        
-        #Register CSSHTMLHeaderTransformer transformer
-        self.register_transformer(CSSHTMLHeaderTransformer)
-                    

IPython/nbconvert/exporters/export.py

@@ -16,6 +16,7 b' Module containing single call export functions.'
 from functools import wraps
 
 from IPython.nbformat.v3.nbbase import NotebookNode
+from IPython.config import Config
 
 from .exporter import Exporter
 from .basichtml import BasicHTMLExporter
@@ -24,7 +25,7 b' from .latex import LatexExporter'
 from .markdown import MarkdownExporter
 from .python import PythonExporter
 from .reveal import RevealExporter
-from .rst import RstExporter
+from .rst import RSTExporter
 from .sphinx_howto import SphinxHowtoExporter
 from .sphinx_manual import SphinxManualExporter
 
@@ -32,22 +33,15 b' from .sphinx_manual import SphinxManualExporter'
 # Classes
 #-----------------------------------------------------------------------------
 
-def DocDecorator(f):    
+def DocDecorator(f):
     
     #Set docstring of function
     f.__doc__ = f.__doc__ + """
     nb : Notebook node
-    config : config
+    config : config (optional, keyword arg)
         User configuration instance.
-    transformers : list[of transformer]
-        Custom transformers to apply to the notebook prior to engaging
-        the Jinja template engine.  Any transformers specified here 
-        will override existing transformers if a naming conflict
-        occurs.
-    filters : list[of filter]
-        Custom filters to make accessible to the Jinja templates.  Any
-        filters specified here will override existing filters if a
-        naming conflict occurs.
+    resources : dict (optional, keyword arg)
+        Resources used in the conversion process.
         
     Returns
     ----------
@@ -85,139 +79,148 b' __all__ = ['
     'export_reveal',
     'export_rst',
     'export_by_name',
-    'get_export_names'
+    'get_export_names',
+    'ExporterNameError'
 ]
 
+
+class ExporterNameError(NameError):
+    pass
+
+
 @DocDecorator
-def export(exporter_type, nb, config=None, transformers=None, filters=None):
+def export(exporter, nb, **kw):
     """
     Export a notebook object using specific exporter class.
     
-    exporter_type : Exporter class type
-        Class type of the exporter that should be used.  This method
-        will initialize 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.}
+    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_type is None:
+    if exporter is None:
         raise TypeError("Exporter is None")
-    elif not issubclass(exporter_type, Exporter):
-        raise TypeError("Exporter type does not inherit from Exporter (base)")
-    
+    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
-    exporter_instance = exporter_type(preprocessors=transformers, 
-                                      jinja_filters=filters, config=config)
+    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)
+        output, resources = exporter_instance.from_notebook_node(nb, resources)
     elif isinstance(nb, basestring):
-        output, resources = exporter_instance.from_filename(nb)
+        output, resources = exporter_instance.from_filename(nb, resources)
     else:
-        output, resources = exporter_instance.from_file(nb)
-    return output, resources, exporter_instance
+        output, resources = exporter_instance.from_file(nb, resources)
+    return output, resources
 
 
 @DocDecorator
-def export_sphinx_manual(nb, config=None, transformers=None, filters=None):
+def export_sphinx_manual(nb, **kw):
     """
     Export a notebook object to Sphinx Manual LaTeX
     """
-    return export(SphinxManualExporter, nb, config, transformers, filters)
+    return export(SphinxManualExporter, nb, **kw)
 
 
 @DocDecorator
-def export_sphinx_howto(nb, config=None, transformers=None, filters=None):
+def export_sphinx_howto(nb, **kw):
     """
     Export a notebook object to Sphinx HowTo LaTeX
     """
-    return export(SphinxHowtoExporter, nb, config, transformers, filters)
+    return export(SphinxHowtoExporter, nb, **kw)
 
 
 @DocDecorator
-def export_basic_html(nb, config=None, transformers=None, filters=None):
+def export_basic_html(nb, **kw):
     """
     Export a notebook object to Basic HTML
     """
-    return export(BasicHTMLExporter, nb, config, transformers, filters)
+    return export(BasicHTMLExporter, nb, **kw)
 
 
 @DocDecorator
-def export_full_html(nb, config=None, transformers=None, filters=None):
+def export_full_html(nb, **kw):
     """
     Export a notebook object to Full HTML
     """
-    return export(FullHTMLExporter, nb, config, transformers, filters)
+    return export(FullHTMLExporter, nb, **kw)
 
 
 @DocDecorator
-def export_latex(nb, config=None, transformers=None, filters=None):
+def export_latex(nb, **kw):
     """
     Export a notebook object to LaTeX
     """
-    return export(LatexExporter, nb, config, transformers, filters)
+    return export(LatexExporter, nb, **kw)
 
 
 @DocDecorator
-def export_markdown(nb, config=None, transformers=None, filters=None):
+def export_markdown(nb, **kw):
     """
     Export a notebook object to Markdown
     """
-    return export(MarkdownExporter, nb, config, transformers, filters)
+    return export(MarkdownExporter, nb, **kw)
 
 
 @DocDecorator
-def export_python(nb, config=None, transformers=None, filters=None):
+def export_python(nb, **kw):
     """
     Export a notebook object to Python
     """
-    return export(PythonExporter, nb, config, transformers, filters)
+    return export(PythonExporter, nb, **kw)
 
 
 @DocDecorator
-def export_reveal(nb, config=None, transformers=None, filters=None):
+def export_reveal(nb, **kw):
     """
-    Export a notebook object to Reveal
+    Export a notebook object to a Reveal.js presentation
     """
-    return export(RevealExporter, nb, config, transformers, filters)
+    return export(RevealExporter, nb, **kw)
 
 
 @DocDecorator
-def export_rst(nb, config=None, transformers=None, filters=None):
+def export_rst(nb, **kw):
     """
-    Export a notebook object to RST
+    Export a notebook object to reStructuredText
     """
-    return export(RstExporter, nb, config, transformers, filters)
+    return export(RSTExporter, nb, **kw)
 
 
 @DocDecorator
-def export_by_name(template_name, nb, config=None, transformers=None, filters=None):
+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.
     
-    template_name : str
+    format_name : str
         Name of the template style to export to.
     """
     
-    function_name = "export_" + template_name.lower()
+    function_name = "export_" + format_name.lower()
     
     if function_name in globals():
-        return globals()[function_name](nb, config, transformers, filters)
+        return globals()[function_name](nb, **kw)
     else:
-        raise NameError("template for `%s` not found" % function_name)
+        raise ExporterNameError("template for `%s` not found" % function_name)
+
 
 def get_export_names():
     "Return a list of the currently supported export targets"
     # grab everything after 'export_'
     l = [x[len('export_'):] for x in __all__ if x.startswith('export_')]
+    
     # filter out the one method that is not a template
     l = [x for x in l if 'by_name' not in x]
     return sorted(l)

IPython/nbconvert/exporters/exporter.py

@@ -20,7 +20,10 b' from __future__ import print_function, absolute_import'
 import io
 import os
 import inspect
-from copy import deepcopy
+import types
+import copy
+import collections
+import datetime
 
 # other libs/dependencies
 from jinja2 import Environment, FileSystemLoader, ChoiceLoader
@@ -29,11 +32,12 b' from jinja2 import Environment, FileSystemLoader, ChoiceLoader'
 from IPython.config.configurable import Configurable
 from IPython.config import Config
 from IPython.nbformat import current as nbformat
-from IPython.utils.traitlets import MetaHasTraits, Unicode
+from IPython.utils.traitlets import MetaHasTraits, DottedObjectName, Unicode, List, Dict
+from IPython.utils.importstring import import_item
 from IPython.utils.text import indent
 
+from IPython.nbconvert import transformers as nbtransformers
 from IPython.nbconvert import filters
-from IPython.nbconvert import transformers
 
 #-----------------------------------------------------------------------------
 # Globals and constants
@@ -68,6 +72,11 b' default_filters = {'
 # Class
 #-----------------------------------------------------------------------------
 
+class ResourcesDict(collections.defaultdict):
+    def __missing__(self, key):
+        return ''
+
+
 class Exporter(Configurable):
     """
     Exports notebooks into other file formats.  Uses Jinja 2 templating engine
@@ -112,27 +121,32 b' class Exporter(Configurable):'
     #Extension that the template files use.    
     template_extension = Unicode(".tpl", config=True)
 
-    #Processors that process the input data prior to the export, set in the 
-    #constructor for this class.
-    transformers = None
+    #Configurability, allows the user to easily add filters and transformers.
+    transformers = List(config=True,
+        help="""List of transformers, by name or namespace, to enable.""")
 
-    
-    def __init__(self, transformers=None, filters=None, config=None, extra_loaders=None, **kw):
+    filters = Dict(config=True,
+        help="""Dictionary of filters, by name and namespace, to add to the Jinja
+        environment.""")
+
+    default_transformers = List([nbtransformers.coalesce_streams,
+                                 nbtransformers.SVG2PDFTransformer,
+                                 nbtransformers.ExtractFigureTransformer,
+                                 nbtransformers.CSSHTMLHeaderTransformer,
+                                 nbtransformers.RevealHelpTransformer,
+                                 nbtransformers.LatexTransformer,
+                                 nbtransformers.SphinxTransformer],
+        config=True,
+        help="""List of transformers available by default, by name, namespace, 
+        instance, or type.""")
+
+
+    def __init__(self, config=None, extra_loaders=None, **kw):
         """
         Public constructor
     
         Parameters
         ----------
-        transformers : list[of transformer]
-            Custom transformers to apply to the notebook prior to engaging
-            the Jinja template engine.  Any transformers specified here 
-            will override existing transformers if a naming conflict
-            occurs.
-        filters : dict[of filter]
-            filters specified here will override existing filters if a naming
-            conflict occurs. Filters are availlable in jinja template through
-            the name of the corresponding key. Cf class docstring for
-            availlable default filters.
         config : config
             User configuration instance.
         extra_loaders : list[of Jinja Loaders]
@@ -147,53 +161,41 b' class Exporter(Configurable):'
 
         super(Exporter, self).__init__(config=c, **kw)
 
-        #Standard environment
+        #Init
         self._init_environment(extra_loaders=extra_loaders)
+        self._init_transformers()
+        self._init_filters()
 
-        #Add transformers
-        self._register_transformers()
-
-        #Add filters to the Jinja2 environment
-        self._register_filters()
-
-        #Load user transformers.  Overwrite existing transformers if need be.
-        if transformers :
-            for transformer in transformers:
-                self.register_transformer(transformer)
-                
-        #Load user filters.  Overwrite existing filters if need be.
-        if not filters is None:
-            for key, user_filter in filters.iteritems():
-                self.register_filter(key, user_filter)
 
     @property
     def default_config(self):
         return Config()
 
     
-    
-    def from_notebook_node(self, nb, resources=None):
+    def from_notebook_node(self, nb, resources=None, **kw):
         """
         Convert a notebook from a notebook node instance.
     
         Parameters
         ----------
         nb : Notebook node
-        resources : a dict of additional resources that
-                can be accessed read/write by transformers
-                and filters.
+        resources : dict (**kw) 
+            of additional resources that can be accessed read/write by 
+            transformers and filters.
         """
-        if resources is None:
-            resources = {}
-        nb, resources = self._preprocess(nb, resources)
-        
-        #Load the template file.
-        self.template = self.environment.get_template(self.template_file+self.template_extension)
-        
-        return self.template.render(nb=nb, resources=resources), resources
+        nb_copy = copy.deepcopy(nb)
+        resources = self._init_resources(resources)
+
+        #Preprocess
+        nb_copy, resources = self._transform(nb_copy, resources)
 
+        #Convert
+        self.template = self.environment.get_template(self.template_file + self.template_extension)
+        output = self.template.render(nb=nb_copy, resources=resources)
+        return output, resources
 
-    def from_filename(self, filename):
+
+    def from_filename(self, filename, resources=None, **kw):
         """
         Convert a notebook from a notebook file.
     
@@ -202,12 +204,24 b' class Exporter(Configurable):'
         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")
         
         with io.open(filename) as f:
-            return self.from_notebook_node(nbformat.read(f, 'json'))
+            return self.from_notebook_node(nbformat.read(f, 'json'), resources=resources,**kw)
 
 
-    def from_file(self, file_stream):
+    def from_file(self, file_stream, resources=None, **kw):
         """
         Convert a notebook from a notebook file.
     
@@ -216,10 +230,10 b' class Exporter(Configurable):'
         file_stream : file-like object
             Notebook file-like object to convert.
         """
-        return self.from_notebook_node(nbformat.read(file_stream, 'json'))
+        return self.from_notebook_node(nbformat.read(file_stream, 'json'), resources=resources, **kw)
 
 
-    def register_transformer(self, transformer):
+    def register_transformer(self, transformer, enabled=False):
         """
         Register a transformer.
         Transformers are classes that act upon the notebook before it is
@@ -231,20 +245,39 b' class Exporter(Configurable):'
         ----------
         transformer : transformer
         """
-        if self.transformers is None:
-            self.transformers = []
+        if transformer is None:
+            raise TypeError('transformer')
+        isclass = inspect.isclass(transformer)
+        constructed = not isclass
+
+        #Handle transformer's registration based on it's type
+        if constructed and isinstance(transformer, types.StringTypes):
+            #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)
         
-        if inspect.isfunction(transformer):
-            self.transformers.append(transformer)
+        if constructed and hasattr(transformer, '__call__'):
+            #Transformer is a function, no need to construct it.
+            #Register and return the transformer.
+            if enabled:
+                transformer.enabled = True
+            self._transformers.append(transformer)
             return transformer
-        elif isinstance(transformer, MetaHasTraits):
-            transformer_instance = transformer(config=self.config)
-            self.transformers.append(transformer_instance)
-            return transformer_instance
+
+        elif isclass and isinstance(transformer, MetaHasTraits):
+            #Transformer is configurable.  Make sure to pass in new default for 
+            #the enabled flag if one was specified.
+            self.register_transformer(transformer(parent=self), enabled)
+
+        elif isclass:
+            #Transformer is not configurable, construct it
+            self.register_transformer(transformer(), enabled)
+
         else:
-            transformer_instance = transformer()
-            self.transformers.append(transformer_instance)
-            return transformer_instance
+            #Transformer is an instance of something without a __call__ 
+            #attribute.  
+            raise TypeError('transformer')
 
 
     def register_filter(self, name, filter):
@@ -259,34 +292,37 b' class Exporter(Configurable):'
             name to give the filter in the Jinja engine
         filter : filter
         """
-        if inspect.isfunction(filter):
+        if filter is None:
+            raise TypeError('filter')
+        isclass = inspect.isclass(filter)
+        constructed = not isclass
+
+        #Handle filter's registration based on it's type
+        if constructed and isinstance(filter, types.StringTypes):
+            #filter is a string, import the namespace and recursively call
+            #this register_filter method
+            filter_cls = import_item(filter)
+            return self.register_filter(name, filter_cls)
+        
+        if constructed and hasattr(filter, '__call__'):
+            #filter is a function, no need to construct it.
             self.environment.filters[name] = filter
-        elif isinstance(filter, MetaHasTraits):
-            self.environment.filters[name] = filter(config=self.config)
+            return filter
+
+        elif isclass and isinstance(filter, MetaHasTraits):
+            #filter is configurable.  Make sure to pass in new default for 
+            #the enabled flag if one was specified.
+            self.register_filter(name, filter(parent=self))
+
+        elif isclass:
+            #filter is not configurable, construct it
+            self.register_filter(name, filter())
+
         else:
-            self.environment.filters[name] = filter()
-        return self.environment.filters[name]
+            #filter is an instance of something without a __call__ 
+            #attribute.  
+            raise TypeError('filter')
 
-    
-    def _register_transformers(self):
-        """
-        Register all of the transformers needed for this exporter.
-        """
-         
-        self.register_transformer(transformers.coalesce_streams)
-        
-        #Remember the figure extraction transformer so it can be enabled and
-        #disabled easily later.
-        self.extract_figure_transformer = self.register_transformer(transformers.ExtractFigureTransformer)
-        
-        
-    def _register_filters(self):
-        """
-        Register all of the filters required for the exporter.
-        """
-        for k, v in default_filters.iteritems():
-            self.register_filter(k, v)
-        
         
     def _init_environment(self, extra_loaders=None):
         """
@@ -321,8 +357,65 b' class Exporter(Configurable):'
         if self.jinja_comment_block_end:
             self.environment.comment_end_string = self.jinja_comment_block_end
 
+    
+    def _init_transformers(self):
+        """
+        Register all of the transformers needed for this exporter, disabled
+        unless specified explicitly.
+        """
+        self._transformers = []
+
+        #Load default transformers (not necessarly enabled by default).
+        if self.default_transformers:
+            for transformer in self.default_transformers:
+                self.register_transformer(transformer)
+
+        #Load user transformers.  Enable by default.
+        if self.transformers:
+            for transformer in self.transformers:
+                self.register_transformer(transformer, 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.iteritems():
+            self.register_filter(key, value)
+
+        #Load user filters.  Overwrite existing filters if need be.
+        if self.filters:
+            for key, user_filter in self.filters.iteritems():
+                self.register_filter(key, user_filter)
+
+
+    def _init_resources(self, resources):
 
-    def _preprocess(self, nb, 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 
@@ -336,13 +429,13 b' class Exporter(Configurable):'
             and filters.
         """
         
-        # Do a deepcopy first, 
+        # Do a copy.deepcopy first, 
         # we are never safe enough with what the transformers could do.
-        nbc =  deepcopy(nb)
-        resc = deepcopy(resources)
+        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:
-            nb, resources = transformer(nbc, resc)
-        return nb, resources
-
+        for transformer in self._transformers:
+            nbc, resc = transformer(nbc, resc)
+        return nbc, resc

IPython/nbconvert/exporters/latex.py

@@ -20,7 +20,7 b' tags to circumvent Jinja/Latex syntax conflicts.'
 import os
 
 # IPython imports
-from IPython.utils.traitlets import Unicode
+from IPython.utils.traitlets import Unicode, List
 from IPython.config import Config
 
 from IPython.nbconvert import filters, transformers
@@ -68,41 +68,35 b' class LatexExporter(Exporter):'
     #Extension that the template files use.    
     template_extension = Unicode(".tplx", config=True)
 
-    def _register_filters(self):
+
+    def _init_filters(self):
         """
         Register all of the filters required for the exporter.
         """
         
         #Register the filters of the base class.
-        super(LatexExporter, self)._register_filters()
+        super(LatexExporter, self)._init_filters()
 
         #Add latex filters to the Jinja2 environment
         self.register_filter('escape_tex', filters.escape_latex) 
         self.register_filter('highlight', filters.highlight2latex) 
     
-    
-    def _register_transformers(self):
-        """
-        Register all of the transformers needed for this exporter.
-        """
-        
-        #Register the transformers of the base class.
-        super(LatexExporter, self)._register_transformers()
-        
-        #Register latex transformer
-        self.register_transformer(transformers.LatexTransformer)
 
     @property
     def default_config(self):
         c = Config({
-            'GlobalConfigurable': {
-                'display_data_priority' : ['latex', 'svg', 'png', 'jpg', 'jpeg' , 'text']
+            'NbConvertBase': {
+                'display_data_priority' : ['latex', 'png', 'jpg', 'svg', 'jpeg', 'text']
                 },
              'ExtractFigureTransformer': {
-                    'enabled':True,
-                    'extra_ext_map':{'svg':'pdf'},
+                    'enabled':True
+                 },
+             'SVG2PDFTransformer': {
+                    'enabled':True
+                 },
+             'LatexTransformer': {
+                    'enabled':True
                  }
          })
         c.merge(super(LatexExporter,self).default_config)
         return c
-

IPython/nbconvert/exporters/reveal.py

@@ -13,7 +13,7 b' Reveal slide show exporter.'
 # Imports
 #-----------------------------------------------------------------------------
 
-from IPython.utils.traitlets import Unicode
+from IPython.utils.traitlets import Unicode, List
 from IPython.config import Config
 
 from .basichtml import BasicHTMLExporter
@@ -35,17 +35,7 b' class RevealExporter(BasicHTMLExporter):'
     template_file = Unicode(
             'reveal', config=True,
             help="Name of the template file to use")
-    
-    def _register_transformers(self):
-        """
-        Register all of the transformers needed for this exporter.
-        """
-        
-        #Register the transformers of the base class.
-        super(RevealExporter, self)._register_transformers()
-        
-        #Register reveal help transformer
-        self.register_transformer(transformers.RevealHelpTransformer)
+
 
     @property
     def default_config(self):

IPython/nbconvert/exporters/rst.py

@@ -22,7 +22,7 b' from .exporter import Exporter'
 # Classes
 #-----------------------------------------------------------------------------
 
-class RstExporter(Exporter):
+class RSTExporter(Exporter):
     """
     Exports restructured text documents.
     """
@@ -38,5 +38,5 b' class RstExporter(Exporter):'
     @property
     def default_config(self):
         c = Config({'ExtractFigureTransformer':{'enabled':True}})
-        c.merge(super(RstExporter,self).default_config)
+        c.merge(super(RSTExporter,self).default_config)
         return c

IPython/nbconvert/exporters/sphinx_howto.py

@@ -14,7 +14,7 b' formatted for use with PDFLatex.'
 # Imports
 #-----------------------------------------------------------------------------
 
-from IPython.utils.traitlets import Unicode
+from IPython.utils.traitlets import Unicode, List
 from IPython.config import Config
 
 # local import
@@ -36,19 +36,9 b' class SphinxHowtoExporter(LatexExporter):'
             'sphinx_howto', config=True,
             help="Name of the template file to use")
 
-    def _register_transformers(self):
-        
-        #Register the transformers of the base class.
-        super(SphinxHowtoExporter, self)._register_transformers()
-        
-        #Register sphinx latex transformer
-        self.register_transformer(transformers.SphinxTransformer) 
-
+    
     @property
     def default_config(self):
-        c = Config({
-        'SphinxTransformer': {'enabled':True}
-        })
+        c = Config({'SphinxTransformer': {'enabled':True}})
         c.merge(super(SphinxHowtoExporter,self).default_config)
         return c
-                    

IPython/nbconvert/filters/ansi.py

@@ -36,7 +36,7 b' def remove_ansi(source):'
         Source to remove the ansi from
     """
     
-    return re.sub(r'\033\[(0|\d;\d\d)m', '', source)
+    return re.sub(r'\033\[(\d|;)+?m', '', source)
 
 
 def ansi2html(text):

IPython/nbconvert/filters/datatypefilter.py

@@ -3,7 +3,7 b''
 The filter contained in the file allows the converter templates to select
 the output format that is most valuable to the active export format.  The
 value of the different formats is set via 
-GlobalConfigurable.display_data_priority
+NbConvertBase.display_data_priority
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
@@ -17,11 +17,11 b' GlobalConfigurable.display_data_priority'
 # Classes and functions
 #-----------------------------------------------------------------------------
 
-from ..utils.config import GlobalConfigurable
+from ..utils.base import NbConvertBase
 
 __all__ = ['DataTypeFilter']
 
-class DataTypeFilter(GlobalConfigurable):
+class DataTypeFilter(NbConvertBase):
     """ Returns the preferred display format """
 
     def __call__(self, output):

IPython/nbconvert/nbconvertapp.py

@@ -1,8 +1,7 b''
 #!/usr/bin/env python
-"""NBConvert is a utility for conversion of IPYNB files.
+"""NBConvert is a utility for conversion of .ipynb files.
 
-Commandline interface for the NBConvert conversion utility.  Read the
-readme.rst for usage information
+Command-line interface for the NbConvert conversion utility.
 """
 #-----------------------------------------------------------------------------
 #Copyright (c) 2013, the IPython Development Team.
@@ -19,211 +18,212 b' readme.rst for usage information'
 #Stdlib imports
 from __future__ import print_function
 import sys
-import io
 import os
+import glob
 
 #From IPython
-from IPython.config.application import Application
-from IPython.utils.traitlets import Bool, Unicode
-
-from .exporters.export import export_by_name, get_export_names
-from .exporters.exporter import Exporter
-from .transformers import extractfigure
-from .utils.config import GlobalConfigurable
-
-#-----------------------------------------------------------------------------
-#Globals and constants
-#-----------------------------------------------------------------------------
-
-#'Keys in resources' user prompt.
-KEYS_PROMPT_HEAD = "====================== Keys in Resources =================================="
-KEYS_PROMPT_BODY = """
-===========================================================================
-You are responsible for writing these files into the appropriate
-directory(ies) if need be.  If you do not want to see this message, enable
-the 'write' (boolean) flag of the converter.
-===========================================================================
-"""
-
-_examples = """
-ipython nbconvert rst Untitled0.ipynb    # convert ipynb to ReStructured Text
-ipython nbconvert latex Untitled0.ipynb  # convert ipynb to LaTeX
-ipython nbconvert reveal Untitled0.ipynb # convert to Reveal (HTML/JS) slideshow
-"""
+from IPython.core.application import BaseIPythonApplication, base_aliases, base_flags
+from IPython.config import catch_config_error, Configurable
+from IPython.utils.traitlets import (
+    Unicode, List, Instance, DottedObjectName, Type, CaselessStrEnum,
+)
+from IPython.utils.importstring import import_item
 
+from .exporters.export import export_by_name, get_export_names, ExporterNameError
+from IPython.nbconvert import exporters, transformers, writers
+from .utils.base import NbConvertBase
 
 #-----------------------------------------------------------------------------
 #Classes and functions
 #-----------------------------------------------------------------------------
 
-class NbConvertApp(Application):
-    __doc__ = """IPython notebook conversion utility
-    
-Convert to and from notebook file type (*.ipynb)
-
-    ipython nbconvert TARGET FILENAME
-
-Supported export TARGETs are: %s
-""" % (" ".join(get_export_names()))
-    description = Unicode(__doc__)
-
-    examples = _examples
-
-    stdout = Bool(
-        False, config=True,
-        help="""Whether to print the converted IPYNB file to stdout
-        use full do diff files without actually writing a new file"""
-        )
-
-    write = Bool(
-        True, config=True,
-        help="""Should the converted notebook file be written to disk
-        along with potential extracted resources."""
+nbconvert_aliases = {}
+nbconvert_aliases.update(base_aliases)
+nbconvert_aliases.update({
+    'format' : 'NbConvertApp.export_format',
+    'notebooks' : 'NbConvertApp.notebooks',
+    'writer' : 'NbConvertApp.writer_class',
+})
+
+nbconvert_flags = {}
+nbconvert_flags.update(base_flags)
+nbconvert_flags.update({
+    'stdout' : (
+        {'NbConvertApp' : {'writer_class' : "StdoutWriter"}},
+        "Write notebook output to stdout instead of files."
         )
+})
 
-    aliases = {
-             'stdout':'NbConvertApp.stdout',
-             'write':'NbConvertApp.write',
-             }
 
-    flags = {}
+class NbConvertApp(BaseIPythonApplication):
+    """Application used to convert to and from notebook file type (*.ipynb)"""
 
-    flags['stdout'] = (
-        {'NbConvertApp' : {'stdout' : True}},
-    """Print converted file to stdout, equivalent to --stdout=True
-    """
-    )
-
-    flags['no-write'] = (
-        {'NbConvertApp' : {'write' : True}},
-    """Do not write to disk, equivalent to --write=False
-    """
+    name = 'ipython-nbconvert'
+    aliases = nbconvert_aliases
+    flags = nbconvert_flags
+    
+    def _classes_default(self):
+        classes = [NbConvertBase]
+        for pkg in (exporters, transformers, writers):
+            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.""")
+
+    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 `--format`.
+        Options include {0}
+        
+        > ipython nbconvert --format latex mynotebook.ipnynb
+        
+        You can also pipe the output to stdout, rather than a file
+        
+        > ipython nbconvert mynotebook.ipynb --stdout
+        
+        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',  
+                      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_factory = Type()
+
+    def _writer_class_changed(self, name, old, new):
+        if new in self.writer_aliases:
+            new = self.writer_aliases[new]
+        self.writer_factory = import_item(new)
+
+
+    #Other configurable variables
+    export_format = CaselessStrEnum(get_export_names(),
+        default_value="full_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):
+        super(NbConvertApp, self).initialize(argv)
+        self.init_notebooks()
+        self.init_writer()
+
+    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.
+        """
 
-    def __init__(self, **kwargs):
-        """Public constructor"""
-
-        #Call base class
-        super(NbConvertApp, self).__init__(**kwargs)
-
-        #Register class here to have help with help all
-        self.classes.insert(0, Exporter)
-        self.classes.insert(0, GlobalConfigurable)
+        # 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:
+            for filename in glob.glob(pattern):
+                if not filename in filenames:
+                    filenames.append(filename)
+        self.notebooks = filenames
 
-    def start(self, argv=None):
-        """Entrypoint of NbConvert application.
-        
-        Parameters
-        ----------
-        argv : list
-            Commandline arguments
+    def init_writer(self):
         """
-        
-        #Parse the commandline options.
-        self.parse_command_line(argv)
+        Initialize the writer (which is stateless)
+        """
+        self._writer_class_changed(None, self.writer_class, self.writer_class)
+        self.writer = self.writer_factory(parent=self)
 
-        #Call base
+    def start(self):
+        """
+        Ran after initialization completed
+        """
         super(NbConvertApp, self).start()
+        self.convert_notebooks()
 
-        #The last arguments in list will be used by nbconvert
-        if len(self.extra_args) is not 3:
-            print( "Wrong number of arguments, use --help flag for usage", file=sys.stderr)
-            sys.exit(-1)
-        export_type = (self.extra_args)[1]
-        ipynb_file = (self.extra_args)[2]
-        
-        #Export
-        try:
-            return_value = export_by_name(export_type, ipynb_file)
-        except NameError as e:
-            print("Error: '%s' exporter not found." % export_type,
-                  file=sys.stderr)
-            print("Known exporters are:",
-                  "\n\t" + "\n\t".join(get_export_names()),
-                  file=sys.stderr)
-            sys.exit(-1)
-        else:
-            (output, resources, exporter) = return_value 
-        
-        #TODO: Allow user to set output directory and file. 
-        destination_filename = None
-        destination_directory = None
-        if self.write:
-                
-            #Get the file name without the '.ipynb' (6 chars) extension and then
-            #remove any addition periods and spaces. The resulting name will
-            #be used to create the directory that the files will be exported
-            #into.
-            out_root = ipynb_file[:-6].replace('.', '_').replace(' ', '_')
-            destination_filename = os.path.join(out_root+'.'+exporter.file_extension)
-            
-            destination_directory = out_root+'_files'
-            if not os.path.exists(destination_directory):
-                os.mkdir(destination_directory)
-                
-        #Write the results
-        if self.stdout or not (destination_filename is None and destination_directory is None):
-            self._write_results(output, resources, destination_filename, destination_directory)
-
-
-    def _write_results(self, output, resources, destination_filename=None, destination_directory=None):
-        """Output the conversion results to the console and/or filesystem
-        
-        Parameters
-        ----------
-        output : str
-            Output of conversion
-        resources : dictionary
-            Additional input/output used by the transformers.  For
-            example, the ExtractFigure transformer outputs the
-            figures it extracts into this dictionary.  This method
-            relies on the figures being in this dictionary when
-            attempting to write the figures to the file system.
-        destination_filename : str, Optional
-            Filename to write output into.  If None, output is not 
-            written to a file.
-        destination_directory : str, Optional 
-            Directory to write notebook data (i.e. figures) to.  If
-            None, figures are not written to the file system.
+    def convert_notebooks(self):
         """
-        
-        if self.stdout:
-            print(output.encode('utf-8'))
-
-        #Write file output from conversion.
-        if not destination_filename is None:
-            with io.open(destination_filename, 'w') as f:
-                f.write(output)
-
-        #Get the key names used by the extract figure transformer
-        figures_key = extractfigure.FIGURES_KEY
-        binary_key = extractfigure.BINARY_KEY
-        text_key = extractfigure.TEXT_KEY
-        
-        #Output any associate figures into the same "root" directory.
-        binkeys = resources.get(figures_key, {}).get(binary_key,{}).keys()
-        textkeys = resources.get(figures_key, {}).get(text_key,{}).keys()
-        if binkeys or textkeys :
-            if not destination_directory is None:
-                for key in binkeys:
-                    with io.open(os.path.join(destination_directory, key), 'wb') as f:
-                        f.write(resources[figures_key][binary_key][key])
-                for key in textkeys:
-                    with io.open(os.path.join(destination_directory, key), 'w') as f:
-                        f.write(resources[figures_key][text_key][key])
-
-            #Figures that weren't exported which will need to be created by the
-            #user.  Tell the user what figures these are.
-            if self.stdout:
-                print(KEYS_PROMPT_HEAD, file=sys.stderr)
-                print(resources[figures_key].keys(), file=sys.stderr)
-                print(KEYS_PROMPT_BODY , file=sys.stderr)
+        Convert the notebooks in the self.notebook traitlet
+        """
+        #Export each notebook
+        conversion_success = 0
+        for notebook_filename in self.notebooks:
+
+            #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('.')]
+            resources = {}
+            resources['unique_key'] = notebook_name
+
+            #Try to export
+            try:
+                output, resources = export_by_name(self.export_format,
+                                              notebook_filename, 
+                                              resources=resources,
+                                              config=self.config)
+            except ExporterNameError as e:
+                print("Error: '%s' exporter not found." % self.export_format,
+                      file=sys.stderr)
+                print("Known exporters are:",
+                      "\n\t" + "\n\t".join(get_export_names()),
+                      file=sys.stderr)
+                sys.exit(-1)
+            #except Exception as e:
+                #print("Error: could not export '%s'" % notebook_filename, file=sys.stderr)
+                #print(e, file=sys.stderr)
+            else:
+                self.writer.write(output, resources, notebook_name=notebook_name)
+                conversion_success += 1
+
+        #If nothing was converted successfully, help the user.
+        if conversion_success == 0:
+
+            #No notebooks were specified, show help.
+            if len(self.notebooks) == 0:
+                self.print_help()
+
+            #Notebooks were specified, but not converted successfully.  Show how
+            #to access help.
+            else:
+                print('For help, use "ipython nbconvert --help"')
+
 
 #-----------------------------------------------------------------------------
 # Main entry point
 #-----------------------------------------------------------------------------
 
 launch_new_instance = NbConvertApp.launch_instance
-

IPython/nbconvert/templates/latex/base.tplx

@@ -41,21 +41,21 b' it introduces a new line'
 
 ((*- block data_png -*))
 \begin{center}
-\includegraphics[max size={0.7\textwidth}{0.9\textheight}]{(((output.key_png)))}
+\includegraphics[max size={0.7\textwidth}{0.9\textheight}]{(((output.png_filename)))}
 \par
 \end{center}
 ((*- endblock -*))
 
 ((*- block data_jpg -*))
 \begin{center}
-\includegraphics[max size={0.7\textwidth}{0.9\textheight}]{(((output.key_jpeg)))}
+\includegraphics[max size={0.7\textwidth}{0.9\textheight}]{(((output.jpeg_filename)))}
 \par
 \end{center}
 ((*- endblock -*))
 
 ((*- block data_svg -*))
 \begin{center}
-\includegraphics[width=0.7\textwidth]{(((output.key_svg)))}
+\includegraphics[width=0.7\textwidth]{(((output.svg_filename)))}
 \par
 \end{center}
 ((*- endblock -*))

IPython/nbconvert/templates/latex/sphinx_base.tplx

@@ -145,11 +145,11 b' Note: For best display, use latex syntax highlighting. =))'
     \sloppy
 
     % Document level variables
-    \title{((( nb.metadata.name | escape_tex )))}
-    \date{((( nb.metadata._draft.date | escape_tex )))}
-    \release{((( nb.metadata._draft.version | escape_tex )))}
-    \author{((( nb.metadata._draft.author | escape_tex )))}
-    \renewcommand{\releasename}{((( nb.metadata._draft.release | escape_tex )))}
+    \title{((( resources.metadata.name | escape_tex )))}
+    \date{((( resources.sphinx.date | escape_tex )))}
+    \release{((( resources.sphinx.version | escape_tex )))}
+    \author{((( resources.sphinx.author | escape_tex )))}
+    \renewcommand{\releasename}{((( resources.sphinx.release | escape_tex )))}
 
     % TODO: Add option for the user to specify a logo for his/her export.
     \newcommand{\sphinxlogo}{}
@@ -347,11 +347,15 b' Note: For best display, use latex syntax highlighting. =))'
 % Supported image formats
 %==============================================================================
 ((*- block data_png -*))
-    ((( conditionally_center_output(insert_graphics(output.key_png)) )))
+    ((( conditionally_center_output(insert_graphics(output.png_filename)) )))
+((*- endblock -*))
+
+((*- block data_jpg -*))
+    ((( conditionally_center_output(insert_graphics(output.jpg_filename)) )))
 ((*- endblock -*))
 
 ((*- block data_svg -*))
-    ((( conditionally_center_output(insert_graphics(output.key_svg)) )))
+    ((( conditionally_center_output(insert_graphics(output.svg_filename)) )))
 ((*- endblock -*))
 
 ((*- block data_latex *))

IPython/nbconvert/templates/markdown.tpl

@@ -30,15 +30,15 b" In[{{cell.prompt_number if cell.prompt_number else ' '}}]:{% endblock in_prompt "
 
 
 {% block data_svg %}
-[!image]({{output.key_svg}})
+[!image]({{output.svg_filename}})
 {% endblock data_svg %}
 
 {% block data_png %}
-[!image]({{output.key_png}})
+[!image]({{output.png_filename}})
 {% endblock data_png %}
 
 {% block data_jpg %}
-[!image]({{output.key_jpg}})
+[!image]({{output.jpg_filename}})
 {% endblock data_jpg %}
 
 

IPython/nbconvert/templates/rst.tpl

@@ -33,15 +33,15 b' Out[{{cell.prompt_number}}]:{% endif %}{% endblock output_prompt %}'
 
 
 
-{% block data_svg %}.. image:: {{output.key_svg}}
+{% block data_svg %}.. image:: {{output.svg_filename}}
 
 {% endblock data_svg %}
 
-{% block data_png %}.. image:: {{output.key_png}}
+{% block data_png %}.. image:: {{output.png_filename}}
 
 {% endblock data_png %}
 
-{% block data_jpg %}..jpg image:: {{output.key_jpg}}
+{% block data_jpg %}..jpg image:: {{output.jpg_filename}}
 
 {% endblock data_jpg %}
 

IPython/nbconvert/transformers/__init__.py

@@ -1,10 +1,12 b''
 # Class base Transformers
-from .activatable import ActivatableTransformer
-from .base import ConfigurableTransformer
+from .base import Transformer
+from .convertfigures import ConvertFiguresTransformer
+from .svg2pdf import SVG2PDFTransformer
 from .extractfigure import ExtractFigureTransformer
 from .revealhelp import RevealHelpTransformer
 from .latex import LatexTransformer
 from .sphinx import SphinxTransformer
+from .csshtmlheader import CSSHTMLHeaderTransformer
 
 # decorated function Transformers
 from .coalescestreams import coalesce_streams

IPython/nbconvert/transformers/base.py

@@ -16,13 +16,14 b' It exposes a convenient class to inherit from to access configurability.'
 # Imports
 #-----------------------------------------------------------------------------
 
-from ..utils.config import GlobalConfigurable
+from ..utils.base import NbConvertBase
+from IPython.utils.traitlets import Bool
 
 #-----------------------------------------------------------------------------
 # Classes and Functions
 #-----------------------------------------------------------------------------
 
-class ConfigurableTransformer(GlobalConfigurable):
+class Transformer(NbConvertBase):
     """ A configurable transformer
 
     Inherit from this class if you wish to have configurability for your
@@ -31,11 +32,16 b' class ConfigurableTransformer(GlobalConfigurable):'
     Any configurable traitlets this class exposed will be configurable in profiles
     using c.SubClassName.atribute=value
 
-    you can overwrite cell_transform to apply a transformation independently on each cell
+    you can overwrite transform_cell to apply a transformation independently on each cell
     or __call__ if you prefer your own logic. See corresponding docstring for informations.
+
+    Disabled by default and can be enabled via the config by
+        'c.YourTransformerName.enabled = True'
     """
     
-    def __init__(self, config=None, **kw):
+    enabled = Bool(False, config=True)
+
+    def __init__(self, **kw):
         """
         Public constructor
         
@@ -47,11 +53,15 b' class ConfigurableTransformer(GlobalConfigurable):'
             Additional arguments
         """
         
-        super(ConfigurableTransformer, self).__init__(config=config, **kw)
+        super(Transformer, self).__init__(**kw)
 
        
     def __call__(self, nb, resources):
-        return self.call(nb,resources)
+        if self.enabled:
+            return self.call(nb,resources)
+        else:
+            return nb, resources
+
 
     def call(self, nb, resources):
         """
@@ -59,7 +69,7 b' class ConfigurableTransformer(GlobalConfigurable):'
         
         You should return modified nb, resources.
         If you wish to apply your transform on each cell, you might want to 
-        overwrite cell_transform method instead.
+        overwrite transform_cell method instead.
         
         Parameters
         ----------
@@ -72,13 +82,13 b' class ConfigurableTransformer(GlobalConfigurable):'
         try :
             for worksheet in nb.worksheets :
                 for index, cell in enumerate(worksheet.cells):
-                    worksheet.cells[index], resources = self.cell_transform(cell, resources, index)
+                    worksheet.cells[index], resources = self.transform_cell(cell, resources, index)
             return nb, resources
         except NotImplementedError:
             raise NotImplementedError('should be implemented by subclass')
 
 
-    def cell_transform(self, cell, resources, index):
+    def transform_cell(self, cell, resources, index):
         """
         Overwrite if you want to apply a transformation on each cell.  You 
         should return modified cell and resource dictionary.

IPython/nbconvert/transformers/coalescestreams.py

@@ -72,4 +72,3 b' def coalesce_streams(cell, resources, index):'
 
     cell.outputs = new_outputs
     return cell, resources
-

IPython/nbconvert/transformers/csshtmlheader.py

@@ -16,18 +16,18 b' import os'
 import io
 
 from pygments.formatters import HtmlFormatter
-        
+
 from IPython.utils import path
 
-from .activatable import ActivatableTransformer
+from .base import Transformer
 
 from IPython.utils.traitlets import Unicode
-        
+
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
-class CSSHTMLHeaderTransformer(ActivatableTransformer):
+class CSSHTMLHeaderTransformer(Transformer):
     """
     Transformer used to pre-process notebook for HTML output.  Adds IPython notebook
     front-end CSS and Pygments CSS to HTML output.

IPython/nbconvert/transformers/extractfigure.py

@@ -12,59 +12,26 b" notebook file. The extracted figures are returned in the 'resources' dictionary"
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
-import itertools
 
-from IPython.utils.traitlets import Dict, Unicode
-from .activatable import ActivatableTransformer
-
-#-----------------------------------------------------------------------------
-# Constants
-#-----------------------------------------------------------------------------
-
-FIGURES_KEY = "figures"
-BINARY_KEY = "binary"
-TEXT_KEY = "text"
+import sys
+from IPython.utils.traitlets import Unicode
+from .base import Transformer
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
-class ExtractFigureTransformer(ActivatableTransformer):
+class ExtractFigureTransformer(Transformer):
     """
     Extracts all of the figures from the notebook file.  The extracted 
     figures are returned in the 'resources' dictionary.
     """
 
-    extra_extension_map =  Dict({},
-        config=True,
-        help="""Extra map to override extension based on type.
-        Useful for latex where SVG will be converted to PDF before inclusion
-        """)
-    
-    key_format_map =  Dict({}, config=True,)
-    figure_name_format_map =  Dict({}, config=True)
-
-    #TODO: Change this to .format {} syntax
-    default_key_template = Unicode('_fig_{index:02d}.{ext}', config=True)
-
-    def __init__(self, config=None, **kw):
-        """
-        Public constructor
-        
-        Parameters
-        ----------
-        config : Config
-            Configuration file structure
-        **kw : misc
-            Additional arguments
-        """
-
-        super(ExtractFigureTransformer, self).__init__(config=config, **kw)
+    figure_filename_template = Unicode(
+        "{unique_key}_{cell_index}_{index}.{extension}", config=True)
 
-        # A unique index for association with extracted figures
-        self.index_generator = itertools.count(1)
 
-    def cell_transform(self, cell, resources, index):
+    def transform_cell(self, cell, resources, cell_index):
         """
         Apply a transformation on each cell,
         
@@ -75,69 +42,49 b' class ExtractFigureTransformer(ActivatableTransformer):'
         resources : dictionary
             Additional resources used in the conversion process.  Allows
             transformers to pass variables into the Jinja engine.
-        index : int
+        cell_index : int
             Index of the cell being processed (see base.py)
         """
+
+        #Get the unique key from the resource dict if it exists.  If it does not 
+        #exist, use 'figure' as the default.
+        unique_key = resources.get('unique_key', 'figure')
         
-        if resources.get(FIGURES_KEY, None) is None :
-            resources[FIGURES_KEY] = {TEXT_KEY:{},BINARY_KEY:{}}
+        #Make sure figures key exists
+        if not 'figures' in resources:
+            resources['figures'] = {}
             
-        for out in cell.get('outputs', []):
+        #Loop through all of the outputs in the cell
+        for index, out in enumerate(cell.get('outputs', [])):
+
+            #Get the output in data formats that the template is interested in.
             for out_type in self.display_data_priority:
-                
                 if out.hasattr(out_type):
-                    figname, key, data, binary = self._new_figure(out[out_type], out_type)
-                    out['key_'+out_type] = figname
+                    data = out[out_type]
+
+                    #Binary files are base64-encoded, SVG is already XML
+                    if out_type in ('png', 'jpg', 'jpeg', 'pdf'):
+                        data = data.decode('base64')
+                    elif sys.platform == 'win32':
+                        data = data.replace('\n', '\r\n').encode("UTF-8")
+                    else:
+                        data = data.encode("UTF-8")
                     
-                    if binary :
-                        resources[FIGURES_KEY][BINARY_KEY][key] = data
-                    else :
-                        resources[FIGURES_KEY][TEXT_KEY][key] = data
-                        
-                    index += 1
-        return cell, resources
-
+                    #Build a figure name
+                    figure_name = self.figure_filename_template.format( 
+                                    unique_key=unique_key,
+                                    cell_index=cell_index,
+                                    index=index,
+                                    extension=out_type)
+
+                    #On the cell, make the figure available via 
+                    #   cell.outputs[i].svg_filename  ... etc (svg in example)
+                    # Where
+                    #   cell.outputs[i].svg  contains the data
+                    out[out_type + '_filename'] = figure_name
+
+                    #In the resources, make the figure available via
+                    #   resources['figures']['filename'] = data
+                    resources['figures'][figure_name] = data
 
-    def _get_override_extension(self, extension):
-        """Gets the overriden extension if it exists, else returns extension. 
-
-        Parameters
-        ----------
-        extension : str
-            File extension.
-        """
-        
-        if extension in self.extra_extension_map :
-            return self.extra_extension_map[extension]
-    
-        return extension
-
-
-    def _new_figure(self, data, format):
-        """Create a new figure file in the given format.
-
-        Parameters
-        ----------
-        data : str
-            Cell data (from Notebook node cell)
-        format : str
-            Figure format
-        index : int
-            Index of the figure being extracted
-        """
-        
-        figure_name_template = self.figure_name_format_map.get(format, self.default_key_template)
-        key_template = self.key_format_map.get(format, self.default_key_template)
-        
-        #TODO: option to pass the hash as data?
-        index = next(self.index_generator)
-        figure_name = figure_name_template.format(index=index, ext=self._get_override_extension(format))
-        key = key_template.format(index=index, ext=self._get_override_extension(format))
-
-        #Binary files are base64-encoded, SVG is already XML
-        binary = False
-        if format in ('png', 'jpg', 'pdf'):
-            data = data.decode('base64')
-            binary = True
-
-        return figure_name, key, data, binary
+        return cell, resources

IPython/nbconvert/transformers/latex.py

@@ -17,19 +17,19 b' from __future__ import print_function, absolute_import'
 
 # Our own imports
 # Needed to override transformer
-from .activatable import (ActivatableTransformer)
+from .base import (Transformer)
 from IPython.nbconvert import filters
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
-class LatexTransformer(ActivatableTransformer):
+class LatexTransformer(Transformer):
     """
     Converter for latex destined documents.
     """
 
-    def cell_transform(self, cell, resources, index):
+    def transform_cell(self, cell, resources, index):
         """
         Apply a transformation on each cell,
         

IPython/nbconvert/transformers/revealhelp.py

@@ -12,14 +12,14 b''
 # Imports
 #-----------------------------------------------------------------------------
 
-from .base import ConfigurableTransformer
+from .base import Transformer
 from IPython.utils.traitlets import Unicode
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
-class RevealHelpTransformer(ConfigurableTransformer):
+class RevealHelpTransformer(Transformer):
 
     url_prefix = Unicode('//cdn.jsdelivr.net/reveal.js/2.4.0',
                          config=True,
@@ -39,9 +39,8 b' class RevealHelpTransformer(ConfigurableTransformer):'
             transformers to pass variables into the Jinja engine.
         """
 
-
         for worksheet in nb.worksheets :
-            for i, cell in enumerate(worksheet.cells):
+            for index, cell in enumerate(worksheet.cells):
 
                 #Make sure the cell has slideshow metadata.
                 cell.metadata.align_type = cell.get('metadata', {}).get('slideshow', {}).get('align_type', 'Left')
@@ -50,9 +49,9 b' class RevealHelpTransformer(ConfigurableTransformer):'
                 #Get the slide type.  If type is start of subslide or slide,
                 #end the last subslide/slide.
                 if cell.metadata.slide_type in ['slide']:
-                    worksheet.cells[i - 1].metadata.slide_helper = 'slide_end'
+                    worksheet.cells[index - 1].metadata.slide_helper = 'slide_end'
                 if cell.metadata.slide_type in ['subslide']:
-                    worksheet.cells[i - 1].metadata.slide_helper = 'subslide_end'
+                    worksheet.cells[index - 1].metadata.slide_helper = 'subslide_end'
 
 
         if 'reveal' not in resources:

IPython/nbconvert/transformers/sphinx.py

@@ -33,7 +33,7 b' from pygments.formatters import LatexFormatter'
 from IPython.utils.traitlets import Unicode, Bool
 
 # Needed to override transformer
-from .activatable import (ActivatableTransformer) #TODO
+from .base import (Transformer)
 
 from IPython.nbconvert.utils import console  
 
@@ -41,7 +41,7 b' from IPython.nbconvert.utils import console'
 # Classes and functions
 #-----------------------------------------------------------------------------
 
-class SphinxTransformer(ActivatableTransformer):
+class SphinxTransformer(Transformer):
     """
     Sphinx utility transformer.
 
@@ -127,9 +127,6 b' class SphinxTransformer(ActivatableTransformer):'
         # TODO: Add versatile method of additional notebook metadata.  Include
         #       handling of multiple files.  For now use a temporay namespace,
         #       '_draft' to signify that this needs to change.
-        if not "_draft" in nb.metadata:
-            nb.metadata._draft = {}
-            
         if not "sphinx" in resources:
             resources["sphinx"] = {}
 
@@ -137,10 +134,10 b' class SphinxTransformer(ActivatableTransformer):'
             
             # Prompt the user for additional meta data that doesn't exist currently
             # but would be usefull for Sphinx.
-            nb.metadata._draft["author"] = self._prompt_author()
-            nb.metadata._draft["version"] = self._prompt_version()
-            nb.metadata._draft["release"] = self._prompt_release()
-            nb.metadata._draft["date"] = self._prompt_date()
+            resources["sphinx"]["author"] = self._prompt_author()
+            resources["sphinx"]["version"] = self._prompt_version()
+            resources["sphinx"]["release"] = self._prompt_release()
+            resources["sphinx"]["date"] = self._prompt_date()
             
             # Prompt the user for the document style.
             resources["sphinx"]["chapterstyle"] = self._prompt_chapter_title_style()
@@ -152,15 +149,17 b' class SphinxTransformer(ActivatableTransformer):'
         else:
             
             # Try to use the traitlets.
-            nb.metadata._draft["author"] = self.author
-            nb.metadata._draft["version"] = self.version
-            nb.metadata._draft["release"] = self.release
+            resources["sphinx"]["author"] = self.author
+            resources["sphinx"]["version"] = self.version
+            resources["sphinx"]["release"] = self.release
             
             # Use todays date if none is provided.
-            if len(self.publish_date.strip()) == 0:
-                nb.metadata._draft["date"] = date.today().strftime("%B %d, %Y")
+            if self.publish_date:
+                resources["sphinx"]["date"] = self.publish_date
+            elif len(resources['metadata']['modified_date'].strip()) == 0:
+                resources["sphinx"]["date"] = date.today().strftime("%B %-d, %Y")
             else:
-                nb.metadata._draft["date"] = self.publish_date
+                resources["sphinx"]["date"] = resources['metadata']['modified_date']
             
             # Sphinx traitlets.
             resources["sphinx"]["chapterstyle"] = self.chapter_style
@@ -175,7 +174,7 b' class SphinxTransformer(ActivatableTransformer):'
         resources["sphinx"]["pygment_definitions"] = self._generate_pygments_latex_def()
         
         if not (self.overridetitle == None or len(self.overridetitle.strip()) == 0):
-            nb.metadata.name = self.overridetitle
+            resources['metadata']['name'] = self.overridetitle
         
         # End
         return nb, resources 
@@ -212,12 +211,16 b' class SphinxTransformer(ActivatableTransformer):'
         return  console.input("Release Name (ie ""Rough draft""): ")
     
     
-    def _prompt_date(self):
+    def _prompt_date(self, resources):
         """
         Prompt the user to enter a date
         """
         
-        default_date = date.today().strftime("%B %d, %Y")
+        if resources['metadata']['modified_date']:
+            default_date = resources['metadata']['modified_date']
+        else:
+            default_date = date.today().strftime("%B %-d, %Y")
+            
         user_date = console.input("Date (deafults to \"" + default_date + "\"): ")
         if len(user_date.strip()) == 0:
             user_date = default_date

IPython/nbconvert/utils/base.py

@@ -18,7 +18,7 b' from IPython.config.configurable import Configurable'
 # Classes and functions
 #-----------------------------------------------------------------------------
            
-class GlobalConfigurable(Configurable):
+class NbConvertBase(Configurable):
     """Global configurable class for shared config
 
     Usefull for display data priority that might be use by many trasnformers
@@ -33,5 +33,5 b' class GlobalConfigurable(Configurable):'
                     """
             )
 
-    def __init__(self, config=None, **kw):
-        super(GlobalConfigurable, self).__init__( config=config, **kw)
+    def __init__(self, **kw):
+        super(NbConvertBase, self).__init__(**kw)