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

standardized nomenclature.   Ready to test...

nbconvert.py

@@ -1,154 +1,155 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
 
 #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
 #-----------------------------------------------------------------------------
 NBCONVERT_DIR = os.path.abspath(os.path.realpath(os.path.dirname(__file__)))
 
 #'Keys in resources' user prompt.
 KEYS_PROMPT_HEAD = "====================== Keys in Resources =================================="
 KEYS_PROMPT_BODY = """
 ===========================================================================
 You are responsible for writting these files into the appropriate 
 directorie(s) if need be.  If you do not want to see this message, enable
 the 'write' (boolean) flag of the converter.
 ===========================================================================
 """
 
 #Error Messages
 ERROR_CONFIG_NOT_FOUND = "Config file for profile '%s' not found, giving up."
 
 #-----------------------------------------------------------------------------
 #Classes and functions
 #-----------------------------------------------------------------------------
 class NbconvertApp(Application):
     """A basic application to convert ipynb files"""
 
     aliases = {
         'stdout':'NbconvertApp.stdout',
         'write':'NbconvertApp.write'
         }
 
     flags = {}
     flags['no-stdout'] = (
         {'NbconvertApp' : {'stdout' : False}}, 
         """Do not print converted file to stdout, equivalent to 
         --stdout=False"""
         )
 
     def __init__(self, **kwargs):
         """Public constructor"""
 
         #Call base class
         super(NbconvertApp, self).__init__(**kwargs)
 
         #Register class here to have help with help all
         self.classes.insert(0, Exporter)
-        self.classes.insert(0, ExtractFigureTransformer)
-        self.classes.insert(0, GlobalConfigurable)
 
 
     def start(self, argv=None):
         """Convert a notebook in one step"""
 
         #Parse the commandline options.
         self.parse_command_line(argv)
 
         #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)
 
 #-----------------------------------------------------------------------------
 #Script main
 #-----------------------------------------------------------------------------
 def main():
     """Convert a notebook in one step"""
 
     app = NbconvertApp.instance()
     app.description = __doc__
     app.run(argv=sys.argv)
 
 if __name__ == '__main__':
     main()
  No newline at end of file

nbconvert/api/convert.py

@@ -1,21 +1,83 b''
 """Latex transformer.
 
 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.
 #-----------------------------------------------------------------------------
 
+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

@@ -1,285 +1,219 b''
 """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.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 from __future__ import print_function, absolute_import
 
 # Stdlib imports
 import io
 import os
-import copy
 
 # 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
 
 # other libs/dependencies
 from jinja2 import Environment, FileSystemLoader
 from markdown import markdown
 
 # local import
 import filters.strings
 import filters.markdown
 import filters.latex
 import filters.datatypefilter
 import filters.pygments
 import filters.ansi
 
 import transformers.extractfigure
 import transformers.coalescestreams
 
 
 #-----------------------------------------------------------------------------
 # Globals and constants
 #-----------------------------------------------------------------------------
 
 #Standard Jinja2 environment constants
 TEMPLATE_PATH = "/../templates/"
 TEMPLATE_SKELETON_PATH = "/../templates/skeleton/"
-TEMPLATE_EXTENSION = ".tpl"
 
 #Jinja2 extensions to load.
 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= """
             An ordered list of pre-transformer to apply to the IPYNB
             file before running through templates
             """
         )
 
     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"
         )
 
     stdout = Bool(
         True, config=True,
         help="""Whether to print the converted IPYNB file to stdout
         "use full do diff files without actually writing a new file"""
         )
 
     write = Bool(
         False, config=True,
         help="""Should the converted notebook file be written to disk
         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 = [] 
 
     # 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.
         #if not preprocessors is None:        
         #    for name in self.pre_transformer_order:
         #        # get the user-defined transformer first
         #        transformer = preprocessors.get(name, getattr(trans, name, None))
         #        if isinstance(transformer, MetaHasTraits):
         #            transformer = transformer(config=config)
         #        self.preprocessors.append(transformer)
 
         #Add transformers
         self._register_transformers()
 
         #Add filters to the Jinja2 environment
         self._register_filters()
 
         #Load user filters.  Overwrite existing filters if need be.
         if not jinja_filters is None:
             for key, user_filter in jinja_filters.iteritems():
                 if isinstance(user_filter, MetaHasTraits):
                     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):
         if MetaHasTraits(filter):
             self.environment.filters[name] = filter(config=self.config)
         else:
             self.environment.filters[name] = filter
         return self.environment.filters[name]
 
+
     # Protected and Private methods #########################################
     
     def _register_transformers(self):
         self.register_transformer(transformers.coalescestreams.coalesce_streams)
         
         #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):
         self.register_filter('indent', indent)
         self.register_filter('markdown', markdown)
         self.register_filter('ansi2html', filters.ansi.ansi2html)
         self.register_filter('filter_data_type', filters.datatypefilter.DataTypeFilter)
         self.register_filter('get_lines', filters.strings.get_lines)
         self.register_filter('highlight', filters.pygments.highlight)
         self.register_filter('highlight2html', filters.pygments.highlight) 
         self.register_filter('highlight2latex', filters.pygments.highlight2latex)
         self.register_filter('markdown2latex', filters.markdown.markdown2latex)
         self.register_filter('markdown2rst', filters.markdown.markdown2rst)
         self.register_filter('pycomment', filters.strings.python_comment)
         self.register_filter('rm_ansi', filters.ansi.remove_ansi)
         self.register_filter('rm_dollars', filters.strings.strip_dollars)
         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):
         self.environment = Environment(
             loader=FileSystemLoader([
                 os.path.dirname(os.path.realpath(__file__)) + TEMPLATE_PATH,
                 os.path.dirname(os.path.realpath(__file__)) + TEMPLATE_SKELETON_PATH,
                 ]),
             extensions=JINJA_EXTENSIONS
             )
 
 
     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 = {}
 
         #Run each transformer on the notebook.  Carry the output along
         #to each transformer
         for transformer in self.preprocessors:
             nb, resources = transformer(nb, resources)
         return nb, resources
-

nbconvert/api/html.py

@@ -1,47 +1,42 b''
- """TODO: Docstring
+"""TODO: Docstring
 """
 
 #-----------------------------------------------------------------------------
 # 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
 #-----------------------------------------------------------------------------
 
 # 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.
         super(exporter.Exporter, self)._register_transformers()
         
         #Register latex transformer
         self.register_transformer(transformers.csshtmlheader.CSSHtmlHeaderTransformer)
                     
  No newline at end of file

nbconvert/api/latex.py

@@ -1,114 +1,99 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.
 #
 # 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 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
 import filters.latex
 import filters.pygments
 from transformers.latex import LatexTransformer
 #-----------------------------------------------------------------------------
 # Globals and constants
 #-----------------------------------------------------------------------------
 
 #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 = ["((=", "=))"]
 LATEX_JINJA_VARIABLE_BLOCK = ["(((", ")))"]
 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,
                 os.path.dirname(os.path.realpath(__file__)) + LATEX_TEMPLATE_SKELETON_PATH,
                 ]),
             extensions=exporter.JINJA_EXTENSIONS
             )
 
         #Set special Jinja2 syntax that will not conflict with latex.
         self.environment.block_start_string = LATEX_JINJA_LOGIC_BLOCK[0]
         self.environment.block_end_string = LATEX_JINJA_LOGIC_BLOCK[1]
         self.environment.variable_start_string = LATEX_JINJA_VARIABLE_BLOCK[0]
         self.environment.variable_end_string = LATEX_JINJA_VARIABLE_BLOCK[1]
         self.environment.comment_start_string = LATEX_JINJA_COMMENT_BLOCK[0]
         self.environment.comment_end_string = LATEX_JINJA_COMMENT_BLOCK[1]
         
         
     def _register_filters(self):
         
         #Register the filters of the base class.
         super(exporter.Exporter, self)._register_filters()
 
         #Add latex filters to the Jinja2 environment
         self.register_filter('escape_tex', filters.latex.escape_tex) 
         self.register_filter('highlight', filters.pygments.highlight2latex) 
     
     def _register_transformers(self):
         
         #Register the transformers of the base class.
         super(exporter.Exporter, self)._register_transformers()
         
         #Register latex transformer
         self.register_transformer(LatexTransformer)
                     
  No newline at end of file

nbconvert/api/markdown.py

@@ -1,32 +1,29 b''
-"""TODO: Docstring
-"""
 
 #-----------------------------------------------------------------------------
 # 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
 #-----------------------------------------------------------------------------
 
 # 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

@@ -1,34 +1,40 b''
 """TODO: Docstring
 """
 
 #-----------------------------------------------------------------------------
 # 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
 #-----------------------------------------------------------------------------
 
 # 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,41 +1,41 b''
- """TODO: Docstring
+"""TODO: Docstring
 """
 
 #-----------------------------------------------------------------------------
 # 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
 #-----------------------------------------------------------------------------
 
 # 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.
         super(html_exporter.HtmlExporter, self)._register_transformers()
         
         #Register reveal help transformer
         self.register_transformer(transformers.revealhelp.RevealHelpTransformer)
         
  No newline at end of file

nbconvert/api/rst.py

@@ -1,51 +1,49 b''
- """TODO: Docstring
+"""TODO: Docstring
 """
 
 #-----------------------------------------------------------------------------
 # 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
 #-----------------------------------------------------------------------------
 
 # 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.
         super(exporter.Exporter, self)._register_filters()
 
         #Add latex filters to the Jinja2 environment
         #self.register_filter('escape_tex', filters.latex.escape_tex)  
 
     
     def _register_transformers(self):
         
         #Register the transformers of the base class.
         super(exporter.Exporter, self)._register_transformers()
         
         #Register latex transformer
         #self.register_transformer(LatexTransformer)
                     

nbconvert/api/sphinx.py

@@ -1,48 +1,34 b''
- """TODO: Docstring
-"""
 
 #-----------------------------------------------------------------------------
 # 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
 #-----------------------------------------------------------------------------
 
 # 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,82 +1,61 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',
         '32': 'ansigreen',
         '33': 'ansiyellow',
         '34': 'ansiblue',
         '35': 'ansipurple',
         '36': 'ansicyan',
         '37': 'ansigrey',
         '01': 'ansibold',
     }
 
     # do ampersand first
     txt = txt.replace('&', '&')
     html_escapes = {
         '<': '&lt;',
         '>': '&gt;',
         "'": '&apos;',
         '"': '&quot;',
         '`': '&#96;',
     }
+    
     for c, escape in html_escapes.iteritems():
         txt = txt.replace(c, escape)
 
     ansi_re = re.compile('\x1b' + r'\[([\dA-Fa-f;]*?)m')
     m = ansi_re.search(txt)
     opened = False
     cmds = []
     opener = ''
     closer = ''
     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])
         classes = []
         for cmd in cmds:
             if cmd in ansi_colormap:
                 classes.append(ansi_colormap.get(cmd))
 
         if classes:
             opener = '<span class="%s">' % (' '.join(classes))
         else:
             opener = ''
         txt = re.sub(ansi_re, closer + opener, txt, 1)
 
         m = ansi_re.search(txt)
 
     if opened:
         txt += '</span>'
-    return txt
+    return txt
  No newline at end of file

nbconvert/filters/datatypefilter.py

@@ -1,31 +1,40 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
 value of the different formats is set via 
 GlobalConfigurable.display_data_priority
 """
 #-----------------------------------------------------------------------------
 # 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.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # 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 """
 
         for fmt in self.display_data_priority:
             if fmt in output:
                 return [fmt]
         return []
  No newline at end of file

nbconvert/filters/latex.py

@@ -1,95 +1,93 b''
 """Latex transformer.
 
 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
 #-----------------------------------------------------------------------------
 import re
 
 #-----------------------------------------------------------------------------
 # Globals and constants
 #-----------------------------------------------------------------------------
 
 #Latex substitutions for escaping latex.
 LATEX_SUBS = (
     (re.compile(r'\\'), r'\\textbackslash'),
     (re.compile(r'([{}_#%&$])'), r'\\\1'),
     (re.compile(r'~'), r'\~{}'),
     (re.compile(r'\^'), r'\^{}'),
     (re.compile(r'"'), r"''"),
     (re.compile(r'\.\.\.+'), r'\\ldots'),
 )
 
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
-
-#TODO: Comment me.
 def escape_tex(value):
     newval = value
     for pattern, replacement in LATEX_SUBS:
         newval = pattern.sub(replacement, newval)
     return newval
     
     
 def rm_math_space(text):
     """
     Remove the space between latex math commands and enclosing $ symbols.
     """
 
     # First, scan through the markdown looking for $.  If
     # a $ symbol is found, without a preceding \, assume
     # it is the start of a math block.  UNLESS that $ is
     # not followed by another within two math_lines.
     math_regions = []
     math_lines = 0
     within_math = False
     math_start_index = 0
     ptext = ''
     last_character = ""
     skip = False
     for index, char in enumerate(text):
 
         #Make sure the character isn't preceeded by a backslash
         if (char == "$" and last_character != "\\"):
 
             # Close the math region if this is an ending $
             if within_math:
                 within_math = False
                 skip = True
                 ptext = ptext+'$'+text[math_start_index+1:index].strip()+'$'
                 math_regions.append([math_start_index, index+1])
             else:
 
                 # Start a new math region
                 within_math = True
                 math_start_index = index
                 math_lines = 0
 
         # If we are in a math region, count the number of lines parsed.
         # Cancel the math region if we find two line breaks!
         elif char == "\n":
             if within_math:
                 math_lines += 1
                 if math_lines > 1:
                     within_math = False
                     ptext = ptext+text[math_start_index:index]
 
         # Remember the last character so we can easily watch
         # for backslashes
         last_character = char
         if not within_math and not skip:
             ptext = ptext+char
         if skip:
             skip = False
     return ptext

nbconvert/filters/strings.py

@@ -1,57 +1,57 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.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # Our own imports
 import textwrap #TODO
 
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
 def wrap(text, width=100):
     """ Intelligently wrap text"""
 
     splitt = text.split('\n')
     wrp = map(lambda x:textwrap.wrap(x,width),splitt)
     wrpd = map('\n'.join, wrp)
     return '\n'.join(wrpd)
 
 
 def strip_dollars(text):
     """Remove all dollar symbols from text"""
 
     return text.strip('$')
 
 
 #TODO: Comment me.
 def rm_fake(strng):
     return strng.replace('/files/', '')
 
 
 #TODO: Comment me.
 def python_comment(string):
     return '# '+'\n# '.join(string.split('\n'))
 
 def get_lines(src, start=None,end=None):
     """
     Split the input text into separate lines and then return the 
     lines that the caller is interested in.
     """
     
     # Split the input into lines.
     lines = src.split("\n")
     
     # Return the right lines.
     return "\n".join(lines[start:end]) #re-join

nbconvert/transformers/activatable.py

@@ -1,19 +1,19 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
     no-op by default but can be activated in profiles with
 
     c.YourTransformerName.enabled = True
     """
 
     enabled = Bool(False, config=True)
 
     def __call__(self, nb, other):
         if not self.enabled :
             return nb, other
         else :
             return super(ActivatableTransformer, self).__call__(nb, other)

nbconvert/transformers/base.py

@@ -1,121 +1,59 b''
 """
 Module that regroups transformer that woudl be applied to ipynb files
 before going through the templating machinery.
 
 It exposes convenient classes to inherit from to access configurability
 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
     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
     or __call__ if you prefer your own logic. See orresponding docstring for informations.
 
 
     """
 
     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.
 
         received a handle to the current notebook as well as a dict of resources
         which structure depends on the transformer.
 
         You should return modified nb, other.
 
         If you wish to apply on each cell, you might want to overwrite cell_transform method.
         """
         try :
             for worksheet in nb.worksheets :
                 for index, cell in enumerate(worksheet.cells):
                     worksheet.cells[index], other = self.cell_transform(cell, other, 100*index)
             return nb, other
         except NotImplementedError:
             raise NotImplementedError('should be implemented by subclass')
 
     def cell_transform(self, cell, other, index):
         """
         Overwrite if you want to apply a transformation on each cell,
 
         receive the current cell, the resource dict and the index of current cell as parameter.
 
         You should return modified cell and resource dict.
         """
 
         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

@@ -1,43 +1,42 b''
 
 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 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/csshtmlheader.py

@@ -1,58 +1,57 b''
- 
+from .activatable import ActivatableTransformer
 
 class CSSHtmlHeaderTransformer(ActivatableTransformer):
 
     def __call__(self, nb, resources):
         """Fetch and add css to the resource dict
 
         Fetch css from IPython adn Pygment to add at the beginning
         of the html files.
 
         Add this css in resources in the "inlining.css" key
         """
         resources['inlining'] = {}
         resources['inlining']['css'] = self.header
         return nb, resources
 
     header = []
 
     def __init__(self, config=None, **kw):
         super(CSSHtmlHeaderTransformer, self).__init__(config=config, **kw)
         if self.enabled :
             self.regen_header()
 
     def regen_header(self):
         ## lazy load asa this might not be use in many transformers
         import os
         from IPython.utils import path
         import io
         from pygments.formatters import HtmlFormatter
         header = []
         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?
             # os.path.join(static, 'jquery', 'css', 'themes', 'base',
             # 'jquery-ui.min.css'),
             # os.path.join(static, 'prettify', 'prettify.css'),
             os.path.join(css, 'boilerplate.css'),
             os.path.join(css, 'fbm.css'),
             os.path.join(css, 'notebook.css'),
             os.path.join(css, 'renderedhtml.css'),
             os.path.join(css, 'style.min.css'),
         ]:
             try:
                 with io.open(sheet, encoding='utf-8') as f:
                     s = f.read()
                     header.append(s)
             except IOError:
                 # new version of ipython with style.min.css, pass
                 pass
 
         pygments_css = HtmlFormatter().get_style_defs('.highlight')
         header.append(pygments_css)
         self.header = header
 

nbconvert/transformers/extractfigure.py

@@ -1,64 +1,66 b''
- 
+from IPython.utils.traitlets import (Dict, List, Unicode)
+from .activatable import ActivatableTransformer
 
 class ExtractFigureTransformer(ActivatableTransformer):
 
 
     extra_ext_map =  Dict({},
             config=True,
             help="""extra map to override extension based on type.
             Usefull for latex where svg will be converted to pdf before inclusion
             """
             )
 
     key_format_map =  Dict({},
             config=True,
             )
 
     figname_format_map =  Dict({},
             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)
 
     def _get_ext(self, ext):
         if ext in self.extra_ext_map :
             return self.extra_ext_map[ext]
         return ext
 
     def _new_figure(self, data, fmt, count):
         """Create a new figure file in the given format.
 
         """
         tplf = self.figname_format_map.get(fmt, self.default_key_tpl)
         tplk = self.key_format_map.get(fmt, self.default_key_tpl)
 
         # option to pass the hash as data ?
         figname = tplf.format(count=count, ext=self._get_ext(fmt))
         key     = tplk.format(count=count, ext=self._get_ext(fmt))
 
         # Binary files are base64-encoded, SVG is already XML
         binary = False
         if fmt in ('png', 'jpg', 'pdf'):
             data = data.decode('base64')
             binary = True
 
         return figname, key, data, binary
 
 
     def cell_transform(self, cell, other, count):
         if other.get('figures', None) is None :
             other['figures'] = {'text':{},'binary':{}}
         for out in cell.get('outputs', []):
             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, count)
                     out['key_'+out_type] = figname
                     if binary :
                         other['figures']['binary'][key] = data
                     else :
                         other['figures']['text'][key] = data
                     count = count+1
         return cell, other
 

nbconvert/transformers/latex.py

@@ -1,42 +1,43 b''
 """Latex transformer.
 
 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 .transformers import (ActivatableTransformer) #TODO
+from .activatable import (ActivatableTransformer)
+from filters import latex
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 class LatexTransformer(ActivatableTransformer):
     """
     Converter for latex destined documents.
     """
 
     def cell_transform(self, cell, other, index):
         """
         Apply a transformation on each cell,
 
         receive the current cell, the resource dict and the index of current cell as parameter.
 
         Returns modified cell and resource dict.
         """
         
         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,17 +1,17 b''
- 
+from .base import ConfigurableTransformer
 
-class RevealHelpTransformer(ConfigurableTransformers):
+class RevealHelpTransformer(ConfigurableTransformer):
 
     def __call__(self, nb, other):
         for worksheet in nb.worksheets :
             for i, cell in enumerate(worksheet.cells):
                 if not cell.get('metadata', None):
                     break
                 cell.metadata.slide_type = cell.metadata.get('slideshow', {}).get('slide_type', None)
                 if cell.metadata.slide_type is None:
                     cell.metadata.slide_type = '-'
                 if cell.metadata.slide_type in ['slide']:
                     worksheet.cells[i - 1].metadata.slide_helper = 'slide_end'
                 if cell.metadata.slide_type in ['subslide']:
                     worksheet.cells[i - 1].metadata.slide_helper = 'subslide_end'
         return nb, other
  No newline at end of file

nbconvert/transformers/sphinx.py

@@ -1,287 +1,287 b''
 """Module that allows custom Sphinx parameters to be set on the notebook and
 on the 'other' object passed into Jinja.
 """
 #-----------------------------------------------------------------------------
 # 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
 # Used to find Sphinx package location
 import sphinx
 import os.path
 
 # Used to determine python version
 import sys
 
 # Used to set the default date to today's date 
 from datetime import date 
 
 # Third-party imports
 # Needed for Pygments latex definitions.
 from pygments.formatters import LatexFormatter
 
 # Our own imports
 # Configurable traitlets
 from IPython.utils.traitlets import Unicode, Bool
 
 # Needed to override transformer
-from .transformers import (ActivatableTransformer) #TODO
+from .activatable import (ActivatableTransformer) #TODO
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 class SphinxTransformer(ActivatableTransformer):
     """
     Sphinx utility transformer.
 
     This transformer is used to set variables needed by the latex to build
     Sphinx stylized templates.
     """
     
     interactive = Bool(True, config=True, help="""
     Allows you to define whether or not the Sphinx exporter will prompt
     you for input during the conversion process.  If this is set to false,
     the author, version, release, date, and chapter_style traits should
     be set.
     """)
     
     author = Unicode("Unknown Author", config=True, help="Author name")
     
     version = Unicode("", config=True, help="""Version number
     You can leave this blank if you do not want to render a version number.
     Example: "1.0.0"
     """)
     
     release = Unicode("", config=True, help="""Release name
     You can leave this blank if you do not want to render a release name.
     Example: "Rough Draft"
     """)
     
     publish_date = Unicode("", config=True, help="""Publish date
     This is the date to render on the document as the publish date.
     Leave this blank to default to todays date.  
     Example: "June 12, 1990"
     """)
     
     chapter_style = Unicode("Bjarne", config=True, help="""Sphinx chapter style
     This is the style to use for the chapter headers in the document.
     You may choose one of the following:
         "Bjarne"    (default)
         "Lenny"
         "Glenn"
         "Conny"
         "Rejne"
         "Sonny"    (used for international documents)
     """)
     
     output_style = Unicode("notebook", config=True, help="""Nbconvert Ipython
     notebook input/output formatting style.
     You may choose one of the following:
         "simple     (recommended for long code segments)"
         "notebook"  (default)
     """)
     
     center_output = Bool(False, config=True, help="""
     Optional attempt to center all output.  If this is false, no additional
     formatting is applied.
     """)
     
     use_headers = Bool(True, config=True, help="""
     Whether not a header should be added to the document.
     """)
     
     overridetitle = Unicode("", config=True, help="")
     
     def __call__(self, nb, other):
         """
         Entry
         Since we are not interested in any additional manipulation on a cell
         by cell basis, we do not  call the base implementation.
         """ 
         if self.enabled:
             return self.transform(nb, other)
         else:
             return nb,other
 
     def transform(self, nb, other):
         """
         Sphinx transformation to apply on each notebook.
         """
          
         # TODO: Add versatile method of additional notebook metadata.  Include
         #       handling of multiple files.  For now use a temporay namespace,
         #       '_draft' to signify that this needs to change.
         if not "_draft" in nb.metadata:
             nb.metadata._draft = {}
             
         if not "sphinx" in other:
             other["sphinx"] = {}
 
         if self.interactive:
             
             # Prompt the user for additional meta data that doesn't exist currently
             # but would be usefull for Sphinx.
             nb.metadata._draft["author"] = self._prompt_author()
             nb.metadata._draft["version"] = self._prompt_version()
             nb.metadata._draft["release"] = self._prompt_release()
             nb.metadata._draft["date"] = self._prompt_date()
             
             # Prompt the user for the document style.
             other["sphinx"]["chapterstyle"] = self._prompt_chapter_title_style()
             other["sphinx"]["outputstyle"] = self._prompt_output_style()
             
             # Small options
             other["sphinx"]["centeroutput"] = self._prompt_boolean("Do you want to center the output? (false)", False)
             other["sphinx"]["header"] = self._prompt_boolean("Should a Sphinx document header be used? (true)", True)
         else:
             
             # Try to use the traitlets.
             nb.metadata._draft["author"] = self.author
             nb.metadata._draft["version"] = self.version
             nb.metadata._draft["release"] = self.release
             
             # Use todays date if none is provided.
             if len(self.publish_date.strip()) == 0:
                 nb.metadata._draft["date"] = date.today().strftime("%B %-d, %Y")
             else:
                 nb.metadata._draft["date"] = self.publish_date
             
             # Sphinx traitlets.
             other["sphinx"]["chapterstyle"] = self.chapter_style
             other["sphinx"]["outputstyle"] = self.output_style
             other["sphinx"]["centeroutput"] = self.center_output
             other["sphinx"]["header"] = self.use_headers
             
         # Find and pass in the path to the Sphinx dependencies.
         other["sphinx"]["texinputs"] = os.path.abspath(sphinx.__file__ + "/../texinputs")
         
         # Generate Pygments definitions for Latex 
         other["sphinx"]["pygment_definitions"] = self._generate_pygments_latex_def()
         
         if not (self.overridetitle == None or len(self.overridetitle.strip()) == 0):
             nb.metadata.name = self.overridetitle
         
         # End
         return nb, other 
     
     def _generate_pygments_latex_def(self):
         return LatexFormatter().get_style_defs()       
     
     def _prompt_author(self):
         return  self._input("Author name: ")
     
     def _prompt_version(self):
         return  self._input("Version (ie ""1.0.0""): ")
     
     def _prompt_release(self):
         return  self._input("Release Name (ie ""Rough draft""): ")
     
     def _prompt_date(self):
         default_date = date.today().strftime("%B %-d, %Y")
         user_date = self._input("Date (deafults to \"" + default_date + "\"): ")
         if len(user_date.strip()) == 0:
             user_date = default_date
         return user_date
     
     def _prompt_boolean(self, prompt, default=False):
         response = self._input(prompt)
         response = response.strip().lower()
         
         #Catch 1, true, yes as True
         if len(response) > 0 and (response == "1" or response[0] == "t" or response[0] == "y"):
             return True
         
         #Catch 0, false, no as False
         elif len(response) > 0 and (response == "0" or response[0] == "f" or response[0] == "n"):
             return False
             
         else:
             return default
         
     def _prompt_output_style(self):
         
         # Dictionary of available output styles
         styles = {1: "simple",
                   2: "notebook"}
         
         #Append comments to the menu when displaying it to the user.
         comments = {1: "(recommended for long code segments)",
                     2: "(default)"}
         
         return self._prompt_dictionary(styles, default_style=2, menu_comments=comments)
     
     def _prompt_chapter_title_style(self):
         
         # Dictionary of available Sphinx styles
         styles = {1: "Bjarne",
                   2: "Lenny",
                   3: "Glenn",
                   4: "Conny",
                   5: "Rejne",
                   6: "Sonny"}
         
         #Append comments to the menu when displaying it to the user.
         comments = {1: "(default)",
                     6: "(for international documents)"}
         
         return self._prompt_dictionary(styles, menu_comments=comments)
     
     def _prompt_dictionary(self, choices, default_style=1, menu_comments={}):
                 
         # Build the menu that will be displayed to the user with
         # all of the options available. 
         prompt = ""
         for key, value in choices.iteritems():
             prompt += "%d %s " % (key, value)
             if key in menu_comments:
                 prompt += menu_comments[key]
             prompt += "\n"
         
         # Continue to ask the user for a style until an appropriate
         # one is specified.
         response = -1
         while (not response in choices):
             try:
                 text_response = self._input(prompt)
                 
                 # Use default option if no input.
                 if len(text_response.strip()) == 0:
                     response = default_style
                 else:
                     response = int(text_response)
             except:
                 print("Error: Value is not an available option.  0 selects the default.\n")
         return choices[response]
           
     def _input(self, prompt_text):
         """
         Prompt the user for input.
         
         The input command will change depending on the version of python
         installed.  To maintain support for 2 and earlier, we must use
         raw_input in that case.  Else use input.
         """
         
         # Try to get the python version.  This command is only available in
         # python 2 and later, so it's important that we catch the exception
         # if the command isn't found.
         try:
             majorversion = sys.version_info[0]
         except:
             majorversion = 1
             
         # Use the correct function to prompt the user for input depending on 
         # what python version the code is running in.
         if majorversion >= 3:
             return input(prompt_text) 
         else:
             return raw_input(prompt_text)