docs: def _group_raw(self, raw_scores, cur=None, level=1):
          """
          Internal recursive method to group raw scores into a cascading score summary.
          Only top level items are tallied for scores.
          @param list raw_scores: list of raw scores (Result objects)
          """
  
          # BEGIN INTERNAL FUNCS ########################################
          def trim_groups(r):
              if isinstance(r.name, tuple) or isinstance(r.name, list):
                  new_name = r.name[1:]
              else:
                  new_name = []
  
              return Result(r.weight, r.value, new_name, r.msgs)
  
          # CHECK FOR TERMINAL CONDITION: all raw_scores.name are single length
          # @TODO could have a problem here with scalar name, but probably still works
          terminal = [len(x.name) for x in raw_scores]
          if terminal == [0] * len(raw_scores):
              return []
  
          def group_func(r):
              """
              Takes a Result object and slices off the first element of its name
              if its's a tuple. Otherwise, does nothing to the name. Returns the
              Result's name and weight in a tuple to be used for sorting in that
              order in a groupby function.
              @param Result r
              @return tuple (str, int)
              """
              if isinstance(r.name, tuple) or isinstance(r.name, list):
                  if len(r.name) == 0:
                      retval = ''
                  else:
                      retval = r.name[0:1][0]
              else:
                  retval = r.name
              return retval, r.weight
          # END INTERNAL FUNCS ##########################################
  
          # NOTE until this point, *ALL* Results in raw_scores are
          # individual Result objects.
  
          # sort then group by name, then by priority weighting
          grouped = itertools.groupby(sorted(raw_scores, key=group_func),
                                      key=group_func)
  
          # NOTE: post-grouping, grouped looks something like
          # [(('Global Attributes', 1), <itertools._grouper at 0x7f10982b5390>),
          #  (('Global Attributes', 3), <itertools._grouper at 0x7f10982b5438>),
          #  (('Not a Global Attr', 1), <itertools._grouper at 0x7f10982b5470>)]
          #  (('Some Variable', 2),     <itertools._grouper at 0x7f10982b5400>),
  
          ret_val = []
  
          for k, v in grouped: # iterate through the grouped tuples
  
              k = k[0]         # slice ("name", weight_val) --> "name"
              v = list(v)      # from itertools._grouper to list
  
              cv = self._group_raw(list(map(trim_groups, v)), k, level + 1)
              if len(cv):
                  # if this node has children, max weight of children + sum of all the scores
                  max_weight = max([x.weight for x in cv])
                  sum_scores = tuple(map(sum, list(zip(*([x.value for x in cv])))))
                  msgs = []
  
              else:
                  max_weight = max([x.weight for x in v])
                  sum_scores = tuple(map(sum, list(zip(*([self._translate_value(x.value) for x in v])))))
                  msgs = sum([x.msgs for x in v], [])
  
              ret_val.append(Result(name=k, weight=max_weight, value=sum_scores, children=cv, msgs=msgs))
  
          return ret_val