F841: local variable assigned to but never used

[thopre]

Summary

tests/server/reporting/analysis.py:

• Ignore unused variables spike and slow which commented code further down refers to

lnt/server/ui/api.py:

• Local variable machine_name and ts in function put() were seemingly introduced from copy/paste and were never used

lnt/server/ui/views.py:

• Local variable comparison_start_run stopped being used from commit 465d5fdbf640b8e53f0f3d773f335e2c4825dd4f
• Local variable session in function v4_latest_runs_report() was seemingly introduced from copy/paste and was never used

lnt/server/ui/profile_views.py:

• Local variables idx and tlc in function v4_profile_ajax_getFunctions() were seemingly introduced from copy/paste and were never used
• Local variable profileDir in function v4_profile() was seemingly introduced from copy/paste and was never used
• Local variables profile1 and profile2 in function v4_profile() have never been used

lnt/server/ui/regression_views.py:

• Local variable e in exception block of function v4_regression_detail() has never been used
• Local variable new_regression_id in function v4_make_regression() has never been used

lnt/server/reporting/summaryreport.py:

• Local variables run and datapoints in function _build_data_table() have never been used

lnt/server/db/testsuitedb.py:

• Local variable testsuitedb in the constructor has never been used

lnt/server/db/fieldchange.py:

• Local variable deleted in function regenerate_fieldchanges_for_run() has never been used

lnt/server/db/migrations/upgrade_14_to_15.py:

• Local variable trans in function update_testsuite() was seemingly introduced from copy/paste from other migration scripts and was never used

tests/testing/profilev1impl.py:

• Local variable s in function test_serialize() has never been used

tests/testing/profilev2impl.py:

• Local variable s in function test_serialize() was seemingly introduced from copy/past eof the v1 version and was never used

[tnfchris]

Nice cleanup!

lnt/server/db/fieldchange.py

for field in list(ts.Sample.get_metric_fields()):
                     .filter(ts.FieldChange.machine == run.machine) \
                     .filter(ts.FieldChange.field_id == field.id) \
                     .one_or_none()
                 if not f:
                     logger.warning("Fell back to field lookup. Should not happen.")
             if not result.is_result_performance_change() and f:
                 # With more data, its not a regression. Kill it!
                 logger.info("Removing field change: {}".format(f.id))
-                deleted = delete_fieldchange(session, ts, f)
+                delete_fieldchange(session, ts, f)
                 continue
 
             if result.is_result_performance_change() and not f:
                 test = session.query(ts.Test) \
                     .filter(ts.Test.id == test_id) \
                     .one()
                 f = ts.FieldChange(start_order=start_order,
                                    end_order=run.order,

lnt/server/db/migrations/upgrade_14_to_15.py

 # Drop the "FieldChange" tables; they have been deprecated and replaced by
 # "FieldChangeV2" for a long while now (but can still cause trouble when trying
 # to delete old runs that are referenced from a FieldChange entry).
 from lnt.server.db.migrations.util import introspect_table
 
 
 def update_testsuite(engine, db_key_name):
     table_name = '%s_FieldChange' % db_key_name
-    with engine.begin() as trans:
+    with engine.begin():
         table = introspect_table(engine, table_name, autoload=False)
         table.drop(checkfirst=True)
 
 
 def upgrade(engine):
     update_testsuite(engine, 'NT')
     update_testsuite(engine, 'compile')

lnt/server/db/testsuitedb.py

class TestSuiteDB(object):
     This wrapper is somewhat special in that it handles specializing the
     metatable instances for the given test suite.
 
     Clients are expected to only access the test suite database tables by going
     through the model classes constructed by this wrapper object.
     """
 
     def __init__(self, v4db, name, test_suite):
-        testsuitedb = self
         self.v4db = v4db
         self.name = name
         self.test_suite = test_suite
 
         # Save caches of the various fields.
         self.machine_fields = list(self.test_suite.machine_fields)
         self.order_fields = list(self.test_suite.order_fields)
         self.run_fields = list(self.test_suite.run_fields)

lnt/server/reporting/summaryreport.py

def _build_data_table(self):
                                           for r in ts_runs)
 
                 # Load all the samples for all runs we are interested in.
                 columns = [ts.Sample.run_id, ts.Sample.test_id]
                 columns.extend(f.column for f in ts.sample_fields)
                 samples = session.query(*columns).filter(
                     ts.Sample.run_id.in_(list(run_id_map.keys())))
                 for sample in samples:
-                    run = run_id_map[sample[0]]
-                    datapoints = list()
                     for key, value in get_datapoints_for_sample(ts, sample):
                         items = self.data_table.get(key)
                         if items is None:
                             items = [[]
                                      for _ in self.report_orders]
                             self.data_table[key] = items
                         items[index].append(value)
 

lnt/server/ui/api.py

def delete(machine_spec):
 
         stream = stream_with_context(perform_delete(ts, machine))
         return Response(stream, mimetype="text/plain")
 
     @staticmethod
     @requires_auth_token
     def put(machine_spec):
         machine = Machine._get_machine(machine_spec)
-        machine_name = "%s:%s" % (machine.name, machine.id)
         data = json.loads(request.data)
         machine_data = data['machine']
         machine.set_from_dict(machine_data)
         session = request.session
-        ts = request.get_testsuite()
         session.commit()
 
     @staticmethod
     @requires_auth_token
     def post(machine_spec):
         session = request.session
         ts = request.get_testsuite()
         machine = Machine._get_machine(machine_spec)

lnt/server/ui/profile_views.py

 def v4_profile_ajax_getFunctions():
     session = request.session
     ts = request.get_testsuite()
     runid = request.args.get('runid')
     testid = request.args.get('testid')
 
     profileDir = current_app.old_config.profileDir
 
-    idx = 0
-    tlc = {}
     sample = _get_sample(session, ts, runid, testid)
 
     if sample and sample.profile:
         p = sample.profile.load(profileDir)
         return json.dumps([[n, f] for n, f in p.getFunctions().items()])
     else:
         abort(404)
 

 @v4_route("/profile/<int:testid>/<int:run1_id>/<int:run2_id>")
 def v4_profile_fwd2(testid, run1_id, run2_id=None):
     return v4_profile(testid, run1_id, run2_id)
 
 
 def v4_profile(testid, run1_id, run2_id=None):
     session = request.session
     ts = request.get_testsuite()
-    profileDir = current_app.old_config.profileDir
 
     try:
         test = session.query(ts.Test).filter(ts.Test.id == testid).one()
         run1 = session.query(ts.Run).filter(ts.Run.id == run1_id).one()
         sample1 = _get_sample(session, ts, run1_id, testid)
         if run2_id is not None:
             run2 = session.query(ts.Run).filter(ts.Run.id == run2_id).one()
             sample2 = _get_sample(session, ts, run2_id, testid)
         else:
             run2 = None
             sample2 = None
     except NoResultFound:
         # FIXME: Make this a nicer error page.
         abort(404)
 
-    if sample1.profile:
-        profile1 = sample1.profile
-    else:
-        profile1 = None
-
-    if sample2 and sample2.profile:
-        profile2 = sample2.profile
-    else:
-        profile2 = None
-
     json_run1 = {
         'id': run1.id,
         'order': run1.order.llvm_project_revision,
         'machine': run1.machine.name,
         'sample': sample1.id if sample1 else None
     }
     if run2:
         json_run2 = {

lnt/server/ui/regression_views.py

def v4_regression_detail(id):
     session = request.session
     ts = request.get_testsuite()
     form = EditRegressionForm(request.form)
 
     try:
         regression_info = session.query(ts.Regression) \
             .filter(ts.Regression.id == id) \
             .one()
-    except NoResultFound as e:
+    except NoResultFound:
         abort(404)
     if request.method == 'POST' and request.form['save_btn'] == "Save Changes":
         regression_info.title = form.title.data
         regression_info.bug = form.bug.data
         regression_info.state = form.state.data
         session.commit()
         flash("Updated " + regression_info.title, FLASH_SUCCESS)
         return v4_redirect(v4_url_for(".v4_regression_list",
def v4_make_regression(machine_id, test_id, field_index, run_id):
 
     It is not nessessarly the case that there will be a real change there,
     so we must create a regression, bypassing the normal analysis.
 
     """
     session = request.session
     ts = request.get_testsuite()
     field = ts.sample_fields[field_index]
-    new_regression_id = 0
     run = session.query(ts.Run).get(run_id)
 
     runs = session.query(ts.Run). \
         filter(ts.Run.order_id == run.order_id). \
         filter(ts.Run.machine_id == run.machine_id). \
         all()
 
     if len(runs) == 0:

lnt/server/ui/views.py

def __init__(self, run_id):
         if baseline_str:
             baseline_id = int(baseline_str)
             baseline = session.query(ts.Run).filter_by(id=baseline_id).first()
             if baseline is None:
                 flash("Could not find baseline " + baseline_str, FLASH_DANGER)
         else:
             baseline = None
 
-        # Gather the runs to use for statistical data.
-        comparison_start_run = compare_to or self.run
-
         # We're going to render this on a real webpage with CSS support, so
         # override the default styles and provide bootstrap class names for
         # the tables.
         styles = {
             'body': '', 'td': '',
             'h1': 'font-size: 14pt',
             'table': 'width: initial; font-size: 9pt;',
             'th': 'text-align: center;'
def v4_summary_report_ui():
 
     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
 

tests/server/reporting/analysis.py

class ComparisonResultTest(unittest.TestCase):
 
     def test_noise_bimodal_overlapping_regression(self):
         bimodal = ComparisonResult(
             min, False, False, [BM_REG_OVER_NOISE[12]],
             BM_REG_OVER_NOISE[0:11], None, None)
         self.assertEqual(bimodal.get_value_status(), REGRESSED)
 
     def test_single_spike(self):
-        spike = ComparisonResult(
+        spike = ComparisonResult(  # noqa: F841  # relates to commented code
             min, False, False, [SPIKE[11]], SPIKE[0:10], None, None)
         # Fixme
         # self.assertEqual(spike.get_value_status(), UNCHANGED_PASS)
 
     def test_noise_single_spike(self):
-        spike = ComparisonResult(
+        spike = ComparisonResult(  # noqa: F841  # relates to commented code
             min, False, False, [NOISE_SPIKE[8]], NOISE_SPIKE[0:7], None, None)
         # Fixme
         # self.assertEqual(spike.get_value_status(), UNCHANGED_PASS)
 
     def test_slow_regression(self):
         slow = ComparisonResult(
             min, False, False, [SLOW_REG[12]], SLOW_REG[0:11], None, None)
         self.assertEqual(slow.get_value_status(), REGRESSED)
 
     def test_noise_slow_regression(self):
         slow = ComparisonResult(
             min, False, False, [SLOW_REG_NOISE[12]], SLOW_REG_NOISE[0:11],
             None, None)
         self.assertEqual(slow.get_value_status(), REGRESSED)
 
     def test_slow_improvement(self):
-        slow = ComparisonResult(
+        slow = ComparisonResult(  # noqa: F841  # relates to commented code
             min, False, False, [SLOW_IMP[12]], SLOW_IMP[0:11], None, None)
         # Fixme
         # self.assertEqual(slow.get_value_status(), IMPROVED)
 
     def test_noise_slow_improvement(self):
-        slow = ComparisonResult(
+        slow = ComparisonResult(  # noqa: F841  # relates to commented code
             min, False, False, [SLOW_IMP_NOISE[12]], SLOW_IMP_NOISE[0:11],
             None, None)
         # Fixme
         # self.assertEqual(slow.get_value_status(), IMPROVED)
 
     def test_handle_zero_sample(self):
         for agfn in (min, median):
             zeroSample = ComparisonResult(

tests/testing/profilev1impl.py

def setUp(self):
                     ]
                 }
             }
         }
 
     def test_serialize(self):
         p = ProfileV1(copy.deepcopy(self.test_data))
         with tempfile.NamedTemporaryFile() as f:
-            s = p.serialize(f.name)
+            p.serialize(f.name)
             self.assertTrue(ProfileV1.checkFile(f.name))
 
     def test_deserialize(self):
         p = ProfileV1(copy.deepcopy(self.test_data))
         s = p.serialize()
         fobj = io.BytesIO(s)
         p2 = ProfileV1.deserialize(fobj)
 

tests/testing/profilev2impl.py

def setUp(self):
                     ]
                 }
             }
         }
 
     def test_serialize(self):
         p = ProfileV2.upgrade(ProfileV1(copy.deepcopy(self.test_data)))
         with tempfile.NamedTemporaryFile() as f:
-            s = p.serialize(f.name)
+            p.serialize(f.name)
             self.assertTrue(ProfileV2.checkFile(f.name))
 
     def test_deserialize(self):
         p = ProfileV2.upgrade(ProfileV1(copy.deepcopy(self.test_data)))
         s = p.serialize()
         fobj = io.BytesIO(s)
         p2 = ProfileV2.deserialize(fobj)