pylint

converters/template.py

@@ -1,224 +1,223 b''
 """Base classes for the notebook conversion pipeline.
 
 This module defines ConverterTemplate, a highly configurable converter
 that uses Jinja2 to convert notebook files into different format.
 
 You can register both pre-transformers that will act on the notebook format
 befor conversion and jinja filter that would then be availlable in the templates
 """
 #-----------------------------------------------------------------------------
 # 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
 
 # IPython imports
 from IPython.utils.traitlets import MetaHasTraits
 from IPython.utils.traitlets import (Unicode, List, Bool)
 from IPython.config.configurable import Configurable
 from IPython.nbformat import current as nbformat
 
 # other libs/dependencies
 from jinja2 import Environment, FileSystemLoader
 
 
 # local import (pre-transformers)
 import converters.transformers as trans
 
 # some jinja filters
 from converters.jinja_filters import (python_comment, indent,
         rm_fake, remove_ansi, markdown, highlight,
         ansi2html, markdown2latex, escape_tex, FilterDataType)
 
 from converters.utils import  markdown2rst
-from converters.config import  GlobalConfigurable
 
 
 
 # define differents environemnt with different
 # delimiters not to conflict with languages inside
 
 env = Environment(
         loader=FileSystemLoader([
             './templates/',
             './templates/skeleton/',
             ]),
         extensions=['jinja2.ext.loopcontrols']
         )
 
 texenv = Environment(
         loader=FileSystemLoader([
             './templates/tex/',
             './templates/skeleton/tex/',
             ]),
         extensions=['jinja2.ext.loopcontrols']
         )
 
 
 texenv.block_start_string = '((*'
 texenv.block_end_string = '*))'
 
 texenv.variable_start_string = '((('
 texenv.variable_end_string = ')))'
 
 texenv.comment_start_string = '((='
 texenv.comment_end_string = '=))'
 
 texenv.filters['escape_tex'] = escape_tex
 
 #-----------------------------------------------------------------------------
 # Class declarations
 #-----------------------------------------------------------------------------
 class ConversionException(Exception):
     pass
 
 class ConverterTemplate(Configurable):
     """ A Jinja2 base converter templates
 
     Preprocess the ipynb files, feed it throug jinja templates,
     and spit an converted files and a data object with other data
 
     shoudl be mostly configurable
     """
 
     pre_transformer_order = List(['haspyout_transformer'],
             config=True,
               help= """
                     An ordered list of pre transformer to apply to the ipynb
                     file befor running through templates
                     """
             )
 
     tex_environement = Bool(False,
             config=True,
             help=""" is this a tex environment or not """)
 
     template_file = Unicode('',
             config=True,
             help=""" Name of the template file to use """ )
     #-------------------------------------------------------------------------
     # Instance-level attributes that are set in the constructor for this
     # class.
     #-------------------------------------------------------------------------
 
 
     preprocessors = []
 
     def __init__(self, preprocessors={}, jinja_filters={}, config=None, **kw):
         """ Init a new converter.
 
         config: the Configurable config object to pass around.
 
         preprocessors: dict of **availlable** 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
                        availlable 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 availlable by default.
         """
         super(ConverterTemplate, self).__init__(config=config, **kw)
 
         # variable parameters depending on the pype of jinja environement
         self.env = texenv  if self.tex_environement else env
         self.ext = '.tplx' if self.tex_environement else '.tpl'
 
         for name in self.pre_transformer_order:
             # get the user-defined transformer first
             transformer = getattr(preprocessors, name, getattr(trans, name, None))
             if isinstance(transformer, MetaHasTraits):
                 transformer = transformer(config=config)
             self.preprocessors.append(transformer)
 
         ## for compat, remove later
         self.preprocessors.append(trans.coalesce_streams)
         self.preprocessors.append(trans.ExtractFigureTransformer(config=config))
         self.preprocessors.append(trans.RevealHelpTransformer(config=config))
         self.preprocessors.append(trans.CSSHtmlHeaderTransformer(config=config))
 
         ##
         self.env.filters['filter_data_type'] = FilterDataType(config=config)
         self.env.filters['pycomment'] = python_comment
         self.env.filters['indent'] = indent
         self.env.filters['rm_fake'] = rm_fake
         self.env.filters['rm_ansi'] = remove_ansi
         self.env.filters['markdown'] = markdown
         self.env.filters['highlight'] = highlight
         self.env.filters['ansi2html'] = ansi2html
         self.env.filters['markdown2latex'] = markdown2latex
         self.env.filters['markdown2rst'] = markdown2rst
 
         ## user  filter will overwrite
         for key, filtr in jinja_filters.iteritems():
             if isinstance(filtr, MetaHasTraits):
                 self.env.filters[key] = filtr(config=config)
             else :
                 self.env.filters[key] = filtr
 
         self.template = self.env.get_template(self.template_file+self.ext)
 
 
     def process(self, nb):
         """
         preprocess the notebook json for easier use with the templates.
         will call all the `preprocessor`s in order before returning it.
         """
 
         # dict of 'resources' that could be made by the preprocessors
         # like key/value data to extract files from ipynb like in latex conversion
         resources = {}
 
         for preprocessor in self.preprocessors:
             nb, resources = preprocessor(nb, resources)
 
         return nb, resources
 
     def convert(self, nb):
         """ convert the ipynb file
 
         return both the converted ipynb file and a dict containing potential
         other resources
         """
         nb, resources = self.process(nb)
         return self.template.render(nb=nb, resources=resources), resources
 
 
     def from_filename(self, filename):
         """read and convert a notebook from a file name"""
         with io.open(filename) as f:
             return self.convert(nbformat.read(f, 'json'))
 
     def from_file(self, filelike):
         """read and convert a notebook from a filelike object
 
         filelike object will just be "read" and should be json format..
         """
         return self.convert(nbformat.read(filelike, 'json'))
 
     def from_json(self, json):
         """ not implemented
 
         Should convert from a json object
         """
         raise NotImplementedError('not implemented (yet?)')
 

converters/transformers.py

@@ -1,271 +1,271 b''
 """
 Module that regroups transformer that woudl be applied to ipynb files
 before going through the templating machinery.
 
 It exposes convenient classes to inherit from to access configurability
 as well as decorator to simplify tasks.
 """
 
 from __future__ import print_function
 
 from IPython.config.configurable import Configurable
 from IPython.utils.traitlets import Unicode, Bool, Dict, List
 
 from converters.config import GlobalConfigurable
 
 class ConfigurableTransformers(GlobalConfigurable):
     """ A configurable transformer
 
     Inherit from this class if you wish to have configurability for your
     transformer.
 
     Any configurable traitlets this class exposed will be configurable in profiles
     using c.SubClassName.atribute=value
 
     you can overwrite cell_transform to apply a transformation independently on each cell
     or __call__ if you prefer your own logic. See orresponding docstring for informations.
 
 
     """
 
     def __init__(self, config=None, **kw):
         super(ConfigurableTransformers, self).__init__(config=config, **kw)
 
     def __call__(self, nb, other):
         """transformation to apply on each notebook.
 
         received a handle to the current notebook as well as a dict of resources
         which structure depends on the transformer.
 
         You should return modified nb, other.
 
         If you wish to apply on each cell, you might want to overwrite cell_transform method.
         """
         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:
             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,
 
         receive the current cell, the resource dict and the index of current cell as parameter.
 
         You should return modified cell and resource dict.
         """
         raise NotImplementedError('should be implemented by subclass')
         return cell, other
 
 
 class ActivatableTransformer(ConfigurableTransformers):
     """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)
 
     def __call__(self, nb, other):
         if not self.enabled :
             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
 
 @cell_preprocessor
 def coalesce_streams(cell, other, count):
     """merge consecutive sequences of stream output into single stream
 
     to prevent extra newlines inserted at flush calls
 
     TODO: handle \r deletion
     """
     outputs = cell.get('outputs', [])
     if not outputs:
         return cell, other
     new_outputs = []
     last = outputs[0]
     new_outputs = [last]
     for output in outputs[1:]:
         if (output.output_type == 'stream' and
             last.output_type == 'stream' and
             last.stream == output.stream
         ):
             last.text += output.text
         else:
             new_outputs.append(output)
 
     cell.outputs = new_outputs
     return cell, other
 
 class ExtractFigureTransformer(ActivatableTransformer):
 
 
     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
             """
             )
 
     key_format_map =  Dict({},
             config=True,
             )
 
     figname_format_map =  Dict({},
             config=True,
             )
 
 
     #to do change this to .format {} syntax
     default_key_tpl = Unicode('_fig_{count:02d}.{ext}', 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.
 
         """
-        tplf = self.figname_format_map.get(fmt,self.default_key_tpl)
-        tplk = self.key_format_map.get(fmt,self.default_key_tpl)
+        tplf = self.figname_format_map.get(fmt, self.default_key_tpl)
+        tplk = self.key_format_map.get(fmt, self.default_key_tpl)
 
         # option to pass the hash as data ?
         figname = tplf.format(count=count, ext=self._get_ext(fmt))
         key     = tplk.format(count=count, ext=self._get_ext(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 other.get('figures', None) is None :
             other['figures'] = {}
         for out in cell.get('outputs', []):
             for out_type in self.display_data_priority:
                 if out.hasattr(out_type):
                     figname, key, data = self._new_figure(out[out_type], out_type, count)
                     out['key_'+out_type] = figname
                     other['figures'][key] = data
                     count = count+1
         return cell, other
 
 
 class RevealHelpTransformer(ConfigurableTransformers):
 
     def __call__(self, nb, other):
         for worksheet in nb.worksheets :
             for i, cell in enumerate(worksheet.cells):
                 cell.metadata.slide_type = cell.metadata.get('slideshow', {}).get('slide_type', None)
                 if cell.metadata.slide_type is None:
                     cell.metadata.slide_type = '-'
                 if cell.metadata.slide_type in ['slide']:
                     worksheet.cells[i - 1].metadata.slide_helper = 'slide_end'
                 if cell.metadata.slide_type in ['subslide']:
                     worksheet.cells[i - 1].metadata.slide_helper = 'subslide_end'
         return nb, other
 
 
 class CSSHtmlHeaderTransformer(ActivatableTransformer):
 
     def __call__(self, nb, resources):
         """Fetch and add css to the resource dict
 
         Fetch css from IPython adn Pygment to add at the beginning
         of the html files.
 
         Add this css in resources in the "inlining.css" key
         """
         resources['inlining'] = {}
         resources['inlining']['css'] = self.header
         return nb, resources
 
     header = []
 
     def __init__(self, config=None, **kw):
         super(CSSHtmlHeaderTransformer, self).__init__(config=config, **kw)
         if self.enabled :
             self.regen_header()
 
     def regen_header(self):
         ## lazy load asa this might not be use in many transformers
         import os
         from IPython.utils import path
         import io
         from pygments.formatters import HtmlFormatter
         header = []
         static = os.path.join(path.get_ipython_package_dir(),
             'frontend', 'html', 'notebook', 'static',
         )
         here = os.path.split(os.path.realpath(__file__))[0]
         css = os.path.join(static, 'css')
         for sheet in [
             # do we need jquery and prettify?
             # os.path.join(static, 'jquery', 'css', 'themes', 'base',
             # 'jquery-ui.min.css'),
             # os.path.join(static, 'prettify', 'prettify.css'),
             os.path.join(css, 'boilerplate.css'),
             os.path.join(css, 'fbm.css'),
             os.path.join(css, 'notebook.css'),
             os.path.join(css, 'renderedhtml.css'),
             os.path.join(css, 'style.min.css'),
             # our overrides:
             os.path.join(here, '..', 'css', 'static_html.css'),
         ]:
             try:
                 with io.open(sheet, encoding='utf-8') as f:
                     s = f.read()
                     header.append(s)
             except IOError:
                 # new version of ipython with style.min.css, pass
                 pass
 
         pygments_css = HtmlFormatter().get_style_defs('.highlight')
         header.append(pygments_css)
         self.header = header