correct depth for configurable

nbconvert/exporters/latex.py

@@ -1,106 +1,111 b''
 """
 Exporter that allows Latex Jinja templates to work.  Contains logic to
 appropriately prepare IPYNB files for export to LaTeX.  Including but 
 not limited to escaping LaTeX, fixing math region tags, using special
 tags to circumvent Jinja/Latex syntax conflicts.
 """
 #-----------------------------------------------------------------------------
 # 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
 #-----------------------------------------------------------------------------
 
 # IPython imports
 from IPython.utils.traitlets import Unicode
 from IPython.config import Config
 
 # other libs/dependencies
 import nbconvert.filters.latex
 import nbconvert.filters.highlight
 from nbconvert.transformers.latex import LatexTransformer
 
 # local import
 import exporter
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 class LatexExporter(exporter.Exporter):
     """
     Exports to a Latex template.  Inherit from this class if your template is
     LaTeX based and you need custom tranformers/filters.  Inherit from it if 
     you are writing your own HTML template and need custom tranformers/filters.  
     If you don't need custom tranformers/filters, just change the 
     'template_file' config option.  Place your template in the special "/latex" 
     subfolder of the "../templates" folder.
     """
     
     file_extension = Unicode(
         'tex', config=True, 
         help="Extension of the file that should be written to disk")
 
     template_file = Unicode(
         'base', config=True,
         help="Name of the template file to use")
 
     #Latex constants
     template_path = Unicode(
         "/../templates/latex/", config=True,
         help="Path where the template files are located.")
 
     template_skeleton_path = Unicode(
         "/../templates/latex/skeleton/", config=True,
         help="Path where the template skeleton files are located.") 
 
     #Special Jinja2 syntax that will not conflict when exporting latex.
     jinja_comment_block_start = Unicode("((=", config=True)
     jinja_comment_block_end = Unicode("=))", config=True)
     jinja_variable_block_start = Unicode("(((", config=True)
     jinja_variable_block_end = Unicode(")))", config=True)
     jinja_logic_block_start = Unicode("((*", config=True)
     jinja_logic_block_end = Unicode("*))", config=True)
     
     #Extension that the template files use.    
     template_extension = Unicode(".tplx", config=True)
 
     def _register_filters(self):
         """
         Register all of the filters required for the exporter.
         """
         
         #Register the filters of the base class.
         super(LatexExporter, self)._register_filters()
 
         #Add latex filters to the Jinja2 environment
         self.register_filter('escape_tex', nbconvert.filters.latex.escape_latex) 
         self.register_filter('highlight', nbconvert.filters.highlight.highlight2latex) 
     
     
     def _register_transformers(self):
         """
         Register all of the transformers needed for this exporter.
         """
         
         #Register the transformers of the base class.
         super(LatexExporter, self)._register_transformers()
         
         #Register latex transformer
         self.register_transformer(LatexTransformer)
 
     @property
     def default_config(self):
         c = Config({
-             'display_data_priority' : ['latex', 'svg', 'png', 'jpg', 'jpeg' , 'text'],
+            'GlobalConfigurable': {
+                'display_data_priority' : ['latex', 'svg', 'png', 'jpg', 'jpeg' , 'text']
+                },
+             'ExtractFigureTransformer': {
+                    'enabled':True,
              'extra_ext_map':{'svg':'pdf'},
-             'ExtractFigureTransformer' : Config({'enabled':True})
+                 
+                 }
          })
         c.merge(super(LatexExporter,self).default_config)
         return c
 

nbconvert/transformers/extractfigure.py

@@ -1,145 +1,145 b''
 """Module containing a transformer that extracts all of the figures from the
 notebook file.  The extracted figures are returned in the 'resources' dictionary.
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 import itertools
 
 from IPython.utils.traitlets import (Dict, List, Unicode)
 from .activatable import ActivatableTransformer
 
 #-----------------------------------------------------------------------------
 # Constants
 #-----------------------------------------------------------------------------
 
 FIGURES_KEY = "figures"
 BINARY_KEY = "binary"
 TEXT_KEY = "text"
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class ExtractFigureTransformer(ActivatableTransformer):
     """
     Extracts all of the figures from the notebook file.  The extracted 
     figures are returned in the 'resources' dictionary.
     """
 
     extra_extension_map =  Dict({},
         config=True,
         help="""Extra map to override extension based on type.
         Useful for latex where SVG will be converted to PDF before inclusion
         """)
     
     key_format_map =  Dict({}, config=True,)
     figure_name_format_map =  Dict({}, config=True)
 
-    display_data_priority = List(['svg', 'png', 'latex', 'jpg', 'jpeg','text'])
+    #display_data_priority = List(['svg', 'png', 'latex', 'jpg', 'jpeg','text'])
 
     #TODO: Change this to .format {} syntax
     default_key_template = Unicode('_fig_{index:02d}.{ext}', config=True)
 
     def __init__(self, config=None, **kw):
         """
         Public constructor
         
         Parameters
         ----------
         config : Config
             Configuration file structure
         **kw : misc
             Additional arguments
         """
 
         super(ExtractFigureTransformer, self).__init__(config=config, **kw)
 
         # A unique index for association with extracted figures
         self.index_generator = itertools.count(1)
 
     def cell_transform(self, cell, resources, index):
         """
         Apply a transformation on each cell,
         
         Parameters
         ----------
         cell : NotebookNode cell
             Notebook cell being processed
         resources : dictionary
             Additional resources used in the conversion process.  Allows
             transformers to pass variables into the Jinja engine.
         index : int
             Index of the cell being processed (see base.py)
         """
         
         if resources.get(FIGURES_KEY, None) is None :
             resources[FIGURES_KEY] = {TEXT_KEY:{},BINARY_KEY:{}}
             
         for out in cell.get('outputs', []):
             for out_type in self.display_data_priority:
                 
                 if out.hasattr(out_type):
                     figname, key, data, binary = self._new_figure(out[out_type], out_type)
                     out['key_'+out_type] = figname
                     
                     if binary :
                         resources[FIGURES_KEY][BINARY_KEY][key] = data
                     else :
                         resources[FIGURES_KEY][TEXT_KEY][key] = data
                         
                     index += 1
         return cell, resources
 
 
     def _get_override_extension(self, extension):
         """Gets the overriden extension if it exists, else returns extension. 
 
         Parameters
         ----------
         extension : str
             File extension.
         """
         
         if extension in self.extra_extension_map :
             return self.extra_extension_map[extension]
     
         return extension
 
 
     def _new_figure(self, data, format):
         """Create a new figure file in the given format.
 
         Parameters
         ----------
         data : str
             Cell data (from Notebook node cell)
         format : str
             Figure format
         index : int
             Index of the figure being extracted
         """
         
         figure_name_template = self.figure_name_format_map.get(format, self.default_key_template)
         key_template = self.key_format_map.get(format, self.default_key_template)
         
         #TODO: option to pass the hash as data?
         index = next(self.index_generator)
         figure_name = figure_name_template.format(index=index, ext=self._get_override_extension(format))
         key = key_template.format(index=index, ext=self._get_override_extension(format))
 
         #Binary files are base64-encoded, SVG is already XML
         binary = False
         if format in ('png', 'jpg', 'pdf'):
             data = data.decode('base64')
             binary = True
 
         return figure_name, key, data, binary