code: def top_events(self, num, valfld, usemax, gid):
          
          def classify():
              if value is None:
                  return
  
              for j in range(num):
                  if top[j] is None:
                      top[j] = [tot, [value]]
                      break
                  elif tot == top[j][0]:
                      top[j][1].append(value)
                      break
                  elif tot > top[j][0]:
                      top.insert(j, [tot, [value]])
                      break
  
          if not self.results:
              return []
  
          results = self.results
          top = [None] * num
          pos = self.key_gids.index(gid)
  
          # Compute top(max) if a value fld is provided
          if valfld is not None:
              val = self.key_gids.index(valfld)
              if usemax:
                  i = 0 
                  for key in sorted(results.keys(), key=lambda x: (int(x[val]), x[pos]),
                                    reverse=True)[:num]:
                      top[i] = [int(key[val]), [key[pos]]]
                      i += 1
                  return [res for res in top if res is not None]
                  
          value = None
          tot = 0
          for key in sorted(results.keys(), key=lambda x: (x[pos])):
              if value is None or value != key[pos]:
                  classify()
                  value = key[pos]
                  tot = results[key] if valfld is None else results[key] * int(key[val])
                  continue
              tot += results[key] if valfld is None else results[key] * int(key[val])
          else:
              classify()
  
          del top[num:]
          return [res for res in top if res is not None]
docs: Return a list with the top NUM list of events. Each list element
          contain a value, indicating the number of events, and a list of
          matching gid values (usernames, email addresses, clients).
          Instead of calculating the top sum of occurrences a value field
          should be provided to compute the max of a numeric value field or
          the sum of product of value field with events.