PEP8-ify rest of the repository.

converters/html.py

@@ -9,16 +9,17 b' from markdown import markdown'
 import os
 import io
 
+
 class ConverterHTML(Converter):
     extension = 'html'
 
     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() )
+                 ' '.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)]
 
@@ -29,7 +30,8 b' class ConverterHTML(Converter):'
 
     def _out_prompt(self, output):
         if output.output_type == 'pyout':
-            n = output.prompt_number if output.prompt_number is not None else '&nbsp;'
+            n = (output.prompt_number if output.prompt_number is not None
+                 else '&nbsp;')
             content = 'Out[%s]:' % n
         else:
             content = ''
@@ -37,7 +39,7 b' class ConverterHTML(Converter):'
 
     def header_body(self):
         """Return the body of the header as a list of strings."""
-        
+
         from pygments.formatters import HtmlFormatter
 
         header = []
@@ -48,29 +50,32 b' class ConverterHTML(Converter):'
         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, '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'),
+            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"')))
-        
+        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"',
+        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'), 
+        with io.open(os.path.join(here, '..', 'js', 'initmathjax.js'),
                      encoding='utf-8') as f:
-            header.extend(self.in_tag('script', f.read(), 
+            header.extend(self.in_tag('script', f.read(),
                                       {'type': '"text/javascript"'}))
         return header
 
@@ -85,34 +90,38 b' class ConverterHTML(Converter):'
     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;'
-        lines.append('<div class="prompt input_prompt">In&nbsp;[%s]:</div>' % n)
+        n = (cell.prompt_number
+             if getattr(cell, 'prompt_number', None) is not None
+             else '&nbsp;')
+        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
-        
+        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
-        
+
+            lines.append('</div>')  # output
+            lines.append('</div>')  # output_wrapper
+
+        lines.append('</div>')  # cell
+
         return lines
 
     @text_cell
@@ -138,14 +147,13 b' class ConverterHTML(Converter):'
     @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 = 
+
+        # stb =
         return self._ansi_colored('\n'.join(output.traceback))
 
     def _img_lines(self, img_file):
@@ -154,7 +162,6 b' class ConverterHTML(Converter):'
     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]
 
@@ -177,7 +184,5 b' class ConverterHTML(Converter):'
         # html ignores json
         return []
 
-
     def render_display_format_javascript(self, output):
         return [output.javascript]
-

converters/latex.py

@@ -1,8 +1,8 b''
 from converters.base import Converter
 from converters.utils import markdown2latex, remove_ansi
-import os, sys
+import os
 import subprocess
-
+import sys
 
 inkscape = 'inkscape'
 if sys.platform == 'darwin':
@@ -10,6 +10,7 b" if sys.platform == 'darwin':"
     if not os.path.exists(inkscape):
         inkscape = None
 
+
 class ConverterLaTeX(Converter):
     """Converts a notebook to a .tex file suitable for pdflatex.
 
@@ -17,13 +18,13 b' class ConverterLaTeX(Converter):'
 
     - `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 
+    the matplotlib backend to create SVG output with
 
     %config InlineBackend.figure_format = 'svg'
 
@@ -57,47 +58,48 b' class ConverterLaTeX(Converter):'
         out.append(ur'\end{%s}' % environment)
         return out
 
-    def convert(self, *kwargs):
+    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(*kwargs)
+        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),
-                  '',
+        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__)
-        with open(os.path.join(os.path.dirname(myfile), '../preamble.tex')) as f:
+        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}', ''])
+        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) ]
+        return ['%s{%s}' % (marker, cell.source)]
 
     def render_code(self, cell):
         if not cell.input:
@@ -105,7 +107,7 b' class ConverterLaTeX(Converter):'
 
         # Cell codes first carry input code, we use lstlisting for that
         lines = [ur'\begin{codecell}']
-        
+
         lines.extend(self.in_env('codeinput',
                               self.in_env('lstlisting', cell.input)))
 
@@ -122,7 +124,6 b' class ConverterLaTeX(Converter):'
 
         return lines
 
-
     def _img_lines(self, img_file):
         return self.in_env('center',
                 [r'\includegraphics[width=6in]{%s}' % img_file, r'\par'])
@@ -130,13 +131,13 b' class ConverterLaTeX(Converter):'
     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,
+        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 = []
 
@@ -152,7 +153,7 b' class ConverterLaTeX(Converter):'
     def render_pyerr(self, output):
         # Note: a traceback is a *list* of frames.
         return self.in_env('traceback',
-                        self.in_env('verbatim', 
+                        self.in_env('verbatim',
                                  remove_ansi('\n'.join(output.traceback))))
 
     def render_raw(self, cell):
@@ -165,7 +166,6 b' class ConverterLaTeX(Converter):'
         return [r'{\vspace{5mm}\bf WARNING:: unknown cell:}'] + \
           self.in_env('verbatim', data)
 
-
     def render_display_format_text(self, output):
         lines = []
 
@@ -186,7 +186,6 b' class ConverterLaTeX(Converter):'
         # latex ignores json
         return []
 
-
     def render_display_format_javascript(self, output):
         # latex ignores javascript
         return []

converters/lexers.py

@@ -17,7 +17,8 b' class IPythonLexer(PythonLexer):'
     filenames = ['*.ipy']
     tokens = PythonLexer.tokens.copy()
     tokens['root'] = [
-        (r'(\%+)(\w+)\s+(\.*)(\n)', bygroups(Operator, Keyword, using(BashLexer), Text)),
+        (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

@@ -2,6 +2,7 b' from converters.base import Converter'
 from converters.utils import highlight, remove_ansi
 from IPython.utils.text import indent
 
+
 class ConverterMarkdown(Converter):
     extension = 'md'
 
@@ -13,7 +14,7 b' class ConverterMarkdown(Converter):'
         self.inline_prompt = inline_prompt
 
     def render_heading(self, cell):
-        return ['{0} {1}'.format('#'*cell.level, cell.source), '']
+        return ['{0} {1}'.format('#' * cell.level, cell.source), '']
 
     def render_code(self, cell):
         if not cell.input:
@@ -24,7 +25,8 b' class ConverterMarkdown(Converter):'
         if self.show_prompts and self.inline_prompt:
             prompt = 'In[%s]: ' % cell.prompt_number
             input_lines = cell.input.split('\n')
-            src = prompt + input_lines[0] + '\n' + indent('\n'.join(input_lines[1:]), nspaces=len(prompt))
+            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)
@@ -50,7 +52,7 b' class ConverterMarkdown(Converter):'
 
     def render_pyout(self, output):
         lines = []
-        
+
         ## if 'text' in output:
         ##     lines.extend(['*Out[%s]:*' % output.prompt_number, ''])
 
@@ -70,7 +72,7 b' class ConverterMarkdown(Converter):'
 
     def _img_lines(self, img_file):
         return ['', '![](%s)' % img_file, '']
-    
+
     def render_display_format_text(self, output):
         return [indent(output.text)]
 

converters/notebook.py

@@ -4,6 +4,7 b' from converters.utils import cell_to_lines'
 from shutil import rmtree
 import json
 
+
 class ConverterNotebook(Converter):
     """
     A converter that is essentially a null-op.
@@ -25,7 +26,8 b' class ConverterNotebook(Converter):'
         rmtree(self.files_dir)
 
     def convert(self):
-        return unicode(json.dumps(json.loads(Converter.convert(self, ',')), indent=1, sort_keys=True))
+        return unicode(json.dumps(json.loads(Converter.convert(self, ',')),
+                                  indent=1, sort_keys=True))
 
     def optional_header(self):
         s = \
@@ -37,7 +39,6 b' class ConverterNotebook(Converter):'
  "worksheets": [
  {
  "cells": [""" % {'name': os.path.basename(self.outbase)}
-
         return s.split('\n')
 
     def optional_footer(self):
@@ -78,6 +79,5 b' class ConverterNotebook(Converter):'
     def render_display_format_json(self, output):
         return [output.json]
 
-
     def render_display_format_javascript(self, output):
         return [output.javascript]

converters/python.py

@@ -2,6 +2,7 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.
@@ -27,10 +28,10 b' class ConverterPy(Converter):'
     @staticmethod
     def comment(input):
         "returns every line in input as commented out"
-        return "# "+input.replace("\n", "\n# ")
+        return "# " + input.replace("\n", "\n# ")
 
     def render_heading(self, cell):
-        return ['#{0} {1}'.format('#'*cell.level, cell.source), '']
+        return ['#{0} {1}'.format('#' * cell.level, cell.source), '']
 
     def render_code(self, cell):
         if not cell.input:
@@ -41,7 +42,7 b' class ConverterPy(Converter):'
         src = cell.input
         lines.extend([src, ''])
         if self.show_output:
-            if cell.outputs :
+            if cell.outputs:
                 lines.extend(['# Out[%s]:' % cell.prompt_number])
             for output in cell.outputs:
                 conv_fn = self.dispatch(output.output_type)
@@ -78,13 +79,13 b' class ConverterPy(Converter):'
         return [indent(remove_ansi('\n'.join(output.traceback))), '']
 
     def _img_lines(self, img_file):
-        return [ self.comment('image file: %s' % 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))]
+        return [self.comment('Warning: Unknown cell' + str(data))]
 
     def render_display_format_html(self, output):
         return [self.comment(output.html)]

custom_converter.py

@@ -6,6 +6,7 b' captures display data and deletes the cell inputs.'
 import copy
 import nbconvert as nb
 
+
 class CustomNotebookConverter(nb.ConverterNotebook):
 
     def render_code(self, cell):
@@ -24,4 +25,3 b" if __name__ == '__main__':"
     infile = 'tests/test_display.ipynb'
     converter = CustomNotebookConverter(infile, 'test_only_display')
     converter.render()
-

dollarmath.py

@@ -16,22 +16,27 b' dollar_pat = r"(?:^|(?<=\\s))[$]([^\\n]*?)(?<![\\\\])[$](?:$|(?=\\s|[.,;\\\\]))"'
 _dollar = re.compile(dollar_pat)
 _notdollar = re.compile(r"\\[$]")
 
+
 def replace_dollar(content):
     content = _dollar.sub(r":math:`\1`", content)
     content = _notdollar.sub("$", content)
     return content
 
+
 def rewrite_rst(app, docname, source):
     source[0] = replace_dollar(source[0])
 
+
 def rewrite_autodoc(app, what, name, obj, options, lines):
     lines[:] = [replace_dollar(L) for L in lines]
 
+
 def setup(app):
     app.connect('source-read', rewrite_rst)
     if 'autodoc-process-docstring' in app._events:
         app.connect('autodoc-process-docstring', rewrite_autodoc)
 
+
 def test_expr(expr, expect):
     result = replace_dollar(expr)
     print 'A math expression: %s' % expr
@@ -41,6 +46,7 b' def test_expr(expr, expect):'
     else:
         print 'NG: A result %s does not match expected one!' % result
 
+
 def test_dollar():
     samples = {
         u"no dollar": u"no dollar",
@@ -59,8 +65,11 b' def test_dollar():'
     for expr, expect in samples.items():
         test_expr(expr, expect)
 
+
 if __name__ == "__main__":
-    import sys, locale, codecs
+    import sys
+    import locale
+    import codecs
     encoding = locale.getpreferredencoding()
     sys.stdout = codecs.getwriter(encoding)(sys.stdout)
     sys.stdin = codecs.getreader(encoding)(sys.stdin)

nbconvert.py

@@ -67,7 +67,8 b" if __name__ == '__main__':"
             formatter_class=argparse.RawTextHelpFormatter)
     # TODO: consider passing file like object around, rather than filenames
     # would allow us to process stdin, or even http streams
-    #parser.add_argument('infile', nargs='?', type=argparse.FileType('r'), default=sys.stdin)
+    #parser.add_argument('infile', nargs='?', type=argparse.FileType('r'),
+    #                    default=sys.stdin)
 
     #Require a filename as a positional argument
     parser.add_argument('infile', nargs=1)

rst2ipynblib/__init__.py

@@ -95,7 +95,6 b' class IPYNBTranslator(nodes.GenericNodeVisitor):'
             p = nbformat.new_text_cell('markdown', source=text)
             self.add_cell(p)
 
-
     def visit_section(self, node):
         self.section_level += 1
         self.default_visit(node)

tests/test_nbconverter.py

@@ -19,7 +19,6 b' def test_roundtrip():'
                          'test.ipynb')
     converter = ConverterNotebook(fname, out1)
     converter.render()
-
     converter2 = ConverterNotebook(out1 + '.ipynb', out2)
     converter2.render()
 
@@ -30,6 +29,5 b' def test_roundtrip():'
 
     nt.assert_true(s1.replace(outbase1, outbase2) == s2)
     shutil.rmtree(directory)
-
     s0 = json.dumps(json.load(file(fname)), indent=1, sort_keys=True)
     nt.assert_true(s0 == s2)

tests/test_references.py

@@ -1,9 +1,9 b''
 import io
 import nose.tools as nt
-from nbconvert import (
+from nose.tools import nottest
+from converts import (
     ConverterLaTeX, ConverterMarkdown, ConverterPy, ConverterHTML
 )
-from nose.tools import nottest
 
 
 def test_evens():
@@ -17,7 +17,7 b' def test_evens():'
     # commenting rst for now as travis build
     # fail because of pandoc version.
     converters = [
-                 #(ConverterRST,'rst'),
+                 #(ConverterRST, 'rst'),
                   (ConverterMarkdown, 'md'),
                   (ConverterLaTeX, 'tex'),
                   (ConverterPy, 'py'),

tests/test_simple.py

@@ -40,7 +40,7 b' def test_render_heading():'
         cell = {
             'cell_type': 'heading',
             'level': level,
-            'source':  ['Test for heading type H{0}'.format(level)]
+            'source': ['Test for heading type H{0}'.format(level)]
             }
         # Convert cell dictionaries to NotebookNode
         cell_nb = nbformat.NotebookNode(cell)