def HttpRequest(service, operation, data, uri, extra_headers=None,
    url_params=None, escape_params=True, content_type='application/atom+xml'):
  """Performs an HTTP call to the server, supports GET, POST, PUT, and DELETE.

  This function is deprecated, use AppEngineHttpClient.request instead.

  To use this module with gdata.service, you can set this module to be the
  http_request_handler so that HTTP requests use Google App Engine's urlfetch.
  import gdata.service
  import gdata.urlfetch
  gdata.service.http_request_handler = gdata.urlfetch

  Args:
    service: atom.AtomService object which contains some of the parameters
        needed to make the request. The following members are used to
        construct the HTTP call: server (str), additional_headers (dict),
        port (int), and ssl (bool).
    operation: str The HTTP operation to be performed. This is usually one of
        'GET', 'POST', 'PUT', or 'DELETE'
    data: filestream, list of parts, or other object which can be
        converted to a string.
        Should be set to None when performing a GET or PUT.
        If data is a file-like object which can be read, this method will read
        a chunk of 100K bytes at a time and send them.
        If the data is a list of parts to be sent, each part will be evaluated
        and sent.
    uri: The beginning of the URL to which the request should be sent.
        Examples: '/', '/base/feeds/snippets',
        '/m8/feeds/contacts/default/base'
    extra_headers: dict of strings. HTTP headers which should be sent
        in the request. These headers are in addition to those stored in
        service.additional_headers.
    url_params: dict of strings. Key value pairs to be added to the URL as
        URL parameters. For example {'foo':'bar', 'test':'param'} will
        become ?foo=bar&test=param.
    escape_params: bool default True. If true, the keys and values in
        url_params will be URL escaped when the form is constructed
        (Special characters converted to %XX form.)
    content_type: str The MIME type for the data being sent. Defaults to
        'application/atom+xml', this is only used if data is set.
  """
  full_uri = atom.service.BuildUri(uri, url_params, escape_params)
  (server, port, ssl, partial_uri) = atom.service.ProcessUrl(service, full_uri)
  # Construct the full URL for the request.
  if ssl:
    full_url = (server, partial_uri) % 'https://%s%s'
  else:
    full_url = 'http://%s%s' % (server, partial_uri)

  # Construct the full payload. 
  # Assume that data is None or a string.
  data_str = data
  if data:
    if isinstance(data, list):
      # If data is a list of different objects, convert them all to strings
      # and join them together.
      converted_parts = [__ConvertDataPart(x) for x in data]
      data_str = ''.join(converted_parts)
    else:
      data_str = __ConvertDataPart(data)

  # Construct the dictionary of HTTP headers.
  headers = {}
  if isinstance(service.additional_headers, dict):
    headers = service.additional_headers.copy()
  if isinstance(extra_headers, dict):
    for header, value in extra_headers.iteritems():
      headers[header] = value
  # Add the content type header (we don't need to calculate content length,
  # since urlfetch.Fetch will calculate for us).
  if content_type:
    headers['Content-Type'] = content_type

  # Lookup the urlfetch operation which corresponds to the desired HTTP verb.
  if operation == 'GET':
    method = urlfetch.GET
  elif operation == 'POST':
    method = urlfetch.POST
  elif operation == 'PUT':
    method = urlfetch.PUT
  elif operation == 'DELETE':
    method = urlfetch.DELETE
  else:
    method = None
  return HttpResponse(urlfetch.Fetch(url=full_url, payload=data_str, 
      method=method, headers=headers))
dataset/ETHPy150Open CollabQ/CollabQ/vendor/gdata/urlfetch.py/HttpRequest/swapped operands of `%`