docs: def _wait_for_response(self, requests):
          """Issues a batch of requests and waits for the responses.
          If some of the requests fail it will retry the failed ones up to `_max_retry` times.
  
          Args:
              requests - A list of requests
          Returns:
              A list of `requests.models.Response` objects
          Raises:
              InvalidRequestError - if any of the requests returns "403 Forbidden" response
          """
          failed_requests = []
          responses_for_requests = OrderedDict.fromkeys(requests)
  
          for retry in range(self._max_retry):
              try:
                  logging.debug('Try #{0}'.format(retry + 1))
                  self._availability_limiter.map_with_retries(requests, responses_for_requests)
  
                  failed_requests = []
                  for request, response in responses_for_requests.items():
                      if self._drop_404s and response is not None and response.status_code == 404:
                          logging.warning('Request to {0} failed with status code 404, dropping.'.format(request.url))
                      elif not response:
                          failed_requests.append((request, response))
  
                  if not failed_requests:
                      break
  
                  logging.warning('Try #{0}. Expected {1} successful response(s) but only got {2}.'.format(
                      retry + 1, len(requests), len(requests) - len(failed_requests),
                  ))
  
                  # retry only for the failed requests
                  requests = [fr[0] for fr in failed_requests]
              except InvalidRequestError:
                  raise
              except Exception as e:
                  # log the exception for the informative purposes and pass to the next iteration
                  logging.exception('Try #{0}. Exception occured: {1}. Retrying.'.format(retry + 1, e))
                  pass
  
          if failed_requests:
              logging.warning('Still {0} failed request(s) after {1} retries:'.format(
                  len(failed_requests), self._max_retry,
              ))
              for failed_request, failed_response in failed_requests:
                  if failed_response is not None:
                      # in case response text does contain some non-ascii characters
                      failed_response_text = failed_response.text.encode('ascii', 'xmlcharrefreplace')
                      logging.warning('Request to {0} failed with status code {1}. Response text: {2}'.format(
                          failed_request.url, failed_response.status_code, failed_response_text,
                      ))
                  else:
                      logging.warning('Request to {0} failed with None response.'.format(failed_request.url))
  
          return list(responses_for_requests.values())