upstream/ipython Commit - r8777:e9ad9448

Fixed bad variable names in nbconvert.py and html.py.

Ivan Djokic -

r8777:e9ad9448

parent child

converters/html.py

0 +2 -1

             from __future__ import absolute_import
             from converters.base import Converter
             from converters.utils import text_cell, output_container
             from converters.utils import highlight, coalesce_streams, ansi2html
             from IPython.utils import path
             from markdown import markdown
             import os
             import io
             class ConverterHTML(Converter):
                 extension = 'html'
                 blank_symbol = '&nbsp;'
                 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 else cell.input)
+                    lines.append(highlight(cell.input) if self.highlight_code
+                                 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]

nbconvert.py

0 +1 -1

             #!/usr/bin/env python
             """Convert IPython notebooks to other formats, such as ReST, and HTML.
             Example:
               ./nbconvert.py --format rst file.ipynb
             Produces 'file.rst', along with auto-generated figure files
             called nb_figure_NN.png.
             """
             #-----------------------------------------------------------------------------
             # Imports
             #-----------------------------------------------------------------------------
             from __future__ import print_function
             # From IPython
             from IPython.external import argparse
             # local
             from converters.html import ConverterHTML
             from converters.markdown import ConverterMarkdown
             from converters.bloggerhtml import ConverterBloggerHTML
             from converters.rst import ConverterRST
             from converters.latex import ConverterLaTeX
             from converters.python import ConverterPy
             # When adding a new format, make sure to add it to the `converters`
             # dictionary below. This is used to create the list of known formats,
             # which gets printed in case an unknown format is encounteres, as well
             # as in the help
             converters = {
                 'rst': ConverterRST,
                 'markdown': ConverterMarkdown,
                 'html': ConverterHTML,
                 'blogger-html': ConverterBloggerHTML,
                 'latex': ConverterLaTeX,
                 'py': ConverterPy,
                 }
             default_format = 'rst'
             # Extract the list of known formats and mark the first format as the default.
             known_formats = ', '.join([key + " (default)" if key == default_format else key
                                        for key in converters])
             def main(infile, format='rst', preamble=None, exclude=None,
                      highlight_code=True):
                 """Convert a notebook to html in one step"""
                 try:
                     ConverterClass = converters[format]
                 except KeyError:
                     raise SystemExit("Unknown format '%s', " % format +
                                      "known formats are: " + known_formats)
                 converter = ConverterClass(infile, highlight_code)
                 converter.render()
             #-----------------------------------------------------------------------------
             # Script main
             #-----------------------------------------------------------------------------
             if __name__ == '__main__':
                 parser = argparse.ArgumentParser(description=__doc__,
                         formatter_class=argparse.RawTextHelpFormatter)
                 # TODO: consider passing file like object around, rather than filenames
                 # would allow us to process stdin, or even http streams
                 #parser.add_argument('infile', nargs='?', type=argparse.FileType('r'),
                 #                    default=sys.stdin)
                 #Require a filename as a positional argument
                 parser.add_argument('infile', nargs=1)
                 parser.add_argument('-f', '--format', default='rst',
                                     help='Output format. Supported formats: \n' +
                                     known_formats)
                 parser.add_argument('-p', '--preamble',
                                     help='Path to a user-specified preamble file')
                 parser.add_argument('-e', '--exclude', default='',
                                     help='Comma-separated list of cells to exclude')
                 parser.add_argument('-H', '--no-highlighting', action='store_false',
                                     help='Disable syntax highlighting for code blocks.')
                 args = parser.parse_args()
                 exclude_cells = [s.strip() for s in args.exclude.split(',')]
                 main(infile=args.infile[0], format=args.format, preamble=args.preamble,
-                     exclude=exclude_cells, highlight_code=args.plain_output)
+                     exclude=exclude_cells, highlight_code=args.no_highlighting)

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages