Fixed all broken references, refactored some stuff here and there,

standardized nomenclature.   Ready to test...

nbconvert.py

@@ -26,13 +26,10 b' import os'
 #From IPython
 #All the stuff needed for the configurable things
 from IPython.config.application import Application
-from IPython.config.loader import ConfigFileNotFound
-from IPython.utils.traitlets import Unicode, Bool
 
 #Local imports
-from api.exporter import Exporter
-from converters.config import GlobalConfigurable #TODO
-from converters.transformers import (ExtractFigureTransformer) #TODO
+from nbconvert.api.convert import export_by_name
+from nbconvert.api.exporter import Exporter
 
 #-----------------------------------------------------------------------------
 #Globals and constants
@@ -78,8 +75,6 b' class NbconvertApp(Application):'
 
         #Register class here to have help with help all
         self.classes.insert(0, Exporter)
-        self.classes.insert(0, ExtractFigureTransformer)
-        self.classes.insert(0, GlobalConfigurable)
 
 
     def start(self, argv=None):
@@ -91,51 +86,57 b' class NbconvertApp(Application):'
         #Call base
         super(NbconvertApp, self).start()
 
-        #The last arguments in chain of arguments will be used as conversion
-        ipynb_file = (self.extra_args or [None])[2]
-
-        #If you are writting a custom transformer, append it to the dictionary
-        #below.
-        userpreprocessors = {}
-
-        #Create the Jinja template exporter.  TODO: Add ability to 
-        #import in IPYNB aswell
-        exporter = Exporter(config=self.config, preprocessors=userpreprocessors,export_format=export_format)
+        #The last arguments in chain of arguments will be used as conversion type
+        ipynb_file = (self.extra_args)[2]
+        export_type = (self.extra_args)[1]
 
         #Export
-        output, resources = exporter.from_filename(ipynb_file)
-        if exporter.stdout :
+        output, resources, exporter = export_by_name(ipynb_file, export_type)
+
+        destination_filename = None
+        destination_directory = None
+        if exporter.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.fileext)
+            
+            destination_directory = out_root+'_files'
+            if not os.path.exists(destination_directory):
+                os.mkdir(destination_directory)
+                
+        #Write the results
+        if exporter.stdout or exporter.write:
+            self._write_results(exporter.stdout, destination_filename, destination_directory, output, resources)
+
+
+    def _write_results(self, stdout, destination_filename, destination_directory, output, resources):
+        if stdout:
             print(output.encode('utf-8'))
 
-        #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(' ', '_')
-
         #Write file output from conversion.
-        if exporter.write :
-            with io.open(os.path.join(out_root+'.'+exporter.fileext), 'w') as f:
+        if not destination_filename is None:
+            with io.open(destination_filename, 'w') as f:
                 f.write(output)
 
         #Output any associate figures into the same "root" directory.
         binkeys = resources.get('figures', {}).get('binary',{}).keys()
         textkeys = resources.get('figures', {}).get('text',{}).keys()
         if binkeys or textkeys :
-            if exporter.write:
-                files_dir = out_root+'_files'
-                if not os.path.exists(out_root+'_files'):
-                    os.mkdir(files_dir)
+            if not destination_directory is None:
                 for key in binkeys:
-                    with io.open(os.path.join(files_dir, key), 'wb') as f:
+                    with io.open(os.path.join(destination_directory, key), 'wb') as f:
                         f.write(resources['figures']['binary'][key])
                 for key in textkeys:
-                    with io.open(os.path.join(files_dir, key), 'w') as f:
+                    with io.open(os.path.join(destination_directory, key), 'w') as f:
                         f.write(resources['figures']['text'][key])
 
             #Figures that weren't exported which will need to be created by the
             #user.  Tell the user what figures these are.
-            elif exporter.stdout:
+            if stdout:
                 print(KEYS_PROMPT_HEAD)
                 print(resources['figures'].keys())
                 print(KEYS_PROMPT_BODY)

nbconvert/api/convert.py

@@ -11,11 +11,73 b' they are converted.'
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
+from .exporter import Exporter
+
+from .html import HtmlExporter
+from .latex import LatexExporter
+from .markdown import MarkdownExporter
+from .python import PythonExporter
+from .reveal import RevealExporter
+from .rst import RstExporter
+from .sphinx import SphinxExporter
+
+from IPython.nbformat.v3.nbbase import NotebookNode
+
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
 
-def export_sphinx_report(nb, config=None):
-    pass
+def export(nb, config=None, transformers=None, filters=None, exporter_type=Exporter):
+    
+    #Check arguments
+    if exporter_type is None:
+        raise TypeError("Exporter is None")
+    elif not isinstance(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(transformers, filters, config)
+
+    #Try to convert the notebook using the appropriate conversion function.
+    if isinstance(nb, NotebookNode):
+        return exporter_instance.from_notebook_node(nb), exporter_instance
+    elif isinstance(nb, str):
+        return exporter_instance.from_filename(nb), exporter_instance
+    else:
+        return exporter_instance.from_file(nb), exporter_instance
+
+
+def export_sphinx(nb, config=None, transformers=None, filters=None):
+    return export(nb, config, transformers, filters, SphinxExporter)
+
+def export_html(nb, config=None, transformers=None, filters=None):
+    return export(nb, config, transformers, filters, HtmlExporter)
+
+def export_latex(nb, config=None, transformers=None, filters=None):
+    return export(nb, config, transformers, filters, LatexExporter)
+
+def export_markdown(nb, config=None, transformers=None, filters=None):
+    return export(nb, config, transformers, filters, MarkdownExporter)
+
+def export_python(nb, config=None, transformers=None, filters=None):
+    return export(nb, config, transformers, filters, PythonExporter)
+
+def export_reveal(nb, config=None, transformers=None, filters=None):
+    return export(nb, config, transformers, filters, RevealExporter)
+
+def export_rst(nb, config=None, transformers=None, filters=None):
+    return export(nb, config, transformers, filters, RstExporter)
+
+EXPORT_FUNCTIONS = {"sphinx": export_sphinx,
+                    "html": export_html,
+                    "latex": export_latex,
+                    "markdown": export_markdown,
+                    "python": export_python,
+                    "reveal": export_reveal,
+                    "rst": export_rst}
 
-#TODO: Add basic export/import utility functions.
+def export_by_name(nb, template_name, config=None, transformers=None, filters=None):
+    return EXPORT_FUNCTIONS[template_name](nb, config, transformers, filters)
  No newline at end of file

nbconvert/api/exporter.py

@@ -23,7 +23,6 b' from __future__ import print_function, absolute_import'
 # Stdlib imports
 import io
 import os
-import copy
 
 # IPython imports
 from IPython.config.configurable import Configurable
@@ -54,7 +53,6 b' import transformers.coalescestreams'
 #Standard Jinja2 environment constants
 TEMPLATE_PATH = "/../templates/"
 TEMPLATE_SKELETON_PATH = "/../templates/skeleton/"
-TEMPLATE_EXTENSION = ".tpl"
 
 #Jinja2 extensions to load.
 JINJA_EXTENSIONS = ['jinja2.ext.loopcontrols']
@@ -63,13 +61,6 b" JINJA_EXTENSIONS = ['jinja2.ext.loopcontrols']"
 # Classes and functions
 #-----------------------------------------------------------------------------
 class Exporter(Configurable):
-    """ A Jinja2 base converter templates
-
-    Pre-process the IPYNB files, feed it through Jinja2 templates,
-    and spit an converted files and a data object with other data
-    should be mostly configurable
-    """
-
     pre_transformer_order = List(['haspyout_transformer'],
         config=True,
         help= """
@@ -99,6 +90,9 b' class Exporter(Configurable):'
         along with potential extracted resources."""
         )
 
+    #Extension that the template files use.    
+    template_extension = ".tpl"
+
     #Processors that process the input data prior to the export, set in the 
     #constructor for this class.
     preprocessors = [] 
@@ -106,32 +100,11 b' class Exporter(Configurable):'
     # Public Constructor #####################################################
     
     def __init__(self, preprocessors=None, jinja_filters=None, config=None, **kw):
-        """ Init a new converter.
-
-        config: the Configurable config object to pass around.
-
-        preprocessors: dict of **available** key/value function to run on
-                       ipynb json data before conversion to extract/in-line file.
-                       See `transformer.py` and `ConfigurableTransformers`
-
-                       set the order in which the transformers should apply
-                       with the `pre_transformer_order` trait of this class
-
-                       transformers registered by this key will take precedence on
-                       default one.
-
-        jinja_filters: dict of supplementary jinja filter that should be made
-                       available in template. If those are of Configurable Class type,
-                       they will be instanciated with the config object as argument.
-
-                       user defined filter will overwrite the one available by default.
-        """ 
     
         #Call the base class constructor
         super(Exporter, self).__init__(config=config, **kw)
 
         #Standard environment
-        self.ext = TEMPLATE_EXTENSION
         self._init_environment()
 
         #TODO: Implement reflection style methods to get user transformers.
@@ -156,63 +129,35 b' class Exporter(Configurable):'
                     self.environment.filters[key] = user_filter(config=config)
                 else:
                     self.environment.filters[key] = user_filter
-
-
-        #Set the default datatype priority.
-        self._set_datatype_priority(['svg', 'png', 'latex', 'jpg', 'jpeg','text'])
-        
     
     # Public methods #########################################
     
     def from_notebook_node(self, nb):
-        """Export NotebookNode instance
-
-        nb: NotebookNode to export.
-
-        Returns both the converted ipynb file and a dict containing the
-        resources created along the way via the transformers and Jinja2
-        processing.
-        """
-
         nb, resources = self._preprocess(nb)
         
         #Load the template file.
-        self.template = self.environment.get_template(self.template_file+self.ext)
+        self.template = self.environment.get_template(self.template_file+self.template_extension)
         
         return self.template.render(nb=nb, resources=resources), resources
 
 
     def from_filename(self, filename):
-        """Read and export a notebook from a filename
-
-        filename: Filename of the notebook file to export.
-
-        Returns both the converted ipynb file and a dict containing the
-        resources created along the way via the transformers and Jinja2
-        processing.
-        """
         with io.open(filename) as f:
             return self.from_notebook_node(nbformat.read(f, 'json'))
 
 
     def from_file(self, file_stream):
-        """Read and export a notebook from a file stream
-
-        file_stream: File handle of file that contains notebook data.
-
-        Returns both the converted ipynb file and a dict containing the
-        resources created along the way via the transformers and Jinja2
-        processing.
-        """
-
         return self.from_notebook_node(nbformat.read(file_stream, 'json'))
 
 
     def register_transformer(self, transformer):
         if MetaHasTraits(transformer):
-            self.preprocessors.append(transformer(config=self.config))
+            transformer_instance = transformer(config=self.config)
+            self.preprocessors.append(transformer_instance)
+            return transformer_instance
         else:
             self.preprocessors.append(transformer)
+            return transformer
 
 
     def register_filter(self, name, filter):
@@ -222,6 +167,7 b' class Exporter(Configurable):'
             self.environment.filters[name] = filter
         return self.environment.filters[name]
 
+
     # Protected and Private methods #########################################
     
     def _register_transformers(self):
@@ -230,7 +176,6 b' class Exporter(Configurable):'
         #Remember the figure extraction transformer so it can be enabled and
         #disabled easily later.
         self.extract_figure_transformer = self.register_transformer(transformers.extractfigure.ExtractFigureTransformer)
-        self.extract_figure_transformer.enabled = False
         
         
     def _register_filters(self):
@@ -250,11 +195,6 b' class Exporter(Configurable):'
         self.register_filter('rm_fake', filters.strings.rm_fake)
         self.register_filter('rm_math_space', filters.latex.rm_math_space)
         self.register_filter('wrap', filters.strings.wrap)
-
-        
-    def _set_datatype_priority(self, priority):
-        self.extract_figure_transformer.display_data_priority=copy.copy(priority)
-        self.display_data_priority=copy.copy(priority)
         
         
     def _init_environment(self):
@@ -268,11 +208,6 b' class Exporter(Configurable):'
 
 
     def _preprocess(self, nb):
-        """ Preprocess the notebook using the transformers specific
-        for the current export format.
-
-        nb: Notebook to preprocess
-        """
 
         #Dict of 'resources' that can be filled by the preprocessors.
         resources = {}
@@ -282,4 +217,3 b' class Exporter(Configurable):'
         for transformer in self.preprocessors:
             nb, resources = transformer(nb, resources)
         return nb, resources
-

nbconvert/api/html.py

@@ -1,4 +1,4 b''
- """TODO: Docstring
+"""TODO: Docstring
 """
 
 #-----------------------------------------------------------------------------
@@ -16,27 +16,22 b''
 # local import
 import exporter
 import transformers.csshtmlheader
+from IPython.utils.traitlets import Unicode
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 class HtmlExporter(exporter.Exporter):
 
-    def __init__(self, preprocessors=None, jinja_filters=None, config=None, full_html=True, **kw):
-        
-        #Call base class constructor.
-        super(exporter.Exporter, self).__init__(preprocessors, jinja_filters, config, **kw)
+    file_extension = Unicode(
+        'html', config=True, 
+        help="Extension of the file that should be written to disk"
+        )
+
+    template_file = Unicode(
+            'fullhtml', config=True,
+            help="Name of the template file to use")
 
-        #Set defaults
-        self.file_extension = "html"  
-        self.extract_figure_transformer.enabled = True
-        
-        #Load the correct template
-        if full_html:
-            self.template_file = "fullhtml"
-        else:
-            self.template_file = "basichtml"
-    
     def _register_transformers(self):
         
         #Register the transformers of the base class.

nbconvert/api/latex.py

@@ -1,12 +1,3 b''
- """Latex exporter for the notebook conversion pipeline.
-
-This module defines Exporter, a highly configurable converter
-that uses Jinja2 to export notebook files into different format.
-
-You can register both pre-transformers that will act on the notebook format
-before conversion and jinja filter that would then be available in the templates
-"""
-
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
@@ -20,18 +11,13 b' before conversion and jinja filter that would then be available in the templates'
 #-----------------------------------------------------------------------------
 
 # Stdlib imports
-import io
 import os
 
 # IPython imports
-from IPython.config.configurable import Configurable
-from IPython.nbformat import current as nbformat
-from IPython.utils.traitlets import MetaHasTraits, Unicode, List, Bool
-from IPython.utils.text import indent
+from IPython.utils.traitlets import Unicode
 
 # other libs/dependencies
 from jinja2 import Environment, FileSystemLoader
-from markdown import markdown
 
 # local import
 import exporter
@@ -45,7 +31,6 b' from transformers.latex import LatexTransformer'
 #Latex Jinja2 constants
 LATEX_TEMPLATE_PATH = "/../templates/tex/"
 LATEX_TEMPLATE_SKELETON_PATH = "/../templates/tex/skeleton/"
-LATEX_TEMPLATE_EXTENSION = ".tplx"
 
 #Special Jinja2 syntax that will not conflict when exporting latex.
 LATEX_JINJA_COMMENT_BLOCK = ["((=", "=))"]
@@ -56,28 +41,28 b' LATEX_JINJA_LOGIC_BLOCK = ["((*", "*))"]'
 # Classes and functions
 #-----------------------------------------------------------------------------
 class LatexExporter(exporter.Exporter):
-    """ A Jinja2 latex exporter
 
-    Preprocess the ipynb files, feed it through jinja templates,
-    and spit an converted files and a data object with other data
-    should be mostly configurable
-    """
+    #Extension that the template files use.    
+    template_extension = ".tplx"
+    
+    file_extension = Unicode(
+        'tex', config=True, 
+        help="Extension of the file that should be written to disk")
 
+    template_file = Unicode(
+            'latex_base', config=True,
+            help="Name of the template file to use")
+    
     def __init__(self, preprocessors=None, jinja_filters=None, config=None, **kw):
         
         #Call base class constructor.
         super(exporter.Exporter, self).__init__(preprocessors, jinja_filters, config, **kw)
-
-        #Set defaults
-        self.file_extension = "tex"
-        self._set_datatype_priority(['latex', 'svg', 'png', 'jpg', 'jpeg' , 'text'])
-        self.extract_figure_transformer.enabled = True
+        
+        self.extract_figure_transformer.display_data_priority = ['latex', 'svg', 'png', 'jpg', 'jpeg' , 'text']
         self.extract_figure_transformer.extra_ext_map={'svg':'pdf'}
-        self.template_file = "latex_base"
         
         
     def _init_environment(self):
-        self.ext = LATEX_TEMPLATE_EXTENSION
         self.environment = Environment(
             loader=FileSystemLoader([
                 os.path.dirname(os.path.realpath(__file__)) + LATEX_TEMPLATE_PATH,

nbconvert/api/markdown.py

@@ -1,5 +1,3 b''
-"""TODO: Docstring
-"""
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
@@ -15,18 +13,17 b''
 
 # local import
 import exporter
+from IPython.utils.traitlets import Unicode
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 class MarkdownExporter(exporter.Exporter):
 
-    def __init__(self, preprocessors=None, jinja_filters=None, config=None, **kw):
-        
-        #Call base class constructor.
-        super(exporter.Exporter, self).__init__(preprocessors, jinja_filters, config, **kw)
+    file_extension = Unicode(
+        'md', config=True, 
+        help="Extension of the file that should be written to disk")
 
-        #Set defaults
-        self.file_extension = "md"  
-        self.extract_figure_transformer.enabled = True
-        self.template_file = "markdown"
+    template_file = Unicode(
+            'markdown', config=True,
+            help="Name of the template file to use")

nbconvert/api/python.py

@@ -15,20 +15,26 b''
 
 # local import
 import exporter
+from IPython.utils.traitlets import Unicode
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 class PythonExporter(exporter.Exporter):
 
+    file_extension = Unicode(
+        'py', config=True, 
+        help="Extension of the file that should be written to disk")
+
+    template_file = Unicode(
+            'python', config=True,
+            help="Name of the template file to use")
+
     def __init__(self, preprocessors=None, jinja_filters=None, config=None, armor=False, **kw):
         
         #Call base class constructor.
         super(exporter.Exporter, self).__init__(preprocessors, jinja_filters, config, **kw)
 
         #Set defaults
-        self.file_extension = "py"  
-        if armor:
-            self.template_file = "python-armor"
-        else:
-            self.template_file = "python"
+        self.extract_figure_transformer.enabled = False
+        

nbconvert/api/reveal.py

@@ -1,4 +1,4 b''
- """TODO: Docstring
+"""TODO: Docstring
 """
 
 #-----------------------------------------------------------------------------
@@ -16,21 +16,21 b''
 # local import
 import html_exporter
 import transformers.revealhelp
+from IPython.utils.traitlets import Unicode
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 class RevealExporter(html_exporter.HtmlExporter):
 
-    def __init__(self, preprocessors=None, jinja_filters=None, config=None, **kw):
-        
-        #Call base class constructor.
-        super(html_exporter.HtmlExporter, self).__init__(preprocessors, jinja_filters, config, **kw)
-
-        #Set defaults
-        self.file_extension = "reveal.html"
-        self.template_file = "reveal"
+    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 the transformers of the base class.

nbconvert/api/rst.py

@@ -1,4 +1,4 b''
- """TODO: Docstring
+"""TODO: Docstring
 """
 
 #-----------------------------------------------------------------------------
@@ -15,23 +15,21 b''
 
 # local import
 import exporter
+from IPython.utils.traitlets import Unicode
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 class RstExporter(exporter.Exporter):
 
-    def __init__(self, preprocessors=None, jinja_filters=None, config=None, **kw):
-        
-        #Call base class constructor.
-        super(exporter.Exporter, self).__init__(preprocessors, jinja_filters, config, **kw)
-
-        #Set defaults
-        self.file_extension = "rst"
-        self.template_file = "rst"
-        self.extract_figure_transformer.enabled = True
-
+    file_extension = Unicode(
+        'rst', config=True, 
+        help="Extension of the file that should be written to disk")
 
+    template_file = Unicode(
+            'rst', config=True,
+            help="Name of the template file to use")
+    
     def _register_filters(self):
         
         #Register the filters of the base class.

nbconvert/api/sphinx.py

@@ -1,5 +1,3 b''
- """TODO: Docstring
-"""
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
@@ -14,35 +12,23 b''
 #-----------------------------------------------------------------------------
 
 # local import
-import latex_exporter
-
+import latex
+from IPython.utils.traitlets import Unicode
+from transformers.sphinx import SphinxTransformer
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
-class SphinxExporter(latex_exporter.LatexExporter):
-
-    def __init__(self, preprocessors=None, jinja_filters=None, config=None, sphinx_type="howto", **kw):
-        
-        #Call base class constructor.
-        super(latex_exporter.LatexExporter, self).__init__(preprocessors, jinja_filters, config, **kw)
-
-        #Defaults
-        self.template_file = "latex_sphinx_" + sphinx_type
-
-    def _register_filters(self):
-        
-        #Register the filters of the base class.
-        super(latex_exporter.LatexExporter, self)._register_filters()
-
-        #Add latex filters to the Jinja2 environment
-        #self.register_filter('escape_tex', filters.latex.escape_tex)  
+class SphinxExporter(latex.LatexExporter):
 
+    template_file = Unicode(
+            'sphinxhowto', config=True,
+            help="Name of the template file to use")
     
     def _register_transformers(self):
         
         #Register the transformers of the base class.
-        super(latex_exporter.LatexExporter, self)._register_transformers()
+        super(latex.LatexExporter, self)._register_transformers()
         
-        #Register latex transformer
-        #self.register_transformer(LatexTransformer)
+        #Register sphinx latex transformer
+        self.register_transformer(SphinxTransformer) 
                     

nbconvert/filters/ansi.py

@@ -1,33 +1,10 b''
-# ANSI color functions:
 import re
-def remove_ansi(src):
-    """Strip all ANSI color escape sequences from input string.
-
-    Parameters
-    ----------
-    src : string
 
-    Returns
-    -------
-    string
-    """
+def remove_ansi(src):
     return re.sub(r'\033\[(0|\d;\d\d)m', '', src)
 
 
 def ansi2html(txt):
-    """Render ANSI colors as HTML colors
-
-    This is equivalent to util.fixConsole in utils.js
-
-    Parameters
-    ----------
-    txt : string
-
-    Returns
-    -------
-    string
-    """
-
     ansi_colormap = {
         '30': 'ansiblack',
         '31': 'ansired',
@@ -49,6 +26,7 b' def ansi2html(txt):'
         '"': '"',
         '`': '`',
     }
+    
     for c, escape in html_escapes.iteritems():
         txt = txt.replace(c, escape)
 
@@ -61,6 +39,7 b' def ansi2html(txt):'
     while m:
         cmds = m.groups()[0].split(';')
         closer = '</span>' if opened else ''
+        
         # True if there is there more than one element in cmds, *or*
         # if there is only one but it is not equal to a string of zeroes.
         opened = len(cmds) > 1 or cmds[0] != '0' * len(cmds[0])
@@ -79,4 +58,4 b' def ansi2html(txt):'
 
     if opened:
         txt += '</span>'
-    return txt
+    return txt
  No newline at end of file

nbconvert/filters/datatypefilter.py

@@ -1,4 +1,4 b''
-"""Filter used to select the first prefered output format available.
+"""Filter used to select the first preferred output format available.
 
 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
@@ -16,11 +16,20 b' GlobalConfigurable.display_data_priority'
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
-class DataTypeFilter(GlobalConfigurable):
-    """ Returns the prefered display format """
+class DataTypeFilter(object):
+    """ Returns the preferred display format """
 
-    def __init__(self, config=None, **kw):
-        super(DataTypeFilter, self).__init__(config=config, **kw)
+    display_data_priority = None
+
+    def __init__(self, display_data_priority):
+        super(object, self).__init__()
+        
+        #Make sure that the display data priority variably is not None.
+        if self.display_data_priority is None:
+            raise TypeError
+        else:
+            self.display_data_priority = display_data_priority
+        
 
     def __call__(self, output):
         """ Return the first available format in the priority """

nbconvert/filters/latex.py

@@ -33,8 +33,6 b' LATEX_SUBS = ('
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
-
-#TODO: Comment me.
 def escape_tex(value):
     newval = value
     for pattern, replacement in LATEX_SUBS:

nbconvert/filters/strings.py

@@ -1,6 +1,6 b''
 """String utilities.
 
-Contains a collection of usefull string manipulations functions.
+Contains a collection of useful string manipulations functions.
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.

nbconvert/transformers/activatable.py

@@ -1,7 +1,7 b''
-from transformers.base import ConfigurableTransformers
+from .base import ConfigurableTransformer
+from IPython.utils.traitlets import (Bool)
 
-
-class ActivatableTransformer(ConfigurableTransformers):
+class ActivatableTransformer(ConfigurableTransformer):
     """A simple ConfigurableTransformers that have an enabled flag
 
     Inherit from that if you just want to have a transformer which is

nbconvert/transformers/base.py

@@ -9,11 +9,8 b' as well as decorator to simplify tasks.'
 from __future__ import print_function, absolute_import
 
 from IPython.config.configurable import Configurable
-from IPython.utils.traitlets import Unicode, Bool, Dict, List
 
-from .config import GlobalConfigurable
-
-class ConfigurableTransformers(GlobalConfigurable):
+class ConfigurableTransformer(Configurable):
     """ A configurable transformer
 
     Inherit from this class if you wish to have configurability for your
@@ -29,7 +26,7 b' class ConfigurableTransformers(GlobalConfigurable):'
     """
 
     def __init__(self, config=None, **kw):
-        super(ConfigurableTransformers, self).__init__(config=config, **kw)
+        super(ConfigurableTransformer, self).__init__(config=config, **kw)
 
     def __call__(self, nb, other):
         """transformation to apply on each notebook.
@@ -60,62 +57,3 b' class ConfigurableTransformers(GlobalConfigurable):'
 
         raise NotImplementedError('should be implemented by subclass')
         return cell, other
-
-def cell_preprocessor(function):
-    """ wrap a function to be executed on all cells of a notebook
-
-    wrapped function  parameters :
-        cell  : the cell
-        other : external resources
-        index : index of the cell
-    """
-    def wrappedfunc(nb, other):
-        for worksheet in nb.worksheets :
-            for index, cell in enumerate(worksheet.cells):
-                worksheet.cells[index], other = function(cell, other, index)
-        return nb, other
-    return wrappedfunc
-
-
-@cell_preprocessor
-def haspyout_transformer(cell, other, count):
-    """
-    Add a haspyout flag to cell that have it
-
-    Easier for templating, where you can't know in advance
-    wether to write the out prompt
-
-    """
-    cell.type = cell.cell_type
-    cell.haspyout = False
-    for out in cell.get('outputs', []):
-        if out.output_type == 'pyout':
-            cell.haspyout = True
-            break
-    return cell, other
-
-@cell_preprocessor
-def coalesce_streams(cell, other, count):
-    """merge consecutive sequences of stream output into single stream
-
-    to prevent extra newlines inserted at flush calls
-
-    TODO: handle \r deletion
-    """
-    outputs = cell.get('outputs', [])
-    if not outputs:
-        return cell, other
-    new_outputs = []
-    last = outputs[0]
-    new_outputs = [last]
-    for output in outputs[1:]:
-        if (output.output_type == 'stream' and
-            last.output_type == 'stream' and
-            last.stream == output.stream
-        ):
-            last.text += output.text
-        else:
-            new_outputs.append(output)
-
-    cell.outputs = new_outputs
-    return cell, other

nbconvert/transformers/coalescestreams.py

@@ -26,7 +26,6 b' TODO: handle \\r deletion'
     outputs = cell.get('outputs', [])
     if not outputs:
         return cell, other
-    new_outputs = []
     last = outputs[0]
     new_outputs = [last]
     for output in outputs[1:]:

nbconvert/transformers/csshtmlheader.py

@@ -1,4 +1,4 b''
- 
+from .activatable import ActivatableTransformer
 
 class CSSHtmlHeaderTransformer(ActivatableTransformer):
 
@@ -31,7 +31,6 b' class CSSHtmlHeaderTransformer(ActivatableTransformer):'
         static = os.path.join(path.get_ipython_package_dir(),
             'frontend', 'html', 'notebook', 'static',
         )
-        here = os.path.split(os.path.realpath(__file__))[0]
         css = os.path.join(static, 'css')
         for sheet in [
             # do we need jquery and prettify?

nbconvert/transformers/extractfigure.py

@@ -1,4 +1,5 b''
- 
+from IPython.utils.traitlets import (Dict, List, Unicode)
+from .activatable import ActivatableTransformer
 
 class ExtractFigureTransformer(ActivatableTransformer):
 
@@ -18,6 +19,7 b' class ExtractFigureTransformer(ActivatableTransformer):'
             config=True,
             )
 
+    display_data_priority = List(['svg', 'png', 'latex', 'jpg', 'jpeg','text'])
 
     #to do change this to .format {} syntax
     default_key_tpl = Unicode('_fig_{count:02d}.{ext}', config=True)

nbconvert/transformers/latex.py

@@ -18,7 +18,8 b' from __future__ import print_function, absolute_import'
 
 # Our own imports
 # Needed to override transformer
-from .transformers import (ActivatableTransformer) #TODO
+from .activatable import (ActivatableTransformer)
+from filters import latex
 
 #-----------------------------------------------------------------------------
 # Classes
@@ -38,5 +39,5 b' class LatexTransformer(ActivatableTransformer):'
         """
         
         if hasattr(cell, "source") and cell.cell_type == "markdown":
-            cell.source = rm_math_space(cell.source)
+            cell.source = latex.rm_math_space(cell.source)
         return cell, other

nbconvert/transformers/revealhelp.py

@@ -1,6 +1,6 b''
- 
+from .base import ConfigurableTransformer
 
-class RevealHelpTransformer(ConfigurableTransformers):
+class RevealHelpTransformer(ConfigurableTransformer):
 
     def __call__(self, nb, other):
         for worksheet in nb.worksheets :

nbconvert/transformers/sphinx.py

@@ -34,7 +34,7 b' from pygments.formatters import LatexFormatter'
 from IPython.utils.traitlets import Unicode, Bool
 
 # Needed to override transformer
-from .transformers import (ActivatableTransformer) #TODO
+from .activatable import (ActivatableTransformer) #TODO
 
 #-----------------------------------------------------------------------------
 # Classes and functions