Add median latency to my_reviews.py. Do more calculation on the fly.

my_reviews.py

 #!/usr/bin/env python
 # Copyright (c) 2011 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.
 
 """Get rietveld stats about the review you done, or forgot to do.
 
 Example:
   - my_reviews.py -r me@chromium.org -Q  for stats for last quarter.
 """
@@ skipping 43 matching lines @@
   if seconds > 0 and not out:
     # Skip seconds unless there's only seconds.
     out.append('%02ds' % seconds)
   return prefix + ''.join(out)
 
 
 class Stats(object):
   def __init__(self):
     self.total = 0
     self.actually_reviewed = 0
-    self.average_latency = 0.
-    self.number_latency = 0
+    self.latencies = []
     self.lgtms = 0
     self.multiple_lgtms = 0
     self.drive_by = 0
     self.not_requested = 0
     self.self_review = 0
 
-    self.percent_done = 0.
     self.percent_lgtm = 0.
     self.percent_drive_by = 0.
     self.percent_not_requested = 0.
     self.days = 0
-    self.review_per_day = 0.
-    self.review_done_per_day = 0.
 
-  def add_latency(self, latency):
-    self.average_latency = (
-        (self.average_latency * self.number_latency + latency) /
-        (self.number_latency + 1.))
-    self.number_latency += 1
+  @property
+  def average_latency(self):
+    if not self.latencies:
+      return 0
+    return sum(self.latencies) / float(len(self.latencies))
+
+  @property
+  def median_latency(self):
+    if not self.latencies:
+      return 0
+    length = len(self.latencies)
+    latencies = sorted(self.latencies)
+    if (length & 1) == 0:
+      return (latencies[length/2] + latencies[length/2+1]) / 2.
+    else:
+      return latencies[length/2]
+
+  @property
+  def percent_done(self):
+    if not self.total:
+      return 0
+    return self.actually_reviewed * 100. / self.total
+
+  @property
+  def review_per_day(self):
+    if not self.days:
+      return 0
+    return self.total * 1. / self.days
+
+  @property
+  def review_done_per_day(self):
+    if not self.days:
+      return 0
+    return self.actually_reviewed * 1. / self.days
 
   def finalize(self, first_day, last_day):
-    if self.total:
-      self.percent_done = (self.actually_reviewed * 100. / self.total)
     if self.actually_reviewed:
       self.percent_lgtm = (self.lgtms * 100. / self.actually_reviewed)
       self.percent_drive_by = (self.drive_by * 100. / self.actually_reviewed)
       self.percent_not_requested = (
           self.not_requested * 100. / self.actually_reviewed)
     if first_day and last_day:
       self.days = (to_datetime(last_day) - to_datetime(first_day)).days + 1
-    if self.days:
-      self.review_per_day = self.total * 1. / self.days
-      self.review_done_per_day = self.actually_reviewed * 1. / self.days
 
 
 def _process_issue_lgtms(issue, reviewer, stats):
   """Calculates LGTMs stats."""
   stats.actually_reviewed += 1
   reviewer_lgtms = len([
     msg for msg in issue['messages']
     if msg['approval'] and msg['sender'] == reviewer])
   if reviewer_lgtms > 1:
     stats.multiple_lgtms += 1
@@ skipping 29 matching lines @@
 
     if first_msg_from_owner and msg['sender'] == reviewer:
       delta = msg['date'] - first_msg_from_owner['date']
       latency = delta.seconds + delta.days * 24 * 3600
       break
 
   if latency is None:
     stats.not_requested += 1
     return '<no rqst sent>'
   if latency > 0:
-    stats.add_latency(latency)
+    stats.latencies.append(latency)
   else:
     stats.not_requested += 1
   return to_time(latency)
 
 
 def _process_issue(issue):
   """Preprocesses the issue to simplify the remaining code."""
   issue['owner_email'] = username(issue['owner_email'])
   issue['reviewers'] = set(username(r) for r in issue['reviewers'])
   # By default, hide commit-bot.
@@ skipping 73 matching lines @@
   print >> sys.stderr, (
       '%4d were requested over IM or irc        (%5.1f%% of reviews done).' % (
         stats.not_requested, stats.percent_not_requested))
   print >> sys.stderr, (
       ('%4d issues LGTM\'d                        (%5.1f%% of reviews done),'
        ' gave multiple LGTMs on %d issues.') % (
       stats.lgtms, stats.percent_lgtm, stats.multiple_lgtms))
   print >> sys.stderr, (
       'Average latency from request to first comment is %s.' %
       to_time(stats.average_latency))
+  print >> sys.stderr, (
+      'Median latency from request to first comment is %s.' %
+      to_time(stats.median_latency))
 
 
 def print_count(reviewer, created_after, created_before, instance_url):
   remote = rietveld.Rietveld(instance_url, None, None)
   print len(list(remote.search(
       reviewer=reviewer,
       created_after=created_after,
       created_before=created_before,
       keys_only=True)))
 
@@ skipping 73 matching lines @@
     print_reviews(
         options.reviewer,
         options.begin,
         options.end,
         options.instance_url)
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main())