create an activatable transformer classes

those are no-op by default

converters/transformers.py

@@ -1,236 +1,239 b''
 """
 
 """
 
 from __future__ import print_function
 
 from IPython.config.configurable import Configurable
 from IPython.utils.traitlets import Unicode, Bool, Dict, List
 
 class ConfigurableTransformers(Configurable):
     """ A configurable transformer """
 
     def __init__(self, config=None, **kw):
         super(ConfigurableTransformers, self).__init__(config=config, **kw)
 
     def __call__(self, nb, other):
         try :
             for worksheet in nb.worksheets :
                 for index, cell in enumerate(worksheet.cells):
                     worksheet.cells[index], other = self.cell_transform(cell, other, index)
             return nb, other
         except NotImplementedError as error :
             raise NotImplementedError('should be implemented by subclass')
 
     def cell_transform(self, cell, other, index):
         """
         Overwrite if you want to apply a transformation on each cell
         """
         raise NotImplementedError('should be implemented by subclass')
 
 
-class Foobar(ConfigurableTransformers):
-    message = Unicode('-- nothing', config=True)
+class ActivatableTransformer(ConfigurableTransformers):
 
+    active = Bool(False, config=True)
 
-    def cell_transform(self, cell, other, index):
-        return cell, other
+    def __call__(self, nb, other):
+        if not self.active :
+            return nb,other
+        else :
+            return super(ActivatableTransformer,self).__call__(nb, other)
 
 
 def cell_preprocessor(function):
     """ wrap a function to be executed on all cells of a notebook
 
     wrapped function  parameters :
     cell  : the cell
     other : external resources
     index : index of the cell
     """
     def wrappedfunc(nb, other):
         for worksheet in nb.worksheets :
             for index, cell in enumerate(worksheet.cells):
                 worksheet.cells[index], other = function(cell, other, index)
         return nb, other
     return wrappedfunc
 
 
 @cell_preprocessor
 def haspyout_transformer(cell, other, count):
     """
     Add a haspyout flag to cell that have it
 
     Easier for templating, where you can't know in advance
     wether to write the out prompt
 
     """
     cell.type = cell.cell_type
     cell.haspyout = False
     for out in cell.get('outputs', []):
         if out.output_type == 'pyout':
             cell.haspyout = True
             break
     return cell, other
 
 
 # todo, make the key part configurable.
 
-class ExtractFigureTransformer(ConfigurableTransformers):
+class ExtractFigureTransformer(ActivatableTransformer):
     enabled = Bool(False,
             config=True,
             help=""" If set to false, this transformer will be no-op """
             )
 
     extra_ext_map =  Dict({},
             config=True,
             help="""extra map to override extension based on type.
             Usefull for latex where svg will be converted to pdf before inclusion
             """
             )
     display_data_priority = List(['html', 'pdf', 'svg', 'latex', 'png', 'jpg', 'jpeg' , 'text'],
             config=True,
               help= """
                     An ordered list of prefered output type, the first
                     encounterd will usually be used when converting discarding
                     the others.
                     """
             )
 
 
     #to do change this to .format {} syntax
     key_tpl = Unicode('_fig_%02i.%s', config=True)
 
     def _get_ext(self, ext):
         if ext in self.extra_ext_map :
             return self.extra_ext_map[ext]
         return ext
 
     def _new_figure(self, data, fmt, count):
         """Create a new figure file in the given format.
 
         Returns a path relative to the input file.
         """
         figname = self.key_tpl % (count, self._get_ext(fmt))
         key     = self.key_tpl % (count, fmt)
 
         # Binary files are base64-encoded, SVG is already XML
         if fmt in ('png', 'jpg', 'pdf'):
             data = data.decode('base64')
 
         return figname, key, data
 
 
     def cell_transform(self, cell, other, count):
         if not self.enabled:
             return cell, other
         if other.get('figures',None) is None :
             other['figures']={}
         for i, out in enumerate(cell.get('outputs', [])):
             for type in self.display_data_priority:
                 if out.hasattr(type):
                     figname, key, data = self._new_figure(out[type], type, count)
                     out['key_'+type] = figname
                     other['figures'][key] = data
                     count = count+1
         return cell, other
 
 class RevealHelpTransformer(ConfigurableTransformers):
 
     section_open = False
     subsection_open = False
     fragment_open = False
 
     def open_subsection(self):
         self.subsection_open = True
         return True
 
     def open_section(self):
         self.section_open = True
         return True
 
     def open_fragment(self):
         self.fragment_open = True
         return True
 
     # could probaly write those maybe_close/open
     # with a function functor
     def maybe_close_section(self):
         """return True is already open, false otherwise
         and change state to close
         """
         if self.section_open :
             self.section_open = False
             return True
         else :
             return False
 
     def maybe_open_section(self):
         """return True is already open, false otherwise
         and change state to close
         """
         if not self.section_open :
             self.section_open = True
             return True
         else :
             return False
 
     def maybe_open_subsection(self):
         """return True is already open, false otherwise
         and change state to close
         """
         if not self.subsection_open :
             self.subsection_open = True
             return True
         else :
             return False
 
     def maybe_close_subsection(self):
         """return True is already open, false otherwise
         and change state to close
         """
         if self.subsection_open :
             self.subsection_open = False
             return True
         else :
             return False
 
     def maybe_close_fragment(self):
         """return True is already open, false otherwise
         and change state to close
         """
         if self.fragment_open :
             self.fragment_open = False
             return True
         else :
             return False
 
     def cell_transform(self, cell, other,count):
         ctype = cell.metadata.get('slideshow',{}).get('slide_type',None)
         if ctype in [None, '-'] :
             cell.metadata.slideshow = {}
             cell.metadata.slideshow['slide_type'] = None
         elif ctype == 'fragment':
             cell.metadata.slideshow.close_fragment = self.maybe_close_fragment()
             cell.metadata.slideshow.close_subsection = False
             cell.metadata.slideshow.close_section = False
 
             cell.metadata.slideshow.open_section = self.maybe_open_section()
             cell.metadata.slideshow.open_subsection = self.maybe_open_subsection()
             cell.metadata.slideshow.open_fragment = self.open_fragment()
 
         elif ctype == 'subslide':
             cell.metadata.slideshow.close_fragment = self.maybe_close_fragment()
             cell.metadata.slideshow.close_subsection = self.maybe_close_subsection()
             cell.metadata.slideshow.close_section = False
 
             cell.metadata.slideshow.open_section = self.maybe_open_section()
             cell.metadata.slideshow.open_subsection = self.open_subsection()
             cell.metadata.slideshow.open_fragment = False
         elif ctype == 'slide':
             cell.metadata.slideshow.close_fragment = self.maybe_close_fragment()
             cell.metadata.slideshow.close_subsection = self.maybe_close_subsection()
             cell.metadata.slideshow.close_section = self.maybe_close_section()
 
             cell.metadata.slideshow.open_section = self.open_section()
             cell.metadata.slideshow.open_subsection = self.open_subsection()
             cell.metadata.slideshow.open_fragment = False
         return cell,other
 

runme.py

@@ -1,136 +1,135 b''
 #!/usr/bin/env python
 """
 ================================================================================
 
 |,---.     |    |                 ,   .|                                   |
 ||---',   .|--- |---.,---.,---.   |\  ||---.,---.,---.,---..    ,,---.,---.|---
 ||    |   ||    |   ||   ||   |   | \ ||   ||    |   ||   | \  / |---'|    |
 ``    `---|`---'`   '`---'`   '   `  `'`---'`---'`---'`   '  `'  `---'`    `---'
       `---'
 ================================================================================
 
 Highly experimental for now
 
 """
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 from __future__ import print_function
 import sys
 import io
 import os
 
 from converters.template import *
 from converters.template import ConverterTemplate
 from converters.html import ConverterHTML
 # From IPython
 
 # All the stuff needed for the configurable things
 from IPython.config.application import Application
 from IPython.config.loader import ConfigFileNotFound
 from IPython.utils.traitlets import List, Unicode, Type, Bool, Dict, CaselessStrEnum
 
-from converters.transformers import (ConfigurableTransformers,Foobar,ExtractFigureTransformer)
+from converters.transformers import (ConfigurableTransformers,ExtractFigureTransformer)
 
 
 class NbconvertApp(Application):
 
     stdout = Bool(True, config=True)
     write = Bool(False, config=True)
 
     fileext = Unicode('txt', config=True)
 
     aliases = {
             'stdout':'NbconvertApp.stdout',
             'write':'NbconvertApp.write',
             }
 
     flags= {}
     flags['no-stdout'] = (
         {'NbconvertApp' : {'stdout' : False}},
     """the doc for this flag
 
     """
     )
 
     def __init__(self, **kwargs):
         super(NbconvertApp, self).__init__(**kwargs)
         self.classes.insert(0,ConverterTemplate)
         # register class here to have help with help all
         self.classes.insert(0,ExtractFigureTransformer)
-        self.classes.insert(0,Foobar)
         # ensure those are registerd
 
     def load_config_file(self, profile_name):
         try:
             Application.load_config_file(
                 self,
                 profile_name+'.nbcv',
                 path=[os.path.join(os.getcwdu(),'profile')]
             )
         except ConfigFileNotFound:
             self.log.warn("Config file for profile '%s' not found, giving up ",profile_name)
             exit(1)
 
 
     def initialize(self, argv=None):
         self.parse_command_line(argv)
         cl_config = self.config
         profile_file = sys.argv[1]
         self.load_config_file(profile_file)
         self.update_config(cl_config)
 
 
 
     def run(self):
         """Convert a notebook to html in one step"""
         template_file = (self.extra_args or [None])[0]
         ipynb_file = (self.extra_args or [None])[1]
 
         template_file = sys.argv[1]
 
         C = ConverterTemplate(config=self.config)
 
         output,resources = C.from_filename(ipynb_file)
         if self.stdout :
             print(output.encode('utf-8'))
 
         out_root = ipynb_file[:-6].replace('.','_').replace(' ','_')
 
         keys = resources.get('figures',{}).keys()
         if self.write :
             with io.open(os.path.join(out_root+'.'+self.fileext),'w') as f:
                         f.write(output)
         if keys :
             if self.write and not os.path.exists(out_root+'_files'):
                 os.mkdir(out_root+'_files')
             for key in keys:
                 if self.write:
                     with io.open(os.path.join(out_root+'_files',key),'wb') as f:
                         print(' writing to ',os.path.join(out_root,key))
                         f.write(resources['figures'][key])
             if self.stdout:
                 print('''
 ====================== Keys in Resources ==================================
 ''')
                 print(resources['figures'].keys())
                 print("""
 ===========================================================================
 you are responsible from writing those data do a file in the right place if
 they need to be.
 ===========================================================================
                   """)
 
 def main():
     """Convert a notebook to html in one step"""
     app = NbconvertApp.instance()
     app.description = __doc__
     app.initialize()
     app.start()
     app.run()
 #-----------------------------------------------------------------------------
 # Script main
 #-----------------------------------------------------------------------------
 
 if __name__ == '__main__':
     main()