Added an option to disable syntax highlighting in code blocks. Simply add the -p or --plain_output tag to the command. This is a fix for issue #21

converters/base.py

@@ -1,365 +1,366 b''
 from __future__ import print_function, absolute_import
 from converters.utils import remove_fake_files_url
 
 # Stdlib
 import codecs
 import io
 import logging
 import os
 import pprint
 import re
 from types import FunctionType
 
 # From IPython
 from IPython.nbformat import current as nbformat
 
 # local
 
 def clean_filename(filename):
     """
     Remove non-alphanumeric characters from filenames.
 
     Parameters
     ----------
     filename : str
         The filename to be sanitized.
 
     Returns
     -------
     clean : str
         A sanitized filename that contains only alphanumeric
         characters and underscores.
     """
     filename = re.sub(r'[^a-zA-Z0-9_]', '_', filename)
     return filename
 
 #-----------------------------------------------------------------------------
 # Class declarations
 #-----------------------------------------------------------------------------
 
 
 class ConversionException(Exception):
     pass
 
 
 class DocStringInheritor(type):
     """
     This metaclass will walk the list of bases until the desired
     superclass method is found AND if that method has a docstring and only
     THEN does it attach the superdocstring to the derived class method.
 
     Please use carefully, I just did the metaclass thing by following
     Michael Foord's Metaclass tutorial
     (http://www.voidspace.org.uk/python/articles/metaclasses.shtml), I may
     have missed a step or two.
 
     source:
     http://groups.google.com/group/comp.lang.python/msg/26f7b4fcb4d66c95
     by Paul McGuire
     """
     def __new__(meta, classname, bases, classDict):
         newClassDict = {}
         for attributeName, attribute in classDict.items():
             if type(attribute) == FunctionType:
                 # look through bases for matching function by name
                 for baseclass in bases:
                     if hasattr(baseclass, attributeName):
                         basefn = getattr(baseclass, attributeName)
                         if basefn.__doc__:
                             attribute.__doc__ = basefn.__doc__
                             break
             newClassDict[attributeName] = attribute
         return type.__new__(meta, classname, bases, newClassDict)
 
 
 class Converter(object):
     __metaclass__ = DocStringInheritor
     default_encoding = 'utf-8'
     extension = str()
     figures_counter = 0
     infile = str()
     infile_dir = str()
     infile_root = str()
     files_dir = str()
     with_preamble = True
     user_preamble = None
     output = unicode()
     raw_as_verbatim = False
     blank_symbol = " "
     # Which display data format is best? Subclasses can override if
     # they have specific requirements.
     display_data_priority = ['pdf', 'svg', 'png', 'jpg', 'text']
 
-    def __init__(self, infile):
+    def __init__(self, infile, highlight):
         self.infile = infile
+        self.highlight = highlight
         self.infile_dir, infile_root = os.path.split(infile)
         infile_root = os.path.splitext(infile_root)[0]
         self.clean_name = clean_filename(infile_root)
         files_dir = os.path.join(self.infile_dir, self.clean_name + '_files')
         if not os.path.isdir(files_dir):
             os.mkdir(files_dir)
         self.infile_root = infile_root
         self.files_dir = files_dir
         self.outbase = os.path.join(self.infile_dir, infile_root)
 
     def __del__(self):
         if os.path.isdir(self.files_dir) and not os.listdir(self.files_dir):
             os.rmdir(self.files_dir)
 
     def _get_prompt_number(self, cell):
         return cell.prompt_number if hasattr(cell, 'prompt_number') \
             else self.blank_symbol
 
     def dispatch(self, cell_type):
         """return cell_type dependent render method,  for example render_code
         """
         return getattr(self, 'render_' + cell_type, self.render_unknown)
 
     def dispatch_display_format(self, format):
         """
         return output_type dependent render method,  for example
         render_output_text
         """
         return getattr(self, 'render_display_format_' + format,
                        self.render_unknown_display)
 
     def convert(self, cell_separator='\n'):
         """
         Generic method to converts notebook to a string representation.
 
         This is accomplished by dispatching on the cell_type, so subclasses of
         Convereter class do not need to re-implement this method, but just
         need implementation for the methods that will be dispatched.
 
         Parameters
         ----------
         cell_separator : string
           Character or string to join cells with. Default is "\n"
 
         Returns
         -------
         out : string
         """
         lines = []
         lines.extend(self.optional_header())
         lines.extend(self.main_body(cell_separator))
         lines.extend(self.optional_footer())
         return u'\n'.join(lines)
 
     def main_body(self, cell_separator='\n'):
         converted_cells = []
         for worksheet in self.nb.worksheets:
             for cell in worksheet.cells:
                 #print(cell.cell_type)  # dbg
                 conv_fn = self.dispatch(cell.cell_type)
                 if cell.cell_type in ('markdown', 'raw'):
                     remove_fake_files_url(cell)
                 converted_cells.append('\n'.join(conv_fn(cell)))
         cell_lines = cell_separator.join(converted_cells).split('\n')
         return cell_lines
 
     def render(self):
         "read, convert, and save self.infile"
         if not hasattr(self, 'nb'):
             self.read()
         self.output = self.convert()
         assert(type(self.output) == unicode)
         return self.save()
 
     def read(self):
         "read and parse notebook into NotebookNode called self.nb"
         with open(self.infile) as f:
             self.nb = nbformat.read(f, 'json')
 
     def save(self, outfile=None, encoding=None):
         "read and parse notebook into self.nb"
         if outfile is None:
             outfile = self.outbase + '.' + self.extension
         if encoding is None:
             encoding = self.default_encoding
         with io.open(outfile, 'w', encoding=encoding) as f:
             f.write(self.output)
         return os.path.abspath(outfile)
 
     def optional_header(self):
         """
         Optional header to insert at the top of the converted notebook
 
         Returns a list
         """
         return []
 
     def optional_footer(self):
         """
         Optional footer to insert at the end of the converted notebook
 
         Returns a list
         """
         return []
 
     def _new_figure(self, data, fmt):
         """Create a new figure file in the given format.
 
         Returns a path relative to the input file.
         """
         figname = '%s_fig_%02i.%s' % (self.clean_name,
                                       self.figures_counter, fmt)
         self.figures_counter += 1
         fullname = os.path.join(self.files_dir, figname)
 
         # Binary files are base64-encoded, SVG is already XML
         if fmt in ('png', 'jpg', 'pdf'):
             data = data.decode('base64')
             fopen = lambda fname: open(fname, 'wb')
         else:
             fopen = lambda fname: codecs.open(fname, 'wb',
                                               self.default_encoding)
 
         with fopen(fullname) as f:
             f.write(data)
 
         return fullname
 
     def render_heading(self, cell):
         """convert a heading cell
 
         Returns list."""
         raise NotImplementedError
 
     def render_code(self, cell):
         """Convert a code cell
 
         Returns list."""
         raise NotImplementedError
 
     def render_markdown(self, cell):
         """convert a markdown cell
 
         Returns list."""
         raise NotImplementedError
 
     def _img_lines(self, img_file):
         """Return list of lines to include an image file."""
         # Note: subclasses may choose to implement format-specific _FMT_lines
         # methods if they so choose (FMT in {png, svg, jpg, pdf}).
         raise NotImplementedError
 
     def render_display_data(self, output):
         """convert display data from the output of a code cell
 
         Returns list.
         """
         for fmt in self.display_data_priority:
             if fmt in output:
                 break
         else:
             for fmt in output:
                 if fmt != 'output_type':
                     break
             else:
                 raise RuntimeError('no display data')
 
         # Is it an image?
         if fmt in ['png', 'svg', 'jpg', 'pdf']:
             img_file = self._new_figure(output[fmt], fmt)
             # Subclasses can have format-specific render functions (e.g.,
             # latex has to auto-convert all SVG to PDF first).
             lines_fun = getattr(self, '_%s_lines' % fmt, None)
             if not lines_fun:
                 lines_fun = self._img_lines
             lines = lines_fun(img_file)
         else:
             lines_fun = self.dispatch_display_format(fmt)
             lines = lines_fun(output)
 
         return lines
 
     def render_raw(self, cell):
         """convert a cell with raw text
 
         Returns list."""
         raise NotImplementedError
 
     def render_unknown(self, cell):
         """Render cells of unkown type
 
         Returns list."""
         data = pprint.pformat(cell)
         logging.warning('Unknown cell: %s' % cell.cell_type)
         return self._unknown_lines(data)
 
     def render_unknown_display(self, output, type):
         """Render cells of unkown type
 
         Returns list."""
         data = pprint.pformat(output)
         logging.warning('Unknown output: %s' % output.output_type)
         return self._unknown_lines(data)
 
     def render_stream(self, output):
         """render the stream part of an output
 
         Returns list.
 
         Identical to render_display_format_text
         """
         return self.render_display_format_text(output)
 
     def render_pyout(self, output):
         """convert pyout part of a code cell
 
         Returns list."""
         raise NotImplementedError
 
     def render_pyerr(self, output):
         """convert pyerr part of a code cell
 
         Returns list."""
         raise NotImplementedError
 
     def _unknown_lines(self, data):
         """Return list of lines for an unknown cell.
 
         Parameters
         ----------
         data : str
           The content of the unknown data as a single string.
         """
         raise NotImplementedError
 
     # These are the possible format types in an output node
 
     def render_display_format_text(self, output):
         """render the text part of an output
 
         Returns list.
         """
         raise NotImplementedError
 
     def render_display_format_html(self, output):
         """render the html part of an output
 
         Returns list.
         """
         raise NotImplementedError
 
     def render_display_format_latex(self, output):
         """render the latex part of an output
 
         Returns list.
         """
         raise NotImplementedError
 
     def render_display_format_json(self, output):
         """render the json part of an output
 
         Returns list.
         """
         raise NotImplementedError
 
     def render_display_format_javascript(self, output):
         """render the javascript part of an output
 
         Returns list.
         """
         raise NotImplementedError

converters/html.py

@@ -1,185 +1,185 b''
 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 = ' '
 
     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))
+        lines.append(highlight(cell.input) if self.highlight 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

@@ -1,85 +1,86 b''
 #!/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):
+def main(infile, highlight, format='rst', preamble=None, exclude=None):
     """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)
+    converter = ConverterClass(infile, highlight)
     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('-p', '--plain_output', action='store_false',
+                        help='Plain output which will contain no syntax highlighting.')
     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)
+    main(infile=args.infile[0], highlight=args.plain_output,
+         format=args.format, preamble=args.preamble, exclude=exclude_cells)