docs: def next(self, now=None, increments=_increments, delta=True, default_utc=WARN_CHANGE):
          '''
          How long to wait in seconds before this crontab entry can next be
          executed.
          '''
          if default_utc is WARN_CHANGE and (isinstance(now, _number_types) or (now and not now.tzinfo) or now is None):
              warnings.warn(WARNING_CHANGE_MESSAGE, FutureWarning, 2)
              default_utc = False
  
          now = now or (datetime.utcnow() if default_utc and default_utc is not WARN_CHANGE else datetime.now())
          if isinstance(now, _number_types):
              now = datetime.utcfromtimestamp(now) if default_utc else datetime.fromtimestamp(now)
  
          # handle timezones if the datetime object has a timezone and get a
          # reasonable future/past start time
          onow, now = now, now.replace(tzinfo=None)
          tz = onow.tzinfo
          future = now.replace(microsecond=0) + increments[0]()
          if future < now:
              # we are going backwards...
              _test = lambda: future.year < self.matchers.year
              if now.microsecond:
                  future = now.replace(microsecond=0)
          else:
              # we are going forwards
              _test = lambda: self.matchers.year < future.year
  
          # Start from the year and work our way down. Any time we increment a
          # higher-magnitude value, we reset all lower-magnitude values. This
          # gets us performance without sacrificing correctness. Still more
          # complicated than a brute-force approach, but also orders of
          # magnitude faster in basically all cases.
          to_test = ENTRIES - 1
          while to_test >= 0:
              if not self._test_match(to_test, future):
                  inc = increments[to_test](future, self.matchers)
                  future += inc
                  for i in xrange(0, to_test):
                      future = increments[ENTRIES+i](future, inc)
                  try:
                      if _test():
                          return None
                  except:
                      print(future, type(future), type(inc))
                      raise
                  to_test = ENTRIES-1
                  continue
              to_test -= 1
  
          # verify the match
          match = [self._test_match(i, future) for i in xrange(ENTRIES)]
          _assert(all(match),
              "\nYou have discovered a bug with crontab, please notify the\n" \
              "author with the following information:\n" \
              "crontab: %r\n" \
              "now: %r", ' '.join(m.input for m in self.matchers), now)
  
          if not delta:
              onow = now = datetime(1970, 1, 1)
  
          delay = future - now
          if tz:
              delay += _fix_none(onow.utcoffset())
              if hasattr(tz, 'localize'):
                  delay -= _fix_none(tz.localize(future).utcoffset())
              else:
                  delay -= _fix_none(future.replace(tzinfo=tz).utcoffset())
  
          return delay.days * 86400 + delay.seconds + delay.microseconds / 1000000.