code: def _do_request(self, method, url, headers, data, target_object):
          
          if len(self._requests) >= self._MAX_BATCH_SIZE:
              raise ValueError(
                  "Too many deferred requests (max %d)" % self._MAX_BATCH_SIZE
              )
          self._requests.append((method, url, headers, data))
          result = _FutureDict()
          self._target_objects.append(target_object)
          if target_object is not None:
              target_object._properties = result
          return _FutureResponse(result)
docs: Override Connection:  defer actual HTTP request.
  
          Only allow up to ``_MAX_BATCH_SIZE`` requests to be deferred.
  
          :type method: str
          :param method: The HTTP method to use in the request.
  
          :type url: str
          :param url: The URL to send the request to.
  
          :type headers: dict
          :param headers: A dictionary of HTTP headers to send with the request.
  
          :type data: str
          :param data: The data to send as the body of the request.
  
          :type target_object: object
          :param target_object:
              (Optional) This allows us to enable custom behavior in our batch
              connection. Here we defer an HTTP request and complete
              initialization of the object at a later time.
  
          :rtype: tuple of ``response`` (a dictionary of sorts)
                  and ``content`` (a string).
          :returns: The HTTP response object and the content of the response.