converters/html.py

"""Implements conversion to ordinary HTML output.

This file implements a class that handles rendering IPython notebooks as
HTML, suitable for posting to the web.

Converters for more specific HTML generation needs (suitable for posting to
a particular web service) can usefully subclass `ConverterHTML` and override
certain methods. For output tuned to the Blogger blogging platform, see the
`ConverterBloggerHTML` class.
"""
#-----------------------------------------------------------------------------
# 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 io
import os

# Third-party imports
from markdown import markdown

# IPython imports
from IPython.utils import path

# Our own imports
from .base import Converter
from .utils import text_cell, output_container
from .utils import highlight, coalesce_streams, ansi2html


#-----------------------------------------------------------------------------
# Class declarations
#-----------------------------------------------------------------------------

class ConverterHTML(Converter):
    #-------------------------------------------------------------------------
    # Class-level attributes determining the behaviour of the class but
    # probably not varying from instance to instance.
    #-------------------------------------------------------------------------
    extension = 'html'
    blank_symbol = ' '

    def in_tag(self, tag, src, attrs=None):
        """Return a list of elements bracketed by the given tag"""
        attr_s = '' if attrs is None else \
                 ' '.join("%s=%s" % (attr, value)
                          for attr, value in attrs.iteritems())
        return ['<%s %s>' % (tag, attr_s), src, '</%s>' % tag]

    def _ansi_colored(self, text):
        return ['<pre>%s</pre>' % ansi2html(text)]

    def _stylesheet(self, fname):
        with io.open(fname, encoding='utf-8') as f:
            s = f.read()
        return self.in_tag('style', s, dict(type='"text/css"'))

    def _out_prompt(self, output):
        if output.output_type == 'pyout':
            content = 'Out[%s]:' % self._get_prompt_number(output)
        else:
            content = ''
        return ['<div class="prompt output_prompt">%s</div>' % content]

    def header_body(self):
        """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'),
        ]:
            header.extend(self._stylesheet(sheet))

        # pygments css
        pygments_css = HtmlFormatter().get_style_defs('.highlight')
        header.extend(['<meta charset="UTF-8">'])
        header.extend(self.in_tag('style', pygments_css,
                                  dict(type='"text/css"')))

        # TODO: this should be allowed to use local mathjax:
        header.extend(self.in_tag('script', '', {'type': '"text/javascript"',
            'src': '"https://c328740.ssl.cf1.rackcdn.com/mathjax/'
                   'latest/MathJax.js?config=TeX-AMS_HTML"',
        }))
        with io.open(os.path.join(here, '..', 'js', 'initmathjax.js'),
                     encoding='utf-8') as f:
            header.extend(self.in_tag('script', f.read(),
                                      {'type': '"text/javascript"'}))
        return header

    def optional_header(self):
        return ['<html>', '<head>'] + self.header_body() + \
          ['</head>', '<body>']

    def optional_footer(self):
        return ['</body>', '</html>']

    @text_cell
    def render_heading(self, cell):
        marker = cell.level
        return [u'<h{1}>\n  {0}\n</h{1}>'.format(cell.source, marker)]

    def render_code(self, cell):
        if not cell.input:
            return []

        lines = ['<div class="cell border-box-sizing code_cell vbox">']

        lines.append('<div class="input hbox">')
        n = self._get_prompt_number(cell)
        lines.append(
            '<div class="prompt input_prompt">In&nbsp;[%s]:</div>' % n
        )
        lines.append('<div class="input_area box-flex1">')
        lines.append(highlight(cell.input) if self.highlight_source
                     else cell.input)
        lines.append('</div>')  # input_area
        lines.append('</div>')  # input

        if cell.outputs:
            lines.append('<div class="vbox output_wrapper">')
            lines.append('<div class="output vbox">')

            for output in coalesce_streams(cell.outputs):
                conv_fn = self.dispatch(output.output_type)
                lines.extend(conv_fn(output))

            lines.append('</div>')  # output
            lines.append('</div>')  # output_wrapper

        lines.append('</div>')  # cell

        return lines

    @text_cell
    def render_markdown(self, cell):
        return [markdown(cell.source)]

    def render_raw(self, cell):
        if self.raw_as_verbatim:
            return self.in_tag('pre', cell.source)
        else:
            return [cell.source]

    @output_container
    def render_pyout(self, output):
        for fmt in ['html', 'latex', 'png', 'jpeg', 'svg', 'text']:
            if fmt in output:
                conv_fn = self.dispatch_display_format(fmt)
                return conv_fn(output)
        return []

    render_display_data = render_pyout

    @output_container
    def render_stream(self, output):
        return self._ansi_colored(output.text)

    @output_container
    def render_pyerr(self, output):
        # Note: a traceback is a *list* of frames.
        # lines = []

        # stb =
        return self._ansi_colored('\n'.join(output.traceback))

    def _img_lines(self, img_file):
        return ['<img src="%s">' % img_file, '</img>']

    def _unknown_lines(self, data):
        return ['<h2>Warning:: Unknown cell</h2>'] + self.in_tag('pre', data)

    def render_display_format_png(self, output):
        return ['<img src="data:image/png;base64,%s"></img>' % output.png]

    def render_display_format_svg(self, output):
        return [output.svg]

    def render_display_format_jpeg(self, output):
        return ['<img src="data:image/jpeg;base64,%s"></img>' % output.jpeg]

    def render_display_format_text(self, output):
        return self._ansi_colored(output.text)

    def render_display_format_html(self, output):
        return [output.html]

    def render_display_format_latex(self, output):
        return [output.latex]

    def render_display_format_json(self, output):
        # html ignores json
        return []

    def render_display_format_javascript(self, output):
        return [output.javascript]