Python Request.method方法代码示例

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import method [as 别名]
    def setUp(self):
        # mock request object
        request = Request()
        request.method = "GET"
        request.url = "http://example.com/"
        request.params = {}
        request.data = {}
        request.params_and_data = {}
        self.request = request

        # mock response object
        response = Mock()
        response.content = "access_token=321"
        response.headers = {"content-type": "text/html; charset=UTF-8"}
        response.ok = True
        response.status_code = 200
        self.response = response

        # mock raise_for_status with an error
        def raise_for_status():
            raise Exception("Response not OK!")

        self.raise_for_status = raise_for_status

        # mock hook object
        hook = Mock()
        hook.consumer_key = "123"
        hook.consumer_secret = "456"
        hook.access_token = "321"
        hook.access_token_secret = "654"
        self.hook = hook

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import method [as 别名]
    def encode(self, onem2m_primitive):
        """
        Encodes OneM2M JSON primitive object to Tx specific HTTP message
        with JSON content type
        """

        params = onem2m_primitive.get_parameters()
        proto_params = onem2m_primitive.get_protocol_specific_parameters()

        # This is Tx encoder so we use Request
        msg = Request()

        if params:
            # Method (Operation)
            if OneM2M.short_operation in params:
                msg.method = self._encode_operation(params[OneM2M.short_operation])

            # URL
            if OneM2M.short_to in params:
                resource_uri = self._translate_uri_from_onem2m(params[OneM2M.short_to])
                entity_address = ""
                if proto_params:
                    if protocol_address in proto_params:
                        entity_address = proto_params[protocol_address]
                        if protocol_port in proto_params:
                            entity_address += (":" + str(proto_params[protocol_port]))

                msg.url = "http://" + entity_address + resource_uri

            # encode headers and query parameters
            delimiter = "?"
            for key, value in params.items():

                # Query parameters
                if msg.url and key in http_query_params:
                    msg.url += (delimiter + key + "=" + str(value))
                    delimiter = "&"
                    continue

                # Headers from primitive parameters
                encoded = http_headers.encode_default_ci(key, None)
                if None is not encoded:
                    msg.headers[encoded] = str(value)

        # Headers from protocol specific parameters
        if proto_params:
            for key, value in proto_params.items():
                encoded = http_headers.encode_default_ci(key, None)
                if None is not encoded:
                    msg.headers[encoded] = str(value)

        # Body (content)
        content = onem2m_primitive.get_content()
        if content:
            msg.json = content
        return msg.prepare()

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import method [as 别名]
def _prepare_request(lex_session, url, params, data, auth, files):
	"""Return a requests Request object that can be "prepared"."""

	headers = {}
	headers.update(lex_session.http.headers)

	request = Request(method='GET', url=url, headers=headers, params=params, auth=auth, cookies=lex_session.http.cookies)

	if not data and not files: # GET request
		return request
	if not auth:
		data.setdefault('api_type', 'json')
	request.method = 'POST'
	request.data = data
	request.files = files
	return request

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import method [as 别名]
def _prepare_request(reddit_session, url, params, data, auth, files):
    """Return a requests Request object that can be "prepared"."""
    # Requests using OAuth for authorization must switch to using the oauth
    # domain.
    if getattr(reddit_session, '_use_oauth', False):
        headers = {'Authorization': 'bearer %s' % reddit_session.access_token}
        config = reddit_session.config
        # pylint: disable-msg=W0212
        for prefix in (config._site_url, config._ssl_url):
            if url.startswith(prefix):
                if config.log_requests >= 1:
                    sys.stderr.write('substituting %s for %s in url\n'
                                     % (config._oauth_url, prefix))
                url = config._oauth_url + url[len(prefix):]
                break
    else:
        headers = {}
    headers.update(reddit_session.http.headers)
    # Log the request if logging is enabled
    if reddit_session.config.log_requests >= 1:
        sys.stderr.write('retrieving: %s\n' % url)
    if reddit_session.config.log_requests >= 2:
        sys.stderr.write('params: %s\n' % (params or 'None'))
        sys.stderr.write('data: %s\n' % (data or 'None'))
        if auth:
            sys.stderr.write('auth: %s\n' % str(auth))
    # Prepare request
    request = Request(method='GET', url=url, headers=headers, params=params,
                      auth=auth, cookies=reddit_session.http.cookies)
    if not data and not files:  # GET request
        return request
    # Most POST requests require adding `api_type` and `uh` to the data.
    if data is True:
        data = {}
    if not auth:
        data.setdefault('api_type', 'json')
        if reddit_session.modhash:
            data.setdefault('uh', reddit_session.modhash)
    request.method = 'POST'
    request.data = data
    request.files = files
    return request

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import method [as 别名]
    def setUp(self):
        # mock request object
        request = Request()
        request.method = 'GET'
        request.url = 'http://example.com/'
        request.headers = {}
        request.params = {}
        request.data = {}
        request.params_and_data = {}
        self.request = request

        # mock consumer object
        consumer = Mock()
        consumer.key = '123'
        consumer.secret = '456'
        self.consumer = consumer

        # mock token object
        token = Mock()
        token.key = '321'
        token.secret = '456'
        self.token = token

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import method [as 别名]
    def setUp(self):
        # mock request object
        request = Request()
        request.method = 'GET'
        request.url = 'http://example.com/'
        request.headers = {}
        request.params = {}
        request.data = {}
        request.params_and_data = {}
        self.request = request

        # mock response object
        response = Mock()
        response.content = 'access_token=321'
        response.headers = {'content-type': 'text/html; charset=UTF-8'}
        response.ok = True
        response.status_code = 200
        response.raise_for_status = lambda: None
        self.response = response

        # mock raise_for_status with an error
        def raise_for_status():
            raise Exception('Response not OK!')

        self.raise_for_status = raise_for_status

        # mock consumer object
        consumer = Mock()
        consumer.key = '123'
        consumer.secret = '456'
        self.consumer = consumer

        # mock token object
        token = Mock()
        token.key = '321'
        token.secret = '456'
        self.token = token

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import method [as 别名]
 def mk_request(self, method):
     http_request = Request()
     http_request.url = self.get_resource_url()
     http_request.method = method
     http_request.headers["Content-Type"] = "application/json"
     return http_request