Almost have nbconvert working again...

nbconvert.py

@@ -1,155 +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
 
 #Local imports
 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)
 
 
     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 type
         ipynb_file = (self.extra_args)[2]
         export_type = (self.extra_args)[1]
 
         #Export
         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'))
 
         #Write file output from conversion.
         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 not destination_directory is None:
                 for key in binkeys:
                     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(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.
             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)
+    app.start(argv=sys.argv)
 
 if __name__ == '__main__':
     main()
  No newline at end of file

nbconvert/api/exporter.py

@@ -1,219 +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
 
 # 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 nbconvert.filters.strings
 import nbconvert.filters.markdown
 import nbconvert.filters.latex
 import nbconvert.filters.datatypefilter
-import nbconvert.filters.pygments
+import nbconvert.filters.highlight
 import nbconvert.filters.ansi
 
 import nbconvert.transformers.extractfigure
 import nbconvert.transformers.coalescestreams
 
 
 #-----------------------------------------------------------------------------
 # Globals and constants
 #-----------------------------------------------------------------------------
 
 #Standard Jinja2 environment constants
 TEMPLATE_PATH = "/../templates/"
 TEMPLATE_SKELETON_PATH = "/../templates/skeleton/"
 
 #Jinja2 extensions to load.
 JINJA_EXTENSIONS = ['jinja2.ext.loopcontrols']
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 class Exporter(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):
     
         #Call the base class constructor
         super(Exporter, self).__init__(config=config, **kw)
 
         #Standard environment
         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 issubclass(user_filter, MetaHasTraits):
                     self.environment.filters[key] = user_filter(config=config)
                 else:
                     self.environment.filters[key] = user_filter
     
     # Public methods #########################################
     
     def from_notebook_node(self, nb):
         nb, resources = self._preprocess(nb)
         
         #Load the template file.
         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):
         with io.open(filename) as f:
             return self.from_notebook_node(nbformat.read(f, 'json'))
 
 
     def from_file(self, file_stream):
         return self.from_notebook_node(nbformat.read(file_stream, 'json'))
 
 
     def register_transformer(self, transformer):
         if isinstance(transformer, MetaHasTraits):
             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 isinstance(filter, MetaHasTraits):
             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(nbconvert.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(nbconvert.transformers.extractfigure.ExtractFigureTransformer)
         
         
     def _register_filters(self):
         self.register_filter('indent', indent)
         self.register_filter('markdown', markdown)
         self.register_filter('ansi2html', nbconvert.filters.ansi.ansi2html)
         self.register_filter('filter_data_type', nbconvert.filters.datatypefilter.DataTypeFilter)
         self.register_filter('get_lines', nbconvert.filters.strings.get_lines)
-        self.register_filter('highlight', nbconvert.filters.pygments.highlight)
-        self.register_filter('highlight2html', nbconvert.filters.pygments.highlight) 
-        self.register_filter('highlight2latex', nbconvert.filters.pygments.highlight2latex)
+        self.register_filter('highlight', nbconvert.filters.highlight.highlight)
+        self.register_filter('highlight2html', nbconvert.filters.highlight.highlight) 
+        self.register_filter('highlight2latex', nbconvert.filters.highlight.highlight2latex)
         self.register_filter('markdown2latex', nbconvert.filters.markdown.markdown2latex)
         self.register_filter('markdown2rst', nbconvert.filters.markdown.markdown2rst)
         self.register_filter('pycomment', nbconvert.filters.strings.python_comment)
         self.register_filter('rm_ansi', nbconvert.filters.ansi.remove_ansi)
         self.register_filter('rm_dollars', nbconvert.filters.strings.strip_dollars)
         self.register_filter('rm_fake', nbconvert.filters.strings.rm_fake)
         self.register_filter('rm_math_space', nbconvert.filters.latex.rm_math_space)
         self.register_filter('wrap', nbconvert.filters.strings.wrap)
         
         
     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):
 
         #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,42 +1,42 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
 import nbconvert.transformers.csshtmlheader
 from IPython.utils.traitlets import Unicode
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 class HtmlExporter(exporter.Exporter):
 
     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")
 
     def _register_transformers(self):
         
         #Register the transformers of the base class.
-        super(exporter.Exporter, self)._register_transformers()
+        super(HtmlExporter, self)._register_transformers()
         
         #Register latex transformer
         self.register_transformer(nbconvert.transformers.csshtmlheader.CSSHtmlHeaderTransformer)
                     
  No newline at end of file

nbconvert/api/latex.py

@@ -1,99 +1,99 b''
 #-----------------------------------------------------------------------------
 # 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 os
 
 # IPython imports
 from IPython.utils.traitlets import Unicode
 
 # other libs/dependencies
 from jinja2 import Environment, FileSystemLoader
 
 # local import
 import exporter
 import nbconvert.filters.latex
-import nbconvert.filters.pygments
+import nbconvert.filters.highlight
 from nbconvert.transformers.latex import LatexTransformer
 #-----------------------------------------------------------------------------
 # Globals and constants
 #-----------------------------------------------------------------------------
 
 #Latex Jinja2 constants
-LATEX_TEMPLATE_PATH = "/../templates/tex/"
-LATEX_TEMPLATE_SKELETON_PATH = "/../templates/tex/skeleton/"
+LATEX_TEMPLATE_PATH = "/../templates/latex/"
+LATEX_TEMPLATE_SKELETON_PATH = "/../templates/latex/skeleton/"
 
 #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):
 
     #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,
+            '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)
+        super(LatexExporter, self).__init__(preprocessors, jinja_filters, config, **kw)
         
         self.extract_figure_transformer.display_data_priority = ['latex', 'svg', 'png', 'jpg', 'jpeg' , 'text']
         self.extract_figure_transformer.extra_ext_map={'svg':'pdf'}
         
         
     def _init_environment(self):
         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()
+        super(LatexExporter, 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) 
+        self.register_filter('escape_tex', nbconvert.filters.latex.escape_tex) 
+        self.register_filter('highlight', nbconvert.filters.highlight.highlight2latex) 
     
     def _register_transformers(self):
         
         #Register the transformers of the base class.
-        super(exporter.Exporter, self)._register_transformers()
+        super(LatexExporter, self)._register_transformers()
         
         #Register latex transformer
         self.register_transformer(LatexTransformer)
                     
  No newline at end of file

nbconvert/api/python.py

@@ -1,40 +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)
+        super(PythonExporter, self).__init__(preprocessors, jinja_filters, config, **kw)
 
         #Set defaults
         self.extract_figure_transformer.enabled = False
         

nbconvert/api/reveal.py

@@ -1,41 +1,41 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 html
 import nbconvert.transformers.revealhelp
 from IPython.utils.traitlets import Unicode
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 class RevealExporter(html.HtmlExporter):
 
     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()
+        super(RevealExporter, self)._register_transformers()
         
         #Register reveal help transformer
-        self.register_transformer(transformers.revealhelp.RevealHelpTransformer)
+        self.register_transformer(nbconvert.transformers.revealhelp.RevealHelpTransformer)
         
  No newline at end of file

nbconvert/api/sphinx.py

@@ -1,34 +1,34 b''
 
 #-----------------------------------------------------------------------------
 # 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
 from IPython.utils.traitlets import Unicode
 from nbconvert.transformers.sphinx import SphinxTransformer
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 class SphinxExporter(latex.LatexExporter):
 
     template_file = Unicode(
-            'sphinxhowto', config=True,
+            'sphinx_howto', config=True,
             help="Name of the template file to use")
     
     def _register_transformers(self):
         
         #Register the transformers of the base class.
-        super(latex.LatexExporter, self)._register_transformers()
+        super(SphinxExporter, self)._register_transformers()
         
         #Register sphinx latex transformer
         self.register_transformer(SphinxTransformer) 
                     

nbconvert/filters/datatypefilter.py

@@ -1,40 +1,39 b''
 """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(object):
     """ Returns the preferred display format """
 
     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:
+        if 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/highlight.py

@@ -1,39 +1,41 b''
+
+from  pygments import highlight as pygements_highlight
+from pygments.lexers import get_lexer_by_name
+from pygments.formatters import HtmlFormatter
+from pygments.formatters import LatexFormatter
+
 # Our own imports
 from nbconvert.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)
+    
+    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)
+    return _pygment_highlight(src, LatexFormatter(), lang)
 
-def pygment_highlight(src, output_formatter, lang='ipython'):
+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) 
+    return pygements_highlight(src, lexer, output_formatter) 

nbconvert/templates/latex/skeleton/null.tplx

@@ -1,92 +1,92 b''
 ((= autogenerated file do not edit =))
 ((=
 
 DO NOT USE THIS AS A BASE WORK,
 IF YOU ARE COPY AND PASTING THIS FILE
 YOU ARE PROBABLY DOING THINGS WRONG.
 
 Null template, Does nothing except defining a basic structure
 To layout the different blocks of a notebook.
 
 Subtemplates can override blocks to define their custom representation.
 
 If one of the block you do overwrite is not a leave block, consider
 calling super.
 
 ((*- block nonLeaveBlock -*))
     #add stuff at beginning
     ((( super() )))
     #add stuff at end
 ((*- endblock nonLeaveBlock -*))
 
 consider calling super even if it is a leave block, we might insert more blocks later.
 
 =))
 ((*- block header -*))
 ((*- endblock header -*))
 ((*- block body -*))
 ((*- for worksheet in nb.worksheets -*))
     ((*- for cell in worksheet.cells -*))
         ((*- block any_cell scoped -*))
-            ((*- if cell.type in ['code'] -*))
+            ((*- if cell.cell_type in ['code'] -*))
                 ((*- block codecell scoped -*))
                     ((*- block input_group -*))
                         ((*- block in_prompt -*))((*- endblock in_prompt -*))
                         ((*- block input -*))((*- endblock input -*))
                     ((*- endblock input_group -*))
                     ((*- if cell.outputs -*))
                     ((*- block output_group -*))
                         ((*- block output_prompt -*))((*- endblock output_prompt -*))
                         ((*- block outputs scoped -*))
                             ((*- for output in cell.outputs -*))
                                 ((*- block output scoped -*))
                                     ((*- if output.output_type in ['pyout'] -*))
                                         ((*- block pyout scoped -*))((*- endblock pyout -*))
                                     ((*- elif output.output_type in ['stream'] -*))
                                         ((*- block stream scoped -*))
                                             ((*- if output.stream in ['stdout'] -*))
                                                 ((*- block stream_stdout scoped -*))
                                                 ((*- endblock stream_stdout -*))
                                             ((*- elif output.stream in ['stderr'] -*))
                                                 ((*- block stream_stderr scoped -*))
                                                 ((*- endblock stream_stderr -*))
                                             ((*- endif -*))
                                         ((*- endblock stream -*))
                                     ((*- elif output.output_type in ['display_data'] -*))
                                         ((*- block display_data scoped -*))
                                             ((*- block data_priority scoped -*))
                                             ((*- endblock data_priority -*))
                                         ((*- endblock display_data -*))
                                     ((*- elif output.output_type in ['pyerr'] -*))
                                         ((*- block pyerr scoped -*))
                                         ((*- for line in output.traceback -*))
                                             ((*- block traceback_line scoped -*))((*- endblock traceback_line -*))
                                         ((*- endfor -*))
                                         ((*- endblock pyerr -*))
                                     ((*- endif -*))
                                 ((*- endblock output -*))
                             ((*- endfor -*))
                         ((*- endblock outputs -*))
                     ((*- endblock output_group -*))
                     ((*- endif -*))
                 ((*- endblock codecell -*))
-            ((*- elif cell.type in ['markdown'] -*))
+            ((*- elif cell.cell_type in ['markdown'] -*))
                 ((*- block markdowncell scoped-*))
                 ((*- endblock markdowncell -*))
-            ((*- elif cell.type in ['heading'] -*))
+            ((*- elif cell.cell_type in ['heading'] -*))
                 ((*- block headingcell scoped-*))
                 ((*- endblock headingcell -*))
-            ((*- elif cell.type in ['raw'] -*))
+            ((*- elif cell.cell_type in ['raw'] -*))
                 ((*- block rawcell scoped-*))
                 ((*- endblock rawcell -*))
             ((*- else -*))
                 ((*- block unknowncell scoped-*))
                 ((*- endblock unknowncell -*))
             ((*- endif -*))
         ((*- endblock any_cell -*))
     ((*- endfor -*))
 ((*- endfor -*))
 ((*- endblock body -*))
 
 ((*- block footer -*))
 ((*- endblock footer -*))

nbconvert/templates/latex/sphinx_base.tplx

@@ -1,439 +1,439 b''
 ((= NBConvert Sphinx-Latex Template
 
 Purpose: Allow export of PDF friendly Latex inspired by Sphinx.  Most of the
        template is derived directly from Sphinx source.
 
-Inheritance: null>display_priority>latex_base 
+Inheritance: null>display_priority 
 
 Note: For best display, use latex syntax highlighting. =))
 
 ((*- extends 'display_priority.tplx' -*))
 
 %==============================================================================
 % Declarations
 %==============================================================================
 
 % In order to make sure that the input/output header follows the code it 
 % preceeds, the needspace package is used to request that a certain
 % amount of lines (specified by this variable) are reserved.  If those
 % lines aren't available on the current page, the documenter will break
 % to the next page and the header along with accomanying lines will be
 % rendered together.  This value specifies the number of lines that
 % the header will be forced to group with without a page break.
 ((*- set min_header_lines = 4 -*))
 
 % This is the number of characters that are permitted per line.  It's
 % important that this limit is set so characters do not run off the
 % edges of latex pages (since latex does not always seem smart enough
 % to prevent this in some cases.)  This is only applied to textual output
 ((* if resources.sphinx.outputstyle == 'simple' *))
     ((*- set wrap_size = 85 -*))
 ((* elif resources.sphinx.outputstyle == 'notebook' *))
     ((*- set wrap_size = 70 -*))
 ((* endif *))
 
 %==============================================================================
 % Header
 %==============================================================================
 ((* block header *))
 
 % Header, overrides base
 
     % Make sure that the sphinx doc style knows who it inherits from.
     \def\sphinxdocclass{(((parentdocumentclass)))}
 
     % Declare the document class
     \documentclass[letterpaper,10pt,english]{((( resources.sphinx.texinputs )))/sphinx(((documentclass)))}
 
     % Imports
     \usepackage[utf8]{inputenc}
     \DeclareUnicodeCharacter{00A0}{\\nobreakspace}
     \usepackage[T1]{fontenc}
     \usepackage{babel}
     \usepackage{times}
     \usepackage{import}
     \usepackage[((( resources.sphinx.chapterstyle )))]{((( resources.sphinx.texinputs )))/fncychap}
     \usepackage{longtable}
     \usepackage{((( resources.sphinx.texinputs )))/sphinx}
     \usepackage{multirow}
 
     \usepackage{amsmath}
     \usepackage{amssymb}
     \usepackage{ucs}
     \usepackage{enumerate}
 
     % Used to make the Input/Output rules follow around the contents.
     \usepackage{needspace}
 
     % Pygments requirements
     \usepackage{fancyvrb}
     \usepackage{color}
 
     % Needed to box output/input
     \usepackage{tikz}
         \usetikzlibrary{calc,arrows,shadows}
     \usepackage[framemethod=tikz]{mdframed}
 
     \usepackage{alltt}
 
     % Used to load and display graphics
     \usepackage{graphicx}
     \graphicspath{ {figs/} }
     \usepackage[Export]{adjustbox} % To resize
 
 
     % For formatting output while also word wrapping.
     \usepackage{listings}
     \lstset{breaklines=true}
     \lstset{basicstyle=\small\ttfamily}
     \def\smaller{\fontsize{9.5pt}{9.5pt}\selectfont}
 
     %Pygments definitions
     ((( resources.sphinx.pygment_definitions )))
 
     %Set pygments styles if needed...
     ((* if resources.sphinx.outputstyle == 'notebook' *))
         \definecolor{nbframe-border}{rgb}{0.867,0.867,0.867}
         \definecolor{nbframe-bg}{rgb}{0.969,0.969,0.969}
         \definecolor{nbframe-in-prompt}{rgb}{0.0,0.0,0.502}
         \definecolor{nbframe-out-prompt}{rgb}{0.545,0.0,0.0}
 
         \newenvironment{ColorVerbatim}
         {\begin{mdframed}[%
             roundcorner=1.0pt, %
             backgroundcolor=nbframe-bg, %
             userdefinedwidth=1\linewidth, %
             leftmargin=0.1\linewidth, %
             innerleftmargin=0pt, %
             innerrightmargin=0pt, %
             linecolor=nbframe-border, %
             linewidth=1pt, %
             usetwoside=false, %
             everyline=true, %
             innerlinewidth=3pt, %
             innerlinecolor=nbframe-bg, %
             middlelinewidth=1pt, %
             middlelinecolor=nbframe-bg, %
             outerlinewidth=0.5pt, %
             outerlinecolor=nbframe-border, %
             needspace=0pt
         ]}
         {\end{mdframed}}
         
         \newenvironment{InvisibleVerbatim}
         {\begin{mdframed}[leftmargin=0.1\linewidth,innerleftmargin=3pt,innerrightmargin=3pt, userdefinedwidth=1\linewidth, linewidth=0pt, linecolor=white, usetwoside=false]}
         {\end{mdframed}}
 
         \renewenvironment{Verbatim}[1][\unskip]
         {\begin{alltt}\smaller}
         {\end{alltt}}
     ((* endif *))
 
     % Help prevent overflowing lines due to urls and other hard-to-break 
     % entities.  This doesn't catch everything...
     \sloppy
 
     % Document level variables
     \title{((( nb.metadata.name | escape_tex )))}
     \date{((( nb.metadata._draft.date | escape_tex )))}
     \release{((( nb.metadata._draft.version | escape_tex )))}
     \author{((( nb.metadata._draft.author | escape_tex )))}
     \renewcommand{\releasename}{((( nb.metadata._draft.release | escape_tex )))}
 
     % TODO: Add option for the user to specify a logo for his/her export.
     \newcommand{\sphinxlogo}{}
 
     % Make the index page of the document.
     \makeindex
 
     % Import sphinx document type specifics.
     ((* block sphinxheader *))((* endblock sphinxheader *)) 
 ((* endblock header *))
 
 %==============================================================================
 % Body
 %==============================================================================
 ((* block body *))
 ((* block bodyBegin *))
 % Body
 
     % Start of the document
     \begin{document}
 
         ((* if resources.sphinx.header *))
             \maketitle
         ((* endif *))
 
         ((* block toc *))
             \tableofcontents 
         ((* endblock toc *))
 
         ((* endblock bodyBegin *))((( super() )))((* block bodyEnd *))
 
         \renewcommand{\indexname}{Index}
         \printindex
 
     % End of document
     \end{document}
 ((* endblock bodyEnd *))
 ((* endblock body *))
 
 %==============================================================================
 % Footer
 %==============================================================================
 ((* block footer *))
 ((* endblock footer *))
 
 %==============================================================================
 % Headings
 %
 % Purpose: Format pynb headers as sphinx headers.  Depending on the Sphinx
 %          style that is active, this will change.  Thus sphinx styles will
 %          override the values here.
 %==============================================================================
 ((* block headingcell -*))
     \
     ((*- if cell.level == 1 -*))
         ((* block h1 -*))part((* endblock h1 -*))
     ((*- elif cell.level == 2 -*))
         ((* block h2 -*))chapter((* endblock h2 -*))
     ((*- elif cell.level == 3 -*))
         ((* block h3 -*))section((* endblock h3 -*))
     ((*- elif cell.level == 4 -*))
         ((* block h4 -*))subsection((* endblock h4 -*))
     ((*- elif cell.level == 5 -*))
         ((* block h5 -*))subsubsection((* endblock h5 -*))
     ((*- elif cell.level == 6 -*))
         ((* block h6 -*))paragraph((* endblock h6 -*))
 
     ((= It's important to make sure that underscores (which tend to be common
     in IPYNB file titles) do not make their way into latex.  Sometimes this
     causes latex to barf. =))
     ((*- endif -*)){((( escape_underscores(cell.source | markdown2latex ) )))}
 ((*- endblock headingcell *))
 
 %==============================================================================
 % Markdown
 %
 % Purpose: Convert markdown to latex.  Here markdown2latex is explicitly
 %          called since we know we want latex output.
 %==============================================================================
 ((*- block markdowncell scoped-*))
     ((( cell.source | markdown2latex )))
 ((*- endblock markdowncell -*))
 
 %==============================================================================
 % Rawcell
 %
 % Purpose: Raw text cells allow the user to manually inject document code that 
 %          will not get touched by the templating system.
 %==============================================================================
 ((*- block rawcell *))
     ((( cell.source | wrap(wrap_size) )))
 ((* endblock rawcell -*))
 
 %==============================================================================
 % Unknowncell
 %
 % Purpose: This is the catch anything unhandled.  To display this data, we
 %          remove all possible latex conflicts and wrap the characters so they
 %          can't flow off of the page.
 %==============================================================================
 ((* block unknowncell scoped*))
 
     % Unsupported cell type, no formatting
     ((( cell.source | wrap | escape_tex )))
 ((* endblock unknowncell *))
 
 %==============================================================================
 % Input
 %==============================================================================
 ((* block input *))
 
     % Make sure that atleast 4 lines are below the HR
     \needspace{((( min_header_lines )))\baselineskip}
 
     ((* if resources.sphinx.outputstyle == 'simple' *))
 
         % Add a horizantal break, along with break title.
         \vspace{10pt}
         {\scriptsize Input}\\*
         \rule[10pt]{\linewidth}{0.5pt}
         \vspace{-25pt}
 
         % Add contents below.
         ((( cell.input | highlight )))
 
     ((* elif resources.sphinx.outputstyle == 'notebook' *))
         \vspace{6pt}
         ((( write_prompt("In", cell.prompt_number, "nbframe-in-prompt") )))
         \vspace{-2.65\baselineskip}
         \begin{ColorVerbatim}
             \vspace{-0.7\baselineskip}
             ((( cell.input | highlight )))
             ((* if cell.input == None or cell.input == '' *))
                 \vspace{0.3\baselineskip}
             ((* else *))
                 \vspace{-0.2\baselineskip}
             ((* endif *))
         \end{ColorVerbatim}
     ((* endif *))
 ((* endblock input *))
 
 %==============================================================================
 % Output_Group
 %
 % Purpose: Make sure that only one header bar only attaches to the output 
 %          once.  By keeping track of when an input group is started
 %==============================================================================
 ((* block output_group *))
     ((* if cell.outputs.__len__() > 0 *))
 
         % If the first block is an image, minipage the image.  Else
         % request a certain amount of space for the input text.
         ((( iff_figure(cell.outputs[0], "\\begin{minipage}{1.0\\textwidth}", "\\needspace{"  ~ min_header_lines ~ "\\baselineskip}") )))
         
         ((* if resources.sphinx.outputstyle == 'simple' *))
 
             % Add a horizantal break, along with break title.
             \vspace{10pt}
             {\scriptsize Output}\\*
             \rule[10pt]{\linewidth}{0.5pt}
             \vspace{-20pt}
 
             % Add the contents of the first block.
             ((( render_output(cell.outputs[0]) )))
 
             % Close the minipage.
             ((( iff_figure(cell.outputs[0], "\\end{minipage}", "") )))
 
             % Add remainer of the document contents below.
             ((* for output in cell.outputs[1:] *))
                 ((( render_output(output, cell.prompt_number) )))
             ((* endfor *))
         ((* elif resources.sphinx.outputstyle == 'notebook' *))
 
             % Add document contents.
             ((* for output in cell.outputs *))
                 ((( render_output(output, cell.prompt_number) )))
             ((* endfor *))
         ((* endif *))
     ((* endif *))
 ((* endblock *))
 
 %==============================================================================
 % Additional formating
 %==============================================================================
 ((* block data_text *))
     ((( custom_verbatim(output.text) )))
 ((* endblock *))
 
 ((* block traceback_line *))
     ((( conditionally_center_output(line | indent| rm_ansi) )))
 ((* endblock traceback_line *))
 
 %==============================================================================
 % Supported image formats
 %==============================================================================
 ((*- block data_png -*))
     ((( conditionally_center_output(insert_graphics(output.key_png)) )))
 ((*- endblock -*))
 
 ((*- block data_svg -*))
     ((( conditionally_center_output(insert_graphics(output.key_svg)) )))
 ((*- endblock -*))
 
 ((*- block data_latex *))
     ((* if resources.sphinx.centeroutput *))\begin{center}((* endif -*))((( output.latex | rm_math_space )))((*- if resources.sphinx.centeroutput *))\end{center} ((* endif -*))
 ((*- endblock -*))
 
 %==============================================================================
 % Support Macros
 %==============================================================================
 
 % Name: write_prompt
 % Purpose: Renders an output/input prompt for notebook style pdfs
 ((* macro write_prompt(prompt, number, color) -*))
     \makebox[0.1\linewidth]{\smaller\hfill\tt\color{((( color )))}((( prompt )))\hspace{4pt}{[}((( number ))){]}:\hspace{4pt}}\\*
 ((*- endmacro *))
 
 % Name: render_output
 % Purpose: Renders an output block appropriately.
 ((* macro render_output(output, prompt_number) -*))
     ((*- if output.output_type == 'pyerr' -*))
         ((*- block pyerr scoped *))
             ((( custom_verbatim(super()) )))
         ((* endblock pyerr -*))
     ((*- else -*))
 
         ((* if resources.sphinx.outputstyle == 'notebook' *))
             ((*- if output.output_type == 'pyout' -*))
                 ((( write_prompt("Out", prompt_number, "nbframe-out-prompt") )))
                 \vspace{-2.55\baselineskip}
             ((*- endif -*))
 
             \begin{InvisibleVerbatim}
                 \vspace{-0.5\baselineskip}
         ((*- endif -*))
 
         ((*- block display_data scoped -*))
             ((( super() )))
         ((*- endblock display_data -*))
 
         ((* if resources.sphinx.outputstyle == 'notebook' *))
             \end{InvisibleVerbatim}
         ((*- endif -*))
     ((*- endif -*))
 ((*- endmacro *))
 
 % Name: iff_figure
 % Purpose: If the output block provided is a figure type, the 'true_content'
 %          parameter will be returned.  Else, the 'false_content'. 
 ((* macro iff_figure(output, true_content, false_content) -*))
     ((*- set is_figure = false -*))
     ((*- for type in output | filter_data_type -*))
         ((*- if type in ['pdf', 'svg', 'png', 'jpeg','html']*))
             ((*- set is_figure = true -*))
         ((*- endif -*))
     ((*- endfor -*))
     
     ((* if is_figure -*))
         ((( true_content )))
     ((*- else -*))
         ((( false_content )))
     ((*- endif *))
 ((*- endmacro *))
 
 % Name: custom_verbatim
 % Purpose: This macro creates a verbatim style block that fits the existing
 %          sphinx style more readily than standard verbatim blocks.
 ((* macro custom_verbatim(text) -*))
     \begin{alltt}
     ((*- if resources.sphinx.centeroutput *))\begin{center} ((* endif -*))
 ((( text | wrap(wrap_size) )))
     ((*- if resources.sphinx.centeroutput *))\end{center}((* endif -*))
     \end{alltt}
 ((*- endmacro *))
 
 % Name: conditionally_center_output
 % Purpose: This macro centers the output if the output centering is enabled.
 ((* macro conditionally_center_output(text) -*))
     ((* if resources.sphinx.centeroutput *)){\centering ((* endif *))((( text )))((* if resources.sphinx.centeroutput *))}((* endif *))
 ((*- endmacro *))
 
 % Name: insert_graphics
 % Purpose: This macro will insert an image in the latex document given a path.
 ((* macro insert_graphics(path) -*))
     \begin{center}
     \includegraphics[max size={\textwidth}{\textheight}]{(((path)))}
     \par
     \end{center}
 ((*- endmacro *))
 
 % Name: escape_underscores
 % Purpose: Underscores cause a problem in latex.  It's important that we 
 %          escape any underscores that appear.
 ((* macro escape_underscores(text) -*))
     ((*- set text = text|replace("_","\\_") -*))
     ((( text )))
 ((*- endmacro *))
  No newline at end of file

nbconvert/templates/latex/sphinx_howto.tplx

@@ -1,25 +1,25 b''
 ((============================================================================
   NBConvert Sphinx-Latex HowTo Template
 
   Purpose: Allow export of PDF friendly Latex inspired by Sphinx HowTo 
            document style.  Most of the is derived directly from Sphinx source.
 
   Inheritance: null>display_priority>latex_base->latex_sphinx_base 
 
   ==========================================================================))
 
-((*- extends 'latex_sphinx_base.tplx' -*))
+((*- extends 'sphinx_base.tplx' -*))
 
 ((* set parentdocumentclass = 'article' *))
 ((* set documentclass = 'howto' *))
 
 ((* block h1 -*))part((* endblock h1 -*))
 ((* block h2 -*))section((* endblock h2 -*))
 ((* block h3 -*))subsection((* endblock h3 -*))
 ((* block h4 -*))subsubsection((* endblock h4 -*))
 ((* block h5 -*))paragraph((* endblock h5 -*))
 ((* block h6 -*))subparagraph((* endblock h6 -*))
 
 % Diasble table of contents for howto
 ((* block toc *))
 ((* endblock toc *))

nbconvert/templates/latex/sphinx_manual.tplx

@@ -1,21 +1,21 b''
 ((============================================================================
   NBConvert Sphinx-Latex Manual Template
 
   Purpose: Allow export of PDF friendly Latex inspired by Sphinx Manual 
            document style.  Most of the is derived directly from Sphinx source.
 
   Inheritance: null>display_priority>latex_base->latex_sphinx_base 
 
   ==========================================================================))
 
-((*- extends 'latex_sphinx_base.tplx' -*))
+((*- extends 'sphinx_base.tplx' -*))
 
 ((* set parentdocumentclass = 'report' *))
 ((* set documentclass = 'manual' *))
 
 ((* block h1 -*))part((* endblock h1 -*))
 ((* block h2 -*))chapter((* endblock h2 -*))
 ((* block h3 -*))section((* endblock h3 -*))
 ((* block h4 -*))subsection((* endblock h4 -*))
 ((* block h5 -*))subsubsection((* endblock h5 -*))
 ((* block h6 -*))paragraph((* endblock h6 -*))

nbconvert/templates/skeleton/null.tpl

@@ -1,91 +1,91 b''
 {#
 
 DO NOT USE THIS AS A BASE WORK,
 IF YOU ARE COPY AND PASTING THIS FILE
 YOU ARE PROBABLY DOING THINGS WRONG.
 
 Null template, Does nothing except defining a basic structure
 To layout the different blocks of a notebook.
 
 Subtemplates can override blocks to define their custom representation.
 
 If one of the block you do overwrite is not a leave block, consider
 calling super.
 
 {%- block nonLeaveBlock -%}
     #add stuff at beginning
     {{ super() }}
     #add stuff at end
 {%- endblock nonLeaveBlock -%}
 
 consider calling super even if it is a leave block, we might insert more blocks later.
 
 #}
 {%- block header -%}
 {%- endblock header -%}
 {%- block body -%}
 {%- for worksheet in nb.worksheets -%}
     {%- for cell in worksheet.cells -%}
         {%- block any_cell scoped -%}
-            {%- if cell.type in ['code'] -%}
+            {%- if cell.cell_type in ['code'] -%}
                 {%- block codecell scoped -%}
                     {%- block input_group -%}
                         {%- block in_prompt -%}{%- endblock in_prompt -%}
                         {%- block input -%}{%- endblock input -%}
                     {%- endblock input_group -%}
                     {%- if cell.outputs -%}
                     {%- block output_group -%}
                         {%- block output_prompt -%}{%- endblock output_prompt -%}
                         {%- block outputs scoped -%}
                             {%- for output in cell.outputs -%}
                                 {%- block output scoped -%}
                                     {%- if output.output_type in ['pyout'] -%}
                                         {%- block pyout scoped -%}{%- endblock pyout -%}
                                     {%- elif output.output_type in ['stream'] -%}
                                         {%- block stream scoped -%}
                                             {%- if output.stream in ['stdout'] -%}
                                                 {%- block stream_stdout scoped -%}
                                                 {%- endblock stream_stdout -%}
                                             {%- elif output.stream in ['stderr'] -%}
                                                 {%- block stream_stderr scoped -%}
                                                 {%- endblock stream_stderr -%}
                                             {%- endif -%}
                                         {%- endblock stream -%}
                                     {%- elif output.output_type in ['display_data'] -%}
                                         {%- block display_data scoped -%}
                                             {%- block data_priority scoped -%}
                                             {%- endblock data_priority -%}
                                         {%- endblock display_data -%}
                                     {%- elif output.output_type in ['pyerr'] -%}
                                         {%- block pyerr scoped -%}
                                         {%- for line in output.traceback -%}
                                             {%- block traceback_line scoped -%}{%- endblock traceback_line -%}
                                         {%- endfor -%}
                                         {%- endblock pyerr -%}
                                     {%- endif -%}
                                 {%- endblock output -%}
                             {%- endfor -%}
                         {%- endblock outputs -%}
                     {%- endblock output_group -%}
                     {%- endif -%}
                 {%- endblock codecell -%}
-            {%- elif cell.type in ['markdown'] -%}
+            {%- elif cell.cell_type in ['markdown'] -%}
                 {%- block markdowncell scoped-%}
                 {%- endblock markdowncell -%}
-            {%- elif cell.type in ['heading'] -%}
+            {%- elif cell.cell_type in ['heading'] -%}
                 {%- block headingcell scoped-%}
                 {%- endblock headingcell -%}
-            {%- elif cell.type in ['raw'] -%}
+            {%- elif cell.cell_type in ['raw'] -%}
                 {%- block rawcell scoped-%}
                 {%- endblock rawcell -%}
             {%- else -%}
                 {%- block unknowncell scoped-%}
                 {%- endblock unknowncell -%}
             {%- endif -%}
         {%- endblock any_cell -%}
     {%- endfor -%}
 {%- endfor -%}
 {%- endblock body -%}
 
 {%- block footer -%}
 {%- endblock footer -%}

nbconvert/transformers/activatable.py

@@ -1,19 +1,19 b''
 from .base import ConfigurableTransformer
 from IPython.utils.traitlets import (Bool)
 
 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)
+    enabled = Bool(True, config=True)
 
     def __call__(self, nb, other):
         if not self.enabled :
             return nb, other
         else :
             return super(ActivatableTransformer, self).__call__(nb, other)