Finished a rough draft of the exporters.

nbconvert/api/html_exporter.py

@@ -0,0 +1,47
+ """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
+
+#-----------------------------------------------------------------------------
+# 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)
+
+        #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/markdown_exporter.py

@@ -0,0 +1,32
+"""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
+
+#-----------------------------------------------------------------------------
+# 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)
+
+        #Set defaults
+        self.file_extension = "md"  
+        self.extract_figure_transformer.enabled = True
+        self.template_file = "markdown"

nbconvert/api/python_exporter.py

@@ -0,0 +1,34
+"""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
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+class PythonExporter(exporter.Exporter):
+
+    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"

nbconvert/api/reveal_exporter.py

@@ -0,0 +1,41
+ """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
+
+#-----------------------------------------------------------------------------
+# 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"
+
+    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_exporter.py

@@ -0,0 +1,51
+ """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
+
+#-----------------------------------------------------------------------------
+# 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
+
+
+    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_exporter.py

@@ -0,0 +1,48
+ """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
+
+#-----------------------------------------------------------------------------
+# 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)  
+
+    
+    def _register_transformers(self):
+        
+        #Register the transformers of the base class.
+        super(latex_exporter.LatexExporter, self)._register_transformers()
+        
+        #Register latex transformer
+        #self.register_transformer(LatexTransformer)
+                    

nbconvert/api/convert.py

@@ -1,23 +1,21
 """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/api/exporter.py

@@ -1,268 +1,285
 """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.csshtmlheader
-import transformers.revealhelp
 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."""
         )
 
     #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
 
-        #Load the template file.
-        self.template = self.environment.get_template(self.template_file+self.ext)
 
+        #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)
+        
         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))
         else:
             self.preprocessors.append(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)
-        self.register_transformer(transformers.extractfigure.ExtractFigureTransformer)
-        self.register_transformer(transformers.revealhelp.RevealHelpTransformer)
-        self.register_transformer(transformers.csshtmlheader.CSSHtmlHeaderTransformer)
+        
+        #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/latex_exporter.py

@@ -1,127 +1,114
  """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
 
 # 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
     """
 
     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/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
-                       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
+        #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.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