fix some relative path issues

converters/jinja_filters.py

@@ -1,74 +1,74 b''
 #-----------------------------------------------------------------------------
 # 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.
 #-----------------------------------------------------------------------------
 
 from __future__ import absolute_import
 
 # Stdlib imports
 import re
 
 from IPython.utils.text import indent
 from markdown import markdown
 from .utils import remove_ansi
 from .utils import highlight, ansi2html
 from .utils import markdown2latex
 from .utils import highlight2latex
 from .utils import get_lines
 
-from converters.config import GlobalConfigurable
+from .config import GlobalConfigurable
 
 from IPython.config.configurable import Configurable
 from IPython.utils.traitlets import List
 
 #-----------------------------------------------------------------------------
 # Class declarations
 #-----------------------------------------------------------------------------
 
 class ConfigurableFilter(GlobalConfigurable):
     """Configurable Jinja Filter"""
 
     def __init__(self, config=None, **kw):
         super(ConfigurableFilter, self).__init__(config=config, **kw)
 
     def __call__(self, *args, **kwargs):
         raise NotImplementedError('should be implemented by subclass')
 
 
 class FilterDataType(ConfigurableFilter):
     """ return the preferd displayed format
     """
 
     def __call__(self, output):
         """ return the first availlable format in priority """
         for fmt in self.display_data_priority:
             if fmt in output:
                 return [fmt]
         raise Exception("did not found any format I can extract in output, shoudl at lest have one")
 
 
 
 def rm_fake(strng):
     return strng.replace('/files/', '')
 
 def python_comment(string):
     return '# '+'\n# '.join(string.split('\n'))
 
 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
 

converters/latex_transformer.py

@@ -1,127 +1,128 b''
 """
 Module that allows latex output notebooks to be conditioned before 
 they are converted.
 """
+from __future__ import absolute_import
 
 # Configurable traitlets
 from IPython.utils.traitlets import Unicode, Bool
 
 # Needed to override transformer
-from converters.transformers import (ActivatableTransformer)
+from .transformers import (ActivatableTransformer)
 
 class LatexTransformer(ActivatableTransformer):
     """
     Converter for latex destined documents.
     """    
 
     def cell_transform(self, cell, other, index):
         """
         Apply a transformation on each cell,
 
         receive the current cell, the resource dict and the index of current cell as parameter.
 
         Returns modified cell and resource dict.
         """
         if hasattr(cell, "source") and cell.cell_type == "markdown":
             cell.source = self.remove_math_space(cell.source)
         return cell, other
 
     def remove_math_space(self, text):
         """
         Remove the space between latex math commands and enclosing $ symbols.
         """
         
         # First, scan through the markdown looking for $.  If
         # a $ symbol is found, without a preceding \, assume
         # it is the start of a math block.  UNLESS that $ is
         # not followed by another within two math_lines.
         math_regions = []
         math_lines = 0
         within_math = False
         math_start_index = 0
         index = 0
         last_character = ""
         for char in text: #Loop through each character in the text.
             
             #Make sure the character isn't preceeded by a backslash
             if (char == "$" and last_character != "\\"):
                 
                 # Close the math region if this is an ending $
                 if within_math:
                     within_math = False
                     math_regions.append([math_start_index, index+1])
                 else:
                     
                     # Start a new math region
                     within_math = True
                     math_start_index = index
                     math_lines = 0
                     
             # If we are in a math region, count the number of lines parsed.
             # Cancel the math region if we find two line breaks!
             elif char == "\n":
                 if within_math:
                     math_lines += 1
                     if math_lines > 1:
                         within_math = False
                         
             # Remember the last character so we can easily watch
             # for backslashes
             last_character = char
             
             # Next index
             index += 1
         
         # Reset the index and last char
         index = 0
         
         # Now that we know what regions of the text are math and
         # what regions aren't, we can separate them into "blocks"
         text_blocks=[]
         math_blocks=[]
         was_math_block = False
         current_block = ""
         for char in text:
             
             # Check if this is a math region.
             ismath = False
             for keypair in math_regions:
                 if (keypair[0] <= index and index <=  keypair[1]):
                     ismath = True
             
             # If the region type has changed since the last
             # iteration, commit all read characters to that
             # region type and reset the buffer.
             if (ismath and not was_math_block):
                 was_math_block = True
                 text_blocks.append(current_block)
                 current_block=""
             elif ((not ismath) and was_math_block):
                 was_math_block = False
                 math_blocks.append(current_block)
                 current_block=""
             
             # Store the character
             current_block += char
             
             # Next index
             index += 1
             
         # Save whatever remains in the buffer that hasn't yet been saved.
         if was_math_block:
             math_blocks.append(current_block)
         else:
             text_blocks.append(current_block)
             
         # Recombine the regions, while processing every math region, removing
         # the spaces between the math and the $ symbols.
         output = ""
         for index in range(0,len(text_blocks) + len(math_blocks)):
             if index % 2 == 0:
                 output += text_blocks[index/2]
             else:
                 mathblock = math_blocks[(index -1)/2]
                 mathblock = mathblock[1:len(mathblock)-2]
                 output += "$" + mathblock.strip() + "$"
         return output
         

converters/sphinx_transformer.py

@@ -1,199 +1,200 b''
 """
 Module that allows custom Sphinx parameters to be set on the notebook and
 on the 'other' object passed into Jinja.
 """
+from __future__ import absolute_import
 
 # Used to find Sphinx package location
 import sphinx
 import os.path
 
 # Used to determine python version
 import sys
 
 # Used to set the default date to today's date 
 from datetime import date 
 
 # Configurable traitlets
 from IPython.utils.traitlets import Unicode, Bool
 
 # Needed for Pygments latex definitions.
 from pygments.formatters import LatexFormatter
 
 # Needed to override transformer
-from converters.transformers import (ActivatableTransformer)
+from .transformers import (ActivatableTransformer)
 
 class SphinxTransformer(ActivatableTransformer):
     """
     Sphinx utility transformer.
 
     This transformer is used to set variables needed by the latex to build
     Sphinx stylized templates.
     """
     
     interactive = Bool(True, config=True, help="""
     Allows you to define whether or not the Sphinx exporter will prompt
     you for input during the conversion process.  If this is set to false,
     the author, version, release, date, and chapterstyle traits should
     be set.
     """)
     
     author = Unicode("Unknown Author", config=True, help="Author name")
     
     version = Unicode("", config=True, help="""Version number
     You can leave this blank if you do not want to render a version number.
     Example: "1.0.0"
     """)
     
     release = Unicode("", config=True, help="""Release name
     You can leave this blank if you do not want to render a release name.
     Example: "Rough Draft"
     """)
     
     publishdate = Unicode("", config=True, help="""Publish date
     This is the date to render on the document as the publish date.
     Leave this blank to default to todays date.  
     Example: "June 12, 1990"
     """)
     
     chapterstyle = Unicode("Bjarne", config=True, help="""Sphinx chapter style
     This is the style to use for the chapter headers in the document.
     You may choose one of the following:
         "Bjarne"    (default)
         "Lenny"
         "Glenn"
         "Conny"
         "Rejne"
         "Sonny"    (used for international documents)
     """)
     
     
     def __call__(self, nb, other):
         """
         Entry
         Since we are not interested in any additional manipulation on a cell
         by cell basis, we do not  call the base implementation.
         """
         if self.enabled:
             return self.transform(nb, other)
         else:
             return nb,other
 
     def transform(self, nb, other):
         """
         Sphinx transformation to apply on each notebook.
         """
         
         if self.interactive:
             
             # Prompt the user for additional meta data that doesn't exist currently
             # but would be usefull for Sphinx.
             nb.metadata["author"] = self._prompt_author()
             nb.metadata["version"] = self._prompt_version()
             nb.metadata["release"] = self._prompt_release()
             nb.metadata["date"] = self._prompt_date()
             
             # Prompt the user for the document style.
             other["sphinx_chapterstyle"] = self._prompt_chapter_title_style()
         else:
             
             # Try to use the traitlets.
             nb.metadata["author"] = self.author
             nb.metadata["version"] = self.version
             nb.metadata["release"] = self.release
             
             if len(self.publishdate.strip()) == 0:
                 nb.metadata["date"] = date.today().strftime("%B %-d, %Y")
             else:
                 nb.metadata["date"] = self.publishdate
                 
             other["sphinx_chapterstyle"] = self.chapterstyle
             
         # Find and pass in the path to the Sphinx dependencies.
         other["sphinx_texinputs"] = os.path.abspath(sphinx.__file__ + "/../texinputs")
         
         # Generate Pygments definitions for Latex 
         other["pygment_definitions"] = self._generate_pygments_latex_def()
         
         # End
         return nb, other 
     
     def _generate_pygments_latex_def(self):
         return LatexFormatter().get_style_defs()       
     
     def _prompt_author(self):
         return  self._input("Author name: ")
     
     def _prompt_version(self):
         return  self._input("Version (ie ""1.0.0""): ")
     
     def _prompt_release(self):
         return  self._input("Release Name (ie ""Rough draft""): ")
     
     def _prompt_date(self):
         default_date = date.today().strftime("%B %-d, %Y")
         user_date = self._input("Date (deafults to \"" + default_date + "\"): ")
         if len(user_date.strip()) == 0:
             user_date = default_date
         return user_date
     
     def _prompt_chapter_title_style(self):
         
         # Dictionary of available Sphinx styles
         styles = {1: "Bjarne",
                   2: "Lenny",
                   3: "Glenn",
                   4: "Conny",
                   5: "Rejne",
                   6: "Sonny"}
         default_style = 1
         
         # Build the menu that will be displayed to the user with
         # all of the options available. 
         style_prompt = ""
         for key, value in styles.iteritems():
             style_prompt += "%d %s" % (key, value)
             if key == default_style:
                 style_prompt += " (default)"
             elif value == "Sonny":
                 style_prompt += " (for international documents)"
             style_prompt += "\n"
         
         # Continue to ask the user for a style until an appropriate
         # one is specified.
         response = -1
         while (0 > response or response > 6):
             try:
                 text_response = self._input(style_prompt)
                 
                 # Use default option if no input.
                 if len(text_response.strip()) == 0:
                     response = 1
                 else:
                     response = int(text_response)
             except:
                 print("Error: Value must be a number between 1 and 6, leave blank for default\n")
         return styles[response]
           
     def _input(self, prompt_text):
         """
         Prompt the user for input.
         
         The input command will change depending on the version of python
         installed.  To maintain support for 2 and earlier, we must use
         raw_input in that case.  Else use input.
         """
         
         # Try to get the python version.  This command is only available in
         # python 2 and later, so it's important that we catch the exception
         # if the command isn't found.
         try:
             majorversion = sys.version_info[0]
         except:
             majorversion = 1
             
         # Use the correct function to prompt the user for input depending on 
         # what python version the code is running in.
         if majorversion >= 3:
             return input(prompt_text) 
         else:
             return raw_input(prompt_text)

converters/template.py

@@ -1,239 +1,247 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
 """
+
+from __future__ import absolute_import
+
 #-----------------------------------------------------------------------------
 # 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
+from __future__ import print_function
+from __future__ import absolute_import
 
 # Stdlib imports
 import io
+import os
 
 # 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
-from converters.sphinx_transformer import (SphinxTransformer)
-from converters.latex_transformer import (LatexTransformer)
+from  . import transformers as trans
+from .sphinx_transformer import (SphinxTransformer)
+from .latex_transformer import (LatexTransformer)
 
 # some jinja filters
-from converters.jinja_filters import (python_comment, indent,
+from .jinja_filters import (python_comment, indent,
         rm_fake, remove_ansi, markdown, highlight, highlight2latex,
         ansi2html, markdown2latex, get_lines, escape_tex, FilterDataType)
 
-from converters.utils import  markdown2rst
+from .utils import  markdown2rst
 
 import textwrap
 
 def wrap(text, width=100):
     """ try to detect and wrap paragraph"""
     splitt = text.split('\n')
     wrp = map(lambda x:textwrap.wrap(x,width),splitt)
     wrpd = map('\n'.join, wrp)
     return '\n'.join(wrpd)
 
 
 
 # define differents environemnt with different
 # delimiters not to conflict with languages inside
 
 env = Environment(
         loader=FileSystemLoader([
-            './templates/',
-            './templates/skeleton/',
+            os.path.dirname(os.path.realpath(__file__))+'/../templates/',
+            os.path.dirname(os.path.realpath(__file__))+'/../templates/skeleton/',
             ]),
         extensions=['jinja2.ext.loopcontrols']
         )
 
+print(os.path.dirname(os.path.realpath(__file__))+'/../templates/')
+
+
 texenv = Environment(
         loader=FileSystemLoader([
-            './templates/tex/',
-            './templates/skeleton/tex/',
+            os.path.dirname(os.path.realpath(__file__))+'/../templates/tex/',
+            os.path.dirname(os.path.realpath(__file__))+'/../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
 
     should be mostly configurable
     """
 
     pre_transformer_order = List(['haspyout_transformer'],
             config=True,
               help= """
                     An ordered list of pre transformer to apply to the ipynb
                     file before 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 = preprocessors.get(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.preprocessors.append(SphinxTransformer(config=config))
         self.preprocessors.append(LatexTransformer(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['highlight2latex'] = highlight2latex
         self.env.filters['ansi2html'] = ansi2html
         self.env.filters['markdown2latex'] = markdown2latex
         self.env.filters['markdown2rst'] = markdown2rst
         self.env.filters['get_lines'] = get_lines
         self.env.filters['wrap'] = wrap
 
         ## 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,269 +1,269 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 __future__ import print_function, absolute_import
 
 from IPython.config.configurable import Configurable
 from IPython.utils.traitlets import Unicode, Bool, Dict, List
 
-from converters.config import GlobalConfigurable
+from .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)
 
         # 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'),
         ]:
             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
 

templates/basichtml.tpl

@@ -1,132 +1,132 b''
 {%- extends 'display_priority.tpl' -%}
 
 
 
 {% block codecell %}
 <div class="cell border-box-sizing code_cell vbox">
 {{ super() }}</div>
 {%- endblock codecell %}
 
 {% block input_group -%}
 <div class="input hbox">
 {{super()}}
 </div>
 {% endblock input_group %}
 
 {% block output_group -%}
 <div class="vbox output_wrapper">
 <div class="output vbox">
-<div class="hbox output_area">
+<div class="vbox output_area">
 {{ super() }}
 </div>
 </div>
 </div>
 {% endblock output_group %}
 
 
 {% block in_prompt -%}
 <div class="prompt input_prompt">In&nbsp;[{{cell.prompt_number}}]:</div>
 {%- endblock in_prompt %}
 
 {% block output_prompt -%}
 <div class="prompt output_prompt">
 {%- if cell.haspyout -%}
 Out[{{cell.prompt_number}}]:
 {%- endif -%}
 </div>
 {% endblock output_prompt %}
 
 {% block input %}
 <div class="input_area box-flex1">
 {{cell.input | highlight }}
 </div>
 {%- endblock input %}
 
 
 {% block markdowncell scoped %}
 <div class="text_cell_render border-box-sizing rendered_html">
 {{ cell.source | markdown| rm_fake}}
 </div>
 {%- endblock markdowncell %}
 
 {% block headingcell scoped %}
 <div class="text_cell_render border-box-sizing rendered_html">
 <h{{cell.level}}>
   {{cell.source}}
 </h{{cell.level}}>
 </div>
 {% endblock headingcell %}
 
 {% block rawcell scoped %}
 {{ cell.source }}
 {% endblock rawcell %}
 
 {% block unknowncell scoped %}
 unknown type  {{cell.type}}
 {% endblock unknowncell %}
 
 
 {% block pyout -%}
 <div class="box-flex1 output_subarea output_pyout">
 {% block data_priority scoped %}{{ super()}}{% endblock %}
 </div>
 {%- endblock pyout %}
 
 {% block stream_stdout -%}
 <div class="box-flex1 output_subarea output_stream output_stdout">
 <pre>{{output.text |ansi2html}}</pre>
 </div>
 {%- endblock stream_stdout %}
 
 {% block stream_stderr -%}
 <div class="box-flex1 output_subarea output_stream output_stderr">
 <pre>{{output.text |ansi2html}}</pre>
 </div>
 {%- endblock stream_stderr %}
 
 {% block data_svg -%}
 {{output.svg}}
 {%- endblock data_svg %}
 
 
 {% block data_html -%}
 <div class="output_html rendered_html">
 {{output.html}}
 </div>
 {%- endblock data_html %}
 
 {% block data_png %}
 <img src="data:image/png;base64,{{output.png}}"></img>
 {%- endblock data_png %}
 
 
 {% block data_jpg %}
 <img src="data:image/jpeg;base64,{{output.jpeg}}"></img>
 {%- endblock data_jpg %}
 
 
 {% block data_latex %}
 {{output.latex}}
 {%- endblock data_latex %}
 
 {% block pyerr -%}
 <div class="box-flex1 output_subarea output_pyerr">
 <pre>{{super()}}</pre>
 </div>
 {%- endblock pyerr %}
 
 {%- block traceback_line %}
 {{line| ansi2html}}
 {%- endblock traceback_line %}
 
 
 {%- block data_text %}
 <pre>{{output.text | ansi2html}}</pre>
 {%- endblock -%}
 
 
 {%- block display_data scoped -%}
 <div class="box-flex1 output_subarea output_display_data">
 {{super()}}
 </div>
-{%- endblock display_data -%}
  No newline at end of file
+{%- endblock display_data -%}