Post code-review, extended refactor.

nbconvert/api/converter.py

@@ -0,0 +1,23 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.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Functions
+#-----------------------------------------------------------------------------
+def export_sphinx_report(nb, config=None):
+    pass
+def export_sphinx_report(nb, fileName, config=None):
+    pass
+
+#TODO: Add basic export/import utility functions.
+__author__ = 'root'

nbconvert/filters/ansi.py

@@ -0,0 +1,82 b''
+# ANSI color functions:
+import re
+def remove_ansi(src):
+    """Strip all ANSI color escape sequences from input string.
+
+    Parameters
+    ----------
+    src : string
+
+    Returns
+    -------
+    string
+    """
+    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

nbconvert/filters/pygments.py

@@ -0,0 +1,39 b''
+# Our own imports
+from utils.lexers import IPythonLexer
+
+#-----------------------------------------------------------------------------
+# Globals and constants
+#-----------------------------------------------------------------------------
+_multiline_outputs = ['text', 'html', 'svg', 'latex', 'javascript', 'json']
+
+
+#-----------------------------------------------------------------------------
+# Utility functions
+#-----------------------------------------------------------------------------
+def highlight(src, lang='ipython'):
+    """
+    Return a syntax-highlighted version of the input source as html output.
+    """
+    from pygments.formatters import HtmlFormatter
+    return pygment_highlight(src, HtmlFormatter(), lang)
+
+def highlight2latex(src, lang='ipython'):
+    """
+    Return a syntax-highlighted version of the input source as latex output.
+    """
+    from pygments.formatters import LatexFormatter
+    return pygment_highlight(src, LatexFormatter(), lang)
+
+def pygment_highlight(src, output_formatter, lang='ipython'):
+    """
+    Return a syntax-highlighted version of the input source
+    """
+    from pygments import highlight
+    from pygments.lexers import get_lexer_by_name
+
+    if lang == 'ipython':
+        lexer = IPythonLexer()
+    else:
+        lexer = get_lexer_by_name(lang, stripall=True)
+
+    return highlight(src, lexer, output_formatter) 

nbconvert/transformers/coalescestreams.py

@@ -0,0 +1,43 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/api/base.py

@@ -1,333 +1,266 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
 befor conversion and jinja filter that would then be availlable 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 re
 
 # 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 (pre-transformers)
-from exceptions import ConversionException
-from . import transformers as trans #TODO
-from .utils import get_lines #TODO
-from .utils import remove_ansi #TODO
-from .utils import highlight, ansi2html #TODO
+# 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.csshtmlheader
+import transformers.revealhelp
+import transformers.coalescestreams
 
-import .utils.strings as strings
-import .utils.markdown as markdown_utils
-import .utils.datatypefilter.DataTypeFilter as DataTypeFilter
 
 #-----------------------------------------------------------------------------
 # 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
 
-    Preprocess the ipynb files, feed it throug jinja 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
+            An ordered list of pre-transformer to apply to the IPYNB
             file before running through templates
             """
         )
 
-#TODO: Flagged for removal.
-    tex_environement = Bool(
-        False,
-        config=True,
-        help=" Whether or not the user is exporting to latex.")
-
     template_file = Unicode(
             '', config=True,
             help="Name of the template file to use")
 
     fileext = 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
+        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."""
         )
 
     #Processors that process the input data prior to the export, set in the 
     #constructor for this class.
     preprocessors = [] 
 
     def __init__(self, preprocessors={}, jinja_filters={}, config=None, export_format, **kw):
         """ Init a new converter.
 
         config: the Configurable config object to pass around.
 
         preprocessors: dict of **availlable** key/value function to run on
                        ipynb json data before conversion to extract/inline 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 registerd by this key will take precedence on
                        default one.
 
         jinja_filters: dict of supplementary jinja filter that should be made
                        availlable 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 availlable by default.
         """
 
-        #Merge default config options with user specific override options.
-        default_config = self._get_default_options()
+        #Set the default options for the exporter.
+        default_config = self.config
+            
+        #Set properties that must be set in the config class in order to 
+        #propagate to other classes.
+        default_config.GlobalConfigurable.display_data_priority =['svg', 'png', 'latex', 'jpg', 'jpeg','text']
+        default_config.ExtractFigureTransformer.display_data_priority=['svg', 'png', 'latex', 'jpg', 'jpeg','text']
+
+        #Set default properties of the exporter.
+        #For most (or all cases), the template file name matches the format name.
+        self.display_data_priority= ['svg', 'png', 'latex', 'jpg', 'jpeg','text']
+        self.template_file = export_format
+
         if not config == None:
             default_config._merge(config)
-        config = default_config
-
+        config = default_config    
+    
         #Call the base class constructor
         super(Exporter, self).__init__(config=config, **kw)
 
         #Standard environment
         self.ext = TEMPLATE_EXTENSION
-        self.env = 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
-            )
+        self._init_environment()
 
-        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)
+        #TODO: Implement reflection style methods to get user transformers.        
+        #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)
 
         #For compatibility, TODO: remove later.
-        self.preprocessors.append(trans.coalesce_streams)
-        self.preprocessors.append(trans.ExtractFigureTransformer(config=config))
-        self.preprocessors.append(trans.RevealHelpTransformer(config=config))
-        self.preprocessors.append(trans.CSSHtmlHeaderTransformer(config=config))
-        self.preprocessors.append(LatexTransformer(config=config))
-
-        #Only load the sphinx transformer if the file reference worked 
-        #(Sphinx dependencies exist on the user's machine.)
-        if SphinxTransformer:
-            self.preprocessors.append(SphinxTransformer(config=config))
+        self.preprocessors.append(transformers.coalescestreams.coalesce_streams)
+        self.preprocessors.append(transformers.extractfigure.ExtractFigureTransformer(config=config))
+        self.preprocessors.append(transformers.revealhelp.RevealHelpTransformer(config=config))
+        self.preprocessors.append(transformers.csshtmlheader.CSSHtmlHeaderTransformer(config=config))
 
         #Add filters to the Jinja2 environment
-        self.env.filters['filter_data_type'] = DataTypeFilter(config=config)
-        self.env.filters['pycomment'] = _python_comment
-        self.env.filters['indent'] = indent
-        self.env.filters['rm_fake'] = _rm_fake
-        self.env.filters['rm_ansi'] = remove_ansi
-        self.env.filters['markdown'] = markdown
-        self.env.filters['ansi2html'] = ansi2html
-        self.env.filters['markdown2latex'] = markdown_utils.markdown2latex
-        self.env.filters['markdown2rst'] = markdown_utils.markdown2rst
-        self.env.filters['get_lines'] = get_lines
-        self.env.filters['wrap'] = strings.wrap
-        self.env.filters['rm_dollars'] = strings.strip_dollars
-        self.env.filters['rm_math_space'] = rm_math_space
-        self.env.filters['highlight2html'] = highlight 
-        self.env.filters['highlight2latex'] = highlight2latex
-
-        #Latex specific filters
-        if self.tex_environement:
-            self.env.filters['escape_tex'] = _escape_tex 
-            self.env.filters['highlight'] = highlight2latex 
-        else:
-            self.env.filters['highlight'] = highlight 
+        self._register_filters(config)
 
         #Load user filters.  Overwrite existing filters if need be.
         for key, user_filter in jinja_filters.iteritems():
             if isinstance(user_filter, MetaHasTraits):
                 self.env.filters[key] = user_filter(config=config)
             else:
                 self.env.filters[key] = user_filter
 
         #Load the template file.
         self.template = self.env.get_template(self.template_file+self.ext)
 
 
     def export(self, nb):
         """Export notebook object
 
         nb: Notebook object 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)
         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.export(nbformat.read(f, 'json'))
 
 
     def from_file(self, file_stream):
         """Read and export a notebook from a filename
 
         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.export(nbformat.read(file_stream, 'json'))
 
 
+    def _init_environment(self):
+        self.env = 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 _register_filters(self, config):
+        self.env.filters['indent'] = indent
+        self.env.filters['markdown'] = markdown
+        
+        self.env.filters['ansi2html'] = filters.ansi.ansi2html
+        self.env.filters['filter_data_type'] = filters.datatypefilter.DataTypeFilter(config=config)
+        self.env.filters['get_lines'] = filters.strings.get_lines 
+        self.env.filters['highlight'] = filters.pygments.highlight
+        self.env.filters['highlight2html'] = filters.pygments.highlight 
+        self.env.filters['highlight2latex'] = filters.pygments.highlight2latex
+        self.env.filters['markdown2latex'] = filters.markdown.markdown2latex
+        self.env.filters['markdown2rst'] = filters.markdown.markdown2rst
+        self.env.filters['pycomment'] = filters.strings.python_comment
+        self.env.filters['rm_ansi'] = filters.ansi.remove_ansi
+        self.env.filters['rm_dollars'] = filters.strings.strip_dollars
+        self.env.filters['rm_fake'] = filters.strings.rm_fake
+        self.env.filters['rm_math_space'] = filters.latex.rm_math_space
+        self.env.filters['wrap'] = filters.strings.wrap
+    
+
     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
 
-
-    def _get_default_options(self, export_format):
-        """ Load the default options for built in formats.
-
-        export_format: Format being exported to.
-        """
-
-        c = get_config()
-        
-        #Set default data extraction priorities.
-        c.GlobalConfigurable.display_data_priority =['svg', 'png', 'latex', 'jpg', 'jpeg','text']
-        c.ExtractFigureTransformer.display_data_priority=['svg', 'png', 'latex', 'jpg', 'jpeg','text']
-        c.ConverterTemplate.display_data_priority= ['svg', 'png', 'latex', 'jpg', 'jpeg','text']
-
-        #For most (or all cases), the template file name matches the format name.
-        c.ConverterTemplate.template_file = export_format
-
-        if export_format == "basichtml" or "fullhtml" or "reveal":
-            c.CSSHtmlHeaderTransformer.enabled=True
-            if export_format == 'reveal'
-                c.NbconvertApp.fileext='reveal.html'
-            else:
-                c.NbconvertApp.fileext='html'
-
-        elif export_format == "latex_sphinx_howto" or export_format == "latex_sphinx_manual":
-
-            #Turn on latex environment 
-            c.ConverterTemplate.tex_environement=True
-
-            #Standard latex extension
-            c.NbconvertApp.fileext='tex'
-
-            #Prioritize latex extraction for latex exports.
-            c.GlobalConfigurable.display_data_priority =['latex', 'svg', 'png', 'jpg', 'jpeg' , 'text']
-            c.ExtractFigureTransformer.display_data_priority=['latex', 'svg', 'png', 'jpg', 'jpeg']
-            c.ExtractFigureTransformer.extra_ext_map={'svg':'pdf'}
-            c.ExtractFigureTransformer.enabled=True
-
-            # Enable latex transformers (make markdown2latex work with math $.)
-            c.LatexTransformer.enabled=True
-            c.SphinxTransformer.enabled = True
-
-        elif export_format == 'markdown':
-            c.NbconvertApp.fileext='md'
-            c.ExtractFigureTransformer.enabled=True
-
-        elif export_format == 'python':
-            c.NbconvertApp.fileext='py'
-
-
-        elif export_format == 'rst':
-            c.NbconvertApp.fileext='rst'
-            c.ExtractFigureTransformer.enabled=True
-        return c
-
-
-    #TODO: Comment me.
-    def _rm_fake(strng):
-        return strng.replace('/files/', '')
-
-
-    #TODO: Comment me.
-    def _python_comment(string):
-        return '# '+'\n# '.join(string.split('\n'))
-
-
-    #TODO: Comment me.
-    def _escape_tex(value):
-        newval = value
-        for pattern, replacement in LATEX_SUBS:
-            newval = pattern.sub(replacement, newval)
-        return newval
  No newline at end of file

nbconvert/api/latex.py

@@ -1,295 +1,150 b''
- 
-"""Latex exporter for the notebook conversion pipeline.
+ """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
 befor conversion and jinja filter that would then be availlable 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 .utils import highlight2latex #TODO
-
-from .transformers.latex import LatexTransformer, rm_math_space #TODO: rm_math_space from filters
+import base.Exporter as Exporter
 
 #Try to import the Sphinx exporter.  If the user doesn't have Sphinx isntalled 
 #on his/her machine, fail silently.
 try:
     from .sphinx_transformer import (SphinxTransformer) #TODO
 except ImportError:
     SphinxTransformer = None
 
 #-----------------------------------------------------------------------------
 # 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 = ["((*", "*))"]
 
-#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'),
-)
-
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
-class LatexExporter(Configurable):
+class LatexExporter(Exporter):
     """ A Jinja2 base converter templates
 
     Preprocess the ipynb files, feed it throug jinja templates,
     and spit an converted files and a data object with other data
     should be mostly configurable
     """
 
     #Processors that process the input data prior to the export, set in the 
     #constructor for this class.
     preprocessors = [] 
 
     def __init__(self, preprocessors={}, jinja_filters={}, config=None, export_format, **kw):
         """ Init a new converter.
 
         config: the Configurable config object to pass around.
 
         preprocessors: dict of **availlable** key/value function to run on
                        ipynb json data before conversion to extract/inline 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 registerd by this key will take precedence on
                        default one.
 
         jinja_filters: dict of supplementary jinja filter that should be made
                        availlable 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 availlable by default.
         """
 
         #Merge default config options with user specific override options.
         default_config = self._get_default_options()
         if not config == None:
             default_config._merge(config)
         config = default_config
 
         #Call the base class constructor
         super(Exporter, self).__init__(config=config, **kw)
 
         #Create a Latex environment if the user is exporting latex.
         if self.tex_environement:
             self.ext = LATEX_TEMPLATE_EXTENSION
             self.env = 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=JINJA_EXTENSIONS
                 )
 
             #Set special Jinja2 syntax that will not conflict with latex.
             self.env.block_start_string = LATEX_JINJA_LOGIC_BLOCK[0]
             self.env.block_end_string = LATEX_JINJA_LOGIC_BLOCK[1]
             self.env.variable_start_string = LATEX_JINJA_VARIABLE_BLOCK[0]
             self.env.variable_end_string = LATEX_JINJA_VARIABLE_BLOCK[1]
             self.env.comment_start_string = LATEX_JINJA_COMMENT_BLOCK[0]
             self.env.comment_end_string = LATEX_JINJA_COMMENT_BLOCK[1]
 
         else: #Standard environment
             self.ext = TEMPLATE_EXTENSION
             self.env = 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
                 )
 
         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)
 
         #For compatibility, TODO: remove later.
         self.preprocessors.append(trans.coalesce_streams)
         self.preprocessors.append(trans.ExtractFigureTransformer(config=config))
         self.preprocessors.append(trans.RevealHelpTransformer(config=config))
         self.preprocessors.append(trans.CSSHtmlHeaderTransformer(config=config))
         self.preprocessors.append(LatexTransformer(config=config))
 
         #Only load the sphinx transformer if the file reference worked 
         #(Sphinx dependencies exist on the user's machine.)
         if SphinxTransformer:
             self.preprocessors.append(SphinxTransformer(config=config))
 
         #Add filters to the Jinja2 environment
-        self.env.filters['filter_data_type'] = DataTypeFilter(config=config)
-        self.env.filters['pycomment'] = _python_comment
-        self.env.filters['indent'] = indent
-        self.env.filters['rm_fake'] = _rm_fake
-        self.env.filters['rm_ansi'] = remove_ansi
-        self.env.filters['markdown'] = markdown
-        self.env.filters['ansi2html'] = ansi2html
-        self.env.filters['markdown2latex'] = markdown_utils.markdown2latex
-        self.env.filters['markdown2rst'] = markdown_utils.markdown2rst
-        self.env.filters['get_lines'] = get_lines
-        self.env.filters['wrap'] = strings.wrap
-        self.env.filters['rm_dollars'] = strings.strip_dollars
-        self.env.filters['rm_math_space'] = rm_math_space
-        self.env.filters['highlight2html'] = highlight 
-        self.env.filters['highlight2latex'] = highlight2latex
-
-        #Latex specific filters
-        if self.tex_environement:
-            self.env.filters['escape_tex'] = _escape_tex 
-            self.env.filters['highlight'] = highlight2latex 
-        else:
-            self.env.filters['highlight'] = highlight 
-
+        self.env.filters['escape_tex'] = filters.latex.escape_tex 
+        self.env.filters['highlight'] = filters.pygments.highlight2latex 
+            
         #Load user filters.  Overwrite existing filters if need be.
         for key, user_filter in jinja_filters.iteritems():
             if isinstance(user_filter, MetaHasTraits):
                 self.env.filters[key] = user_filter(config=config)
             else:
                 self.env.filters[key] = user_filter
 
         #Load the template file.
         self.template = self.env.get_template(self.template_file+self.ext)
-
-
-    def export(self, nb):
-        """Export notebook object
-
-        nb: Notebook object 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)
-        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.export(nbformat.read(f, 'json'))
-
-
-    def from_file(self, file_stream):
-        """Read and export a notebook from a filename
-
-        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.export(nbformat.read(file_stream, 'json'))
-
-
-    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
-
-
-    def _get_default_options(self, export_format):
-        """ Load the default options for built in formats.
-
-        export_format: Format being exported to.
-        """
-
-        c = get_config()
-        
-        #Set default data extraction priorities.
-        c.GlobalConfigurable.display_data_priority =['svg', 'png', 'latex', 'jpg', 'jpeg','text']
-        c.ExtractFigureTransformer.display_data_priority=['svg', 'png', 'latex', 'jpg', 'jpeg','text']
-        c.ConverterTemplate.display_data_priority= ['svg', 'png', 'latex', 'jpg', 'jpeg','text']
-
-        #For most (or all cases), the template file name matches the format name.
-        c.ConverterTemplate.template_file = export_format
-
-        if export_format == "basichtml" or "fullhtml" or "reveal":
-            c.CSSHtmlHeaderTransformer.enabled=True
-            if export_format == 'reveal'
-                c.NbconvertApp.fileext='reveal.html'
-            else:
-                c.NbconvertApp.fileext='html'
-
-        elif export_format == "latex_sphinx_howto" or export_format == "latex_sphinx_manual":
-
-            #Turn on latex environment 
-            c.ConverterTemplate.tex_environement=True
-
-            #Standard latex extension
-            c.NbconvertApp.fileext='tex'
-
-            #Prioritize latex extraction for latex exports.
-            c.GlobalConfigurable.display_data_priority =['latex', 'svg', 'png', 'jpg', 'jpeg' , 'text']
-            c.ExtractFigureTransformer.display_data_priority=['latex', 'svg', 'png', 'jpg', 'jpeg']
-            c.ExtractFigureTransformer.extra_ext_map={'svg':'pdf'}
-            c.ExtractFigureTransformer.enabled=True
-
-            # Enable latex transformers (make markdown2latex work with math $.)
-            c.LatexTransformer.enabled=True
-            c.SphinxTransformer.enabled = True
-
-        elif export_format == 'markdown':
-            c.NbconvertApp.fileext='md'
-            c.ExtractFigureTransformer.enabled=True
-
-        elif export_format == 'python':
-            c.NbconvertApp.fileext='py'
-
-
-        elif export_format == 'rst':
-            c.NbconvertApp.fileext='rst'
-            c.ExtractFigureTransformer.enabled=True
-        return c
  No newline at end of file

nbconvert/filters/datatypefilter.py

@@ -1,31 +1,31 b''
 """Filter used to select the first prefered 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 """
 
     def __init__(self, config=None, **kw):
-        super(FilterDataType, self).__init__(config=config, **kw)
+        super(DataTypeFilter, self).__init__(config=config, **kw)
 
     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,72 +1,95 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
+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/markdown.py

@@ -1,75 +1,77 b''
 """Markdown utilities
 
 This file contains a collection of utility functions for dealing with 
 markdown.
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 from __future__ import print_function
 
 # Stdlib imports
+import sys
 import subprocess
 
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
+
 # Pandoc-dependent code
 def markdown2latex(src):
     """Convert a markdown string to LaTeX via pandoc.
 
     This function will raise an error if pandoc is not installed.
 
     Any error messages generated by pandoc are printed to stderr.
 
     Parameters
     ----------
     src : string
       Input string, assumed to be valid markdown.
 
     Returns
     -------
     out : string
       Output as returned by pandoc.
     """
     p = subprocess.Popen('pandoc -f markdown -t latex'.split(),
                          stdin=subprocess.PIPE, stdout=subprocess.PIPE)
     out, err = p.communicate(src.encode('utf-8'))
     if err:
         print(err, file=sys.stderr)
     #print('*'*20+'\n', out, '\n'+'*'*20)  # dbg
     return unicode(out, 'utf-8')
 
 
 def markdown2rst(src):
     """Convert a markdown string to LaTeX via pandoc.
 
     This function will raise an error if pandoc is not installed.
 
     Any error messages generated by pandoc are printed to stderr.
 
     Parameters
     ----------
     src : string
       Input string, assumed to be valid markdown.
 
     Returns
     -------
     out : string
       Output as returned by pandoc.
     """
     p = subprocess.Popen('pandoc -f markdown -t rst'.split(),
                          stdin=subprocess.PIPE, stdout=subprocess.PIPE)
     out, err = p.communicate(src.encode('utf-8'))
     if err:
         print(err, file=sys.stderr)
     #print('*'*20+'\n', out, '\n'+'*'*20)  # dbg
     return unicode(out, 'utf-8')
  No newline at end of file

nbconvert/filters/strings.py

@@ -1,35 +1,57 b''
- """String utilities.
+"""String utilities.
 
 Contains a collection of usefull 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('$')
  No newline at end of file
+    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,18 +1,19 b''
- 
+from transformers.base import ConfigurableTransformers
+
+
 class ActivatableTransformer(ConfigurableTransformers):
     """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,120 +1,121 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):
     """ 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)
 
     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