PEP8

converters/base.py

@@ -1,323 +1,323 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
-    
+
     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 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, 
+        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/notebook.py

@@ -1,82 +1,82 b''
 from converters.base import Converter
 from converters.utils import cell_to_lines
 from shutil import rmtree
 import json
 
 class ConverterNotebook(Converter):
     """
     A converter that is essentially a null-op.
     This exists so it can be subclassed
-    for custom handlers of .ipynb files 
+    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':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]

tests/test_references.py

@@ -1,46 +1,48 b''
 import os
 import io
 import nose.tools as nt
-from nbconvert import *
+from nbconvert import (
+    ConverterLaTeX, ConverterMarkdown, ConverterPy, ConverterHTML
+)
 from nose.tools import nottest
 
 
 def test_evens():
-    ###### 
-    # for now, we don't need to really run inkscape to extract svg 
+    ######
+    # for now, we don't need to really run inkscape to extract svg
     # from file, on unix, for test, we monkeypathc it to 'true'
     # which does not fail as doing anything.
     ####
     ConverterLaTeX.inkscape = 'true'
 
-    # commenting rst for now as travis build 
+    # commenting rst for now as travis build
     # fail because of pandoc version.
     converters = [
                  #(ConverterRST,'rst'),
-                  (ConverterMarkdown,'md'),
-                  (ConverterLaTeX,'tex'),
-                  (ConverterPy,'py'),
-                  (ConverterHTML,'html')
+                  (ConverterMarkdown, 'md'),
+                  (ConverterLaTeX, 'tex'),
+                  (ConverterPy, 'py'),
+                  (ConverterHTML, 'html')
                 ]
     reflist = [
             'tests/ipynbref/IntroNumPy.orig'
             ]
-    for root in reflist :
-        for conv,ext in converters:
-            yield test_conversion, conv,root+'.ipynb',root+'.'+ext
+    for root in reflist:
+        for conv, ext in converters:
+            yield test_conversion, conv, root + '.ipynb', root + '.' + ext
+
 
 @nottest
 def compfiles(stra, strb):
-    nt.assert_equal(map(unicode.strip,stra.split('\n')),map(unicode.strip,strb.split('\n')))
+    nt.assert_equal(map(unicode.strip, stra.split('\n')),
+                    map(unicode.strip, strb.split('\n')))
+
 
 @nottest
 def test_conversion(ConverterClass, ipynb, ref_file):
-
     converter = ConverterClass(ipynb)
     converter.read()
-    cv =converter.convert()
+    cv = converter.convert()
     with io.open(ref_file) as ref:
         value = ref.read()
-        compfiles(cv,value)
-    
-
+        compfiles(cv, value)

tests/test_simple.py

@@ -1,70 +1,71 b''
 from nbconvert import ConverterRST, main
 import nose.tools as nt
 
 import os
 import glob
 from IPython.nbformat import current as nbformat
 
 fname = 'tests/test.ipynb'
 out_fname = 'tests/test.rst'
 
 
 def clean_dir():
     "Remove .rst files created during conversion"
     map(os.remove, glob.glob("./tests/*.rst"))
     map(os.remove, glob.glob("./tests/*.png"))
     map(os.remove, glob.glob("./tests/*.html"))
     map(os.remove, glob.glob("./tests/test_files/*"))
 
 
 @nt.with_setup(clean_dir, clean_dir)
 def test_simple():
     c = ConverterRST(fname)
     f = c.render()
     nt.assert_true('rst' in f, 'changed file extension to rst')
 
 
 @nt.with_setup(clean_dir, clean_dir)
 def test_main():
     """
     Test main entry point
     """
     main(fname)
     nt.assert_true(os.path.exists(out_fname))
 
 
 def test_render_heading():
     """ Unit test for cell type "heading" """
     # Generate and test heading cells level 1-6
     for level in xrange(1, 7):
         cell = {
             'cell_type': 'heading',
-            'level'    : level,
-            'source'   :  ['Test for heading type H{0}'.format(level)]
+            'level': level,
+            'source':  ['Test for heading type H{0}'.format(level)]
             }
         # Convert cell dictionaries to NotebookNode
         cell_nb = nbformat.NotebookNode(cell)
         # Make sure "source" attribute is uniconde not list.
         # For some reason, creating a NotebookNode manually like
         # this isn't converting source to a string like using
         # the create-from-file routine.
         if type(cell_nb.source) is list:
             cell_nb.source = '\n'.join(cell_nb.source)
         # Render to rst
         c = ConverterRST('')
         rst_list = c.render_heading(cell_nb)
-        nt.assert_true(isinstance(rst_list, list))  # render should return a list
+        # render should return a list
+        nt.assert_true(isinstance(rst_list, list))
         rst_str = "".join(rst_list)
         # Confirm rst content
         chk_str = "Test for heading type H{0}\n{1}\n".format(
              level, c.heading_level[level] * 24)
         nt.assert_equal(rst_str, chk_str)
 
 
 @nt.with_setup(clean_dir, clean_dir)
 def test_main_html():
     """
     Test main entry point
     """
     main(fname, format='html')
     nt.assert_true(os.path.exists('tests/test.html'))