code: def _notify_bucket(self, real_time):
          
          (delayed_call, calls) = self._buckets[real_time]
          del self._buckets[real_time]
          errors = []
  
          def notify_one_chunk(calls, chunk_size, chunk_delay_ms):
              for call in calls[:chunk_size]:
                  try:
                      call()
                  except Exception as e:
                      errors.append(e)
              calls = calls[chunk_size:]
              if calls:
                  self._create_delayed_call(
                      chunk_delay_ms / 1000.0,
                      notify_one_chunk, calls, chunk_size, chunk_delay_ms,
                  )
              else:
                  # done all calls; make sure there were no errors
                  if len(errors):
                      msg = u"Error(s) processing call_later bucket:\n"
                      for e in errors:
                          msg += u"{}\n".format(e)
                      raise RuntimeError(msg)
          # ceil()ing because we want the number of chunks, and a
          # partial chunk is still a chunk
          delay_ms = self._bucket_milliseconds / math.ceil(float(len(calls)) / self._chunk_size)
          # I can't imagine any scenario in which chunk_delay_ms is
          # actually less than zero, but just being safe here
          notify_one_chunk(calls, self._chunk_size, max(0.0, delay_ms))
docs: Internal helper. This 'does' the callbacks in a particular bucket.
  
          :param real_time: the bucket to do callbacks on