move html header out

converters/template.py

@@ -1,230 +1,187 b''
 """Base classes for the notebook conversion pipeline.
 
 This module defines Converter, from which all objects designed to implement
 a conversion of IPython notebooks to some other format should inherit.
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2012, 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
 import converters.transformers as trans
 from converters.jinja_filters import (python_comment, indent,
         rm_fake, remove_ansi, markdown, highlight,
         ansi2html, markdown2latex, escape_tex, FilterDataType)
 
 from converters.utils import  markdown2rst
 
 
 
 # Stdlib imports
 import io
-import os
-from IPython.utils import path
+
 from IPython.utils.traitlets import MetaHasTraits
 
 from jinja2 import Environment, FileSystemLoader
 env = Environment(
         loader=FileSystemLoader([
             './templates/',
             './templates/skeleton/',
             ]),
         extensions=['jinja2.ext.loopcontrols']
         )
 
 texenv = Environment(
         loader=FileSystemLoader([
             './templates/tex/',
             './templates/skeleton/tex/',
             ]),
         extensions=['jinja2.ext.loopcontrols']
         )
 
 # IPython imports
 from IPython.nbformat import current as nbformat
 from IPython.config.configurable import Configurable
 from IPython.utils.traitlets import ( Unicode, Any, List, Bool)
 
 #-----------------------------------------------------------------------------
 # Class declarations
 #-----------------------------------------------------------------------------
 class ConversionException(Exception):
     pass
 
-#todo move this out
-def header_body():
-    """Return the body of the header as a list of strings."""
-
-    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)
-    return header
-
-
-
-
-
-inlining = {}
-inlining['css'] = header_body()
-
 
 
 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 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 confgg object to pass around
 
         preprocessors: dict of **availlable** key/value function to run on
         ipynb json data before conversion to extract/inline file,
 
         jinja_filter : 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.
 
         """
         super(ConverterTemplate, self).__init__(config=config, **kw)
         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:
             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.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
         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, inlining=inlining), resources
+        return self.template.render(nb=nb, resources=resources), resources
 
 
     def from_filename(self, filename):
         "read and parse notebook into NotebookNode called self.nb"
         with io.open(filename) as f:
             return self.convert(nbformat.read(f, 'json'))
 
 
+

converters/transformers.py

@@ -1,225 +1,293 b''
 """
 
 """
 
-from __future__ import print_function, absolute_import
+from __future__ import print_function
+
 
 from IPython.config.configurable import Configurable
 from IPython.utils.traitlets import Unicode, Bool, Dict, List
-from .jinja_filters import GlobalConfigurable
 
-class ConfigurableTransformers(GlobalConfigurable):
+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 ActivatableTransformer(ConfigurableTransformers):
 
     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
 
 
 # todo, make the key part configurable.
 
 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
             """
             )
+    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 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
 
+
+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
+

profile/base_html.nbcv

@@ -1,10 +1,11 b''
 c = get_config()
 
 
 c.ConverterTemplate.extract_figures=False
 c.ConverterTemplate.template_file='basichtml'
 c.ConverterTemplate.tex_environement=False
 
 c.NbconvertApp.fileext='html'
 
 c.ExtractFigureTransformer.enabled = False
+c.CSSHtmlHeaderTransformer.enabled=True

profile/full_html.nbcv

@@ -1,9 +1,5 b''
 c = get_config()
-
+load_subconfig('base_html.nbcv')
 
 c.ConverterTemplate.template_file='fullhtml'
-c.ConverterTemplate.tex_environement=False
-
-c.NbconvertApp.fileext='html'
 
-c.ExtractFigureTransformer.enabled = False

templates/fullhtml.tpl

@@ -1,46 +1,46 b''
 {%- extends 'basichtml.tpl' -%}
 
 {%- block header -%}<!DOCTYPE html>
 <html>
 <head>
 <meta charset="UTF-8">
 <title>[{{nb.metadata.name}}]</title>
-{% for css in inlining.css -%}
+{% for css in resources.inlining.css -%}
 <style type="text/css">
 {{css}}
 </style>
 {% endfor %}
 <script src="https://c328740.ssl.cf1.rackcdn.com/mathjax/latest/MathJax.js?config=TeX-AMS_HTML" type="text/javascript">
 
 </script>
 <script type="text/javascript">
 init_mathjax = function() {
     if (window.MathJax) {
         // MathJax loaded
         MathJax.Hub.Config({
             tex2jax: {
                 inlineMath: [ ['$','$'], ["\\(","\\)"] ],
                 displayMath: [ ['$$','$$'], ["\\[","\\]"] ]
             },
             displayAlign: 'left', // Change this to 'center' to center equations.
             "HTML-CSS": {
                 styles: {'.MathJax_Display': {"margin": 0}}
             }
         });
         MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
     }
 }
 init_mathjax();
 </script>
 </head>
 {%- endblock header -%}
 
 
 {% block body %}
 <body>{{ super() }}
 </body>
 {%- endblock body %}
 
 
 {% block footer %}
 </html>{% endblock footer %}

templates/reveal.tpl

@@ -1,150 +1,150 b''
 {%- extends 'basichtml.tpl' -%}
 
 
 {% block any_cell -%}
 
 {% if cell.metadata.slideshow.close_fragment %}
 </div>
 {% endif %}
 {% if cell.metadata.slideshow.close_subsection %}
 </section>
 {% endif %}
 {% if cell.metadata.slideshow.close_section %}
 </section>
 {% endif %}
 
 {% if cell.metadata.slideshow.open_section %}
 <section>
 {%- endif %}
 {% if cell.metadata.slideshow.open_subsection %}
 <section>
 {%- endif %}
 {% if cell.metadata.slideshow.open_fragment %}
 <div class='fragment'>
 {% endif %}
 {% if cell.metadata.slideshow.slide_type in ['notes'] %}
 <aside class="notes">
 {{ super() }}
 </aside>
 {% elif cell.metadata.slideshow.slide_type not in ['skip'] %}
 {{ super() }}
 {% endif %}
 
 {% endblock %}
 
 
 {% block body %}
 <body>
 <div class="reveal"><div class="slides">
 {{ super() }}
 </section>
 </section>
 </div></div>
 
 <script src="reveal/lib/js/head.min.js"></script>
 
 <script src="reveal/js/reveal.min.js"></script>
 
 <script>
  
 // Full list of configuration options available here: https://github.com/hakimel/reveal.js#configuration
 Reveal.initialize({
 controls: true,
 progress: true,
 history: true,
 
 theme: Reveal.getQueryHash().theme, // available themes are in /css/theme
 transition: Reveal.getQueryHash().transition || 'linear', // default/cube/page/concave/zoom/linear/none
 
 // Optional libraries used to extend on reveal.js
 dependencies: [
 { src: 'reveal/lib/js/classList.js', condition: function() { return !document.body.classList; } },
 { src: 'reveal/plugin/highlight/highlight.js', async: true, callback: function() { hljs.initHighlightingOnLoad(); } },
 { src: 'reveal/plugin/zoom-js/zoom.js', async: true, condition: function() { return !!document.body.classList; } },
 { src: 'notes/notes.js', async: true, condition: function() { return !!document.body.classList; } },
 { src: 'https://c328740.ssl.cf1.rackcdn.com/mathjax/latest/MathJax.js?config=TeX-AMS_HTML', async: true },
 { src: 'js/revealmathjax.js', async: true}
 ]
 });
 </script>
 
 <script>
 Reveal.addEventListener( 'slidechanged', function( event ) {
 MathJax.Hub.Rerender(event.currentSlide);
 });
 </script>
 </body>
 </html>{% endblock body %}
 
 
 
 
 {% block header %}<!DOCTYPE html>
 <html>
 <head>
 
 <meta charset="utf-8" />
 <meta http-equiv="X-UA-Compatible" content="chrome=1">
 
 <meta name="apple-mobile-web-app-capable" content="yes" />
 <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
 
 <link rel="stylesheet" href="reveal/css/reveal.css">
 <link rel="stylesheet" href="reveal/css/theme/simple.css" id="theme">
 
 <!-- For syntax highlighting -->
 <link rel="stylesheet" href="reveal/lib/css/zenburn.css">
 
 <!-- If the query includes 'print-pdf', use the PDF print sheet -->
 <script>
 document.write( '<link rel="stylesheet" href="reveal/css/print/' + ( window.location.search.match( /print-pdf/gi ) ? 'pdf' : 'paper' ) + '.css" type="text/css" media="print">' );
 </script>
 
 <!--[if lt IE 9]>
 <script src="reveal/lib/js/html5shiv.js"></script>
 <![endif]-->
 
-{% for css in inlining.css -%}
+{% for css in resources.inlining.css -%}
 <style type="text/css">
 {{css}}
 </style>
 {% endfor %}
 
 <style type="text/css">
 /* Overrides of notebook CSS for static HTML export */
 
 .reveal {
   font-size: 20px;
 }
 .reveal pre {
     width: 100%;
     padding: 0.2em;
     margin: 0px auto;
     font-family: monospace, sans-serif;
     font-size: 60%;
     box-shadow: 0px 0px 0px rgba(0, 0, 0, 0);
 }
 .reveal section img {
     border: 0px solid black;
     box-shadow: 0 0 10px rgba(0, 0, 0, 0);
 }
 div.input_area {
     padding: 0.2em;
 }
 div.code_cell {
     background-color: transparent;
 }
 div.prompt {
     width: 11ex;
     padding: 0.0em;
     margin: 0px;
     font-family: monospace;
     font-size: 60%;
     text-align: center;
 }
 div.output_prompt {
     /* 5px right shift to account for margin in parent container */
     margin: 5px 5px 0 -5px;
 }
 </style>
 </head>{% endblock %}