##// END OF EJS Templates
use new css with old nbconvert html
use new css with old nbconvert html

File last commit:

r9535:b30d6a21
r9535:b30d6a21
Show More
html.py
216 lines | 7.3 KiB | text/x-python | PythonLexer
"""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, 'style.min.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]