Quick fix for failing tests. This will be cleaned up soon.

This is only a quick fix to make the tests pass. Note that some tests
which access the 'prompt_number' attribute were not affected by the
additional unexecuted cell in tests/test.ipynb which was added in
commit ec19b407dee30fb7e692ce753af9fc5bd3808f8f. So this probably
indicates that not all corner cases are covered.

converters/python.py

@@ -1,99 +1,104 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 = " "
+
         if not cell.input:
             return []
         lines = []
         if self.show_prompts:
-            lines.extend(['# In[%s]:' % cell.prompt_number])
+            lines.extend(['# In[%s]:' % prompt_number])
         src = cell.input
         lines.extend([src, ''])
         if self.show_output:
             if cell.outputs :
-                lines.extend(['# Out[%s]:' % cell.prompt_number])
+                lines.extend(['# Out[%s]:' % prompt_number])
             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, ''])
 
         # 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,73 +1,79 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 []
 
-        lines = ['In[%s]:' % cell.prompt_number, '']
+        try:
+            prompt_number = cell.prompt_number
+        except AttributeError:
+            prompt_number = " "
+
+        lines = ['In[%s]:' % prompt_number, '']
         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, '']
 
         # 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)