code: def _calculate_scores(self):
          
          scores = {}
          for node in self.graph.nodes():
              score = -1 * len([
                  d for d in nx.descendants(self.graph, node)
                  if self._include_in_cost(d)
              ])
              scores[node] = score
          return scores
docs: Calculate the 'value' of each node in the graph based on how many
          blocking descendants it has. We use this score for the internal
          priority queue's ordering, so the quality of this metric is important.
  
          The score is stored as a negative number because the internal
          PriorityQueue picks lowest values first.
  
          We could do this in one pass over the graph instead of len(self.graph)
          passes but this is easy. For large graphs this may hurt performance.
  
          This operates on the graph, so it would require a lock if called from
          outside __init__.
  
          :return Dict[str, int]: The score dict, mapping unique IDs to integer
              scores. Lower scores are higher priority.