docs: def cumulative_blame(self, branch='master', by='committer', limit=None, skip=None, num_datapoints=None, committer=True, ignore_globs=None, include_globs=None):
          """
          Returns a time series of cumulative blame for a collection of projects.  The goal is to return a dataframe for a
          collection of projects with the LOC attached to an entity at each point in time. The returned dataframe can be
          returned in 3 forms (switched with the by parameter, default 'committer'):
  
           * committer: one column per committer
           * project: one column per project
           * raw: one column per committed per project
  
          :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, default=True) true if committer should be reported, false if author
          :param by: (optional, default='committer') whether to arrange the output by committer or project
          :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
  
          """
  
          blames = []
          for repo in self.repos:
              try:
                  blame = repo.cumulative_blame(
                      branch=branch,
                      limit=limit,
                      skip=skip,
                      num_datapoints=num_datapoints,
                      committer=committer,
                      ignore_globs=ignore_globs,
                      include_globs=include_globs
                  )
                  blames.append((repo.repo_name, blame))
              except GitCommandError:
                  print('Warning! Repo: %s couldn\'t be inspected' % (repo, ))
                  pass
  
          global_blame = blames[0][1]
          global_blame.columns = [x + '__' + str(blames[0][0]) for x in global_blame.columns.values]
          blames = blames[1:]
          for reponame, blame in blames:
              blame.columns = [x + '__' + reponame for x in blame.columns.values]
              global_blame = pd.merge(global_blame, blame, left_index=True, right_index=True, how='outer')
  
          global_blame.fillna(method='pad', inplace=True)
          global_blame.fillna(0.0, inplace=True)
  
          if by == 'committer':
              committers = [(str(x).split('__')[0].lower().strip(), x) for x in global_blame.columns.values]
  
              if sys.version_info.major == 2:
                  committer_mapping = dict([(c, [x[1] for x in committers if x[0] == c]) for c in set([x[0] for x in committers])])
              else:
                  committer_mapping = {c: [x[1] for x in committers if x[0] == c] for c in {x[0] for x in committers}}
  
              for committer in committer_mapping.keys():
                  global_blame[committer] = 0
                  for col in committer_mapping.get(committer, []):
                      global_blame[committer] += global_blame[col]
  
              global_blame = global_blame.reindex(columns=list(committer_mapping.keys()))
          elif by == 'project':
              projects = [(str(x).split('__')[1].lower().strip(), x) for x in global_blame.columns.values]
  
              if sys.version_info.major == 2:
                  project_mapping = dict([(c, [x[1] for x in projects if x[0] == c]) for c in set([x[0] for x in projects])])
              else:
                  project_mapping = {c: [x[1] for x in projects if x[0] == c] for c in {x[0] for x in projects}}
  
              for project in project_mapping.keys():
                  global_blame[project] = 0
                  for col in project_mapping.get(project, []):
                      global_blame[project] += global_blame[col]
  
              global_blame = global_blame.reindex(columns=list(project_mapping.keys()))
  
          global_blame = global_blame[~global_blame.index.duplicated()]
  
          return global_blame