Fix whitespaces flake8 errors and warnings

[thopre]

Summary

• fix E302 errors (2 blank lines before class/functions)
• fix E305 errors (2 blank lines after class/functions)
• fix W293 warnings (blank line contains whitespace)

lnt/server/reporting/analysis.py

 UNCHANGED_FAIL = 'UNCHANGED_FAIL'
 
 # The smallest measureable change we can detect in seconds.
 MIN_VALUE_PRECISION = 0.0001
 
 # Minimal percentage difference that is visible in reports
 MIN_PERCENTAGE_CHANGE = .01
 
+
 def absmin_diff(current, prevs):
     """Min of differences between current sample and all previous samples.
     Given more than one min, use the last one detected which is probably a
     newer value. Returns (difference, prev used)
     """
     diffs = [abs(current-prev) for prev in prevs]
     smallest_pos = 0
     smallest = diffs[0]

lnt/server/reporting/report.py

 """
 Common functions and classes that are used by reports.
 """
 
 import colorsys
 
 from collections import namedtuple
 
 OrderAndHistory = namedtuple('OrderAndHistory', ['max_order', 'recent_orders'])
 
+
 def pairs(l):
     """Make an iterable of all pairs of consecutive elements in l."""
     return zip(l[:-1], l[1:])
 
+
 # The hash color palette avoids green and red as these colours are already used
 # in quite a few places to indicate "good" or "bad".
 _hash_color_palette = (
     colorsys.hsv_to_rgb(h=45. / 360, s=0.3, v=0.9999),  # warm yellow
     colorsys.hsv_to_rgb(h=210. / 360, s=0.3, v=0.9999),  # blue cyan
     colorsys.hsv_to_rgb(h=300. / 360, s=0.3, v=0.9999),  # mid magenta
     colorsys.hsv_to_rgb(h=150. / 360, s=0.3, v=0.9999),  # green cyan
     colorsys.hsv_to_rgb(h=225. / 360, s=0.3, v=0.9999),  # cool blue
     colorsys.hsv_to_rgb(h=180. / 360, s=0.3, v=0.9999),  # mid cyan
 )
 
+
 def _clamp(v, minVal, maxVal):
     return min(max(v, minVal), maxVal)
 
 
 def _toColorString(col):
     r, g, b = [_clamp(int(v * 255), 0, 255)
                for v in col]
     return "#%02x%02x%02x" % (r, g, b)
for hash_string in hash_strings:
             result.append(None)
         else:
             # If not one of the first N hashes, return rgb value 0,0,0 which is
             # white.
             rgb = hash2color.get(hash_string, (0.999, 0.999, 0.999))
             result.append(_toColorString(rgb))
     return result
 
+
 # Helper classes to make the sparkline chart construction easier in the jinja
 # template.
 class RunResult:
     def __init__(self, comparisonResult):
         self.cr = comparisonResult
         self.hash = self.cr.cur_hash
         self.samples = self.cr.samples
         if self.samples is None:
             self.samples = []
 
+
 class RunResults:
     """
     RunResults contains pre-processed data to easily construct the HTML for
     a single row in the results table, showing how one test on one board
     evolved over a number of runs.
     """
     def __init__(self):
         self.results = []
def complete(self):
                 hashes.append(None)
             else:
                 hashes.append(dr.hash)
         rgb_colors = _get_rgb_colors_for_hashes(hashes)
         for i, dr in enumerate(self.results):
             if dr is not None:
                 dr.hash_rgb_color = rgb_colors[i]
 
+
 # Compute static CSS styles for elements. We use the style directly on
 # elements instead of via a stylesheet to support major email clients
 # (like Gmail) which can't deal with embedded style sheets.
 # These are derived from the static style.css file we use elsewhere.
 
 report_css_styles = {
         "body": ("color:#000000; background-color:#ffffff; "
             "font-family: Helvetica, sans-serif; font-size:9pt"),

lnt/server/reporting/runs.py

data = {
         'start_time': start_time,
         'sri': sri,
         'visible_note': visible_note,
     }
     return data
 
 
 BucketEntry = namedtuple('BucketEntry', ['name', 'cr', 'test_id'])
+
+
 def _get_changes_by_type(ts, run_a, run_b, metric_fields, test_names,
                          num_comparison_runs, sri):
     comparison_results = {}
     results_by_type = []
     for field in metric_fields:
         new_failures = []
         new_passes = []
         perf_regressions = []

lnt/server/ui/globals.py

def v4_url_available(*args, **kwargs):
     in the global context.
     """
     try:
         flask.g.testsuite_name
         return True
     except Exception:
         return False
 
+
 class fixed_location_response(Response):
     autocorrect_location_header = False
 
+
 def v4_redirect(*args, **kwargs):
     """
     Like redirect but can be used to allow relative URL redirection.
     Flask's default response makes URLs absolute before putting in the
     Location header due to adhering to the out-dated RFC 2616 which has
     been superseded by RFC 7231.
 
     The RFC outdated in 2018 but Flask still does not implement the new
     standard.
     """
     return flask.redirect(*args, Response=fixed_location_response, **kwargs)
 
+
 def register(env):
     # Add some normal Python builtins which can be useful in templates.
     env.globals.update(zip=zip)
 
     # Add our custom global functions.
     env.globals.update(
         db_url_for=db_url_for,
         v4_url_for=v4_url_for,
         v4_redirect=v4_redirect,
         v4_url_available=v4_url_available)

lnt/server/ui/views.py

for ts in testsuites:
             all_orders.add(name)
     all_machines = sorted(all_machines)
     all_orders = sorted(all_orders, key=to_key)
 
     return render_template("v4_summary_report_ui.html",
                            config=config, all_machines=all_machines,
                            all_orders=all_orders, **ts_data(ts))
 
+
 @v4_route("/latest_runs_report")
 def v4_latest_runs_report():
     session = request.session
     ts = request.get_testsuite()
 
     num_runs_str = request.args.get('num_runs')
     if num_runs_str is not None:
         num_runs = int(num_runs_str)
     else:
         num_runs = 10
 
     report = lnt.server.reporting.latestrunsreport.LatestRunsReport(ts, num_runs)
     report.build(request.session)
 
     return render_template("v4_latest_runs_report.html", report=report,
                            analysis=lnt.server.reporting.analysis,
                            **ts_data(ts))
 
+
 @db_route("/summary_report")
 def v4_summary_report():
     session = request.session
     # Load the summary report configuration.
     config_path = get_summary_config_path()
     if not os.path.exists(config_path):
         return render_template("error.html", message="""\
 You must define a summary report configuration first.""")

tests/SharedInputs/FakeCompilers/fakecompiler.py

 Target: arm-apple-darwin11.4.0
 Thread model: posix
 InstalledDir: /home/foo/bin
 """, file=sys.stderr)
         print("""\
  "%s" "-cc1" "-E" ... more boring stuff here ...""" % (
             g_program,), file=sys.stderr)
 
+
 # Monorepo clang build with some extra stuff after the version string
 class Clang_monorepo2(LLVMCompiler):
     compiler_name = "clang-monorepo2"
     def print_verbose_info(self):
         print("""\
 clang version 1.2.3 (ssh://something.com/llvm-project.git 597522d740374f093a089a2acbec5b20466b2f34) (extra) (stuff) (here)
 Thread model: posix
 InstalledDir: /home/foo/bin
 """, file=sys.stderr)
         print("""\
  "%s" "-cc1" "-E" ... more boring stuff here ...""" % (
             g_program,), file=sys.stderr)
 
+
 class AppleClang_138_1(LLVMCompiler):
     compiler_name = "apple-clang-138.1"
 
     def print_verbose_info(self):
         print("""\
 Apple clang version 2.0 (tags/Apple/clang-138.1) (based on LLVM 2.9svn)
 Target: x86_64-apple-darwin11.3.0
 Thread model: posix

tests/__init__.py

 import os
 import lit.discovery
 
+
 def test_all():
     return lit.discovery.load_test_suite([os.path.dirname(__file__)])

tests/server/db/Migrations.py

for ln in data[test_suite_list_start:test_suite_list_end].split("\n"):
         # We found a test suite link...
         link, name = m.groups()
         logging.info("visiting test suite %r", name)
 
         # Get the test suite overview page.
         overview = client.get(os.path.join("/", link))
         assert "LNT : %s - Recent Activity" % (name,) in overview.data
 
+
 def check_instance(instance_path, temp_path):
     logging.info("checking instance: %r", instance_path)
 
     # Create a temporary directory to copy the instance into.
     instance_temp_path = os.path.join(temp_path,
                                       os.path.basename(instance_path))
 
     # Copy the instance into the temporary path.
     logging.info("copying instance to temporary path: %r",
                  instance_temp_path)
     shutil.copytree(instance_path, instance_temp_path)
 
     # Execute the migration on the instance.
     db_path = os.path.join(instance_temp_path, "data", "lnt.db")
     logging.info("migrating database: %r", db_path)
     lnt.server.db.migrate.update_path(db_path)
 
     # Sanity check that the update instance works correctly.
     sanity_check_instance(instance_temp_path)
 
+
 def main():
     _, temp_path = sys.argv
 
     # Clean the temporary path, if necessary.
     if os.path.exists(temp_path):
         shutil.rmtree(temp_path)
     os.makedirs(temp_path)
 
     inputs_dir = os.path.join(os.path.dirname(__file__), 'Inputs')
 
     for item in glob.glob(inputs_dir + '/*'):
         input_path = os.path.join(inputs_dir, item)
 
         # Ignore non-directories.
         if not os.path.isdir(input_path):
             continue
 
         # Otherwise, we have a test instance. Check migration of it.
         check_instance(input_path, temp_path)
 
+
 if __name__ == '__main__':
     main()

tests/server/db/search.py

def test_default_order(self):
 
         results = self._mangleResults(search(session, ts, 'machi ne3'))
         self.assertEqual(results, [
             ('machine3', '11324'),
             ('machine3', '7623'),
             ('machine3', '6512'),
             ('machine3', '65')
         ])
-        
     def test_default_machine(self):
         session = self.session
         ts = self.db.testsuite.get('nts')
 
         results = self._mangleResults(search(session, ts, '65',
                                              default_machine=3))
         self.assertEqual(results, [
             ('machine2', '6512')
         ])
 
+
 if __name__ == '__main__':
     if len(sys.argv) > 1:
         base_path = sys.argv[1]
     unittest.main(argv=[sys.argv[0], ])

tests/testing/cPerf.py

 # RUN: python %s
 
 import unittest
 import sys
 import os
 import tempfile
 from lnt.testing.profile.perf import LinuxPerfProfile
-    
+
 class CPerfTest(unittest.TestCase):
     def setUp(self):
         self.inputs = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                                    'Inputs')
         self.fake_nm = 'python %s/fake-nm.py' % self.inputs
 
         self.expected_data = {'fib-aarch64': {u'counters': {u'cycles': 240949386},
                  u'functions': {u'fib': {u'counters': {u'cycles': 99.77243187496647},
'fib2-aarch64': {u'counters': {u'branch-misses': 1820692,
                                                     [{u'branch-misses': 21.05246347953268,
                                                       u'cache-misses': 11.03420523138833,
                                                       u'cycles': 12.93369541658887},
                                                      4196088,
                                                      u'\ta8c24ff4 \tldp\tx20, x19, [sp],#32'],
                                                     [{},
                                                      4196092,
                                                      u'\td65f03c0 \tret']]}}}}
-        
     def _getNm(self, perf_data_fname, non_dynamic=False):
         stub = perf_data_fname.rsplit('.perf_data', 1)[0]
         s = 'python %s/fake-nm.py %s.nm.out' % (self.inputs, stub)
         if non_dynamic:
             s += ' --fake-nm-be-non-dynamic'
         return s
 
     def _getObjdump(self, perf_data_fname):
         stub = perf_data_fname.rsplit('.perf_data', 1)[0]
         return 'python %s/fake-objdump.py %s.objdump' % (self.inputs, stub)
 
     def _getInput(self, fname):
         return os.path.join(self.inputs, fname)
-    
     def test_check_file(self):
         self.assertTrue(LinuxPerfProfile.checkFile(self._getInput('fib-aarch64.perf_data')))
 
     def test_aarch64_fib(self):
         perf_data = self._getInput('fib-aarch64.perf_data')
         p = LinuxPerfProfile.deserialize(open(perf_data),
                                          nm=self._getNm(perf_data),
                                          objdump=self._getObjdump(perf_data),
def test_random_guff2(self):
         # AssertionError. This version contains the correct magic number.
         data = 'PERFILE28620k hshjsjhs&6362kkjh25090nnjh'
         with tempfile.NamedTemporaryFile() as fd:
             open(fd.name, 'w').write(data)
             with self.assertRaises(AssertionError):
                 LinuxPerfProfile.deserialize(open(fd.name),
                                              propagateExceptions=True)
 
+
 if __name__ == '__main__':
     unittest.main(argv=[sys.argv[0], ])

tests/testing/profilev1impl.py

 # RUN: python %s
 
 import unittest
 import logging
 import sys
 import copy
 import tempfile
 import io
 from lnt.testing.profile.profilev1impl import ProfileV1
 from lnt.testing.profile.profile import Profile
 
 logging.basicConfig(level=logging.DEBUG)
 
+
 class ProfileV1Test(unittest.TestCase):
     def setUp(self):
         self.test_data = {
             'counters': {'cycles': 12345.0, 'branch-misses': 200.0},
             'disassembly-format': 'raw',
             'functions': {
                 'fn1': {
                     'counters': {'cycles': 45.0, 'branch-misses': 10.0},
def test_saveFromRendered(self):
         s = Profile(p).render()
 
         with tempfile.NamedTemporaryFile() as f:
             Profile.saveFromRendered(s, filename=f.name)
             p2 = ProfileV1.deserialize(open(f.name, "rb"))
 
         self.assertEqual(p2.data, self.test_data)
 
+
 if __name__ == '__main__':
     unittest.main(argv=[sys.argv[0], ])

tests/testing/profilev2impl.py

 # RUN: python %s
 
 import unittest
 import logging
 import sys
 import copy
 import tempfile
 import io
 from lnt.testing.profile.profilev2impl import ProfileV2
 from lnt.testing.profile.profilev1impl import ProfileV1
 
 
 logging.basicConfig(level=logging.DEBUG)
 
+
 class ProfileV2Test(unittest.TestCase):
     def setUp(self):
         self.test_data = {
             'counters': {'cycles': 12345.0, 'branch-misses': 200.0},
             'disassembly-format': 'raw',
             'functions': {
                 'fn1': {
                     'counters': {'cycles': 45.0, 'branch-misses': 10.0},
def test_deserialize(self):
         l2 = self.test_data['functions']['fn1']['data']
         self.assertEqual(l, l2)
 
     def test_getFunctions(self):
         p = ProfileV2.upgrade(ProfileV1(copy.deepcopy(self.test_data)))
         self.assertEqual(p.getFunctions(),
                          {'fn1': {'counters': {'cycles': 45.0, 'branch-misses': 10.0},
                                   'length': 2}})
-        
+
 if __name__ == '__main__':
     unittest.main(argv=[sys.argv[0], ])