Python Response.headers方法代码示例

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import headers [as 别名]
    def send(self, request, stream=None, timeout=None, verify=None, cert=None, proxies=None):
        pathname = url_to_path(request.url)

        resp = Response()
        resp.status_code = 200
        resp.url = request.url

        try:
            stats = stat(pathname)
        except OSError as exc:
            resp.status_code = 404
            resp.raw = exc
        else:
            modified = formatdate(stats.st_mtime, usegmt=True)
            content_type = guess_type(pathname)[0] or "text/plain"
            resp.headers = CaseInsensitiveDict({
                "Content-Type": content_type,
                "Content-Length": stats.st_size,
                "Last-Modified": modified,
            })

            resp.raw = open(pathname, "rb")
            resp.close = resp.raw.close

        return resp

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import headers [as 别名]
def build_response(request,
                   status_code=200,
                   headers={},
                   content='(none)'):
    """
    Build a :class:`requests.Response` object on the basis of the passed
    parameters.
    """

    response = Response()

    response.status_code = status_code
    response.reason = responses[status_code]
    response.headers = CaseInsensitiveDict(headers)
    # Pretend that we've already read from the socket
    response._content = content

    response.encoding = get_encoding_from_headers(response.headers)
    response.url = request.url
    response.raw = MockRawResponse()

    # Give the Response some context.
    response.request = request
    response.connection = MockConnection()

    return response

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import headers [as 别名]
def responses(code, path=None, redirection=None, data=None,
              url=None,
              headers=None):
    if headers is None:
        headers = {'Content-Type': 'text/xml'}
    response = Response()
    response.status_code = code
    if path is not None and redirection is None:
        with open(data_file(path), 'rb') as f:
            response.raw = BytesIO(f.read())
    elif data is not None:
        response._content = data.encode('utf-8')
    if redirection is not None:
        temp = Response()
        temp.status_code = 301 if 'permanent' in redirection else 302
        temp.url = path
        response.history.append(temp)
        response.url = redirection
        headers['location'] = path
    if url is None:
        if redirection is not None:
            url = redirection
        else:
            url = 'https://example.com/{}'.format(str(uuid4()))
    response.url = url
    response.headers = headers
    return response

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import headers [as 别名]
 def new_response(self, response):
     """Convert an tornado.HTTPResponse object to a requests.Response object"""
     new = Response()
     new._content = response.body
     new.status_code = response.code
     new.headers = dict(response.headers.get_all())
     return new

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import headers [as 别名]
 async def new_response(self, response):
     """Convert an aiohttp.Response object to a requests.Response object"""
     new = Response()
     new._content = await response.read()
     new.status_code = response.status
     new.headers = response.headers
     new.cookies = response.cookies
     new.encoding = response.charset
     return new

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import headers [as 别名]
    def send(self, request, stream=None, timeout=None, verify=None, cert=None, proxies=None):

        resp = Response()
        resp.status_code = 200
        resp.url = request.url

        try:
            import boto
        except ImportError:
            stderrlog.info('\nError: boto is required for S3 channels. '
                           'Please install it with `conda install boto`\n'
                           'Make sure to run `source deactivate` if you '
                           'are in a conda environment.\n')
            resp.status_code = 404
            return resp

        conn = boto.connect_s3()

        bucket_name, key_string = url_to_s3_info(request.url)

        # Get the bucket without validation that it exists and that we have
        # permissions to list its contents.
        bucket = conn.get_bucket(bucket_name, validate=False)

        try:
            key = bucket.get_key(key_string)
        except boto.exception.S3ResponseError as exc:
            # This exception will occur if the bucket does not exist or if the
            # user does not have permission to list its contents.
            resp.status_code = 404
            resp.raw = exc
            return resp

        if key and key.exists:
            modified = key.last_modified
            content_type = key.content_type or "text/plain"
            resp.headers = CaseInsensitiveDict({
                "Content-Type": content_type,
                "Content-Length": key.size,
                "Last-Modified": modified,
            })

            _, self._temp_file = mkstemp()
            key.get_contents_to_filename(self._temp_file)
            f = open(self._temp_file, 'rb')
            resp.raw = f
            resp.close = resp.raw.close
        else:
            resp.status_code = 404

        return resp

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import headers [as 别名]
    def doQuery(self, url, method='GET', getParmeters=None, postParameters=None, files=None):
        """Send a request to the server and return the result"""

        if method == 'POST':
            if not files:
                r = requests.post(self.baseURI + '/' + url, params=getParmeters, data=postParameters, stream=True)
            else:  
                # Special way, for big files
                # Requests is not usable: https://github.com/shazow/urllib3/issues/51
                
                from poster.encode import multipart_encode, MultipartParam
                from poster.streaminghttp import register_openers
                import urllib2

                # Register the streaming http handlers with urllib2
                register_openers()

                # headers contains the necessary Content-Type and Content-Length
                # datagen is a generator object that yields the encoded parameters
                data = {}
                for x in postParameters:
                    data[x] = postParameters[x]

                for f in files:
                    data[f] = MultipartParam(f, fileobj=open(files[f].temporary_file_path(), 'rb'), filename=files[f].name)

                datagen, headers = multipart_encode(data)

                # Create the Request object
                request = urllib2.Request(self.baseURI + '/' + url, datagen, headers)

                re = urllib2.urlopen(request)

                from requests import Response

                r = Response()
                r.status_code = re.getcode()
                r.headers = re.info()
                r.encoding = "application/json"
                r.raw = re.read()
                r._content = r.raw

                return r

        else:
            # Call the function based on the method.
            r = getattr(requests, method.lower())(self.baseURI + '/' + url, params=getParmeters, stream=True)

        return r

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import headers [as 别名]
def responses(code, path=None, redirection=None,
              headers={'Content-Type': 'text/xml'}):
    response = Response()
    response.status_code = code
    if path is not None:
        with open(test_file(path), 'r') as f:
            response.raw = BytesIO(f.read())
    if redirection is not None:
        temp = Response()
        temp.status_code = 301 if 'permanent' in redirection else 302
        temp.url = path
        response.history.append(temp)
        response.url = redirection
    response.headers = headers
    return response

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import headers [as 别名]
    def test_response_headers(self):
        """
        Make sure that whatever headers come back on the response get added
        to the report.
        """
        URL = 'http://fakeurl/robots.txt'
        req = DownloadRequest(URL, StringIO(), headers={'pulp_header': 'awesome!'})
        response = Response()
        response.status_code = httplib.OK
        response.headers = {'content-length': '1024'}
        response.raw = StringIO('abc')
        self.session.get.return_value = response

        report = self.downloader._fetch(req)

        self.assertEqual(report.headers['content-length'], '1024')

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import headers [as 别名]
    def setUpResponse(self, headers, body, status_code=200):
        if not headers:
            headers = {'Content-Type': 'application/json'}

        def decode_content():
            pass

        response = Response()
        response.status_code = status_code
        response.headers = headers
        stream = Mock()
        stream.read = Mock()
        stream.read.side_effect = [body, None]
        response.raw = stream

        return response

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import headers [as 别名]
def make_fake_response(status, doc):
    """
    Helper function to conveniently build a fake Response instance from
    a status code and a dictionary, as if this is a response coming from the
    YesGraph API.
    """
    text = json.dumps(doc)
    body = text.encode('utf-8')  # body must be bytes

    response = Response()
    response.status_code = status
    response.headers = CaseInsensitiveDict({
        'Content-Type': 'application/json',
    })
    response.raw = io.BytesIO(body)
    return response

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import headers [as 别名]
def fake_request(*args, **kwargs):
    r = Response()
    r.status_code = 200

    try:
        _token = kwargs['headers']['Authorization']
    except KeyError:
        r._content = b'{"shoe_size": 10}'
    else:
        _token = _token[7:]
        if _token == 'abcdef':
            r._content = b'{"shoe_size": 11}'
        else:
            r._content = b'{"shoe_size": 12}'

    r.headers = {'content-type': 'application/json'}
    return r

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import headers [as 别名]
    def test_response_headers(self):
        """
        Make sure that whatever headers come back on the response get added
        to the report.
        """
        URL = 'http://pulpproject.org/robots.txt'
        req = DownloadRequest(URL, StringIO(), headers={'pulp_header': 'awesome!'})
        response = Response()
        response.status_code = httplib.OK
        response.headers = {'content-length': '1024'}
        response.raw = StringIO('abc')
        session = threaded.build_session(self.config)
        session.get = mock.MagicMock(return_value=response, spec_set=session.get)

        report = self.downloader._fetch(req, session)

        self.assertEqual(report.headers['content-length'], '1024')

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import headers [as 别名]
def responses(code, path=None, redirection=None, data=None,
              headers={'Content-Type': 'text/xml'}):
    response = Response()
    response.status_code = code
    if path is not None and redirection is None:
        with open(data_file(path), 'rb') as f:
            response.raw = BytesIO(f.read())
    elif data is not None:
        response._content = data.encode('utf-8')
    if redirection is not None:
        temp = Response()
        temp.status_code = 301 if 'permanent' in redirection else 302
        temp.url = path
        response.history.append(temp)
        response.url = redirection
        headers['location'] = path
    response.headers = headers
    return response

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import headers [as 别名]
def make_json_response(data, status_code=200, headers=None):
    """
    :type data: dict
    :type status_code: int
    :type headers: dict

    :returns: A Response object with the corresponding JSON body
    :rtype: requests.models.Response
    """
    if headers is None:
        headers = {}

    response = Response()

    response.status_code = status_code
    response._content = json.dumps(data).encode("utf-8")

    headers["content-type"] = "application/json"
    response.headers = headers

    return response