[LNT] Python 3 support: Remove implicit tuple parameter unpacking on lambdas

[hubert.reinterpretcast]

Summary

Lambda changes split out and updated from D67535.

Applies the 2to3 -f tuple_params fixes, tweaks the variable naming, and updates the affected tuples to be named tuples.

[thopre]

LGTM

lnt/trunk/lnt/server/reporting/runs.py

 """
 Report functionality centered around individual runs.
 """
 
+from collections import namedtuple
 import time
 import lnt.server.reporting.analysis
 import lnt.server.ui.app
 import lnt.util.stats
 
 
 def generate_run_data(session, run, baseurl, num_comparison_runs=0,
                       result=None, compare_to=None, baseline=None,
def generate_run_data(session, run, baseurl, num_comparison_runs=0,
 
     num_item_buckets = [aggregate_counts_across_all_bucket_types(x[0], x[1][0])
                         for x in enumerate(test_results[0][1])]
 
     def maybe_sort_bucket(bucket, bucket_name, show_perf):
         if not bucket or bucket_name == 'Unchanged Test' or not show_perf:
             return bucket
         else:
-            return sorted(bucket, key=lambda (_, cr, __): -abs(cr.pct_delta))
+            return sorted(
+                bucket,
+                key=lambda bucket_entry: -abs(bucket_entry.cr.pct_delta))
 
     def prioritize_buckets(test_results):
         prioritized = [(priority, field, bucket_name,
                         maybe_sort_bucket(bucket, bucket_name, show_perf),
                         [name for name, _, __ in bucket], show_perf)
                        for field, field_results in test_results
                        for priority, (bucket_name, bucket,
                                       show_perf) in enumerate(field_results)]
data = {
         'classes': classes_,
         '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 = []
for field in metric_fields:
                 bucket = existing_failures
             elif perf_status == lnt.server.reporting.analysis.REGRESSED:
                 bucket = perf_regressions
             elif perf_status == lnt.server.reporting.analysis.IMPROVED:
                 bucket = perf_improvements
             else:
                 bucket = unchanged_tests
 
-            bucket.append((name, cr, test_id))
+            bucket.append(BucketEntry(name, cr, test_id))
 
         results_by_type.append(
             (field, (('New Failures', new_failures, False),
                      ('New Passes', new_passes, False),
                      ('Performance Regressions', perf_regressions, True),
                      ('Performance Improvements', perf_improvements, True),
                      ('Removed Tests', removed_tests, False),
                      ('Added Tests', added_tests, False),
                      ('Existing Failures', existing_failures, False),
                      ('Unchanged Tests', unchanged_tests, False))))
     return comparison_results, results_by_type

lnt/trunk/lnt/server/ui/views.py

def v4_graph():
     options['hide_highlight'] = bool(
         request.args.get('hide_highlight'))
     options['logarithmic_scale'] = bool(
         request.args.get('logarithmic_scale'))
 
     show_highlight = not options['hide_highlight']
 
     # Load the graph parameters.
+    GraphParameter = namedtuple('GraphParameter',
+                                ['machine', 'test', 'field', 'field_index'])
     graph_parameters = []
     for name, value in request.args.items():
         # Plots to graph are passed as::
         #
         #  plot.<unused>=<machine id>.<test id>.<field index>
         if not name.startswith(str('plot.')):
             continue
 
for name, value in request.args.items():
         try:
             machine = session.query(ts.Machine) \
                              .filter(ts.Machine.id == machine_id) \
                              .one()
             test = session.query(ts.Test).filter(ts.Test.id == test_id).one()
             field = ts.sample_fields[field_index]
         except NoResultFound:
             return abort(404)
-        graph_parameters.append((machine, test, field, field_index))
+        graph_parameters.append(GraphParameter(machine, test, field, field_index))
 
     # Order the plots by machine name, test name and then field.
-    graph_parameters.sort(key=lambda (m, t, f, _): (m.name, t.name, f.name, _))
+    graph_parameters.sort(key=lambda graph_parameter:
+                          (graph_parameter.machine.name, graph_parameter.test.name,
+                           graph_parameter.field.name, graph_parameter.field_index))
 
     # Extract requested mean trend.
     mean_parameter = None
     for name, value in request.args.items():
         # Mean to graph is passed as:
         #
         #  mean=<machine id>.<field index>
         if name != 'mean':