PEP8-ify several files

converters/base.py

@@ -18,9 +18,11 b' from IPython.nbformat import current as nbformat'
 # Class declarations
 #-----------------------------------------------------------------------------
 
+
 class ConversionException(Exception):
     pass
 
+
 class DocStringInheritor(type):
     """
     This metaclass will walk the list of bases until the desired
@@ -50,6 +52,7 b' class DocStringInheritor(type):'
             newClassDict[attributeName] = attribute
         return type.__new__(meta, classname, bases, newClassDict)
 
+
 class Converter(object):
     __metaclass__ = DocStringInheritor
     default_encoding = 'utf-8'
@@ -85,9 +88,12 b' class Converter(object):'
         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)
+        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'):
         """
@@ -178,7 +184,8 b' class Converter(object):'
             data = data.decode('base64')
             fopen = lambda fname: open(fname, 'wb')
         else:
-            fopen = lambda fname: codecs.open(fname, 'wb', self.default_encoding)
+            fopen = lambda fname: codecs.open(fname, 'wb',
+                                              self.default_encoding)
 
         with fopen(fullname) as f:
             f.write(data)
@@ -267,7 +274,6 b' class Converter(object):'
         Returns list."""
         raise NotImplementedError
 
-
     def render_pyerr(self, output):
         """convert pyerr part of a code cell
 
@@ -320,4 +326,3 b' class Converter(object):'
         Returns list.
         """
         raise NotImplementedError
-

converters/bloggerhtml.py

@@ -1,6 +1,7 b''
-from converters.html import ConverterHTML 
+from converters.html import ConverterHTML
 import io
 
+
 class ConverterBloggerHTML(ConverterHTML):
     """Convert a notebook to html suitable for easy pasting into Blogger.
 
@@ -9,7 +10,7 b' class ConverterBloggerHTML(ConverterHTML):'
     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:
@@ -18,4 +19,3 b' class ConverterBloggerHTML(ConverterHTML):'
 
     def optional_footer(self):
         return []
-

converters/rst.py

@@ -2,6 +2,7 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: '~'}
@@ -51,7 +52,7 b' class ConverterRST(Converter):'
 
     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)
 
@@ -67,7 +68,5 b' class ConverterRST(Converter):'
     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)
-

converters/utils.py

@@ -12,23 +12,26 b' from IPython.utils.text import indent'
 from IPython.utils import path, py3compat
 from IPython.nbformat.v3.nbjson import BytesEncoder
 
+
 #-----------------------------------------------------------------------------
 # Utility functions
 #-----------------------------------------------------------------------------
 def highlight(src, lang='ipython'):
-    """Return a syntax-highlighted version of the input source.
+    """
+    Return a syntax-highlighted version of the input source.
     """
     from pygments import highlight
     from pygments.lexers import get_lexer_by_name
     from pygments.formatters import HtmlFormatter
-    
+
     if lang == 'ipython':
         lexer = IPythonLexer()
     else:
         lexer = get_lexer_by_name(lang, stripall=True)
-        
+
     return highlight(src, lexer, HtmlFormatter())
 
+
 def output_container(f):
     """add a prompt-area next to an output"""
     def wrapped(self, output):
@@ -41,18 +44,19 b' def output_container(f):'
         lines.extend(self._out_prompt(output))
         classes = "output_subarea output_%s" % output.output_type
         if 'html' in output.keys():
-            classes +=  ' output_html rendered_html'
+            classes += ' output_html rendered_html'
         if output.output_type == 'stream':
             classes += " output_%s" % output.stream
         lines.append('<div class="%s">' % classes)
         lines.extend(rendered)
-        lines.append('</div>') # subarea
-        lines.append('</div>') # output_area
-        
+        lines.append('</div>')  # subarea
+        lines.append('</div>')  # output_area
+
         return lines
-    
+
     return wrapped
 
+
 def text_cell(f):
     """wrap text cells in appropriate divs"""
     def wrapped(self, cell):
@@ -88,9 +92,9 b' def remove_ansi(src):'
 
 def ansi2html(txt):
     """Render ANSI colors as HTML colors
-    
+
     This is equivalent to util.fixConsole in utils.js
-    
+
     Parameters
     ----------
     txt : string
@@ -99,7 +103,7 b' def ansi2html(txt):'
     -------
     string
     """
-    
+
     ansi_colormap = {
         '30': 'ansiblack',
         '31': 'ansired',
@@ -111,7 +115,7 b' def ansi2html(txt):'
         '37': 'ansigrey',
         '01': 'ansibold',
     }
-    
+
     # do ampersand first
     txt = txt.replace('&', '&amp;')
     html_escapes = {
@@ -123,7 +127,7 b' def ansi2html(txt):'
     }
     for c, escape in html_escapes.iteritems():
         txt = txt.replace(c, escape)
-    
+
     ansi_re = re.compile('\x1b' + r'\[([\dA-Fa-f;]*?)m')
     m = ansi_re.search(txt)
     opened = False
@@ -133,20 +137,22 b' def ansi2html(txt):'
     while m:
         cmds = m.groups()[0].split(';')
         closer = '</span>' if opened else ''
-        opened = len(cmds) > 1 or cmds[0] != '0'*len(cmds[0]);
+        # True if there is there more than one element in cmds, *or*
+        # if there is only one but it is not equal to a string of zeroes.
+        opened = len(cmds) > 1 or cmds[0] != '0' * len(cmds[0])
         classes = []
         for cmd in cmds:
             if cmd in ansi_colormap:
                 classes.append(ansi_colormap.get(cmd))
-        
+
         if classes:
             opener = '<span class="%s">' % (' '.join(classes))
         else:
             opener = ''
         txt = re.sub(ansi_re, closer + opener, txt, 1)
-        
+
         m = ansi_re.search(txt)
-    
+
     if opened:
         txt += '</span>'
     return txt
@@ -177,7 +183,7 b' def markdown2latex(src):'
     if err:
         print(err, file=sys.stderr)
     #print('*'*20+'\n', out, '\n'+'*'*20)  # dbg
-    return unicode(out,'utf-8')
+    return unicode(out, 'utf-8')
 
 
 def markdown2rst(src):
@@ -203,7 +209,7 b' def markdown2rst(src):'
     if err:
         print(err, file=sys.stderr)
     #print('*'*20+'\n', out, '\n'+'*'*20)  # dbg
-    return unicode(out,'utf-8')
+    return unicode(out, 'utf-8')
 
 
 def rst_directive(directive, text=''):
@@ -218,9 +224,9 b" def rst_directive(directive, text=''):"
 
 def coalesce_streams(outputs):
     """merge consecutive sequences of stream output into single stream
-    
+
     to prevent extra newlines inserted at flush calls
-    
+
     TODO: handle \r deletion
     """
     new_outputs = []
@@ -234,7 +240,7 b' def coalesce_streams(outputs):'
             last.text += output.text
         else:
             new_outputs.append(output)
-    
+
     return new_outputs
 
 
@@ -270,8 +276,8 b' def rst2simplehtml(infile):'
     walker = iter(html.splitlines())
 
     # Find start of main text, break out to then print until we find end /div.
-    # This may only work if there's a real title defined so we get a 'div class'
-    # tag, I haven't really tried.
+    # This may only work if there's a real title defined so we get a 'div
+    # class' tag, I haven't really tried.
     for line in walker:
         if line.startswith('<body>'):
             break
@@ -286,6 +292,7 b' def rst2simplehtml(infile):'
 
     return newfname
 
+
 #-----------------------------------------------------------------------------
 # Cell-level functions -- similar to IPython.nbformat.v3.rwbase functions
 # but at cell level instead of whole notebook level
@@ -295,7 +302,7 b' def writes_cell(cell, **kwargs):'
     kwargs['cls'] = BytesEncoder
     kwargs['indent'] = 3
     kwargs['sort_keys'] = True
-    kwargs['separators'] = (',',': ')
+    kwargs['separators'] = (',', ': ')
     if kwargs.pop('split_lines', True):
         cell = split_lines_cell(copy.deepcopy(cell))
     return py3compat.str_to_unicode(json.dumps(cell, **kwargs), 'utf-8')
@@ -306,7 +313,7 b" _multiline_outputs = ['text', 'html', 'svg', 'latex', 'javascript', 'json']"
 
 def split_lines_cell(cell):
     """
-    Split lines within a cell as in 
+    Split lines within a cell as in
     IPython.nbformat.v3.rwbase.split_lines
 
     """
@@ -318,7 +325,7 b' def split_lines_cell(cell):'
                 item = output.get(key, None)
                 if isinstance(item, basestring):
                     output[key] = (item + '\n').splitlines()
-    else: # text, heading cell
+    else:  # text, heading cell
         for key in ['source', 'rendered']:
             item = cell.get(key, None)
             if isinstance(item, basestring):