docs: def requeue_delayed_jobs(self):
          """
          Put all delayed jobs that are now ready, back in the queue waiting list
          Return a list of failures
          """
          lock_key = self.make_key(
              self._name,
              self.pk.get(),
              "requeue_all_delayed_ready_jobs",
          )
          connection = self.get_connection()
  
          if connection.exists(lock_key):
              # if locked, a worker is already on it, don't wait and exit
              return []
  
          with Lock(connection, lock_key, timeout=60):
  
              # stop here if we know we have nothing
              first_delayed_time = self.first_delayed_time
              if not first_delayed_time:
                  return []
  
              # get when we are :)
              now_timestamp = datetime_to_score(datetime.utcnow())
  
              # the first job will be ready later, and so the other ones too, then
              # abort
              if float(first_delayed_time) > now_timestamp:
                  return []
  
              failures = []
              while True:
                  # get the first entry
                  first_entry = self.first_delayed
  
                  # no first entry, another worker took all from us !
                  if not first_entry:
                      break
  
                  # split into vars for readability
                  job_ident, delayed_until = first_entry
  
                  # if the date of the job is in the future, another work took the
                  # job we wanted, so we let this job here and stop the loop as we
                  # know (its a zset sorted by date) that no other jobs are ready
                  if delayed_until > now_timestamp:
                      break
  
                  # remove the entry we just got from the delayed ones
                  self.delayed.zrem(job_ident)
  
                  # and add it to the waiting queue
                  try:
                      job = Job.get_from_ident(job_ident)
                      if job.status.hget() == STATUSES.DELAYED:
                          job.status.hset(STATUSES.WAITING)
                      self.enqueue_job(job)
                  except Exception as e:
                      failures.append((job_ident, '%s' % e))
  
              return failures