docs: def _parse_crontab(self, which, entry):
          '''
          This parses a single crontab field and returns the data necessary for
          this matcher to accept the proper values.
  
          See the README for information about what is accepted.
          '''
  
          # this handles day of week/month abbreviations
          def _fix(it):
              if which in _alternate and not it.isdigit():
                  if it in _alternate[which]:
                      return _alternate[which][it]
              _assert(it.isdigit(),
                  "invalid range specifier: %r (%r)", it, entry)
              it = int(it, 10)
              _assert(_start <= it <= _end_limit,
                  "item value %r out of range [%r, %r]",
                  it, _start, _end_limit)
              return it
  
          # this handles individual items/ranges
          def _parse_piece(it):
              if '-' in it:
                  start, end = map(_fix, it.split('-'))
                  # Allow "sat-sun"
                  if which in (DAY_OFFSET, WEEK_OFFSET) and end == 0:
                      end = 7
              elif it == '*':
                  start = _start
                  end = _end
              else:
                  start = _fix(it)
                  end = _end
                  if increment is None:
                      return set([start])
  
              _assert(_start <= start <= _end_limit,
                  "%s range start value %r out of range [%r, %r]",
                  _attribute[which], start, _start, _end_limit)
              _assert(_start <= end <= _end_limit,
                  "%s range end value %r out of range [%r, %r]",
                  _attribute[which], end, _start, _end_limit)
              _assert(start <= end,
                  "%s range start value %r > end value %r",
                  _attribute[which], start, end)
  
              if increment:
                  next_value = start + increment
                  _assert(next_value <= _end_limit,
                          "first next value %r is out of range [%r, %r]",
                          next_value, start, _end_limit)
              return set(range(start, end+1, increment or 1))
  
          _start, _end = _ranges[which]
          _end_limit = _end
          # wildcards
          if entry in ('*', '?'):
              if entry == '?':
                  _assert(which in (DAY_OFFSET, WEEK_OFFSET),
                      "cannot use '?' in the %r field", _attribute[which])
              return None, _end
  
          # last day of the month
          if entry == 'l':
              _assert(which == DAY_OFFSET,
                  "you can only specify a bare 'L' in the 'day' field")
              return None, _end
  
          # for the last 'friday' of the month, for example
          elif entry.startswith('l'):
              _assert(which == WEEK_OFFSET,
                  "you can only specify a leading 'L' in the 'weekday' field")
              es, _, ee = entry[1:].partition('-')
              _assert((entry[1:].isdigit() and 0 <= int(es) <= 7) or
                      (_ and es.isdigit() and ee.isdigit() and 0 <= int(es) <= 7 and 0 <= int(ee) <= 7),
                  "last <day> specifier must include a day number or range in the 'weekday' field, you entered %r", entry)
              return None, _end
  
          # allow Sunday to be specified as weekday 7
          if which == WEEK_OFFSET:
              _end_limit = 7
  
          increment = None
          # increments
          if '/' in entry:
              entry, increment = entry.split('/')
              increment = int(increment, 10)
              _assert(increment > 0,
                  "you can only use positive increment values, you provided %r",
                  increment)
              _assert(increment <= _end_limit,
                      "increment value must be less than %r, you provided %r",
                      _end_limit, increment)
  
          # handle singles and ranges
          good = _parse_piece(entry)
  
          # change Sunday to weekday 0
          if which == WEEK_OFFSET and 7 in good:
              good.discard(7)
              good.add(0)
  
          return good, _end