Replace ad-hoc/broken code with safe method to extract the prompt_number of a cell.

The helper function returns the converter's blank symbol (' ' for HTML,
space for other converters) if the cell doesn't have a prompt_number.

converters/base.py

@@ -1,323 +1,328 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
 from types import FunctionType
 
 # From IPython
 from IPython.nbformat import current as nbformat
 
 # local
 
 #-----------------------------------------------------------------------------
 # 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 = " "
 
     def __init__(self, infile):
         self.infile = infile
         self.infile_dir, infile_root = os.path.split(infile)
         infile_root = os.path.splitext(infile_root)[0]
         files_dir = os.path.join(self.infile_dir, infile_root + '_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.infile_root,
                                       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.
         """
         lines = []
 
         for fmt in output.keys():
             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.extend(lines_fun(img_file))
             elif fmt != 'output_type':
                 conv_fn = self.dispatch_display_format(fmt)
                 lines.extend(conv_fn(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,183 +1,183 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':
-            n = output.prompt_number if output.prompt_number is not None else '&nbsp;'
-            content = 'Out[%s]:' % n
+            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 = cell.prompt_number if getattr(cell, 'prompt_number', None) is not None else '&nbsp;'
+        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('</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/markdown.py

@@ -1,90 +1,91 b''
 from converters.base import Converter
 from converters.utils import highlight, remove_ansi
 from IPython.utils.text import indent
 
 class ConverterMarkdown(Converter):
     extension = 'md'
 
     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 and not self.inline_prompt:
-            lines.extend(['*In[%s]:*' % cell.prompt_number, ''])
+            lines.extend(['*In[%s]:*' % n, ''])
         if self.show_prompts and self.inline_prompt:
-            prompt = 'In[%s]: ' % cell.prompt_number
+            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]:*' % cell.prompt_number, ''])
+            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]:*' % output.prompt_number, ''])
+        ##     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/python.py

@@ -1,104 +1,100 b''
 from converters.base import Converter
 from IPython.utils.text import indent
 from converters.utils import remove_ansi
 
 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):
-        try:
-            prompt_number = cell.prompt_number
-        except AttributeError:
-            prompt_number = " "
-
+        n = self._get_prompt_number(cell)
         if not cell.input:
             return []
         lines = []
         if self.show_prompts:
-            lines.extend(['# In[%s]:' % prompt_number])
+            lines.extend(['# In[%s]:' % n])
         src = cell.input
         lines.extend([src, ''])
         if self.show_output:
             if cell.outputs :
-                lines.extend(['# Out[%s]:' % prompt_number])
+                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]:*' % output.prompt_number, ''])
+        ##     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,79 +1,74 b''
 from converters.base import Converter
 from converters.utils import markdown2rst, rst_directive, remove_ansi
 from IPython.utils.text import indent
 
 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 []
 
-        try:
-            prompt_number = cell.prompt_number
-        except AttributeError:
-            prompt_number = " "
-
-        lines = ['In[%s]:' % prompt_number, '']
+        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]:' % output.prompt_number, '']
+        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)