Python Request.data方法代码示例

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import data [as 别名]
    def do_target(self, target, method, payload):
        req = Request(
            method  = method,
            headers = self.headers)

        if target.submission_type == 'urlparams':
            payload = dict_to_urlparams(payload)
            req.url = target.uri + '?' + payload

        elif target.submission_type == 'json':
            payload  = serialise_to_json(payload, True)
            req.url  = target.uri
            req.data = payload

        elif target.submission_type == 'urlencode':
            payload = serialise_to_url(payload)
            req.url  = target.uri
            req.data = payload
        else:
            raise NotImplementedError

        try:
            resp = self.send(
                request = req.prepare(),
                timeout = self.timeout)
        except RequestException as e:
            return e
        return resp

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import data [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 data [as 别名]
def _prepare_request(reddit_session, url, params, data, auth, files,
                     method=None):
    """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):
        bearer = 'bearer {0}'.format(reddit_session.access_token)
        headers = {'Authorization': bearer}
        config = reddit_session.config
        for prefix in (config.api_url, config.permalink_url):
            if url.startswith(prefix):
                if config.log_requests >= 1:
                    msg = 'substituting {0} for {1} in url\n'.format(
                        config.oauth_url, prefix)
                    sys.stderr.write(msg)
                url = config.oauth_url + url[len(prefix):]
                break
    else:
        headers = {}
    headers.update(reddit_session.http.headers)

    if method:
        pass
    elif data or files:
        method = 'POST'
    else:
        method = 'GET'

    # Log the request if logging is enabled
    if reddit_session.config.log_requests >= 1:
        sys.stderr.write('{0}: {1}\n'.format(method, url))
    if reddit_session.config.log_requests >= 2:
        if params:
            sys.stderr.write('params: {0}\n'.format(params))
        if data:
            sys.stderr.write('data: {0}\n'.format(data))
        if auth:
            sys.stderr.write('auth: {0}\n'.format(auth))
    # Prepare request
    request = Request(method=method, url=url, headers=headers, params=params,
                      auth=auth, cookies=reddit_session.http.cookies)
    if method == 'GET':
        return request
    # Most POST requests require adding `api_type` and `uh` to the data.
    if data is True:
        data = {}

    if isinstance(data, dict):
        if not auth:
            data.setdefault('api_type', 'json')
            if reddit_session.modhash:
                data.setdefault('uh', reddit_session.modhash)
    else:
        request.headers.setdefault('Content-Type', 'application/json')

    request.data = data
    request.files = files
    return request

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import data [as 别名]
def _prepare_request(reddit_session, url, params, data, auth, files, method=None):
    """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
        for prefix in (config.api_url, config.permalink_url):
            if url.startswith(prefix):
                if config.log_requests >= 1:
                    sys.stderr.write("substituting {} for {} in url\n".format(config.oauth_url, prefix))
                url = config.oauth_url + url[len(prefix) :]
                break
    else:
        headers = {}
    headers.update(reddit_session.http.headers)

    if method:
        pass
    elif data or files:
        method = "POST"
    else:
        method = "GET"

    # Log the request if logging is enabled
    if reddit_session.config.log_requests >= 1:
        sys.stderr.write("{0}: {1}\n".format(method, url))
    if reddit_session.config.log_requests >= 2:
        if params:
            sys.stderr.write("params: {0}\n".format(params))
        if data:
            sys.stderr.write("data: {0}\n".format(data))
        if auth:
            sys.stderr.write("auth: {0}\n".format(auth))
    # Prepare request
    request = Request(
        method=method, url=url, headers=headers, params=params, auth=auth, cookies=reddit_session.http.cookies
    )
    if method == "GET":
        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.data = data
    request.files = files
    return request

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import data [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 data [as 别名]
def sendHttpRequest(_args):
    s = Session()
    url = makeURL(_args)
    req = Request(_args.get("method"), url)
    if (_args.get("headers") is not None) : req.headers = _args.get("headers")
    if (_args.get("auth") is not None) : req.auth = HTTPBasicAuth(_args.get("auth")[0], _args.get("auth")[1])
    if (_args.get("params") is not None) : req.params = _args.get("params")
    if (_args.get("cookies") is not None) : req.cookies = _args.get("cookies")
    if (_args.get("data") is not None) : req.data = _args.get("data")

    prepped = req.prepare()
    if (_args.get("body") is not None) : prepped.body = _args.get("body")

    # do something with prepped.body
    # do something with prepped.headers

    resp = s.send(prepped,timeout=_args.get("timeout"), proxies=_args.get("proxies"))
    return resp

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import data [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 data [as 别名]
def _prepare_request(session, url, params, data, auth, files, method=None):
    """Return a requests Request object that can be "prepared"."""
    headers = {}
    headers.update(session.http.headers)

    if method:
        pass
    elif data or files:
        method = 'POST'
    else:
        method = 'GET'

    # Log the request if logging is enabled
    if session.config.log_requests >= 1:
        sys.stderr.write('{0}: {1}\n'.format(method, url))
    if session.config.log_requests >= 2:
        if params:
            sys.stderr.write('params: {0}\n'.format(params))
        if data:
            sys.stderr.write('data: {0}\n'.format(data))
        if auth:
            sys.stderr.write('auth: {0}\n'.format(auth))
    # Prepare request
    request = Request(method=method, url=url, headers=headers, params=params,
                      auth=auth, cookies=session.http.cookies)
    if method == 'GET':
        return request
    # Most POST requests require adding `api_type` and `uh` to the data.
    if data is True:
        data = {}

    if isinstance(data, dict):
        if not auth:
            data.setdefault('api_type', 'json')
            if session.modhash:
                data.setdefault('uh', session.modhash)
    else:
        request.headers.setdefault('Content-Type', 'application/json')

    request.data = data
    request.files = files
    return request

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import data [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 data [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 data [as 别名]
    def upload_file(self, local_file, remote_name=None, metadata={}, headers={},
                    queue_derive=True, ignore_bucket=False, verbose=False, debug=False):
        """Upload a single file to an item. The item will be created
        if it does not exist.

        :type local_file: str or file
        :param local_file: The filepath or file-like object to be uploaded.

        :type remote_name: str
        :param remote_name: (optional) Sets the remote filename.

        :type metadata: dict
        :param metadata: (optional) Metadata used to create a new item.

        :type headers: dict
        :param headers: (optional) Add additional IA-S3 headers to
                        request.

        :type queue_derive: bool
        :param queue_derive: (optional) Set to False to prevent an item from
                             being derived after upload.

        :type ignore_bucket: bool
        :param ignore_bucket: (optional) Set to True to ignore and
                              clobber existing files and metadata.

        :type debug: bool
        :param debug: (optional) Set to True to print headers to stdout,
                      and exit without sending the upload request.

        Usage::

            >>> import internetarchive
            >>> item = internetarchive.Item('identifier')
            >>> item.upload_file('/path/to/image.jpg',
            ...                  remote_name='photos/image1.jpg')
            True

        :rtype: bool
        :returns: True if the request was successful and file was
                  uploaded, False otherwise.

        """
        if not self.session:
            self.session = Session()

        if not hasattr(local_file, 'read'):
            local_file = open(local_file, 'rb')
        if not remote_name:
            remote_name = local_file.name.split('/')[-1]

        # Attempt to add size-hint header.    
        if not headers.get('x-archive-size-hint'):
            try:
                local_file.seek(0, os.SEEK_END)
                headers['x-archive-size-hint'] = local_file.tell()
                local_file.seek(0, os.SEEK_SET)
            except IOError:
                pass

        # Prepare Request.
        endpoint = 'http://s3.us.archive.org/{0}/{1}'.format(self.identifier, remote_name)
        headers = ias3.build_headers(metadata, headers, queue_derive=queue_derive,
                                     ignore_bucket=ignore_bucket)
        request = Request('PUT', endpoint, headers=headers)
        # TODO: Add support for multipart.
        # `contextlib.closing()` is used to make StringIO work with 
        # `with` statement.
        with closing(local_file) as data:
            request.data = data.read()
        prepped_request = request.prepare()

        if debug:
            return prepped_request 
        else:
            if verbose:
                stdout.write(' uploading file: {0}\n'.format(remote_name))
            return self.session.send(prepped_request)