docs: def cumulative_blame(self, branch='master', limit=None, skip=None, num_datapoints=None, committer=True,
                           ignore_globs=None, include_globs=None):
          """
          Returns the blame at every revision of interest. Index is a datetime, column per committer, with number of lines
          blamed to each committer at each timestamp as data.
  
          :param branch: (optional, default 'master') the branch to work in
          :param limit: (optional, default None), the maximum number of revisions to return, None for no limit
          :param skip: (optional, default None), the number of revisions to skip. Ex: skip=2 returns every other revision, None for no skipping.
          :param num_datapoints: (optional, default=None) if limit and skip are none, and this isn't, then num_datapoints evenly spaced revs will be used
          :param committer: (optional, defualt=True) true if committer should be reported, false if author
          :param ignore_globs: (optional, default=None) a list of globs to ignore, default none excludes nothing
          :param include_globs: (optinal, default=None) a list of globs to include, default of None includes everything.
          :return: DataFrame
  
          """
  
          revs = self.revs(branch=branch, limit=limit, skip=skip, num_datapoints=num_datapoints)
  
          # get the commit history to stub out committers (hacky and slow)
          if sys.version_info.major == 2:
              committers = set([x.committer.name for x in self.repo.iter_commits(branch, max_count=sys.maxsize)])
          else:
              committers = {x.committer.name for x in self.repo.iter_commits(branch, max_count=sys.maxsize)}
  
          for y in committers:
              revs[y] = 0
  
          if self.verbose:
              print('Beginning processing for cumulative blame:')
  
          # now populate that table with some actual values
          for idx, row in revs.iterrows():
              if self.verbose:
                  print('%s. [%s] getting blame for rev: %s' % (
                  str(idx), datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S'), row.rev,))
  
              blame = self.blame(rev=row.rev, committer=committer, ignore_globs=ignore_globs, include_globs=include_globs)
              for y in committers:
                  try:
                      loc = blame.loc[y, 'loc']
                      revs.set_value(idx, y, loc)
                  except KeyError:
                      pass
  
          del revs['rev']
  
          revs['date'] = to_datetime(revs['date'].map(datetime.datetime.fromtimestamp))
          revs.set_index(keys=['date'], drop=True, inplace=True)
          revs = revs.fillna(0.0)
  
          # drop 0 cols
          for col in revs.columns.values:
              if col != 'col':
                  if revs[col].sum() == 0:
                      del revs[col]
  
          # drop 0 rows
          keep_idx = []
          committers = [x for x in revs.columns.values if x != 'date']
          for idx, row in revs.iterrows():
              if sum([row[x] for x in committers]) > 0:
                  keep_idx.append(idx)
  
          revs = revs.ix[keep_idx]
  
          return revs