flag for extracting figure

converters/template.py

@@ -1,289 +1,281 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
 import re
 from IPython.utils import path
 
 from jinja2 import Environment, FileSystemLoader
 env = Environment(
         loader=FileSystemLoader('./templates/'),
         extensions=['jinja2.ext.loopcontrols']
         )
 
 texenv = Environment(
         loader=FileSystemLoader('./templates/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)
+from IPython.utils.traitlets import ( Unicode, Any, List, Bool)
 
 # Our own imports
 from IPython.utils.text import indent
 from .utils import remove_ansi
 from markdown import markdown
 from .utils import highlight, ansi2html
 from .utils import markdown2latex
 #-----------------------------------------------------------------------------
 # 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
 
 # todo, make the key part configurable.
 def _new_figure(data, fmt, count):
     """Create a new figure file in the given format.
 
     Returns a path relative to the input file.
     """
     figname = '_fig_%02i.%s' % (count, fmt)
 
     # Binary files are base64-encoded, SVG is already XML
     if fmt in ('png', 'jpg', 'pdf'):
         data = data.decode('base64')
 
     return figname,data
 
 
 
 
 inlining = {}
 inlining['css'] = header_body()
 
-
-
-
-
-
-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
-
-
-
 LATEX_SUBS = (
     (re.compile(r'\\'), r'\\textbackslash'),
     (re.compile(r'([{}_#%&$])'), r'\\\1'),
     (re.compile(r'~'), r'\~{}'),
     (re.compile(r'\^'), r'\^{}'),
     (re.compile(r'"'), r"''"),
     (re.compile(r'\.\.\.+'), r'\\ldots'),
 )
 
 def escape_tex(value):
     newval = value
     for pattern, replacement in LATEX_SUBS:
         newval = pattern.sub(replacement, newval)
     return newval
 
 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
 
-texenv.filters['pycomment'] = python_comment
-texenv.filters['indent'] = indent
-texenv.filters['rm_fake'] = rm_fake
-texenv.filters['rm_ansi'] = remove_ansi
-texenv.filters['markdown'] = markdown
-texenv.filters['highlight'] = highlight
-texenv.filters['ansi2html'] = ansi2html
-texenv.filters['markdown2latex'] = markdown2latex
-
 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 outline_figure_transformer(cell,other,count):
+def extract_figure_transformer(cell,other,count):
     for i,out in enumerate(cell.get('outputs', [])):
         for type in ['html', 'pdf', 'svg', 'latex', 'png', 'jpg', 'jpeg']:
             if out.hasattr(type):
                 figname,data = _new_figure(out[type], type,count)
                 cell.outputs[i][type] = figname
                 out['key_'+type] = figname
                 other[figname] = data
                 count = count+1
-    return nb,other
+    return cell,other
 
 
 class ConverterTemplate(Configurable):
     """ A Jinja2 base converter templates"""
 
     display_data_priority = List(['html', 'pdf', 'svg', 'latex', 'png', 'jpg', 'jpeg' , 'text'],
             config=True,
               help= """
                     A list of ast.NodeTransformer subclass instances, which will be applied
                     to user input before code is run.
                     """
             )
 
     extract_figures = Bool(False,
             config=True,
               help= """
                     wether to remove figure data from ipynb and store them in auxiliary
                     dictionnary
                     """
             )
     #-------------------------------------------------------------------------
     # Instance-level attributes that are set in the constructor for this
     # class.
     #-------------------------------------------------------------------------
     infile = Any()
 
 
     infile_dir = Unicode()
 
     def filter_data_type(self,output):
         for fmt in self.display_data_priority:
             if fmt in output:
                 return [fmt]
 
     def __init__(self, tplfile='fullhtml', preprocessors=[], config=None,tex_environement=False, **kw):
         """
         tplfile : jinja template file to process.
 
         config: the Configurable confg object to pass around
 
         preprocessors: list of function to run on ipynb json data before conversion
         to extract/inline file,
 
         """
+        super(ConverterTemplate, self).__init__(config=config, **kw)
         self.env = texenv if tex_environement else env
         self.ext = '.tplx' if tex_environement else '.tpl'
         self.nb = None
         self.preprocessors = preprocessors
         self.preprocessors.append(haspyout_transformer)
-        self.preprocessors.append(outline_figure_transformer)
-        super(ConverterTemplate, self).__init__(config=config, **kw)
+        if self.extract_figures:
+            self.preprocessors.append(extract_figure_transformer)
+
         self.env.filters['filter_data_type'] = self.filter_data_type
+        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.template = self.env.get_template(tplfile+self.ext)
 
 
 
     def process(self):
         """
         preprocess the notebook json for easier use with the templates.
         will call all the `preprocessor`s in order before returning it.
         """
         nb = self.nb
 
+        # 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,others = preprocessor(nb,{})
+            nb,resources = preprocessor(nb,resources)
 
-        return nb
+        return nb, resources
 
     def convert(self):
         """ convert the ipynb file
 
         return both the converted ipynb file and a dict containing potential
         other resources
         """
-        return self.template.render(nb=self.process(), inlining=inlining), {}
+        nb,resources = self.process()
+        return self.template.render(nb=nb, inlining=inlining), resources
 
 
     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')
 

runme.py

@@ -1,65 +1,80 b''
 #!/usr/bin/env python
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 from __future__ import print_function
 import sys
 import io
 
 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.utils.traitlets import List, Unicode, Type, Bool, Dict, CaselessStrEnum
 
 
 class NbconvertApp(Application):
 
 
     def __init__(self, **kwargs):
         super(NbconvertApp, self).__init__(**kwargs)
         self.classes.insert(0,ConverterTemplate)
         # ensure those are registerd
 
 
     def initialize(self, argv=None):
         self.parse_command_line(argv)
         cl_config = self.config
         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]
 
         if template_file.startswith('latex'):
             tex_environement=True
         else:
             tex_environement=False
 
-        C = ConverterTemplate(tplfile=sys.argv[1], tex_environement=tex_environement, config=self.config)
+        C = ConverterTemplate(tplfile=sys.argv[1],
+                tex_environement=tex_environement,
+                config=self.config)
         C.read(ipynb_file)
 
-        output,rest = C.convert()
+        output,resources = C.convert()
 
         print(output.encode('utf-8'))
 
+        keys = resources.keys()
+        if keys :
+            print('''
+====================== Keys in Resources ==================================
+''')
+            print(resources.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.initialize()
     app.start()
     app.run()
 #-----------------------------------------------------------------------------
 # Script main
 #-----------------------------------------------------------------------------
 
 if __name__ == '__main__':
     main()