docs: def curl(url, params=None, auth=None, req_type='GET', data=None, headers=None, timeout=None, use_gzip=True, use_stream=False):
    """
    Make request to web resource
  
    :param url: Url to endpoint
    :param params: list of params after "?"
    :param auth: authorization tokens
    :param req_type: column_type of the request
    :param data: data which need to be posted
    :param headers: headers which would be posted with request
    :param timeout: Request timeout
    :param use_gzip: Accept gzip and deflate response from the server
    :param use_stream: Do not parse content of response ans stream it via raw property
    :return Response object
  
    :type url str
    :type params dict
    :type auth CURLAuth
    :type req_type str
    :type headers dict
    :type timeout int
    :type use_gzip bool
    :type use_stream bool
    :rtype CURLResponse
    """
    post_req = ["POST", "PUT"]
    get_req = ["GET", "DELETE"]
  
    if params is not None:
      url += "?" + urlencode(params)
  
    if req_type not in post_req + get_req:
      raise IOError("Wrong request column_type \"%s\" passed" % req_type)
  
    _headers = {}
    handler_chain = []
    req_args = {
      "headers": _headers
    }
    # process content
    if req_type in post_req and data is not None:
      _data, __header = __parse_content(data)
      _headers.update(__header)
      _headers["Content-Length"] = len(_data)
      req_args["data"] = _data
  
    # process gzip and deflate
    if use_gzip:
      if "Accept-Encoding" in _headers:
        if "gzip" not in _headers["Accept-Encoding"]:
          _headers["Accept-Encoding"] += ", gzip, x-gzip, deflate"
      else:
        _headers["Accept-Encoding"] = "gzip, x-gzip, deflate"
  
    if auth is not None and auth.force is False:
      manager = HTTPPasswordMgrWithDefaultRealm()
      manager.add_password(None, url, auth.user, auth.password)
      handler_chain.append(HTTPBasicAuthHandler(manager))
  
    if auth is not None and auth.force:
      _headers.update(auth.headers)
  
    if headers is not None:
      _headers.update(headers)
  
    director = build_opener(*handler_chain)
    req = Request(url, **req_args)
    req.get_method = lambda: req_type
  
    try:
      if timeout is not None:
        return CURLResponse(director.open(req, timeout=timeout), is_stream=use_stream)
      else:
        return CURLResponse(director.open(req), is_stream=use_stream)
    except URLError as e:
      if isinstance(e, HTTPError):
        raise e
      else:
        raise TimeoutError