Return the commits that make up the counts for no_review_url, tbr_no_lgtm, and blank_tbr

infra/tools/antibody/compute_stats.py

 # Copyright 2015 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import json
 
 
 def ratio_calculator(numerator, denominator):
   """Computes the ratio of the counts in two lists
 
@@ skipping 21 matching lines @@
 def totaled_ratio_calculator(numerator, denominator):
   """Computes the ratio of the counts in two lists
 
   Args:
     numerator(int): a totaled count
     denominator(int): a totaled count
 
   Return:
     ratio(float): a ratio rounded to three decimal places
   """
-  if denominator != 0: 
+  if denominator != 0:
     ratio = round(float(numerator) / denominator, 3)
   else:
-    raise ZeroDivisionError
+    ratio = 0
   return ratio
 
 
 # functions that return stats calculated as lists of lists by month
 def total_commits(cc):  # pragma: no cover
   """Counts all the git commits sorted by month and year
 
   Args:
     cc(cursor)
 
@@ skipping 250 matching lines @@
 def totaled_tbr_no_lgtm(cc, sql_time_specification):  # pragma: no cover
   """Counts the number of commits with a TBR that have not been lgtm'ed
      in a given timeframe
 
   Args:
     cc(cursor)
     sql_time_specification(str): a sql command to limit the dates of the
                                  returned results
 
   Return:
-    result(int): a count of all commits with a TBR and no lgtm
+    count(int): a count of all commits with a TBR and no lgtm
+    results(list): a list of lists with all tbr'ed commits with no lgtm in the
+                   format [rietveld_url, git_timestamp, git_subject, git_hash]
   """
-  cc.execute("""SELECT COUNT(*)
+  cc.execute("""SELECT git_commit.review_url, git_commit.timestamp,
+      git_commit.subject, git_commit.hash
       FROM review
       INNER JOIN git_commit
       ON review.review_url = git_commit.review_url
       INNER JOIN commit_people
       ON commit_people.git_commit_hash = git_commit.hash
       LEFT JOIN (
         SELECT review_url, COUNT(*) AS c
           FROM review_people
           WHERE type = 'lgtm'
           GROUP BY review_url) lgtm_count
       ON review.review_url = lgtm_count.review_url
       WHERE lgtm_count.c = 0 OR lgtm_count.c IS NULL
         AND commit_people.type = 'tbr' AND %s""" % sql_time_specification)
-  result = cc.fetchone()
-  return int(result[0])
+  result = cc.fetchall()
+  count = len(result)
+  results = []
+  parsed_commit = []
+  for commit in result:
+    parsed_commit.append(commit[0])
+    parsed_commit.append(commit[1].strftime("%Y-%m-%d %H:%M:%S"))
+    parsed_commit.append(commit[2])
+    parsed_commit.append(commit[3])
+    results.append(parsed_commit)

[pgervais, 2015/07/27 20:50:47]

Not sure this does what you want. parsed_commit is never reset: values will
accumulate.

Why not something like that instead of the loop?

results = [(commit[0], commit[1].strftime("%Y-%m-%d %H:%M:%S"),
            commit[2], commit[3]) for commit in result]

(and same comment for lines 373 and 403. You can even create a small helper
function)

+  return count, results
 
 
 def totaled_blank_tbr(cc, sql_time_specification):  # pragma: no cover
   """Counts the number of occurences of TBR= with no reviewer listed in a
      given timeframe
 
   Args:
     cc(cursor)
     sql_time_specification(str): a sql command to limit the dates of the
                                  returned results
 
   Return:
-    result(int): a count of all blank TBRs (TBR=)
+    count(int): a count of all blank TBRs (TBR=)
+    results(list): a list of lists with all tbr'ed commits with no lgtm in the
+                   format [rietveld_url, git_timestamp, git_subject, git_hash]
   """
-  cc.execute("""SELECT COUNT(*)
+  cc.execute("""SELECT git_commit.review_url, git_commit.timestamp,
+      git_commit.subject, git_commit.hash
       FROM commit_people
       INNER JOIN git_commit
       ON commit_people.git_commit_hash = git_commit.hash
       WHERE commit_people.people_email_address = 'NOBODY'
         AND %s""" % sql_time_specification)
-  result = cc.fetchone()
-  return int(result[0])
+  result = cc.fetchall()
+  count = len(result)
+  results = []
+  parsed_commit = []
+  for commit in result:
+    parsed_commit.append(commit[0])
+    parsed_commit.append(commit[1].strftime("%Y-%m-%d %H:%M:%S"))
+    parsed_commit.append(commit[2])
+    parsed_commit.append(commit[3])
+    results.append(parsed_commit)
+  return count, results
 
 
 def totaled_no_review_url(cc, sql_time_specification):  # pragma: no cover
   """Counts the number of commits with no review url in a given timeframe
 
   Args:
     cc(cursor)
     sql_time_specification(str): a sql command to limit the dates of the
                                  returned results
 
   Return:
-    result(int): a count of all commits with no review_url
+    count(int): a count of all commits with no review_url
+    results(list): a list of lists with all tbr'ed commits with no lgtm in the
+                   format [rietveld_url, git_timestamp, git_subject, git_hash]
   """
-  cc.execute("""SELECT COUNT(*)
+  cc.execute("""SELECT git_commit.review_url, git_commit.timestamp,
+      git_commit.subject, git_commit.hash
     FROM git_commit
     WHERE review_url IS NULL AND %s""" % sql_time_specification)
-  result = cc.fetchone()
-  return int(result[0])
+  result = cc.fetchall()
+  count = len(result)
+  results = []
+  parsed_commit = []
+  for commit in result:
+    parsed_commit.append(commit[0])
+    parsed_commit.append(commit[1].strftime("%Y-%m-%d %H:%M:%S"))
+    parsed_commit.append(commit[2])
+    parsed_commit.append(commit[3])
+    results.append(parsed_commit)
+  return count, results
 
 
 # TODO(keelerh): change the SQL query to avoid using temporary tables
 def tbr_to_total_people_ratio(cc,
                               sql_time_specification=''):  # pragma: no cover
   """Calculate TBR stats by author for the Antibody leaderboard and writes
      them to a json file
 
   Args:
     cc(cursor)
@@ skipping 99 matching lines @@
 
 def compute_stats_by_time(cc):  # pragma: no cover
   """Computes the stats for the past 7 days, past 30 days, and all time
 
   Args:
     cc(cursor)
 
   Returns:
     output(list): three dictionaries containing stats for the past 7 days, 30
                   days, and all time respectively, each including timeframe,
-                  suspicious_to_total_ratio, total_commits, tbr_no_lgtm,
-                  no_review_url, blank_tbr
+                  suspicious_to_total_ratio, a count of the number of commits
+                  for total_commits, tbr_no_lgtm, no_review_url, and blank_tbr,
+                  and a list of lists with the relevant commits for
+                  tbr_no_lgtm, no_review_url, and blank_tbr
   """
   stats_7_days = {'timeframe': '7_days'}
   stats_30_days = {'timeframe': '30_days'}
   stats_all_time = {'timeframe': 'all_time'}
   for d in [stats_7_days, stats_30_days, stats_all_time]:
     if d == stats_7_days:
       sql_insert = 'DATEDIFF(NOW(), git_commit.timestamp) <= 7'
     elif d == stats_30_days:
       sql_insert = 'DATEDIFF(NOW(), git_commit.timestamp) <= 30'
     elif d == stats_all_time:
       sql_insert = 'DATEDIFF(git_commit.timestamp, NOW()) < 0'
     tot_commits = totaled_total_commits(cc, sql_insert)
     tot_suspicious = totaled_total_suspicious(cc, sql_insert)
     d['suspicious_to_total_ratio'] = totaled_ratio_calculator(tot_suspicious,
                                                               tot_commits)
     d['total_commits'] = tot_commits
-    d['tbr_no_lgtm'] = totaled_tbr_no_lgtm(cc, sql_insert)
-    d['no_review_url'] = totaled_no_review_url(cc, sql_insert)
-    d['blank_tbr'] = totaled_blank_tbr(cc, sql_insert)
+    count_tbr_no_lgtm, tbr_no_lgtm_commits = totaled_tbr_no_lgtm(cc, sql_insert)
+    d['tbr_no_lgtm'] = count_tbr_no_lgtm
+    d['tbr_no_lgtm_commits'] = tbr_no_lgtm_commits
+    count_no_review_url, no_review_url_commits = totaled_no_review_url(
+        cc, sql_insert)
+    d['no_review_url'] = count_no_review_url
+    d['no_review_url_commits'] = no_review_url_commits
+    count_blank_tbr, blank_tbr_commits = totaled_blank_tbr(cc, sql_insert)
+    d['blank_tbr'] = count_blank_tbr
+    d['blank_tbr_commits'] = blank_tbr_commits
   output = [stats_7_days, stats_30_days, stats_all_time]
   return output
 
 
 def all_monthly_stats(cc, filename):  # pragma: no cover
   """Write stats calculated over different time segments as json to file
 
   Args:
     cc(cursor)
     filename(str): the json file to write to
@@ skipping 25 matching lines @@
   """Writes stats for the past month Antibody leaderboard to a json file
 
   Args:
     cc(cursor)
     filename(str): the json file to write to
   """
   sql_time_specification = 'AND DATEDIFF(NOW(), git_commit.timestamp) <= 30'
   output = tbr_to_total_people_ratio(cc, sql_time_specification)
   with open(filename, 'w') as f:
     json.dump(output, f)