code: def _constrain_glob(glob, paths, limit=5):
      
  
      def digit_set_wildcard(chars):
          """
          Makes a wildcard expression for the set, a bit readable, e.g. [1-5].
          """
          chars = sorted(chars)
          if len(chars) > 1 and ord(chars[-1]) - ord(chars[0]) == len(chars) - 1:
              return '[%s-%s]' % (chars[0], chars[-1])
          else:
              return '[%s]' % ''.join(chars)
  
      current = {glob: paths}
      while True:
          pos = list(current.keys())[0].find('[0-9]')
          if pos == -1:
              # no wildcard expressions left to specialize in the glob
              return list(current.keys())
          char_sets = {}
          for g, p in six.iteritems(current):
              char_sets[g] = sorted({path[pos] for path in p})
          if sum(len(s) for s in char_sets.values()) > limit:
              return [g.replace('[0-9]', digit_set_wildcard(char_sets[g]), 1) for g in current]
          for g, s in six.iteritems(char_sets):
              for c in s:
                  new_glob = g.replace('[0-9]', c, 1)
                  new_paths = list(filter(lambda p: p[pos] == c, current[g]))
                  current[new_glob] = new_paths
              del current[g]
docs: Tweaks glob into a list of more specific globs that together still cover paths and not too much extra.
  
      Saves us minutes long listings for long dataset histories.
  
      Specifically, in this implementation the leftmost occurrences of "[0-9]"
      give rise to a few separate globs that each specialize the expression to
      digits that actually occur in paths.