preprocessing and namespace fix

use preprocessing with current transform,
and ability to access notebook namespace from template

converters/template.py

@@ -1,165 +1,169 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
 
 # Stdlib imports
 import io
 import os
 from IPython.utils import path
 
 from jinja2 import Environment, FileSystemLoader
 env = Environment(
         loader=FileSystemLoader('./templates/'),
         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)
 
 # Our own imports
 from IPython.utils.text import indent
 from .utils import remove_ansi
 from markdown import markdown
 from .utils import highlight, ansi2html
 #-----------------------------------------------------------------------------
 # Class declarations
 #-----------------------------------------------------------------------------
 def rm_fake(strng):
     return strng.replace('/files/', '')
 
 class ConversionException(Exception):
     pass
 
 
 def python_comment(string):
     return '# '+'\n# '.join(string.split('\n'))
 
 
 
 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'),
         # our overrides:
         os.path.join(here, '..', 'css', 'static_html.css'),
     ]:
 
         with io.open(sheet, encoding='utf-8') as f:
             s = f.read()
             header.append(s)
 
     pygments_css = HtmlFormatter().get_style_defs('.highlight')
     header.append(pygments_css)
     return header
 
 inlining = {}
 inlining['css'] = header_body()
 
 
 def filter_data_type(output):
     for fmt in ['html', 'pdf', 'svg', 'latex', 'png', 'jpg', 'jpeg' , 'text']:
         if fmt in output:
             return [fmt]
 
 
 env.filters['filter_data_type'] = filter_data_type
 env.filters['pycomment'] = python_comment
 env.filters['indent'] = indent
 env.filters['rm_fake'] = rm_fake
 env.filters['rm_ansi'] = remove_ansi
 env.filters['markdown'] = markdown
 env.filters['highlight'] = highlight
 env.filters['ansi2html'] = ansi2html
 
+
+def haspyout_transformer(nb,_):
+    print('calling...')
+    for worksheet in nb.worksheets:
+        print('worksheet')
+        for cell in worksheet.cells:
+            cell.type = cell.cell_type
+            cell.haspyout = False
+            for out in cell.get('outputs', []):
+                if out.output_type == 'pyout':
+                    cell.haspyout = True
+                    break
+    return nb
+
 class ConverterTemplate(Configurable):
 
     display_data_priority = ['pdf', 'svg', 'png', 'jpg', 'text']
     #-------------------------------------------------------------------------
     # Instance-level attributes that are set in the constructor for this
     # class.
     #-------------------------------------------------------------------------
     infile = Any()
 
 
     infile_dir = Unicode()
 
     def __init__(self, tplfile='fullhtml', preprocessors=[], config=None, **kw):
         """
         preprocessors: list of function to run on ipynb json data before conversion
         to extract/inline file,
 
 
 
         """
         self.template = env.get_template(tplfile+'.tpl')
         self.nb = None
         self.preprocessors = preprocessors
+        self.preprocessors.append(haspyout_transformer)
         super(ConverterTemplate, self).__init__(config=config, **kw)
 
+
     def process(self):
         nb = self.nb
 
         for preprocessor in self.preprocessors:
             nb = preprocessor(nb,{})
 
-        worksheets = []
-        for worksheet in nb.worksheets:
-            for cell in worksheet.cells:
-                cell.type = cell.cell_type
-                cell.haspyout = False
-                for out in cell.get('outputs', []):
-                    if out.output_type == 'pyout':
-                        cell.haspyout = True
-                        break
-            worksheets.append(worksheet)
-
-
-        return worksheets
+        return nb
 
     def convert(self):
         """ convert the ipynb file
 
         return both the converted ipynb file and a dict containing potential
         other resources
         """
-        return self.template.render(worksheets=self.process(), inlining=inlining), {}
+        return self.template.render(nb=self.process(), inlining=inlining), {}
 
 
     def read(self, filename):
         "read and parse notebook into NotebookNode called self.nb"
         with io.open(filename) as f:
             self.nb = nbformat.read(f, 'json')
 

templates/null.tpl

@@ -1,89 +1,89 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 diferents blocks of a notebook.
 
 Subtemplates can Override Blocks to define their custom reresentation.
 
 If one of the block you do overrite 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 block is leave block, we might insert more block later.
 
 #}
 {%- block header -%}
 {%- endblock header -%}
 {%- block body -%}
-{%- for worksheet in worksheets -%}
+{%- for worksheet in nb.worksheets -%}
     {%- for cell in worksheet.cells -%}
         {%- block any_cell scoped -%}
             {%- if 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 -%}
                                 {%- for output in cell.outputs -%}
                                     {%- 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 -%}
                                 {%- endfor -%}
                             {%- endblock outputs -%}
                     {%- endblock output_group -%}
                         {%- endif -%}
                 {%- endblock codecell -%}
             {%- elif cell.type in ['markdown'] -%}
                 {%- block markdowncell scoped-%}
                 {%- endblock markdowncell -%}
             {%- elif cell.type in ['heading'] -%}
                 {%- block headingcell scoped-%}
                 {%- endblock headingcell -%}
             {%- elif 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 -%}