Added latexexporter

nbconvert/api/exporter.py

@@ -4,7 +4,7 b' 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
+before conversion and jinja filter that would then be available in the templates
 """
 
 #-----------------------------------------------------------------------------
@@ -83,7 +83,7 b' class Exporter(Configurable):'
             '', config=True,
             help="Name of the template file to use")
 
-    fileext = Unicode(
+    file_extension = Unicode(
         'txt', config=True, 
         help="Extension of the file that should be written to disk"
         )
@@ -142,11 +142,8 b' class Exporter(Configurable):'
         #            transformer = transformer(config=config)
         #        self.preprocessors.append(transformer)
 
-        #For compatibility, TODO: remove later.
-        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 transformers
+        self._register_transformers()
 
         #Add filters to the Jinja2 environment
         self._register_filters()
@@ -155,12 +152,12 b' class Exporter(Configurable):'
         if not jinja_filters is None:
             for key, user_filter in jinja_filters.iteritems():
                 if isinstance(user_filter, MetaHasTraits):
-                    self.env.filters[key] = user_filter(config=config)
+                    self.environment.filters[key] = user_filter(config=config)
                 else:
-                    self.env.filters[key] = user_filter
+                    self.environment.filters[key] = user_filter
 
         #Load the template file.
-        self.template = self.env.get_template(self.template_file+self.ext)
+        self.template = self.environment.get_template(self.template_file+self.ext)
 
 
     def from_notebook_node(self, nb):
@@ -203,13 +200,27 b' class Exporter(Configurable):'
         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))
+        else:
+            self.preprocessors.append(transformer)
+
+
     def register_filter(self, name, filter):
         if MetaHasTraits(filter):
-            self.env.filters[name] = filter(config=self.config)
+            self.environment.filters[name] = filter(config=self.config)
         else:
-            self.env.filters[name] = filter
+            self.environment.filters[name] = filter
 
 
+    def _register_transformers(self):
+        self.register_transformer(transformers.coalescestreams.coalesce_streams)
+        self.register_transformer(transformers.extractfigure.ExtractFigureTransformer)
+        self.register_transformer(transformers.revealhelp.RevealHelpTransformer)
+        self.register_transformer(transformers.csshtmlheader.CSSHtmlHeaderTransformer)
+        
+        
     def _register_filters(self):
         self.register_filter('indent', indent)
         self.register_filter('markdown', markdown)
@@ -230,7 +241,7 b' class Exporter(Configurable):'
 
         
     def _init_environment(self):
-        self.env = Environment(
+        self.environment = Environment(
             loader=FileSystemLoader([
                 os.path.dirname(os.path.realpath(__file__)) + TEMPLATE_PATH,
                 os.path.dirname(os.path.realpath(__file__)) + TEMPLATE_SKELETON_PATH,

nbconvert/api/latexexporter.py

@@ -33,17 +33,11 b' from IPython.utils.text import indent'
 from jinja2 import Environment, FileSystemLoader
 from markdown import markdown
 
-import base.Exporter as Exporter
+# local import
+import exporter
 import filters.latex
 import filters.pygments
-
-#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
-
+from transformers.latex import LatexTransformer
 #-----------------------------------------------------------------------------
 # Globals and constants
 #-----------------------------------------------------------------------------
@@ -61,19 +55,15 b' LATEX_JINJA_LOGIC_BLOCK = ["((*", "*))"]'
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
-class LatexExporter(Exporter):
-    """ A Jinja2 base converter templates
+class LatexExporter(exporter.Exporter):
+    """ A Jinja2 latex exporter
 
-    Preprocess the ipynb files, feed it throug jinja templates,
+    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
     """
 
-    #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):
+    def __init__(self, preprocessors=None, jinja_filters=None, config=None, **kw):
         """ Init a new converter.
 
         config: the Configurable config object to pass around.
@@ -96,45 +86,42 b' class LatexExporter(Exporter):'
         """
 
         #Call the base class constructor
-        super(Exporter, self).__init__(config=config, **kw)
-
-        #For compatibility, TODO: remove later.
-        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.register_filter('escape_tex', filters.latex.escape_tex) 
-        self.register_filter('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)
+        super(exporter.Exporter, self).__init__(preprocessors, jinja_filters, config, **kw)
 
 
     def _init_environment(self):
         self.ext = LATEX_TEMPLATE_EXTENSION
-        self.env = Environment(
+        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=JINJA_EXTENSIONS
+            extensions=exporter.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]
  No newline at end of file
+        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