Added writers and supporting code.

IPython/nbconvert/transformers/convertfigures.py

@@ -0,0 +1,74 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 .activatable import ActivatableTransformer
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+
+class ConvertFiguresTransformer(ActivatableTransformer):
+    """
+    Converts all of the outputs in a notebook from one format to another.
+    """
+
+
+    def __init__(self, from_formats, to_format, **kw):
+        """
+        Public constructor
+        
+        Parameters
+        ----------
+        from_formats : list [of string]
+            Formats that the converter can convert from
+        to_format : string
+            Format that the converter converts to
+        config : Config
+            Configuration file structure
+        **kw : misc
+            Additional arguments
+        """
+        super(ConvertFiguresTransformer, self).__init__(**kw)
+
+        self._from_formats = from_formats
+        self._to_format = to_format
+
+
+    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():
+                self._convert_figure(cell_out, data_type, data)
+        return cell, resources
+
+
+    def _convert_figure(self, cell_out, 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 in self._from_formats:
+                cell_out[self._to_format] = self.convert_figure(data_type, data)

IPython/nbconvert/transformers/convertsvg.py

@@ -0,0 +1,70 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
+from IPython.utils.tempdir import TemporaryDirectory
+
+from .convertfigures import ConvertFiguresTransformer
+
+
+#-----------------------------------------------------------------------------
+# Constants
+#-----------------------------------------------------------------------------
+
+INKSCAPE_COMMAND = "inkscape --without-gui --export-pdf=\"{to_filename}\" \"{from_filename}\""
+
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+
+class ConvertSvgTransformer(ConvertFiguresTransformer):
+    """
+    Converts all of the outputs in a notebook from one format to another.
+    """
+
+
+    def __init__(self, **kw):
+        """
+        Constructor
+        """
+        super(ConvertSvgTransformer, self).__init__(['svg'], 'pdf', **kw)
+
+
+    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)
+
+            #Call conversion application
+            output_filename = os.path.join(tmpdir, 'figure.pdf')
+            shell = INKSCAPE_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) as f:
+                    return f.read()      
+            else:
+                return TypeError("Inkscape svg to png conversion failed")

IPython/nbconvert/__init__.py

@@ -1,5 +1,6 b''
 """Utilities for converting notebooks to and from different formats."""
 
 from .exporters import *
 import filters
 import transformers
+import writers

IPython/nbconvert/exporters/export.py

@@ -1,223 +1,217 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 Exporter
 from .basichtml import BasicHTMLExporter
 from .fullhtml import FullHTMLExporter
 from .latex import LatexExporter
 from .markdown import MarkdownExporter
 from .python import PythonExporter
 from .reveal import RevealExporter
 from .rst import RstExporter
 from .sphinx_howto import SphinxHowtoExporter
 from .sphinx_manual import SphinxManualExporter
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 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
     ----------
     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."""
             
     @wraps(f)
     def decorator(*args, **kwargs):
         return f(*args, **kwargs)
     
     return decorator
 
 
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
 
 __all__ = [
     'export',
     'export_sphinx_manual',
     'export_sphinx_howto',
     'export_basic_html',
     'export_full_html',
     'export_latex',
     'export_markdown',
     'export_python',
     'export_reveal',
     'export_rst',
     'export_by_name',
     'get_export_names'
 ]
 
 @DocDecorator
-def export(exporter_type, nb, config=None, transformers=None, filters=None):
+def export(exporter_type, 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.}
     """
     
     #Check arguments
     if exporter_type is None:
         raise TypeError("Exporter is None")
     elif not issubclass(exporter_type, Exporter):
         raise TypeError("Exporter type 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)
+    exporter_instance = exporter_type(config=kw.get('config', Config()))
 
     #Try to convert the notebook using the appropriate conversion function.
+    resources = kw.get('resources', {})
     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
     """
-    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
     """
-    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)
 
 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
+    
+	# 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

@@ -1,346 +1,360 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 types
 from copy import deepcopy
 
 # other libs/dependencies
 from jinja2 import Environment, FileSystemLoader, ChoiceLoader
 
 # IPython imports
 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 filters
 from IPython.nbconvert import transformers
 
 #-----------------------------------------------------------------------------
 # Globals and constants
 #-----------------------------------------------------------------------------
 
 #Jinja2 extensions to load.
 JINJA_EXTENSIONS = ['jinja2.ext.loopcontrols']
 
 default_filters = {
         'indent': indent,
         'markdown': filters.markdown2html,
         'ansi2html': filters.ansi2html,
         'filter_data_type': filters.DataTypeFilter,
         'get_lines': filters.get_lines,
         'highlight': filters.highlight,
         'highlight2html': filters.highlight,
         'highlight2latex': filters.highlight2latex,
         'markdown2latex': filters.markdown2latex,
         'markdown2rst': filters.markdown2rst,
         'pycomment': filters.python_comment,
         'rm_ansi': filters.remove_ansi,
         'rm_dollars': filters.strip_dollars,
         'rm_fake': filters.rm_fake,
         'ansi2latex': filters.ansi2latex,
         'rm_math_space': filters.rm_math_space,
         'wrap': filters.wrap
 }
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class Exporter(Configurable):
     """
     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/transformers.  If the filters/
     transformers 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(
             '', config=True,
             help="Name of the template file to use")
 
     file_extension = Unicode(
         'txt', config=True, 
         help="Extension of the file that should be written to disk"
         )
 
     template_path = Unicode(
         os.path.join("..", "templates"), config=True,
         help="Path where the template files are located.")
 
     template_skeleton_path = Unicode(
         os.path.join("..", "templates", "skeleton"), config=True,
         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)
 
-    #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.""")
+    filters = Dict(config=True,
+        help="""Dictionary of filters, by name and namespace, to add to the Jinja
+        environment.""")
     
-    def __init__(self, transformers=None, filters=None, config=None, extra_loaders=None, **kw):
+    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]
             ordered list of Jinja loder to find templates. Will be tried in order
             before the default FileSysteme ones.
         """
         
         #Call the base class constructor
         c = self.default_config
         if config:
             c.merge(config)
 
         super(Exporter, self).__init__(config=c, **kw)
 
         #Standard environment
         self._init_environment(extra_loaders=extra_loaders)
 
         #Add transformers
+        self._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 transformers.  Enabled by default.
+        if self.transformers:
+            for transformer in self.transformers:
+                self.register_transformer(transformer, True)
                 
         #Load user filters.  Overwrite existing filters if need be.
-        if not filters is None:
-            for key, user_filter in filters.iteritems():
+        if self.filters:
+            for key, user_filter in self.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={}, **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 = {}
+
+        #Preprocess
         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
 
+        #Convert
+        self.template = self.environment.get_template(self.template_file + self.template_extension)
+        output = self.template.render(nb=nb, resources=resources)
+
+        #Set output extension in resources dict
+        resources['output_extension'] = self.file_extension
+        return output, resources
 
-    def from_filename(self, filename):
+
+    def from_filename(self, filename, resources={}, **kw):
         """
         Convert a notebook from a notebook file.
     
         Parameters
         ----------
         filename : str
             Full filename of the notebook file to open and convert.
         """
         
         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={}, **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'))
+        return self.from_notebook_node(nbformat.read(file_stream, 'json'), resources=resources, **kw)
 
 
-    def register_transformer(self, transformer):
+    def register_transformer(self, transformer, enabled=None):
         """
         Register a transformer.
         Transformers are classes that act upon the notebook before it is
         passed into the Jinja templating engine.  Transformers are also
         capable of passing additional information to the Jinja
         templating engine.
     
         Parameters
         ----------
         transformer : transformer
         """
-        if self.transformers is None:
-            self.transformers = []
-        
+
+        #Handle transformer's registration based on it's type
         if inspect.isfunction(transformer):
-            self.transformers.append(transformer)
+            #Transformer is a function, no need to construct it.
+            self._transformers.append(transformer)
             return transformer
+
+        elif isinstance(transformer, types.StringTypes):
+            #Transformer is a string, import the namespace and recursively call
+            #this register_transformer method
+            transformer_cls = import_item(DottedObjectName(transformer))
+            return self.register_transformer(transformer_cls, enabled=None)
+
         elif isinstance(transformer, MetaHasTraits):
-            transformer_instance = transformer(config=self.config)
-            self.transformers.append(transformer_instance)
-            return transformer_instance
+            #Transformer is configurable.  Make sure to pass in new default for 
+            #the enabled flag if one was specified.
+            c = Config()
+            if not enabled is None:
+                c = Config({transformer.__name__: {'enabled': enabled}})
+            c.merge(self.config)
+            transformer_instance = transformer(config=c)
+
         else:
+            #Transformer is not configurable, construct it
             transformer_instance = transformer()
-            self.transformers.append(transformer_instance)
-            return transformer_instance
+
+        #Register and return the transformer.
+        self._transformers.append(transformer_instance)
+        return transformer_instance
 
 
     def register_filter(self, name, 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 inspect.isfunction(filter):
             self.environment.filters[name] = filter
+        elif isinstance(filter, types.StringTypes):
+            filter_cls = import_item(DottedObjectName(filter))
+            self.register_filter(name, filter_cls)
         elif isinstance(filter, MetaHasTraits):
             self.environment.filters[name] = filter(config=self.config)
         else:
             self.environment.filters[name] = filter()
         return self.environment.filters[name]
 
     
     def _register_transformers(self):
         """
-        Register all of the transformers needed for this exporter.
+        Register all of the transformers needed for this exporter, disabled
+        unless specified explicitly.
         """
-         
+
         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)
+        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)
+        for key, value in default_filters.iteritems():
+            self.register_filter(key, value)
         
         
     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)
 
         loaders.append(FileSystemLoader([
                 os.path.join(here, self.template_path),
                 os.path.join(here, self.template_skeleton_path),
                 ]))
 
         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 _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 transformers
             and filters.
         """
         
         # Do a deepcopy first, 
         # we are never safe enough with what the transformers could do.
         nbc =  deepcopy(nb)
         resc = 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

@@ -1,108 +1,111 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
 from IPython.config import Config
 
 from IPython.nbconvert import filters, transformers
 from .exporter import Exporter
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 class LatexExporter(Exporter):
     """
     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")
 
     template_file = Unicode(
         'base', config=True,
         help="Name of the template file to use")
 
     #Latex constants
     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)
 
     def _register_filters(self):
         """
         Register all of the filters required for the exporter.
         """
         
         #Register the filters of the base class.
         super(LatexExporter, self)._register_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 ConvertSvgTransformer before any other transformers!  
+        #Important because it allows the conversion of svg->png BEFORE the
+        #extract figure transformer acts on the data.
+        self.register_transformer(transformers.ConvertSvgTransformer, True)
         
-        #Register the transformers of the base class.
+        #Register transformers
         super(LatexExporter, self)._register_transformers()
-        
-        #Register latex transformer
-        self.register_transformer(transformers.LatexTransformer)
+        self.register_transformer(transformers.LatexTransformer, True)
 
     @property
     def default_config(self):
         c = Config({
             'GlobalConfigurable': {
-                'display_data_priority' : ['latex', 'svg', 'png', 'jpg', 'jpeg' , 'text']
+                'display_data_priority' : ['latex', 'png', 'jpg', 'jpeg']
                 },
              'ExtractFigureTransformer': {
-                    'enabled':True,
-                    'extra_ext_map':{'svg':'pdf'},
+                    'enabled':True
                  }
+                 
          })
         c.merge(super(LatexExporter,self).default_config)
         return c
 

IPython/nbconvert/exporters/reveal.py

@@ -1,61 +1,61 b''
 """
 Reveal 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.config import Config
 
 from .basichtml import BasicHTMLExporter
 from IPython.nbconvert import transformers
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class RevealExporter(BasicHTMLExporter):
     """
     Exports a Reveal slide show (.HTML) which may be rendered in a web browser.
     """
     
     file_extension = Unicode(
         'reveal.html', config=True, 
         help="Extension of the file that should be written to disk")
 
     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)
+        self.register_transformer(transformers.RevealHelpTransformer, True)
 
     @property
     def default_config(self):
         c = Config({
             'CSSHTMLHeaderTransformer':{
                 'enabled':True
                 },
             'RevealHelpTransformer':{
                 'enabled':True,
                 },                
             })
         c.merge(super(RevealExporter,self).default_config)
         return c

IPython/nbconvert/exporters/sphinx_howto.py

@@ -1,54 +1,45 b''
 """
 Exporter for exporting notebooks to Sphinx 'HowTo' style latex.  Latex 
 formatted for use with PDFLatex.
 """
 #-----------------------------------------------------------------------------
 # 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
 
 # local import
 from .latex import LatexExporter
 
 from IPython.nbconvert import transformers
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class SphinxHowtoExporter(LatexExporter):
     """
     Exports Sphinx "HowTo" LaTeX documents.  The Sphinx "HowTo" exporter 
     produces short document format latex for use with PDFLatex.
     """
     
     template_file = Unicode(
             '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.merge(super(SphinxHowtoExporter,self).default_config)
-        return c
-                    
+        self.register_transformer(transformers.SphinxTransformer, True) 

IPython/nbconvert/nbconvertapp.py

@@ -1,229 +1,167 b''
 #!/usr/bin/env python
 """NBConvert is a utility for conversion of IPYNB files.
 
 Commandline interface for the NBConvert conversion utility.  Read the
 readme.rst for usage information
 """
 #-----------------------------------------------------------------------------
 #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
 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 IPython.core.application import BaseIPythonApplication
+from IPython.config.application import catch_config_error
+from IPython.utils.traitlets import Unicode, List, Instance, DottedObjectName, Type
+from IPython.utils.importstring import import_item
 
 from .exporters.export import export_by_name, get_export_names
 from .exporters.exporter import Exporter
-from .transformers import extractfigure
+from .writers.base import WriterBase
 from .utils.config import GlobalConfigurable
 
 #-----------------------------------------------------------------------------
-#Globals and constants
+#Classes and functions
 #-----------------------------------------------------------------------------
 
-#'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.
-===========================================================================
-"""
+class NbConvertApp(BaseIPythonApplication):
+    """Application used to convert to and from notebook file type (*.ipynb)"""
 
-_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
-"""
 
+    description = Unicode(
+        u"""This application is used to convert notebook files (*.ipynb).
+        An ipython config file can be used to batch convert notebooks in the 
+        current directory.""")
 
-#-----------------------------------------------------------------------------
-#Classes and functions
-#-----------------------------------------------------------------------------
+    examples = Unicode(u"""
+        Running `ipython nbconvert` will read the directory config file and then 
+        apply it to one or more notebooks.
 
-class NbConvertApp(Application):
-    __doc__ = """IPython notebook conversion utility
+        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
+        > ipython nbconvert # this will use the config file to fill in the notebooks
+        """)
     
-Convert to and from notebook file type (*.ipynb)
+    config_file_name = Unicode(u'ipython_nbconvert_config.py')
 
-    ipython nbconvert TARGET FILENAME
+    #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()
 
-Supported export TARGETs are: %s
-""" % (" ".join(get_export_names()))
-    description = Unicode(__doc__)
+    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)
 
-    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"""
-        )
+    #Other configurable variables
+    export_format = Unicode(
+        "", config=True,
+        help="""If specified, nbconvert will convert the document(s) specified
+                using this format.""")
 
-    write = Bool(
-        True, config=True,
-        help="""Should the converted notebook file be written to disk
-        along with potential extracted resources."""
-        )
+    notebooks = List([], config=True, help="""List of notebooks to convert.
+                     Search patterns are supported.""")
 
-    aliases = {
-             'stdout':'NbConvertApp.stdout',
-             'write':'NbConvertApp.write',
-             }
+    aliases = {'format':'NbConvertApp.export_format',
+               'notebooks':'NbConvertApp.notebooks',
+               'writer':'NbConvertApp.writer_class'} 
 
-    flags = {}
 
-    flags['stdout'] = (
-        {'NbConvertApp' : {'stdout' : True}},
-    """Print converted file to stdout, equivalent to --stdout=True
-    """
-    )
+    @catch_config_error
+    def initialize(self, argv=None):
+        super(NbConvertApp, self).initialize(argv)
 
-    flags['no-write'] = (
-        {'NbConvertApp' : {'write' : True}},
-    """Do not write to disk, equivalent to --write=False
-    """
-    )
+        #Register class here to have help with help all
+        self.classes.insert(0, Exporter)
+        self.classes.insert(0, WriterBase)
+        self.classes.insert(0, GlobalConfigurable)
 
+        #Init
+        self.init_config(self.extra_args)
+        self.init_writer()
 
-    def __init__(self, **kwargs):
-        """Public constructor"""
 
-        #Call base class
-        super(NbConvertApp, self).__init__(**kwargs)
+    def init_config(self, extra_args):
+        """
+        Add notebooks to the config if needed.  Glob each notebook to replace
+        notebook patterns with filenames.
+        """
 
-        #Register class here to have help with help all
-        self.classes.insert(0, Exporter)
-        self.classes.insert(0, GlobalConfigurable)
+        #Get any additional notebook patterns from the commandline
+        if len(extra_args) > 0:
+            for pattern in extra_args:
+                self.notebooks.append(pattern)
+
+        #Use glob to replace all the notebook patterns with filenames.
+        filenames = []
+        for pattern in self.notebooks:
+            for filename in glob.glob(pattern):
+                if not filename in filenames:
+                    filenames.append(filename)
+        self.notebooks = filenames
+
+
+    def init_writer(self):
+        """
+        Initialize the writer (which is stateless)
+        """
+        self._writer_class_changed(None, self.writer_class, self.writer_class)
+        self.writer = self.writer_factory(parent=self)
 
 
     def start(self, argv=None):
-        """Entrypoint of NbConvert application.
-        
-        Parameters
-        ----------
-        argv : list
-            Commandline arguments
         """
-        
-        #Parse the commandline options.
-        self.parse_command_line(argv)
+        Entrypoint of NbConvert application.
+        """
 
         #Call base
         super(NbConvertApp, self).start()
 
-        #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.
-        """
-        
-        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)
+        #Export each notebook
+        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
+
+            #Export & write
+            output, resources = export_by_name(self.export_format,
+                                               notebook_filename, 
+                                               resources=resources,
+                                               config=self.config)
+            self.writer.write(output, resources, notebook_name=notebook_name)
+
 
 #-----------------------------------------------------------------------------
 # Main entry point
 #-----------------------------------------------------------------------------
 
 launch_new_instance = NbConvertApp.launch_instance
 

IPython/nbconvert/transformers/__init__.py

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

IPython/nbconvert/transformers/base.py

@@ -1,99 +1,99 b''
 """
 Module that re-groups transformer that would be applied to ipynb files
 before going through the templating machinery.
 
 It exposes a convenient class to inherit from to access configurability.
 """
 #-----------------------------------------------------------------------------
 # 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 ..utils.config import GlobalConfigurable
 
 #-----------------------------------------------------------------------------
 # Classes and Functions
 #-----------------------------------------------------------------------------
 
 class ConfigurableTransformer(GlobalConfigurable):
     """ A configurable transformer
 
     Inherit from this class if you wish to have configurability for your
     transformer.
 
     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.
     """
     
     def __init__(self, config=None, **kw):
         """
         Public constructor
         
         Parameters
         ----------
         config : Config
             Configuration file structure
         **kw : misc
             Additional arguments
         """
         
         super(ConfigurableTransformer, self).__init__(config=config, **kw)
 
        
     def __call__(self, nb, resources):
         return self.call(nb,resources)
 
     def call(self, nb, resources):
         """
         Transformation to apply on each notebook.
         
         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
         ----------
         nb : NotebookNode
             Notebook being converted
         resources : dictionary
             Additional resources used in the conversion process.  Allows
             transformers to pass variables into the Jinja engine.
         """
         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.
         
         Parameters
         ----------
         cell : NotebookNode cell
             Notebook cell being processed
         resources : dictionary
             Additional resources used in the conversion process.  Allows
             transformers to pass variables into the Jinja engine.
         index : int
             Index of the cell being processed
         """
 
         raise NotImplementedError('should be implemented by subclass')
         return cell, resources
 

IPython/nbconvert/transformers/extractfigure.py

@@ -1,143 +1,97 b''
 """Module containing a transformer that extracts all of the figures from the
 notebook file.  The extracted figures are returned in the 'resources' dictionary.
 """
 #-----------------------------------------------------------------------------
 # 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 itertools
 
 from IPython.utils.traitlets import Dict, Unicode
 from .activatable import ActivatableTransformer
 
 #-----------------------------------------------------------------------------
 # Constants
 #-----------------------------------------------------------------------------
 
-FIGURES_KEY = "figures"
-BINARY_KEY = "binary"
-TEXT_KEY = "text"
+# win64 is win32 for backwards compatability, for now.  See 
+# http://mail.python.org/pipermail/patches/2000-May/000648.html
+# for the original patch that this decision was made.
+WINDOWS_PLATFORMS = ['win32']
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class ExtractFigureTransformer(ActivatableTransformer):
     """
     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)
+    figure_filename_template = Unicode(
+        "{unique_key}_{cell_index}_{index}.{extension}", 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)
-
-        # 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,
         
         Parameters
         ----------
         cell : NotebookNode cell
             Notebook cell being processed
         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
-                    
-                    if binary :
-                        resources[FIGURES_KEY][BINARY_KEY][key] = data
-                    else :
-                        resources[FIGURES_KEY][TEXT_KEY][key] = data
-                        
-                    index += 1
-        return cell, resources
-
-
-    def _get_override_extension(self, extension):
-        """Gets the overriden extension if it exists, else returns extension. 
+                    data = out[out_type]
 
-        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.
+                    #Binary files are base64-encoded, SVG is already XML
+                    if out_type in ('png', 'jpg', 'pdf'):
+                        data = data.decode('base64')
+                    elif sys.platform in WINDOWS_PLATFORMS:
+                        data = data.replace('\n', '\r\n')
+                    
+                    #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
 
-        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

@@ -1,53 +1,53 b''
 """Module that allows latex output notebooks to be conditioned before
 they are converted.
 """
 #-----------------------------------------------------------------------------
 # 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
 
 # Our own imports
 # Needed to override transformer
 from .activatable import (ActivatableTransformer)
 from IPython.nbconvert import filters
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class LatexTransformer(ActivatableTransformer):
     """
     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,
         
         Parameters
         ----------
         cell : NotebookNode cell
             Notebook cell being processed
         resources : dictionary
             Additional resources used in the conversion process.  Allows
             transformers to pass variables into the Jinja engine.
         index : int
             Modified index of the cell being processed (see base.py)
         """
         
         #If the cell is a markdown cell, preprocess the ampersands used to
         #remove the space between them and their contents.  Latex will complain
         #if spaces exist between the ampersands and the math content.  
         #See filters.latex.rm_math_space for more information.
         if hasattr(cell, "source") and cell.cell_type == "markdown":
             cell.source = filters.rm_math_space(cell.source)
         return cell, resources

IPython/nbconvert/transformers/revealhelp.py

@@ -1,62 +1,61 b''
 """Module that pre-processes the notebook for export via Reveal.
 """
 #-----------------------------------------------------------------------------
 # 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 ConfigurableTransformer
 from IPython.utils.traitlets import Unicode
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 class RevealHelpTransformer(ConfigurableTransformer):
 
     url_prefix = Unicode('//cdn.jsdelivr.net/reveal.js/2.4.0',
                          config=True,
                          help="""If you want to use a local reveal.js library,
                          use 'url_prefix':'reveal.js' in your config object.""")
 
     def call(self, nb, resources):
         """
         Called once to 'transform' contents of the notebook.
 
         Parameters
         ----------
         nb : NotebookNode
             Notebook being converted
         resources : dictionary
             Additional resources used in the conversion process.  Allows
             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')
                 cell.metadata.slide_type = cell.get('metadata', {}).get('slideshow', {}).get('slide_type', '-')
 
                 #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:
             resources['reveal'] = {}
         resources['reveal']['url_prefix'] = self.url_prefix
 
         return nb, resources