More descriptive comment headers.

converters/bloggerhtml.py

@@ -1,46 +1,46 b''
 """Notebook export in Blogger-aware HTML.
 
 This file contains `ConverterBloggerHTML`, a subclass of `ConverterHTML` that
 provides output suitable for easy pasting into a blog hosted on the Blogger
 platform. See the class docstring for more information.
 """
 #-----------------------------------------------------------------------------
 # 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.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # Stdlib imports
 import io
 
 # Our own imports
 from converters.html import ConverterHTML
 
 
 #-----------------------------------------------------------------------------
-# Classes and functions
+# Classes declarations
 #-----------------------------------------------------------------------------
 
 class ConverterBloggerHTML(ConverterHTML):
     """Convert a notebook to html suitable for easy pasting into Blogger.
 
     It generates an html file that has *only* the pure HTML contents, and a
     separate file with `_header` appended to the name with all header contents.
     Typically, the header file only needs to be used once when setting up a
     blog, as the CSS for all posts is stored in a single location in Blogger.
     """
 
     def optional_header(self):
         with io.open(self.outbase + '_header.html', 'w',
                      encoding=self.default_encoding) as f:
             f.write('\n'.join(self.header_body()))
         return []
 
     def optional_footer(self):
         return []

converters/html.py

@@ -1,213 +1,213 b''
 """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 converters.base import Converter
 from converters.utils import text_cell, output_container
 from converters.utils import highlight, coalesce_streams, ansi2html
 
 
 #-----------------------------------------------------------------------------
-# Classes and functions
+# Class declarations
 #-----------------------------------------------------------------------------
 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) 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]

converters/latex.py

@@ -1,228 +1,228 b''
 """Notebook export to LaTeX.
 
 This file implements a converter class for rendering IPython notebooks as
 LaTeX, suitable for rendering by pdflatex.
 """
 #-----------------------------------------------------------------------------
 # 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.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # Stdlib imports
 import os
 import subprocess
 import sys
 
 # Our own imports
 from converters.base import Converter
 from converters.utils import markdown2latex, remove_ansi
 
 
 #-----------------------------------------------------------------------------
 # Globals and constants
 #-----------------------------------------------------------------------------
 
 # XXX: This is a hack that needs to be addressed in a more principled fashion.
 inkscape = 'inkscape'
 if sys.platform == 'darwin':
     inkscape = '/Applications/Inkscape.app/Contents/Resources/bin/inkscape'
     if not os.path.exists(inkscape):
         inkscape = None
 
 
 #-----------------------------------------------------------------------------
-# Classes and functions
+# Class declarations
 #-----------------------------------------------------------------------------
 
 class ConverterLaTeX(Converter):
     """Converts a notebook to a .tex file suitable for pdflatex.
 
     Note: this converter *needs*:
 
     - `pandoc`: for all conversion of markdown cells.  If your notebook only
        has Raw cells, pandoc will not be needed.
 
     -  `inkscape`: if your notebook has SVG figures.  These need to be
        converted to PDF before inclusion in the TeX file, as LaTeX doesn't
        understand SVG natively.
 
     You will in general obtain much better final PDF results if you configure
     the matplotlib backend to create SVG output with
 
     %config InlineBackend.figure_format = 'svg'
 
     (or set the equivalent flag at startup or in your configuration profile).
     """
     inkscape = inkscape
     extension = 'tex'
     documentclass = 'article'
     documentclass_options = '11pt,english'
     heading_map = {1: r'\section',
                    2: r'\subsection',
                    3: r'\subsubsection',
                    4: r'\paragraph',
                    5: r'\subparagraph',
                    6: r'\subparagraph'}
     user_preamble = None
     exclude_cells = []
 
     def in_env(self, environment, lines):
         """Return list of environment lines for input lines
 
         Parameters
         ----------
         env : string
           Name of the environment to bracket with begin/end.
 
         lines: """
         out = [ur'\begin{%s}' % environment]
         if isinstance(lines, basestring):
             out.append(lines)
         else:  # list
             out.extend(lines)
         out.append(ur'\end{%s}' % environment)
         return out
 
     def convert(self, *args, **kwargs):
         # The main body is done by the logic in the parent class, and that's
         # all we need if preamble support has been turned off.
         body = super(ConverterLaTeX, self).convert(*args, **kwargs)
         if not self.with_preamble:
             return body
         # But if preamble is on, then we need to construct a proper, standalone
         # tex file.
 
         # Tag the document at the top and set latex class
         final = [r'%% This file was auto-generated by IPython, do NOT edit',
                  r'%% Conversion from the original notebook file:',
                  r'%% {0}'.format(self.infile),
                  r'%%',
                  r'\documentclass[%s]{%s}' % (self.documentclass_options,
                                               self.documentclass),
                  '',
                  ]
         # Load our own preamble, which is stored next to the main file.  We
         # need to be careful in case the script entry point is a symlink
         myfile = os.path.realpath(__file__)
         preamble = '../preamble.tex'
         with open(os.path.join(os.path.dirname(myfile), preamble)) as f:
             final.append(f.read())
 
         # Load any additional user-supplied preamble
         if self.user_preamble:
             final.extend(['', '%% Adding user preamble from file:',
                           '%% {0}'.format(self.user_preamble), ''])
             with open(self.user_preamble) as f:
                 final.append(f.read())
 
         # Include document body
         final.extend([r'\begin{document}', '',
                       body,
                       r'\end{document}', ''])
         # Retun value must be a string
         return '\n'.join(final)
 
     def render_heading(self, cell):
         marker = self.heading_map[cell.level]
         return ['%s{%s}' % (marker, cell.source)]
 
     def render_code(self, cell):
         if not cell.input:
             return []
 
         # Cell codes first carry input code, we use lstlisting for that
         lines = [ur'\begin{codecell}']
 
         if 'source' not in self.exclude_cells:
             lines.extend(self.in_env('codeinput',
                                      self.in_env('lstlisting', cell.input)))
         else:
             # Empty output is still needed for LaTeX formatting
             lines.extend(self.in_env('codeinput', ''))
 
         outlines = []
         if 'output' not in self.exclude_cells:
             for output in cell.outputs:
                 conv_fn = self.dispatch(output.output_type)
                 outlines.extend(conv_fn(output))
 
         # And then output of many possible types; use a frame for all of it.
         if outlines:
             lines.extend(self.in_env('codeoutput', outlines))
 
         lines.append(ur'\end{codecell}')
 
         return lines
 
     def _img_lines(self, img_file):
         return self.in_env('center',
                 [r'\includegraphics[width=6in]{%s}' % img_file, r'\par'])
 
     def _svg_lines(self, img_file):
         base_file = os.path.splitext(img_file)[0]
         pdf_file = base_file + '.pdf'
         subprocess.check_call([self.inkscape, '--export-pdf=%s' % pdf_file,
                                img_file])
         return self._img_lines(pdf_file)
 
     def render_markdown(self, cell):
         return [markdown2latex(cell.source)]
 
     def render_pyout(self, output):
         lines = []
 
         # output is a dictionary like object with type as a key
         if 'latex' in output:
             lines.extend(output.latex)
 
         if 'text' in output:
             lines.extend(self.in_env('verbatim', output.text))
 
         return lines
 
     def render_pyerr(self, output):
         # Note: a traceback is a *list* of frames.
         return self.in_env('traceback',
                         self.in_env('verbatim',
                                  remove_ansi('\n'.join(output.traceback))))
 
     def render_raw(self, cell):
         if self.raw_as_verbatim:
             return self.in_env('verbatim', cell.source)
         else:
             return [cell.source]
 
     def _unknown_lines(self, data):
         return [r'{\vspace{5mm}\bf WARNING:: unknown cell:}'] + \
           self.in_env('verbatim', data)
 
     def render_display_format_text(self, output):
         lines = []
 
         if 'text' in output:
             lines.extend(self.in_env('verbatim', output.text.strip()))
 
         return lines
 
     def render_display_format_html(self, output):
         return []
 
     def render_display_format_latex(self, output):
         if type(output.latex) == type([]):
             return output.latex
         return [output.latex]
 
     def render_display_format_json(self, output):
         # latex ignores json
         return []
 
     def render_display_format_javascript(self, output):
         # latex ignores javascript
         return []

converters/lexers.py

@@ -1,38 +1,38 b''
 """A custom pygments lexer for IPython code cells.
 
 Informs The pygments highlighting library of the quirks of IPython's superset
 of Python -- magic commands, !shell commands, etc.
 """
 #-----------------------------------------------------------------------------
 # 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.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # Third-party imports
 from pygments.lexers import PythonLexer, BashLexer
 from pygments.lexer import bygroups, using
 from pygments.token import Keyword, Operator, Text
 
 
 #-----------------------------------------------------------------------------
-# Classes
+# Class declarations
 #-----------------------------------------------------------------------------
 
 class IPythonLexer(PythonLexer):
     name = 'IPython'
     aliases = ['ip', 'ipython']
     filenames = ['*.ipy']
     tokens = PythonLexer.tokens.copy()
     tokens['root'] = [
         (r'(\%+)(\w+)\s+(\.*)(\n)', bygroups(Operator, Keyword,
                                              using(BashLexer), Text)),
         (r'(\%+)(\w+)\b', bygroups(Operator, Keyword)),
         (r'^(!)(.+)(\n)', bygroups(Operator, using(BashLexer), Text)),
     ] + tokens['root']

converters/markdown.py

@@ -1,120 +1,120 b''
 """Converter implementing Markdown export.
 
 Implements a Converter that allows IPython notebooks to reasonably rendered
 as a Markdown document.
 """
 #-----------------------------------------------------------------------------
 # 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.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # Our own imports
 from converters.base import Converter
 from converters.utils import highlight, remove_ansi
 from IPython.utils.text import indent
 
 
 #-----------------------------------------------------------------------------
-# Classes and functions
+# Class declarations
 #-----------------------------------------------------------------------------
 class ConverterMarkdown(Converter):
     extension = 'md'
     # show_prompts controls the display of In[} and Out[] prompts for code
     # cells.
     show_prompts = False
     # If inline_prompt is False, display prompts on a separate line.
     inline_prompt = False
 
     def __init__(self, infile, highlight_source=True, show_prompts=False,
                  inline_prompt=False):
         super(ConverterMarkdown, self).__init__(infile)
         self.highlight_source = highlight_source
         self.show_prompts = show_prompts
         self.inline_prompt = inline_prompt
 
     def render_heading(self, cell):
         return ['{0} {1}'.format('#' * cell.level, cell.source), '']
 
     def render_code(self, cell):
         if not cell.input:
             return []
         lines = []
         n = self._get_prompt_number(cell)
         if self.show_prompts:
             if not self.inline_prompt:
                 lines.extend(['*In[%s]:*' % n, ''])
             else:
                 prompt = 'In[%s]: ' % n
                 input_lines = cell.input.split('\n')
                 src = (prompt + input_lines[0] + '\n' +
                        indent('\n'.join(input_lines[1:]), nspaces=len(prompt)))
         else:
             src = cell.input
         src = highlight(src) if self.highlight_source else indent(src)
         lines.extend([src, ''])
         if cell.outputs and self.show_prompts and not self.inline_prompt:
             lines.extend(['*Out[%s]:*' % n, ''])
         for output in cell.outputs:
             conv_fn = self.dispatch(output.output_type)
             lines.extend(conv_fn(output))
 
         #lines.append('----')
         lines.append('')
         return lines
 
     def render_markdown(self, cell):
         return [cell.source, '']
 
     def render_raw(self, cell):
         if self.raw_as_verbatim:
             return [indent(cell.source), '']
         else:
             return [cell.source, '']
 
     def render_pyout(self, output):
         lines = []
 
         ## if 'text' in output:
         ##     lines.extend(['*Out[%s]:*' % self._get_prompt_number(cell), ''])
 
         # output is a dictionary like object with type as a key
         if 'latex' in output:
             pass
 
         if 'text' in output:
             lines.extend(['<pre>', indent(output.text), '</pre>'])
 
         lines.append('')
         return lines
 
     def render_pyerr(self, output):
         # Note: a traceback is a *list* of frames.
         return [indent(remove_ansi('\n'.join(output.traceback))), '']
 
     def _img_lines(self, img_file):
         return ['', '![](%s)' % img_file, '']
 
     def render_display_format_text(self, output):
         return [indent(output.text)]
 
     def _unknown_lines(self, data):
         return ['Warning: Unknown cell', data]
 
     def render_display_format_html(self, output):
         return [output.html]
 
     def render_display_format_latex(self, output):
         return ['LaTeX::', indent(output.latex)]
 
     def render_display_format_json(self, output):
         return ['JSON:', indent(output.json)]
 
     def render_display_format_javascript(self, output):
         return ['JavaScript:', indent(output.javascript)]

converters/notebook.py

@@ -1,107 +1,107 b''
 """Base class for doing notebook-to-notebook transformations.
 
 This implements a converter class that turns an IPython notebook into another
 IPython notebook, mainly so that it can be subclassed to perform more useful
 and sophisticated transformations.
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2011, 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
 #-----------------------------------------------------------------------------
 
 # Stdlib imports
 import json
 import os
 from shutil import rmtree
 
 # Our own imports
 from converters.base import Converter
 from converters.utils import cell_to_lines
 
 
 #-----------------------------------------------------------------------------
-# Classes and functions
+# Class declarations
 #-----------------------------------------------------------------------------
 class ConverterNotebook(Converter):
     """
     A converter that is essentially a null-op.
     This exists so it can be subclassed
     for custom handlers of .ipynb files
     that create new .ipynb files.
 
     What distinguishes this from JSONWriter is that
     subclasses can specify what to do with each type of cell.
 
     Writes out a notebook file.
 
     """
     extension = 'ipynb'
 
     def __init__(self, infile, outbase):
         Converter.__init__(self, infile)
         self.outbase = outbase
         rmtree(self.files_dir)
 
     def convert(self):
         return unicode(json.dumps(json.loads(Converter.convert(self, ',')),
                                   indent=1, sort_keys=True))
 
     def optional_header(self):
         s = \
 """{
  "metadata": {
  "name": "%(name)s"
  },
  "nbformat": 3,
  "worksheets": [
  {
  "cells": [""" % {'name': os.path.basename(self.outbase)}
         return s.split('\n')
 
     def optional_footer(self):
         s = \
 """]
   }
  ]
 }"""
         return s.split('\n')
 
     def render_heading(self, cell):
         return cell_to_lines(cell)
 
     def render_code(self, cell):
         return cell_to_lines(cell)
 
     def render_markdown(self, cell):
         return cell_to_lines(cell)
 
     def render_raw(self, cell):
         return cell_to_lines(cell)
 
     def render_pyout(self, output):
         return cell_to_lines(output)
 
     def render_pyerr(self, output):
         return cell_to_lines(output)
 
     def render_display_format_text(self, output):
         return [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):
         return [output.json]
 
     def render_display_format_javascript(self, output):
         return [output.javascript]

converters/python.py

@@ -1,125 +1,125 b''
 """Notebook export to .py source code files.
 
 Since Python export is provided in the notebook itself (provided by classes
 in `IPython.nbformat`), this class serves mainly as a base class for other
 converters that may wish to implement cell-type-specific behaviors.
 """
 #-----------------------------------------------------------------------------
 # 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.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # IPython imports
 from IPython.utils.text import indent
 
 # Our own imports
 from converters.base import Converter
 from converters.utils import remove_ansi
 
 
 #-----------------------------------------------------------------------------
-# Classes and functions
+# Class declarations
 #-----------------------------------------------------------------------------
 class ConverterPy(Converter):
     """
     A converter that takes a notebook and converts it to a .py file.
 
     What distinguishes this from PyWriter and PyReader in IPython.nbformat is
     that subclasses can specify what to do with each type of cell.
     Additionally, unlike PyWriter, this does not preserve the '# <markdown>'
     opening and closing comments style comments in favor of a cleaner looking
     python program.
 
     Note:
         Even though this produces a .py file, it is not guaranteed to be valid
         python file, since the notebook may be using magics and even cell
         magics.
     """
     extension = 'py'
 
     def __init__(self, infile, show_prompts=True, show_output=True):
         super(ConverterPy, self).__init__(infile)
         self.show_prompts = show_prompts
         self.show_output = show_output
 
     @staticmethod
     def comment(input):
         "returns every line in input as commented out"
         return "# " + input.replace("\n", "\n# ")
 
     def render_heading(self, cell):
         return ['#{0} {1}'.format('#' * cell.level, cell.source), '']
 
     def render_code(self, cell):
         n = self._get_prompt_number(cell)
         if not cell.input:
             return []
         lines = []
         if self.show_prompts:
             lines.extend(['# In[%s]:' % n])
         src = cell.input
         lines.extend([src, ''])
         if self.show_output:
             if cell.outputs:
                 lines.extend(['# Out[%s]:' % n])
             for output in cell.outputs:
                 conv_fn = self.dispatch(output.output_type)
                 lines.extend(conv_fn(output))
         return lines
 
     def render_markdown(self, cell):
         return [self.comment(cell.source), '']
 
     def render_raw(self, cell):
         if self.raw_as_verbatim:
             return [self.comment(indent(cell.source)), '']
         else:
             return [self.comment(cell.source), '']
 
     def render_pyout(self, output):
         lines = []
 
         ## if 'text' in output:
         ##     lines.extend(['*Out[%s]:*' % self._get_prompt_number(cell), ''])
 
         # output is a dictionary like object with type as a key
         if 'latex' in output:
             pass
 
         if 'text' in output:
             lines.extend([self.comment(indent(output.text)), ''])
 
         lines.append('')
         return lines
 
     def render_pyerr(self, output):
         # Note: a traceback is a *list* of frames.
         return [indent(remove_ansi('\n'.join(output.traceback))), '']
 
     def _img_lines(self, img_file):
         return [self.comment('image file: %s' % img_file), '']
 
     def render_display_format_text(self, output):
         return [self.comment(indent(output.text))]
 
     def _unknown_lines(self, data):
         return [self.comment('Warning: Unknown cell' + str(data))]
 
     def render_display_format_html(self, output):
         return [self.comment(output.html)]
 
     def render_display_format_latex(self, output):
         return []
 
     def render_display_format_json(self, output):
         return []
 
     def render_display_format_javascript(self, output):
         return []

converters/rst.py

@@ -1,96 +1,96 b''
 """Notebook export to reStructuredText (rST).
 
 This file provides a converter class for rendering IPython notebooks as valid
 reStructuredText, suitable for inclusion in e.g. Sphinx documentation.
 """
 #-----------------------------------------------------------------------------
 # 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.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # IPython imports
 from IPython.utils.text import indent
 
 # Our own imports
 from converters.base import Converter
 from converters.utils import markdown2rst, rst_directive, remove_ansi
 
 
 #-----------------------------------------------------------------------------
-# Classes and functions
+# Class declarations
 #-----------------------------------------------------------------------------
 class ConverterRST(Converter):
     extension = 'rst'
     heading_level = {1: '=', 2: '-', 3: '`', 4: '\'', 5: '.', 6: '~'}
 
     def render_heading(self, cell):
         marker = self.heading_level[cell.level]
         return ['{0}\n{1}\n'.format(cell.source, marker * len(cell.source))]
 
     def render_code(self, cell):
         # Note: cell has type 'IPython.nbformat.v3.nbbase.NotebookNode'
         if not cell.input:
             return []
 
         lines = ['In[%s]:' % self._get_prompt_number(cell), '']
         lines.extend(rst_directive('.. code:: python', cell.input))
 
         for output in cell.outputs:
             conv_fn = self.dispatch(output.output_type)
             lines.extend(conv_fn(output))
 
         return lines
 
     def render_markdown(self, cell):
         #return [cell.source]
         return [markdown2rst(cell.source)]
 
     def render_raw(self, cell):
         if self.raw_as_verbatim:
             return ['::', '', indent(cell.source), '']
         else:
             return [cell.source]
 
     def render_pyout(self, output):
         lines = ['Out[%s]:' % self._get_prompt_number(output), '']
 
         # output is a dictionary like object with type as a key
         if 'latex' in output:
             lines.extend(rst_directive('.. math::', output.latex))
 
         if 'text' in output:
             lines.extend(rst_directive('.. parsed-literal::', output.text))
 
         return lines
 
     def render_pyerr(self, output):
         # Note: a traceback is a *list* of frames.
         return ['::', '', indent(remove_ansi('\n'.join(output.traceback))), '']
 
     def _img_lines(self, img_file):
         return ['.. image:: %s' % img_file, '']
 
     def render_display_format_text(self, output):
         return rst_directive('.. parsed-literal::', output.text)
 
     def _unknown_lines(self, data):
         return rst_directive('.. warning:: Unknown cell') + [data]
 
     def render_display_format_html(self, output):
         return rst_directive('.. raw:: html', output.html)
 
     def render_display_format_latex(self, output):
         return rst_directive('.. math::', output.latex)
 
     def render_display_format_json(self, output):
         return rst_directive('.. raw:: json', output.json)
 
     def render_display_format_javascript(self, output):
         return rst_directive('.. raw:: javascript', output.javascript)