--- a/testing/mozbase/docs/_static/structured_example.py
+++ b/testing/mozbase/docs/_static/structured_example.py
@@ -1,51 +1,60 @@
 import argparse
 import sys
 import traceback
 import types
 
 from mozlog import commandline, get_default_logger
 
+
 class TestAssertion(Exception):
     pass
 
+
 def assert_equals(a, b):
     if a != b:
         raise TestAssertion("%r not equal to %r" % (a, b))
 
+
 def expected(status):
     def inner(f):
         def test_func():
             f()
         test_func.__name__ = f.__name__
         test_func._expected = status
         return test_func
     return inner
 
+
 def test_that_passes():
     assert_equals(1, int("1"))
 
+
 def test_that_fails():
     assert_equals(1, int("2"))
 
+
 def test_that_has_an_error():
     assert_equals(2, 1 + "1")
 
+
 @expected("FAIL")
 def test_expected_fail():
     assert_equals(2 + 2, 5)
 
+
 class TestRunner(object):
+
     def __init__(self):
         self.logger = get_default_logger(component='TestRunner')
 
     def gather_tests(self):
         for item in globals().itervalues():
-            if type(item) == types.FunctionType and item.__name__.startswith("test_"):
+            if isinstance(item, types.FunctionType) and item.__name__.startswith("test_"):
                 yield item.__name__, item
 
     def run(self):
         tests = list(self.gather_tests())
 
         self.logger.suite_start(tests=[name for name, func in tests])
         self.logger.info("Running tests")
         for name, func in tests:
@@ -64,20 +73,22 @@ class TestRunner(object):
             message = e.message
         except:
             status = "ERROR"
             message = traceback.format_exc()
         else:
             status = "PASS"
         self.logger.test_end(name, status=status, expected=expected, message=message)
 
+
 def get_parser():
     parser = argparse.ArgumentParser()
     return parser
 
+
 def main():
     parser = get_parser()
     commandline.add_logging_group(parser)
 
     args = parser.parse_args()
 
     logger = commandline.setup_logging("structured-example", args, {"raw": sys.stdout})
 

--- a/testing/mozbase/docs/conf.py
+++ b/testing/mozbase/docs/conf.py
@@ -6,46 +6,47 @@
 # This file is execfile()d with the current directory set to its containing dir.
 #
 # Note that not all possible configuration values are present in this
 # autogenerated file.
 #
 # All configuration values have a default; values that are commented out
 # serve to show the default.
 
-import sys, os
+import sys
+import os
 
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.
 here = os.path.dirname(os.path.abspath(__file__))
 parent = os.path.dirname(here)
 for item in os.listdir(parent):
     path = os.path.join(parent, item)
     if (not os.path.isdir(path)) or (not os.path.exists(os.path.join(path, 'setup.py'))):
         continue
     sys.path.insert(0, path)
 
 # -- General configuration -----------------------------------------------------
 
 # If your documentation needs a minimal Sphinx version, state it here.
-#needs_sphinx = '1.0'
+# needs_sphinx = '1.0'
 
 # Add any Sphinx extension module names here, as strings. They can be extensions
 # coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
 extensions = ['sphinx.ext.autodoc', 'sphinx.ext.doctest', 'sphinx.ext.todo', 'sphinx.ext.viewcode']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']
 
 # The suffix of source filenames.
 source_suffix = '.rst'
 
 # The encoding of source files.
-#source_encoding = 'utf-8-sig'
+# source_encoding = 'utf-8-sig'
 
 # The master toctree document.
 master_doc = 'index'
 
 # General information about the project.
 project = u'MozBase'
 copyright = u'2012, Mozilla Automation and Tools team'
 
@@ -55,47 +56,47 @@ copyright = u'2012, Mozilla Automation a
 #
 # The short X.Y version.
 version = '1'
 # The full version, including alpha/beta/rc tags.
 release = '1'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
-#language = None
+# language = None
 
 # There are two options for replacing |today|: either, you set today to some
 # non-false value, then it is used:
-#today = ''
+# today = ''
 # Else, today_fmt is used as the format for a strftime call.
-#today_fmt = '%B %d, %Y'
+# today_fmt = '%B %d, %Y'
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
 exclude_patterns = ['_build']
 
 # The reST default role (used for this markup: `text`) to use for all documents.
-#default_role = None
+# default_role = None
 
 # If true, '()' will be appended to :func: etc. cross-reference text.
-#add_function_parentheses = True
+# add_function_parentheses = True
 
 # If true, the current module name will be prepended to all description
 # unit titles (such as .. function::).
-#add_module_names = True
+# add_module_names = True
 
 # If true, sectionauthor and moduleauthor directives will be shown in the
 # output. They are ignored by default.
-#show_authors = False
+# show_authors = False
 
 # The name of the Pygments (syntax highlighting) style to use.
 pygments_style = 'sphinx'
 
 # A list of ignored prefixes for module index sorting.
-#modindex_common_prefix = []
+# modindex_common_prefix = []
 
 
 # -- Options for HTML output ---------------------------------------------------
 
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
 html_theme = 'default'
 on_rtd = os.environ.get('READTHEDOCS', None) == 'True'
@@ -106,152 +107,152 @@ if not on_rtd:
         html_theme = 'sphinx_rtd_theme'
         html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
     except ImportError:
         pass
 
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the
 # documentation.
-#html_theme_options = {}
+# html_theme_options = {}
 
 # Add any paths that contain custom themes here, relative to this directory.
-#html_theme_path = []
+# html_theme_path = []
 
 # The name for this set of Sphinx documents.  If None, it defaults to
 # "<project> v<release> documentation".
 html_title = "mozbase documentation"
 
 # A shorter title for the navigation bar.  Default is the same as html_title.
-#html_short_title = None
+# html_short_title = None
 
 # The name of an image file (relative to this directory) to place at the top
 # of the sidebar.
-#html_logo = None
+# html_logo = None
 
 # The name of an image file (within the static path) to use as favicon of the
 # docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
 # pixels large.
-#html_favicon = None
+# html_favicon = None
 
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
 html_static_path = ['_static']
 
 # If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
 # using the given strftime format.
-#html_last_updated_fmt = '%b %d, %Y'
+# html_last_updated_fmt = '%b %d, %Y'
 
 # If true, SmartyPants will be used to convert quotes and dashes to
 # typographically correct entities.
-#html_use_smartypants = True
+# html_use_smartypants = True
 
 # Custom sidebar templates, maps document names to template names.
-#html_sidebars = {}
+# html_sidebars = {}
 
 # Additional templates that should be rendered to pages, maps page names to
 # template names.
-#html_additional_pages = {}
+# html_additional_pages = {}
 
 # If false, no module index is generated.
-#html_domain_indices = True
+# html_domain_indices = True
 
 # If false, no index is generated.
-#html_use_index = True
+# html_use_index = True
 
 # If true, the index is split into individual pages for each letter.
-#html_split_index = False
+# html_split_index = False
 
 # If true, links to the reST sources are added to the pages.
-#html_show_sourcelink = True
+# html_show_sourcelink = True
 
 # If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
-#html_show_sphinx = True
+# html_show_sphinx = True
 
 # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
-#html_show_copyright = True
+# html_show_copyright = True
 
 # If true, an OpenSearch description file will be output, and all pages will
 # contain a <link> tag referring to it.  The value of this option must be the
 # base URL from which the finished HTML is served.
-#html_use_opensearch = ''
+# html_use_opensearch = ''
 
 # This is the file name suffix for HTML files (e.g. ".xhtml").
-#html_file_suffix = None
+# html_file_suffix = None
 
 # Output file base name for HTML help builder.
 htmlhelp_basename = 'MozBasedoc'
 
 
 # -- Options for LaTeX output --------------------------------------------------
 
 latex_elements = {
-# The paper size ('letterpaper' or 'a4paper').
-#'papersize': 'letterpaper',
+    # The paper size ('letterpaper' or 'a4paper').
+    # 'papersize': 'letterpaper',
 
-# The font size ('10pt', '11pt' or '12pt').
-#'pointsize': '10pt',
+    # The font size ('10pt', '11pt' or '12pt').
+    # 'pointsize': '10pt',
 
-# Additional stuff for the LaTeX preamble.
-#'preamble': '',
+    # Additional stuff for the LaTeX preamble.
+    # 'preamble': '',
 }
 
 # Grouping the document tree into LaTeX files. List of tuples
 # (source start file, target name, title, author, documentclass [howto/manual]).
 latex_documents = [
-  ('index', 'MozBase.tex', u'MozBase Documentation',
-   u'Mozilla Automation and Tools team', 'manual'),
+    ('index', 'MozBase.tex', u'MozBase Documentation',
+     u'Mozilla Automation and Tools team', 'manual'),
 ]
 
 # The name of an image file (relative to this directory) to place at the top of
 # the title page.
-#latex_logo = None
+# latex_logo = None
 
 # For "manual" documents, if this is true, then toplevel headings are parts,
 # not chapters.
-#latex_use_parts = False
+# latex_use_parts = False
 
 # If true, show page references after internal links.
-#latex_show_pagerefs = False
+# latex_show_pagerefs = False
 
 # If true, show URL addresses after external links.
-#latex_show_urls = False
+# latex_show_urls = False
 
 # Documents to append as an appendix to all manuals.
-#latex_appendices = []
+# latex_appendices = []
 
 # If false, no module index is generated.
-#latex_domain_indices = True
+# latex_domain_indices = True
 
 
 # -- Options for manual page output --------------------------------------------
 
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
 man_pages = [
     ('index', 'mozbase', u'MozBase Documentation',
      [u'Mozilla Automation and Tools team'], 1)
 ]
 
 # If true, show URL addresses after external links.
-#man_show_urls = False
+# man_show_urls = False
 
 
 # -- Options for Texinfo output ------------------------------------------------
 
 # Grouping the document tree into Texinfo files. List of tuples
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-  ('index', 'MozBase', u'MozBase Documentation',
-   u'Mozilla Automation and Tools team', 'MozBase', 'One line description of project.',
-   'Miscellaneous'),
+    ('index', 'MozBase', u'MozBase Documentation',
+     u'Mozilla Automation and Tools team', 'MozBase', 'One line description of project.',
+     'Miscellaneous'),
 ]
 
 # Documents to append as an appendix to all manuals.
-#texinfo_appendices = []
+# texinfo_appendices = []
 
 # If false, no module index is generated.
-#texinfo_domain_indices = True
+# texinfo_domain_indices = True
 
 # How to display URL addresses: 'footnote', 'no', or 'inline'.
-#texinfo_show_urls = 'footnote'
+# texinfo_show_urls = 'footnote'

--- a/testing/mozbase/manifestparser/manifestparser/__init__.py
+++ b/testing/mozbase/manifestparser/manifestparser/__init__.py
@@ -1,7 +1,8 @@
+# flake8: noqa
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this file,
 # You can obtain one at http://mozilla.org/MPL/2.0/.
 
 from .manifestparser import *
 from .expression import *
 from .ini import *

--- a/testing/mozbase/manifestparser/manifestparser/cli.py
+++ b/testing/mozbase/manifestparser/manifestparser/cli.py
@@ -13,17 +13,18 @@ import sys
 
 from .manifestparser import (
     convert,
     ManifestParser,
 )
 
 
 class ParserError(Exception):
-  """error for exceptions while parsing the command line"""
+    """error for exceptions while parsing the command line"""
+
 
 def parse_args(_args):
     """
     parse and return:
     --keys=value (or --key value)
     -tags
     args
     """
@@ -56,46 +57,51 @@ def parse_args(_args):
             if key:
                 _dict[key] = arg
                 continue
             args.append(arg)
 
     # return values
     return (_dict, tags, args)
 
+
 class CLICommand(object):
     usage = '%prog [options] command'
+
     def __init__(self, parser):
-      self._parser = parser # master parser
+        self._parser = parser  # master parser
+
     def parser(self):
-      return OptionParser(usage=self.usage, description=self.__doc__,
-                          add_help_option=False)
+        return OptionParser(usage=self.usage, description=self.__doc__,
+                            add_help_option=False)
+
 
 class Copy(CLICommand):
     usage = '%prog [options] copy manifest directory -tag1 -tag2 --key1=value1 --key2=value2 ...'
+
     def __call__(self, options, args):
-      # parse the arguments
-      try:
-        kwargs, tags, args = parse_args(args)
-      except ParserError, e:
-        self._parser.error(e.message)
+        # parse the arguments
+        try:
+            kwargs, tags, args = parse_args(args)
+        except ParserError, e:
+            self._parser.error(e.message)
 
-      # make sure we have some manifests, otherwise it will
-      # be quite boring
-      if not len(args) == 2:
-        HelpCLI(self._parser)(options, ['copy'])
-        return
+        # make sure we have some manifests, otherwise it will
+        # be quite boring
+        if not len(args) == 2:
+            HelpCLI(self._parser)(options, ['copy'])
+            return
 
-      # read the manifests
-      # TODO: should probably ensure these exist here
-      manifests = ManifestParser()
-      manifests.read(args[0])
+        # read the manifests
+        # TODO: should probably ensure these exist here
+        manifests = ManifestParser()
+        manifests.read(args[0])
 
-      # print the resultant query
-      manifests.copy(args[1], None, *tags, **kwargs)
+        # print the resultant query
+        manifests.copy(args[1], None, *tags, **kwargs)
 
 
 class CreateCLI(CLICommand):
     """
     create a manifest from a list of directories
     """
     usage = '%prog [options] create directory <directory> <...>'
 
@@ -129,16 +135,17 @@ class CreateCLI(CLICommand):
             print manifest
 
 
 class WriteCLI(CLICommand):
     """
     write a manifest based on a query
     """
     usage = '%prog [options] write manifest <manifest> -tag1 -tag2 --key1=value1 --key2=value2 ...'
+
     def __call__(self, options, args):
 
         # parse the arguments
         try:
             kwargs, tags, args = parse_args(args)
         except ParserError, e:
             self._parser.error(e.message)
 
@@ -152,32 +159,32 @@ class WriteCLI(CLICommand):
         # TODO: should probably ensure these exist here
         manifests = ManifestParser()
         manifests.read(*args)
 
         # print the resultant query
         manifests.write(global_tags=tags, global_kwargs=kwargs)
 
 
-
 class HelpCLI(CLICommand):
     """
     get help on a command
     """
     usage = '%prog [options] help [command]'
 
     def __call__(self, options, args):
         if len(args) == 1 and args[0] in commands:
             commands[args[0]](self._parser).parser().print_help()
         else:
             self._parser.print_help()
             print '\nCommands:'
             for command in sorted(commands):
                 print '  %s : %s' % (command, commands[command].__doc__.strip())
 
+
 class UpdateCLI(CLICommand):
     """
     update the tests as listed in a manifest from a directory
     """
     usage = '%prog [options] update manifest directory -tag1 -tag2 --key1=value1 --key2=value2 ...'
 
     def __call__(self, options, args):
         # parse the arguments
@@ -197,20 +204,21 @@ class UpdateCLI(CLICommand):
         manifests = ManifestParser()
         manifests.read(args[0])
 
         # print the resultant query
         manifests.update(args[1], None, *tags, **kwargs)
 
 
 # command -> class mapping
-commands = { 'create': CreateCLI,
-             'help': HelpCLI,
-             'update': UpdateCLI,
-             'write': WriteCLI }
+commands = {'create': CreateCLI,
+            'help': HelpCLI,
+            'update': UpdateCLI,
+            'write': WriteCLI}
+
 
 def main(args=sys.argv[1:]):
     """console_script entry point"""
 
     # set up an option parser
     usage = '%prog [options] [command] ...'
     description = "%s. Use `help` to display commands" % __doc__.strip()
     parser = OptionParser(usage=usage, description=description)
@@ -223,15 +231,16 @@ def main(args=sys.argv[1:]):
 
     if not args:
         HelpCLI(parser)(options, args)
         parser.exit()
 
     # get the command
     command = args[0]
     if command not in commands:
-        parser.error("Command must be one of %s (you gave '%s')" % (', '.join(sorted(commands.keys())), command))
+        parser.error("Command must be one of %s (you gave '%s')" %
+                     (', '.join(sorted(commands.keys())), command))
 
     handler = commands[command](parser)
     handler(options, args[1:])
 
 if __name__ == '__main__':
     main()

--- a/testing/mozbase/manifestparser/manifestparser/expression.py
+++ b/testing/mozbase/manifestparser/manifestparser/expression.py
@@ -40,119 +40,155 @@ import traceback
 # argument.
 
 # Glossary (see above URL for details):
 # - nud: null denotation
 # - led: left detonation
 # - lbp: left binding power
 # - rbp: right binding power
 
+
 class ident_token(object):
+
     def __init__(self, scanner, value):
         self.value = value
+
     def nud(self, parser):
         # identifiers take their value from the value mappings passed
         # to the parser
         return parser.value(self.value)
 
+
 class literal_token(object):
+
     def __init__(self, scanner, value):
         self.value = value
+
     def nud(self, parser):
         return self.value
 
+
 class eq_op_token(object):
     "=="
+
     def led(self, parser, left):
         return left == parser.expression(self.lbp)
 
+
 class neq_op_token(object):
     "!="
+
     def led(self, parser, left):
         return left != parser.expression(self.lbp)
 
+
 class lt_op_token(object):
     "<"
+
     def led(self, parser, left):
         return left < parser.expression(self.lbp)
 
+
 class gt_op_token(object):
     ">"
+
     def led(self, parser, left):
         return left > parser.expression(self.lbp)
 
+
 class le_op_token(object):
     "<="
+
     def led(self, parser, left):
         return left <= parser.expression(self.lbp)
 
+
 class ge_op_token(object):
     ">="
+
     def led(self, parser, left):
         return left >= parser.expression(self.lbp)
 
+
 class not_op_token(object):
     "!"
+
     def nud(self, parser):
         return not parser.expression(100)
 
+
 class and_op_token(object):
     "&&"
+
     def led(self, parser, left):
         right = parser.expression(self.lbp)
         return left and right
 
+
 class or_op_token(object):
     "||"
+
     def led(self, parser, left):
         right = parser.expression(self.lbp)
         return left or right
 
+
 class lparen_token(object):
     "("
+
     def nud(self, parser):
         expr = parser.expression()
         parser.advance(rparen_token)
         return expr
 
+
 class rparen_token(object):
     ")"
 
+
 class end_token(object):
     """always ends parsing"""
 
-### derived literal tokens
+# derived literal tokens
+
 
 class bool_token(literal_token):
+
     def __init__(self, scanner, value):
-        value = {'true':True, 'false':False}[value]
+        value = {'true': True, 'false': False}[value]
         literal_token.__init__(self, scanner, value)
 
+
 class int_token(literal_token):
+
     def __init__(self, scanner, value):
         literal_token.__init__(self, scanner, int(value))
 
+
 class string_token(literal_token):
+
     def __init__(self, scanner, value):
         literal_token.__init__(self, scanner, value[1:-1])
 
 precedence = [(end_token, rparen_token),
               (or_op_token,),
               (and_op_token,),
               (lt_op_token, gt_op_token, le_op_token, ge_op_token,
                eq_op_token, neq_op_token),
               (lparen_token,),
               ]
 for index, rank in enumerate(precedence):
     for token in rank:
-        token.lbp = index # lbp = lowest left binding power
+        token.lbp = index  # lbp = lowest left binding power
+
 
 class ParseError(Exception):
     """error parsing conditional expression"""
 
+
 class ExpressionParser(object):
     """
     A parser for a simple expression language.
 
     The expression language can be described as follows::
 
         EXPRESSION ::= LITERAL | '(' EXPRESSION ')' | '!' EXPRESSION | EXPRESSION OP EXPRESSION
         OP ::= '==' | '!=' | '<' | '>' | '<=' | '>=' | '&&' | '||'
@@ -210,17 +246,17 @@ class ExpressionParser(object):
                 (r">=", ge_op_token()),
                 (r"<", lt_op_token()),
                 (r">", gt_op_token()),
                 (r"\|\|", or_op_token()),
                 (r"!", not_op_token()),
                 (r"&&", and_op_token()),
                 (r"\(", lparen_token()),
                 (r"\)", rparen_token()),
-                (r"\s+", None), # skip whitespace
+                (r"\s+", None),  # skip whitespace
             ])
         tokens, remainder = ExpressionParser.scanner.scan(self.text)
         for t in tokens:
             yield t
         yield end_token()
 
     def value(self, ident):
         """
@@ -233,17 +269,17 @@ class ExpressionParser(object):
             return self.valuemapping.get(ident, None)
 
     def advance(self, expected):
         """
         Assert that the next token is an instance of |expected|, and advance
         to the next token.
         """
         if not isinstance(self.token, expected):
-            raise Exception, "Unexpected token!"
+            raise Exception("Unexpected token!")
         self.token = self.iter.next()
 
     def expression(self, rbp=0):
         """
         Parse and return the value of an expression until a token with
         right binding power greater than rbp is encountered.
         """
         t = self.token
@@ -263,17 +299,20 @@ class ExpressionParser(object):
         """
         try:
             self.iter = self._tokenize()
             self.token = self.iter.next()
             return self.expression()
         except:
             extype, ex, tb = sys.exc_info()
             formatted = ''.join(traceback.format_exception_only(extype, ex))
-            raise ParseError("could not parse: %s\nexception: %svariables: %s" % (self.text, formatted, self.valuemapping)), None, tb
+            raise ParseError("could not parse: "
+                             "%s\nexception: %svariables: %s" % (self.text,
+                                                                 formatted,
+                                                                 self.valuemapping)), None, tb
 
     __call__ = parse
 
 
 def parse(text, **values):
     """
     Parse and evaluate a boolean expression.
     :param text: The expression to parse, as a string.

--- a/testing/mozbase/manifestparser/manifestparser/filters.py
+++ b/testing/mozbase/manifestparser/manifestparser/filters.py
@@ -112,16 +112,17 @@ class subsuite(InstanceFilter):
        subsuite = foo,condition
 
     where 'foo' is the subsuite name, and 'condition' is the same type of
     condition used for skip-if.  If the condition doesn't evaluate to true,
     the subsuite designation will be removed from the test.
 
     :param name: The name of the subsuite to run (default None)
     """
+
     def __init__(self, name=None):
         InstanceFilter.__init__(self, name=name)
         self.name = name
 
     def __call__(self, tests, values):
         # Look for conditional subsuites, and replace them with the subsuite
         # itself (if the condition is true), or nothing.
         for test in tests:
@@ -222,17 +223,17 @@ class chunk_by_dir(InstanceFilter):
         ordered_dirs = []
         for test in tests:
             path = test['relpath']
 
             if path.startswith(os.sep):
                 path = path[1:]
 
             dirs = path.split(os.sep)
-            dirs = dirs[:min(self.depth, len(dirs)-1)]
+            dirs = dirs[:min(self.depth, len(dirs) - 1)]
             path = os.sep.join(dirs)
 
             # don't count directories that only have disabled tests in them,
             # but still yield disabled tests that are alongside enabled tests
             if path not in ordered_dirs and 'disabled' not in test:
                 ordered_dirs.append(path)
             tests_by_dir[path].append(test)
 
@@ -298,17 +299,17 @@ class chunk_by_runtime(InstanceFilter):
         for runtime, batch in tests_by_manifest:
             # sort first by runtime, then by number of tests in case of a tie.
             # This guarantees the chunk with the fastest runtime will always
             # get the next batch of tests.
             tests_by_chunk.sort(key=lambda x: (x[0], len(x[1])))
             tests_by_chunk[0][0] += runtime
             tests_by_chunk[0][1].extend(batch)
 
-        return (t for t in tests_by_chunk[self.this_chunk-1][1])
+        return (t for t in tests_by_chunk[self.this_chunk - 1][1])
 
 
 class tags(InstanceFilter):
     """
     Removes tests that don't contain any of the given tags. This overrides
     InstanceFilter's __eq__ method, so multiple instances can be added.
     Multiple tag filters is equivalent to joining tags with the AND operator.
 

--- a/testing/mozbase/manifestparser/manifestparser/ini.py
+++ b/testing/mozbase/manifestparser/manifestparser/ini.py
@@ -1,15 +1,16 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this file,
 # You can obtain one at http://mozilla.org/MPL/2.0/.
 
+import os
+
 __all__ = ['read_ini']
 
-import os
 
 def read_ini(fp, variables=None, default='DEFAULT', defaults_only=False,
              comments=';#', separators=('=', ':'),
              strict=True):
     """
     read an .ini file and return a list of [(section, values)]
     - fp : file pointer or path to read
     - variables : default set of variables
@@ -53,17 +54,18 @@ def read_ini(fp, variables=None, default
                 if strict:
                     assert default not in section_names
                 section_names.add(default)
                 current_section = variables
                 continue
 
             if strict:
                 # make sure this section doesn't already exist
-                assert section not in section_names, "Section '%s' already found in '%s'" % (section, section_names)
+                assert section not in section_names, "Section '%s' already found in '%s'" % (
+                    section, section_names)
 
             section_names.add(section)
             current_section = {}
             sections.append((section, current_section))
             continue
 
         # if there aren't any sections yet, something bad happen
         if not section_names:
@@ -114,15 +116,16 @@ def read_ini(fp, variables=None, default
         variables = global_dict.copy()
 
         # These variables are combinable when they appear both in default
         # and per-entry.
         for field_name, pattern in (('skip-if', '(%s) || (%s)'),
                                     ('support-files', '%s %s')):
             local_value, global_value = local_dict.get(field_name), variables.get(field_name)
             if local_value and global_value:
-                local_dict[field_name] = pattern % (global_value.split('#')[0], local_value.split('#')[0])
+                local_dict[field_name] = pattern % (
+                    global_value.split('#')[0], local_value.split('#')[0])
         variables.update(local_dict)
 
         return variables
 
     sections = [(i, interpret_variables(variables, j)) for i, j in sections]
     return sections

--- a/testing/mozbase/manifestparser/manifestparser/manifestparser.py
+++ b/testing/mozbase/manifestparser/manifestparser/manifestparser.py
@@ -1,50 +1,51 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this file,
 # You can obtain one at http://mozilla.org/MPL/2.0/.
 
-__all__ = ['ManifestParser', 'TestManifest', 'convert']
-
 from StringIO import StringIO
 import json
 import fnmatch
 import os
 import shutil
 import sys
 import types
 
 from .ini import read_ini
 from .filters import (
     DEFAULT_FILTERS,
     enabled,
     exists as _exists,
     filterlist,
 )
 
+__all__ = ['ManifestParser', 'TestManifest', 'convert']
+
 relpath = os.path.relpath
 string = (basestring,)
 
 
-### path normalization
+# path normalization
 
 def normalize_path(path):
     """normalize a relative path"""
     if sys.platform.startswith('win'):
         return path.replace('/', os.path.sep)
     return path
 
+
 def denormalize_path(path):
     """denormalize a relative path"""
     if sys.platform.startswith('win'):
         return path.replace(os.path.sep, '/')
     return path
 
 
-### objects for parsing manifests
+# objects for parsing manifests
 
 class ManifestParser(object):
     """read .ini manifests"""
 
     def __init__(self, manifests=(), defaults=None, strict=True, rootdir=None,
                  finder=None):
         """Creates a ManifestParser from the given manifest files.
 
@@ -77,17 +78,17 @@ class ManifestParser(object):
         if manifests:
             self.read(*manifests)
 
     def path_exists(self, path):
         if self.finder:
             return self.finder.get(path) is not None
         return os.path.exists(path)
 
-    ### methods for reading manifests
+    # methods for reading manifests
 
     def _read(self, root, filename, defaults, defaults_only=False, parentmanifest=None):
         """
         Internal recursive method for reading and parsing manifests.
         Stores all found tests in self.tests
         :param root: The base path
         :param filename: File object or string path for the base manifest file
         :param defaults: Options that apply to all items
@@ -181,17 +182,17 @@ class ManifestParser(object):
             test['name'] = section
 
             # Will be None if the manifest being read is a file-like object.
             test['manifest'] = filename
 
             # determine the path
             path = test.get('path', section)
             _relpath = path
-            if '://' not in path: # don't futz with URLs
+            if '://' not in path:  # don't futz with URLs
                 path = normalize_path(path)
                 if here and not os.path.isabs(path):
                     # Profiling indicates 25% of manifest parsing is spent
                     # in this call to normpath, but almost all calls return
                     # their argument unmodified, so we avoid the call if
                     # '..' if not present in the path.
                     path = os.path.join(here, path)
                     if '..' in path:
@@ -255,27 +256,26 @@ class ManifestParser(object):
 
         # process each file
         for filename in filenames:
             # set the per file defaults
             defaults = _defaults.copy()
             here = None
             if isinstance(filename, string):
                 here = os.path.dirname(os.path.abspath(filename))
-                defaults['here'] = here # directory of master .ini file
+                defaults['here'] = here  # directory of master .ini file
 
             if self.rootdir is None:
                 # set the root directory
                 # == the directory of the first manifest given
                 self.rootdir = here
 
             self._read(here, filename, defaults)
 
-
-    ### methods for querying manifests
+    # methods for querying manifests
 
     def query(self, *checks, **kw):
         """
         general query function for tests
         - checks : callable conditions to test if the test fulfills the query
         """
         tests = kw.get('tests', None)
         if tests is None:
@@ -299,24 +299,28 @@ class ManifestParser(object):
         # fix up tags
         if tags:
             tags = set(tags)
         else:
             tags = set()
 
         # make some check functions
         if inverse:
-            has_tags = lambda test: not tags.intersection(test.keys())
+            def has_tags(test):
+                return not tags.intersection(test.keys())
+
             def dict_query(test):
                 for key, value in kwargs.items():
                     if test.get(key) == value:
                         return False
                 return True
         else:
-            has_tags = lambda test: tags.issubset(test.keys())
+            def has_tags(test):
+                return tags.issubset(test.keys())
+
             def dict_query(test):
                 for key, value in kwargs.items():
                     if test.get(key) != value:
                         return False
                 return True
 
         # query the tests
         tests = self.query(has_tags, dict_query, tests=tests)
@@ -344,18 +348,17 @@ class ManifestParser(object):
                 continue
             if manifest not in manifests:
                 manifests.append(manifest)
         return manifests
 
     def paths(self):
         return [i['path'] for i in self.tests]
 
-
-    ### methods for auditing
+    # methods for auditing
 
     def missing(self, tests=None):
         """
         return list of tests that do not exist on the filesystem
         """
         if tests is None:
             tests = self.tests
         existing = list(_exists(tests, {}))
@@ -365,17 +368,17 @@ class ManifestParser(object):
         missing = self.missing(tests=tests)
         if missing:
             missing_paths = [test['path'] for test in missing]
             if self.strict:
                 raise IOError("Strict mode enabled, test paths must exist. "
                               "The following test(s) are missing: %s" %
                               json.dumps(missing_paths, indent=2))
             print >> sys.stderr, "Warning: The following test(s) are missing: %s" % \
-                                  json.dumps(missing_paths, indent=2)
+                json.dumps(missing_paths, indent=2)
         return missing
 
     def verifyDirectory(self, directories, pattern=None, extensions=None):
         """
         checks what is on the filesystem vs what is in a manifest
         returns a 2-tuple of sets:
         (missing_from_filesystem, missing_from_manifest)
         """
@@ -399,18 +402,17 @@ class ManifestParser(object):
 
                 files.update([os.path.join(dirpath, filename) for filename in filenames])
 
         paths = set(self.paths())
         missing_from_filesystem = paths.difference(files)
         missing_from_manifest = files.difference(paths)
         return (missing_from_filesystem, missing_from_manifest)
 
-
-    ### methods for output
+    # methods for output
 
     def write(self, fp=sys.stdout, rootdir=None,
               global_tags=None, global_kwargs=None,
               local_tags=None, local_kwargs=None):
         """
         write a manifest given a query
         global and local options will be munged to do the query
         globals will be written to the top of the file
@@ -449,17 +451,17 @@ class ManifestParser(object):
             print >> fp, '[DEFAULT]'
             for tag in global_tags:
                 print >> fp, '%s =' % tag
             for key, value in global_kwargs.items():
                 print >> fp, '%s = %s' % (key, value)
             print >> fp
 
         for test in tests:
-            test = test.copy() # don't overwrite
+            test = test.copy()  # don't overwrite
 
             path = test['name']
             if not os.path.isabs(path):
                 path = test['path']
                 if self.rootdir:
                     path = relpath(test['path'], self.rootdir)
                 path = denormalize_path(path)
             print >> fp, '[%s]' % path
@@ -504,17 +506,17 @@ class ManifestParser(object):
             os.path.makedirs(directory)
         else:
             # sanity check
             assert os.path.isdir(directory)
 
         # tests to copy
         tests = self.get(tags=tags, **kwargs)
         if not tests:
-            return # nothing to do!
+            return  # nothing to do!
 
         # root directory
         if rootdir is None:
             rootdir = self.rootdir
 
         # copy the manifests + tests
         manifests = [relpath(manifest, rootdir) for manifest in self.manifests()]
         for manifest in manifests:
@@ -562,42 +564,45 @@ class ManifestParser(object):
                     message = "Missing test: '%s' does not exist!"
                     if self.strict:
                         raise IOError(message)
                     print >> sys.stderr, message + " Skipping."
                     continue
                 destination = os.path.join(rootdir, _relpath)
                 shutil.copy(source, destination)
 
-    ### directory importers
+    # directory importers
 
     @classmethod
     def _walk_directories(cls, directories, callback, pattern=None, ignore=()):
         """
         internal function to import directories
         """
 
         if isinstance(pattern, basestring):
             patterns = [pattern]
         else:
             patterns = pattern
         ignore = set(ignore)
 
         if not patterns:
-            accept_filename = lambda filename: True
+            def accept_filename(filename):
+                return True
         else:
             def accept_filename(filename):
                 for pattern in patterns:
                     if fnmatch.fnmatch(filename, pattern):
                         return True
 
         if not ignore:
-            accept_dirname = lambda dirname: True
+            def accept_dirname(dirname):
+                return True
         else:
-            accept_dirname = lambda dirname: dirname not in ignore
+            def accept_dirname(dirname):
+                return dirname not in ignore
 
         rootdirectories = directories[:]
         seen_directories = set()
         for rootdirectory in rootdirectories:
             # let's recurse directories using list
             directories = [os.path.realpath(rootdirectory)]
             while directories:
                 directory = directories.pop(0)
@@ -627,22 +632,22 @@ class ManifestParser(object):
                         # this subdir is added for recursion
                         directories.insert(0, path)
 
                 # here we got all subdirs and files filtered, we can
                 # call the callback function if directory is not empty
                 if subdirs or files:
                     callback(rootdirectory, directory, subdirs, files)
 
-
     @classmethod
-    def populate_directory_manifests(cls, directories, filename, pattern=None, ignore=(), overwrite=False):
+    def populate_directory_manifests(cls, directories, filename, pattern=None, ignore=(),
+                                     overwrite=False):
         """
-        walks directories and writes manifests of name `filename` in-place; returns `cls` instance populated
-        with the given manifests
+        walks directories and writes manifests of name `filename` in-place;
+        returns `cls` instance populated with the given manifests
 
         filename -- filename of manifests to write
         pattern -- shell pattern (glob) or patterns of filenames to match
         ignore -- directory names to ignore
         overwrite -- whether to overwrite existing files of given name
         """
 
         manifest_dict = {}
@@ -687,20 +692,19 @@ class ManifestParser(object):
         pattern -- shell pattern (glob) or patterns of filenames to match
         ignore -- directory names to ignore
         write -- filename or file-like object of manifests to write;
                  if `None` then a StringIO instance will be created
         relative_to -- write paths relative to this path;
                        if false then the paths are absolute
         """
 
-
         # determine output
-        opened_manifest_file = None # name of opened manifest file
-        absolute = not relative_to # whether to output absolute path names as names
+        opened_manifest_file = None  # name of opened manifest file
+        absolute = not relative_to  # whether to output absolute path names as names
         if isinstance(write, string):
             opened_manifest_file = write
             write = file(write, 'w')
         if write is None:
             write = StringIO()
 
         # walk the directories, generating manifests
         def callback(directory, dirpath, dirnames, filenames):
@@ -713,33 +717,31 @@ class ManifestParser(object):
                          if filename != opened_manifest_file]
             # normalize paths
             if not absolute and relative_to:
                 filenames = [relpath(filename, relative_to)
                              for filename in filenames]
 
             # write to manifest
             print >> write, '\n'.join(['[%s]' % denormalize_path(filename)
-                                               for filename in filenames])
-
+                                       for filename in filenames])
 
         cls._walk_directories(directories, callback, pattern=pattern, ignore=ignore)
 
         if opened_manifest_file:
             # close file
             write.close()
             manifests = [opened_manifest_file]
         else:
             # manifests/write is a file-like object;
             # rewind buffer
             write.flush()
             write.seek(0)
             manifests = [write]
 
-
         # make a ManifestParser instance
         return cls(manifests=manifests)
 
 convert = ManifestParser.from_directories
 
 
 class TestManifest(ManifestParser):
     """
@@ -757,17 +759,17 @@ class TestManifest(ManifestParser):
         Run all applied filters on the set of tests.
 
         :param exists: filter out non-existing tests (default True)
         :param disabled: whether to return disabled tests (default True)
         :param values: keys and values to filter on (e.g. `os = linux mac`)
         :param filters: list of filters to apply to the tests
         :returns: list of test objects that were not filtered out
         """
-        tests = [i.copy() for i in self.tests] # shallow copy
+        tests = [i.copy() for i in self.tests]  # shallow copy
 
         # mark all tests as passing
         for test in tests:
             test['expected'] = test.get('expected', 'pass')
 
         # make a copy so original doesn't get modified
         fltrs = self.filters[:]
         if exists:

--- a/testing/mozbase/manifestparser/setup.py
+++ b/testing/mozbase/manifestparser/setup.py
@@ -6,22 +6,22 @@ from setuptools import setup
 
 PACKAGE_NAME = "manifestparser"
 PACKAGE_VERSION = '1.1'
 
 setup(name=PACKAGE_NAME,
       version=PACKAGE_VERSION,
       description="Library to create and manage test manifests",
       long_description="see http://mozbase.readthedocs.org/",
-      classifiers=[], # Get strings from http://pypi.python.org/pypi?%3Aaction=list_classifiers
+      classifiers=[],  # Get strings from http://pypi.python.org/pypi?%3Aaction=list_classifiers
       keywords='mozilla manifests',
       author='Mozilla Automation and Testing Team',
       author_email='tools@lists.mozilla.org',
       url='https://wiki.mozilla.org/Auto-tools/Projects/Mozbase',
       license='MPL',
       zip_safe=False,
       packages=['manifestparser'],
       install_requires=[],
       entry_points="""
       [console_scripts]
       manifestparser = manifestparser.cli:main
       """,
-     )
+      )

--- a/testing/mozbase/manifestparser/tests/test_chunking.py
+++ b/testing/mozbase/manifestparser/tests/test_chunking.py
@@ -28,17 +28,17 @@ class ChunkBySlice(TestCase):
         return tests
 
     def run_all_combos(self, num_tests, disabled=None):
         tests = self.generate_tests(num_tests, disabled=disabled)
 
         for total in range(1, num_tests + 1):
             res = []
             res_disabled = []
-            for chunk in range(1, total+1):
+            for chunk in range(1, total + 1):
                 f = chunk_by_slice(chunk, total)
                 res.append(list(f(tests, {})))
                 if disabled:
                     f.disabled = True
                     res_disabled.append(list(f(tests, {})))
 
             lengths = [len([t for t in c if 'disabled' not in t]) for c in res]
             # the chunk with the most tests should have at most one more test
@@ -91,30 +91,30 @@ class ChunkByDir(TestCase):
                 name = 'test%i' % i
                 test = {'name': name,
                         'relpath': os.path.join(d, name)}
                 yield test
 
     def run_all_combos(self, dirs):
         tests = list(self.generate_tests(dirs))
 
-        deepest = max(len(t['relpath'].split(os.sep))-1 for t in tests)
-        for depth in range(1, deepest+1):
+        deepest = max(len(t['relpath'].split(os.sep)) - 1 for t in tests)
+        for depth in range(1, deepest + 1):
 
             def num_groups(tests):
                 unique = set()
                 for p in [t['relpath'] for t in tests]:
                     p = p.split(os.sep)
-                    p = p[:min(depth, len(p)-1)]
+                    p = p[:min(depth, len(p) - 1)]
                     unique.add(os.sep.join(p))
                 return len(unique)
 
-            for total in range(1, num_groups(tests)+1):
+            for total in range(1, num_groups(tests) + 1):
                 res = []
-                for this in range(1, total+1):
+                for this in range(1, total + 1):
                     f = chunk_by_dir(this, total, depth)
                     res.append(list(f(tests, {})))
 
                 lengths = map(num_groups, res)
                 # the chunk with the most dirs should have at most one more
                 # dir than the chunk with the least dirs
                 self.assertLessEqual(max(lengths) - min(lengths), 1)
 
@@ -203,36 +203,36 @@ class ChunkByRuntime(TestCase):
 
         chunks = [[] for i in range(total)]
         d = 1  # direction
         i = 0
         for runtime, batch in tests_by_manifest:
             chunks[i].extend(batch)
 
             # "draft" style (last pick goes first in the next round)
-            if (i == 0 and d == -1) or (i == total-1 and d == 1):
+            if (i == 0 and d == -1) or (i == total - 1 and d == 1):
                 d = -d
             else:
                 i += d
 
         # make sure this test algorithm is valid
         all_chunks = list(chain.from_iterable(chunks))
         self.assertEqual(len(all_chunks), len(tests))
         for t in tests:
             self.assertIn(t, all_chunks)
 
         return chunks
 
     def run_all_combos(self, dirs):
         tests = list(self.generate_tests(dirs))
         runtimes = self.get_runtimes(tests)
 
-        for total in range(1, len(dirs)+1):
+        for total in range(1, len(dirs) + 1):
             chunks = []
-            for this in range(1, total+1):
+            for this in range(1, total + 1):
                 f = chunk_by_runtime(this, total, runtimes)
                 ret = list(f(tests, {}))
                 chunks.append(ret)
 
             # chunk_by_runtime will mess up order, but chained chunks should
             # contain all of the original tests and be the same length
             all_chunks = list(chain.from_iterable(chunks))
             self.assertEqual(len(all_chunks), len(tests))

--- a/testing/mozbase/manifestparser/tests/test_convert_directory.py
+++ b/testing/mozbase/manifestparser/tests/test_convert_directory.py
@@ -15,22 +15,25 @@ from manifestparser import ManifestParse
 here = os.path.dirname(os.path.abspath(__file__))
 
 # In some cases tempfile.mkdtemp() may returns a path which contains
 # symlinks. Some tests here will then break, as the manifestparser.convert
 # function returns paths that does not contains symlinks.
 #
 # Workaround is to use the following function, if absolute path of temp dir
 # must be compared.
+
+
 def create_realpath_tempdir():
     """
     Create a tempdir without symlinks.
     """
     return os.path.realpath(tempfile.mkdtemp())
 
+
 class TestDirectoryConversion(unittest.TestCase):
     """test conversion of a directory tree to a manifest structure"""
 
     def create_stub(self, directory=None):
         """stub out a directory with files in it"""
 
         files = ('foo', 'bar', 'fleem')
         if directory is None:
@@ -51,34 +54,34 @@ class TestDirectoryConversion(unittest.T
         # create a stub directory
         stub = self.create_stub()
         try:
             stub = stub.replace(os.path.sep, "/")
             self.assertTrue(os.path.exists(stub) and os.path.isdir(stub))
 
             # Make a manifest for it
             manifest = convert([stub])
-            self.assertEqual(str(manifest),
-"""[%(stub)s/bar]
+            out_tmpl = """[%(stub)s/bar]
 subsuite = 
 
 [%(stub)s/fleem]
 subsuite = 
 
 [%(stub)s/foo]
 subsuite = 
 
 [%(stub)s/subdir/subfile]
 subsuite = 
 
-""" % dict(stub=stub))
+"""  # noqa
+            self.assertEqual(str(manifest), out_tmpl % dict(stub=stub))
         except:
             raise
         finally:
-            shutil.rmtree(stub) # cleanup
+            shutil.rmtree(stub)  # cleanup
 
     def test_convert_directory_manifests_in_place(self):
         """
         keep the manifests in place
         """
 
         stub = self.create_stub()
         try:
@@ -98,17 +101,18 @@ subsuite =
         finally:
             shutil.rmtree(stub)
 
     def test_manifest_ignore(self):
         """test manifest `ignore` parameter for ignoring directories"""
 
         stub = self.create_stub()
         try:
-            ManifestParser.populate_directory_manifests([stub], filename='manifest.ini', ignore=('subdir',))
+            ManifestParser.populate_directory_manifests(
+                [stub], filename='manifest.ini', ignore=('subdir',))
             parser = ManifestParser()
             parser.read(os.path.join(stub, 'manifest.ini'))
             self.assertEqual([i['name'] for i in parser.tests],
                              ['bar', 'fleem', 'foo'])
             self.assertFalse(os.path.exists(os.path.join(stub, 'subdir', 'manifest.ini')))
         except:
             raise
         finally:
@@ -157,25 +161,25 @@ subsuite =
         paths = [str(i) for i in range(10)]
         self.assertEqual([i['name'] for i in manifest.missing()],
                          paths)
 
         # But then we copy one over:
         self.assertEqual(manifest.get('name', name='1'), ['1'])
         manifest.update(tempdir, name='1')
         self.assertEqual(sorted(os.listdir(newtempdir)),
-                        ['1', 'manifest.ini'])
+                         ['1', 'manifest.ini'])
 
         # Update that one file and copy all the "tests":
         file(os.path.join(tempdir, '1'), 'w').write('secret door')
         manifest.update(tempdir)
         self.assertEqual(sorted(os.listdir(newtempdir)),
-                        ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'manifest.ini'])
+                         ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'manifest.ini'])
         self.assertEqual(file(os.path.join(newtempdir, '1')).read().strip(),
-                        'secret door')
+                         'secret door')
 
         # clean up:
         shutil.rmtree(tempdir)
         shutil.rmtree(newtempdir)
 
 
 if __name__ == '__main__':
     unittest.main()

--- a/testing/mozbase/manifestparser/tests/test_convert_symlinks.py
+++ b/testing/mozbase/manifestparser/tests/test_convert_symlinks.py
@@ -6,16 +6,17 @@
 
 import os
 import shutil
 import tempfile
 import unittest
 
 from manifestparser import convert, ManifestParser
 
+
 class TestSymlinkConversion(unittest.TestCase):
     """
     test conversion of a directory tree with symlinks to a manifest structure
     """
 
     def create_stub(self, directory=None):
         """stub out a directory with files in it"""
 
@@ -120,16 +121,17 @@ class TestSymlinkConversion(unittest.Tes
         os.symlink(os.path.join('..', 'dir2'),
                    os.path.join(workspace, 'dir1', 'ldir2'))
 
         # create one file in each dir
         open(os.path.join(workspace, 'dir1', 'f1.txt'), 'a').close()
         open(os.path.join(workspace, 'dir1', 'ldir2', 'f2.txt'), 'a').close()
 
         data = []
+
         def callback(rootdirectory, directory, subdirs, files):
             for f in files:
                 data.append(f)
 
         ManifestParser._walk_directories([workspace], callback)
         self.assertEqual(sorted(data), ['f1.txt', 'f2.txt'])
 
 

--- a/testing/mozbase/manifestparser/tests/test_default_overrides.py
+++ b/testing/mozbase/manifestparser/tests/test_default_overrides.py
@@ -5,38 +5,40 @@
 # You can obtain one at http://mozilla.org/MPL/2.0/.
 
 import os
 import unittest
 from manifestparser import ManifestParser
 
 here = os.path.dirname(os.path.abspath(__file__))
 
+
 class TestDefaultSkipif(unittest.TestCase):
     """Tests applying a skip-if condition in [DEFAULT] and || with the value for the test"""
 
-
     def test_defaults(self):
 
         default = os.path.join(here, 'default-skipif.ini')
         parser = ManifestParser(manifests=(default,))
         for test in parser.tests:
             if test['name'] == 'test1':
                 self.assertEqual(test['skip-if'], "(os == 'win' && debug ) || (debug)")
             elif test['name'] == 'test2':
                 self.assertEqual(test['skip-if'], "(os == 'win' && debug ) || (os == 'linux')")
             elif test['name'] == 'test3':
                 self.assertEqual(test['skip-if'], "(os == 'win' && debug ) || (os == 'win')")
             elif test['name'] == 'test4':
-                self.assertEqual(test['skip-if'], "(os == 'win' && debug ) || (os == 'win' && debug)")
+                self.assertEqual(
+                    test['skip-if'], "(os == 'win' && debug ) || (os == 'win' && debug)")
             elif test['name'] == 'test5':
                 self.assertEqual(test['skip-if'], "os == 'win' && debug # a pesky comment")
             elif test['name'] == 'test6':
                 self.assertEqual(test['skip-if'], "(os == 'win' && debug ) || (debug )")
 
+
 class TestDefaultSupportFiles(unittest.TestCase):
     """Tests combining support-files field in [DEFAULT] with the value for a test"""
 
     def test_defaults(self):
 
         default = os.path.join(here, 'default-suppfiles.ini')
         parser = ManifestParser(manifests=(default,))
         expected_supp_files = {

--- a/testing/mozbase/manifestparser/tests/test_expressionparser.py
+++ b/testing/mozbase/manifestparser/tests/test_expressionparser.py
@@ -1,13 +1,14 @@
 #!/usr/bin/env python
 
 import unittest
 from manifestparser import parse
 
+
 class ExpressionParserTest(unittest.TestCase):
     """Test the conditional expression parser."""
 
     def test_basic(self):
 
         self.assertEqual(parse("1"), 1)
         self.assertEqual(parse("100"), 100)
         self.assertEqual(parse("true"), True)
@@ -59,17 +60,16 @@ class ExpressionParserTest(unittest.Test
         self.assertTrue(parse("(true || false)"))
         self.assertTrue(parse("(true && true || false)"))
         self.assertFalse(parse("(true || false) && false"))
         self.assertTrue(parse("(true || false) && true"))
         self.assertTrue(parse("true && (true || false)"))
         self.assertTrue(parse("true && (true || false)"))
         self.assertTrue(parse("(true && false) || (true && (true || false))"))
 
-
     def test_comments(self):
         # comments in expressions work accidentally, via an implementation
         # detail - the '#' character doesn't match any of the regular
         # expressions we specify as tokens, and thus are ignored.
         # However, having explicit tests for them means that should the
         # implementation ever change, comments continue to work, even if that
         # means a new implementation must handle them explicitly.
         self.assertTrue(parse("true == true # it does!"))

--- a/testing/mozbase/manifestparser/tests/test_filters.py
+++ b/testing/mozbase/manifestparser/tests/test_filters.py
@@ -1,9 +1,10 @@
 #!/usr/bin/env python
+# flake8: noqa
 
 from copy import deepcopy
 import os
 import unittest
 
 from manifestparser.filters import (
     subsuite,
     tags,
@@ -139,17 +140,17 @@ class BuiltinFilters(unittest.TestCase):
 
     def test_subsuite(self):
         sub1 = subsuite()
         sub2 = subsuite('baz')
 
         tests = deepcopy(self.tests)
         tests = list(sub1(tests, {}))
         self.assertNotIn(self.tests[5], tests)
-        self.assertEquals(len(tests), len(self.tests)-1)
+        self.assertEquals(len(tests), len(self.tests) - 1)
 
         tests = deepcopy(self.tests)
         tests = list(sub2(tests, {}))
         self.assertEquals(len(tests), 1)
         self.assertIn(self.tests[5], tests)
 
     def test_subsuite_condition(self):
         sub1 = subsuite()

--- a/testing/mozbase/manifestparser/tests/test_manifestparser.py
+++ b/testing/mozbase/manifestparser/tests/test_manifestparser.py
@@ -8,16 +8,17 @@ import os
 import shutil
 import tempfile
 import unittest
 from manifestparser import ManifestParser
 from StringIO import StringIO
 
 here = os.path.dirname(os.path.abspath(__file__))
 
+
 class TestManifestParser(unittest.TestCase):
     """
     Test the manifest parser
 
     You must have manifestparser installed before running these tests.
     Run ``python manifestparser.py setup develop`` with setuptools installed.
     """
 
@@ -36,57 +37,59 @@ class TestManifestParser(unittest.TestCa
 
         # Show how you select subsets of tests:
         mozmill_restart_example = os.path.join(here, 'mozmill-restart-example.ini')
         parser.read(mozmill_restart_example)
         restart_tests = parser.get(type='restart')
         self.assertTrue(len(restart_tests) < len(parser.tests))
         self.assertEqual(len(restart_tests), len(parser.get(manifest=mozmill_restart_example)))
         self.assertFalse([test for test in restart_tests
-                          if test['manifest'] != os.path.join(here, 'mozmill-restart-example.ini')])
+                          if test['manifest'] != os.path.join(here,
+                                                              'mozmill-restart-example.ini')])
         self.assertEqual(parser.get('name', tags=['foo']),
                          ['restartTests/testExtensionInstallUninstall/test2.js',
                           'restartTests/testExtensionInstallUninstall/test1.js'])
         self.assertEqual(parser.get('name', foo='bar'),
                          ['restartTests/testExtensionInstallUninstall/test2.js'])
 
     def test_include(self):
         """Illustrate how include works"""
 
         include_example = os.path.join(here, 'include-example.ini')
         parser = ManifestParser(manifests=(include_example,))
 
         # All of the tests should be included, in order:
         self.assertEqual(parser.get('name'),
                          ['crash-handling', 'fleem', 'flowers'])
-        self.assertEqual([(test['name'], os.path.basename(test['manifest'])) for test in parser.tests],
-                         [('crash-handling', 'bar.ini'), ('fleem', 'include-example.ini'), ('flowers', 'foo.ini')])
+        self.assertEqual([(test['name'], os.path.basename(test['manifest']))
+                          for test in parser.tests],
+                         [('crash-handling', 'bar.ini'),
+                          ('fleem', 'include-example.ini'),
+                          ('flowers', 'foo.ini')])
 
         # The including manifest is always reported as a part of the generated test object.
         self.assertTrue(all([t['ancestor-manifest'] == include_example
                              for t in parser.tests if t['name'] != 'fleem']))
 
-
         # The manifests should be there too:
         self.assertEqual(len(parser.manifests()), 3)
 
         # We already have the root directory:
         self.assertEqual(here, parser.rootdir)
 
-
         # DEFAULT values should persist across includes, unless they're
         # overwritten.  In this example, include-example.ini sets foo=bar, but
         # it's overridden to fleem in bar.ini
         self.assertEqual(parser.get('name', foo='bar'),
                          ['fleem', 'flowers'])
         self.assertEqual(parser.get('name', foo='fleem'),
                          ['crash-handling'])
 
         # Passing parameters in the include section allows defining variables in
-        #the submodule scope:
+        # the submodule scope:
         self.assertEqual(parser.get('name', tags=['red']),
                          ['flowers'])
 
         # However, this should be overridable from the DEFAULT section in the
         # included file and that overridable via the key directly connected to
         # the test:
         self.assertEqual(parser.get(name='flowers')[0]['blue'],
                          'ocean')
@@ -102,40 +105,53 @@ class TestManifestParser(unittest.TestCa
                          ['crash-handling', 'fleem'])
 
         # All of the included tests actually exist:
         self.assertEqual([i['name'] for i in parser.missing()], [])
 
         # Write the output to a manifest:
         buffer = StringIO()
         parser.write(fp=buffer, global_kwargs={'foo': 'bar'})
+        expected_output = """[DEFAULT]
+foo = bar
+
+[fleem]
+subsuite = 
+
+[include/flowers]
+blue = ocean
+red = roses
+subsuite = 
+yellow = submarine"""  # noqa
+
         self.assertEqual(buffer.getvalue().strip(),
-                         '[DEFAULT]\nfoo = bar\n\n[fleem]\nsubsuite = \n\n[include/flowers]\nblue = ocean\nred = roses\nsubsuite = \nyellow = submarine')
+                         expected_output)
 
     def test_invalid_path(self):
         """
         Test invalid path should not throw when not strict
         """
         manifest = os.path.join(here, 'include-invalid.ini')
-        parser = ManifestParser(manifests=(manifest,), strict=False)
+        ManifestParser(manifests=(manifest,), strict=False)
 
     def test_parent_inheritance(self):
         """
         Test parent manifest variable inheritance
         Specifically tests that inherited variables from parent includes
         properly propagate downstream
         """
         parent_example = os.path.join(here, 'parent', 'level_1', 'level_2',
                                       'level_3', 'level_3.ini')
         parser = ManifestParser(manifests=(parent_example,))
 
         # Parent manifest test should not be included
         self.assertEqual(parser.get('name'),
                          ['test_3'])
-        self.assertEqual([(test['name'], os.path.basename(test['manifest'])) for test in parser.tests],
+        self.assertEqual([(test['name'], os.path.basename(test['manifest']))
+                          for test in parser.tests],
                          [('test_3', 'level_3.ini')])
 
         # DEFAULT values should be the ones from level 1
         self.assertEqual(parser.get('name', x='level_1'),
                          ['test_3'])
 
         # Write the output to a manifest:
         buffer = StringIO()
@@ -149,17 +165,18 @@ class TestManifestParser(unittest.TestCa
         """
         parent_example = os.path.join(here, 'parent', 'level_1', 'level_2',
                                       'level_3', 'level_3_default.ini')
         parser = ManifestParser(manifests=(parent_example,))
 
         # Parent manifest test should not be included
         self.assertEqual(parser.get('name'),
                          ['test_3'])
-        self.assertEqual([(test['name'], os.path.basename(test['manifest'])) for test in parser.tests],
+        self.assertEqual([(test['name'], os.path.basename(test['manifest']))
+                          for test in parser.tests],
                          [('test_3', 'level_3_default.ini')])
 
         # DEFAULT values should be the ones from level 3
         self.assertEqual(parser.get('name', x='level_3'),
                          ['test_3'])
 
         # Write the output to a manifest:
         buffer = StringIO()
@@ -186,17 +203,17 @@ class TestManifestParser(unittest.TestCa
         Test server_root properly expands as an absolute path
         """
         server_example = os.path.join(here, 'parent', 'level_1', 'level_2',
                                       'level_3', 'level_3_server-root.ini')
         parser = ManifestParser(manifests=(server_example,))
 
         # A regular variable will inherit its value directly
         self.assertEqual(parser.get('name', **{'other-root': '../root'}),
-                                    ['test_3'])
+                         ['test_3'])
 
         # server-root will expand its value as an absolute path
         # we will not find anything for the original value
         self.assertEqual(parser.get('name', **{'server-root': '../root'}), [])
 
         # check that the path has expanded
         self.assertEqual(parser.get('server-root')[0],
                          os.path.join(here, 'parent', 'root'))

--- a/testing/mozbase/manifestparser/tests/test_read_ini.py
+++ b/testing/mozbase/manifestparser/tests/test_read_ini.py
@@ -10,16 +10,17 @@ is the default:
 http://docs.python.org/2/library/configparser.html
 """
 
 import unittest
 from manifestparser import read_ini
 from ConfigParser import ConfigParser
 from StringIO import StringIO
 
+
 class IniParserTest(unittest.TestCase):
 
     def test_inline_comments(self):
         """
         We have no inline comments; so we're testing to ensure we don't:
         https://bugzilla.mozilla.org/show_bug.cgi?id=855288
         """
 

--- a/testing/mozbase/manifestparser/tests/test_testmanifest.py
+++ b/testing/mozbase/manifestparser/tests/test_testmanifest.py
@@ -13,19 +13,21 @@ here = os.path.dirname(os.path.abspath(_
 
 class TestTestManifest(unittest.TestCase):
     """Test the Test Manifest"""
 
     def test_testmanifest(self):
         # Test filtering based on platform:
         filter_example = os.path.join(here, 'filter-example.ini')
         manifest = TestManifest(manifests=(filter_example,), strict=False)
-        self.assertEqual([i['name'] for i in manifest.active_tests(os='win', disabled=False, exists=False)],
+        self.assertEqual([i['name'] for i in manifest.active_tests(os='win', disabled=False,
+                                                                   exists=False)],
                          ['windowstest', 'fleem'])
-        self.assertEqual([i['name'] for i in manifest.active_tests(os='linux', disabled=False, exists=False)],
+        self.assertEqual([i['name'] for i in manifest.active_tests(os='linux', disabled=False,
+                                                                   exists=False)],
                          ['fleem', 'linuxtest'])
 
         # Look for existing tests.  There is only one:
         self.assertEqual([i['name'] for i in manifest.active_tests()],
                          ['fleem'])
 
         # You should be able to expect failures:
         last = manifest.active_tests(exists=False, toolkit='gtk2')[-1]

--- a/testing/mozbase/mozcrash/mozcrash/__init__.py
+++ b/testing/mozbase/mozcrash/mozcrash/__init__.py
@@ -1,8 +1,10 @@
+# flake8: noqa
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this file,
 # You can obtain one at http://mozilla.org/MPL/2.0/.
 """
-mozcrash is a library for getting a stack trace out of processes that have crashed and left behind a minidump file using the Google Breakpad library.
+mozcrash is a library for getting a stack trace out of processes that have crashed
+and left behind a minidump file using the Google Breakpad library.
 """
 
 from mozcrash import *

--- a/testing/mozbase/mozcrash/mozcrash/mozcrash.py
+++ b/testing/mozbase/mozcrash/mozcrash/mozcrash.py
@@ -1,36 +1,36 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this file,
 # You can obtain one at http://mozilla.org/MPL/2.0/.
 
-__all__ = [
-    'check_for_crashes',
-    'check_for_java_exception',
-    'kill_and_get_minidump',
-    'log_crashes',
-    'cleanup_pending_crash_reports',
-]
-
 import glob
 import os
 import re
 import shutil
 import signal
 import subprocess
 import sys
 import tempfile
 import urllib2
 import zipfile
 from collections import namedtuple
 
 import mozfile
 import mozinfo
 import mozlog
 
+__all__ = [
+    'check_for_crashes',
+    'check_for_java_exception',
+    'kill_and_get_minidump',
+    'log_crashes',
+    'cleanup_pending_crash_reports',
+]
+
 
 StackInfo = namedtuple("StackInfo",
                        ["minidump_path",
                         "signature",
                         "stackwalk_stdout",
                         "stackwalk_stderr",
                         "stackwalk_retcode",
                         "stackwalk_errors",
@@ -188,17 +188,18 @@ class CrashInfo(object):
     def dump_files(self):
         """List of tuple (path_to_dump_file, path_to_extra_file) for each dump
            file in self.dump_directory. The extra files may not exist."""
         if self._dump_files is None:
             self._dump_files = [(path, os.path.splitext(path)[0] + '.extra') for path in
                                 glob.glob(os.path.join(self.dump_directory, '*.dmp'))]
             max_dumps = 10
             if len(self._dump_files) > max_dumps:
-                self.logger.warning("Found %d dump files -- limited to %d!" % (len(self._dump_files), max_dumps))
+                self.logger.warning("Found %d dump files -- limited to %d!" %
+                                    (len(self._dump_files), max_dumps))
                 del self._dump_files[max_dumps:]
 
         return self._dump_files
 
     @property
     def has_dumps(self):
         """Boolean indicating whether any crash dump files were found in the
         current directory"""
@@ -233,17 +234,17 @@ class CrashInfo(object):
         errors = []
         signature = None
         include_stderr = False
         out = None
         err = None
         retcode = None
         if (self.symbols_path and self.stackwalk_binary and
             os.path.exists(self.stackwalk_binary) and
-            os.access(self.stackwalk_binary, os.X_OK)):
+                os.access(self.stackwalk_binary, os.X_OK)):
 
             command = [
                 self.stackwalk_binary,
                 path,
                 self.symbols_path
             ]
             self.logger.info('Copy/paste: ' + ' '.join(command))
             # run minidump_stackwalk
@@ -257,22 +258,23 @@ class CrashInfo(object):
 
             if len(out) > 3:
                 # minidump_stackwalk is chatty,
                 # so ignore stderr when it succeeds.
                 # The top frame of the crash is always the line after "Thread N (crashed)"
                 # Examples:
                 #  0  libc.so + 0xa888
                 #  0  libnss3.so!nssCertificate_Destroy [certificate.c : 102 + 0x0]
-                #  0  mozjs.dll!js::GlobalObject::getDebuggers() [GlobalObject.cpp:89df18f9b6da : 580 + 0x0]
-                #  0  libxul.so!void js::gc::MarkInternal<JSObject>(JSTracer*, JSObject**) [Marking.cpp : 92 + 0x28]
+                #  0  mozjs.dll!js::GlobalObject::getDebuggers() [GlobalObject.cpp:89df18f9b6da : 580 + 0x0] # noqa
+                # 0  libxul.so!void js::gc::MarkInternal<JSObject>(JSTracer*, JSObject**)
+                # [Marking.cpp : 92 + 0x28]
                 lines = out.splitlines()
                 for i, line in enumerate(lines):
                     if "(crashed)" in line:
-                        match = re.search(r"^ 0  (?:.*!)?(?:void )?([^\[]+)", lines[i+1])
+                        match = re.search(r"^ 0  (?:.*!)?(?:void )?([^\[]+)", lines[i + 1])
                         if match:
                             signature = "@ %s" % match.group(1).strip()
                         break
             else:
                 include_stderr = True
 
         else:
             if not self.symbols_path:
@@ -320,50 +322,52 @@ class CrashInfo(object):
 
 
 def check_for_java_exception(logcat, quiet=False):
     """
     Print a summary of a fatal Java exception, if present in the provided
     logcat output.
 
     Example:
-    PROCESS-CRASH | java-exception | java.lang.NullPointerException at org.mozilla.gecko.GeckoApp$21.run(GeckoApp.java:1833)
+    PROCESS-CRASH | java-exception | java.lang.NullPointerException at org.mozilla.gecko.GeckoApp$21.run(GeckoApp.java:1833) # noqa
 
     `logcat` should be a list of strings.
 
     If `quiet` is set, no PROCESS-CRASH message will be printed to stdout if a
     crash is detected.
 
     Returns True if a fatal Java exception was found, False otherwise.
     """
     found_exception = False
 
     for i, line in enumerate(logcat):
         # Logs will be of form:
         #
-        # 01-30 20:15:41.937 E/GeckoAppShell( 1703): >>> REPORTING UNCAUGHT EXCEPTION FROM THREAD 9 ("GeckoBackgroundThread")
+        # 01-30 20:15:41.937 E/GeckoAppShell( 1703): >>> REPORTING UNCAUGHT EXCEPTION FROM THREAD 9 ("GeckoBackgroundThread") # noqa
         # 01-30 20:15:41.937 E/GeckoAppShell( 1703): java.lang.NullPointerException
-        # 01-30 20:15:41.937 E/GeckoAppShell( 1703): 	at org.mozilla.gecko.GeckoApp$21.run(GeckoApp.java:1833)
-        # 01-30 20:15:41.937 E/GeckoAppShell( 1703): 	at android.os.Handler.handleCallback(Handler.java:587)
+        # 01-30 20:15:41.937 E/GeckoAppShell( 1703): at org.mozilla.gecko.GeckoApp$21.run(GeckoApp.java:1833) # noqa
+        # 01-30 20:15:41.937 E/GeckoAppShell( 1703): at android.os.Handler.handleCallback(Handler.java:587) # noqa
         if "REPORTING UNCAUGHT EXCEPTION" in line or "FATAL EXCEPTION" in line:
             # Strip away the date, time, logcat tag and pid from the next two lines and
             # concatenate the remainder to form a concise summary of the exception.
             found_exception = True
             if len(logcat) >= i + 3:
                 logre = re.compile(r".*\): \t?(.*)")
-                m = logre.search(logcat[i+1])
+                m = logre.search(logcat[i + 1])
                 if m and m.group(1):
                     exception_type = m.group(1)
-                m = logre.search(logcat[i+2])
+                m = logre.search(logcat[i + 2])
                 if m and m.group(1):
                     exception_location = m.group(1)
                 if not quiet:
-                    print "PROCESS-CRASH | java-exception | %s %s" % (exception_type, exception_location)
+                    print "PROCESS-CRASH | java-exception | %s %s" % (exception_type,
+                                                                      exception_location)
             else:
-                print "Automation Error: java exception in logcat at line %d of %d: %s" % (i, len(logcat), line)
+                print "Automation Error: java exception in logcat at line " \
+                    "%d of %d: %s" % (i, len(logcat), line)
             break
 
     return found_exception
 
 if mozinfo.isWin:
     import ctypes
     import uuid
 
@@ -385,17 +389,17 @@ if mozinfo.isWin:
         CREATE_ALWAYS = 2
         FILE_ATTRIBUTE_NORMAL = 0x80
         INVALID_HANDLE_VALUE = -1
 
         file_name = os.path.join(dump_directory,
                                  str(uuid.uuid4()) + ".dmp")
 
         if (mozinfo.info['bits'] != ctypes.sizeof(ctypes.c_voidp) * 8 and
-            utility_path):
+                utility_path):
             # We're not going to be able to write a minidump with ctypes if our
             # python process was compiled for a different architecture than
             # firefox, so we invoke the minidumpwriter utility program.
 
             log = get_logger()
             minidumpwriter = os.path.normpath(os.path.join(utility_path,
                                                            "minidumpwriter.exe"))
             log.info("Using %s to write a dump to %s for [%d]" %
@@ -460,16 +464,17 @@ else:
     def kill_pid(pid):
         """
         Terminate a process with extreme prejudice.
 
         :param pid: PID of the process to terminate.
         """
         os.kill(pid, signal.SIGKILL)
 
+
 def kill_and_get_minidump(pid, dump_directory, utility_path=None):
     """
     Attempt to kill a process and leave behind a minidump describing its
     execution state.
 
     :param pid: The PID of the process to kill.
     :param dump_directory: The directory where a minidump should be written on
     Windows, where the dump will be written from outside the process.
@@ -487,16 +492,17 @@ def kill_and_get_minidump(pid, dump_dire
     if mozinfo.isWin:
         write_minidump(pid, dump_directory, utility_path)
     elif mozinfo.isLinux or mozinfo.isMac:
         os.kill(pid, signal.SIGABRT)
         needs_killing = False
     if needs_killing:
         kill_pid(pid)
 
+
 def cleanup_pending_crash_reports():
     """
     Delete any pending crash reports.
 
     The presence of pending crash reports may be reported by the browser,
     affecting test results; it is best to ensure that these are removed
     before starting any browser tests.
 

--- a/testing/mozbase/mozcrash/setup.py
+++ b/testing/mozbase/mozcrash/setup.py
@@ -8,19 +8,20 @@ PACKAGE_NAME = 'mozcrash'
 PACKAGE_VERSION = '0.17'
 
 # dependencies
 deps = ['mozfile >= 1.0',
         'mozlog >= 3.0']
 
 setup(name=PACKAGE_NAME,
       version=PACKAGE_VERSION,
-      description="Library for printing stack traces from minidumps left behind by crashed processes",
+      description="Library for printing stack traces from minidumps "
+      "left behind by crashed processes",
       long_description="see http://mozbase.readthedocs.org/",
-      classifiers=[], # Get strings from http://pypi.python.org/pypi?%3Aaction=list_classifiers
+      classifiers=[],  # Get strings from http://pypi.python.org/pypi?%3Aaction=list_classifiers
       keywords='mozilla',
       author='Mozilla Automation and Tools team',
       author_email='tools@lists.mozilla.org',
       url='https://wiki.mozilla.org/Auto-tools/Projects/Mozbase',
       license='MPL',
       packages=['mozcrash'],
       include_package_data=True,
       zip_safe=False,

--- a/testing/mozbase/mozcrash/tests/test.py
+++ b/testing/mozbase/mozcrash/tests/test.py
@@ -1,41 +1,52 @@
 #!/usr/bin/env python
 #
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this file,
 # You can obtain one at http://mozilla.org/MPL/2.0/.
 
-import os, unittest, subprocess, tempfile, shutil, urlparse, zipfile, StringIO
+import os
+import unittest
+import subprocess
+import tempfile
+import shutil
+import urlparse
+import zipfile
+import StringIO
 import mozcrash
 import mozhttpd
 import mozlog.unstructured as mozlog
 
 # Make logs go away
 log = mozlog.getLogger("mozcrash", handler=mozlog.FileHandler(os.devnull))
 
+
 def popen_factory(stdouts):
     """
     Generate a class that can mock subprocess.Popen. |stdouts| is an iterable that
     should return an iterable for the stdout of each process in turn.
     """
     class mock_popen(object):
+
         def __init__(self, args, *args_rest, **kwargs):
             self.stdout = stdouts.next()
             self.returncode = 0
 
         def wait(self):
             return 0
 
         def communicate(self):
             return (self.stdout.next(), "")
 
     return mock_popen
 
+
 class TestCrash(unittest.TestCase):
+
     def setUp(self):
         self.tempdir = tempfile.mkdtemp()
         # a fake file to use as a stackwalk binary
         self.stackwalk = os.path.join(self.tempdir, "stackwalk")
         open(self.stackwalk, "w").write("fake binary")
         self._subprocess_popen = subprocess.Popen
         subprocess.Popen = popen_factory(self.next_mock_stdout())
         self.stdouts = []
@@ -168,61 +179,72 @@ class TestCrash(unittest.TestCase):
         self.stdouts.append(["this is some output"])
 
         def make_zipfile():
             data = StringIO.StringIO()
             z = zipfile.ZipFile(data, 'w')
             z.writestr("symbols.txt", "abc/xyz")
             z.close()
             return data.getvalue()
+
         def get_symbols(req):
             headers = {}
             return (200, headers, make_zipfile())
         httpd = mozhttpd.MozHttpd(port=0,
-                                  urlhandlers=[{'method':'GET', 'path':'/symbols', 'function':get_symbols}])
+                                  urlhandlers=[{'method': 'GET',
+                                                'path': '/symbols',
+                                                'function': get_symbols}])
         httpd.start()
         symbol_url = urlparse.urlunsplit(('http', '%s:%d' % httpd.httpd.server_address,
-                                        '/symbols','',''))
+                                          '/symbols', '', ''))
         self.assert_(mozcrash.check_for_crashes(self.tempdir,
                                                 symbol_url,
                                                 stackwalk_binary=self.stackwalk,
                                                 quiet=True))
 
+
 class TestJavaException(unittest.TestCase):
-       def setUp(self):
-               self.test_log = ["01-30 20:15:41.937 E/GeckoAppShell( 1703): >>> REPORTING UNCAUGHT EXCEPTION FROM THREAD 9 (\"GeckoBackgroundThread\")",
-                       "01-30 20:15:41.937 E/GeckoAppShell( 1703): java.lang.NullPointerException",
-                       "01-30 20:15:41.937 E/GeckoAppShell( 1703):    at org.mozilla.gecko.GeckoApp$21.run(GeckoApp.java:1833)",
-                       "01-30 20:15:41.937 E/GeckoAppShell( 1703):    at android.os.Handler.handleCallback(Handler.java:587)"]
 
-       def test_uncaught_exception(self):
-               """
-               Test for an exception which should be caught
-               """
-               self.assert_(mozcrash.check_for_java_exception(self.test_log, quiet=True))
+    def setUp(self):
+        self.test_log = [
+            "01-30 20:15:41.937 E/GeckoAppShell( 1703): >>> "
+            "REPORTING UNCAUGHT EXCEPTION FROM THREAD 9 (\"GeckoBackgroundThread\")",
+            "01-30 20:15:41.937 E/GeckoAppShell( 1703): java.lang.NullPointerException",
+            "01-30 20:15:41.937 E/GeckoAppShell( 1703):"
+            "    at org.mozilla.gecko.GeckoApp$21.run(GeckoApp.java:1833)",
+            "01-30 20:15:41.937 E/GeckoAppShell( 1703):"
+            "    at android.os.Handler.handleCallback(Handler.java:587)"]
+
+    def test_uncaught_exception(self):
+        """
+        Test for an exception which should be caught
+        """
+        self.assert_(mozcrash.check_for_java_exception(self.test_log, quiet=True))
 
-       def test_fatal_exception(self):
-               """
-               Test for an exception which should be caught
-               """
-               fatal_log = list(self.test_log)
-               fatal_log[0] = "01-30 20:15:41.937 E/GeckoAppShell( 1703): >>> FATAL EXCEPTION FROM THREAD 9 (\"GeckoBackgroundThread\")"
-               self.assert_(mozcrash.check_for_java_exception(fatal_log, quiet=True))
+    def test_fatal_exception(self):
+        """
+        Test for an exception which should be caught
+        """
+        fatal_log = list(self.test_log)
+        fatal_log[0] = "01-30 20:15:41.937 E/GeckoAppShell( 1703):" \
+                       " >>> FATAL EXCEPTION FROM THREAD 9 (\"GeckoBackgroundThread\")"
+        self.assert_(mozcrash.check_for_java_exception(fatal_log, quiet=True))
 
-       def test_truncated_exception(self):
-               """
-               Test for an exception which should be caught which
-               was truncated
-               """
-               truncated_log = list(self.test_log)
-               truncated_log[0], truncated_log[1] = truncated_log[1], truncated_log[0]
-               self.assert_(mozcrash.check_for_java_exception(truncated_log, quiet=True))
+    def test_truncated_exception(self):
+        """
+        Test for an exception which should be caught which
+        was truncated
+        """
+        truncated_log = list(self.test_log)
+        truncated_log[0], truncated_log[1] = truncated_log[1], truncated_log[0]
+        self.assert_(mozcrash.check_for_java_exception(truncated_log, quiet=True))
 
-       def test_unchecked_exception(self):
-               """
-               Test for an exception which should not be caught
-               """
-               passable_log = list(self.test_log)
-               passable_log[0] = "01-30 20:15:41.937 E/GeckoAppShell( 1703): >>> NOT-SO-BAD EXCEPTION FROM THREAD 9 (\"GeckoBackgroundThread\")"
-               self.assert_(not mozcrash.check_for_java_exception(passable_log, quiet=True))
+    def test_unchecked_exception(self):
+        """
+        Test for an exception which should not be caught
+        """
+        passable_log = list(self.test_log)
+        passable_log[0] = "01-30 20:15:41.937 E/GeckoAppShell( 1703):" \
+                          " >>> NOT-SO-BAD EXCEPTION FROM THREAD 9 (\"GeckoBackgroundThread\")"
+        self.assert_(not mozcrash.check_for_java_exception(passable_log, quiet=True))
 
 if __name__ == '__main__':
     unittest.main()

--- a/testing/mozbase/mozdebug/mozdebug/__init__.py
+++ b/testing/mozbase/mozdebug/mozdebug/__init__.py
@@ -1,8 +1,9 @@
+# flake8: noqa
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this file,
 # You can obtain one at http://mozilla.org/MPL/2.0/.
 
 """
 This module contains a set of function to gather information about the
 debugging capabilities of the platform. It allows to look for a specific
 debugger or to query the system for a compatible/default debugger.

--- a/testing/mozbase/mozdebug/mozdebug/mozdebug.py
+++ b/testing/mozbase/mozdebug/mozdebug/mozdebug.py
@@ -56,36 +56,38 @@ To add support for a new debugger, simpl
     # Windows Development Kit super-debugger.
     'windbg.exe': {
         'interactive': True,
     },
 }
 
 # Maps each OS platform to the preferred debugger programs found in _DEBUGGER_INFO.
 _DEBUGGER_PRIORITIES = {
-      'win': ['devenv.exe', 'wdexpress.exe'],
-      'linux': ['gdb', 'cgdb', 'lldb'],
-      'mac': ['lldb', 'gdb'],
-      'android': ['gdb'],
-      'unknown': ['gdb']
+    'win': ['devenv.exe', 'wdexpress.exe'],
+    'linux': ['gdb', 'cgdb', 'lldb'],
+    'mac': ['lldb', 'gdb'],
+    'android': ['gdb'],
+    'unknown': ['gdb']
 }
 
+
 def _windbg_installation_paths():
     programFilesSuffixes = ['', ' (x86)']
     programFiles = "C:/Program Files"
     # Try the most recent versions first.
     windowsKitsVersions = ['10', '8.1', '8']
 
     for suffix in programFilesSuffixes:
         windowsKitsPrefix = os.path.join(programFiles + suffix,
                                          'Windows Kits')
         for version in windowsKitsVersions:
             yield os.path.join(windowsKitsPrefix, version,
                                'Debuggers', 'x86', 'windbg.exe')
 
+
 def get_debugger_path(debugger):
     '''
     Get the full path of the debugger.
 
     :param debugger: The name of the debugger.
     '''
 
     if mozinfo.os == 'mac' and debugger == 'lldb':
@@ -100,17 +102,18 @@ def get_debugger_path(debugger):
             if path:
                 return path
         except:
             # Just default to find_executable instead.
             pass
 
     return find_executable(debugger)
 
-def get_debugger_info(debugger, debuggerArgs = None, debuggerInteractive = False):
+
+def get_debugger_info(debugger, debuggerArgs=None, debuggerInteractive=False):
     '''
     Get the information about the requested debugger.
 
     Returns a dictionary containing the |path| of the debugger executable,
     if it will run in |interactive| mode, its arguments and whether it needs
     to escape arguments it passes to the debugged program (|requiresEscapedArgs|).
     If the debugger cannot be found in the system, returns |None|.
 
@@ -122,17 +125,17 @@ def get_debugger_info(debugger, debugger
     '''
 
     debuggerPath = None
 
     if debugger:
         # Append '.exe' to the debugger on Windows if it's not present,
         # so things like '--debugger=devenv' work.
         if (os.name == 'nt'
-            and not debugger.lower().endswith('.exe')):
+                and not debugger.lower().endswith('.exe')):
             debugger += '.exe'
 
         debuggerPath = get_debugger_path(debugger)
 
     if not debuggerPath:
         # windbg is not installed with the standard set of tools, and it's
         # entirely possible that the user hasn't added the install location to
         # PATH, so we have to be a little more clever than normal to locate it.
@@ -181,19 +184,22 @@ def get_debugger_info(debugger, debugger
         debugger_interactive,
         debugger_arguments,
         get_debugger_info('requiresEscapedArgs', False)
     )
 
     return d
 
 # Defines the search policies to use in get_default_debugger_name.
+
+
 class DebuggerSearch:
-  OnlyFirst = 1
-  KeepLooking = 2
+    OnlyFirst = 1
+    KeepLooking = 2
+
 
 def get_default_debugger_name(search=DebuggerSearch.OnlyFirst):
     '''
     Get the debugger name for the default debugger on current platform.
 
     :param search: If specified, stops looking for the debugger if the
      default one is not found (|DebuggerSearch.OnlyFirst|) or keeps
      looking for other compatible debuggers (|DebuggerSearch.KeepLooking|).
@@ -254,28 +260,32 @@ def get_default_debugger_name(search=Deb
 # TODO: pass in the path to the Valgrind to be used (--valgrind=), and
 # check what flags it accepts.  Possible args that might be beneficial:
 #
 # --num-transtab-sectors=24   [reduces re-jitting overheads in long runs]
 # --px-default=allregs-at-mem-access
 # --px-file-backed=unwindregs-at-mem-access
 #                             [these reduce PX overheads as described above]
 #
+
+
 def get_default_valgrind_args():
     return (['--fair-sched=yes',
              '--smc-check=all-non-file',
              '--vex-iropt-register-updates=allregs-at-mem-access',
              '--trace-children=yes',
              '--child-silent-after-fork=yes',
              ('--trace-children-skip='
               + '/usr/bin/hg,/bin/rm,*/bin/certutil,*/bin/pk12util,'
               + '*/bin/ssltunnel,*/bin/uname,*/bin/which,*/bin/ps,'
               + '*/bin/grep,*/bin/java'),
-            ]
+             ]
             + get_default_valgrind_tool_specific_args())
 
 # The default tool is Memcheck.  Feeding these arguments to a different
 # Valgrind tool will cause it to fail at startup, so don't do that!
+
+
 def get_default_valgrind_tool_specific_args():
     return ['--partial-loads-ok=yes',
             '--leak-check=full',
             '--show-possibly-lost=no',
-           ]
+            ]

--- a/testing/mozbase/mozdebug/setup.py
+++ b/testing/mozbase/mozdebug/setup.py
@@ -3,25 +3,25 @@
 # You can obtain one at http://mozilla.org/MPL/2.0/.
 
 from setuptools import setup
 
 PACKAGE_VERSION = '0.1'
 
 setup(name='mozdebug',
       version=PACKAGE_VERSION,
-      description="Utilities for running applications under native code debuggers intended for use in Mozilla testing",
+      description="Utilities for running applications under native code debuggers "
+      "intended for use in Mozilla testing",
       long_description="see http://mozbase.readthedocs.org/",
-      classifiers=[], # Get strings from http://pypi.python.org/pypi?%3Aaction=list_classifiers
+      classifiers=[],  # Get strings from http://pypi.python.org/pypi?%3Aaction=list_classifiers
       keywords='mozilla',
       author='Mozilla Automation and Testing Team',
       author_email='tools@lists.mozilla.org',
       url='https://wiki.mozilla.org/Auto-tools/Projects/Mozbase',
       license='MPL',
       packages=['mozdebug'],
       include_package_data=True,
       zip_safe=False,
       install_requires=['mozinfo'],
       entry_points="""
       # -*- Entry points: -*-
       """,
       )
-

--- a/testing/mozbase/mozdevice/adb_tests/test_device_running_adb_as_root.py
+++ b/testing/mozbase/mozdevice/adb_tests/test_device_running_adb_as_root.py
@@ -5,17 +5,19 @@
  Running this test case requires various reboots which makes it a
  very slow test case to run.
 """
 import unittest
 import sys
 
 from mozdevice import DeviceManagerADB
 
+
 class TestFileOperations(unittest.TestCase):
+
     def setUp(self):
         dm = DeviceManagerADB()
         dm.reboot(wait=True)
 
     def test_run_adb_as_root_parameter(self):
         dm = DeviceManagerADB()
         self.assertTrue(dm.processInfo("adbd")[2] != "root")
         dm = DeviceManagerADB(runAdbAsRoot=True)
@@ -29,18 +31,18 @@ class TestFileOperations(unittest.TestCa
 
     def tearDown(self):
         dm = DeviceManagerADB()
         dm.reboot()
 
 if __name__ == "__main__":
     dm = DeviceManagerADB()
     if not dm.devices():
-       print "There are no connected adb devices"
-       sys.exit(1)
+        print "There are no connected adb devices"
+        sys.exit(1)
     else:
-        if not (int(dm._runCmd(["shell", "getprop", "ro.secure"]).output[0]) and \
+        if not (int(dm._runCmd(["shell", "getprop", "ro.secure"]).output[0]) and
                 int(dm._runCmd(["shell", "getprop", "ro.debuggable"]).output[0])):
             print "This test case is meant for devices with devices that start " \
-                    "adbd as non-root and allows for adbd to be restarted as root."
+                "adbd as non-root and allows for adbd to be restarted as root."
             sys.exit(1)
 
     unittest.main()

--- a/testing/mozbase/mozdevice/adb_tests/test_devicemanagerADB.py
+++ b/testing/mozbase/mozdevice/adb_tests/test_devicemanagerADB.py
@@ -39,21 +39,23 @@ import re
 import socket
 import sys
 import tempfile
 import unittest
 from StringIO import StringIO
 
 from mozdevice import DeviceManagerADB, DMError
 
+
 def find_mount_permissions(dm, mount_path):
     for mount_point in dm._runCmd(["shell", "mount"]).output:
         if mount_point.find(mount_path) > 0:
             return re.search('(ro|rw)(?=,)', mount_point).group(0)
 
+
 class DeviceManagerADBTestCase(unittest.TestCase):
     tempLocalDir = "tempDir"
     tempLocalFile = os.path.join(tempLocalDir, "tempfile.txt")
     tempRemoteDir = None
     tempRemoteFile = None
     tempRemoteSystemFile = None
 
     def setUp(self):
@@ -76,32 +78,33 @@ class DeviceManagerADBTestCase(unittest.
         self.dm = DeviceManagerADB()
         if not os.path.exists(self.tempLocalDir):
             os.mkdir(self.tempLocalDir)
         if not os.path.exists(self.tempLocalFile):
             # Create empty file
             open(self.tempLocalFile, 'w').close()
         self.tempRemoteDir = self.dm.getTempDir()
         self.tempRemoteFile = os.path.join(self.tempRemoteDir,
-                os.path.basename(self.tempLocalFile))
+                                           os.path.basename(self.tempLocalFile))
         self.tempRemoteSystemFile = \
             os.path.join("/system", os.path.basename(self.tempLocalFile))
 
     @classmethod
     def tearDownClass(self):
         os.remove(self.tempLocalFile)
         os.rmdir(self.tempLocalDir)
         if self.dm.dirExists(self.tempRemoteDir):
             # self.tempRemoteFile will get deleted with it
             self.dm.removeDir(self.tempRemoteDir)
         if self.dm.fileExists(self.tempRemoteSystemFile):
             self.dm.removeFile(self.tempRemoteSystemFile)
 
 
 class TestFileOperations(DeviceManagerADBTestCase):
+
     def test_make_and_remove_directory(self):
         dir1 = os.path.join(self.tempRemoteDir, "dir1")
         self.assertFalse(self.dm.dirExists(dir1))
         self.dm.mkDir(dir1)
         self.assertTrue(self.dm.dirExists(dir1))
         self.dm.removeDir(dir1)
         self.assertFalse(self.dm.dirExists(dir1))
 
@@ -163,32 +166,33 @@ class TestFileOperations(DeviceManagerAD
         self.dm.removeFile(self.tempRemoteSystemFile)
         self.assertFalse(self.dm.fileExists(self.tempRemoteSystemFile))
         self.dm.shell(['mount', '-r', '-o', 'remount', '/system'], out)
         out.close()
         self.assertTrue(find_mount_permissions(self.dm, "/system") == "ro")
 
 
 class TestOther(DeviceManagerADBTestCase):
+
     def test_get_list_of_processes(self):
         self.assertEquals(type(self.dm.getProcessList()), list)
 
     def test_get_current_time(self):
         self.assertEquals(type(self.dm.getCurrentTime()), int)
 
     def test_get_info(self):
         self.assertEquals(type(self.dm.getInfo()), dict)
 
     def test_list_devices(self):
         self.assertEquals(len(list(self.dm.devices())), 1)
 
     def test_shell(self):
         out = StringIO()
         self.dm.shell(["echo", "$COMPANY", ";", "pwd"], out,
-                env={"COMPANY":"Mozilla"}, cwd="/", timeout=4, root=True)
+                      env={"COMPANY": "Mozilla"}, cwd="/", timeout=4, root=True)
         output = str(out.getvalue()).rstrip().splitlines()
         out.close()
         self.assertEquals(output, ['Mozilla', '/'])
 
     def test_port_forwarding(self):
         s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         s.bind(("", 0))
         port = s.getsockname()[1]
@@ -198,18 +202,18 @@ class TestOther(DeviceManagerADBTestCase
 
     def test_port_forwarding_error(self):
         self.assertRaises(DMError, self.dm.forward, "", "")
 
 
 if __name__ == '__main__':
     dm = DeviceManagerADB()
     if not dm.devices():
-       print "There are no connected adb devices"
-       sys.exit(1)
+        print "There are no connected adb devices"
+        sys.exit(1)
 
     if find_mount_permissions(dm, "/system") == "rw":
         print "We've found out that /system is mounted as 'rw'. This is because the command " \
-        "'adb remount' has been run before running this test case. Please reboot the device " \
-        "and try again."
+            "'adb remount' has been run before running this test case. Please reboot the device " \
+            "and try again."
         sys.exit(1)
 
     unittest.main()

--- a/testing/mozbase/mozdevice/mozdevice/__init__.py
+++ b/testing/mozbase/mozdevice/mozdevice/__init__.py
@@ -4,8 +4,12 @@
 
 from adb import ADBError, ADBRootError, ADBTimeoutError, ADBProcess, ADBCommand, ADBHost, ADBDevice
 from adb_android import ADBAndroid
 from adb_b2g import ADBB2G
 from devicemanager import DeviceManager, DMError, ZeroconfListener
 from devicemanagerADB import DeviceManagerADB
 from devicemanagerSUT import DeviceManagerSUT
 from droid import DroidADB, DroidSUT, DroidConnectByHWID
+
+__all__ = ['ADBError', 'ADBRootError', 'ADBTimeoutError', 'ADBProcess', 'ADBCommand', 'ADBHost',
+           'ADBDevice', 'ADBAndroid', 'ADBB2G', 'DeviceManager', 'DMError', 'ZeroconfListener',
+           'DeviceManagerADB', 'DeviceManagerSUT', 'DroidADB', 'DroidSUT', 'DroidConnectByHWID']

--- a/testing/mozbase/mozdevice/mozdevice/adb.py
+++ b/testing/mozbase/mozdevice/mozdevice/adb.py
@@ -10,16 +10,17 @@ import tempfile
 import time
 import traceback
 
 from abc import ABCMeta, abstractmethod
 
 
 class ADBProcess(object):
     """ADBProcess encapsulates the data related to executing the adb process."""
+
     def __init__(self, args):
         #: command argument argument list.
         self.args = args
         #: Temporary file handle to be used for stdout.
         self.stdout_file = tempfile.TemporaryFile()
         #: Temporary file handle to be used for stderr.
         self.stderr_file = tempfile.TemporaryFile()
         #: boolean indicating if the command timed out.
@@ -54,42 +55,47 @@ class ADBProcess(object):
     def __str__(self):
         return ('args: %s, exitcode: %s, stdout: %s, stderr: %s' % (
             ' '.join(self.args), self.exitcode, self.stdout, self.stderr))
 
 # ADBError, ADBRootError, and ADBTimeoutError are treated
 # differently in order that unhandled ADBRootErrors and
 # ADBTimeoutErrors can be handled distinctly from ADBErrors.
 
+
 class ADBError(Exception):
     """ADBError is raised in situations where a command executed on a
     device either exited with a non-zero exitcode or when an
     unexpected error condition has occurred. Generally, ADBErrors can
     be handled and the device can continue to be used.
     """
     pass
 
+
 class ADBListDevicesError(ADBError):
     """ADBListDevicesError is raised when errors are found listing the
     devices, typically not any permissions.
 
     The devices information is stocked with the *devices* member.
     """
+
     def __init__(self, msg, devices):
         ADBError.__init__(self, msg)
         self.devices = devices
 
+
 class ADBRootError(Exception):
     """ADBRootError is raised when a shell command is to be executed as
     root but the device does not support it. This error is fatal since
     there is no recovery possible by the script. You must either root
     your device or change your scripts to not require running as root.
     """
     pass
 
+
 class ADBTimeoutError(Exception):
     """ADBTimeoutError is raised when either a host command or shell
     command takes longer than the specified timeout to execute. The
     timeout value is set in the ADBCommand constructor and is 300 seconds by
     default. This error is typically fatal since the host is having
     problems communicating with the device. You may be able to recover
     by rebooting, but this is not guaranteed.
 
@@ -229,20 +235,20 @@ class ADBCommand(object):
         adb_process = ADBProcess(args)
 
         if timeout is None:
             timeout = self._timeout
 
         start_time = time.time()
         adb_process.exitcode = adb_process.proc.poll()
         while ((time.time() - start_time) <= timeout and
-               adb_process.exitcode == None):
+               adb_process.exitcode is None):
             time.sleep(self._polling_interval)
             adb_process.exitcode = adb_process.proc.poll()
-        if adb_process.exitcode == None:
+        if adb_process.exitcode is None:
             adb_process.proc.kill()
             adb_process.timedout = True
             adb_process.exitcode = adb_process.proc.poll()
 
         adb_process.stdout_file.seek(0, os.SEEK_SET)
         adb_process.stderr_file.seek(0, os.SEEK_SET)
 
         return adb_process
@@ -305,16 +311,17 @@ class ADBHost(ADBCommand):
 
     ::
 
        from mozdevice import ADBHost
 
        adbhost = ADBHost()
        adbhost.start_server()
     """
+
     def __init__(self,
                  adb='adb',
                  adb_host=None,
                  adb_port=None,
                  logger_name='adb',
                  timeout=300,
                  verbose=False):
         """Initializes the ADBHost object.
@@ -453,17 +460,19 @@ class ADBHost(ADBCommand):
 
         is parsed and placed into an object as in
 
         [{'device_serial': 'b313b945', 'state': 'device', 'product': 'd2vzw',
           'usb': '1-7', 'device': 'd2vzw', 'model': 'SCH_I535' }]
         """
         # b313b945               device usb:1-7 product:d2vzw model:SCH_I535 device:d2vzw
         # from Android system/core/adb/transport.c statename()
-        re_device_info = re.compile(r'([^\s]+)\s+(offline|bootloader|device|host|recovery|sideload|no permissions|unauthorized|unknown)')
+        re_device_info = re.compile(
+            r"([^\s]+)\s+(offline|bootloader|device|host|recovery|sideload|"
+            "no permissions|unauthorized|unknown)")
         devices = []
         lines = self.command_output(["devices", "-l"], timeout=timeout).split('\n')
         for line in lines:
             if line == 'List of devices attached ':
                 continue
             match = re_device_info.match(line)
             if match:
                 device = {
@@ -660,17 +669,16 @@ class ADBDevice(ADBCommand):
                 self.command_output(
                     ["root"],
                     timeout=timeout).find("cannot run as root") == -1):
                 self._have_root_shell = True
                 self._logger.info("adbd restarted as root")
         except ADBError:
             self._logger.debug("Check for root adbd failed")
 
-
     @staticmethod
     def _escape_command_line(cmd):
         """Utility function to return escaped and quoted version of command
         line.
         """
         quoted_cmd = []
 
         for arg in cmd:
@@ -1034,20 +1042,20 @@ class ADBDevice(ADBCommand):
         args.extend(["wait-for-device", "shell", cmd])
         adb_process = ADBProcess(args)
 
         if timeout is None:
             timeout = self._timeout
 
         start_time = time.time()
         exitcode = adb_process.proc.poll()
-        while ((time.time() - start_time) <= timeout) and exitcode == None:
+        while ((time.time() - start_time) <= timeout) and exitcode is None:
             time.sleep(self._polling_interval)
             exitcode = adb_process.proc.poll()
-        if exitcode == None:
+        if exitcode is None:
             adb_process.proc.kill()
             adb_process.timedout = True
             adb_process.exitcode = adb_process.proc.poll()
         elif exitcode == 0:
             adb_process.exitcode = self._get_exitcode(adb_process.stdout_file)
         else:
             adb_process.exitcode = exitcode
 
@@ -1125,22 +1133,22 @@ class ADBDevice(ADBCommand):
             output = adb_process.stdout_file.read().rstrip()
             if self._verbose:
                 self._logger.debug('shell_output: %s, '
                                    'timeout: %s, '
                                    'root: %s, '
                                    'timedout: %s, '
                                    'exitcode: %s, '
                                    'output: %s' %
-                                (' '.join(adb_process.args),
-                                 timeout,
+                                   (' '.join(adb_process.args),
+                                    timeout,
                                     root,
-                                 adb_process.timedout,
-                                 adb_process.exitcode,
-                                 output))
+                                    adb_process.timedout,
+                                    adb_process.exitcode,
+                                    output))
 
             return output
         finally:
             if adb_process and isinstance(adb_process.stdout_file, file):
                 adb_process.stdout_file.close()
                 adb_process.stderr_file.close()
 
     # Informational methods
@@ -1693,17 +1701,17 @@ class ADBDevice(ADBCommand):
                     raise
             pid_set = set(pid_list)
             current_pid_set = set([str(proc[0]) for proc in
                                    self.get_process_list(timeout=timeout)])
             pid_list = list(pid_set.intersection(current_pid_set))
             if not pid_list:
                 break
             self._logger.debug("Attempt %d of %d to kill processes %s failed" %
-                               (attempt+1, attempts, pid_list))
+                               (attempt + 1, attempts, pid_list))
             time.sleep(wait)
 
         if pid_list:
             raise ADBError('kill: processes %s not killed' % pid_list)
 
     def pkill(self, appname, sig=None, attempts=3, wait=5,
               timeout=None, root=False):
         """Kills a processes on the device matching a name.